/**
* Read config-variables from cfgfile and parse into input-structure.
* An error is reported if the config-file reading fails, but the
* individual variable-reads are treated as optional
*/
int
XLALUserVarReadCfgfile ( const CHAR *cfgfile ) /**< [in] name of config-file */
{
XLAL_CHECK ( cfgfile != NULL, XLAL_EINVAL );
XLAL_CHECK ( UVAR_vars.next != NULL, XLAL_EINVAL, "No memory allocated in UVAR_vars.next, did you register any user-variables?\n" );
LALParsedDataFile *cfg = NULL;
XLAL_CHECK ( XLALParseDataFile ( &cfg, cfgfile ) == XLAL_SUCCESS, XLAL_EFUNC );
// step through all user-variable: read those with names from config-file
LALUserVariable *ptr = &UVAR_vars;
while ( (ptr=ptr->next) != NULL)
{
if (ptr->name == NULL) { // ignore name-less user-variable
continue;
}
XLAL_CHECK ( (ptr->type > UVAR_TYPE_START) && (ptr->type < UVAR_TYPE_END), XLAL_EFAILED, "Invalid UVAR_TYPE '%d' outside of [%d,%d]\n", ptr->type, UVAR_TYPE_START+1, UVAR_TYPE_END-1 );
BOOLEAN wasRead;
CHAR *valString = NULL; // first read the value as a string
XLAL_CHECK ( XLALReadConfigSTRINGVariable ( &valString, cfg, NULL, ptr->name, &wasRead ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( wasRead ) // if successful, parse this as the desired type
{
// destroy previous value, is applicable, then parse new one
if ( UserVarTypeMap [ ptr->type ].destructor != NULL )
{
UserVarTypeMap [ ptr->type ].destructor( *(char**)ptr->varp );
*(char**)ptr->varp = NULL;
} // if a destructor was registered
XLAL_CHECK ( UserVarTypeMap [ ptr->type ].parser( ptr->varp, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALFree (valString);
check_and_mark_as_set ( ptr );
} // if wasRead
} // while ptr->next
// ok, that should be it: check if there were more definitions we did not read
UINT4Vector *unread = XLALConfigFileGetUnreadEntries ( cfg );
XLAL_CHECK ( xlalErrno == 0, XLAL_EFUNC, "XLALConfigFileGetUnreadEntries() failed\n");
if ( unread != NULL )
{
XLALPrintWarning ("The following entries in config-file '%s' have not been parsed:\n", cfgfile );
for ( UINT4 i = 0; i < unread->length; i ++ ) {
XLALPrintWarning ("%s\n", cfg->lines->tokens[ unread->data[i] ] );
}
XLALDestroyUINT4Vector ( unread );
}
XLALDestroyParsedDataFile ( cfg );
return XLAL_SUCCESS;
} // XLALUserVarReadCfgfile()
/**
* Function to parse a config-file-type string (or section thereof)
* into a PulsarParams struct.
*
* NOTE: The section-name is optional, and can be given as NULL,
* in which case the top of the file (ie the "default section")
* is used.
*
* NOTE2: eventually ATNF/TEMPO2-style 'par-file' variables will also
* be understood by this function, but we start out with a simpler version
* that just deals with our 'CW-style' input variable for now
*
* NOTE3: The config-file must be of a special "SourceParamsIO" form,
* defining the following required and optional parameters:
*
* REQUIRED:
* Alpha, Delta, Freq, refTime
*
* OPTIONAL:
* f1dot, f2dot, f3dot, f4dot, f5dot, f6dot
* {h0, cosi} or {aPlus, aCross}, psi, phi0
* transientWindowType, transientStartTime, transientTauDays
*
* Other config-variables found in the file will ... ?? error or accept?
*/
int
XLALReadPulsarParams ( PulsarParams *pulsarParams, ///< [out] pulsar parameters to fill in from config string
LALParsedDataFile *cfgdata, ///< [in] pre-parsed "SourceParamsIO" config-file contents
const CHAR *secName ///< [in] section-name to use from config-file string (can be NULL)
)
{
XLAL_CHECK ( pulsarParams != NULL, XLAL_EINVAL );
XLAL_CHECK ( cfgdata != NULL, XLAL_EINVAL );
XLAL_INIT_MEM ( (*pulsarParams) ); // wipe input struct clean
// ---------- PulsarAmplitudeParams ----------
// ----- h0, cosi
REAL8 h0 = 0; BOOLEAN have_h0;
REAL8 cosi = 0; BOOLEAN have_cosi;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &h0, cfgdata, secName, "h0", &have_h0 ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &cosi, cfgdata, secName, "cosi", &have_cosi ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- ALTERNATIVE: aPlus, aCross
REAL8 aPlus = 0; BOOLEAN have_aPlus;
REAL8 aCross = 0; BOOLEAN have_aCross;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &aPlus, cfgdata, secName, "aPlus", &have_aPlus ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &aCross, cfgdata, secName, "aCross", &have_aCross ) == XLAL_SUCCESS, XLAL_EFUNC );
// if h0 then also need cosi, and vice-versa
XLAL_CHECK ( (have_h0 && have_cosi) || ( !have_h0 && !have_cosi ), XLAL_EINVAL );
// if aPlus then also need aCross, and vice-versa
XLAL_CHECK ( (have_aPlus && have_aCross) || ( !have_aPlus && !have_aCross ), XLAL_EINVAL );
// {h0,cosi} or {aPlus, aCross} mutually exclusive sets
XLAL_CHECK ( ! ( have_h0 && have_aPlus ), XLAL_EINVAL );
if ( have_aPlus ) /* translate A_{+,x} into {h_0, cosi} */
{
XLAL_CHECK ( fabs ( aCross ) <= aPlus, XLAL_EDOM, "ERROR: |aCross| (= %g) must be <= aPlus (= %g).\n", fabs(aCross), aPlus );
REAL8 disc = sqrt ( SQ(aPlus) - SQ(aCross) );
h0 = aPlus + disc;
if ( h0 > 0 ) {
cosi = aCross / h0; // avoid division by 0!
}
} //if {aPlus, aCross}
XLAL_CHECK ( h0 >= 0, XLAL_EDOM );
pulsarParams->Amp.h0 = h0;
XLAL_CHECK ( (cosi >= -1) && (cosi <= 1), XLAL_EDOM );
pulsarParams->Amp.cosi= cosi;
// ----- psi
REAL8 psi = 0; BOOLEAN have_psi;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &psi, cfgdata, secName, "psi", &have_psi ) == XLAL_SUCCESS, XLAL_EFUNC );
pulsarParams->Amp.psi = psi;
// ----- phi0
REAL8 phi0 = 0; BOOLEAN have_phi0;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &phi0, cfgdata, secName, "phi0", &have_phi0 ) == XLAL_SUCCESS, XLAL_EFUNC );
pulsarParams->Amp.phi0 = phi0;
// ---------- PulsarDopplerParams ----------
// ----- refTime
LIGOTimeGPS refTime_GPS; BOOLEAN have_refTime;
XLAL_CHECK ( XLALReadConfigEPOCHVariable ( &refTime_GPS, cfgdata, secName, "refTime", &have_refTime ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( have_refTime, XLAL_EINVAL );
pulsarParams->Doppler.refTime = refTime_GPS;
// ----- Alpha
REAL8 Alpha_Rad = 0; BOOLEAN have_Alpha;
XLAL_CHECK ( XLALReadConfigRAJVariable ( &Alpha_Rad, cfgdata, secName, "Alpha", &have_Alpha ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( have_Alpha, XLAL_EINVAL );
XLAL_CHECK ( (Alpha_Rad >= 0) && (Alpha_Rad < LAL_TWOPI), XLAL_EDOM );
pulsarParams->Doppler.Alpha = Alpha_Rad;
// ----- Delta
REAL8 Delta_Rad = 0; BOOLEAN have_Delta;
XLAL_CHECK ( XLALReadConfigDECJVariable ( &Delta_Rad, cfgdata, secName, "Delta", &have_Delta ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( have_Delta, XLAL_EINVAL );
XLAL_CHECK ( (Delta_Rad >= -LAL_PI_2) && (Delta_Rad <= LAL_PI_2), XLAL_EDOM );
pulsarParams->Doppler.Delta = Delta_Rad;
// ----- fkdot
// Freq
REAL8 Freq = 0; BOOLEAN have_Freq;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &Freq, cfgdata, secName, "Freq", &have_Freq ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( have_Freq, XLAL_EINVAL );
XLAL_CHECK ( Freq > 0, XLAL_EDOM );
pulsarParams->Doppler.fkdot[0] = Freq;
// f1dot
REAL8 f1dot = 0; BOOLEAN have_f1dot;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &f1dot, cfgdata, secName, "f1dot", &have_f1dot ) == XLAL_SUCCESS, XLAL_EFUNC );
pulsarParams->Doppler.fkdot[1] = f1dot;
// f2dot
REAL8 f2dot = 0; BOOLEAN have_f2dot;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &f2dot, cfgdata, secName, "f2dot", &have_f2dot ) == XLAL_SUCCESS, XLAL_EFUNC );
pulsarParams->Doppler.fkdot[2] = f2dot;
// f3dot
REAL8 f3dot = 0; BOOLEAN have_f3dot;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &f3dot, cfgdata, secName, "f3dot", &have_f3dot ) == XLAL_SUCCESS, XLAL_EFUNC );
pulsarParams->Doppler.fkdot[3] = f3dot;
// f4dot
REAL8 f4dot = 0; BOOLEAN have_f4dot;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &f4dot, cfgdata, secName, "f4dot", &have_f4dot ) == XLAL_SUCCESS, XLAL_EFUNC );
pulsarParams->Doppler.fkdot[4] = f4dot;
// f5dot
REAL8 f5dot = 0; BOOLEAN have_f5dot;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &f5dot, cfgdata, secName, "f5dot", &have_f5dot ) == XLAL_SUCCESS, XLAL_EFUNC );
pulsarParams->Doppler.fkdot[5] = f5dot;
// f6dot
REAL8 f6dot = 0; BOOLEAN have_f6dot;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &f6dot, cfgdata, secName, "f6dot", &have_f6dot ) == XLAL_SUCCESS, XLAL_EFUNC );
pulsarParams->Doppler.fkdot[6] = f6dot;
// ----- orbit
LIGOTimeGPS orbitTp; BOOLEAN have_orbitTp;
XLAL_CHECK ( XLALReadConfigEPOCHVariable ( &orbitTp, cfgdata, secName, "orbitTp", &have_orbitTp ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 orbitArgp = 0; BOOLEAN have_orbitArgp;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &orbitArgp, cfgdata, secName, "orbitArgp", &have_orbitArgp ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 orbitasini = 0 /* isolated pulsar */; BOOLEAN have_orbitasini;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &orbitasini, cfgdata, secName, "orbitasini", &have_orbitasini ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 orbitEcc = 0; BOOLEAN have_orbitEcc;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &orbitEcc, cfgdata, secName, "orbitEcc", &have_orbitEcc ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 orbitPeriod = 0;BOOLEAN have_orbitPeriod;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &orbitPeriod, cfgdata, secName, "orbitPeriod", &have_orbitPeriod ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( have_orbitasini || have_orbitEcc || have_orbitPeriod || have_orbitArgp || have_orbitTp )
{
XLAL_CHECK ( orbitasini >= 0, XLAL_EDOM );
XLAL_CHECK ( (orbitasini == 0) || ( have_orbitEcc && have_orbitPeriod && have_orbitArgp && have_orbitTp ), XLAL_EINVAL );
XLAL_CHECK ( (orbitEcc >= 0) && (orbitEcc <= 1), XLAL_EDOM );
/* fill in orbital parameter structure */
pulsarParams->Doppler.tp = orbitTp;
pulsarParams->Doppler.argp = orbitArgp;
pulsarParams->Doppler.asini = orbitasini;
pulsarParams->Doppler.ecc = orbitEcc;
pulsarParams->Doppler.period = orbitPeriod;
} // if have non-trivial orbit
// ---------- transientWindow_t ----------
// ----- type
char *transientWindowType = NULL; BOOLEAN have_transientWindowType;
XLAL_CHECK ( XLALReadConfigSTRINGVariable ( &transientWindowType, cfgdata, secName, "transientWindowType", &have_transientWindowType ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- t0
REAL8 transientStartTime = 0; BOOLEAN have_transientStartTime;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &transientStartTime, cfgdata, secName, "transientStartTime", &have_transientStartTime ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- tau
REAL8 transientTauDays = 0; BOOLEAN have_transientTauDays;
XLAL_CHECK ( XLALReadConfigREAL8Variable ( &transientTauDays, cfgdata, secName, "transientTauDays", &have_transientTauDays ) == XLAL_SUCCESS, XLAL_EFUNC );
int twtype = TRANSIENT_NONE;
if ( have_transientWindowType ) {
XLAL_CHECK ( (twtype = XLALParseTransientWindowName ( transientWindowType )) >= 0, XLAL_EFUNC );
XLALFree ( transientWindowType );
}
pulsarParams->Transient.type = twtype;
if ( pulsarParams->Transient.type != TRANSIENT_NONE )
{
XLAL_CHECK ( have_transientStartTime && have_transientTauDays, XLAL_EINVAL );
XLAL_CHECK ( transientStartTime >= 0, XLAL_EDOM );
XLAL_CHECK ( transientTauDays > 0, XLAL_EDOM );
pulsarParams->Transient.t0 = (UINT4) transientStartTime;
pulsarParams->Transient.tau = (UINT4) ( transientTauDays * 86400 );
} /* if transient window != none */
else
{
XLAL_CHECK ( !(have_transientStartTime || have_transientTauDays), XLAL_EINVAL );
}
return XLAL_SUCCESS;
} // XLALParsePulsarParams()
/*
* main program entry point
*/
INT4 main(INT4 argc, CHAR **argv)
{
/* status */
LALStatus status = blank_status;
/* counters */
int c;
UINT4 i;
/* mode counters */
UINT4 l, m;
/* metadata file/directory */
CHAR *nrMetaFile = NULL;
CHAR *nrDataDir = NULL;
CHAR file_path[FILENAME_MAX];
/* metadata format */
CHAR *metadata_format = NULL;
/* metadata parsing variables */
LALParsedDataFile *meta_file = NULL;
BOOLEAN wasRead = 0;
CHAR field[HISTORY_COMMENT];
CHAR *wf_name[MAX_L+1][(2*MAX_L) + 1];
/* common metadata */
CHAR *md_mass_ratio = NULL;
CHAR *md_spin1x = NULL;
CHAR *md_spin1y = NULL;
CHAR *md_spin1z = NULL;
CHAR *md_spin2x = NULL;
CHAR *md_spin2y = NULL;
CHAR *md_spin2z = NULL;
CHAR *md_freq_start_22 = NULL;
/* NINJA1 metadata */
CHAR *md_simulation_details = NULL;
CHAR *md_nr_group = NULL;
CHAR *md_email = NULL;
/* NINJA2 metadata */
CHAR *md_waveform_name = NULL;
CHAR *md_initial_separation = NULL;
CHAR *md_eccentricity = NULL;
CHAR *md_number_of_cycles_22 = NULL;
CHAR *md_code = NULL;
CHAR *md_submitter_email = NULL;
CHAR *md_authors_emails = NULL;
/* common metadata strings */
CHAR str_mass_ratio[HISTORY_COMMENT];
CHAR str_spin1x[HISTORY_COMMENT];
CHAR str_spin1y[HISTORY_COMMENT];
CHAR str_spin1z[HISTORY_COMMENT];
CHAR str_spin2x[HISTORY_COMMENT];
CHAR str_spin2y[HISTORY_COMMENT];
CHAR str_spin2z[HISTORY_COMMENT];
CHAR str_freq_start_22[HISTORY_COMMENT];
CHAR str_creator[HISTORY_COMMENT];
/* NINJA1 metadata strings */
CHAR str_simulation_details[HISTORY_COMMENT];
CHAR str_nr_group[HISTORY_COMMENT];
CHAR str_email[HISTORY_COMMENT];
/* NINJA2 metadata strings */
CHAR str_waveform_name[HISTORY_COMMENT];
CHAR str_initial_separation[HISTORY_COMMENT];
CHAR str_eccentricity[HISTORY_COMMENT];
CHAR str_number_of_cycles_22[HISTORY_COMMENT];
CHAR str_code[HISTORY_COMMENT];
CHAR str_submitter_email[HISTORY_COMMENT];
CHAR str_authors_emails[HISTORY_COMMENT];
/* channel names */
CHAR *plus_channel[MAX_L+1][(2*MAX_L) + 1];
CHAR *cross_channel[MAX_L+1][(2*MAX_L) + 1];
/* waveforms */
UINT4 wf_length;
REAL4TimeVectorSeries *waveforms[MAX_L][(2*MAX_L) + 1];
REAL4TimeSeries *hplus[MAX_L+1][(2*MAX_L) + 1];
REAL4TimeSeries *hcross[MAX_L+1][(2*MAX_L) + 1];
REAL8TimeVectorSeries *waveformsREAL8[MAX_L][(2*MAX_L) + 1];
REAL8TimeSeries *hplusREAL8[MAX_L+1][(2*MAX_L) + 1];
REAL8TimeSeries *hcrossREAL8[MAX_L+1][(2*MAX_L) + 1];
/* frame variables */
LALFrameH *frame;
CHAR *frame_name = NULL;
LIGOTimeGPS epoch;
INT4 duration;
INT4 detector_flags;
INT4 generatingREAL8 = 0;
/* LALgetopt arguments */
struct LALoption long_options[] =
{
/* options that set a flag */
{"verbose", no_argument, &vrbflg, 1},
/* options that don't set a flag */
{"format", required_argument, 0, 'f'},
{"nr-meta-file", required_argument, 0, 'm'},
{"nr-data-dir", required_argument, 0, 'd'},
{"output", required_argument, 0, 'o'},
{"double-precision", no_argument, 0, 'p'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{0, 0, 0, 0}
};
/* default debug level */
lal_errhandler = LAL_ERR_EXIT;
/* parse the arguments */
while(1)
{
/* LALgetopt_long stores long option here */
int option_index = 0;
size_t LALoptarg_len;
c = LALgetopt_long_only(argc, argv, "f:m:d:o:phV", long_options, &option_index);
/* detect the end of the options */
if (c == -1)
break;
switch(c)
{
case 0:
/* if this option sets a flag, do nothing else for now */
if (long_options[option_index].flag != 0)
break;
else
{
fprintf(stderr, "Error parsing option %s with argument %s\n", long_options[option_index].name, LALoptarg);
exit(1);
}
break;
case 'h':
/* help message */
print_usage(stdout, argv[0]);
exit(0);
break;
case 'V':
/* print version information and exit */
fprintf(stdout, "Numerical Relativity Frame Generation\n");
XLALOutputVersionString(stderr, 0);
exit(0);
break;
case 'f':
/* create storage for the metadata format */
LALoptarg_len = strlen(LALoptarg) + 1;
metadata_format = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR));
memcpy(metadata_format, LALoptarg, LALoptarg_len);
break;
case 'm':
/* create storage for the meta file name */
LALoptarg_len = strlen(LALoptarg) + 1;
nrMetaFile = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR));
memcpy(nrMetaFile, LALoptarg, LALoptarg_len);
break;
case 'd':
/* create storage for the meta data directory name */
LALoptarg_len = strlen(LALoptarg) + 1;
nrDataDir = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR));
memcpy(nrDataDir, LALoptarg, LALoptarg_len);
break;
case 'o':
/* create storage for the output frame file name */
LALoptarg_len = strlen(LALoptarg) + 1;
frame_name = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR));
memcpy(frame_name, LALoptarg, LALoptarg_len);
break;
case 'p':
/* We're generating a double-precision frame */
generatingREAL8 = 1;
break;
case '?':
print_usage(stderr, argv[0]);
exit(1);
break;
default:
fprintf(stderr, "Unknown error while parsing arguments\n");
print_usage(stderr, argv[0]);
exit(1);
break;
}
}
/* check for extraneous command line arguments */
if (LALoptind < argc)
{
fprintf(stderr, "Extraneous command line arguments:\n");
while(LALoptind < argc)
fprintf(stderr, "%s\n", argv[LALoptind++]);
exit(1);
}
/*
* check validity of arguments
*/
/* metadata format specified */
if (metadata_format == NULL)
{
fprintf(stderr, "warning: --format not specified, assuming NINJA1\n");
metadata_format = (CHAR *)calloc(7, sizeof(CHAR));
memcpy(metadata_format, "NINJA1", 7);
}
/* check for supported metadata format */
if (strcmp(metadata_format, "NINJA1") == 0);
else if (strcmp(metadata_format, "NINJA2") == 0);
else
{
fprintf(stderr, "Supported metadata formats are NINJA1 and NINJA2 (%s specified)\n", metadata_format);
exit(1);
}
/* meta file specified */
if (nrMetaFile == NULL)
{
fprintf(stderr, "--nr-meta-file must be specified\n");
exit(1);
}
/* data directory specified */
if (nrDataDir == NULL)
{
fprintf(stderr, "--nr-data-dir must be specified\n");
exit(1);
}
/* output frame filename specified */
if (frame_name == NULL)
{
fprintf(stderr, "--output must be specified\n");
exit(1);
}
/*
* main code
*/
/* frame metadata */
/* TODO: set these to something sensible */
duration = 0;
epoch.gpsSeconds = 0;
epoch.gpsNanoSeconds = 0;
detector_flags = 0;
if (vrbflg)
fprintf(stdout, "reading metadata: %s\n", nrMetaFile);
/* open metadata file */
XLAL_CHECK ( XLALParseDataFile(&meta_file, nrMetaFile) == XLAL_SUCCESS, XLAL_EFUNC );
/*
* get metadata
*/
/* common metadata */
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_mass_ratio, meta_file, NULL, "mass-ratio", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin1x, meta_file, NULL, "spin1x", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin1y, meta_file, NULL, "spin1y", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin1z, meta_file, NULL, "spin1z", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin2x, meta_file, NULL, "spin2x", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin2y, meta_file, NULL, "spin2y", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin2z, meta_file, NULL, "spin2z", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
/* format specific metadata */
if (strcmp(metadata_format, "NINJA1") == 0)
{
/* NINJA1 */
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_simulation_details, meta_file, NULL, "simulation-details", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_nr_group, meta_file, NULL, "nr-group", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_email, meta_file, NULL, "email", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_freq_start_22, meta_file, NULL, "freqStart22", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
}
else if (strcmp(metadata_format, "NINJA2") == 0)
{
/* NINJA2 */
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_waveform_name, meta_file, NULL, "waveform-name", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_initial_separation, meta_file, NULL, "initial-separation", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_eccentricity, meta_file, NULL, "eccentricity", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_number_of_cycles_22, meta_file, NULL, "number-of-cycles-22", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_code, meta_file, NULL, "code", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_submitter_email, meta_file, NULL, "submitter-email", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_authors_emails, meta_file, NULL, "authors-emails", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_freq_start_22, meta_file, NULL, "freq-start-22", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
}
else
{
/* unknown metadata format - should not be executed */
fprintf(stderr, "error: unsupported metadata format: %s\n", metadata_format);
exit(1);
}
/*
* set metadata strings
*/
/* common waveform */
snprintf(str_mass_ratio, HISTORY_COMMENT, "mass-ratio:%s", md_mass_ratio);
snprintf(str_spin1x, HISTORY_COMMENT, "spin1x:%s", md_spin1x);
snprintf(str_spin1y, HISTORY_COMMENT, "spin1y:%s", md_spin1y);
snprintf(str_spin1z, HISTORY_COMMENT, "spin1z:%s", md_spin1z);
snprintf(str_spin2x, HISTORY_COMMENT, "spin2x:%s", md_spin2x);
snprintf(str_spin2y, HISTORY_COMMENT, "spin2y:%s", md_spin2y);
snprintf(str_spin2z, HISTORY_COMMENT, "spin2z:%s", md_spin2z);
snprintf(str_creator, HISTORY_COMMENT, "creator:%s(git:%s)", PROGRAM_NAME, lalAppsVCSId);
/* format specific metadata */
if (strcmp(metadata_format, "NINJA1") == 0)
{
/* NINJA1 */
snprintf(str_freq_start_22, HISTORY_COMMENT, "freqStart22:%s", md_freq_start_22);
snprintf(str_simulation_details, HISTORY_COMMENT, "simulation-details:%s", md_simulation_details);
snprintf(str_nr_group, HISTORY_COMMENT, "nr-group:%s", md_nr_group);
snprintf(str_email, HISTORY_COMMENT, "email:%s", md_email);
}
else if (strcmp(metadata_format, "NINJA2") == 0)
{
/* NINJA2 */
snprintf(str_waveform_name, HISTORY_COMMENT, "waveform-name:%s", md_waveform_name);
snprintf(str_initial_separation, HISTORY_COMMENT, "inital-separation:%s", md_initial_separation);
snprintf(str_eccentricity, HISTORY_COMMENT, "eccentricity:%s", md_eccentricity);
snprintf(str_freq_start_22, HISTORY_COMMENT, "freq_start_22:%s", md_freq_start_22);
snprintf(str_number_of_cycles_22, HISTORY_COMMENT, "number-of-cycles-22:%s", md_number_of_cycles_22);
snprintf(str_code, HISTORY_COMMENT, "code:%s", md_code);
snprintf(str_submitter_email, HISTORY_COMMENT, "submitter-email:%s", md_submitter_email);
snprintf(str_authors_emails, HISTORY_COMMENT, "authors-emails:%s", md_authors_emails);
}
else
{
/* unknown metadata format - should not be executed */
fprintf(stderr, "error: unsupported metadata format: %s\n", metadata_format);
exit(1);
}
/* define frame */
frame = XLALFrameNew(&epoch, duration, "NR", 0, 1, detector_flags);
/*
* add metadata as FrHistory structures
*/
/* common metadata */
XLALFrameAddFrHistory(frame, "creator", str_creator);
XLALFrameAddFrHistory(frame, "mass-ratio", str_mass_ratio);
XLALFrameAddFrHistory(frame, "spin1x", str_spin1x);
XLALFrameAddFrHistory(frame, "spin1y", str_spin1y);
XLALFrameAddFrHistory(frame, "spin1z", str_spin1z);
XLALFrameAddFrHistory(frame, "spin2x", str_spin2x);
XLALFrameAddFrHistory(frame, "spin2y", str_spin2y);
XLALFrameAddFrHistory(frame, "spin2z", str_spin2z);
/* format specific metadata */
if (strcmp(metadata_format, "NINJA1") == 0)
{
/* NINJA1 */
XLALFrameAddFrHistory(frame, "simulation-details", str_simulation_details);
XLALFrameAddFrHistory(frame, "nr-group", str_nr_group);
XLALFrameAddFrHistory(frame, "email", str_email);
XLALFrameAddFrHistory(frame, "freqStart22", str_freq_start_22);
}
else if (strcmp(metadata_format, "NINJA2") == 0)
{
/* NINJA2 */
XLALFrameAddFrHistory(frame, "waveform-name", str_waveform_name);
XLALFrameAddFrHistory(frame, "initial-separation", str_initial_separation);
XLALFrameAddFrHistory(frame, "eccentricity", str_eccentricity);
XLALFrameAddFrHistory(frame, "freq_start_22", str_freq_start_22);
XLALFrameAddFrHistory(frame, "number-of-cycles-22", str_number_of_cycles_22);
XLALFrameAddFrHistory(frame, "code", str_code);
XLALFrameAddFrHistory(frame, "submitter-email", str_code);
XLALFrameAddFrHistory(frame, "authors-emails", str_authors_emails);
}
else
{
/* unknown metadata format - should not be executed */
fprintf(stderr, "error: unsupported metadata format: %s\n", metadata_format);
exit(1);
}
/* loop over l & m values */
for (l = MIN_L; l <= MAX_L; l++)
{
for (m = (MAX_L - l); m <= MAX_L + l; m++)
{
/* ensure pointers are NULL */
wf_name[l][m] = NULL;
plus_channel[l][m] = NULL;
cross_channel[l][m] = NULL;
/* generate channel names */
plus_channel[l][m] = XLALGetNinjaChannelName("plus", l, m - MAX_L);
cross_channel[l][m] = XLALGetNinjaChannelName("cross", l, m - MAX_L);
if (generatingREAL8)
{
hplusREAL8[l][m] = NULL;
hcrossREAL8[l][m] = NULL;
waveformsREAL8[l][m] = NULL;
/* initilise waveform time series */
hplusREAL8[l][m] = XLALCreateREAL8TimeSeries(plus_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0);
hcrossREAL8[l][m] = XLALCreateREAL8TimeSeries(cross_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0);
}
else
{
hplus[l][m] = NULL;
hcross[l][m] = NULL;
waveforms[l][m] = NULL;
/* initilise waveform time series */
hplus[l][m] = XLALCreateREAL4TimeSeries(plus_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0);
hcross[l][m] = XLALCreateREAL4TimeSeries(cross_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0);
}
/* read ht-data section of metadata file */
snprintf(field, HISTORY_COMMENT, "%d,%d", l, m - MAX_L);
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &wf_name[l][m], meta_file, NULL, field, &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
/* read waveform */
if (wf_name[l][m] != NULL)
{
/* get full path to waveform data file */
snprintf(file_path, FILENAME_MAX, "%s/%s", nrDataDir, wf_name[l][m]);
if (vrbflg)
fprintf(stdout, "reading waveform: %s\n", file_path);
/* read waveforms */
if (generatingREAL8)
{
LAL_CALL(LALReadNRWave_raw_real8(&status, &waveformsREAL8[l][m], file_path), &status);
}
else
{
LAL_CALL(LALReadNRWave_raw(&status, &waveforms[l][m], file_path), &status);
}
}
/* generate waveform time series from vector series */
/* TODO: should use pointer arithmetic here and update the data
* pointer in the REAL4TimeSeries to point to the appropriate
* location within the REAL4TimeVector Series */
if (generatingREAL8) {
if (waveformsREAL8[l][m])
{
/* get length of waveform */
wf_length = waveformsREAL8[l][m]->data->vectorLength;
/* allocate memory for waveform */
XLALResizeREAL8TimeSeries(hplusREAL8[l][m], 0, wf_length);
XLALResizeREAL8TimeSeries(hcrossREAL8[l][m], 0, wf_length);
/* set time spacing */
hplusREAL8[l][m]->deltaT = waveformsREAL8[l][m]->deltaT;
hcrossREAL8[l][m]->deltaT = waveformsREAL8[l][m]->deltaT;
/* copy waveforms into appropriate series */
for (i = 0; i < wf_length; i ++) {
hplusREAL8[l][m]->data->data[i] = waveformsREAL8[l][m]->data->data[i];
hcrossREAL8[l][m]->data->data[i] = waveformsREAL8[l][m]->data->data[wf_length + i];
}
/* Done with waveformsREAL8, clean up here to limit memory usage */
LALFree(waveformsREAL8[l][m]->data->data);
LALFree(waveformsREAL8[l][m]->data);
LALFree(waveformsREAL8[l][m]);
}
}
else /* REAL4 */
{
if (waveforms[l][m])
{
/* get length of waveform */
wf_length = waveforms[l][m]->data->vectorLength;
/* allocate memory for waveform */
XLALResizeREAL4TimeSeries(hplus[l][m], 0, wf_length);
XLALResizeREAL4TimeSeries(hcross[l][m], 0, wf_length);
/* set time spacing */
hplus[l][m]->deltaT = waveforms[l][m]->deltaT;
hcross[l][m]->deltaT = waveforms[l][m]->deltaT;
/* copy waveforms into appropriate series */
for (i = 0; i < wf_length; i ++) {
hplus[l][m]->data->data[i] = waveforms[l][m]->data->data[i];
hcross[l][m]->data->data[i] = waveforms[l][m]->data->data[wf_length + i];
}
}
}
/* add channels to frame */
if (generatingREAL8)
{
if ((hplusREAL8[l][m]->data->length) && (hcrossREAL8[l][m]->data->length))
{
XLALFrameAddREAL8TimeSeriesSimData(frame, hplusREAL8[l][m]);
XLALFrameAddREAL8TimeSeriesSimData(frame, hcrossREAL8[l][m]);
}
}
else
{
if ((hplus[l][m]->data->length) && (hcross[l][m]->data->length))
{
XLALFrameAddREAL4TimeSeriesSimData(frame, hplus[l][m]);
XLALFrameAddREAL4TimeSeriesSimData(frame, hcross[l][m]);
}
}
}
}
if (vrbflg)
fprintf(stdout, "writing frame: %s\n", frame_name);
/* write frame */
if (XLALFrameWrite(frame, frame_name) != 0 )
{
fprintf(stderr, "Error: Cannot save frame file '%s'\n", frame_name);
exit(1);
}
/*
* clear memory
*/
/* strings */
if(nrMetaFile) free(nrMetaFile);
if(nrDataDir) free(nrDataDir);
if(frame_name) free(frame_name);
if(metadata_format) free(metadata_format);
/* common metadata */
if(md_mass_ratio) LALFree(md_mass_ratio);
if(md_spin1x) LALFree(md_spin1x);
if(md_spin1y) LALFree(md_spin1y);
if(md_spin1z) LALFree(md_spin1z);
if(md_spin2x) LALFree(md_spin2x);
if(md_spin2y) LALFree(md_spin2y);
if(md_spin2z) LALFree(md_spin2z);
if(md_freq_start_22) LALFree(md_freq_start_22);
/* NINJA1 metadata */
if(md_simulation_details) LALFree(md_simulation_details);
if(md_nr_group) LALFree(md_nr_group);
if(md_email) LALFree(md_email);
/* NINJA2 metadata */
if(md_waveform_name) LALFree(md_waveform_name);
if(md_initial_separation) LALFree(md_initial_separation);
if(md_eccentricity) LALFree(md_eccentricity);
if(md_number_of_cycles_22) LALFree(md_number_of_cycles_22);
if(md_code) LALFree(md_code);
if(md_submitter_email) LALFree(md_submitter_email);
if(md_authors_emails) LALFree(md_authors_emails);
/* config file */
if(meta_file->lines->list->data) LALFree(meta_file->lines->list->data);
if(meta_file->lines->list) LALFree(meta_file->lines->list);
if(meta_file->lines->tokens) LALFree(meta_file->lines->tokens);
if(meta_file->lines) LALFree(meta_file->lines);
if(meta_file->wasRead) LALFree(meta_file->wasRead);
if(meta_file) LALFree(meta_file);
/* waveforms */
if (generatingREAL8)
{
for (l = MIN_L; l <= MAX_L; l++)
{
for (m = (MAX_L - l); m <= MAX_L + l; m++)
{
/* channel names */
if (plus_channel[l][m])
LALFree(plus_channel[l][m]);
if (cross_channel[l][m])
LALFree(cross_channel[l][m]);
if (wf_name[l][m])
LALFree(wf_name[l][m]);
/* hplus */
if (hplusREAL8[l][m])
XLALDestroyREAL8TimeSeries(hplusREAL8[l][m]);
/* hcross */
if (hcrossREAL8[l][m])
XLALDestroyREAL8TimeSeries(hcrossREAL8[l][m]);
}
}
}
else
{
for (l = MIN_L; l <= MAX_L; l++)
{
for (m = (MAX_L - l); m <= MAX_L + l; m++)
{
/* channel names */
if (plus_channel[l][m])
LALFree(plus_channel[l][m]);
if (cross_channel[l][m])
LALFree(cross_channel[l][m]);
if (wf_name[l][m])
LALFree(wf_name[l][m]);
/* raw waveforms */
if (waveforms[l][m]) {
LALFree(waveforms[l][m]->data->data);
LALFree(waveforms[l][m]->data);
LALFree(waveforms[l][m]);
}
/* hplus */
if (hplus[l][m])
XLALDestroyREAL4TimeSeries(hplus[l][m]);
/* hcross */
if (hcross[l][m])
XLALDestroyREAL4TimeSeries(hcross[l][m]);
}
}
}
/* clear frame */
XLALFrameFree(frame);
/* check for memory leaks */
LALCheckMemoryLeaks();
exit(0);
}
/**
* Read config-variables from cfgfile and parse into input-structure.
* An error is reported if the config-file reading fails, but the
* individual variable-reads are treated as optional
*
* If \p *should_exit is TRUE when this function returns, the
* caller should exit immediately.
*/
int
XLALUserVarReadCfgfile ( BOOLEAN *should_exit, const CHAR *cfgfile )
{
XLAL_CHECK ( should_exit != NULL, XLAL_EFAULT );
XLAL_CHECK ( cfgfile != NULL, XLAL_EINVAL );
XLAL_CHECK ( UVAR_vars.next != NULL, XLAL_EINVAL, "No memory allocated in UVAR_vars.next, did you register any user-variables?\n" );
*should_exit = 0;
LALParsedDataFile *cfg = NULL;
XLAL_CHECK ( XLALParseDataFile ( &cfg, cfgfile ) == XLAL_SUCCESS, XLAL_EFUNC );
// step through all user-variable: read those with names from config-file
LALUserVariable *ptr = &UVAR_vars;
while ( (ptr=ptr->next) != NULL)
{
XLAL_CHECK ( (ptr->type > UVAR_TYPE_START) && (ptr->type < UVAR_TYPE_END), XLAL_EFAILED, "Invalid UVAR_TYPE '%d' outside of [%d,%d]\n", ptr->type, UVAR_TYPE_START+1, UVAR_TYPE_END-1 );
BOOLEAN wasRead;
CHAR *valString = NULL; // first read the value as a string
XLAL_CHECK ( XLALReadConfigSTRINGVariable ( &valString, cfg, NULL, ptr->name, &wasRead ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( wasRead ) // if successful, parse this as the desired type
{
// destroy previous value, is applicable, then parse new one
if ( UserVarTypeMap [ ptr->type ].destructor != NULL )
{
UserVarTypeMap [ ptr->type ].destructor( *(char**)ptr->varp );
*(char**)ptr->varp = NULL;
} // if a destructor was registered
if ( UserVarTypeMap [ ptr->type ].parser( ptr->varp, valString ) != XLAL_SUCCESS )
{
XLALPrintError( "\n%s: could not parse value given to option " UVAR_FMT "\n\n", program_name, ptr->name );
*should_exit = 1;
return XLAL_SUCCESS;
}
XLALFree (valString);
switch ( ptr->was_set ) {
case 0: // this variable has not been set; mark as set in configuration file
ptr->was_set = 1;
break;
default: // this variable has been set before; error
XLALUserVarCheck( should_exit, 0, "configuration option `%s' was set more than once!", ptr->name );
return XLAL_SUCCESS;
}
} // if wasRead
} // while ptr->next
// ok, that should be it: check if there were more definitions we did not read
UINT4Vector *unread = XLALConfigFileGetUnreadEntries ( cfg );
XLAL_CHECK ( xlalErrno == 0, XLAL_EFUNC, "XLALConfigFileGetUnreadEntries() failed\n");
if ( unread != NULL )
{
XLALPrintWarning ("The following entries in config-file '%s' have not been parsed:\n", cfgfile );
for ( UINT4 i = 0; i < unread->length; i ++ ) {
XLALPrintWarning ("%s\n", cfg->lines->tokens[ unread->data[i] ] );
}
XLALDestroyUINT4Vector ( unread );
}
XLALDestroyParsedDataFile ( cfg );
return XLAL_SUCCESS;
} // XLALUserVarReadCfgfile()
