static REAL8VectorList *
XLALREAL8VectorListAddEntry (REAL8VectorList *head, const REAL8Vector *entry)
{
UINT4 dim;
REAL8VectorList *ptr = NULL; /* running list-pointer */
REAL8VectorList *newElement = NULL; /* new list-element */
/* check illegal input */
if ( (head == NULL) || (entry == NULL) )
return NULL;
/* find tail of list */
ptr = head;
while ( ptr->next )
ptr = ptr->next;
/* construct new list-element */
dim = entry->length;
if ( (newElement = LALCalloc (1, sizeof (*newElement))) == NULL)
return NULL;
if ( (newElement->entry.data = LALCalloc (dim, sizeof(entry->data[0]))) == NULL ) {
LALFree (newElement);
return NULL;
}
newElement->entry.length = dim;
memcpy (newElement->entry.data, entry->data, dim * sizeof(entry->data[0]) );
/* link this to the tail of list */
ptr->next = newElement;
newElement->prev = ptr;
return newElement;
} /* XLALREAL8VectorListAddEntry() */
static int frEvent2snglInspiral(SnglInspiralTable **snglInspiralEvent,
FrEvent *frameEvent )
{
FrEvent *frEvt = NULL;
SnglInspiralTable *snglEvt = NULL;
int numEvt = 0;
double timeAfter = 0;
/* If we already have events in snglInspiralEvent,
* wind on to the end of the list */
for( snglEvt = *snglInspiralEvent; snglEvt; snglEvt=snglEvt->next);
/* store the frameEvents in the snglInspiral linked list */
for(frEvt=frameEvent; frEvt; frEvt=frEvt->next, ++numEvt)
{
if ( !(*snglInspiralEvent) )
{
*snglInspiralEvent = snglEvt = (SnglInspiralTable * )
LALCalloc( 1, sizeof(SnglInspiralTable) );
}
else
{
snglEvt = snglEvt->next = (SnglInspiralTable * )
LALCalloc( 1, sizeof(SnglInspiralTable) );
}
/* read data from the frEvt */
snprintf(snglEvt->search, LIGOMETA_SEARCH_MAX, "%s", frEvt->name);
snglEvt->snr = frEvt->amplitude;
snglEvt->end_time.gpsSeconds = frEvt->GTimeS;
snglEvt->end_time.gpsNanoSeconds = frEvt->GTimeN;
timeAfter = frEvt->timeAfter;
XLALGPSAdd(&snglEvt->end_time,timeAfter);
snglEvt->eff_distance = FrEventGetParam ( frEvt, ignore_const("distance (Mpc)") );
snglEvt->mass1 = FrEventGetParam ( frEvt, ignore_const("mass1") );
snglEvt->mass2 = FrEventGetParam ( frEvt, ignore_const("mass2") );
snglEvt->tau0 =FrEventGetParam ( frEvt, ignore_const("tau0") );
snglEvt->tau3 = FrEventGetParam ( frEvt, ignore_const("tau1p5") );
snglEvt->coa_phase = FrEventGetParam ( frEvt, ignore_const("phase") );
snglEvt->chisq = FrEventGetParam ( frEvt, ignore_const("chi2") );
/* populate additional colums */
snglEvt->mtotal = snglEvt->mass1 + snglEvt->mass2;
snglEvt->eta = (snglEvt->mass1 * snglEvt->mass2) /
(snglEvt->mtotal * snglEvt->mtotal);
snglEvt->mchirp = pow( snglEvt->eta, 0.6) * snglEvt->mtotal;
snprintf(snglEvt->ifo, LIGOMETA_IFO_MAX, "%s", ifo);
}
return( numEvt );
}
LALFrameUFrDetector *XLALFrameUFrDetectorAlloc_FrameL_(const char *name,
const char *prefix, double latitude, double longitude, double elevation,
double azimuthX, double azimuthY, double altitudeX, double altitudeY, double midpointX, double midpointY, int localTime)
{
LALFrameUFrDetector *detector;
detector = LALCalloc(1, sizeof(*detector));
if (!detector)
XLAL_ERROR_NULL(XLAL_ENOMEM);
detector->handle = calloc(1, sizeof(*detector->handle));
if (!detector->handle)
XLAL_ERROR_NULL(XLAL_ENOMEM);
detector->handle->classe = FrDetectorDef();
detector->handle->name = strdup(name);
if (!detector->handle->name) {
XLALFrameUFrDetectorFree(detector);
XLAL_ERROR_NULL(XLAL_ENOMEM);
}
if (prefix) {
memcpy(detector->prefix, prefix, 2);
memcpy(detector->handle->prefix, prefix, 2);
}
detector->handle->longitude = longitude; /* longitude (east of greenwich) in radians */
detector->handle->latitude = latitude; /* latitude (north of equator) in radians */
detector->handle->elevation = elevation; /* detector altitude (meter) */
detector->handle->armXazimuth = azimuthX; /* orientation of X arm in radians CW from North */
detector->handle->armYazimuth = azimuthY; /* orientation of Y arm in radians CW from North */
/* Azimuth values should be in the range 0 to 2pi */
detector->handle->armXaltitude = altitudeX; /* altitude (pitch) of the X arm */
detector->handle->armYaltitude = altitudeY; /* altitude (pitch) of the Y arm */
detector->handle->armXmidpoint = midpointX; /* vertex to middle of the X arm distance */
detector->handle->armYmidpoint = midpointY; /* vertex to middle of the Y arm distance */
detector->handle->localTime = localTime; /* local time - UTC time (second) */
return detector;
}
/* Does no error checking, so check immediately after calling. */
static void
allocate(
REAL4 x,
REAL4 y,
REAL4 z,
REAL4 f0,
SnglInspiralTable **tmplt,
INT4 *ntiles,
BOOLEAN havePsi )
{
REAL4 mass, eta, m1, m2;
*tmplt = (*tmplt)->next = (SnglInspiralTable *) LALCalloc( 1,
sizeof(SnglInspiralTable) );
mass = -y/x / (16.0*LAL_PI*LAL_PI*f0);
eta = 16.0457 * pow( -x*x/y/y/y/y/y, 0.3333333 );
m1 = 0.5*mass* (1 + sqrt(1 - 4*eta));
m2 = 0.5*mass* (1 - sqrt(1 - 4*eta));
if ( ! havePsi )
{
(*tmplt)->mass1 = m1;
(*tmplt)->mass2 = m2;
(*tmplt)->eta = eta;
(*tmplt)->mchirp = pow(m1*m2,0.6)/pow(m1+m2,0.2);
}
(*tmplt)->psi0 = x*pow(f0,5./3);
(*tmplt)->psi3 = y*pow(f0,2./3);
(*tmplt)->beta = z*pow(f0,2./3);
++(*ntiles);
} /* allocate() */
/**
* Function for interpolating PSD to a given sample rate
*/
REAL8FrequencySeries *
XLALInterpolatePSD( REAL8FrequencySeries *in, /**< input strain time series */
REAL8 deltaFout /**< sample rate of time series */)
{
REAL8FrequencySeries *ret=NULL;
REAL8 deltaFin, r, y_1, y_2;
UINT4 k, lo, numPoints;
deltaFin = in->deltaF;
/* length of output vector */
numPoints = (UINT4) (in->data->length * deltaFin / deltaFout);
/* allocate memory */
ret = LALCalloc(1, sizeof(*ret));
if (!ret)
{
XLAL_ERROR_NULL( XLAL_ENOMEM );
}
ret->data = XLALCreateREAL8Vector( numPoints );
if (! ret->data)
{
XLAL_ERROR_NULL( XLAL_ENOMEM );
}
ret->deltaF = deltaFout;
/* copy values from in which should be the same */
ret->epoch = in->epoch;
ret->f0 = in->f0;
ret->sampleUnits = in->sampleUnits;
strcpy(ret->name, in->name);
/* go over points of output vector and interpolate linearly
using closest points of input */
for (k = 0; k < numPoints; k++) {
lo = (UINT4)( k*deltaFout / deltaFin);
/* y_1 and y_2 are the input values at x1 and x2 */
/* here we need to make sure that we don't exceed
bounds of input vector */
if ( lo < in->data->length - 1) {
y_1 = in->data->data[lo];
y_2 = in->data->data[lo+1];
/* we want to calculate y_2*r + y_1*(1-r) where
r = (x-x1)/(x2-x1) */
r = k*deltaFout / deltaFin - lo;
ret->data->data[k] = y_2 * r + y_1 * (1 - r);
}
else {
ret->data->data[k] = 0.0;
}
}
return ret;
}
REAL4Vector *
XLALComputeFreq(
REAL4TimeSeries *hp,
REAL4TimeSeries *hc)
{
REAL4Vector *Freq = NULL;
REAL4Vector *hpDot = NULL, *hcDot = NULL;
UINT4 k, len;
REAL8 dt;
len = hp->data->length;
dt = hp->deltaT;
Freq = LALCalloc(1, sizeof(*Freq));
Freq= XLALCreateREAL4Vector(len);
hpDot = LALCalloc(1, sizeof(*hpDot));
hpDot= XLALCreateREAL4Vector(len);
hcDot = LALCalloc(1, sizeof(*hcDot));
hcDot= XLALCreateREAL4Vector(len);
/* Construct the dot vectors (2nd order differencing) */
hpDot->data[0] = 0.0;
hpDot->data[len] = 0.0;
hcDot->data[0] = 0.0;
hcDot->data[len] = 0.0;
for( k = 1; k < len-1; k++)
{
hpDot->data[k] = 1./(2.*dt) *
(hp->data->data[k+1]-hp->data->data[k-1]);
hcDot->data[k] = 1./(2.*dt) *
(hc->data->data[k+1]-hc->data->data[k-1]);
}
/* Compute frequency using the fact that */
/*h(t) = A(t) e^(i Phi) = Re(h) + i Im(h) */
for( k = 0; k < len; k++)
{
Freq->data[k] = hcDot->data[k] * hp->data->data[k] -
hpDot->data[k] * hc->data->data[k];
Freq->data[k] /= LAL_TWOPI;
Freq->data[k] /= (pow(hp->data->data[k],2.) + pow(hc->data->data[k], 2.));
}
return Freq;
}
int main(int argc, char *argv[])
{
char tstr[32]; // string to hold GPS time -- 31 characters is enough
const double H0 = 0.72 * LAL_H0FAC_SI; // Hubble's constant in seconds
const size_t length = 65536; // number of points in a segment
const size_t stride = length / 2; // number of points in a stride
size_t i, n;
REAL8FrequencySeries *OmegaGW = NULL;
REAL8TimeSeries **seg = NULL;
LIGOTimeGPS epoch;
gsl_rng *rng;
XLALSetErrorHandler(XLALAbortErrorHandler);
parseargs(argc, argv);
XLALGPSSetREAL8(&epoch, tstart);
gsl_rng_env_setup();
rng = gsl_rng_alloc(gsl_rng_default);
OmegaGW = XLALSimSGWBOmegaGWFlatSpectrum(Omega0, flow, srate/length, length/2 + 1);
n = duration * srate;
seg = LALCalloc(numDetectors, sizeof(*seg));
printf("# time (s)");
for (i = 0; i < numDetectors; ++i) {
char name[LALNameLength];
snprintf(name, sizeof(name), "%s:STRAIN", detectors[i].frDetector.prefix);
seg[i] = XLALCreateREAL8TimeSeries(name, &epoch, 0.0, 1.0/srate, &lalStrainUnit, length);
printf("\t%s (strain)", name);
}
printf("\n");
XLALSimSGWB(seg, detectors, numDetectors, 0, OmegaGW, H0, rng); // first time to initilize
while (1) { // infinite loop
size_t j;
for (j = 0; j < stride; ++j, --n) { // output first stride points
LIGOTimeGPS t = seg[0]->epoch;
if (n == 0) // check if we're done
goto end;
printf("%s", XLALGPSToStr(tstr, XLALGPSAdd(&t, j * seg[0]->deltaT)));
for (i = 0; i < numDetectors; ++i)
printf("\t%e", seg[i]->data->data[j]);
printf("\n");
}
XLALSimSGWB(seg, detectors, numDetectors, stride, OmegaGW, H0, rng); // make more data
}
end:
for (i = 0; i < numDetectors; ++i)
XLALDestroyREAL8TimeSeries(seg[i]);
XLALFree(seg);
XLALDestroyREAL8FrequencySeries(OmegaGW);
LALCheckMemoryLeaks();
return 0;
}
static int frSimEvent2simInspiral (SimInspiralTable **simInspiralEvent,
FrSimEvent *frSimEvent )
{
FrSimEvent *frSimEvt = NULL;
SimInspiralTable *simEvt = NULL;
int numSim = 0;
/* If we already have events in snglInspiralEvent,
* wind on to the end of the list */
for( simEvt = *simInspiralEvent; simEvt; simEvt = simEvt->next);
/* store the frameEvents in the snglInspiral linked list */
for( frSimEvt = frSimEvent; frSimEvt; frSimEvt = frSimEvt->next, ++numSim)
{
if ( !(*simInspiralEvent) )
{
*simInspiralEvent = simEvt = (SimInspiralTable * )
LALCalloc( 1, sizeof(SimInspiralTable) );
}
else
{
simEvt = simEvt->next = (SimInspiralTable * )
LALCalloc( 1, sizeof(SimInspiralTable) );
}
/* read data from the frSimEvt */
snprintf(simEvt->waveform, LIGOMETA_SEARCH_MAX, "%s", frSimEvt->name);
simEvt->geocent_end_time.gpsSeconds = frSimEvt->GTimeS;
simEvt->geocent_end_time.gpsNanoSeconds = frSimEvt->GTimeN;
simEvt->v_end_time = simEvt->geocent_end_time;
simEvt->distance = FrSimEventGetParam ( frSimEvt, ignore_const("distance") );
simEvt->eff_dist_v = simEvt->distance;
simEvt->mass1 = FrSimEventGetParam ( frSimEvt, ignore_const("m1") );
simEvt->mass2 = FrSimEventGetParam ( frSimEvt, ignore_const("m2") );
}
return ( numSim );
}
/** Create a DetectorStateSeries with length entries */
DetectorStateSeries*
XLALCreateDetectorStateSeries ( UINT4 length ) /**< number of entries */
{
DetectorStateSeries *ret = NULL;
if ( (ret = LALCalloc(1, sizeof(DetectorStateSeries) )) == NULL ) {
XLALPrintError ("%s: failed to LALCalloc(1, %zu)\n", __func__, sizeof(DetectorStateSeries) );
XLAL_ERROR_NULL ( XLAL_ENOMEM );
}
if ( (ret->data = LALCalloc (length, sizeof(DetectorState) )) == NULL ) {
XLALFree (ret);
XLALPrintError ("%s: failed to LALCalloc(%d, %zu)\n", __func__, length, sizeof(DetectorState) );
XLAL_ERROR_NULL ( XLAL_ENOMEM );
}
ret->length = length;
return ret;
} /* XLALCreateDetectorStateSeries() */
int main(int argc, char *argv[])
{
const double H0 = 0.72 * LAL_H0FAC_SI; // Hubble's constant in seconds
const double srate = 16384.0; // sampling rate in Hertz
const size_t length = 65536; // number of points in a segment
const size_t stride = length / 2; // number of points in a stride
size_t i, n;
REAL8FrequencySeries *OmegaGW = NULL;
REAL8TimeSeries **seg = NULL;
LIGOTimeGPS epoch;
gsl_rng *rng;
XLALSetErrorHandler(XLALAbortErrorHandler);
parseargs(argc, argv);
XLALGPSSetREAL8(&epoch, tstart);
gsl_rng_env_setup();
rng = gsl_rng_alloc(gsl_rng_default);
OmegaGW = XLALSimSGWBOmegaGWFlatSpectrum(Omega0, flow, srate/length, length/2 + 1);
n = duration * srate;
seg = LALCalloc(numDetectors, sizeof(*seg));
for (i = 0; i < numDetectors; ++i)
seg[i] = XLALCreateREAL8TimeSeries("STRAIN", &epoch, 0.0, 1.0/srate, &lalStrainUnit, length);
XLALSimSGWB(seg, detectors, numDetectors, 0, OmegaGW, H0, rng); // first time to initilize
while (1) { // infinite loop
double t0 = XLALGPSGetREAL8(&seg[0]->epoch);
size_t j;
for (j = 0; j < stride; ++j, --n) { // output first stride points
if (n == 0) // check if we're done
goto end;
printf("%.9f", t0 + j * seg[0]->deltaT);
for (i = 0; i < numDetectors; ++i)
printf("\t%e", seg[i]->data->data[j]);
printf("\n");
}
XLALSimSGWB(seg, detectors, numDetectors, stride, OmegaGW, H0, rng); // make more data
}
end:
for (i = 0; i < numDetectors; ++i)
XLALDestroyREAL8TimeSeries(seg[i]);
XLALFree(seg);
XLALDestroyREAL8FrequencySeries(OmegaGW);
LALCheckMemoryLeaks();
return 0;
}
void
XLALComputeComplexVector(
COMPLEX8Vector **outPlus,
COMPLEX8Vector **outCross,
REAL4FrequencySeries *Ampl,
REAL4FrequencySeries *Phase)
{
COMPLEX8Vector *uPlus = NULL, *uCross = NULL;
COMPLEX8 num;
REAL4 Re, Im;
UINT4 k, n;
n = Ampl->data->length;
uPlus = LALCalloc(1, sizeof(*uPlus));
uPlus = XLALCreateCOMPLEX8Vector(n);
uCross = LALCalloc(1, sizeof(*uCross));
uCross = XLALCreateCOMPLEX8Vector(n);
for( k = 0 ; k < n ; k++ ) {
Re = Ampl->data->data[k] * cos(Phase->data->data[k]);
Im = Ampl->data->data[k] * sin(Phase->data->data[k]);
num.re = Re;
num.im = Im;
uPlus->data[k] = num;
Re = Ampl->data->data[k] * cos(Phase->data->data[k] - LAL_PI/2.);
Im = Ampl->data->data[k] * sin(Phase->data->data[k] - LAL_PI/2.);
num.re = Re;
num.im = Im;
uCross->data[k] = num;
}
*outPlus = uPlus;
*outCross = uCross;
}
/**
* @brief Opens a LALFrStream associated with a LALCache
* @details
* This routine creates a #LALFrStream that is a stream associated with
* the frame files contained in a LALCache.
* @param cache Pointer to a LALCache structure describing the frame files to stream.
* @returns Pointer to a newly created #LALFrStream structure.
* @retval NULL Failure.
*/
LALFrStream *XLALFrStreamCacheOpen(LALCache * cache)
{
LALFrStream *stream;
size_t i;
if (!cache)
XLAL_ERROR_NULL(XLAL_EFAULT);
stream = LALCalloc(1, sizeof(*stream));
if (!stream)
XLAL_ERROR_NULL(XLAL_ENOMEM);
stream->cache = XLALCacheDuplicate(cache);
/* check cache entries for t0 and dt; if these are not set then read
* the framefile to try to get them */
for (i = 0; i < stream->cache->length; ++i) {
if (stream->cache->list[i].t0 == 0 || stream->cache->list[i].dt == 0) {
LIGOTimeGPS end;
size_t nFrame;
if (XLALFrStreamFileOpen(stream, i) < 0) {
XLALFrStreamClose(stream);
XLAL_ERROR_NULL(XLAL_EIO);
}
nFrame = XLALFrFileQueryNFrame(stream->file);
stream->cache->list[i].t0 = stream->epoch.gpsSeconds;
XLALFrFileQueryGTime(&end, stream->file, nFrame - 1);
XLALGPSAdd(&end, XLALFrFileQueryDt(stream->file, nFrame - 1));
stream->cache->list[i].dt =
ceil(XLALGPSGetREAL8(&end)) - stream->cache->list[i].t0;
XLALFrStreamFileClose(stream);
}
}
/* sort and uniqify the cache */
if (XLALCacheSort(stream->cache) || XLALCacheUniq(stream->cache)) {
XLALFrStreamClose(stream);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
stream->mode = LAL_FR_STREAM_DEFAULT_MODE;
/* open up the first file */
if (XLALFrStreamFileOpen(stream, 0) < 0) {
XLALFrStreamClose(stream);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
return stream;
}
REAL8 start_freq_from_frame_url(CHAR *url)
{
FrameH *frame=NULL;
FrFile *frFile=NULL;
FrHistory *frHist=NULL;
FrHistory *thisHist;
CHAR *comment=NULL;
CHAR *token=NULL;
REAL8 ret=0;
CHAR *path;
/* convert url to path by skipping protocol part of protocol:path */
path = strchr(url, ':');
if (path == NULL)
path = url;
else
path+=strlen("://localhost"); /* skip the '://localhost' -- now on the path */
frFile = FrFileINew( path );
frame = FrameRead (frFile);
frHist = frame->history;
thisHist = frHist;
while (thisHist) {
/* get history comment string and parse it */
comment = LALCalloc(1, (strlen(thisHist->comment)+1)*sizeof(CHAR));
strcpy(comment, thisHist->comment);
token = strtok(comment,":");
if (strstr(token,"freqStart22") || strstr(token,"freq_start_22")) {
token = strtok(NULL,":");
ret = atof(token);
}
LALFree(comment);
comment = NULL;
thisHist = thisHist->next;
}
FrFileIEnd( frFile );
return ret;
}
/* helper function to create new channel of appropriate type */
static LALFrameUFrChan *XLALFrameUFrChanAlloc(const char *name, int chanType, int dataType, size_t ndata)
{
LALFrameUFrChan *channel;
channel = LALCalloc(1, sizeof(*channel));
if (!channel)
XLAL_ERROR_NULL(XLAL_ENOMEM);
channel->type = chanType;
switch (chanType) {
case XLAL_FRAMEU_FR_CHAN_TYPE_ADC:
channel->handle.adc = XLALFrameUFrAdcDataNew(name, dataType);
if (!channel->handle.adc) {
LALFree(channel);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
break;
case XLAL_FRAMEU_FR_CHAN_TYPE_SIM:
channel->handle.sim = XLALFrameUFrSimDataNew(name);
if (!channel->handle.sim) {
LALFree(channel);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
break;
case XLAL_FRAMEU_FR_CHAN_TYPE_PROC:
channel->handle.proc = XLALFrameUFrProcDataNew(name);
if (!channel->handle.proc) {
LALFree(channel);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
break;
default: /* unrecognized channel type */
LALFree(channel);
XLAL_ERROR_NULL(XLAL_ETYPE);
}
if (XLALFrameUFrChanVectorAlloc(channel, dataType, ndata) < 0) {
XLALFrameUFrChanFree(channel);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
return channel;
}
void
XLALSortSimRingdown(
SimRingdownTable **head,
int (*comparefunc)(const SimRingdownTable * const *,
const SimRingdownTable * const *)
)
{
INT4 i;
INT4 length;
SimRingdownTable *event;
SimRingdownTable **array;
/* empty list --> no-op */
if(!head || !*head)
return;
/* count the number of events in the list */
for(length = 0, event = *head; event; event = event->next)
length++;
/* construct an array of pointers into the list */
array = LALCalloc(length, sizeof(*array));
for(i = 0, event = *head; event; event = event->next)
array[i++] = event;
/* sort the array using the specified function */
qsort(array, length, sizeof(*array),
(int(*)(const void *, const void *)) comparefunc);
/* re-link the list according to the sorted array */
for(i = 0; i < length; i++, head = &(*head)->next)
*head = array[i];
*head = NULL;
/* free the array */
LALFree(array);
}
/**
* Function for reading a numerical relativity metadata file.
* It returns a list of numrel wave parameters. It uses
* XLALParseDataFile() for reading the data file. This automatically
* takes care of removing comment lines starting with # and other details.
*/
void
LALNRDataFind( LALStatus *status, /**< pointer to LALStatus structure */
NRWaveCatalog *out, /**< [out] list of numrel metadata */
const CHAR *dir, /**< [in] directory with data files */
const CHAR *filename /**< [in] File with metadata information */)
{
LALParsedDataFile *cfgdata=NULL;
UINT4 k, numWaves;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
ASSERT (filename != NULL, status, NRWAVEIO_ENULL, NRWAVEIO_MSGENULL );
ASSERT ( out != NULL, status, NRWAVEIO_ENULL, NRWAVEIO_MSGENULL );
ASSERT ( dir != NULL, status, NRWAVEIO_ENULL, NRWAVEIO_MSGENULL );
if ( XLALParseDataFile ( &cfgdata, filename ) != XLAL_SUCCESS ) {
ABORT( status, NRWAVEIO_EFILE, NRWAVEIO_MSGEFILE );
}
numWaves = cfgdata->lines->nTokens; /*number of waves */
/* allocate memory for output catalog */
out->length = numWaves;
out->data = LALCalloc(1, out->length * sizeof(NRWaveMetaData));
if ( out->data == NULL) {
ABORT( status, NRWAVEIO_ENOMEM, NRWAVEIO_MSGENOMEM );
}
/* now get wave parameters from each line of data */
for (k = 0; k < numWaves; k++) {
TRY(LALGetSingleNRMetaData( status->statusPtr, out->data + k, dir, cfgdata->lines->tokens[k]), status);
}
XLALDestroyParsedDataFile (cfgdata);
DETATCHSTATUSPTR(status);
RETURN(status);
}
int
XLALCoincSimRingdownTest (
SimRingdownTable **simHead,
CoincRingdownTable **coincHead,
SimRingdownTable **missedSimHead,
CoincRingdownTable **missedCoincHead
)
{
CoincRingdownTable *thisCoinc = *coincHead;
CoincRingdownTable *prevCoinc = NULL;
CoincRingdownTable *thisMissedCoinc = NULL;
SimRingdownTable *thisSim = NULL;
SimRingdownTable *prevSim = NULL;
SimRingdownTable *thisMissedSim = NULL;
SnglRingdownTable *thisSngl = NULL;
EventIDColumn *thisId = NULL;
InterferometerNumber ifoInCoinc = LAL_UNKNOWN_IFO;
int numSimFound = 0;
if ( !*coincHead )
{
XLALPrintInfo(
"XLALCoincSimRingdown: Empty coincInspiral passed as input" );
*missedSimHead = *simHead;
*simHead = NULL;
return( 0 );
}
*coincHead = NULL;
while( thisCoinc )
{
thisSim = NULL;
/* loop over the interferometers to get the event_id*/
for ( ifoInCoinc = (InterferometerNumber) 0; ifoInCoinc < LAL_NUM_IFO; ifoInCoinc++)
{
if ( (thisSngl = thisCoinc->snglRingdown[ifoInCoinc]) )
{
thisSim = thisSngl->event_id->simRingdownTable;
break;
}
}
for ( ; ifoInCoinc < LAL_NUM_IFO; ifoInCoinc++)
{
if ( (thisSngl = thisCoinc->snglRingdown[ifoInCoinc]) &&
(thisSim != thisSngl->event_id->simRingdownTable) )
{
thisSim = NULL;
break;
}
}
if ( thisSim )
{
/* thisCoinc is coincident with a thisSim */
thisCoinc->simRingdown = thisSim;
/* set the event_id's */
if ( !thisSim->event_id )
{
thisId = thisSim->event_id = LALCalloc( 1, sizeof(EventIDColumn) );
}
else
{
for ( thisId = thisSim->event_id; thisId->next; thisId = thisId->next);
thisId = thisId->next = LALCalloc( 1, sizeof(EventIDColumn) );
}
thisId->simRingdownTable = thisSim;
thisId->coincRingdownTable = thisCoinc;
if ( ! *coincHead )
{
*coincHead = thisCoinc;
}
XLALPrintInfo( "+" );
/* move on to
* * next coinc */
prevCoinc = thisCoinc;
thisCoinc = thisCoinc->next;
}
else
{
/* discard this event and move on to the next one */
if ( ! *missedCoincHead )
{
*missedCoincHead = thisMissedCoinc = thisCoinc;
}
else
{
thisMissedCoinc = thisMissedCoinc->next = thisCoinc;
}
if ( prevCoinc ) prevCoinc->next = thisCoinc->next;
thisCoinc = thisCoinc->next;
XLALPrintInfo( "-" );
/* terminate the missed list */
thisMissedCoinc->next = NULL;
}
}
/* run through simRingdowns, keeping only those in coincs */
thisSim = *simHead;
*simHead = NULL;
while( thisSim )
{
if( thisSim->event_id )
{
/* keep this event in the list and move to the next sim event */
if ( ! *simHead ) *simHead = thisSim;
prevSim = thisSim;
++numSimFound;
thisSim = thisSim->next;
XLALPrintInfo( "F" );
}
else
{
/* save this sim event in the list of missed events... */
if ( ! *missedSimHead )
{
*missedSimHead = thisMissedSim = thisSim;
}
else
{
thisMissedSim = thisMissedSim->next = thisSim;
}
/* ...and remove it from the list of found events */
if ( prevSim ) prevSim->next = thisSim->next;
XLALPrintInfo( "M" );
/* move to the next sim in the list */
thisSim = thisSim->next;
/* make sure the missed sim list is terminated */
thisMissedSim->next = NULL;
}
}
XLALPrintInfo( "\n" );
return( numSimFound );
}
void
XLALMCMCMetro (
LALMCMCParameter **paraPtr,
LALMCMCInput *inputMCMC
) {
static LALStatus status;
LALMCMCParameter *parameter = NULL;
LALMCMCParam *paraHead = NULL;
gsl_matrix *startCovMat = NULL;
gsl_matrix *covMat = NULL;
REAL4Vector *vector = NULL;
StateMCMC state;
REAL4 logPrior, logLikelihood, currentLogPosterior;
REAL8 range=0.0;
int foundBurnin, loopMCMC, move, dim, i,j;
/* initialize the parameter structure */
parameter = *paraPtr;
inputMCMC->funcInit( parameter, inputMCMC->inspiralTable );
dim = parameter->dimension;
inputMCMC->dim = dim;
/* initialize the internal vectors */
for (paraHead=parameter->param; paraHead;
paraHead=paraHead->next)
{
paraHead->core->chain=NULL;
LALSCreateVector( &status, ¶Head->core->chain, inputMCMC->numberDraw+1);
}
/* initialize vectors in the MCMC structure */
LALSCreateVector( &status, &vector, dim);
inputMCMC->mean = (REAL8*)LALCalloc( sizeof(REAL8), dim );
inputMCMC->xdiff= (REAL8*)LALCalloc( sizeof(REAL8), dim );
inputMCMC->ndiff= (REAL8*)LALCalloc( sizeof(REAL8), dim );
/* prepare the gsl matrices */
startCovMat = gsl_matrix_alloc( dim, dim);
covMat = gsl_matrix_alloc( dim, dim);
/* set everything to zeros in the matrix */
for (i=0;i<dim;i++)
for (j=0;j<dim;j++)
gsl_matrix_set( startCovMat, i, j, 0.0 );
/* populate the startCovMat with initial values */
printf("populating the covariance matrix:\n");
for (paraHead=parameter->param,i=0; paraHead; paraHead=paraHead->next,i++)
{
range=paraHead->core->maxVal - paraHead->core->minVal;
gsl_matrix_set( startCovMat, i, i, 0.001*range*range );
printf("element %d: %f\n", i, 0.001*range*range);
}
gsl_matrix_memcpy( covMat, startCovMat );
/* initialize the state */
inputMCMC->counter=inputMCMC->counterState=inputMCMC->counterAccept=inputMCMC->counterAcceptDraw=0;
inputMCMC->burninCounter=0;
loopMCMC=1;
if (inputMCMC->useScaling)
{
state = doScaling;
inputMCMC->scaling = inputMCMC->scalePeak;
}
else if (inputMCMC->useAnnealing)
{
state = doAnnealing;
inputMCMC->scaling = inputMCMC->scaleNormal;
}
else
{
state = unknownState; /* TODO: error*/
printf("ERROR: unknown state\n");
exit(1);
}
/* get the first values */
inputMCMC->funcPrior( inputMCMC, parameter );
logLikelihood = inputMCMC->funcLikelihood( inputMCMC, parameter);
logPrior = parameter->logPrior;
currentLogPosterior=logLikelihood+logPrior;
do
{
/* increase the counters */
inputMCMC->counter++; /*k*/
inputMCMC->counterState++; /*c*/
/* print generel information */
printf("####################################################\n");
printf("\nMCMCSTATUS k: %d c: %d state: ",
inputMCMC->counter, inputMCMC->counterState);
printState( state);
printf("\n");
/* do the sampling from the underlying distribution */
move=XLALMCMCSample(inputMCMC, ¶meter, ¤tLogPosterior, covMat);
/* count the accepted moves */
if (move)
{
inputMCMC->counterAccept++;
}
/* ------------------------------
checking the burnin
------------------------------ */
if ( inputMCMC->flagBurnin && state == doScaling)
{
/* store the actual parameters in the chain structure */
for (paraHead=parameter->param; paraHead; paraHead=paraHead->next)
{
paraHead->core->chain->data[inputMCMC->burninCounter]= paraHead->value;
}
/* increase internal burnin counter */
inputMCMC->burninCounter++;
if ( inputMCMC->counterState>=inputMCMC->burninNumber &&
inputMCMC->burninCounter>=inputMCMC->burninStep )
{
/* reset internal burnin counter */
inputMCMC->burninCounter=0;
/* check if burnin found */
foundBurnin=XLALMCMCCheckBurnin( inputMCMC, parameter );
if (foundBurnin || inputMCMC->counterState >= inputMCMC->burninMaxNumber )
{
if (inputMCMC->verbose)
printf("MCMCINFO: Burnin period found at step %d."
"Moving to updating state.\n", inputMCMC->counter );
/* reset the counter */
inputMCMC->burninTime = inputMCMC->counter;
/* adjust scaling factor and the cov-matrix*/
inputMCMC->scaling = inputMCMC->scaleNormal;
gsl_matrix_scale( covMat, 0.20);
/* deactivate this algorithm and set the new state */
inputMCMC->flagBurnin=0;
state=doUpdating;
inputMCMC->counterState=0;
}
}
}
/* print content of the covariance matrix to screen
if verbose flag is set */
if (inputMCMC->verbose)
{
printMatrix( covMat, dim );
}
/* ------------------------------
updating the covariance matrix
------------------------------ */
if ( state == doUpdating )
{
/* check if enough iterations used here */
if ( inputMCMC->counterState < inputMCMC->updateNumber )
{
/* update the covariance matrix */
XLALMCMCCheckUpdate( inputMCMC, parameter, covMat );
}
else
{
/* move to the next state */
if (inputMCMC->verbose)
{
printf("MCMCINFO: Matrix updating complete at step %d. "
"Moving to drawing state. " \
"Content of the matrix: \n", inputMCMC->counter);
printMatrix(covMat, dim);
}
/* set drawing state after matrix updating is finished */
state = doDrawing;
inputMCMC->counterState=0;
}
}
/* ------------------------------
drawing the values from the chain, and store them
------------------------------ */
if ( state == doDrawing )
{
/* store the drawn values in the chain */
for (paraHead=parameter->param; paraHead; paraHead=paraHead->next)
{
paraHead->core->chain->data[inputMCMC->counterState]= paraHead->value;
}
/* check if end of loop is reached, i.e. if enough values has been drawn */
if ( inputMCMC->counterState == inputMCMC->numberDraw )
{
loopMCMC=0; /* ending condition for this loop */
}
}
/*if (inputMCMC->counterState>1000) loopMCMC=0;*/
} while( loopMCMC );
LALFree(inputMCMC->mean);
LALFree(inputMCMC->xdiff);
LALFree(inputMCMC->ndiff);
gsl_matrix_free(covMat);
gsl_matrix_free( startCovMat);
/* print some summary informations */
if ( inputMCMC->verbose>0 )
{
printf("MCMCINFO: Total number of iterations: %d , steps accepted: %d ( %.1f %% )\n",
inputMCMC->counter, inputMCMC->counterAccept,
100.0*(float)inputMCMC->counterAccept/(float)inputMCMC->counter );
printf("MCMCINFO: Number of draws used: %d, steps accepted: %d ( %.1f %%)\n",
inputMCMC->numberDraw, inputMCMC->counterAccept,
100.0*(float)inputMCMC->counterAccept/(float)inputMCMC->numberDraw );
}
/* set the correct pointer */
paraPtr= ¶meter;
}
/** The main function of binary2sft.c
*
*/
int main( int argc, char *argv[] ) {
UserInput_t uvar = empty_UserInput; /* user input variables */
INT4 i,j; /* counter */
SFTVector *SFTvect = NULL;
char *noisestr = XLALCalloc(1,sizeof(char));
/**********************************************************************************/
/* register and read all user-variables */
if (XLALReadUserVars(argc,argv,&uvar)) {
LogPrintf(LOG_CRITICAL,"%s : XLALReadUserVars() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_DEBUG,"%s : read in uservars\n",__func__);
/**********************************************************************************/
/* read in the cache file */
FILE *cachefp = NULL;
if ((cachefp = fopen(uvar.cachefile,"r")) == NULL) {
LogPrintf(LOG_CRITICAL,"%s : failed to open binary input file %s\n",__func__,uvar.cachefile);
return 1;
}
i = 0;
while (fscanf(cachefp,"%*s %*d %*d")!=EOF) i++;
INT4 Nfiles = i;
fclose(cachefp);
LogPrintf(LOG_DEBUG,"%s : counted %d files listed in the cache file.\n",__func__,Nfiles);
/* allocate memory */
char **filenames = LALCalloc(Nfiles,sizeof(char*));
LIGOTimeGPSVector fileStart;
fileStart.data = LALCalloc(Nfiles,sizeof(LIGOTimeGPS));
for (i=0;i<Nfiles;i++) filenames[i] = LALCalloc(512,sizeof(char));
if ((cachefp = fopen(uvar.cachefile,"r")) == NULL) {
LogPrintf(LOG_CRITICAL,"%s : failed to open binary input file %s\n",__func__,uvar.cachefile);
return 1;
}
for (i=0;i<Nfiles;i++) {
fscanf(cachefp,"%s %d %d %*d",filenames[i],&(fileStart.data[i].gpsSeconds),&(fileStart.data[i].gpsNanoSeconds));
}
fclose(cachefp);
/* initialise the random number generator */
gsl_rng * r;
if (XLALInitgslrand(&r,uvar.seed)) {
LogPrintf(LOG_CRITICAL,"%s: XLALinitgslrand() failed with error = %d\n",__func__,xlalErrno);
XLAL_ERROR(XLAL_EFAULT);
}
/* setup the binaryToSFT parameters */
BinaryToSFTparams par;
par.tsft = uvar.tsft;
par.freq = uvar.freq;
par.freqband = uvar.freqband;
par.tsamp = uvar.tsamp;
par.highpassf = uvar.highpassf;
par.amp_inj = uvar.amp_inj;
par.f_inj = uvar.f_inj;
par.asini_inj = uvar.asini_inj;
XLALGPSSetREAL8(&(par.tasc_inj),uvar.tasc_inj);
par.tref = fileStart.data[0];
par.P_inj = uvar.P_inj;
par.phi_inj = uvar.phi_inj;
par.r = r;
/**********************************************************************************/
/* loop over the input files */
long int ntot = 0;
for (j=0;j<Nfiles;j++) {
UINT4 k = 0;
INT8Vector *np = NULL;
REAL8Vector *R = NULL;
par.tstart = fileStart.data[j];
REAL8 norm1 = par.tsamp/par.tsft;
REAL8 norm2 = 1.0/(par.tsamp*par.tsft);
UINT4 oldlen;
if (SFTvect==NULL) oldlen = 0;
else oldlen = SFTvect->length;
LogPrintf(LOG_DEBUG,"%s : working on file %s\n",__func__,filenames[j]);
if (XLALBinaryToSFTVector(&SFTvect,filenames[j],&(fileStart.data[j]),&par,&np,&R)) {
LogPrintf(LOG_CRITICAL,"%s : failed to convert binary input file %s to sfts\n",__func__,filenames[j]);
return 1;
}
if ((np!=NULL) && (R!=NULL)) {
for (k=0;k<np->length;k++) {
ntot += np->data[k];
char temp[64];
sprintf(temp,"%d %e %e\n",SFTvect->data[oldlen+k].epoch.gpsSeconds,(REAL8)np->data[k]*norm1,R->data[k]*norm2);
noisestr = (char *)XLALRealloc(noisestr,sizeof(char)*(1+strlen(noisestr)+strlen(temp)));
strcat(noisestr,temp);
}
XLALDestroyINT8Vector(np);
XLALDestroyREAL8Vector(R);
}
} /* end loop over input files */
/**********************************************************************************/
/* create a noise string */
/**********************************************************************************/
/* generate comment string */
char *VCSInfoString = XLALGetVersionString(0);
XLAL_CHECK ( VCSInfoString != NULL, XLAL_EFUNC, "XLALGetVersionString(0) failed.\n" );
CHAR *logstr;
size_t len;
XLAL_CHECK ( (logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE )) != NULL, XLAL_EFUNC );
char *comment = XLALCalloc ( 1, len = strlen ( logstr ) + strlen(VCSInfoString) + strlen(noisestr) + 512 );
XLAL_CHECK ( comment != NULL, XLAL_ENOMEM, "XLALCalloc(1,%zd) failed.\n", len );
sprintf ( comment, "Generated by:\n%s\n%s\nTotal number of photons = %ld\n%s\n", logstr, VCSInfoString, ntot, noisestr );
/**********************************************************************************/
/* either write whole SFT-vector to single concatenated file */
if ( uvar.outSingleSFT ) {
XLAL_CHECK ( XLALWriteSFTVector2File( SFTvect, uvar.outputdir, comment, uvar.outLabel ) == XLAL_SUCCESS, XLAL_EFUNC );
} else { /* or as individual SFT-files */
XLAL_CHECK ( XLALWriteSFTVector2Dir( SFTvect, uvar.outputdir, comment, uvar.outLabel ) == XLAL_SUCCESS, XLAL_EFUNC );
}
/**********************************************************************************/
/* free memory */
XLALDestroySFTVector(SFTvect);
XLALFree(logstr);
XLALFree(comment);
XLALFree(noisestr);
LALCheckMemoryLeaks();
return 0;
}
/**
* \brief Provides an interface between code build from \ref lalinspiral_findchirp and
* various simulation packages for injecting chirps into data.
* \author Brown, D. A. and Creighton, T. D
*
* Injects the signals described
* in the linked list of \c SimInspiralTable structures \c events
* into the data \c chan. The response function \c resp should
* contain the response function to use when injecting the signals into the data.
*/
void
LALFindChirpInjectIMR (
LALStatus *status,
REAL4TimeSeries *chan,
SimInspiralTable *events,
SimRingdownTable *ringdownevents,
COMPLEX8FrequencySeries *resp,
INT4 injectSignalType
)
{
UINT4 k;
DetectorResponse detector;
SimInspiralTable *thisEvent = NULL;
SimRingdownTable *thisRingdownEvent = NULL;
PPNParamStruc ppnParams;
CoherentGW waveform, *wfm;
INT8 waveformStartTime;
REAL4TimeSeries signalvec;
COMPLEX8Vector *unity = NULL;
CHAR warnMsg[512];
#if 0
UINT4 n;
UINT4 i;
#endif
INITSTATUS(status);
ATTATCHSTATUSPTR( status );
ASSERT( chan, status,
FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( chan->data, status,
FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( chan->data->data, status,
FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( events, status,
FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( resp, status,
FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( resp->data, status,
FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( resp->data->data, status,
FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
/*
*
* set up structures and parameters needed
*
*/
/* fixed waveform injection parameters */
memset( &ppnParams, 0, sizeof(PPNParamStruc) );
ppnParams.deltaT = chan->deltaT;
ppnParams.lengthIn = 0;
ppnParams.ppn = NULL;
/*
*
* compute the transfer function from the given response function
*
*/
/* allocate memory and copy the parameters describing the freq series */
memset( &detector, 0, sizeof( DetectorResponse ) );
detector.transfer = (COMPLEX8FrequencySeries *)
LALCalloc( 1, sizeof(COMPLEX8FrequencySeries) );
if ( ! detector.transfer )
{
ABORT( status, FINDCHIRPH_EALOC, FINDCHIRPH_MSGEALOC );
}
memcpy( &(detector.transfer->epoch), &(resp->epoch),
sizeof(LIGOTimeGPS) );
detector.transfer->f0 = resp->f0;
detector.transfer->deltaF = resp->deltaF;
detector.site = (LALDetector *) LALMalloc( sizeof(LALDetector) );
/* set the detector site */
switch ( chan->name[0] )
{
case 'H':
*(detector.site) = lalCachedDetectors[LALDetectorIndexLHODIFF];
LALWarning( status, "computing waveform for Hanford." );
break;
case 'L':
*(detector.site) = lalCachedDetectors[LALDetectorIndexLLODIFF];
LALWarning( status, "computing waveform for Livingston." );
break;
case 'G':
*(detector.site) = lalCachedDetectors[LALDetectorIndexGEO600DIFF];
LALWarning( status, "computing waveform for GEO600." );
break;
case 'T':
*(detector.site) = lalCachedDetectors[LALDetectorIndexTAMA300DIFF];
LALWarning( status, "computing waveform for TAMA300." );
break;
case 'V':
*(detector.site) = lalCachedDetectors[LALDetectorIndexVIRGODIFF];
LALWarning( status, "computing waveform for Virgo." );
break;
default:
LALFree( detector.site );
detector.site = NULL;
LALWarning( status, "Unknown detector site, computing plus mode "
"waveform with no time delay" );
break;
}
/* set up units for the transfer function */
if (XLALUnitDivide( &(detector.transfer->sampleUnits),
&lalADCCountUnit, &lalStrainUnit ) == NULL) {
ABORTXLAL(status);
}
/* invert the response function to get the transfer function */
LALCCreateVector( status->statusPtr, &( detector.transfer->data ),
resp->data->length );
CHECKSTATUSPTR( status );
LALCCreateVector( status->statusPtr, &unity, resp->data->length );
CHECKSTATUSPTR( status );
for ( k = 0; k < resp->data->length; ++k )
{
unity->data[k] = 1.0;
}
LALCCVectorDivide( status->statusPtr, detector.transfer->data, unity,
resp->data );
CHECKSTATUSPTR( status );
LALCDestroyVector( status->statusPtr, &unity );
CHECKSTATUSPTR( status );
thisRingdownEvent = ringdownevents;
/*
*
* loop over the signals and inject them into the time series
*
*/
for ( thisEvent = events; thisEvent; thisEvent = thisEvent->next)
{
/*
*
* generate waveform and inject it into the data
*
*/
/* clear the waveform structure */
memset( &waveform, 0, sizeof(CoherentGW) );
LALGenerateInspiral(status->statusPtr, &waveform, thisEvent, &ppnParams);
CHECKSTATUSPTR( status );
/* add the ringdown */
wfm = XLALGenerateInspRing( &waveform, thisEvent, thisRingdownEvent,
injectSignalType );
if ( !wfm )
{
fprintf( stderr, "Failed to generate the waveform \n" );
if (xlalErrno == XLAL_EFAILED)
{
fprintf( stderr, "Too much merger\n");
XLALDestroyREAL4TimeSeries( chan );
xlalErrno = XLAL_SUCCESS;
return;
}
else exit ( 1 );
}
waveform = *wfm;
LALInfo( status, ppnParams.termDescription );
if ( thisEvent->geocent_end_time.gpsSeconds )
{
/* get the gps start time of the signal to inject */
waveformStartTime = XLALGPSToINT8NS( &(thisEvent->geocent_end_time) );
waveformStartTime -= (INT8) ( 1000000000.0 * ppnParams.tc );
}
else
{
LALInfo( status, "Waveform start time is zero: injecting waveform "
"into center of data segment" );
/* center the waveform in the data segment */
waveformStartTime = XLALGPSToINT8NS( &(chan->epoch) );
waveformStartTime += (INT8) ( 1000000000.0 *
((REAL8) (chan->data->length - ppnParams.length) / 2.0) * chan->deltaT
);
}
snprintf( warnMsg, sizeof(warnMsg)/sizeof(*warnMsg),
"Injected waveform timing:\n"
"thisEvent->geocent_end_time.gpsSeconds = %d\n"
"thisEvent->geocent_end_time.gpsNanoSeconds = %d\n"
"ppnParams.tc = %e\n"
"waveformStartTime = %" LAL_INT8_FORMAT "\n",
thisEvent->geocent_end_time.gpsSeconds,
thisEvent->geocent_end_time.gpsNanoSeconds,
ppnParams.tc,
waveformStartTime );
LALInfo( status, warnMsg );
/* clear the signal structure */
memset( &signalvec, 0, sizeof(REAL4TimeSeries) );
/* set the start times for injection */
XLALINT8NSToGPS( &(waveform.a->epoch), waveformStartTime );
memcpy( &(waveform.f->epoch), &(waveform.a->epoch),
sizeof(LIGOTimeGPS) );
memcpy( &(waveform.phi->epoch), &(waveform.a->epoch),
sizeof(LIGOTimeGPS) );
/* set the start time of the signal vector to the start time of the chan */
signalvec.epoch = chan->epoch;
/* set the parameters for the signal time series */
signalvec.deltaT = chan->deltaT;
if ( ( signalvec.f0 = chan->f0 ) != 0 )
{
ABORT( status, FINDCHIRPH_EHETR, FINDCHIRPH_MSGEHETR );
}
signalvec.sampleUnits = lalADCCountUnit;
/* simulate the detectors response to the inspiral */
LALSCreateVector( status->statusPtr, &(signalvec.data), chan->data->length );
CHECKSTATUSPTR( status );
LALSimulateCoherentGW( status->statusPtr,
&signalvec, &waveform, &detector );
CHECKSTATUSPTR( status );
/* *****************************************************************************/
#if 0
FILE *fp;
char fname[512];
UINT4 jj, kplus, kcross;
snprintf( fname, sizeof(fname) / sizeof(*fname),
"waveform-%d-%d-%s.txt",
thisEvent->geocent_end_time.gpsSeconds,
thisEvent->geocent_end_time.gpsNanoSeconds,
thisEvent->waveform );
fp = fopen( fname, "w" );
for( jj = 0, kplus = 0, kcross = 1; jj < waveform.phi->data->length;
++jj, kplus += 2, kcross +=2 )
{
fprintf(fp, "%d %e %e %le %e\n", jj,
waveform.a->data->data[kplus],
waveform.a->data->data[kcross],
waveform.phi->data->data[jj],
waveform.f->data->data[jj]);
}
fclose( fp );
#endif
/* ********************************************************************************/
#if 0
FILE *fp;
char fname[512];
UINT4 jj;
snprintf( fname, sizeof(fname) / sizeof(*fname),
"waveform-%d-%d-%s.txt",
thisEvent->geocent_end_time.gpsSeconds,
thisEvent->geocent_end_time.gpsNanoSeconds,
thisEvent->waveform );
fp = fopen( fname, "w" );
for( jj = 0; jj < signalvec.data->length; ++jj )
{
fprintf(fp, "%d %e %e \n", jj, signalvec.data->data[jj]);
}
fclose( fp );
#endif
/* ********************************************************************************/
/* inject the signal into the data channel */
LALSSInjectTimeSeries( status->statusPtr, chan, &signalvec );
CHECKSTATUSPTR( status );
/* allocate and go to next SimRingdownTable */
if( thisEvent->next )
thisRingdownEvent = thisRingdownEvent->next = (SimRingdownTable *)
calloc( 1, sizeof(SimRingdownTable) );
else
thisRingdownEvent->next = NULL;
/* destroy the signal */
LALSDestroyVector( status->statusPtr, &(signalvec.data) );
CHECKSTATUSPTR( status );
LALSDestroyVectorSequence( status->statusPtr, &(waveform.a->data) );
CHECKSTATUSPTR( status );
LALSDestroyVector( status->statusPtr, &(waveform.f->data) );
CHECKSTATUSPTR( status );
LALDDestroyVector( status->statusPtr, &(waveform.phi->data) );
CHECKSTATUSPTR( status );
if ( waveform.shift )
{
LALSDestroyVector( status->statusPtr, &(waveform.shift->data) );
CHECKSTATUSPTR( status );
}
LALFree( waveform.a );
LALFree( waveform.f );
LALFree( waveform.phi );
if ( waveform.shift )
{
LALFree( waveform.shift );
}
}
LALCDestroyVector( status->statusPtr, &( detector.transfer->data ) );
CHECKSTATUSPTR( status );
if ( detector.site ) LALFree( detector.site );
LALFree( detector.transfer );
DETATCHSTATUSPTR( status );
RETURN( status );
}
/**
* Main function for injecting numetrical relativity waveforms.
* Takes as input a list of injections, and adds h(t) to a given
* timeseries for a specified ifo and a dynamic range factor.
*/
void InjectNumRelWaveformsREAL8 (LALStatus *status, /**< pointer to LALStatus structure */
REAL8TimeSeries *chan, /**< [out] the output time series */
SimInspiralTable *injections, /**< [in] list of injections */
CHAR ifo[3], /**< [in] 2 char code for interferometer */
REAL8 freqLowCutoff, /**< [in] Lower cutoff frequency */
REAL8 snrLow, /**< [in] lower cutoff value of snr */
REAL8 snrHigh, /**< TO BE DOCUMENTED */
CHAR *fname) /**< [in] higher cutoff value of snr */
{
SimInspiralTable *thisInj = NULL;
REAL8 startFreq, startFreqHz, massTotal;
REAL8 thisSNR;
SimInspiralTable *simTableOut=NULL;
SimInspiralTable *thisInjOut=NULL;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
ASSERT( chan, status, INSPIRALH_ENULL, INSPIRALH_MSGENULL );
ASSERT( ifo, status, INSPIRALH_ENULL, INSPIRALH_MSGENULL );
/* loop over injections */
for ( thisInj = injections; thisInj; thisInj = thisInj->next )
{
startFreq = start_freq_from_frame_url(thisInj->numrel_data);
massTotal = (thisInj->mass1 + thisInj->mass2) * LAL_MTSUN_SI;
startFreqHz = startFreq / ( LAL_TWOPI * massTotal);
if (startFreqHz < freqLowCutoff)
{
REAL8TimeSeries *strain = NULL;
strain = XLALNRInjectionStrain(ifo, thisInj);
thisSNR = calculate_ligo_snr_from_strain_real8(strain, ifo);
/* set channel name */
snprintf( chan->name, LALNameLength * sizeof( CHAR ),
"%s:STRAIN", ifo );
if ((thisSNR < snrHigh) && (thisSNR > snrLow))
{
/* simTableOut will be null only the first time */
if ( simTableOut == NULL) {
simTableOut = (SimInspiralTable *)LALCalloc( 1, sizeof(SimInspiralTable) );
memcpy(simTableOut, thisInj, sizeof(*thisInj));
simTableOut->next = NULL;
thisInjOut = simTableOut;
}
else {
thisInjOut->next = (SimInspiralTable *)LALCalloc( 1, sizeof(SimInspiralTable) );
memcpy(thisInjOut->next, thisInj, sizeof(*thisInj));
thisInjOut->next->next = NULL;
thisInjOut = thisInjOut->next;
}
XLALSimAddInjectionREAL8TimeSeries( chan, strain, NULL);
}
XLALDestroyREAL8TimeSeries (strain);
}
} /* loop over injectionsj */
/* write and free the output simInspiral table */
if ( simTableOut ) {
LIGOLwXMLStream xmlfp;
MetadataTable dummyTable;
dummyTable.simInspiralTable = simTableOut;
/* write the xml table of actual injections */
memset( &xmlfp, 0, sizeof(LIGOLwXMLStream) );
TRY( LALOpenLIGOLwXMLFile( status->statusPtr, &xmlfp, fname ), status );
TRY( LALBeginLIGOLwXMLTable( status->statusPtr, &xmlfp, sim_inspiral_table ),
status );
TRY( LALWriteLIGOLwXMLTable( status->statusPtr, &xmlfp, dummyTable,
sim_inspiral_table ), status );
TRY( LALEndLIGOLwXMLTable ( status->statusPtr, &xmlfp ), status );
TRY( LALCloseLIGOLwXMLFile ( status->statusPtr, &xmlfp ), status );
}
while (simTableOut) {
thisInjOut = simTableOut;
simTableOut = simTableOut->next;
LALFree(thisInjOut);
}
DETATCHSTATUSPTR(status);
RETURN(status);
}
int main( int argc, char *argv[] )
{
LALStatus status = blank_status;
#if 0
const INT4 S2StartTime = 729273613; /* Feb 14 2003 16:00:00 UTC */
const INT4 S2StopTime = 734367613; /* Apr 14 2003 15:00:00 UTC */
#endif
/* command line options */
LIGOTimeGPS gpsStartTime = {S2StartTime, 0};
LIGOTimeGPS gpsEndTime = {S2StopTime, 0};
REAL8 meanTimeStep = 2630 / LAL_PI;
REAL8 timeInterval = 0;
UINT4 randSeed = 1;
CHAR *userTag = NULL;
REAL4 minMass = 3.0; /* minimum component mass */
REAL4 maxMass = 20.0; /* maximum component mass */
REAL4 sumMaxMass = 0.0; /* maximum total mass sum */
UINT4 sumMaxMassUse=0; /* flag indicating to use the sumMaxMass */
REAL4 dmin = 1.0; /* minimum distance from earth (kpc) */
REAL4 dmax = 20000.0 ; /* maximum distance from earth (kpc) */
REAL4 fLower = 0; /* default value for th lower cut off frequency */
/* REAL4 Rcore = 0.0; */
UINT4 ddistr = 0, mdistr=0;
/* program variables */
RandomParams *randParams = NULL;
REAL4 u, exponent, d2;
REAL4 deltaM, mtotal;
/* waveform */
CHAR waveform[LIGOMETA_WAVEFORM_MAX];
#if 0
int i, stat;
double d, cosphi, sinphi;
#endif
/* GalacticInspiralParamStruc galacticPar; */
/* xml output data */
CHAR fname[256];
MetadataTable proctable;
MetadataTable procparams;
MetadataTable injections;
ProcessParamsTable *this_proc_param;
SimInspiralTable *this_inj = NULL;
LIGOLwXMLStream xmlfp;
UINT4 outCompress = 0;
/* getopt arguments */
struct option long_options[] =
{
{"help", no_argument, 0, 'h'},
{"verbose", no_argument, &vrbflg, 1 },
{"write-compress", no_argument, &outCompress, 1 },
{"version", no_argument, 0, 'V'},
{"f-lower", required_argument, 0, 'f'},
{"gps-start-time", required_argument, 0, 'a'},
{"gps-end-time", required_argument, 0, 'b'},
{"time-step", required_argument, 0, 't'},
{"time-interval", required_argument, 0, 'i'},
{"seed", required_argument, 0, 's'},
{"min-mass", required_argument, 0, 'A'},
{"max-mass", required_argument, 0, 'B'},
{"max-total-mass", required_argument, 0, 'x'},
{"min-distance", required_argument, 0, 'p'},
{"max-distance", required_argument, 0, 'r'},
{"d-distr", required_argument, 0, 'd'},
{"m-distr", required_argument, 0, 'm'},
{"waveform", required_argument, 0, 'w'},
{"user-tag", required_argument, 0, 'Z'},
{"userTag", required_argument, 0, 'Z'},
{0, 0, 0, 0}
};
int c;
/* set up inital debugging values */
lal_errhandler = LAL_ERR_EXIT;
/* create the process and process params tables */
proctable.processTable = (ProcessTable *)
calloc( 1, sizeof(ProcessTable) );
XLALGPSTimeNow(&(proctable.processTable->start_time));
if (strcmp(CVS_REVISION,"$Revi" "sion$"))
{
XLALPopulateProcessTable(proctable.processTable,
PROGRAM_NAME, CVS_REVISION, CVS_SOURCE, CVS_DATE, 0);
}
else
{
XLALPopulateProcessTable(proctable.processTable,
PROGRAM_NAME, lalappsGitCommitID,
lalappsGitGitStatus,
lalappsGitCommitDate, 0);
}
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " );
this_proc_param = procparams.processParamsTable = (ProcessParamsTable *)
calloc( 1, sizeof(ProcessParamsTable) );
/* clear the waveform field */
memset( waveform, 0, LIGOMETA_WAVEFORM_MAX * sizeof(CHAR) );
/*
*
* parse command line arguments
*
*/
while ( 1 )
{
/* getopt_long stores long option here */
int option_index = 0;
long int gpsinput;
size_t optarg_len;
c = getopt_long_only( argc, argv,
"a:A:b:B:d:f:hi:m:p:q:r:s:t:vZ:w:", long_options, &option_index );
/* detect the end of the options */
if ( c == - 1 )
{
break;
}
switch ( c )
{
case 0:
/* if this option set a flag, do nothing else now */
if ( long_options[option_index].flag != 0 )
{
break;
}
else
{
fprintf( stderr, "error parsing option %s with argument %s\n",
long_options[option_index].name, optarg );
exit( 1 );
}
break;
case 'a':
gpsinput = atol( optarg );
if ( gpsinput < 441417609 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time is prior to "
"Jan 01, 1994 00:00:00 UTC:\n"
"(%ld specified)\n",
long_options[option_index].name, gpsinput );
exit( 1 );
}
gpsStartTime.gpsSeconds = gpsinput;
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "int",
"%ld", gpsinput );
break;
case 'b':
gpsinput = atol( optarg );
if ( gpsinput < 441417609 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time is prior to "
"Jan 01, 1994 00:00:00 UTC:\n"
"(%ld specified)\n",
long_options[option_index].name, gpsinput );
exit( 1 );
}
gpsEndTime.gpsSeconds = gpsinput;
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "int",
"%ld", gpsinput );
break;
case 'f':
fLower = atof( optarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "float",
"%f", fLower );
break;
case 's':
randSeed = atoi( optarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "int",
"%d", randSeed );
break;
case 't':
meanTimeStep = (REAL8) atof( optarg );
if ( meanTimeStep <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"time step must be > 0: (%e seconds specified)\n",
long_options[option_index].name, meanTimeStep );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "float",
"%e", meanTimeStep );
break;
case 'i':
timeInterval = atof( optarg );
if ( timeInterval < 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"time interval must be >= 0: (%e seconds specified)\n",
long_options[option_index].name, meanTimeStep );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", timeInterval );
break;
case 'A':
/* minimum component mass */
minMass = (REAL4) atof( optarg );
if ( minMass <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"miniumum component mass must be > 0: "
"(%f solar masses specified)\n",
long_options[option_index].name, minMass );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", minMass );
break;
case 'B':
/* maximum component mass */
maxMass = (REAL4) atof( optarg );
if ( maxMass <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"maxiumum component mass must be > 0: "
"(%f solar masses specified)\n",
long_options[option_index].name, maxMass );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", maxMass );
break;
case 'x':
/* maximum sum of components */
sumMaxMass = (REAL4) atof( optarg );
if ( sumMaxMass <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"sum of two component masses must be > 0: "
"(%f solar masses specified)\n",
long_options[option_index].name, sumMaxMass );
exit( 1 );
}
sumMaxMassUse=1;
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", sumMaxMass );
break;
case 'p':
/* minimum distance from earth */
dmin = (REAL4) atof( optarg );
if ( dmin <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"minimum distance must be > 0: "
"(%f kpc specified)\n",
long_options[option_index].name, dmin );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", dmin );
break;
case 'r':
/* max distance from earth */
dmax = (REAL4) atof( optarg );
if ( dmax <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"maximum distance must be greater than 0: "
"(%f kpc specified)\n",
long_options[option_index].name, dmax );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", dmax );
break;
case 'd':
ddistr = (UINT4) atoi( optarg );
if ( ddistr != 0 && ddistr != 1 && ddistr != 2)
{
fprintf( stderr, "invalid argument to --%s:\n"
"DDISTR must be either 0 or 1 or 2\n",
long_options[option_index].name);
exit(1);
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"int", "%d", ddistr );
break;
case 'm':
mdistr = (UINT4) atoi( optarg );
if ( mdistr != 0 && mdistr != 1 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"MDISTR must be either 0 or 1\n",
long_options[option_index].name);
exit(1);
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"int", "%d", mdistr );
break;
case 'Z':
/* create storage for the usertag */
optarg_len = strlen( optarg ) + 1;
userTag = (CHAR *) calloc( optarg_len, sizeof(CHAR) );
memcpy( userTag, optarg, optarg_len );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"string", "%s", optarg );
break;
case 'w':
snprintf( waveform, LIGOMETA_WAVEFORM_MAX, "%s", optarg);
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "string",
"%s", optarg);
break;
case 'V':
/* print version information and exit */
fprintf( stdout, "Binary Black Hole INJection generation routine\n"
"Duncan A Brown and Eirini Messaritaki\n"
"CVS Version: " CVS_ID_STRING "\n"
"CVS Tag: " CVS_NAME_STRING "\n" );
fprintf( stdout, lalappsGitID );
exit( 0 );
break;
case 'h':
case '?':
fprintf( stderr, USAGE );
exit( 0 );
break;
default:
fprintf( stderr, "unknown error while parsing options\n" );
fprintf( stderr, USAGE );
exit( 1 );
}
}
if ( optind < argc )
{
fprintf( stderr, "extraneous command line arguments:\n" );
while ( optind < argc )
{
fprintf ( stderr, "%s\n", argv[optind++] );
}
exit( 1 );
}
if ( !*waveform )
{
/* use EOBtwoPN as the default waveform */
snprintf( waveform, LIGOMETA_WAVEFORM_MAX, "EOBtwoPN");
}
if ( !fLower )
{
fprintf( stderr, "--f-lower must be specified and non-zero\n" );
exit( 1 );
}
/*
*
* initialization
*
*/
/* initialize the random number generator */
LAL_CALL( LALCreateRandomParams( &status, &randParams, randSeed ), &status );
/* mass range, per component */
deltaM = maxMass - minMass;
/* null out the head of the linked list */
injections.simInspiralTable = NULL;
/* create the output file name */
if ( userTag && outCompress )
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d_%s-%d-%d.xml.gz",
randSeed, userTag, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else if ( userTag && !outCompress )
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d_%s-%d-%d.xml",
randSeed, userTag, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else if ( !userTag && outCompress )
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d-%d-%d.xml.gz",
randSeed, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d-%d-%d.xml",
randSeed, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
/*
*
* loop over duration of desired output times
*
*/
while ( XLALGPSCmp( &gpsStartTime, &gpsEndTime ) < 0 )
{
/* rho, z and lGal are the galactocentric galactic axial coordinates */
/* r and phi are the geocentric galactic spherical coordinates */
#if 0
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
galacticPar.lGal = LAL_TWOPI * u;
galacticPar.z = r * sinphi ;
galacticPar.rho = 0.0 - Rcore * cos(galacticPar.lGal) +
sqrt( r * r - galacticPar.z * galacticPar.z -
Rcore * Rcore * sin(galacticPar.lGal) * sin(galacticPar.lGal) );
#endif
#if 0
if ( vrbflg ) fprintf( stdout, "%e %e %e %e %e\n",
galacticPar.m1, galacticPar.m2,
galacticPar.rho * cos( galacticPar.lGal ),
galacticPar.rho * sin( galacticPar.lGal ),
galacticPar.z );
#endif
/* create the sim_inspiral table */
if ( injections.simInspiralTable )
{
this_inj = this_inj->next = (SimInspiralTable *)
LALCalloc( 1, sizeof(SimInspiralTable) );
}
else
{
injections.simInspiralTable = this_inj = (SimInspiralTable *)
LALCalloc( 1, sizeof(SimInspiralTable) );
}
/* set the geocentric end time of the injection */
/* XXX CHECK XXX */
this_inj->geocent_end_time = gpsStartTime;
if ( timeInterval )
{
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
XLALGPSAdd( &(this_inj->geocent_end_time), u * timeInterval );
}
/* set gmst */
this_inj->end_time_gmst = fmod(XLALGreenwichMeanSiderealTime(
&this_inj->geocent_end_time), LAL_TWOPI) * 24.0 / LAL_TWOPI; /* hours */
if( XLAL_IS_REAL8_FAIL_NAN(this_inj->end_time_gmst) )
{
fprintf(stderr, "XLALGreenwichMeanSiderealTime() failed\n");
exit(1);
}
/* XXX END CHECK XXX */
/* populate the sim_inspiral table */
if (mdistr == 1)
/* uniformly distributed mass1 and uniformly distributed mass2 */
{
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->mass1 = minMass + u * deltaM;
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->mass2 = minMass + u * deltaM;
mtotal = this_inj->mass1 + this_inj->mass2 ;
this_inj->eta = this_inj->mass1 * this_inj->mass2 / ( mtotal * mtotal );
this_inj->mchirp = (this_inj->mass1 + this_inj->mass2) *
pow(this_inj->eta, 0.6);
}
else if (mdistr == 0)
/*uniformly distributed total mass */
{
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status);
mtotal = 2.0 * minMass + u * 2.0 *deltaM ;
if (sumMaxMassUse==1) {
while (mtotal > sumMaxMass) {
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status);
mtotal = 2.0 * minMass + u * 2.0 *deltaM ;
}
}
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->mass1 = minMass + u * deltaM;
this_inj->mass2 = mtotal - this_inj->mass1;
while (this_inj->mass1 >= mtotal ||
this_inj->mass2 >= maxMass || this_inj->mass2 <= minMass )
{
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->mass1 = minMass + u * deltaM;
this_inj->mass2 = mtotal - this_inj->mass1;
}
this_inj->eta = this_inj->mass1 * this_inj->mass2 / ( mtotal * mtotal );
this_inj->mchirp = (this_inj->mass1 + this_inj->mass2) *
pow(this_inj->eta, 0.6);
}
/* spatial distribution */
#if 0
LAL_CALL( LALUniformDeviate( &status, &u, randParams ),
&status );
sinphi = 2.0 * u - 1.0;
cosphi = sqrt( 1.0 - sinphi*sinphi );
#endif
if (ddistr == 0)
/* uniform distribution in distance */
{
REAL4 deltaD = dmax - dmin ;
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->distance = dmin + deltaD * u ;
}
else if (ddistr == 1)
/* uniform distribution in log(distance) */
{
REAL4 lmin = log10(dmin);
REAL4 lmax = log10(dmax);
REAL4 deltaL = lmax - lmin;
LAL_CALL( LALUniformDeviate(&status,&u,randParams),&status );
exponent = lmin + deltaL * u;
this_inj->distance = pow(10.0,(REAL4) exponent);
}
else if (ddistr == 2)
/* uniform volume distribution */
{
REAL4 d2min = pow(dmin,3.0) ;
REAL4 d2max = pow(dmax,3.0) ;
REAL4 deltad2 = d2max - d2min ;
LAL_CALL( LALUniformDeviate(&status,&u,randParams),&status );
d2 = d2min + u * deltad2 ;
this_inj->distance = pow(d2,1.0/3.0);
}
this_inj->distance = this_inj->distance / 1000.0; /*convert to Mpc */
/* compute random longitude and latitude */
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->latitude = asin( 2.0 * u - 1.0 ) ;
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->longitude = LAL_TWOPI * u ;
#if 0
LAL_CALL( LALGalacticInspiralParamsToSimInspiralTable( &status,
this_inj, &galacticPar, randParams ), &status );
if (vrbflg)
{
fprintf( stdout, "%e\n",
sqrt(galacticPar.z*galacticPar.z+galacticPar.rho*galacticPar.rho
+ Rcore*Rcore + 2.0*Rcore*galacticPar.rho*cos(galacticPar.lGal))-
this_inj->distance*1000.0);
}
#endif
/* set the source and waveform fields */
snprintf( this_inj->source, LIGOMETA_SOURCE_MAX, "???" );
memcpy( this_inj->waveform, waveform, LIGOMETA_WAVEFORM_MAX *
sizeof(CHAR));
/* XXX CHECK XXX */
/* compute random inclination, polarization and coalescence phase */
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->inclination = acos( 2.0 * u - 1.0 );
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->polarization = LAL_TWOPI * u ;
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->coa_phase = LAL_TWOPI * u ;
/* populate the site specific information */
LAL_CALL(LALPopulateSimInspiralSiteInfo( &status, this_inj ),
&status);
/* increment the injection time */
XLALGPSAdd( &gpsStartTime, meanTimeStep );
/* finally populate the flower */
if (fLower > 0)
{
this_inj->f_lower = fLower;
}
else
{
this_inj->f_lower = 0;
}
/* XXX END CHECK XXX */
} /* end loop over injection times */
/* destroy random parameters */
LAL_CALL( LALDestroyRandomParams( &status, &randParams ), &status );
/*
*
* write output to LIGO_LW XML file
*
*/
/* open the xml file */
memset( &xmlfp, 0, sizeof(LIGOLwXMLStream) );
LAL_CALL( LALOpenLIGOLwXMLFile( &status, &xmlfp, fname ), &status );
/* write the process table */
snprintf( proctable.processTable->ifos, LIGOMETA_IFOS_MAX, "H1H2L1" );
XLALGPSTimeNow(&(proctable.processTable->end_time));
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlfp, process_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlfp, proctable,
process_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlfp ), &status );
free( proctable.processTable );
/* free the unused process param entry */
this_proc_param = procparams.processParamsTable;
procparams.processParamsTable = procparams.processParamsTable->next;
free( this_proc_param );
/* write the process params table */
if ( procparams.processParamsTable )
{
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlfp, process_params_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlfp, procparams,
process_params_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlfp ), &status );
while( procparams.processParamsTable )
{
this_proc_param = procparams.processParamsTable;
procparams.processParamsTable = this_proc_param->next;
free( this_proc_param );
}
}
/* write the sim_inspiral table */
if ( injections.simInspiralTable )
{
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlfp, sim_inspiral_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlfp, injections,
sim_inspiral_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlfp ), &status );
}
while ( injections.simInspiralTable )
{
this_inj = injections.simInspiralTable;
injections.simInspiralTable = injections.simInspiralTable->next;
LALFree( this_inj );
}
/* close the injection file */
LAL_CALL( LALCloseLIGOLwXMLFile ( &status, &xmlfp ), &status );
/* check for memory leaks and exit */
LALCheckMemoryLeaks();
return 0;
}
int main(int argc, char *argv[]){
static LALStatus status;
static LALDetector *detector;
static LIGOTimeGPSVector timeV;
static REAL8Cart3CoorVector velV;
static REAL8Vector timeDiffV;
static REAL8 foft;
static HoughPulsarTemplate pulsarTemplate;
EphemerisData *edat = NULL;
CHAR *uvar_earthEphemeris = NULL;
CHAR *uvar_sunEphemeris = NULL;
SFTVector *inputSFTs = NULL;
REAL8 *alphaVec=NULL;
REAL8 *deltaVec=NULL;
REAL8 *freqVec=NULL;
REAL8 *spndnVec=NULL;
/* pgV is vector of peakgrams and pg1 is onepeakgram */
static UCHARPeakGram *pg1, **pgV;
UINT4 msp; /*number of spin-down parameters */
CHAR *uvar_ifo = NULL;
CHAR *uvar_sftDir = NULL; /* the directory where the SFT could be */
CHAR *uvar_fnameOut = NULL; /* The output prefix filename */
CHAR *uvar_fnameIn = NULL;
INT4 numberCount, ind;
UINT8 nTemplates;
UINT4 mObsCoh;
REAL8 uvar_peakThreshold;
REAL8 f_min, f_max, fWings, timeBase;
INT4 uvar_blocksRngMed;
UINT4 sftlength;
INT4 sftFminBin;
UINT4 loopId, tempLoopId;
FILE *fpOut = NULL;
CHAR *fnameLog=NULL;
FILE *fpLog = NULL;
CHAR *logstr=NULL;
/*REAL8 asq, bsq;*/ /* square of amplitude modulation functions a and b */
/******************************************************************/
/* Set up the default parameters. */
/* ****************************************************************/
/* LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
msp = 1; /*only one spin-down */
/* memory allocation for spindown */
pulsarTemplate.spindown.length = msp;
pulsarTemplate.spindown.data = NULL;
pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(msp*sizeof(REAL8));
uvar_peakThreshold = THRESHOLD;
uvar_earthEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_earthEphemeris,EARTHEPHEMERIS);
uvar_sunEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_sunEphemeris,SUNEPHEMERIS);
uvar_sftDir = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_sftDir,SFTDIRECTORY);
uvar_fnameOut = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_fnameOut,VALIDATEOUT);
uvar_fnameIn = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_fnameIn,VALIDATEIN);
uvar_blocksRngMed = BLOCKSRNGMED;
/* register user input variables */
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_ifo, "ifo", STRING, 'i', OPTIONAL, "Detector GEO(1) LLO(2) LHO(3)" ) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_earthEphemeris, "earthEphemeris", STRING, 'E', OPTIONAL, "Earth Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sunEphemeris, "sunEphemeris", STRING, 'S', OPTIONAL, "Sun Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sftDir, "sftDir", STRING, 'D', OPTIONAL, "SFT Directory") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameIn, "fnameIn", STRING, 'T', OPTIONAL, "Input template file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameOut, "fnameOut", STRING, 'o', OPTIONAL, "Output filename") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_blocksRngMed, "blocksRngMed", INT4, 'w', OPTIONAL, "RngMed block size") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_peakThreshold, "peakThreshold", REAL8, 't', OPTIONAL, "Peak selection threshold") == XLAL_SUCCESS, XLAL_EFUNC);
/* read all command line variables */
BOOLEAN should_exit = 0;
XLAL_CHECK_MAIN( XLALUserVarReadAllInput(&should_exit, argc, argv, lalAppsVCSInfoList) == XLAL_SUCCESS, XLAL_EFUNC);
if (should_exit)
exit(1);
/* open log file for writing */
fnameLog = LALCalloc( (strlen(uvar_fnameOut) + strlen(".log") + 10),1);
strcpy(fnameLog,uvar_fnameOut);
strcat(fnameLog,".log");
if ((fpLog = fopen(fnameLog, "w")) == NULL) {
fprintf(stderr, "Unable to open file %s for writing\n", fnameLog);
LALFree(fnameLog);
exit(1);
}
/* get the log string */
XLAL_CHECK_MAIN( ( logstr = XLALUserVarGetLog(UVAR_LOGFMT_CFGFILE) ) != NULL, XLAL_EFUNC);
fprintf( fpLog, "## Log file for HoughValidate\n\n");
fprintf( fpLog, "# User Input:\n");
fprintf( fpLog, "#-------------------------------------------\n");
fprintf( fpLog, "%s", logstr);
LALFree(logstr);
/* append an ident-string defining the exact CVS-version of the code used */
{
CHAR command[1024] = "";
fprintf (fpLog, "\n\n# CVS-versions of executable:\n");
fprintf (fpLog, "# -----------------------------------------\n");
fclose (fpLog);
sprintf (command, "ident %s | sort -u >> %s", argv[0], fnameLog);
/* we don't check this. If it fails, we assume that */
/* one of the system-commands was not available, and */
/* therefore the CVS-versions will not be logged */
if ( system(command) ) fprintf (stderr, "\nsystem('%s') returned non-zero status!\n\n", command );
LALFree(fnameLog);
}
/* open output file for writing */
fpOut= fopen(uvar_fnameOut, "w");
/*setlinebuf(fpOut);*/ /* line buffered on */
setvbuf(fpOut, (char *)NULL, _IOLBF, 0);
/*****************************************************************/
/* read template file */
/*****************************************************************/
{
FILE *fpIn = NULL;
INT4 r;
REAL8 temp1, temp2, temp3, temp4, temp5;
UINT8 templateCounter;
fpIn = fopen(uvar_fnameIn, "r");
if ( !fpIn )
{
fprintf(stderr, "Unable to fine file %s\n", uvar_fnameIn);
return DRIVEHOUGHCOLOR_EFILE;
}
nTemplates = 0;
do
{
r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, &temp2, &temp3, &temp4, &temp5);
/* make sure the line has the right number of entries or is EOF */
if (r==5) nTemplates++;
} while ( r != EOF);
rewind(fpIn);
alphaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
deltaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
freqVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
spndnVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
for (templateCounter = 0; templateCounter < nTemplates; templateCounter++)
{
r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, alphaVec + templateCounter, deltaVec + templateCounter,
freqVec + templateCounter, spndnVec + templateCounter);
}
fclose(fpIn);
}
/**************************************************/
/* read sfts */
/*************************************************/
f_min = freqVec[0]; /* initial frequency to be analyzed */
/* assume that the last frequency in the templates file is also the highest frequency */
f_max = freqVec[nTemplates-1] ;
/* we need to add wings to fmin and fmax to account for
the Doppler shift, the size of the rngmed block size
and also nfsizecylinder. The block size and nfsizecylinder are
specified in terms of frequency bins...this goes as one of the arguments of
LALReadSFTfiles */
/* first correct for Doppler shift */
fWings = f_max * VTOT;
f_min -= fWings;
f_max += fWings;
/* create pattern to look for in SFT directory */
{
CHAR *tempDir = NULL;
SFTCatalog *catalog = NULL;
static SFTConstraints constraints;
/* set detector constraint */
constraints.detector = NULL;
if ( XLALUserVarWasSet( &uvar_ifo ) )
constraints.detector = XLALGetChannelPrefix ( uvar_ifo );
/* get sft catalog */
tempDir = (CHAR *)LALCalloc(512, sizeof(CHAR));
strcpy(tempDir, uvar_sftDir);
strcat(tempDir, "/*SFT*.*");
XLAL_CHECK_MAIN( ( catalog = XLALSFTdataFind( tempDir, &constraints) ) != NULL, XLAL_EFUNC);
detector = XLALGetSiteInfo( catalog->data[0].header.name);
mObsCoh = catalog->length;
timeBase = 1.0 / catalog->data->header.deltaF;
XLAL_CHECK_MAIN( ( inputSFTs = XLALLoadSFTs ( catalog, f_min, f_max) ) != NULL, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALNormalizeSFTVect( inputSFTs, uvar_blocksRngMed, 0.0 ) == XLAL_SUCCESS, XLAL_EFUNC);
if ( XLALUserVarWasSet( &uvar_ifo ) )
LALFree( constraints.detector );
LALFree( tempDir);
XLALDestroySFTCatalog(catalog );
}
sftlength = inputSFTs->data->data->length;
{
INT4 tempFbin;
sftFminBin = floor( (REAL4)(timeBase * inputSFTs->data->f0) + (REAL4)(0.5));
tempFbin = floor( timeBase * inputSFTs->data->f0 + 0.5);
if (tempFbin - sftFminBin)
{
fprintf(stderr, "Rounding error in calculating fminbin....be careful! \n");
}
}
/* loop over sfts and select peaks */
/* first the memory allocation for the peakgramvector */
pgV = NULL;
pgV = (UCHARPeakGram **)LALMalloc(mObsCoh*sizeof(UCHARPeakGram *));
/* memory for peakgrams */
for (tempLoopId=0; tempLoopId < mObsCoh; tempLoopId++)
{
pgV[tempLoopId] = (UCHARPeakGram *)LALMalloc(sizeof(UCHARPeakGram));
pgV[tempLoopId]->length = sftlength;
pgV[tempLoopId]->data = NULL;
pgV[tempLoopId]->data = (UCHAR *)LALMalloc(sftlength* sizeof(UCHAR));
LAL_CALL (SFTtoUCHARPeakGram( &status, pgV[tempLoopId], inputSFTs->data + tempLoopId, uvar_peakThreshold), &status);
}
/* having calculated the peakgrams we don't need the sfts anymore */
XLALDestroySFTVector( inputSFTs);
/* ****************************************************************/
/* setting timestamps vector */
/* ****************************************************************/
timeV.length = mObsCoh;
timeV.data = NULL;
timeV.data = (LIGOTimeGPS *)LALMalloc(mObsCoh*sizeof(LIGOTimeGPS));
{
UINT4 j;
for (j=0; j < mObsCoh; j++){
timeV.data[j].gpsSeconds = pgV[j]->epoch.gpsSeconds;
timeV.data[j].gpsNanoSeconds = pgV[j]->epoch.gpsNanoSeconds;
}
}
/******************************************************************/
/* compute the time difference relative to startTime for all SFTs */
/******************************************************************/
timeDiffV.length = mObsCoh;
timeDiffV.data = NULL;
timeDiffV.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8));
{
REAL8 t0, ts, tn, midTimeBase;
UINT4 j;
midTimeBase=0.5*timeBase;
ts = timeV.data[0].gpsSeconds;
tn = timeV.data[0].gpsNanoSeconds * 1.00E-9;
t0=ts+tn;
timeDiffV.data[0] = midTimeBase;
for (j=1; j< mObsCoh; ++j){
ts = timeV.data[j].gpsSeconds;
tn = timeV.data[j].gpsNanoSeconds * 1.00E-9;
timeDiffV.data[j] = ts + tn -t0 + midTimeBase;
}
}
/******************************************************************/
/* compute detector velocity for those time stamps */
/******************************************************************/
velV.length = mObsCoh;
velV.data = NULL;
velV.data = (REAL8Cart3Coor *)LALMalloc(mObsCoh*sizeof(REAL8Cart3Coor));
{
VelocityPar velPar;
REAL8 vel[3];
UINT4 j;
velPar.detector = *detector;
velPar.tBase = timeBase;
velPar.vTol = ACCURACY;
velPar.edat = NULL;
/* read in ephemeris data */
XLAL_CHECK_MAIN( ( edat = XLALInitBarycenter( uvar_earthEphemeris, uvar_sunEphemeris ) ) != NULL, XLAL_EFUNC);
velPar.edat = edat;
/* now calculate average velocity */
for(j=0; j< velV.length; ++j){
velPar.startTime.gpsSeconds = timeV.data[j].gpsSeconds;
velPar.startTime.gpsNanoSeconds = timeV.data[j].gpsNanoSeconds;
LAL_CALL( LALAvgDetectorVel ( &status, vel, &velPar), &status );
velV.data[j].x= vel[0];
velV.data[j].y= vel[1];
velV.data[j].z= vel[2];
}
}
/* amplitude modulation stuff */
{
AMCoeffs XLAL_INIT_DECL(amc);
AMCoeffsParams *amParams;
EarthState earth;
BarycenterInput baryinput; /* Stores detector location and other barycentering data */
/* detector location */
baryinput.site.location[0] = detector->location[0]/LAL_C_SI;
baryinput.site.location[1] = detector->location[1]/LAL_C_SI;
baryinput.site.location[2] = detector->location[2]/LAL_C_SI;
baryinput.dInv = 0.e0;
/* alpha and delta must come from the skypatch */
/* for now set it to something arbitrary */
baryinput.alpha = 0.0;
baryinput.delta = 0.0;
/* Allocate space for amParams stucture */
/* Here, amParams->das is the Detector and Source info */
amParams = (AMCoeffsParams *)LALMalloc(sizeof(AMCoeffsParams));
amParams->das = (LALDetAndSource *)LALMalloc(sizeof(LALDetAndSource));
amParams->das->pSource = (LALSource *)LALMalloc(sizeof(LALSource));
/* Fill up AMCoeffsParams structure */
amParams->baryinput = &baryinput;
amParams->earth = &earth;
amParams->edat = edat;
amParams->das->pDetector = detector;
/* make sure alpha and delta are correct */
amParams->das->pSource->equatorialCoords.latitude = baryinput.delta;
amParams->das->pSource->equatorialCoords.longitude = baryinput.alpha;
amParams->das->pSource->orientation = 0.0;
amParams->das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
amParams->polAngle = amParams->das->pSource->orientation ; /* These two have to be the same!!*/
/* timeV is start time ---> change to mid time */
LAL_CALL (LALComputeAM(&status, &amc, timeV.data, amParams), &status);
/* calculate a^2 and b^2 */
/* for (ii=0, asq=0.0, bsq=0.0; ii<mObsCoh; ii++) */
/* { */
/* REAL8 *a, *b; */
/* a = amc.a + ii; */
/* b = amc.b + ii; */
/* asq += (*a) * (*a); */
/* bsq += (*b) * (*b); */
/* } */
/* free amParams */
LALFree(amParams->das->pSource);
LALFree(amParams->das);
LALFree(amParams);
}
/* loop over templates */
for(loopId=0; loopId < nTemplates; ++loopId){
/* set template parameters */
pulsarTemplate.f0 = freqVec[loopId];
pulsarTemplate.longitude = alphaVec[loopId];
pulsarTemplate.latitude = deltaVec[loopId];
pulsarTemplate.spindown.data[0] = spndnVec[loopId];
{
REAL8 f0new, vcProdn, timeDiffN;
REAL8 sourceDelta, sourceAlpha, cosDelta, factorialN;
UINT4 j, i, f0newBin;
REAL8Cart3Coor sourceLocation;
sourceDelta = pulsarTemplate.latitude;
sourceAlpha = pulsarTemplate.longitude;
cosDelta = cos(sourceDelta);
sourceLocation.x = cosDelta* cos(sourceAlpha);
sourceLocation.y = cosDelta* sin(sourceAlpha);
sourceLocation.z = sin(sourceDelta);
/* loop for all different time stamps,calculate frequency and produce number count*/
/* first initialize number count */
numberCount=0;
for (j=0; j<mObsCoh; ++j)
{
/* calculate v/c.n */
vcProdn = velV.data[j].x * sourceLocation.x
+ velV.data[j].y * sourceLocation.y
+ velV.data[j].z * sourceLocation.z;
/* loop over spindown values to find f_0 */
f0new = pulsarTemplate.f0;
factorialN = 1.0;
timeDiffN = timeDiffV.data[j];
for (i=0; i<msp;++i)
{
factorialN *=(i+1.0);
f0new += pulsarTemplate.spindown.data[i]*timeDiffN / factorialN;
timeDiffN *= timeDiffN;
}
f0newBin = floor(f0new*timeBase + 0.5);
foft = f0newBin * (1.0 +vcProdn) / timeBase;
/* get the right peakgram */
pg1 = pgV[j];
/* calculate frequency bin for template */
ind = floor( foft * timeBase + 0.5 ) - sftFminBin;
/* update the number count */
numberCount+=pg1->data[ind];
}
} /* end of block calculating frequency path and number count */
/******************************************************************/
/* printing result in the output file */
/******************************************************************/
fprintf(fpOut,"%d %f %f %f %g \n",
numberCount, pulsarTemplate.longitude, pulsarTemplate.latitude, pulsarTemplate.f0,
pulsarTemplate.spindown.data[0] );
} /* end of loop over templates */
/******************************************************************/
/* Closing files */
/******************************************************************/
fclose(fpOut);
/******************************************************************/
/* Free memory and exit */
/******************************************************************/
LALFree(alphaVec);
LALFree(deltaVec);
LALFree(freqVec);
LALFree(spndnVec);
for (tempLoopId = 0; tempLoopId < mObsCoh; tempLoopId++){
pg1 = pgV[tempLoopId];
LALFree(pg1->data);
LALFree(pg1);
}
LALFree(pgV);
LALFree(timeV.data);
LALFree(timeDiffV.data);
LALFree(velV.data);
LALFree(pulsarTemplate.spindown.data);
XLALDestroyEphemerisData(edat);
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return DRIVEHOUGHCOLOR_ENORM;
}
void
LALFindChirpCreateCoherentInput(
LALStatus *status,
COMPLEX8TimeSeries **coherentInputData,
COMPLEX8TimeSeries *input,
SnglInspiralTable *templt,
REAL4 coherentSegmentLength,/*in seconds*/
INT4 corruptedDataLength /*in timepoints */
)
{
COMPLEX8TimeSeries *cohInputData = NULL;
LIGOTimeGPS end_time;
INT4 numPoints = 0;
REAL4 cohSegLength = 0.0;
INT4 inputEpochSeconds = 0;
INT4 inputEpochNanoSeconds = 0;
REAL8 deltaT = 0.0;
REAL8 intpart = 0.0;
REAL8 fracpart = 0.0;
REAL8 tempTime = 0.0;
INT4 crupDataLength = 0;
INT4 UNUSED cohSegEnd = 0;
INT4 cohSegStart = 0;
INT4 nonCorruptEnd = 0;
INT4 nonCorruptStart = 0;
/*INT4 overlap = 0;*/
INT4 fullCohSegLength = 0;
INT4 eventTimePoint = 0;
INITSTATUS(status);
ATTATCHSTATUSPTR( status );
/* Ensure that arguments are reasonable */
/* check that the output handle exists, but points to a null pointer */
ASSERT( coherentInputData, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( !*coherentInputData, status, FINDCHIRPH_ENNUL, FINDCHIRPH_MSGENNUL );
/* check that a valid COMPLEX8TimeSeries is input */
ASSERT( input, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( input->data, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( input->data->data, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( input->deltaT > 0, status, FINDCHIRPH_EDTZO, FINDCHIRPH_MSGEDTZO );
ASSERT( input->epoch.gpsSeconds > 0, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( input->epoch.gpsNanoSeconds >= 0, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( input->data->length, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
/* check that a valid snglInspiralTable is input */
ASSERT( templt, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( templt->end.gpsSeconds > 0, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
ASSERT( templt->end.gpsNanoSeconds >= 0, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL );
/* check for valid lengths */
ASSERT( coherentSegmentLength > 0, status, FINDCHIRPH_ENUMZ, FINDCHIRPH_MSGENUMZ );
ASSERT( corruptedDataLength >= 0, status, FINDCHIRPH_ENUMZ, FINDCHIRPH_MSGENUMZ );
/* Get necessary info from input structures */
end_time = templt->end;
numPoints = input->data->length;
cohSegLength = coherentSegmentLength;
inputEpochSeconds = input->epoch.gpsSeconds;
inputEpochNanoSeconds = input->epoch.gpsNanoSeconds;
deltaT = input->deltaT;
crupDataLength = corruptedDataLength;
/* Now determine if the event lies in corrupted data */
nonCorruptStart = crupDataLength;
nonCorruptEnd = numPoints - crupDataLength;
cohSegStart = (INT4) rint( ((end_time.gpsSeconds + end_time.gpsNanoSeconds*1.0e-9) - (inputEpochSeconds + inputEpochNanoSeconds*1.0e-9)-cohSegLength)/deltaT - 1.0);
cohSegEnd = cohSegStart + 2* (INT4)cohSegLength/deltaT + 1;
eventTimePoint = (INT4) rint( ((end_time.gpsSeconds + end_time.gpsNanoSeconds*1.0e-9) - (inputEpochSeconds + inputEpochNanoSeconds*1.0e-9))/deltaT - 1.0);
if( eventTimePoint < nonCorruptEnd && eventTimePoint >= nonCorruptStart )
{
/* The coherent chunk is outside of the corrupted data */
cohInputData = *coherentInputData = (COMPLEX8TimeSeries *)
LALCalloc(1, sizeof(COMPLEX8TimeSeries) );
fullCohSegLength = 2*cohSegLength/deltaT;
LALCCreateVector(status->statusPtr, &(cohInputData->data), fullCohSegLength);
CHECKSTATUSPTR( status );
/* store C-data snippet and its associated info */
memcpy(cohInputData->name, input->name, LALNameLength * sizeof(CHAR) );
memcpy(cohInputData->data->data, &(input->data->data[cohSegStart]), fullCohSegLength * sizeof(COMPLEX8) );
cohInputData->deltaT = deltaT;
/*CHECK: Below is a temporary fix for communicating sigmasq
from inspiral to coherent_inspiral via the f0 member of
the COMPLEX8TimeSeries structure*/
cohInputData->f0 = (REAL8) templt->sigmasq;
tempTime = inputEpochSeconds + inputEpochNanoSeconds*1.0e-9 + cohSegStart * deltaT;
fracpart = modf(tempTime, &intpart);
cohInputData->epoch.gpsSeconds = (INT4) intpart;
cohInputData->epoch.gpsNanoSeconds = (INT4) (fracpart*1.0e9);
}
else
{
/* return a null pointer cohInputData */
}
/* normal exit */
DETATCHSTATUSPTR( status );
RETURN( status );
}
int
XLALAddNumRelStrainModesREAL8(
REAL8TimeSeries **seriesPlus, /**< [out] h+, hx data */
REAL8TimeSeries **seriesCross, /**< [out] h+, hx data */
SimInspiralTable *thisinj /**< [in] injection data */
)
{
INT4 modeL, modeM, modeLlo, modeLhi;
INT4 len, lenPlus, lenCross, k;
CHAR *channel_name_plus;
CHAR *channel_name_cross;
LALFrStream *frStream = NULL;
LALCache frCache;
LIGOTimeGPS epoch;
REAL8TimeSeries *modePlus=NULL;
REAL8TimeSeries *modeCross=NULL;
REAL8 massMpc, timeStep;
modeLlo = thisinj->numrel_mode_min;
modeLhi = thisinj->numrel_mode_max;
/* create a frame cache and open the frame stream */
frCache.length = 1;
frCache.list = LALCalloc(1, sizeof(frCache.list[0]));
frCache.list[0].url = thisinj->numrel_data;
frStream = XLALFrStreamCacheOpen( &frCache );
/* the total mass of the binary in Mpc */
massMpc = (thisinj->mass1 + thisinj->mass2) * LAL_MRSUN_SI / ( LAL_PC_SI * 1.0e6);
/* Time step in dimensionful units */
timeStep = (thisinj->mass1 + thisinj->mass2) * LAL_MTSUN_SI;
/* start time of waveform -- set it to something */
epoch.gpsSeconds = thisinj->geocent_end_time.gpsSeconds;
epoch.gpsNanoSeconds = thisinj->geocent_end_time.gpsNanoSeconds;
/* loop over l values */
for ( modeL = modeLlo; modeL <= modeLhi; modeL++ ) {
/* loop over m values */
for ( modeM = -modeL; modeM <= modeL; modeM++ ) {
/* read numrel waveform */
/* first the plus polarization */
channel_name_plus = XLALGetNinjaChannelName("plus", modeL, modeM);
/*get number of data points */
if (XLALCheckFrameHasChannel(channel_name_plus, frStream ) )
{
lenPlus = XLALFrStreamGetVectorLength ( channel_name_plus, frStream );
}
else
{
lenPlus = -1;
}
/* now the cross polarization */
channel_name_cross = XLALGetNinjaChannelName("cross", modeL, modeM);
/*get number of data points */
if (XLALCheckFrameHasChannel(channel_name_cross, frStream ) )
{
lenCross = XLALFrStreamGetVectorLength ( channel_name_cross, frStream );
}
else
{
lenCross = -1;
}
/* skip on to next mode if mode doesn't exist */
if ( (lenPlus <= 0) || (lenCross <= 0) || (lenPlus != lenCross) ) {
XLALClearErrno();
LALFree(channel_name_plus);
LALFree(channel_name_cross);
continue;
}
/* note: lenPlus and lenCross must be equal if we got this far*/
len = lenPlus;
/* allocate and read the plus/cross time series */
modePlus = XLALCreateREAL8TimeSeries ( channel_name_plus, &epoch, 0, 0, &lalDimensionlessUnit, len);
memset(modePlus->data->data, 0, modePlus->data->length*sizeof(REAL8));
XLALFrStreamGetREAL8TimeSeries ( modePlus, frStream );
XLALFrStreamRewind( frStream );
LALFree(channel_name_plus);
modeCross = XLALCreateREAL8TimeSeries ( channel_name_cross, &epoch, 0, 0, &lalDimensionlessUnit, len);
memset(modeCross->data->data, 0, modeCross->data->length*sizeof(REAL8));
XLALFrStreamGetREAL8TimeSeries ( modeCross, frStream );
XLALFrStreamRewind( frStream );
LALFree(channel_name_cross);
/* scale and add */
if (*seriesPlus == NULL) {
*seriesPlus = XLALCreateREAL8TimeSeries ( "hplus", &epoch, 0, 0, &lalDimensionlessUnit, len);
memset((*seriesPlus)->data->data, 0, (*seriesPlus)->data->length*sizeof(REAL8));
(*seriesPlus)->deltaT = modePlus->deltaT;
}
if (*seriesCross == NULL) {
*seriesCross = XLALCreateREAL8TimeSeries ( "hcross", &epoch, 0, 0, &lalDimensionlessUnit, len);
memset((*seriesCross)->data->data, 0, (*seriesCross)->data->length*sizeof(REAL8));
(*seriesCross)->deltaT = modeCross->deltaT;
}
XLALOrientNRWaveTimeSeriesREAL8( modePlus, modeCross, modeL, modeM, thisinj->inclination, thisinj->coa_phase );
for (k = 0; k < len; k++) {
(*seriesPlus)->data->data[k] += massMpc * modePlus->data->data[k];
(*seriesCross)->data->data[k] += massMpc * modeCross->data->data[k];
}
/* we are done with seriesPlus and Cross for this iteration */
XLALDestroyREAL8TimeSeries (modePlus);
XLALDestroyREAL8TimeSeries (modeCross);
} /* end loop over modeM values */
} /* end loop over modeL values */
(*seriesPlus)->deltaT *= timeStep;
(*seriesCross)->deltaT *= timeStep;
XLALFrStreamClose( frStream );
LALFree(frCache.list);
return XLAL_SUCCESS;
}
int main( int argc, char *argv[] )
{
static LALStatus status;
UINT4 loop = 0; /* loop counter */
Math3DPointList *list = NULL; /* structure for mathematica plot */
Math3DPointList *first = NULL;
SnglInspiralTable *bankHead = NULL;
SnglInspiralTable *tmplt = NULL;
InspiralCoarseBankIn coarseIn;
INT4 ntiles = 0; /* number of tiles */
INT2 Math3DPlot = 0; /* option flag for Mathematica plot */
INT4 opt = 0; /* returning value of LALgetopt() */
INT4 optflag = -1; /* Command Line option */
REAL8Vector *psd = NULL;
REAL8 df = 1.0;
InspiralTemplate inspiralTemplate;
REAL4 noiseMin = 1;
BOOLEAN haveXML = 0;
if( (list = (Math3DPointList *) LALCalloc( 1, sizeof( Math3DPointList )))
== NULL )
{
LALError( &status, INSPIRALSPINBANKTESTC_MSGEMEM );
printf( INSPIRALSPINBANKTESTC_MSGEMEM );
return INSPIRALSPINBANKTESTC_EMEM;
}
first = list;
/* Stuff for calculating the PSD and Noise Moments */
coarseIn.fLower = inspiralTemplate.fLower = 30;
coarseIn.fUpper = inspiralTemplate.fCutoff = 2000;
coarseIn.iflso = 0;
/* Parse options. */
do
{
optflag++;
switch (opt)
{
case 'b':
#if LAL_METAIO_ENABLED
if( (ntiles = LALSnglInspiralTableFromLIGOLw( &bankHead, LALoptarg, 1,
20000)) < 1 )
{
fprintf( stderr, INSPIRALSPINBANKTESTC_MSGEFILE );
return INSPIRALSPINBANKTESTC_EFILE;
}
haveXML = 1;
#endif
break;
case 'm':
coarseIn.mmCoarse = atof( LALoptarg );
break;
case 'n':
coarseIn.mMin = atof( LALoptarg );
break;
case 'p':
Math3DPlot = 1;
break;
case 's':
break;
case 'x':
coarseIn.MMax = atof( LALoptarg );
break;
default:
coarseIn.mmCoarse = 0.1;
coarseIn.mMin = 1.0;
coarseIn.MMax = 2*3.0;
Math3DPlot = 0;
break;
}
}
while( (opt = LALgetopt( argc, argv, "b:n:m:x:ps" )) != -1 );
/* Generate template bank from model noise if not given an XML file. */
if( !haveXML )
{
coarseIn.shf.data = NULL;
memset( &(coarseIn.shf), 0, sizeof( REAL8FrequencySeries ) );
coarseIn.shf.f0 = 0;
LALDCreateVector( &status, &psd, coarseIn.fUpper );
df = 1.0;
LALNoiseSpectralDensity( &status, psd, &LALLIGOIPsd, df );
coarseIn.shf.data = psd;
coarseIn.shf.deltaF = df;
for( loop = 0; loop < psd->length; loop++ )
{
if( psd->data[loop] > 0 && psd->data[loop] < noiseMin )
{
noiseMin = psd->data[loop];
}
}
LALInspiralSpinBank( &status, &bankHead, &ntiles, &coarseIn );
if( status.statusCode )
{
LALError( &status, INSPIRALSPINBANKTESTC_MSGESUB );
printf( INSPIRALSPINBANKTESTC_MSGESUB );
return INSPIRALSPINBANKTESTC_ESUB;
}
}
/* Convert template bank structure to plot input structure. */
if( Math3DPlot )
{
for( tmplt = bankHead; tmplt != NULL; tmplt = tmplt->next )
{
list->x = tmplt->psi0;
list->y = tmplt->psi3;
list->z = tmplt->beta;
list->grayLevel = 1.0*loop/ntiles;
if( (list = list->next = (Math3DPointList *) LALCalloc( 1, sizeof(
Math3DPointList ))) == NULL ) {
LALError( &status, INSPIRALSPINBANKTESTC_MSGEMEM );
printf( INSPIRALSPINBANKTESTC_MSGEMEM );
return INSPIRALSPINBANKTESTC_EMEM;
}
}
list->next = NULL;
LALMath3DPlot( &status, first, &ntiles, NULL );
if( status.statusCode )
{
LALError( &status, INSPIRALSPINBANKTESTC_MSGESUB );
printf( INSPIRALSPINBANKTESTC_MSGESUB );
return INSPIRALSPINBANKTESTC_ESUB;
}
/* Clean Up the memory from the MathPlot3D structure */
list = first;
while( list->next )
{
first = list->next;
LALFree( list );
list = first;
}
}
/* free the last (first?) memory allocated for Math3DPlot. */
LALFree( list );
if (status.statusCode)
return INSPIRALSPINBANKTESTC_ESUB;
else
return INSPIRALSPINBANKTESTC_ENORM;
}
/**
* Computes running median in an efficient manner.
*
* \param data Pointer to input data array
*
* \param lendata Length of input data array
*
* \param nblocks Block size for computing running median
*
* \param medians Pointer to output array. Number of elements is
* lendata - nblocks+1. Must be
* allocated outside this function.
*
*/
int rngmed(const double *data, unsigned int lendata, unsigned int nblocks, double *medians){
/*--------------------------
Structure to store samples in one block
----------------------------*/
struct node{
double data;
struct node *next_sorted;
struct node *next_sequence;
struct node *prev_sorted;
};
/*-------------------------------
checks: pointers to subset of nodes to use
as checkpoints
---------------------------------*/
double *sorted_indices;
struct rngmed_val_index *index_block;
struct node **checks,**node_addresses;
struct node *first_sequence,*last_sequence;
struct node *currentnode=NULL,*previousnode;
struct node *leftnode=NULL, *rightnode=NULL;
struct node *reuse_next_sorted=NULL,*reuse_prev_sorted=NULL;
struct node *dummy_node,*dummy_node1,*dummy_node2;
int ncheckpts,stepchkpts;
int nextchkptindx,*checks4shift;
int nearestchk,midpoint,offset,numberoffsets;
int samplecount,k,counter_chkpt,chkcount=0,shiftcounter=0;
double nextsample,deletesample,dummy;
int shift,dummy_int;
/*-----------------------------------
Sort the first block of nblocks samples
using the qsort function
------------------------------------*/
index_block =(struct rngmed_val_index *)LALCalloc(nblocks, sizeof(struct rngmed_val_index));
if(!index_block){
printf("Could not allocate memory for index_block\n");
return 1;
}
for(k=0;k<(int)nblocks;k++){
index_block[k].data=data[k];
index_block[k].index=k;
}
qsort(index_block, nblocks, sizeof(struct rngmed_val_index),rngmed_sortindex);
sorted_indices=(double *)LALCalloc(nblocks,sizeof(double));
if (!sorted_indices){
printf("Could not allocate memory for sorted_indices\n");
return 1;
}
for(k=0;k<(int)nblocks;k++){
sorted_indices[k]=index_block[k].index;
}
LALFree(index_block);
/*----------------------------------
Indices of checkpoint nodes.
Number of nodes per checkpoint=floor(sqrt(nblocks))
------------------------------------*/
stepchkpts=sqrt(nblocks);
ncheckpts=nblocks/stepchkpts;
checks=(struct node **)LALCalloc(ncheckpts,sizeof(struct node*));
if(!checks){
printf("Could not allocate storage for checks\n");
return 1;
}
if(!(checks4shift=(int*)LALCalloc(ncheckpts,sizeof(int)))){
printf("Could not allocate storage for checks4shift\n");
return 1;
}
/*---------------------------------
Offsets for getting median from nearest
checkpoint: For nblocks even,
(node(offset(1))+node(offset(2)))/2;
for nblocks odd,
(node(offset(1))+node(offset(1)))/2;
THIS CAN BE OPTIMISED.
----------------------------------*/
if((int)fmod(nblocks,2.0)){
/*Odd*/
midpoint=(nblocks+1)/2-1;
numberoffsets=1;
}
else{
/*Even*/
midpoint=nblocks/2-1;
numberoffsets=2;
}
nearestchk=floor(midpoint/stepchkpts);
offset=midpoint-nearestchk*stepchkpts;
/*----------------------------------
Build up linked list using first nblock points
in sequential order
------------------------------------*/
node_addresses=(struct node **)LALCalloc(nblocks,sizeof(struct node *));
if(!node_addresses){
printf("Could not allocate storage for node_addresses\n");
return 1;
}
first_sequence=(struct node *)LALCalloc(1,sizeof(struct node));
if(!first_sequence){
printf("Could not create first node\n");
return 1;
}
node_addresses[0]=first_sequence;
first_sequence->next_sequence=NULL;
first_sequence->next_sorted=NULL;
first_sequence->prev_sorted=NULL;
first_sequence->data=data[0];
previousnode=first_sequence;
for(samplecount=1;samplecount<(int)nblocks;samplecount++){
currentnode=(struct node *)LALCalloc(1,sizeof(struct node));
if(!currentnode){
printf("Could not create node \n");
return 1;
}
node_addresses[samplecount]=currentnode;
previousnode->next_sequence=currentnode;
currentnode->next_sequence=NULL;
currentnode->prev_sorted=NULL;
currentnode->next_sorted=NULL;
currentnode->data=data[samplecount];
previousnode=currentnode;
}
last_sequence=currentnode;
/*------------------------------------
Set the sorted sequence pointers and
the pointers to checkpoint nodes
-------------------------------------*/
currentnode=node_addresses[(int)sorted_indices[0]];
previousnode=NULL;
checks[0]=currentnode;
nextchkptindx=stepchkpts;
counter_chkpt=1;
for(samplecount=1;samplecount<(int)nblocks;samplecount++){
dummy_node=node_addresses[(int)sorted_indices[samplecount]];
currentnode->next_sorted=dummy_node;
currentnode->prev_sorted=previousnode;
previousnode=currentnode;
currentnode=dummy_node;
if(samplecount==nextchkptindx && counter_chkpt<ncheckpts){
checks[counter_chkpt]=currentnode;
nextchkptindx+=stepchkpts;
counter_chkpt++;
}
}
currentnode->prev_sorted=previousnode;
currentnode->next_sorted=NULL;
LALFree(sorted_indices);
/*------------------------------
Get the first output element
-------------------------------*/
if(!medians){
printf("Null output array");
return 1;
}
currentnode=checks[nearestchk];
for(k=1;k<=offset;k++){
currentnode=currentnode->next_sorted;
}
dummy=0;
for(k=1;k<=numberoffsets;k++){
dummy+=currentnode->data;
currentnode=currentnode->next_sorted;
}
medians[0]=dummy/numberoffsets;
/*---------------------------------
This is the main part.
Find the nodes whose values
form the smallest closed interval
around the new incoming value.
The right limit is always >
the new value.
----------------------------------*/
for(samplecount=nblocks;samplecount<(int)lendata;samplecount++){
nextsample=data[samplecount];
if(nextsample>=checks[0]->data){
for(chkcount=1;chkcount<ncheckpts;chkcount++){
if(nextsample>=checks[chkcount]->data){
}
else{
break;
}
}
chkcount-=1;
rightnode=checks[chkcount];
leftnode=NULL; /*NEW*/
while(rightnode){
if(nextsample<rightnode->data){
break;
}
leftnode=rightnode;
rightnode=rightnode->next_sorted;
}
}
else {
if(nextsample<checks[0]->data){
chkcount=0;
/* dummy_node=checks[0]; */
rightnode=checks[0];
leftnode=NULL;
}
}
/*-------------------------
Determine if checkpoints need to be
shifted or not.
---------------------------*/
dummy_node=NULL;
if(rightnode==first_sequence){
dummy_node=rightnode;
}
else if(leftnode==first_sequence){
dummy_node=leftnode;
}
if(dummy_node) {
dummy_node->data=nextsample;
first_sequence=first_sequence->next_sequence;
dummy_node->next_sequence=NULL;
last_sequence->next_sequence=dummy_node;
last_sequence=dummy_node;
shift=0;
}
else{
reuse_next_sorted=rightnode;
reuse_prev_sorted=leftnode;
shift=1; /*shift maybe required*/
}
/*-----------------------------------
Getting check points to be shifted
-----------------------------------*/
if(shift){
deletesample=first_sequence->data;
if(deletesample>nextsample){
shiftcounter=0;
for(k=chkcount;k<ncheckpts;k++){
dummy=checks[k]->data;
if(dummy>nextsample){
if(dummy<=deletesample){
checks4shift[shiftcounter]=k;
shiftcounter++;
}
else{
break;
}
}
}
shift=-1; /*Left shift*/
}
else
if(deletesample<=nextsample){
shiftcounter=0;
for(k=chkcount;k>=0;k--){
dummy=checks[k]->data;
if(dummy>=deletesample){
checks4shift[shiftcounter]=k;
shiftcounter++;
}
else{
break;
}
}
shift=1; /*Shift Right*/
}
}
/*------------------------------
Recycle the node with the
oldest value.
--------------------------------*/
if(shift){
/*---------------------
Reset sequential links
---------------------*/
dummy_node=first_sequence;
first_sequence=dummy_node->next_sequence;
dummy_node->next_sequence=NULL;
last_sequence->next_sequence=dummy_node;
last_sequence=dummy_node;
dummy_node->data=nextsample;
dummy_node1=dummy_node->prev_sorted;
dummy_node2=dummy_node->next_sorted;
/*-----------------------
Repair deletion point
------------------------*/
if(!dummy_node1){
dummy_node2->prev_sorted=dummy_node1;
}
else {
if(!dummy_node2){
dummy_node1->next_sorted=dummy_node2;
}
else{
dummy_node1->next_sorted=dummy_node2;
dummy_node2->prev_sorted=dummy_node1;
}
}
/*------------------------
Set pointers from neighbours to new node at insertion point
-------------------------*/
if(!rightnode){
leftnode->next_sorted=dummy_node;
}
else {
if(!leftnode){
rightnode->prev_sorted=dummy_node;
}
else{
leftnode->next_sorted=dummy_node;
rightnode->prev_sorted=dummy_node;
}
}
/*-------------------------------
Shift check points before resetting sorted list
--------------------------------*/
if(shift==-1){
for(k=0;k<shiftcounter;k++){
dummy_int=checks4shift[k];
checks[dummy_int]=checks[dummy_int]->prev_sorted;
}
}
else
if(shift==1){
for(k=0;k<shiftcounter;k++){
dummy_int=checks4shift[k];
checks[dummy_int]=checks[dummy_int]->next_sorted;
}
}
/*--------------------------------
insert node
--------------------------------*/
dummy_node->next_sorted=reuse_next_sorted;
dummy_node->prev_sorted=reuse_prev_sorted;
}
/*--------------------------------
Get the median
---------------------------------*/
currentnode=checks[nearestchk];
for(k=1;k<=offset;k++){
currentnode=currentnode->next_sorted;
}
dummy=0;
for(k=1;k<=numberoffsets;k++){
dummy+=currentnode->data;
currentnode=currentnode->next_sorted;
}
medians[samplecount-nblocks+1]=dummy/numberoffsets;
}/*Outer For Loop*/
/*--------------------------------
Clean Up
---------------------------------*/
LALFree(node_addresses);
currentnode=first_sequence;
while(currentnode){
previousnode=currentnode;
currentnode=currentnode->next_sequence;
LALFree(previousnode);
}
LALFree(checks4shift);
LALFree(checks);
return 0;
}
void AddNumRelStrainModes( LALStatus *status, /**< pointer to LALStatus structure */
REAL4TimeVectorSeries **outStrain, /**< [out] h+, hx data */
SimInspiralTable *thisinj /**< [in] injection data */)
{
INT4 modeL, modeM, modeLlo, modeLhi;
INT4 len, lenPlus, lenCross, k;
CHAR *channel_name_plus;
CHAR *channel_name_cross;
LALFrStream *frStream = NULL;
LALCache frCache;
LIGOTimeGPS epoch;
REAL4TimeSeries *seriesPlus=NULL;
REAL4TimeSeries *seriesCross=NULL;
REAL8 massMpc;
REAL4TimeVectorSeries *sumStrain=NULL;
REAL4TimeVectorSeries *tempStrain=NULL;
/* NRWaveMetaData thisMetaData; */
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
modeLlo = thisinj->numrel_mode_min;
modeLhi = thisinj->numrel_mode_max;
/* create a frame cache and open the frame stream */
frCache.length = 1;
frCache.list = LALCalloc(1, sizeof(frCache.list[0]));
frCache.list[0].url = thisinj->numrel_data;
frStream = XLALFrStreamCacheOpen( &frCache );
/* the total mass of the binary in Mpc */
massMpc = (thisinj->mass1 + thisinj->mass2) * LAL_MRSUN_SI / ( LAL_PC_SI * 1.0e6);
/* start time of waveform -- set it to something */
epoch.gpsSeconds = 0;
epoch.gpsNanoSeconds = 0;
/* loop over l values */
for ( modeL = modeLlo; modeL <= modeLhi; modeL++ ) {
/* loop over m values */
for ( modeM = -modeL; modeM <= modeL; modeM++ ) {
/* read numrel waveform */
/* first the plus polarization */
channel_name_plus = XLALGetNinjaChannelName("plus", modeL, modeM);
/*get number of data points */
lenPlus = XLALFrStreamGetVectorLength ( channel_name_plus, frStream );
/* now the cross polarization */
channel_name_cross = XLALGetNinjaChannelName("cross", modeL, modeM);
/*get number of data points */
lenCross = XLALFrStreamGetVectorLength ( channel_name_cross, frStream );
/* skip on to next mode if mode doesn't exist */
if ( (lenPlus <= 0) || (lenCross <= 0) || (lenPlus != lenCross) ) {
XLALClearErrno();
LALFree(channel_name_plus);
LALFree(channel_name_cross);
continue;
}
/* note: lenPlus and lenCross must be equal if we got this far*/
/* len = lenPlus; */
len = lenPlus;
/* allocate and read the plus/cross time series */
seriesPlus = XLALCreateREAL4TimeSeries ( channel_name_plus, &epoch, 0, 0, &lalDimensionlessUnit, len);
memset(seriesPlus->data->data, 0, seriesPlus->data->length*sizeof(REAL4));
XLALFrStreamGetREAL4TimeSeries ( seriesPlus, frStream );
XLALFrStreamRewind( frStream );
LALFree(channel_name_plus);
seriesCross = XLALCreateREAL4TimeSeries ( channel_name_cross, &epoch, 0, 0, &lalDimensionlessUnit, len);
memset(seriesCross->data->data, 0, seriesCross->data->length*sizeof(REAL4));
XLALFrStreamGetREAL4TimeSeries ( seriesCross, frStream );
XLALFrStreamRewind( frStream );
LALFree(channel_name_cross);
/* allocate memory for tempStrain */
tempStrain = LALCalloc(1, sizeof(*tempStrain));
tempStrain->data = XLALCreateREAL4VectorSequence(2, len);
tempStrain->deltaT = LAL_MTSUN_SI * (thisinj->mass1 + thisinj->mass2) * seriesPlus->deltaT ;
tempStrain->f0 = seriesPlus->f0;
tempStrain->sampleUnits = seriesPlus->sampleUnits;
memset(tempStrain->data->data, 0, tempStrain->data->length * tempStrain->data->vectorLength*sizeof(REAL4));
/* now copy the data and scale amplitude corresponding to distance of 1Mpc*/
for (k = 0; k < len; k++) {
tempStrain->data->data[k] = massMpc * seriesPlus->data->data[k];
tempStrain->data->data[len + k] = massMpc * seriesCross->data->data[k]; }
/* we are done with seriesPlus and Cross for this iteration */
XLALDestroyREAL4TimeSeries (seriesPlus);
XLALDestroyREAL4TimeSeries (seriesCross);
seriesPlus = NULL;
seriesCross = NULL;
/* compute the h+ and hx for given inclination and coalescence phase*/
XLALOrientNRWave( tempStrain, modeL, modeM, thisinj->inclination, thisinj->coa_phase );
if (sumStrain == NULL) {
sumStrain = LALCalloc(1, sizeof(*sumStrain));
sumStrain->data = XLALCreateREAL4VectorSequence(2, tempStrain->data->vectorLength);
sumStrain->deltaT = tempStrain->deltaT;
sumStrain->f0 = tempStrain->f0;
sumStrain->sampleUnits = tempStrain->sampleUnits;
memset(sumStrain->data->data,0.0,2*tempStrain->data->vectorLength*sizeof(REAL4));
sumStrain = XLALSumStrain( sumStrain, tempStrain );
} else {
sumStrain = XLALSumStrain( sumStrain, tempStrain );
}
/* clear memory for strain */
if (tempStrain->data != NULL) {
XLALDestroyREAL4VectorSequence ( tempStrain->data );
LALFree( tempStrain );
tempStrain = NULL;
}
} /* end loop over modeM values */
} /* end loop over modeL values */
XLALFrStreamClose( frStream );
LALFree(frCache.list);
*outStrain = sumStrain;
DETATCHSTATUSPTR(status);
RETURN(status);
}
/**
* Multi-IFO version of LALGetBinarytimes().
* Get all binary-timings for all input detector-series.
*
*/
void
LALGetMultiBinarytimes (LALStatus *status, /**< pointer to LALStatus structure */
MultiSSBtimes **multiBinary, /**< [out] SSB-timings for all input detector-state series */
const MultiSSBtimes *multiSSB, /**< [in] SSB-timings for all input detector-state series */
const MultiDetectorStateSeries *multiDetStates, /**< [in] detector-states at timestamps t_i */
const BinaryOrbitParams *binaryparams, /**< [in] source binary orbit parameters */
LIGOTimeGPS refTime /**< SSB reference-time T_0 for SSB-timing */
)
{
UINT4 X, numDetectors;
MultiSSBtimes *ret = NULL;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* check input */
ASSERT (multiDetStates, status,COMPUTEFSTATC_ENULL, COMPUTEFSTATC_MSGENULL);
ASSERT (multiDetStates->length, status,COMPUTEFSTATC_ENULL, COMPUTEFSTATC_MSGENULL);
ASSERT (multiSSB, status,COMPUTEFSTATC_ENULL, COMPUTEFSTATC_MSGENULL);
ASSERT ( *multiBinary == NULL, status,COMPUTEFSTATC_ENONULL, COMPUTEFSTATC_MSGENONULL);
ASSERT (multiSSB != NULL, status,COMPUTEFSTATC_ENULL, COMPUTEFSTATC_MSGENULL);
numDetectors = multiDetStates->length;
if ( ( ret = LALCalloc( 1, sizeof( *ret ) )) == NULL ) {
ABORT (status, COMPUTEFSTATC_EMEM, COMPUTEFSTATC_MSGEMEM);
}
ret->length = numDetectors;
if ( ( ret->data = LALCalloc ( numDetectors, sizeof ( *ret->data ) )) == NULL ) {
LALFree ( ret );
ABORT (status, COMPUTEFSTATC_EMEM, COMPUTEFSTATC_MSGEMEM);
}
for ( X=0; X < numDetectors; X ++ )
{
SSBtimes *BinarytimesX = NULL;
UINT4 numStepsX = multiDetStates->data[X]->length;
ret->data[X] = LALCalloc ( 1, sizeof ( *(ret->data[X]) ) );
BinarytimesX = ret->data[X];
BinarytimesX->DeltaT = XLALCreateREAL8Vector ( numStepsX );
if ( (BinarytimesX->Tdot = XLALCreateREAL8Vector ( numStepsX )) == NULL ) {
XLALPrintError ("\nOut of memory!\n\n");
goto failed;
}
/* printf("calling LALGetBinarytimes\n"); */
LALGetBinarytimes (status->statusPtr, BinarytimesX, multiSSB->data[X], multiDetStates->data[X], binaryparams, refTime);
/* printf("finished LALGetBinarytimes\n"); */
if ( status->statusPtr->statusCode )
{
XLALPrintError ( "\nCall to LALGetBinarytimes() has failed ... \n\n");
goto failed;
}
// NOTE! It seems the old LAL-function *did not* set the reference time of the output binary-SSB vectors
// so we 'fix' this here retro-actively, in order to facilitate comparison with the new XLAL function:
BinarytimesX->refTime = multiSSB->data[X]->refTime;
} /* for X < numDet */
goto success;
failed:
/* free all memory allocated so far */
XLALDestroyMultiSSBtimes ( ret );
ABORT ( status, -1, "LALGetMultiBinarytimes failed" );
success:
(*multiBinary) = ret;
DETATCHSTATUSPTR (status);
RETURN(status);
} /* LALGetMultiBinarytimes() */
/**
* Main function for injecting numetrical relativity waveforms.
* Takes as input a list of injections, and adds h(t) to a given
* timeseries for a specified ifo and a dynamic range factor.
* Updated/generalized version of InjectNumRelWaveforms that allows
* arbitrary LIGO and Virgo PSDs and integration starting frequencies
*/
void InjectNumRelWaveformsUsingPSDREAL8(LALStatus *status, /**< pointer to LALStatus structure */
REAL8TimeSeries *chan, /**< [out] the output time series */
SimInspiralTable *injections, /**< [in] list of injections */
CHAR ifo[3], /**< [in] 2 char code for interferometer */
REAL8 freqLowCutoff, /**< [in] Lower cutoff frequency */
REAL8 snrLow, /**< [in] lower cutoff value of snr */
REAL8 snrHigh, /**< TO BE DOCUMENTED */
REAL8FrequencySeries *ligoPSD, /**< [in] PSD to use for LIGO SNRs. If NULL, use initial PSD */
REAL8 ligoSnrLowFreq, /**< [in] Frequency at which to start integration for LIGO SNRs */
REAL8FrequencySeries *virgoPSD, /**< [in] PSD to use for Virgo SNRs. If NULL, use initial PSD */
REAL8 virgoSnrLowFreq, /**< [in] Frequency at which to start integration for Virgo SNRs */
CHAR *fname) /**< [in] higher cutoff value of snr */
{
SimInspiralTable *thisInj = NULL;
REAL8 startFreq, startFreqHz, massTotal;
REAL8 thisSNR;
SimInspiralTable *simTableOut=NULL;
SimInspiralTable *thisInjOut=NULL;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
ASSERT( chan, status, INSPIRALH_ENULL, INSPIRALH_MSGENULL );
ASSERT( ifo, status, INSPIRALH_ENULL, INSPIRALH_MSGENULL );
/* loop over injections */
for ( thisInj = injections; thisInj; thisInj = thisInj->next )
{
startFreq = start_freq_from_frame_url(thisInj->numrel_data);
massTotal = (thisInj->mass1 + thisInj->mass2) * LAL_MTSUN_SI;
startFreqHz = startFreq / ( LAL_TWOPI * massTotal);
if (startFreqHz < freqLowCutoff)
{
REAL8TimeSeries *strain = NULL;
strain = XLALNRInjectionStrain(ifo, thisInj);
if (ifo[0] == 'V')
thisSNR = calculate_snr_from_strain_and_psd_real8( strain, virgoPSD, virgoSnrLowFreq, ifo );
else
thisSNR = calculate_snr_from_strain_and_psd_real8( strain, ligoPSD, ligoSnrLowFreq, ifo );
/* set channel name */
snprintf( chan->name, LALNameLength * sizeof( CHAR ),
"%s:STRAIN", ifo );
printf("Injection at %d.%d in ifo %s has SNR %f\n",
thisInj->geocent_end_time.gpsSeconds,
thisInj->geocent_end_time.gpsNanoSeconds,
ifo,
thisSNR);
if ((thisSNR < snrHigh) && (thisSNR > snrLow))
{
/* simTableOut will be null only the first time */
if ( simTableOut == NULL) {
simTableOut = (SimInspiralTable *)LALCalloc( 1, sizeof(SimInspiralTable) );
memcpy(simTableOut, thisInj, sizeof(*thisInj));
simTableOut->next = NULL;
thisInjOut = simTableOut;
}
else {
thisInjOut->next = (SimInspiralTable *)LALCalloc( 1, sizeof(SimInspiralTable) );
memcpy(thisInjOut->next, thisInj, sizeof(*thisInj));
thisInjOut->next->next = NULL;
thisInjOut = thisInjOut->next;
}
XLALSimAddInjectionREAL8TimeSeries( chan, strain, NULL);
}
XLALDestroyREAL8TimeSeries (strain);
}
else
{
fprintf( stderr, "Skipping injection at %d because it turns on at %f Hz, "
"but the low frequency cutoff is %f\n",
thisInj->geocent_end_time.gpsSeconds, startFreqHz, freqLowCutoff);
}
} /* loop over injectionsj */
/* write and free the output simInspiral table */
if ( simTableOut ) {
LIGOLwXMLStream xmlfp;
MetadataTable dummyTable;
dummyTable.simInspiralTable = simTableOut;
/* write the xml table of actual injections */
if (fname) {
memset( &xmlfp, 0, sizeof(LIGOLwXMLStream) );
TRY( LALOpenLIGOLwXMLFile( status->statusPtr, &xmlfp, fname ), status );
TRY( LALBeginLIGOLwXMLTable( status->statusPtr, &xmlfp, sim_inspiral_table ),
status );
TRY( LALWriteLIGOLwXMLTable( status->statusPtr, &xmlfp, dummyTable,
sim_inspiral_table ), status );
TRY( LALEndLIGOLwXMLTable ( status->statusPtr, &xmlfp ), status );
TRY( LALCloseLIGOLwXMLFile ( status->statusPtr, &xmlfp ), status );
}
}
while (simTableOut) {
thisInjOut = simTableOut;
simTableOut = simTableOut->next;
LALFree(thisInjOut);
}
DETATCHSTATUSPTR(status);
RETURN(status);
}