M3_internal.h

/*******************************************************************************
*   M3:  M3.h                                                                  *
*                                                                              *
*   Version 1.0 May 2004                                                       *
*                                                                              *
*   Copyright (C) 2004  C.M. Cantalupo                                         *
*                                                                              *
*   This program is free software; you can redistribute it and/or modify       *
*   it under the terms of the GNU General Public License as published by       *
*   the Free Software Foundation; either version 2 of the License, or          *
*   (at your option) any later version.                                        *
*                                                                              *
*   This program is distributed in the hope that it will be useful,            *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of             *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
*   GNU General Public License for more details.                               *
*                                                                              *
*   You should have received a copy of the GNU General Public License          *
*   along with this program; if not, write to the Free Software                *
*   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  *
*                                                                              *
*******************************************************************************/


#ifndef _H_M3_internal
#define _H_M3_internal

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>

#define M3_TOD_FILE_TYPE 0
#define M3_TOC_FILE_TYPE 1
#define M3_POINTING_FILE_TYPE 2
#define M3_NOISE_FILE_TYPE 3
#define M3_FILTER_FILE_TYPE 4
#define M3_MAP_FILE_TYPE 5
#define M3_MASK_FILE_TYPE 6
#define M3_COORD_FILE_TYPE 7
#define M3_SPECTRUM_FILE_TYPE 8
#define M3_BIN_FILE_TYPE 9
#define M3_BPS_FILE_TYPE 10
#define M3_FISHER_FILE_TYPE 11
#define M3_SPARSE_FILE_TYPE 12
#define M3_GCPOINTING_FILE_TYPE 13
#define M3_AUX_FILE_TYPE 14

#define M3_NO_SIM_TYPE 0
#define M3_MAPSCAN_SIM_TYPE 1
#define M3_OOFNOISE_SIM_TYPE 2

#define M3_MULTIPLY_TOC_ACTION 0
#define M3_DIVIDE_TOC_ACTION 1


/* A list of intervals */

typedef struct intervalTag 
{ 
  M3_Interval interval;
  void *v;
  struct intervalTag *next;
} M3_IntervalLL;

typedef struct timeIntervalTag
{
  M3_TimeInterval interval;
  void *v;
  struct timeIntervalTag *next;
} M3_TimeIntervalLL;


/********************************/
/* Define The M3 Data File */
/********************************/

/* The type-specific file parameters */

typedef struct 
{
  M3_Interval interval;
  double calib;
} M3_TODfileParamStruct;

typedef struct 
{
  M3_Interval interval;
  double calib;
  int32_t action;
} M3_TOCfileParamStruct;

typedef struct 
{
  M3_Interval interval;
  double calib;
} M3_PointingFileParamStruct;

typedef struct 
{
  M3_Interval interval;
  double calib;
  int64_t corLength;
} M3_NoiseFileParamStruct;

typedef struct 
{
  M3_Interval interval;
  int64_t length;
  int64_t bandWidth;
} M3_FilterFileParamStruct;

typedef struct 
{
  int32_t numPixel;
  int32_t offset;
} M3_MapFileParamStruct;

typedef struct
{
  int64_t numColumn;
  int64_t numNZ;
  int64_t offset;
} M3_SparseFileParamStruct;

typedef struct
{
  int32_t offset;
} M3_CoordFileParamStruct;

typedef struct
{
  int32_t offset;
} M3_MaskFileParamStruct;

typedef struct
{
  M3_TimeEl firstTime;
  int64_t numSample;
  double sampleRate;
  int32_t numDataPerSample;
} M3_GCPointingFileParamStruct;

typedef struct
{
  size_t size;
} M3_AuxFileParamStruct;

/*



typedef struct
{

} M3_SpectrumFileParamStruct;

typedef struct
{

} M3_BinFileParamStruct;

typedef struct
{

} M3_BPSfileParamStruct;

typedef struct
{

} M3_FisherFileParamStruct;

*/

