printData.c

#include "M3.h"
#include "M3_system.h"
#include <M3_format.h>

void M3_File_printData_mask( M3_File *theFile, int32_t numValToPrint, int32_t firstValToPrint  );
void M3_File_printData_map( M3_File *theFile, int32_t numValToPrint, int32_t firstValToPrint  );
void M3_File_printData_coord( M3_File *theFile, int32_t numValsToPrint, int32_t firstValToPrint );
void M3_File_printData_noise( M3_File *theFile, int32_t numValsToPrint, int32_t firstValToPrint );
void M3_File_printData_sparse( M3_File *theFile, int32_t numValsToPrint, int32_t firstValToPrint );
void M3_File_printData_gcpointing( M3_File *theFile, int64_t numValsToPrint, int64_t firstValToPrint );


void M3_File_printData_mask( M3_File *theFile, int32_t numValToPrint, int32_t firstValToPrint  )
{
  int32_t i,j,k,l;
  M3_AnyHeader header;
  M3_MapEl *mask;
  static int64_t diskBufferSize = -1;
  char *tempPtr;
  int64_t diskBufferLength;

  if( diskBufferSize == -1 )
  {
    tempPtr = getenv("M3_DISK_BUFFER_SIZE");
    if( tempPtr )
      diskBufferSize = strtoll( tempPtr, NULL, 10);
    else
      diskBufferSize = M3_DISK_BUFFER_SIZE;
  }
  
  diskBufferLength = diskBufferSize/sizeof(M3_MapEl );

  M3_File_ReadHeader( theFile, &header );

  fprintf( stdout, "     %i\n\n", header.mask.numPixelInClass );

  mask = (M3_MapEl *)calloc( diskBufferLength, sizeof(M3_MapEl) );
  
  M3_ErrorCheck( -1, "M3_File_printData_mask", mask, M3_EFLAG_MALLOC_FSTRING );

  j = 0;
  i = firstValToPrint;
  while( j < numValToPrint && i < header.mask.numPixelInClass )
  {
    for( k = 0; k < diskBufferLength && i < header.mask.numPixelInClass; k++ )
    {
      mask[k].pixel = i;
      i++;
    }
    M3_File_ReadData( theFile, &k, mask );
     
    for( l = 0; l < k && j < numValToPrint; l++ )
    {
      fprintf( stdout, "     %i     %.8e\n", mask[l].pixel, mask[l].value );
      j++;
    }
  }
  fprintf( stdout, "\n\n");
  free( mask );

  return;
}

void M3_File_printData_map( M3_File *theFile, int32_t numValToPrint, int32_t firstValToPrint  )
{
  int32_t i, j, k, l;
  M3_AnyHeader header;
  M3_MapEl *map;
  static int64_t diskBufferSize = -1;
  char *tempPtr;
  int64_t diskBufferLength;

  if( diskBufferSize == -1 )
  {
    tempPtr = getenv("M3_DISK_BUFFER_SIZE");
    if( tempPtr )
      diskBufferSize = strtoll( tempPtr, NULL, 10);
    else
      diskBufferSize = M3_DISK_BUFFER_SIZE;
  }
  
  diskBufferLength = diskBufferSize/sizeof(M3_MapEl );

  M3_File_ReadHeader( theFile, &header );

  fprintf(stdout, "%i     %i\n\n", header.map.numPixelInClass, header.map.numPixelInMap );

  map = (M3_MapEl *)calloc( diskBufferLength, sizeof(M3_MapEl) );
  
  M3_ErrorCheck( -1, "M3_File_printData_map", map, M3_EFLAG_MALLOC_FSTRING );

  j = 0;
  i = firstValToPrint;
  while( j < numValToPrint && i < header.map.numPixelInClass )
  {
    for( k = 0; k < diskBufferLength && i < header.map.numPixelInClass; k++ )
    {
      map[k].pixel = i;
      i++;
    }
    M3_File_ReadData( theFile, &k, map );
    
    for( l = 0; l < k && j < numValToPrint; l++ )
    {
      if( !isnan(map[l].value) )
      {
        fprintf( stdout, "     %i     %.8e\n", map[l].pixel, map[l].value );
        j++;
      }
    }
  }

  fprintf( stdout, "\n\n");

  free(map);
  
  return;
}

