M3_format_ebex.c

#include "M3.h"
#include "M3_gcp.h"
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "M3_format_ebex.h"
#include "ccFitsTools.h"

#define M3_CONTENT_LENGTH 256

void M3_File_readHeader_ebex( M3_File *theFile, void *data )
{
  /* Simple switch over sub-functions for each file type */
  switch( theFile->fileType )
  {
    case M3_GCPOINTING_FILE_TYPE:
      M3_File_readHeader_ebex_gcpointing( theFile, (M3_GCPointingHeader *)data);
      break;
    case M3_AUX_FILE_TYPE:
      M3_File_readHeader_ebex_aux(theFile, data );
      break;
    default:
      M3_ErrorCheck(-1, "M3 can only read ebex files for the gcpointing and aux file types", 0, M3_EFLAG_DEFAULT );
      break;
  }
}

void M3_File_readData_ebex( M3_File *theFile, void *readArg, void *data )
{
  /* Simple switch over sub-functions for each file type */
  switch( theFile->fileType )
  {
    case M3_GCPOINTING_FILE_TYPE:
      M3_File_readData_ebex_gcpointing(theFile, (M3_Interval*)readArg, (double*)data );
      break;
    case M3_AUX_FILE_TYPE:
      M3_File_readData_ebex_aux(theFile, data );
      break;
    default:
      M3_ErrorCheck(-1, "M3 can only read ebex files for the gcpointing and aux file types", 0, M3_EFLAG_DEFAULT );
      break;
  }
}

void M3_File_parseFormatString_ebex( M3_File *theFile, M3_FormatStruct_ebex *out )
{
  M3_FormatStruct_ebex formatStruct;
  char *s1, *s2;
  char errorString[M3_CONTENT_LENGTH];
  static char lastFormatString[M3_CONTENT_LENGTH] = {0};
  static M3_FormatStruct_ebex lastFormatStruct;

   /* Build in a last call cache, as we will often be parsing the same format strings over and over again.  */
  if( strcmp( theFile->format, lastFormatString ) == 0 )
  {
    *out = lastFormatStruct;
    return;
  }
  
  /* set default values */
  out->sampleRate = 0;
  out->polarSpinRate = 0;
  out->polarSpinStart.sec = 0;
  out->polarSpinStart.nsec = 0;
  out->firstTime.sec = 0;
  out->firstTime.nsec = 0;
  out->isBigEndian = testEndian();

  sprintf( errorString, "Error interpreting format Xstring: \"%s\"", theFile->format );

  /* Advance to the first parameter */
  s1 = strchr( theFile->format, '_');

  /* Loop over the parameters in the format string */
  while( s1 )
  {
    /* Skip '_' character */
    s1++;

    /* Switch over all of the parameters */
    if( strncmp( s1, "firstTimeSec", 12 ) == 0 )
    {
      s1 += 12;
      M3_ErrorCheck( -1, errorString, *s1 == '=', M3_EFLAG_DEFAULT);
      s1++;
      out->firstTime.sec = strtoll(s1, NULL, 10);
    }
    else if( strncmp( s1, "firstTimeNsec", 13 ) == 0 )
    {
      s1 += 13;
      M3_ErrorCheck( -1, errorString, *s1 == '=', M3_EFLAG_DEFAULT);
      s1++;
      out->firstTime.nsec = atof(s1);
    }
    else if( strncmp( s1, "sampleRate", 10 ) == 0 )
    {
      s1 += 10;
      M3_ErrorCheck( -1, errorString, *s1 == '=', M3_EFLAG_DEFAULT);
      s1++;
      out->sampleRate = atof(s1);
    }
    else if( strncmp( s1, "polarSpinRate", 13 ) == 0 )
    {
      s1 += 13;
      M3_ErrorCheck( -1, errorString, *s1 == '=', M3_EFLAG_DEFAULT);
      s1++;
      out->polarSpinRate = atof(s1);
    }
    else if( strncmp( s1, "polarSpinStartSec", 17 ) == 0 )
    {
      s1 += 17;
      M3_ErrorCheck( -1, errorString, *s1 == '=', M3_EFLAG_DEFAULT);
      s1++;
      out->polarSpinStart.sec = atof(s1);
    }
    else if( strncmp( s1, "polarSpinStartNsec", 18 ) == 0 )
    {
      s1 += 18;
      M3_ErrorCheck( -1, errorString, *s1 == '=', M3_EFLAG_DEFAULT);
      s1++;
      out->polarSpinStart.nsec = atof(s1);
    }
    else if( strncmp( s1, "endian", 6) == 0 ) 
    {
      s1 += 6;
      M3_ErrorCheck( -1, errorString, *s1 == '=', M3_EFLAG_DEFAULT);
      s1++;
      if( strncmp( s1, "big", 3) == 0 )
        out->isBigEndian = 1;
      else if( strncmp( s1, "little", 6) == 0)
        out->isBigEndian = 0;
      else
        M3_ErrorCheck(-1, errorString, 0, M3_EFLAG_DEFAULT);
    }
    s1 = strchr( s1, '_');
  }


  /* Set last call cache */
  strcpy( lastFormatString, theFile->format );
  lastFormatStruct = *out;

}


