createSetIntervals.c

#include "M3.c"
#include "fitsio.h"
#include "M3_format_LevelS.h"

#define M3_CONTENT_LENGTH 256
#define M3_CREATESETINTERVALS_TIME_MODE 1
#define M3_CREATESETINTERVALS_SAMPLE_MODE 2
#define M3_CREATESETINTERVALS_POINTING_MODE 3


void M3_createSetIntervals(M3_RunConfigStruct *runConfig, int mode, double timePeriod, int64_t samplePeriod, double maxTime, int64_t maxSample, int64_t periods )
{
  fitsfile *thisFitsFile;
  M3_DataSetLL *thisDataSet;
  M3_IntervalLL *inIntervalList = NULL;
  M3_IntervalLL *newIntervalList = NULL;
  M3_IntervalLL *thisInterval = NULL;
  int64_t lastSample;
  double tempd;
  M3_FormatStruct_LevelS formatStruct;
  int status = 0;
  M3_File *theFile;
  char errorString[M3_CONTENT_LENGTH];
  char strBuffer[M3_CONTENT_LENGTH];
  int64_t numRow, i;
  M3_TimeEl firstTime, lastTime;

  
  for( thisDataSet = runConfig->dataSetList; 
       thisDataSet; 
       thisDataSet = thisDataSet->next  )
  {
    if( thisDataSet->coveredIntervalList )
    {
      for( thisInterval = thisDataSet->coveredIntervalList; thisInterval->next; thisInterval = thisInterval->next );
      lastSample = thisInterval->interval.lastSample;
      
      switch( mode )
      {
        case M3_CREATESETINTERVALS_TIME_MODE:
          samplePeriod = timePeriod*thisDataSet->sampleRate;
          maxSample = maxTime*thisDataSet->sampleRate;
          break;
        case M3_CREATESETINTERVALS_SAMPLE_MODE:
          if( maxSample && maxSample - 1 < lastSample )
            lastSample = maxSample - 1;
          newIntervalList = (M3_IntervalLL *)calloc(sizeof(M3_IntervalLL), 1);
          M3_ErrorCheck(-1, "M3_createSetIntervals()", (newIntervalList ? 1 : 0), M3_EFLAG_MALLOC_FSTRING );
          thisInterval = newIntervalList;
          thisInterval->interval.firstSample = 0;
          thisInterval->interval.lastSample = samplePeriod-1;
          while(thisInterval->interval.lastSample < lastSample )
          {
            thisInterval->next = (M3_IntervalLL *)calloc(sizeof(M3_IntervalLL), 1);
            M3_ErrorCheck(-1, "M3_createSetIntervals()", (thisInterval->next ? 1 : 0), M3_EFLAG_MALLOC_FSTRING );
            thisInterval->next->interval.firstSample = thisInterval->interval.lastSample + 1;
            thisInterval->next->interval.lastSample = thisInterval->interval.lastSample + samplePeriod;
            thisInterval = thisInterval->next; 
          }
          break;
        case M3_CREATESETINTERVALS_POINTING_MODE:
          M3_ErrorCheck(-1, "No GCPointingGroup in list", (thisDataSet->pointingClassList->subclassList->GCPointingGroupNode ? 1:0), M3_EFLAG_DEFAULT);
          M3_ErrorCheck(-1, "No simmission files", (thisDataSet->pointingClassList->subclassList->GCPointingGroupNode->GCPointingFileList ? 1:0), M3_EFLAG_DEFAULT );
          theFile = &(thisDataSet->pointingClassList->subclassList->GCPointingGroupNode->GCPointingFileList->file);
          M3_File_parseFormatString_LevelS( theFile, &formatStruct);
          M3_ErrorCheck(-1, "Simmission must be simmission2006 format", formatStruct.simmission2006, M3_EFLAG_DEFAULT);;
          M3_ErrorCheck(-1, "Multiple simmission files", thisDataSet->pointingClassList->subclassList->GCPointingGroupNode->GCPointingFileList->next == NULL, M3_EFLAG_DEFAULT );
          
          fits_open_file( &thisFitsFile, theFile->name , READONLY, &status);
          M3_ErrorCheck(-1, theFile->name, status == 0, M3_EFLAG_FOPEN_READ );
         
          fits_movabs_hdu( thisFitsFile, 2, NULL, &status );
          sprintf( errorString, "Could not go to second fits header in file %s", theFile->name );
          M3_ErrorCheck( -1, errorString, status == 0, M3_EFLAG_DEFAULT );

          fits_read_key_str( thisFitsFile, "NAXIS2", strBuffer, NULL, &status );
          sprintf( errorString, "Could not read NAXIS2 flag from second header unit of file: %s", theFile->name );
          M3_ErrorCheck(-1, errorString, status == 0, M3_EFLAG_DEFAULT );
          numRow = strtoll(strBuffer, NULL, 10);
          
          newIntervalList = (M3_IntervalLL *)calloc(sizeof(M3_IntervalLL), 1);
          M3_ErrorCheck(-1, "M3_createSetIntervals()", (newIntervalList ? 1 : 0), M3_EFLAG_MALLOC_FSTRING );
          thisInterval = newIntervalList;
          
          
          fits_read_col( thisFitsFile, TDOUBLE, 1, 1, 1, 1, NULL, &tempd, NULL, &status );
          firstTime.sec = tempd;
          fits_read_col( thisFitsFile, TDOUBLE, 2, 1, 1, 1, NULL, &tempd, NULL, &status );
          firstTime.nsec = tempd*1e9;
          fits_read_col( thisFitsFile, TDOUBLE, 13, periods, 1, 1, NULL, &tempd, NULL, &status );
          lastTime.sec = tempd;
          fits_read_col( thisFitsFile, TDOUBLE, 14, periods, 1, 1, NULL, &tempd, NULL, &status );
          lastTime.nsec = tempd*1e9;
          
          thisInterval->interval.firstSample = M3_myRound(M3_TimeEl_Difference(firstTime, thisDataSet->firstTime)*thisDataSet->sampleRate);
          thisInterval->interval.lastSample = M3_myRound(M3_TimeEl_Difference(lastTime, thisDataSet->firstTime)*thisDataSet->sampleRate);
          
          for(i = 1+periods; i <= numRow && thisInterval->interval.lastSample < lastSample; i += periods )
          {
            thisInterval->next = (M3_IntervalLL *)calloc(sizeof(M3_IntervalLL), 1);
            M3_ErrorCheck(-1, "M3_createSetIntervals()", (thisInterval->next ? 1 : 0), M3_EFLAG_MALLOC_FSTRING );
            thisInterval = thisInterval->next; 
            
            fits_read_col( thisFitsFile, TDOUBLE, 1, i, 1, 1, NULL, &tempd, NULL, &status );
            firstTime.sec = tempd;
            fits_read_col( thisFitsFile, TDOUBLE, 2, i, 1, 1, NULL, &tempd, NULL, &status );
            firstTime.nsec = tempd*1e9;
            fits_read_col( thisFitsFile, TDOUBLE, 13, i + periods - 1, 1, 1, NULL, &tempd, NULL, &status );
            lastTime.sec = tempd;
            fits_read_col( thisFitsFile, TDOUBLE, 14, i + periods - 1, 1, 1, NULL, &tempd, NULL, &status );
            lastTime.nsec = tempd*1e9;
            
            thisInterval->interval.firstSample = M3_myRound(M3_TimeEl_Difference(firstTime, thisDataSet->firstTime)*thisDataSet->sampleRate);
            thisInterval->interval.lastSample = M3_myRound(M3_TimeEl_Difference(lastTime, thisDataSet->firstTime)*thisDataSet->sampleRate) - 1;
          }
          break;
      }
    }

    inIntervalList = thisDataSet->coveredIntervalList;
    thisDataSet->coveredIntervalList = M3_intersectIntervalLists( inIntervalList, newIntervalList );
  
    M3_IntervalLL_destroyList( inIntervalList );
    M3_IntervalLL_destroyList( newIntervalList );
  }
}



