/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv------------------------------------ */
int main(int argc, char *argv[]){
static LALStatus status; /* LALStatus pointer */
static LALDetector detector;
static LIGOTimeGPSVector timeV;
static REAL8Cart3CoorVector velV;
static HOUGHptfLUTVector lutV; /* the Look Up Table vector*/
static HOUGHPeakGramVector pgV;
static PHMDVectorSequence phmdVS; /* the partial Hough map derivatives */
static UINT8FrequencyIndexVector freqInd;
static HOUGHResolutionPar parRes;
static HOUGHPatchGrid patch; /* Patch description */
static HOUGHParamPLUT parLut; /* parameters needed to build lut */
static HOUGHDemodPar parDem; /* demodulation parameters or */
static HOUGHSizePar parSize;
static VelocityPar velPar;
static HOUGHMapTotal ht; /* the total Hough map */
/* ------------------------------------------------------- */
CHAR *earthEphemeris = NULL;
CHAR *sunEphemeris = NULL;
INT4 ifo;
REAL8 vel[3];
INT4 mObsCoh;
UINT2 maxNBins, maxNBorders;
INT8 f0Bin; /* freq. bin to construct LUT */
INT8 fBin;
UINT2 xSide, ySide;
CHAR *fname = NULL; /* The output filename */
FILE *fp=NULL; /* Output file */
INT4 arg; /* Argument counter */
UINT4 i,j; /* Index counter, etc */
INT4 k;
REAL8 f0, alpha, delta;
REAL8 patchSizeX, patchSizeY;
REAL8 Xx,Xy,Xz;
/******************************************************************/
/* Set up the default parameters. */
/* ****************************************************************/
detector = lalCachedDetectors[LALDetectorIndexGEO600DIFF]; /* default */
ifo = IFO;
if (ifo ==1) detector=lalCachedDetectors[LALDetectorIndexGEO600DIFF];
if (ifo ==2) detector=lalCachedDetectors[LALDetectorIndexLLODIFF];
if (ifo ==3) detector=lalCachedDetectors[LALDetectorIndexLHODIFF];
earthEphemeris = EARTHEPHEMERIS;
sunEphemeris = SUNEPHEMERIS;
mObsCoh = MOBSCOH;
timeV.length = mObsCoh;
velV.length = mObsCoh;
lutV.length = mObsCoh;
pgV.length = mObsCoh;
phmdVS.length = mObsCoh;
freqInd.length = mObsCoh;
phmdVS.nfSize = NFSIZE;
freqInd.deltaF = DF;
phmdVS.deltaF = DF;
timeV.time = NULL;
velV.data = NULL;
lutV.lut = NULL;
pgV.pg = NULL;
phmdVS.phmd = NULL;
freqInd.data = NULL;
ht.map = NULL;
f0 = F0;
f0Bin = F0*TCOH;
parRes.f0Bin = f0Bin;
parRes.deltaF = DF;
/*
* parRes.patchSkySizeX = patchSizeX = 1.0/(TCOH*F0*VEPI);
* parRes.patchSkySizeY = patchSizeY = 1.0/(TCOH*F0*VEPI);
*/
parRes.patchSkySizeX = patchSizeX = PATCHSIZEX;
parRes.patchSkySizeY = patchSizeY = PATCHSIZEY;
parRes.pixelFactor = PIXELFACTOR;
parRes.pixErr = PIXERR;
parRes.linErr = LINERR;
parRes.vTotC = VTOT;
/* Case: no spins & Non demodulation */
parDem.deltaF = DF;
parDem.skyPatch.alpha = ALPHA;
parDem.skyPatch.delta = DELTA;
parDem.timeDiff = 0.0;
parDem.spin.length = 0;
parDem.spin.data = NULL;
parDem.positC.x = 0.0;
parDem.positC.y = 0.0;
parDem.positC.z = 0.0;
velPar.detector = detector;
velPar.tBase = TCOH;
velPar.vTol = ACCURACY;
alpha = ALPHA;
delta = DELTA;
/*****************************************************************/
/*****************************************************************/
/* Parse argument list. i stores the current position. */
/*****************************************************************/
arg = 1;
while ( arg < argc ) {
/* Parse debuglevel option. */
if ( !strcmp( argv[arg], "-d" ) ) {
if ( argc > arg + 1 ) {
arg++;
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse interferometer option. */
else if ( !strcmp( argv[arg], "-i" ) ) {
if ( argc > arg + 1 ) {
arg++;
ifo = atoi( argv[arg++] );
if (ifo ==1) detector=lalCachedDetectors[LALDetectorIndexGEO600DIFF];
if (ifo ==2) detector=lalCachedDetectors[LALDetectorIndexLLODIFF];
if (ifo ==3) detector=lalCachedDetectors[LALDetectorIndexLHODIFF];
velPar.detector = detector;
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse filename of earth ephemeris data option. */
else if ( !strcmp( argv[arg], "-E" ) ) {
if ( argc > arg + 1 ) {
arg++;
earthEphemeris = argv[arg++];
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse filename of sun ephemeris data option. */
else if ( !strcmp( argv[arg], "-S" ) ) {
if ( argc > arg + 1 ) {
arg++;
sunEphemeris = argv[arg++];
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse output file option. */
else if ( !strcmp( argv[arg], "-o" ) ) {
if ( argc > arg + 1 ) {
arg++;
fname = argv[arg++];
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse frequency option. */
else if ( !strcmp( argv[arg], "-f" ) ) {
if ( argc > arg + 1 ) {
arg++;
f0 = atof(argv[arg++]);
f0Bin = f0*TCOH;
parRes.f0Bin = f0Bin;
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse sky position options. */
else if ( !strcmp( argv[arg], "-p" ) ) {
if ( argc > arg + 2 ) {
arg++;
alpha = atof(argv[arg++]);
delta = atof(argv[arg++]);
parDem.skyPatch.alpha = alpha;
parDem.skyPatch.delta = delta;
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse patch size option. */
else if ( !strcmp( argv[arg], "-s" ) ) {
if ( argc > arg + 2 ) {
arg++;
parRes.patchSkySizeX = patchSizeX = atof(argv[arg++]);
parRes.patchSkySizeY = patchSizeY = atof(argv[arg++]);
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Unrecognized option. */
else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
} /* End of argument parsing loop. */
/******************************************************************/
if ( f0 < 0 ) {
ERROR( VALIDATION1_EBAD, VALIDATION1_MSGEBAD, "freq<0:" );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EBAD;
}
/******************************************************************/
/******************************************************************/
/* create time stamps (for a test) */
/******************************************************************/
timeV.time = (LIGOTimeGPS *)LALMalloc(mObsCoh*sizeof(LIGOTimeGPS));
timeV.time[0].gpsSeconds = T0SEC;
timeV.time[0].gpsNanoSeconds = T0NSEC;
for(j=1; j<timeV.length; ++j){
timeV.time[j].gpsSeconds = timeV.time[j-1].gpsSeconds + TCOH + JUMPTIME;
timeV.time[j].gpsNanoSeconds = T0NSEC;
}
/******************************************************************/
/* compute detector velocity for those time stamps (for a test) */
/******************************************************************/
velV.data = (REAL8Cart3Coor *)LALMalloc(mObsCoh*sizeof(REAL8Cart3Coor));
velPar.edat = NULL;
{
EphemerisData *edat=NULL;
/* ephemeris info */
edat = (EphemerisData *)LALMalloc(sizeof(EphemerisData));
(*edat).ephiles.earthEphemeris = earthEphemeris;
(*edat).ephiles.sunEphemeris = sunEphemeris;
/* read in ephemeris data */
SUB( LALInitBarycenter( &status, edat), &status);
velPar.edat = edat;
for(j=0; j<velV.length; ++j){
velPar.startTime.gpsSeconds = timeV.time[j].gpsSeconds;
velPar.startTime.gpsNanoSeconds = timeV.time[j].gpsNanoSeconds;
SUB( LALAvgDetectorVel ( &status, vel, &velPar), &status );
velV.data[j].x= vel[0];
velV.data[j].y= vel[1];
velV.data[j].z= vel[2];
}
LALFree(edat->ephemE);
LALFree(edat->ephemS);
LALFree(edat);
}
/******************************************************************/
/******************************************************************/
/* create patch grid */
/******************************************************************/
SUB( LALHOUGHComputeNDSizePar( &status, &parSize, &parRes ), &status );
xSide = parSize.xSide;
ySide = parSize.ySide;
maxNBins = parSize.maxNBins;
maxNBorders = parSize.maxNBorders;
/* allocate memory based on xSide and ySide */
patch.xSide = xSide;
patch.ySide = ySide;
/* allocate memory based on xSide and ySide */
patch.xCoor = NULL;
patch.yCoor = NULL;
patch.xCoor = (REAL8 *)LALMalloc(xSide*sizeof(REAL8));
patch.yCoor = (REAL8 *)LALMalloc(ySide*sizeof(REAL8));
SUB( LALHOUGHFillPatchGrid( &status, &patch, &parSize ), &status );
/******************************************************************/
/******************************************************************/
/* memory allocation and settings */
/******************************************************************/
lutV.lut = (HOUGHptfLUT *)LALMalloc(mObsCoh*sizeof(HOUGHptfLUT));
pgV.pg = (HOUGHPeakGram *)LALMalloc(mObsCoh*sizeof(HOUGHPeakGram));
phmdVS.phmd =(HOUGHphmd *)LALMalloc(mObsCoh*NFSIZE*sizeof(HOUGHphmd));
freqInd.data = ( UINT8 *)LALMalloc(mObsCoh*sizeof(UINT8));
for(j=0; j<lutV.length; ++j){
lutV.lut[j].maxNBins = maxNBins;
lutV.lut[j].maxNBorders = maxNBorders;
lutV.lut[j].border =
(HOUGHBorder *)LALMalloc(maxNBorders*sizeof(HOUGHBorder));
lutV.lut[j].bin =
(HOUGHBin2Border *)LALMalloc(maxNBins*sizeof(HOUGHBin2Border));
}
for(j=0; j<phmdVS.length * phmdVS.nfSize; ++j){
phmdVS.phmd[j].maxNBorders = maxNBorders;
phmdVS.phmd[j].leftBorderP =
(HOUGHBorder **)LALMalloc(maxNBorders*sizeof(HOUGHBorder *));
phmdVS.phmd[j].rightBorderP =
(HOUGHBorder **)LALMalloc(maxNBorders*sizeof(HOUGHBorder *));
}
ht.xSide = xSide;
ht.ySide = ySide;
ht.map = NULL;
ht.map = (HoughTT *)LALMalloc(xSide*ySide*sizeof(HoughTT));
for(j=0; j<phmdVS.length * phmdVS.nfSize; ++j){
phmdVS.phmd[j].ySide = ySide;
phmdVS.phmd[j].firstColumn = NULL;
phmdVS.phmd[j].firstColumn = (UCHAR *)LALMalloc(ySide*sizeof(UCHAR));
}
for (j=0; j<lutV.length ; ++j){
for (i=0; i<maxNBorders; ++i){
lutV.lut[j].border[i].ySide = ySide;
lutV.lut[j].border[i].xPixel =
(COORType *)LALMalloc(ySide*sizeof(COORType));
}
}
/******************************************************************/
/******************************************************************/
/* create Peakgrams for testing */
/******************************************************************/
/* let us fix a source at a given position
(not at the center of the patch, but a pixel center) */
{
UINT2 xPos, yPos;
REAL8Cart2Coor sourceProjected;
REAL8UnitPolarCoor sourceRotated;
REAL8UnitPolarCoor skyPatchCenter;
REAL8UnitPolarCoor sourceLocation;
xPos = xSide/2;
yPos = ySide/2;
sourceProjected.x = patch.xCoor[xPos];
sourceProjected.y = patch.yCoor[yPos];
skyPatchCenter.alpha = parDem.skyPatch.alpha;
skyPatchCenter.delta = parDem.skyPatch.delta;
/* invert the stereographic projection for a point on the projected plane */
SUB( LALStereoInvProjectCart( &status, &sourceRotated, &sourceProjected ), &status );
/* undo roation in case the patch is not centered at the south pole */
SUB( LALInvRotatePolarU( &status, &sourceLocation, &sourceRotated, &skyPatchCenter ), &status );
Xx= cos(sourceLocation.delta)* cos(sourceLocation.alpha);
Xy= cos(sourceLocation.delta)* sin(sourceLocation.alpha);
Xz= sin(sourceLocation.delta);
}
for (j=0;j< mObsCoh; ++j) { /* create all the peakgrams */
REAL8 veldotX;
pgV.pg[j].deltaF = DF;
/*
* pgV.pg[j].fBinIni = f0Bin/2;
* pgV.pg[j].fBinFin = f0Bin*2;
*/
pgV.pg[j].fBinIni = f0Bin-maxNBins;
pgV.pg[j].fBinFin = f0Bin+3*maxNBins;
/* pgV.pg[j].length = 2; */
pgV.pg[j].length = 1;
pgV.pg[j].peak = NULL;
pgV.pg[j].peak = (INT4 *)LALMalloc( ( pgV.pg[j].length) * sizeof(INT4));
veldotX = Xx*velV.data[j].x + Xy*velV.data[j].y + Xz*velV.data[j].z;
/* fBin = [ f0Bin * ( 1 + veldotX ) ] */
pgV.pg[j].peak[0]= floor( f0Bin*(1.0+veldotX) +0.5) - pgV.pg[j].fBinIni;
/* pgV.pg[j].peak[1]= pgV.pg[j].peak[0]+2; */
}
/******************************************************************/
/******************************************************************/
/* create all the LUTs */
/******************************************************************/
for (j=0;j< mObsCoh;++j){ /* create all the LUTs */
parDem.veloC.x = velV.data[j].x;
parDem.veloC.y = velV.data[j].y;
parDem.veloC.z = velV.data[j].z;
/* calculate parameters needed for buiding the LUT */
SUB( LALNDHOUGHParamPLUT( &status, &parLut, &parSize, &parDem ), &status );
/* build the LUT */
SUB( LALHOUGHConstructPLUT( &status, &(lutV.lut[j]), &patch, &parLut ),
&status );
}
/******************************************************************/
/* starting the search (A very simple case for only 1 frequency) */
/******************************************************************/
/* build the set of PHMD starting at f0Bin*/
/******************************************************************/
fBin = f0Bin;
phmdVS.fBinMin = fBin;
SUB( LALHOUGHConstructSpacePHMD(&status, &phmdVS, &pgV, &lutV), &status );
/* shift the structure one frequency bin */
/* SUB( LALHOUGHupdateSpacePHMDup(&status, &phmdVS, &pgV, &lutV), &status );*/
/******************************************************************/
/* initializing the Hough map space */
/******************************************************************/
SUB( LALHOUGHInitializeHT( &status, &ht, &patch ), &status );
/******************************************************************/
/* construction of a total Hough map */
/******************************************************************/
for (j=0;j< mObsCoh;++j){
freqInd.data[j]= fBin;
}
SUB( LALHOUGHConstructHMT( &status, &ht, &freqInd, &phmdVS ), &status );
/******************************************************************/
/* printing the results into a particular file */
/* if the -o option was given, or into FILEOUT */
/******************************************************************/
if ( fname ) {
fp = fopen( fname, "w" );
} else {
fp = fopen( FILEOUT , "w" );
}
if ( !fp ){
ERROR( VALIDATION1_EFILE, VALIDATION1_MSGEFILE, 0 );
return VALIDATION1_EFILE;
}
for(k=ySide-1; k>=0; --k){
for(i=0;i<xSide;++i){
fprintf( fp ," %d", ht.map[k*xSide +i]);
fflush( fp );
}
fprintf( fp ," \n");
fflush( fp );
}
fclose( fp );
/******************************************************************/
/* Free memory and exit */
/******************************************************************/
for (j=0;j< mObsCoh;++j){
LALFree( pgV.pg[j].peak); /* All of them */
}
for (j=0; j<lutV.length ; ++j){
for (i=0; i<maxNBorders; ++i){
LALFree( lutV.lut[j].border[i].xPixel);
}
LALFree( lutV.lut[j].border);
LALFree( lutV.lut[j].bin);
}
for(j=0; j<phmdVS.length * phmdVS.nfSize; ++j){
LALFree( phmdVS.phmd[j].leftBorderP);
LALFree( phmdVS.phmd[j].rightBorderP);
LALFree( phmdVS.phmd[j].firstColumn);
}
LALFree(timeV.time);
LALFree(velV.data);
LALFree(lutV.lut);
LALFree(pgV.pg);
LALFree(phmdVS.phmd);
LALFree(freqInd.data);
LALFree(ht.map);
LALFree(patch.xCoor);
LALFree(patch.yCoor);
LALCheckMemoryLeaks();
INFO( VALIDATION1_MSGENORM );
return VALIDATION1_ENORM;
}
/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv------------------------------------ */
int main(int argc, char *argv[]){
static LALStatus status; /* LALStatus pointer */
static HOUGHptfLUTVector lutV; /* the Look Up Table vector*/
static HOUGHPeakGramVector pgV;
static PHMDVectorSequence phmdVS; /* the partial Hough map derivatives */
static UINT8FrequencyIndexVector freqInd;
static HOUGHResolutionPar parRes;
static HOUGHPatchGrid patch; /* Patch description */
static HOUGHParamPLUT parLut; /* parameters needed to build lut */
static HOUGHDemodPar parDem; /* demodulation parameters */
static HOUGHSizePar parSize;
static HOUGHMapTotal ht; /* the total Hough map */
/* ------------------------------------------------------- */
UINT2 maxNBins, maxNBorders;
INT8 f0Bin; /* freq. bin to construct LUT */
INT8 fBin;
UINT2 xSide, ySide;
CHAR *fname = NULL; /* The output filename */
FILE *fp=NULL; /* Output file */
INT4 arg; /* Argument counter */
UINT4 i,j; /* Index counter, etc */
INT4 k;
REAL8 f0, alpha, delta, veloMod;
REAL8 patchSizeX, patchSizeY;
/************************************************************/
/* Set up the default parameters. */
/* **********************************************************/
lutV.length = MOBSCOH;
pgV.length = MOBSCOH;
phmdVS.length = MOBSCOH;
freqInd.length = MOBSCOH;
phmdVS.nfSize = NFSIZE;
freqInd.deltaF = DF;
phmdVS.deltaF = DF;
lutV.lut = NULL;
pgV.pg = NULL;
phmdVS.phmd = NULL;
freqInd.data = NULL;
ht.map = NULL;
f0 = F0;
f0Bin = F0*TCOH;
parRes.f0Bin = f0Bin;
parRes.deltaF = DF;
parRes.patchSkySizeX = patchSizeX = 1.0/(TCOH*F0*VEPI);
parRes.patchSkySizeY = patchSizeY = 1.0/(TCOH*F0*VEPI);
parRes.pixelFactor = PIXELFACTOR;
parRes.pixErr = PIXERR;
parRes.linErr = LINERR;
parRes.vTotC = VTOT;
alpha = ALPHA;
delta = DELTA;
veloMod = VTOT;
/********************************************************/
/* Parse argument list. i stores the current position. */
/********************************************************/
arg = 1;
while ( arg < argc ) {
/* Parse debuglevel option. */
if ( !strcmp( argv[arg], "-d" ) ) {
if ( argc > arg + 1 ) {
arg++;
} else {
ERROR( TESTDRIVENDHOUGHC_EARG, TESTDRIVENDHOUGHC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTDRIVENDHOUGHC_EARG;
}
}
/* Parse output file option. */
else if ( !strcmp( argv[arg], "-o" ) ) {
if ( argc > arg + 1 ) {
arg++;
fname = argv[arg++];
} else {
ERROR( TESTDRIVENDHOUGHC_EARG, TESTDRIVENDHOUGHC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTDRIVENDHOUGHC_EARG;
}
}
/* Parse frequency option. */
else if ( !strcmp( argv[arg], "-f" ) ) {
if ( argc > arg + 1 ) {
arg++;
f0 = atof(argv[arg++]);
f0Bin = f0*TCOH;
parRes.f0Bin = f0Bin;
} else {
ERROR( TESTDRIVENDHOUGHC_EARG, TESTDRIVENDHOUGHC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTDRIVENDHOUGHC_EARG;
}
}
/* Parse velocity position options. */
else if ( !strcmp( argv[arg], "-p" ) ) {
if ( argc > arg + 2 ) {
arg++;
alpha = atof(argv[arg++]);
delta = atof(argv[arg++]);
} else {
ERROR( TESTDRIVENDHOUGHC_EARG, TESTDRIVENDHOUGHC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTDRIVENDHOUGHC_EARG;
}
}
/* Parse patch size option. */
else if ( !strcmp( argv[arg], "-s" ) ) {
if ( argc > arg + 2 ) {
arg++;
parRes.patchSkySizeX = patchSizeX = atof(argv[arg++]);
parRes.patchSkySizeY = patchSizeY = atof(argv[arg++]);
} else {
ERROR( TESTDRIVENDHOUGHC_EARG, TESTDRIVENDHOUGHC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTDRIVENDHOUGHC_EARG;
}
}
/* Unrecognized option. */
else {
ERROR( TESTDRIVENDHOUGHC_EARG, TESTDRIVENDHOUGHC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTDRIVENDHOUGHC_EARG;
}
} /* End of argument parsing loop. */
/******************************************************************/
if ( f0 < 0 ) {
ERROR( TESTDRIVENDHOUGHC_EBAD, TESTDRIVENDHOUGHC_MSGEBAD, "freq<0:" );
XLALPrintError( USAGE, *argv );
return TESTDRIVENDHOUGHC_EBAD;
}
/******************************************************************/
/* create patch grid */
/******************************************************************/
SUB( LALHOUGHComputeNDSizePar( &status, &parSize, &parRes ), &status );
xSide = parSize.xSide;
ySide = parSize.ySide;
maxNBins = parSize.maxNBins;
maxNBorders = parSize.maxNBorders;
/* allocate memory based on xSide and ySide */
patch.xSide = xSide;
patch.ySide = ySide;
/* allocate memory based on xSide and ySide */
patch.xCoor = NULL;
patch.yCoor = NULL;
patch.xCoor = (REAL8 *)LALMalloc(xSide*sizeof(REAL8));
patch.yCoor = (REAL8 *)LALMalloc(ySide*sizeof(REAL8));
SUB( LALHOUGHFillPatchGrid( &status, &patch, &parSize ), &status );
/******************************************************************/
/* memory allocation and settings */
/******************************************************************/
lutV.lut = (HOUGHptfLUT *)LALMalloc(MOBSCOH*sizeof(HOUGHptfLUT));
pgV.pg = (HOUGHPeakGram *)LALMalloc(MOBSCOH*sizeof(HOUGHPeakGram));
phmdVS.phmd =(HOUGHphmd *)LALMalloc(MOBSCOH*NFSIZE*sizeof(HOUGHphmd));
freqInd.data = ( UINT8 *)LALMalloc(MOBSCOH*sizeof(UINT8));
for(j=0; j<lutV.length; ++j){
lutV.lut[j].maxNBins = maxNBins;
lutV.lut[j].maxNBorders = maxNBorders;
lutV.lut[j].border =
(HOUGHBorder *)LALMalloc(maxNBorders*sizeof(HOUGHBorder));
lutV.lut[j].bin =
(HOUGHBin2Border *)LALMalloc(maxNBins*sizeof(HOUGHBin2Border));
}
for(j=0; j<phmdVS.length * phmdVS.nfSize; ++j){
phmdVS.phmd[j].maxNBorders = maxNBorders;
phmdVS.phmd[j].leftBorderP =
(HOUGHBorder **)LALMalloc(maxNBorders*sizeof(HOUGHBorder *));
phmdVS.phmd[j].rightBorderP =
(HOUGHBorder **)LALMalloc(maxNBorders*sizeof(HOUGHBorder *));
}
ht.xSide = xSide;
ht.ySide = ySide;
ht.map = NULL;
ht.map = (HoughTT *)LALMalloc(xSide*ySide*sizeof(HoughTT));
for(j=0; j<phmdVS.length * phmdVS.nfSize; ++j){
phmdVS.phmd[j].ySide = ySide;
phmdVS.phmd[j].firstColumn = NULL;
phmdVS.phmd[j].firstColumn = (UCHAR *)LALMalloc(ySide*sizeof(UCHAR));
}
for (j=0; j<lutV.length ; ++j){
for (i=0; i<maxNBorders; ++i){
lutV.lut[j].border[i].ySide = ySide;
lutV.lut[j].border[i].xPixel =
(COORType *)LALMalloc(ySide*sizeof(COORType));
}
}
/******************************************************************/
/* Case: no spins, patch at south pole */
/************************************************************/
parDem.deltaF = DF;
parDem.skyPatch.alpha = 0.0;
parDem.skyPatch.delta = -LAL_PI_2;
parDem.timeDiff = 0.0;
parDem.spin.length = 0;
parDem.spin.data = NULL;
/*************************************************/
for (j=0;j< MOBSCOH;++j){ /* create all the LUTs */
parDem.veloC.x = veloMod*cos(delta)*cos(alpha);
parDem.veloC.y = veloMod*cos(delta)*sin(alpha);
parDem.veloC.z = veloMod*sin(delta);
alpha += STEPALPHA; /* shift alpha several degrees */
/* calculate parameters needed for buiding the LUT */
SUB( LALNDHOUGHParamPLUT( &status, &parLut, &parSize, &parDem ), &status );
/* build the LUT */
SUB( LALHOUGHConstructPLUT( &status, &(lutV.lut[j]), &patch, &parLut ),
&status );
}
/******************************************************************/
/* create Peakgrams for testing */
/******************************************************************/
fBin = f0Bin + 21; /* a Frequency-bin shifted from the LUT */
for (j=0;j< MOBSCOH;++j){ /* create all the peakgrams */
pgV.pg[j].deltaF = DF;
pgV.pg[j].fBinIni = (fBin) - maxNBins;
pgV.pg[j].fBinFin = (fBin)+ 5*maxNBins;
pgV.pg[j].length = maxNBins; /* could be much smaller */
pgV.pg[j].peak = NULL;
pgV.pg[j].peak = (INT4 *)LALMalloc( ( pgV.pg[j].length) * sizeof(INT4));
for (i=0; i< pgV.pg[j].length; ++i){ pgV.pg[j].peak[i] = 3*i; } /* test */
}
/******************************************************************/
/* build the set of PHMD */
/******************************************************************/
phmdVS.fBinMin = fBin;
SUB( LALHOUGHConstructSpacePHMD(&status, &phmdVS, &pgV, &lutV), &status );
/* shift the structure one frequency bin */
SUB( LALHOUGHupdateSpacePHMDup(&status, &phmdVS, &pgV, &lutV), &status );
/******************************************************************/
/* initializing the Hough map space */
/******************************************************************/
SUB( LALHOUGHInitializeHT( &status, &ht, &patch ), &status );
/******************************************************************/
/* construction of a total Hough map */
/******************************************************************/
for (j=0;j< MOBSCOH;++j){
freqInd.data[j]= fBin+2;
}
SUB( LALHOUGHConstructHMT( &status, &ht, &freqInd, &phmdVS ), &status );
/******************************************************************/
/* printing the results into a particular file */
/* if the -o option was given, or into FILEOUT */
/******************************************************************/
if ( fname ) {
fp = fopen( fname, "w" );
} else {
fp = fopen( FILEOUT , "w" );
}
if ( !fp ){
ERROR( TESTDRIVENDHOUGHC_EFILE, TESTDRIVENDHOUGHC_MSGEFILE, 0 );
return TESTDRIVENDHOUGHC_EFILE;
}
for(k=ySide-1; k>=0; --k){
for(i=0;i<xSide;++i){
fprintf( fp ," %f", ht.map[k*xSide +i]);
fflush( fp );
}
fprintf( fp ," \n");
fflush( fp );
}
fclose( fp );
/******************************************************************/
/* Free memory and exit */
/******************************************************************/
for (j=0;j< MOBSCOH;++j){
LALFree( pgV.pg[j].peak); /* All of them */
}
for (j=0; j<lutV.length ; ++j){
for (i=0; i<maxNBorders; ++i){
LALFree( lutV.lut[j].border[i].xPixel);
}
LALFree( lutV.lut[j].border);
LALFree( lutV.lut[j].bin);
}
for(j=0; j<phmdVS.length * phmdVS.nfSize; ++j){
LALFree( phmdVS.phmd[j].leftBorderP);
LALFree( phmdVS.phmd[j].rightBorderP);
LALFree( phmdVS.phmd[j].firstColumn);
}
LALFree(lutV.lut);
LALFree(pgV.pg);
LALFree(phmdVS.phmd);
LALFree(freqInd.data);
LALFree(ht.map);
LALFree(patch.xCoor);
LALFree(patch.yCoor);
LALCheckMemoryLeaks();
INFO( TESTDRIVENDHOUGHC_MSGENORM );
return TESTDRIVENDHOUGHC_ENORM;
}
/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv------------------------------------ */
int main(int argc, char *argv[]){
static LALStatus status; /* LALStatus pointer */
static HOUGHptfLUT lut; /* the Look Up Table */
static HOUGHPatchGrid patch; /* Patch description */
static HOUGHParamPLUT parLut; /* parameters needed to build lut */
static HOUGHResolutionPar parRes;
static HOUGHDemodPar parDem; /* demodulation parameters */
static HOUGHSizePar parSize;
static HOUGHPeakGram pg;
static HOUGHphmd phmd; /* the partial Hough map derivative */
static HOUGHMapDeriv hd; /* the Hough map derivative */
static HOUGHMapTotal ht; /* the total Hough map */
/* ------------------------------------------------------- */
UINT2 maxNBins, maxNBorders;
INT8 f0Bin; /* freq. bin to construct LUT */
UINT2 xSide, ySide;
CHAR *fname = NULL; /* The output filename */
FILE *fp=NULL; /* Output file */
INT4 arg; /* Argument counter */
INT4 i,j; /* Index counter, etc */
UINT4 k;
REAL8 f0, alpha, delta, veloMod;
REAL8 patchSizeX, patchSizeY;
/************************************************************/
/* Set up the default parameters. */
/************************************************************/
ht.map = NULL;
hd.map = NULL;
f0 = F0;
f0Bin = F0*TCOH;
parRes.f0Bin = f0Bin;
parRes.deltaF = DF;
parRes.patchSkySizeX = patchSizeX = 1.0/(TCOH*F0*VEPI);
parRes.patchSkySizeY = patchSizeY = 1.0/(TCOH*F0*VEPI);
parRes.pixelFactor = PIXELFACTOR;
parRes.pixErr = PIXERR;
parRes.linErr = LINERR;
parRes.vTotC = VTOT;
parDem.deltaF = DF;
parDem.skyPatch.alpha = 0.0;
parDem.skyPatch.delta = -LAL_PI_2;
alpha = ALPHA;
delta = DELTA;
veloMod = VTOT;
/********************************************************/
/* Parse argument list. i stores the current position. */
/********************************************************/
arg = 1;
while ( arg < argc ) {
/* Parse debuglevel option. */
if ( !strcmp( argv[arg], "-d" ) ) {
if ( argc > arg + 1 ) {
arg++;
} else {
ERROR( TESTHOUGHMAPC_EARG, TESTHOUGHMAPC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTHOUGHMAPC_EARG;
}
}
/* Parse output file option. */
else if ( !strcmp( argv[arg], "-o" ) ) {
if ( argc > arg + 1 ) {
arg++;
fname = argv[arg++];
} else {
ERROR( TESTHOUGHMAPC_EARG, TESTHOUGHMAPC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTHOUGHMAPC_EARG;
}
}
/* Parse frequency option. */
else if ( !strcmp( argv[arg], "-f" ) ) {
if ( argc > arg + 1 ) {
arg++;
f0 = atof(argv[arg++]);
f0Bin = f0*TCOH;
parRes.f0Bin = f0Bin;
} else {
ERROR( TESTHOUGHMAPC_EARG, TESTHOUGHMAPC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTHOUGHMAPC_EARG;
}
}
/* Parse velocity position options. */
else if ( !strcmp( argv[arg], "-p" ) ) {
if ( argc > arg + 2 ) {
arg++;
alpha = atof(argv[arg++]);
delta = atof(argv[arg++]);
} else {
ERROR( TESTHOUGHMAPC_EARG, TESTHOUGHMAPC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTHOUGHMAPC_EARG;
}
}
/* Parse patch size option. */
else if ( !strcmp( argv[arg], "-s" ) ) {
if ( argc > arg + 2 ) {
arg++;
parRes.patchSkySizeX = patchSizeX = atof(argv[arg++]);
parRes.patchSkySizeY = patchSizeY = atof(argv[arg++]);
} else {
ERROR( TESTHOUGHMAPC_EARG, TESTHOUGHMAPC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTHOUGHMAPC_EARG;
}
}
/* Unrecognized option. */
else {
ERROR( TESTHOUGHMAPC_EARG, TESTHOUGHMAPC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTHOUGHMAPC_EARG;
}
} /* End of argument parsing loop. */
/******************************************************************/
if ( f0 < 0 ) {
ERROR( TESTHOUGHMAPC_EBAD, TESTHOUGHMAPC_MSGEBAD, "freq<0:" );
XLALPrintError( USAGE, *argv );
return TESTHOUGHMAPC_EBAD;
}
/******************************************************************/
/* create patch grid */
/******************************************************************/
SUB( LALHOUGHComputeSizePar( &status, &parSize, &parRes ), &status );
xSide = parSize.xSide;
ySide = parSize.ySide;
maxNBins = parSize.maxNBins;
maxNBorders = parSize.maxNBorders;
/* allocate memory based on xSide and ySide */
patch.xSide = xSide;
patch.ySide = ySide;
patch.xCoor = NULL;
patch.yCoor = NULL;
patch.xCoor = (REAL8 *)LALMalloc(xSide*sizeof(REAL8));
patch.yCoor = (REAL8 *)LALMalloc(ySide*sizeof(REAL8));
SUB( LALHOUGHFillPatchGrid( &status, &patch, &parSize ), &status );
/******************************************************************/
/* memory allocation again and settings */
/******************************************************************/
lut.maxNBins = maxNBins;
lut.maxNBorders = maxNBorders;
lut.border =
(HOUGHBorder *)LALMalloc(maxNBorders*sizeof(HOUGHBorder));
lut.bin =
(HOUGHBin2Border *)LALMalloc(maxNBins*sizeof(HOUGHBin2Border));
phmd.maxNBorders = maxNBorders;
phmd.leftBorderP =
(HOUGHBorder **)LALMalloc(maxNBorders*sizeof(HOUGHBorder *));
phmd.rightBorderP =
(HOUGHBorder **)LALMalloc(maxNBorders*sizeof(HOUGHBorder *));
ht.xSide = xSide;
ht.ySide = ySide;
ht.map = (HoughTT *)LALMalloc(xSide*ySide*sizeof(HoughTT));
hd.xSide = xSide;
hd.ySide = ySide;
hd.map = (HoughDT *)LALMalloc((xSide+1)*ySide*sizeof(HoughDT));
phmd.ySide = ySide;
phmd.firstColumn = NULL;
phmd.firstColumn = (UCHAR *)LALMalloc(ySide*sizeof(UCHAR));
for (i=0; i<maxNBorders; ++i){
lut.border[i].ySide = ySide;
lut.border[i].xPixel = (COORType *)LALMalloc(ySide*sizeof(COORType));
}
/******************************************************************/
/* Case: no spins, patch at south pole */
/************************************************************/
parDem.veloC.x = veloMod*cos(delta)*cos(alpha);
parDem.veloC.y = veloMod*cos(delta)*sin(alpha);
parDem.veloC.z = veloMod*sin(delta);
parDem.positC.x = 0.0;
parDem.positC.y = 0.0;
parDem.positC.z = 0.0;
parDem.timeDiff = 0.0;
parDem.spin.length = 0;
parDem.spin.data = NULL;
/******************************************************************/
/* Frequency-bin of the Partial Hough Map*/
/******************************************************************/
phmd.fBin = f0Bin + 21; /* a bit shifted from the LUT */
/******************************************************************/
/* A Peakgram for testing */
/******************************************************************/
pg.deltaF = DF;
pg.fBinIni = (phmd.fBin) - maxNBins;
pg.fBinFin = (phmd.fBin)+ 5*maxNBins;
pg.length = maxNBins; /* could be much smaller */
pg.peak = NULL;
pg.peak = (INT4 *)LALMalloc( (pg.length) * sizeof(INT4));
for (k=0; k< pg.length; ++k){ pg.peak[k] = 3*k; } /* a test */
/******************************************************************/
/* calculate parameters needed for buiding the LUT */
/******************************************************************/
SUB( LALHOUGHCalcParamPLUT( &status, &parLut, &parSize, &parDem ), &status );
/******************************************************************/
/* build the LUT */
/******************************************************************/
SUB( LALHOUGHConstructPLUT( &status, &lut, &patch, &parLut ), &status );
/******************************************************************/
/* build a PHMD from a peakgram and LUT */
/******************************************************************/
SUB( LALHOUGHPeak2PHMD( &status, &phmd, &lut, &pg ), &status );
/******************************************************************/
/* initializing the Hough map space */
/******************************************************************/
SUB( LALHOUGHInitializeHT( &status, &ht, &patch ), &status );
/******************************************************************/
/* initializing the Hough map derivative space */
/******************************************************************/
SUB( LALHOUGHInitializeHD( &status, &hd), &status );
/******************************************************************/
/* sum a partial-HMD into a HD */
/******************************************************************/
SUB( LALHOUGHAddPHMD2HD( &status, &hd, &phmd ), &status );
/******************************************************************/
/* construction of a total Hough map: integration of a HM-deriv. */
/******************************************************************/
SUB( LALHOUGHIntegrHD2HT( &status, &ht, &hd ), &status );
/******************************************************************/
/* printing the results into a particular file */
/* if the -o option was given, or into FILEOUT */
/******************************************************************/
if ( fname ) {
fp = fopen( fname, "w" );
} else {
fp = fopen( FILEOUT , "w" );
}
if ( !fp ){
ERROR( TESTHOUGHMAPC_EFILE, TESTHOUGHMAPC_MSGEFILE, 0 );
return TESTHOUGHMAPC_EFILE;
}
for(j=ySide-1; j>=0; --j){
for(i=0;i<xSide;++i){
fprintf( fp ," %f", ht.map[j*xSide +i]);
fflush( fp );
}
fprintf( fp ," \n");
fflush( fp );
}
fclose( fp );
/******************************************************************/
/* Free memory and exit */
/******************************************************************/
LALFree(pg.peak);
for (i=0; i<maxNBorders; ++i){
LALFree( lut.border[i].xPixel);
}
LALFree( lut.border);
LALFree( lut.bin);
LALFree( phmd.leftBorderP);
LALFree( phmd.rightBorderP);
LALFree( phmd.firstColumn);
LALFree( ht.map);
LALFree( hd.map);
LALFree( patch.xCoor);
LALFree( patch.yCoor);
LALCheckMemoryLeaks();
INFO( TESTHOUGHMAPC_MSGENORM );
return TESTHOUGHMAPC_ENORM;
}
/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv------------------------------------ */
int main(int argc, char *argv[]){
static LALStatus status; /* LALStatus pointer */
static HOUGHptfLUT lut; /* the Look Up Table */
static HOUGHPatchGrid patch; /* Patch description */
static HOUGHParamPLUT parLut; /* parameters needed to build lut */
static HOUGHResolutionPar parRes;
static HOUGHDemodPar parDem; /* demodulation parameters */
static HOUGHSizePar parSize;
static HOUGHPeakGram pg;
static HOUGHphmd phmd; /* the partial Hough map derivative */
/* ------------------------------------------------------- */
INT8 f0Bin; /* freq. bin to construct LUT */
UINT4 xSide, ySide;
UINT4 maxNBins, maxNBorders;
/* the Hough derivative map. The patch containing at most
SIDEX*SIDEY pixels */
/* HoughDT PHMD[SIDEY][SIDEX+1]; */
HoughDT *PHMD;
HoughDT *pointer;
CHAR *fname = NULL; /* The output filename */
FILE *fp=NULL; /* Output file */
INT4 arg; /* Argument counter */
INT4 j; /* Index counter, etc */
UINT4 i, k;
REAL8 f0, alpha, delta, veloMod;
REAL8 patchSizeX, patchSizeY;
/************************************************************/
/* Set up the default parameters. */
/************************************************************/
f0 = F0;
f0Bin = F0*TCOH;
parRes.f0Bin = f0Bin;
parRes.deltaF = DF;
parRes.patchSkySizeX = patchSizeX = 1.0/(TCOH*F0*VEPI);
parRes.patchSkySizeY = patchSizeY = 1.0/(TCOH*F0*VEPI);
parRes.pixelFactor = PIXELFACTOR;
parRes.pixErr = PIXERR;
parRes.linErr = LINERR;
parRes.vTotC = VTOT;
parDem.deltaF = DF;
parDem.skyPatch.alpha = 0.0;
parDem.skyPatch.delta = -LAL_PI_2;
alpha = ALPHA;
delta = DELTA;
veloMod = VTOT;
/********************************************************/
/* Parse argument list. i stores the current position. */
/********************************************************/
arg = 1;
while ( arg < argc ) {
/* Parse debuglevel option. */
if ( !strcmp( argv[arg], "-d" ) ) {
if ( argc > arg + 1 ) {
arg++;
} else {
ERROR( TESTNDPEAK2PHMDC_EARG, TESTNDPEAK2PHMDC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTNDPEAK2PHMDC_EARG;
}
}
/* Parse output file option. */
else if ( !strcmp( argv[arg], "-o" ) ) {
if ( argc > arg + 1 ) {
arg++;
fname = argv[arg++];
} else {
ERROR( TESTNDPEAK2PHMDC_EARG, TESTNDPEAK2PHMDC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTNDPEAK2PHMDC_EARG;
}
}
/* Parse frequency option. */
else if ( !strcmp( argv[arg], "-f" ) ) {
if ( argc > arg + 1 ) {
arg++;
f0 = atof(argv[arg++]);
f0Bin = f0*TCOH;
parRes.f0Bin = f0Bin;
} else {
ERROR( TESTNDPEAK2PHMDC_EARG, TESTNDPEAK2PHMDC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTNDPEAK2PHMDC_EARG;
}
}
/* Parse velocity position options. */
else if ( !strcmp( argv[arg], "-p" ) ) {
if ( argc > arg + 2 ) {
arg++;
alpha = atof(argv[arg++]);
delta = atof(argv[arg++]);
} else {
ERROR( TESTNDPEAK2PHMDC_EARG, TESTNDPEAK2PHMDC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTNDPEAK2PHMDC_EARG;
}
}
/* Parse patch size option. */
else if ( !strcmp( argv[arg], "-s" ) ) {
if ( argc > arg + 2 ) {
arg++;
parRes.patchSkySizeX = patchSizeX = atof(argv[arg++]);
parRes.patchSkySizeY = patchSizeY = atof(argv[arg++]);
} else {
ERROR( TESTNDPEAK2PHMDC_EARG, TESTNDPEAK2PHMDC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTNDPEAK2PHMDC_EARG;
}
}
/* Unrecognized option. */
else {
ERROR( TESTNDPEAK2PHMDC_EARG, TESTNDPEAK2PHMDC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTNDPEAK2PHMDC_EARG;
}
} /* End of argument parsing loop. */
/******************************************************************/
if ( f0 < 0 ) {
ERROR( TESTNDPEAK2PHMDC_EBAD, TESTNDPEAK2PHMDC_MSGEBAD, "freq<0:" );
XLALPrintError( USAGE, *argv );
return TESTNDPEAK2PHMDC_EBAD;
}
/******************************************************************/
/* create patch grid */
/******************************************************************/
SUB( LALHOUGHComputeNDSizePar( &status, &parSize, &parRes ), &status );
xSide = parSize.xSide;
ySide = parSize.ySide;
maxNBins = parSize.maxNBins;
maxNBorders = parSize.maxNBorders;
/* allocate memory based on xSide and ySide */
patch.xSide = xSide;
patch.ySide = ySide;
patch.xCoor = NULL;
patch.yCoor = NULL;
patch.xCoor = (REAL8 *)LALMalloc(xSide*sizeof(REAL8));
patch.yCoor = (REAL8 *)LALMalloc(ySide*sizeof(REAL8));
SUB( LALHOUGHFillPatchGrid( &status, &patch, &parSize ), &status );
/******************************************************************/
/* memory allocation and settings */
/******************************************************************/
lut.maxNBins = maxNBins;
lut.maxNBorders = maxNBorders;
lut.border =
(HOUGHBorder *)LALMalloc(maxNBorders*sizeof(HOUGHBorder));
lut.bin =
(HOUGHBin2Border *)LALMalloc(maxNBins*sizeof(HOUGHBin2Border));
phmd.maxNBorders = maxNBorders;
phmd.leftBorderP =
(HOUGHBorder **)LALMalloc(maxNBorders*sizeof(HOUGHBorder *));
phmd.rightBorderP =
(HOUGHBorder **)LALMalloc(maxNBorders*sizeof(HOUGHBorder *));
phmd.ySide = ySide;
phmd.firstColumn = NULL;
phmd.firstColumn = (UCHAR *)LALMalloc(ySide*sizeof(UCHAR));
PHMD = (HoughDT *)LALMalloc((xSide+1)*ySide*sizeof(HoughDT));
for (i=0; i<maxNBorders; ++i){
lut.border[i].ySide = ySide;
lut.border[i].xPixel = (COORType *)LALMalloc(ySide*sizeof(COORType));
}
/******************************************************************/
/* Case: no spins, patch at south pole */
/******************************************************************/
parDem.veloC.x = veloMod*cos(delta)*cos(alpha);
parDem.veloC.y = veloMod*cos(delta)*sin(alpha);
parDem.veloC.z = veloMod*sin(delta);
parDem.timeDiff = 0.0;
parDem.spin.length = 0;
parDem.spin.data = NULL;
/******************************************************************/
/* Frequency-bin of the Partial Hough Map*/
/******************************************************************/
phmd.fBin = f0Bin + 21; /* a bit shifted from the LUT */
/******************************************************************/
/* A Peakgram for testing */
/******************************************************************/
pg.deltaF = DF;
pg.fBinIni = (phmd.fBin) - 20000 ;
pg.fBinFin = (phmd.fBin) + 20000;
pg.length = 1;
pg.peak = NULL;
pg.peak = (INT4 *)LALMalloc( (pg.length) * sizeof(INT4));
/* for (ii=0; ii< pg.length; ++ii){ pg.peak[ii] = 8*ii; }*/ /* a test */
/******************************************************************/
/* calculate parameters needed for buiding the LUT */
/******************************************************************/
SUB( LALNDHOUGHParamPLUT( &status, &parLut, &parSize, &parDem ), &status );
/******************************************************************/
/* build the LUT */
/******************************************************************/
SUB( LALHOUGHConstructPLUT( &status, &lut, &patch, &parLut ), &status );
/******************************************************************/
/* build a PHMD from a peakgram and LUT */
/******************************************************************/
pg.peak[0] = 20000 + lut.offset;
SUB( LALHOUGHPeak2PHMD( &status, &phmd, &lut, &pg ), &status );
/******************************************************************/
/* construct PHMD[i][j] accordingly */
/*******************************************************/
/* initializing output space */
pointer = &( PHMD[0]);
for ( k=0; k< (xSide+1)*ySide; ++k ){
*pointer = 0;
++pointer;
}
/* first column correction */
for ( k=0; k< ySide; ++k ){
PHMD[k*(xSide+1) +0] = phmd.firstColumn[k];
}
/* left borders => +1 */
for (k=0; k< phmd.lengthLeft; ++k){
INT2 xindex, yLower,yUpper;
COORType *xPixel;
yLower = (*(phmd.leftBorderP[k])).yLower;
yUpper = (*(phmd.leftBorderP[k])).yUpper;
xPixel = &( (*(phmd.leftBorderP[k])).xPixel[0] );
for(j=yLower; j<=yUpper;++j){
xindex = xPixel[j];
PHMD[j*(xSide+1) + xindex] += 1;
}
}
/* right borders => -1 */
for (k=0; k< phmd.lengthRight; ++k){
INT2 xindex, yLower,yUpper;
COORType *xPixel;
yLower = (*(phmd.rightBorderP[k])).yLower;
yUpper = (*(phmd.rightBorderP[k])).yUpper;
xPixel = &( (*(phmd.rightBorderP[k])).xPixel[0] );
for(j=yLower; j<=yUpper;++j){
xindex = xPixel[j];
PHMD[j*(xSide+1) + xindex] -= 1;
}
}
/******************************************************************/
/* printing the results into a particular file */
/* if the -o option was given, or into FILEOUT */
/******************************************************************/
if ( fname ) {
fp = fopen( fname, "w" );
} else {
fp = fopen( FILEOUT , "w" );
}
if ( !fp ){
ERROR( TESTNDPEAK2PHMDC_EFILE, TESTNDPEAK2PHMDC_MSGEFILE, 0 );
return TESTNDPEAK2PHMDC_EFILE;
}
for(j=ySide-1; j>=0; --j){
for(i=0;i<xSide;++i){
fprintf( fp ," %f", PHMD[j*(xSide+1) + i]);
fflush( fp );
}
fprintf( fp ," \n");
fflush( fp );
}
fclose( fp );
/******************************************************************/
/* Free memory and exit */
/******************************************************************/
LALFree(pg.peak);
for (i=0; i<maxNBorders; ++i){
LALFree( lut.border[i].xPixel);
}
LALFree( lut.border);
LALFree( lut.bin);
LALFree( phmd.leftBorderP);
LALFree( phmd.rightBorderP);
LALFree( phmd.firstColumn);
LALFree( PHMD);
LALFree( patch.xCoor);
LALFree( patch.yCoor);
LALCheckMemoryLeaks();
INFO( TESTNDPEAK2PHMDC_MSGENORM );
return TESTNDPEAK2PHMDC_ENORM;
}
