/**
* 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()
void XLALVPrintWarningMessage(const char *func, const char *file, int line,
const char *fmt, va_list ap)
{
XLALPrintWarning("XLAL Warning");
if (func && *func)
XLALPrintWarning(" - %s", func);
if (file && *file)
XLALPrintWarning(" (%s:%d)", file, line);
XLALPrintWarning(": ");
XLALVPrintWarning(fmt, ap);
XLALPrintWarning("\n");
return;
}
int XLALREAL4FreqTimeFFT(
REAL4TimeSeries *time,
const COMPLEX8FrequencySeries *freq,
const REAL4FFTPlan *plan
)
{
UINT4 j;
if ( ! freq || ! time || ! plan )
XLAL_ERROR( XLAL_EFAULT );
if ( freq->deltaF <= 0.0 )
XLAL_ERROR( XLAL_EINVAL );
/* perform the transform */
if ( XLALREAL4ReverseFFT( time->data, freq->data, plan ) == XLAL_FAILURE )
XLAL_ERROR( XLAL_EFUNC );
/* adjust the units */
if ( ! XLALUnitMultiply( &time->sampleUnits, &freq->sampleUnits, &lalHertzUnit ) )
XLAL_ERROR( XLAL_EFUNC );
/* remaining fields */
if ( freq->f0 ) /* TODO: need to figure out what to do here */
XLALPrintWarning( "XLAL Warning - time series may have incorrect f0" );
time->f0 = 0.0; /* FIXME: what if heterodyned data? */
time->epoch = freq->epoch;
time->deltaT = 1.0 / ( freq->deltaF * time->data->length );
/* provide the correct scaling of the result */
for ( j = 0; j < time->data->length; ++j )
time->data->data[j] *= freq->deltaF;
return 0;
}
int XLALREAL4TimeFreqFFT(
COMPLEX8FrequencySeries *freq,
const REAL4TimeSeries *time,
const REAL4FFTPlan *plan
)
{
UINT4 k;
if ( ! freq || ! time || ! plan )
XLAL_ERROR( XLAL_EFAULT );
if ( time->deltaT <= 0.0 )
XLAL_ERROR( XLAL_EINVAL );
/* perform the transform */
if ( XLALREAL4ForwardFFT( freq->data, time->data, plan ) == XLAL_FAILURE )
XLAL_ERROR( XLAL_EFUNC );
/* adjust the units */
if ( ! XLALUnitMultiply( &freq->sampleUnits, &time->sampleUnits, &lalSecondUnit ) )
XLAL_ERROR( XLAL_EFUNC );
/* remaining fields */
if ( time->f0 ) /* TODO: need to figure out what to do here */
XLALPrintWarning( "XLAL Warning - frequency series may have incorrect f0" );
freq->f0 = 0.0; /* FIXME: what if heterodyned data? */
freq->epoch = time->epoch;
freq->deltaF = 1.0 / ( time->deltaT * time->data->length );
/* provide the correct scaling of the result */
for ( k = 0; k < freq->data->length; ++k )
freq->data->data[k] *= time->deltaT;
return 0;
}
/**
* \brief Serializes a \c LALInferenceVariables structure into a VOTable XML %node
*
* This function takes a \c LALInferenceVariables structure and serializes it into a VOTable
* \c PARAM %node identified by the given name. The returned \c xmlNode can then be
* embedded into an existing %node hierarchy or turned into a full VOTable document.
*
* \param vars [in] Pointer to the \c LALInferenceVariables structure to be serialized
*
* \return A pointer to a \c xmlNode that holds the VOTable fragment that represents
* the \c LALInferenceVariables structure.
* In case of an error, a null-pointer is returned.\n
* \b Important: the caller is responsible to free the allocated memory (when the
* fragment isn't needed anymore) using \c xmlFreeNode. Alternatively, \c xmlFreeDoc
* can be used later on when the returned fragment has been embedded in a XML document.
*
* \sa LALInferenceVariableItem2VOTParamNode
*
* \author John Veitch
*
*/
xmlNodePtr XLALInferenceVariables2VOTParamNode (LALInferenceVariables *const vars)
{
/* set up local variables */
/*const char *fn = __func__;*/
xmlNodePtr xmlChildNodeList = NULL;
xmlNodePtr xmlChild;
LALInferenceVariableItem *marker=vars->head;
/* Walk through the LALInferenceVariables adding each one */
while(marker){
xmlChild = (LALInferenceVariableItem2VOTParamNode(marker));
marker=marker->next;
if(!xmlChild) {
/* clean up */
/* if(xmlChildNodeList) xmlFreeNodeList(xmlChildNodeList); */
XLALPrintWarning("Couldn't create PARAM node for %s\n", marker->name);
/* XLAL_ERROR_NULL(fn, XLAL_EFAILED); */
continue;
}
if(!xmlChildNodeList) xmlChildNodeList=xmlChild;
else xmlAddSibling(xmlChildNodeList,xmlChild);
}
return(xmlChildNodeList);
}
/**
* Mark the user-variable as set, check if it has been
* set previously and issue a warning if set more than once ...
*/
void
check_and_mark_as_set ( LALUserVariable *varp )
{
// output warning if this variable has been set before ...
if ( varp->was_set ) {
XLALPrintWarning ( "User-variable '%s' was set more than once!\n", varp->name ? varp->name : "(NULL)" );
}
varp->was_set = 1;
return;
} // check_and_mark_as_set()
/**
* \brief Serializes an array of \c LALInferenceVariables into a VOTable XML %node
*
* This function takes a \c LALInferenceVariables structure and serializes it into a VOTable
* \c RESOURCE %node identified by the given name. The returned \c xmlNode can then be
* embedded into an existing %node hierarchy or turned into a full VOTable document.
* A VOTable Table element is returned, with fixed variables as PARAMs and the varying ones as FIELDs.
*
* \param varsArray [in] Pointer to an array of \c LALInferenceVariables structures to be serialized
* \param N [in] Number of items in the array
* \param tablename UNDOCUMENTED
*
* \return A pointer to a \c xmlNode that holds the VOTable fragment that represents
* the \c LALInferenceVariables array.
* In case of an error, a null-pointer is returned.\n
* \b Important: the caller is responsible to free the allocated memory (when the
* fragment isn't needed anymore) using \c xmlFreeNode. Alternatively, \c xmlFreeDoc
* can be used later on when the returned fragment has been embedded in a XML document.
*
* \sa XLALCreateVOTParamNode
* \sa XLALCreateVOTResourceNode
*
* \author John Veitch
*
*/
xmlNodePtr XLALInferenceVariablesArray2VOTTable(LALInferenceVariables * const *const varsArray, UINT4 N, const char *tablename)
{
xmlNodePtr fieldNodeList=NULL;
xmlNodePtr paramNodeList=NULL;
xmlNodePtr xmlTABLEDATAnode=NULL;
xmlNodePtr VOTtableNode=NULL;
xmlNodePtr tmpNode=NULL;
xmlNodePtr field_ptr,param_ptr;
LALInferenceVariableItem *varitem=NULL;
UINT4 Nfields=0;
UINT4 bufsize=1024;
int err;
/* Sanity check input */
if(!varsArray) {
XLALPrintError("Received null varsArray pointer");
XLAL_ERROR_NULL(XLAL_EFAULT);
}
if(N==0) return(NULL);
field_ptr=fieldNodeList;
param_ptr=paramNodeList;
char *field_names[varsArray[0]->dimension];
/* Build a list of PARAM and FIELD elements */
for(varitem=varsArray[0]->head;varitem;varitem=varitem->next)
{
tmpNode=NULL;
switch(varitem->vary){
case LALINFERENCE_PARAM_LINEAR:
case LALINFERENCE_PARAM_CIRCULAR:
case LALINFERENCE_PARAM_OUTPUT:
{
tmpNode=LALInferenceVariableItem2VOTFieldNode(varitem);
if(!tmpNode) {
XLALPrintWarning ("%s: xmlAddNextSibling() failed to add field node for %s.\n", __func__, varitem->name );
//XLAL_ERROR_NULL(XLAL_EFAILED);
continue;
}
if(field_ptr) field_ptr=xmlAddNextSibling(field_ptr,tmpNode);
else {field_ptr=tmpNode; fieldNodeList=field_ptr;}
field_names[Nfields]=varitem->name;
Nfields++;
break;
}
case LALINFERENCE_PARAM_FIXED:
{
tmpNode=LALInferenceVariableItem2VOTParamNode(varitem);
if(!tmpNode) {
XLALPrintWarning ("%s: xmlAddNextSibling() failed to add param node for %s.\n", __func__, varitem->name );
//XLAL_ERROR_NULL(XLAL_EFAILED);
continue;
}
if(param_ptr) param_ptr=xmlAddNextSibling(param_ptr,tmpNode);
else {param_ptr=tmpNode; paramNodeList=param_ptr;}
break;
}
default:
{
XLALPrintWarning("Unknown param vary type");
}
}
}
if(Nfields>0)
{
UINT4 row,col;
/* create TABLEDATA node */
if ( ( xmlTABLEDATAnode = xmlNewNode ( NULL, CAST_CONST_XMLCHAR("TABLEDATA") ))== NULL ) {
XLALPrintError ("%s: xmlNewNode() failed to create 'TABLEDATA' node.\n", __func__ );
err = XLAL_ENOMEM;
goto failed;
}
/* ---------- loop over data-arrays and generate each table-row */
for ( row = 0; row < N; row ++ )
{
/* create TR node */
xmlNodePtr xmlThisRowNode = NULL;
if ( (xmlThisRowNode = xmlNewNode ( NULL, CAST_CONST_XMLCHAR("TR") )) == NULL ) {
XLALPrintError ("%s: xmlNewNode() failed to create new 'TR' node.\n", __func__ );
err = XLAL_EFAILED;
goto failed;
}
if ( xmlAddChild(xmlTABLEDATAnode, xmlThisRowNode ) == NULL ) {
XLALPrintError ("%s: failed to insert 'TR' node into 'TABLEDATA' node.\n", __func__ );
err = XLAL_EFAILED;
goto failed;
}
/* ----- loop over columns and generate each table element */
for ( col = 0; col < Nfields; col ++ )
{
/* create TD node */
xmlNodePtr xmlThisEntryNode = NULL;
if ( (xmlThisEntryNode = xmlNewNode ( NULL, CAST_CONST_XMLCHAR("TD") )) == NULL ) {
XLALPrintError ("%s: xmlNewNode() failed to create new 'TD' node.\n", __func__ );
err = XLAL_EFAILED;
goto failed;
}
if ( xmlAddChild(xmlThisRowNode, xmlThisEntryNode ) == NULL ) {
XLALPrintError ("%s: failed to insert 'TD' node into 'TR' node.\n", __func__ );
err = XLAL_EFAILED;
goto failed;
}
char *valuestr=XLALCalloc(bufsize,sizeof(char));
varitem = LALInferenceGetItem(varsArray[row],field_names[col]);
UINT4 required_size=LALInferencePrintNVariableItem(valuestr,bufsize,varitem);
if(required_size>bufsize)
{
bufsize=required_size;
valuestr=XLALRealloc(valuestr,required_size*sizeof(char));
required_size=LALInferencePrintNVariableItem(valuestr,bufsize,varitem);
}
xmlNodePtr xmlTextNode= xmlNewText (CAST_CONST_XMLCHAR(valuestr) );
if ( xmlTextNode == NULL ) {
XLALPrintError("%s: xmlNewText() failed to turn text '%s' into node\n", __func__, valuestr );
err = XLAL_EFAILED;
XLALFree(valuestr);
goto failed;
}
if ( xmlAddChild(xmlThisEntryNode, xmlTextNode ) == NULL ) {
XLALPrintError ("%s: failed to insert text-node node into 'TD' node.\n", __func__ );
err = XLAL_EFAILED;
XLALFree(valuestr);
goto failed;
}
XLALFree(valuestr);
} /* for col < numFields */
} /* for row < numRows */
}
/* Create a TABLE from the FIELDs, PARAMs, and TABLEDATA nodes */
VOTtableNode= XLALCreateVOTTableNode (tablename, fieldNodeList, paramNodeList, xmlTABLEDATAnode );
return(VOTtableNode);
failed:
XLAL_ERROR_NULL ( err );
return(NULL);
}
/**
* Core function for computing the ROM waveform.
* Interpolate projection coefficient data and evaluate coefficients at desired (q, chi).
* Construct 1D splines for amplitude and phase.
* Compute strain waveform from amplitude and phase.
*/
static int SEOBNRv1ROMEffectiveSpinCore(
COMPLEX16FrequencySeries **hptilde,
COMPLEX16FrequencySeries **hctilde,
double phiRef,
double fRef,
double distance,
double inclination,
double Mtot_sec,
double q,
double chi,
const REAL8Sequence *freqs_in, /* Frequency points at which to evaluate the waveform (Hz) */
double deltaF
/* If deltaF > 0, the frequency points given in freqs are uniformly spaced with
* spacing deltaF. Otherwise, the frequency points are spaced non-uniformly.
* Then we will use deltaF = 0 to create the frequency series we return. */
)
{
/* Check output arrays */
if(!hptilde || !hctilde)
XLAL_ERROR(XLAL_EFAULT);
SEOBNRROMdata *romdata=&__lalsim_SEOBNRv1ROMSS_data;
if(*hptilde || *hctilde) {
XLALPrintError("(*hptilde) and (*hctilde) are supposed to be NULL, but got %p and %p",(*hptilde),(*hctilde));
XLAL_ERROR(XLAL_EFAULT);
}
int retcode=0;
// 'Nudge' parameter values to allowed boundary values if close by
if (q < 1.0) nudge(&q, 1.0, 1e-6);
if (q > 100.0) nudge(&q, 100.0, 1e-6);
if (chi < -1.0) nudge(&chi, -1.0, 1e-6);
if (chi > 0.6) nudge(&chi, 0.6, 1e-6);
/* If either spin > 0.6, model not available, exit */
if ( chi < -1.0 || chi > 0.6 ) {
XLALPrintError( "XLAL Error - %s: chi smaller than -1 or larger than 0.6!\nSEOBNRv1ROMEffectiveSpin is only available for spins in the range -1 <= a/M <= 0.6.\n", __func__);
XLAL_ERROR( XLAL_EDOM );
}
if (q > 100) {
XLALPrintError( "XLAL Error - %s: q=%lf larger than 100!\nSEOBNRv1ROMEffectiveSpin is only available for q in the range 1 <= q <= 100.\n", __func__,q);
XLAL_ERROR( XLAL_EDOM );
}
if (q >= 20 && q <= 40 && chi < -0.75 && chi > -0.9) {
XLALPrintWarning( "XLAL Warning - %s: q in [20,40] and chi in [-0.8]. The SEOBNRv1 model is not trustworthy in this region!\nSee Fig 15 in CQG 31 195010, 2014 for details.", __func__);
XLAL_ERROR( XLAL_EDOM );
}
/* Find frequency bounds */
if (!freqs_in) XLAL_ERROR(XLAL_EFAULT);
double fLow = freqs_in->data[0];
double fHigh = freqs_in->data[freqs_in->length - 1];
if(fRef==0.0)
fRef=fLow;
/* Convert to geometric units for frequency */
double Mf_ROM_min = fmax(gA[0], gPhi[0]); // lowest allowed geometric frequency for ROM
double Mf_ROM_max = fmin(gA[nk_amp-1], gPhi[nk_phi-1]); // highest allowed geometric frequency for ROM
double fLow_geom = fLow * Mtot_sec;
double fHigh_geom = fHigh * Mtot_sec;
double fRef_geom = fRef * Mtot_sec;
double deltaF_geom = deltaF * Mtot_sec;
// Enforce allowed geometric frequency range
if (fLow_geom < Mf_ROM_min)
XLAL_ERROR(XLAL_EDOM, "Starting frequency Mflow=%g is smaller than lowest frequency in ROM Mf=%g. Starting at lowest frequency in ROM.\n", fLow_geom, Mf_ROM_min);
if (fHigh_geom == 0)
fHigh_geom = Mf_ROM_max;
else if (fHigh_geom > Mf_ROM_max) {
XLALPrintWarning("Maximal frequency Mf_high=%g is greater than highest ROM frequency Mf_ROM_Max=%g. Using Mf_high=Mf_ROM_Max.", fHigh_geom, Mf_ROM_max);
fHigh_geom = Mf_ROM_max;
}
else if (fHigh_geom < Mf_ROM_min)
XLAL_ERROR(XLAL_EDOM, "End frequency %g is smaller than starting frequency %g!\n", fHigh_geom, fLow_geom);
if (fRef_geom > Mf_ROM_max) {
XLALPrintWarning("Reference frequency Mf_ref=%g is greater than maximal frequency in ROM Mf=%g. Starting at maximal frequency in ROM.\n", fRef_geom, Mf_ROM_max);
fRef_geom = Mf_ROM_max; // If fref > fhigh we reset fref to default value of cutoff frequency.
}
if (fRef_geom < Mf_ROM_min) {
XLALPrintWarning("Reference frequency Mf_ref=%g is smaller than lowest frequency in ROM Mf=%g. Starting at lowest frequency in ROM.\n", fLow_geom, Mf_ROM_min);
fRef_geom = Mf_ROM_min;
}
/* Internal storage for w.f. coefficiencts */
SEOBNRROMdata_coeff *romdata_coeff=NULL;
SEOBNRROMdata_coeff_Init(&romdata_coeff);
REAL8 amp_pre;
/* Interpolate projection coefficients and evaluate them at (q,chi) */
retcode=TP_Spline_interpolation_2d(
q, // Input: q-value for which projection coefficients should be evaluated
chi, // Input: chi-value for which projection coefficients should be evaluated
romdata->cvec_amp, // Input: data for spline coefficients for amplitude
romdata->cvec_phi, // Input: data for spline coefficients for phase
romdata->cvec_amp_pre, // Input: data for spline coefficients for amplitude prefactor
romdata_coeff->c_amp, // Output: interpolated projection coefficients for amplitude
romdata_coeff->c_phi, // Output: interpolated projection coefficients for phase
&_pre // Output: interpolated amplitude prefactor
);
if(retcode!=0) {
SEOBNRROMdata_coeff_Cleanup(romdata_coeff);
XLAL_ERROR(retcode, "Parameter-space interpolation failed.");
}
// Compute function values of amplitude an phase on sparse frequency points by evaluating matrix vector products
// amp_pts = B_A^T . c_A
// phi_pts = B_phi^T . c_phi
gsl_vector* amp_f = gsl_vector_alloc(nk_amp);
gsl_vector* phi_f = gsl_vector_alloc(nk_phi);
gsl_blas_dgemv(CblasTrans, 1.0, romdata->Bamp, romdata_coeff->c_amp, 0.0, amp_f);
gsl_blas_dgemv(CblasTrans, 1.0, romdata->Bphi, romdata_coeff->c_phi, 0.0, phi_f);
// Setup 1d splines in frequency
gsl_interp_accel *acc_amp = gsl_interp_accel_alloc();
gsl_spline *spline_amp = gsl_spline_alloc(gsl_interp_cspline, nk_amp);
gsl_spline_init(spline_amp, gA, gsl_vector_const_ptr(amp_f,0), nk_amp);
gsl_interp_accel *acc_phi = gsl_interp_accel_alloc();
gsl_spline *spline_phi = gsl_spline_alloc(gsl_interp_cspline, nk_phi);
gsl_spline_init(spline_phi, gPhi, gsl_vector_const_ptr(phi_f,0), nk_phi);
size_t npts = 0;
LIGOTimeGPS tC = {0, 0};
UINT4 offset = 0; // Index shift between freqs and the frequency series
REAL8Sequence *freqs = NULL;
if (deltaF > 0) { // freqs contains uniform frequency grid with spacing deltaF; we start at frequency 0
/* Set up output array with size closest power of 2 */
npts = NextPow2(fHigh_geom / deltaF_geom) + 1;
if (fHigh_geom < fHigh * Mtot_sec) /* Resize waveform if user wants f_max larger than cutoff frequency */
npts = NextPow2(fHigh * Mtot_sec / deltaF_geom) + 1;
XLALGPSAdd(&tC, -1. / deltaF); /* coalesce at t=0 */
*hptilde = XLALCreateCOMPLEX16FrequencySeries("hptilde: FD waveform", &tC, 0.0, deltaF, &lalStrainUnit, npts);
*hctilde = XLALCreateCOMPLEX16FrequencySeries("hctilde: FD waveform", &tC, 0.0, deltaF, &lalStrainUnit, npts);
// Recreate freqs using only the lower and upper bounds
UINT4 iStart = (UINT4) ceil(fLow_geom / deltaF_geom);
UINT4 iStop = (UINT4) ceil(fHigh_geom / deltaF_geom);
freqs = XLALCreateREAL8Sequence(iStop - iStart);
if (!freqs) {
XLAL_ERROR(XLAL_EFUNC, "Frequency array allocation failed.");
}
for (UINT4 i=iStart; i<iStop; i++)
freqs->data[i-iStart] = i*deltaF_geom;
offset = iStart;
} else { // freqs contains frequencies with non-uniform spacing; we start at lowest given frequency
npts = freqs_in->length;
*hptilde = XLALCreateCOMPLEX16FrequencySeries("hptilde: FD waveform", &tC, fLow, 0, &lalStrainUnit, npts);
*hctilde = XLALCreateCOMPLEX16FrequencySeries("hctilde: FD waveform", &tC, fLow, 0, &lalStrainUnit, npts);
offset = 0;
freqs = XLALCreateREAL8Sequence(freqs_in->length);
if (!freqs) {
XLAL_ERROR(XLAL_EFUNC, "Frequency array allocation failed.");
}
for (UINT4 i=0; i<freqs_in->length; i++)
freqs->data[i] = freqs_in->data[i] * Mtot_sec;
}
if (!(*hptilde) || !(*hctilde))
{
XLALDestroyREAL8Sequence(freqs);
gsl_spline_free(spline_amp);
gsl_spline_free(spline_phi);
gsl_interp_accel_free(acc_amp);
gsl_interp_accel_free(acc_phi);
gsl_vector_free(amp_f);
gsl_vector_free(phi_f);
SEOBNRROMdata_coeff_Cleanup(romdata_coeff);
XLAL_ERROR(XLAL_EFUNC, "Waveform allocation failed.");
}
memset((*hptilde)->data->data, 0, npts * sizeof(COMPLEX16));
memset((*hctilde)->data->data, 0, npts * sizeof(COMPLEX16));
XLALUnitMultiply(&(*hptilde)->sampleUnits, &(*hptilde)->sampleUnits, &lalSecondUnit);
XLALUnitMultiply(&(*hctilde)->sampleUnits, &(*hctilde)->sampleUnits, &lalSecondUnit);
COMPLEX16 *pdata=(*hptilde)->data->data;
COMPLEX16 *cdata=(*hctilde)->data->data;
REAL8 cosi = cos(inclination);
REAL8 pcoef = 0.5*(1.0 + cosi*cosi);
REAL8 ccoef = cosi;
REAL8 s = 1.0/sqrt(2.0); // Scale polarization amplitude so that strain agrees with FFT of SEOBNRv1
double Mtot = Mtot_sec / LAL_MTSUN_SI;
double amp0 = Mtot * amp_pre * Mtot_sec * LAL_MRSUN_SI / (distance); // Correct overall amplitude to undo mass-dependent scaling used in single-spin ROM
// Evaluate reference phase for setting phiRef correctly
double phase_change = gsl_spline_eval(spline_phi, fRef_geom, acc_phi) - 2*phiRef;
// Assemble waveform from aplitude and phase
for (UINT4 i=0; i<freqs->length; i++) { // loop over frequency points in sequence
double f = freqs->data[i];
if (f > Mf_ROM_max) continue; // We're beyond the highest allowed frequency; since freqs may not be ordered, we'll just skip the current frequency and leave zero in the buffer
int j = i + offset; // shift index for frequency series if needed
double A = gsl_spline_eval(spline_amp, f, acc_amp);
double phase = gsl_spline_eval(spline_phi, f, acc_phi) - phase_change;
COMPLEX16 htilde = s*amp0*A * cexp(I*phase);
pdata[j] = pcoef * htilde;
cdata[j] = -I * ccoef * htilde;
}
/* Correct phasing so we coalesce at t=0 (with the definition of the epoch=-1/deltaF above) */
// Get SEOBNRv1 ringdown frequency for 22 mode
double Mf_final = SEOBNRROM_Ringdown_Mf_From_Mtot_q(Mtot_sec, q, chi, chi, SEOBNRv1);
UINT4 L = freqs->length;
// prevent gsl interpolation errors
if (Mf_final > freqs->data[L-1])
Mf_final = freqs->data[L-1];
if (Mf_final < freqs->data[0])
{
XLALDestroyREAL8Sequence(freqs);
gsl_spline_free(spline_amp);
gsl_spline_free(spline_phi);
gsl_interp_accel_free(acc_amp);
gsl_interp_accel_free(acc_phi);
gsl_vector_free(amp_f);
gsl_vector_free(phi_f);
SEOBNRROMdata_coeff_Cleanup(romdata_coeff);
XLAL_ERROR(XLAL_EDOM, "f_ringdown < f_min");
}
// Time correction is t(f_final) = 1/(2pi) dphi/df (f_final)
// We compute the dimensionless time correction t/M since we use geometric units.
REAL8 t_corr = gsl_spline_eval_deriv(spline_phi, Mf_final, acc_phi) / (2*LAL_PI);
// Now correct phase
for (UINT4 i=0; i<freqs->length; i++) { // loop over frequency points in sequence
double f = freqs->data[i] - fRef_geom;
int j = i + offset; // shift index for frequency series if needed
pdata[j] *= cexp(-2*LAL_PI * I * f * t_corr);
cdata[j] *= cexp(-2*LAL_PI * I * f * t_corr);
}
XLALDestroyREAL8Sequence(freqs);
gsl_spline_free(spline_amp);
gsl_spline_free(spline_phi);
gsl_interp_accel_free(acc_amp);
gsl_interp_accel_free(acc_phi);
gsl_vector_free(amp_f);
gsl_vector_free(phi_f);
SEOBNRROMdata_coeff_Cleanup(romdata_coeff);
return(XLAL_SUCCESS);
}
/**
* Handle user-input and set up shop accordingly, and do all
* consistency-checks on user-input.
*/
int
XLALInitMakefakedata ( ConfigVars_t *cfg, UserVariables_t *uvar )
{
XLAL_CHECK ( cfg != NULL, XLAL_EINVAL, "Invalid NULL input 'cfg'\n" );
XLAL_CHECK ( uvar != NULL, XLAL_EINVAL, "Invalid NULL input 'uvar'\n");
cfg->VCSInfoString = XLALGetVersionString(0);
XLAL_CHECK ( cfg->VCSInfoString != NULL, XLAL_EFUNC, "XLALGetVersionString(0) failed.\n" );
// version info was requested: output then exit
if ( uvar->version )
{
printf ("%s\n", cfg->VCSInfoString );
exit (0);
}
/* if requested, log all user-input and code-versions */
if ( uvar->logfile ) {
XLAL_CHECK ( XLALWriteMFDlog ( uvar->logfile, cfg ) == XLAL_SUCCESS, XLAL_EFUNC, "XLALWriteMFDlog() failed with xlalErrno = %d\n", xlalErrno );
}
/* Init ephemerides */
XLAL_CHECK ( (cfg->edat = XLALInitBarycenter ( uvar->ephemEarth, uvar->ephemSun )) != NULL, XLAL_EFUNC );
/* check for negative fMin and Band, which would break the fMin_eff, fBand_eff calculation below */
XLAL_CHECK ( uvar->fmin >= 0, XLAL_EDOM, "Invalid negative frequency fMin=%f!\n\n", uvar->fmin );
XLAL_CHECK ( uvar->Band > 0, XLAL_EDOM, "Invalid non-positive frequency band Band=%f!\n\n", uvar->Band );
// ---------- check user-input consistency ----------
// ----- check if frames + frame channels given
BOOLEAN have_frames = (uvar->inFrames != NULL);
BOOLEAN have_channels= (uvar->inFrChannels != NULL);
XLAL_CHECK ( !(have_frames || have_channels) || (have_frames && have_channels), XLAL_EINVAL, "Need both --inFrames and --inFrChannels, or NONE\n");
// ----- IFOs : only from one of {--IFOs, --noiseSFTs, --inFrChannels}: mutually exclusive
BOOLEAN have_IFOs = (uvar->IFOs != NULL);
BOOLEAN have_noiseSFTs = (uvar->noiseSFTs != NULL);
XLAL_CHECK ( have_frames || have_IFOs || have_noiseSFTs, XLAL_EINVAL, "Need one of --IFOs, --noiseSFTs or --inFrChannels to determine detectors\n");
if ( have_frames ) {
XLAL_CHECK ( !have_IFOs && !have_noiseSFTs, XLAL_EINVAL, "If --inFrames given, cannot handle --IFOs or --noiseSFTs input\n");
XLAL_CHECK ( XLALParseMultiLALDetector ( &(cfg->multiIFO), uvar->inFrChannels ) == XLAL_SUCCESS, XLAL_EFUNC );
} else { // !have_frames
XLAL_CHECK ( !(have_IFOs && have_noiseSFTs), XLAL_EINVAL, "Cannot handle both --IFOs and --noiseSFTs input\n");
}
if ( have_IFOs ) {
XLAL_CHECK ( XLALParseMultiLALDetector ( &(cfg->multiIFO), uvar->IFOs ) == XLAL_SUCCESS, XLAL_EFUNC );
}
// ----- TIMESTAMPS: either from --timestampsFiles, --startTime+duration, or --noiseSFTs
BOOLEAN have_startTime = XLALUserVarWasSet ( &uvar->startTime );
BOOLEAN have_duration = XLALUserVarWasSet ( &uvar->duration );
BOOLEAN have_timestampsFiles = ( uvar->timestampsFiles != NULL );
// need BOTH startTime+duration or none
XLAL_CHECK ( ( have_duration && have_startTime) || !( have_duration || have_startTime ), XLAL_EINVAL, "Need BOTH {--startTime,--duration} or NONE\n");
// at least one of {startTime,timestamps,noiseSFTs,inFrames} required
XLAL_CHECK ( have_timestampsFiles || have_startTime || have_noiseSFTs || have_frames, XLAL_EINVAL, "Need at least one of {--timestampsFiles, --startTime+duration, --noiseSFTs, --inFrames}\n" );
// don't allow timestamps + {startTime+duration OR noiseSFTs}
XLAL_CHECK ( !have_timestampsFiles || !(have_startTime||have_noiseSFTs), XLAL_EINVAL, "--timestampsFiles incompatible with {--noiseSFTs or --startTime+duration}\n");
// note, however, that we DO allow --noiseSFTs and --startTime+duration, which will act as a constraint
// on the noise-SFTs to load in
// don't allow --SFToverlap with either --noiseSFTs OR --timestampsFiles
XLAL_CHECK ( uvar->SFToverlap >= 0, XLAL_EDOM );
BOOLEAN haveOverlap = ( uvar->SFToverlap > 0 );
XLAL_CHECK ( !haveOverlap || !( have_noiseSFTs || have_timestampsFiles ), XLAL_EINVAL, "--SFToverlap incompatible with {--noiseSFTs or --timestampsFiles}\n" );
// now handle the 3 mutually-exclusive cases: have_noiseSFTs || have_timestampsFiles || have_startTime (only)
if ( have_noiseSFTs )
{
SFTConstraints XLAL_INIT_DECL(constraints);
if ( have_startTime && have_duration ) // use optional (startTime+duration) as constraints,
{
LIGOTimeGPS minStartTime, maxStartTime;
minStartTime = uvar->startTime;
maxStartTime = uvar->startTime;
XLALGPSAdd ( &maxStartTime, uvar->duration );
constraints.minStartTime = &minStartTime;
constraints.maxStartTime = &maxStartTime;
char bufGPS1[32], bufGPS2[32];
XLALPrintWarning ( "Only noise-SFTs between GPS [%s, %s] will be used!\n", XLALGPSToStr(bufGPS1, &minStartTime), XLALGPSToStr(bufGPS2, &maxStartTime) );
} /* if start+duration given */
XLAL_CHECK ( (cfg->noiseCatalog = XLALSFTdataFind ( uvar->noiseSFTs, &constraints )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( cfg->noiseCatalog->length > 0, XLAL_EINVAL, "No noise-SFTs matching (start+duration, timestamps) were found!\n" );
XLAL_CHECK ( (cfg->multiNoiseCatalogView = XLALGetMultiSFTCatalogView ( cfg->noiseCatalog )) != NULL, XLAL_EFUNC );
// extract multi-timestamps from the multi-SFT-catalog view
XLAL_CHECK ( (cfg->multiTimestamps = XLALTimestampsFromMultiSFTCatalogView ( cfg->multiNoiseCatalogView )) != NULL, XLAL_EFUNC );
// extract IFOs from multi-SFT catalog
XLAL_CHECK ( XLALMultiLALDetectorFromMultiSFTCatalogView ( &(cfg->multiIFO), cfg->multiNoiseCatalogView ) == XLAL_SUCCESS, XLAL_EFUNC );
} // endif have_noiseSFTs
else if ( have_timestampsFiles )
{
XLAL_CHECK ( (cfg->multiTimestamps = XLALReadMultiTimestampsFiles ( uvar->timestampsFiles )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (cfg->multiTimestamps->length > 0) && (cfg->multiTimestamps->data != NULL), XLAL_EINVAL, "Got empty timestamps-list from XLALReadMultiTimestampsFiles()\n" );
for ( UINT4 X=0; X < cfg->multiTimestamps->length; X ++ ) {
cfg->multiTimestamps->data[X]->deltaT = uvar->Tsft; // Tsft information not given by timestamps-file
}
} // endif have_timestampsFiles
else if ( have_startTime && have_duration )
{
XLAL_CHECK ( ( cfg->multiTimestamps = XLALMakeMultiTimestamps ( uvar->startTime, uvar->duration, uvar->Tsft, uvar->SFToverlap, cfg->multiIFO.length )) != NULL, XLAL_EFUNC );
} // endif have_startTime
// check if the user asked for Gaussian white noise to be produced (sqrtSn[X]!=0), otherwise leave noise-floors at 0
if ( uvar->sqrtSX != NULL ) {
XLAL_CHECK ( XLALParseMultiNoiseFloor ( &(cfg->multiNoiseFloor), uvar->sqrtSX, cfg->multiIFO.length ) == XLAL_SUCCESS, XLAL_EFUNC );
} else {
cfg->multiNoiseFloor.length = cfg->multiIFO.length;
// values remain at their default sqrtSn[X] = 0;
}
#ifdef HAVE_LIBLALFRAME
// if user requested time-series data from frames to be added: try to read the frames now
if ( have_frames )
{
UINT4 numDetectors = uvar->inFrChannels->length;
XLAL_CHECK ( uvar->inFrames->length == numDetectors, XLAL_EINVAL, "Need equal number of channel names (%d) as frame specifications (%d)\n", uvar->inFrChannels->length, numDetectors );
XLAL_CHECK ( (cfg->inputMultiTS = XLALCalloc ( 1, sizeof(*cfg->inputMultiTS))) != NULL, XLAL_ENOMEM );
cfg->inputMultiTS->length = numDetectors;
XLAL_CHECK ( (cfg->inputMultiTS->data = XLALCalloc ( numDetectors, sizeof(cfg->inputMultiTS->data[0]) )) != NULL, XLAL_ENOMEM );
if ( cfg->multiTimestamps == NULL )
{
XLAL_CHECK ( (cfg->multiTimestamps = XLALCalloc ( 1, sizeof(*cfg->multiTimestamps) )) != NULL, XLAL_ENOMEM );
XLAL_CHECK ( (cfg->multiTimestamps->data = XLALCalloc ( numDetectors, sizeof(cfg->multiTimestamps->data[0]))) != NULL, XLAL_ENOMEM );
cfg->multiTimestamps->length = numDetectors;
}
for ( UINT4 X = 0; X < numDetectors; X ++ )
{
LALCache *cache;
XLAL_CHECK ( (cache = XLALCacheImport ( uvar->inFrames->data[X] )) != NULL, XLAL_EFUNC, "Failed to import cache file '%s'\n", uvar->inFrames->data[X] );
// this is a sorted cache, so extract its time-range:
REAL8 cache_tStart = cache->list[0].t0;
REAL8 cache_tEnd = cache->list[cache->length-1].t0 + cache->list[cache->length-1].dt;
REAL8 cache_duration = (cache_tEnd - cache_tStart);
LIGOTimeGPS ts_start;
REAL8 ts_duration;
// check that it's consistent with timestamps, if given, otherwise create timestamps from this
if ( cfg->multiTimestamps->data[X] != NULL ) // FIXME: implicitly assumes timestamps are sorted, which is not guaranteed by timestamps-reading from file
{
const LIGOTimeGPSVector *timestampsX = cfg->multiTimestamps->data[X];
REAL8 tStart = XLALGPSGetREAL8( ×tampsX->data[0] );
REAL8 tEnd = XLALGPSGetREAL8( ×tampsX->data[timestampsX->length-1]) + timestampsX->deltaT;
XLAL_CHECK ( tStart >= cache_tStart && tEnd <= cache_tEnd, XLAL_EINVAL, "Detector X=%d: Requested timestamps-range [%.0f, %.0f]s outside of cache range [%.0f,%.0f]s\n",
X, tStart, tEnd, cache_tStart, cache_tEnd );
XLALGPSSetREAL8 ( &ts_start, tStart );
ts_duration = (tEnd - tStart);
}
else
{
XLALGPSSetREAL8 ( &ts_start, (REAL8)cache_tStart + 1); // cache times can apparently be by rounded up or down by 1s, so shift by 1s to be safe
ts_duration = cache_duration - 1;
XLAL_CHECK ( (cfg->multiTimestamps->data[X] = XLALMakeTimestamps ( ts_start, ts_duration, uvar->Tsft, uvar->SFToverlap ) ) != NULL, XLAL_EFUNC );
}
// ----- now open frame stream and read *all* the data within this time-range [FIXME] ----------
LALFrStream *stream;
XLAL_CHECK ( (stream = XLALFrStreamCacheOpen ( cache )) != NULL, XLAL_EFUNC, "Failed to open stream from cache file '%s'\n", uvar->inFrames->data[X] );
XLALDestroyCache ( cache );
const char *channel = uvar->inFrChannels->data[X];
size_t limit = 0; // unlimited read
REAL8TimeSeries *ts;
XLAL_CHECK ( (ts = XLALFrStreamInputREAL8TimeSeries ( stream, channel, &ts_start, ts_duration, limit )) != NULL,
XLAL_EFUNC, "Frame reading failed for stream created for '%s': ts_start = {%d,%d}, duration=%.0f\n", uvar->inFrames->data[X], ts_start.gpsSeconds, ts_start.gpsNanoSeconds, ts_duration );
cfg->inputMultiTS->data[X] = ts;
XLAL_CHECK ( XLALFrStreamClose ( stream ) == XLAL_SUCCESS, XLAL_EFUNC, "Stream closing failed for cache file '%s'\n", uvar->inFrames->data[X] );
} // for X < numDetectors
} // if inFrames
// if user requested timeseries *output* to frame files, handle deprecated options
XLAL_CHECK ( !(uvar->TDDframedir && uvar->outFrameDir), XLAL_EINVAL, "Specify only ONE of {--TDDframedir or --outFrameDir} or NONE\n");
if ( uvar->TDDframedir ) {
cfg->outFrameDir = uvar->TDDframedir;
} else if ( uvar->outFrameDir ) {
cfg->outFrameDir = uvar->outFrameDir;
}
#endif
return XLAL_SUCCESS;
} /* XLALInitMakefakedata() */
/*
-------------------------------------------------------------------------
* This function minimises fContact defined above using the
* Brent method. It returns the minima with a negative sign (which then
* becomes the maxima of the actual contact function. This can be compared
* to 1 to check if two ellipsoids indeed overlap.
* ------------------------------------------------------------------------*/
REAL8 XLALCheckOverlapOfEllipsoids (
const gsl_vector *ra,
const gsl_vector *rb,
fContactWorkSpace *workSpace )
{
gsl_function F;
INT4 min_status;
INT4 iter = 0, max_iter = 100;
REAL8 m = 0.6180339887;
REAL8 a = 0.0L, b = 1.0L;
gsl_min_fminimizer *s = workSpace->s;
/* Sanity check on input arguments */
if ( !ra || !rb || !workSpace )
XLAL_ERROR_REAL8( XLAL_EFAULT );
if ( ra->size != rb->size || ra->size != workSpace->n )
XLAL_ERROR_REAL8( XLAL_EBADLEN);
/* Set r_AB to be rb - ra */
XLAL_CALLGSL( gsl_vector_memcpy( workSpace->r_AB, rb) );
XLAL_CALLGSL( gsl_vector_sub (workSpace->r_AB, ra) );
if ( gsl_vector_isnull( workSpace->r_AB ))
{
XLALPrintWarning("Position vectors ra and rb are identical.\n");
return 0;
}
F.function = &fContact;
F.params = workSpace;
XLAL_CALLGSL( min_status = gsl_min_fminimizer_set (s, &F, m, a, b) );
if ( min_status != GSL_SUCCESS )
XLAL_ERROR_REAL8( XLAL_EFUNC );
do
{
iter++;
XLAL_CALLGSL( min_status = gsl_min_fminimizer_iterate (s) );
if (min_status != GSL_SUCCESS )
{
if (min_status == GSL_EBADFUNC)
XLAL_ERROR_REAL8( XLAL_EFUNC | XLAL_EFPINVAL );
else if (min_status == GSL_EZERODIV)
XLAL_ERROR_REAL8( XLAL_EFUNC | XLAL_EFPDIV0 );
else
XLAL_ERROR_REAL8( XLAL_EFUNC );
}
m = gsl_min_fminimizer_x_minimum (s);
a = gsl_min_fminimizer_x_lower (s);
b = gsl_min_fminimizer_x_upper (s);
XLAL_CALLGSL( min_status = gsl_min_test_interval (a, b, workSpace->convParam, 0.0) );
if (min_status != GSL_CONTINUE && min_status != GSL_SUCCESS )
XLAL_ERROR_REAL8( XLAL_EFUNC );
}
while (min_status == GSL_CONTINUE && iter < max_iter );
/* End of minimization routine */
/* Throw an error if max iterations would have been exceeded */
if ( iter == max_iter && min_status == GSL_CONTINUE )
{
XLAL_ERROR_REAL8( XLAL_EMAXITER );
}
return ( -(s->f_minimum) );
}
/**
* Unit test for metric functions XLALComputeDopplerPhaseMetric()
* and XLALComputeDopplerFstatMetric()
*
* Initially modelled afer testMetricCodes.py script:
* Check metric codes 'getMetric' 'FstatMetric' and 'FstatMetric_v2' by
* comparing them against each other.
* Given that they represent 3 very different implementations of
* metric calculations, this provides a very powerful consistency test
*
*/
static int
test_XLALComputeDopplerMetrics ( void )
{
int ret;
const REAL8 tolPh = 0.01; // 1% tolerance on phase metrics [taken from testMetricCodes.py]
// ----- load ephemeris
const char earthEphem[] = TEST_DATA_DIR "earth00-19-DE200.dat.gz";
const char sunEphem[] = TEST_DATA_DIR "sun00-19-DE200.dat.gz";
EphemerisData *edat = XLALInitBarycenter ( earthEphem, sunEphem );
XLAL_CHECK ( edat != NULL, XLAL_EFUNC, "XLALInitBarycenter('%s','%s') failed with xlalErrno = %d\n", earthEphem, sunEphem, xlalErrno );
// ----- set test-parameters ----------
const LIGOTimeGPS startTimeGPS = { 792576013, 0 };
const REAL8 Tseg = 60000;
const REAL8 Alpha = 1.0;
const REAL8 Delta = 0.5;
const REAL8 Freq = 100;
const REAL8 f1dot = 0;// -1e-8;
LALStringVector *detNames = XLALCreateStringVector ( "H1", "L1", "V1", NULL );
LALStringVector *sqrtSX = XLALCreateStringVector ( "1.0", "0.5", "1.5", NULL );
MultiLALDetector multiIFO;
XLAL_CHECK ( XLALParseMultiLALDetector ( &multiIFO, detNames ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyStringVector ( detNames );
MultiNoiseFloor multiNoiseFloor;
XLAL_CHECK ( XLALParseMultiNoiseFloor ( &multiNoiseFloor, sqrtSX, multiIFO.length ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyStringVector ( sqrtSX );
// prepare metric parameters for modern XLALComputeDopplerFstatMetric() and mid-old XLALOldDopplerFstatMetric()
const DopplerCoordinateSystem coordSys = { 4, { DOPPLERCOORD_FREQ, DOPPLERCOORD_ALPHA, DOPPLERCOORD_DELTA, DOPPLERCOORD_F1DOT } };
const PulsarAmplitudeParams Amp = { 0.03, -0.3, 0.5, 0.0 }; // h0, cosi, psi, phi0
const PulsarDopplerParams dop = {
.refTime = startTimeGPS,
.Alpha = Alpha,
.Delta = Delta,
.fkdot = { Freq, f1dot },
};
LALSegList XLAL_INIT_DECL(segList);
ret = XLALSegListInitSimpleSegments ( &segList, startTimeGPS, 1, Tseg );
XLAL_CHECK ( ret == XLAL_SUCCESS, XLAL_EFUNC, "XLALSegListInitSimpleSegments() failed with xlalErrno = %d\n", xlalErrno );
const DopplerMetricParams master_pars2 = {
.coordSys = coordSys,
.detMotionType = DETMOTION_SPIN | DETMOTION_ORBIT,
.segmentList = segList,
.multiIFO = multiIFO,
.multiNoiseFloor = multiNoiseFloor,
.signalParams = { .Amp = Amp, .Doppler = dop },
.projectCoord = - 1, // -1==no projection
.approxPhase = 0,
};
// ========== BEGINNING OF TEST CALLS ==========
XLALPrintWarning("\n---------- ROUND 1: ephemeris-based, single-IFO phase metrics ----------\n");
{
OldDopplerMetric *metric1;
DopplerPhaseMetric *metric2P;
REAL8 diff_2_1;
DopplerMetricParams pars2 = master_pars2;
pars2.multiIFO.length = 1; // truncate to first detector
pars2.multiNoiseFloor.length = 1; // truncate to first detector
// 1) compute metric using old FstatMetric code, now wrapped into XLALOldDopplerFstatMetric()
XLAL_CHECK ( (metric1 = XLALOldDopplerFstatMetric ( OLDMETRIC_TYPE_PHASE, &pars2, edat )) != NULL, XLAL_EFUNC );
// 2) compute metric using modern UniversalDopplerMetric module: (used in lalapps_FstatMetric_v2)
XLAL_CHECK ( (metric2P = XLALComputeDopplerPhaseMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
// compare metrics against each other:
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( metric2P->g_ij, metric1->g_ij )) < tolPh, XLAL_ETOL, "Error(g2,g1)= %g exceeds tolerance of %g\n", diff_2_1, tolPh );
XLALPrintWarning ("diff_2_1 = %e\n", diff_2_1 );
XLALDestroyOldDopplerMetric ( metric1 );
XLALDestroyDopplerPhaseMetric ( metric2P );
}
XLALPrintWarning("\n---------- ROUND 2: Ptolemaic-based, single-IFO phase metrics ----------\n");
{
OldDopplerMetric *metric1;
DopplerPhaseMetric *metric2P;
REAL8 diff_2_1;
DopplerMetricParams pars2 = master_pars2;
pars2.multiIFO.length = 1; // truncate to first detector
pars2.multiNoiseFloor.length = 1; // truncate to first detector
pars2.detMotionType = DETMOTION_SPIN | DETMOTION_PTOLEORBIT;
// 1) compute metric using old FstatMetric code, now wrapped into XLALOldDopplerFstatMetric()
XLAL_CHECK ( (metric1 = XLALOldDopplerFstatMetric ( OLDMETRIC_TYPE_PHASE, &pars2, edat )) != NULL, XLAL_EFUNC );
// 2) compute metric using modern UniversalDopplerMetric module: (used in lalapps_FstatMetric_v2)
XLAL_CHECK ( (metric2P = XLALComputeDopplerPhaseMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
// compare all 3 metrics against each other:
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( metric2P->g_ij, metric1->g_ij )) < tolPh, XLAL_ETOL, "Error(g2,g1)= %g exceeds tolerance of %g\n", diff_2_1, tolPh );
XLALPrintWarning ("diff_2_1 = %e\n", diff_2_1 );
XLALDestroyOldDopplerMetric ( metric1 );
XLALDestroyDopplerPhaseMetric ( metric2P );
}
XLALPrintWarning("\n---------- ROUND 3: ephemeris-based, multi-IFO F-stat metrics ----------\n");
{
OldDopplerMetric *metric1;
DopplerFstatMetric *metric2F;
REAL8 diff_2_1;
DopplerMetricParams pars2 = master_pars2;
pars2.detMotionType = DETMOTION_SPIN | DETMOTION_ORBIT;
pars2.multiIFO = multiIFO; // 3 IFOs
pars2.multiNoiseFloor = multiNoiseFloor;// 3 IFOs
// 1) compute metric using old FstatMetric code, now wrapped into XLALOldDopplerFstatMetric()
XLAL_CHECK ( (metric1 = XLALOldDopplerFstatMetric ( OLDMETRIC_TYPE_FSTAT, &pars2, edat )) != NULL, XLAL_EFUNC );
// 2) compute metric using modern UniversalDopplerMetric module: (used in lalapps_FstatMetric_v2)
XLAL_CHECK ( (metric2F = XLALComputeDopplerFstatMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
// compare both metrics against each other:
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( metric2F->gF_ij, metric1->gF_ij )) < tolPh, XLAL_ETOL, "Error(gF2,gF1)= %e exceeds tolerance of %e\n", diff_2_1, tolPh );
XLALPrintWarning ("gF: diff_2_1 = %e\n", diff_2_1 );
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( metric2F->gFav_ij, metric1->gFav_ij )) < tolPh, XLAL_ETOL, "Error(gFav2,gFav1)= %e exceeds tolerance of %e\n", diff_2_1, tolPh );
XLALPrintWarning ("gFav: diff_2_1 = %e\n", diff_2_1 );
XLALDestroyOldDopplerMetric ( metric1 );
XLALDestroyDopplerFstatMetric ( metric2F );
}
XLALPrintWarning("\n---------- ROUND 4: compare analytic {f,f1dot,f2dot,f3dot} phase metric vs XLALComputeDopplerPhaseMetric() ----------\n");
{
DopplerPhaseMetric *metric2P;
REAL8 diff_2_1;
DopplerMetricParams pars2 = master_pars2;
pars2.multiIFO.length = 1; // truncate to 1st detector
pars2.multiNoiseFloor.length = 1; // truncate to 1st detector
pars2.detMotionType = DETMOTION_SPIN | DETMOTION_ORBIT;
pars2.approxPhase = 1; // use same phase-approximation as in analytic solution to improve comparison
DopplerCoordinateSystem coordSys2 = { 4, { DOPPLERCOORD_FREQ, DOPPLERCOORD_F1DOT, DOPPLERCOORD_F2DOT, DOPPLERCOORD_F3DOT } };
pars2.coordSys = coordSys2;
gsl_matrix* gN_ij;
// a) compute metric at refTime = startTime
pars2.signalParams.Doppler.refTime = startTimeGPS;
XLAL_CHECK ( (metric2P = XLALComputeDopplerPhaseMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
gN_ij = NULL;
XLAL_CHECK ( XLALNaturalizeMetric ( &gN_ij, NULL, metric2P->g_ij, &pars2 ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 gStart_ij[] = { 1.0/3, 2.0/3, 6.0/5, 32.0/15, \
2.0/3, 64.0/45, 8.0/3, 512.0/105, \
6.0/5, 8.0/3, 36.0/7, 48.0/5, \
32.0/15, 512.0/105, 48.0/5, 4096.0/225 };
const gsl_matrix_view gStart = gsl_matrix_view_array ( gStart_ij, 4, 4 );
// compare natural-units metric against analytic solution
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( gN_ij, &(gStart.matrix) )) < tolPh, XLAL_ETOL,
"RefTime=StartTime: Error(g_ij,g_analytic)= %e exceeds tolerance of %e\n", diff_2_1, tolPh );
XLALPrintWarning ("Analytic (refTime=startTime): diff_2_1 = %e\n", diff_2_1 );
XLALDestroyDopplerPhaseMetric ( metric2P );
gsl_matrix_free ( gN_ij );
// b) compute metric at refTime = midTime
pars2.signalParams.Doppler.refTime = startTimeGPS;
pars2.signalParams.Doppler.refTime.gpsSeconds += Tseg / 2;
XLAL_CHECK ( (metric2P = XLALComputeDopplerPhaseMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
gN_ij = NULL;
XLAL_CHECK ( XLALNaturalizeMetric ( &gN_ij, NULL, metric2P->g_ij, &pars2 ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 gMid_ij[] = { 1.0/3, 0, 1.0/5, 0, \
0, 4.0/45, 0, 8.0/105, \
1.0/5, 0, 1.0/7, 0, \
0, 8.0/105, 0, 16.0/225 };
const gsl_matrix_view gMid = gsl_matrix_view_array ( gMid_ij, 4, 4 );
// compare natural-units metric against analytic solution
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( gN_ij, &(gMid.matrix) )) < tolPh, XLAL_ETOL,
"RefTime=MidTime: Error(g_ij,g_analytic)= %e exceeds tolerance of %e\n", diff_2_1, tolPh );
XLALPrintWarning ("Analytic (refTime=midTime): diff_2_1 = %e\n\n", diff_2_1 );
XLALDestroyDopplerPhaseMetric ( metric2P );
gsl_matrix_free ( gN_ij );
}
XLALPrintWarning("\n---------- ROUND 5: ephemeris-based, single-IFO, segment-averaged phase metrics ----------\n");
{
OldDopplerMetric *metric1;
DopplerPhaseMetric *metric2P;
REAL8 diff_2_1;
DopplerMetricParams pars2 = master_pars2;
pars2.detMotionType = DETMOTION_SPIN | DETMOTION_ORBIT;
pars2.multiIFO.length = 1; // truncate to first detector
pars2.multiNoiseFloor.length = 1; // truncate to first detector
pars2.approxPhase = 1;
const UINT4 Nseg = 10;
LALSegList XLAL_INIT_DECL(NsegList);
ret = XLALSegListInitSimpleSegments ( &NsegList, startTimeGPS, Nseg, Tseg );
XLAL_CHECK ( ret == XLAL_SUCCESS, XLAL_EFUNC, "XLALSegListInitSimpleSegments() failed with xlalErrno = %d\n", xlalErrno );
pars2.segmentList = NsegList;
LALSegList XLAL_INIT_DECL(segList_k);
LALSeg segment_k;
XLALSegListInit( &segList_k ); // prepare single-segment list containing segment k
segList_k.arraySize = 1;
segList_k.length = 1;
segList_k.segs = &segment_k;
// 1) compute metric using old FstatMetric code, now wrapped into XLALOldDopplerFstatMetric()
metric1 = NULL;
for (UINT4 k = 0; k < Nseg; ++k) {
// setup 1-segment segment-list pointing k-th segment
DopplerMetricParams pars2_k = pars2;
pars2_k.segmentList = segList_k;
pars2_k.segmentList.segs[0] = pars2.segmentList.segs[k];
// XLALOldDopplerFstatMetric() does not agree numerically with UniversalDopplerMetric when using refTime != startTime
pars2_k.signalParams.Doppler.refTime = pars2_k.segmentList.segs[0].start;
OldDopplerMetric *metric1_k; // per-segment coherent metric
XLAL_CHECK ( (metric1_k = XLALOldDopplerFstatMetric ( OLDMETRIC_TYPE_PHASE, &pars2_k, edat )) != NULL, XLAL_EFUNC );
// manually correct reference time of metric1_k->g_ij; see Prix, "Frequency metric for CW searches" (2014-08-17), p. 4
const double dt = XLALGPSDiff( &(pars2_k.signalParams.Doppler.refTime), &(pars2.signalParams.Doppler.refTime) );
const double gFF = gsl_matrix_get( metric1_k->g_ij, 0, 0 );
const double gFA = gsl_matrix_get( metric1_k->g_ij, 0, 1 );
const double gFD = gsl_matrix_get( metric1_k->g_ij, 0, 2 );
const double gFf = gsl_matrix_get( metric1_k->g_ij, 0, 3 );
const double gAf = gsl_matrix_get( metric1_k->g_ij, 1, 3 );
const double gDf = gsl_matrix_get( metric1_k->g_ij, 2, 3 );
const double gff = gsl_matrix_get( metric1_k->g_ij, 3, 3 );
gsl_matrix_set( metric1_k->g_ij, 0, 3, gFf + gFF*dt ); gsl_matrix_set( metric1_k->g_ij, 3, 0, gsl_matrix_get( metric1_k->g_ij, 0, 3 ) );
gsl_matrix_set( metric1_k->g_ij, 1, 3, gAf + gFA*dt ); gsl_matrix_set( metric1_k->g_ij, 3, 1, gsl_matrix_get( metric1_k->g_ij, 1, 3 ) );
gsl_matrix_set( metric1_k->g_ij, 2, 3, gDf + gFD*dt ); gsl_matrix_set( metric1_k->g_ij, 3, 2, gsl_matrix_get( metric1_k->g_ij, 2, 3 ) );
gsl_matrix_set( metric1_k->g_ij, 3, 3, gff + 2*gFf*dt + gFF*dt*dt );
XLAL_CHECK ( XLALAddOldDopplerMetric ( &metric1, metric1_k ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyOldDopplerMetric ( metric1_k );
}
XLAL_CHECK ( XLALScaleOldDopplerMetric ( metric1, 1.0 / Nseg ) == XLAL_SUCCESS, XLAL_EFUNC );
// 2) compute metric using modern UniversalDopplerMetric module: (used in lalapps_FstatMetric_v2)
XLAL_CHECK ( (metric2P = XLALComputeDopplerPhaseMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
GPMAT( metric1->g_ij, "%0.4e" );
GPMAT( metric2P->g_ij, "%0.4e" );
// compare both metrics against each other:
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( metric2P->g_ij, metric1->g_ij )) < tolPh, XLAL_ETOL, "Error(g2,g1)= %g exceeds tolerance of %g\n", diff_2_1, tolPh );
XLALPrintWarning ("diff_2_1 = %e\n", diff_2_1 );
XLALDestroyOldDopplerMetric ( metric1 );
XLALDestroyDopplerPhaseMetric ( metric2P );
XLALSegListClear ( &NsegList );
}
XLALPrintWarning("\n---------- ROUND 6: directed binary orbital metric ----------\n");
{
REAL8 Period = 68023.70496;
REAL8 Omega = LAL_TWOPI / Period;
REAL8 asini = 1.44;
REAL8 tAsc = 897753994;
REAL8 argp = 0;
LIGOTimeGPS tP; XLALGPSSetREAL8 ( &tP, tAsc + argp / Omega );
const PulsarDopplerParams dopScoX1 = {
.refTime = startTimeGPS,
.Alpha = Alpha,
.Delta = Delta,
.fkdot = { Freq },
.asini = asini,
.period = Period,
.tp = tP
};
REAL8 TspanScoX1 = 20 * 19 * 3600; // 20xPorb for long-segment regime
LALSegList XLAL_INIT_DECL(segListScoX1);
XLAL_CHECK ( XLALSegListInitSimpleSegments ( &segListScoX1, startTimeGPS, 1, TspanScoX1 ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 tMid = XLALGPSGetREAL8(&startTimeGPS) + 0.5 * TspanScoX1;
REAL8 DeltaMidAsc = tMid - tAsc;
const DopplerCoordinateSystem coordSysScoX1 = { 6, { DOPPLERCOORD_FREQ, DOPPLERCOORD_ASINI, DOPPLERCOORD_TASC, DOPPLERCOORD_PORB, DOPPLERCOORD_KAPPA, DOPPLERCOORD_ETA } };
DopplerMetricParams pars_ScoX1 = {
.coordSys = coordSysScoX1,
.detMotionType = DETMOTION_SPIN | DETMOTION_ORBIT,
.segmentList = segListScoX1,
.multiIFO = multiIFO,
.multiNoiseFloor = multiNoiseFloor,
.signalParams = { .Amp = Amp, .Doppler = dopScoX1 },
.projectCoord = - 1, // -1==no projection
.approxPhase = 1,
};
pars_ScoX1.multiIFO.length = 1; // truncate to first detector
pars_ScoX1.multiNoiseFloor.length = 1; // truncate to first detector
// compute metric using modern UniversalDopplerMetric module: (used in lalapps_FstatMetric_v2)
DopplerPhaseMetric *metric_ScoX1;
XLAL_CHECK ( (metric_ScoX1 = XLALComputeDopplerPhaseMetric ( &pars_ScoX1, edat )) != NULL, XLAL_EFUNC );
// compute analytic metric computed from Eq.(47) in Leaci,Prix PRD91, 102003 (2015):
gsl_matrix *g0_ij;
XLAL_CHECK ( (g0_ij = gsl_matrix_calloc ( 6, 6 )) != NULL, XLAL_ENOMEM, "Failed to gsl_calloc a 6x6 matrix\n");
gsl_matrix_set ( g0_ij, 0, 0, pow ( LAL_PI * TspanScoX1, 2 ) / 3.0 );
gsl_matrix_set ( g0_ij, 1, 1, 2.0 * pow ( LAL_PI * Freq, 2 ) );
gsl_matrix_set ( g0_ij, 2, 2, 2.0 * pow ( LAL_PI * Freq * asini * Omega, 2 ) );
gsl_matrix_set ( g0_ij, 3, 3, 0.5 * pow ( Omega, 4 ) * pow ( Freq * asini, 2 ) * ( pow ( TspanScoX1, 2 ) / 12.0 + pow ( DeltaMidAsc, 2 ) ) );
REAL8 gPAsc = LAL_PI * pow ( Freq * asini, 2 ) * pow ( Omega, 3 ) * DeltaMidAsc;
gsl_matrix_set ( g0_ij, 2, 3, gPAsc );
gsl_matrix_set ( g0_ij, 3, 2, gPAsc );
gsl_matrix_set ( g0_ij, 4, 4, 0.5 * pow ( LAL_PI * Freq * asini, 2 ) );
gsl_matrix_set ( g0_ij, 5, 5, 0.5 * pow ( LAL_PI * Freq * asini, 2 ) );
GPMAT ( metric_ScoX1->g_ij, "%0.4e" );
GPMAT ( g0_ij, "%0.4e" );
// compare metrics against each other
REAL8 diff, tolScoX1 = 0.05;
XLAL_CHECK ( (diff = XLALCompareMetrics ( metric_ScoX1->g_ij, g0_ij )) < tolScoX1, XLAL_ETOL, "Error(gNum,gAn)= %g exceeds tolerance of %g\n", diff, tolScoX1 );
XLALPrintWarning ("diff_Num_An = %e\n", diff );
gsl_matrix_free ( g0_ij );
XLALDestroyDopplerPhaseMetric ( metric_ScoX1 );
XLALSegListClear ( &segListScoX1 );
}
/*
* Core function for computing the ROM waveform.
* Evaluates projection coefficients and shifts in time and phase at desired q.
* Construct 1D splines for amplitude and phase.
* Compute strain waveform from amplitude and phase.
*/
static INT4 EOBNRv2HMROMCore(
COMPLEX16FrequencySeries **hptilde,
COMPLEX16FrequencySeries **hctilde,
REAL8 phiRef,
REAL8 deltaF,
REAL8 fLow,
REAL8 fHigh,
REAL8 fRef,
REAL8 distance,
REAL8 inclination,
REAL8 Mtot_sec,
REAL8 q)
{
INT4 ret = XLAL_SUCCESS;
INT4 i;
INT4 j;
double tpeak22estimate = 0.;
/* Check output arrays */
if(!hptilde || !hctilde) XLAL_ERROR(XLAL_EFAULT);
if(*hptilde || *hctilde)
{
XLALPrintError("(*hptilde) and (*hctilde) are supposed to be NULL, but got %p and %p\n",(*hptilde),(*hctilde));
XLAL_ERROR(XLAL_EFAULT);
}
/* Check if the data has been set up */
if(__lalsim_EOBNRv2HMROM_setup) {
XLALPrintError("Error: the ROM data has not been set up\n");
XLAL_ERROR(XLAL_EFAULT);
}
/* Set the global pointers to data */
ListmodesEOBNRHMROMdata* listdata = *__lalsim_EOBNRv2HMROM_data;
ListmodesEOBNRHMROMdata_interp* listdata_interp = *__lalsim_EOBNRv2HMROM_interp;
/* Global amplitude prefactor - includes total mass scaling, Fourier scaling, distance scaling, and undoing an additional arbitrary scaling */
REAL8 Mtot_msol = Mtot_sec / LAL_MTSUN_SI; /* Mtot_msol and M_ROM in units of solar mass */
REAL8 amp0 = (Mtot_msol/M_ROM) * Mtot_sec * 1.E-16 * 1.E6 * LAL_PC_SI / distance;
/* Highest allowed geometric frequency for the first mode of listmode in the ROM - used for fRef
* by convention, we use the first mode of listmode (presumably the 22) for phiref */
ListmodesEOBNRHMROMdata* listdata_ref = ListmodesEOBNRHMROMdata_GetMode(listdata, listmode[0][0], listmode[0][1]);
EOBNRHMROMdata* data_ref = listdata_ref->data;
REAL8 Mf_ROM_max_ref = gsl_vector_get(data_ref->freq, nbfreq-1);
/* Convert to geometric units for frequency */
REAL8 fLow_geom = fLow * Mtot_sec;
REAL8 fHigh_geom = fHigh * Mtot_sec;
REAL8 fRef_geom = fRef * Mtot_sec;
REAL8 deltaF_geom = deltaF * Mtot_sec;
/* Enforce allowed geometric frequency range */
if (fLow_geom < Mf_ROM_min) { /* Enforce minimal frequency */
XLALPrintWarning("Starting frequency Mflow=%g is smaller than lowest frequency in ROM Mf=%g. Starting at lowest frequency in ROM.\n", fLow_geom, Mf_ROM_min);
fLow_geom = Mf_ROM_min;
}
/* Default highest frequency */
if (fHigh == 0)
fHigh_geom = Mf_ROM_max;
/* In case the user asks for a frequency higher than covered by the ROM, we keep it that way as we will just 0-pad the waveform (and do it anyway for some modes) */
if (fRef_geom > Mf_ROM_max_ref || fRef_geom == 0)
fRef_geom = Mf_ROM_max_ref; /* If fRef > fhigh or 0 we reset fRef to default value of cutoff frequency for the first mode of the list (presumably the 22 mode) */
if (0 < fRef_geom && fRef_geom < Mf_ROM_min) {
XLALPrintWarning("Reference frequency Mf_ref=%g is smaller than lowest frequency in ROM Mf=%g. Setting it to the lowest frequency in ROM.\n", fLow_geom, Mf_ROM_min);
fRef_geom = Mf_ROM_min;
}
/* Set up output array with size closest power of 2 - fHigh is the upper frequency specified by the user */
size_t nbpt = NextPow2(fHigh_geom / deltaF_geom) + 1;
/* Internal storage for the projection coefficients and shifts in time and phase */
/* Initialized only once, and reused for the different modes */
EOBNRHMROMdata_coeff *data_coeff = NULL;
EOBNRHMROMdata_coeff_Init(&data_coeff);
/* Create spherical harmonic frequency series that will contain the hlm's */
SphHarmFrequencySeries** hlmsphharmfreqseries = XLALMalloc(sizeof(SphHarmFrequencySeries));
*hlmsphharmfreqseries = NULL;
/* GPS time definition - common to all modes */
LIGOTimeGPS tC;
XLALGPSAdd(&tC, -1. / deltaF); /* coalesce at t=0 */
/* The phase change imposed by phiref, from the phase of the first mode in the list - to be set in the first step of the loop on the modes */
REAL8 phase_change_ref = 0;
/* Main loop over the modes */
for( i=0; i<nbmode; i++ ){
UINT4 l = listmode[i][0];
INT4 m = listmode[i][1];
/* Getting the relevant modes in the lists of data */
ListmodesEOBNRHMROMdata* listdata_mode = ListmodesEOBNRHMROMdata_GetMode(listdata, l, m);
ListmodesEOBNRHMROMdata_interp* listdata_interp_mode = ListmodesEOBNRHMROMdata_interp_GetMode(listdata_interp, l, m);
/* Evaluating the projection coefficients and shift in time and phase */
ret |= Evaluate_Spline_Data(q, listdata_interp_mode->data_interp, data_coeff);
/* Evaluating the unnormalized amplitude and unshifted phase vectors for the mode */
/* Notice a change in convention: B matrices are transposed with respect to the B matrices in SEOBNRROM */
/* amp_pts = Bamp . Camp_coeff */
/* phi_pts = Bphi . Cphi_coeff */
gsl_vector* amp_f = gsl_vector_alloc(nbfreq);
gsl_vector* phi_f = gsl_vector_alloc(nbfreq);
gsl_blas_dgemv(CblasNoTrans, 1.0, listdata_mode->data->Bamp, data_coeff->Camp_coeff, 0.0, amp_f);
gsl_blas_dgemv(CblasNoTrans, 1.0, listdata_mode->data->Bphi, data_coeff->Cphi_coeff, 0.0, phi_f);
/* The downsampled frequencies for the mode - we undo the rescaling of the frequency for the 44 and 55 modes */
gsl_vector* freq_ds = gsl_vector_alloc(nbfreq);
gsl_vector_memcpy(freq_ds, listdata_mode->data->freq);
if ( l==4 && m==4) gsl_vector_scale( freq_ds, 1./Scaling44(q));
if ( l==5 && m==5) gsl_vector_scale( freq_ds, 1./Scaling55(q));
/* Evaluating the shifts in time and phase - conditional scaling for the 44 and 55 modes */
/* Note: the stored values of 'shifttime' correspond actually to 2pi*Deltat */
SplineList* shifttime_splinelist = listdata_interp_mode->data_interp->shifttime_interp;
SplineList* shiftphase_splinelist = listdata_interp_mode->data_interp->shiftphase_interp;
REAL8 twopishifttime;
if( l==4 && m==4) {
twopishifttime = gsl_spline_eval(shifttime_splinelist->spline, q, shifttime_splinelist->accel) * Scaling44(q);
}
else if( l==5 && m==5) {
twopishifttime = gsl_spline_eval(shifttime_splinelist->spline, q, shifttime_splinelist->accel) * Scaling55(q);
}
else {
twopishifttime = gsl_spline_eval(shifttime_splinelist->spline, q, shifttime_splinelist->accel);
}
REAL8 shiftphase = gsl_spline_eval(shiftphase_splinelist->spline, q, shiftphase_splinelist->accel);
/* If first mode in the list, assumed to be the 22 mode, set totalshifttime and phase_change_ref */
if( i==0 ) {
if(l==2 && m==2) {
/* Setup 1d cubic spline for the phase of the 22 mode */
gsl_interp_accel* accel_phi22 = gsl_interp_accel_alloc();
gsl_spline* spline_phi22 = gsl_spline_alloc(gsl_interp_cspline, nbfreq);
gsl_spline_init(spline_phi22, gsl_vector_const_ptr(freq_ds,0), gsl_vector_const_ptr(phi_f,0), nbfreq);
/* Compute the shift in time needed to set the peak of the 22 mode roughly at t=0 */
/* We use the SPA formula tf = -(1/2pi)*dPsi/df to estimate the correspondence between frequency and time */
/* The frequency corresponding to the 22 peak is omega22peak/2pi, with omega22peak taken from the fit to NR in Pan&al 1106 EOBNRv2HM paper */
double f22peak = fmin(omega22peakOfq(q)/(2*LAL_PI), Mf_ROM_max_ref); /* We ensure we evaluate the spline within its range */
tpeak22estimate = -1./(2*LAL_PI) * gsl_spline_eval_deriv(spline_phi22, f22peak, accel_phi22);
/* Determine the change in phase (to be propagated to all modes) required to have phi22(fRef) = 2*phiRef */
phase_change_ref = 2*phiRef + (gsl_spline_eval(spline_phi22, fRef_geom, accel_phi22) - (twopishifttime - 2*LAL_PI*tpeak22estimate) * fRef_geom - shiftphase);
gsl_spline_free(spline_phi22);
gsl_interp_accel_free(accel_phi22);
}
else {
XLALPrintError("Error: the first mode in listmode must be the 22 mode to set the changes in phase and time \n");
XLAL_ERROR(XLAL_EFAILED);
}
}
/* Total shift in time, and total change in phase for this mode */
double totaltwopishifttime = twopishifttime - 2*LAL_PI*tpeak22estimate;
double constphaseshift = (double) m/listmode[0][1] * phase_change_ref + shiftphase;
/* Initialize the complex series for the mode - notice that metadata used here is useless, only the one for the final output will matter */
COMPLEX16FrequencySeries* mode = XLALCreateCOMPLEX16FrequencySeries("mode hlm", &tC, 0.0, deltaF, &lalStrainUnit, nbpt);
memset(mode->data->data, 0, nbpt * sizeof(COMPLEX16));
/* Setup 1d cubic spline for the phase and amplitude of the mode */
gsl_interp_accel* accel_phi = gsl_interp_accel_alloc();
gsl_interp_accel* accel_amp = gsl_interp_accel_alloc();
gsl_spline* spline_phi = gsl_spline_alloc(gsl_interp_cspline, nbfreq);
gsl_spline* spline_amp = gsl_spline_alloc(gsl_interp_cspline, nbfreq);
gsl_spline_init(spline_phi, gsl_vector_const_ptr(freq_ds,0), gsl_vector_const_ptr(phi_f,0), nbfreq);
gsl_spline_init(spline_amp, gsl_vector_const_ptr(freq_ds,0), gsl_vector_const_ptr(amp_f,0), nbfreq);
/* Interval in frequency covered by the ROM */
REAL8 fLow_geom_mode = gsl_vector_get(freq_ds, 0);
REAL8 fHigh_geom_mode = fmin(gsl_vector_get(freq_ds, nbfreq-1), fHigh_geom);
/* Initialize the loop - values outside this range in j are 0 by default */
INT4 jStart = (UINT4) ceil(fLow_geom_mode / deltaF_geom);
INT4 jStop = (UINT4) ceil(fHigh_geom_mode / deltaF_geom);
COMPLEX16 *modedata = mode->data->data;
/* Mode-dependent complete amplitude prefactor */
REAL8 amp_pre = amp0 * ModeAmpFactor( l, m, q);
/* Loop on the frequency samples chosen to evaluate the waveform */
/* We set apart the first and last step to avoid falling outside of the range of the splines by numerical errors */
REAL8 f, A, phase;
f = fmax(fLow_geom_mode, jStart*deltaF_geom);
A = gsl_spline_eval(spline_amp, f, accel_amp);
phase = -gsl_spline_eval(spline_phi, f, accel_phi) + totaltwopishifttime * f + constphaseshift; /* Minus sign put here, in the internals of the ROM model \Psi = -phase */
modedata[jStart] = amp_pre * A * cexp(I*phase);
for (j=jStart+1; j<jStop-1; j++) {
f = j*deltaF_geom;
A = gsl_spline_eval(spline_amp, f, accel_amp);
phase = -gsl_spline_eval(spline_phi, f, accel_phi) + totaltwopishifttime * f + constphaseshift; /* Minus sign put here, in the internals of the ROM model \Psi = -phase */
modedata[j] = amp_pre * A * cexp(I*phase);
}
f = fmin(fHigh_geom_mode, (jStop-1)*deltaF_geom);
A = gsl_spline_eval(spline_amp, f, accel_amp);
phase = -gsl_spline_eval(spline_phi, f, accel_phi) + totaltwopishifttime * f + constphaseshift; /* Minus sign put here, in the internals of the ROM model \Psi = -phase */
modedata[jStop-1] = amp_pre * A * cexp(I*phase);
/* Add the computed mode to the SphHarmFrequencySeries structure */
*hlmsphharmfreqseries = XLALSphHarmFrequencySeriesAddMode(*hlmsphharmfreqseries, mode, l, m);
/* Cleanup for the mode */
gsl_spline_free(spline_amp);
gsl_spline_free(spline_phi);
gsl_interp_accel_free(accel_amp);
gsl_interp_accel_free(accel_phi);
gsl_vector_free(amp_f);
gsl_vector_free(phi_f);
gsl_vector_free(freq_ds);
XLALDestroyCOMPLEX16FrequencySeries(mode);
}
/* Cleanup of the coefficients data structure */
EOBNRHMROMdata_coeff_Cleanup(data_coeff);
/* Combining the modes for a hplus, hcross output */
/* Initialize the complex series hplus, hcross */
*hptilde = XLALCreateCOMPLEX16FrequencySeries("hptilde: FD waveform", &tC, 0.0, deltaF, &lalStrainUnit, nbpt);
*hctilde = XLALCreateCOMPLEX16FrequencySeries("hctilde: FD waveform", &tC, 0.0, deltaF, &lalStrainUnit, nbpt);
if (!(hptilde) || !(*hctilde)) XLAL_ERROR(XLAL_EFUNC);
memset((*hptilde)->data->data, 0, nbpt * sizeof(COMPLEX16));
memset((*hctilde)->data->data, 0, nbpt * sizeof(COMPLEX16));
XLALUnitDivide(&(*hptilde)->sampleUnits, &(*hptilde)->sampleUnits, &lalSecondUnit);
XLALUnitDivide(&(*hctilde)->sampleUnits, &(*hctilde)->sampleUnits, &lalSecondUnit);
/* Adding the modes to form hplus, hcross
* - use of a function that copies XLALSimAddMode but for Fourier domain structures */
INT4 sym; /* sym will decide whether to add the -m mode (when equatorial symmetry is present) */
for( i=0; i<nbmode; i++){
INT4 l = listmode[i][0];
INT4 m = listmode[i][1];
COMPLEX16FrequencySeries* mode = XLALSphHarmFrequencySeriesGetMode(*hlmsphharmfreqseries, l, m);
if ( m==0 ) sym = 0; /* We test for hypothetical m=0 modes */
else sym = 1;
FDAddMode( *hptilde, *hctilde, mode, inclination, 0., l, m, sym); /* The phase \Phi is set to 0 - assumes phiRef is defined as half the phase of the 22 mode h22 (or the first mode in the list), not for h = hplus-I hcross */
}
/* Destroying the list of frequency series for the modes, including the COMPLEX16FrequencySeries that it contains */
XLALDestroySphHarmFrequencySeries(*hlmsphharmfreqseries);
XLALFree(hlmsphharmfreqseries);
/* Additional complex conjugation of hptilde, hctilde - due to the difference in convention for the Fourier transform between LAL and the ROM internals */
COMPLEX16* datap = (*hptilde)->data->data;
COMPLEX16* datac = (*hctilde)->data->data;
for ( j = 0; j < (INT4) (*hptilde)->data->length; ++j ) {
datap[j] = conj(datap[j]);
}
for ( j = 0; j < (INT4) (*hctilde)->data->length; ++j ) {
datac[j] = conj(datac[j]);
}
return(XLAL_SUCCESS);
}
REAL8VectorSequence * XLALASCIIFileReadColumns( INT4 ncol, const char *fname )
{
char line[LINE_MAX];
REAL8VectorSequence *data;
int nline;
int nrow;
int row;
int col;
FILE *fp;
if ( ncol < 0 )
XLAL_ERROR_NULL( XLAL_EINVAL );
/* count rows */
nrow = XLALASCIIFileCountRows( fname );
if ( nrow < 0 )
XLAL_ERROR_NULL( XLAL_EFUNC );
/* allocate memory for data */
/* column 0 will contain line number of input file */
data = XLALCreateREAL8VectorSequence( nrow, ncol + 1 );
if ( ! data )
XLAL_ERROR_NULL( XLAL_EFUNC );
/* open file */
fp = fopen( fname, "r" );
if ( ! fp )
{
XLALDestroyREAL8VectorSequence( data );
XLAL_ERROR_NULL( XLAL_EIO );
}
nline = 0;
row = 0;
while ( row < nrow )
if ( fgets( line, sizeof( line ), fp ) )
{
char *p = line;
++nline;
if ( strlen( line ) >= sizeof( line ) - 1 )
{
XLALPrintError( "XLAL Error - %s: line %d too long\n\tfile: %s\n", __func__, nline, fname );
XLALDestroyREAL8VectorSequence( data );
fclose( fp );
XLAL_ERROR_NULL( XLAL_EBADLEN );
}
if ( line[0] == '#' || line[0] == '%' )
continue;
data->data[row*data->vectorLength] = nline;
for ( col = 1; col <= ncol; ++col )
{
char *endp;
REAL8 val;
val = strtod( p, &endp );
if ( p == endp ) /* no conversion */
{
XLALPrintError( "XLAL Error - %s: unable to parse line %d\n\tfile: %s\n", __func__, nline, fname );
XLALDestroyREAL8VectorSequence( data );
fclose( fp );
XLAL_ERROR_NULL( XLAL_EFAILED );
}
if ( isnan( val ) )
{
XLALPrintWarning( "XLAL Warning - %s: invalid data (nan) in column %d of line %d\n\tfile: %s\n", __func__, col, nline, fname );
val = 0;
}
if ( isinf( val ) )
{
XLALPrintWarning( "XLAL Warning - %s: invalid data (inf) in column %d of line %d\n\tfile: %s\n", __func__, col, nline, fname );
val = 0;
}
data->data[row*data->vectorLength + col] = val;
p = endp;
}
++row;
}
else
{
XLALDestroyREAL8VectorSequence( data );
XLAL_ERROR_NULL( XLAL_EIO );
}
fclose( fp );
return data;
}
/**
* Single-IFO version of XLALCWMakeFakeMultiData(), handling the actual
* work, but same input API. The 'detectorIndex' has the index of the detector
* to be used from the multi-IFO arrays.
*/
int
XLALCWMakeFakeData ( SFTVector **SFTvect,
REAL8TimeSeries **Tseries,
const PulsarParamsVector *injectionSources,
const CWMFDataParams *dataParams,
UINT4 detectorIndex, /* index for current detector in dataParams */
const EphemerisData *edat
)
{
XLAL_CHECK ( (SFTvect == NULL) || ((*SFTvect) == NULL ), XLAL_EINVAL );
XLAL_CHECK ( (Tseries == NULL) || ((*Tseries) == NULL ), XLAL_EINVAL );
XLAL_CHECK ( (SFTvect != NULL) || (Tseries != NULL), XLAL_EINVAL );
XLAL_CHECK ( edat != NULL, XLAL_EINVAL );
XLAL_CHECK ( dataParams != NULL, XLAL_EINVAL );
XLAL_CHECK ( detectorIndex < dataParams->multiIFO.length, XLAL_EINVAL );
XLAL_CHECK ( detectorIndex < dataParams->multiNoiseFloor.length, XLAL_EINVAL );
XLAL_CHECK ( detectorIndex < dataParams->multiTimestamps.length, XLAL_EINVAL );
XLAL_CHECK ( (dataParams->inputMultiTS == NULL) || (detectorIndex < dataParams->inputMultiTS->length), XLAL_EINVAL );
XLAL_CHECK ( (dataParams->inputMultiTS == NULL) || (dataParams->fMin == 0 && dataParams->Band == 0), XLAL_EINVAL, "If given time-series, must have fMin=Band=0\n");
// initial default values fMin, sampling rate from caller input or timeseries
REAL8 fMin = dataParams->fMin;
REAL8 fBand = dataParams->Band;
REAL8 fSamp = 2.0 * fBand;
if ( dataParams->inputMultiTS != NULL )
{
XLAL_CHECK ( (fMin == 0) && (fBand == 0), XLAL_EINVAL, "fMin and fBand must be 0 if input timeseries is given\n");
const REAL8TimeSeries *ts = dataParams->inputMultiTS->data[detectorIndex];
XLAL_CHECK ( ts != NULL, XLAL_EINVAL );
REAL8 dt = ts->deltaT;
fMin = ts->f0;
fSamp = 1.0 / dt;
fBand = 0.5 * fSamp;
}
const LIGOTimeGPSVector *timestamps = dataParams->multiTimestamps.data[detectorIndex];
const LALDetector *site = &dataParams->multiIFO.sites[detectorIndex];
REAL8 Tsft = timestamps->deltaT;
// if SFT output requested: need *effective* fMin and Band consistent with SFT bins
if ( SFTvect )
{
UINT4 firstBinEff, numBinsEff;
XLAL_CHECK ( XLALFindCoveringSFTBins ( &firstBinEff, &numBinsEff, fMin, fBand, Tsft ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 fBand_eff = (numBinsEff - 1.0) / Tsft;
REAL8 fMin_eff = firstBinEff / Tsft;
REAL8 fMax = fMin + dataParams->Band;
REAL8 fMax_eff = fMin_eff + fBand_eff;
if ( (fMin_eff != fMin) || (fBand_eff != fBand ) ) {
XLALPrintWarning("Caller asked for Band [%.16g, %.16g] Hz, effective SFT-Band produced is [%.16g, %.16g] Hz\n",
fMin, fMax, fMin_eff, fMax_eff );
XLAL_CHECK ( dataParams->inputMultiTS == NULL, XLAL_EINVAL, "Cannot expand effective frequency band with input timeseries given. Timeseries seems inconsistent with SFTs\n");
fMin = fMin_eff; // (potentially) lower minimal frequency to fit SFT bins
fBand = fBand_eff;
fSamp = 2.0 * fBand_eff; // (potentially) higher sampling rate required to fit SFT bins
} // if (fMin_eff != fMin) || (fBand_eff != fBand)
} // if SFT-output requested
// characterize the output time-series
UINT4 n0_fSamp = (UINT4) round ( Tsft * fSamp );
// by construction, fSamp * Tsft = integer, but if there are gaps between SFTs,
// then we might have to sample at higher rates in order for all SFT-boundaries to
// fall on exact timesteps of the timeseries.
// ie we start from fsamp0 = n0_fSamp/Tsft, and then try to find the smallest
// n1_fSamp >= n0_fSamp, such that for fsamp1 = n1_fSamp/Tsft, for all gaps i: Dt_i * fsamp1 = int
UINT4 n1_fSamp;
XLAL_CHECK ( XLALFindSmallestValidSamplingRate ( &n1_fSamp, n0_fSamp, timestamps ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( n1_fSamp != n0_fSamp )
{
REAL8 fSamp1 = n1_fSamp / Tsft; // increased sampling rate to fit all gaps
XLALPrintWarning ( "GAPS: Initial SFT sampling frequency fSamp0= %d/%.0f = %g had to be increased to fSamp1 = %d/%.0f = %g\n",
n0_fSamp, Tsft, fSamp, n1_fSamp, Tsft, fSamp1 );
XLAL_CHECK ( dataParams->inputMultiTS == NULL, XLAL_EINVAL, "Cannot expand effective frequency band with input timeseries given. Timeseries seems inconsistent with SFT timestamps\n");
fSamp = fSamp1;
} // if higher effective sampling rate required
// ----- start-time and duration -----
LIGOTimeGPS firstGPS = timestamps->data[0];
REAL8 firstGPS_REAL8 = XLALGPSGetREAL8 ( &firstGPS );
LIGOTimeGPS lastGPS = timestamps->data [ timestamps->length - 1 ];
REAL8 lastGPS_REAL8 = XLALGPSGetREAL8 ( &lastGPS );
XLALGPSAdd( &lastGPS, Tsft );
REAL8 duration = XLALGPSDiff ( &lastGPS, &firstGPS );
// start with an empty output time-series
REAL4TimeSeries *Tseries_sum;
{
REAL8 numSteps = ceil ( fSamp * duration );
XLAL_CHECK ( numSteps < (REAL8)LAL_UINT4_MAX, XLAL_EDOM, "Sorry, time-series of %g samples too long to fit into REAL4TimeSeries (maxLen = %g)\n", numSteps, (REAL8)LAL_UINT4_MAX );
REAL8 dt = 1.0 / fSamp;
REAL8 fHeterodyne = fMin; // heterodyne signals at lower end of frequency-band
CHAR *detPrefix = XLALGetChannelPrefix ( site->frDetector.name );
XLAL_CHECK ( (Tseries_sum = XLALCreateREAL4TimeSeries ( detPrefix, &firstGPS, fHeterodyne, dt, &lalStrainUnit, (UINT4)numSteps )) != NULL, XLAL_EFUNC );
memset ( Tseries_sum->data->data, 0, Tseries_sum->data->length * sizeof(Tseries_sum->data->data[0]) );
XLALFree ( detPrefix );
} // generate empty timeseries
// add CW signals, if any
UINT4 numPulsars = injectionSources ? injectionSources->length : 0;
for ( UINT4 iInj = 0; iInj < numPulsars; iInj ++ )
{
// truncate any transient-CW timeseries to the actual support of the transient signal,
// in order to make the generation more efficient, these 'partial timeseries'
// will then be added to the full timeseries
const PulsarParams *pulsarParams = &( injectionSources->data[iInj] );
UINT4 t0, t1;
XLAL_CHECK ( XLALGetTransientWindowTimespan ( &t0, &t1, pulsarParams->Transient ) == XLAL_SUCCESS, XLAL_EFUNC );
// use latest possible start-time: max(t0,firstGPS), but not later than than lastGPS
LIGOTimeGPS XLAL_INIT_DECL(signalStartGPS);
if ( t0 <= firstGPS_REAL8 ) {
signalStartGPS = firstGPS;
} else if ( t0 >= lastGPS_REAL8 ) {
signalStartGPS = lastGPS;
}
else {
signalStartGPS.gpsSeconds = t0;
}
// use earliest possible end-time: min(t1,lastGPS), but not earlier than firstGPS
LIGOTimeGPS XLAL_INIT_DECL(signalEndGPS);
if ( t1 >= lastGPS_REAL8 ) {
signalEndGPS = lastGPS;
} else if ( t1 <= firstGPS_REAL8 ) {
signalEndGPS = firstGPS;
} else {
signalEndGPS.gpsSeconds = t1;
}
REAL8 signalDuration = XLALGPSDiff ( &signalEndGPS, &signalStartGPS );
XLAL_CHECK ( signalDuration >= 0, XLAL_EFAILED, "Something went wrong, got negative signal duration = %g\n", signalDuration );
if ( signalDuration > 0 ) // only need to do sth if transient-window had finite overlap with output TS
{
REAL4TimeSeries *Tseries_i = NULL;
XLAL_CHECK ( (Tseries_i = XLALGenerateCWSignalTS ( pulsarParams, site, signalStartGPS, signalDuration, fSamp, fMin, edat )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (Tseries_sum = XLALAddREAL4TimeSeries ( Tseries_sum, Tseries_i )) != NULL, XLAL_EFUNC );
XLALDestroyREAL4TimeSeries ( Tseries_i );
}
} // for iInj < numSources
/* add Gaussian noise if requested */
REAL8 sqrtSn = dataParams->multiNoiseFloor.sqrtSn[detectorIndex];
if ( sqrtSn > 0)
{
REAL8 noiseSigma = sqrtSn * sqrt ( 0.5 * fSamp );
INT4 randSeed = (dataParams->randSeed == 0) ? 0 : (dataParams->randSeed + detectorIndex); // seed=0 means to use /dev/urandom, so don't touch it
XLAL_CHECK ( XLALAddGaussianNoise ( Tseries_sum, noiseSigma, randSeed ) == XLAL_SUCCESS, XLAL_EFUNC );
}
// convert final signal+Gaussian-noise timeseries into REAL8 precision:
REAL8TimeSeries *outTS;
XLAL_CHECK ( (outTS = XLALConvertREAL4TimeSeriesToREAL8 ( Tseries_sum )) != NULL, XLAL_EFUNC );
XLALDestroyREAL4TimeSeries ( Tseries_sum );
// add input noise time-series here if given
if ( dataParams->inputMultiTS != NULL ) {
XLAL_CHECK ( (outTS = XLALAddREAL8TimeSeries ( outTS, dataParams->inputMultiTS->data[detectorIndex] )) != NULL, XLAL_EFUNC );
}
// turn final timeseries into SFTs, if requested
if ( SFTvect != NULL )
{
// compute SFTs from timeseries
SFTVector *sftVect;
XLAL_CHECK ( (sftVect = XLALMakeSFTsFromREAL8TimeSeries ( outTS, timestamps, dataParams->SFTWindowType, dataParams->SFTWindowBeta)) != NULL, XLAL_EFUNC );
// extract effective band from this, if neccessary (ie if faster-sampled output SFTs)
if ( n1_fSamp != n0_fSamp )
{
XLAL_CHECK ( ((*SFTvect) = XLALExtractBandFromSFTVector ( sftVect, fMin, fBand )) != NULL, XLAL_EFUNC );
XLALDestroySFTVector ( sftVect );
}
else
{
(*SFTvect) = sftVect;
}
} // if SFTvect
// return timeseries if requested
if ( Tseries != NULL ) {
(*Tseries) = outTS;
} else {
XLALDestroyREAL8TimeSeries ( outTS );
}
return XLAL_SUCCESS;
} // XLALCWMakeFakeData()
int XLALSQTPNWaveformForInjection(CoherentGW *waveform,
InspiralTemplate *params, PPNParamStruc *ppnParams) {
// Check the relevant pointers
if( !waveform || !params || waveform->a || waveform->f
|| waveform->phi || waveform->shift )
XLAL_ERROR(XLAL_EFAULT);
// variable declaration and initialization
UINT4 i;
InspiralInit paramsInit;
// Compute some parameters
XLALInspiralInit(params, ¶msInit);
if (xlalErrno)
XLAL_ERROR(XLAL_EFUNC);
if (paramsInit.nbins == 0) {
XLALPrintWarning("Warning! Waveform of zero length requested in %s. Returning empty waveform.\n ", __func__);
return XLAL_SUCCESS;
}
// Allocate the waveform structures.
xlalErrno = 0;
XLALSQTPNAllocateCoherentGW(waveform, paramsInit.nbins);
LALSQTPNWave wave;
wave.h = NULL;
wave.hp = wave.hc = NULL;
wave.waveform = waveform;
LALSQTPNWaveformParams wave_Params;
// filling the parameters
XLALSQTPNFillParams(&wave_Params, params);
if (xlalErrno)
XLAL_ERROR(XLAL_EFUNC);
// calling the engine function
if(XLALSQTPNGenerator(&wave, &wave_Params)) {
XLALSQTPNDestroyCoherentGW(waveform);
XLAL_ERROR(XLAL_EFUNC);
}
params->fFinal = wave_Params.finalFreq;
for (i = 0; i < wave.length; i++) {
if (waveform->phi->data->data[i] != 0.) {
break;
}
if (i == wave.length - 1) {
XLALSQTPNDestroyCoherentGW(waveform);
XLAL_ERROR(XLAL_EFUNC);
}
}
{
if (waveform->a != NULL) {
waveform->f->data->length = waveform->phi->data->length = waveform->shift->data->length = wave.length;
waveform->a->data->length = 2 * wave.length;
for (i = 0; i < wave.length; i++) {
// (PPNParamStruct)ppnParams->phi === (InspiralTemplate)params->startPhase === (SimInspiralTable)injparams/this_event->coa_phase it is set to 0 in LALSQTPNWaveformTest.c at line 83.
waveform->phi->data->data[i]
= waveform->phi->data->data[i]
- waveform->phi->data->data[wave.length-1]
+ ppnParams->phi;
}
waveform->a->deltaT = waveform->f->deltaT
= waveform->phi->deltaT
= waveform->shift->deltaT
= 1. / params->tSampling;
waveform->a->sampleUnits = lalStrainUnit;
waveform->f->sampleUnits = lalHertzUnit;
waveform->phi->sampleUnits = lalDimensionlessUnit;
waveform->shift->sampleUnits = lalDimensionlessUnit;
waveform->position = ppnParams->position;
waveform->psi = ppnParams->psi;
snprintf(waveform->a->name, LALNameLength,
"STPN inspiral amplitudes");
snprintf(waveform->f->name, LALNameLength,
"STPN inspiral frequency");
snprintf(waveform->phi->name, LALNameLength,
"STPN inspiral phase");
snprintf(waveform->shift->name, LALNameLength,
"STPN inspiral polshift");
}
// --- fill some output ---
ppnParams->tc = (REAL8) (wave.length - 1) / params->tSampling;
ppnParams->length = wave.length;
ppnParams->dfdt
= ((REAL4) (waveform->f->data->data[wave.length - 1]
- waveform->f->data->data[wave.length - 2]))
* ppnParams->deltaT;
ppnParams->fStop = params->fFinal;
ppnParams->termCode = GENERATEPPNINSPIRALH_EFSTOP;
ppnParams->termDescription = GENERATEPPNINSPIRALH_MSGEFSTOP;
ppnParams->fStart = ppnParams->fStartIn;
} // end phase condition
return XLAL_SUCCESS;
}
/**
* Wrapper similar to XLALSimInspiralChooseFDWaveform() for waveforms to be generated a specific freqencies.
* Returns the waveform in the frequency domain at the frequencies of the REAL8Sequence frequencies.
*/
int XLALSimInspiralChooseFDWaveformSequence(
COMPLEX16FrequencySeries **hptilde, /**< FD plus polarization */
COMPLEX16FrequencySeries **hctilde, /**< FD cross polarization */
REAL8 phiRef, /**< reference orbital phase (rad) */
REAL8 m1, /**< mass of companion 1 (kg) */
REAL8 m2, /**< mass of companion 2 (kg) */
REAL8 S1x, /**< x-component of the dimensionless spin of object 1 */
REAL8 S1y, /**< y-component of the dimensionless spin of object 1 */
REAL8 S1z, /**< z-component of the dimensionless spin of object 1 */
REAL8 S2x, /**< x-component of the dimensionless spin of object 2 */
REAL8 S2y, /**< y-component of the dimensionless spin of object 2 */
REAL8 S2z, /**< z-component of the dimensionless spin of object 2 */
REAL8 f_ref, /**< Reference frequency (Hz) */
REAL8 distance, /**< distance of source (m) */
REAL8 inclination, /**< inclination of source (rad) */
LALDict *LALpars, /**< LALDictionary containing non-mandatory variables/flags */
Approximant approximant, /**< post-Newtonian approximant to use for waveform production */
REAL8Sequence *frequencies /**< sequence of frequencies for which the waveform will be computed. Pass in NULL (or None in python) for standard f_min to f_max sequence. */
)
{
int ret;
unsigned int j;
REAL8 pfac, cfac;
REAL8 LNhatx, LNhaty, LNhatz;
/* Support variables for precessing wfs*/
REAL8 incl;
REAL8 spin1x,spin1y,spin1z;
REAL8 spin2x,spin2y,spin2z;
/* Variables for IMRPhenomP and IMRPhenomPv2 */
REAL8 chi1_l, chi2_l, chip, thetaJ, alpha0;
/* General sanity checks that will abort
*
* If non-GR approximants are added, include them in
* XLALSimInspiralApproximantAcceptTestGRParams()
*/
if ( !XLALSimInspiralWaveformParamsNonGRAreDefault(LALpars) && XLALSimInspiralApproximantAcceptTestGRParams(approximant) != LAL_SIM_INSPIRAL_TESTGR_PARAMS ) {
XLALPrintError("XLAL Error - %s: Passed in non-NULL testGRparams for an approximant that does not use them\n", __func__);
XLAL_ERROR(XLAL_EINVAL);
}
if (!frequencies) XLAL_ERROR(XLAL_EFAULT);
REAL8 f_min = frequencies->data[0];
/* General sanity check the input parameters - only give warnings! */
if( m1 < 0.09 * LAL_MSUN_SI )
XLALPrintWarning("XLAL Warning - %s: Small value of m1 = %e (kg) = %e (Msun) requested...Perhaps you have a unit conversion error?\n", __func__, m1, m1/LAL_MSUN_SI);
if( m2 < 0.09 * LAL_MSUN_SI )
XLALPrintWarning("XLAL Warning - %s: Small value of m2 = %e (kg) = %e (Msun) requested...Perhaps you have a unit conversion error?\n", __func__, m2, m2/LAL_MSUN_SI);
if( m1 + m2 > 1000. * LAL_MSUN_SI )
XLALPrintWarning("XLAL Warning - %s: Large value of total mass m1+m2 = %e (kg) = %e (Msun) requested...Signal not likely to be in band of ground-based detectors.\n", __func__, m1+m2, (m1+m2)/LAL_MSUN_SI);
if( S1x*S1x + S1y*S1y + S1z*S1z > 1.000001 )
XLALPrintWarning("XLAL Warning - %s: S1 = (%e,%e,%e) with norm > 1 requested...Are you sure you want to violate the Kerr bound?\n", __func__, S1x, S1y, S1z);
if( S2x*S2x + S2y*S2y + S2z*S2z > 1.000001 )
XLALPrintWarning("XLAL Warning - %s: S2 = (%e,%e,%e) with norm > 1 requested...Are you sure you want to violate the Kerr bound?\n", __func__, S2x, S2y, S2z);
if( f_min < 1. )
XLALPrintWarning("XLAL Warning - %s: Small value of fmin = %e requested...Check for errors, this could create a very long waveform.\n", __func__, f_min);
if( f_min > 40.000001 )
XLALPrintWarning("XLAL Warning - %s: Large value of fmin = %e requested...Check for errors, the signal will start in band.\n", __func__, f_min);
/* The non-precessing waveforms return h(f) for optimal orientation
* (i=0, Fp=1, Fc=0; Lhat pointed toward the observer)
* To get generic polarizations we multiply by inclination dependence
* and note hc(f) \propto -I * hp(f)
* Non-precessing waveforms multiply hp by pfac, hc by -I*cfac
*/
cfac = cos(inclination);
pfac = 0.5 * (1. + cfac*cfac);
REAL8 lambda1=XLALSimInspiralWaveformParamsLookupTidalLambda1(LALpars);
REAL8 lambda2=XLALSimInspiralWaveformParamsLookupTidalLambda2(LALpars);
switch (approximant)
{
/* inspiral-only models */
case TaylorF2:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFrameAxisIsDefault(LALpars) )
ABORT_NONDEFAULT_FRAME_AXIS(LALpars);
if( !XLALSimInspiralWaveformParamsModesChoiceIsDefault(LALpars) )
ABORT_NONDEFAULT_MODES_CHOICE(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
/* Call the waveform driver routine */
ret = XLALSimInspiralTaylorF2Core(hptilde, frequencies, phiRef,
m1, m2, S1z, S2z, f_ref, 0., distance, LALpars);
if (ret == XLAL_FAILURE) XLAL_ERROR(XLAL_EFUNC);
/* Produce both polarizations */
*hctilde = XLALCreateCOMPLEX16FrequencySeries("FD hcross",
&((*hptilde)->epoch), (*hptilde)->f0, 0.0,
&((*hptilde)->sampleUnits), (*hptilde)->data->length);
for(j = 0; j < (*hptilde)->data->length; j++) {
(*hctilde)->data->data[j] = -I*cfac * (*hptilde)->data->data[j];
(*hptilde)->data->data[j] *= pfac;
}
break;
/* inspiral-merger-ringdown models */
case SEOBNRv1_ROM_EffectiveSpin:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if (!checkAlignedSpinsEqual(S1z, S2z))
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
ret = XLALSimIMRSEOBNRv1ROMEffectiveSpinFrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, XLALSimIMRPhenomBComputeChi(m1, m2, S1z, S2z));
break;
case SEOBNRv1_ROM_DoubleSpin:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
ret = XLALSimIMRSEOBNRv1ROMDoubleSpinFrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, S1z, S2z);
break;
case SEOBNRv2_ROM_EffectiveSpin:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
ret = XLALSimIMRSEOBNRv2ROMEffectiveSpinFrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, XLALSimIMRPhenomBComputeChi(m1, m2, S1z, S2z));
break;
case SEOBNRv2_ROM_DoubleSpin:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
ret = XLALSimIMRSEOBNRv2ROMDoubleSpinFrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, S1z, S2z);
break;
case SEOBNRv2_ROM_DoubleSpin_HI:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
ret = XLALSimIMRSEOBNRv2ROMDoubleSpinHIFrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, S1z, S2z, -1);
break;
case Lackey_Tidal_2013_SEOBNRv2_ROM:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
ret = XLALSimIMRLackeyTidal2013FrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, S1z, lambda2);
break;
case IMRPhenomP:
XLALSimInspiralInitialConditionsPrecessingApproxs(&incl,&spin1x,&spin1y,&spin1z,&spin2x,&spin2y,&spin2z,inclination,S1x,S1y,S1z,S2x,S2y,S2z,m1,m2,f_ref,phiRef,XLALSimInspiralWaveformParamsLookupFrameAxis(LALpars));
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFrameAxisIsDefault(LALpars) )
ABORT_NONDEFAULT_FRAME_AXIS(LALpars);/* Default is LAL_SIM_INSPIRAL_FRAME_AXIS_VIEW : z-axis along direction of GW propagation (line of sight). */
if( !XLALSimInspiralWaveformParamsModesChoiceIsDefault(LALpars) )
ABORT_NONDEFAULT_MODES_CHOICE(LALpars);
/* Default is (2,2) or l=2 modes. */
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
LNhatx = sin(incl);
LNhaty = 0.;
LNhatz = cos(incl);
/* Tranform to model parameters */
if(f_ref==0.0)
f_ref = f_min; /* Default reference frequency is minimum frequency */
XLALSimIMRPhenomPCalculateModelParameters(
&chi1_l, &chi2_l, &chip, &thetaJ, &alpha0,
m1, m2, f_ref,
LNhatx, LNhaty, LNhatz,
spin1x, spin1y, spin1z,
spin2x, spin2y, spin2z, IMRPhenomPv1_V);
/* Call the waveform driver routine */
ret = XLALSimIMRPhenomPFrequencySequence(hptilde, hctilde, frequencies,
chi1_l, chi2_l, chip, thetaJ,
m1, m2, distance, alpha0, phiRef, f_ref, IMRPhenomPv1_V, NULL);
if (ret == XLAL_FAILURE) XLAL_ERROR(XLAL_EFUNC);
break;
case IMRPhenomPv2:
XLALSimInspiralInitialConditionsPrecessingApproxs(&incl,&spin1x,&spin1y,&spin1z,&spin2x,&spin2y,&spin2z,inclination,S1x,S1y,S1z,S2x,S2y,S2z,m1,m2,f_ref,phiRef,XLALSimInspiralWaveformParamsLookupFrameAxis(LALpars));
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFrameAxisIsDefault(LALpars) )
ABORT_NONDEFAULT_FRAME_AXIS(LALpars);/* Default is LAL_SIM_INSPIRAL_FRAME_AXIS_VIEW : z-axis along direction of GW propagation (line of sight). */
if( !XLALSimInspiralWaveformParamsModesChoiceIsDefault(LALpars) )
ABORT_NONDEFAULT_MODES_CHOICE(LALpars);
/* Default is (2,2) or l=2 modes. */
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
LNhatx = sin(incl);
LNhaty = 0.;
LNhatz = cos(incl);
/* Tranform to model parameters */
if(f_ref==0.0)
f_ref = f_min; /* Default reference frequency is minimum frequency */
XLALSimIMRPhenomPCalculateModelParameters(
&chi1_l, &chi2_l, &chip, &thetaJ, &alpha0,
m1, m2, f_ref,
LNhatx, LNhaty, LNhatz,
spin1x, spin1y, spin1z,
spin2x, spin2y, spin2z, IMRPhenomPv2_V);
/* Call the waveform driver routine */
ret = XLALSimIMRPhenomPFrequencySequence(hptilde, hctilde, frequencies,
chi1_l, chi2_l, chip, thetaJ,
m1, m2, distance, alpha0, phiRef, f_ref, IMRPhenomPv2_V, NULL);
if (ret == XLAL_FAILURE) XLAL_ERROR(XLAL_EFUNC);
break;
default:
XLALPrintError("FD version of approximant not implemented in lalsimulation\n");
XLAL_ERROR(XLAL_EINVAL);
}
if (ret == XLAL_FAILURE) XLAL_ERROR(XLAL_EFUNC);
return ret;
}
/* ----- function definitions ---------- */
int
main ( int argc, char *argv[] )
{
LALStatus status;
UserInput_t uvar_s;
UserInput_t *uvar = &uvar_s;
INIT_MEM ( status );
INIT_MEM ( uvar_s );
struct tms buf;
uvar->randSeed = times(&buf);
// ---------- register all our user-variable ----------
XLALregBOOLUserStruct ( help, 'h', UVAR_HELP , "Print this help/usage message");
XLALregINTUserStruct ( randSeed, 's', UVAR_OPTIONAL, "Specify random-number seed for reproducible noise.");
/* read cmdline & cfgfile */
XLAL_CHECK ( XLALUserVarReadAllInput ( argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( uvar->help ) { /* if help was requested, we're done */
exit (0);
}
srand ( uvar->randSeed );
REAL8 startTimeREAL8 = 714180733;
REAL8 duration = 180000; /* 50 hours */
REAL8 Tsft = 1800; /* assume 30min SFTs */
char earthEphem[] = TEST_DATA_DIR "earth00-19-DE200.dat.gz";
char sunEphem[] = TEST_DATA_DIR "sun00-19-DE200.dat.gz";
//REAL8 tolerance = 2e-10; /* same algorithm, should be basically identical results */
LIGOTimeGPS startTime, refTime;
XLALGPSSetREAL8 ( &startTime, startTimeREAL8 );
refTime = startTime;
// pick skyposition at random ----- */
SkyPosition skypos;
skypos.longitude = LAL_TWOPI * (1.0 * rand() / ( RAND_MAX + 1.0 ) ); // alpha uniform in [0, 2pi)
skypos.latitude = LAL_PI_2 - acos ( 1 - 2.0 * rand()/RAND_MAX ); // sin(delta) uniform in [-1,1]
skypos.system = COORDINATESYSTEM_EQUATORIAL;
// pick binary orbital parameters:
// somewhat inspired by Sco-X1 parameters from S2-paper (PRD76, 082001 (2007), gr-qc/0605028)
// but with a more extreme eccentricity, and random argp
REAL8 argp = LAL_TWOPI * (1.0 * rand() / ( RAND_MAX + 1.0 ) ); // uniform in [0, 2pi)
BinaryOrbitParams orbit;
XLALGPSSetREAL8 ( &orbit.tp, 731163327 ); // time of observed periapsis passage (in SSB)
orbit.argp = argp; // argument of periapsis (radians)
orbit.asini = 1.44; // projected, normalized orbital semi-major axis (s) */
orbit.ecc = 1e-2; // relatively large value, for better testing
orbit.period = 68023; // period (s) : about ~18.9h
// ----- step 0: prepare test-case input for calling the BinarySSB-functions
// setup detectors
const char *sites[3] = { "H1", "L1", "V1" };
UINT4 numDetectors = sizeof( sites ) / sizeof ( sites[0] );
MultiLALDetector multiIFO;
multiIFO.length = numDetectors;
for ( UINT4 X = 0; X < numDetectors; X ++ )
{
LALDetector *det = XLALGetSiteInfo ( sites[X] );
XLAL_CHECK ( det != NULL, XLAL_EFUNC, "XLALGetSiteInfo ('%s') failed for detector X=%d\n", sites[X], X );
multiIFO.sites[X] = (*det); // struct copy
XLALFree ( det );
}
// load ephemeris
EphemerisData *edat = XLALInitBarycenter ( earthEphem, sunEphem );
XLAL_CHECK ( edat != NULL, XLAL_EFUNC, "XLALInitBarycenter('%s','%s') failed\n", earthEphem, sunEphem );
// setup multi-timeseries
MultiLIGOTimeGPSVector *multiTS;
XLAL_CHECK ( (multiTS = XLALCalloc ( 1, sizeof(*multiTS))) != NULL, XLAL_ENOMEM );
XLAL_CHECK ( (multiTS->data = XLALCalloc (numDetectors, sizeof(*multiTS->data))) != NULL, XLAL_ENOMEM );
multiTS->length = numDetectors;
for ( UINT4 X = 0; X < numDetectors; X ++ )
{
multiTS->data[X] = XLALMakeTimestamps ( startTime, duration, Tsft, 0 );
XLAL_CHECK ( multiTS->data[X] != NULL, XLAL_EFUNC, "XLALMakeTimestamps() failed.\n");
} /* for X < numIFOs */
// generate detector-states
MultiDetectorStateSeries *multiDetStates = XLALGetMultiDetectorStates ( multiTS, &multiIFO, edat, 0 );
XLAL_CHECK ( multiDetStates != NULL, XLAL_EFUNC, "XLALGetMultiDetectorStates() failed.\n");
// generate isolated-NS SSB times
MultiSSBtimes *multiSSBIn = XLALGetMultiSSBtimes ( multiDetStates, skypos, refTime, SSBPREC_RELATIVISTICOPT );
XLAL_CHECK ( multiSSBIn != NULL, XLAL_EFUNC, "XLALGetMultiSSBtimes() failed.\n");
// ----- step 1: compute reference-result using old LALGetMultiBinarytimes()
MultiSSBtimes *multiBinary_ref = NULL;
LALGetMultiBinarytimes (&status, &(multiBinary_ref), multiSSBIn, multiDetStates, &orbit, refTime );
XLAL_CHECK ( status.statusCode == 0, XLAL_EFAILED, "LALGetMultiBinarytimes() failed with status = %d : '%s'\n", status.statusCode, status.statusDescription );
// ----- step 2: compute test-result using new XLALAddMultiBinaryTimes()
MultiSSBtimes *multiBinary_test = NULL;
PulsarDopplerParams doppler;
memset(&doppler, 0, sizeof(doppler));
doppler.tp = orbit.tp;
doppler.argp = orbit.argp;
doppler.asini = orbit.asini;
doppler.ecc = orbit.ecc;
doppler.period = orbit.period;
XLAL_CHECK ( XLALAddMultiBinaryTimes ( &multiBinary_test, multiSSBIn, &doppler ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- step 3: compare results
REAL8 err_DeltaT, err_Tdot;
REAL8 tolerance = 1e-10;
int ret = XLALCompareMultiSSBtimes ( &err_DeltaT, &err_Tdot, multiBinary_ref, multiBinary_test );
XLAL_CHECK ( ret == XLAL_SUCCESS, XLAL_EFUNC, "XLALCompareMultiSSBtimes() failed.\n");
XLALPrintWarning ( "INFO: err(DeltaT) = %g, err(Tdot) = %g\n", err_DeltaT, err_Tdot );
XLAL_CHECK ( err_DeltaT < tolerance, XLAL_ETOL, "error(DeltaT) = %g exceeds tolerance of %g\n", err_DeltaT, tolerance );
XLAL_CHECK ( err_Tdot < tolerance, XLAL_ETOL, "error(Tdot) = %g exceeds tolerance of %g\n", err_Tdot, tolerance );
// ---- step 4: clean-up memory
XLALDestroyUserVars();
XLALDestroyEphemerisData ( edat );
XLALDestroyMultiSSBtimes ( multiBinary_test );
XLALDestroyMultiSSBtimes ( multiBinary_ref );
XLALDestroyMultiSSBtimes ( multiSSBIn );
XLALDestroyMultiTimestamps ( multiTS );
XLALDestroyMultiDetectorStateSeries ( multiDetStates );
// check for memory-leaks
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
/**
* 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()
