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