void LALSelectPeakWhiteNoise(LALStatus *status,
UCHARPeakGram *pg,
REAL8 *thr,
REAL8Periodogram1 *peri)
{
INT4 length;
INT4 nPeaks;
/* --------------------------------------------- */
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* Make sure the arguments are not NULL: */
ASSERT (peri, status, PEAKSELECTH_ENULL, PEAKSELECTH_MSGENULL);
ASSERT (pg, status, PEAKSELECTH_ENULL, PEAKSELECTH_MSGENULL);
ASSERT (thr, status, PEAKSELECTH_ENULL, PEAKSELECTH_MSGENULL);
pg->epoch.gpsSeconds = peri->epoch.gpsSeconds;
pg->epoch.gpsNanoSeconds = peri->epoch.gpsNanoSeconds;
pg->timeBase = peri->timeBase;
pg->fminBinIndex = peri->fminBinIndex;
length = peri->length;
nPeaks = 0;
ASSERT (length==pg->length, status, PEAKSELECTH_EVAL, PEAKSELECTH_MSGEVAL);
if (length > 0){
UCHAR *out;
REAL8 *in1;
REAL8 threshold;
INT4 n;
ASSERT (peri->data, status, PEAKSELECTH_ENULL, PEAKSELECTH_MSGENULL);
ASSERT (pg->data, status, PEAKSELECTH_ENULL, PEAKSELECTH_MSGENULL);
out = pg->data;
in1 = peri->data;
threshold = *thr;
n = length;
while (n-- >0){
if ( *in1 > threshold){
*out = 1 ;
nPeaks++ ;
} else {
*out = 0;
}
++out;
++in1;
}
}
pg->nPeaks = nPeaks;
DETATCHSTATUSPTR (status);
/* normal exit */
RETURN (status);
}
void LALAstroOmega (LALStatus *s, REAL8 *omeganu, REAL8 nu, void *p)
{
DIntegrateIn zint;
AstroOmegaParams params;
AstroOmegaSourceParams sourcep;
AstroOmegaCosmoParams cosmop;
REAL8 omegaz, zmax, numax, lambda;
INITSTATUS(s);
ATTATCHSTATUSPTR (s);
params = *((AstroOmegaParams *)p);
cosmop=params.cosmoparams;
sourcep = params.sourceparams;
numax= sourcep.numax;
lambda = sourcep.lambda;
if((nu >= numax)||(nu <= 0.)){*omeganu = 0.;}
else
{
if (nu < (numax / 6.)) {zmax = 5.;}
else {zmax = (numax / nu) - 1.;}
zint.function = dAstroOmega;
zint.xmin = 0;
zint.xmax = zmax;
zint.type = ClosedInterval;
LALDRombergIntegrate (s->statusPtr, &omegaz, &zint, ¶ms);
*omeganu = 4.66e-56 * lambda / (cosmop.ho * cosmop.ho) * nu * omegaz;
}
CHECKSTATUSPTR (s);
DETATCHSTATUSPTR (s);
RETURN (s);
}
/**
* Calculate the binary system time delay using the pulsar parameters in
* \c params
*/
void
LALBinaryPulsarDeltaT( LALStatus *status,
BinaryPulsarOutput *output,
BinaryPulsarInput *input,
BinaryPulsarParams *params ){
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/* Check input arguments */
ASSERT(input != (BinaryPulsarInput *)NULL, status,
BINARYPULSARTIMINGH_ENULLINPUT, BINARYPULSARTIMINGH_MSGENULLINPUT);
ASSERT(output != (BinaryPulsarOutput *)NULL, status,
BINARYPULSARTIMINGH_ENULLOUTPUT, BINARYPULSARTIMINGH_MSGENULLOUTPUT);
ASSERT(params != (BinaryPulsarParams *)NULL, status,
BINARYPULSARTIMINGH_ENULLPARAMS, BINARYPULSARTIMINGH_MSGENULLPARAMS);
ASSERT((!strcmp(params->model, "BT")) ||
(!strcmp(params->model, "BT1P")) ||
(!strcmp(params->model, "BT2P")) ||
(!strcmp(params->model, "BTX")) ||
(!strcmp(params->model, "ELL1")) ||
(!strcmp(params->model, "DD")) ||
(!strcmp(params->model, "DDS")) ||
(!strcmp(params->model, "MSS")) ||
(!strcmp(params->model, "T2")), status,
BINARYPULSARTIMINGH_ENULLBINARYMODEL,
BINARYPULSARTIMINGH_MSGNULLBINARYMODEL);
XLALBinaryPulsarDeltaT( output, input, params );
DETATCHSTATUSPTR(status);
RETURN(status);
}
/** \see See \ref Eigen_c for documentation */
void
LALDSymmetricEigenValues( LALStatus *stat, REAL8Vector *values, REAL8Array *matrix )
{
REAL8Vector *offDiag = NULL; /* off-diagonal line of
tri-diagonalized matrix */
INITSTATUS(stat);
ATTATCHSTATUSPTR( stat );
/* Check dimension length. All other argument testing is done by
the subroutines. */
ASSERT( values, stat, MATRIXUTILSH_ENUL, MATRIXUTILSH_MSGENUL );
ASSERT( values->length, stat, MATRIXUTILSH_ENUL, MATRIXUTILSH_MSGENUL );
/* Allocate an off-diagonal vector for the tri-diagonal matrix. */
TRY( LALDCreateVector( stat->statusPtr, &offDiag, values->length ),
stat );
/* Call the subroutines. */
LALDSymmetricToTriDiagonal2( stat->statusPtr, values, matrix,
offDiag );
BEGINFAIL( stat ) {
TRY( LALDDestroyVector( stat->statusPtr, &offDiag ), stat );
} ENDFAIL( stat );
LALDTriDiagonalToDiagonal2( stat->statusPtr, values, matrix,
offDiag );
BEGINFAIL( stat ) {
TRY( LALDDestroyVector( stat->statusPtr, &offDiag ), stat );
} ENDFAIL( stat );
/* Clean up. */
TRY( LALDDestroyVector( stat->statusPtr, &offDiag ), stat );
DETATCHSTATUSPTR( stat );
RETURN( stat );
}
void
LALStringToZ(LALStatus * stat, COMPLEX16 * value, const CHAR * string,
CHAR ** endptr)
{
REAL8 re, im; /* real and imaginary parts */
CHAR *end; /* substring following parsed numbers */
INITSTATUS(stat);
ATTATCHSTATUSPTR(stat);
/* Check for valid input arguments. */
ASSERT(value, stat, STRINGINPUTH_ENUL, STRINGINPUTH_MSGENUL);
ASSERT(string, stat, STRINGINPUTH_ENUL, STRINGINPUTH_MSGENUL);
/* Parse string. Return if nothing was parsed. */
TRY(LALStringToD(stat->statusPtr, &re, string, &end), stat);
TRY(LALStringToD(stat->statusPtr, &im, end, &end), stat);
if (string == end) {
if (endptr)
*endptr = end;
DETATCHSTATUSPTR(stat);
RETURN(stat);
}
/* Set values and return. */
*value = re;
*value += im * I;
if (endptr)
*endptr = end;
DETATCHSTATUSPTR(stat);
RETURN(stat);
}
void LALForwardRealDFT(
LALStatus *status,
COMPLEX8Vector *output,
REAL4Vector *input
)
{
COMPLEX8Vector *a = NULL;
COMPLEX8Vector *b = NULL;
UINT4 n;
UINT4 j;
UINT4 k;
INITSTATUS(status);
ATTATCHSTATUSPTR( status );
n = input->length;
TRY( LALCCreateVector( status->statusPtr, &a, n ), status );
TRY( LALCCreateVector( status->statusPtr, &b, n ), status );
for ( j = 0; j < n; ++j )
a->data[j] = input->data[j];
TRY( LALDFT( status->statusPtr, b, a, -1 ), status );
for ( k = 0; k <= n / 2; ++k )
output->data[k] = b->data[k];
TRY( LALCDestroyVector( status->statusPtr, &a ), status );
TRY( LALCDestroyVector( status->statusPtr, &b ), status );
DETATCHSTATUSPTR( status );
RETURN( status );
}
static void dAstroOmega (LALStatus *s, REAL8 *domegaz, REAL8 z, void *p)
{
AstroOmegaParams params;
AstroOmegaSourceParams sourcep;
/*AstroOmegaCosmoParams cosmop;*/
REAL8LALSDensity *SDensitySource;
REAL8 Rc, dEgw, nu, nuz;
INITSTATUS(s);
ATTATCHSTATUSPTR (s);
params = *((AstroOmegaParams *)p);
sourcep = params.sourceparams;
SDensitySource = sourcep.SDensitySource;
nu = *((REAL8 *)params.extraparams);
/*frequency in the source frame*/
nuz = (1. + z) * nu;
/*single spectral energy density in the source frame*/
SDensitySource(&dEgw, nuz);
/*cosmic formation rate*/
SFR(&Rc, z);
*domegaz = dEgw * Rc / pow((1.+z),3.5);
CHECKSTATUSPTR (s);
DETATCHSTATUSPTR (s);
RETURN (s);
}
void
LALInspiralEccentricityTemplates(
LALStatus *status,
REAL4Vector *signalvec1,
REAL4Vector *signalvec2,
InspiralTemplate *params
)
{
INT4 count;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
ASSERT(signalvec1, status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL);
ASSERT(signalvec2, status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL);
ASSERT(signalvec1->data, status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL);
ASSERT(signalvec2->data, status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL);
/* Initially the waveforms are empty */
memset(signalvec1->data, 0, signalvec1->length * sizeof(REAL4));
memset(signalvec2->data, 0, signalvec2->length * sizeof(REAL4));
/* Call the engine function */
LALInspiralEccentricityEngine(status->statusPtr, signalvec1, signalvec2, NULL, NULL, NULL, &count, params);
CHECKSTATUSPTR(status);
DETATCHSTATUSPTR(status);
RETURN (status);
}
void ComputeFoft(LALStatus *status,
REAL8Vector *foft,
HoughTemplate *pulsarTemplate,
REAL8Vector *timeDiffV,
REAL8Cart3CoorVector *velV,
REAL8 timeBase){
INT4 mObsCoh;
REAL8 f0new, vcProdn, timeDiffN;
INT4 f0newBin;
REAL8 sourceDelta, sourceAlpha, cosDelta;
INT4 j,i, nspin, factorialN;
REAL8Cart3Coor sourceLocation;
/* --------------------------------------------- */
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* Make sure the arguments are not NULL: */
ASSERT (foft, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (pulsarTemplate, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (timeDiffV, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (velV, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (foft->data, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (timeDiffV->data, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (velV->data, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
sourceDelta = pulsarTemplate->latitude;
sourceAlpha = pulsarTemplate->longitude;
cosDelta = cos(sourceDelta);
sourceLocation.x = cosDelta* cos(sourceAlpha);
sourceLocation.y = cosDelta* sin(sourceAlpha);
sourceLocation.z = sin(sourceDelta);
mObsCoh = foft->length;
nspin = pulsarTemplate->spindown.length;
for (j=0; j<mObsCoh; ++j){ /* loop for all different time stamps */
vcProdn = velV->data[j].x * sourceLocation.x
+ velV->data[j].y * sourceLocation.y
+ velV->data[j].z * sourceLocation.z;
f0new = pulsarTemplate->f0;
factorialN = 1;
timeDiffN = timeDiffV->data[j];
for (i=0; i<nspin;++i){ /* loop for spin-down values */
factorialN *=(i+1);
f0new += pulsarTemplate->spindown.data[i]* timeDiffN / factorialN;
timeDiffN *= timeDiffN;
}
f0newBin = floor( f0new * timeBase + 0.5);
foft->data[j] = f0newBin * (1.0 +vcProdn) / timeBase;
}
DETATCHSTATUSPTR (status);
/* normal exit */
RETURN (status);
}
/**
* register all our "user-variables"
*/
void
InitUserVars (LALStatus *status, struct CommandLineArgsTag *CLA)
{
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* Initialize default values */
CLA->Tsft=1800;
CLA->nTsft=0;
CLA->timestamps=NULL;
CLA->gpsStart=-1;
CLA->sqrtSh=1.0;
/** Default year-span of ephemeris-files to be used */
CLA->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
CLA->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
/* ---------- register all our user-variable ---------- */
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->Alpha), "Alpha", REAL8, 'a', OPTIONAL, "Sky position Alpha (equatorial coordinates) in radians") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->Alpha), "longitude", REAL8, 0, DEVELOPER, "[DEPRECATED] Use --Alpha instead!") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->Delta), "Delta", REAL8, 'd', OPTIONAL, "Sky position Delta (equatorial coordinates) in radians") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->Delta), "latitude", REAL8, 0, DEVELOPER, "[DEPRECATED] Use --Delta instead!") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->phi0), "phi0", REAL8, 'Q', OPTIONAL, "Phi_0: Initial phase in radians") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->psi), "psi", REAL8, 'Y', OPTIONAL, "Polarisation in radians") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->cosi), "cosi", REAL8, 'i', OPTIONAL, "Cos(iota)") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->cosiota), "cosiota", REAL8, 0, DEVELOPER, "[DEPRECATED] Use --cosi instead") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->h0), "h0", REAL8, 's', OPTIONAL, "Strain amplitude h_0") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->sqrtSh), "sqrtSh", REAL8, 'N', OPTIONAL, "Noise floor: one-sided sqrt(Sh) in 1/sqrt(Hz)") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->timestamps), "timestampsFile", STRING, 'T', OPTIONAL, "Name of timestamps file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->gpsStart), "startTime", INT4, 'S', OPTIONAL, "GPS start time of continuous observation") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->Tsft), "Tsft", REAL8, 't', OPTIONAL, "Length of an SFT in seconds") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->nTsft), "nTsft", INT4, 'n', OPTIONAL, "Number of SFTs") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->IFO), "IFO", STRING, 'D', OPTIONAL, "Detector: H1, H2, L1, G1, ... ") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->detector), "detector", STRING, 0, DEVELOPER, "[DEPRECATED] Use --IFO instead!") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->ephemEarth), "ephemEarth", STRING, 0, OPTIONAL, "Earth ephemeris file to use") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL( status, XLALRegisterNamedUvar(&(CLA->ephemSun), "ephemSun", STRING, 0, OPTIONAL, "Sun ephemeris file to use") == XLAL_SUCCESS, XLAL_EFUNC);
/* ----- added for mfd_v4 compatibility ---------- */
XLAL_CHECK_LAL ( status, XLALRegisterNamedUvar(&(CLA->duration), "duration", REAL8, 0, OPTIONAL, "Duration of requested signal in seconds") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL ( status, XLALRegisterNamedUvar(&(CLA->aPlus), "aPlus", REAL8, 0, OPTIONAL, "Plus polarization amplitude aPlus") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_LAL ( status, XLALRegisterNamedUvar(&(CLA->aCross), "aCross", REAL8, 0, OPTIONAL, "Cross polarization amplitude aCross") == XLAL_SUCCESS, XLAL_EFUNC);
DETATCHSTATUSPTR (status);
RETURN(status);
} /* InitUserVars() */
/** Main driver funtion for doing Numerical Relativity Injections */
void LALDriveNRInject( LALStatus *status, /**< pointer to LALStatus structure */
REAL4TimeSeries *injData, /**< The time series to inject into */
SimInspiralTable *injections, /**< The list of injections to perform */
NumRelInjectParams *params /**< Parameters */
)
{
REAL4TimeVectorSeries *sumStrain = NULL;
SimInspiralTable *thisInj = NULL; /* current injection */
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* loop over injections */
for ( thisInj = injections; thisInj; thisInj = thisInj->next )
{
TRY( LALAddStrainModes(status->statusPtr, &sumStrain, params->nrCatalog,
params->modeLlo, params->modeLhi, thisInj), status);
TRY( LALInjectStrainGW( status->statusPtr, injData, sumStrain, thisInj, params->ifo, params->dynRange), status);
XLALDestroyREAL4VectorSequence ( sumStrain->data );
LALFree( sumStrain );
sumStrain = NULL;
} /* end loop over injections */
DETATCHSTATUSPTR(status);
RETURN(status);
}
/**
* \ingroup LALInspiralBank_h
* \brief Module to check whether a point with coordinates (x,y) is inside
* a polygon defined by the vectors (vx, vy), which size (n) must be
* provided. The functions returns 1 if the point is inside or 0 otherwise.
*
* \author Cokelaer. T
*
* ### Notes ###
*
* Tested in matlab codes and some BCV tests within lal/lalapps.
*
*/
void LALInsidePolygon( LALStatus *status, /**< LAL status pointer */
REAL4 *inputx, /**< [in] two arrays of floats defining the polygon */
REAL4 *inputy, /**< [in] two arrays of floats defining the polygon */
INT4 n, /**< [in] the size of the vectors */
REAL4 x, /**< [in] the coordinate of the point */
REAL4 y, /**< [in] the coordinate of the point */
INT4 *valid /**< [out] 0 if outside and 1 if inside */
)
{
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
ASSERT (n>=3, status, LALINSPIRALBANKH_ENULL, LALINSPIRALBANKH_MSGENULL);
{
int i, j, c = 0;
for (i = 0, j = n-1; i < n; j = i++) {
if ((((inputy[i] <= y) && (y < inputy[j])) ||
((inputy[j] <= y) && (y < inputy[i]))) &&
(x < (inputx[j] - inputx[i]) * (y - inputy[i]) / (inputy[j] - inputy[i]) + inputx[i]))
c = !c;
}
*valid = c;
}
DETATCHSTATUSPTR(status);
RETURN(status);
}
/**
* \deprecated Use XLALComputeDetAMResponse() instead.
*/
void LALComputeDetAMResponse(LALStatus * status, LALDetAMResponse * pResponse, const LALDetAndSource * pDetAndSrc, const LIGOTimeGPS * gps)
{
double fplus, fcross;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
ASSERT(pResponse != (LALDetAMResponse *) NULL, status, DETRESPONSEH_ENULLOUTPUT, DETRESPONSEH_MSGENULLOUTPUT);
ASSERT(pDetAndSrc != NULL, status, DETRESPONSEH_ENULLINPUT, DETRESPONSEH_MSGENULLINPUT);
ASSERT(gps != (LIGOTimeGPS *) NULL, status, DETRESPONSEH_ENULLINPUT, DETRESPONSEH_MSGENULLINPUT);
/* source coordinates must be in equatorial system */
ASSERT(pDetAndSrc->pSource->equatorialCoords.system == COORDINATESYSTEM_EQUATORIAL, status, DETRESPONSEH_ESRCNOTEQUATORIAL, DETRESPONSEH_MSGESRCNOTEQUATORIAL);
XLALComputeDetAMResponse(&fplus, &fcross, pDetAndSrc->pDetector->response, pDetAndSrc->pSource->equatorialCoords.longitude, pDetAndSrc->pSource->equatorialCoords.latitude, pDetAndSrc->pSource->orientation, XLALGreenwichMeanSiderealTime(gps));
pResponse->plus = fplus;
pResponse->cross = fcross;
pResponse->scalar = 0.0; /* not implemented */
DETATCHSTATUSPTR(status);
RETURN(status);
}
void
LALFreqTimeRealFFT(
LALStatus *status,
REAL4TimeSeries *time,
COMPLEX8FrequencySeries *freq,
RealFFTPlan *plan
)
{
INITSTATUS(status);
XLAL_PRINT_DEPRECATION_WARNING("XLALREAL4FreqTimeFFT");
ATTATCHSTATUSPTR( status );
ASSERT( plan, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( freq, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( time, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( time->data, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( time->data->length, status,
TIMEFREQFFTH_ESIZE, TIMEFREQFFTH_MSGESIZE );
ASSERT( freq->deltaF > 0, status, TIMEFREQFFTH_ERATE, TIMEFREQFFTH_MSGERATE );
/* call the XLAL function */
if ( XLALREAL4FreqTimeFFT( time, freq, plan ) == XLAL_FAILURE )
{
XLALClearErrno();
ABORTXLAL( status );
}
DETATCHSTATUSPTR( status );
RETURN( status );
}
/**
* Function to clean a sft vector -- calls LALCleanCOMPLEX8SFT repeatedly for each
* sft in vector
*/
void LALCleanMultiSFTVect (LALStatus *status, /**< pointer to LALStatus structure */
MultiSFTVector *multVect, /**< SFTVector to be cleaned */
INT4 width, /**< maximum width to be cleaned -- set sufficiently large if all bins in each line are to be cleaned*/
INT4 window, /**< window size for noise floor estimation in vicinity of a line */
LineNoiseInfo *lineInfo, /**< list of lines */
RandomParams *randPar /**< parameters for generating random noise */)
{
UINT4 k;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
ASSERT (multVect, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (multVect->data, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (multVect->length > 0, status, SFTCLEANH_EVAL, SFTCLEANH_MSGEVAL);
ASSERT (lineInfo, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (lineInfo->nLines, status, SFTCLEANH_EVAL, SFTCLEANH_MSGEVAL);
ASSERT (lineInfo->lineFreq, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (lineInfo->leftWing, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (lineInfo->rightWing, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (window > 0, status, SFTCLEANH_EVAL, SFTCLEANH_MSGEVAL);
ASSERT (width >= 0, status, SFTCLEANH_EVAL, SFTCLEANH_MSGEVAL);
for ( k = 0; k < multVect->length; k++) {
TRY (LALCleanSFTVector (status->statusPtr, multVect->data[k], width, window, lineInfo, randPar), status);
}
DETATCHSTATUSPTR (status);
/* normal exit */
RETURN (status);
}
void SplitSFTs(LALStatus *status,
REAL8Vector *weightsV,
HoughParamsTest *chi2Params){
UINT4 j=0; /* index of each block. It runs betwen 0 and p */
UINT4 iSFT=0;
REAL8 *weights_ptr; /* pointer to weightsV.data */
REAL8 sumWeightpMax; /* Value of sumWeight we want to fix in each set of SFTs */
UINT4 numberSFT; /* Counter with the # of SFTs in each block */
UINT4 mObsCoh, p;
REAL8 partialsumWeightp, partialsumWeightSquarep;
/* --------------------------------------------- */
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* Make sure the arguments are not NULL: */
ASSERT (weightsV, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (chi2Params, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (weightsV->data, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (chi2Params->length, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (chi2Params->numberSFTp, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (chi2Params->sumWeight, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (chi2Params->sumWeightSquare, status, DRIVEHOUGHCOLOR_ENULL, DRIVEHOUGHCOLOR_MSGENULL);
ASSERT (chi2Params->length < weightsV->length, status, DRIVEHOUGHCOLOR_EBAD, DRIVEHOUGHCOLOR_MSGEBAD);
mObsCoh = weightsV->length;
p = chi2Params->length;
sumWeightpMax= (REAL8)(mObsCoh)/p; /* Compute the value of the sumWeight we want to fix in each set of SFT's */
weights_ptr=weightsV->data; /* Make the pointer to point to the first position of the vector weightsV.data */
iSFT = 0;
for (j = 0; j < p; j++){
partialsumWeightSquarep = 0;
partialsumWeightp = 0;
for(numberSFT = 0;(partialsumWeightp<sumWeightpMax)&&(iSFT<mObsCoh); numberSFT++, iSFT++){
partialsumWeightp += *weights_ptr;
partialsumWeightSquarep += (*weights_ptr)*(*weights_ptr);
weights_ptr++;
} /* loop over SFTs */
ASSERT ( (UINT4)j < p, status, DRIVEHOUGHCOLOR_EBAD, DRIVEHOUGHCOLOR_MSGEBAD);
chi2Params->numberSFTp[j] = numberSFT;
chi2Params->sumWeight[j] = partialsumWeightp;
chi2Params->sumWeightSquare[j] = partialsumWeightSquarep;
} /* loop over the p blocks of data */
DETATCHSTATUSPTR (status);
/* normal exit */
RETURN (status);
}
/**
* top level function to remove lines from a multi sft vector given a list of files
* containing list of known spectral lines
*/
void LALRemoveKnownLinesInMultiSFTVector (LALStatus *status, /**< pointer to LALStatus structure */
MultiSFTVector *MultiSFTVect, /**< SFTVector to be cleaned */
INT4 width, /**< maximum width to be cleaned */
INT4 window, /**< window size for noise floor estimation in vicinity of a line */
LALStringVector *linefiles, /**< file with list of lines */
RandomParams *randPar) /**< for creating random numbers */
{
UINT4 k, j, numifos;
CHAR *ifo;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
ASSERT (MultiSFTVect, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (MultiSFTVect->data, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (MultiSFTVect->length > 0, status, SFTCLEANH_EVAL, SFTCLEANH_MSGEVAL);
ASSERT (width > 0, status, SFTCLEANH_EVAL, SFTCLEANH_MSGEVAL);
ASSERT (window > 0, status, SFTCLEANH_EVAL, SFTCLEANH_MSGEVAL);
numifos = MultiSFTVect->length;
if ( linefiles != NULL ) {
ASSERT (linefiles->length > 0, status, SFTCLEANH_EVAL, SFTCLEANH_MSGEVAL);
ASSERT (linefiles->data, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
/* loop over linefiles and clean the relevant SFTs */
for ( k = 0; k < linefiles->length; k++)
{
ifo = NULL;
/* try to get the ifo name from the linefile name */
if ( (ifo = XLALGetChannelPrefix ( linefiles->data[k])) == NULL) {
ABORT ( status, SFTCLEANH_ELINENAME, SFTCLEANH_MSGELINENAME);
}
/* loop over ifos and see if any matches */
for ( j = 0; j < numifos; j++)
{
if ( strncmp( ifo, MultiSFTVect->data[j]->data->name, 3) == 0) {
/* clean the sftvector which has matched */
TRY ( LALRemoveKnownLinesInSFTVect ( status->statusPtr, MultiSFTVect->data[j],
width, window, linefiles->data[k], randPar), status);
}
} /* loop over ifos */
LALFree( ifo );
} /* loop over linefiles */
} /* if linefiles != NULL */
DETATCHSTATUSPTR (status);
/* normal exit */
RETURN (status);
}
void integrator_free(LALStatus *status, integrator_System *integrator) {
INITSTATUS(status, "runge_kutta_free", INTEGRATORC);
ATTATCHSTATUSPTR(status);
gsl_odeiv_step_free(integrator->solver_step);
gsl_odeiv_evolve_free(integrator->solver_evolve);
gsl_odeiv_control_free(integrator->solver_control);
DETATCHSTATUSPTR(status);
RETURN (status);
}
void LALReadHarmonicsInfo (LALStatus *status, /**< pointer to LALStatus structure */
LineHarmonicsInfo *harmonicsInfo, /**< list of harmonics */
CHAR *fname /**< input file */)
{
/* this reads the information about the lines: central frequency, left wing and
right wing */
FILE *fp = NULL;
INT4 r, count, nHarmonicSets;
REAL8 *startFreq=NULL;
REAL8 *gapFreq=NULL;
INT4 *numHarmonics=NULL;
REAL8 *leftWing=NULL;
REAL8 *rightWing=NULL;
CHAR dump[128];
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* make sure arguments are not null */
ASSERT (harmonicsInfo, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (harmonicsInfo->nHarmonicSets > 0, status, SFTCLEANH_EVAL, SFTCLEANH_MSGEVAL);
ASSERT (harmonicsInfo->startFreq, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (harmonicsInfo->gapFreq, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (harmonicsInfo->numHarmonics, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (harmonicsInfo->leftWing, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (harmonicsInfo->rightWing, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (fname, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
/* open line noise file for reading */
fp = fopen( fname, "r");
ASSERT (fp, status, SFTCLEANH_EFILE, SFTCLEANH_MSGEFILE);
nHarmonicSets = harmonicsInfo->nHarmonicSets;
startFreq = harmonicsInfo->startFreq;
gapFreq = harmonicsInfo->gapFreq;
numHarmonics = harmonicsInfo->numHarmonics;
leftWing = harmonicsInfo->leftWing;
rightWing = harmonicsInfo->rightWing;
/* read line information from file */
for (count = 0; count < nHarmonicSets; count++){
r=fscanf(fp,"%lf%lf%d%lf%lf%s\n", startFreq+count, gapFreq+count, numHarmonics+count,
leftWing+count, rightWing+count, dump);
if ( !(r==6 ) )
ABORT ( status, SFTCLEANH_EHEADER, SFTCLEANH_MSGEVAL);
}
fclose(fp);
DETATCHSTATUSPTR (status);
/* normal exit */
RETURN (status);
}
// LAL wrapper to XLAL Generator function
void LALSQTPNGenerator(LALStatus *status, LALSQTPNWave *waveform, LALSQTPNWaveformParams *params) {
XLAL_PRINT_DEPRECATION_WARNING("XLALSQTPNGenerator");
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
if(XLALSQTPNGenerator(waveform, params))
ABORTXLAL(status);
DETATCHSTATUSPTR(status);
RETURN(status);
}
void LALSQTPNWaveform (LALStatus *status, REAL4Vector *signalvec, InspiralTemplate *params){
XLAL_PRINT_DEPRECATION_WARNING("XLALSQTPNWaveform");
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
if(XLALSQTPNWaveform(signalvec, params))
ABORTXLAL(status);
DETATCHSTATUSPTR(status);
RETURN(status);
}
/** Parse a single string to fill the NRWaveMetaData structure */
void
LALGetSingleNRMetaData( LALStatus *status, /**< pointer to LALStatus structure */
NRWaveMetaData *out, /**< [out] Meta data struct to be filled */
const CHAR *dir, /**< [in] data directory */
const CHAR *cfgstr /**< [in] config string containing the data for a single NR wave*/)
{
REAL4 tmpR[7];
INT4 tmpI[2];
INT4 test;
CHAR tmpStr[512];
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
ASSERT (cfgstr != NULL, status, NRWAVEIO_ENULL, NRWAVEIO_MSGENULL );
ASSERT (out != NULL, status, NRWAVEIO_ENULL, NRWAVEIO_MSGENULL );
ASSERT (dir != NULL, status, NRWAVEIO_ENULL, NRWAVEIO_MSGENULL );
test = sscanf(cfgstr, "%f%f%f%f%f%f%f%d%d%s", tmpR, tmpR+1, tmpR+2, tmpR+3, tmpR+4, tmpR+5,
tmpR+6, tmpI, tmpI+1, tmpStr);
/* Check the metadata file format */
if ( test != 10) {
/* there must be exactly 10 data entries
-- massratio, spin1[3], spin2[3], l, m, filename */
ABORT( status, NRWAVEIO_EFORMAT, NRWAVEIO_MSGEFORMAT );
}
/* the mass ratio must be positive */
ASSERT (tmpR[0] >= 0, status, NRWAVEIO_EVAL, NRWAVEIO_MSGEVAL );
/*** need a few more format checks here ***/
/* copy values to out */
out->massRatio = tmpR[0];
out->spin1[0] = tmpR[1];
out->spin1[1] = tmpR[2];
out->spin1[2] = tmpR[3];
out->spin2[0] = tmpR[4];
out->spin2[1] = tmpR[5];
out->spin2[2] = tmpR[6];
out->mode[0] = tmpI[0];
out->mode[1] = tmpI[1];
strcpy(out->filename, dir);
strcat(out->filename, "/");
strcat(out->filename, tmpStr);
DETATCHSTATUSPTR(status);
RETURN(status);
}
void LALSQTPNWaveformForInjection(LALStatus *status, CoherentGW *waveform,
InspiralTemplate *params, PPNParamStruc *ppnParams) {
XLAL_PRINT_DEPRECATION_WARNING("XLALSQTPNWaveformForInjection");
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
if(XLALSQTPNWaveformForInjection(waveform, params, ppnParams))
ABORTXLAL(status);
DETATCHSTATUSPTR(status);
RETURN(status);
}
void
LALMakeTemplateBank(
LALStatus *status,
TemplateBankType *type,
MakeTemplateBankInput *input,
MetadataTable *table)
{
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
if(type == NULL){
ABORT(status, TEMPLATEBANKGENERATIONH_ENULL, TEMPLATEBANKGENERATIONH_MSGENULL);
}
if(table == NULL){
ABORT(status, TEMPLATEBANKGENERATIONH_ENULL, TEMPLATEBANKGENERATIONH_MSGENULL);
}
if (input == NULL){
ABORT(status, TEMPLATEBANKGENERATIONH_ENULL, TEMPLATEBANKGENERATIONH_MSGENULL);
}
/* look at inspiral Searches */
#if 0
if ((*type >= 100) && (*type < 200)){
printf("\nInside if type statement in MakeTemplateBank\n");
TRY(LALInspiralBankGeneration(status->statusPtr,
type,
input->InspiralInput,
table->snglInspiralTable), status);
printf("Just called LALInspiralBankGeneration\n");
}
#endif
/*
if ((*type >= 200) && (*type < 300)){
LALPulsarBankGeneration(status->statusPointer, type,
input.PulsarInput,
table.pulsarTable);
}
if ((*type >= 300) && (*type < 400)){
LALBurstBankGeneration(status->statusPointer, type,
input.BurstInput,
table.snglBurstTable);
}*/
DETATCHSTATUSPTR(status);
RETURN(status);
} /* LALMakeTemplateBank() */
void SumStacks( LALStatus *status,
REAL4FrequencySeries **SUMData,
REAL4FrequencySeries **STKData,
StackSlideParams *params)
{
INT4 kSUM = 0; /* index gives which SUM */ /* HARD CODED TO 0; This function only returns one SUM! */
INT4 iSUM = 0; /* index gives which SUM bin */
REAL4 invNumSTKs = 1.0/((REAL4)params->numSTKs);
INT4 i,k;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
INT4 iMinSTK = floor((params->f0SUM-params->f0STK)*params->tSTK + 0.5); /* Index of mimimum frequency to include when making SUMs from STKs */
INT4 iMaxSTK = iMinSTK + params->nBinsPerSUM - 1; /* Index of maximum frequency to include when making SUMs from STKs */
for (k=0;k<params->numSTKs;k++) {
for (i=iMinSTK;i<=iMaxSTK; i++) {
iSUM = i - iMinSTK;
if (k==0) {
/* Starting a new SUM: initialize */
SUMData[kSUM]->data->data[iSUM] = STKData[k]->data->data[i];
SUMData[kSUM]->epoch.gpsSeconds = params->gpsStartTimeSec;
SUMData[kSUM]->epoch.gpsNanoSeconds = params->gpsStartTimeNan;
SUMData[kSUM]->f0=params->f0SUM;
SUMData[kSUM]->deltaF=params->dfSUM;
SUMData[kSUM]->data->length=params->nBinsPerSUM;
} else {
SUMData[kSUM]->data->data[iSUM] += STKData[k]->data->data[i];
}
}/*end of for iMinSTK*/
} /* END for(k=0;k<params->numSTKs;k++) */
/* Normalize the SUMs with params->numSTKs*/
if (params->divideSUMsByNumSTKs) {
/* Normalize the SUMs with params->numSTKs*/
for(i=0;i<params->nBinsPerSUM; i++) {
SUMData[kSUM]->data->data[i] = SUMData[kSUM]->data->data[i]*invNumSTKs;
}
}
CHECKSTATUSPTR (status);
DETATCHSTATUSPTR (status);
} /*end of void SumStacks*/
void
LALInspiralRestrictedAmplitude (LALStatus *status,
InspiralTemplate *params )
{
XLAL_PRINT_DEPRECATION_WARNING("XLALInspiralRestrictedAmplitude");
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
if ( XLALInspiralRestrictedAmplitude(params) == XLAL_FAILURE )
{
ABORTXLAL(status);
}
DETATCHSTATUSPTR(status);
RETURN(status);
}
/**
* Looks into the input file containing list of lines, does some checks on the
* file format, and calculates the number of harmonic sets in this file.
*/
void LALFindNumberHarmonics (LALStatus *status, /**< pointer to LALStatus structure */
LineHarmonicsInfo *harmonicInfo, /**< list of harmonics */
CHAR *fname /**< input filename */)
{
FILE *fp = NULL;
CHAR dump[128];
INT4 harmonicCount, r, tempint;
REAL8 temp1, temp2, temp3, temp4;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* make sure arguments are not null */
ASSERT (harmonicInfo, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL );
/* ASSERT (harmonicInfo->nHarmonicSets > 0, status, SFTCLEANH_EVAL, SFTCLEANH_MSGEVAL);
ASSERT (harmonicInfo->startFreq, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (harmonicInfo->gapFreq, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (harmonicInfo->numHarmonics, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (harmonicInfo->leftWing, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL);
ASSERT (harmonicInfo->rightWing, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL); */ /* 09/09/05 gam */
ASSERT (fname, status, SFTCLEANH_ENULL, SFTCLEANH_MSGENULL );
/* open harmonics file for reading */
fp = fopen( fname, "r");
/* ASSERT (fname, status, SFTCLEANH_EFILE, SFTCLEANH_MSGEFILE); */ /* 09/09/05 gam */
ASSERT (fp, status, SFTCLEANH_EFILE, SFTCLEANH_MSGEFILE);
harmonicCount = 0;
do {
r=fscanf(fp,"%lf%lf%d%lf%lf%s\n", &temp1, &temp2,
&tempint, &temp3, &temp4, dump);
/* make sure the line has the right number of entries or is EOF */
ASSERT( (r==6)||(r==EOF), status, SFTCLEANH_EHEADER, SFTCLEANH_MSGEVAL);
if (r==6) harmonicCount++;
} while ( r != EOF);
harmonicInfo->nHarmonicSets = harmonicCount;
fclose(fp);
DETATCHSTATUSPTR (status);
/* normal exit */
RETURN (status);
}
void LALUCHAR2HOUGHPeak(LALStatus *status,
HOUGHPeakGram *pgOut,
UCHARPeakGram *pgIn)
{
INT4 length;
UINT4 nPeaks;
/* --------------------------------------------- */
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* Make sure the arguments are not NULL: */
ASSERT (pgIn, status, PEAKSELECTH_ENULL, PEAKSELECTH_MSGENULL);
ASSERT (pgOut, status, PEAKSELECTH_ENULL, PEAKSELECTH_MSGENULL);
length = pgIn->length;
pgOut->deltaF = 1./pgIn->timeBase;
pgOut->fBinIni = pgIn->fminBinIndex;
pgOut->fBinFin = pgOut->fBinIni + length -1;
nPeaks = pgIn->nPeaks;
ASSERT (nPeaks==pgOut->length, status, PEAKSELECTH_EVAL, PEAKSELECTH_MSGEVAL);
if (nPeaks >0){
INT4 *peak;
UCHAR *in1;
INT4 i;
ASSERT (pgOut->peak, status, PEAKSELECTH_ENULL, PEAKSELECTH_MSGENULL);
ASSERT (pgIn->data, status, PEAKSELECTH_ENULL, PEAKSELECTH_MSGENULL);
peak = pgOut->peak;
in1 = pgIn->data;
for (i=0; i < length; i++){
if (*in1){
*peak = i;
++peak;
}
++in1;
}
}
DETATCHSTATUSPTR (status);
/* normal exit */
RETURN (status);
}
/**
* \ingroup LALInspiralBank_h
* \brief Function to update the parameters used in creating a coarse bank based on a square lattice.
* \author Sathyaprakash, B. S., T. Cokelaer
*
* While scanning the \f$\tau_0\f$-direction after reaching the
* boundary of the parameter space, we have to return to the
* starting point of the same line and use the metric there
* to increment one step upwards in the direction of \f$\tau_{2(3)}.\f$
* to a <em>template list</em>.
*
* The \f$dx_i\f$ returned by this function gives the spacing for a
* square lattice (e.g., \f$dx_i\f$ as given in \cite Owen_96.
*
* ### Algorithm ###
*
* Copy the parameters in the temporary parameter structure
* to the current parameter structure.
*/
void LALInspiralUpdateParams(LALStatus *status, /**< LAL status pointer */
InspiralBankParams *bankParams, /**< [out] refreshed to get the next location */
InspiralMetric metric, /**< [in] metric at the current location */
REAL8 minimalmatch /**< [in] the minimal match */
)
{
REAL8 dx0, dx1, myphi, theta, fac;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
ASSERT (bankParams, status, LALINSPIRALBANKH_ENULL, LALINSPIRALBANKH_MSGENULL);
ASSERT (metric.g00 > 0, status, LALINSPIRALBANKH_ESIZE, LALINSPIRALBANKH_MSGESIZE);
ASSERT (metric.g11 > 0, status, LALINSPIRALBANKH_ESIZE, LALINSPIRALBANKH_MSGESIZE);
ASSERT (minimalmatch < 1., status, LALINSPIRALBANKH_ESIZE, LALINSPIRALBANKH_MSGESIZE);
ASSERT (minimalmatch > 0., status, LALINSPIRALBANKH_ESIZE, LALINSPIRALBANKH_MSGESIZE);
ASSERT (metric.theta < LAL_PI_2, status, LALINSPIRALBANKH_ESIZE, LALINSPIRALBANKH_MSGESIZE);
ASSERT (metric.theta > -LAL_PI_2, status, LALINSPIRALBANKH_ESIZE, LALINSPIRALBANKH_MSGESIZE);
/* This dx0, dx1 are linked to a square placement only !! */
dx0 = sqrt(2.L * (1.L - minimalmatch)/metric.g00 );
dx1 = sqrt(2.L * (1.L - minimalmatch)/metric.g11 );
if (metric.theta==0.L)
{
bankParams->dx0 = dx0;
bankParams->dx1 = dx1;
}
else
{
myphi = atan2(dx1, dx0);
theta = fabs(metric.theta);
if (theta <= myphi) {
fac = cos(theta);
bankParams->dx0 = dx0 / fac;
bankParams->dx1 = dx1 * fac;
}
else {
fac = sin(theta);
bankParams->dx0 = dx1 / fac;
bankParams->dx1 = dx0 * fac;
}
}
DETATCHSTATUSPTR(status);
RETURN(status);
}
void FUNC ( LALStatus *status, STYPE **aseq )
{
/*
* Initialize status
*/
INITSTATUS(status);
ATTATCHSTATUSPTR( status );
/*
* Check aseq: is it non-NULL?
*/
ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
/*
* Check aseq: does it point to non-NULL?
*/
ASSERT (*aseq != NULL,status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);
/*
* Check dimLength in aseq: does it point to non-NULL?
*/
ASSERT ((*aseq)->dimLength != NULL, status,
SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);
/*
* Check data in aseq: does it point to non-NULL?
*/
ASSERT ((*aseq)->data != NULL, status,
SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);
/* Ok, now let's free allocated storage */
TRY( LALU4DestroyVector( status->statusPtr, &((*aseq)->dimLength) ),
status );
LALFree ( (*aseq)->data ); /* free allocated data */
LALFree ( *aseq ); /* free aseq struct itself */
*aseq = NULL; /* make sure we don't point to freed struct */
DETATCHSTATUSPTR( status );
RETURN (status);
}
