M3.h

Go to the documentation of this file.

#include <stdint.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
#define _H_M3

#include <M3_error.h>


#define M3_NUM_FILTER_TYPE 4

#define M3_W_FILTER_TYPE 0

#define M3_E_FILTER_TYPE 1

#define M3_S_FILTER_TYPE 2

#define M3_B_FILTER_TYPE 3

#define M3_DEFAULT_PIXEL_TYPE 0

#define M3_CMB_I_PIXEL_TYPE 1
#define M3_CMB_Q_PIXEL_TYPE 2
#define M3_CMB_U_PIXEL_TYPE 3

#define M3_TT_SPECTRUM_TYPE 0
#define M3_EE_SPECTRUM_TYPE 1
#define M3_BB_SPECTRUM_TYPE 2
#define M3_TE_SPECTRUM_TYPE 3
#define M3_TB_SPECTRUM_TYPE 4
#define M3_EB_SPECTRUM_TYPE 5

#define M3_MADNES_RUN_TYPE 1
#define M3_MADMAP_RUN_TYPE 2
#define M3_MADSPEC_RUN_TYPE 3
#define M3_SPRINGTIDE_RUN_TYPE 4

/******************************************/
/* Define The Basic M3 Data Elements */
/******************************************/



typedef struct 
{
  int32_t pixel;
  float weight;
} M3_PointingEl;


typedef struct 
{
  int32_t pixel;
  double value;
} M3_MapEl;


typedef struct 
{
  double freq;
  double re;
  double im;
} M3_FilterEl;


typedef struct 
{
  int64_t firstSample;
  int64_t lastSample;
} M3_Interval;

typedef struct 
{
  int32_t pixel;
  double ra;
  double dec;
} M3_CoordEl;

typedef struct 
{
  int32_t lmin;
  int32_t lmax;
} M3_BinEl;

typedef struct 
{
  int32_t lmin;
  int32_t lmax;
  double power;
  double lowerBound;
  double upperBound;
} M3_BPSel;

typedef struct
{
  int32_t rowClass;
  int32_t rowPixel;
  double value;
} M3_SparsePixelMatrixEl;

typedef struct
{
  int32_t columnClass;
  int32_t columnPixel;
  int64_t numNZ;  
} M3_SparsePixelMatrixColumn;

typedef struct
{
  int64_t numColumn;
  int64_t numNZ;
  M3_SparsePixelMatrixColumn *column;
  M3_SparsePixelMatrixEl *matrix;
} M3_SparsePixelMatrixData;


typedef struct
{
  int64_t sec;
  double nsec;
} M3_TimeEl;

typedef struct 
{
  M3_TimeEl firstTime;
  M3_TimeEl lastTime;
} M3_TimeInterval;


/* Include the other header files */

#include "M3_internal.h"

/*************************************/
/* M3 Data Interface Functions  */
/*************************************/

/* OBJECT:  M3_RunConfigStruct */

void M3_RunConfigStruct_Read( 
  M3_RunConfigStruct **runConfig,
  char *runConfigFileName, 
  int runType );


void M3_RunConfigStruct_ReadBin( 
  M3_RunConfigStruct **runConfigOut, 
  char *runConfigFileName, 
  int runType );

void M3_RunConfigStruct_Write(
  M3_RunConfigStruct *runConfig,
  char *runConfigFileName );

void M3_RunConfigStruct_Destroy( 
  M3_RunConfigStruct *runConfig );

void M3_RunConfigStruct_Duplicate( 
  M3_RunConfigStruct *inRunConfig,   
  M3_RunConfigStruct **outRunConfig );

int M3_RunConfigStruct_GetDataSetRoot( 
  M3_RunConfigStruct *runConfig,
  M3_DataSetLL **dataSetRoot );

int M3_RunConfigStruct_GetPixelClassRoot( 
  M3_RunConfigStruct *runConfig, 
  M3_PixelClassLL **pixelClassRoot );