typedef union 
{
  M3_TODfileParamStruct tod;
  M3_TOCfileParamStruct toc;
  M3_PointingFileParamStruct pointing;
  M3_NoiseFileParamStruct noise;
  M3_FilterFileParamStruct filter;
  M3_MapFileParamStruct map;
  M3_SparseFileParamStruct sparse;
  M3_MaskFileParamStruct mask;
  M3_CoordFileParamStruct coord;
  M3_GCPointingFileParamStruct gcpointing;
  M3_AuxFileParamStruct aux;
  /*
  M3_SpectrumFileParamStruct spectrum;
  M3_BinFileParamStruct bin;
  M3_BPSfileParamStruct bps;
  M3_FisherFileParamStruct fisher;
  */
} M3_FileParamUnion;


/* A file of a particular type */

typedef struct
{
  char *name;
  char *format;
  int32_t fileType;
  M3_FileParamUnion param;
} M3_File;

/* A list of files of a particular type */

typedef struct fileTag 
{
  M3_File file;
  void *v;
  struct fileTag *next;
} M3_FileLL;

/********************************************************/
/* Define The List Of Spectrum Classes In A M3 Run */
/********************************************************/

typedef struct spectrumClassTag
{
  int32_t spectrumType;
  int32_t lmax;
  int32_t numBin;
  M3_File *shapeFile;
  M3_File *binFile;
  M3_File *bpsFile;
  struct spectrumClassTag *next;
} M3_SpectrumClassLL;


typedef struct 
{
  int32_t numBin;
  M3_SpectrumClassLL *spectrumClassList;
  M3_File *fisherMatrix;
} M3_PowerSpectrumStruct;


/*****************************************************/
/* Define The List Of Pixel Classes In A M3 Run      */
/*****************************************************/

typedef struct pixelClassTag 
{
  char *className;
  int32_t classIndex;
  int32_t pixelType;
  int32_t numPixelInClass;
  int32_t globalPixelOffset;
  M3_File *mapFile;
  M3_File *coordFile;
  M3_File *windowFile;
  M3_FileLL *maskFileList;
  M3_FileLL *templateFileList;
  void *v;
  struct pixelClassTag *next;
} M3_PixelClassLL;

/**********************************************************/
/* Define The List Of Pointing Files In A M3 Dataset      */
/**********************************************************/

typedef struct GCPointingStoreTag
{
  M3_TimeEl firstTime;
  int64_t numSample;
  double sampleRate;
  int32_t numDataPerSample;
  double *data;
  void *v;
  struct GCPointingStoreTag *next;
} M3_GCPointingStoreLL;

typedef struct GCPointingGroupTag
{
  char *name;
  char *GCPointingType;
  M3_File *auxFile;
  M3_FileLL *GCPointingFileList;
  M3_GCPointingStoreLL *GCPointingStoreList;
  void *auxStore;
  void *v;
  struct GCPointingGroupTag *next;
} M3_GCPointingGroupLL;

/* A dataset's pointing subclass, including a list of associated pointing files */

typedef struct pointingSubclassTag
{
  int32_t numNZ;
  int32_t columnOffset;
  int32_t isFull;
  M3_FileLL *pointingFileList;
  M3_GCPointingGroupLL *GCPointingGroupNode;
  char *auxComplement;
  void *v;
  struct pointingSubclassTag *next;
} M3_PointingSubclassLL;

/* A dataset's pointing class, including a list of associated subclasses */

typedef struct pointingClassTag 
{
  int32_t numNZ;
  int32_t columnOffset;
  M3_PixelClassLL *pixelClassNode;
  M3_PointingSubclassLL *subclassList;
  M3_FileLL *pointingCalibFileList;
  void *v;
  struct pointingClassTag *next;
} M3_PointingClassLL;

/************************************************/
/* Define The List Of Datasets In an M3 Run     */
/************************************************/

