/**
* \brief Chop up the data into chunks smaller the the maximum allowed length
*
* This function chops any chunks that are greater than \c chunkMax into chunks smaller than, or equal to \c chunkMax,
* and greater than \c chunkMin. On some occasions this might result in a segment smaller than \c chunkMin, but these
* are ignored in the likelihood calculation anyway.
*
* \param chunkIndex [in] a vector of segment split positions
* \param chunkMax [in] the maximum allowed segment/chunk length
* \param chunkMin [in] the minimum allowed segment/chunk length
*/
void rechop_data( UINT4Vector *chunkIndex, INT4 chunkMax, INT4 chunkMin ){
INT4 i = 0, j = 0, count = 0;
INT4 length = chunkIndex->length;
INT4 endIndex = (INT4)chunkIndex->data[length-1];
UINT4 startindex = 0, chunklength = 0;
UINT4Vector *newindex = NULL;
newindex = XLALCreateUINT4Vector( ceil((REAL8)endIndex / (REAL8)chunkMax ) );
/* chop any chunks that are greater than chunkMax into chunks smaller than, or equal to chunkMax, and greater than chunkMin */
for ( i = 0; i < length; i++ ){
if ( i == 0 ) { startindex = 0; }
else { startindex = chunkIndex->data[i-1]+1; }
chunklength = chunkIndex->data[i] - startindex;
if ( chunklength > (UINT4)chunkMax ){
INT4 remain = chunklength % chunkMax;
/* cut segment into as many chunkMin chunks as possible */
for ( j = 0; j < floor(chunklength / chunkMax); j++ ){
newindex->data[count] = startindex + (j+1)*chunkMax;
count++;
}
/* last chunk values */
if ( remain != 0 ){
/* set final value */
newindex->data[count] = startindex + j*chunkMax + remain;
if ( remain < chunkMin ){
/* split the last two cells into one that is chunkMin long and one that is (chunkMax+remainder)-chunkMin long
* - this may leave a cell shorter than chunkMin, but we'll have to live with that! */
INT4 n1 = (chunkMax + remain) - chunkMin;
/* reset second to last value two values */
newindex->data[count-1] = newindex->data[count] - chunkMin;
if ( n1 < chunkMin && verbose_output ){
fprintf(stderr, "Non-fatal error... segment no. %d is %d long, which is less than chunkMin = %d.\n",
count, n1, chunkMin);
}
}
count++;
}
}
else{
newindex->data[count] = chunkIndex->data[i];
count++;
}
}
chunkIndex = XLALResizeUINT4Vector( chunkIndex, count );
for ( i = 0; i < count; i++ ) { chunkIndex->data[i] = newindex->data[i]; }
XLALDestroyUINT4Vector( newindex );
}
/**
* \brief Chops and remerges data into stationary segments
*
* This function finds segments of data that appear to be stationary (have the same standard deviation).
*
* The function first attempts to chop up the data into as many stationary segments as possible. The splitting may not
* be optimal, so it then tries remerging consecutive segments to see if the merged segments show more evidence of
* stationarity. <b>[NOTE: Remerging is currently turned off and will make very little difference to the algorithm]</b>.
* It then, if necessary, chops the segments again to make sure there are none greater than the required \c chunkMax.
* The default \c chunkMax is 0, so this rechopping will not normally happen.
*
* This is all performed on data that has had a running median subtracted, to try and removed any underlying trends in
* the data (e.g. those caused by a strong signal), which might affect the calculations (which assume the data is
* Gaussian with zero mean).
*
* If the \c verbose flag is set then a list of the segments will be output to a file called \c data_segment_list.txt,
* with a prefix of the detector name.
*
* \param data [in] A data structure
* \param chunkMin [in] The minimum length of a segment
* \param chunkMax [in] The maximum length of a segment
*
* \return A vector of segment/chunk lengths
*
* \sa subtract_running_median
* \sa chop_data
* \sa merge_data
* \sa rechop_data
*/
UINT4Vector *chop_n_merge( LALInferenceIFOData *data, INT4 chunkMin, INT4 chunkMax ){
UINT4 j = 0;
UINT4Vector *chunkLengths = NULL;
UINT4Vector *chunkIndex = NULL;
COMPLEX16Vector *meddata = NULL;
/* subtract a running median value from the data to remove any underlying trends (e.g. caused by a string signal) that
* might affect the chunk calculations (which can assume the data is Gaussian with zero mean). */
meddata = subtract_running_median( data->compTimeData->data );
/* pass chop data a gsl_vector_view, so that internally it can use vector views rather than having to create new vectors */
gsl_vector_complex_view meddatagsl = gsl_vector_complex_view_array((double*)meddata->data, meddata->length);
chunkIndex = chop_data( &meddatagsl.vector, chunkMin );
/* DON'T BOTHER WITH THE MERGING AS IT WILL MAKE VERY LITTLE DIFFERENCE */
/* merge_data( meddata, chunkIndex ); */
/* if a maximum chunk length is defined then rechop up the data, to segment any chunks longer than this value */
if ( chunkMax > chunkMin ) { rechop_data( chunkIndex, chunkMax, chunkMin ); }
chunkLengths = XLALCreateUINT4Vector( chunkIndex->length );
/* go through segments and turn into vector of chunk lengths */
for ( j = 0; j < chunkIndex->length; j++ ){
if ( j == 0 ) { chunkLengths->data[j] = chunkIndex->data[j]; }
else { chunkLengths->data[j] = chunkIndex->data[j] - chunkIndex->data[j-1]; }
}
/* if verbose print out the segment end indices to a file */
if ( verbose_output ){
FILE *fpsegs = NULL;
CHAR *outfile = NULL;
/* set detector name as prefix */
outfile = XLALStringDuplicate( data->detector->frDetector.prefix );
outfile = XLALStringAppend( outfile, "data_segment_list.txt" );
if ( (fpsegs = fopen(outfile, "w")) == NULL ){
fprintf(stderr, "Non-fatal error open file to output segment list.\n");
return chunkLengths;
}
for ( j = 0; j < chunkIndex->length; j++ ) { fprintf(fpsegs, "%u\n", chunkIndex->data[j]); }
/* add space at the end so that you can separate lists from different detector data streams */
fprintf(fpsegs, "\n");
fclose( fpsegs );
}
return chunkLengths;
}
ATYPE * XFUNC ( UINT4Vector *dimLength )
{
ATYPE *arr;
UINT4 size = 1;
UINT4 ndim;
UINT4 dim;
if ( ! dimLength )
XLAL_ERROR_NULL( XLAL_EFAULT );
if ( ! dimLength->length )
XLAL_ERROR_NULL( XLAL_EBADLEN );
if ( ! dimLength->data )
XLAL_ERROR_NULL( XLAL_EINVAL );
ndim = dimLength->length;
for ( dim = 0; dim < ndim; ++dim )
size *= dimLength->data[dim];
if ( ! size )
XLAL_ERROR_NULL( XLAL_EBADLEN );
/* create array */
arr = LALMalloc( sizeof( *arr ) );
if ( ! arr )
XLAL_ERROR_NULL( XLAL_ENOMEM );
/* create array dimensions */
arr->dimLength = XLALCreateUINT4Vector( ndim );
if ( ! arr->dimLength )
{
LALFree( arr );
XLAL_ERROR_NULL( XLAL_EFUNC );
}
/* copy dimension lengths */
memcpy( arr->dimLength->data, dimLength->data,
ndim * sizeof( *arr->dimLength->data ) );
/* allocate data storage */
arr->data = LALMalloc( size * sizeof( *arr->data ) );
if ( ! arr->data )
{
XLALDestroyUINT4Vector( arr->dimLength );
LALFree( arr );
XLAL_ERROR_NULL( XLAL_ENOMEM );
}
return arr;
}
/**
* \brief Split the data into segments
*
* This function is deprecated to \c chop_n_merge, but gives the functionality of the old code.
*
* It cuts the data into as many contiguous segments of data as possible of length \c chunkMax. Where contiguous is
* defined as containing consecutive point within 180 seconds of each other. The length of segments that do not fit into
* a \c chunkMax length are also included.
*
* \param ifo [in] the LALInferenceIFOModel variable
* \param chunkMax [in] the maximum length of a data chunk/segment
*
* \return A vector of chunk/segment lengths
*/
UINT4Vector *get_chunk_lengths( LALInferenceIFOModel *ifo, UINT4 chunkMax ){
UINT4 i = 0, j = 0, count = 0;
UINT4 length;
REAL8 t1, t2;
UINT4Vector *chunkLengths = NULL;
length = ifo->times->length;
chunkLengths = XLALCreateUINT4Vector( length );
REAL8 dt = *(REAL8*)LALInferenceGetVariable( ifo->params, "dt" );
/* create vector of data segment length */
while( 1 ){
count++; /* counter */
/* break clause */
if( i > length - 2 ){
/* set final value of chunkLength */
chunkLengths->data[j] = count;
j++;
break;
}
i++;
t1 = XLALGPSGetREAL8( &ifo->times->data[i-1] );
t2 = XLALGPSGetREAL8( &ifo->times->data[i] );
/* if consecutive points are within two sample times of each other count as in the same chunk */
if( t2 - t1 > 2.*dt || count == chunkMax ){
chunkLengths->data[j] = count;
count = 0; /* reset counter */
j++;
}
}
chunkLengths = XLALResizeUINT4Vector( chunkLengths, j );
return chunkLengths;
}
/**
* \brief Chops the data into stationary segments based on Bayesian change point analysis
*
* This function splits data into two (and recursively runs on those two segments) if it is found that the odds ratio
* for them being from two independent Gaussian distributions is greater than a certain threshold.
*
* The threshold for the natural logarithm of the odds ratio is empirically set to be
* \f[
* T = 4.07 + 1.33\log{}_{10}{N},
* \f]
* where \f$N\f$ is the length in samples of the dataset. This is based on Monte Carlo simulations of
* many realisations of Gaussian noise for data of different lengths. The threshold comes from a linear
* fit to the log odds ratios required to give a 1% chance of splitting Gaussian data (drawn from a single
* distribution) for data of various lengths. Note, however, that this relation is not good for stretches of data
* with lengths of less than about 30 points, and in fact is rather consevative for such short stretches
* of data, i.e. such short stretches of data will require relatively larger odds ratios for splitting than
* longer stretches.
*
* \param data [in] A complex data vector
* \param chunkMin [in] The minimum allowed segment length
*
* \return A vector of segment lengths
*
* \sa find_change_point
*/
UINT4Vector *chop_data( gsl_vector_complex *data, UINT4 chunkMin ){
UINT4Vector *chunkIndex = NULL;
UINT4 length = (UINT4)data->size;
REAL8 logodds = 0.;
UINT4 changepoint = 0;
REAL8 threshold = 0.; /* may need tuning or setting globally */
chunkIndex = XLALCreateUINT4Vector( 1 );
changepoint = find_change_point( data, &logodds, chunkMin );
/* threshold scaling for a 0.5% false alarm probability of splitting Gaussian data */
threshold = 4.07 + 1.33*log10((REAL8)length);
if ( logodds > threshold ){
UINT4Vector *cp1 = NULL;
UINT4Vector *cp2 = NULL;
gsl_vector_complex_view data1 = gsl_vector_complex_subvector( data, 0, changepoint );
gsl_vector_complex_view data2 = gsl_vector_complex_subvector( data, changepoint, length-changepoint );
UINT4 i = 0, l = 0;
cp1 = chop_data( &data1.vector, chunkMin );
cp2 = chop_data( &data2.vector, chunkMin );
l = cp1->length + cp2->length;
chunkIndex = XLALResizeUINT4Vector( chunkIndex, l );
/* combine new chunks */
for (i = 0; i < cp1->length; i++) { chunkIndex->data[i] = cp1->data[i]; }
for (i = 0; i < cp2->length; i++) { chunkIndex->data[i+cp1->length] = cp2->data[i] + changepoint; }
XLALDestroyUINT4Vector( cp1 );
XLALDestroyUINT4Vector( cp2 );
}
else{ chunkIndex->data[0] = length; }
return chunkIndex;
}
int main(int argc, char *argv[]){
UserInput_t XLAL_INIT_DECL(uvar);
static ConfigVariables config;
/* sft related variables */
MultiSFTVector *inputSFTs = NULL;
MultiPSDVector *multiPSDs = NULL;
MultiNoiseWeights *multiWeights = NULL;
MultiLIGOTimeGPSVector *multiTimes = NULL;
MultiLALDetector multiDetectors;
MultiDetectorStateSeries *multiStates = NULL;
MultiAMCoeffs *multiCoeffs = NULL;
SFTIndexList *sftIndices = NULL;
SFTPairIndexList *sftPairs = NULL;
REAL8Vector *shiftedFreqs = NULL;
UINT4Vector *lowestBins = NULL;
COMPLEX8Vector *expSignalPhases = NULL;
REAL8VectorSequence *sincList = NULL;
PulsarDopplerParams XLAL_INIT_DECL(dopplerpos);
PulsarDopplerParams thisBinaryTemplate, binaryTemplateSpacings;
PulsarDopplerParams minBinaryTemplate, maxBinaryTemplate;
SkyPosition XLAL_INIT_DECL(skyPos);
MultiSSBtimes *multiBinaryTimes = NULL;
INT4 k;
UINT4 j;
REAL8 fMin, fMax; /* min and max frequencies read from SFTs */
REAL8 deltaF; /* frequency resolution associated with time baseline of SFTs */
REAL8 diagff = 0; /*diagonal metric components*/
REAL8 diagaa = 0;
REAL8 diagTT = 0;
REAL8 diagpp = 1;
REAL8 ccStat = 0;
REAL8 evSquared=0;
REAL8 estSens=0; /*estimated sensitivity(4.13)*/
BOOLEAN dopplerShiftFlag = TRUE;
toplist_t *ccToplist=NULL;
CrossCorrBinaryOutputEntry thisCandidate;
UINT4 checksum;
LogPrintf (LOG_CRITICAL, "Starting time\n"); /*for debug convenience to record calculating time*/
/* initialize and register user variables */
LIGOTimeGPS computingStartGPSTime, computingEndGPSTime;
XLALGPSTimeNow (&computingStartGPSTime); /* record the rough starting GPS time*/
if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read user input from the command line or config file */
if ( XLALUserVarReadAllInput ( argc, argv ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if (uvar.help) /* if help was requested, then exit */
return 0;
CHAR *VCSInfoString = XLALGetVersionString(0); /**<LAL + LALapps Vsersion string*/
/*If the version information was requested, output it and exit*/
if ( uvar.version ){
XLAL_CHECK ( VCSInfoString != NULL, XLAL_EFUNC, "XLALGetVersionString(0) failed.\n" );
printf ("%s\n", VCSInfoString );
exit (0);
}
/* configure useful variables based on user input */
if ( XLALInitializeConfigVars ( &config, &uvar) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
deltaF = config.catalog->data[0].header.deltaF;
REAL8 Tsft = 1.0 / deltaF;
if (XLALUserVarWasSet(&uvar.spacingF) && XLALUserVarWasSet(&uvar.mismatchF))
LogPrintf (LOG_CRITICAL, "spacingF and mismatchF are both set, use spacingF %.9g by default\n\n", uvar.spacingF);
if (XLALUserVarWasSet(&uvar.spacingA) && XLALUserVarWasSet(&uvar.mismatchA))
LogPrintf (LOG_CRITICAL, "spacingA and mismatchA are both set, use spacingA %.9g by default\n\n", uvar.spacingA);
if (XLALUserVarWasSet(&uvar.spacingT) && XLALUserVarWasSet(&uvar.mismatchT))
LogPrintf (LOG_CRITICAL, "spacingT and mismatchT are both set, use spacingT %.9g by default\n\n", uvar.spacingT);
if (XLALUserVarWasSet(&uvar.spacingP) && XLALUserVarWasSet(&uvar.mismatchP))
LogPrintf (LOG_CRITICAL, "spacingP and mismatchP are both set, use spacingP %.9g by default\n\n", uvar.spacingP);
/* create the toplist */
create_crossCorrBinary_toplist( &ccToplist, uvar.numCand);
/* now read the data */
/* /\* get SFT parameters so that we can initialise search frequency resolutions *\/ */
/* /\* calculate deltaF_SFT *\/ */
/* deltaF_SFT = catalog->data[0].header.deltaF; /\* frequency resolution *\/ */
/* timeBase= 1.0/deltaF_SFT; /\* sft baseline *\/ */
/* /\* catalog is ordered in time so we can get start, end time and tObs *\/ */
/* firstTimeStamp = catalog->data[0].header.epoch; */
/* lastTimeStamp = catalog->data[catalog->length - 1].header.epoch; */
/* tObs = XLALGPSDiff( &lastTimeStamp, &firstTimeStamp ) + timeBase; */
/* /\*set pulsar reference time *\/ */
/* if (LALUserVarWasSet ( &uvar_refTime )) { */
/* XLALGPSSetREAL8(&refTime, uvar_refTime); */
/* } */
/* else { /\*if refTime is not set, set it to midpoint of sfts*\/ */
/* XLALGPSSetREAL8(&refTime, (0.5*tObs) + XLALGPSGetREAL8(&firstTimeStamp)); */
/* } */
/* /\* set frequency resolution defaults if not set by user *\/ */
/* if (!(LALUserVarWasSet (&uvar_fResolution))) { */
/* uvar_fResolution = 1/tObs; */
/* } */
/* { */
/* /\* block for calculating frequency range to read from SFTs *\/ */
/* /\* user specifies freq and fdot range at reftime */
/* we translate this range of fdots to start and endtime and find */
/* the largest frequency band required to cover the */
/* frequency evolution *\/ */
/* PulsarSpinRange spinRange_startTime; /\**< freq and fdot range at start-time of observation *\/ */
/* PulsarSpinRange spinRange_endTime; /\**< freq and fdot range at end-time of observation *\/ */
/* PulsarSpinRange spinRange_refTime; /\**< freq and fdot range at the reference time *\/ */
/* REAL8 startTime_freqLo, startTime_freqHi, endTime_freqLo, endTime_freqHi, freqLo, freqHi; */
/* REAL8Vector *fdotsMin=NULL; */
/* REAL8Vector *fdotsMax=NULL; */
/* UINT4 k; */
/* fdotsMin = (REAL8Vector *)LALCalloc(1, sizeof(REAL8Vector)); */
/* fdotsMin->length = N_SPINDOWN_DERIVS; */
/* fdotsMin->data = (REAL8 *)LALCalloc(fdotsMin->length, sizeof(REAL8)); */
/* fdotsMax = (REAL8Vector *)LALCalloc(1, sizeof(REAL8Vector)); */
/* fdotsMax->length = N_SPINDOWN_DERIVS; */
/* fdotsMax->data = (REAL8 *)LALCalloc(fdotsMax->length, sizeof(REAL8)); */
/* XLAL_INIT_MEM(spinRange_startTime); */
/* XLAL_INIT_MEM(spinRange_endTime); */
/* XLAL_INIT_MEM(spinRange_refTime); */
/* spinRange_refTime.refTime = refTime; */
/* spinRange_refTime.fkdot[0] = uvar_f0; */
/* spinRange_refTime.fkdotBand[0] = uvar_fBand; */
/* } */
/* FIXME: need to correct fMin and fMax for Doppler shift, rngmedian bins and spindown range */
/* this is essentially just a place holder for now */
/* FIXME: this running median buffer is overkill, since the running median block need not be centered on the search frequency */
REAL8 vMax = LAL_TWOPI * (uvar.orbitAsiniSec + uvar.orbitAsiniSecBand) / uvar.orbitPSec + LAL_TWOPI * LAL_REARTH_SI / (LAL_DAYSID_SI * LAL_C_SI) + LAL_TWOPI * LAL_AU_SI/(LAL_YRSID_SI * LAL_C_SI); /*calculate the maximum relative velocity in speed of light*/
fMin = uvar.fStart * (1 - vMax) - 0.5 * uvar.rngMedBlock * deltaF;
fMax = (uvar.fStart + uvar.fBand) * (1 + vMax) + 0.5 * uvar.rngMedBlock * deltaF;
/* read the SFTs*/
if ((inputSFTs = XLALLoadMultiSFTs ( config.catalog, fMin, fMax)) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALLoadMultiSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* calculate the psd and normalize the SFTs */
if (( multiPSDs = XLALNormalizeMultiSFTVect ( inputSFTs, uvar.rngMedBlock, NULL )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALNormalizeMultiSFTVect() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* compute the noise weights for the AM coefficients */
if (( multiWeights = XLALComputeMultiNoiseWeights ( multiPSDs, uvar.rngMedBlock, 0 )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALComputeMultiNoiseWeights() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read the timestamps from the SFTs */
if ((multiTimes = XLALExtractMultiTimestampsFromSFTs ( inputSFTs )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALExtractMultiTimestampsFromSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read the detector information from the SFTs */
if ( XLALMultiLALDetectorFromMultiSFTs ( &multiDetectors, inputSFTs ) != XLAL_SUCCESS){
LogPrintf ( LOG_CRITICAL, "%s: XLALMultiLALDetectorFromMultiSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Find the detector state for each SFT */
/* Offset by Tsft/2 to get midpoint as timestamp */
if ((multiStates = XLALGetMultiDetectorStates ( multiTimes, &multiDetectors, config.edat, 0.5 * Tsft )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALGetMultiDetectorStates() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Note this is specialized to a single sky position */
/* This might need to be moved into the config variables */
skyPos.system = COORDINATESYSTEM_EQUATORIAL;
skyPos.longitude = uvar.alphaRad;
skyPos.latitude = uvar.deltaRad;
/* Calculate the AM coefficients (a,b) for each SFT */
if ((multiCoeffs = XLALComputeMultiAMCoeffs ( multiStates, multiWeights, skyPos )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALComputeMultiAMCoeffs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Construct the flat list of SFTs (this sort of replicates the
catalog, but there's not an obvious way to get the information
back) */
if ( ( XLALCreateSFTIndexListFromMultiSFTVect( &sftIndices, inputSFTs ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateSFTIndexListFromMultiSFTVect() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Construct the list of SFT pairs */
#define PCC_SFTPAIR_HEADER "# The length of SFT-pair list is %u #\n"
#define PCC_SFTPAIR_BODY "%u %u\n"
#define PCC_SFT_HEADER "# The length of SFT list is %u #\n"
#define PCC_SFT_BODY "%s %d %d\n"
FILE *fp = NULL;
if (XLALUserVarWasSet(&uvar.pairListInputFilename)) { /* If the user provided a list for reading, use it */
if((sftPairs = XLALCalloc(1, sizeof(sftPairs))) == NULL){
XLAL_ERROR(XLAL_ENOMEM);
}
if((fp = fopen(uvar.pairListInputFilename, "r")) == NULL){
LogPrintf ( LOG_CRITICAL, "didn't find SFT-pair list file with given input name\n");
XLAL_ERROR( XLAL_EFUNC );
}
if(fscanf(fp,PCC_SFTPAIR_HEADER,&sftPairs->length)==EOF){
LogPrintf ( LOG_CRITICAL, "can't read the length of SFT-pair list from the header\n");
XLAL_ERROR( XLAL_EFUNC );
}
if((sftPairs->data = XLALCalloc(sftPairs->length, sizeof(*sftPairs->data)))==NULL){
XLALFree(sftPairs);
XLAL_ERROR(XLAL_ENOMEM);
}
for(j = 0; j < sftPairs->length; j++){ /*read in the SFT-pair list */
if(fscanf(fp,PCC_SFTPAIR_BODY, &sftPairs->data[j].sftNum[0], &sftPairs->data[j].sftNum[1])==EOF){
LogPrintf ( LOG_CRITICAL, "The length of SFT-pair list doesn't match!");
XLAL_ERROR( XLAL_EFUNC );
}
}
fclose(fp);
}
else { /* if not, construct the list of pairs */
if ( ( XLALCreateSFTPairIndexList( &sftPairs, sftIndices, inputSFTs, uvar.maxLag, uvar.inclAutoCorr ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateSFTPairIndexList() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
}
if (XLALUserVarWasSet(&uvar.pairListOutputFilename)) { /* Write the list of pairs to a file, if a name was provided */
if((fp = fopen(uvar.pairListOutputFilename, "w")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in SFT-pair list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_SFTPAIR_HEADER, sftPairs->length ); /*output the length of SFT-pair list to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_SFTPAIR_BODY, sftPairs->data[j].sftNum[0], sftPairs->data[j].sftNum[1]);
}
fclose(fp);
}
if (XLALUserVarWasSet(&uvar.sftListOutputFilename)) { /* Write the list of SFTs to a file for sanity-checking purposes */
if((fp = fopen(uvar.sftListOutputFilename, "w")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in flat SFT list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_SFT_HEADER, sftIndices->length ); /*output the length of SFT list to the header*/
for(j = 0; j < sftIndices->length; j++){ /*output the SFT list */
fprintf(fp,PCC_SFT_BODY, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].name, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsSeconds, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsNanoSeconds);
}
fclose(fp);
}
else if(XLALUserVarWasSet(&uvar.sftListInputFilename)){ /*do a sanity check of the order of SFTs list if the name of input SFT list is given*/
UINT4 numofsft=0;
if((fp = fopen(uvar.sftListInputFilename, "r")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't read in flat SFT list \n");
XLAL_ERROR( XLAL_EFUNC );
}
if (fscanf(fp, PCC_SFT_HEADER, &numofsft)==EOF){
LogPrintf ( LOG_CRITICAL, "can't read in the length of SFT list from header\n");
XLAL_ERROR( XLAL_EFUNC );
}
CHARVectorSequence *checkDet=NULL;
if ((checkDet = XLALCreateCHARVectorSequence (numofsft, LALNameLength) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateCHARVector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
INT4 checkGPS[numofsft], checkGPSns[numofsft];
if(numofsft == sftIndices->length){
for (j=0; j<numofsft; j++){
if( fscanf(fp,PCC_SFT_BODY,&checkDet->data[j * LALNameLength], &checkGPS[j], &checkGPSns[j])==EOF){
LogPrintf ( LOG_CRITICAL, "The length of SFT list doesn't match\n");
XLAL_ERROR( XLAL_EFUNC );
}
if(strcmp( inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].name, &checkDet->data[j * LALNameLength] ) != 0
||inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsSeconds != checkGPS[j]
||inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsNanoSeconds != checkGPSns[j] ){
LogPrintf ( LOG_CRITICAL, "The order of SFTs has been changed, it's the end of civilization\n");
XLAL_ERROR( XLAL_EFUNC );
}
}
fclose(fp);
XLALDestroyCHARVectorSequence(checkDet);
}
else{
LogPrintf ( LOG_CRITICAL, "Run for your life, the length of SFT list doesn't match");
XLAL_ERROR( XLAL_EFUNC );
}
}
else
{
}
/* Get weighting factors for calculation of metric */
/* note that the sigma-squared is now absorbed into the curly G
because the AM coefficients are noise-weighted. */
REAL8Vector *GammaAve = NULL;
REAL8Vector *GammaCirc = NULL;
if ( ( XLALCalculateCrossCorrGammas( &GammaAve, &GammaCirc, sftPairs, sftIndices, multiCoeffs) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrGammas() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
#define PCC_GAMMA_HEADER "# The normalization Sinv_Tsft is %g #\n"
#define PCC_GAMMA_BODY "%.10g\n"
if (XLALUserVarWasSet(&uvar.gammaAveOutputFilename)) { /* Write the aa+bb weight for each pair to a file, if a name was provided */
if((fp = fopen(uvar.gammaAveOutputFilename, "w")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Can't write in Gamma_ave list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_GAMMA_HEADER, multiWeights->Sinv_Tsft); /*output the normalization factor to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_GAMMA_BODY, GammaAve->data[j]);
}
fclose(fp);
}
if (XLALUserVarWasSet(&uvar.gammaCircOutputFilename)) { /* Write the ab-ba weight for each pair to a file, if a name was provided */
if((fp = fopen(uvar.gammaCircOutputFilename, "w")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Can't write in Gamma_circ list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_GAMMA_HEADER, multiWeights->Sinv_Tsft); /*output the normalization factor to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_GAMMA_BODY, GammaCirc->data[j]);
}
fclose(fp);
}
/*initialize binary parameters structure*/
XLAL_INIT_MEM(minBinaryTemplate);
XLAL_INIT_MEM(maxBinaryTemplate);
XLAL_INIT_MEM(thisBinaryTemplate);
XLAL_INIT_MEM(binaryTemplateSpacings);
/*fill in minbinaryOrbitParams*/
XLALGPSSetREAL8( &minBinaryTemplate.tp, uvar.orbitTimeAsc);
minBinaryTemplate.argp = 0.0;
minBinaryTemplate.asini = uvar.orbitAsiniSec;
minBinaryTemplate.ecc = 0.0;
minBinaryTemplate.period = uvar.orbitPSec;
minBinaryTemplate.fkdot[0] = uvar.fStart;
/*fill in maxBinaryParams*/
XLALGPSSetREAL8( &maxBinaryTemplate.tp, uvar.orbitTimeAsc + uvar.orbitTimeAscBand);
maxBinaryTemplate.argp = 0.0;
maxBinaryTemplate.asini = uvar.orbitAsiniSec + uvar.orbitAsiniSecBand;
maxBinaryTemplate.ecc = 0.0;
maxBinaryTemplate.period = uvar.orbitPSec;
maxBinaryTemplate.fkdot[0] = uvar.fStart + uvar.fBand;
/*fill in thisBinaryTemplate*/
XLALGPSSetREAL8( &thisBinaryTemplate.tp, uvar.orbitTimeAsc + 0.5 * uvar.orbitTimeAscBand);
thisBinaryTemplate.argp = 0.0;
thisBinaryTemplate.asini = 0.5*(minBinaryTemplate.asini + maxBinaryTemplate.asini);
thisBinaryTemplate.ecc = 0.0;
thisBinaryTemplate.period =0.5*(minBinaryTemplate.period + maxBinaryTemplate.period);
thisBinaryTemplate.fkdot[0]=0.5*(minBinaryTemplate.fkdot[0] + maxBinaryTemplate.fkdot[0]);
/*Get metric diagonal components, also estimate sensitivity i.e. E[rho]/(h0)^2 (4.13)*/
if ( (XLALCalculateLMXBCrossCorrDiagMetric(&estSens, &diagff, &diagaa, &diagTT, thisBinaryTemplate, GammaAve, sftPairs, sftIndices, inputSFTs, multiWeights /*, kappaValues*/) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateLMXBCrossCorrDiagMetric() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* spacing in frequency from diagff */ /* set spacings in new dopplerparams struct */
if (XLALUserVarWasSet(&uvar.spacingF)) /* If spacing was given by CMD line, use it, else calculate spacing by mismatch*/
binaryTemplateSpacings.fkdot[0] = uvar.spacingF;
else
binaryTemplateSpacings.fkdot[0] = sqrt(uvar.mismatchF / diagff);
if (XLALUserVarWasSet(&uvar.spacingA))
binaryTemplateSpacings.asini = uvar.spacingA;
else
binaryTemplateSpacings.asini = sqrt(uvar.mismatchA / diagaa);
/* this is annoying: tp is a GPS time while we want a difference
in time which should be just REAL8 */
if (XLALUserVarWasSet(&uvar.spacingT))
XLALGPSSetREAL8( &binaryTemplateSpacings.tp, uvar.spacingT);
else
XLALGPSSetREAL8( &binaryTemplateSpacings.tp, sqrt(uvar.mismatchT / diagTT));
if (XLALUserVarWasSet(&uvar.spacingP))
binaryTemplateSpacings.period = uvar.spacingP;
else
binaryTemplateSpacings.period = sqrt(uvar.mismatchP / diagpp);
/* metric elements for eccentric case not considered? */
UINT8 fCount = 0, aCount = 0, tCount = 0 , pCount = 0;
const UINT8 fSpacingNum = floor( uvar.fBand / binaryTemplateSpacings.fkdot[0]);
const UINT8 aSpacingNum = floor( uvar.orbitAsiniSecBand / binaryTemplateSpacings.asini);
const UINT8 tSpacingNum = floor( uvar.orbitTimeAscBand / XLALGPSGetREAL8(&binaryTemplateSpacings.tp));
const UINT8 pSpacingNum = floor( uvar.orbitPSecBand / binaryTemplateSpacings.period);
/*reset minbinaryOrbitParams to shift the first point a factor so as to make the center of all seaching points centers at the center of searching band*/
minBinaryTemplate.fkdot[0] = uvar.fStart + 0.5 * (uvar.fBand - fSpacingNum * binaryTemplateSpacings.fkdot[0]);
minBinaryTemplate.asini = uvar.orbitAsiniSec + 0.5 * (uvar.orbitAsiniSecBand - aSpacingNum * binaryTemplateSpacings.asini);
XLALGPSSetREAL8( &minBinaryTemplate.tp, uvar.orbitTimeAsc + 0.5 * (uvar.orbitTimeAscBand - tSpacingNum * XLALGPSGetREAL8(&binaryTemplateSpacings.tp)));
minBinaryTemplate.period = uvar.orbitPSec + 0.5 * (uvar.orbitPSecBand - pSpacingNum * binaryTemplateSpacings.period);
/* initialize the doppler scan struct which stores the current template information */
XLALGPSSetREAL8(&dopplerpos.refTime, config.refTime);
dopplerpos.Alpha = uvar.alphaRad;
dopplerpos.Delta = uvar.deltaRad;
dopplerpos.fkdot[0] = minBinaryTemplate.fkdot[0];
/* set all spindowns to zero */
for (k=1; k < PULSAR_MAX_SPINS; k++)
dopplerpos.fkdot[k] = 0.0;
dopplerpos.asini = minBinaryTemplate.asini;
dopplerpos.period = minBinaryTemplate.period;
dopplerpos.tp = minBinaryTemplate.tp;
dopplerpos.ecc = minBinaryTemplate.ecc;
dopplerpos.argp = minBinaryTemplate.argp;
/* now set the initial values of binary parameters */
/* thisBinaryTemplate.asini = uvar.orbitAsiniSec;
thisBinaryTemplate.period = uvar.orbitPSec;
XLALGPSSetREAL8( &thisBinaryTemplate.tp, uvar.orbitTimeAsc);
thisBinaryTemplate.ecc = 0.0;
thisBinaryTemplate.argp = 0.0;*/
/* copy to dopplerpos */
/* Calculate SSB times (can do this once since search is currently only for one sky position, and binary doppler shift is added later) */
MultiSSBtimes *multiSSBTimes = NULL;
if ((multiSSBTimes = XLALGetMultiSSBtimes ( multiStates, skyPos, dopplerpos.refTime, SSBPREC_RELATIVISTICOPT )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALGetMultiSSBtimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* "New" general metric computation */
/* For now hard-code circular parameter space */
const DopplerCoordinateSystem coordSys = {
.dim = 4,
.coordIDs = { DOPPLERCOORD_FREQ,
DOPPLERCOORD_ASINI,
DOPPLERCOORD_TASC,
DOPPLERCOORD_PORB, },
};
REAL8VectorSequence *phaseDerivs = NULL;
if ( ( XLALCalculateCrossCorrPhaseDerivatives ( &phaseDerivs, &thisBinaryTemplate, config.edat, sftIndices, multiSSBTimes, &coordSys ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrPhaseDerivatives() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* fill in metric and parameter offsets */
gsl_matrix *g_ij = NULL;
gsl_vector *eps_i = NULL;
REAL8 sumGammaSq = 0;
if ( ( XLALCalculateCrossCorrPhaseMetric ( &g_ij, &eps_i, &sumGammaSq, phaseDerivs, sftPairs, GammaAve, GammaCirc, &coordSys ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrPhaseMetric() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
XLALDestroyREAL8VectorSequence ( phaseDerivs );
XLALDestroyREAL8Vector ( GammaCirc );
if ((fp = fopen("gsldata.dat","w"))==NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in gsl matrix file");
XLAL_ERROR( XLAL_EFUNC );
}
XLALfprintfGSLvector(fp, "%g", eps_i);
XLALfprintfGSLmatrix(fp, "%g", g_ij);
/* Allocate structure for binary doppler-shifting information */
if ((multiBinaryTimes = XLALDuplicateMultiSSBtimes ( multiSSBTimes )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALDuplicateMultiSSBtimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
UINT8 numSFTs = sftIndices->length;
if ((shiftedFreqs = XLALCreateREAL8Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((lowestBins = XLALCreateUINT4Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateUINT4Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((expSignalPhases = XLALCreateCOMPLEX8Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((sincList = XLALCreateREAL8VectorSequence ( numSFTs, uvar.numBins ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8VectorSequence() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* args should be : spacings, min and max doppler params */
BOOLEAN firstPoint = TRUE; /* a boolean to help to search at the beginning point in parameter space, after the search it is set to be FALSE to end the loop*/
if ( (XLALAddMultiBinaryTimes( &multiBinaryTimes, multiSSBTimes, &dopplerpos ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALAddMultiBinaryTimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
} /*Need to apply additional doppler shifting before the loop, or the first point in parameter space will be lost and return a wrong SNR when fBand!=0*/
while ( GetNextCrossCorrTemplate(&dopplerShiftFlag, &firstPoint, &dopplerpos, &binaryTemplateSpacings, &minBinaryTemplate, &maxBinaryTemplate, &fCount, &aCount, &tCount, &pCount, fSpacingNum, aSpacingNum, tSpacingNum, pSpacingNum) == 0)
{
/* do useful stuff here*/
/* Apply additional Doppler shifting using current binary orbital parameters */
/* Might want to be clever about checking whether we've changed the orbital parameters or only the frequency */
if (dopplerShiftFlag == TRUE)
{
if ( (XLALAddMultiBinaryTimes( &multiBinaryTimes, multiSSBTimes, &dopplerpos ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALAddMultiBinaryTimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
}
if ( (XLALGetDopplerShiftedFrequencyInfo( shiftedFreqs, lowestBins, expSignalPhases, sincList, uvar.numBins, &dopplerpos, sftIndices, inputSFTs, multiBinaryTimes, Tsft ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALGetDopplerShiftedFrequencyInfo() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ( (XLALCalculatePulsarCrossCorrStatistic( &ccStat, &evSquared, GammaAve, expSignalPhases, lowestBins, sincList, sftPairs, sftIndices, inputSFTs, multiWeights, uvar.numBins) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculatePulsarCrossCorrStatistic() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* fill candidate struct and insert into toplist if necessary */
thisCandidate.freq = dopplerpos.fkdot[0];
thisCandidate.tp = XLALGPSGetREAL8( &dopplerpos.tp );
thisCandidate.argp = dopplerpos.argp;
thisCandidate.asini = dopplerpos.asini;
thisCandidate.ecc = dopplerpos.ecc;
thisCandidate.period = dopplerpos.period;
thisCandidate.rho = ccStat;
thisCandidate.evSquared = evSquared;
thisCandidate.estSens = estSens;
insert_into_crossCorrBinary_toplist(ccToplist, thisCandidate);
} /* end while loop over templates */
/* write candidates to file */
sort_crossCorrBinary_toplist( ccToplist );
/* add error checking */
final_write_crossCorrBinary_toplist_to_file( ccToplist, uvar.toplistFilename, &checksum);
REAL8 h0Sens = sqrt((10 / sqrt(estSens))); /*for a SNR=10 signal, the h0 we can detect*/
XLALGPSTimeNow (&computingEndGPSTime); /*record the rough end time*/
UINT4 computingTime = computingEndGPSTime.gpsSeconds - computingStartGPSTime.gpsSeconds;
/* make a meta-data file*/
if(XLALUserVarWasSet(&uvar.logFilename)){
CHAR *CMDInputStr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE );
if ((fp = fopen(uvar.logFilename,"w"))==NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in logfile");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp, "[UserInput]\n\n");
fprintf(fp, "%s\n", CMDInputStr);
fprintf(fp, "[CalculatedValues]\n\n");
fprintf(fp, "g_ff = %.9f\n", diagff );
fprintf(fp, "g_aa = %.9f\n", diagaa );
fprintf(fp, "g_TT = %.9f\n", diagTT );
fprintf(fp, "FSpacing = %.9g\n", binaryTemplateSpacings.fkdot[0]);
fprintf(fp, "ASpacing = %.9g\n", binaryTemplateSpacings.asini);
fprintf(fp, "TSpacing = %.9g\n", XLALGPSGetREAL8(&binaryTemplateSpacings.tp));
/* fprintf(fp, "PSpacing = %.9g\n", binaryTemplateSpacings.period );*/
fprintf(fp, "TemplatenumF = %" LAL_UINT8_FORMAT "\n", (fSpacingNum + 1));
fprintf(fp, "TemplatenumA = %" LAL_UINT8_FORMAT "\n", (aSpacingNum + 1));
fprintf(fp, "TemplatenumT = %" LAL_UINT8_FORMAT "\n", (tSpacingNum + 1));
fprintf(fp, "TemplatenumP = %" LAL_UINT8_FORMAT "\n", (pSpacingNum + 1));
fprintf(fp, "TemplatenumTotal = %" LAL_UINT8_FORMAT "\n",(fSpacingNum + 1) * (aSpacingNum + 1) * (tSpacingNum + 1) * (pSpacingNum + 1));
fprintf(fp, "Sens = %.9g\n", estSens);/*(E[rho]/h0^2)^2*/
fprintf(fp, "h0_min_SNR10 = %.9g\n", h0Sens);/*for rho = 10 in our pipeline*/
fprintf(fp, "startTime = %" LAL_INT4_FORMAT "\n", computingStartGPSTime.gpsSeconds );/*start time in GPS-time*/
fprintf(fp, "endTime = %" LAL_INT4_FORMAT "\n", computingEndGPSTime.gpsSeconds );/*end time in GPS-time*/
fprintf(fp, "computingTime = %" LAL_UINT4_FORMAT "\n", computingTime );/*total time in sec*/
fprintf(fp, "SFTnum = %" LAL_UINT4_FORMAT "\n", sftIndices->length);/*total number of SFT*/
fprintf(fp, "pairnum = %" LAL_UINT4_FORMAT "\n", sftPairs->length);/*total number of pair of SFT*/
fprintf(fp, "Tsft = %.6g\n", Tsft);/*SFT duration*/
fprintf(fp, "\n[Version]\n\n");
fprintf(fp, "%s", VCSInfoString);
fclose(fp);
XLALFree(CMDInputStr);
}
XLALFree(VCSInfoString);
XLALDestroyCOMPLEX8Vector ( expSignalPhases );
XLALDestroyUINT4Vector ( lowestBins );
XLALDestroyREAL8Vector ( shiftedFreqs );
XLALDestroyREAL8VectorSequence ( sincList );
XLALDestroyMultiSSBtimes ( multiBinaryTimes );
XLALDestroyMultiSSBtimes ( multiSSBTimes );
XLALDestroyREAL8Vector ( GammaAve );
XLALDestroySFTPairIndexList( sftPairs );
XLALDestroySFTIndexList( sftIndices );
XLALDestroyMultiAMCoeffs ( multiCoeffs );
XLALDestroyMultiDetectorStateSeries ( multiStates );
XLALDestroyMultiTimestamps ( multiTimes );
XLALDestroyMultiNoiseWeights ( multiWeights );
XLALDestroyMultiPSDVector ( multiPSDs );
XLALDestroyMultiSFTVector ( inputSFTs );
/* de-allocate memory for configuration variables */
XLALDestroyConfigVars ( &config );
/* de-allocate memory for user input variables */
XLALDestroyUserVars();
/* free toplist memory */
free_crossCorr_toplist(&ccToplist);
/* check memory leaks if we forgot to de-allocate anything */
LALCheckMemoryLeaks();
LogPrintf (LOG_CRITICAL, "End time\n");/*for debug convenience to record calculating time*/
return 0;
} /* main */
/* initialize and register user variables */
int XLALInitUserVars (UserInput_t *uvar)
{
/* initialize with some defaults */
uvar->help = FALSE;
uvar->maxLag = 0.0;
uvar->inclAutoCorr = FALSE;
uvar->fStart = 100.0;
uvar->fBand = 0.1;
/* uvar->fdotStart = 0.0; */
/* uvar->fdotBand = 0.0; */
uvar->alphaRad = 0.0;
uvar->deltaRad = 0.0;
uvar->refTime = 0.0;
uvar->rngMedBlock = 50;
uvar->numBins = 1;
/* zero binary orbital parameters means not a binary */
uvar->orbitAsiniSec = 0.0;
uvar->orbitAsiniSecBand = 0.0;
uvar->orbitPSec = 0.0;
uvar->orbitPSecBand = 0.0;
uvar->orbitTimeAsc = 0;
uvar->orbitTimeAscBand = 0;
/*default mismatch values */
/* set to 0.1 by default -- for no real reason */
/* make 0.1 a macro? */
uvar->mismatchF = 0.1;
uvar->mismatchA = 0.1;
uvar->mismatchT = 0.1;
uvar->mismatchP = 0.1;
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->sftLocation = XLALCalloc(1, MAXFILENAMELENGTH+1);
/* initialize number of candidates in toplist -- default is just to return the single best candidate */
uvar->numCand = 1;
uvar->toplistFilename = XLALStringDuplicate("toplist_crosscorr.dat");
uvar->version = FALSE;
/* register user-variables */
XLALregBOOLUserStruct ( help, 'h', UVAR_HELP, "Print this message");
XLALregINTUserStruct ( startTime, 0, UVAR_REQUIRED, "Desired start time of analysis in GPS seconds");
XLALregINTUserStruct ( endTime, 0, UVAR_REQUIRED, "Desired end time of analysis in GPS seconds");
XLALregREALUserStruct ( maxLag, 0, UVAR_OPTIONAL, "Maximum lag time in seconds between SFTs in correlation");
XLALregBOOLUserStruct ( inclAutoCorr, 0, UVAR_OPTIONAL, "Include auto-correlation terms (an SFT with itself)");
XLALregREALUserStruct ( fStart, 0, UVAR_OPTIONAL, "Start frequency in Hz");
XLALregREALUserStruct ( fBand, 0, UVAR_OPTIONAL, "Frequency band to search over in Hz ");
/* XLALregREALUserStruct ( fdotStart, 0, UVAR_OPTIONAL, "Start value of spindown in Hz/s"); */
/* XLALregREALUserStruct ( fdotBand, 0, UVAR_OPTIONAL, "Band for spindown values in Hz/s"); */
XLALregREALUserStruct ( alphaRad, 0, UVAR_OPTIONAL, "Right ascension for directed search (radians)");
XLALregREALUserStruct ( deltaRad, 0, UVAR_OPTIONAL, "Declination for directed search (radians)");
XLALregREALUserStruct ( refTime, 0, UVAR_OPTIONAL, "SSB reference time for pulsar-parameters [Default: midPoint]");
XLALregREALUserStruct ( orbitAsiniSec, 0, UVAR_OPTIONAL, "Start of search band for projected semimajor axis (seconds) [0 means not a binary]");
XLALregREALUserStruct ( orbitAsiniSecBand, 0, UVAR_OPTIONAL, "Width of search band for projected semimajor axis (seconds)");
XLALregREALUserStruct ( orbitPSec, 0, UVAR_OPTIONAL, "Binary orbital period (seconds) [0 means not a binary]");
XLALregREALUserStruct ( orbitPSecBand, 0, UVAR_OPTIONAL, "Band for binary orbital period (seconds) ");
XLALregREALUserStruct ( orbitTimeAsc, 0, UVAR_OPTIONAL, "Start of orbital time-of-ascension band in GPS seconds");
XLALregREALUserStruct ( orbitTimeAscBand, 0, UVAR_OPTIONAL, "Width of orbital time-of-ascension band (seconds)");
XLALregSTRINGUserStruct( ephemEarth, 0, UVAR_OPTIONAL, "Earth ephemeris file to use");
XLALregSTRINGUserStruct( ephemSun, 0, UVAR_OPTIONAL, "Sun ephemeris file to use");
XLALregSTRINGUserStruct( sftLocation, 0, UVAR_REQUIRED, "Filename pattern for locating SFT data");
XLALregINTUserStruct ( rngMedBlock, 0, UVAR_OPTIONAL, "Running median block size for PSD estimation");
XLALregINTUserStruct ( numBins, 0, UVAR_OPTIONAL, "Number of frequency bins to include in calculation");
XLALregREALUserStruct ( mismatchF, 0, UVAR_OPTIONAL, "Desired mismatch for frequency spacing");
XLALregREALUserStruct ( mismatchA, 0, UVAR_OPTIONAL, "Desired mismatch for asini spacing");
XLALregREALUserStruct ( mismatchT, 0, UVAR_OPTIONAL, "Desired mismatch for periapse passage time spacing");
XLALregREALUserStruct ( mismatchP, 0, UVAR_OPTIONAL, "Desired mismatch for period spacing");
XLALregREALUserStruct ( spacingF, 0, UVAR_OPTIONAL, "Desired frequency spacing");
XLALregREALUserStruct ( spacingA, 0, UVAR_OPTIONAL, "Desired asini spacing");
XLALregREALUserStruct ( spacingT, 0, UVAR_OPTIONAL, "Desired periapse passage time spacing");
XLALregREALUserStruct ( spacingP, 0, UVAR_OPTIONAL, "Desired period spacing");
XLALregINTUserStruct ( numCand, 0, UVAR_OPTIONAL, "Number of candidates to keep in toplist");
XLALregSTRINGUserStruct( pairListInputFilename, 0, UVAR_OPTIONAL, "Name of file from which to read list of SFT pairs");
XLALregSTRINGUserStruct( pairListOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write list of SFT pairs");
XLALregSTRINGUserStruct( sftListOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write list of SFTs (for sanity checks)");
XLALregSTRINGUserStruct( sftListInputFilename, 0, UVAR_OPTIONAL, "Name of file to which to read in list of SFTs (for sanity checks)");
XLALregSTRINGUserStruct( gammaAveOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write aa+bb weights (for e.g., false alarm estimation)");
XLALregSTRINGUserStruct( gammaCircOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write ab-ba weights (for e.g., systematic error)");
XLALregSTRINGUserStruct( toplistFilename, 0, UVAR_OPTIONAL, "Output filename containing candidates in toplist");
XLALregSTRINGUserStruct( logFilename, 0, UVAR_OPTIONAL, "Output a meta-data file for the search");
XLALregBOOLUserStruct ( version, 'V', UVAR_SPECIAL, "Output version(VCS) information");
if ( xlalErrno ) {
XLALPrintError ("%s: user variable initialization failed with errno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
return XLAL_SUCCESS;
}
// ---------- main ----------
int
main ( int argc, char *argv[] )
{
UserInput_t XLAL_INIT_DECL(uvar_s);
UserInput_t *uvar = &uvar_s;
uvar->randSeed = 1;
uvar->Nruns = 1;
uvar->inAlign = uvar->outAlign = sizeof(void*);
// ---------- register user-variable ----------
XLALRegisterUvarMember( randSeed, INT4, 's', OPTIONAL, "Random-number seed");
XLALRegisterUvarMember( Nruns, INT4, 'r', OPTIONAL, "Number of repeated timing 'runs' to average over (=improves variance)" );
XLALRegisterUvarMember( inAlign, INT4, 'a', OPTIONAL, "Alignment of input vectors; default is sizeof(void*), i.e. no particular alignment" );
XLALRegisterUvarMember( outAlign, INT4, 'b', OPTIONAL, "Alignment of output vectors; default is sizeof(void*), i.e. no particular alignment" );
BOOLEAN should_exit = 0;
XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv, lalVCSInfoList ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( should_exit ) {
exit (1);
}
srand ( uvar->randSeed );
XLAL_CHECK ( uvar->Nruns >= 1, XLAL_EDOM );
UINT4 Nruns = (UINT4)uvar->Nruns;
UINT4 Ntrials = 1000000 + 7;
REAL4VectorAligned *xIn_a, *xIn2_a, *xOut_a, *xOut2_a;
XLAL_CHECK ( ( xIn_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xIn2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOut_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOut2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
REAL4VectorAligned *xOutRef_a, *xOutRef2_a;
XLAL_CHECK ( (xOutRef_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (xOutRef2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
// extract aligned REAL4 vectors from these
REAL4 *xIn = xIn_a->data;
REAL4 *xIn2 = xIn2_a->data;
REAL4 *xOut = xOut_a->data;
REAL4 *xOut2 = xOut2_a->data;
REAL4 *xOutRef = xOutRef_a->data;
REAL4 *xOutRef2 = xOutRef2_a->data;
UINT4Vector *xOutU4;
UINT4Vector *xOutRefU4;
XLAL_CHECK ( ( xOutU4 = XLALCreateUINT4Vector ( Ntrials )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOutRefU4 = XLALCreateUINT4Vector ( Ntrials )) != NULL, XLAL_EFUNC );
REAL8VectorAligned *xInD_a, *xIn2D_a, *xOutD_a, *xOutRefD_a;
XLAL_CHECK ( ( xInD_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xIn2D_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOutD_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (xOutRefD_a= XLALCreateREAL8VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
// extract aligned REAL8 vectors from these
REAL8 *xInD = xInD_a->data;
REAL8 *xIn2D = xIn2D_a->data;
REAL8 *xOutD = xOutD_a->data;
REAL8 *xOutRefD = xOutRefD_a->data;
REAL8 tic, toc;
REAL4 maxErr = 0, maxRelerr = 0;
REAL4 abstol, reltol;
XLALPrintInfo ("Testing sin(x), cos(x) for x in [-1000, 1000]\n");
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = 2000 * ( frand() - 0.5 );
}
abstol = 2e-7, reltol = 1e-5;
// ==================== SIN() ====================
TESTBENCH_VECTORMATH_S2S(Sin,xIn);
// ==================== COS() ====================
TESTBENCH_VECTORMATH_S2S(Cos,xIn);
// ==================== SINCOS() ====================
TESTBENCH_VECTORMATH_S2SS(SinCos,xIn);
// ==================== SINCOS(2PI*x) ====================
TESTBENCH_VECTORMATH_S2SS(SinCos2Pi,xIn);
// ==================== EXP() ====================
XLALPrintInfo ("\nTesting exp(x) for x in [-10, 10]\n");
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = 20 * ( frand() - 0.5 );
}
abstol = 4e-3, reltol = 3e-7;
TESTBENCH_VECTORMATH_S2S(Exp,xIn);
// ==================== LOG() ====================
XLALPrintInfo ("\nTesting log(x) for x in (0, 10000]\n");
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = 10000.0f * frand() + 1e-6;
} // for i < Ntrials
abstol = 2e-6, reltol = 2e-7;
TESTBENCH_VECTORMATH_S2S(Log,xIn);
// ==================== ADD,MUL ====================
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = -10000.0f + 20000.0f * frand() + 1e-6;
xIn2[i] = -10000.0f + 20000.0f * frand() + 1e-6;
xInD[i] = -100000.0 + 200000.0 * frand() + 1e-6;
xIn2D[i]= -100000.0 + 200000.0 * frand() + 1e-6;
} // for i < Ntrials
abstol = 2e-7, reltol = 2e-7;
XLALPrintInfo ("\nTesting add,multiply,shift,scale(x,y) for x,y in (-10000, 10000]\n");
TESTBENCH_VECTORMATH_SS2S(Add,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2S(Multiply,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2S(Max,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2S(Shift,xIn[0],xIn2);
TESTBENCH_VECTORMATH_SS2S(Scale,xIn[0],xIn2);
TESTBENCH_VECTORMATH_DD2D(Scale,xInD[0],xIn2D);
// ==================== FIND ====================
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = -10000.0f + 20000.0f * frand() + 1e-6;
xIn2[i] = -10000.0f + 20000.0f * frand() + 1e-6;
} // for i < Ntrials
XLALPrintInfo ("\nTesting find for x,y in (-10000, 10000]\n");
TESTBENCH_VECTORMATH_SS2uU(FindVectorLessEqual,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2uU(FindScalarLessEqual,xIn[0],xIn2);
XLALPrintInfo ("\n");
// ---------- clean up memory ----------
XLALDestroyREAL4VectorAligned ( xIn_a );
XLALDestroyREAL4VectorAligned ( xIn2_a );
XLALDestroyREAL4VectorAligned ( xOut_a );
XLALDestroyREAL4VectorAligned ( xOut2_a );
XLALDestroyREAL4VectorAligned ( xOutRef_a );
XLALDestroyREAL4VectorAligned ( xOutRef2_a );
XLALDestroyUINT4Vector ( xOutU4 );
XLALDestroyUINT4Vector ( xOutRefU4 );
XLALDestroyREAL8VectorAligned ( xInD_a );
XLALDestroyREAL8VectorAligned ( xIn2D_a );
XLALDestroyREAL8VectorAligned ( xOutD_a );
XLALDestroyREAL8VectorAligned ( xOutRefD_a );
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
/**
* basic initializations: deal with user input and return standardized 'ConfigVariables'
*/
int
XLALInitCode ( ConfigVariables *cfg, const UserVariables_t *uvar, const char *app_name)
{
XLAL_CHECK ( cfg && uvar && app_name, XLAL_EINVAL, "Illegal NULL pointer input." );
/* init ephemeris data */
XLAL_CHECK ( ( cfg->edat = XLALInitBarycenter( uvar->ephemEarth, uvar->ephemSun ) ) != NULL, XLAL_EFUNC, "XLALInitBarycenter failed: could not load Earth ephemeris '%s' and Sun ephemeris '%s.", uvar->ephemEarth, uvar->ephemSun);
cfg->numDetectors = uvar->IFOs->length;
cfg->numTimeStamps = 0;
XLAL_CHECK ( (cfg->numTimeStampsX = XLALCreateUINT4Vector ( cfg->numDetectors )) != NULL, XLAL_EFUNC, "XLALCreateREAL8Vector(%d) failed.", cfg->numDetectors );
BOOLEAN haveTimeGPS = XLALUserVarWasSet( &uvar->timeGPS );
BOOLEAN haveTimeStampsFile = XLALUserVarWasSet( &uvar->timeStampsFile );
BOOLEAN haveTimeStampsFiles = XLALUserVarWasSet( &uvar->timeStampsFiles );
XLAL_CHECK ( !(haveTimeStampsFiles && haveTimeStampsFile), XLAL_EINVAL, "Can't handle both timeStampsFiles and (deprecated) haveTimeStampsFiles input options." );
XLAL_CHECK ( !(haveTimeGPS && haveTimeStampsFile), XLAL_EINVAL, "Can't handle both (deprecated) timeStampsFile and timeGPS input options." );
XLAL_CHECK ( !(haveTimeGPS && haveTimeStampsFiles), XLAL_EINVAL, "Can't handle both timeStampsFiles and timeGPS input options." );
XLAL_CHECK ( haveTimeGPS || haveTimeStampsFiles || haveTimeStampsFile, XLAL_EINVAL, "Need either timeStampsFiles or timeGPS input option." );
if ( haveTimeStampsFiles ) {
XLAL_CHECK ( (uvar->timeStampsFiles->length == 1 ) || ( uvar->timeStampsFiles->length == cfg->numDetectors ), XLAL_EINVAL, "Length of timeStampsFiles list is neither 1 (one file for all detectors) nor does it match the number of detectors. (%d != %d)", uvar->timeStampsFiles->length, cfg->numDetectors );
XLAL_CHECK ( (uvar->timeStampsFiles->length == 1 ) || !uvar->outab, XLAL_EINVAL, "At the moment, can't produce a(t), b(t) output (--outab) when given per-IFO --timeStampsFiles.");
}
if ( haveTimeStampsFiles && ( uvar->timeStampsFiles->length == cfg->numDetectors ) ) {
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 '%s'.", uvar->timeStampsFiles );
}
else {
/* prepare multiTimestamps structure */
UINT4 nTS = 0;
XLAL_CHECK ( ( cfg->multiTimestamps = XLALCalloc ( 1, sizeof(*cfg->multiTimestamps))) != NULL, XLAL_ENOMEM, "Allocating multiTimestamps failed." );
XLAL_CHECK ( ( cfg->multiTimestamps->data = XLALCalloc ( cfg->numDetectors, sizeof(cfg->multiTimestamps->data) )) != NULL, XLAL_ENOMEM, "Allocating multiTimestamps->data failed." );
cfg->multiTimestamps->length = cfg->numDetectors;
if ( haveTimeGPS ) { /* set up timestamps vector from timeGPS, use same for all IFOs */
nTS = uvar->timeGPS->length;
XLAL_CHECK ( (cfg->multiTimestamps->data[0] = XLALCreateTimestampVector ( nTS ) ) != NULL, XLAL_EFUNC, "XLALCreateTimestampVector( %d ) failed.", nTS );
/* convert input REAL8 times into LIGOTimeGPS for first detector */
for (UINT4 t = 0; t < nTS; t++) {
REAL8 temp_real8_timestamp = 0;
XLAL_CHECK ( 1 == sscanf ( uvar->timeGPS->data[t], "%" LAL_REAL8_FORMAT, &temp_real8_timestamp ), XLAL_EINVAL, "Illegal REAL8 commandline argument to --timeGPS[%d]: '%s'", t, uvar->timeGPS->data[t] );
XLAL_CHECK ( XLALGPSSetREAL8( &cfg->multiTimestamps->data[0]->data[t], temp_real8_timestamp ) != NULL, XLAL_EFUNC, "Failed to convert input GPS %g into LIGOTimeGPS", temp_real8_timestamp );
} // for (UINT4 t = 0; t < nTS; t++)
} // if ( haveTimeGPS )
else { // haveTimeStampsFiles || haveTimeStampsFile
CHAR *singleTimeStampsFile = NULL;
if ( haveTimeStampsFiles ) {
singleTimeStampsFile = uvar->timeStampsFiles->data[0];
}
else if ( haveTimeStampsFile ) {
singleTimeStampsFile = uvar->timeStampsFile;
}
XLAL_CHECK ( ( cfg->multiTimestamps->data[0] = XLALReadTimestampsFile ( singleTimeStampsFile ) ) != NULL, XLAL_EFUNC );
nTS = cfg->multiTimestamps->data[0]->length;
} // else: haveTimeStampsFiles || haveTimeStampsFile
/* copy timestamps from first detector to all others */
if ( cfg->numDetectors > 1 ) {
for ( UINT4 X=1; X < cfg->numDetectors; X++ ) {
XLAL_CHECK ( (cfg->multiTimestamps->data[X] = XLALCreateTimestampVector ( nTS ) ) != NULL, XLAL_EFUNC, "XLALCreateTimestampVector( %d ) failed.", nTS );
for (UINT4 t = 0; t < nTS; t++) {
cfg->multiTimestamps->data[X]->data[t].gpsSeconds = cfg->multiTimestamps->data[0]->data[t].gpsSeconds;
cfg->multiTimestamps->data[X]->data[t].gpsNanoSeconds = cfg->multiTimestamps->data[0]->data[t].gpsNanoSeconds;
} // for (UINT4 t = 0; t < nTS; t++)
} // for ( UINT4 X=1; X < cfg->numDetectors X++ )
} // if ( cfg->numDetectors > 1 )
} // if !( haveTimeStampsFiles && ( uvar->timeStampsFiles->length == cfg->numDetectors ) )
for ( UINT4 X=0; X < cfg->numDetectors; X++ ) {
cfg->numTimeStampsX->data[X] = cfg->multiTimestamps->data[X]->length;
cfg->numTimeStamps += cfg->numTimeStampsX->data[X];
}
/* convert detector names into site-info */
MultiLALDetector multiDet;
XLAL_CHECK ( XLALParseMultiLALDetector ( &multiDet, uvar->IFOs ) == XLAL_SUCCESS, XLAL_EFUNC );
/* get detector states */
XLAL_CHECK ( (cfg->multiDetStates = XLALGetMultiDetectorStates ( cfg->multiTimestamps, &multiDet, cfg->edat, 0.5 * uvar->Tsft )) != NULL, XLAL_EFUNC, "XLALGetDetectorStates() failed." );
BOOLEAN haveAlphaDelta = ( XLALUserVarWasSet(&uvar->Alpha) && XLALUserVarWasSet(&uvar->Delta) );
BOOLEAN haveSkyGrid = XLALUserVarWasSet( &uvar->skyGridFile );
XLAL_CHECK ( !(haveAlphaDelta && haveSkyGrid), XLAL_EINVAL, "Can't handle both Alpha/Delta and skyGridFile input options." );
XLAL_CHECK ( haveAlphaDelta || haveSkyGrid, XLAL_EINVAL, "Need either Alpha/Delta or skyGridFile input option." );
if (haveAlphaDelta) { /* parse this into one-element Alpha, Delta vectors */
XLAL_CHECK ( (cfg->Alpha = XLALCreateREAL8Vector ( 1 )) != NULL, XLAL_EFUNC, "XLALCreateREAL8Vector(1) failed." );
cfg->Alpha->data[0] = uvar->Alpha;
XLAL_CHECK ( (cfg->Delta = XLALCreateREAL8Vector ( 1 )) != NULL, XLAL_EFUNC, "XLALCreateREAL8Vector(1) failed." );
cfg->Delta->data[0] = uvar->Delta;
cfg->numSkyPoints = 1;
} // if (haveAlphaDelta)
else if ( haveSkyGrid ) {
LALParsedDataFile *data = NULL;
XLAL_CHECK ( XLALParseDataFile (&data, uvar->skyGridFile) == XLAL_SUCCESS, XLAL_EFUNC, "Failed to parse data file '%s'.", uvar->skyGridFile );
cfg->numSkyPoints = data->lines->nTokens;
XLAL_CHECK ( (cfg->Alpha = XLALCreateREAL8Vector ( cfg->numSkyPoints )) != NULL, XLAL_EFUNC, "XLALCreateREAL8Vector( %d ) failed.", cfg->numSkyPoints );
XLAL_CHECK ( (cfg->Delta = XLALCreateREAL8Vector ( cfg->numSkyPoints )) != NULL, XLAL_EFUNC, "XLALCreateREAL8Vector( %d ) failed.", cfg->numSkyPoints );
for (UINT4 n=0; n < cfg->numSkyPoints; n++) {
XLAL_CHECK ( 2 == sscanf( data->lines->tokens[n], "%" LAL_REAL8_FORMAT "%" LAL_REAL8_FORMAT, &cfg->Alpha->data[n], &cfg->Delta->data[n] ), XLAL_EDATA, "Could not parse 2 numbers from line %d in candidate-file '%s':\n'%s'", n, uvar->skyGridFile, data->lines->tokens[n] );
} // for (UINT4 n=0; n < cfg->numSkyPoints; n++)
XLALDestroyParsedDataFile ( data );
} // else if ( haveSkyGrid )
if ( uvar->noiseSqrtShX ) { /* translate user-input PSD sqrt(SX) to noise-weights (this actually does not care whether they were normalized or not) */
if ( uvar->noiseSqrtShX->length != cfg->numDetectors ) {
fprintf(stderr, "Length of noiseSqrtShX vector does not match number of detectors! (%d != %d)\n", uvar->noiseSqrtShX->length, cfg->numDetectors);
XLAL_ERROR ( XLAL_EINVAL );
}
REAL8Vector *noiseSqrtShX = NULL;
if ( (noiseSqrtShX = XLALCreateREAL8Vector ( cfg->numDetectors )) == NULL ) {
fprintf(stderr, "Failed call to XLALCreateREAL8Vector( %d )\n", cfg->numDetectors );
XLAL_ERROR ( XLAL_EFUNC );
}
REAL8 psd_normalization = 0;
for (UINT4 X = 0; X < cfg->numDetectors; X++) {
if ( 1 != sscanf ( uvar->noiseSqrtShX->data[X], "%" LAL_REAL8_FORMAT, &noiseSqrtShX->data[X] ) ) {
fprintf(stderr, "Illegal REAL8 commandline argument to --noiseSqrtShX[%d]: '%s'\n", X, uvar->noiseSqrtShX->data[X]);
XLAL_ERROR ( XLAL_EINVAL );
}
if ( noiseSqrtShX->data[X] <= 0.0 ) {
fprintf(stderr, "Non-positive input PSD ratio for detector X=%d: noiseSqrtShX[X]=%f\n", X, noiseSqrtShX->data[X] );
XLAL_ERROR ( XLAL_EINVAL );
}
psd_normalization += 1.0/SQ(noiseSqrtShX->data[X]);
} /* for X < cfg->numDetectors */
psd_normalization = (REAL8)cfg->numDetectors/psd_normalization; /* S = NSFT / sum S_Xalpha^-1, no per-SFT variation here -> S = Ndet / sum S_X^-1 */
/* create multi noise weights */
if ( (cfg->multiNoiseWeights = XLALCalloc(1, sizeof(*cfg->multiNoiseWeights))) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, sizeof(*cfg->multiNoiseWeights) );
XLAL_ERROR ( XLAL_ENOMEM );
}
if ( (cfg->multiNoiseWeights->data = XLALCalloc(cfg->numDetectors, sizeof(*cfg->multiNoiseWeights->data))) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( %d, %d )\n", __func__, cfg->numDetectors, sizeof(*cfg->multiNoiseWeights->data) );
XLAL_ERROR ( XLAL_ENOMEM );
}
cfg->multiNoiseWeights->length = cfg->numDetectors;
for (UINT4 X = 0; X < cfg->numDetectors; X++) {
REAL8 noise_weight_X = psd_normalization/SQ(noiseSqrtShX->data[X]); /* w_Xalpha = S_Xalpha^-1/S^-1 = S / S_Xalpha */
/* create k^th weights vector */
if( ( cfg->multiNoiseWeights->data[X] = XLALCreateREAL8Vector ( cfg->numTimeStampsX->data[X] ) ) == NULL )
{
/* free weights vectors created previously in loop */
XLALDestroyMultiNoiseWeights ( cfg->multiNoiseWeights );
XLAL_ERROR ( XLAL_EFUNC, "Failed to allocate noiseweights for IFO X = %d\n", X );
} /* if XLALCreateREAL8Vector() failed */
/* loop over rngmeds and calculate weights -- one for each sft */
for ( UINT4 alpha = 0; alpha < cfg->numTimeStampsX->data[X]; alpha++) {
cfg->multiNoiseWeights->data[X]->data[alpha] = noise_weight_X;
}
} /* for X < cfg->numDetectors */
XLALDestroyREAL8Vector ( noiseSqrtShX );
} /* if ( uvar->noiseSqrtShX ) */
else {
cfg->multiNoiseWeights = NULL;
}
return XLAL_SUCCESS;
} /* XLALInitCode() */