int M3_RunConfigStruct_GetPowerSpectrum( 
  M3_RunConfigStruct *runConfig, 
  M3_PowerSpectrumStruct **powerSpectrum );

int M3_RunConfigStruct_GetSparseMatrixName(
  M3_RunConfigStruct *runConfig,
  char *name,
  long maxStringLength );

int M3_RunConfigStruct_GetSparseMatrixNumNZ(
  M3_RunConfigStruct *runConfig,
  M3_SparsePixelMatrixData *sparsePixelMatrixData ); 

  /* sparsePixelMatrixData->numColumn INPUT
     sparsePixelMatrixData->numNZ     OUTPUT
     sparsePixelMatrixData->column    INPUT/OUTPUT (allocate numColumn elements before calling)
                                                   (columnClass and columnPixel elements set by user,
                                                    numNZ elements set by function call )
     sparsePixelMatrixData->matrix    NULL
  */

int M3_RunConfigStruct_GetSparseMatrix( 
  M3_RunConfigStruct *runConfig,
  M3_SparsePixelMatrixData *sparsePixelMatrixData );
  /* sparsePixelMatrixData->numColumn INPUT
     sparsePixelMatrixData->numNZ     INPUT
     sparsePixelMatrixData->column    INPUT
     sparsePixelMatrixData->matrix    OUTPUT   (allocate total numNZ elemetns before calling)
  */

int M3_RunConfigStruct_GetDenseMatrixName(
  M3_RunConfigStruct *runConfig,
  char *name,
  long maxStringLength );

/* 
int M3_RunConfigStruct_GetDenseMatrix(
  M3_RunConfigStruct *runConfig, 
  int64_t numColumn,
  int32_t *requestColumn);
*/

int M3_RunConfigStruct_GetGCPointingGroupRoot( 
  M3_RunConfigStruct *runConfig, 
  M3_GCPointingGroupLL **GCPointingRoot );

int M3_GCPointingGroupLL_GetNextNodeInList(
  M3_GCPointingGroupLL **GCPointingGroupNode );



void M3_GCPointingGroupLL_GetStoreSize( 
  M3_GCPointingGroupLL *gcpointingGroupNode, 
  M3_TimeIntervalLL *timeIntervalList, 
  size_t *storeSize );

void M3_GCPointingGroupLL_InitializeStore(M3_GCPointingGroupLL *gcpointingGroupNode, 
                                          M3_TimeIntervalLL *timeIntervalList, 
                                          void *workSpace );

void M3_GCPointingGroupLL_DestroyStore( M3_GCPointingGroupLL *GCPointingGroup, 
                                        int destroyAuxStore );


/* OBJECT:  M3_DataSetLL */

int M3_DataSetLL_GetNextNodeInList( 
  M3_DataSetLL **dataSetNode );

void M3_DataSetLL_GetName( 
  M3_DataSetLL *dataSetNode, 
  char *name,  
  long maxStringLength );

int M3_DataSetLL_GetCoveredIntervalRoot( 
  M3_DataSetLL *dataSetNode, 
  M3_IntervalLL **intervalRoot );

void M3_DataSetLL_GetNumNZ( 
  M3_DataSetLL *dataSetNode, 
  int32_t *numNZ );

int M3_DataSetLL_GetPointingClassRoot( 
  M3_DataSetLL *dataSetNode, 
  M3_PointingClassLL **pointingClassRoot );

void M3_DataSetLL_GetTOD( 
  M3_DataSetLL *dataSetNode, 
  M3_Interval readInterval, 
  double *tod );

void M3_DataSetLL_GetPointing( 
  M3_DataSetLL *dataSetNode, 
  M3_Interval readInterval, 
  M3_PointingEl *pointing );

void M3_DataSetLL_GetEuler(
  M3_DataSetLL *dataSetNode,
  M3_Interval readInterval,
  double *eulerAngles );


int M3_DataSetLL_GetNoiseFileRoot(
  M3_DataSetLL *dataSetNode,
  M3_FileLL **noiseFileRoot );

