Reading Unformatted Binary file: Unexpected output - Fortran90

From your replies and what others have commented, I think your problem might be a misunderstanding of what a Fortran "record" is:

You say that you have a binary file where each entry (you said record, but more on that later) is 57 bytes.

The problem is that a "record" in Fortran I/O is not what you would expect it is coming from a C (or anywhere else, really) background. See the following document from Intel, which gives a good explanation of the different access modes:

• https://software.intel.com/sites/products/documentation/hpc/composerxe/en-us/2011Update/fortran/lin/bldaps_for/common/bldaps_rectypes.htm

In short, it has extra data (a header) describing the data in each entry.

Moreover, I can't use ACCESS=stream due to machine being old and not supported, so I conclude that above is the only possibility to figure out the file structure. Any guidance would be a big help!

If you can't use stream, AFAIK there is really no simple and painless way to read binary files with no record information.

A possible solution which requires a C compiler is to do IO in a C function that you call from Fortran, "minimal" example:

main.f90:

program main integer, parameter :: dp = selected_real_kind(15) character(len=*), parameter :: filename = 'test.bin' real(dp) :: val call read_bin(filename, val) print*, 'Read: ', val end program 

read.c:

#include <string.h> #include <stdio.h> void read_bin_(const char *fname, double *ret, unsigned int len) { char buf[256]; printf("len = %d\n", len); strncpy(buf, fname, len); buf[len] = '\0'; // fortran strings are not 0-terminated FILE* fh = fopen(buf, "rb"); fread(ret, sizeof(double), 1, fh); fclose(fh); } 

Note that there is an extra parameter needed in the end and some string manipulation because of the way Fortran handles strings, which differs from C.

write.c:

#include <stdio.h> int main() { double d = 1.234; FILE* fh = fopen("test.bin", "wb"); fwrite(&d, sizeof(double), 1, fh); fclose(fh); } 

Compilation instructions:

gcc -o write write.c gcc -c -g read.c gfortran -g -o readbin main.f90 read.o 

Create binary file with ./write, then see how the Fortran code can read it back with ./readbin.

This can be extended for different data types to basically emulate access=stream. In the end, if you can recompile the original Fortran code to output the data file differently, this will be the easiest solution, as this one is pretty much a crude hack.

Lastly, a tip for getting into unknown data formats: The tool od is your friend, check its manpage. It can directly convert binary represantations into a variety of different native datatypes. Try with the above example (the z adds the character representation in the right-hand column, not very useful here, in general yes):

od -t fDz test.bin