/** Read in input user arguments
*
*/
int XLALReadUserVars( int argc, /**< [in] the command line argument counter */
char *argv[], /**< [in] the command line arguments */
UserInput_t *uvar /**< [out] the user input structure */
)
{
/* initialise user variables */
uvar->outLabel = NULL;
uvar->outputdir = NULL;
uvar->cachefile = NULL;
uvar->binfile = NULL;
uvar->tempdir = NULL;
uvar->tsamp = 2048;
uvar->Tmin = 16;
uvar->Tmax = 256;
uvar->freq = 550;
uvar->freqband = 1;
uvar->highpassf = 40;
uvar->mismatch = 0.1;
uvar->thresh = 20;
uvar->blocksize = 100;
uvar->verbose = 0;
/* ---------- register all user-variables ---------- */
XLALRegisterUvarMember( outLabel, STRING, 'n', REQUIRED, "'misc' entry in SFT-filenames or 'description' entry of frame filenames" );
XLALRegisterUvarMember( outputdir, STRING, 'o', REQUIRED, "The output directory name" );
XLALRegisterUvarMember( binfile, STRING, 'i', REQUIRED, "The input binary file name" );
XLALRegisterUvarMember( cachefile, STRING, 'e', REQUIRED, "The input cache file name" );
XLALRegisterUvarMember( tempdir, STRING, 'x', OPTIONAL, "The temporary directory" );
XLALRegisterUvarMember( freq, REAL8, 'f', REQUIRED, "The starting frequency (Hz)" );
XLALRegisterUvarMember( freqband, REAL8, 'b', REQUIRED, "The frequency band (Hz)" );
XLALRegisterUvarMember( Tmin, INT4, 't', OPTIONAL, "The min length of segemnts (sec)" );
XLALRegisterUvarMember( Tmax, INT4, 'T', OPTIONAL, "The max length of segments (sec)" );
XLALRegisterUvarMember( tsamp, REAL8, 's', REQUIRED, "The sampling time (sec)" );
XLALRegisterUvarMember( highpassf, REAL8, 'H', OPTIONAL, "The high pass filter frequency" );
XLALRegisterUvarMember( minorbperiod, REAL8, 'p', REQUIRED, "The minimum orbital period (sec)" );
XLALRegisterUvarMember( maxorbperiod, REAL8, 'P', REQUIRED, "The maximum orbital period (sec)" );
XLALRegisterUvarMember( minasini, REAL8, 'a', REQUIRED, "The minimum projected orbital radius (sec)" );
XLALRegisterUvarMember( maxasini, REAL8, 'A', REQUIRED, "The maximum projected orbital radius (sec)" );
XLALRegisterUvarMember( tasc, REAL8, 'c', REQUIRED, "The best guess orbital time of ascension (rads)" );
XLALRegisterUvarMember( deltaorbphase, REAL8, 'C', OPTIONAL, "The orbital phase uncertainty (cycles)" );
XLALRegisterUvarMember( mismatch, REAL8, 'm', OPTIONAL, "The grid mismatch (0->1)" );
XLALRegisterUvarMember( thresh, REAL8, 'z', OPTIONAL, "The threshold on Leahy power" );
XLALRegisterUvarMember( blocksize, INT4, 'B', OPTIONAL, "The running median block size" );
XLALRegisterUvarMember( verbose, BOOLEAN, 'v', OPTIONAL, "Output status to standard out" );
/* do ALL cmdline and cfgfile handling */
BOOLEAN should_exit = 0;
if ( XLALUserVarReadAllInput( &should_exit, argc, argv, lalAppsVCSInfoList ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALUserVarReadAllInput failed with error = %d\n", __func__, xlalErrno );
return XLAL_EFAULT;
}
if ( should_exit ) {
exit( 1 );
}
LogPrintf( LOG_DEBUG, "%s : leaving.\n", __func__ );
return XLAL_SUCCESS;
}
/*---------- function definitions ---------- */
int main(int argc,char *argv[])
{
LALStatus status = blank_status; /* initialize status */
vrbflg = 1; /* verbose error-messages */
/* set LAL error-handler */
lal_errhandler = LAL_ERR_EXIT; /* exit with returned status-code on error */
/* register all user-variables */
LAL_CALL (InitUserVars(&status, &CommandLineArgs), &status);
/* read cmdline & cfgfile */
BOOLEAN should_exit = 0;
XLAL_CHECK_MAIN (XLALUserVarReadAllInput(&should_exit, argc, argv, lalAppsVCSInfoList) == XLAL_SUCCESS, XLAL_EFUNC);
if (should_exit)
return EXIT_FAILURE;
LAL_CALL ( CheckUserInput (&status, &CommandLineArgs), &status);
LAL_CALL ( Initialize (&status, &CommandLineArgs), &status);
/*---------- central function: compute F-statistic ---------- */
LAL_CALL ( ComputeF(&status, CommandLineArgs), &status);
/* Free remaining memory */
LAL_CALL ( LALSDestroyVector(&status, &(amc.a) ), &status);
LAL_CALL ( LALSDestroyVector(&status, &(amc.b) ), &status);
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return 0;
} /* main() */
INT4 InitUserVars(UserVariables_t *uvar, int argc, char *argv[])
{
XLAL_CHECK ( uvar != NULL, XLAL_EINVAL, "Invalid NULL input 'uvar'\n");
XLAL_CHECK ( argv != NULL, XLAL_EINVAL, "Invalid NULL input 'argv'\n");
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->outfilename = XLALStringDuplicate("output.dat");
uvar->Tsft = 1800;
uvar->SFToverlap = 900;
uvar->skylocations = 1;
XLALregBOOLUserStruct( help, 'h', UVAR_HELP , "Print this help/usage message");
XLALregREALUserStruct( Tsft, 0 , UVAR_OPTIONAL , "SFT coherence time");
XLALregREALUserStruct( SFToverlap, 0 , UVAR_OPTIONAL , "SFT overlap in seconds, usually Tsft/2");
XLALregREALUserStruct( t0, 0 , UVAR_OPTIONAL , "GPS start time of the search");
XLALregREALUserStruct( Tobs, 0 , UVAR_OPTIONAL , "Duration of the search (in seconds)");
XLALregREALUserStruct( cosi, 0 , UVAR_OPTIONAL , "Cosine of NS inclinaiont angle");
XLALregREALUserStruct( psi, 0 , UVAR_OPTIONAL , "Polarization angle of GW");
XLALregREALUserStruct( alpha, 0 , UVAR_OPTIONAL , "Right ascension of source (in radians)");
XLALregREALUserStruct( delta, 0 , UVAR_OPTIONAL , "Declination of source (in radians)");
XLALregINTUserStruct( skylocations, 0 , UVAR_OPTIONAL , "Number of sky locations");
XLALregLISTUserStruct( IFO, 0 , UVAR_REQUIRED , "CSV list of detectors, eg. \"H1,H2,L1,G1, ...\" ");
XLALregSTRINGUserStruct(outfilename, 0 , UVAR_OPTIONAL , "Output filename");
XLALregSTRINGUserStruct(ephemEarth, 0 , UVAR_OPTIONAL , "Earth ephemeris file");
XLALregSTRINGUserStruct(ephemSun, 0 , UVAR_OPTIONAL , "Sun ephemeris file");
XLAL_CHECK( XLALUserVarReadAllInput(argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
if ( uvar->help ) exit (0);
return XLAL_SUCCESS;
}
INT4 InitUserVars2(UserVariables_t *uvar, int argc, char *argv[])
{
XLAL_CHECK ( uvar != NULL, XLAL_EINVAL, "Invalid NULL input 'uvar'\n");
XLAL_CHECK ( argv != NULL, XLAL_EINVAL, "Invalid NULL input 'argv'\n");
uvar->Tsft = 1800;
uvar->SFToverlap = 900;
XLALRegisterUvarMember( help, BOOLEAN, 'h', HELP , "Print this help/usage message");
XLALRegisterUvarMember( Pmin, REAL8, 0 , REQUIRED, "Minimum period");
XLALRegisterUvarMember( Pmax, REAL8, 0 , REQUIRED, "Maximum period");
XLALRegisterUvarMember( dfmin, REAL8, 0 , REQUIRED, "Minimum modulation depth");
XLALRegisterUvarMember( dfmax, REAL8, 0 , REQUIRED, "Maximum modulation depth");
XLALRegisterUvarMember( Tsft, REAL8, 0 , OPTIONAL, "SFT coherence length");
XLALRegisterUvarMember( SFToverlap, REAL8, 0 , OPTIONAL, "SFT overlap in second");
XLALRegisterUvarMember( Tobs, REAL8, 0 , REQUIRED, "Total observation time");
XLALRegisterUvarMember( minTemplateLength, INT4, 0 , REQUIRED, "Minimum number of pixels in templates");
XLALRegisterUvarMember( maxTemplateLength, INT4, 0 , REQUIRED, "Maximum number of pixels in tempaltes");
XLALRegisterUvarMember( maxVectorLength, INT4, 0 , REQUIRED, "Maximum vector length");
XLALRegisterUvarMember( vectorMath, INT4, 0 , OPTIONAL, "Vector math flag: 0 = no SSE/AVX, 1 = SSE, 2 = AVX");
XLALRegisterUvarMember( exactflag, BOOLEAN, 0 , OPTIONAL, "Flag to specify using exact templates");
XLALRegisterUvarMember(filename, STRING, 0 , OPTIONAL, "Filename of output file (if not specified, the vector is destroyed upon exit)");
XLAL_CHECK( XLALUserVarReadAllInput(argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
if ( uvar->help ) exit (0);
return XLAL_SUCCESS;
}
/** \deprecated use XLALUserVarReadAllInput() instead */
void
LALUserVarReadAllInput (LALStatus *status, int argc, char *argv[])
{
INITSTATUS(status);
if ( XLALUserVarReadAllInput ( argc, argv ) != XLAL_SUCCESS ) {
XLALPrintError ( "XLALUserVarReadAllInput() failed with code %d\n", xlalErrno );
ABORT ( status, USERINPUTH_EXLAL, USERINPUTH_MSGEXLAL );
}
RETURN (status);
} // LALReadUserInput()
/** Read in input user arguments
*
*/
int XLALReadUserVars(int argc, /**< [in] the command line argument counter */
char *argv[], /**< [in] the command line arguments */
UserInput_t *uvar /**< [out] the user input structure */
)
{
/* initialise user variables */
uvar->outLabel = NULL;
uvar->outputdir = NULL;
uvar->cachefile = NULL;
uvar->tsamp = 1.0/8192;
uvar->tsft = 100;
uvar->freq = 550;
uvar->freqband = 1;
uvar->highpassf = 40;
uvar->outSingleSFT = 0;
uvar->amp_inj = 0;
uvar->f_inj = 550.2;
uvar->asini_inj = 2.0;
uvar->tasc_inj = 800000000;
uvar->P_inj = 68212;
uvar->phi_inj = 1.0;
uvar->seed = 0;
/* ---------- register all user-variables ---------- */
XLALRegisterUvarMember(outLabel, STRING, 'n', REQUIRED, "'misc' entry in SFT-filenames or 'description' entry of frame filenames");
XLALRegisterUvarMember(outputdir, STRING, 'o', REQUIRED, "The output directory name");
XLALRegisterUvarMember(cachefile, STRING, 'i', REQUIRED, "The input binary file name");
XLALRegisterUvarMember(freq, REAL8, 'f', OPTIONAL, "The starting frequency (Hz)");
XLALRegisterUvarMember(freqband, REAL8, 'b', OPTIONAL, "The frequency band (Hz)");
XLALRegisterUvarMember(tsft, INT4, 't', OPTIONAL, "The length of SFTs (sec)");
XLALRegisterUvarMember(tsamp, REAL8, 's', OPTIONAL, "The sampling time (sec)");
XLALRegisterUvarMember(highpassf, REAL8, 'p', OPTIONAL, "The high pass filter frequency");
XLALRegisterUvarMember(outSingleSFT, BOOLEAN, 'S', OPTIONAL, "Write a single concatenated SFT file instead of individual files" );
XLALRegisterUvarMember(amp_inj, REAL8, 'I', OPTIONAL, "Fractional amplitude of injected signal");
XLALRegisterUvarMember(f_inj, REAL8, 'A', OPTIONAL, "frequency of injected signal");
XLALRegisterUvarMember(asini_inj, REAL8, 'B', OPTIONAL, "projected semi-major axis of injected signal");
XLALRegisterUvarMember(tasc_inj, REAL8, 'C', OPTIONAL, "time of ascension of injected signal");
XLALRegisterUvarMember(P_inj, REAL8, 'D', OPTIONAL, "orbital period of injected signal");
XLALRegisterUvarMember(phi_inj, REAL8, 'E', OPTIONAL, "initial phase of injected signal");
XLALRegisterUvarMember(seed, INT4, 'r', OPTIONAL, "The random seed");
/* do ALL cmdline and cfgfile handling */
BOOLEAN should_exit = 0;
if (XLALUserVarReadAllInput(&should_exit, argc, argv)) {
LogPrintf(LOG_CRITICAL,"%s : XLALUserVarReadAllInput failed with error = %d\n",__func__,xlalErrno);
return XLAL_EFAULT;
}
if (should_exit) exit(1);
LogPrintf(LOG_DEBUG,"%s : leaving.\n",__func__);
return XLAL_SUCCESS;
}
/** register all "user-variables" */
int
initUserVars ( int argc, char *argv[], UserVariables_t *uvar )
{
XLAL_CHECK ( argc > 0 && (argv != NULL) && (uvar != NULL), XLAL_EINVAL );
/* set a few defaults */
uvar->RAJ = NULL;
uvar->DECJ = NULL;
uvar->TstartUTCMJD = 53400;
uvar->TrefTDBMJD = 53400;
uvar->DeltaTMJD = 1;
uvar->DurationMJD = 1800;
uvar->f0 = 1.0;
uvar->fdot = 0.0;
uvar->PSRJ = XLALStringDuplicate ( "TEMPOcomparison" );
uvar->Observatory = XLALStringDuplicate ( "JODRELL" );
uvar->randSeed = 1;
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
/* register user input variables */
XLALRegisterUvarMember( RAJ, STRING, 'r', OPTIONAL, "Right ascension hh:mm.ss.ssss [Default=random]");
XLALRegisterUvarMember( DECJ, STRING, 'j', OPTIONAL, "Declination deg:mm.ss.ssss [Default=random]");
XLALRegisterUvarMember( ephemEarth, STRING, 0, OPTIONAL, "Earth ephemeris file to use");
XLALRegisterUvarMember( ephemSun, STRING, 0, OPTIONAL, "Sun ephemeris file to use");
XLALRegisterUvarMember( f0, REAL8, 'f', OPTIONAL, "The signal frequency in Hz at SSB at the reference time");
XLALRegisterUvarMember( fdot, REAL8, 'p', OPTIONAL, "The signal frequency derivitive in Hz at SSB at the reference time");
XLALRegisterUvarMember( TrefTDBMJD, REAL8, 'R', OPTIONAL, "Reference time at the SSB in TDB in MJD");
XLALRegisterUvarMember( TstartUTCMJD, REAL8, 'T', OPTIONAL, "Start time of output TOAs in UTC");
XLALRegisterUvarMember( DeltaTMJD, REAL8, 't', OPTIONAL, "Time inbetween TOAs (in days)");
XLALRegisterUvarMember( DurationMJD, REAL8, 'D', OPTIONAL, "Full duration of TOAs (in days)");
XLALRegisterUvarMember( PSRJ, STRING, 'n', OPTIONAL, "Name of pulsar");
XLALRegisterUvarMember( Observatory, STRING, 'O', OPTIONAL, "TEMPO observatory name (GBT,ARECIBO,NARRABRI,NANSHAN,DSS_43,PARKES,JODRELL,VLA,NANCAY,COE,SSB)");
XLALRegisterUvarMember( randSeed, INT4, 0, OPTIONAL, "The random seed [0 = clock]");
/* read all command line variables */
BOOLEAN should_exit = 0;
XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv, lalPulsarVCSInfoList ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( should_exit ) {
exit(1);
}
return XLAL_SUCCESS;
} /* initUserVars() */
/** register all "user-variables" */
int
initUserVars ( int argc, char *argv[], UserVariables_t *uvar )
{
XLAL_CHECK ( argc > 0 && (argv != NULL) && (uvar != NULL), XLAL_EINVAL );
/* set a few defaults */
uvar->help = FALSE;
uvar->RAJ = NULL;
uvar->DECJ = NULL;
uvar->TstartUTCMJD = 53400;
uvar->TrefTDBMJD = 53400;
uvar->DeltaTMJD = 1;
uvar->DurationMJD = 1800;
uvar->f0 = 1.0;
uvar->fdot = 0.0;
uvar->PSRJ = XLALStringDuplicate ( "TEMPOcomparison" );
uvar->Observatory = XLALStringDuplicate ( "JODRELL" );
uvar->randSeed = 1;
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
/* register user input variables */
XLALregBOOLUserStruct ( help, 'h', UVAR_HELP, "Print this message" );
XLALregSTRINGUserStruct ( RAJ, 'r', UVAR_OPTIONAL, "Right ascension hh:mm.ss.ssss [Default=random]");
XLALregSTRINGUserStruct ( DECJ, 'j', UVAR_OPTIONAL, "Declination deg:mm.ss.ssss [Default=random]");
XLALregSTRINGUserStruct ( ephemEarth, 0, UVAR_OPTIONAL, "Earth ephemeris file to use");
XLALregSTRINGUserStruct ( ephemSun, 0, UVAR_OPTIONAL, "Sun ephemeris file to use");
XLALregREALUserStruct ( f0, 'f', UVAR_OPTIONAL, "The signal frequency in Hz at SSB at the reference time");
XLALregREALUserStruct ( fdot, 'p', UVAR_OPTIONAL, "The signal frequency derivitive in Hz at SSB at the reference time");
XLALregREALUserStruct ( TrefTDBMJD, 'R', UVAR_OPTIONAL, "Reference time at the SSB in TDB in MJD");
XLALregREALUserStruct ( TstartUTCMJD, 'T', UVAR_OPTIONAL, "Start time of output TOAs in UTC");
XLALregREALUserStruct ( DeltaTMJD, 't', UVAR_OPTIONAL, "Time inbetween TOAs (in days)");
XLALregREALUserStruct ( DurationMJD, 'D', UVAR_OPTIONAL, "Full duration of TOAs (in days)");
XLALregSTRINGUserStruct ( PSRJ, 'n', UVAR_OPTIONAL, "Name of pulsar");
XLALregSTRINGUserStruct ( Observatory, 'O', UVAR_OPTIONAL, "TEMPO observatory name (GBT,ARECIBO,NARRABRI,NANSHAN,DSS_43,PARKES,JODRELL,VLA,NANCAY,COE,SSB)");
XLALregINTUserStruct ( randSeed, 0, UVAR_OPTIONAL, "The random seed [0 = clock]");
/* read all command line variables */
XLAL_CHECK ( XLALUserVarReadAllInput( argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
return XLAL_SUCCESS;
} /* initUserVars() */
int
XLALReadUserInput ( int argc, char *argv[], UserVariables_t *uvar )
{
XLALRegisterUvarMember( help, BOOLEAN, 'h', HELP, "Print this help/usage message");
XLALRegisterUvarMember( SFTfiles, STRING, 'i', REQUIRED, "File-pattern for input SFTs");
XLALRegisterUvarMember( headerOnly, BOOLEAN, 'H', OPTIONAL, "Output only header-info");
XLALRegisterUvarMember( noHeader, BOOLEAN, 'n', OPTIONAL, "Output only data, no header");
/* read cmdline & cfgfile */
XLAL_CHECK ( XLALUserVarReadAllInput ( argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar->help) { /* help requested: we're done */
exit (0);
}
XLAL_CHECK ( !(uvar->headerOnly && uvar->noHeader), XLAL_EINVAL, "Contradictory input --headerOnly --noHeader\n" );
return XLAL_SUCCESS;
}
INT4 InitUserVars(UserVariables_t *uvar, int argc, char *argv[])
{
XLAL_CHECK ( uvar != NULL, XLAL_EINVAL, "Invalid NULL input 'uvar'\n");
XLAL_CHECK ( argv != NULL, XLAL_EINVAL, "Invalid NULL input 'argv'\n");
uvar->ephemEarth = XLALStringDuplicate("earth00-40-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-40-DE405.dat.gz");
uvar->outfilename = XLALStringDuplicate("output.dat");
uvar->Tsft = 1800;
uvar->SFToverlap = 900;
uvar->skylocations = 1;
uvar->unrestrictedCosi = 0;
uvar->rectWindow = 0;
XLALRegisterUvarMember( Tsft, REAL8, 0 , OPTIONAL , "SFT coherence time");
XLALRegisterUvarMember( SFToverlap, REAL8, 0 , OPTIONAL , "SFT overlap in seconds, usually Tsft/2");
XLALRegisterUvarMember( t0, REAL8, 0 , OPTIONAL , "GPS start time of the search");
XLALRegisterUvarMember( Tobs, REAL8, 0 , OPTIONAL , "Duration of the search (in seconds)");
XLALRegisterUvarMember( cosi, REAL8, 0 , OPTIONAL , "Cosine of NS inclinaiont angle");
XLALRegisterUvarMember( psi, REAL8, 0 , OPTIONAL , "Polarization angle of GW");
XLALRegisterUvarMember( alpha, REAL8, 0 , OPTIONAL , "Right ascension of source (in radians)");
XLALRegisterUvarMember( delta, REAL8, 0 , OPTIONAL , "Declination of source (in radians)");
XLALRegisterUvarMember( skylocations, INT4, 0 , OPTIONAL , "Number of sky locations");
XLALRegisterUvarMember( IFO, STRINGVector, 0 , REQUIRED , "CSV list of detectors, eg. \"H1,H2,L1,G1, ...\" ");
XLALRegisterUvarMember(outfilename, STRING, 0 , OPTIONAL , "Output filename");
XLALRegisterUvarMember(ephemEarth, STRING, 0 , OPTIONAL , "Earth ephemeris file");
XLALRegisterUvarMember(ephemSun, STRING, 0 , OPTIONAL , "Sun ephemeris file");
XLALRegisterUvarMember( unrestrictedCosi, BOOLEAN, 0 , OPTIONAL , "Marginalize over cos(iota) from -1 to 1");
XLALRegisterUvarMember( rectWindow, BOOLEAN, 0 , OPTIONAL , "Use rectangular window function instead of Hann windowing");
BOOLEAN should_exit = 0;
XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv, lalAppsVCSInfoList ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( should_exit ) exit (1);
return XLAL_SUCCESS;
}
INT4 InitUserVars(UserVariables_t *uvar, int argc, char *argv[])
{
XLAL_CHECK ( uvar != NULL, XLAL_EINVAL, "Invalid NULL input 'uvar'\n");
XLAL_CHECK ( argv != NULL, XLAL_EINVAL, "Invalid NULL input 'argv'\n");
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->outfilename = XLALStringDuplicate("skygrid.dat");
uvar->skyRegion = XLALStringDuplicate("allsky");
uvar->Tsft = 1800;
uvar->SFToverlap = 900;
uvar->fspan = 0.25;
XLALRegisterUvarMember( help, BOOLEAN, 'h', HELP , "Print this help/usage message");
XLALRegisterUvarMember( Tsft, REAL8, 0 , OPTIONAL , "SFT coherence time");
XLALRegisterUvarMember( SFToverlap, REAL8, 0 , OPTIONAL , "SFT overlap in seconds, usually Tsft/2");
XLALRegisterUvarMember( t0, REAL8, 0 , OPTIONAL , "GPS start time of the search; not needed if --v1 is specified");
XLALRegisterUvarMember( Tobs, REAL8, 0 , OPTIONAL , "Duration of the search (in seconds); not needed if --v1 is specified");
XLALRegisterUvarMember( fmin, REAL8, 0 , OPTIONAL , "Minimum frequency of band");
XLALRegisterUvarMember( fspan, REAL8, 0 , OPTIONAL , "Frequency span of band");
XLALRegisterUvarMember(IFO, STRING, 0 , REQUIRED , "Interferometer whose data is being analyzed");
XLALRegisterUvarMember(outfilename, STRING, 0 , OPTIONAL , "Output filename");
XLALRegisterUvarMember(ephemEarth, STRING, 0 , OPTIONAL , "Earth ephemeris file");
XLALRegisterUvarMember(ephemSun, STRING, 0 , OPTIONAL , "Sun ephemeris file");
XLALRegisterUvarMember(skyRegion, STRING, 0 , OPTIONAL , "Region of the sky to search (e.g. (ra1,dec1),(ra2,dec2),(ra3,dec3)...) or allsky");
XLALRegisterUvarMember( v1, BOOLEAN, 0 , DEVELOPER, "Flag to use older style of CompDetectorVmax (for S6/VSR2-3 analysis)");
XLAL_CHECK( XLALUserVarReadAllInput(argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
if ( uvar->help ) exit (0);
if (!uvar->v1 && !XLALUserVarWasSet(&uvar->t0)) XLAL_ERROR( XLAL_EINVAL, "Must set t0" );
if (!uvar->v1 && !XLALUserVarWasSet(&uvar->Tobs)) XLAL_ERROR( XLAL_EINVAL, "Must set Tobs" );
return XLAL_SUCCESS;
}
/** Read in input user arguments
*
*/
int XLALReadUserVars(int argc, /**< [in] the command line argument counter */
char *argv[], /**< [in] the command line arguments */
UserInput_t *uvar, /**< [out] the user input structure */
CHAR **clargs /**< [out] the command line args string */
)
{
CHAR *version_string;
INT4 i;
/* initialise user variables */
uvar->sftbasename = NULL;
uvar->comment = NULL;
uvar->gpsstart = -1;
uvar->gpsend = -1;
uvar->mismatch = 0.2;
uvar->ntoplist = 10;
uvar->coverage = -1;
uvar->blocksize = 100;
uvar->tsft = 256;
uvar->seed = 1;
uvar->tempdir = NULL;
/* initialise all parameter space ranges to zero */
uvar->freqband = 0;
uvar->minorbperiod = 0.0;
uvar->maxorbperiod = 0.0;
uvar->minasini = 0.0;
uvar->maxasini = 0.0;
uvar->tasc = -1.0;
uvar->deltaorbphase = 2.0*LAL_PI;
/* ---------- register all user-variables ---------- */
XLALRegisterUvarMember(sftbasename, STRING, 'i', REQUIRED, "The basename of the input SFT files");
XLALRegisterUvarMember(outputdir, STRING, 'o', REQUIRED, "The output directory name");
XLALRegisterUvarMember(comment, STRING, 'C', REQUIRED, "An analysis descriptor string");
XLALRegisterUvarMember(tempdir, STRING, 'z', OPTIONAL, "A temporary directory");
XLALRegisterUvarMember(freq, REAL8, 'f', REQUIRED, "The starting frequency (Hz)");
XLALRegisterUvarMember(freqband, REAL8, 'b', OPTIONAL, "The frequency band (Hz)");
XLALRegisterUvarMember(minorbperiod, REAL8, 'p', REQUIRED, "The minimum orbital period value (sec)");
XLALRegisterUvarMember(maxorbperiod, REAL8, 'P', OPTIONAL, "The maximum orbital period value (sec)");
XLALRegisterUvarMember(minasini, REAL8, 'a', REQUIRED, "The minimum orbital semi-major axis (sec)");
XLALRegisterUvarMember(maxasini, REAL8, 'A', OPTIONAL, "The maximum orbital semi-major axis (sec)");
XLALRegisterUvarMember(tasc, REAL8, 't', REQUIRED, "The best guess orbital time of ascension (rads)");
XLALRegisterUvarMember(deltaorbphase, REAL8, 'T', OPTIONAL, "The orbital phase uncertainty (cycles)");
XLALRegisterUvarMember(mismatch, REAL8, 'm', OPTIONAL, "The grid mismatch (0->1)");
XLALRegisterUvarMember(coverage, REAL8, 'c', OPTIONAL, "The random template coverage (0->1)");
XLALRegisterUvarMember(blocksize, INT4, 'r', OPTIONAL, "The running median block size");
XLALRegisterUvarMember(tsft, INT4, 'S', OPTIONAL, "The length of the input SFTs in seconds");
XLALRegisterUvarMember(ntoplist, INT4, 'x', OPTIONAL, "output the top N results");
XLALRegisterUvarMember(seed, INT4, 'X', OPTIONAL, "The random number seed (0 = clock)");
XLALRegisterUvarMember(gpsstart, INT4, 's', OPTIONAL, "The minimum start time (GPS sec)");
XLALRegisterUvarMember(gpsend, INT4, 'e', OPTIONAL, "The maximum end time (GPS sec)");
XLALRegisterUvarMember(version, BOOLEAN, 'V', SPECIAL, "Output code version");
/* do ALL cmdline and cfgfile handling */
BOOLEAN should_exit = 0;
if (XLALUserVarReadAllInput(&should_exit, argc, argv)) {
LogPrintf(LOG_CRITICAL,"%s : XLALUserVarReadAllInput failed with error = %d\n",__func__,xlalErrno);
return XLAL_EFAULT;
}
if (should_exit) exit(1);
if ((version_string = XLALGetVersionString(0)) == NULL) {
XLALPrintError("XLALGetVersionString(0) failed.\n");
exit(1);
}
if (uvar->version) {
printf("%s\n",version_string);
exit(0);
}
XLALFree(version_string);
/* put clargs into string */
*clargs = XLALCalloc(1,sizeof(CHAR));
for (i=0;i<argc;i++) {
INT4 len = 2 + strlen(argv[i]) + strlen(*clargs);
*clargs = XLALRealloc(*clargs,len*sizeof(CHAR));
strcat(*clargs,argv[i]);
strcat(*clargs," ");
}
LogPrintf(LOG_DEBUG,"%s : leaving.\n",__func__);
return XLAL_SUCCESS;
}
/** register all "user-variables" */
int
initUserVars (int argc, char *argv[], UserVariables_t *uvar)
{
/* set a few defaults */
uvar->maxBinsClean = 100;
uvar->blocksRngMed = 101;
uvar->startTime = 0.0;
uvar->endTime = 0.0;
uvar->inputData = NULL;
uvar->IFO = NULL;
/* default: read all SFT bins */
uvar->fStart = -1;
uvar->fBand = 0;
uvar->outputPSD = NULL;
uvar->outputNormSFT = FALSE;
uvar->outFreqBinEnd = FALSE;
uvar->PSDmthopSFTs = MATH_OP_HARMONIC_MEAN;
uvar->PSDmthopIFOs = MATH_OP_HARMONIC_SUM;
uvar->nSFTmthopSFTs = MATH_OP_ARITHMETIC_MEAN;
uvar->nSFTmthopIFOs = MATH_OP_MAXIMUM;
uvar->dumpMultiPSDVector = FALSE;
uvar->binSizeHz = 0.0;
uvar->binSize = 1;
uvar->PSDmthopBins = MATH_OP_ARITHMETIC_MEDIAN;
uvar->nSFTmthopBins = MATH_OP_MAXIMUM;
uvar->binStep = 0.0;
uvar->binStep = 1;
/* register user input variables */
XLALRegisterUvarMember(inputData, STRING, 'i', REQUIRED, "Input SFT pattern");
XLALRegisterUvarMember(outputPSD, STRING, 'o', OPTIONAL, "Output PSD into this file");
XLALRegisterUvarMember(outputQ, STRING, 0, OPTIONAL, "Output the 'data-quality factor' Q(f) into this file");
XLALRegisterUvarMember(outputSpectBname, STRING, 0 , OPTIONAL, "Filename-base for (binary) spectrograms (one per IFO)");
XLALRegisterUvarMember(Freq, REAL8, 0, OPTIONAL, "physical start frequency to compute PSD for (excluding rngmed wings)");
XLALRegisterUvarMember(FreqBand, REAL8, 0, OPTIONAL, "physical frequency band to compute PSD for (excluding rngmed wings)");
XLALRegisterUvarMember(startTime, REAL8, 's', OPTIONAL, "GPS timestamp of earliest SFT to include");
XLALRegisterUvarMember(endTime, REAL8, 'e', OPTIONAL, "GPS timestamp of last SFT to include (NOTE: this refers to the SFT start-time!)");
XLALRegisterUvarMember(timeStampsFile, STRING, 't', OPTIONAL, "Time-stamps file");
XLALRegisterUvarMember(IFO, STRING, 0 , OPTIONAL, "Detector filter");
XLALRegisterUvarMember(blocksRngMed, INT4, 'w', OPTIONAL, "Running Median window size");
XLALRegisterUvarMember(PSDmthopSFTs, INT4, 'S', OPTIONAL, "For PSD, type of math. operation over SFTs: "
"0=arith-sum, 1=arith-mean, 2=arith-median, "
"3=harm-sum, 4=harm-mean, "
"5=power-2-sum, 6=power-2-mean, "
"7=min, 8=max");
XLALRegisterUvarMember(PSDmthopIFOs, INT4, 'I', OPTIONAL, "For PSD, type of math. op. over IFOs: "
"see --PSDmthopSFTs");
XLALRegisterUvarMember(outputNormSFT, BOOLEAN, 'n', OPTIONAL, "Output normalised SFT power to PSD file");
XLALRegisterUvarMember(nSFTmthopSFTs, INT4, 'N', OPTIONAL, "For norm. SFT, type of math. op. over SFTs: "
"see --PSDmthopSFTs");
XLALRegisterUvarMember(nSFTmthopIFOs, INT4, 'J', OPTIONAL, "For norm. SFT, type of math. op. over IFOs: "
"see --PSDmthopSFTs");
XLALRegisterUvarMember(binSize, INT4, 'z', OPTIONAL, "Bin the output into bins of size (in number of bins)");
XLALRegisterUvarMember(binSizeHz, REAL8, 'Z', OPTIONAL, "Bin the output into bins of size (in Hz)");
XLALRegisterUvarMember(PSDmthopBins, INT4, 'A', OPTIONAL, "If binning, for PSD type of math. op. over bins: "
"see --PSDmthopSFTs");
XLALRegisterUvarMember(nSFTmthopBins, INT4, 'B', OPTIONAL, "If binning, for norm. SFT type of math. op. over bins: "
"see --PSDmthopSFTs");
XLALRegisterUvarMember(binStep, INT4, 'p', OPTIONAL, "If binning, step size to move bin along "
"(in number of bins, default is bin size)");
XLALRegisterUvarMember(binStepHz, REAL8, 'P', OPTIONAL, "If binning, step size to move bin along "
"(in Hz, default is bin size)");
XLALRegisterUvarMember(outFreqBinEnd, BOOLEAN, 'E', OPTIONAL, "Output the end frequency of each bin");
XLALRegisterUvarMember(maxBinsClean, INT4, 'm', OPTIONAL, "Maximum Cleaning Bins");
XLALRegisterUvarMember(linefiles, STRINGVector, 0 , OPTIONAL, "Comma separated list of linefiles "
"(names must contain IFO name)");
XLALRegisterUvarMember(dumpMultiPSDVector,BOOLEAN, 'd',OPTIONAL, "Output multi-PSD vector over IFOs, timestamps, and frequencies into file(s) '<outputPSD>-IFO'");
/* ----- developer options ---------- */
XLALRegisterUvarMember(fStart, REAL8, 'f', DEVELOPER, "Start Frequency to load from SFT and compute PSD, including rngmed wings (BETTER: use --Freq instead)");
XLALRegisterUvarMember(fBand, REAL8, 'b', DEVELOPER, "Frequency Band to load from SFT and compute PSD, including rngmed wings (BETTER: use --FreqBand instead)");
/* read all command line variables */
BOOLEAN should_exit = 0;
XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv, lalAppsVCSInfoList ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( should_exit ) {
exit(1);
}
/* check user-input consistency */
if (XLALUserVarWasSet(&(uvar->PSDmthopSFTs)) && !(0 <= uvar->PSDmthopSFTs && uvar->PSDmthopSFTs < MATH_OP_LAST)) {
XLALPrintError("ERROR: --PSDmthopSFTs(-S) must be between 0 and %i", MATH_OP_LAST - 1);
return XLAL_FAILURE;
}
if (XLALUserVarWasSet(&(uvar->PSDmthopIFOs)) && !(0 <= uvar->PSDmthopIFOs && uvar->PSDmthopIFOs < MATH_OP_LAST)) {
XLALPrintError("ERROR: --PSDmthopIFOs(-I) must be between 0 and %i", MATH_OP_LAST - 1);
return XLAL_FAILURE;
}
if (XLALUserVarWasSet(&(uvar->nSFTmthopSFTs)) && !(0 <= uvar->nSFTmthopSFTs && uvar->nSFTmthopSFTs < MATH_OP_LAST)) {
XLALPrintError("ERROR: --nSFTmthopSFTs(-N) must be between 0 and %i", MATH_OP_LAST - 1);
return XLAL_FAILURE;
}
if (XLALUserVarWasSet(&(uvar->nSFTmthopIFOs)) && !(0 <= uvar->nSFTmthopIFOs && uvar->nSFTmthopIFOs < MATH_OP_LAST)) {
XLALPrintError("ERROR: --nSFTmthopIFOs(-J) must be between 0 and %i", MATH_OP_LAST - 1);
return XLAL_FAILURE;
}
if (XLALUserVarWasSet(&(uvar->PSDmthopBins)) && !(0 <= uvar->PSDmthopBins && uvar->PSDmthopBins < MATH_OP_LAST)) {
XLALPrintError("ERROR: --PSDmthopBins(-A) must be between 0 and %i", MATH_OP_LAST - 1);
return XLAL_FAILURE;
}
if (XLALUserVarWasSet(&(uvar->nSFTmthopBins)) && !(0 <= uvar->nSFTmthopBins && uvar->nSFTmthopBins < MATH_OP_LAST)) {
XLALPrintError("ERROR: --nSFTmthopBins(-B) must be between 0 and %i", MATH_OP_LAST - 1);
return XLAL_FAILURE;
}
if (XLALUserVarWasSet(&(uvar->binSize)) && XLALUserVarWasSet(&(uvar->binSizeHz))) {
XLALPrintError("ERROR: --binSize(-z) and --binSizeHz(-Z) are mutually exclusive");
return XLAL_FAILURE;
}
if (XLALUserVarWasSet(&(uvar->binSize)) && uvar->binSize <= 0) {
XLALPrintError("ERROR: --binSize(-z) must be strictly positive");
return XLAL_FAILURE;
}
if (XLALUserVarWasSet(&(uvar->binSizeHz)) && uvar->binSizeHz <= 0.0) {
XLALPrintError("ERROR: --binSizeHz(-Z) must be strictly positive");
return XLAL_FAILURE;
}
if (XLALUserVarWasSet(&(uvar->binStep)) && XLALUserVarWasSet(&(uvar->binStepHz))) {
XLALPrintError("ERROR: --binStep(-p) and --binStepHz(-P) are mutually exclusive");
return XLAL_FAILURE;
}
if (XLALUserVarWasSet(&(uvar->binStep)) && uvar->binStep <= 0) {
XLALPrintError("ERROR: --binStep(-p) must be strictly positive");
return XLAL_FAILURE;
}
if (XLALUserVarWasSet(&(uvar->binStepHz)) && uvar->binStepHz <= 0.0) {
XLALPrintError("ERROR: --binStepHz(-P) must be strictly positive");
return XLAL_FAILURE;
}
return XLAL_SUCCESS;
} /* initUserVars() */
int
main(int argc, char *argv[])
{
ConfigVariables XLAL_INIT_DECL(config);
UserVariables_t XLAL_INIT_DECL(uvar);
DopplerMetricParams XLAL_INIT_DECL(metricParams);
vrbflg = 1; /* verbose error-messages */
/* set LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
/* register user-variables */
if ( initUserVars(&uvar) != XLAL_SUCCESS ) {
XLALPrintError( "%s(): initUserVars() failed\n", __func__ );
return EXIT_FAILURE;
}
/* read cmdline & cfgfile */
if ( XLALUserVarReadAllInput(argc,argv) != XLAL_SUCCESS ) {
XLALPrintError( "%s(): XLALUserVarReadAllInput() failed\n", __func__ );
return EXIT_FAILURE;
}
if (uvar.help) /* help requested: we're done */
return 0;
CHAR *VCSInfoString;
if ( (VCSInfoString = XLALGetVersionString(0)) == NULL ) {
XLALPrintError("XLALGetVersionString(0) failed.\n");
exit(1);
}
if ( uvar.version ) {
printf ( "%s\n", VCSInfoString );
return 0;
}
if ( uvar.coordsHelp )
{
CHAR *helpstr;
if ( (helpstr = XLALDopplerCoordinateHelpAll()) == NULL )
{
LogPrintf ( LOG_CRITICAL, "XLALDopplerCoordinateHelpAll() failed!\n\n");
return -1;
}
printf ( "\n%s\n", helpstr );
XLALFree ( helpstr );
return 0;
} /* if coordsHelp */
/* basic setup and initializations */
XLAL_CHECK ( XLALInitCode( &config, &uvar, argv[0] ) == XLAL_SUCCESS, XLAL_EFUNC, "XLALInitCode() failed with xlalErrno = %d\n\n", xlalErrno );
config.history->VCSInfoString = VCSInfoString;
/* parse detector motion string */
int detMotionType = XLALParseDetectorMotionString( uvar.detMotionStr );
XLAL_CHECK ( detMotionType != XLAL_FAILURE, XLAL_EFUNC, "Failed to pass detector motion string '%s'", uvar.detMotionStr );
metricParams.detMotionType = detMotionType;
metricParams.segmentList = config.segmentList;
metricParams.coordSys = config.coordSys;
metricParams.multiIFO = config.multiIFO;
metricParams.multiNoiseFloor = config.multiNoiseFloor;
metricParams.signalParams = config.signalParams;
metricParams.projectCoord = uvar.projection - 1; /* user-input counts from 1, but interally we count 0=1st coord. (-1==no projection) */
metricParams.approxPhase = uvar.approxPhase;
/* ----- compute metric full metric + Fisher matrix ---------- */
DopplerPhaseMetric *Pmetric = NULL;
if ( uvar.metricType == 0 || uvar.metricType == 2 ) {
if ( (Pmetric = XLALComputeDopplerPhaseMetric ( &metricParams, config.edat )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Something failed in XLALComputeDopplerPhaseMetric(). xlalErrno = %d\n\n", xlalErrno);
return -1;
}
}
DopplerFstatMetric *Fmetric = NULL;
if ( uvar.metricType == 1 || uvar.metricType == 2 ) {
if ( (Fmetric = XLALComputeDopplerFstatMetric ( &metricParams, config.edat )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Something failed in XLALComputeDopplerFstatMetric(). xlalErrno = %d\n\n", xlalErrno);
return -1;
}
}
/* ---------- output results ---------- */
if ( uvar.outputMetric )
{
FILE *fpMetric;
if ( (fpMetric = fopen ( uvar.outputMetric, "wb" )) == NULL ) {
LogPrintf (LOG_CRITICAL, "%s: failed to open '%s' for writing. error = '%s'\n",
__func__, uvar.outputMetric, strerror(errno));
return FSTATMETRIC_EFILE;
}
if ( XLALOutputDopplerMetric ( fpMetric, Pmetric, Fmetric, config.history ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "%s: failed to write Doppler metric into output-file '%s'. xlalErrno = %d\n\n",
__func__, uvar.outputMetric, xlalErrno );
return FSTATMETRIC_EFILE;
}
fclose ( fpMetric );
} /* if outputMetric */
/* ----- done: free all memory */
XLALDestroyDopplerPhaseMetric ( Pmetric );
XLALDestroyDopplerFstatMetric ( Fmetric );
if ( XLALDestroyConfig( &config ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "%s: XLADestroyConfig() failed, xlalErrno = %d.\n\n", __func__, xlalErrno );
return FSTATMETRIC_EXLAL;
}
LALCheckMemoryLeaks();
return 0;
} /* main */
/**
* some basic consistency checks of the (XLAL) UserInput module, far from exhaustive,
* but should be enough to catch big obvious malfunctions
*/
int
main(void)
{
int i, my_argc = 8;
char **my_argv;
const char *argv_in[] = { "progname", "--argNum=1", "--argStr=xyz", "--argBool=true", "-a", "1", "-b", "@" TEST_DATA_DIR "ConfigFileSample.cfg" };
UserInput_t XLAL_INIT_DECL(my_uvars);
my_argv = XLALCalloc ( my_argc, sizeof(char*) );
for (i=0; i < my_argc; i ++ )
{
my_argv[i] = XLALCalloc ( 1, strlen(argv_in[i])+1);
strcpy ( my_argv[i], argv_in[i] );
}
/* ---------- Register all test user-variables ---------- */
UserInput_t *uvar = &my_uvars;
uvar->string2 = XLALStringDuplicate ( "this is the default value");
XLAL_CHECK ( XLALRegisterUvarMember( argNum, REAL8, 0, REQUIRED, "Testing float argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argStr, STRING, 0, REQUIRED, "Testing string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argBool, BOOLEAN, 0, REQUIRED, "Testing bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argInt, INT4, 'a', REQUIRED, "Testing INT4 argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( dummy, INT4, 'c', OPTIONAL, "Testing INT4 argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argB2, BOOLEAN, 'b', REQUIRED, "Testing short-option bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( string2, STRING, 0, REQUIRED, "Testing another string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( epochGPS, EPOCH, 0, REQUIRED, "Testing epoch given as GPS time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( epochMJDTT, EPOCH, 0, REQUIRED, "Testing epoch given as MJD(TT) time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( longHMS, RAJ, 0, REQUIRED, "Testing RAJ(HMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( longRad, RAJ, 0, REQUIRED, "Testing RAJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( latDMS, DECJ, 0, REQUIRED, "Testing DECJ(DMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( latRad, DECJ, 0, REQUIRED, "Testing DECJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( longInt, INT8, 0, REQUIRED, "Testing INT8 argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( long_help, BOOLEAN, 0, NODEFAULT,
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"\n"
"This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces.~"
"This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces.~"
"This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces."
) == XLAL_SUCCESS, XLAL_EFUNC );
/* ---------- now read all input from commandline and config-file ---------- */
BOOLEAN should_exit = 0;
XLAL_CHECK ( XLALUserVarReadAllInput ( &should_exit, my_argc, my_argv ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( should_exit == 0, XLAL_EFUNC );
/* ---------- test print usage and help page */
printf( "=== Begin usage string ===\n" );
fflush( stdout );
XLALUserVarPrintUsage( stdout );
printf( "--- End usage string ---\n" );
printf( "=== Begin help page ===\n" );
fflush( stdout );
XLALUserVarPrintHelp( stdout );
printf( "--- End help page ---\n" );
fflush( stdout );
/* ---------- test log-generation */
CHAR *logstr;
XLAL_CHECK ( ( logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE )) != NULL, XLAL_EFUNC );
XLALFree ( logstr );
/* ---------- test values were read in correctly ---------- */
XLAL_CHECK ( uvar->argNum == 1, XLAL_EFAILED, "Failed to read in argNum\n" );
XLAL_CHECK ( strcmp ( uvar->argStr, "xyz" ) == 0, XLAL_EFAILED, "Failed to read in argStr\n" );
XLAL_CHECK ( uvar->argBool, XLAL_EFAILED, "Failed to read in argBool\n" );
XLAL_CHECK ( uvar->argInt == 1, XLAL_EFAILED, "Failed to read in argInt\n" );
XLAL_CHECK ( uvar->argB2, XLAL_EFAILED, "Failed to read in argB2\n" );
XLAL_CHECK ( strcmp ( uvar->string2, "this is also possible, and # here does nothing; and neither does semi-colon " ) == 0, XLAL_EFAILED, "Failed to read in string2\n" );
char buf1[256], buf2[256];
XLAL_CHECK ( XLALGPSCmp ( &uvar->epochGPS, &uvar->epochMJDTT ) == 0, XLAL_EFAILED, "GPS epoch %s differs from MJD(TT) epoch %s\n",
XLALGPSToStr ( buf1, &uvar->epochGPS), XLALGPSToStr ( buf2, &uvar->epochMJDTT ) );
REAL8 diff, tol = 3e-15;
XLAL_CHECK ( (diff = fabs(uvar->longHMS - uvar->longRad)) < tol, XLAL_EFAILED, "longitude(HMS) = %.16g differs from longitude(rad) = %.16g by %g > %g\n", uvar->longHMS, uvar->longRad, diff, tol );
XLAL_CHECK ( (diff = fabs(uvar->latDMS - uvar->latRad)) < tol, XLAL_EFAILED, "latitude(HMS) = %.16g differs from latitude(rad) = %.16g by %g > %g\n", uvar->latDMS, uvar->latRad, diff, tol );
XLAL_CHECK ( uvar->longInt == 4294967294, XLAL_EFAILED, "Failed to read an INT8: longInt = %" LAL_INT8_FORMAT " != 4294967294", uvar->longInt );
/* ----- cleanup ---------- */
XLALDestroyUserVars();
for (i=0; i < my_argc; i ++ ) {
XLALFree ( my_argv[i] );
}
XLALFree ( my_argv );
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
int
main(int argc, char *argv[])
{
ConfigVariables config = empty_ConfigVariables;
UserVariables_t uvar = empty_UserVariables;
/* register user-variables */
XLAL_CHECK ( XLALInitUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
/* read cmdline & cfgfile */
XLAL_CHECK ( XLALUserVarReadAllInput ( argc,argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar.help) { /* help requested: we're done */
exit(0);
}
if ( uvar.version )
{
XLALOutputVersionString ( stdout, lalDebugLevel );
exit(0);
}
/* basic setup and initializations */
XLAL_CHECK ( XLALInitCode( &config, &uvar, argv[0] ) == XLAL_SUCCESS, XLAL_EFUNC );
/* prepare output files */
FILE *fpOutab = NULL;
if ( uvar.outab ) {
XLAL_CHECK ( (fpOutab = fopen (uvar.outab, "wb")) != NULL, XLAL_EIO, "Error opening file '%s' for writing...", uvar.outab );
/* write header info in comments */
XLAL_CHECK ( XLAL_SUCCESS == XLALOutputVersionString ( fpOutab, 0 ), XLAL_EFUNC );
/* write the command-line */
for (int a = 0; a < argc; a++)
{
fprintf(fpOutab,"%%%% argv[%d]: '%s'\n", a, argv[a]);
}
/* write column headings */
fprintf(fpOutab, "%%%% columns:\n%%%% Alpha Delta tGPS ");
if ( config.numDetectors == 1 ) {
fprintf(fpOutab, " a(t) b(t)");
}
else {
for ( UINT4 X=0; X < config.numDetectors; X++ ) {
fprintf(fpOutab, " a[%d](t) b[%d](t)", X, X);
}
}
fprintf(fpOutab, "\n");
}
FILE *fpOutABCD = NULL;
if ( uvar.outABCD ) {
XLAL_CHECK ( (fpOutABCD = fopen (uvar.outABCD, "wb")) != NULL, XLAL_EIO, "Error opening file '%s' for writing...", uvar.outABCD );
/* write header info in comments */
XLAL_CHECK ( XLAL_SUCCESS == XLALOutputVersionString ( fpOutABCD, 0 ), XLAL_EFUNC );
/* write the command-line */
for (int a = 0; a < argc; a++)
{
fprintf(fpOutABCD,"%%%% argv[%d]: '%s'\n", a, argv[a]);
}
/* write column headings */
fprintf(fpOutABCD, "%%%% columns:\n%%%% Alpha Delta");
fprintf(fpOutABCD, " A B C D");
if ( config.numDetectors > 1 ) {
fprintf(fpOutABCD, " ");
for ( UINT4 X=0; X < config.numDetectors; X++ ) {
fprintf(fpOutABCD, " A[%d] B[%d] C[%d] D[%d]", X, X, X, X);
}
}
fprintf(fpOutABCD, "\n");
}
/* loop over sky positions (outer loop, could allow for buffering if necessary) */
for (UINT4 n = 0; n < config.numSkyPoints; n++) {
SkyPosition skypos;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
skypos.longitude = config.Alpha->data[n];
skypos.latitude = config.Delta->data[n];
/* do the actual computation of the antenna pattern functions */
MultiAMCoeffs *multiAM;
XLAL_CHECK ( ( multiAM = XLALComputeMultiAMCoeffs ( config.multiDetStates, config.multiNoiseWeights, skypos ) ) != NULL, XLAL_EFUNC, "XLALComputeAMCoeffs() failed." );
/* for multi-IFO run with weights, do it again, without weights, to get single-IFO quantities consistent with single-IFO runs
* FIXME: remove this temporary hack when MultiAmCoeffs have been changed to include non-weighted single-IFO quantities
*/
MultiAMCoeffs *multiAMforSingle = NULL;
MultiAMCoeffs *multiAMunweighted = NULL;
if ( ( config.numDetectors > 1 ) && ( config.multiNoiseWeights != NULL ) ) {
XLAL_CHECK ( ( multiAMunweighted = XLALComputeMultiAMCoeffs ( config.multiDetStates, NULL, skypos ) ) != NULL, XLAL_EFUNC, "XLALComputeAMCoeffs() failed." );
multiAMforSingle = multiAMunweighted;
}
else {
multiAMforSingle = multiAM;
}
/* write out the data for this sky point */
if ( uvar.outab ) { // output a(t), b(t) at each timestamp
for (UINT4 t = 0; t < config.numTimeStamps; t++) { // FIXME: does not work for different multi-IFO numTimeStampsX
fprintf (fpOutab, "%.7f %.7f %d", config.Alpha->data[n], config.Delta->data[n], config.multiTimestamps->data[0]->data[t].gpsSeconds );
for ( UINT4 X=0; X < config.numDetectors; X++ ) {
fprintf(fpOutab, " %12.8f %12.8f", multiAMforSingle->data[X]->a->data[t], multiAMforSingle->data[X]->b->data[t]);
} // for ( UINT4 X=0; X < config.numDetectors; X++ )
fprintf(fpOutab, "\n");
} // for (UINT4 t = 0; t < config.numTimeStamps; t++)
} // if ( uvar.outab )
if ( uvar.outABCD ) { // output ABCD averaged over all timestamps
// FIXME: stop doing average manually when AMCoeffs is changed to contain averaged values
REAL8 A = multiAM->Mmunu.Ad/config.numTimeStamps;
REAL8 B = multiAM->Mmunu.Bd/config.numTimeStamps;
REAL8 C = multiAM->Mmunu.Cd/config.numTimeStamps;
REAL8 D = A*B-SQ(C);
fprintf (fpOutABCD, "%.7f %.7f %12.8f %12.8f %12.8f %12.8f", config.Alpha->data[n], config.Delta->data[n], A, B, C, D );
if ( config.numDetectors > 1 ) {
for ( UINT4 X=0; X < config.numDetectors; X++ ) {
REAL4 AX = multiAMforSingle->data[X]->A/config.numTimeStampsX->data[X];
REAL4 BX = multiAMforSingle->data[X]->B/config.numTimeStampsX->data[X];
REAL4 CX = multiAMforSingle->data[X]->C/config.numTimeStampsX->data[X];
REAL4 DX = AX*BX-SQ(CX);
fprintf(fpOutABCD, " %12.8f %12.8f %12.8f %12.8f", AX, BX, CX, DX);
}
}
fprintf(fpOutABCD, "\n");
} // if ( uvar.outABCD )
XLALDestroyMultiAMCoeffs ( multiAM );
if ( multiAMunweighted ) {
XLALDestroyMultiAMCoeffs ( multiAMunweighted );
}
} // for (UINT4 n = 0; n < config.numSkyPoints; n++)
/* ----- close output files ----- */
if ( fpOutab ) {
fprintf (fpOutab, "\n");
fclose ( fpOutab );
}
if ( fpOutABCD ) {
fprintf (fpOutABCD, "\n");
fclose ( fpOutABCD );
}
/* ----- done: free all memory */
XLAL_CHECK ( XLALDestroyConfig( &config ) == XLAL_SUCCESS, XLAL_EFUNC );
LALCheckMemoryLeaks();
return 0;
} /* main */
int main(int argc, char *argv[]){
static LALStatus status;
static LALDetector *detector;
static LIGOTimeGPSVector timeV;
static REAL8Cart3CoorVector velV;
static REAL8Vector timeDiffV;
static REAL8 foft;
static HoughPulsarTemplate pulsarTemplate;
EphemerisData *edat = NULL;
CHAR *uvar_earthEphemeris = NULL;
CHAR *uvar_sunEphemeris = NULL;
SFTVector *inputSFTs = NULL;
REAL8 *alphaVec=NULL;
REAL8 *deltaVec=NULL;
REAL8 *freqVec=NULL;
REAL8 *spndnVec=NULL;
/* pgV is vector of peakgrams and pg1 is onepeakgram */
static UCHARPeakGram *pg1, **pgV;
UINT4 msp; /*number of spin-down parameters */
CHAR *uvar_ifo = NULL;
CHAR *uvar_sftDir = NULL; /* the directory where the SFT could be */
CHAR *uvar_fnameOut = NULL; /* The output prefix filename */
CHAR *uvar_fnameIn = NULL;
INT4 numberCount, ind;
UINT8 nTemplates;
UINT4 mObsCoh;
REAL8 uvar_peakThreshold;
REAL8 f_min, f_max, fWings, timeBase;
INT4 uvar_blocksRngMed;
UINT4 sftlength;
INT4 sftFminBin;
UINT4 loopId, tempLoopId;
FILE *fpOut = NULL;
CHAR *fnameLog=NULL;
FILE *fpLog = NULL;
CHAR *logstr=NULL;
/*REAL8 asq, bsq;*/ /* square of amplitude modulation functions a and b */
/******************************************************************/
/* Set up the default parameters. */
/* ****************************************************************/
/* LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
msp = 1; /*only one spin-down */
/* memory allocation for spindown */
pulsarTemplate.spindown.length = msp;
pulsarTemplate.spindown.data = NULL;
pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(msp*sizeof(REAL8));
uvar_peakThreshold = THRESHOLD;
uvar_earthEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_earthEphemeris,EARTHEPHEMERIS);
uvar_sunEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_sunEphemeris,SUNEPHEMERIS);
uvar_sftDir = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_sftDir,SFTDIRECTORY);
uvar_fnameOut = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_fnameOut,VALIDATEOUT);
uvar_fnameIn = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_fnameIn,VALIDATEIN);
uvar_blocksRngMed = BLOCKSRNGMED;
/* register user input variables */
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_ifo, "ifo", STRING, 'i', OPTIONAL, "Detector GEO(1) LLO(2) LHO(3)" ) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_earthEphemeris, "earthEphemeris", STRING, 'E', OPTIONAL, "Earth Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sunEphemeris, "sunEphemeris", STRING, 'S', OPTIONAL, "Sun Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sftDir, "sftDir", STRING, 'D', OPTIONAL, "SFT Directory") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameIn, "fnameIn", STRING, 'T', OPTIONAL, "Input template file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameOut, "fnameOut", STRING, 'o', OPTIONAL, "Output filename") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_blocksRngMed, "blocksRngMed", INT4, 'w', OPTIONAL, "RngMed block size") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_peakThreshold, "peakThreshold", REAL8, 't', OPTIONAL, "Peak selection threshold") == XLAL_SUCCESS, XLAL_EFUNC);
/* read all command line variables */
BOOLEAN should_exit = 0;
XLAL_CHECK_MAIN( XLALUserVarReadAllInput(&should_exit, argc, argv, lalAppsVCSInfoList) == XLAL_SUCCESS, XLAL_EFUNC);
if (should_exit)
exit(1);
/* open log file for writing */
fnameLog = LALCalloc( (strlen(uvar_fnameOut) + strlen(".log") + 10),1);
strcpy(fnameLog,uvar_fnameOut);
strcat(fnameLog,".log");
if ((fpLog = fopen(fnameLog, "w")) == NULL) {
fprintf(stderr, "Unable to open file %s for writing\n", fnameLog);
LALFree(fnameLog);
exit(1);
}
/* get the log string */
XLAL_CHECK_MAIN( ( logstr = XLALUserVarGetLog(UVAR_LOGFMT_CFGFILE) ) != NULL, XLAL_EFUNC);
fprintf( fpLog, "## Log file for HoughValidate\n\n");
fprintf( fpLog, "# User Input:\n");
fprintf( fpLog, "#-------------------------------------------\n");
fprintf( fpLog, "%s", logstr);
LALFree(logstr);
/* append an ident-string defining the exact CVS-version of the code used */
{
CHAR command[1024] = "";
fprintf (fpLog, "\n\n# CVS-versions of executable:\n");
fprintf (fpLog, "# -----------------------------------------\n");
fclose (fpLog);
sprintf (command, "ident %s | sort -u >> %s", argv[0], fnameLog);
/* we don't check this. If it fails, we assume that */
/* one of the system-commands was not available, and */
/* therefore the CVS-versions will not be logged */
if ( system(command) ) fprintf (stderr, "\nsystem('%s') returned non-zero status!\n\n", command );
LALFree(fnameLog);
}
/* open output file for writing */
fpOut= fopen(uvar_fnameOut, "w");
/*setlinebuf(fpOut);*/ /* line buffered on */
setvbuf(fpOut, (char *)NULL, _IOLBF, 0);
/*****************************************************************/
/* read template file */
/*****************************************************************/
{
FILE *fpIn = NULL;
INT4 r;
REAL8 temp1, temp2, temp3, temp4, temp5;
UINT8 templateCounter;
fpIn = fopen(uvar_fnameIn, "r");
if ( !fpIn )
{
fprintf(stderr, "Unable to fine file %s\n", uvar_fnameIn);
return DRIVEHOUGHCOLOR_EFILE;
}
nTemplates = 0;
do
{
r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, &temp2, &temp3, &temp4, &temp5);
/* make sure the line has the right number of entries or is EOF */
if (r==5) nTemplates++;
} while ( r != EOF);
rewind(fpIn);
alphaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
deltaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
freqVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
spndnVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
for (templateCounter = 0; templateCounter < nTemplates; templateCounter++)
{
r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, alphaVec + templateCounter, deltaVec + templateCounter,
freqVec + templateCounter, spndnVec + templateCounter);
}
fclose(fpIn);
}
/**************************************************/
/* read sfts */
/*************************************************/
f_min = freqVec[0]; /* initial frequency to be analyzed */
/* assume that the last frequency in the templates file is also the highest frequency */
f_max = freqVec[nTemplates-1] ;
/* we need to add wings to fmin and fmax to account for
the Doppler shift, the size of the rngmed block size
and also nfsizecylinder. The block size and nfsizecylinder are
specified in terms of frequency bins...this goes as one of the arguments of
LALReadSFTfiles */
/* first correct for Doppler shift */
fWings = f_max * VTOT;
f_min -= fWings;
f_max += fWings;
/* create pattern to look for in SFT directory */
{
CHAR *tempDir = NULL;
SFTCatalog *catalog = NULL;
static SFTConstraints constraints;
/* set detector constraint */
constraints.detector = NULL;
if ( XLALUserVarWasSet( &uvar_ifo ) )
constraints.detector = XLALGetChannelPrefix ( uvar_ifo );
/* get sft catalog */
tempDir = (CHAR *)LALCalloc(512, sizeof(CHAR));
strcpy(tempDir, uvar_sftDir);
strcat(tempDir, "/*SFT*.*");
XLAL_CHECK_MAIN( ( catalog = XLALSFTdataFind( tempDir, &constraints) ) != NULL, XLAL_EFUNC);
detector = XLALGetSiteInfo( catalog->data[0].header.name);
mObsCoh = catalog->length;
timeBase = 1.0 / catalog->data->header.deltaF;
XLAL_CHECK_MAIN( ( inputSFTs = XLALLoadSFTs ( catalog, f_min, f_max) ) != NULL, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALNormalizeSFTVect( inputSFTs, uvar_blocksRngMed, 0.0 ) == XLAL_SUCCESS, XLAL_EFUNC);
if ( XLALUserVarWasSet( &uvar_ifo ) )
LALFree( constraints.detector );
LALFree( tempDir);
XLALDestroySFTCatalog(catalog );
}
sftlength = inputSFTs->data->data->length;
{
INT4 tempFbin;
sftFminBin = floor( (REAL4)(timeBase * inputSFTs->data->f0) + (REAL4)(0.5));
tempFbin = floor( timeBase * inputSFTs->data->f0 + 0.5);
if (tempFbin - sftFminBin)
{
fprintf(stderr, "Rounding error in calculating fminbin....be careful! \n");
}
}
/* loop over sfts and select peaks */
/* first the memory allocation for the peakgramvector */
pgV = NULL;
pgV = (UCHARPeakGram **)LALMalloc(mObsCoh*sizeof(UCHARPeakGram *));
/* memory for peakgrams */
for (tempLoopId=0; tempLoopId < mObsCoh; tempLoopId++)
{
pgV[tempLoopId] = (UCHARPeakGram *)LALMalloc(sizeof(UCHARPeakGram));
pgV[tempLoopId]->length = sftlength;
pgV[tempLoopId]->data = NULL;
pgV[tempLoopId]->data = (UCHAR *)LALMalloc(sftlength* sizeof(UCHAR));
LAL_CALL (SFTtoUCHARPeakGram( &status, pgV[tempLoopId], inputSFTs->data + tempLoopId, uvar_peakThreshold), &status);
}
/* having calculated the peakgrams we don't need the sfts anymore */
XLALDestroySFTVector( inputSFTs);
/* ****************************************************************/
/* setting timestamps vector */
/* ****************************************************************/
timeV.length = mObsCoh;
timeV.data = NULL;
timeV.data = (LIGOTimeGPS *)LALMalloc(mObsCoh*sizeof(LIGOTimeGPS));
{
UINT4 j;
for (j=0; j < mObsCoh; j++){
timeV.data[j].gpsSeconds = pgV[j]->epoch.gpsSeconds;
timeV.data[j].gpsNanoSeconds = pgV[j]->epoch.gpsNanoSeconds;
}
}
/******************************************************************/
/* compute the time difference relative to startTime for all SFTs */
/******************************************************************/
timeDiffV.length = mObsCoh;
timeDiffV.data = NULL;
timeDiffV.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8));
{
REAL8 t0, ts, tn, midTimeBase;
UINT4 j;
midTimeBase=0.5*timeBase;
ts = timeV.data[0].gpsSeconds;
tn = timeV.data[0].gpsNanoSeconds * 1.00E-9;
t0=ts+tn;
timeDiffV.data[0] = midTimeBase;
for (j=1; j< mObsCoh; ++j){
ts = timeV.data[j].gpsSeconds;
tn = timeV.data[j].gpsNanoSeconds * 1.00E-9;
timeDiffV.data[j] = ts + tn -t0 + midTimeBase;
}
}
/******************************************************************/
/* compute detector velocity for those time stamps */
/******************************************************************/
velV.length = mObsCoh;
velV.data = NULL;
velV.data = (REAL8Cart3Coor *)LALMalloc(mObsCoh*sizeof(REAL8Cart3Coor));
{
VelocityPar velPar;
REAL8 vel[3];
UINT4 j;
velPar.detector = *detector;
velPar.tBase = timeBase;
velPar.vTol = ACCURACY;
velPar.edat = NULL;
/* read in ephemeris data */
XLAL_CHECK_MAIN( ( edat = XLALInitBarycenter( uvar_earthEphemeris, uvar_sunEphemeris ) ) != NULL, XLAL_EFUNC);
velPar.edat = edat;
/* now calculate average velocity */
for(j=0; j< velV.length; ++j){
velPar.startTime.gpsSeconds = timeV.data[j].gpsSeconds;
velPar.startTime.gpsNanoSeconds = timeV.data[j].gpsNanoSeconds;
LAL_CALL( LALAvgDetectorVel ( &status, vel, &velPar), &status );
velV.data[j].x= vel[0];
velV.data[j].y= vel[1];
velV.data[j].z= vel[2];
}
}
/* amplitude modulation stuff */
{
AMCoeffs XLAL_INIT_DECL(amc);
AMCoeffsParams *amParams;
EarthState earth;
BarycenterInput baryinput; /* Stores detector location and other barycentering data */
/* detector location */
baryinput.site.location[0] = detector->location[0]/LAL_C_SI;
baryinput.site.location[1] = detector->location[1]/LAL_C_SI;
baryinput.site.location[2] = detector->location[2]/LAL_C_SI;
baryinput.dInv = 0.e0;
/* alpha and delta must come from the skypatch */
/* for now set it to something arbitrary */
baryinput.alpha = 0.0;
baryinput.delta = 0.0;
/* Allocate space for amParams stucture */
/* Here, amParams->das is the Detector and Source info */
amParams = (AMCoeffsParams *)LALMalloc(sizeof(AMCoeffsParams));
amParams->das = (LALDetAndSource *)LALMalloc(sizeof(LALDetAndSource));
amParams->das->pSource = (LALSource *)LALMalloc(sizeof(LALSource));
/* Fill up AMCoeffsParams structure */
amParams->baryinput = &baryinput;
amParams->earth = &earth;
amParams->edat = edat;
amParams->das->pDetector = detector;
/* make sure alpha and delta are correct */
amParams->das->pSource->equatorialCoords.latitude = baryinput.delta;
amParams->das->pSource->equatorialCoords.longitude = baryinput.alpha;
amParams->das->pSource->orientation = 0.0;
amParams->das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
amParams->polAngle = amParams->das->pSource->orientation ; /* These two have to be the same!!*/
/* timeV is start time ---> change to mid time */
LAL_CALL (LALComputeAM(&status, &amc, timeV.data, amParams), &status);
/* calculate a^2 and b^2 */
/* for (ii=0, asq=0.0, bsq=0.0; ii<mObsCoh; ii++) */
/* { */
/* REAL8 *a, *b; */
/* a = amc.a + ii; */
/* b = amc.b + ii; */
/* asq += (*a) * (*a); */
/* bsq += (*b) * (*b); */
/* } */
/* free amParams */
LALFree(amParams->das->pSource);
LALFree(amParams->das);
LALFree(amParams);
}
/* loop over templates */
for(loopId=0; loopId < nTemplates; ++loopId){
/* set template parameters */
pulsarTemplate.f0 = freqVec[loopId];
pulsarTemplate.longitude = alphaVec[loopId];
pulsarTemplate.latitude = deltaVec[loopId];
pulsarTemplate.spindown.data[0] = spndnVec[loopId];
{
REAL8 f0new, vcProdn, timeDiffN;
REAL8 sourceDelta, sourceAlpha, cosDelta, factorialN;
UINT4 j, i, f0newBin;
REAL8Cart3Coor sourceLocation;
sourceDelta = pulsarTemplate.latitude;
sourceAlpha = pulsarTemplate.longitude;
cosDelta = cos(sourceDelta);
sourceLocation.x = cosDelta* cos(sourceAlpha);
sourceLocation.y = cosDelta* sin(sourceAlpha);
sourceLocation.z = sin(sourceDelta);
/* loop for all different time stamps,calculate frequency and produce number count*/
/* first initialize number count */
numberCount=0;
for (j=0; j<mObsCoh; ++j)
{
/* calculate v/c.n */
vcProdn = velV.data[j].x * sourceLocation.x
+ velV.data[j].y * sourceLocation.y
+ velV.data[j].z * sourceLocation.z;
/* loop over spindown values to find f_0 */
f0new = pulsarTemplate.f0;
factorialN = 1.0;
timeDiffN = timeDiffV.data[j];
for (i=0; i<msp;++i)
{
factorialN *=(i+1.0);
f0new += pulsarTemplate.spindown.data[i]*timeDiffN / factorialN;
timeDiffN *= timeDiffN;
}
f0newBin = floor(f0new*timeBase + 0.5);
foft = f0newBin * (1.0 +vcProdn) / timeBase;
/* get the right peakgram */
pg1 = pgV[j];
/* calculate frequency bin for template */
ind = floor( foft * timeBase + 0.5 ) - sftFminBin;
/* update the number count */
numberCount+=pg1->data[ind];
}
} /* end of block calculating frequency path and number count */
/******************************************************************/
/* printing result in the output file */
/******************************************************************/
fprintf(fpOut,"%d %f %f %f %g \n",
numberCount, pulsarTemplate.longitude, pulsarTemplate.latitude, pulsarTemplate.f0,
pulsarTemplate.spindown.data[0] );
} /* end of loop over templates */
/******************************************************************/
/* Closing files */
/******************************************************************/
fclose(fpOut);
/******************************************************************/
/* Free memory and exit */
/******************************************************************/
LALFree(alphaVec);
LALFree(deltaVec);
LALFree(freqVec);
LALFree(spndnVec);
for (tempLoopId = 0; tempLoopId < mObsCoh; tempLoopId++){
pg1 = pgV[tempLoopId];
LALFree(pg1->data);
LALFree(pg1);
}
LALFree(pgV);
LALFree(timeV.data);
LALFree(timeDiffV.data);
LALFree(velV.data);
LALFree(pulsarTemplate.spindown.data);
XLALDestroyEphemerisData(edat);
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return DRIVEHOUGHCOLOR_ENORM;
}
/**
* MAIN function
* Generates samples of B-stat and F-stat according to their pdfs for given signal-params.
*/
int main(int argc,char *argv[])
{
UserInput_t XLAL_INIT_DECL(uvar);
ConfigVariables XLAL_INIT_DECL(cfg);
vrbflg = 1; /* verbose error-messages */
/* turn off default GSL error handler */
gsl_set_error_handler_off ();
/* ----- register and read all user-variables ----- */
if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
/* do ALL cmdline and cfgfile handling */
BOOLEAN should_exit = 0;
if ( XLALUserVarReadAllInput ( &should_exit, argc, argv ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
if ( should_exit )
return EXIT_FAILURE;
if ( uvar.version ) {
/* output verbose VCS version string if requested */
CHAR *vcs;
if ( (vcs = XLALGetVersionString (lalDebugLevel)) == NULL ) {
LogPrintf ( LOG_CRITICAL, "%s:XLALGetVersionString(%d) failed with errno=%d.\n", __func__, lalDebugLevel, xlalErrno );
return 1;
}
printf ( "%s\n", vcs );
XLALFree ( vcs );
return 0;
}
/* ---------- Initialize code-setup ---------- */
if ( XLALInitCode( &cfg, &uvar ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "%s: XLALInitCode() failed with error = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* compare IFO name for line injection with IFO list, find the corresponding index, or throw an error if not found */
UINT4 numDetectors = cfg.multiDetStates->length;
INT4 lineX = -1;
if ( uvar.lineIFO ) {
for ( UINT4 X=0; X < numDetectors; X++ ) {
if ( strcmp( uvar.lineIFO, uvar.IFOs->data[X] ) == 0 )
lineX = X;
}
if ( lineX == -1 ) {
XLALPrintError ("\nError in function %s, line %d : Could not match detector ID \"%s\" for line injection to any detector.\n\n", __func__, __LINE__, uvar.lineIFO);
XLAL_ERROR ( XLAL_EFAILED );
}
}
/* ----- prepare stats output ----- */
FILE *fpStats = NULL;
if ( uvar.outputStats )
{
if ( (fpStats = fopen (uvar.outputStats, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputStats );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpStats, "%s", cfg.logString ); /* write search log comment */
if ( write_BSGL_candidate_to_fp ( fpStats, NULL, uvar.IFOs, NULL, uvar.computeBSGL ) != XLAL_SUCCESS ) { /* write header-line comment */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputStats */
/* ----- prepare injection params output ----- */
FILE *fpInjParams = NULL;
if ( uvar.outputInjParams )
{
if ( (fpInjParams = fopen (uvar.outputInjParams, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputInjParams );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpInjParams, "%s", cfg.logString ); /* write search log comment */
if ( write_InjParams_to_fp ( fpInjParams, NULL, 0, uvar.outputMmunuX, numDetectors ) != XLAL_SUCCESS ) { /* write header-line comment */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputInjParams */
multiAMBuffer_t XLAL_INIT_DECL(multiAMBuffer); /* prepare AM-buffer */
/* ----- prepare BSGL computation */
BSGLSetup *BSGLsetup = NULL;
if ( uvar.computeBSGL )
{
BOOLEAN useLogCorrection = TRUE;
REAL4 *oLGX_p = NULL;
REAL4 oLGX[PULSAR_MAX_DETECTORS];
if ( uvar.oLGX != NULL )
{
XLAL_CHECK ( uvar.oLGX->length == numDetectors, XLAL_EINVAL, "Invalid input: length(oLGX) = %d differs from number of detectors (%d)'\n", uvar.oLGX->length, numDetectors );
XLAL_CHECK ( XLALParseLinePriors ( &oLGX[0], uvar.oLGX ) == XLAL_SUCCESS, XLAL_EFUNC );
oLGX_p = &oLGX[0];
}
XLAL_CHECK ( ( BSGLsetup = XLALCreateBSGLSetup ( numDetectors, uvar.Fstar0, oLGX_p, useLogCorrection ) ) != NULL, XLAL_EFUNC );
} // if computeBSGL
/* ----- main MC loop over numDraws trials ---------- */
INT4 i;
for ( i=0; i < uvar.numDraws; i ++ )
{
InjParams_t XLAL_INIT_DECL(injParamsDrawn);
/* ----- generate signal random draws from ranges and generate Fstat atoms */
MultiFstatAtomVector *multiAtoms;
multiAtoms = XLALSynthesizeTransientAtoms ( &injParamsDrawn, cfg.skypos, cfg.AmpPrior, cfg.transientInjectRange, cfg.multiDetStates, cfg.SignalOnly, &multiAMBuffer, cfg.rng, lineX, cfg.multiNoiseWeights );
XLAL_CHECK ( multiAtoms != NULL, XLAL_EFUNC );
/* ----- if requested, output signal injection parameters into file */
if ( fpInjParams && (write_InjParams_to_fp ( fpInjParams, &injParamsDrawn, uvar.dataStartGPS, uvar.outputMmunuX, numDetectors ) != XLAL_SUCCESS ) ) {
XLAL_ERROR ( XLAL_EFUNC );
} /* if fpInjParams & failure*/
/* initialise BSGLComponents structure and allocate memory */
BSGLComponents XLAL_INIT_DECL(synthStats); /* struct containing multi-detector Fstat, single-detector Fstats, line-robust stat */
synthStats.numDetectors = numDetectors;
/* compute F- and BSGListics from atoms */
UINT4 X;
for ( X=0; X < numDetectors; X++ ) {
synthStats.TwoFX[X] = XLALComputeFstatFromAtoms ( multiAtoms, X );
if ( xlalErrno != 0 ) {
XLALPrintError ("\nError in function %s, line %d : Failed call to XLALComputeFstatFromAtoms().\n\n", __func__, __LINE__);
XLAL_ERROR ( XLAL_EFUNC );
}
}
synthStats.TwoF = XLALComputeFstatFromAtoms ( multiAtoms, -1 );
if ( xlalErrno != 0 ) {
XLALPrintError ("\nError in function %s, line %d : Failed call to XLALComputeFstatFromAtoms().\n\n", __func__, __LINE__);
XLAL_ERROR ( XLAL_EFUNC );
}
if ( uvar.computeBSGL ) {
synthStats.log10BSGL = XLALComputeBSGL ( synthStats.TwoF, synthStats.TwoFX, BSGLsetup );
XLAL_CHECK ( xlalErrno == 0, XLAL_EFUNC, "XLALComputeBSGL() failed with xlalErrno = %d\n", xlalErrno );
}
/* ----- if requested, output atoms-vector into file */
if ( uvar.outputAtoms )
{
FILE *fpAtoms;
char *fnameAtoms;
UINT4 len = strlen ( uvar.outputAtoms ) + 20;
if ( (fnameAtoms = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnameAtoms, "%s_%04d_of_%04d.dat", uvar.outputAtoms, i + 1, uvar.numDraws );
if ( ( fpAtoms = fopen ( fnameAtoms, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open atoms-output file '%s' for writing.\n", __func__, fnameAtoms );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpAtoms, "%s", cfg.logString ); /* output header info */
if ( write_MultiFstatAtoms_to_fp ( fpAtoms, multiAtoms ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to write atoms to output file '%s'. xlalErrno = %d\n", __func__, fnameAtoms, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
XLALFree ( fnameAtoms );
fclose (fpAtoms);
} /* if outputAtoms */
/* ----- if requested, output transient-cand statistics */
if ( fpStats && write_BSGL_candidate_to_fp ( fpStats, &synthStats, uvar.IFOs, &injParamsDrawn, uvar.computeBSGL ) != XLAL_SUCCESS ) {
XLALPrintError ( "%s: write_transientCandidate_to_fp() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- free Memory */
XLALDestroyMultiFstatAtomVector ( multiAtoms );
} /* for i < numDraws */
/* ----- close files ----- */
if ( fpStats ) fclose ( fpStats );
if ( fpInjParams ) fclose ( fpInjParams );
/* ----- free memory ---------- */
XLALDestroyMultiDetectorStateSeries ( cfg.multiDetStates );
XLALDestroyMultiNoiseWeights ( cfg.multiNoiseWeights );
XLALDestroyExpLUT();
XLALDestroyMultiAMCoeffs ( multiAMBuffer.multiAM );
/* ----- free amplitude prior pdfs ----- */
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_h0Nat );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_cosi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_psi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_phi0 );
XLALFree ( BSGLsetup );
BSGLsetup = NULL;
if ( cfg.logString ) {
XLALFree ( cfg.logString );
}
gsl_rng_free ( cfg.rng );
XLALDestroyUserVars();
/* did we forget anything ? (doesn't cover gsl-memory!) */
LALCheckMemoryLeaks();
return 0;
} /* main() */
/** Read in input user arguments
*
*/
int XLALReadUserVars(int argc, /**< [in] the command line argument counter */
char *argv[], /**< [in] the command line arguments */
UserInput_t *uvar, /**< [out] the user input structure */
CHAR **clargs /**< [out] the command line args string */
)
{
INT4 i;
/* initialise user variables */
uvar->sftbasename = NULL;
uvar->comment = NULL;
uvar->gpsstart = -1;
uvar->gpsend = -1;
uvar->mismatch = 0.2;
uvar->ntoplist = 10;
uvar->coverage = -1;
uvar->blocksize = 100;
uvar->ndim = -1;
uvar->bins_factor = BINS_FACTOR;
uvar->tsft = 256;
uvar->seed = 1;
uvar->tempdir = NULL;
uvar->with_xbins = 1;
/* initialise all parameter space ranges to zero */
uvar->freqband = 0;
uvar->minorbperiod = 0.0;
uvar->maxorbperiod = 0.0;
uvar->minasini = 0.0;
uvar->maxasini = 0.0;
uvar->tasc = -1.0;
uvar->deltaorbphase = 2.0*LAL_PI;
/* ---------- register all user-variables ---------- */
XLALRegisterUvarMember(sftbasename, STRING, 'i', REQUIRED, "The basename of the input SFT files");
XLALRegisterUvarMember(outputdir, STRING, 'o', REQUIRED, "The output directory name");
XLALRegisterUvarMember(comment, STRING, 'C', REQUIRED, "An analysis descriptor string");
XLALRegisterUvarMember(tempdir, STRING, 'z', OPTIONAL, "A temporary directory");
XLALRegisterUvarMember(freq, REAL8, 'f', REQUIRED, "The starting frequency (Hz)");
XLALRegisterUvarMember(freqband, REAL8, 'b', OPTIONAL, "The frequency band (Hz)");
XLALRegisterUvarMember(minorbperiod, REAL8, 'p', REQUIRED, "The minimum orbital period value (sec)");
XLALRegisterUvarMember(maxorbperiod, REAL8, 'P', OPTIONAL, "The maximum orbital period value (sec)");
XLALRegisterUvarMember(minasini, REAL8, 'a', REQUIRED, "The minimum orbital semi-major axis (sec)");
XLALRegisterUvarMember(maxasini, REAL8, 'A', OPTIONAL, "The maximum orbital semi-major axis (sec)");
XLALRegisterUvarMember(tasc, REAL8, 't', REQUIRED, "The best guess orbital time of ascension (rads)");
XLALRegisterUvarMember(deltaorbphase, REAL8, 'T', OPTIONAL, "The orbital phase uncertainty (cycles)");
XLALRegisterUvarMember(mismatch, REAL8, 'm', OPTIONAL, "The grid mismatch (0->1)");
XLALRegisterUvarMember(coverage, REAL8, 'c', OPTIONAL, "The random template coverage (0->1)");
XLALRegisterUvarMember(blocksize, INT4, 'r', OPTIONAL, "The running median block size");
XLALRegisterUvarMember(ndim, INT4, 'n', OPTIONAL, "The number of spin derivitive dimensions required (default: automatic)");
XLALRegisterUvarMember(bins_factor, REAL8, 'R', OPTIONAL, "The percentage of bins to add to each side of the fft for safety");
XLALRegisterUvarMember(tsft, REAL8, 'S', OPTIONAL, "The length of the input SFTs in seconds");
XLALRegisterUvarMember(ntoplist, INT4, 'x', OPTIONAL, "output the top N results");
XLALRegisterUvarMember(seed, INT4, 'X', OPTIONAL, "The random number seed (0 = clock)");
XLALRegisterUvarMember(gpsstart, INT4, 's', OPTIONAL, "The minimum start time (GPS sec)");
XLALRegisterUvarMember(gpsend, INT4, 'e', OPTIONAL, "The maximum end time (GPS sec)");
XLALRegisterUvarMember(with_xbins, BOOLEAN, 0, DEVELOPER, "Enable fast summing of extra bins");
/* do ALL cmdline and cfgfile handling */
BOOLEAN should_exit = 0;
if (XLALUserVarReadAllInput(&should_exit, argc, argv, lalAppsVCSInfoList)) {
LogPrintf(LOG_CRITICAL,"%s : XLALUserVarReadAllInput failed with error = %d\n",__func__,xlalErrno);
return XLAL_EFAULT;
}
if (should_exit) exit(1);
/* put clargs into string */
*clargs = XLALCalloc(1,sizeof(CHAR));
for (i=0;i<argc;i++) {
INT4 len = 2 + strlen(argv[i]) + strlen(*clargs);
*clargs = XLALRealloc(*clargs,len*sizeof(CHAR));
strcat(*clargs,argv[i]);
strcat(*clargs," ");
}
LogPrintf(LOG_DEBUG,"%s : leaving.\n",__func__);
return XLAL_SUCCESS;
}
int
main(int argc, char *argv[])
{
LALStatus status = blank_status;
ConfigVariables XLAL_INIT_DECL(config);
UserVariables_t XLAL_INIT_DECL(uvar);
/* register user-variables */
XLAL_CHECK ( XLALInitUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
/* read cmdline & cfgfile */
BOOLEAN should_exit = 0;
XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( should_exit ) {
exit(1);
}
if ( uvar.version )
{
XLALOutputVersionString ( stdout, lalDebugLevel );
exit(0);
}
/* basic setup and initializations */
XLAL_CHECK ( XLALInitCode( &config, &uvar, argv[0] ) == XLAL_SUCCESS, XLAL_EFUNC );
/* ----- allocate memory for AM-coeffs ----- */
AMCoeffs AMold, AMnew1, AMnew2; /**< containers holding AM-coefs computed by 3 different AM functions */
AMold.a = XLALCreateREAL4Vector ( 1 );
AMold.b = XLALCreateREAL4Vector ( 1 );
AMnew1.a = XLALCreateREAL4Vector ( 1 );
AMnew1.b = XLALCreateREAL4Vector ( 1 );
AMnew2.a = XLALCreateREAL4Vector ( 1 );
AMnew2.b = XLALCreateREAL4Vector ( 1 );
XLAL_CHECK ( AMold.a && AMold.b && AMnew1.a && AMnew1.b && AMnew2.a && AMnew2.a, XLAL_ENOMEM, "Failed to XLALCreateREAL4Vector ( 1 )\n" );
/* ----- get detector-state series ----- */
DetectorStateSeries *detStates = NULL;
XLAL_CHECK ( (detStates = XLALGetDetectorStates ( config.timestamps, config.det, config.edat, 0 )) != NULL, XLAL_EFUNC );
/* ----- compute associated SSB timing info ----- */
SSBtimes *tSSB = XLALGetSSBtimes ( detStates, config.skypos, config.timeGPS, SSBPREC_RELATIVISTIC );
XLAL_CHECK ( tSSB != NULL, XLAL_EFUNC, "XLALGetSSBtimes() failed with xlalErrno = %d\n", xlalErrno );
/* ===== 1) compute AM-coeffs the 'old way': [used in CFSv1] ===== */
BarycenterInput XLAL_INIT_DECL(baryinput);
AMCoeffsParams XLAL_INIT_DECL(amParams);
EarthState earth;
baryinput.site.location[0] = config.det->location[0]/LAL_C_SI;
baryinput.site.location[1] = config.det->location[1]/LAL_C_SI;
baryinput.site.location[2] = config.det->location[2]/LAL_C_SI;
baryinput.alpha = config.skypos.longitude;
baryinput.delta = config.skypos.latitude;
baryinput.dInv = 0.e0;
/* amParams structure to compute a(t) and b(t) */
amParams.das = XLALMalloc(sizeof(*amParams.das));
amParams.das->pSource = XLALMalloc(sizeof(*amParams.das->pSource));
amParams.baryinput = &baryinput;
amParams.earth = &earth;
amParams.edat = config.edat;
amParams.das->pDetector = config.det;
amParams.das->pSource->equatorialCoords.longitude = config.skypos.longitude;
amParams.das->pSource->equatorialCoords.latitude = config.skypos.latitude;
amParams.das->pSource->orientation = 0.0;
amParams.das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
amParams.polAngle = 0;
LAL_CALL ( LALComputeAM ( &status, &AMold, config.timestamps->data, &amParams), &status);
XLALFree ( amParams.das->pSource );
XLALFree ( amParams.das );
/* ===== 2) compute AM-coeffs the 'new way' using LALNewGetAMCoeffs() */
LALGetAMCoeffs ( &status, &AMnew1, detStates, config.skypos );
if ( status.statusCode ) {
XLALPrintError ("%s: call to LALGetAMCoeffs() failed, status = %d\n\n", __func__, status.statusCode );
XLAL_ERROR ( status.statusCode & XLAL_EFUNC );
}
/* ===== 3) compute AM-coeffs the 'newer way' using LALNewGetAMCoeffs() [used in CFSv2] */
LALNewGetAMCoeffs ( &status, &AMnew2, detStates, config.skypos );
if ( status.statusCode ) {
XLALPrintError ("%s: call to LALNewGetAMCoeffs() failed, status = %d\n\n", __func__, status.statusCode );
XLAL_ERROR ( status.statusCode & XLAL_EFUNC );
}
/* ===== 4) use standalone version of the above [used in FstatMetric_v2] */
REAL8 a0,b0;
if ( XLALComputeAntennaPatternCoeffs ( &a0, &b0, &config.skypos, &config.timeGPS, config.det, config.edat ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALComputeAntennaPatternCoeffs() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ==================== output the results ==================== */
printf ("\n");
printf ("----- Input parameters:\n");
printf ("tGPS = { %d, %d }\n", config.timeGPS.gpsSeconds, config.timeGPS.gpsNanoSeconds );
printf ("Detector = %s\n", config.det->frDetector.name );
printf ("Sky position: longitude = %g rad, latitude = %g rad [equatorial coordinates]\n", config.skypos.longitude, config.skypos.latitude );
printf ("\n");
printf ("----- Antenna pattern functions (a,b):\n");
printf ("LALComputeAM: ( %-12.8g, %-12.8g) [REAL4]\n", AMold.a->data[0], AMold.b->data[0] );
printf ("LALGetAMCoeffs: ( %-12.8g, %-12.8g) [REAL4]\n", AMnew1.a->data[0], AMnew1.b->data[0] );
printf ("LALNewGetAMCoeffs: ( %-12.8g, %-12.8g) [REAL4]\n", AMnew2.a->data[0]/config.sinzeta, AMnew2.b->data[0]/config.sinzeta );
printf ("XLALComputeAntennaPatternCoeffs: ( %-12.8g, %-12.8g) [REAL8]\n", a0/config.sinzeta, b0/config.sinzeta );
printf ("\n");
printf ("----- Detector & Earth state:\n");
REAL8 *pos = detStates->data[0].rDetector;
printf ("Detector position [ICRS J2000. Units=sec]: rDet = {%g, %g, %g}\n", pos[0], pos[1], pos[2] );
REAL8 *vel = detStates->data[0].vDetector;
printf ("Detector velocity [ICRS J2000. Units=c]: vDet = {%g, %g, %g}\n", vel[0], vel[1], vel[2] );
printf ("Local mean sideral time: LMST = %g rad\n", detStates->data[0].LMST);
printf ("\n");
printf ("----- SSB timing data:\n");
printf ("TOA difference tSSB - tDet = %g s\n", tSSB->DeltaT->data[0] );
printf ("TOA rate of change dtSSB/dtDet - 1 = %g\n", tSSB->Tdot->data[0] - 1.0 );
printf ("\n\n");
/* ----- done: free all memory */
XLAL_CHECK ( XLALDestroyConfig( &config ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyDetectorStateSeries ( detStates );
XLALDestroyREAL4Vector ( AMold.a );
XLALDestroyREAL4Vector ( AMold.b );
XLALDestroyREAL4Vector ( AMnew1.a );
XLALDestroyREAL4Vector ( AMnew1.b );
XLALDestroyREAL4Vector ( AMnew2.a );
XLALDestroyREAL4Vector ( AMnew2.b );
XLALDestroyREAL8Vector ( tSSB->DeltaT );
XLALDestroyREAL8Vector ( tSSB->Tdot );
XLALFree (tSSB);
LALCheckMemoryLeaks();
return 0;
} /* main */
/*----------------------------------------------------------------------
* main function
*----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
SFTConstraints XLAL_INIT_DECL(constraints);
CHAR detector[2] = "??"; /* allow reading v1-SFTs without detector-info */
SFTVector *diffs = NULL;
REAL8 maxd = 0;
/* register all user-variables */
UserInput_t XLAL_INIT_DECL(uvar);
XLAL_CHECK_MAIN ( initUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
/* read cmdline & cfgfile */
XLAL_CHECK_MAIN ( XLALUserVarReadAllInput ( argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar.help) { /* help requested: we're done */
exit (0);
}
/* now read in the two complete sft-vectors */
constraints.detector = detector;
SFTCatalog *catalog;
XLAL_CHECK_MAIN ( (catalog = XLALSFTdataFind ( uvar.sftBname1, &constraints )) != NULL, XLAL_EFUNC );
SFTVector *SFTs1;
XLAL_CHECK_MAIN ( (SFTs1 = XLALLoadSFTs( catalog, -1, -1 )) != NULL, XLAL_EFUNC );
XLALDestroySFTCatalog ( catalog );
XLAL_CHECK_MAIN ( (catalog = XLALSFTdataFind ( uvar.sftBname2, &constraints )) != NULL, XLAL_EFUNC );
SFTVector *SFTs2;
XLAL_CHECK_MAIN ( (SFTs2 = XLALLoadSFTs( catalog, -1, -1 )) != NULL, XLAL_EFUNC );
XLALDestroySFTCatalog ( catalog );
/* ---------- do some sanity checks of consistency of SFTs ----------*/
XLAL_CHECK_MAIN ( SFTs1->length == SFTs2->length, XLAL_EINVAL, "Number of SFTs differ for SFTbname1 and SFTbname2!\n");
for ( UINT4 i=0; i < SFTs1->length; i++ )
{
SFTtype *sft1 = &(SFTs1->data[i]);
SFTtype *sft2 = &(SFTs2->data[i]);
if( strcmp( sft1->name, sft2->name ) )
{
if ( lalDebugLevel ) { XLALPrintError("WARNING SFT %d: detector-prefix differ! '%s' != '%s'\n", i, sft1->name, sft2->name ); }
/* exit (1); */ /* can't be too strict here, as we also allow v1-SFTs, which don't have detector-name */
}
XLAL_CHECK_MAIN ( sft1->data->length == sft2->data->length, XLAL_EINVAL, "\nERROR SFT %d: lengths differ! %d != %d\n", i, sft1->data->length, sft2->data->length );
REAL8 Tdiff = XLALGPSDiff(&(sft1->epoch), &(sft2->epoch));
CHAR buf1[32], buf2[32];;
XLAL_CHECK_MAIN ( Tdiff == 0.0, XLAL_EINVAL, "SFT %d: epochs differ: %s vs %s\n", i, XLALGPSToStr(buf1,&sft1->epoch), XLALGPSToStr(buf2,&sft2->epoch) );
XLAL_CHECK_MAIN ( sft1->f0 == sft2->f0, XLAL_EINVAL, "ERROR SFT %d: fmin differ: %fHz vs %fHz\n", i, sft1->f0, sft2->f0 );
XLAL_CHECK_MAIN ( sft1->deltaF == sft2->deltaF, XLAL_EINVAL, "ERROR SFT %d: deltaF differs: %fHz vs %fHz\n", i, sft1->deltaF, sft2->deltaF );
} /* for i < numSFTs */
/*---------- now do some actual comparisons ----------*/
XLAL_CHECK_MAIN ( (diffs = subtractSFTVectors ( SFTs1, SFTs2)) != NULL, XLAL_EFUNC );
if ( uvar.verbose)
{
for ( UINT4 i=0; i < SFTs1->length; i++)
{
SFTtype *sft1 = &(SFTs1->data[i]);
SFTtype *sft2 = &(SFTs2->data[i]);
XLALPrintInfo ("i=%02d: ", i);
REAL4 norm1 = scalarProductSFT ( sft1, sft1 );
norm1 = sqrt(norm1);
REAL4 norm2 = scalarProductSFT ( sft2, sft2 );
norm2 = sqrt(norm2);
REAL4 scalar = scalarProductSFT ( sft1, sft2 );
REAL4 normdiff = scalarProductSFT ( &(diffs->data[i]), &(diffs->data[i]) );
REAL4 d1 = (norm1 - norm2)/norm1;
REAL4 d2 = 1.0 - scalar / (norm1*norm2);
REAL4 d3 = normdiff / (norm1*norm1 + norm2*norm2 );
REAL4 d4 = getMaxErrSFT (sft1, sft2);
XLALPrintInfo ("(|x|-|y|)/|x|=%10.3e, 1-x.y/(|x||y|)=%10.3e, |x-y|^2/(|x|^2+|y|^2))=%10.3e, maxErr=%10.3e\n", d1, d2, d3, d4);
} /* for i < SFTs->length */
} /* if verbose */
/* ---------- COMBINED measures ---------- */
{
REAL4 ret;
ret = scalarProductSFTVector ( SFTs1, SFTs1 );
REAL8 norm1 = sqrt( (REAL8)ret );
ret = scalarProductSFTVector ( SFTs2, SFTs2 );
REAL8 norm2 = sqrt( (REAL8)ret );
ret = scalarProductSFTVector ( SFTs1, SFTs2 );
REAL8 scalar = (REAL8) ret;
ret = scalarProductSFTVector ( diffs, diffs );
REAL8 normdiff = (REAL8) ret;
REAL8 d1 = (norm1 - norm2)/norm1;
maxd = fmax ( maxd, d1 );
REAL8 d2 = 1.0 - scalar / (norm1*norm2);
maxd = fmax ( maxd, d2 );
REAL8 d3 = normdiff / ( norm1*norm1 + norm2*norm2);
maxd = fmax ( maxd, d3 );
REAL8 d4 = getMaxErrSFTVector (SFTs1, SFTs2);
maxd = fmax ( maxd, d4 );
if ( uvar.verbose ) {
printf ("\nTOTAL:(|x|-|y|)/|x|=%10.3e, 1-x.y/(|x||y|)=%10.3e, |x-y|^2/(|x|^2+|y|^2)=%10.3e, maxErr=%10.3e\n", d1, d2, d3, d4);
}
else
{
printf ("%10.3e %10.3e\n", d3, d4);
}
} /* combined total measures */
/* free memory */
XLALDestroySFTVector ( SFTs1 );
XLALDestroySFTVector ( SFTs2 );
XLALDestroySFTVector ( diffs );
XLALDestroyUserVars();
LALCheckMemoryLeaks();
if ( maxd <= uvar.relErrorMax ) {
return 0;
}
else {
return 1;
}
} /* main */
/**
* some basic consistency checks of the (XLAL) UserInput module, far from exhaustive,
* but should be enough to catch big obvious malfunctions
*/
int
main(int argc, char *argv[])
{
int i, my_argc = 8;
char **my_argv;
const char *argv_in[] = { "progname", "--argNum=1", "--argStr=xyz", "--argBool=true", "-a", "1", "-b", "@" TEST_DATA_DIR "ConfigFileSample.cfg" };
UserInput_t XLAL_INIT_DECL(my_uvars);
XLAL_CHECK ( argc == 1, XLAL_EINVAL, "No input arguments allowed.\n");
my_argv = XLALCalloc ( my_argc, sizeof(char*) );
for (i=0; i < my_argc; i ++ )
{
my_argv[i] = XLALCalloc ( 1, strlen(argv_in[i])+1);
strcpy ( my_argv[i], argv_in[i] );
}
/* ---------- Register all test user-variables ---------- */
UserInput_t *uvar = &my_uvars;
XLAL_CHECK ( XLALregREALUserStruct( argNum, 0, UVAR_REQUIRED, "Testing float argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregSTRINGUserStruct( argStr, 0, UVAR_REQUIRED, "Testing string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregBOOLUserStruct( argBool, 0, UVAR_REQUIRED, "Testing bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregINTUserStruct( argInt, 'a', UVAR_REQUIRED, "Testing INT argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregINTUserStruct( dummy, 'c', UVAR_OPTIONAL, "Testing INT argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregBOOLUserStruct( argB2, 'b', UVAR_REQUIRED, "Testing short-option bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregSTRINGUserStruct( string2, 0, UVAR_REQUIRED, "Testing another string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregEPOCHUserStruct( epochGPS, 0, UVAR_REQUIRED, "Testing epoch given as GPS time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregEPOCHUserStruct( epochMJDTT, 0, UVAR_REQUIRED, "Testing epoch given as MJD(TT) time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregRAJUserStruct( longHMS, 0, UVAR_REQUIRED, "Testing RAJ(HMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregRAJUserStruct( longRad, 0, UVAR_REQUIRED, "Testing RAJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregDECJUserStruct( latDMS, 0, UVAR_REQUIRED, "Testing DECJ(DMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregDECJUserStruct( latRad, 0, UVAR_REQUIRED, "Testing DECJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
/* ---------- now read all input from commandline and config-file ---------- */
XLAL_CHECK ( XLALUserVarReadAllInput ( my_argc, my_argv ) == XLAL_SUCCESS, XLAL_EFUNC );
/* ---------- test help-string generation */
CHAR *helpstr;
XLAL_CHECK ( (helpstr = XLALUserVarHelpString ( argv[0])) != NULL, XLAL_EFUNC );
XLALFree ( helpstr );
/* ---------- test log-generation */
CHAR *logstr;
XLAL_CHECK ( ( logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE )) != NULL, XLAL_EFUNC );
XLALFree ( logstr );
/* ---------- test values were read in correctly ---------- */
XLAL_CHECK ( uvar->argNum == 1, XLAL_EFAILED, "Failed to read in argNum\n" );
XLAL_CHECK ( strcmp ( uvar->argStr, "xyz" ) == 0, XLAL_EFAILED, "Failed to read in argStr\n" );
XLAL_CHECK ( uvar->argBool, XLAL_EFAILED, "Failed to read in argBool\n" );
XLAL_CHECK ( uvar->argInt == 1, XLAL_EFAILED, "Failed to read in argInt\n" );
XLAL_CHECK ( uvar->argB2, XLAL_EFAILED, "Failed to read in argB2\n" );
XLAL_CHECK ( strcmp ( uvar->string2, "this is also possible, and # here does nothing; and neither does semi-colon " ) == 0, XLAL_EFAILED, "Failed to read in string2\n" );
char buf1[256], buf2[256];
XLAL_CHECK ( XLALGPSCmp ( &uvar->epochGPS, &uvar->epochMJDTT ) == 0, XLAL_EFAILED, "GPS epoch %s differs from MJD(TT) epoch %s\n",
XLALGPSToStr ( buf1, &uvar->epochGPS), XLALGPSToStr ( buf2, &uvar->epochMJDTT ) );
REAL8 diff, tol = 3e-15;
XLAL_CHECK ( (diff = fabs(uvar->longHMS - uvar->longRad)) < tol, XLAL_EFAILED, "longitude(HMS) = %.16g differs from longitude(rad) = %.16g by %g > tolerance\n", uvar->longHMS, uvar->longRad, diff, tol );
XLAL_CHECK ( (diff = fabs(uvar->latDMS - uvar->latRad)) < tol, XLAL_EFAILED, "latitude(HMS) = %.16g differs from latitude(rad) = %.16g by %g > tolerance\n", uvar->latDMS, uvar->latRad, diff, tol );
/* ----- cleanup ---------- */
XLALDestroyUserVars();
for (i=0; i < my_argc; i ++ ) {
XLALFree ( my_argv[i] );
}
XLALFree ( my_argv );
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
// ---------- main ----------
int
main ( int argc, char *argv[] )
{
UserInput_t XLAL_INIT_DECL(uvar_s);
UserInput_t *uvar = &uvar_s;
uvar->randSeed = 1;
uvar->Nruns = 1;
uvar->inAlign = uvar->outAlign = sizeof(void*);
// ---------- register user-variable ----------
XLALRegisterUvarMember( randSeed, INT4, 's', OPTIONAL, "Random-number seed");
XLALRegisterUvarMember( Nruns, INT4, 'r', OPTIONAL, "Number of repeated timing 'runs' to average over (=improves variance)" );
XLALRegisterUvarMember( inAlign, INT4, 'a', OPTIONAL, "Alignment of input vectors; default is sizeof(void*), i.e. no particular alignment" );
XLALRegisterUvarMember( outAlign, INT4, 'b', OPTIONAL, "Alignment of output vectors; default is sizeof(void*), i.e. no particular alignment" );
BOOLEAN should_exit = 0;
XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv, lalVCSInfoList ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( should_exit ) {
exit (1);
}
srand ( uvar->randSeed );
XLAL_CHECK ( uvar->Nruns >= 1, XLAL_EDOM );
UINT4 Nruns = (UINT4)uvar->Nruns;
UINT4 Ntrials = 1000000 + 7;
REAL4VectorAligned *xIn_a, *xIn2_a, *xOut_a, *xOut2_a;
XLAL_CHECK ( ( xIn_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xIn2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOut_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOut2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
REAL4VectorAligned *xOutRef_a, *xOutRef2_a;
XLAL_CHECK ( (xOutRef_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (xOutRef2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
// extract aligned REAL4 vectors from these
REAL4 *xIn = xIn_a->data;
REAL4 *xIn2 = xIn2_a->data;
REAL4 *xOut = xOut_a->data;
REAL4 *xOut2 = xOut2_a->data;
REAL4 *xOutRef = xOutRef_a->data;
REAL4 *xOutRef2 = xOutRef2_a->data;
UINT4Vector *xOutU4;
UINT4Vector *xOutRefU4;
XLAL_CHECK ( ( xOutU4 = XLALCreateUINT4Vector ( Ntrials )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOutRefU4 = XLALCreateUINT4Vector ( Ntrials )) != NULL, XLAL_EFUNC );
REAL8VectorAligned *xInD_a, *xIn2D_a, *xOutD_a, *xOutRefD_a;
XLAL_CHECK ( ( xInD_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xIn2D_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOutD_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (xOutRefD_a= XLALCreateREAL8VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
// extract aligned REAL8 vectors from these
REAL8 *xInD = xInD_a->data;
REAL8 *xIn2D = xIn2D_a->data;
REAL8 *xOutD = xOutD_a->data;
REAL8 *xOutRefD = xOutRefD_a->data;
REAL8 tic, toc;
REAL4 maxErr = 0, maxRelerr = 0;
REAL4 abstol, reltol;
XLALPrintInfo ("Testing sin(x), cos(x) for x in [-1000, 1000]\n");
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = 2000 * ( frand() - 0.5 );
}
abstol = 2e-7, reltol = 1e-5;
// ==================== SIN() ====================
TESTBENCH_VECTORMATH_S2S(Sin,xIn);
// ==================== COS() ====================
TESTBENCH_VECTORMATH_S2S(Cos,xIn);
// ==================== SINCOS() ====================
TESTBENCH_VECTORMATH_S2SS(SinCos,xIn);
// ==================== SINCOS(2PI*x) ====================
TESTBENCH_VECTORMATH_S2SS(SinCos2Pi,xIn);
// ==================== EXP() ====================
XLALPrintInfo ("\nTesting exp(x) for x in [-10, 10]\n");
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = 20 * ( frand() - 0.5 );
}
abstol = 4e-3, reltol = 3e-7;
TESTBENCH_VECTORMATH_S2S(Exp,xIn);
// ==================== LOG() ====================
XLALPrintInfo ("\nTesting log(x) for x in (0, 10000]\n");
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = 10000.0f * frand() + 1e-6;
} // for i < Ntrials
abstol = 2e-6, reltol = 2e-7;
TESTBENCH_VECTORMATH_S2S(Log,xIn);
// ==================== ADD,MUL ====================
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = -10000.0f + 20000.0f * frand() + 1e-6;
xIn2[i] = -10000.0f + 20000.0f * frand() + 1e-6;
xInD[i] = -100000.0 + 200000.0 * frand() + 1e-6;
xIn2D[i]= -100000.0 + 200000.0 * frand() + 1e-6;
} // for i < Ntrials
abstol = 2e-7, reltol = 2e-7;
XLALPrintInfo ("\nTesting add,multiply,shift,scale(x,y) for x,y in (-10000, 10000]\n");
TESTBENCH_VECTORMATH_SS2S(Add,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2S(Multiply,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2S(Max,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2S(Shift,xIn[0],xIn2);
TESTBENCH_VECTORMATH_SS2S(Scale,xIn[0],xIn2);
TESTBENCH_VECTORMATH_DD2D(Scale,xInD[0],xIn2D);
// ==================== FIND ====================
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = -10000.0f + 20000.0f * frand() + 1e-6;
xIn2[i] = -10000.0f + 20000.0f * frand() + 1e-6;
} // for i < Ntrials
XLALPrintInfo ("\nTesting find for x,y in (-10000, 10000]\n");
TESTBENCH_VECTORMATH_SS2uU(FindVectorLessEqual,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2uU(FindScalarLessEqual,xIn[0],xIn2);
XLALPrintInfo ("\n");
// ---------- clean up memory ----------
XLALDestroyREAL4VectorAligned ( xIn_a );
XLALDestroyREAL4VectorAligned ( xIn2_a );
XLALDestroyREAL4VectorAligned ( xOut_a );
XLALDestroyREAL4VectorAligned ( xOut2_a );
XLALDestroyREAL4VectorAligned ( xOutRef_a );
XLALDestroyREAL4VectorAligned ( xOutRef2_a );
XLALDestroyUINT4Vector ( xOutU4 );
XLALDestroyUINT4Vector ( xOutRefU4 );
XLALDestroyREAL8VectorAligned ( xInD_a );
XLALDestroyREAL8VectorAligned ( xIn2D_a );
XLALDestroyREAL8VectorAligned ( xOutD_a );
XLALDestroyREAL8VectorAligned ( xOutRefD_a );
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
/**
* MAIN function
* Generates samples of B-stat and F-stat according to their pdfs for given signal-params.
*/
int main(int argc,char *argv[])
{
UserInput_t XLAL_INIT_DECL(uvar);
ConfigVariables XLAL_INIT_DECL(cfg); /**< various derived configuration settings */
vrbflg = 1; /* verbose error-messages */
LogSetLevel(lalDebugLevel);
/* turn off default GSL error handler */
gsl_set_error_handler_off ();
/* ----- register and read all user-variables ----- */
LogSetLevel(lalDebugLevel);
if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
/* do ALL cmdline and cfgfile handling */
if ( XLALUserVarReadAllInput ( argc, argv ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
if (uvar.help) /* if help was requested, we're done here */
return 0;
if ( uvar.version ) {
/* output verbose VCS version string if requested */
CHAR *vcs;
if ( (vcs = XLALGetVersionString (lalDebugLevel)) == NULL ) {
LogPrintf ( LOG_CRITICAL, "%s:XLALGetVersionString(%d) failed with errno=%d.\n", __func__, lalDebugLevel, xlalErrno );
return 1;
}
printf ( "%s\n", vcs );
XLALFree ( vcs );
return 0;
}
/* ---------- Initialize code-setup ---------- */
if ( XLALInitCode( &cfg, &uvar ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "%s: XLALInitCode() failed with error = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- prepare stats output ----- */
FILE *fpTransientStats = NULL;
if ( uvar.outputStats )
{
if ( (fpTransientStats = fopen (uvar.outputStats, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputStats );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpTransientStats, "%s", cfg.logString ); /* write search log comment */
if ( write_transientCandidate_to_fp ( fpTransientStats, NULL ) != XLAL_SUCCESS ) { /* write header-line comment */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputStats */
/* ----- prepare injection params output ----- */
FILE *fpInjParams = NULL;
if ( uvar.outputInjParams )
{
if ( (fpInjParams = fopen (uvar.outputInjParams, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputInjParams );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpInjParams, "%s", cfg.logString ); /* write search log comment */
if ( write_InjParams_to_fp ( fpInjParams, NULL, 0, 0, 0 ) != XLAL_SUCCESS ) { /* write header-line comment - options outputMmunuX and numDetectors not supported here, so pass defaults to deactivate them */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputInjParams */
/* ----- main MC loop over numDraws trials ---------- */
multiAMBuffer_t XLAL_INIT_DECL(multiAMBuffer); /* prepare AM-buffer */
INT4 i;
for ( i=0; i < uvar.numDraws; i ++ )
{
InjParams_t XLAL_INIT_DECL(injParamsDrawn);
/* ----- generate signal random draws from ranges and generate Fstat atoms */
MultiFstatAtomVector *multiAtoms;
multiAtoms = XLALSynthesizeTransientAtoms ( &injParamsDrawn, cfg.skypos, cfg.AmpPrior, cfg.transientInjectRange, cfg.multiDetStates, cfg.SignalOnly, &multiAMBuffer, cfg.rng, -1, NULL ); // options lineX and noise_weights not supported here, so pass defaults to deactivate them
if ( multiAtoms ==NULL ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALSynthesizeTransientAtoms() failed with xlalErrno = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- if requested, output signal injection parameters into file */
if ( fpInjParams && (write_InjParams_to_fp ( fpInjParams, &injParamsDrawn, uvar.dataStartGPS, 0, 0 ) ) != XLAL_SUCCESS ) { // options outputMmunuX and numDetectors not supported here, so pass defaults to deactivate them
XLAL_ERROR ( XLAL_EFUNC );
} /* if fpInjParams & failure*/
/* ----- add meta-info on current transient-CW candidate */
transientCandidate_t XLAL_INIT_DECL(cand);
cand.doppler.Alpha = multiAMBuffer.skypos.longitude;
cand.doppler.Delta = multiAMBuffer.skypos.latitude;
cand.windowRange = cfg.transientSearchRange;
/* ----- if needed: compute transient-Bstat search statistic on these atoms */
if ( fpTransientStats || uvar.outputFstatMap || uvar.outputPosteriors )
{
/* compute Fstat map F_mn over {t0, tau} */
if ( (cand.FstatMap = XLALComputeTransientFstatMap ( multiAtoms, cand.windowRange, uvar.useFReg)) == NULL ) {
XLALPrintError ("%s: XLALComputeTransientFstatMap() failed with xlalErrno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if we'll need the Fstat-map F_mn */
/* ----- if requested compute marginalized Bayes factor */
if ( fpTransientStats )
{
cand.logBstat = XLALComputeTransientBstat ( cand.windowRange, cand.FstatMap );
UINT4 err = xlalErrno;
if ( err ) {
XLALPrintError ("%s: XLALComputeTransientBstat() failed with xlalErrno = %d\n", __func__, err );
XLAL_ERROR ( XLAL_EFUNC );
}
if ( uvar.SignalOnly )
{
cand.FstatMap->maxF += 2;
cand.logBstat += 2;
}
} /* if Bstat requested */
/* ----- if requested, compute parameter posteriors for {t0, tau} */
pdf1D_t *pdf_t0 = NULL;
pdf1D_t *pdf_tau = NULL;
if ( fpTransientStats || uvar.outputPosteriors )
{
if ( (pdf_t0 = XLALComputeTransientPosterior_t0 ( cand.windowRange, cand.FstatMap )) == NULL ) {
XLALPrintError ("%s: failed to compute t0-posterior\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
if ( (pdf_tau = XLALComputeTransientPosterior_tau ( cand.windowRange, cand.FstatMap )) == NULL ) {
XLALPrintError ("%s: failed to compute tau-posterior\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* get maximum-posterior estimate (MP) from the modes of these pdfs */
cand.t0_MP = XLALFindModeOfPDF1D ( pdf_t0 );
if ( xlalErrno ) {
XLALPrintError ("%s: mode-estimation failed for pdf_t0. xlalErrno = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
cand.tau_MP = XLALFindModeOfPDF1D ( pdf_tau );
if ( xlalErrno ) {
XLALPrintError ("%s: mode-estimation failed for pdf_tau. xlalErrno = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
} // if posteriors required
/* ----- if requested, compute Ftotal over full data-span */
if ( uvar.computeFtotal )
{
transientFstatMap_t *FtotalMap;
/* prepare special window to cover all the data with one F-stat calculation == Ftotal */
transientWindowRange_t XLAL_INIT_DECL(winRangeAll);
winRangeAll.type = TRANSIENT_NONE;
BOOLEAN useFReg = false;
if ( (FtotalMap = XLALComputeTransientFstatMap ( multiAtoms, winRangeAll, useFReg)) == NULL ) {
XLALPrintError ("%s: XLALComputeTransientFstatMap() failed with xlalErrno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* we only use twoFtotal = 2 * maxF from this single-Fstat calculation */
REAL8 twoFtotal = 2.0 * FtotalMap->maxF;
if ( uvar.SignalOnly )
twoFtotal += 4;
/* ugly hack: lacking a good container for twoFtotal, we borrow fkdot[3] for this here ;) [only used for paper-MCs] */
cand.doppler.fkdot[3] = twoFtotal;
/* good riddance .. */
XLALDestroyTransientFstatMap ( FtotalMap );
} /* if computeFtotal */
/* ----- if requested, output atoms-vector into file */
if ( uvar.outputAtoms )
{
FILE *fpAtoms;
char *fnameAtoms;
UINT4 len = strlen ( uvar.outputAtoms ) + 20;
if ( (fnameAtoms = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnameAtoms, "%s_%04d_of_%04d.dat", uvar.outputAtoms, i + 1, uvar.numDraws );
if ( ( fpAtoms = fopen ( fnameAtoms, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open atoms-output file '%s' for writing.\n", __func__, fnameAtoms );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpAtoms, "%s", cfg.logString ); /* output header info */
if ( write_MultiFstatAtoms_to_fp ( fpAtoms, multiAtoms ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to write atoms to output file '%s'. xlalErrno = %d\n", __func__, fnameAtoms, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
XLALFree ( fnameAtoms );
fclose (fpAtoms);
} /* if outputAtoms */
/* ----- if requested, output Fstat-map over {t0, tau} */
if ( uvar.outputFstatMap )
{
FILE *fpFstatMap;
char *fnameFstatMap;
UINT4 len = strlen ( uvar.outputFstatMap ) + 20;
if ( (fnameFstatMap = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnameFstatMap, "%s_%04d_of_%04d.dat", uvar.outputFstatMap, i + 1, uvar.numDraws );
if ( ( fpFstatMap = fopen ( fnameFstatMap, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open Fstat-map output file '%s' for writing.\n", __func__, fnameFstatMap );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpFstatMap, "%s", cfg.logString ); /* output header info */
fprintf (fpFstatMap, "\nFstat_mn = \\\n" );
if ( XLALfprintfGSLmatrix ( fpFstatMap, "%.9g", cand.FstatMap->F_mn ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALfprintfGSLmatrix() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
XLALFree ( fnameFstatMap );
fclose (fpFstatMap);
} /* if outputFstatMap */
/* ----- if requested, output posterior pdfs on transient params {t0, tau} into a file */
if ( uvar.outputPosteriors )
{
FILE *fpPosteriors;
char *fnamePosteriors;
UINT4 len = strlen ( uvar.outputPosteriors ) + 20;
if ( (fnamePosteriors = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnamePosteriors, "%s_%04d_of_%04d.dat", uvar.outputPosteriors, i + 1, uvar.numDraws );
if ( ( fpPosteriors = fopen ( fnamePosteriors, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open posteriors-output file '%s' for writing.\n", __func__, fnamePosteriors );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpPosteriors, "%s", cfg.logString ); /* output header info */
/* write them to file, using pdf-method */
if ( XLALOutputPDF1D_to_fp ( fpPosteriors, pdf_t0, "pdf_t0" ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to output t0-posterior to file '%s'.\n", __func__, fnamePosteriors );
XLAL_ERROR ( XLAL_EFUNC );
}
if ( XLALOutputPDF1D_to_fp ( fpPosteriors, pdf_tau, "pdf_tau" ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to output tau-posterior to file '%s'.\n", __func__, fnamePosteriors );
XLAL_ERROR ( XLAL_EFUNC );
}
/* free mem, close file */
XLALFree ( fnamePosteriors );
fclose (fpPosteriors);
} /* if outputPosteriors */
/* ----- if requested, output transient-cand statistics */
if ( fpTransientStats && write_transientCandidate_to_fp ( fpTransientStats, &cand ) != XLAL_SUCCESS ) {
XLALPrintError ( "%s: write_transientCandidate_to_fp() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- free Memory */
XLALDestroyTransientFstatMap ( cand.FstatMap );
XLALDestroyMultiFstatAtomVector ( multiAtoms );
XLALDestroyPDF1D ( pdf_t0 );
XLALDestroyPDF1D ( pdf_tau );
} /* for i < numDraws */
/* ----- close files ----- */
if ( fpTransientStats) fclose ( fpTransientStats );
if ( fpInjParams ) fclose ( fpInjParams );
/* ----- free memory ---------- */
XLALDestroyMultiDetectorStateSeries ( cfg.multiDetStates );
XLALDestroyMultiAMCoeffs ( multiAMBuffer.multiAM );
XLALDestroyExpLUT();
/* ----- free amplitude prior pdfs ----- */
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_h0Nat );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_cosi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_psi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_phi0 );
if ( cfg.logString ) XLALFree ( cfg.logString );
gsl_rng_free ( cfg.rng );
XLALDestroyUserVars();
/* did we forget anything ? (doesn't cover gsl-memory!) */
LALCheckMemoryLeaks();
return 0;
} /* main() */
// ---------- main ----------
int
main ( int argc, char *argv[] )
{
// ---------- handle user input ----------
UserInput_t XLAL_INIT_DECL(uvar_s);
UserInput_t *uvar = &uvar_s;
uvar->FstatMethod = XLALStringDuplicate("ResampBest");
uvar->Freq = 100;
uvar->f1dot = -3e-9;
uvar->FreqResolution = XLALCreateREAL8Vector ( 2 );
uvar->FreqResolution->data[0] = 1;
uvar->FreqResolution->data[1] = 10;
uvar->numFreqBins = XLALCreateINT4Vector ( 2 );
uvar->numFreqBins->data[0] = 1000;
uvar->numFreqBins->data[1] = 100000;
uvar->Tseg = 60 * 3600;
uvar->numSegments = 90;
uvar->numTrials = 1;
uvar->Tsft = 1800;
uvar->runBuffered = 0;
XLAL_CHECK ( (uvar->IFOs = XLALCreateStringVector ( "H1", NULL )) != NULL, XLAL_EFUNC );
uvar->outputInfo = NULL;
XLAL_CHECK ( XLALRegisterUvarMember ( help, BOOLEAN, 'h', HELP, "Print help message" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( FstatMethod, STRING, 0, OPTIONAL, XLALFstatMethodHelpString() ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Freq, REAL8, 0, OPTIONAL, "Search frequency in Hz" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( f1dot, REAL8, 0, OPTIONAL, "Search spindown f1dot in Hz/s" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( FreqResolution, REAL8Vector, 0, OPTIONAL, "Range of frequency resolution factor 'r' (st dFreq = 1/(r*T)) [2-number range input]" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Tseg, REAL8, 0, OPTIONAL, "Coherent segment length" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numSegments, INT4, 0, OPTIONAL, "Number of semi-coherent segment" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numFreqBins, INT4Vector, 0, OPTIONAL, "Range of number of frequency bins to search [2-number range input]" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( IFOs, STRINGVector, 0, OPTIONAL, "IFOs to use" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numTrials, INT4, 0, OPTIONAL, "Number of repeated trials to run (with potentially randomized parameters)" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( outputInfo, STRING, 0, OPTIONAL, "Append Resampling internal info into this file") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Tsft, REAL8, 0, DEVELOPER, "SFT length" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( runBuffered, BOOLEAN, 0, DEVELOPER, "Explicitly time buffered Fstat call (only useful for double-checking and Demod timing)" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALUserVarReadAllInput(argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar->help) { // if help was requested, we're done here
return XLAL_SUCCESS;
}
// check user input
XLAL_CHECK ( uvar->numSegments >= 1, XLAL_EINVAL );
XLAL_CHECK ( (uvar->FreqResolution->length == 1) || (uvar->FreqResolution->length == 2), XLAL_EINVAL );
XLAL_CHECK ( uvar->FreqResolution->data[0] > 0, XLAL_EINVAL );
REAL8 FreqResolutionMin, FreqResolutionMax;
FreqResolutionMin = FreqResolutionMax = uvar->FreqResolution->data[0];
if ( uvar->FreqResolution->length == 2 )
{
XLAL_CHECK ( uvar->FreqResolution->data[1] > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->FreqResolution->data[1] > uvar->FreqResolution->data[0], XLAL_EINVAL );
FreqResolutionMax = uvar->FreqResolution->data[1];
}
XLAL_CHECK ( uvar->Freq > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->Tseg > uvar->Tsft, XLAL_EINVAL );
XLAL_CHECK ( uvar->Tsft > 1, XLAL_EINVAL );
XLAL_CHECK ( (uvar->numFreqBins->length == 1) || (uvar->numFreqBins->length == 2), XLAL_EINVAL );
XLAL_CHECK ( uvar->numFreqBins->data[0] > 0, XLAL_EINVAL );
UINT4 numFreqBinsMax, numFreqBinsMin;
numFreqBinsMin = numFreqBinsMax = uvar->numFreqBins->data[0];
if ( uvar->numFreqBins->length == 2 )
{
XLAL_CHECK ( uvar->numFreqBins->data[1] > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->numFreqBins->data[1] > uvar->numFreqBins->data[0], XLAL_EINVAL );
numFreqBinsMax = uvar->numFreqBins->data[1];
}
XLAL_CHECK ( uvar->numTrials >= 1, XLAL_EINVAL );
// ---------- end: handle user input ----------
// common setup over repeated trials
FstatMethodType FstatMethod;
XLAL_CHECK ( XLALParseFstatMethodString ( &FstatMethod, uvar->FstatMethod ) == XLAL_SUCCESS, XLAL_EFUNC );
EphemerisData *ephem;
XLAL_CHECK ( (ephem = XLALInitBarycenter ( TEST_DATA_DIR "earth00-19-DE405.dat.gz", TEST_DATA_DIR "sun00-19-DE405.dat.gz" )) != NULL, XLAL_EFUNC );
REAL8 memBase = XLALGetPeakHeapUsageMB();
UINT4 numDetectors = uvar->IFOs->length;
// ----- setup injection and data parameters
LIGOTimeGPS startTime = {711595934, 0};
LIGOTimeGPS startTime_l = startTime;
LIGOTimeGPS endTime_l;
SFTCatalog **catalogs;
XLAL_CHECK ( (catalogs = XLALCalloc ( uvar->numSegments, sizeof( catalogs[0] ))) != NULL, XLAL_ENOMEM );
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
endTime_l = startTime_l;
XLALGPSAdd( &endTime_l, uvar->Tseg );
MultiLIGOTimeGPSVector *multiTimestamps;
XLAL_CHECK ( (multiTimestamps = XLALMakeMultiTimestamps ( startTime_l, uvar->Tseg, uvar->Tsft, 0, numDetectors )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (catalogs[l] = XLALMultiAddToFakeSFTCatalog ( NULL, uvar->IFOs, multiTimestamps )) != NULL, XLAL_EFUNC );
XLALDestroyMultiTimestamps ( multiTimestamps );
startTime_l = endTime_l;
} // for l < numSegments
LIGOTimeGPS endTime = endTime_l;
UINT4 numSFTsPerSeg = catalogs[0]->length;
FILE *fpInfo = NULL;
if ( (uvar->outputInfo != NULL) && (FstatMethod == FMETHOD_RESAMP_GENERIC) )
{
XLAL_CHECK ( (fpInfo = fopen (uvar->outputInfo, "ab")) != NULL, XLAL_ESYS, "Failed to open '%s' for appending\n", uvar->outputInfo );
XLALAppendResampInfo2File ( fpInfo, NULL ); // create header comment line
}
PulsarSpinRange XLAL_INIT_DECL(spinRange);
LIGOTimeGPS refTime = { startTime.gpsSeconds - 2.3 * uvar->Tseg, 0 };
spinRange.refTime = refTime;
spinRange.fkdot[0] = uvar->Freq;
spinRange.fkdot[1] = uvar->f1dot;
spinRange.fkdotBand[1] = 0;
REAL8 asini = 0, Period = 0, ecc = 0;
REAL8 minCoverFreq, maxCoverFreq;
PulsarDopplerParams XLAL_INIT_DECL(Doppler);
Doppler.refTime = refTime;
Doppler.Alpha = 0.5;
Doppler.Delta = 0.5;
memcpy ( &Doppler.fkdot, &spinRange.fkdot, sizeof(Doppler.fkdot) );;
Doppler.period = Period;
Doppler.ecc = ecc;
Doppler.asini = asini;
// ----- setup optional Fstat arguments
FstatOptionalArgs optionalArgs = FstatOptionalArgsDefaults;
MultiNoiseFloor XLAL_INIT_DECL(injectSqrtSX);
injectSqrtSX.length = numDetectors;
for ( UINT4 X=0; X < numDetectors; X ++ ) {
injectSqrtSX.sqrtSn[X] = 1;
}
optionalArgs.injectSqrtSX = &injectSqrtSX;
optionalArgs.FstatMethod = FstatMethod;
FstatWorkspace *sharedWorkspace = NULL;
FstatInputVector *inputs;
FstatQuantities whatToCompute = (FSTATQ_2F | FSTATQ_2F_PER_DET);
FstatResults *results = NULL;
REAL8 tauF1NoBuf = 0;
REAL8 tauF1Buf = 0;
// ---------- main loop over repeated trials ----------
for ( INT4 i = 0; i < uvar->numTrials; i ++ )
{
// randomize numFreqBins
UINT4 numFreqBins_i = numFreqBinsMin + (UINT4)round ( 1.0 * (numFreqBinsMax - numFreqBinsMin) * rand() / RAND_MAX );
// randomize FreqResolution
REAL8 FreqResolution_i = FreqResolutionMin + 1.0 * ( FreqResolutionMax - FreqResolutionMin ) * rand() / RAND_MAX;
XLAL_CHECK ( (inputs = XLALCreateFstatInputVector ( uvar->numSegments )) != NULL, XLAL_EFUNC );
REAL8 dFreq = 1.0 / ( FreqResolution_i * uvar->Tseg );
REAL8 FreqBand = numFreqBins_i * dFreq;
fprintf ( stderr, "trial %d/%d: Tseg = %.1f d, numSegments = %d, Freq = %.1f Hz, f1dot = %.1e Hz/s, FreqResolution r = %f, numFreqBins = %d [dFreq = %.2e Hz, FreqBand = %.2e Hz]\n",
i+1, uvar->numTrials, uvar->Tseg / 86400.0, uvar->numSegments, uvar->Freq, uvar->f1dot, FreqResolution_i, numFreqBins_i, dFreq, FreqBand );
spinRange.fkdotBand[0] = FreqBand;
XLAL_CHECK ( XLALCWSignalCoveringBand ( &minCoverFreq, &maxCoverFreq, &startTime, &endTime, &spinRange, asini, Period, ecc ) == XLAL_SUCCESS, XLAL_EFUNC );
UINT4 numBinsSFT = ceil ( (maxCoverFreq - minCoverFreq) * uvar->Tsft + 2 * 8 );
REAL8 memSFTs = uvar->numSegments * numSFTsPerSeg * ( sizeof(SFTtype) + numBinsSFT * sizeof(COMPLEX8)) / 1e6;
// create per-segment input structs
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLAL_CHECK ( (inputs->data[l] = XLALCreateFstatInput ( catalogs[l], minCoverFreq, maxCoverFreq, dFreq, ephem, &optionalArgs )) != NULL, XLAL_EFUNC );
if ( l == 0 ) {
sharedWorkspace = XLALGetSharedFstatWorkspace ( inputs->data[0] );
}
optionalArgs.sharedWorkspace = sharedWorkspace;
}
// ----- compute Fstatistics over segments
REAL8 tauF1NoBuf_i = 0;
REAL8 tauF1Buf_i = 0;
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLAL_CHECK ( XLALComputeFstat ( &results, inputs->data[l], &Doppler, numFreqBins_i, whatToCompute ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- output timing details if requested
if ( (fpInfo != NULL) ) {
XLALAppendResampInfo2File ( fpInfo, inputs->data[l] );
}
REAL8 tauF1NoBuf_il, tauF1Buf_il;
XLAL_CHECK ( XLALGetResampTimingInfo ( &tauF1NoBuf_il, &tauF1Buf_il, inputs->data[l] ) == XLAL_SUCCESS, XLAL_EFUNC );
tauF1NoBuf_i += tauF1NoBuf_il;
tauF1Buf_i += tauF1Buf_il;
} // for l < numSegments
tauF1NoBuf_i /= uvar->numSegments;
tauF1Buf_i /= uvar->numSegments;
REAL8 memMaxCompute = XLALGetPeakHeapUsageMB() - memBase;
tauF1Buf += tauF1Buf_i;
tauF1NoBuf += tauF1NoBuf_i;
fprintf (stderr, "%-15s: tauF1Buf = %.2g s, tauF1NoBuf = %.2g s, memSFTs = %.1f MB, memMaxCompute = %.1f MB\n",
XLALGetFstatMethodName ( FstatMethod ), tauF1Buf_i, tauF1NoBuf_i, memSFTs, memMaxCompute );
XLALDestroyFstatInputVector ( inputs );
XLALDestroyFstatWorkspace ( sharedWorkspace );
optionalArgs.sharedWorkspace = NULL;
} // for i < numTrials
tauF1Buf /= uvar->numTrials;
tauF1NoBuf /= uvar->numTrials;
fprintf (stderr, "\nAveraged timings: <tauF1Buf> = %.2g s, <tauF1NoBuf> = %.2g s\n", tauF1Buf, tauF1NoBuf );
// ----- free memory ----------
if ( fpInfo != NULL ) {
fclose ( fpInfo );
}
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLALDestroySFTCatalog ( catalogs[l] );
}
XLALFree ( catalogs );
XLALDestroyFstatResults ( results );
XLALDestroyUserVars();
XLALDestroyEphemerisData ( ephem );
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
/*----------------------------------------------------------------------
* main function
*----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
SFTConstraints XLAL_INIT_DECL(constraints);
LIGOTimeGPS XLAL_INIT_DECL(minStartTimeGPS);
LIGOTimeGPS XLAL_INIT_DECL(maxStartTimeGPS);
SFTCatalog *FullCatalog = NULL;
CHAR *add_comment = NULL;
UINT4 i;
REAL8 fMin, fMax;
UserInput_t XLAL_INIT_DECL(uvar);
/* register all user-variables */
XLAL_CHECK_MAIN ( initUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
/* read cmdline & cfgfile */
XLAL_CHECK_MAIN ( XLALUserVarReadAllInput (argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar.help) { /* help requested: we're done */
exit (0);
}
/* ----- make sure output directory exists ---------- */
if ( uvar.outputDir )
{
int ret;
ret = mkdir ( uvar.outputDir, 0777);
if ( (ret == -1) && ( errno != EEXIST ) )
{
int errsv = errno;
LogPrintf (LOG_CRITICAL, "Failed to create directory '%s': %s\n", uvar.outputDir, strerror(errsv) );
return -1;
}
}
LIGOTimeGPSVector *timestamps = NULL;
if ( uvar.timestampsFile )
{
if ( (timestamps = XLALReadTimestampsFile ( uvar.timestampsFile )) == NULL ) {
XLALPrintError ("XLALReadTimestampsFile() failed to load timestamps from file '%s'\n", uvar.timestampsFile );
return -1;
}
}
/* use IFO-contraint if one given by the user */
if ( LALUserVarWasSet ( &uvar.IFO ) ) {
XLAL_CHECK_MAIN ( (constraints.detector = XLALGetChannelPrefix ( uvar.IFO )) != NULL, XLAL_EINVAL );
}
minStartTimeGPS.gpsSeconds = uvar.minStartTime;
maxStartTimeGPS.gpsSeconds = uvar.maxStartTime;
constraints.minStartTime = &minStartTimeGPS;
constraints.maxStartTime = &maxStartTimeGPS;
constraints.timestamps = timestamps;
/* get full SFT-catalog of all matching (multi-IFO) SFTs */
XLAL_CHECK_MAIN ( (FullCatalog = XLALSFTdataFind ( uvar.inputSFTs, &constraints )) != NULL, XLAL_EFUNC );
if ( constraints.detector ) {
XLALFree ( constraints.detector );
}
XLAL_CHECK_MAIN ( (FullCatalog != NULL) && (FullCatalog->length > 0), XLAL_EINVAL, "\nSorry, didn't find any matching SFTs with pattern '%s'!\n\n", uvar.inputSFTs );
/* build up full comment-string to be added to SFTs: 1) converted by ConvertToSFTv2, VCS ID 2) user extraComment */
{
UINT4 len = 128;
len += strlen ( uvar.inputSFTs );
if ( uvar.extraComment )
len += strlen ( uvar.extraComment );
XLAL_CHECK_MAIN ( ( add_comment = LALCalloc ( 1, len )) != NULL, XLAL_ENOMEM );
/** \deprecated FIXME: the following code uses obsolete CVS ID tags.
* It should be modified to use git version information. */
sprintf ( add_comment, "Converted by $Id$, inputSFTs = '%s';", uvar.inputSFTs );
if ( uvar.extraComment )
{
strcat ( add_comment, "\n");
strcat ( add_comment, uvar.extraComment );
}
} /* construct comment-string */
/* which frequency-band to extract? */
fMin = -1; /* default: all */
fMax = -1;
if ( LALUserVarWasSet ( &uvar.fmin ) )
fMin = uvar.fmin;
if ( LALUserVarWasSet ( &uvar.fmax ) )
fMax = uvar.fmax;
FILE *fpSingleSFT = NULL;
if ( uvar.outputSingleSFT )
XLAL_CHECK ( ( fpSingleSFT = fopen ( uvar.outputSingleSFT, "wb" )) != NULL,
XLAL_EIO, "Failed to open singleSFT file '%s' for writing\n", uvar.outputSingleSFT );
/* loop over all SFTs in SFTCatalog */
for ( i=0; i < FullCatalog->length; i ++ )
{
SFTCatalog oneSFTCatalog;
SFTVector *thisSFT = NULL;
const CHAR *sft_comment;
CHAR *new_comment;
UINT4 comment_len = 0;
/* set catalog containing only one SFT */
oneSFTCatalog.length = 1;
oneSFTCatalog.data = &(FullCatalog->data[i]);
comment_len = strlen ( add_comment ) + 10;
sft_comment = oneSFTCatalog.data->comment;
if ( sft_comment )
comment_len += strlen ( sft_comment );
XLAL_CHECK_MAIN ( ( new_comment = LALCalloc (1, comment_len )) != NULL, XLAL_ENOMEM );
if ( sft_comment ) {
strcpy ( new_comment, sft_comment );
strcat ( new_comment, ";\n");
}
strcat ( new_comment, add_comment );
XLAL_CHECK_MAIN ( (thisSFT = XLALLoadSFTs ( &oneSFTCatalog, fMin, fMax )) != NULL, XLAL_EFUNC );
if ( uvar.mysteryFactor != 1.0 ) {
XLAL_CHECK_MAIN ( applyFactor2SFTs ( thisSFT, uvar.mysteryFactor ) == XLAL_SUCCESS, XLAL_EFUNC );
}
// if user asked for single-SFT output, add this SFT to the open file
if ( uvar.outputSingleSFT )
XLAL_CHECK ( XLAL_SUCCESS == XLALWriteSFT2fp( &(thisSFT->data[0]), fpSingleSFT, new_comment ),
XLAL_EFUNC, "XLALWriteSFT2fp() failed to write SFT to '%s'!\n", uvar.outputSingleSFT );
// if user asked for directory output, write this SFT into that directory
if ( uvar.outputDir ) {
XLAL_CHECK_MAIN ( XLALWriteSFTVector2Dir ( thisSFT, uvar.outputDir, new_comment, uvar.descriptionMisc ) == XLAL_SUCCESS, XLAL_EFUNC );
}
XLALDestroySFTVector ( thisSFT );
XLALFree ( new_comment );
} /* for i < numSFTs */
if ( fpSingleSFT ) {
fclose ( fpSingleSFT );
}
/* free memory */
XLALFree ( add_comment );
XLALDestroySFTCatalog ( FullCatalog );
XLALDestroyUserVars();
XLALDestroyTimestampVector ( timestamps );
LALCheckMemoryLeaks();
return 0;
} /* main */
int main(int argc, char *argv[]){
UserInput_t XLAL_INIT_DECL(uvar);
static ConfigVariables config;
/* sft related variables */
MultiSFTVector *inputSFTs = NULL;
MultiPSDVector *multiPSDs = NULL;
MultiNoiseWeights *multiWeights = NULL;
MultiLIGOTimeGPSVector *multiTimes = NULL;
MultiLALDetector multiDetectors;
MultiDetectorStateSeries *multiStates = NULL;
MultiAMCoeffs *multiCoeffs = NULL;
SFTIndexList *sftIndices = NULL;
SFTPairIndexList *sftPairs = NULL;
REAL8Vector *shiftedFreqs = NULL;
UINT4Vector *lowestBins = NULL;
COMPLEX8Vector *expSignalPhases = NULL;
REAL8VectorSequence *sincList = NULL;
PulsarDopplerParams XLAL_INIT_DECL(dopplerpos);
PulsarDopplerParams thisBinaryTemplate, binaryTemplateSpacings;
PulsarDopplerParams minBinaryTemplate, maxBinaryTemplate;
SkyPosition XLAL_INIT_DECL(skyPos);
MultiSSBtimes *multiBinaryTimes = NULL;
INT4 k;
UINT4 j;
REAL8 fMin, fMax; /* min and max frequencies read from SFTs */
REAL8 deltaF; /* frequency resolution associated with time baseline of SFTs */
REAL8 diagff = 0; /*diagonal metric components*/
REAL8 diagaa = 0;
REAL8 diagTT = 0;
REAL8 diagpp = 1;
REAL8 ccStat = 0;
REAL8 evSquared=0;
REAL8 estSens=0; /*estimated sensitivity(4.13)*/
BOOLEAN dopplerShiftFlag = TRUE;
toplist_t *ccToplist=NULL;
CrossCorrBinaryOutputEntry thisCandidate;
UINT4 checksum;
LogPrintf (LOG_CRITICAL, "Starting time\n"); /*for debug convenience to record calculating time*/
/* initialize and register user variables */
LIGOTimeGPS computingStartGPSTime, computingEndGPSTime;
XLALGPSTimeNow (&computingStartGPSTime); /* record the rough starting GPS time*/
if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read user input from the command line or config file */
if ( XLALUserVarReadAllInput ( argc, argv ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if (uvar.help) /* if help was requested, then exit */
return 0;
CHAR *VCSInfoString = XLALGetVersionString(0); /**<LAL + LALapps Vsersion string*/
/*If the version information was requested, output it and exit*/
if ( uvar.version ){
XLAL_CHECK ( VCSInfoString != NULL, XLAL_EFUNC, "XLALGetVersionString(0) failed.\n" );
printf ("%s\n", VCSInfoString );
exit (0);
}
/* configure useful variables based on user input */
if ( XLALInitializeConfigVars ( &config, &uvar) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
deltaF = config.catalog->data[0].header.deltaF;
REAL8 Tsft = 1.0 / deltaF;
if (XLALUserVarWasSet(&uvar.spacingF) && XLALUserVarWasSet(&uvar.mismatchF))
LogPrintf (LOG_CRITICAL, "spacingF and mismatchF are both set, use spacingF %.9g by default\n\n", uvar.spacingF);
if (XLALUserVarWasSet(&uvar.spacingA) && XLALUserVarWasSet(&uvar.mismatchA))
LogPrintf (LOG_CRITICAL, "spacingA and mismatchA are both set, use spacingA %.9g by default\n\n", uvar.spacingA);
if (XLALUserVarWasSet(&uvar.spacingT) && XLALUserVarWasSet(&uvar.mismatchT))
LogPrintf (LOG_CRITICAL, "spacingT and mismatchT are both set, use spacingT %.9g by default\n\n", uvar.spacingT);
if (XLALUserVarWasSet(&uvar.spacingP) && XLALUserVarWasSet(&uvar.mismatchP))
LogPrintf (LOG_CRITICAL, "spacingP and mismatchP are both set, use spacingP %.9g by default\n\n", uvar.spacingP);
/* create the toplist */
create_crossCorrBinary_toplist( &ccToplist, uvar.numCand);
/* now read the data */
/* /\* get SFT parameters so that we can initialise search frequency resolutions *\/ */
/* /\* calculate deltaF_SFT *\/ */
/* deltaF_SFT = catalog->data[0].header.deltaF; /\* frequency resolution *\/ */
/* timeBase= 1.0/deltaF_SFT; /\* sft baseline *\/ */
/* /\* catalog is ordered in time so we can get start, end time and tObs *\/ */
/* firstTimeStamp = catalog->data[0].header.epoch; */
/* lastTimeStamp = catalog->data[catalog->length - 1].header.epoch; */
/* tObs = XLALGPSDiff( &lastTimeStamp, &firstTimeStamp ) + timeBase; */
/* /\*set pulsar reference time *\/ */
/* if (LALUserVarWasSet ( &uvar_refTime )) { */
/* XLALGPSSetREAL8(&refTime, uvar_refTime); */
/* } */
/* else { /\*if refTime is not set, set it to midpoint of sfts*\/ */
/* XLALGPSSetREAL8(&refTime, (0.5*tObs) + XLALGPSGetREAL8(&firstTimeStamp)); */
/* } */
/* /\* set frequency resolution defaults if not set by user *\/ */
/* if (!(LALUserVarWasSet (&uvar_fResolution))) { */
/* uvar_fResolution = 1/tObs; */
/* } */
/* { */
/* /\* block for calculating frequency range to read from SFTs *\/ */
/* /\* user specifies freq and fdot range at reftime */
/* we translate this range of fdots to start and endtime and find */
/* the largest frequency band required to cover the */
/* frequency evolution *\/ */
/* PulsarSpinRange spinRange_startTime; /\**< freq and fdot range at start-time of observation *\/ */
/* PulsarSpinRange spinRange_endTime; /\**< freq and fdot range at end-time of observation *\/ */
/* PulsarSpinRange spinRange_refTime; /\**< freq and fdot range at the reference time *\/ */
/* REAL8 startTime_freqLo, startTime_freqHi, endTime_freqLo, endTime_freqHi, freqLo, freqHi; */
/* REAL8Vector *fdotsMin=NULL; */
/* REAL8Vector *fdotsMax=NULL; */
/* UINT4 k; */
/* fdotsMin = (REAL8Vector *)LALCalloc(1, sizeof(REAL8Vector)); */
/* fdotsMin->length = N_SPINDOWN_DERIVS; */
/* fdotsMin->data = (REAL8 *)LALCalloc(fdotsMin->length, sizeof(REAL8)); */
/* fdotsMax = (REAL8Vector *)LALCalloc(1, sizeof(REAL8Vector)); */
/* fdotsMax->length = N_SPINDOWN_DERIVS; */
/* fdotsMax->data = (REAL8 *)LALCalloc(fdotsMax->length, sizeof(REAL8)); */
/* XLAL_INIT_MEM(spinRange_startTime); */
/* XLAL_INIT_MEM(spinRange_endTime); */
/* XLAL_INIT_MEM(spinRange_refTime); */
/* spinRange_refTime.refTime = refTime; */
/* spinRange_refTime.fkdot[0] = uvar_f0; */
/* spinRange_refTime.fkdotBand[0] = uvar_fBand; */
/* } */
/* FIXME: need to correct fMin and fMax for Doppler shift, rngmedian bins and spindown range */
/* this is essentially just a place holder for now */
/* FIXME: this running median buffer is overkill, since the running median block need not be centered on the search frequency */
REAL8 vMax = LAL_TWOPI * (uvar.orbitAsiniSec + uvar.orbitAsiniSecBand) / uvar.orbitPSec + LAL_TWOPI * LAL_REARTH_SI / (LAL_DAYSID_SI * LAL_C_SI) + LAL_TWOPI * LAL_AU_SI/(LAL_YRSID_SI * LAL_C_SI); /*calculate the maximum relative velocity in speed of light*/
fMin = uvar.fStart * (1 - vMax) - 0.5 * uvar.rngMedBlock * deltaF;
fMax = (uvar.fStart + uvar.fBand) * (1 + vMax) + 0.5 * uvar.rngMedBlock * deltaF;
/* read the SFTs*/
if ((inputSFTs = XLALLoadMultiSFTs ( config.catalog, fMin, fMax)) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALLoadMultiSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* calculate the psd and normalize the SFTs */
if (( multiPSDs = XLALNormalizeMultiSFTVect ( inputSFTs, uvar.rngMedBlock, NULL )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALNormalizeMultiSFTVect() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* compute the noise weights for the AM coefficients */
if (( multiWeights = XLALComputeMultiNoiseWeights ( multiPSDs, uvar.rngMedBlock, 0 )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALComputeMultiNoiseWeights() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read the timestamps from the SFTs */
if ((multiTimes = XLALExtractMultiTimestampsFromSFTs ( inputSFTs )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALExtractMultiTimestampsFromSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read the detector information from the SFTs */
if ( XLALMultiLALDetectorFromMultiSFTs ( &multiDetectors, inputSFTs ) != XLAL_SUCCESS){
LogPrintf ( LOG_CRITICAL, "%s: XLALMultiLALDetectorFromMultiSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Find the detector state for each SFT */
/* Offset by Tsft/2 to get midpoint as timestamp */
if ((multiStates = XLALGetMultiDetectorStates ( multiTimes, &multiDetectors, config.edat, 0.5 * Tsft )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALGetMultiDetectorStates() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Note this is specialized to a single sky position */
/* This might need to be moved into the config variables */
skyPos.system = COORDINATESYSTEM_EQUATORIAL;
skyPos.longitude = uvar.alphaRad;
skyPos.latitude = uvar.deltaRad;
/* Calculate the AM coefficients (a,b) for each SFT */
if ((multiCoeffs = XLALComputeMultiAMCoeffs ( multiStates, multiWeights, skyPos )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALComputeMultiAMCoeffs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Construct the flat list of SFTs (this sort of replicates the
catalog, but there's not an obvious way to get the information
back) */
if ( ( XLALCreateSFTIndexListFromMultiSFTVect( &sftIndices, inputSFTs ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateSFTIndexListFromMultiSFTVect() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Construct the list of SFT pairs */
#define PCC_SFTPAIR_HEADER "# The length of SFT-pair list is %u #\n"
#define PCC_SFTPAIR_BODY "%u %u\n"
#define PCC_SFT_HEADER "# The length of SFT list is %u #\n"
#define PCC_SFT_BODY "%s %d %d\n"
FILE *fp = NULL;
if (XLALUserVarWasSet(&uvar.pairListInputFilename)) { /* If the user provided a list for reading, use it */
if((sftPairs = XLALCalloc(1, sizeof(sftPairs))) == NULL){
XLAL_ERROR(XLAL_ENOMEM);
}
if((fp = fopen(uvar.pairListInputFilename, "r")) == NULL){
LogPrintf ( LOG_CRITICAL, "didn't find SFT-pair list file with given input name\n");
XLAL_ERROR( XLAL_EFUNC );
}
if(fscanf(fp,PCC_SFTPAIR_HEADER,&sftPairs->length)==EOF){
LogPrintf ( LOG_CRITICAL, "can't read the length of SFT-pair list from the header\n");
XLAL_ERROR( XLAL_EFUNC );
}
if((sftPairs->data = XLALCalloc(sftPairs->length, sizeof(*sftPairs->data)))==NULL){
XLALFree(sftPairs);
XLAL_ERROR(XLAL_ENOMEM);
}
for(j = 0; j < sftPairs->length; j++){ /*read in the SFT-pair list */
if(fscanf(fp,PCC_SFTPAIR_BODY, &sftPairs->data[j].sftNum[0], &sftPairs->data[j].sftNum[1])==EOF){
LogPrintf ( LOG_CRITICAL, "The length of SFT-pair list doesn't match!");
XLAL_ERROR( XLAL_EFUNC );
}
}
fclose(fp);
}
else { /* if not, construct the list of pairs */
if ( ( XLALCreateSFTPairIndexList( &sftPairs, sftIndices, inputSFTs, uvar.maxLag, uvar.inclAutoCorr ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateSFTPairIndexList() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
}
if (XLALUserVarWasSet(&uvar.pairListOutputFilename)) { /* Write the list of pairs to a file, if a name was provided */
if((fp = fopen(uvar.pairListOutputFilename, "w")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in SFT-pair list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_SFTPAIR_HEADER, sftPairs->length ); /*output the length of SFT-pair list to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_SFTPAIR_BODY, sftPairs->data[j].sftNum[0], sftPairs->data[j].sftNum[1]);
}
fclose(fp);
}
if (XLALUserVarWasSet(&uvar.sftListOutputFilename)) { /* Write the list of SFTs to a file for sanity-checking purposes */
if((fp = fopen(uvar.sftListOutputFilename, "w")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in flat SFT list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_SFT_HEADER, sftIndices->length ); /*output the length of SFT list to the header*/
for(j = 0; j < sftIndices->length; j++){ /*output the SFT list */
fprintf(fp,PCC_SFT_BODY, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].name, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsSeconds, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsNanoSeconds);
}
fclose(fp);
}
else if(XLALUserVarWasSet(&uvar.sftListInputFilename)){ /*do a sanity check of the order of SFTs list if the name of input SFT list is given*/
UINT4 numofsft=0;
if((fp = fopen(uvar.sftListInputFilename, "r")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't read in flat SFT list \n");
XLAL_ERROR( XLAL_EFUNC );
}
if (fscanf(fp, PCC_SFT_HEADER, &numofsft)==EOF){
LogPrintf ( LOG_CRITICAL, "can't read in the length of SFT list from header\n");
XLAL_ERROR( XLAL_EFUNC );
}
CHARVectorSequence *checkDet=NULL;
if ((checkDet = XLALCreateCHARVectorSequence (numofsft, LALNameLength) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateCHARVector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
INT4 checkGPS[numofsft], checkGPSns[numofsft];
if(numofsft == sftIndices->length){
for (j=0; j<numofsft; j++){
if( fscanf(fp,PCC_SFT_BODY,&checkDet->data[j * LALNameLength], &checkGPS[j], &checkGPSns[j])==EOF){
LogPrintf ( LOG_CRITICAL, "The length of SFT list doesn't match\n");
XLAL_ERROR( XLAL_EFUNC );
}
if(strcmp( inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].name, &checkDet->data[j * LALNameLength] ) != 0
||inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsSeconds != checkGPS[j]
||inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsNanoSeconds != checkGPSns[j] ){
LogPrintf ( LOG_CRITICAL, "The order of SFTs has been changed, it's the end of civilization\n");
XLAL_ERROR( XLAL_EFUNC );
}
}
fclose(fp);
XLALDestroyCHARVectorSequence(checkDet);
}
else{
LogPrintf ( LOG_CRITICAL, "Run for your life, the length of SFT list doesn't match");
XLAL_ERROR( XLAL_EFUNC );
}
}
else
{
}
/* Get weighting factors for calculation of metric */
/* note that the sigma-squared is now absorbed into the curly G
because the AM coefficients are noise-weighted. */
REAL8Vector *GammaAve = NULL;
REAL8Vector *GammaCirc = NULL;
if ( ( XLALCalculateCrossCorrGammas( &GammaAve, &GammaCirc, sftPairs, sftIndices, multiCoeffs) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrGammas() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
#define PCC_GAMMA_HEADER "# The normalization Sinv_Tsft is %g #\n"
#define PCC_GAMMA_BODY "%.10g\n"
if (XLALUserVarWasSet(&uvar.gammaAveOutputFilename)) { /* Write the aa+bb weight for each pair to a file, if a name was provided */
if((fp = fopen(uvar.gammaAveOutputFilename, "w")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Can't write in Gamma_ave list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_GAMMA_HEADER, multiWeights->Sinv_Tsft); /*output the normalization factor to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_GAMMA_BODY, GammaAve->data[j]);
}
fclose(fp);
}
if (XLALUserVarWasSet(&uvar.gammaCircOutputFilename)) { /* Write the ab-ba weight for each pair to a file, if a name was provided */
if((fp = fopen(uvar.gammaCircOutputFilename, "w")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Can't write in Gamma_circ list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_GAMMA_HEADER, multiWeights->Sinv_Tsft); /*output the normalization factor to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_GAMMA_BODY, GammaCirc->data[j]);
}
fclose(fp);
}
/*initialize binary parameters structure*/
XLAL_INIT_MEM(minBinaryTemplate);
XLAL_INIT_MEM(maxBinaryTemplate);
XLAL_INIT_MEM(thisBinaryTemplate);
XLAL_INIT_MEM(binaryTemplateSpacings);
/*fill in minbinaryOrbitParams*/
XLALGPSSetREAL8( &minBinaryTemplate.tp, uvar.orbitTimeAsc);
minBinaryTemplate.argp = 0.0;
minBinaryTemplate.asini = uvar.orbitAsiniSec;
minBinaryTemplate.ecc = 0.0;
minBinaryTemplate.period = uvar.orbitPSec;
minBinaryTemplate.fkdot[0] = uvar.fStart;
/*fill in maxBinaryParams*/
XLALGPSSetREAL8( &maxBinaryTemplate.tp, uvar.orbitTimeAsc + uvar.orbitTimeAscBand);
maxBinaryTemplate.argp = 0.0;
maxBinaryTemplate.asini = uvar.orbitAsiniSec + uvar.orbitAsiniSecBand;
maxBinaryTemplate.ecc = 0.0;
maxBinaryTemplate.period = uvar.orbitPSec;
maxBinaryTemplate.fkdot[0] = uvar.fStart + uvar.fBand;
/*fill in thisBinaryTemplate*/
XLALGPSSetREAL8( &thisBinaryTemplate.tp, uvar.orbitTimeAsc + 0.5 * uvar.orbitTimeAscBand);
thisBinaryTemplate.argp = 0.0;
thisBinaryTemplate.asini = 0.5*(minBinaryTemplate.asini + maxBinaryTemplate.asini);
thisBinaryTemplate.ecc = 0.0;
thisBinaryTemplate.period =0.5*(minBinaryTemplate.period + maxBinaryTemplate.period);
thisBinaryTemplate.fkdot[0]=0.5*(minBinaryTemplate.fkdot[0] + maxBinaryTemplate.fkdot[0]);
/*Get metric diagonal components, also estimate sensitivity i.e. E[rho]/(h0)^2 (4.13)*/
if ( (XLALCalculateLMXBCrossCorrDiagMetric(&estSens, &diagff, &diagaa, &diagTT, thisBinaryTemplate, GammaAve, sftPairs, sftIndices, inputSFTs, multiWeights /*, kappaValues*/) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateLMXBCrossCorrDiagMetric() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* spacing in frequency from diagff */ /* set spacings in new dopplerparams struct */
if (XLALUserVarWasSet(&uvar.spacingF)) /* If spacing was given by CMD line, use it, else calculate spacing by mismatch*/
binaryTemplateSpacings.fkdot[0] = uvar.spacingF;
else
binaryTemplateSpacings.fkdot[0] = sqrt(uvar.mismatchF / diagff);
if (XLALUserVarWasSet(&uvar.spacingA))
binaryTemplateSpacings.asini = uvar.spacingA;
else
binaryTemplateSpacings.asini = sqrt(uvar.mismatchA / diagaa);
/* this is annoying: tp is a GPS time while we want a difference
in time which should be just REAL8 */
if (XLALUserVarWasSet(&uvar.spacingT))
XLALGPSSetREAL8( &binaryTemplateSpacings.tp, uvar.spacingT);
else
XLALGPSSetREAL8( &binaryTemplateSpacings.tp, sqrt(uvar.mismatchT / diagTT));
if (XLALUserVarWasSet(&uvar.spacingP))
binaryTemplateSpacings.period = uvar.spacingP;
else
binaryTemplateSpacings.period = sqrt(uvar.mismatchP / diagpp);
/* metric elements for eccentric case not considered? */
UINT8 fCount = 0, aCount = 0, tCount = 0 , pCount = 0;
const UINT8 fSpacingNum = floor( uvar.fBand / binaryTemplateSpacings.fkdot[0]);
const UINT8 aSpacingNum = floor( uvar.orbitAsiniSecBand / binaryTemplateSpacings.asini);
const UINT8 tSpacingNum = floor( uvar.orbitTimeAscBand / XLALGPSGetREAL8(&binaryTemplateSpacings.tp));
const UINT8 pSpacingNum = floor( uvar.orbitPSecBand / binaryTemplateSpacings.period);
/*reset minbinaryOrbitParams to shift the first point a factor so as to make the center of all seaching points centers at the center of searching band*/
minBinaryTemplate.fkdot[0] = uvar.fStart + 0.5 * (uvar.fBand - fSpacingNum * binaryTemplateSpacings.fkdot[0]);
minBinaryTemplate.asini = uvar.orbitAsiniSec + 0.5 * (uvar.orbitAsiniSecBand - aSpacingNum * binaryTemplateSpacings.asini);
XLALGPSSetREAL8( &minBinaryTemplate.tp, uvar.orbitTimeAsc + 0.5 * (uvar.orbitTimeAscBand - tSpacingNum * XLALGPSGetREAL8(&binaryTemplateSpacings.tp)));
minBinaryTemplate.period = uvar.orbitPSec + 0.5 * (uvar.orbitPSecBand - pSpacingNum * binaryTemplateSpacings.period);
/* initialize the doppler scan struct which stores the current template information */
XLALGPSSetREAL8(&dopplerpos.refTime, config.refTime);
dopplerpos.Alpha = uvar.alphaRad;
dopplerpos.Delta = uvar.deltaRad;
dopplerpos.fkdot[0] = minBinaryTemplate.fkdot[0];
/* set all spindowns to zero */
for (k=1; k < PULSAR_MAX_SPINS; k++)
dopplerpos.fkdot[k] = 0.0;
dopplerpos.asini = minBinaryTemplate.asini;
dopplerpos.period = minBinaryTemplate.period;
dopplerpos.tp = minBinaryTemplate.tp;
dopplerpos.ecc = minBinaryTemplate.ecc;
dopplerpos.argp = minBinaryTemplate.argp;
/* now set the initial values of binary parameters */
/* thisBinaryTemplate.asini = uvar.orbitAsiniSec;
thisBinaryTemplate.period = uvar.orbitPSec;
XLALGPSSetREAL8( &thisBinaryTemplate.tp, uvar.orbitTimeAsc);
thisBinaryTemplate.ecc = 0.0;
thisBinaryTemplate.argp = 0.0;*/
/* copy to dopplerpos */
/* Calculate SSB times (can do this once since search is currently only for one sky position, and binary doppler shift is added later) */
MultiSSBtimes *multiSSBTimes = NULL;
if ((multiSSBTimes = XLALGetMultiSSBtimes ( multiStates, skyPos, dopplerpos.refTime, SSBPREC_RELATIVISTICOPT )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALGetMultiSSBtimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* "New" general metric computation */
/* For now hard-code circular parameter space */
const DopplerCoordinateSystem coordSys = {
.dim = 4,
.coordIDs = { DOPPLERCOORD_FREQ,
DOPPLERCOORD_ASINI,
DOPPLERCOORD_TASC,
DOPPLERCOORD_PORB, },
};
REAL8VectorSequence *phaseDerivs = NULL;
if ( ( XLALCalculateCrossCorrPhaseDerivatives ( &phaseDerivs, &thisBinaryTemplate, config.edat, sftIndices, multiSSBTimes, &coordSys ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrPhaseDerivatives() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* fill in metric and parameter offsets */
gsl_matrix *g_ij = NULL;
gsl_vector *eps_i = NULL;
REAL8 sumGammaSq = 0;
if ( ( XLALCalculateCrossCorrPhaseMetric ( &g_ij, &eps_i, &sumGammaSq, phaseDerivs, sftPairs, GammaAve, GammaCirc, &coordSys ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrPhaseMetric() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
XLALDestroyREAL8VectorSequence ( phaseDerivs );
XLALDestroyREAL8Vector ( GammaCirc );
if ((fp = fopen("gsldata.dat","w"))==NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in gsl matrix file");
XLAL_ERROR( XLAL_EFUNC );
}
XLALfprintfGSLvector(fp, "%g", eps_i);
XLALfprintfGSLmatrix(fp, "%g", g_ij);
/* Allocate structure for binary doppler-shifting information */
if ((multiBinaryTimes = XLALDuplicateMultiSSBtimes ( multiSSBTimes )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALDuplicateMultiSSBtimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
UINT8 numSFTs = sftIndices->length;
if ((shiftedFreqs = XLALCreateREAL8Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((lowestBins = XLALCreateUINT4Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateUINT4Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((expSignalPhases = XLALCreateCOMPLEX8Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((sincList = XLALCreateREAL8VectorSequence ( numSFTs, uvar.numBins ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8VectorSequence() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* args should be : spacings, min and max doppler params */
BOOLEAN firstPoint = TRUE; /* a boolean to help to search at the beginning point in parameter space, after the search it is set to be FALSE to end the loop*/
if ( (XLALAddMultiBinaryTimes( &multiBinaryTimes, multiSSBTimes, &dopplerpos ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALAddMultiBinaryTimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
} /*Need to apply additional doppler shifting before the loop, or the first point in parameter space will be lost and return a wrong SNR when fBand!=0*/
while ( GetNextCrossCorrTemplate(&dopplerShiftFlag, &firstPoint, &dopplerpos, &binaryTemplateSpacings, &minBinaryTemplate, &maxBinaryTemplate, &fCount, &aCount, &tCount, &pCount, fSpacingNum, aSpacingNum, tSpacingNum, pSpacingNum) == 0)
{
/* do useful stuff here*/
/* Apply additional Doppler shifting using current binary orbital parameters */
/* Might want to be clever about checking whether we've changed the orbital parameters or only the frequency */
if (dopplerShiftFlag == TRUE)
{
if ( (XLALAddMultiBinaryTimes( &multiBinaryTimes, multiSSBTimes, &dopplerpos ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALAddMultiBinaryTimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
}
if ( (XLALGetDopplerShiftedFrequencyInfo( shiftedFreqs, lowestBins, expSignalPhases, sincList, uvar.numBins, &dopplerpos, sftIndices, inputSFTs, multiBinaryTimes, Tsft ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALGetDopplerShiftedFrequencyInfo() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ( (XLALCalculatePulsarCrossCorrStatistic( &ccStat, &evSquared, GammaAve, expSignalPhases, lowestBins, sincList, sftPairs, sftIndices, inputSFTs, multiWeights, uvar.numBins) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculatePulsarCrossCorrStatistic() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* fill candidate struct and insert into toplist if necessary */
thisCandidate.freq = dopplerpos.fkdot[0];
thisCandidate.tp = XLALGPSGetREAL8( &dopplerpos.tp );
thisCandidate.argp = dopplerpos.argp;
thisCandidate.asini = dopplerpos.asini;
thisCandidate.ecc = dopplerpos.ecc;
thisCandidate.period = dopplerpos.period;
thisCandidate.rho = ccStat;
thisCandidate.evSquared = evSquared;
thisCandidate.estSens = estSens;
insert_into_crossCorrBinary_toplist(ccToplist, thisCandidate);
} /* end while loop over templates */
/* write candidates to file */
sort_crossCorrBinary_toplist( ccToplist );
/* add error checking */
final_write_crossCorrBinary_toplist_to_file( ccToplist, uvar.toplistFilename, &checksum);
REAL8 h0Sens = sqrt((10 / sqrt(estSens))); /*for a SNR=10 signal, the h0 we can detect*/
XLALGPSTimeNow (&computingEndGPSTime); /*record the rough end time*/
UINT4 computingTime = computingEndGPSTime.gpsSeconds - computingStartGPSTime.gpsSeconds;
/* make a meta-data file*/
if(XLALUserVarWasSet(&uvar.logFilename)){
CHAR *CMDInputStr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE );
if ((fp = fopen(uvar.logFilename,"w"))==NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in logfile");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp, "[UserInput]\n\n");
fprintf(fp, "%s\n", CMDInputStr);
fprintf(fp, "[CalculatedValues]\n\n");
fprintf(fp, "g_ff = %.9f\n", diagff );
fprintf(fp, "g_aa = %.9f\n", diagaa );
fprintf(fp, "g_TT = %.9f\n", diagTT );
fprintf(fp, "FSpacing = %.9g\n", binaryTemplateSpacings.fkdot[0]);
fprintf(fp, "ASpacing = %.9g\n", binaryTemplateSpacings.asini);
fprintf(fp, "TSpacing = %.9g\n", XLALGPSGetREAL8(&binaryTemplateSpacings.tp));
/* fprintf(fp, "PSpacing = %.9g\n", binaryTemplateSpacings.period );*/
fprintf(fp, "TemplatenumF = %" LAL_UINT8_FORMAT "\n", (fSpacingNum + 1));
fprintf(fp, "TemplatenumA = %" LAL_UINT8_FORMAT "\n", (aSpacingNum + 1));
fprintf(fp, "TemplatenumT = %" LAL_UINT8_FORMAT "\n", (tSpacingNum + 1));
fprintf(fp, "TemplatenumP = %" LAL_UINT8_FORMAT "\n", (pSpacingNum + 1));
fprintf(fp, "TemplatenumTotal = %" LAL_UINT8_FORMAT "\n",(fSpacingNum + 1) * (aSpacingNum + 1) * (tSpacingNum + 1) * (pSpacingNum + 1));
fprintf(fp, "Sens = %.9g\n", estSens);/*(E[rho]/h0^2)^2*/
fprintf(fp, "h0_min_SNR10 = %.9g\n", h0Sens);/*for rho = 10 in our pipeline*/
fprintf(fp, "startTime = %" LAL_INT4_FORMAT "\n", computingStartGPSTime.gpsSeconds );/*start time in GPS-time*/
fprintf(fp, "endTime = %" LAL_INT4_FORMAT "\n", computingEndGPSTime.gpsSeconds );/*end time in GPS-time*/
fprintf(fp, "computingTime = %" LAL_UINT4_FORMAT "\n", computingTime );/*total time in sec*/
fprintf(fp, "SFTnum = %" LAL_UINT4_FORMAT "\n", sftIndices->length);/*total number of SFT*/
fprintf(fp, "pairnum = %" LAL_UINT4_FORMAT "\n", sftPairs->length);/*total number of pair of SFT*/
fprintf(fp, "Tsft = %.6g\n", Tsft);/*SFT duration*/
fprintf(fp, "\n[Version]\n\n");
fprintf(fp, "%s", VCSInfoString);
fclose(fp);
XLALFree(CMDInputStr);
}
XLALFree(VCSInfoString);
XLALDestroyCOMPLEX8Vector ( expSignalPhases );
XLALDestroyUINT4Vector ( lowestBins );
XLALDestroyREAL8Vector ( shiftedFreqs );
XLALDestroyREAL8VectorSequence ( sincList );
XLALDestroyMultiSSBtimes ( multiBinaryTimes );
XLALDestroyMultiSSBtimes ( multiSSBTimes );
XLALDestroyREAL8Vector ( GammaAve );
XLALDestroySFTPairIndexList( sftPairs );
XLALDestroySFTIndexList( sftIndices );
XLALDestroyMultiAMCoeffs ( multiCoeffs );
XLALDestroyMultiDetectorStateSeries ( multiStates );
XLALDestroyMultiTimestamps ( multiTimes );
XLALDestroyMultiNoiseWeights ( multiWeights );
XLALDestroyMultiPSDVector ( multiPSDs );
XLALDestroyMultiSFTVector ( inputSFTs );
/* de-allocate memory for configuration variables */
XLALDestroyConfigVars ( &config );
/* de-allocate memory for user input variables */
XLALDestroyUserVars();
/* free toplist memory */
free_crossCorr_toplist(&ccToplist);
/* check memory leaks if we forgot to de-allocate anything */
LALCheckMemoryLeaks();
LogPrintf (LOG_CRITICAL, "End time\n");/*for debug convenience to record calculating time*/
return 0;
} /* main */
/* initialize and register user variables */
int XLALInitUserVars (UserInput_t *uvar)
{
/* initialize with some defaults */
uvar->help = FALSE;
uvar->maxLag = 0.0;
uvar->inclAutoCorr = FALSE;
uvar->fStart = 100.0;
uvar->fBand = 0.1;
/* uvar->fdotStart = 0.0; */
/* uvar->fdotBand = 0.0; */
uvar->alphaRad = 0.0;
uvar->deltaRad = 0.0;
uvar->refTime = 0.0;
uvar->rngMedBlock = 50;
uvar->numBins = 1;
/* zero binary orbital parameters means not a binary */
uvar->orbitAsiniSec = 0.0;
uvar->orbitAsiniSecBand = 0.0;
uvar->orbitPSec = 0.0;
uvar->orbitPSecBand = 0.0;
uvar->orbitTimeAsc = 0;
uvar->orbitTimeAscBand = 0;
/*default mismatch values */
/* set to 0.1 by default -- for no real reason */
/* make 0.1 a macro? */
uvar->mismatchF = 0.1;
uvar->mismatchA = 0.1;
uvar->mismatchT = 0.1;
uvar->mismatchP = 0.1;
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->sftLocation = XLALCalloc(1, MAXFILENAMELENGTH+1);
/* initialize number of candidates in toplist -- default is just to return the single best candidate */
uvar->numCand = 1;
uvar->toplistFilename = XLALStringDuplicate("toplist_crosscorr.dat");
uvar->version = FALSE;
/* register user-variables */
XLALregBOOLUserStruct ( help, 'h', UVAR_HELP, "Print this message");
XLALregINTUserStruct ( startTime, 0, UVAR_REQUIRED, "Desired start time of analysis in GPS seconds");
XLALregINTUserStruct ( endTime, 0, UVAR_REQUIRED, "Desired end time of analysis in GPS seconds");
XLALregREALUserStruct ( maxLag, 0, UVAR_OPTIONAL, "Maximum lag time in seconds between SFTs in correlation");
XLALregBOOLUserStruct ( inclAutoCorr, 0, UVAR_OPTIONAL, "Include auto-correlation terms (an SFT with itself)");
XLALregREALUserStruct ( fStart, 0, UVAR_OPTIONAL, "Start frequency in Hz");
XLALregREALUserStruct ( fBand, 0, UVAR_OPTIONAL, "Frequency band to search over in Hz ");
/* XLALregREALUserStruct ( fdotStart, 0, UVAR_OPTIONAL, "Start value of spindown in Hz/s"); */
/* XLALregREALUserStruct ( fdotBand, 0, UVAR_OPTIONAL, "Band for spindown values in Hz/s"); */
XLALregREALUserStruct ( alphaRad, 0, UVAR_OPTIONAL, "Right ascension for directed search (radians)");
XLALregREALUserStruct ( deltaRad, 0, UVAR_OPTIONAL, "Declination for directed search (radians)");
XLALregREALUserStruct ( refTime, 0, UVAR_OPTIONAL, "SSB reference time for pulsar-parameters [Default: midPoint]");
XLALregREALUserStruct ( orbitAsiniSec, 0, UVAR_OPTIONAL, "Start of search band for projected semimajor axis (seconds) [0 means not a binary]");
XLALregREALUserStruct ( orbitAsiniSecBand, 0, UVAR_OPTIONAL, "Width of search band for projected semimajor axis (seconds)");
XLALregREALUserStruct ( orbitPSec, 0, UVAR_OPTIONAL, "Binary orbital period (seconds) [0 means not a binary]");
XLALregREALUserStruct ( orbitPSecBand, 0, UVAR_OPTIONAL, "Band for binary orbital period (seconds) ");
XLALregREALUserStruct ( orbitTimeAsc, 0, UVAR_OPTIONAL, "Start of orbital time-of-ascension band in GPS seconds");
XLALregREALUserStruct ( orbitTimeAscBand, 0, UVAR_OPTIONAL, "Width of orbital time-of-ascension band (seconds)");
XLALregSTRINGUserStruct( ephemEarth, 0, UVAR_OPTIONAL, "Earth ephemeris file to use");
XLALregSTRINGUserStruct( ephemSun, 0, UVAR_OPTIONAL, "Sun ephemeris file to use");
XLALregSTRINGUserStruct( sftLocation, 0, UVAR_REQUIRED, "Filename pattern for locating SFT data");
XLALregINTUserStruct ( rngMedBlock, 0, UVAR_OPTIONAL, "Running median block size for PSD estimation");
XLALregINTUserStruct ( numBins, 0, UVAR_OPTIONAL, "Number of frequency bins to include in calculation");
XLALregREALUserStruct ( mismatchF, 0, UVAR_OPTIONAL, "Desired mismatch for frequency spacing");
XLALregREALUserStruct ( mismatchA, 0, UVAR_OPTIONAL, "Desired mismatch for asini spacing");
XLALregREALUserStruct ( mismatchT, 0, UVAR_OPTIONAL, "Desired mismatch for periapse passage time spacing");
XLALregREALUserStruct ( mismatchP, 0, UVAR_OPTIONAL, "Desired mismatch for period spacing");
XLALregREALUserStruct ( spacingF, 0, UVAR_OPTIONAL, "Desired frequency spacing");
XLALregREALUserStruct ( spacingA, 0, UVAR_OPTIONAL, "Desired asini spacing");
XLALregREALUserStruct ( spacingT, 0, UVAR_OPTIONAL, "Desired periapse passage time spacing");
XLALregREALUserStruct ( spacingP, 0, UVAR_OPTIONAL, "Desired period spacing");
XLALregINTUserStruct ( numCand, 0, UVAR_OPTIONAL, "Number of candidates to keep in toplist");
XLALregSTRINGUserStruct( pairListInputFilename, 0, UVAR_OPTIONAL, "Name of file from which to read list of SFT pairs");
XLALregSTRINGUserStruct( pairListOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write list of SFT pairs");
XLALregSTRINGUserStruct( sftListOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write list of SFTs (for sanity checks)");
XLALregSTRINGUserStruct( sftListInputFilename, 0, UVAR_OPTIONAL, "Name of file to which to read in list of SFTs (for sanity checks)");
XLALregSTRINGUserStruct( gammaAveOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write aa+bb weights (for e.g., false alarm estimation)");
XLALregSTRINGUserStruct( gammaCircOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write ab-ba weights (for e.g., systematic error)");
XLALregSTRINGUserStruct( toplistFilename, 0, UVAR_OPTIONAL, "Output filename containing candidates in toplist");
XLALregSTRINGUserStruct( logFilename, 0, UVAR_OPTIONAL, "Output a meta-data file for the search");
XLALregBOOLUserStruct ( version, 'V', UVAR_SPECIAL, "Output version(VCS) information");
if ( xlalErrno ) {
XLALPrintError ("%s: user variable initialization failed with errno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
return XLAL_SUCCESS;
}
// Initialise test array data
for ( size_t i = 0; i < XLAL_NUM_ELEM( testarray ); ++i ) {
for ( size_t j = 0; j < XLAL_NUM_ELEM( testarray[0] ); ++j ) {
testarray[i][j] = LAL_PI*i - LAL_E*j;
}
}
// Create a dummy user enviroment and command line, for testing XLALFITSFileWriteUVarCmdLine()
struct uvar_type { INT4 dummy; } uvar_struct = { .dummy = 0 };
struct uvar_type *const uvar = &uvar_struct;
XLAL_CHECK_MAIN( XLALRegisterUvarMember( dummy, INT4, 0, OPTIONAL, "Dummy option" ) == XLAL_SUCCESS, XLAL_EFUNC );
BOOLEAN should_exit = 0;
XLAL_CHECK_MAIN( argc > 0, XLAL_ESYS );
char *my_argv[] = { argv[0], XLALStringDuplicate( "--dummy=3" ) };
XLAL_CHECK_MAIN( XLALUserVarReadAllInput( &should_exit, XLAL_NUM_ELEM( my_argv ), my_argv, lalPulsarVCSInfoList ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK_MAIN( !should_exit, XLAL_EFAILED );
XLALFree( my_argv[1] );
// Write an example FITS file
{
FITSFile *file = XLALFITSFileOpenWrite( "FITSFileIOTest.fits" );
XLAL_CHECK_MAIN( file != NULL, XLAL_EFUNC );
XLAL_CHECK_MAIN( XLALFITSFileWriteVCSInfo( file, lalPulsarVCSInfoList ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK_MAIN( XLALFITSFileWriteUVarCmdLine( file ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK_MAIN( XLALFITSHeaderWriteComment( file, "%s\n%s", "This is a test comment", longstring_ref ) == XLAL_SUCCESS, XLAL_EFUNC );
fprintf( stderr, "PASSED: opened 'FITSFileIOTest.fits' for writing\n" );
XLAL_CHECK_MAIN( XLALFITSHeaderWriteBOOLEAN( file, "testbool", 1, "This is a test BOOLEAN" ) == XLAL_SUCCESS, XLAL_EFUNC );
fprintf( stderr, "PASSED: wrote a BOOLEAN\n" );
/* ----- function definitions ---------- */
int
main ( int argc, char *argv[] )
{
LALStatus status;
UserInput_t uvar_s;
UserInput_t *uvar = &uvar_s;
INIT_MEM ( status );
INIT_MEM ( uvar_s );
struct tms buf;
uvar->randSeed = times(&buf);
// ---------- register all our user-variable ----------
XLALregBOOLUserStruct ( help, 'h', UVAR_HELP , "Print this help/usage message");
XLALregINTUserStruct ( randSeed, 's', UVAR_OPTIONAL, "Specify random-number seed for reproducible noise.");
/* read cmdline & cfgfile */
XLAL_CHECK ( XLALUserVarReadAllInput ( argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( uvar->help ) { /* if help was requested, we're done */
exit (0);
}
srand ( uvar->randSeed );
REAL8 startTimeREAL8 = 714180733;
REAL8 duration = 180000; /* 50 hours */
REAL8 Tsft = 1800; /* assume 30min SFTs */
char earthEphem[] = TEST_DATA_DIR "earth00-19-DE200.dat.gz";
char sunEphem[] = TEST_DATA_DIR "sun00-19-DE200.dat.gz";
//REAL8 tolerance = 2e-10; /* same algorithm, should be basically identical results */
LIGOTimeGPS startTime, refTime;
XLALGPSSetREAL8 ( &startTime, startTimeREAL8 );
refTime = startTime;
// pick skyposition at random ----- */
SkyPosition skypos;
skypos.longitude = LAL_TWOPI * (1.0 * rand() / ( RAND_MAX + 1.0 ) ); // alpha uniform in [0, 2pi)
skypos.latitude = LAL_PI_2 - acos ( 1 - 2.0 * rand()/RAND_MAX ); // sin(delta) uniform in [-1,1]
skypos.system = COORDINATESYSTEM_EQUATORIAL;
// pick binary orbital parameters:
// somewhat inspired by Sco-X1 parameters from S2-paper (PRD76, 082001 (2007), gr-qc/0605028)
// but with a more extreme eccentricity, and random argp
REAL8 argp = LAL_TWOPI * (1.0 * rand() / ( RAND_MAX + 1.0 ) ); // uniform in [0, 2pi)
BinaryOrbitParams orbit;
XLALGPSSetREAL8 ( &orbit.tp, 731163327 ); // time of observed periapsis passage (in SSB)
orbit.argp = argp; // argument of periapsis (radians)
orbit.asini = 1.44; // projected, normalized orbital semi-major axis (s) */
orbit.ecc = 1e-2; // relatively large value, for better testing
orbit.period = 68023; // period (s) : about ~18.9h
// ----- step 0: prepare test-case input for calling the BinarySSB-functions
// setup detectors
const char *sites[3] = { "H1", "L1", "V1" };
UINT4 numDetectors = sizeof( sites ) / sizeof ( sites[0] );
MultiLALDetector multiIFO;
multiIFO.length = numDetectors;
for ( UINT4 X = 0; X < numDetectors; X ++ )
{
LALDetector *det = XLALGetSiteInfo ( sites[X] );
XLAL_CHECK ( det != NULL, XLAL_EFUNC, "XLALGetSiteInfo ('%s') failed for detector X=%d\n", sites[X], X );
multiIFO.sites[X] = (*det); // struct copy
XLALFree ( det );
}
// load ephemeris
EphemerisData *edat = XLALInitBarycenter ( earthEphem, sunEphem );
XLAL_CHECK ( edat != NULL, XLAL_EFUNC, "XLALInitBarycenter('%s','%s') failed\n", earthEphem, sunEphem );
// setup multi-timeseries
MultiLIGOTimeGPSVector *multiTS;
XLAL_CHECK ( (multiTS = XLALCalloc ( 1, sizeof(*multiTS))) != NULL, XLAL_ENOMEM );
XLAL_CHECK ( (multiTS->data = XLALCalloc (numDetectors, sizeof(*multiTS->data))) != NULL, XLAL_ENOMEM );
multiTS->length = numDetectors;
for ( UINT4 X = 0; X < numDetectors; X ++ )
{
multiTS->data[X] = XLALMakeTimestamps ( startTime, duration, Tsft, 0 );
XLAL_CHECK ( multiTS->data[X] != NULL, XLAL_EFUNC, "XLALMakeTimestamps() failed.\n");
} /* for X < numIFOs */
// generate detector-states
MultiDetectorStateSeries *multiDetStates = XLALGetMultiDetectorStates ( multiTS, &multiIFO, edat, 0 );
XLAL_CHECK ( multiDetStates != NULL, XLAL_EFUNC, "XLALGetMultiDetectorStates() failed.\n");
// generate isolated-NS SSB times
MultiSSBtimes *multiSSBIn = XLALGetMultiSSBtimes ( multiDetStates, skypos, refTime, SSBPREC_RELATIVISTICOPT );
XLAL_CHECK ( multiSSBIn != NULL, XLAL_EFUNC, "XLALGetMultiSSBtimes() failed.\n");
// ----- step 1: compute reference-result using old LALGetMultiBinarytimes()
MultiSSBtimes *multiBinary_ref = NULL;
LALGetMultiBinarytimes (&status, &(multiBinary_ref), multiSSBIn, multiDetStates, &orbit, refTime );
XLAL_CHECK ( status.statusCode == 0, XLAL_EFAILED, "LALGetMultiBinarytimes() failed with status = %d : '%s'\n", status.statusCode, status.statusDescription );
// ----- step 2: compute test-result using new XLALAddMultiBinaryTimes()
MultiSSBtimes *multiBinary_test = NULL;
PulsarDopplerParams doppler;
memset(&doppler, 0, sizeof(doppler));
doppler.tp = orbit.tp;
doppler.argp = orbit.argp;
doppler.asini = orbit.asini;
doppler.ecc = orbit.ecc;
doppler.period = orbit.period;
XLAL_CHECK ( XLALAddMultiBinaryTimes ( &multiBinary_test, multiSSBIn, &doppler ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- step 3: compare results
REAL8 err_DeltaT, err_Tdot;
REAL8 tolerance = 1e-10;
int ret = XLALCompareMultiSSBtimes ( &err_DeltaT, &err_Tdot, multiBinary_ref, multiBinary_test );
XLAL_CHECK ( ret == XLAL_SUCCESS, XLAL_EFUNC, "XLALCompareMultiSSBtimes() failed.\n");
XLALPrintWarning ( "INFO: err(DeltaT) = %g, err(Tdot) = %g\n", err_DeltaT, err_Tdot );
XLAL_CHECK ( err_DeltaT < tolerance, XLAL_ETOL, "error(DeltaT) = %g exceeds tolerance of %g\n", err_DeltaT, tolerance );
XLAL_CHECK ( err_Tdot < tolerance, XLAL_ETOL, "error(Tdot) = %g exceeds tolerance of %g\n", err_Tdot, tolerance );
// ---- step 4: clean-up memory
XLALDestroyUserVars();
XLALDestroyEphemerisData ( edat );
XLALDestroyMultiSSBtimes ( multiBinary_test );
XLALDestroyMultiSSBtimes ( multiBinary_ref );
XLALDestroyMultiSSBtimes ( multiSSBIn );
XLALDestroyMultiTimestamps ( multiTS );
XLALDestroyMultiDetectorStateSeries ( multiDetStates );
// check for memory-leaks
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
/**
* Register all "user-variables", and initialized them from command-line and config-files
*/
int
XLALInitUserVars ( UserVariables_t *uvar, int argc, char *argv[] )
{
XLAL_CHECK ( uvar != NULL, XLAL_EINVAL, "Invalid NULL input 'uvar'\n");
XLAL_CHECK ( argv != NULL, XLAL_EINVAL, "Invalid NULL input 'argv'\n");
// ---------- set a few defaults ----------
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->Tsft = 1800;
uvar->fmin = 0; /* no heterodyning by default */
uvar->Band = 8192; /* 1/2 LIGO sampling rate by default */
#define MISC_DEFAULT "mfdv5"
XLAL_CHECK ( (uvar->outLabel = XLALStringDuplicate ( MISC_DEFAULT )) != NULL, XLAL_EFUNC );
// ---------- register all our user-variable ----------
/* output options */
XLALRegisterUvarMember( outSingleSFT, BOOLEAN, 's', OPTIONAL, "Write a single concatenated SFT file instead of individual files" );
XLALRegisterUvarMember( outSFTdir, STRING, 'n', OPTIONAL, "Output SFTs: directory for output SFTs");
XLALRegisterUvarMember( outLabel, STRING, 0, OPTIONAL, "'misc' entry in SFT-filenames or 'description' entry of frame filenames" );
XLALRegisterUvarMember( TDDfile, STRING, 't', OPTIONAL, "Filename to output time-series into");
XLALRegisterUvarMember( logfile, STRING, 'l', OPTIONAL, "Filename for log-output");
/* detectors and respective noise-floors */
XLALRegisterUvarMember( IFOs, STRINGVector, 'I', OPTIONAL, "CSV list of detectors, eg. \"H1,H2,L1,G1, ...\" ");
XLALRegisterUvarMember( sqrtSX, STRINGVector, 0, OPTIONAL, "Add Gaussian Noise: CSV list of detectors' noise-floors sqrt{Sn}");
XLALRegisterUvarMember( ephemEarth, STRING, 0, OPTIONAL, "Earth ephemeris file to use");
XLALRegisterUvarMember( ephemSun, STRING, 0, OPTIONAL, "Sun ephemeris file to use");
/* start + duration of timeseries */
XLALRegisterUvarMember(startTime, EPOCH, 'G', OPTIONAL, "Start-time of requested signal in detector-frame (format 'xx.yy[GPS|MJD]')");
XLALRegisterUvarMember( duration, INT4, 0, OPTIONAL, "Duration of requested signal in seconds");
XLALRegisterUvarMember( timestampsFiles, STRINGVector, 0, OPTIONAL, "ALTERNATIVE: File to read timestamps from (file-format: lines with <seconds> <nanoseconds>)");
/* sampling and heterodyning frequencies */
XLALRegisterUvarMember( fmin, REAL8, 0, OPTIONAL, "Lowest frequency in output SFT (= heterodyning frequency)");
XLALRegisterUvarMember( Band, REAL8, 0, OPTIONAL, "Bandwidth of output SFT in Hz (= 1/2 sampling frequency)");
/* SFT properties */
XLALRegisterUvarMember( Tsft, REAL8, 0, OPTIONAL, "Time baseline of one SFT in seconds");
XLALRegisterUvarMember( SFToverlap, REAL8, 0, OPTIONAL, "Overlap between successive SFTs in seconds (conflicts with --noiseSFTs or --timestampsFiles)");
XLALRegisterUvarMember( SFTWindowType, STRING, 0, OPTIONAL, "Window function to be applied to the SFTs (required when using --noiseSFTs)");
XLALRegisterUvarMember( SFTWindowBeta, REAL8, 0, OPTIONAL, "Window 'beta' parameter required for a few window-types (eg. 'tukey')");
/* pulsar params */
XLALRegisterUvarMember( injectionSources, STRINGVector, 0, OPTIONAL, "Source parameters to inject: comma-separated list of file-patterns and/or direct config-strings ('{...}')" );
/* noise */
XLALRegisterUvarMember( noiseSFTs, STRING, 'D', OPTIONAL, "Noise-SFTs to be added to signal (Used also to set IFOs and timestamps)");
/* frame input/output options */
#ifdef HAVE_LIBLALFRAME
XLALRegisterUvarMember ( outFrameDir, STRING, 'F', OPTIONAL, "Output Frames: directory for output timeseries frame files");
XLALRegisterUvarMember ( inFrames, STRINGVector,'C', OPTIONAL, "CSV list (one per IFO) of input frame cache files");
XLALRegisterUvarMember ( inFrChannels, STRINGVector,'N', OPTIONAL, "CSV list (one per IFO) of frame channels to read timeseries from");
XLALRegisterUvarMember ( outFrChannels, STRINGVector, 0, NODEFAULT, "CSV list (one per IFO) of output frame channel names [default: <inFrChannels>-<outLabel> or <IFO>:<outLabel>]");
#else
XLALRegisterUvarMember ( outFrameDir, STRING, 'F', DEFUNCT, "Need to compile with lalframe support for this option to work");
XLALRegisterUvarMember ( inFrames, STRINGVector, 'C', DEFUNCT, "Need to compile with lalframe support for this option to work");
XLALRegisterUvarMember ( inFrChannels, STRINGVector, 'N', DEFUNCT, "Need to compile with lalframe support for this option to work");
XLALRegisterUvarMember ( outFrChannels, STRINGVector, 0, DEFUNCT, "Need to compile with lalframe support for this option to work");
#endif
XLALRegisterUvarMember( version, BOOLEAN, 'V', SPECIAL, "Output version information");
// ----- 'expert-user/developer' options ----- (only shown in help at lalDebugLevel >= warning)
XLALRegisterUvarMember( randSeed, INT4, 0, DEVELOPER, "Specify random-number seed for reproducible noise (0 means use /dev/urandom for seeding).");
// ----- deprecated but still supported options [throw warning if used] (only shown in help at lalDebugLevel >= info) ----------
#ifdef HAVE_LIBLALFRAME
XLALRegisterUvarMember ( TDDframedir, STRING, 0, DEPRECATED, "Use --outFrameDir instead");
#else
XLALRegisterUvarMember ( TDDframedir, STRING, 0, DEFUNCT, "Need to compile with lalframe support. BUT this option is deprecated and --outFrameDir should be used instead");
#endif
// ----- obsolete and unsupported options [throw error if used] (never shown in help) ----------
/* read cmdline & cfgfile */
BOOLEAN should_exit = 0;
XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( should_exit ) {
exit (1);
}
return XLAL_SUCCESS;
} /* XLALInitUserVars() */
