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