void M3_File_readHeader_ebex_gcpointing( M3_File *theFile, M3_GCPointingHeader *data )
{
  M3_FormatStruct_ebex formatStruct;
  M3_TimeEl firstTime;
  struct stat statStruct;

  M3_File_parseFormatString_ebex( theFile, &formatStruct );

  data->firstTime_sec = formatStruct.firstTime.sec;
  data->firstTime_nsec = formatStruct.firstTime.nsec;
  stat(theFile->name, &statStruct);
  data->numSample = statStruct.st_size/(3*sizeof(double));
  data->sampleRate = formatStruct.sampleRate;
  data->numDataPerSample = 3;
}

void M3_File_readData_ebex_gcpointing( M3_File *theFile, M3_Interval *readInterval, double *data )
{
  FILE *fid;
  M3_FormatStruct_ebex formatStruct;
  int64_t nread;

  /* Parse the format string.  */
  M3_File_parseFormatString_ebex( theFile, &formatStruct );

  /* Open the file and seek to the first stample. */
  fid = fopen(theFile->name, "r");
  M3_ErrorCheck(-1, theFile->name, (fid?1:0), M3_EFLAG_FOPEN_READ );
  fseek(fid, (readInterval->firstSample)*3*sizeof(double), SEEK_SET );
  
  /* Just do a binary read.  */
  nread = fread( data, 3*sizeof(double), readInterval->lastSample - readInterval->firstSample + 1, fid );
  M3_ErrorCheck(-1, theFile->name, nread == readInterval->lastSample - readInterval->firstSample + 1, M3_EFLAG_FREAD_COUNT );

  if( formatStruct.isBigEndian != testEndian() )  
    flipByteOrder( (void*)data, 3*(readInterval->lastSample - readInterval->firstSample + 1), sizeof(double));  

  fclose(fid);
}


void M3_File_readHeader_ebex_aux( M3_File *theFile, M3_AuxHeader *data )
{
  char line[M3_CONTENT_LENGTH] = {0};
  FILE *fid;
  int j;

  /* Open the file.  */
  fid = fopen(theFile->name, "r");
  M3_ErrorCheck(-1, theFile->name, (fid?1:0), M3_EFLAG_FOPEN_READ );

  /* Count the number of lines that don't begin with a # */
  j = 0;
  while( fgets( line, M3_CONTENT_LENGTH, fid ) )
  {
    if( line[0] != '#' && line[0] != '\0' )
      j++;
  }
  /* Set the size. */
  data->size = sizeof(M3_ebexAux) + j*sizeof(M3_ebexDetector);

  fclose(fid);

}


void M3_File_readData_ebex_aux( M3_File *theFile, void *data )
{
  char line[M3_CONTENT_LENGTH] = {0};
  FILE *fid;
  M3_ebexAux *ebexAux;
  M3_FormatStruct_ebex formatStruct;
  int numLines,j;

  M3_File_parseFormatString_ebex( theFile, &formatStruct );

  fid = fopen(theFile->name, "r");
  M3_ErrorCheck(-1, theFile->name, (fid?1:0), M3_EFLAG_FOPEN_READ );

  numLines = 0;
  while( fgets( line, M3_CONTENT_LENGTH, fid ) )
  {
    if( line[0] != '#' && line[0] != '\0' )
      numLines++;
  }

  fseek(fid, 0, SEEK_SET );

  ebexAux = data;
  data = ((char*)data+sizeof(M3_ebexAux));
  ebexAux->polarSpinStart = formatStruct.polarSpinStart;
  ebexAux->polarSpinRate = formatStruct.polarSpinRate;
  ebexAux->numDetector = numLines;
  ebexAux->detectorInfo = data;

  j = 0;
  while( fgets( line, M3_CONTENT_LENGTH, fid ) )
  {
    if( line[0] != '#' && line[0] != '\0' )
    {
      sscanf(line, "%d %*d %*d %*d %lf %lf %*d %*d", &(ebexAux->detectorInfo[j].detectorID), &(ebexAux->detectorInfo[j].offset[0]), &(ebexAux->detectorInfo[j].offset[1]) );
      j++;
    }
  }
  fclose(fid);
}

---