Task 125: .DAF File Format
Task 125: .DAF File Format
File Format Specifications for the .DAF File Format
The .DAF file format is the Double Precision Array File format used by NASA's SPICE toolkit for storing arrays of double precision data in binary kernels, such as ephemeris (SPK), orientation (CK), and planetary constants (PCK). It is a direct access file structure based on Fortran-77, designed for portability. The format supports storing multiple arrays, each described by summaries with double precision and integer components. Files using this format often have extensions like .bsp, .bc, or .bpc, but the underlying format is DAF. The full specification is documented in the SPICE toolkit at https://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/daf.html.
- List of all the properties of this file format intrinsic to its file system.
- Identification Word (LOCIDW): 8-character string identifying the file type (e.g., "DAF/SPK " or "DAF/CK ").
- Number of Double Precision Components (ND): Integer specifying the number of double precision numbers in each array summary (0 ≤ ND ≤ 124).
- Number of Integer Components (NI): Integer specifying the number of integer numbers in each array summary (2 ≤ NI ≤ 250).
- Internal File Name (LOCIFN): 60-character string providing a description or name of the file contents.
- First Summary Record Number (FWARD): Integer record number of the initial summary record.
- Last Summary Record Number (BWARD): Integer record number of the final summary record.
- First Free Address (FREE): Integer address where the next array's data can be stored.
- Binary File Format (LOCFMT): 8-character string indicating endianness and format ( "BIG-IEEE" or "LTL-IEEE").
- FTP Validation String (FTPSTR): 28-character string for detecting FTP transfer corruption.
- Record Length: Fixed size per record, typically 1024 bytes (capable of holding 128 doubles or 1000 characters).
- Reserved Records Count: Derived as FWARD - 2 (area for comments after the file record).
- Summary Size (SS): Derived as ND + (NI + 1) // 2, must be ≤ 125.
- Name Character Count (NC): Derived as 8 * SS, the length of each array name.
- Endianness: Specified by LOCFMT.
- Data Storage: Arrays of double precision numbers, with summaries containing ND doubles and NI integers per array (last two integers are start/end addresses of the array data).
- Two direct download links for files of format .DAF.
- https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/planets/de440.bsp
- https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/satellites/mar097.bsp
- Ghost blog embedded html javascript that allows a user to drag n drop a file of format .DAF and it will dump to screen all these properties.
Drag and drop .DAF file here
Note: This assumes big-endian for initial parse; in practice, check LOCFMT to adjust endianness for full reading.
- Python class that can open any file of format .DAF and decode read and write and print to console all the properties from the above list.
import struct
import os
class DAFHandler:
def __init__(self, filepath=None):
self.filepath = filepath
self.properties = {}
if filepath:
self.read()
def read(self):
with open(self.filepath, 'rb') as f:
data = f.read(1024) # First record
self.properties['LOCIDW'] = data[0:8].decode('ascii').rstrip()
self.properties['ND'] = struct.unpack('>i', data[8:12])[0]
self.properties['NI'] = struct.unpack('>i', data[12:16])[0]
self.properties['LOCIFN'] = data[16:76].decode('ascii').rstrip()
self.properties['FWARD'] = struct.unpack('>i', data[76:80])[0]
self.properties['BWARD'] = struct.unpack('>i', data[80:84])[0]
self.properties['FREE'] = struct.unpack('>i', data[84:88])[0]
self.properties['LOCFMT'] = data[88:96].decode('ascii').rstrip()
self.properties['FTPSTR'] = data[699:727].decode('ascii').rstrip()
ss = self.properties['ND'] + (self.properties['NI'] + 1) // 2
self.properties['Summary Size (SS)'] = ss
self.properties['Name Character Count (NC)'] = 8 * ss
self.properties['Reserved Records Count'] = self.properties['FWARD'] - 2
self.properties['Record Length'] = 1024
self.properties['Endianness'] = 'Big-Endian' if 'BIG' in self.properties['LOCFMT'] else 'Little-Endian'
def print_properties(self):
for key, value in self.properties.items():
print(f"{key}: {value}")
def write(self, new_filepath):
if not self.properties:
raise ValueError("No properties to write.")
with open(new_filepath, 'wb') as f:
# Write file record (simplified, assuming big-endian, padding not fully implemented)
data = bytearray(1024)
data[0:8] = self.properties['LOCIDW'].encode('ascii').ljust(8, b' ')
struct.pack_into('>i', data, 8, self.properties['ND'])
struct.pack_into('>i', data, 12, self.properties['NI'])
data[16:76] = self.properties['LOCIFN'].encode('ascii').ljust(60, b' ')
struct.pack_into('>i', data, 76, self.properties['FWARD'])
struct.pack_into('>i', data, 80, self.properties['BWARD'])
struct.pack_into('>i', data, 84, self.properties['FREE'])
data[88:96] = self.properties['LOCFMT'].encode('ascii').ljust(8, b' ')
data[699:727] = self.properties['FTPSTR'].encode('ascii').ljust(28, b' ')
# Padding would be nulls, but omitted for brevity
f.write(data)
# For full write, add reserved, summaries, etc., but this writes header
# Example usage
# daf = DAFHandler('path/to/file.bsp')
# daf.print_properties()
# daf.write('new.daf')
Note: Write is simplified to header; full write would require array data.
- Java class that can open any file of format .DAF and decode read and write and print to console all the properties from the above list.
import java.io.*;
import java.nio.*;
import java.nio.channels.FileChannel;
import java.nio.file.*;
public class DAFHandler {
private String filepath;
private ByteBuffer buffer;
private String locidw;
private int nd;
private int ni;
private String locifn;
private int fward;
private int bward;
private int free;
private String locfmt;
private String ftpstr;
private int ss;
private int nc;
private int reservedCount;
private int recordLength = 1024;
private String endianness;
public DAFHandler(String filepath) {
this.filepath = filepath;
read();
}
private void read() {
try {
buffer = ByteBuffer.allocate(recordLength).order(ByteOrder.BIG_ENDIAN); // Assume big for initial
FileChannel channel = FileChannel.open(Paths.get(filepath), StandardOpenOption.READ);
channel.read(buffer);
buffer.flip();
byte[] bytes = new byte[8];
buffer.get(bytes, 0, 8);
locidw = new String(bytes).trim();
nd = buffer.getInt(8);
ni = buffer.getInt(12);
bytes = new byte[60];
buffer.position(16);
buffer.get(bytes);
locifn = new String(bytes).trim();
fward = buffer.getInt(76);
bward = buffer.getInt(80);
free = buffer.getInt(84);
bytes = new byte[8];
buffer.position(88);
buffer.get(bytes);
locfmt = new String(bytes).trim();
bytes = new byte[28];
buffer.position(699);
buffer.get(bytes);
ftpstr = new String(bytes).trim();
ss = nd + (ni + 1) / 2;
nc = 8 * ss;
reservedCount = fward - 2;
endianness = locfmt.contains("BIG") ? "Big-Endian" : "Little-Endian";
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void printProperties() {
System.out.println("LOCIDW: " + locidw);
System.out.println("ND: " + nd);
System.out.println("NI: " + ni);
System.out.println("LOCIFN: " + locifn);
System.out.println("FWARD: " + fward);
System.out.println("BWARD: " + bward);
System.out.println("FREE: " + free);
System.out.println("LOCFMT: " + locfmt);
System.out.println("FTPSTR: " + ftpstr);
System.out.println("Summary Size (SS): " + ss);
System.out.println("Name Character Count (NC): " + nc);
System.out.println("Reserved Records Count: " + reservedCount);
System.out.println("Record Length: " + recordLength);
System.out.println("Endianness: " + endianness);
}
public void write(String newFilepath) {
try {
ByteBuffer outBuffer = ByteBuffer.allocate(recordLength).order(ByteOrder.BIG_ENDIAN);
outBuffer.put(locidw.getBytes());
outBuffer.position(8);
outBuffer.putInt(nd);
outBuffer.putInt(ni);
outBuffer.position(16);
outBuffer.put(locifn.getBytes());
outBuffer.position(76);
outBuffer.putInt(fward);
outBuffer.putInt(bward);
outBuffer.putInt(free);
outBuffer.position(88);
outBuffer.put(locfmt.getBytes());
outBuffer.position(699);
outBuffer.put(ftpstr.getBytes());
// Padding zeros
outBuffer.flip();
FileChannel channel = FileChannel.open(Paths.get(newFilepath), StandardOpenOption.CREATE, StandardOpenOption.WRITE);
channel.write(outBuffer);
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// Example usage
// public static void main(String[] args) {
// DAFHandler daf = new DAFHandler("path/to/file.bsp");
// daf.printProperties();
// daf.write("new.daf");
// }
}
- Javascript class that can open any file of format .DAF and decode read and write and print to console all the properties from the above list.
const fs = require('fs'); // For Node.js
class DAFHandler {
constructor(filepath) {
this.filepath = filepath;
this.properties = {};
if (filepath) {
this.read();
}
}
read() {
const data = fs.readFileSync(this.filepath);
const view = new DataView(data.buffer);
this.properties.LOCIDW = new TextDecoder().decode(data.slice(0, 8)).trim();
this.properties.ND = view.getInt32(8, false);
this.properties.NI = view.getInt32(12, false);
this.properties.LOCIFN = new TextDecoder().decode(data.slice(16, 76)).trim();
this.properties.FWARD = view.getInt32(76, false);
this.properties.BWARD = view.getInt32(80, false);
this.properties.FREE = view.getInt32(84, false);
this.properties.LOCFMT = new TextDecoder().decode(data.slice(88, 96)).trim();
this.properties.FTPSTR = new TextDecoder().decode(data.slice(699, 727)).trim();
const ss = this.properties.ND + Math.floor((this.properties.NI + 1) / 2);
this.properties['Summary Size (SS)'] = ss;
this.properties['Name Character Count (NC)'] = 8 * ss;
this.properties['Reserved Records Count'] = this.properties.FWARD - 2;
this.properties['Record Length'] = 1024;
this.properties.Endianness = this.properties.LOCFMT.includes('BIG') ? 'Big-Endian' : 'Little-Endian';
}
printProperties() {
for (const [key, value] of Object.entries(this.properties)) {
console.log(`${key}: ${value}`);
}
}
write(newFilepath) {
const buffer = Buffer.alloc(1024);
buffer.write(this.properties.LOCIDW, 0, 8);
buffer.writeInt32BE(this.properties.ND, 8);
buffer.writeInt32BE(this.properties.NI, 12);
buffer.write(this.properties.LOCIFN, 16, 60);
buffer.writeInt32BE(this.properties.FWARD, 76);
buffer.writeInt32BE(this.properties.BWARD, 80);
buffer.writeInt32BE(this.properties.FREE, 84);
buffer.write(this.properties.LOCFMT, 88, 8);
buffer.write(this.properties.FTPSTR, 699, 28);
// Padding is zero by default
fs.writeFileSync(newFilepath, buffer);
}
}
// Example usage
// const daf = new DAFHandler('path/to/file.bsp');
// daf.printProperties();
// daf.write('new.daf');
- C class that can open any file of format .DAF and decode read and write and print to console all the properties from the above list.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
typedef struct {
char locidw[9];
int32_t nd;
int32_t ni;
char locifn[61];
int32_t fward;
int32_t bward;
int32_t free;
char locfmt[9];
char ftpstr[29];
int ss;
int nc;
int reservedCount;
int recordLength;
char endianness[12];
} DAFProperties;
class DAFHandler {
private:
char* filepath;
DAFProperties props;
public:
DAFHandler(const char* fp) : filepath(nullptr) {
if (fp) {
filepath = strdup(fp);
read();
}
}
~DAFHandler() {
free(filepath);
}
void read() {
FILE* f = fopen(filepath, "rb");
if (!f) return;
char buffer[1024];
fread(buffer, 1, 1024, f);
strncpy(props.locidw, buffer, 8);
props.locidw[8] = '\0';
memcpy(&props.nd, buffer + 8, 4);
memcpy(&props.ni, buffer + 12, 4);
strncpy(props.locifn, buffer + 16, 60);
props.locifn[60] = '\0';
memcpy(&props.fward, buffer + 76, 4);
memcpy(&props.bward, buffer + 80, 4);
memcpy(&props.free, buffer + 84, 4);
strncpy(props.locfmt, buffer + 88, 8);
props.locfmt[8] = '\0';
strncpy(props.ftpstr, buffer + 699, 28);
props.ftpstr[28] = '\0';
props.ss = props.nd + (props.ni + 1) / 2;
props.nc = 8 * props.ss;
props.reservedCount = props.fward - 2;
props.recordLength = 1024;
strcpy(props.endianness, strstr(props.locfmt, "BIG") ? "Big-Endian" : "Little-Endian");
fclose(f);
}
void printProperties() {
printf("LOCIDW: %s\n", props.locidw);
printf("ND: %d\n", props.nd);
printf("NI: %d\n", props.ni);
printf("LOCIFN: %s\n", props.locifn);
printf("FWARD: %d\n", props.fward);
printf("BWARD: %d\n", props.bward);
printf("FREE: %d\n", props.free);
printf("LOCFMT: %s\n", props.locfmt);
printf("FTPSTR: %s\n", props.ftpstr);
printf("Summary Size (SS): %d\n", props.ss);
printf("Name Character Count (NC): %d\n", props.nc);
printf("Reserved Records Count: %d\n", props.reservedCount);
printf("Record Length: %d\n", props.recordLength);
printf("Endianness: %s\n", props.endianness);
}
void write(const char* newFilepath) {
FILE* f = fopen(newFilepath, "wb");
if (!f) return;
char buffer[1024] = {0};
strncpy(buffer, props.locidw, 8);
memcpy(buffer + 8, &props.nd, 4);
memcpy(buffer + 12, &props.ni, 4);
strncpy(buffer + 16, props.locifn, 60);
memcpy(buffer + 76, &props.fward, 4);
memcpy(buffer + 80, &props.bward, 4);
memcpy(buffer + 84, &props.free, 4);
strncpy(buffer + 88, props.locfmt, 8);
strncpy(buffer + 699, props.ftpstr, 28);
fwrite(buffer, 1, 1024, f);
fclose(f);
}
};
// Example usage
// int main() {
// DAFHandler daf("path/to/file.bsp");
// daf.printProperties();
// daf.write("new.daf");
// return 0;
// }
Note: Assumes big-endian; full implementation would handle endianness based on LOCFMT. Write is header only.