int M3_DataSetLL_GetNoiseFile( 
  M3_DataSetLL *dataSetNode, 
  M3_Interval stationaryInterval,
  M3_FileLL **noiseFile );

int M3_DataSetLL_GetNoiseCorLength( 
  M3_DataSetLL *dataSetNode, 
  int64_t sample, 
  int64_t *corLength );

int M3_DataSetLL_GetNoise( 
  M3_DataSetLL *dataSetNode, 
  int64_t sample, 
  double *noise );

int M3_DataSetLL_GetFilterFileRoot( 
  M3_DataSetLL *dataSetNode,
  int32_t filterType,  
  M3_FileLL **filterFile );

int M3_DataSetLL_GetFilterFile(
  M3_DataSetLL *dataSetNode, 
  M3_Interval stationaryInterval, 
  int32_t filterType, 
  M3_FileLL **filterFile );

void M3_DataSetLL_GetSampleZeroTime( 
  M3_DataSetLL *dataSetNode,
  M3_TimeEl *zeroTime );

void M3_DataSetLL_GetSampleFreq(
  M3_DataSetLL *dataSetNode, 
  double *sampleFreq );

void M3_DataSetLL_SampleIntervalToTimeInterval( 
  M3_DataSetLL *dataSetNode,
  M3_Interval sampleInterval,
  M3_TimeInterval *timeInterval );

char *M3_DataSetLL_GetGCPointingGroupNode(
  M3_DataSetLL *dataSetNode,
  M3_GCPointingGroupLL **GCPointingGroupNode );

/* OBJECT:  M3_PixelClassLL */

int M3_PixelClassLL_GetNextNodeInList( 
  M3_PixelClassLL **pixelClassNode );

void M3_PixelClassLL_GetClassName( 
  M3_PixelClassLL *pixelClassNode, 
  char *className, 
  long maxStringLength );

void M3_PixelClassLL_GetClassIndex(
  M3_PixelClassLL *pixelClassNode,
  int32_t *classIndex );

void M3_PixelClassLL_GetPixelType( 
  M3_PixelClassLL *pixelClassNode, 
  int32_t *pixelType );

void M3_PixelClassLL_GetNumPixelInClass( 
  M3_PixelClassLL *pixelClassNode, 
  int32_t *numPixelInClass );

void M3_PixelClassLL_GetNumPixelInMap( 
  M3_PixelClassLL *pixelClassNode, 
  int32_t *numPixelInMap );

int M3_PixelClassLL_GetMapName(
  M3_PixelClassLL *pixelClassNode,
  char *mapName,
  long maxStringLength );

void M3_PixelClassLL_GetFullMap( 
  M3_PixelClassLL *pixelClassNode, 
  M3_MapEl *map );

void M3_PixelClassLL_GetIndexedMap( 
  M3_PixelClassLL *pixelClassNode, 
  int32_t numPixel, 
  M3_MapEl *map );

void M3_PixelClassLL_GetIndexedCoord( 
  M3_PixelClassLL *pixelClassNode, 
  int32_t numPixel, 
  M3_CoordEl *coord );

void M3_PixelClassLL_GetWindow( 
  M3_PixelClassLL *pixelClassNode, 
  int32_t lmax, 
  double *window );

void M3_PixelClassLL_GetIndexedMask( 
  M3_PixelClassLL *pixelClassNode, 
  int32_t numPixel, 
  M3_MapEl *mask );

int M3_PixelClassLL_GetTemplateFileRoot( 
  M3_PixelClassLL *pixelClassNode, 
  M3_FileLL **templateFileRoot );

/* OBJECT:  M3_PointingClassLL */

int M3_PointingClassLL_GetNextNodeInList( 
  M3_PointingClassLL **pointingClassNode );

void M3_PointingClassLL_GetNumNZ( 
  M3_PointingClassLL *pointingClassNode, 
  int32_t *numNZ );

void M3_PointingClassLL_GetPixelClassNode( 
  M3_PointingClassLL *pointingClassNode, 
  M3_PixelClassLL **pixelClassNode );