void M3_File_printData_coord( M3_File *theFile, int32_t numValsToPrint, int32_t firstValToPrint  )
{
  M3_CoordEl *coords;
  M3_CoordHeader header;
  int32_t i;

  M3_File_ReadHeader( theFile, &header );

  coords = (M3_CoordEl *)calloc( numValsToPrint, sizeof(M3_CoordEl) );

  M3_ErrorCheck( -1, "M3_File_printData_coord", coords, M3_EFLAG_MALLOC_FSTRING );

  for( i = 0; i < numValsToPrint; i++)
  {
    coords[i].pixel = i + firstValToPrint;
  }

  M3_File_ReadData( theFile, &numValsToPrint, coords );

  fprintf(stdout, "     %i\n", header.numPixelInClass );

  for( i = 0; i < numValsToPrint; i++)
    fprintf( stdout, "     %i     %.8e     %.8e\n", coords[i].pixel, coords[i].ra, coords[i].dec );
  fprintf(stdout, "\n\n");
  free( coords);
  
}



void M3_File_printData_noise( M3_File *theFile, int32_t numValsToPrint, int32_t firstValToPrint )
{
  int64_t i;
  M3_NoiseHeader header;
  double *noise;

  M3_File_ReadHeader( theFile, &header );

  fprintf( stdout, "     %lli     %lli     %lli\n\n", header.firstSample, header.lastSample, header.corLength );

  noise = (double*)malloc(sizeof(double)*(header.corLength + 1));
  M3_ErrorCheck(-1, "M3_File_printData_noise()", noise, M3_EFLAG_MALLOC_FSTRING);

  M3_File_ReadData(theFile, NULL, noise );



  for( i = firstValToPrint; i < firstValToPrint + numValsToPrint && i < header.corLength + 1; i++ )
    fprintf( stdout, "     %.8e\n", noise[i] );

  free(noise);
}

void M3_File_printData_sparse( M3_File *theFile, int32_t numValToPrint, int32_t firstValToPrint )
{
  int32_t i, j; 
  int32_t k, l;
  M3_SparseHeader header;
  M3_SparsePixelMatrixEl *sparseEl;
  static int64_t diskBufferSize = -1;
  char *tempPtr;
  int64_t diskBufferLength;

  if( diskBufferSize == -1 )
  {
    tempPtr = getenv("M3_DISK_BUFFER_SIZE");
    if( tempPtr )
      diskBufferSize = strtoll( tempPtr, NULL, 10);
    else
      diskBufferSize = M3_DISK_BUFFER_SIZE;
  }


  diskBufferLength = diskBufferSize/sizeof(M3_SparsePixelMatrixEl);
  sparseEl = (M3_SparsePixelMatrixEl *)calloc( diskBufferLength, sizeof(M3_SparsePixelMatrixEl) );
  M3_ErrorCheck(-1, "M3_File_printData_sparse()", (sparseEl ? 1 : 0), M3_EFLAG_MALLOC_FSTRING);
 
  M3_File_ReadHeader( theFile, &header );

  fprintf(stdout, "%lli     %lli\n\n", header.numColumn, header.numNZ );

  j = 0;
  i = firstValToPrint;
  while( j < numValToPrint )
  {
    for( k = 0; k < diskBufferLength && i < header.numColumn; k++ )
    {
      sparseEl[k].rowClass = 1;
      sparseEl[k].rowPixel = i;
      i++;
    }
    M3_File_ReadData( theFile, &k, sparseEl );
     
    for( l = 0; l < k && j < numValToPrint; l++ )
    {
      if( !isnan(sparseEl[l].value) )
      {
        fprintf( stdout, "     %i     %i     %.8e\n", sparseEl[l].rowClass, sparseEl[l].rowPixel, sparseEl[l].value );
        j++;
      }
    }
  }

  fprintf( stdout, "\n\n");

  free(sparseEl);

}