typedef struct subcomponentTag
{
  int32_t simType;
  M3_FileLL *todFileList;
  M3_PointingClassLL *mapScanSimPointingList;
  M3_FileLL *oofNoiseSimFileList;
  void *v;
  struct subcomponentTag *next;
} M3_SubcomponentLL;

typedef struct componentTag
{
  M3_SubcomponentLL *subcomponentList;
  M3_FileLL *todCalibFileList;
  void *v;
  struct componentTag *next;
} M3_ComponentLL;

typedef struct NoiseFilterTag
{
  M3_Interval interval;
  int64_t corLength;
  int64_t filterLength;
  double *noiseFilterTime;
  double *noiseFilterFreq;
  void *v;
  struct NoiseFilterTag *next;
} M3_NoiseFilterLL;

typedef struct
{
  int32_t numGlobalPix;        /* The total number of pixels in all of the classes. */
  int32_t myNumPix;            /* Number of pixels observed in the data asigned to the particular processor */
  int32_t numPixelClass;       /* Number of pixel classes.  */
  int32_t useFullLookup;       /* Switch that determines if globalPixToMyPix will be allocated and used.  */
  int32_t *globalPixToMyPix;   /* An array that maps from global indicies to myPix, only used if global size is small.  */
  int32_t *myPixToGlobalPix;   /* An array that maps from myPix to global indices ( pixel index plus classOffset ). */
  int32_t *classOffset;        /* An array that maps from pixel class index to a classOffset ( total number of pixels in all of the classes with a lower class index ) */
  M3_MapEl *mapSimStore;       /* Pointer to the map to be scanned in a simulation this is indexed with "myPixels" */
} M3_PixelConvertStruct;


typedef struct mallocRecordTag
{
  void *space;
  size_t size;
  struct mallocRecordTag *next;
} M3_MallocRecordLL;

struct runConfigTag;

typedef struct dataSetTag 
{
  char *name;
  M3_TimeEl firstTime;
  double sampleRate;
  M3_IntervalLL *coveredIntervalList;
  M3_ComponentLL *componentList;
  M3_FileLL *noiseFileList;
  M3_FileLL *filterFileList[M3_NUM_FILTER_TYPE];
  M3_PointingClassLL *pointingClassList;
  int32_t numNZ;
  M3_NoiseFilterLL *noiseFilterSimStore;
  M3_PixelConvertStruct *pixelConvertNode;
  struct runConfigTag *runConfigNode;
  void *v;
  struct dataSetTag *next;
} M3_DataSetLL;


typedef struct todRequestTag
{
  M3_DataSetLL *dataSetNode;
  M3_Interval sampleInterval;
  struct todRequestTag *next;
} M3_TODrequestLL;


typedef struct
{
  int useGCPcache;
  int useScanMapCache;
  M3_TODrequestLL *todRequestList;
  M3_MallocRecordLL *mallocRecordList;
  size_t storeSize;
} M3_TODcacheStruct;


/****************************/
/* Define The M3 Run Config */
/****************************/

typedef struct runConfigTag
{
  uint64_t globalSeedSim;
  M3_TODcacheStruct todCache;
  M3_PixelConvertStruct pixelConvert;
  M3_DataSetLL *dataSetList;
  M3_PixelClassLL *pixelClassList;
  M3_PowerSpectrumStruct powerSpectrum;
  M3_File *sparsePixelMatrix;
  M3_GCPointingGroupLL *GCPointingGroupList;
  void *v;
} M3_RunConfigStruct;


/* INTERNAL FUNCTION DECLARATIONS */
size_t M3_RunConfigStruct_duplicateP( M3_RunConfigStruct *inRunConfig, M3_RunConfigStruct **outRunConfig, int outputIsPacked );
void M3_RunConfigStruct_refine( M3_RunConfigStruct *runConfig, int runType );

