/* 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; }