/** register all "user-variables" */
int
XLALInitUserVars ( UserVariables_t *uvar )
{
XLAL_CHECK ( uvar != NULL, XLAL_EINVAL );
/* set a few defaults */
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->timeGPS = 714180733;
/* register all user-variables */
XLALRegisterUvarMember( detector, STRING, 'I', REQUIRED, "Detector name (eg. H1,H2,L1,G1,etc).");
XLALRegisterUvarMember( Alpha, REAL8, 'a', OPTIONAL, "skyposition Alpha in radians, equatorial coords.");
XLALRegisterUvarMember( Delta, REAL8, 'd', OPTIONAL, "skyposition Delta in radians, equatorial coords.");
XLALRegisterUvarMember( timeGPS, REAL8, 't', OPTIONAL, "GPS time at which to compute detector state");
XLALRegisterUvarMember( ephemEarth, STRING, 0, OPTIONAL, "Earth ephemeris file to use");
XLALRegisterUvarMember( ephemSun, STRING, 0, OPTIONAL, "Sun ephemeris file to use");
XLALRegisterUvarMember( version, BOOLEAN, 'V', SPECIAL, "Output code version");
return XLAL_SUCCESS;
} /* XLALInitUserVars() */
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;
}
/* register all our "user-variables" */
int
initUserVars ( UserInput_t *uvar )
{
XLAL_CHECK ( uvar != NULL, XLAL_EINVAL );
/* set some defaults */
uvar->debug = lalDebugLevel;
uvar->verbose = 0;
uvar->relErrorMax = 1e-4;
/* now register all our user-variable */
XLALRegisterUvarMember( help, BOOLEAN, 'h', HELP, "Print this help/usage message");
XLALRegisterUvarMember( sftBname1, STRING, '1', REQUIRED, "Path and basefilename for SFTs1");
XLALRegisterUvarMember( sftBname2, STRING, '2', REQUIRED, "Path and basefilename for SFTs2");
XLALRegisterUvarMember( verbose, BOOLEAN, 'v', OPTIONAL, "Verbose output of differences");
XLALRegisterUvarMember( relErrorMax, REAL8, 'e', OPTIONAL, "Maximal relative error acceptable to 'pass' comparison");
return XLAL_SUCCESS;
} /* initUserVars() */
/** register all "user-variables" */
int
initUserVars (UserVariables_t *uvar)
{
/* set a few defaults */
uvar->help = FALSE;
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->Freq = 100;
uvar->f1dot = 0.0;
uvar->f2dot = 0.0;
uvar->f3dot = 0.0;
uvar->h0 = 1;
uvar->phi0 = 0;
uvar->startTime.gpsSeconds = 714180733;
uvar->duration = 10 * 3600;
uvar->Nseg = 1;
uvar->segmentList = NULL;
uvar->refTime.gpsSeconds = -1; /* default: use mid-time */
uvar->projection = 0;
if ( (uvar->IFOs = XLALCreateStringVector ( "H1", NULL )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Call to XLALCreateStringVector() failed with xlalErrno = %d\n", xlalErrno );
XLAL_ERROR ( XLAL_ENOMEM );
}
uvar->sqrtSX = NULL;
uvar->detMotionStr = XLALStringDuplicate(XLALDetectorMotionName(DETMOTION_SPIN | DETMOTION_ORBIT));
uvar->metricType = 0; /* by default: compute only phase metric */
if ( (uvar->coords = XLALCreateStringVector ( "freq", "alpha", "delta", "f1dot", NULL )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Call to XLALCreateStringVector() failed with xlalErrno = %d\n", xlalErrno );
XLAL_ERROR ( XLAL_ENOMEM );
}
uvar->approxPhase = FALSE;
/* register all our user-variables */
XLALRegisterUvarMember(help, BOOLEAN, 'h', HELP, "Print this help/usage message");
XLALRegisterUvarMember(IFOs, STRINGVector, 'I', OPTIONAL, "CSV list of detectors, eg. \"H1,H2,L1,G1, ...\" ");
XLALRegisterUvarMember(sqrtSX, STRINGVector, 0, OPTIONAL, "[for F-metric weights] CSV list of detectors' noise-floors sqrt{Sn}");
XLALRegisterUvarMember(Alpha, RAJ, 'a', OPTIONAL, "Sky: equatorial J2000 right ascension (in radians or hours:minutes:seconds)");
XLALRegisterUvarMember(Delta, DECJ, 'd', OPTIONAL, "Sky: equatorial J2000 declination (in radians or degrees:minutes:seconds)");
XLALRegisterUvarMember(Freq, REAL8, 'f', OPTIONAL, "Target frequency");
XLALRegisterUvarMember(f1dot, REAL8, 's', OPTIONAL, "First spindown-value df/dt");
XLALRegisterUvarMember(f2dot, REAL8, 0 , OPTIONAL, "Second spindown-value d2f/dt2");
XLALRegisterUvarMember(f3dot, REAL8, 0 , OPTIONAL, "Third spindown-value d3f/dt3");
XLALRegisterUvarMember ( orbitasini, REAL8, 0, OPTIONAL, "Target projected semimajor axis of binary orbit (Units: light seconds)");
XLALRegisterUvarMember ( orbitPeriod, REAL8, 0, OPTIONAL, "Target period of binary orbit (Units: s).");
XLALRegisterUvarMember ( orbitTp, EPOCH, 0, OPTIONAL, "Target time of periapse passage of the CW source in a binary orbit (Units: GPS seconds)");
XLALRegisterUvarMember ( orbitArgp, REAL8, 0, OPTIONAL, "Target argument of periapse of binary orbit (Units: rad)");
XLALRegisterUvarMember ( orbitEcc, REAL8, 0, OPTIONAL, "Target eccentricity of binary orbit (Units: none)");
XLALRegisterUvarMember(refTime, EPOCH, 0, OPTIONAL, "Reference epoch for phase-evolution parameters (format 'xx.yy[GPS|MJD]'). [0=startTime, default=mid-time]");
XLALRegisterUvarMember(startTime, EPOCH, 't', OPTIONAL, "Start time of observation (format 'xx.yy[GPS|MJD]')");
XLALRegisterUvarMember(duration, REAL8, 'T', OPTIONAL, "Duration of observation in seconds");
XLALRegisterUvarMember(Nseg, INT4, 'N', OPTIONAL, "Compute semi-coherent metric for this number of segments within 'duration'" );
XLALRegisterUvarMember(segmentList, STRING, 0, OPTIONAL, "ALTERNATIVE: specify segment file with format: repeated lines <startGPS endGPS duration[h] NumSFTs>");
XLALRegisterUvarMember( ephemEarth, STRING, 0, OPTIONAL, "Earth ephemeris file to use");
XLALRegisterUvarMember( ephemSun, STRING, 0, OPTIONAL, "Sun ephemeris file to use");
XLALRegisterUvarMember(h0, REAL8, 0, OPTIONAL, "GW amplitude h0" );
XLALRegisterUvarMember(cosi, REAL8, 0, OPTIONAL, "Pulsar orientation-angle cos(iota) [-1,1]" );
XLALRegisterUvarMember(psi, REAL8, 0, OPTIONAL, "Wave polarization-angle psi [0, pi]" );
XLALRegisterUvarMember(phi0, REAL8, 0, OPTIONAL, "GW initial phase phi_0 [0, 2pi]" );
XLALRegisterUvarMember(metricType, INT4, 0, OPTIONAL, "type of metric to compute: 0=phase-metric, 1=F-metric(s), 2=both" );
XLALRegisterUvarMember(outputMetric, STRING, 'o', OPTIONAL, "Output the metric components (in octave format) into this file.");
XLALRegisterUvarMember(projection, INT4, 0, OPTIONAL, "Project onto subspace orthogonal to this axis: 0=none, 1=1st-coord, 2=2nd-coord etc");
XLALRegisterUvarMember(coords, STRINGVector, 'c', OPTIONAL, "Doppler-coordinates to compute metric in (see --coordsHelp)");
XLALRegisterUvarMember(coordsHelp, BOOLEAN, 0, OPTIONAL, "output help-string explaining all the possible Doppler-coordinate names for --coords");
XLALRegisterUvarMember(detMotionStr, STRING, 0, DEVELOPER, "Detector-motion string: S|O|S+O where S=spin|spinz|spinxy and O=orbit|ptoleorbit");
XLALRegisterUvarMember(approxPhase, BOOLEAN, 0, DEVELOPER, "Use an approximate phase-model, neglecting Roemer delay in spindown coordinates (or orders >= 1)");
XLALRegisterUvarMember(version, BOOLEAN, 'V', SPECIAL, "Output code version");
return XLAL_SUCCESS;
} /* initUserVars() */
/**
* 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()
/**
* 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() */
/** 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;
}
/** 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;
}
/** 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;
}
// ---------- 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 ----------
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()
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;
}
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;
}
};
int main( int argc, char *argv[] )
{
// 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" );
/** 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() */
/**
* Register all our "user-variables" that can be specified from cmd-line and/or config-file.
* Here we set defaults for some user-variables and register them with the UserInput module.
*/
int
XLALInitUserVars ( UserInput_t *uvar )
{
/* set a few defaults */
uvar->help = 0;
uvar->outputStats = NULL;
uvar->Alpha = -1; /* Alpha < 0 indicates "allsky" */
uvar->Delta = 0;
uvar->phi0 = 0;
uvar->psi = 0;
uvar->dataStartGPS = 814838413; /* 1 Nov 2005, ~ start of S5 */
uvar->dataDuration = (INT4) round ( LAL_YRSID_SI ); /* 1 year of data */
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->numDraws = 1;
uvar->TAtom = 1800;
uvar->computeFtotal = 0;
uvar->useFReg = 0;
uvar->fixedh0Nat = -1;
uvar->fixedSNR = -1;
uvar->fixedh0NatMax = -1;
uvar->fixedRhohMax = -1;
#define DEFAULT_IFO "H1"
uvar->IFO = XLALMalloc ( strlen(DEFAULT_IFO)+1 );
strcpy ( uvar->IFO, DEFAULT_IFO );
/* ---------- transient window defaults ---------- */
#define DEFAULT_TRANSIENT "rect"
uvar->injectWindow_type = XLALMalloc(strlen(DEFAULT_TRANSIENT)+1);
strcpy ( uvar->injectWindow_type, DEFAULT_TRANSIENT );
uvar->searchWindow_type = XLALMalloc(strlen(DEFAULT_TRANSIENT)+1);
strcpy ( uvar->searchWindow_type, DEFAULT_TRANSIENT );
uvar->injectWindow_tauDays = 1.0;
uvar->injectWindow_tauDaysBand = 13.0;
REAL8 tauMaxDays = ( uvar->injectWindow_tauDays + uvar->injectWindow_tauDaysBand );
/* default window-ranges are t0 in [dataStartTime, dataStartTime - 3 * tauMax] */
uvar->injectWindow_t0Days = 0; // offset in days from uvar->dataStartGPS
uvar->injectWindow_t0DaysBand = fmax ( 0.0, 1.0*uvar->dataDuration/DAY24 - TRANSIENT_EXP_EFOLDING * tauMaxDays ); /* make sure it's >= 0 */
/* search-windows by default identical to inject-windows */
uvar->searchWindow_t0Days = uvar->injectWindow_t0Days;
uvar->searchWindow_t0DaysBand = uvar->injectWindow_t0DaysBand;
uvar->searchWindow_tauDays = uvar->injectWindow_tauDays;
uvar->searchWindow_tauDaysBand = uvar->injectWindow_tauDaysBand;
uvar->searchWindow_dt0 = uvar->TAtom;
uvar->searchWindow_dtau = uvar->TAtom;
/* register all our user-variables */
XLALRegisterUvarMember( help, BOOLEAN, 'h', HELP, "Print this message");
/* signal Doppler parameters */
XLALRegisterUvarMember( Alpha, REAL8, 'a', OPTIONAL, "Sky position alpha (equatorial coordinates) in radians [Default:allsky]");
XLALRegisterUvarMember( Delta, REAL8, 'd', OPTIONAL, "Sky position delta (equatorial coordinates) in radians [Default:allsky]");
/* signal amplitude parameters */
XLALRegisterUvarMember( fixedh0Nat, REAL8, 0, OPTIONAL, "Alternative 1: if >=0 fix the GW amplitude: h0/sqrt(Sn)");
XLALRegisterUvarMember( fixedSNR, REAL8, 0, OPTIONAL, "Alternative 2: if >=0 fix the optimal SNR of the injected signals");
XLALRegisterUvarMember( fixedh0NatMax, REAL8, 0, OPTIONAL, "Alternative 3: if >=0 draw GW amplitude h0 in [0, h0NatMax ] (FReg prior)");
XLALRegisterUvarMember( fixedRhohMax, REAL8, 0, OPTIONAL, "Alternative 4: if >=0 draw rhoh=h0*(detM)^(1/8) in [0, rhohMax] (canonical F-stat prior)");
XLALRegisterUvarMember( cosi, REAL8, 'i', OPTIONAL, "cos(inclination angle). If not set: randomize within [-1,1].");
XLALRegisterUvarMember( psi, REAL8, 0, OPTIONAL, "polarization angle psi. If not set: randomize within [-pi/4,pi/4].");
XLALRegisterUvarMember( phi0, REAL8, 0, OPTIONAL, "initial GW phase phi_0. If not set: randomize within [0, 2pi]");
XLALRegisterUvarMember( AmpPriorType, INT4, 0, OPTIONAL, "Enumeration of types of amplitude-priors: 0=physical, 1=canonical");
XLALRegisterUvarMember( IFO, STRING, 'I', OPTIONAL, "Detector: 'G1','L1','H1,'H2', 'V1', ... ");
XLALRegisterUvarMember( dataStartGPS, INT4, 0, OPTIONAL, "data start-time in GPS seconds");
XLALRegisterUvarMember( dataDuration, INT4, 0, OPTIONAL, "data-span to generate (in seconds)");
/* transient window ranges: for injection ... */
XLALRegisterUvarMember( injectWindow_type, STRING, 0, OPTIONAL, "Type of transient window to inject ('none', 'rect', 'exp')");
XLALRegisterUvarMember( injectWindow_tauDays, REAL8, 0, OPTIONAL, "Shortest transient-window timescale to inject, in days");
XLALRegisterUvarMember( injectWindow_tauDaysBand,REAL8, 0,OPTIONAL,"Range of transient-window timescale to inject, in days");
XLALRegisterUvarMember( injectWindow_t0Days, REAL8, 0, OPTIONAL, "Earliest start-time of transient window to inject, as offset in days from dataStartGPS");
XLALRegisterUvarMember( injectWindow_t0DaysBand,REAL8, 0,OPTIONAL,"Range of GPS start-time of transient window to inject, in days [Default:dataDuration-3*tauMax]");
/* ... and for search */
XLALRegisterUvarMember( searchWindow_type, STRING, 0, OPTIONAL, "Type of transient window to search with ('none', 'rect', 'exp') [Default:injectWindow]");
XLALRegisterUvarMember( searchWindow_tauDays, REAL8, 0, OPTIONAL, "Shortest transient-window timescale to search, in days [Default:injectWindow]");
XLALRegisterUvarMember( searchWindow_tauDaysBand,REAL8, 0,OPTIONAL, "Range of transient-window timescale to search, in days [Default:injectWindow]");
XLALRegisterUvarMember( searchWindow_t0Days, REAL8, 0, OPTIONAL, "Earliest start-time of transient window to search, as offset in days from dataStartGPS [Default:injectWindow]");
XLALRegisterUvarMember( searchWindow_t0DaysBand,REAL8, 0,OPTIONAL, "Range of GPS start-time of transient window to search, in days [Default:injectWindow]");
XLALRegisterUvarMember( searchWindow_dtau, INT4, 0, OPTIONAL, "Step-size for search/marginalization over transient-window timescale, in seconds [Default:TAtom]");
XLALRegisterUvarMember( searchWindow_dt0, INT4, 0, OPTIONAL, "Step-size for search/marginalization over transient-window start-time, in seconds [Default:TAtom]");
/* misc params */
XLALRegisterUvarMember( computeFtotal, BOOLEAN, 0, OPTIONAL, "Also compute 'total' F-statistic over the full data-span" );
XLALRegisterUvarMember( numDraws, INT4, 'N', OPTIONAL,"Number of random 'draws' to simulate");
XLALRegisterUvarMember( randSeed, INT4, 0, OPTIONAL, "GSL random-number generator seed value to use");
XLALRegisterUvarMember( outputStats, STRING, 'o', OPTIONAL, "Output file containing 'numDraws' random draws of stats");
XLALRegisterUvarMember( outputAtoms, STRING, 0, OPTIONAL, "Output F-statistic atoms into a file with this basename");
XLALRegisterUvarMember( outputFstatMap, STRING, 0, OPTIONAL, "Output F-statistic over 2D parameter space {t0, tau} into file with this basename");
XLALRegisterUvarMember( outputInjParams, STRING, 0, OPTIONAL, "Output injection parameters into this file");
XLALRegisterUvarMember( outputPosteriors, STRING, 0, OPTIONAL, "output posterior pdfs on t0 and tau (in octave format) into this file ");
XLALRegisterUvarMember( SignalOnly, BOOLEAN, 'S', OPTIONAL, "Signal only: generate pure signal without noise");
XLALRegisterUvarMember( useFReg, BOOLEAN, 0, OPTIONAL, "use 'regularized' Fstat (1/D)*e^F (if TRUE) for marginalization, or 'standard' e^F (if FALSE)");
XLALRegisterUvarMember( ephemEarth, STRING, 0, OPTIONAL, "Earth ephemeris file to use");
XLALRegisterUvarMember( ephemSun, STRING, 0, OPTIONAL, "Sun ephemeris file to use");
XLALRegisterUvarMember( version, BOOLEAN, 'V', SPECIAL, "Output code version");
/* 'hidden' stuff */
XLALRegisterUvarMember( TAtom, INT4, 0, DEVELOPER, "Time baseline for Fstat-atoms (typically Tsft) in seconds." );
if ( xlalErrno ) {
XLALPrintError ("%s: something failed in initializing user variabels .. errno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
return XLAL_SUCCESS;
} /* XLALInitUserVars() */
/** 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 our "user-variables" that can be specified from cmd-line and/or config-file.
* Here we set defaults for some user-variables and register them with the UserInput module.
*/
int
XLALInitUserVars ( UserInput_t *uvar )
{
/* set a few defaults */
uvar->outputStats = NULL;
uvar->Alpha = -1; /* Alpha < 0 indicates "allsky" */
uvar->Delta = 0;
uvar->phi0 = 0;
uvar->psi = 0;
uvar->dataStartGPS = 814838413; /* 1 Nov 2005, ~ start of S5 */
uvar->dataDuration = (INT4) round ( LAL_YRSID_SI ) ; /* 1 year of data */
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->numDraws = 1;
uvar->TAtom = 1800;
uvar->computeBSGL = 1;
uvar->Fstar0 = -LAL_REAL4_MAX; /* corresponding to OSL limit */
uvar->oLGX = NULL;
uvar->sqrtSX = NULL;
uvar->useFReg = 0;
uvar->fixedh0Nat = -1;
uvar->fixedSNR = -1;
uvar->fixedh0NatMax = -1;
uvar->fixedRhohMax = -1;
if ( (uvar->IFOs = XLALCreateStringVector ( "H1", NULL )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Call to XLALCreateStringVector() failed with xlalErrno = %d\n", xlalErrno );
XLAL_ERROR ( XLAL_ENOMEM );
}
uvar->lineIFO = NULL;
/* ---------- transient window defaults ---------- */
#define DEFAULT_TRANSIENT "rect"
/* register all our user-variables */
/* signal Doppler parameters */
XLALRegisterUvarMember( Alpha, REAL8, 'a', OPTIONAL, "Sky position alpha (equatorial coordinates) in radians [Default:allsky]");
XLALRegisterUvarMember( Delta, REAL8, 'd', OPTIONAL, "Sky position delta (equatorial coordinates) in radians [Default:allsky]");
/* signal amplitude parameters */
XLALRegisterUvarMember( fixedh0Nat, REAL8, 0, OPTIONAL, "Alternative 1: if >=0 fix the GW amplitude: h0/sqrt(Sn)");
XLALRegisterUvarMember( fixedSNR, REAL8, 0, OPTIONAL, "Alternative 2: if >=0 fix the optimal SNR of the injected signals");
XLALRegisterUvarMember( fixedh0NatMax, REAL8, 0, OPTIONAL, "Alternative 3: if >=0 draw GW amplitude h0 in [0, h0NatMax ] (FReg prior)");
XLALRegisterUvarMember( fixedRhohMax, REAL8, 0, OPTIONAL, "Alternative 4: if >=0 draw rhoh=h0*(detM)^(1/8) in [0, rhohMax] (canonical F-stat prior)");
XLALRegisterUvarMember( cosi, REAL8, 'i', OPTIONAL, "cos(inclination angle). If not set: randomize within [-1,1].");
XLALRegisterUvarMember( psi, REAL8, 0, OPTIONAL, "polarization angle psi. If not set: randomize within [-pi/4,pi/4].");
XLALRegisterUvarMember( phi0, REAL8, 0, OPTIONAL, "initial GW phase phi_0. If not set: randomize within [0, 2pi]");
XLALRegisterUvarMember( AmpPriorType, INT4, 0, OPTIONAL, "Enumeration of types of amplitude-priors: 0=physical, 1=canonical");
XLALRegisterUvarMember( IFOs, STRINGVector, 'I', OPTIONAL, "Comma-separated list of detectors, eg. \"H1,H2,L1,G1, ...\" ");
XLALRegisterUvarMember( lineIFO, STRING, 0, OPTIONAL, "Insert a line (signal in this one IFO, pure gaussian noise in others), e.g. \"H1\"");
XLALRegisterUvarMember( dataStartGPS, INT4, 0, OPTIONAL, "data start-time in GPS seconds");
XLALRegisterUvarMember( dataDuration, INT4, 0, OPTIONAL, "data-span to generate (in seconds)");
/* misc params */
XLALRegisterUvarMember( computeBSGL, BOOLEAN, 0, OPTIONAL, "Compute line-robust statistic (BSGL)");
XLALRegisterUvarMember( Fstar0, REAL8, 0, OPTIONAL, "BSGL: transition-scale parameter 'Fstar0'");
XLALRegisterUvarMember( oLGX, STRINGVector, 0, OPTIONAL, "BSGL: prior per-detector line-vs-Gauss odds, length must be numDetectors. (Defaults to oLGX=1/Ndet)");
XLALRegisterUvarMember( sqrtSX, STRINGVector, 0, OPTIONAL, "Per-detector noise PSD sqrt(SX). Only ratios relevant to compute noise weights. Defaults to 1,1,...");
XLALRegisterUvarMember( numDraws, INT4, 'N', OPTIONAL,"Number of random 'draws' to simulate");
XLALRegisterUvarMember( randSeed, INT4, 0, OPTIONAL, "GSL random-number generator seed value to use");
XLALRegisterUvarMember( outputStats, STRING, 'o', OPTIONAL, "Output file containing 'numDraws' random draws of stats");
XLALRegisterUvarMember( outputAtoms, STRING, 0, OPTIONAL, "Output F-statistic atoms into a file with this basename");
XLALRegisterUvarMember( outputInjParams, STRING, 0, OPTIONAL, "Output injection parameters into this file");
XLALRegisterUvarMember( outputMmunuX, BOOLEAN, 0, OPTIONAL, "Write the per-IFO antenna pattern matrices into the parameter file");
XLALRegisterUvarMember( SignalOnly, BOOLEAN, 'S', OPTIONAL, "Signal only: generate pure signal without noise");
XLALRegisterUvarMember( useFReg, BOOLEAN, 0, OPTIONAL, "use 'regularized' Fstat (1/D)*e^F (if TRUE) for marginalization, or 'standard' e^F (if FALSE)");
XLALRegisterUvarMember( ephemEarth, STRING, 0, OPTIONAL, "Earth ephemeris file to use");
XLALRegisterUvarMember( ephemSun, STRING, 0, OPTIONAL, "Sun ephemeris file to use");
XLALRegisterUvarMember( version, BOOLEAN, 'V', SPECIAL, "Output code version");
/* 'hidden' stuff */
XLALRegisterUvarMember( TAtom, INT4, 0, DEVELOPER, "Time baseline for Fstat-atoms (typically Tsft) in seconds." );
if ( xlalErrno ) {
XLALPrintError ("%s: something failed in initializing user variabels .. errno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
return XLAL_SUCCESS;
} /* XLALInitUserVars() */
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;
}