/* OBJECT:  M3_PowerSpectrumStruct */

void M3_PowerSpectrumStruct_GetNumBin( 
  M3_PowerSpectrumStruct *powerSpectrum, 
  int32_t *numBin );

int M3_PowerSpectrumStruct_GetSpectrumClassRoot( 
  M3_PowerSpectrumStruct *powerSpectrum, 
  M3_SpectrumClassLL **spectrumClassRoot );

void M3_PowerSpectrumStruct_GetFisherMatrix( 
  M3_PowerSpectrumStruct *powerSpectrum, 
  double *fisherMatrix );

/* OBJECT:  M3_SpectrumClassLL */


int M3_SpectrumClassLL_GetNextNodeInList(
  M3_SpectrumClassLL **spectrumClassNode );

void M3_SpectrumClassLL_GetSpectrumType( 
  M3_SpectrumClassLL *spectrumClassNode, 
  int32_t *spectrumType );

void M3_SpectrumClassLL_GetMultipoleMax( 
  M3_SpectrumClassLL *spectrumClassNode, 
  int32_t *lmax );

void M3_SpectrumClassLL_GetNumBin( 
  M3_SpectrumClassLL *spectrumClassNode, 
  int32_t *numBin );

void M3_SpectrumClassLL_GetShape( 
  M3_SpectrumClassLL *spectrumClassNode, 
  double *shape );

void M3_SpectrumClassLL_GetBin( 
  M3_SpectrumClassLL *spectrumClassNode, 
  M3_BinEl *bin );

void M3_SpectrumClassLL_GetBPS( 
  M3_SpectrumClassLL *spectrumClassNode, 
  M3_BPSel *bps );


/* OBJECT:  M3_IntervalLL */

int M3_IntervalLL_GetNextNodeInList( 
  M3_IntervalLL **intervalNode );

void M3_IntervalLL_GetInterval( 
  M3_IntervalLL *intervalNode, 
  M3_Interval *interval );

/* OBJECT:  M3_TimeIntervalLL */

int M3_TimeIntervalLL_GetNextNodeInList(
  M3_TimeIntervalLL **timeIntervalNode );

void M3_TimeIntervalLL_GetInterval(
  M3_TimeIntervalLL *timeIntervalNode,
  M3_TimeInterval *timeInterval );

void M3_TimeIntervalLL_InsertInterval(
  M3_TimeIntervalLL **timeIntervalList,
  M3_TimeInterval timeInterval );

M3_TimeIntervalLL *M3_TimeIntervalLL_Union( 
  M3_TimeIntervalLL *aList, 
  M3_TimeIntervalLL *bList );

void M3_TimeIntervalLL_DestroyList(
  M3_TimeIntervalLL *timeIntervalList );

/* OBJECT:  M3_FileLL */

int M3_FileLL_GetNextNodeInList( 
  M3_FileLL **fileNode );

void M3_FileLL_GetIndexedTemplate( 
  M3_FileLL *templateFileNode, 
  int32_t numPixel, 
  M3_MapEl *theTemplate );

void M3_FileLL_GetNoiseInterval(
  M3_FileLL *noiseFileNode,
  M3_Interval *noiseInterval );

void M3_FileLL_GetNoiseCorLength( 
  M3_FileLL *noiseFileNode,
  int64_t *corLength );

void M3_FileLL_GetNoise( 
  M3_FileLL *noiseFileNode, 
  double *noise );

void M3_FileLL_GetFilterInterval(
  M3_FileLL *filterFileNode, 
  M3_Interval *interval );

void M3_FileLL_GetFilterLength(
  M3_FileLL *filterFileNode,
  int64_t *length );

void M3_FileLL_GetFilterBandWidth(
  M3_FileLL *filterFileNode, 
  int64_t *bandWidth );

void M3_FileLL_GetFilter( 
  M3_FileLL *filterFileNode, 
  M3_FilterEl *filter );

#include <M3_format.h>

#endif

---