void M3_File_printData_gcpointing( M3_File *theFile, int64_t numValsToPrint, int64_t firstValToPrint )
{
  int64_t i, j, k, numRead;
  double *data;
  M3_Interval readInterval;
  static int64_t diskBufferSize = -1;
  char *tempPtr;
  int64_t diskBufferLength;
  int64_t offset;
  
  int dataPerSample = theFile->param.gcpointing.numDataPerSample;

  if( diskBufferSize == -1 )
  {
    tempPtr = getenv("M3_DISK_BUFFER_SIZE");
    if( tempPtr )
      diskBufferSize = strtoll( tempPtr, NULL, 10);
    else
      diskBufferSize = M3_DISK_BUFFER_SIZE;
  }
  
  diskBufferLength = diskBufferSize / (dataPerSample*sizeof(double));
  
  data = (double*)malloc(diskBufferSize);
  M3_ErrorCheck(-1, "M3_File_printData_gcpointing()", (data?1:0), M3_EFLAG_MALLOC_FSTRING );

  numRead = numValsToPrint/diskBufferLength + ( numValsToPrint%diskBufferLength ? 1 : 0 );
 
  fprintf(stdout, "%lli  %e  %lli  %e  %i\n\n", 
          theFile->param.gcpointing.firstTime.sec, 
          theFile->param.gcpointing.firstTime.nsec,
          theFile->param.gcpointing.numSample,
          theFile->param.gcpointing.sampleRate,
          theFile->param.gcpointing.numDataPerSample );
  
  for( k = 0; k < numRead; k++ )
  {
    readInterval.firstSample = firstValToPrint + k*diskBufferLength;

    if( k == numRead-1 && numValsToPrint%diskBufferLength )
      diskBufferLength = numValsToPrint%diskBufferLength;

    readInterval.lastSample = readInterval.firstSample + diskBufferLength - 1;

    M3_File_ReadData( theFile, &readInterval, data );

    for( i = 0; i < diskBufferLength; i++ )
    {
      offset = i * (int64_t)dataPerSample;
      for (j = 0; j < dataPerSample; j++) {
        fprintf(stdout, "%.15e ", data[offset + j]);
      }
      fprintf(stdout, "\n");
      fflush(stdout);
    }
  }
  free(data);
  return;
}


void printData_RCpointing( M3_DataSetLL *dataSet, int64_t firstValToPrint, int64_t numValsToPrint )
{
  int64_t i, j, k, l, numRead;
  M3_PointingEl *data;
  M3_Interval readInterval;
  static int64_t diskBufferSize = -1;
  char *tempPtr;
  int64_t diskBufferLength;

  if( diskBufferSize == -1 )
  {
    tempPtr = getenv("M3_DISK_BUFFER_SIZE");
    if( tempPtr )
      diskBufferSize = strtoll( tempPtr, NULL, 10);
    else
      diskBufferSize = M3_DISK_BUFFER_SIZE;
  }


  diskBufferLength = diskBufferSize/(dataSet->numNZ*sizeof(M3_PointingEl));

  data = (M3_PointingEl*)malloc(diskBufferSize);
  M3_ErrorCheck(-1, "printData_RCpointing()", (data?1:0), M3_EFLAG_MALLOC_FSTRING );

  numRead = numValsToPrint/diskBufferLength + ( numValsToPrint%diskBufferLength ? 1 : 0 );
 
  for( k = 0; k < numRead; k++ )
  {
    readInterval.firstSample = firstValToPrint + k*diskBufferLength;

    if( k == numRead-1 && numValsToPrint%diskBufferLength )
      diskBufferLength = numValsToPrint%diskBufferLength;

    readInterval.lastSample = readInterval.firstSample + diskBufferLength - 1;

    M3_DataSetLL_GetPointing( dataSet, readInterval, data );

    for( i = 0; i < diskBufferLength; i++ )
    {
      for( l = 0; l < dataSet->numNZ; l++ )
        fprintf(stdout, "%i     %e     ", data[i*dataSet->numNZ + l].pixel, data[i*dataSet->numNZ + l].weight);
      fprintf(stdout, "\n");
    }
  }
  free(data);
}



void printData_RCtod( M3_DataSetLL *dataSet, int64_t firstValToPrint, int64_t numValsToPrint )
{
  int64_t i, j, k, l, numRead;
  double *data;
  M3_Interval readInterval;
  static int64_t diskBufferSize = -1;
  char *tempPtr;
  int64_t diskBufferLength;

  if( diskBufferSize == -1 )
  {
    tempPtr = getenv("M3_DISK_BUFFER_SIZE");
    if( tempPtr )
      diskBufferSize = strtoll( tempPtr, NULL, 10);
    else
      diskBufferSize = M3_DISK_BUFFER_SIZE;
  }

  diskBufferLength = diskBufferSize/(sizeof(double));

  data = (double*)malloc(diskBufferSize);
  M3_ErrorCheck(-1, "printData_RCtod()", (data?1:0), M3_EFLAG_MALLOC_FSTRING );

  numRead = numValsToPrint/diskBufferLength + ( numValsToPrint%diskBufferLength ? 1 : 0 );
 
  for( k = 0; k < numRead; k++ )
  {
    readInterval.firstSample = firstValToPrint + k*diskBufferLength;

    if( k == numRead-1 && numValsToPrint%diskBufferLength )
      diskBufferLength = numValsToPrint%diskBufferLength;

    readInterval.lastSample = readInterval.firstSample + diskBufferLength - 1;

    M3_DataSetLL_GetTOD( dataSet, readInterval, data );

    for( i = 0; i < diskBufferLength; i++ )
    {
      fprintf(stdout, "%e\n", data[i]);
    }
  }
  free(data);
}