void M3_DataSetLL_getClassPointing( M3_DataSetLL *dataSetNode, M3_Interval readInterval, char *className, M3_PointingEl *pointing);
void M3_DataSetLL_destroyList( M3_DataSetLL *dataSetList );
void M3_DataSetLL_calibratePointing( M3_DataSetLL *dataSetNode, M3_PointingEl *pointing, M3_Interval pointingInterval );
void M3_DataSetLL_getPointingIQU( M3_DataSetLL *dataSetNode, M3_Interval requestInterval, int32_t nside, int pixelScheme, long *pixels, double *weights );

void M3_RunConfigStruct_shiftPointers( M3_RunConfigStruct *runConfig, int shiftDirection);
size_t M3_RunConfigStruct_duplicateP( M3_RunConfigStruct *inRunConfig, M3_RunConfigStruct **outRunConfig, int outputIsPacked );



void M3_GCPointingGroupLL_destroyList( M3_GCPointingGroupLL *GCPointingGroupList );
void M3_GCPointingStoreLL_destroyList( M3_GCPointingStoreLL *GCPointingStoreList );

void M3_PixelClassLL_insertInOrder( M3_PixelClassLL *thisPixelClass, M3_PixelClassLL **pixeClassList );
void M3_PixelClassLL_destroyList( M3_PixelClassLL *pixelClassList );

void M3_IntervalLL_insertInOrder( M3_IntervalLL *intervalNode,  M3_IntervalLL **intervalList );
void M3_IntervalLL_destroyList( M3_IntervalLL *list);

void M3_FileLL_insertInOrder( M3_FileLL *fileNode, M3_FileLL **fileList );
void M3_FileLL_duplicateList( M3_FileLL *inFileList, M3_FileLL **outFileList );
void M3_FileLL_destroyList( M3_FileLL *list );

void M3_File_getInterval( M3_File *thisFile, M3_Interval *theInterval );
int M3_File_getStringSizes( M3_File theFile );
void M3_File_destroy( M3_File *thisFile );

void M3_SpectrumClassLL_destroyList( M3_SpectrumClassLL *spectrumClassList );


void M3_XML_decend( xmlNodePtr thisXMlnode, xmlNodePtr *childXMLnode, int nameLength, char *name );
void M3_XML_follow( xmlNodePtr theXMLnode, xmlNodePtr *nextXMLnode, int nameLength, char *name );
void M3_XML_getContent( xmlNodePtr theXMLnode, int contentLength, char *content );

void M3_XML_parsePixelClassNode(  xmlNodePtr pixelClassXMLnode, int runType, M3_PixelClassLL *thisPixelClass );
void M3_XML_parseSparsePixelMatrixNode( xmlNodePtr sparseMatrixNode, int runType, M3_File **m3file );
void M3_XML_parseFileNode( xmlNodePtr fileXMLnode, int fileType, int isInputFile, M3_File *m3file );
void M3_XML_parseIntervalNode( xmlNodePtr intervalXMLnode, M3_Interval *interval );
void M3_XML_parseDataSetNode( xmlNodePtr dataSetXMLnode, int32_t runType, M3_PixelClassLL *pixelClassList, M3_GCPointingGroupLL *GCPointingGroupList, M3_DataSetLL *outDataSet );
void M3_XML_parsePowerSpectrumNode( xmlNodePtr spectrumXMLnode, int runType, M3_PowerSpectrumStruct *outPowerSpectrum );
void M3_XML_parseGCPointingGroupNode( xmlNodePtr GCPointingGroupXMLnode, int runType, M3_GCPointingGroupLL *outPointingGroup );

M3_IntervalLL *M3_fileListToIntervalList( M3_FileLL *fileList );
M3_IntervalLL *M3_intersectIntervalLists( M3_IntervalLL *aList, M3_IntervalLL *bList );
M3_IntervalLL *M3_gcpFileListToIntervalList( M3_FileLL *gcpFileList, M3_TimeEl dataSetFirstTime, double dataSetSampleRate );

#endif

---