int main( int argc, char **argv )
{
  double timePeriod = 0;
  int64_t samplePeriod = 0;
  int mode;
  char runConfigName[M3_CONTENT_LENGTH];
  char runConfigNameOut[M3_CONTENT_LENGTH];
  double maxTime = 0;
  int64_t maxSample = 0;
  int64_t periods = 1;

  M3_RunConfigStruct *runConfig;

  /* Usage:  createSetIntervals { -t time [maxTime] | -n samples [maxSample] | -p [periods] } runConfig*/


  if( strcmp( argv[1], "-t") == 0 )
  {
    M3_ErrorCheck(-1, "Usage:  createSetIntervals { -t time [maxTime] | -s samples [maxSample] | -p [periods]} runConfig", argc >= 4, M3_EFLAG_DEFAULT );
    mode = M3_CREATESETINTERVALS_TIME_MODE;
    timePeriod = atof(argv[2]);
    if( argc == 4 )
      strcpy( runConfigName, argv[3]);
    else
    {
      maxTime = atof(argv[3]);
      strcpy( runConfigName, argv[4] );
    }
        
  }
  else if( strcmp(argv[1], "-s") == 0 )
  {
    M3_ErrorCheck(-1, "Usage:  createSetIntervals { -t time [maxTime] | -s samples [maxSample] | -p [periods]} runConfig", argc >= 4, M3_EFLAG_DEFAULT );
    mode = M3_CREATESETINTERVALS_SAMPLE_MODE;
    samplePeriod = strtoll(argv[2], NULL, 10);
    if( argc == 4 )
      strcpy( runConfigName, argv[3]);
    else
    {
      maxSample = strtoll(argv[3], NULL, 10);
      strcpy( runConfigName, argv[4]);
    }
  }
  else if( strcmp(argv[1], "-p") == 0 )
  {
    M3_ErrorCheck(-1, "Usage:  createSetIntervals { -t time [maxTime] | -s samples [maxSample] | -p [periods] } runConfig", argc >= 3, M3_EFLAG_DEFAULT );
    if( argc >= 4 )
    {
      periods = atoi( argv[2] );
      strcpy( runConfigName, argv[3]);      
    }
    else
    {
      periods = 1;
      strcpy( runConfigName, argv[2]);
    }      
    mode = M3_CREATESETINTERVALS_POINTING_MODE;

  }
  else
    M3_ErrorCheck(-1, "Usage:  createSetIntervals { -t time [maxTime] | -s samples [maxSample] | -p [periods] } runConfig", 0, M3_EFLAG_DEFAULT );
  

  M3_RunConfigStruct_Read(&runConfig, runConfigName, M3_SPRINGTIDE_RUN_TYPE);

  M3_createSetIntervals(runConfig, mode, timePeriod, samplePeriod, maxTime, maxSample, periods);

  sprintf( runConfigNameOut, "%s.csi", runConfigName);

  M3_RunConfigStruct_Write(runConfig, runConfigNameOut );

  M3_RunConfigStruct_Destroy( runConfig );

  return(0);
}

---