自学教程：C++ ATTATCHSTATUSPTR函数代码示例

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, &params);     *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 */voidLALBinaryPulsarDeltaT( 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 */voidLALDSymmetricEigenValues( 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 );}

voidLALStringToZ(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); }

voidLALInspiralEccentricityTemplates(   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" */voidInitUserVars (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);}

voidLALFreqTimeRealFFT(    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 functionvoid 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 */voidLALGetSingleNRMetaData( 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);}

voidLALMakeTemplateBank(     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*/

voidLALInspiralRestrictedAmplitude (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);}