/* 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( TESTNDHOUGHMAPC_EARG, TESTNDHOUGHMAPC_MSGEARG, 0 ); XLALPrintError( USAGE, *argv ); return TESTNDHOUGHMAPC_EARG; } } /* Parse output file option. */ else if ( !strcmp( argv[arg], "-o" ) ) { if ( argc > arg + 1 ) { arg++; fname = argv[arg++]; } else { ERROR( TESTNDHOUGHMAPC_EARG, TESTNDHOUGHMAPC_MSGEARG, 0 ); XLALPrintError( USAGE, *argv ); return TESTNDHOUGHMAPC_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( TESTNDHOUGHMAPC_EARG, TESTNDHOUGHMAPC_MSGEARG, 0 ); XLALPrintError( USAGE, *argv ); return TESTNDHOUGHMAPC_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( TESTNDHOUGHMAPC_EARG, TESTNDHOUGHMAPC_MSGEARG, 0 ); XLALPrintError( USAGE, *argv ); return TESTNDHOUGHMAPC_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( TESTNDHOUGHMAPC_EARG, TESTNDHOUGHMAPC_MSGEARG, 0 ); XLALPrintError( USAGE, *argv ); return TESTNDHOUGHMAPC_EARG; } } /* Unrecognized option. */ else { ERROR( TESTNDHOUGHMAPC_EARG, TESTNDHOUGHMAPC_MSGEARG, 0 ); XLALPrintError( USAGE, *argv ); return TESTNDHOUGHMAPC_EARG; } } /* End of argument parsing loop. */ /******************************************************************/ if ( f0 < 0 ) { ERROR( TESTNDHOUGHMAPC_EBAD, TESTNDHOUGHMAPC_MSGEBAD, "freq<0:" ); XLALPrintError( USAGE, *argv ); return TESTNDHOUGHMAPC_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 *)); 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.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( LALNDHOUGHParamPLUT( &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( TESTNDHOUGHMAPC_EFILE, TESTNDHOUGHMAPC_MSGEFILE, 0 ); return TESTNDHOUGHMAPC_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( TESTNDHOUGHMAPC_MSGENORM ); return TESTNDHOUGHMAPC_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; }