int main( int argc, char **argv )
{
  int myRank, numProc;
  int64_t numValsToPrint, firstValToPrint, i, j;
  M3_File theFile = {0};
  M3_AnyHeader header;
  void *buffer = NULL;
  M3_Interval readInterval;
  int returnValue = 0;
  int runType;
  M3_RunConfigStruct *runConfig;
  M3_DataSetLL *dataSet;
  size_t cacheSize;
  M3_TODcacheStruct *todCache;

  /* printData fileName fileFormat fileType [numValsToPrint] [firstValToPrint] */

  if( argc < 4 )
  {
    fprintf(stderr, "Usage:  %s fileName fileFormat fileType [numValsToPrint] [firstValToPrint]\n", argv[0]);
    fprintf(stderr, "        or\n");
    fprintf(stderr, "Usage:  %s -r xmlFileName runType dataType groupID [numValsToPrint] [firstValToPrint]\n", argv[0]);
    return(1);
  }

  if( strcmp(argv[1], "-r") && strcmp(argv[1], "-R") )
  {
    theFile.name = argv[1];
    theFile.format = argv[2];

    if( strcmp( argv[3], "tod" ) == 0 )
      theFile.fileType = M3_TOD_FILE_TYPE;
    else if( strcmp( argv[3], "toc" ) == 0 )
      theFile.fileType = M3_TOC_FILE_TYPE;
    else if( strcmp( argv[3], "pointing" ) == 0 )
      theFile.fileType = M3_POINTING_FILE_TYPE;
    else if( strcmp( argv[3], "noise" ) == 0 )
      theFile.fileType = M3_NOISE_FILE_TYPE;
    else if( strcmp( argv[3], "filter" ) == 0 )
      theFile.fileType = M3_FILTER_FILE_TYPE;
    else if( strcmp( argv[3], "map" ) == 0 )
      theFile.fileType = M3_MAP_FILE_TYPE;
    else if( strcmp( argv[3], "mask" ) == 0 )
      theFile.fileType = M3_MASK_FILE_TYPE;
    else if( strcmp( argv[3], "coord") == 0 )
      theFile.fileType = M3_COORD_FILE_TYPE;
    else if( strcmp( argv[3], "spectrum") == 0 )
      theFile.fileType = M3_SPECTRUM_FILE_TYPE;
    else if( strcmp( argv[3], "bin") == 0 )
      theFile.fileType = M3_BIN_FILE_TYPE;
    else if( strcmp( argv[3], "bps") == 0 )
      theFile.fileType = M3_BPS_FILE_TYPE;
    else if( strcmp( argv[3], "fisher") == 0 )
      theFile.fileType = M3_FISHER_FILE_TYPE;
    else if( strcmp( argv[3], "sparse") == 0 )
      theFile.fileType = M3_SPARSE_FILE_TYPE;
    else if( strcmp( argv[3], "gcpointing") == 0 )
      theFile.fileType = M3_GCPOINTING_FILE_TYPE;
    else
      M3_ErrorCheck(-1, "Could not interperate file type", 0, M3_EFLAG_DEFAULT );

    if( argc > 4 )
      numValsToPrint = strtoll(argv[4], NULL, 10);
    else 
      numValsToPrint = 10;

    if( argc > 5 )
      firstValToPrint = strtoll(argv[5], NULL, 10);
    else
      firstValToPrint = 0;

    M3_File_ReadHeader( &theFile, &header );

    switch( theFile.fileType )
    {
      case M3_TOD_FILE_TYPE:
        /* Print the header */
        fprintf( stdout, "%lli     %lli\n\n", header.tod.firstSample, header.tod.lastSample);

        /* Allocate some memory */
        if( numValsToPrint )
        {
          /* Interpret the header */
          theFile.param.tod.interval.firstSample = header.tod.firstSample;
          theFile.param.tod.interval.lastSample = header.tod.lastSample;
          theFile.param.tod.calib = 1;


          buffer = malloc(numValsToPrint*sizeof(double));
          M3_ErrorCheck( 0, "main", buffer, M3_EFLAG_MALLOC_FSTRING );

          /* Read data */
          readInterval.firstSample = header.tod.firstSample + firstValToPrint;
          readInterval.lastSample = readInterval.firstSample + numValsToPrint - 1;
          M3_File_ReadData( &theFile, &readInterval, buffer);

          /* Print the data */
          for( i = 0; i < numValsToPrint; i++ )
            fprintf( stdout, "%.8e\n", ((double *)buffer)[i] );
        }

        fprintf( stdout, "\n\n");

        break;
      case M3_TOC_FILE_TYPE:
        /* Print the header */
        fprintf( stdout, "%lli     %lli\n\n", header.tod.firstSample, header.tod.lastSample );


        if( numValsToPrint )
        {
          /* Interpret the header */
          theFile.param.toc.interval.firstSample = header.toc.firstSample;
          theFile.param.toc.interval.lastSample = header.toc.lastSample;
          theFile.param.toc.calib = 1;
          theFile.param.toc.action = M3_MULTIPLY_TOC_ACTION;

          /* Allocate some memory */
          buffer = malloc(numValsToPrint*sizeof(double));
          M3_ErrorCheck( 0, "main", buffer, M3_EFLAG_MALLOC_FSTRING );

          /* Read data */
          readInterval.firstSample = header.toc.firstSample + firstValToPrint;
          readInterval.lastSample = readInterval.firstSample + numValsToPrint - 1;
          M3_File_ReadData( &theFile, &readInterval, buffer );

          /* Print the data */
          for( i = 0; i < numValsToPrint; i++ )
            fprintf( stdout, "%.8e\n", ((double *)buffer)[i] );
        }
        fprintf( stdout, "\n\n");

        break;
      case M3_POINTING_FILE_TYPE:
        fprintf( stdout, "%lli     %lli     %i     %i\n\n", header.pointing.firstSample, 
                                                    header.pointing.lastSample, 
                                                    header.pointing.numPixelInClass, 
                                                    header.pointing.numNZ);

        if( numValsToPrint )
        {
          theFile.param.pointing.interval.firstSample = header.pointing.firstSample;
          theFile.param.pointing.interval.lastSample = header.pointing.lastSample;
          theFile.param.pointing.calib = 1;

          buffer = malloc(numValsToPrint*header.pointing.numNZ*sizeof(M3_PointingEl));
          M3_ErrorCheck( 0, "main", buffer, M3_EFLAG_MALLOC_FSTRING );

          readInterval.firstSample = header.pointing.firstSample + firstValToPrint;
          readInterval.lastSample = readInterval.firstSample + numValsToPrint - 1;
          M3_File_ReadData( &theFile, &readInterval, buffer);

          for( i = 0; i < numValsToPrint; i++ )
          {
            for( j = 0; j < header.pointing.numNZ; j++ )
            {
              fprintf( stdout, "%i     %.8e    ", ((M3_PointingEl*)buffer)[i*header.pointing.numNZ + j].pixel, 
                                                  ((M3_PointingEl*)buffer)[i*header.pointing.numNZ + j].weight );
            }

            fprintf( stdout, "\n");
          }
        }
        break;
      case M3_NOISE_FILE_TYPE:
        theFile.param.noise.interval.firstSample = header.noise.firstSample;
        theFile.param.noise.interval.lastSample = header.noise.lastSample;
        theFile.param.noise.calib = 1;
        theFile.param.noise.corLength = header.noise.corLength;
        M3_File_printData_noise( &theFile, numValsToPrint, firstValToPrint );
        break;
      case M3_FILTER_FILE_TYPE:
        theFile.param.filter.interval.firstSample = header.filter.firstSample;
        theFile.param.filter.interval.lastSample = header.filter.lastSample;
        theFile.param.filter.length = header.filter.length;
        theFile.param.filter.bandWidth = header.filter.bandWidth;
        break;
      case M3_MAP_FILE_TYPE:
        theFile.param.map.numPixel = header.map.numPixelInMap;
        theFile.param.map.offset = 0;
        M3_File_printData_map( &theFile, numValsToPrint, firstValToPrint );
        break;
      case M3_MASK_FILE_TYPE:
        theFile.param.mask.offset = 0;
        M3_File_printData_mask( &theFile, numValsToPrint, firstValToPrint );
        break;
      case M3_COORD_FILE_TYPE:
        M3_File_printData_coord( &theFile, numValsToPrint, firstValToPrint  );
        break;
      case M3_SPECTRUM_FILE_TYPE:
        break;
      case M3_BIN_FILE_TYPE:
        break;
      case M3_BPS_FILE_TYPE:
        break;
      case M3_FISHER_FILE_TYPE:
        break;
      case M3_SPARSE_FILE_TYPE:
        M3_File_printData_sparse( &theFile, numValsToPrint, firstValToPrint );
        break;
      case M3_GCPOINTING_FILE_TYPE:
        theFile.param.gcpointing.firstTime.sec = header.gcpointing.firstTime_sec;
        theFile.param.gcpointing.firstTime.nsec = header.gcpointing.firstTime_nsec;
        theFile.param.gcpointing.numSample = header.gcpointing.numSample;
        theFile.param.gcpointing.sampleRate = header.gcpointing.sampleRate;
        theFile.param.gcpointing.numDataPerSample = header.gcpointing.numDataPerSample;
        M3_File_printData_gcpointing( &theFile, numValsToPrint, firstValToPrint );
        break;
    }

    if( buffer )
      free(buffer);

    return(returnValue);
  }
  else
  {
    if( argc > 6 )
      numValsToPrint = strtoll(argv[6], NULL, 10);
    else 
      numValsToPrint = 10;

    if( argc > 7 )
      firstValToPrint = strtoll(argv[7], NULL, 10);
    else
      firstValToPrint = 0;

    if( strcmp( argv[4], "MADnes" ) == 0 )
      runType = M3_MADNES_RUN_TYPE;
    else if( strcmp( argv[3], "MADmap") == 0 )
      runType = M3_MADMAP_RUN_TYPE;
    else if( strcmp( argv[3], "MADspec") == 0 )
      runType = M3_MADSPEC_RUN_TYPE;
    else if( strcmp( argv[3], "springtide") == 0 )
      runType = M3_SPRINGTIDE_RUN_TYPE;
    else 
    {
      fprintf(stderr, "ERROR:  runType is not recognized.  Must be one of (MADnes, MADmap, MADspec, or springtide)\n");
      return 1;
    }
    if(strcmp(argv[1], "-r") == 0)
      M3_RunConfigStruct_Read( &runConfig, argv[2], runType );
    else 
      M3_RunConfigStruct_ReadBin( &runConfig, argv[2], runType);

    if( strcmp( argv[4], "pointing") == 0 )
    {
      M3_RunConfigStruct_GetDataSetRoot( runConfig, &dataSet );
      while(dataSet && strcmp( dataSet->name, argv[5] ) )
        dataSet = dataSet->next;

      M3_ErrorCheck(-1, "groupID does not match any data set names", (dataSet?1:0), M3_EFLAG_DEFAULT);
      readInterval.firstSample = firstValToPrint;
      readInterval.lastSample = firstValToPrint+numValsToPrint - 1;

      M3_RunConfigStruct_GetTODcache( runConfig, &todCache );
      M3_TODcacheStruct_AppendRequest( todCache, dataSet, readInterval);
      M3_TODcacheStruct_Initialize( todCache, runConfig, &cacheSize );
      printData_RCpointing(dataSet, firstValToPrint, numValsToPrint );
      M3_TODcacheStruct_Destroy( todCache );
    }
    else if( strcmp( argv[4], "tod") == 0 )
    {
      M3_RunConfigStruct_GetDataSetRoot( runConfig, &dataSet );
      while(dataSet && strcmp( dataSet->name, argv[5] ) )
        dataSet = dataSet->next;

      M3_ErrorCheck(-1, "groupID does not match any data set names", (dataSet?1:0), M3_EFLAG_DEFAULT);
      readInterval.firstSample = firstValToPrint;
      readInterval.lastSample = firstValToPrint+numValsToPrint - 1;

      M3_RunConfigStruct_GetTODcache( runConfig, &todCache );
      M3_TODcacheStruct_AppendRequest( todCache, dataSet, readInterval);
      M3_TODcacheStruct_Initialize( todCache, runConfig, &cacheSize );
      printData_RCtod(dataSet, firstValToPrint, numValsToPrint );
      M3_TODcacheStruct_Destroy( todCache );
    }

    M3_RunConfigStruct_Destroy( runConfig );    

  }

  return 0;

}

---