int GetSSBTime(LIGOTimeGPS *tdet, LIGOTimeGPS *tssb)
{
static LALStatus status;
printf("start function GetSSBTime\n");
baryinput.tgps.gpsSeconds=tdet->gpsSeconds;
baryinput.tgps.gpsNanoSeconds=tdet->gpsNanoSeconds;
/*Get coords for detector LHO*/
cachedDetector=lalCachedDetectors[LALDetectorIndexLHODIFF];
baryinput.site.location[0]=cachedDetector.location[0]/LAL_C_SI;
baryinput.site.location[1]=cachedDetector.location[1]/LAL_C_SI;
baryinput.site.location[2]=cachedDetector.location[2]/LAL_C_SI;
baryinput.alpha=0;
baryinput.delta=0;
baryinput.dInv=0.e0;
LALBarycenterEarth(&status, &earth, tdet, edat);
REPORTSTATUS(&status);
LALBarycenter(&status, &emit, &baryinput, &earth);
tssb->gpsSeconds=emit.te.gpsSeconds;
tssb->gpsNanoSeconds=emit.te.gpsNanoSeconds;
printf("time at the SSB is : %d\n",tssb->gpsSeconds);
printf("end function GetSSBTime");
return 4;
}
int main (void) {
static REAL4Vector *signal1;
static LALStatus status;
static InspiralTemplate params;
static REAL8 dt;
UINT4 n;
params.OmegaS = 0.;
params.Theta = 0.;
params.ieta=1;
params.mass1=5.1;
params.mass2=5.;
params.startTime=0.0;
params.startPhase=0.0;
params.fLower=40.0;
params.fCutoff=2048.00;
params.tSampling=8192.0;
params.order=6;
params.approximant=IMRPhenomB;
/* SpinTaylorT3 */
params.signalAmplitude=1.0;
params.nStartPad=0;
params.nEndPad=0;
params.massChoice=m1Andm2;
params.distance = 100.;
dt = 1./params.tSampling;
params.spin1[2]=1.0;
params.spin2[2]=0.99;
LALInspiralWaveLength(&status, &n, params);
LALInspiralParameterCalc(&status, ¶ms);
fprintf(stderr, "Testing Inspiral Signal Generation Codes:\n");
fprintf(stderr, "Signal length=%d, m1=%e, m2=%e, fLower=%e, fUpper=%e\n",
n, params.mass1, params.mass2, params.fLower, params.fCutoff);
LALCreateVector(&status, &signal1, n);
LALInspiralWave(&status, signal1, ¶ms);
fprintf(stderr,"fFinal = %e\n", params.fFinal);
printf_timeseries(signal1->length, signal1->data, dt, params.startTime);
REPORTSTATUS(&status);
printf("duration is %f \n", params.tC);
printf("final frequency is %f \n", params.fFinal);
LALDestroyVector(&status, &signal1);
LALCheckMemoryLeaks();
return 0;
}
/*
* TestStatus ()
*
* Routine to check that the status code status->statusCode agrees with one of
* the codes specified in the space-delimited string ignored; if not,
* exit to the system with code exitcode.
*
*/
static void
TestStatus (
LALStatus *status,
const char *ignored,
int exitcode
)
{
char str[64];
char *tok;
if (verbose)
{
REPORTSTATUS (status);
}
if (strncpy (str, ignored, sizeof (str)))
{
if ((tok = strtok (str, " ")))
{
do
{
if (status->statusCode == atoi (tok))
{
return;
}
}
while ((tok = strtok (NULL, " ")));
}
else
{
if (status->statusCode == atoi (tok))
{
return;
}
}
}
fprintf (stderr, "\nExiting to system with code %d\n", exitcode);
exit (exitcode);
}
INT4
CheckStatus(LALStatus *status, const INT4 code, const CHAR *message,
const INT4 exitcode, const CHAR *error)
{
if (optVerbose)
{
REPORTSTATUS (status);
}
if (status->statusCode!= code)
{
if (code) printf (" FAIL: did not recognize \"%s\"\n", message);
if (optVerbose) printf("Exiting with error: %s\n", error);
return(exitcode);
}
else if (code && strcmp(message, status->statusDescription))
{
printf(" FAIL: incorrect error message \"%s\" not \"%s\"\n",
status->statusDescription, message);
if (optVerbose) printf("Exiting with error: %s\n", error);
return(exitcode);
}
return 0;
}
int main(void)
{
const INT4 Nsignal=16;
const INT4 Nwindow=5;
const INT4 Nfft=8;
static LALStatus status;
REAL4Vector *signalvec = NULL;
CreateTimeFreqIn tfrIn;
TimeFreqRep *tfr = NULL;
TimeFreqParam *param = NULL;
INT4 column;
INT4 row;
/*--------------------------------------------------------------------*/
LALSCreateVector(&status, &signalvec, Nsignal);
for (column = 0; column < (INT4)signalvec->length; column++)
signalvec->data[column]=(rand() % 10) / 2.0;
/*--------------------------------------------------------------------*/
tfrIn.type=Spectrogram;
tfrIn.fRow=Nfft;
tfrIn.tCol=Nsignal;
tfrIn.wlengthT=Nwindow;
tfrIn.wlengthF=0;
/*--------------------------------------------------------------------*/
LALCreateTimeFreqRep(&status, &tfr, &tfrIn);
for (column = 0; column < tfr->tCol; column++)
tfr->timeInstant[column]=column;
LALCreateTimeFreqParam(&status, ¶m, &tfrIn);
for (column = 0; column < (INT4)param->windowT->length; column++)
param->windowT->data[column]=1.0;
/*--------------------------------------------------------------------*/
LALTfrSp(&status,signalvec,tfr,param);
REPORTSTATUS(&status);
/*--------------------------------------------------------------------*/
printf("Signal:\n");
for (column= 0; column < (INT4)signalvec->length; column++)
printf("%1.1f ",signalvec->data[column]);
printf("\n\n");
printf("TFR:\n");
for (row= 0; row < (tfr->fRow/2+1); row++)
{
for (column= 0; column < tfr->tCol; column++)
printf("%2.2f ",tfr->map[column][row]);
printf("\n");
}
/*--------------------------------------------------------------------*/
LALSDestroyVector(&status,&signalvec);
LALDestroyTimeFreqRep(&status,&tfr);
LALDestroyTimeFreqParam(&status,¶m);
LALCheckMemoryLeaks();
return 0;
}
/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv------------------------------------ */
int main(int argc, char *argv[]){
static LALStatus status; /* LALStatus pointer */
SFTtype *sft1, *sft2;
REAL8 startFreq, bandFreq;
/* CHAR file1[MAXFILENAMELENGTH], file2[MAXFILENAMELENGTH]; */
CHAR *file1, *file2;
INT4 arg;
/* set defaults */
file1 = FILE1;
file2 = FILE2;
startFreq = STARTFREQ;
bandFreq = BANDFREQ;
/********************************************************/
/* 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++;
}
}
/* parse first sft filename */
else if ( !strcmp( argv[arg], "-A" ) ) {
if ( argc > arg + 1 ) {
arg++;
file1 = argv[arg++];
}
}
/* parse second sft filename */
else if ( !strcmp( argv[arg], "-B" ) ) {
if ( argc > arg + 1 ) {
arg++;
file2 = argv[arg++];
}
}
/* parse start freq */
else if ( !strcmp( argv[arg], "-f" ) ) {
if ( argc > arg + 1 ) {
arg++;
startFreq = atof(argv[arg++]);
}
}
/* parse bandwidth */
else if ( !strcmp( argv[arg], "-b" ) ) {
if ( argc > arg + 1 ) {
arg++;
bandFreq = atof(argv[arg++]);
}
}
/* Unrecognized option. */
else {
printf("unknown argument\n");
printf("options are: \n");
printf("-d LALdebuglevel -A firstsftfile -B secondsftfile -f startfrequency -b freqband\n");
exit(0);
}
}
/* End of argument parsing loop. */
/******************************************************************/
sft1 = NULL;
sft2 = NULL;
LALReadSFTfile (&status, &sft1, startFreq, startFreq + bandFreq, file1);
REPORTSTATUS( &status);
LALReadSFTfile (&status, &sft2, startFreq, startFreq + bandFreq, file2);
/*REPORTSTATUS( &status);*/
{
UINT4 j, nBins;
REAL8 diff;
COMPLEX8 *data1, *data2;
nBins = sft1->data->length;
for (j=0; j<nBins; j++)
{
data1 = sft1->data->data + j;
data2 = sft2->data->data + j;
diff = (data1->re - data2->re)*(data1->re - data2->re) + (data1->im - data2->im)*(data1->im - data2->im);
printf("%1.3e\n", sqrt(diff));
}
}
LALDestroySFTtype (&status, &sft1);
/*REPORTSTATUS( &status);*/
LALDestroySFTtype (&status, &sft2);
/*REPORTSTATUS( &status);*/
LALCheckMemoryLeaks();
/*REPORTSTATUS( &status);*/
return status.statusCode;
}
int main(void){
static LALStatus status;
INT4 loopx = 0; /* loop counters */
INT4 loopy = 0;
INT4 loopz = 0;
INT4 ntiles = 0;
Math3DPointList *list = NULL; /* Pointer to structure for mathematica plot */
Math3DPointList *first = NULL;
if ((list = (Math3DPointList *) LALCalloc(1, sizeof(Math3DPointList))) == NULL){
LALError(&status, LALMATH3DPLOTTESTC_MSGEMEM);
printf(LALMATH3DPLOTTESTC_MSGEMEM);
return LALMATH3DPLOTTESTC_EMEM;
}
first=list;
for(loopx=1; loopx <= 20; loopx++){
for(loopy=1; loopy <= 20; loopy++){
for(loopz=0; loopz <= 1; loopz++){
list->x = loopx;
list->y = loopy;
list->z = loopz;
list->grayLevel = 0.0;
ntiles++;
if ((list = list->next = (Math3DPointList *) LALCalloc(1, sizeof(Math3DPointList))) == NULL){
LALError(&status, LALMATH3DPLOTTESTC_MSGEMEM);
printf(LALMATH3DPLOTTESTC_MSGEMEM);
return LALMATH3DPLOTTESTC_EMEM;
}
}
}
}
for(loopx=1; loopx <= 20; loopx++){
for(loopy=1; loopy <= 20; loopy++){
list->x = loopx;
list->y = loopy;
list->z = 2;
list->grayLevel = 1.0;
ntiles++;
if ((list = list->next = (Math3DPointList *) LALCalloc(1, sizeof(Math3DPointList))) == NULL){
LALError(&status, LALMATH3DPLOTTESTC_MSGEMEM);
printf(LALMATH3DPLOTTESTC_MSGEMEM);
return LALMATH3DPLOTTESTC_EMEM;
}
}
}
/*LAL!*/
for(loopx=1; loopx <= 20; loopx++){
for(loopy=1; loopy <= 20; loopy++){
for(loopz=3; loopz <= 4; loopz++){
if( ((loopx==6)||(loopx==19)) && (loopy<16) && (loopy>5)) continue;
if((loopy==15)&&(((loopx<20)&&(loopx>14))||((loopx<7)&&(loopx>1)))) continue;
if((loopx>9)&&(loopx<12)&&(((loopy>6)&&(loopy<10))||(loopy==12))) continue;
if(((loopx==9)||(loopx==12)) && ((loopy>9)&&(loopy<13))) continue;
if(((loopx==8)||(loopx==13)) && ((loopy>12)&&(loopy<16))) continue;
list->x = loopx;
list->y = loopy;
list->z = loopz;
list->grayLevel = 0.0;
ntiles++;
if ((list = list->next = (Math3DPointList *) LALCalloc(1, sizeof(Math3DPointList))) == NULL){
LALError(&status, LALMATH3DPLOTTESTC_MSGEMEM);
printf(LALMATH3DPLOTTESTC_MSGEMEM);
return LALMATH3DPLOTTESTC_EMEM;
}
}
}
}
list->next = NULL;
printf("\nCalling LALMath3DPlot()......\n");
LALMath3DPlot(&status, first, &ntiles, NULL);
REPORTSTATUS(&status);
if (status.statusCode){
LALError(&status, LALMATH3DPLOTTESTC_MSGESUB);
printf(LALMATH3DPLOTTESTC_MSGESUB);
return LALMATH3DPLOTTESTC_ESUB;
}
/* Clean Up the memory from the MathPlot3D structure */
list = first;
while(list->next){
first = list->next;
LALFree(list);
list = first;
}
/* free the last (first?) memory allocated for Math3DPlot. */
LALFree(list);
if (status.statusCode)
return LALMATH3DPLOTTESTC_ESUB;
else
return LALMATH3DPLOTTESTC_ENORM;
}
int main(int argc, char *argv[]){
/* LALStatus pointer */
static LALStatus status;
/* time and velocity */
static LIGOTimeGPSVector timeV;
static REAL8Cart3CoorVector velV;
static REAL8Vector timeDiffV;
LIGOTimeGPS firstTimeStamp;
/* standard pulsar sft types */
MultiSFTVector *inputSFTs = NULL;
UINT4 binsSFT;
UINT4 sftFminBin;
UINT4 numsft;
INT4 k;
FILE *fp=NULL;
/* information about all the ifos */
MultiDetectorStateSeries *mdetStates = NULL;
UINT4 numifo;
/* vector of weights */
REAL8Vector weightsV;
/* ephemeris */
EphemerisData *edat=NULL;
static UCHARPeakGram pg1;
static HoughTemplate pulsarTemplate;
static REAL8Vector foft;
/* miscellaneous */
UINT4 mObsCoh;
REAL8 timeBase, deltaF;
REAL8 numberCount;
/* Chi2Test parameters */
HoughParamsTest chi2Params;
REAL8Vector numberCountV; /* Vector with the number count of each block inside */
REAL8 numberCountTotal; /* Sum over all the numberCounts */
REAL8 chi2;
/* sft constraint variables */
LIGOTimeGPS startTimeGPS, endTimeGPS;
LIGOTimeGPSVector *inputTimeStampsVector=NULL;
REAL8 alphaPeak, meanN, sigmaN;
/* user input variables */
BOOLEAN uvar_help, uvar_weighAM, uvar_weighNoise;
INT4 uvar_blocksRngMed, uvar_nfSizeCylinder, uvar_maxBinsClean;
REAL8 uvar_startTime, uvar_endTime;
REAL8 uvar_fStart, uvar_peakThreshold, uvar_fSearchBand;
REAL8 uvar_Alpha, uvar_Delta, uvar_Freq, uvar_fdot;
REAL8 uvar_AlphaWeight, uvar_DeltaWeight;
CHAR *uvar_earthEphemeris=NULL;
CHAR *uvar_sunEphemeris=NULL;
CHAR *uvar_sftDir=NULL;
CHAR *uvar_timeStampsFile=NULL;
CHAR *uvar_outfile=NULL;
LALStringVector *uvar_linefiles=NULL;
INT4 uvar_p;
/* Set up the default parameters */
/* LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
uvar_help = FALSE;
uvar_weighAM = TRUE;
uvar_weighNoise = TRUE;
uvar_blocksRngMed = BLOCKSRNGMED;
uvar_nfSizeCylinder = NFSIZE;
uvar_fStart = F0;
uvar_fSearchBand = FBAND;
uvar_peakThreshold = THRESHOLD;
uvar_maxBinsClean = 100;
uvar_startTime= 0;
uvar_endTime = LAL_INT4_MAX;
uvar_Alpha = 1.0;
uvar_Delta = 1.0;
uvar_Freq = 310.0;
uvar_fdot = 0.0;
uvar_AlphaWeight = uvar_Alpha;
uvar_DeltaWeight = uvar_Delta;
uvar_p = NBLOCKSTEST;
chi2Params.length=uvar_p;
chi2Params.numberSFTp=NULL;
chi2Params.sumWeight=NULL;
chi2Params.sumWeightSquare=NULL;
uvar_outfile = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR));
strcpy(uvar_outfile, "./tempout");
uvar_earthEphemeris = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR));
strcpy(uvar_earthEphemeris,EARTHEPHEMERIS);
uvar_sunEphemeris = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR));
strcpy(uvar_sunEphemeris,SUNEPHEMERIS);
uvar_sftDir = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR));
strcpy(uvar_sftDir,SFTDIRECTORY);
/* register user input variables */
LAL_CALL( LALRegisterBOOLUserVar( &status, "help", 'h', UVAR_HELP, "Print this message", &uvar_help), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "fStart", 'f', UVAR_OPTIONAL, "Start search frequency", &uvar_fStart), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "fSearchBand", 'b', UVAR_OPTIONAL, "Search frequency band", &uvar_fSearchBand), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "startTime", 0, UVAR_OPTIONAL, "GPS start time of observation", &uvar_startTime), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "endTime", 0, UVAR_OPTIONAL, "GPS end time of observation", &uvar_endTime), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "timeStampsFile", 0, UVAR_OPTIONAL, "Input time-stamps file", &uvar_timeStampsFile), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "peakThreshold", 0, UVAR_OPTIONAL, "Peak selection threshold", &uvar_peakThreshold), &status);
LAL_CALL( LALRegisterBOOLUserVar( &status, "weighAM", 0, UVAR_OPTIONAL, "Use amplitude modulation weights", &uvar_weighAM), &status);
LAL_CALL( LALRegisterBOOLUserVar( &status, "weighNoise", 0, UVAR_OPTIONAL, "Use SFT noise weights", &uvar_weighNoise), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "earthEphemeris", 'E', UVAR_OPTIONAL, "Earth Ephemeris file", &uvar_earthEphemeris), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sunEphemeris", 'S', UVAR_OPTIONAL, "Sun Ephemeris file", &uvar_sunEphemeris), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sftDir", 'D', UVAR_REQUIRED, "SFT filename pattern", &uvar_sftDir), &status);
LAL_CALL( LALRegisterLISTUserVar( &status, "linefiles", 0, UVAR_OPTIONAL, "Comma separated List of linefiles (filenames must contain IFO name)",
&uvar_linefiles), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "Alpha", 0, UVAR_OPTIONAL, "Sky location (longitude)", &uvar_Alpha), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "Delta", 0, UVAR_OPTIONAL, "Sky location (latitude)", &uvar_Delta), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "Freq", 0, UVAR_OPTIONAL, "Template frequency", &uvar_Freq), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "fdot", 0, UVAR_OPTIONAL, "First spindown", &uvar_fdot), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "AlphaWeight", 0, UVAR_OPTIONAL, "sky Alpha for weight calculation", &uvar_AlphaWeight), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "DeltaWeight", 0, UVAR_OPTIONAL, "sky Delta for weight calculation", &uvar_DeltaWeight), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "nfSizeCylinder", 0, UVAR_OPTIONAL, "Size of cylinder of PHMDs", &uvar_nfSizeCylinder), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "blocksRngMed", 0, UVAR_OPTIONAL, "Running Median block size", &uvar_blocksRngMed), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "maxBinsClean", 0, UVAR_OPTIONAL, "Maximum number of bins in cleaning", &uvar_maxBinsClean), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "outfile", 0, UVAR_OPTIONAL, "output file name", &uvar_outfile), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "pdatablock", 'p', UVAR_OPTIONAL, "Number of data blocks for veto tests", &uvar_p), &status);
/* read all command line variables */
LAL_CALL( LALUserVarReadAllInput(&status, argc, argv), &status);
/* exit if help was required */
if (uvar_help)
exit(0);
/* very basic consistency checks on user input */
if ( uvar_fStart < 0 ) {
fprintf(stderr, "start frequency must be positive\n");
exit(1);
}
if ( uvar_fSearchBand < 0 ) {
fprintf(stderr, "search frequency band must be positive\n");
exit(1);
}
if ( uvar_peakThreshold < 0 ) {
fprintf(stderr, "peak selection threshold must be positive\n");
exit(1);
}
/***** start main calculations *****/
chi2Params.length=uvar_p;
chi2Params.numberSFTp = (UINT4 *)LALMalloc( uvar_p*sizeof(UINT4));
chi2Params.sumWeight = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8));
chi2Params.sumWeightSquare = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8));
/* read sft Files and set up weights */
{
/* new SFT I/O data types */
SFTCatalog *catalog = NULL;
static SFTConstraints constraints;
REAL8 doppWings, f_min, f_max;
/* set detector constraint */
constraints.detector = NULL;
if ( LALUserVarWasSet( &uvar_startTime ) ) {
XLALGPSSetREAL8(&startTimeGPS, uvar_startTime);
constraints.minStartTime = &startTimeGPS;
}
if ( LALUserVarWasSet( &uvar_endTime ) ) {
XLALGPSSetREAL8(&endTimeGPS, uvar_endTime);
constraints.maxEndTime = &endTimeGPS;
}
if ( LALUserVarWasSet( &uvar_timeStampsFile ) ) {
LAL_CALL ( LALReadTimestampsFile ( &status, &inputTimeStampsVector, uvar_timeStampsFile), &status);
constraints.timestamps = inputTimeStampsVector;
}
/* get sft catalog */
LAL_CALL( LALSFTdataFind( &status, &catalog, uvar_sftDir, &constraints), &status);
if ( (catalog == NULL) || (catalog->length == 0) ) {
fprintf (stderr,"Unable to match any SFTs with pattern '%s'\n", uvar_sftDir );
exit(1);
}
/* now we can free the inputTimeStampsVector */
if ( LALUserVarWasSet( &uvar_timeStampsFile ) ) {
LALDestroyTimestampVector ( &status, &inputTimeStampsVector);
}
/* get some sft parameters */
mObsCoh = catalog->length; /* number of sfts */
deltaF = catalog->data->header.deltaF; /* frequency resolution */
timeBase= 1.0/deltaF; /* coherent integration time */
// unused: UINT8 f0Bin = floor( uvar_fStart * timeBase + 0.5); /* initial search frequency */
// unused: INT4 length = uvar_fSearchBand * timeBase; /* total number of search bins - 1 */
/* catalog is ordered in time so we can get start, end time and tObs*/
firstTimeStamp = catalog->data[0].header.epoch;
// unused: LIGOTimeGPS lastTimeStamp = catalog->data[mObsCoh - 1].header.epoch;
/* allocate memory for velocity vector */
velV.length = mObsCoh;
velV.data = NULL;
velV.data = (REAL8Cart3Coor *)LALCalloc(mObsCoh, sizeof(REAL8Cart3Coor));
/* allocate memory for timestamps vector */
timeV.length = mObsCoh;
timeV.data = NULL;
timeV.data = (LIGOTimeGPS *)LALCalloc( mObsCoh, sizeof(LIGOTimeGPS));
/* allocate memory for vector of time differences from start */
timeDiffV.length = mObsCoh;
timeDiffV.data = NULL;
timeDiffV.data = (REAL8 *)LALCalloc(mObsCoh, sizeof(REAL8));
/* add wings for Doppler modulation and running median block size*/
doppWings = (uvar_fStart + uvar_fSearchBand) * VTOT;
f_min = uvar_fStart - doppWings - (uvar_blocksRngMed + uvar_nfSizeCylinder) * deltaF;
f_max = uvar_fStart + uvar_fSearchBand + doppWings + (uvar_blocksRngMed + uvar_nfSizeCylinder) * deltaF;
/* read sft files making sure to add extra bins for running median */
/* read the sfts */
LAL_CALL( LALLoadMultiSFTs ( &status, &inputSFTs, catalog, f_min, f_max), &status);
/* clean sfts if required */
if ( LALUserVarWasSet( &uvar_linefiles ) )
{
RandomParams *randPar=NULL;
FILE *fpRand=NULL;
INT4 seed, ranCount;
if ( (fpRand = fopen("/dev/urandom", "r")) == NULL ) {
fprintf(stderr,"Error in opening /dev/urandom" );
exit(1);
}
if ( (ranCount = fread(&seed, sizeof(seed), 1, fpRand)) != 1 ) {
fprintf(stderr,"Error in getting random seed" );
exit(1);
}
LAL_CALL ( LALCreateRandomParams (&status, &randPar, seed), &status );
LAL_CALL( LALRemoveKnownLinesInMultiSFTVector ( &status, inputSFTs, uvar_maxBinsClean, uvar_blocksRngMed, uvar_linefiles, randPar), &status);
LAL_CALL ( LALDestroyRandomParams (&status, &randPar), &status);
fclose(fpRand);
} /* end cleaning */
/* SFT info -- assume all SFTs have same length */
numifo = inputSFTs->length;
binsSFT = inputSFTs->data[0]->data->data->length;
sftFminBin = (INT4) floor(inputSFTs->data[0]->data[0].f0 * timeBase + 0.5);
LAL_CALL( LALDestroySFTCatalog( &status, &catalog ), &status);
} /* end of sft reading block */
/* get detector velocities weights vector, and timestamps */
{
MultiNoiseWeights *multweight = NULL;
MultiPSDVector *multPSD = NULL;
UINT4 iIFO, iSFT, j;
/* get ephemeris */
edat = (EphemerisData *)LALCalloc(1, sizeof(EphemerisData));
(*edat).ephiles.earthEphemeris = uvar_earthEphemeris;
(*edat).ephiles.sunEphemeris = uvar_sunEphemeris;
LAL_CALL( LALInitBarycenter( &status, edat), &status);
/* normalize sfts */
LAL_CALL( LALNormalizeMultiSFTVect (&status, &multPSD, inputSFTs, uvar_blocksRngMed), &status);
/* set up weights */
weightsV.length = mObsCoh;
weightsV.data = (REAL8 *)LALCalloc(1, mObsCoh * sizeof(REAL8));
/* initialize all weights to unity */
LAL_CALL( LALHOUGHInitializeWeights( &status, &weightsV), &status);
/* compute multi noise weights if required */
if ( uvar_weighNoise ) {
LAL_CALL ( LALComputeMultiNoiseWeights ( &status, &multweight, multPSD, uvar_blocksRngMed, 0), &status);
}
/* we are now done with the psd */
LAL_CALL ( LALDestroyMultiPSDVector ( &status, &multPSD), &status);
/* get information about all detectors including velocity and timestamps */
/* note that this function returns the velocity at the
mid-time of the SFTs -- should not make any difference */
LAL_CALL ( LALGetMultiDetectorStates ( &status, &mdetStates, inputSFTs, edat), &status);
/* copy the timestamps, weights, and velocity vector */
for (j = 0, iIFO = 0; iIFO < numifo; iIFO++ ) {
numsft = mdetStates->data[iIFO]->length;
for ( iSFT = 0; iSFT < numsft; iSFT++, j++) {
velV.data[j].x = mdetStates->data[iIFO]->data[iSFT].vDetector[0];
velV.data[j].y = mdetStates->data[iIFO]->data[iSFT].vDetector[1];
velV.data[j].z = mdetStates->data[iIFO]->data[iSFT].vDetector[2];
if ( uvar_weighNoise )
weightsV.data[j] = multweight->data[iIFO]->data[iSFT];
/* mid time of sfts */
timeV.data[j] = mdetStates->data[iIFO]->data[iSFT].tGPS;
} /* loop over SFTs */
} /* loop over IFOs */
if ( uvar_weighNoise ) {
LAL_CALL( LALHOUGHNormalizeWeights( &status, &weightsV), &status);
}
/* compute the time difference relative to startTime for all SFTs */
for(j = 0; j < mObsCoh; j++)
timeDiffV.data[j] = XLALGPSDiff( timeV.data + j, &firstTimeStamp );
if ( uvar_weighNoise ) {
LAL_CALL ( LALDestroyMultiNoiseWeights ( &status, &multweight), &status);
}
} /* end block for noise weights, velocity and time */
/* calculate amplitude modulation weights if required */
if (uvar_weighAM)
{
MultiAMCoeffs *multiAMcoef = NULL;
UINT4 iIFO, iSFT;
SkyPosition skypos;
/* get the amplitude modulation coefficients */
skypos.longitude = uvar_AlphaWeight;
skypos.latitude = uvar_DeltaWeight;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
LAL_CALL ( LALGetMultiAMCoeffs ( &status, &multiAMcoef, mdetStates, skypos), &status);
/* loop over the weights and multiply them by the appropriate
AM coefficients */
for ( k = 0, iIFO = 0; iIFO < numifo; iIFO++) {
numsft = mdetStates->data[iIFO]->length;
for ( iSFT = 0; iSFT < numsft; iSFT++, k++) {
REAL8 a, b;
a = multiAMcoef->data[iIFO]->a->data[iSFT];
b = multiAMcoef->data[iIFO]->b->data[iSFT];
weightsV.data[k] *= (a*a + b*b);
} /* loop over SFTs */
} /* loop over IFOs */
LAL_CALL( LALHOUGHNormalizeWeights( &status, &weightsV), &status);
XLALDestroyMultiAMCoeffs ( multiAMcoef );
} /* end AM weights calculation */
/* misc. memory allocations */
/* memory for one spindown */
pulsarTemplate.spindown.length = 1;
pulsarTemplate.spindown.data = NULL;
pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(sizeof(REAL8));
/* copy template parameters */
pulsarTemplate.spindown.data[0] = uvar_fdot;
pulsarTemplate.f0 = uvar_Freq;
pulsarTemplate.latitude = uvar_Delta;
pulsarTemplate.longitude = uvar_Alpha;
/* memory for f(t) vector */
foft.length = mObsCoh;
foft.data = NULL;
foft.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8));
/* memory for peakgram */
pg1.length = binsSFT;
pg1.data = NULL;
pg1.data = (UCHAR *)LALCalloc( binsSFT, sizeof(UCHAR));
/* memory for number Count Vector */
numberCountV.length = uvar_p;
numberCountV.data = NULL;
numberCountV.data = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8));
/* block for calculating peakgram and number count */
{
UINT4 iIFO, iSFT, ii, numberSFTp;
INT4 ind;
REAL8 sumWeightSquare;
SFTtype *sft;
/* compute mean and sigma for noise only */
/* first calculate the sum of the weights squared */
sumWeightSquare = 0.0;
for ( k = 0; k < (INT4)mObsCoh; k++)
sumWeightSquare += weightsV.data[k] * weightsV.data[k];
/* probability of selecting a peak expected mean and standard deviation for noise only */
alphaPeak = exp( - uvar_peakThreshold);
meanN = mObsCoh* alphaPeak;
sigmaN = sqrt(sumWeightSquare * alphaPeak * (1.0 - alphaPeak));
/* the received frequency as a function of time */
LAL_CALL( ComputeFoft(&status, &foft, &pulsarTemplate, &timeDiffV, &velV, timeBase), &status);
LAL_CALL(SplitSFTs(&status, &weightsV, &chi2Params), &status);
/* loop over SFT, generate peakgram and get number count */
UINT4 j;
j=0;
iIFO=0;
iSFT=0;
numsft = mdetStates->data[iIFO]->length;
for (k=0 ; k<uvar_p ; k++ ){
numberSFTp=chi2Params.numberSFTp[k];
numberCount = 0;
for (ii=0 ; (ii < numberSFTp)&&(iIFO<numifo) ; ii++) {
sft = inputSFTs->data[iIFO]->data + iSFT;
LAL_CALL (SFTtoUCHARPeakGram( &status, &pg1, sft, uvar_peakThreshold), &status);
ind = floor( foft.data[j]*timeBase - sftFminBin + 0.5);
numberCount += pg1.data[ind]*weightsV.data[j];
j++;
iSFT++;
if (iSFT >= numsft){
iIFO++;
iSFT=0;
if (iIFO<numifo){
numsft = mdetStates->data[iIFO]->length;
}
}
} /* loop over SFTs */
numberCountV.data[k]=numberCount;
} /* loop over blocks */
}
/* Chi2 Test */
{
REAL8 eta; /* Auxiliar variable */
REAL8 nj, sumWeightj, sumWeightSquarej;
numberCountTotal=0;
chi2=0;
for(k=0; k<uvar_p ; k++){
numberCountTotal += numberCountV.data[k];
}
eta=numberCountTotal/mObsCoh;
INT4 j;
for(j=0 ; j<(uvar_p) ; j++){
nj=numberCountV.data[j];
sumWeightj=chi2Params.sumWeight[j];
sumWeightSquarej=chi2Params.sumWeightSquare[j];
chi2 += (nj-sumWeightj*eta)*(nj-sumWeightj*eta)/(sumWeightSquarej*eta*(1-eta));
}
}
fp = fopen(uvar_outfile , "w");
setvbuf(fp, (char *)NULL, _IOLBF, 0);
fprintf(fp, "%g %g %g %g %g %g %g %g \n", (numberCountTotal - meanN)/sigmaN, meanN ,sigmaN, chi2, uvar_Freq, uvar_Alpha, uvar_Delta, uvar_fdot);
/* fprintf(stdout, "%g %g %g %g %g %g %g %g \n", (numberCountTotal - meanN)/sigmaN, meanN ,sigmaN, chi2, uvar_Freq, uvar_Alpha, uvar_Delta, uvar_fdot);*/
fclose(fp);
/* free memory */
LALFree(pulsarTemplate.spindown.data);
LALFree(timeV.data);
LALFree(timeDiffV.data);
LALFree(foft.data);
LALFree(velV.data);
LALFree(weightsV.data);
XLALDestroyMultiDetectorStateSeries ( mdetStates );
LALFree(edat->ephemE);
LALFree(edat->ephemS);
LALFree(edat);
LAL_CALL (LALDestroyMultiSFTVector(&status, &inputSFTs), &status );
LALFree(pg1.data);
LALFree(numberCountV.data);
LALFree(chi2Params.numberSFTp);
LALFree(chi2Params.sumWeight);
LALFree(chi2Params.sumWeightSquare);
LAL_CALL (LALDestroyUserVars(&status), &status);
LALCheckMemoryLeaks();
if ( lalDebugLevel )
REPORTSTATUS ( &status);
return status.statusCode;
}
int main( void )
{
static LALStatus status;
static TrackSearchOut out;
static TimeFreqRep in;
static TrackSearchParams params;
INT4 i,j,cnt,maxVal;
FILE *fp;
unsigned char dummy;
char stringd[256];
char *str;
int rc;
/* set the parameters */
params.sigma=2; /* 2 */
params.high = 1; /* 3.0 */
params.low= 3; /* 1 */
params.low = params.high/3; /* ? */
/* open an input pgm file */
fp = fopen(TEST_DATA_DIR "a.pgm", "rb");
str = fgets(stringd,255,fp);
if (str == NULL)
{
fprintf(stderr, "Error: Unable to read input\n");
exit(1);
}
str = fgets(stringd,255,fp);
if (str == NULL)
{
fprintf(stderr, "Error: Unable to read input\n");
exit(1);
}
/* read the height and width of the image */
rc = fscanf(fp,"%d ",¶ms.height);
if (rc != 1)
{
fprintf(stderr, "Error: Unable to read input\n");
exit(1);
}
rc = fscanf(fp,"%d ",¶ms.width);
if (rc != 1)
{
fprintf(stderr, "Error: Unable to read input\n");
exit(1);
}
rc = fscanf(fp,"%d ",&maxVal);
if (rc != 1)
{
fprintf(stderr, "Error: Unable to read input\n");
exit(1);
}
/* Allocate space for the input array */
in.map=LALMalloc(params.height*sizeof(REAL4 *));
for(i=0;i<params.height;i++)
in.map[i] = LALMalloc(params.width*sizeof(REAL4));
/* Read the image */
for(j=0;j<params.width;j++){
for(i=0;i<params.height;i++){
rc = fscanf(fp,"%c",&dummy);
if (rc != 1)
{
fprintf(stderr, "Error: Unable to read input\n");
exit(1);
}
/* bright parts of the image should have higer values
hence the inversion */
*(in.map[i] + j) = maxVal - dummy;
}
}
/*
* Use information about image to setup TF Rep tCol and fRow
* values which must be
* fRow/2+1 == width
* tCol == height
*/
in.fRow=(params.width-1)*2;
in.tCol=params.height;
/* Added static function to write out in.map structure */
/* in is of type timefreqrep */
printf("MaxVal = %d \n",maxVal);
fclose(fp);
/* set the allocFlag so that space can be allocated */
params.allocFlag=1;
/* Search for curves */
LALSignalTrackSearch(&status, &out, &in, ¶ms);
REPORTSTATUS(&status);
/* Output the details of the curves found.*/
for(i=0;i<params.height;i++)
for(j=0;j<params.width;j++)
*(in.map[i] + j)=0;
printf("number of curves %d\n",out.numberOfCurves);
cnt=0;
for(i=0;i<out.numberOfCurves;i++){
if(out.curves[i].n>5){
cnt++;
printf(" curve number = %d, length = %d, power = %4.2e\n",cnt,out.curves[i].n,out.curves[i].totalPower);
for(j=0;j<out.curves[i].n;j++){
printf("%d %d %4.4e\n",out.curves[i].row[j],out.curves[i].col[j],out.curves[i].depth[j]);
*(in.map[out.curves[i].row[j]] + out.curves[i].col[j]) = cnt;
}
}
}
/* Free the space allocated for output structures */
for(i=0;i<out.numberOfCurves;i++){
LALFree(out.curves[i].row);
LALFree(out.curves[i].col);
LALFree(out.curves[i].depth); /*added*/
}
if(out.curves!=NULL)
LALFree(out.curves);
out.curves=NULL;
/* set params.allocFlag=2 and call the routine again to free space*/
params.allocFlag=2;
LALSignalTrackSearch(&status, &out, &in, ¶ms);
REPORTSTATUS(&status);
return(0);
}
int main(int argc, char *argv[]){
/* LALStatus pointer */
static LALStatus status;
/* time and velocity */
static LIGOTimeGPSVector timeV;
REAL8 timeBase;
LALDetector *det;
DetectorStateSeries *detStates=NULL;
/* ephemeris */
EphemerisData *edat=NULL;
/* user input variables */
BOOLEAN uvar_help;
CHAR *uvar_earthEphemeris=NULL;
CHAR *uvar_sunEphemeris=NULL;
CHAR *uvar_sftDir=NULL;
/* Set up the default parameters */
/* LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
uvar_help = FALSE;
uvar_earthEphemeris = (CHAR *)LALCalloc( 512 , sizeof(CHAR));
strcpy(uvar_earthEphemeris,EARTHEPHEMERIS);
uvar_sunEphemeris = (CHAR *)LALCalloc( 512 , sizeof(CHAR));
strcpy(uvar_sunEphemeris,SUNEPHEMERIS);
/* register user input variables */
LAL_CALL( LALRegisterBOOLUserVar( &status, "help", 'h', UVAR_HELP, "Print this message", &uvar_help), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "earthEphemeris", 'E', UVAR_REQUIRED, "Earth Ephemeris file", &uvar_earthEphemeris), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sunEphemeris", 'S', UVAR_REQUIRED, "Sun Ephemeris file", &uvar_sunEphemeris), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sftDir", 'D', UVAR_REQUIRED, "SFT filename pattern", &uvar_sftDir), &status);
/* read all command line variables */
LAL_CALL( LALUserVarReadAllInput(&status, argc, argv), &status);
/* exit if help was required */
if (uvar_help)
exit(0);
/* get ephemeris */
edat = (EphemerisData *)LALCalloc(1, sizeof(EphemerisData));
(*edat).ephiles.earthEphemeris = uvar_earthEphemeris;
(*edat).ephiles.sunEphemeris = uvar_sunEphemeris;
LAL_CALL( LALInitBarycenter( &status, edat), &status);
/* read sft Files and set up weights and nstar vector */
{
/* new SFT I/O data types */
SFTCatalog *catalog = NULL;
static SFTConstraints constraints;
UINT4 k;
/* set detector constraint */
constraints.detector = NULL;
/* get sft catalog */
LAL_CALL( LALSFTdataFind( &status, &catalog, uvar_sftDir, &constraints), &status);
if ( (catalog == NULL) || (catalog->length == 0) ) {
fprintf (stderr,"Unable to match any SFTs with pattern '%s'\n", uvar_sftDir );
exit(1);
}
for (k = 0; k < catalog->length; k++) {
det = XLALGetSiteInfo ( catalog->data[k].header.name);
timeBase = 1./catalog->data[k].header.deltaF;
timeV.length = 1;
timeV.deltaT = timeBase;
timeV.data = &(catalog->data[k].header.epoch);
LAL_CALL( LALGetDetectorStates ( &status, &detStates, &timeV, det, edat, 0.5*timeBase), &status);
fprintf(stdout, "%g %g %g\n", detStates->data[0].vDetector[0], detStates->data[0].vDetector[1],
detStates->data[0].vDetector[2]);
LALDestroyDetectorStateSeries (&status, &detStates );
LALFree (det);
} /* end loop over sfts */
LAL_CALL( LALDestroySFTCatalog( &status, &catalog ), &status);
} /* end of sft reading block */
LALFree(edat->ephemE);
LALFree(edat->ephemS);
LALFree(edat);
LAL_CALL (LALDestroyUserVars(&status), &status);
LALCheckMemoryLeaks();
if ( lalDebugLevel )
REPORTSTATUS ( &status);
return status.statusCode;
}