int
main(int argc, char **argv)
{
static LALStatus stat; /* LALStatus pointer */
CHAR *infile = NULL; /* The input filename */
CHAR *outfile = NULL; /* The output filename */
INT4 arg; /* Argument counter */
UINT4 npts = NPTS; /* Number of points in time series */
UINT4 offset = OFFSET; /* Position of delta function */
REAL8 dt = DT; /* Sampling interval. */
static REAL4TimeSeries series; /* Time series */
static PassBandParamStruc params; /* Filter parameters */
XLALSetErrorHandler( XLALAbortErrorHandler );
/* Set up the default filter parameters. */
params.f1 = F1;
params.f2 = F2;
params.a1 = A1;
params.a2 = A2;
params.nMax = ORDER;
/* Parse argument list. i stores the current position. */
arg = 1;
while ( arg < argc ) {
/* Parse debuglevel option. */
if ( !strcmp( argv[arg], "-d" ) ) {
if ( argc > arg + 1 ) {
arg++;
} else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
}
/* Parse input file option. */
else if ( !strcmp( argv[arg], "-i" ) ) {
if ( argc > arg + 1 ) {
arg++;
infile = argv[arg++];
} else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
}
/* Parse output file option. */
else if ( !strcmp( argv[arg], "-o" ) ) {
if ( argc > arg + 1 ) {
arg++;
outfile = argv[arg++];
} else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
}
/* Parse filter options. */
else if ( !strcmp( argv[arg], "-f" ) ) {
if ( argc > arg + 5 ) {
arg++;
params.f1=atof(argv[arg++]);
params.f2=atof(argv[arg++]);
params.a1=atof(argv[arg++]);
params.a2=atof(argv[arg++]);
params.nMax=atoi(argv[arg++]);
} else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
}
/* Parse time series options. */
else if ( !strcmp( argv[arg], "-n" ) ) {
if ( argc > arg + 3 ) {
arg++;
npts=atoi(argv[arg++]);
dt=atof(argv[arg++]);
offset=atoi(argv[arg++]);
} else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
}
/* Unrecognized option. */
else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
} /* End of argument parsing loop. */
/* Check input values. */
if ( !infile ) {
if ( offset >= npts ) {
ERROR( BANDPASSTESTC_EBAD, BANDPASSTESTC_MSGEBAD, 0 );
LALPrintError( "\toffset=%i must be less than npts=%i\n", offset,
npts );
return BANDPASSTESTC_EBAD;
}
}
/* Create the time series. */
if ( infile ) {
FILE *fp = fopen( infile, "r" );
if ( !fp ) {
ERROR( BANDPASSTESTC_EFILE, BANDPASSTESTC_MSGEFILE, infile );
return BANDPASSTESTC_EFILE;
}
SUB( LALSReadTSeries( &stat, &series, fp ), &stat );
fclose( fp );
} else {
snprintf( series.name, LALNameLength, "%s", "Impulse" );
series.deltaT = dt;
SUB( LALSCreateVector( &stat, &(series.data), npts ), &stat );
memset( series.data->data, 0, npts*sizeof(REAL4) );
series.data->data[offset] = 1.0;
}
/* Filter the time series. */
SUB( LALDButterworthREAL4TimeSeries( &stat, &series, ¶ms ),
&stat );
/* Print the output, if the -o option was given. */
if ( outfile ) {
FILE *fp = fopen( outfile, "w" );
if ( !fp ){
ERROR( BANDPASSTESTC_EFILE, BANDPASSTESTC_MSGEFILE, outfile );
return BANDPASSTESTC_EFILE;
}
SUB( LALSWriteTSeries( &stat, fp, &series ), &stat );
fclose( fp );
}
/* Free memory and exit. */
SUB( LALSDestroyVector( &stat, &(series.data) ), &stat );
LALCheckMemoryLeaks();
INFO( BANDPASSTESTC_MSGENORM );
return BANDPASSTESTC_ENORM;
}
/** \see See \ref DetInverse_c for documentation */
void
LALSMatrixInverse( LALStatus *stat, REAL4 *det, REAL4Array *matrix, REAL4Array *inverse )
{
INT2 sgn; /* sign of permutation. */
UINT4 n, i, j, ij; /* array dimension and indecies */
UINT4Vector *indx = NULL; /* permutation storage vector */
REAL4Vector *col = NULL; /* columns of inverse matrix */
INITSTATUS(stat);
ATTATCHSTATUSPTR( stat );
/* Check dimension length. Other argument testing is done by the
subroutines. */
ASSERT( matrix, stat, MATRIXUTILSH_ENUL, MATRIXUTILSH_MSGENUL );
ASSERT( matrix->dimLength, stat, MATRIXUTILSH_ENUL,
MATRIXUTILSH_MSGENUL );
ASSERT( matrix->dimLength->data, stat, MATRIXUTILSH_ENUL,
MATRIXUTILSH_MSGENUL );
ASSERT( inverse, stat, MATRIXUTILSH_ENUL, MATRIXUTILSH_MSGENUL );
ASSERT( inverse->dimLength, stat, MATRIXUTILSH_ENUL,
MATRIXUTILSH_MSGENUL );
ASSERT( inverse->dimLength->data, stat, MATRIXUTILSH_ENUL,
MATRIXUTILSH_MSGENUL );
ASSERT( inverse->dimLength->length == 2, stat, MATRIXUTILSH_EDIM,
MATRIXUTILSH_MSGEDIM );
n = inverse->dimLength->data[0];
ASSERT( n, stat, MATRIXUTILSH_EDIM, MATRIXUTILSH_MSGEDIM );
ASSERT( n == inverse->dimLength->data[1], stat, MATRIXUTILSH_EDIM,
MATRIXUTILSH_MSGEDIM );
/* Allocate vectors to store the matrix permutation and column
vectors. */
TRY( LALU4CreateVector( stat->statusPtr, &indx, n ), stat );
LALSCreateVector( stat->statusPtr, &col, n );
BEGINFAIL( stat ) {
TRY( LALU4DestroyVector( stat->statusPtr, &indx ), stat );
} ENDFAIL( stat );
/* Decompose the matrix. */
sgn = 0; /* silence -Werror=maybe-uninitialized. note: there is no check here that LALSLUDecomp() is successful and the compiler knows this. *that's* the real problem, but I'm not fixing (Kipp) */
LALSLUDecomp( stat->statusPtr, &sgn, matrix, indx );
BEGINFAIL( stat ) {
TRY( LALU4DestroyVector( stat->statusPtr, &indx ), stat );
TRY( LALSDestroyVector( stat->statusPtr, &col ), stat );
} ENDFAIL( stat );
/* Compute the determinant, if available. */
if ( det ) {
*det = sgn;
for ( i = 0; i < n; i++ )
*det *= matrix->data[i*(n+1)];
}
/* Compute each column of inverse matrix. */
for ( j = 0; j < n; j++ ) {
memset( col->data, 0, n*sizeof(REAL4) );
col->data[j] = 1.0;
LALSLUBackSub( stat->statusPtr, col, matrix, indx );
BEGINFAIL( stat ) {
TRY( LALU4DestroyVector( stat->statusPtr, &indx ), stat );
TRY( LALSDestroyVector( stat->statusPtr, &col ), stat );
} ENDFAIL( stat );
for ( i = 0, ij = j; i < n; i++, ij += n )
inverse->data[ij] = col->data[i];
}
/* Clean up. */
TRY( LALU4DestroyVector( stat->statusPtr, &indx ), stat );
TRY( LALSDestroyVector( stat->statusPtr, &col ), stat );
DETATCHSTATUSPTR( stat );
RETURN( stat );
}
void
LALCoarseFitToPulsar ( LALStatus *status,
CoarseFitOutput *output,
CoarseFitInput *input,
CoarseFitParams *params )
{
/******* DECLARE VARIABLES ************/
UINT4 n,i; /* integer indices */
REAL8 psi;
REAL8 h0/*,h*/;
REAL8 cosIota;
REAL8 phase;
REAL8 chiSquare;
LALDetector detector;
LALSource pulsar;
LALDetAndSource detAndSource;
LALDetAMResponse computedResponse;
REAL4Vector *Fp, *Fc; /* pointers to amplitude responses of the detector */
REAL8Vector *var;
REAL8 cos2phase,sin2phase;
COMPLEX16 Xp, Xc;
REAL8 Y, cosIota2;
COMPLEX16 A,B;
REAL8 sumAA, sumBB, sumAB;
REAL8 h0BestFit=0,phaseBestFit=0, psiBestFit=0, cosIotaBestFit=0;
REAL8 minChiSquare;
COMPLEX16 eh0;
REAL8 oldMinEh0, oldMaxEh0, weh0;
UINT4 iH0, iCosIota, iPhase, iPsi, arg;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/******* CHECK VALIDITY OF ARGUMENTS ************/
ASSERT(output != (CoarseFitOutput *)NULL, status,
FITTOPULSARH_ENULLOUTPUT, FITTOPULSARH_MSGENULLOUTPUT);
ASSERT(params != (CoarseFitParams *)NULL, status,
FITTOPULSARH_ENULLPARAMS, FITTOPULSARH_MSGENULLPARAMS);
ASSERT(input != (CoarseFitInput *)NULL, status,
FITTOPULSARH_ENULLINPUT, FITTOPULSARH_MSGENULLINPUT);
ASSERT(input->B->length == input->var->length, status,
FITTOPULSARH_EVECSIZE , FITTOPULSARH_MSGEVECSIZE );
/******* EXTRACT INPUTS AND PARAMETERS ************/
n = input->B->length;
for (i = 0; i < n; i++)
ASSERT(creal(input->var->data[i]) > 0.0 && cimag(input->var->data[i]) > 0.0, status,
FITTOPULSARH_EVAR, FITTOPULSARH_MSGEVAR);
detector = params->detector;
detAndSource.pDetector = &detector;
pulsar = params->pulsarSrc;
/******* ALLOCATE MEMORY TO VECTORS **************/
Fp = NULL;
LALSCreateVector(status->statusPtr, &Fp, n);
Fp->length = n;
Fc = NULL;
LALSCreateVector(status->statusPtr, &Fc, n);
Fc->length = n;
var = NULL;
LALDCreateVector(status->statusPtr, &var, n);
var->length = n;
/******* INITIALIZE VARIABLES *******************/
minChiSquare = INICHISQU;
oldMaxEh0 = INIMAXEH;
oldMinEh0 = INIMINEH;
for (i=0;i<n;i++)
{
var->data[i] = creal(input->var->data[i]) + cimag(input->var->data[i]);
}
/******* DO ANALYSIS ************/
for (iPsi = 0; iPsi < params->meshPsi[2]; iPsi++)
{
psi = params->meshPsi[0] + iPsi*params->meshPsi[1];
pulsar.orientation = psi;
detAndSource.pSource = &pulsar;
/* create vectors containing amplitude response of detector for specified times */
for (i=0;i<n;i++)
{
LALComputeDetAMResponse(status->statusPtr, &computedResponse,&detAndSource, &input->t[i]);
Fp->data[i] = (REAL8)computedResponse.plus;
Fc->data[i] = (REAL8)computedResponse.cross;
}
for (iPhase = 0; iPhase < params->meshPhase[2]; iPhase++)
{
phase = params->meshPhase[0] + iPhase*params->meshPhase[1];
cos2phase = cos(2.0*phase);
sin2phase = sin(2.0*phase);
for (iCosIota = 0; iCosIota < params->meshCosIota[2]; iCosIota++)
{
cosIota = params->meshCosIota[0] + iCosIota*params->meshCosIota[1];
cosIota2 = 1.0 + cosIota*cosIota;
Xp = crect( cosIota2 * cos2phase, cosIota2 * sin2phase );
Y = 2.0*cosIota;
Xc = crect( Y*sin2phase, -Y*cos2phase );
sumAB = 0.0;
sumAA = 0.0;
sumBB = 0.0;
eh0 = 0.0;
for (i = 0; i < n; i++)
{
B = input->B->data[i];
A = crect( Fp->data[i]*creal(Xp) + Fc->data[i]*creal(Xc), Fp->data[i]*cimag(Xp) + Fc->data[i]*cimag(Xc) );
sumBB += (creal(B)*creal(B) + cimag(B)*cimag(B)) / var->data[i];
sumAA += (creal(A)*creal(A) + cimag(A)*cimag(A)) / var->data[i];
sumAB += (creal(B)*creal(A) + cimag(B)*cimag(A)) / var->data[i];
/**** calculate error on h0 **********/
eh0 += crect( (Fp->data[i]*cosIota2*cos2phase + 2.0*Fc->data[i]*cosIota*sin2phase) * (Fp->data[i]*cosIota2*cos2phase + 2.0*Fc->data[i]*cosIota*sin2phase) / creal(input->var->data[i]), (Fp->data[i]*cosIota2*sin2phase - 2.0*Fc->data[i]*cosIota*cos2phase) * (Fp->data[i]*cosIota2*sin2phase - 2.0*Fc->data[i]*cosIota*cos2phase) / cimag(input->var->data[i]) );
}
for (iH0 = 0; iH0 < params->meshH0[2]; iH0++)
{
h0 = params->meshH0[0] + iH0*params->meshH0[1];
chiSquare = sumBB - 2.0*h0*sumAB + h0*h0*sumAA;
if (chiSquare<minChiSquare)
{
minChiSquare = chiSquare;
h0BestFit = h0;
cosIotaBestFit = cosIota;
psiBestFit = psi;
phaseBestFit = phase;
output->eh0[0] = 1.0 /sqrt(sqrt(creal(eh0)*creal(eh0) + cimag(eh0)*cimag(eh0)));
}
weh0 = 1.0 /sqrt(sqrt(creal(eh0)*creal(eh0) + cimag(eh0)*cimag(eh0)));
if (weh0>oldMaxEh0)
{
output->eh0[2] = weh0;
oldMaxEh0 = weh0;
}
if (weh0<oldMinEh0)
{
output->eh0[1] = weh0;
oldMinEh0 = weh0;
}
arg = iH0 + params->meshH0[2]*(iCosIota + params->meshCosIota[2]*(iPhase + params->meshPhase[2]*iPsi));
output->mChiSquare->data[arg] = chiSquare;
}
}
}
}
/******* CONSTRUCT OUTPUT ************/
output->h0 = h0BestFit;
output->cosIota = cosIotaBestFit;
output->phase = phaseBestFit;
output->psi = psiBestFit;
output->chiSquare = minChiSquare;
ASSERT(minChiSquare < INICHISQU, status,
FITTOPULSARH_EMAXCHI , FITTOPULSARH_MSGEMAXCHI);
LALSDestroyVector(status->statusPtr, &Fp);
LALSDestroyVector(status->statusPtr, &Fc);
LALDDestroyVector(status->statusPtr, &var);
DETATCHSTATUSPTR(status);
RETURN(status);
}
void
LALFindChirpTDTemplate (
LALStatus *status,
FindChirpTemplate *fcTmplt,
InspiralTemplate *tmplt,
FindChirpTmpltParams *params
)
{
UINT4 j;
UINT4 shift;
UINT4 waveLength;
UINT4 numPoints;
REAL4 *xfac;
REAL8 deltaF;
REAL8 deltaT;
REAL8 sampleRate;
const REAL4 cannonDist = 1.0; /* Mpc */
/*CHAR infomsg[512];*/
PPNParamStruc ppnParams;
CoherentGW waveform;
REAL4Vector *tmpxfac = NULL; /* Used for band-passing */
INITSTATUS(status);
ATTATCHSTATUSPTR( status );
/*
*
* check that the arguments are reasonable
*
*/
/* check that the output structures exist */
ASSERT( fcTmplt, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
ASSERT( fcTmplt->data, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
ASSERT( fcTmplt->data->data, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
/* check that the parameter structure exists */
ASSERT( params, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
ASSERT( params->xfacVec, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
ASSERT( params->xfacVec->data, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
/* check we have an fft plan for the template */
ASSERT( params->fwdPlan, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
/* check that the timestep is positive */
ASSERT( params->deltaT > 0, status,
FINDCHIRPTDH_EDELT, FINDCHIRPTDH_MSGEDELT );
/* check that the input exists */
ASSERT( tmplt, status, FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
/* store deltaT and zero out the time domain waveform vector */
deltaT = params->deltaT;
sampleRate = 1.0 / deltaT;
xfac = params->xfacVec->data;
numPoints = params->xfacVec->length;
memset( xfac, 0, numPoints * sizeof(REAL4) );
ASSERT( numPoints == (2 * (fcTmplt->data->length - 1)), status,
FINDCHIRPTDH_EMISM, FINDCHIRPTDH_MSGEMISM );
/* choose the time domain template */
if ( params->approximant == GeneratePPN )
{
/*
*
* generate the waveform using LALGeneratePPNInspiral() from inject
*
*/
/* input parameters */
memset( &ppnParams, 0, sizeof(PPNParamStruc) );
ppnParams.deltaT = deltaT;
ppnParams.mTot = tmplt->mass1 + tmplt->mass2;
ppnParams.eta = tmplt->mass1 * tmplt->mass2 /
( ppnParams.mTot * ppnParams.mTot );
ppnParams.d = 1.0;
ppnParams.fStartIn = params->fLow;
ppnParams.fStopIn = -1.0 /
(6.0 * sqrt(6.0) * LAL_PI * ppnParams.mTot * LAL_MTSUN_SI);
/* generate waveform amplitude and phase */
memset( &waveform, 0, sizeof(CoherentGW) );
LALGeneratePPNInspiral( status->statusPtr, &waveform, &ppnParams );
CHECKSTATUSPTR( status );
/* print termination information and check sampling */
LALInfo( status, ppnParams.termDescription );
if ( ppnParams.dfdt > 2.0 )
{
ABORT( status, FINDCHIRPTDH_ESMPL, FINDCHIRPTDH_MSGESMPL );
}
if ( waveform.a->data->length > numPoints )
{
ABORT( status, FINDCHIRPTDH_ELONG, FINDCHIRPTDH_MSGELONG );
}
/* compute h(t) */
for ( j = 0; j < waveform.a->data->length; ++j )
{
xfac[j] =
waveform.a->data->data[2*j] * cos( waveform.phi->data->data[j] );
}
/* free the memory allocated by LALGeneratePPNInspiral() */
LALSDestroyVectorSequence( status->statusPtr, &(waveform.a->data) );
CHECKSTATUSPTR( status );
LALSDestroyVector( status->statusPtr, &(waveform.f->data) );
CHECKSTATUSPTR( status );
LALDDestroyVector( status->statusPtr, &(waveform.phi->data) );
CHECKSTATUSPTR( status );
LALFree( waveform.a );
LALFree( waveform.f );
LALFree( waveform.phi );
/* waveform parameters needed for findchirp filter */
tmplt->approximant = params->approximant;
tmplt->tC = ppnParams.tc;
tmplt->fFinal = ppnParams.fStop;
fcTmplt->tmpltNorm = params->dynRange / ( cannonDist * 1.0e6 * LAL_PC_SI );
fcTmplt->tmpltNorm *= fcTmplt->tmpltNorm;
}
else
{
/*
*
* generate the waveform by calling LALInspiralWave() from inspiral
*
*/
/* set up additional template parameters */
deltaF = 1.0 / ((REAL8) numPoints * deltaT);
tmplt->ieta = 1;
tmplt->approximant = params->approximant;
tmplt->order = params->order;
tmplt->massChoice = m1Andm2;
tmplt->tSampling = sampleRate;
tmplt->fLower = params->fLow;
tmplt->fCutoff = sampleRate / 2.0 - deltaF;
/* get the template norm right */
if ( params->approximant==EOBNR )
{
/* lalinspiral EOBNR code produces correct norm when
fed unit signalAmplitude and non-physical distance */
tmplt->signalAmplitude = 1.0;
tmplt->distance = -1.0;
}
else if ( params->approximant==EOBNRv2 )
{
/* this formula sets the ampl0 variable to 1.0
* within the lalsimulation EOBNRv2 waveform engine
* which again produces a correct template norm */
tmplt->distance = tmplt->totalMass*LAL_MRSUN_SI;
}
else if ( params->approximant==IMRPhenomD )
{
/* 1Mpc standard distance - not clear if this produces correct norm */
tmplt->distance = 1.0;
}
else if ( (params->approximant==IMRPhenomB) || (params->approximant==IMRPhenomC) )
{
XLALPrintError("**** LALFindChirpTDTemplate ERROR ****\n");
XLALPrintError("Old IMRPhenom approximant requested! Please switch to IMRPhenomD.\n");
XLALPrintError("If an approximant that precedes IMRPhenomD MUST be used, then\n");
XLALPrintError("comment out lines 251-257 in lalinspiral/src/FindChirpTDTemplate.c,\n");
XLALPrintError("recompile, and rerun.\n");
XLALPrintError("**************************************\n");
XLAL_ERROR_VOID(XLAL_EFUNC);
/* 1Mpc standard distance - not clear if this produces correct norm */
tmplt->distance = 1.0;
tmplt->spin1[2] = 2 * tmplt->chi/(1. + sqrt(1.-4.*tmplt->eta));
}
else
{
tmplt->distance = -1.0;
}
/* compute the tau parameters from the input template */
LALInspiralParameterCalc( status->statusPtr, tmplt );
CHECKSTATUSPTR( status );
/* determine the length of the chirp in sample points */
/* This call implicitely checks that a valid approximant+order combination
was fed in, because LALInspiralWaveLength calls XLALInspiralChooseModel
which is what ultimately limits the available choices. */
LALInspiralWaveLength( status->statusPtr, &waveLength, *tmplt );
CHECKSTATUSPTR( status );
if ( waveLength > numPoints )
{
ABORT( status, FINDCHIRPTDH_ELONG, FINDCHIRPTDH_MSGELONG );
}
/* generate the chirp in the time domain */
LALInspiralWave( status->statusPtr, params->xfacVec, tmplt );
CHECKSTATUSPTR( status );
/* template dependent normalization */
fcTmplt->tmpltNorm = 2 * tmplt->mu;
fcTmplt->tmpltNorm *= 2 * LAL_MRSUN_SI / ( cannonDist * 1.0e6 * LAL_PC_SI );
fcTmplt->tmpltNorm *= params->dynRange;
fcTmplt->tmpltNorm *= fcTmplt->tmpltNorm;
}
/* Taper the waveform if required */
if ( params->taperTmplt != LAL_SIM_INSPIRAL_TAPER_NONE )
{
if ( XLALSimInspiralREAL4WaveTaper( params->xfacVec, params->taperTmplt )
== XLAL_FAILURE )
{
ABORTXLAL( status );
}
}
/* Find the end of the chirp */
j = numPoints - 1;
while ( xfac[j] == 0 )
{
/* search for the end of the chirp but don't fall off the array */
if ( --j == 0 )
{
ABORT( status, FINDCHIRPTDH_EEMTY, FINDCHIRPTDH_MSGEEMTY );
}
}
++j;
/* Band pass the template if required */
if ( params->bandPassTmplt )
{
REAL4Vector bpVector; /*Used to save time */
/* We want to shift the template to the middle of the vector so */
/* that band-passing will work properly */
shift = ( numPoints - j ) / 2;
memmove( xfac + shift, xfac, j * sizeof( *xfac ) );
memset( xfac, 0, shift * sizeof( *xfac ) );
memset( xfac + ( numPoints + j ) / 2, 0,
( numPoints - ( numPoints + j ) / 2 ) * sizeof( *xfac ) );
/* Select an appropriate part of the vector to band pass. */
/* band passing the whole thing takes a lot of time */
if ( j > 2 * sampleRate && 2 * j <= numPoints )
{
bpVector.length = 2 * j;
bpVector.data = params->xfacVec->data + numPoints / 2 - j;
}
else if ( j <= 2 * sampleRate && j + 2 * sampleRate <= numPoints )
{
bpVector.length = j + 2 * sampleRate;
bpVector.data = params->xfacVec->data
+ ( numPoints - j ) / 2 - (INT4)sampleRate;
}
else
{
bpVector.length = params->xfacVec->length;
bpVector.data = params->xfacVec->data;
}
if ( XLALBandPassInspiralTemplate( &bpVector, 0.95 * tmplt->fLower,
1.02 * tmplt->fFinal, sampleRate ) == XLAL_FAILURE )
{
ABORTXLAL( status );
}
/* Now we need to do the shift to the end. */
/* Use a temporary vector to avoid mishaps */
if ( ( tmpxfac = XLALCreateREAL4Vector( numPoints ) ) == NULL )
{
ABORTXLAL( status );
}
if ( params->approximant == EOBNR || params->approximant == EOBNRv2
|| params->approximant == IMRPhenomB || params->approximant == IMRPhenomC )
{
/* We need to do something slightly different for EOBNR */
UINT4 endIndx = (UINT4) (tmplt->tC * sampleRate);
memcpy( tmpxfac->data, xfac + ( numPoints - j ) / 2 + endIndx,
( numPoints - ( numPoints - j ) / 2 - endIndx ) * sizeof( *xfac ) );
memcpy( tmpxfac->data + numPoints - ( numPoints - j ) / 2 - endIndx,
xfac, ( ( numPoints - j ) / 2 + endIndx ) * sizeof( *xfac ) );
}
else
{
memcpy( tmpxfac->data, xfac + ( numPoints + j ) / 2,
( numPoints - ( numPoints + j ) / 2 ) * sizeof( *xfac ) );
memcpy( tmpxfac->data + numPoints - ( numPoints + j ) / 2,
xfac, ( numPoints + j ) / 2 * sizeof( *xfac ) );
}
memcpy( xfac, tmpxfac->data, numPoints * sizeof( *xfac ) );
XLALDestroyREAL4Vector( tmpxfac );
tmpxfac = NULL;
}
else if ( params->approximant == EOBNR || params->approximant == EOBNRv2
|| params->approximant == IMRPhenomB || params->approximant == IMRPhenomC )
{
/* For EOBNR we shift so that tC is at the end of the vector */
if ( ( tmpxfac = XLALCreateREAL4Vector( numPoints ) ) == NULL )
{
ABORTXLAL( status );
}
/* Set the coalescence index depending on tC */
j = (UINT4) (tmplt->tC * sampleRate);
memcpy( tmpxfac->data + numPoints - j, xfac, j * sizeof( *xfac ) );
memcpy( tmpxfac->data, xfac + j, ( numPoints - j ) * sizeof( *xfac ) );
memcpy( xfac, tmpxfac->data, numPoints * sizeof( *xfac ) );
XLALDestroyREAL4Vector( tmpxfac );
tmpxfac = NULL;
}
else
{
/* No need for so much shifting around if not band passing */
/* shift chirp to end of vector so it is the correct place for the filter */
memmove( xfac + numPoints - j, xfac, j * sizeof( *xfac ) );
memset( xfac, 0, ( numPoints - j ) * sizeof( *xfac ) );
}
/*
*
* create the frequency domain findchirp template
*
*/
/* fft chirp */
if ( XLALREAL4ForwardFFT( fcTmplt->data, params->xfacVec,
params->fwdPlan ) == XLAL_FAILURE )
{
ABORTXLAL( status );
}
/* copy the template parameters to the findchirp template structure */
memcpy( &(fcTmplt->tmplt), tmplt, sizeof(InspiralTemplate) );
/* normal exit */
DETATCHSTATUSPTR( status );
RETURN( status );
}
int main( int argc, char *argv[] )
{
static LALStatus status;
StochasticOmegaGWParameters parameters;
REAL4FrequencySeries omegaGW;
UINT4 i;
REAL4 omega, f;
INT4 code;
/* define valid parameters */
parameters.alpha = STOCHASTICOMEGAGWTESTC_ALPHA;
parameters.fRef = STOCHASTICOMEGAGWTESTC_FREF;
parameters.omegaRef = STOCHASTICOMEGAGWTESTC_OMEGAREF;
parameters.length = STOCHASTICOMEGAGWTESTC_LENGTH;
parameters.f0 = STOCHASTICOMEGAGWTESTC_F0;
parameters.deltaF = STOCHASTICOMEGAGWTESTC_DELTAF;
omegaGW.data = NULL;
#ifndef LAL_NDEBUG
REAL4FrequencySeries dummyOutput;
dummyOutput.data = NULL;
#endif
ParseOptions( argc, argv );
LALSCreateVector(&status, &(omegaGW.data), STOCHASTICOMEGAGWTESTC_LENGTH);
if ( ( code = CheckStatus(&status, 0 , "",
STOCHASTICOMEGAGWTESTC_EFLS,
STOCHASTICOMEGAGWTESTC_MSGEFLS) ) )
{
return code;
}
/* TEST INVALID DATA HERE ------------------------------------------ */
#ifndef LAL_NDEBUG
if ( ! lalNoDebug )
{
/* test behavior for null pointer to real frequency series for output */
LALStochasticOmegaGW(&status, NULL, ¶meters);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: null pointer to output series results in error: \n\"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* test behavior for null pointer to parameter structure */
LALStochasticOmegaGW(&status, &omegaGW, NULL);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: null pointer to parameter structure results in error: \n\"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* test behavior for null pointer to data member of real frequency
series for output */
LALStochasticOmegaGW(&status, &dummyOutput, ¶meters);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: null pointer to data member of output series results in error: \n\"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* Create a vector for testing null data-data pointer */
LALSCreateVector(&status, &(dummyOutput.data), STOCHASTICOMEGAGWTESTC_LENGTH);
if ( ( code = CheckStatus(&status, 0 , "",
STOCHASTICOMEGAGWTESTC_EFLS,
STOCHASTICOMEGAGWTESTC_MSGEFLS) ) )
{
return code;
}
REAL4 *tempPtr;
tempPtr = dummyOutput.data->data;
dummyOutput.data->data = NULL;
/* test behavior for null pointer to data member of data member of
real frequency series for output */
LALStochasticOmegaGW(&status, &dummyOutput, ¶meters);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: null pointer to data member of data member of output series results in error: \n\"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* clean up */
dummyOutput.data->data = tempPtr;
LALSDestroyVector(&status, &(dummyOutput.data));
if ( ( code = CheckStatus(&status, 0 , "",
STOCHASTICOMEGAGWTESTC_EFLS,
STOCHASTICOMEGAGWTESTC_MSGEFLS) ) )
{
return code;
}
/* test behavior for length parameter equal to zero */
parameters.length = 0;
LALStochasticOmegaGW(&status, &omegaGW, ¶meters);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_EZEROLEN,
STOCHASTICCROSSCORRELATIONH_MSGEZEROLEN,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: zero length parameter results in error: \n\"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGEZEROLEN);
/* assign valid length parameter */
parameters.length = STOCHASTICOMEGAGWTESTC_LENGTH;
/* test behavior for frequency spacing less than or equal to zero */
parameters.deltaF = -1;
LALStochasticOmegaGW(&status, &omegaGW, ¶meters);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_ENONPOSDELTAF,
STOCHASTICCROSSCORRELATIONH_MSGENONPOSDELTAF,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: negative frequency spacing results in error: \n\"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENONPOSDELTAF);
parameters.deltaF = 0;
LALStochasticOmegaGW(&status, &omegaGW, ¶meters);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_ENONPOSDELTAF,
STOCHASTICCROSSCORRELATIONH_MSGENONPOSDELTAF,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: zero frequency spacing results in error: \n\"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENONPOSDELTAF);
/* assign valid frequency spacing */
parameters.deltaF = STOCHASTICOMEGAGWTESTC_DELTAF;
}
#endif /* LAL_NDEBUG */
/* test behavior for negative start frequency */
parameters.f0 = -20.0;
LALStochasticOmegaGW(&status, &omegaGW, ¶meters);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_ENEGFMIN,
STOCHASTICCROSSCORRELATIONH_MSGENEGFMIN,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: negative start frequency results in error:\n \"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENEGFMIN);
/* reassign valid start frequency */
parameters.f0 = STOCHASTICOMEGAGWTESTC_F0;
/* test behavior for length of data member of real frequency series
for output not equal to length specified in input parameters */
parameters.length += 1;
LALStochasticOmegaGW(&status, &omegaGW, ¶meters);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_EMMLEN,
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: mismatch between length of output series and length parameter results in error: \n\"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN);
/* reassign valid length to data member of dummy output */
parameters.length -= 1;
/* test behavior for fRef < deltaf */
parameters.fRef = 0;
LALStochasticOmegaGW(&status, &omegaGW, ¶meters);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_EOORFREF,
STOCHASTICCROSSCORRELATIONH_MSGEOORFREF,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: zero reference frequency results in error: \n\"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGEOORFREF);
parameters.fRef = STOCHASTICOMEGAGWTESTC_FREF;
/* test behavior for omegaRef <=0 */
parameters.omegaRef = -1.0;
LALStochasticOmegaGW(&status, &omegaGW, ¶meters);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_ENONPOSOMEGA,
STOCHASTICCROSSCORRELATIONH_MSGENONPOSOMEGA,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: negative amplitude parameter results in error: \n\"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENONPOSOMEGA);
parameters.omegaRef = 0.0;
LALStochasticOmegaGW(&status, &omegaGW, ¶meters);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_ENONPOSOMEGA,
STOCHASTICCROSSCORRELATIONH_MSGENONPOSOMEGA,
STOCHASTICOMEGAGWTESTC_ECHK,
STOCHASTICOMEGAGWTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: zero amplitude parameter results in error: \n\"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENONPOSOMEGA);
parameters.omegaRef = STOCHASTICOMEGAGWTESTC_OMEGAREF;
/* TEST VALID DATA HERE -------------------------------------------- */
/* generate omegaGW */
LALStochasticOmegaGW(&status, &omegaGW, ¶meters);
if ( ( code = CheckStatus(&status,0, "",
STOCHASTICOMEGAGWTESTC_EFLS,
STOCHASTICOMEGAGWTESTC_MSGEFLS) ) )
{
return code;
}
/* test values */
for (i=0; i<STOCHASTICOMEGAGWTESTC_LENGTH; ++i)
{
f = i * STOCHASTICOMEGAGWTESTC_DELTAF;
omega = STOCHASTICOMEGAGWTESTC_OMEGAREF
* pow(f/STOCHASTICOMEGAGWTESTC_FREF,STOCHASTICOMEGAGWTESTC_ALPHA);
if (optVerbose)
{
printf("Omega(%f Hz)=%g, should be %g\n",
f, omegaGW.data->data[i], omega);
}
if ( (omegaGW.data->data[i] - omega) &&
abs((omegaGW.data->data[i] - omega)/omega) > STOCHASTICOMEGAGWTESTC_TOL )
{
printf(" FAIL: Valid data test #1 (alpha=%f)\n",STOCHASTICOMEGAGWTESTC_ALPHA);
return STOCHASTICOMEGAGWTESTC_EFLS;
}
}
printf(" PASS: Valid data test #1 (alpha=%f)\n",STOCHASTICOMEGAGWTESTC_ALPHA);
/* change parameters */
parameters.alpha = 0.0;
/* generate omegaGW */
LALStochasticOmegaGW(&status, &omegaGW, ¶meters);
if ( ( code = CheckStatus(&status,0, "",
STOCHASTICOMEGAGWTESTC_EFLS,
STOCHASTICOMEGAGWTESTC_MSGEFLS) ) )
{
return code;
}
/* test values */
for (i=0; i<STOCHASTICOMEGAGWTESTC_LENGTH; ++i)
{
f = i * STOCHASTICOMEGAGWTESTC_DELTAF;
if (optVerbose) {
printf("Omega(%f Hz)=%g, should be %g\n",
f, omegaGW.data->data[i], STOCHASTICOMEGAGWTESTC_OMEGAREF);
}
if ( abs(omegaGW.data->data[i] - STOCHASTICOMEGAGWTESTC_OMEGAREF)
/ STOCHASTICOMEGAGWTESTC_OMEGAREF > STOCHASTICOMEGAGWTESTC_TOL )
{
printf(" FAIL: Valid data test #2 (alpha=0)\n");
return STOCHASTICOMEGAGWTESTC_EFLS;
}
}
printf(" PASS: Valid data test #2 (alpha=0)\n");
/* clean up valid data */
LALSDestroyVector(&status, &(omegaGW.data));
if ( ( code = CheckStatus(&status, 0 , "",
STOCHASTICOMEGAGWTESTC_EFLS,
STOCHASTICOMEGAGWTESTC_MSGEFLS) ) )
{
return code;
}
LALCheckMemoryLeaks();
printf("PASS: all tests\n");
if (optFile[0]) {
parameters.alpha = optAlpha;
parameters.length = optLength;
parameters.deltaF = optDeltaF;
parameters.f0 = optF0;
parameters.omegaRef = optOmegaR;
parameters.fRef = optFR;
LALSCreateVector(&status, &(omegaGW.data), optLength);
if ( ( code = CheckStatus(&status, 0 , "",
STOCHASTICOMEGAGWTESTC_EUSE,
STOCHASTICOMEGAGWTESTC_MSGEUSE) ) )
{
return code;
}
LALStochasticOmegaGW(&status, &omegaGW, ¶meters);
if ( ( code = CheckStatus(&status,0, "",
STOCHASTICOMEGAGWTESTC_EUSE,
STOCHASTICOMEGAGWTESTC_MSGEUSE) ) )
{
return code;
}
LALSPrintFrequencySeries( &omegaGW, optFile );
printf("=== Stochastic Gravitational-wave Spectrum Written to File %s ===\n", optFile);
LALSDestroyVector(&status, &(omegaGW.data));
if ( ( code = CheckStatus(&status, 0 , "",
STOCHASTICOMEGAGWTESTC_EUSE,
STOCHASTICOMEGAGWTESTC_MSGEUSE) ) )
{
return code;
}
LALCheckMemoryLeaks();
}
return STOCHASTICOMEGAGWTESTC_ENOM;
}
int main( int argc, char *argv[] )
{
const UINT4 n = 65536;
const REAL4 dt = 1.0 / 16384.0;
static LALStatus status;
static REAL4TimeSeries x;
static COMPLEX8FrequencySeries X;
static REAL4TimeSeries y;
static REAL4FrequencySeries Y;
static COMPLEX8TimeSeries z;
static COMPLEX8FrequencySeries Z;
RealFFTPlan *fwdRealPlan = NULL;
RealFFTPlan *revRealPlan = NULL;
ComplexFFTPlan *fwdComplexPlan = NULL;
ComplexFFTPlan *revComplexPlan = NULL;
RandomParams *randpar = NULL;
AverageSpectrumParams avgSpecParams;
UINT4 srate[] = { 4096, 9000 };
UINT4 npts[] = { 262144, 1048576 };
REAL4 var[] = { 5, 16 };
UINT4 j, sr, np, vr;
/*CHAR fname[2048];*/
ParseOptions( argc, argv );
LALSCreateVector( &status, &x.data, n );
TestStatus( &status, CODES( 0 ), 1 );
LALCCreateVector( &status, &X.data, n / 2 + 1 );
TestStatus( &status, CODES( 0 ), 1 );
LALCCreateVector( &status, &z.data, n );
TestStatus( &status, CODES( 0 ), 1 );
LALCCreateVector( &status, &Z.data, n );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateForwardRealFFTPlan( &status, &fwdRealPlan, n, 0 );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateReverseRealFFTPlan( &status, &revRealPlan, n, 0 );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateForwardComplexFFTPlan( &status, &fwdComplexPlan, n, 0 );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateReverseComplexFFTPlan( &status, &revComplexPlan, n, 0 );
TestStatus( &status, CODES( 0 ), 1 );
randpar = XLALCreateRandomParams( 100 );
/*
*
* Try the real transform.
*
*/
x.f0 = 0;
x.deltaT = dt;
x.sampleUnits = lalMeterUnit;
snprintf( x.name, sizeof( x.name ), "x" );
XLALNormalDeviates( x.data, randpar );
for ( j = 0; j < n; ++j ) /* add a 60 Hz line */
{
REAL4 t = j * dt;
x.data->data[j] += 0.1 * cos( LAL_TWOPI * 60.0 * t );
}
LALSPrintTimeSeries( &x, "x.out" );
snprintf( X.name, sizeof( X.name ), "X" );
LALTimeFreqRealFFT( &status, &X, &x, fwdRealPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALCPrintFrequencySeries( &X, "X.out" );
LALFreqTimeRealFFT( &status, &x, &X, revRealPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALSPrintTimeSeries( &x, "xx.out" );
/*
*
* Try the average power spectum.
*
*/
avgSpecParams.method = useMean;
for ( np = 0; np < XLAL_NUM_ELEM(npts) ; ++np )
{
/* length of time series for 7 segments, overlapped by 1/2 segment */
UINT4 tsLength = npts[np] * 7 - 6 * npts[np] / 2;
LALCreateVector( &status, &y.data, tsLength );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateVector( &status, &Y.data, npts[np] / 2 + 1 );
TestStatus( &status, CODES( 0 ), 1 );
avgSpecParams.overlap = npts[np] / 2;
/* create the window */
avgSpecParams.window = XLALCreateHannREAL4Window(npts[np]);
avgSpecParams.plan = NULL;
LALCreateForwardRealFFTPlan( &status, &avgSpecParams.plan, npts[np], 0 );
TestStatus( &status, CODES( 0 ), 1 );
for ( sr = 0; sr < XLAL_NUM_ELEM(srate) ; ++sr )
{
/* set the sample rate of the time series */
y.deltaT = 1.0 / (REAL8) srate[sr];
for ( vr = 0; vr < XLAL_NUM_ELEM(var) ; ++vr )
{
REAL4 eps = 1e-6; /* very conservative fp precision */
REAL4 Sfk = 2.0 * var[vr] * var[vr] * y.deltaT;
REAL4 sfk = 0;
REAL4 lbn;
REAL4 sig;
REAL4 ssq;
REAL4 tol;
/* create the data */
XLALNormalDeviates( y.data, randpar );
ssq = 0;
for ( j = 0; j < y.data->length; ++j )
{
y.data->data[j] *= var[vr];
ssq += y.data->data[j] * y.data->data[j];
}
/* compute tolerance for comparison */
lbn = log( y.data->length ) / log( 2 );
sig = sqrt( 2.5 * lbn * eps * eps * ssq / y.data->length );
tol = 5 * sig;
/* compute the psd and find the average */
LALREAL4AverageSpectrum( &status, &Y, &y, &avgSpecParams );
TestStatus( &status, CODES( 0 ), 1 );
LALSMoment( &status, &sfk, Y.data, 1 );
TestStatus( &status, CODES( 0 ), 1 );
/* check the result */
if ( fabs(Sfk-sfk) > tol )
{
fprintf( stderr, "FAIL: PSD estimate appears incorrect\n");
fprintf( stderr, "expected %e, got %e ", Sfk, sfk );
fprintf( stderr, "(difference = %e, tolerance = %e)\n",
fabs(Sfk-sfk), tol );
exit(2);
}
}
}
/* destroy structures that need to be resized */
LALDestroyRealFFTPlan( &status, &avgSpecParams.plan );
TestStatus( &status, CODES( 0 ), 1 );
XLALDestroyREAL4Window( avgSpecParams.window );
LALDestroyVector( &status, &y.data );
TestStatus( &status, CODES( 0 ), 1 );
LALDestroyVector( &status, &Y.data );
TestStatus( &status, CODES( 0 ), 1 );
}
/*
*
* Try the complex transform.
*
*/
z.f0 = 0;
z.deltaT = dt;
z.sampleUnits = lalVoltUnit;
snprintf( z.name, sizeof( z.name ), "z" );
{ /* dirty hack */
REAL4Vector tmp;
tmp.length = 2 * z.data->length;
tmp.data = (REAL4 *)z.data->data;
XLALNormalDeviates( &tmp, randpar );
}
for ( j = 0; j < n; ++j ) /* add a 50 Hz line and a 500 Hz ringdown */
{
REAL4 t = j * dt;
z.data->data[j] += 0.2 * cos( LAL_TWOPI * 50.0 * t );
z.data->data[j] += I * exp( -t ) * sin( LAL_TWOPI * 500.0 * t );
}
LALCPrintTimeSeries( &z, "z.out" );
TestStatus( &status, CODES( 0 ), 1 );
snprintf( Z.name, sizeof( Z.name ), "Z" );
LALTimeFreqComplexFFT( &status, &Z, &z, fwdComplexPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALCPrintFrequencySeries( &Z, "Z.out" );
LALFreqTimeComplexFFT( &status, &z, &Z, revComplexPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALCPrintTimeSeries( &z, "zz.out" );
XLALDestroyRandomParams( randpar );
LALDestroyRealFFTPlan( &status, &fwdRealPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALDestroyRealFFTPlan( &status, &revRealPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALDestroyComplexFFTPlan( &status, &fwdComplexPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALDestroyComplexFFTPlan( &status, &revComplexPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALCDestroyVector( &status, &Z.data );
TestStatus( &status, CODES( 0 ), 1 );
LALCDestroyVector( &status, &z.data );
TestStatus( &status, CODES( 0 ), 1 );
LALCDestroyVector( &status, &X.data );
TestStatus( &status, CODES( 0 ), 1 );
LALSDestroyVector( &status, &x.data );
TestStatus( &status, CODES( 0 ), 1 );
LALCheckMemoryLeaks();
return 0;
}
void
LALFitToPulsarStudentT ( LALStatus *status,
CoarseFitOutput *output,
FitInputStudentT *input,
CoarseFitParams *params )
{
/******* DECLARE VARIABLES ************/
UINT4 n,i,j,k;
REAL8 psi;
REAL8 h0;
REAL8 cosIota;
REAL8 phase;
REAL8 chiSquare;
LALDetector detector;
LALSource pulsar;
LALDetAndSource detAndSource;
LALDetAMResponse computedResponse;
REAL4Vector *Fp, *Fc; /* pointers to amplitude responses of the detector */
REAL8 cos2phase,sin2phase;
COMPLEX16 Xp, Xc;
REAL8 Y, cosIota2;
COMPLEX16 A,B;
REAL8 sumAA, sumBB, sumAB;
REAL8 h0BestFit=0,phaseBestFit=0, psiBestFit=0, cosIotaBestFit=0;
REAL8 minChiSquare;
UINT4 iH0, iCosIota, iPhase, iPsi, arg;
LALGPSandAcc pGPSandAcc;
INT4Vector *kVec=NULL;
UINT4 count=0;
REAL8 meanSegLength=0.0;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/******* CHECK VALIDITY OF ARGUMENTS ************/
ASSERT(params != (CoarseFitParams *)NULL, status,
FITTOPULSARH_ENULLPARAMS, FITTOPULSARH_MSGENULLPARAMS);
ASSERT(input != (FitInputStudentT *)NULL, status,
FITTOPULSARH_ENULLINPUT, FITTOPULSARH_MSGENULLINPUT);
/******* EXTRACT INPUTS AND PARAMETERS ************/
n = input->B->length;
detector = params->detector;
detAndSource.pDetector = &detector;
pulsar = params->pulsarSrc;
/******* ALLOCATE MEMORY TO VECTORS **************/
Fp = NULL;
LALSCreateVector(status->statusPtr, &Fp, n);
Fp->length = n;
Fc = NULL;
LALSCreateVector(status->statusPtr, &Fc, n);
Fc->length = n;
/******* INITIALIZE VARIABLES *******************/
for (i=0;i<params->meshH0[2]*params->meshCosIota[2]*params->meshPhase[2]*params->meshPsi[2];i++)
output->mChiSquare->data[i] = 0.0;
/* create kVec of chunk lengths within lock stretches */
LALI4CreateVector(status->statusPtr, &kVec, n);
j=i=0;
while(1){
count++;
if((input->t[i+1].gpsSeconds - input->t[i].gpsSeconds)>180.0 || count==input->N){
kVec->data[j] = count;
count = 0;
/* check if last segment is found this loop */
if(i+1 > n-1)
break;
j++;
}
i++;
/* break clause */
if(i>n-1){
/* set final value of kVec */
kVec->data[j] = count;
break;
}
}
kVec->length = j+1;
for(i=0;i<kVec->length;i++){
meanSegLength += kVec->data[i];
}
fprintf(stderr, "Mean segment length = %f.\n",
meanSegLength/(double)kVec->length);
j=i=count=0;
minChiSquare = INICHISQU;
/******* DO ANALYSIS ************/
for (iPsi = 0; iPsi < params->meshPsi[2]; iPsi++)
{
fprintf(stderr,"%d out of %f iPsi\n", iPsi+1, params->meshPsi[2]);
fflush(stderr);
psi = params->meshPsi[0] + (REAL8)iPsi*params->meshPsi[1];
pulsar.orientation = psi;
detAndSource.pSource = &pulsar;
/* create vectors containing amplitude response of detector for specified times */
for (i=0;i<n;i++){
pGPSandAcc.gps.gpsNanoSeconds = input->t[i].gpsNanoSeconds;
pGPSandAcc.gps.gpsSeconds = input->t[i].gpsSeconds;
pGPSandAcc.accuracy = 1.0;
LALComputeDetAMResponse(status->statusPtr, &computedResponse,&detAndSource, &pGPSandAcc);
Fp->data[i] = (REAL8)computedResponse.plus;
Fc->data[i] = (REAL8)computedResponse.cross;
}
for (iPhase = 0; iPhase < params->meshPhase[2]; iPhase++){
phase = params->meshPhase[0] + (REAL8)iPhase*params->meshPhase[1];
cos2phase = cos(2.0*phase);
sin2phase = sin(2.0*phase);
for (iCosIota = 0; iCosIota < params->meshCosIota[2]; iCosIota++){
INT4 tempLength;
cosIota = params->meshCosIota[0] + (REAL8)iCosIota*params->meshCosIota[1];
cosIota2 = 1.0 + cosIota*cosIota;
Xp.re = 0.25*cosIota2 * cos2phase;
Xp.im = 0.25*cosIota2 * sin2phase;
Y = 0.5*cosIota;
Xc.re = Y*sin2phase;
Xc.im = -Y*cos2phase;
sumAB = 0.0;
sumAA = 0.0;
sumBB = 0.0;
/*k = input->N;*/
count=0;
for (i = 0; i < n-kVec->data[kVec->length-1]; i+=tempLength){
tempLength = kVec->data[count];
/* don't include data segments under 5 mins long */
if(kVec->data[count] < 5){
count++;
continue;
}
sumBB = 0.0;
sumAA = 0.0;
sumAB = 0.0;
for (j=i;j<i+kVec->data[count];j++){
B.re = input->B->data[j].re;
B.im = input->B->data[j].im;
A.re = Fp->data[j]*Xp.re + Fc->data[j]*Xc.re;
A.im = Fp->data[j]*Xp.im + Fc->data[j]*Xc.im;
sumBB += B.re*B.re + B.im*B.im;
sumAA += A.re*A.re + A.im*A.im;
sumAB += B.re*A.re + B.im*A.im;
}
for (iH0 = 0; iH0 < params->meshH0[2]; iH0++){
h0 = params->meshH0[0] + (float)iH0*params->meshH0[1];
chiSquare = sumBB - 2.0*h0*sumAB + h0*h0*sumAA;
arg = iH0 + params->meshH0[2]*(iCosIota + params->meshCosIota[2]*(iPhase + params->meshPhase[2]*iPsi));
output->mChiSquare->data[arg] += 2.0*((REAL8)kVec->data[count])*log(chiSquare);
} /* iH0 */
count++;
} /* n*/
/* find best fit */
for (iH0 = 0; iH0 < params->meshH0[2]; iH0++){
arg = iH0 + params->meshH0[2]*(iCosIota + params->meshCosIota[2]*(iPhase + params->meshPhase[2]*iPsi));
if ((output->mChiSquare->data[arg])<minChiSquare){
minChiSquare = output->mChiSquare->data[arg];
h0 = params->meshH0[0] + (float)iH0*params->meshH0[1];
h0BestFit = h0;
cosIotaBestFit = cosIota;
psiBestFit = psi;
phaseBestFit = phase;
}
} /* end find best fit */
} /* iCosIota */
} /* iPhase */
} /* iPsi */
/******* CONSTRUCT OUTPUT ************/
output->h0 = h0BestFit;
output->cosIota = cosIotaBestFit;
output->phase = phaseBestFit;
output->psi = psiBestFit;
output->chiSquare = minChiSquare;
ASSERT(minChiSquare < INICHISQU, status,
FITTOPULSARH_EMAXCHI , FITTOPULSARH_MSGEMAXCHI);
LALI4DestroyVector(status->statusPtr, &kVec);
LALSDestroyVector(status->statusPtr, &Fp);
LALSDestroyVector(status->statusPtr, &Fc);
DETATCHSTATUSPTR(status);
RETURN(status);
}
int
main( int argc, char **argv )
{
static LALStatus stat; /* status structure */
int arg; /* command-line argument counter */
UINT4 n = SIZE, i, j; /* array size and indecies */
CHAR *infile = NULL; /* input filename */
CHAR *outfile = NULL; /* output filename */
BOOLEAN timing = 0; /* whether -t option was given */
BOOLEAN single = 0; /* whether -s option was given */
BOOLEAN invert = 0; /* whether -v option was given */
REAL4 sDet = 0.0; /* determinant if -s option is given */
REAL8 dDet = 0.0; /* determinant if -s option isn't given */
REAL4Array *sMatrix = NULL; /* matrix if -s option is given */
REAL8Array *dMatrix = NULL; /* matrix if -s option is not given */
REAL4Array *sInverse = NULL; /* inverse if -s option is given */
REAL8Array *dInverse = NULL; /* inverse if -s option isn't given */
UINT4Vector dimLength; /* dimensions used to create matrix */
UINT4 dims[2]; /* dimLength.data array */
clock_t start = 0, stop = 0; /* start and stop times for timing */
FILE *fp = NULL; /* input/output file pointer */
/*******************************************************************
* PARSE ARGUMENTS (arg stores the current position) *
*******************************************************************/
arg = 1;
while ( arg < argc ) {
/* Parse matrix size option. */
if ( !strcmp( argv[arg], "-n" ) ) {
if ( argc > arg + 1 ) {
arg++;
n = atoi( argv[arg++] );
} else {
ERROR( DETINVERSETESTC_EARG, DETINVERSETESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return DETINVERSETESTC_EARG;
}
}
/* Parse input option. */
else if ( !strcmp( argv[arg], "-i" ) ) {
if ( argc > arg + 1 ) {
arg++;
infile = argv[arg++];
} else {
ERROR( DETINVERSETESTC_EARG, DETINVERSETESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return DETINVERSETESTC_EARG;
}
}
/* Parse output option. */
else if ( !strcmp( argv[arg], "-o" ) ) {
if ( argc > arg + 1 ) {
arg++;
outfile = argv[arg++];
} else {
ERROR( DETINVERSETESTC_EARG, DETINVERSETESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return DETINVERSETESTC_EARG;
}
}
/* Parse inversion, single-precision, and timing options. */
else if ( !strcmp( argv[arg], "-v" ) ) {
arg++;
invert = 1;
}
else if ( !strcmp( argv[arg], "-s" ) ) {
arg++;
single = 1;
}
else if ( !strcmp( argv[arg], "-t" ) ) {
arg++;
timing = 1;
}
/* Parse debug level option. */
else if ( !strcmp( argv[arg], "-d" ) ) {
if ( argc > arg + 1 ) {
arg++;
}else{
ERROR( DETINVERSETESTC_EARG, DETINVERSETESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return DETINVERSETESTC_EARG;
}
}
/* Check for unrecognized options. */
else {
ERROR( DETINVERSETESTC_EARG, DETINVERSETESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return DETINVERSETESTC_EARG;
}
} /* End of argument parsing loop. */
/*******************************************************************
* GET INPUT MATRIX *
*******************************************************************/
/* Set up array creation vector. */
dimLength.length = 2;
dimLength.data = dims;
/* Read input matrix file. */
if ( infile ) {
/* Open input file. */
if ( !strcmp( infile, "stdin" ) )
fp = stdin;
else if ( !( fp = fopen( infile, "r" ) ) ) {
ERROR( DETINVERSETESTC_EFILE, "- " DETINVERSETESTC_MSGEFILE, infile );
return DETINVERSETESTC_EFILE;
}
/* Single-precision mode: */
if ( single ) {
REAL4Vector *vec = NULL; /* parsed input line */
/* Read first non-comment line and create array. */
do {
SUB( LALSReadVector( &stat, &vec, fp, 0 ), &stat );
} while ( ( n = vec->length ) == 0 );
dimLength.data[0] = dimLength.data[1] = n;
SUB( LALSCreateArray( &stat, &sMatrix, &dimLength ), &stat );
for ( j = 0; j < n; j++ )
sMatrix->data[j] = vec->data[j];
SUB( LALSDestroyVector( &stat, &vec ), &stat );
/* Read remaining lines. */
for ( i = 1; i < n; i++ ) {
SUB( LALSReadVector( &stat, &vec, fp, 1 ), &stat );
if ( vec->length != n ) {
ERROR( DETINVERSETESTC_EFMT, DETINVERSETESTC_MSGEFMT, 0 );
return DETINVERSETESTC_EFMT;
}
for ( j = 0; j < n; j++ )
sMatrix->data[i*n+j] = vec->data[j];
SUB( LALSDestroyVector( &stat, &vec ), &stat );
}
}
/* Double-precision mode: */
else {
REAL8Vector *vec = NULL; /* parsed input line */
/* Read first non-comment line and create array. */
do {
SUB( LALDReadVector( &stat, &vec, fp, 0 ), &stat );
} while ( ( n = vec->length ) == 0 );
dimLength.data[0] = dimLength.data[1] = n;
SUB( LALDCreateArray( &stat, &dMatrix, &dimLength ), &stat );
for ( j = 0; j < n; j++ )
dMatrix->data[j] = vec->data[j];
SUB( LALDDestroyVector( &stat, &vec ), &stat );
/* Read remaining lines. */
for ( i = 1; i < n; i++ ) {
SUB( LALDReadVector( &stat, &vec, fp, 1 ), &stat );
if ( vec->length != n ) {
ERROR( DETINVERSETESTC_EFMT, DETINVERSETESTC_MSGEFMT, 0 );
return DETINVERSETESTC_EFMT;
}
for ( j = 0; j < n; j++ )
dMatrix->data[i*n+j] = vec->data[j];
SUB( LALDDestroyVector( &stat, &vec ), &stat );
}
}
}
/* Generate random matrix. */
else {
RandomParams *params = NULL;
SUB( LALCreateRandomParams( &stat, ¶ms, 0 ), &stat );
dimLength.data[0] = dimLength.data[1] = n;
/* Single-precision mode: */
if ( single ) {
SUB( LALSCreateArray( &stat, &sMatrix, &dimLength ), &stat );
for ( i = 0; i < n; i++ ) {
REAL4 x;
for ( j = 0; j < n; j++ ) {
SUB( LALUniformDeviate( &stat, &x, params ), &stat );
sMatrix->data[i*n+j] = 2.0*x - 1.0;
}
}
}
/* Double-precision mode: */
else {
SUB( LALDCreateArray( &stat, &dMatrix, &dimLength ), &stat );
for ( i = 0; i < n; i++ ) {
REAL4 x;
for ( j = 0; j < n; j++ ) {
SUB( LALUniformDeviate( &stat, &x, params ), &stat );
dMatrix->data[i*n+j] = 2.0*(REAL8)( x ) - 1.0;
}
}
}
SUB( LALDestroyRandomParams( &stat, ¶ms ), &stat );
}
/* Write input matrix to output file. */
if ( outfile ) {
/* Open output file. */
if ( !strcmp( outfile, "stdout" ) )
fp = stdout;
else if ( !strcmp( outfile, "stderr" ) )
fp = stderr;
else if ( !( fp = fopen( outfile, "r" ) ) ) {
ERROR( DETINVERSETESTC_EFILE, "- " DETINVERSETESTC_MSGEFILE, outfile );
return DETINVERSETESTC_EFILE;
}
/* Single-precision mode: */
if ( single ) {
for ( i = 0; i < n; i++ ) {
fprintf( fp, "%16.9e", sMatrix->data[i*n] );
for ( j = 1; j < n; j++ )
fprintf( fp, " %16.9e", sMatrix->data[i*n+j] );
fprintf( fp, "\n" );
}
}
/* Double-precision mode: */
else {
for ( i = 0; i < n; i++ ) {
fprintf( fp, "%25.17e", dMatrix->data[i*n] );
for ( j = 1; j < n; j++ )
fprintf( fp, " %25.17e", dMatrix->data[i*n+j] );
fprintf( fp, "\n" );
}
}
}
/*******************************************************************
* COMPUTE INVERSE *
*******************************************************************/
if ( timing )
start = clock();
/* Single-precision mode: */
if ( single ) {
if ( invert ) {
SUB( LALSCreateArray( &stat, &sInverse, &dimLength ), &stat );
SUB( LALSMatrixInverse( &stat, &sDet, sMatrix, sInverse ),
&stat );
}
}
/* Double-precision mode: */
else {
if ( invert ) {
SUB( LALDCreateArray( &stat, &dInverse, &dimLength ), &stat );
SUB( LALDMatrixInverse( &stat, &dDet, dMatrix, dInverse ),
&stat );
} else {
SUB( LALDMatrixDeterminant( &stat, &dDet, dMatrix ), &stat );
}
}
if ( timing ) {
stop = clock();
fprintf( stderr, "Elapsed time: %.2f s\n",
(double)( stop - start )/CLOCKS_PER_SEC );
}
/* Write output. */
if ( outfile ) {
/* Write determinant. */
fprintf( fp, "\n" );
if ( single )
fprintf( fp, "%16.9e\n", sDet );
else
fprintf( fp, "%25.17e\n", dDet );
/* Write inverse. */
if ( invert ) {
fprintf( fp, "\n" );
if ( single ) {
for ( i = 0; i < n; i++ ) {
fprintf( fp, "%16.9e", sInverse->data[i*n] );
for ( j = 1; j < n; j++ )
fprintf( fp, " %16.9e", sInverse->data[i*n+j] );
fprintf( fp, "\n" );
}
} else {
for ( i = 0; i < n; i++ ) {
fprintf( fp, "%25.17e", dInverse->data[i*n] );
for ( j = 1; j < n; j++ )
fprintf( fp, " %25.17e", dInverse->data[i*n+j] );
fprintf( fp, "\n" );
}
}
}
/* Finished output. */
if ( fp != stdout && fp != stderr )
fclose( fp );
}
/* Clean up and exit. */
if ( single ) {
SUB( LALSDestroyArray( &stat, &sMatrix ), &stat );
if ( invert ) {
SUB( LALSDestroyArray( &stat, &sInverse ), &stat );
}
} else {
SUB( LALDDestroyArray( &stat, &dMatrix ), &stat );
if ( invert ) {
SUB( LALDDestroyArray( &stat, &dInverse ), &stat );
}
}
LALCheckMemoryLeaks();
INFO( DETINVERSETESTC_MSGENORM );
return DETINVERSETESTC_ENORM;
}
/**
* Computes REAL4TimeSeries containing time series of response amplitudes.
* \deprecated Use XLALComputeDetAMResponseSeries() instead.
*/
void LALComputeDetAMResponseSeries(LALStatus * status, LALDetAMResponseSeries * pResponseSeries, const LALDetAndSource * pDetAndSource, const LALTimeIntervalAndNSample * pTimeInfo)
{
/* Want to loop over the time and call LALComputeDetAMResponse() */
LALDetAMResponse instResponse;
unsigned i;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/*
* Error-checking assertions
*/
ASSERT(pResponseSeries != (LALDetAMResponseSeries *) NULL, status, DETRESPONSEH_ENULLOUTPUT, DETRESPONSEH_MSGENULLOUTPUT);
ASSERT(pDetAndSource != (LALDetAndSource *) NULL, status, DETRESPONSEH_ENULLINPUT, DETRESPONSEH_MSGENULLINPUT);
ASSERT(pTimeInfo != (LALTimeIntervalAndNSample *) NULL, status, DETRESPONSEH_ENULLINPUT, DETRESPONSEH_MSGENULLINPUT);
/*
* Set names
*/
pResponseSeries->pPlus->name[0] = '\0';
pResponseSeries->pCross->name[0] = '\0';
pResponseSeries->pScalar->name[0] = '\0';
strncpy(pResponseSeries->pPlus->name, "plus", LALNameLength);
strncpy(pResponseSeries->pCross->name, "cross", LALNameLength);
strncpy(pResponseSeries->pScalar->name, "scalar", LALNameLength);
/*
* Set sampling parameters
*/
pResponseSeries->pPlus->epoch = pTimeInfo->epoch;
pResponseSeries->pPlus->deltaT = pTimeInfo->deltaT;
pResponseSeries->pPlus->f0 = 0.;
pResponseSeries->pPlus->sampleUnits = lalDimensionlessUnit;
pResponseSeries->pCross->epoch = pTimeInfo->epoch;
pResponseSeries->pCross->deltaT = pTimeInfo->deltaT;
pResponseSeries->pCross->f0 = 0.;
pResponseSeries->pCross->sampleUnits = lalDimensionlessUnit;
pResponseSeries->pScalar->epoch = pTimeInfo->epoch;
pResponseSeries->pScalar->deltaT = pTimeInfo->deltaT;
pResponseSeries->pScalar->f0 = 0.;
pResponseSeries->pScalar->sampleUnits = lalDimensionlessUnit;
/*
* Ensure enough memory for requested vectors
*/
if(pResponseSeries->pPlus->data->length < pTimeInfo->nSample) {
if(lalDebugLevel >= 8)
LALInfo(status, "plus sequence too short -- reallocating");
TRY(LALSDestroyVector(status->statusPtr, &(pResponseSeries->pPlus->data)), status);
TRY(LALSCreateVector(status->statusPtr, &(pResponseSeries->pPlus->data), pTimeInfo->nSample), status);
if(lalDebugLevel > 0)
printf("pResponseSeries->pPlus->data->length = %d\n", pResponseSeries->pPlus->data->length);
}
if(pResponseSeries->pCross->data->length < pTimeInfo->nSample) {
if(lalDebugLevel >= 8)
LALInfo(status, "cross sequence too short -- reallocating");
TRY(LALSDestroyVector(status->statusPtr, &(pResponseSeries->pCross->data)), status);
TRY(LALSCreateVector(status->statusPtr, &(pResponseSeries->pCross->data), pTimeInfo->nSample), status);
}
if(pResponseSeries->pScalar->data->length < pTimeInfo->nSample) {
if(lalDebugLevel & 0x08)
LALInfo(status, "scalar sequence too short -- reallocating");
TRY(LALSDestroyVector(status->statusPtr, &(pResponseSeries->pScalar->data)), status);
TRY(LALSCreateVector(status->statusPtr, &(pResponseSeries->pScalar->data), pTimeInfo->nSample), status);
}
/*
* Loop to compute each element in time series.
*/
for(i = 0; i < pTimeInfo->nSample; ++i) {
LIGOTimeGPS gps = pTimeInfo->epoch;
XLALGPSAdd(&gps, i * pTimeInfo->deltaT);
TRY(LALComputeDetAMResponse(status->statusPtr, &instResponse, pDetAndSource, &gps), status);
pResponseSeries->pPlus->data->data[i] = instResponse.plus;
pResponseSeries->pCross->data->data[i] = instResponse.cross;
pResponseSeries->pScalar->data->data[i] = instResponse.scalar;
}
DETATCHSTATUSPTR(status);
RETURN(status);
}
int main(void)
{
static LALStatus status;
LALDetector detector;
LALSource pulsar;
CoarseFitOutput output;
CoarseFitInput input;
CoarseFitParams params;
LIGOTimeGPS tgps[FITTOPULSARTEST_LENGTH];
REAL4 cosIota;
REAL4 phase;
REAL4 psi;
REAL4 h0;
REAL4 cos2phase, sin2phase;
static RandomParams *randomParams;
static REAL4Vector *noise;
INT4 seed = 0;
LALDetAndSource detAndSource;
LALDetAMResponseSeries pResponseSeries = {NULL,NULL,NULL};
REAL4TimeSeries Fp, Fc, Fs;
LALTimeIntervalAndNSample time_info;
UINT4 i;
/* Allocate memory */
input.B = NULL;
input.var = NULL;
LALZCreateVector( &status, &input.B, FITTOPULSARTEST_LENGTH);
LALZCreateVector( &status, &input.var, FITTOPULSARTEST_LENGTH);
noise = NULL;
LALCreateVector( &status, &noise, FITTOPULSARTEST_LENGTH);
LALCreateRandomParams( &status, &randomParams, seed);
Fp.data = NULL;
Fc.data = NULL;
Fs.data = NULL;
pResponseSeries.pPlus = &(Fp);
pResponseSeries.pCross = &(Fc);
pResponseSeries.pScalar = &(Fs);
LALSCreateVector(&status, &(pResponseSeries.pPlus->data), 1);
LALSCreateVector(&status, &(pResponseSeries.pCross->data), 1);
LALSCreateVector(&status, &(pResponseSeries.pScalar->data), 1);
input.t = tgps;
/******** GENERATE FAKE INPUT **********/
time_info.epoch.gpsSeconds = FITTOPULSARTEST_T0;
time_info.epoch.gpsNanoSeconds = 0;
time_info.deltaT = 60;
time_info.nSample = FITTOPULSARTEST_LENGTH;
cosIota = 0.5;
psi = 0.1;
phase = 0.4;
h0 = 5.0;
cos2phase = cos(2.0*phase);
sin2phase = sin(2.0*phase);
detector = lalCachedDetectors[LALDetectorIndexGEO600DIFF]; /* use GEO 600 detector for tests */
pulsar.equatorialCoords.longitude = 1.4653; /* right ascention of pulsar */
pulsar.equatorialCoords.latitude = -1.2095; /* declination of pulsar */
pulsar.equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL; /* coordinate system */
pulsar.orientation = psi; /* polarization angle */
strcpy(pulsar.name, "fakepulsar"); /* name of pulsar */
detAndSource.pDetector = &detector;
detAndSource.pSource = &pulsar;
LALNormalDeviates( &status, noise, randomParams );
LALComputeDetAMResponseSeries(&status, &pResponseSeries, &detAndSource, &time_info);
for (i = 0;i < FITTOPULSARTEST_LENGTH; i++)
{
input.t[i].gpsSeconds = FITTOPULSARTEST_T0 + 60*i;
input.t[i].gpsNanoSeconds = 0;
input.B->data[i] = crect( pResponseSeries.pPlus->data->data[i]*h0*(1.0 + cosIota*cosIota)*cos2phase + 2.0*pResponseSeries.pCross->data->data[i]*h0*cosIota*sin2phase, pResponseSeries.pPlus->data->data[i]*h0*(1.0 + cosIota*cosIota)*sin2phase - 2.0*pResponseSeries.pCross->data->data[i]*h0*cosIota*cos2phase );
input.var->data[i] = crect( noise->data[FITTOPULSARTEST_LENGTH-i-1]*noise->data[FITTOPULSARTEST_LENGTH-i-1], noise->data[i]*noise->data[i] );
}
input.B->length = FITTOPULSARTEST_LENGTH;
input.var->length = FITTOPULSARTEST_LENGTH;
/******* TEST RESPONSE TO VALID DATA ************/
/* Test that valid data generate the correct answers */
params.detector = detector;
params.pulsarSrc = pulsar;
params.meshH0[0] = 4.0;
params.meshH0[1] = 0.2;
params.meshH0[2] = 10;
params.meshCosIota[0] = 0.0;
params.meshCosIota[1] = 0.1;
params.meshCosIota[2] = 10;
params.meshPhase[0] = 0.0;
params.meshPhase[1] = 0.1;
params.meshPhase[2] = 10;
params.meshPsi[0] = 0.0;
params.meshPsi[1] = 0.1;
params.meshPsi[2] = 10;
output.mChiSquare = NULL;
LALDCreateVector( &status, &output.mChiSquare,params.meshH0[2]*params.meshCosIota[2]*params.meshPhase[2]*params.meshPsi[2]);
LALCoarseFitToPulsar(&status,&output, &input, ¶ms);
if(status.statusCode)
{
printf("Unexpectedly got error code %d and message %s\n",
status.statusCode, status.statusDescription);
return FITTOPULSARTESTC_EFLS;
}
if(output.phase > phase + params.meshPhase[2] || output.phase < phase - params.meshPhase[2])
{
printf("Got incorrect phase %f when expecting %f \n",
output.phase, phase);
return FITTOPULSARTESTC_EFLS;
}
if(output.cosIota > cosIota + params.meshCosIota[2] || output.cosIota < cosIota - params.meshCosIota[2])
{
printf("Got incorrect cosIota %f when expecting %f \n",
output.cosIota, cosIota);
return FITTOPULSARTESTC_EFLS;
}
if(output.psi > psi + params.meshPsi[2] || output.psi < psi - params.meshPsi[2])
{
printf("Got incorrect psi %f when expecting %f \n",
output.psi, psi);
return FITTOPULSARTESTC_EFLS;
}
/******* TEST RESPONSE OF LALCoarseFitToPulsar TO INVALID DATA ************/
#ifndef LAL_NDEBUG
if ( ! lalNoDebug ) {
/* Test that all the error conditions are correctly detected by the function */
LALCoarseFitToPulsar(&status, NULL, &input, ¶ms);
if (status.statusCode != FITTOPULSARH_ENULLOUTPUT
|| strcmp(status.statusDescription, FITTOPULSARH_MSGENULLOUTPUT))
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription);
printf( "Expected error code %d and message %s\n",
FITTOPULSARH_ENULLOUTPUT, FITTOPULSARH_MSGENULLOUTPUT);
return FITTOPULSARTESTC_ECHK;
}
LALCoarseFitToPulsar(&status, &output, NULL, ¶ms);
if (status.statusCode != FITTOPULSARH_ENULLINPUT
|| strcmp(status.statusDescription, FITTOPULSARH_MSGENULLINPUT))
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription);
printf( "Expected error code %d and message %s\n",
FITTOPULSARH_ENULLINPUT, FITTOPULSARH_MSGENULLINPUT);
return FITTOPULSARTESTC_ECHK;
}
LALCoarseFitToPulsar(&status, &output, &input, NULL);
if (status.statusCode != FITTOPULSARH_ENULLPARAMS
|| strcmp(status.statusDescription, FITTOPULSARH_MSGENULLPARAMS))
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription);
printf( "Expected error code %d and message %s\n",
FITTOPULSARH_ENULLPARAMS, FITTOPULSARH_MSGENULLPARAMS);
return FITTOPULSARTESTC_ECHK;
}
/* try having two input vectors of different length */
input.var->length = 1;
LALCoarseFitToPulsar(&status, &output, &input, ¶ms);
if (status.statusCode != FITTOPULSARH_EVECSIZE
|| strcmp(status.statusDescription, FITTOPULSARH_MSGEVECSIZE))
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription);
printf( "Expected error code %d and message %s\n",
FITTOPULSARH_EVECSIZE, FITTOPULSARH_MSGEVECSIZE);
return FITTOPULSARTESTC_ECHK;
}
input.var->length = FITTOPULSARTEST_LENGTH;
} /* if ( ! lalNoDebug ) */
#endif /* LAL_NDEBUG */
/******* CLEAN UP ************/
LALZDestroyVector(&status, &input.B);
LALZDestroyVector(&status, &input.var);
LALDestroyVector(&status, &noise);
LALDDestroyVector(&status, &output.mChiSquare);
LALDestroyRandomParams(&status, &randomParams);
LALSDestroyVector(&status, &(pResponseSeries.pPlus->data));
LALSDestroyVector(&status, &(pResponseSeries.pCross->data));
LALSDestroyVector(&status, &(pResponseSeries.pScalar->data));
LALCheckMemoryLeaks();
return FITTOPULSARTESTC_ENOM;
}
int main( void )
{
/* Declare inputs of LAL function */
static LALStatus status;
REAL4Vector *output;
FoldAmplitudesInput input;
FoldAmplitudesInput badinput;
FoldAmplitudesParams param;
/* Declare other variables */
REAL4 f = FOLDAMPLITUDESTESTC_FREQ; /* A frequency for producing test amplitudes */
REAL4 fDot = FOLDAMPLITUDESTESTC_FREQDOT; /* A frequency for producing test phases */
REAL4 delT = FOLDAMPLITUDESTESTC_TIMESTEP; /* A time step for producing test data */
REAL4 twoPi = (REAL4) LAL_TWOPI; /* For phase bins between 0 an 2*pi */
REAL4 binRange; /* binMax - binMin */
INT4 lengthAmpVec = FOLDAMPLITUDESTESTC_LENGTH; /* length of the vector of amplitudes */
INT4 i; /* generic integer index */
INT4 j; /* generic integer index */
INT4 k; /* generic integer index */
INT2 gotError = 0; /* Set nonzero if error condition occurs */
/* Allocate memory */
input.phaseVec = NULL;
input.amplitudeVec = NULL;
badinput.phaseVec = NULL;
badinput.amplitudeVec = NULL;
output = NULL;
LALSCreateVector( &status, &input.phaseVec, FOLDAMPLITUDESTESTC_LENGTH );
LALSCreateVector( &status, &input.amplitudeVec, FOLDAMPLITUDESTESTC_LENGTH );
LALSCreateVector( &status, &badinput.phaseVec, FOLDAMPLITUDESTESTC_BADLENGTH );
LALSCreateVector( &status, &badinput.amplitudeVec, FOLDAMPLITUDESTESTC_LENGTH );
LALSCreateVector( &status, &output, FOLDAMPLITUDESTESTC_NUMBINS );
/* ****** TEST RESPONSE TO INVALID DATA ************/
/* Test that all the error conditions are correctly detected by the function */
#ifndef LAL_NDEBUG
if ( ! lalNoDebug )
{
/* Test NULL output */
param.numBins = FOLDAMPLITUDESTESTC_NUMBINS;
param.binMin = 0.0;
param.binMax = twoPi;
LALFoldAmplitudes( &status, NULL, &input, ¶m );
if ( status.statusCode != FOLDAMPLITUDESH_ENULLP
|| strcmp(status.statusDescription, FOLDAMPLITUDESH_MSGENULLP) )
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription );
printf( "Expected error code %d and message %s\n",
FOLDAMPLITUDESH_ENULLP, FOLDAMPLITUDESH_MSGENULLP );
return FOLDAMPLITUDESTESTC_ECHK;
}
/* Test input vectors of different length */
param.numBins = FOLDAMPLITUDESTESTC_NUMBINS;
param.binMin = 0.0;
param.binMax = twoPi;
LALFoldAmplitudes( &status, output, &badinput, ¶m );
if ( status.statusCode != FOLDAMPLITUDESH_EVECSIZE
|| strcmp(status.statusDescription, FOLDAMPLITUDESH_MSGEVECSIZE) )
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription );
printf( "Expected error code %d and message %s\n",
FOLDAMPLITUDESH_EVECSIZE, FOLDAMPLITUDESH_MSGEVECSIZE );
return FOLDAMPLITUDESTESTC_ECHK;
}
/* Test number of bins < 1 */
param.numBins = 0;
param.binMin = 0.0;
param.binMax = twoPi;
LALFoldAmplitudes( &status, output, &input, ¶m );
if ( status.statusCode != FOLDAMPLITUDESH_ENUMBINS
|| strcmp(status.statusDescription, FOLDAMPLITUDESH_MSGENUMBINS) )
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription );
printf( "Expected error code %d and message %s\n",
FOLDAMPLITUDESH_ENUMBINS, FOLDAMPLITUDESH_MSGENUMBINS );
return FOLDAMPLITUDESTESTC_ECHK;
}
/* Test bin max <= bin min */
param.numBins = FOLDAMPLITUDESTESTC_NUMBINS;
param.binMin = 0.0;
param.binMax = 0.0;
LALFoldAmplitudes( &status, output, &input, ¶m );
if ( status.statusCode != FOLDAMPLITUDESH_EBINSIZE
|| strcmp(status.statusDescription, FOLDAMPLITUDESH_MSGEBINSIZE) )
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription );
printf( "Expected error code %d and message %s\n",
FOLDAMPLITUDESH_EBINSIZE, FOLDAMPLITUDESH_MSGEBINSIZE );
return FOLDAMPLITUDESTESTC_ECHK;
}
/* Test bin min != 0 */
param.numBins = FOLDAMPLITUDESTESTC_NUMBINS;
param.binMin = -0.5;
param.binMax = 0.5;
LALFoldAmplitudes( &status, output, &input, ¶m );
if ( status.statusCode != FOLDAMPLITUDESH_EBINMIN
|| strcmp(status.statusDescription, FOLDAMPLITUDESH_MSGEBINMIN) )
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription );
printf( "Expected error code %d and message %s\n",
FOLDAMPLITUDESH_EBINMIN, FOLDAMPLITUDESH_MSGEBINMIN );
return FOLDAMPLITUDESTESTC_ECHK;
}
}
#endif /* LAL_NDEBUG */
/* ****** TEST RESPONSE TO VALID DATA ************/
/* Test that valid data generate the correct answers */
/* Test 1: Simple test with constant amplitudes and constant phases */
/* All the amplitudes should end up in one bin; specifically the (j + 8)/2 % param.numBins bin. */
for (k = 0; k < 2; ++k) {
param.numBins = 4;
param.binMin = 0.0;
if (k == 0) {
param.binMax = 1.0; /* test phase measured in cycles */
} else {
param.binMax = twoPi; /* test phase measured in radians */
}
binRange = param.binMax - param.binMin;
for (j = -8; j <= 8; ++j) {
for ( i = 0 ; i < (INT4)input.amplitudeVec->length ; ++i )
{
input.amplitudeVec->data[i] = 1.0;
/* Set the phase: Add in a multiple of twoPi to check that values bin correctly */
input.phaseVec->data[i] = j*(binRange/8.0) + j*j*j*binRange + .001;
}
/* Initialize the output vector */
for ( i = 0 ; i < (INT4)output->length ; ++i )
{
output->data[i] = 0.0;
}
/*
printf("\n");
for ( i = 0 ; i < input.amplitudeVec->length ; ++i )
{
printf("Index %i Input Amplitude %f \n",i, input.amplitudeVec->data[i]);
}
printf("\n");
for ( i = 0 ; i < input.phaseVec->length ; ++i )
{
printf("Index %i Input Phase %f \n",i, input.phaseVec->data[i]);
}
*/
LALFoldAmplitudes( &status, output, &input, ¶m );
if ( status.statusCode )
{
printf( "Unexpectedly got error code %d and message %s\n",
status.statusCode, status.statusDescription );
return FOLDAMPLITUDESTESTC_EFLS;
}
printf("\n");
for ( i = 0 ; i < param.numBins ; ++i )
{
printf("Constant phase test binRange %g, index %i, Bin %i, Output Amplitude %f \n",binRange,j,i,output->data[i]);
if (i == (j + 8)/2 % param.numBins) {
if (output->data[i] != lengthAmpVec*1.0) {
printf ("For binRange %g expected all the amplitudes to fold into bin %i but instead got %g in this bin. \n",binRange, i,output->data[i]);
gotError = 1;
}
} else {
if (output->data[i] != 0.0) {
printf ("For binRange %g expected no amplitudes to fold into bin %i but instead got %g in this bin. \n",binRange, i,output->data[i]);
gotError = 1;
}
}
}
} /* end for (j = -8; j < 8; ++j) */
} /* end for (k = 0; k < 1; ++k) */
printf("\n");
if (gotError > 0) {
printf("Test 1 in FoldAmplitudesTest.c Failed. \n");
return FOLDAMPLITUDESTESTC_EFLS;
} else {
printf("Test 1 in FoldAmplitudesTest.c Passed. \n");
}
/* Test 2: Constant amplitudes, simple phases */
/* One should end up in each bin. */
param.numBins = 10;
param.binMin = 0.0;
param.binMax = twoPi; /* test phase measured in radians */
binRange = param.binMax - param.binMin;
for ( i = 0 ; i < (INT4)input.amplitudeVec->length ; ++i )
{
input.amplitudeVec->data[i] = 1;
input.phaseVec->data[i] = twoPi*i/10.0 + .0001;
}
/* Initialize the output vector */
for ( i = 0 ; i < (INT4)output->length ; ++i )
{
output->data[i] = 0.0;
}
/*
printf("\n");
for ( i = 0 ; i < input.amplitudeVec->length ; ++i )
{
printf("Index %i Input Amplitude %f \n",i, input.amplitudeVec->data[i]);
}
printf("\n");
for ( i = 0 ; i < input.phaseVec->length ; ++i )
{
printf("Index %i Input Phase %f \n",i, input.phaseVec->data[i]);
}
*/
LALFoldAmplitudes( &status, output, &input, ¶m );
if ( status.statusCode )
{
printf( "Unexpectedly got error code %d and message %s\n",
status.statusCode, status.statusDescription );
return FOLDAMPLITUDESTESTC_EFLS;
}
printf("\n");
for ( i = 0 ; i < param.numBins ; ++i )
{
printf("Bin %i Output Amplitude %f \n",i,output->data[i]);
if (output->data[i] != 1.0) {
printf ("In bin %i expected 1 but instead got %g in this bin. \n",i,output->data[i]);
gotError = 1;
}
}
printf("\n");
if (gotError > 0) {
printf("Test 2 in FoldAmplitudesTest.c Failed. \n");
return FOLDAMPLITUDESTESTC_EFLS;
} else {
printf("Test 2 in FoldAmplitudesTest.c Passed. \n");
}
/* Test 3: One amplitude goes into each bin, so that sin(\PHI) should return sin(\PHI) */
param.numBins = 10;
param.binMin = 0.0;
param.binMax = twoPi; /* test phase measured in radians */
binRange = param.binMax - param.binMin;
for ( i = 0 ; i < (INT4)input.amplitudeVec->length ; ++i )
{
input.amplitudeVec->data[i] = sin(twoPi*i/10.0 + .0001);
input.phaseVec->data[i] = twoPi*i/10.0 + .0001;
}
/* Initialize the output vector */
for ( i = 0 ; i < (INT4)output->length ; ++i )
{
output->data[i] = 0.0;
}
/*
printf("\n");
for ( i = 0 ; i < input.amplitudeVec->length ; ++i )
{
printf("Index %i Input Amplitude %f \n",i, input.amplitudeVec->data[i]);
}
printf("\n");
for ( i = 0 ; i < input.phaseVec->length ; ++i )
{
printf("Index %i Input Phase %f \n",i, input.phaseVec->data[i]);
}
*/
LALFoldAmplitudes( &status, output, &input, ¶m );
if ( status.statusCode )
{
printf( "Unexpectedly got error code %d and message %s\n",
status.statusCode, status.statusDescription );
return FOLDAMPLITUDESTESTC_EFLS;
}
printf("\n");
for ( i = 0 ; i < param.numBins ; ++i )
{
printf("Bin %i Output Amplitude %f \n",i,output->data[i]);
if (fabs(output->data[i] - sin(twoPi*i/10.0 + .0001)) > fabs(output->data[i]*FOLDAMPLITUDESTESTC_TOL)) {
printf ("In bin %i expected %g but instead got %g in this bin. \n",i,sin(twoPi*i/10.0 + .0001),output->data[i]);
gotError = 1;
}
}
printf("\n");
if (gotError > 0) {
printf("Test 3 in FoldAmplitudesTest.c Failed. \n");
return FOLDAMPLITUDESTESTC_EFLS;
} else {
printf("Test 3 in FoldAmplitudesTest.c Passed. \n");
}
/* Test 4: Two amplitudes go into each bin, such that sin(2*\PHI) should return 2*sin(\PHI) */
/* Also, phases are input as cycles. */
param.numBins = 5;
param.binMin = 0.0;
param.binMax = 1.0; /* test phase measured in radians */
binRange = param.binMax - param.binMin;
for ( i = 0 ; i < (INT4)input.amplitudeVec->length ; ++i )
{
input.amplitudeVec->data[i] = sin(2.0*twoPi*i/5.0 + .001);
input.phaseVec->data[i] = i/5.0 + .001;
}
/* Initialize the output vector */
for ( i = 0 ; i < (INT4)output->length ; ++i )
{
output->data[i] = 0.0;
}
printf("\n");
for ( i = 0 ; i < (INT4)input.amplitudeVec->length ; ++i )
{
printf("Index %i Input Amplitude %f \n",i, input.amplitudeVec->data[i]);
}
printf("\n");
for ( i = 0 ; i < (INT4)input.phaseVec->length ; ++i )
{
printf("Index %i Input Phase in Cycles %f \n",i, input.phaseVec->data[i]);
}
LALFoldAmplitudes( &status, output, &input, ¶m );
if ( status.statusCode )
{
printf( "Unexpectedly got error code %d and message %s\n",
status.statusCode, status.statusDescription );
return FOLDAMPLITUDESTESTC_EFLS;
}
printf("\n");
for ( i = 0 ; i < param.numBins ; ++i )
{
printf("Bin %i Output Amplitude %f \n",i,output->data[i]);
if (fabs(output->data[i] - 2.0*sin(2.0*twoPi*i/5.0 + .001)) > fabs(output->data[i]*FOLDAMPLITUDESTESTC_TOL)) {
printf ("In bin %i expected %g but instead got %g in this bin. \n",i,2.0*sin(2.0*twoPi*i/5.0 + .001),output->data[i]);
gotError = 1;
}
}
printf("\n");
if (gotError > 0) {
printf("Test 4 in FoldAmplitudesTest.c Failed. \n");
return FOLDAMPLITUDESTESTC_EFLS;
} else {
printf("Test 4 in FoldAmplitudesTest.c Passed. \n");
}
/* Test 5: More realistic data; check output by hand */
param.numBins = FOLDAMPLITUDESTESTC_NUMBINS;
param.binMin = 0.0;
param.binMax = twoPi;
printf("\n");
printf("Test 5 check by hand: numBins, binMax = %i, %g \n",param.numBins,param.binMax);
for ( i = 0 ; i < (INT4)input.amplitudeVec->length ; ++i )
{
input.amplitudeVec->data[i] = sin(twoPi*f*i*delT + 0.5*fDot*i*delT*i*delT - 10.001);
input.phaseVec->data[i] = twoPi*f*i*delT + 0.5*fDot*i*delT*i*delT - 10.001;
}
for ( i = 0 ; i < (INT4)output->length ; ++i )
{
output->data[i] = 0.0;
}
printf("\n");
for ( i = 0 ; i < (INT4)input.amplitudeVec->length ; ++i )
{
printf("Index %i Input Amplitude %f \n",i, input.amplitudeVec->data[i]);
}
printf("\n");
for ( i = 0 ; i < (INT4)input.phaseVec->length ; ++i )
{
printf("Index %i Input Phase %f \n",i, input.phaseVec->data[i]);
}
LALFoldAmplitudes( &status, output, &input, ¶m );
if ( status.statusCode )
{
printf( "Unexpectedly got error code %d and message %s\n",
status.statusCode, status.statusDescription );
return FOLDAMPLITUDESTESTC_EFLS;
}
printf("\n");
for ( i = 0 ; i < param.numBins ; ++i )
{
printf("Bin %i Output Amplitude %f \n",i,output->data[i]);
}
printf("\n");
if (gotError > 0) {
printf("Test 5in FoldAmplitudesTest.c Failed. \n");
return FOLDAMPLITUDESTESTC_EFLS;
} else {
printf("Test 5 in FoldAmplitudesTest.c Passed. \n");
}
/* some check on the contents of output */
/* ****** CLEAN UP ************/
LALSDestroyVector( &status, &input.phaseVec );
LALSDestroyVector( &status, &input.amplitudeVec );
LALSDestroyVector( &status, &badinput.phaseVec );
LALSDestroyVector( &status, &badinput.amplitudeVec );
LALSDestroyVector( &status, &output );
LALCheckMemoryLeaks();
printf("\n");
printf("PASS: All tests \n");
printf("\n");
return FOLDAMPLITUDESTESTC_ENOM;
}
/**
* \author Creighton, T. D.
*
* \brief Computes a continuous waveform with frequency drift and Doppler
* modulation from a hyperbolic orbital trajectory.
*
* This function computes a quaiperiodic waveform using the spindown and
* orbital parameters in <tt>*params</tt>, storing the result in
* <tt>*output</tt>.
*
* In the <tt>*params</tt> structure, the routine uses all the "input"
* fields specified in \ref GenerateSpinOrbitCW_h, and sets all of the
* "output" fields. If <tt>params-\>f</tt>=\c NULL, no spindown
* modulation is performed. If <tt>params-\>oneMinusEcc</tt>\f$\not<0\f$ (a
* non-hyperbolic orbit), or if
* <tt>params-\>rPeriNorm</tt>\f$\times\f$<tt>params-\>angularSpeed</tt>\f$\geq1\f$
* (faster-than-light speed at periapsis), an error is returned.
*
* In the <tt>*output</tt> structure, the field <tt>output-\>h</tt> is
* ignored, but all other pointer fields must be set to \c NULL. The
* function will create and allocate space for <tt>output-\>a</tt>,
* <tt>output-\>f</tt>, and <tt>output-\>phi</tt> as necessary. The
* <tt>output-\>shift</tt> field will remain set to \c NULL.
*
* ### Algorithm ###
*
* For hyperbolic orbits, we combine \eqref{eq_spinorbit-tr},
* \eqref{eq_spinorbit-t}, and \eqref{eq_spinorbit-upsilon} to get \f$t_r\f$
* directly as a function of \f$E\f$:
* \f{eqnarray}{
* \label{eq_tr-e3}
* t_r = t_p & + & \left(\frac{r_p \sin i}{c}\right)\sin\omega\\
* & + & \frac{1}{n} \left( -E +
* \left[v_p(e-1)\cos\omega + e\right]\sinh E
* - \left[v_p\sqrt{\frac{e-1}{e+1}}\sin\omega\right]
* [\cosh E - 1]\right) \;,
* \f}
* where \f$v_p=r_p\dot{\upsilon}_p\sin i/c\f$ is a normalized velocity at
* periapsis and \f$n=\dot{\upsilon}_p\sqrt{(1-e)^3/(1+e)}\f$ is a normalized
* angular speed for the orbit (the hyperbolic analogue of the mean
* angular speed for closed orbits). For simplicity we write this as:
* \f{equation}{
* \label{eq_tr-e4}
* t_r = T_p + \frac{1}{n}\left( E + A\sinh E + B[\cosh E - 1] \right) \;,
* \f}
*
* \figure{inject_hanomaly,eps,0.23,Function to be inverted to find eccentric anomaly}
*
* where \f$T_p\f$ is the \e observed time of periapsis passage. Thus
* the key numerical procedure in this routine is to invert the
* expression \f$x=E+A\sinh E+B(\cosh E - 1)\f$ to get \f$E(x)\f$. This function
* is sketched to the right (solid line), along with an approximation
* used for making an initial guess (dotted line), as described later.
*
* We note that \f$A^2-B^2<1\f$, although it approaches 1 when
* \f$e\rightarrow1\f$, or when \f$v_p\rightarrow1\f$ and either \f$e=0\f$ or
* \f$\omega=\pi\f$. Except in this limit, Newton-Raphson methods will
* converge rapidly for any initial guess. In this limit, though, the
* slope \f$dx/dE\f$ approaches zero at \f$E=0\f$, and an initial guess or
* iteration landing near this point will send the next iteration off to
* unacceptably large or small values. A hybrid root-finding strategy is
* used to deal with this, and with the exponential behaviour of \f$x\f$ at
* large \f$E\f$.
*
* First, we compute \f$x=x_{\pm1}\f$ at \f$E=\pm1\f$. If the desired \f$x\f$ lies
* in this range, we use a straightforward Newton-Raphson root finder,
* with the constraint that all guesses of \f$E\f$ are restricted to the
* domain \f$[-1,1]\f$. This guarantees that the scheme will eventually find
* itself on a uniformly-convergent trajectory.
*
* Second, for \f$E\f$ outside of this range, \f$x\f$ is dominated by the
* exponential terms: \f$x\approx\frac{1}{2}(A+B)\exp(E)\f$ for \f$E\gg1\f$, and
* \f$x\approx-\frac{1}{2}(A-B)\exp(-E)\f$ for \f$E\ll-1\f$. We therefore do an
* \e approximate Newton-Raphson iteration on the function \f$\ln|x|\f$,
* where the approximation is that we take \f$d\ln|x|/d|E|\approx1\f$. This
* involves computing an extra logarithm inside the loop, but gives very
* rapid convergence to high precision, since \f$\ln|x|\f$ is very nearly
* linear in these regions.
*
* At the start of the algorithm, we use an initial guess of
* \f$E=-\ln[-2(x-x_{-1})/(A-B)-\exp(1)]\f$ for \f$x<x_{-1}\f$, \f$E=x/x_{-1}\f$ for
* \f$x_{-1}\leq x\leq0\f$, \f$E=x/x_{+1}\f$ for \f$0\leq x\leq x_{+1}\f$, or
* \f$E=\ln[2(x-x_{+1})/(A+B)-\exp(1)]\f$ for \f$x>x_{+1}\f$. We refine this
* guess until we get agreement to within 0.01 parts in part in
* \f$N_\mathrm{cyc}\f$ (where \f$N_\mathrm{cyc}\f$ is the larger of the number
* of wave cycles in a time \f$2\pi/n\f$, or the number of wave cycles in the
* entire waveform being generated), or one part in \f$10^{15}\f$ (an order
* of magnitude off the best precision possible with \c REAL8
* numbers). The latter case indicates that \c REAL8 precision may
* fail to give accurate phasing, and one should consider modeling the
* orbit as a set of Taylor frequency coefficients \'{a} la
* <tt>LALGenerateTaylorCW()</tt>. On subsequent timesteps, we use the
* previous timestep as an initial guess, which is good so long as the
* timesteps are much smaller than \f$1/n\f$.
*
* Once a value of \f$E\f$ is found for a given timestep in the output
* series, we compute the system time \f$t\f$ via \eqref{eq_spinorbit-t},
* and use it to determine the wave phase and (non-Doppler-shifted)
* frequency via \eqref{eq_taylorcw-freq}
* and \eqref{eq_taylorcw-phi}. The Doppler shift on the frequency is
* then computed using \eqref{eq_spinorbit-upsilon}
* and \eqref{eq_orbit-rdot}. We use \f$\upsilon\f$ as an intermediate in
* the Doppler shift calculations, since expressing \f$\dot{R}\f$ directly in
* terms of \f$E\f$ results in expression of the form \f$(e-1)/(e\cosh E-1)\f$,
* which are difficult to simplify and face precision losses when
* \f$E\sim0\f$ and \f$e\rightarrow1\f$. By contrast, solving for \f$\upsilon\f$ is
* numerically stable provided that the system <tt>atan2()</tt> function is
* well-designed.
*
* This routine does not account for relativistic timing variations, and
* issues warnings or errors based on the criterea of
* \eqref{eq_relativistic-orbit} in \ref LALGenerateEllipticSpinOrbitCW().
*/
void
LALGenerateHyperbolicSpinOrbitCW( LALStatus *stat,
PulsarCoherentGW *output,
SpinOrbitCWParamStruc *params )
{
UINT4 n, i; /* number of and index over samples */
UINT4 nSpin = 0, j; /* number of and index over spindown terms */
REAL8 t, dt, tPow; /* time, interval, and t raised to a power */
REAL8 phi0, f0, twopif0; /* initial phase, frequency, and 2*pi*f0 */
REAL8 f, fPrev; /* current and previous values of frequency */
REAL4 df = 0.0; /* maximum difference between f and fPrev */
REAL8 phi; /* current value of phase */
REAL8 vDotAvg; /* nomalized orbital angular speed */
REAL8 vp; /* projected speed at periapsis */
REAL8 upsilon, argument; /* true anomaly, and argument of periapsis */
REAL8 eCosOmega; /* eccentricity * cosine of argument */
REAL8 tPeriObs; /* time of observed periapsis */
REAL8 spinOff; /* spin epoch - orbit epoch */
REAL8 x; /* observed ``mean anomaly'' */
REAL8 xPlus, xMinus; /* limits where exponentials dominate */
REAL8 dx, dxMax; /* current and target errors in x */
REAL8 a, b; /* constants in equation for x */
REAL8 ecc; /* orbital eccentricity */
REAL8 eccMinusOne, eccPlusOne; /* ecc - 1 and ecc + 1 */
REAL8 e; /* hyperbolic anomaly */
REAL8 sinhe, coshe; /* sinh of e, and cosh of e minus 1 */
REAL8 *fSpin = NULL; /* pointer to Taylor coefficients */
REAL4 *fData; /* pointer to frequency data */
REAL8 *phiData; /* pointer to phase data */
INITSTATUS(stat);
ATTATCHSTATUSPTR( stat );
/* Make sure parameter and output structures exist. */
ASSERT( params, stat, GENERATESPINORBITCWH_ENUL,
GENERATESPINORBITCWH_MSGENUL );
ASSERT( output, stat, GENERATESPINORBITCWH_ENUL,
GENERATESPINORBITCWH_MSGENUL );
/* Make sure output fields don't exist. */
ASSERT( !( output->a ), stat, GENERATESPINORBITCWH_EOUT,
GENERATESPINORBITCWH_MSGEOUT );
ASSERT( !( output->f ), stat, GENERATESPINORBITCWH_EOUT,
GENERATESPINORBITCWH_MSGEOUT );
ASSERT( !( output->phi ), stat, GENERATESPINORBITCWH_EOUT,
GENERATESPINORBITCWH_MSGEOUT );
ASSERT( !( output->shift ), stat, GENERATESPINORBITCWH_EOUT,
GENERATESPINORBITCWH_MSGEOUT );
/* If Taylor coeficients are specified, make sure they exist. */
if ( params->f ) {
ASSERT( params->f->data, stat, GENERATESPINORBITCWH_ENUL,
GENERATESPINORBITCWH_MSGENUL );
nSpin = params->f->length;
fSpin = params->f->data;
}
/* Set up some constants (to avoid repeated calculation or
dereferencing), and make sure they have acceptable values. */
eccMinusOne = -params->oneMinusEcc;
ecc = 1.0 + eccMinusOne;
eccPlusOne = 2.0 + eccMinusOne;
if ( eccMinusOne <= 0.0 ) {
ABORT( stat, GENERATESPINORBITCWH_EECC,
GENERATESPINORBITCWH_MSGEECC );
}
vp = params->rPeriNorm*params->angularSpeed;
vDotAvg = params->angularSpeed
*sqrt( eccMinusOne*eccMinusOne*eccMinusOne/eccPlusOne );
n = params->length;
dt = params->deltaT;
f0 = fPrev = params->f0;
if ( vp >= 1.0 ) {
ABORT( stat, GENERATESPINORBITCWH_EFTL,
GENERATESPINORBITCWH_MSGEFTL );
}
if ( vp <= 0.0 || dt <= 0.0 || f0 <= 0.0 || vDotAvg <= 0.0 ||
n == 0 ) {
ABORT( stat, GENERATESPINORBITCWH_ESGN,
GENERATESPINORBITCWH_MSGESGN );
}
/* Set up some other constants. */
twopif0 = f0*LAL_TWOPI;
phi0 = params->phi0;
argument = params->omega;
a = vp*eccMinusOne*cos( argument ) + ecc;
b = -vp*sqrt( eccMinusOne/eccPlusOne )*sin( argument );
eCosOmega = ecc*cos( argument );
if ( n*dt*vDotAvg > LAL_TWOPI )
dxMax = 0.01/( f0*n*dt );
else
dxMax = 0.01/( f0*LAL_TWOPI/vDotAvg );
if ( dxMax < 1.0e-15 ) {
dxMax = 1.0e-15;
#ifndef NDEBUG
LALWarning( stat, "REAL8 arithmetic may not have sufficient"
" precision for this orbit" );
#endif
}
#ifndef NDEBUG
if ( lalDebugLevel & LALWARNING ) {
REAL8 tau = n*dt;
if ( tau > LAL_TWOPI/vDotAvg )
tau = LAL_TWOPI/vDotAvg;
if ( f0*tau*vp*vp*ecc/eccPlusOne > 0.25 )
LALWarning( stat, "Orbit may have significant relativistic"
" effects that are not included" );
}
#endif
/* Compute offset between time series epoch and observed periapsis,
and betweem true periapsis and spindown reference epoch. */
tPeriObs = (REAL8)( params->orbitEpoch.gpsSeconds -
params->epoch.gpsSeconds );
tPeriObs += 1.0e-9 * (REAL8)( params->orbitEpoch.gpsNanoSeconds -
params->epoch.gpsNanoSeconds );
tPeriObs += params->rPeriNorm*sin( params->omega );
spinOff = (REAL8)( params->orbitEpoch.gpsSeconds -
params->spinEpoch.gpsSeconds );
spinOff += 1.0e-9 * (REAL8)( params->orbitEpoch.gpsNanoSeconds -
params->spinEpoch.gpsNanoSeconds );
/* Determine bounds of hybrid root-finding algorithm, and initial
guess for e. */
xMinus = 1.0 + a*sinh( -1.0 ) + b*cosh( -1.0 ) - b;
xPlus = -1.0 + a*sinh( 1.0 ) + b*cosh( 1.0 ) - b;
x = -vDotAvg*tPeriObs;
if ( x < xMinus )
e = -log( -2.0*( x - xMinus )/( a - b ) - exp( 1.0 ) );
else if ( x <= 0 )
e = x/xMinus;
else if ( x <= xPlus )
e = x/xPlus;
else
e = log( 2.0*( x - xPlus )/( a + b ) - exp( 1.0 ) );
sinhe = sinh( e );
coshe = cosh( e ) - 1.0;
/* Allocate output structures. */
if ( ( output->a = (REAL4TimeVectorSeries *)
LALMalloc( sizeof(REAL4TimeVectorSeries) ) ) == NULL ) {
ABORT( stat, GENERATESPINORBITCWH_EMEM,
GENERATESPINORBITCWH_MSGEMEM );
}
memset( output->a, 0, sizeof(REAL4TimeVectorSeries) );
if ( ( output->f = (REAL4TimeSeries *)
LALMalloc( sizeof(REAL4TimeSeries) ) ) == NULL ) {
LALFree( output->a ); output->a = NULL;
ABORT( stat, GENERATESPINORBITCWH_EMEM,
GENERATESPINORBITCWH_MSGEMEM );
}
memset( output->f, 0, sizeof(REAL4TimeSeries) );
if ( ( output->phi = (REAL8TimeSeries *)
LALMalloc( sizeof(REAL8TimeSeries) ) ) == NULL ) {
LALFree( output->a ); output->a = NULL;
LALFree( output->f ); output->f = NULL;
ABORT( stat, GENERATESPINORBITCWH_EMEM,
GENERATESPINORBITCWH_MSGEMEM );
}
memset( output->phi, 0, sizeof(REAL8TimeSeries) );
/* Set output structure metadata fields. */
output->position = params->position;
output->psi = params->psi;
output->a->epoch = output->f->epoch = output->phi->epoch
= params->epoch;
output->a->deltaT = n*params->deltaT;
output->f->deltaT = output->phi->deltaT = params->deltaT;
output->a->sampleUnits = lalStrainUnit;
output->f->sampleUnits = lalHertzUnit;
output->phi->sampleUnits = lalDimensionlessUnit;
snprintf( output->a->name, LALNameLength, "CW amplitudes" );
snprintf( output->f->name, LALNameLength, "CW frequency" );
snprintf( output->phi->name, LALNameLength, "CW phase" );
/* Allocate phase and frequency arrays. */
LALSCreateVector( stat->statusPtr, &( output->f->data ), n );
BEGINFAIL( stat ) {
LALFree( output->a ); output->a = NULL;
LALFree( output->f ); output->f = NULL;
LALFree( output->phi ); output->phi = NULL;
} ENDFAIL( stat );
LALDCreateVector( stat->statusPtr, &( output->phi->data ), n );
BEGINFAIL( stat ) {
TRY( LALSDestroyVector( stat->statusPtr, &( output->f->data ) ),
stat );
LALFree( output->a ); output->a = NULL;
LALFree( output->f ); output->f = NULL;
LALFree( output->phi ); output->phi = NULL;
} ENDFAIL( stat );
/* Allocate and fill amplitude array. */
{
CreateVectorSequenceIn in; /* input to create output->a */
in.length = 2;
in.vectorLength = 2;
LALSCreateVectorSequence( stat->statusPtr, &(output->a->data), &in );
BEGINFAIL( stat ) {
TRY( LALSDestroyVector( stat->statusPtr, &( output->f->data ) ),
stat );
TRY( LALDDestroyVector( stat->statusPtr, &( output->phi->data ) ),
stat );
LALFree( output->a ); output->a = NULL;
LALFree( output->f ); output->f = NULL;
LALFree( output->phi ); output->phi = NULL;
} ENDFAIL( stat );
output->a->data->data[0] = output->a->data->data[2] = params->aPlus;
output->a->data->data[1] = output->a->data->data[3] = params->aCross;
}
/* Fill frequency and phase arrays. */
fData = output->f->data->data;
phiData = output->phi->data->data;
for ( i = 0; i < n; i++ ) {
x = vDotAvg*( i*dt - tPeriObs );
/* Use approximate Newton-Raphson method on ln|x| if |x| > 1. */
if ( x < xMinus ) {
x = log( -x );
while ( fabs( dx = log( e - a*sinhe - b*coshe ) - x ) > dxMax ) {
e += dx;
sinhe = sinh( e );
coshe = cosh( e ) - 1.0;
}
}
else if ( x > xPlus ) {
x = log( x );
while ( fabs( dx = log( -e + a*sinhe + b*coshe ) - x ) > dxMax ) {
e -= dx;
sinhe = sinh( e );
coshe = cosh( e ) - 1.0;
}
}
/* Use ordinary Newton-Raphson method on x if |x| <= 1. */
else {
while ( fabs( dx = -e + a*sinhe + b*coshe - x ) > dxMax ) {
e -= dx/( -1.0 + a*coshe + a + b*sinhe );
if ( e < -1.0 )
e = -1.0;
else if ( e > 1.0 )
e = 1.0;
sinhe = sinh( e );
coshe = cosh( e ) - 1.0;
}
}
/* Compute source emission time, phase, and frequency. */
phi = t = tPow =
( ecc*sinhe - e )/vDotAvg + spinOff;
f = 1.0;
for ( j = 0; j < nSpin; j++ ) {
f += fSpin[j]*tPow;
phi += fSpin[j]*( tPow*=t )/( j + 2.0 );
}
/* Appy frequency Doppler shift. */
upsilon = 2.0*atan2( sqrt( eccPlusOne*coshe ),
sqrt( eccMinusOne*( coshe + 2.0 ) ) );
f *= f0 / ( 1.0 + vp*( cos( argument + upsilon ) + eCosOmega )
/eccPlusOne );
phi *= twopif0;
if ( fabs( f - fPrev ) > df )
df = fabs( f - fPrev );
*(fData++) = fPrev = f;
*(phiData++) = phi + phi0;
}
/* Set output field and return. */
params->dfdt = df*dt;
DETATCHSTATUSPTR( stat );
RETURN( stat );
}
int main( int argc, char *argv[] )
{
static LALStatus status;
RealFFTPlan *fwd = NULL;
RealFFTPlan *rev = NULL;
REAL4Vector *dat = NULL;
REAL4Vector *rfft = NULL;
REAL4Vector *ans = NULL;
COMPLEX8Vector *dft = NULL;
COMPLEX8Vector *fft = NULL;
#if LAL_CUDA_ENABLED
/* The test itself should pass at 1e-4, but it might fail at
* some rare cases where accuracy is bad for some numbers. */
REAL8 eps = 3e-4;
#else
/* very conservative floating point precision */
REAL8 eps = 1e-6;
#endif
REAL8 lbn;
REAL8 ssq;
REAL8 var;
REAL8 tol;
UINT4 nmax;
UINT4 m;
UINT4 n;
UINT4 i;
UINT4 j;
UINT4 k;
UINT4 s = 0;
FILE *fp;
ParseOptions( argc, argv );
m = m_;
n = n_;
fp = verbose ? stdout : NULL ;
if ( n == 0 )
{
nmax = 65536;
}
else
{
nmax = n--;
}
while ( n < nmax )
{
if ( n < 128 )
{
++n;
}
else
{
n *= 2;
}
LALSCreateVector( &status, &dat, n );
TestStatus( &status, CODES( 0 ), 1 );
LALSCreateVector( &status, &rfft, n );
TestStatus( &status, CODES( 0 ), 1 );
LALSCreateVector( &status, &ans, n );
TestStatus( &status, CODES( 0 ), 1 );
LALCCreateVector( &status, &dft, n / 2 + 1 );
TestStatus( &status, CODES( 0 ), 1 );
LALCCreateVector( &status, &fft, n / 2 + 1 );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateForwardRealFFTPlan( &status, &fwd, n, 0 );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateReverseRealFFTPlan( &status, &rev, n, 0 );
TestStatus( &status, CODES( 0 ), 1 );
/*
*
* Do m trials of random data.
*
*/
for ( i = 0; i < m; ++i )
{
srand( s++ ); /* seed the random number generator */
/*
*
* Create data and compute error tolerance.
*
* Reference: Kaneko and Liu,
* "Accumulation of round-off error in fast fourier tranforms"
* J. Asssoc. Comp. Mach, Vol 17 (No 4) 637-654, October 1970.
*
*/
srand( i ); /* seed the random number generator */
ssq = 0;
for ( j = 0; j < n; ++j )
{
dat->data[j] = 20.0 * rand() / (REAL4)( RAND_MAX + 1.0 ) - 10.0;
ssq += dat->data[j] * dat->data[j];
fp ? fprintf( fp, "%e\n", dat->data[j] ) : 0;
}
lbn = log( n ) / log( 2 );
var = 2.5 * lbn * eps * eps * ssq / n;
tol = 5 * sqrt( var ); /* up to 5 sigma excursions */
fp ? fprintf( fp, "\neps = %e \ntol = %e\n", eps, tol ) : 0;
/*
*
* Perform forward FFT and DFT (only if n < 100).
*
*/
LALForwardRealFFT( &status, fft, dat, fwd );
TestStatus( &status, CODES( 0 ), 1 );
LALREAL4VectorFFT( &status, rfft, dat, fwd );
TestStatus( &status, CODES( 0 ), 1 );
LALREAL4VectorFFT( &status, ans, rfft, rev );
TestStatus( &status, CODES( 0 ), 1 );
fp ? fprintf( fp, "rfft()\t\trfft(rfft())\trfft(rfft())\n\n" ) : 0;
for ( j = 0; j < n; ++j )
{
fp ? fprintf( fp, "%e\t%e\t%e\n",
rfft->data[j], ans->data[j], ans->data[j] / n ) : 0;
}
if ( n < 128 )
{
LALForwardRealDFT( &status, dft, dat );
TestStatus( &status, CODES( 0 ), 1 );
/*
*
* Check accuracy of FFT vs DFT.
*
*/
fp ? fprintf( fp, "\nfftre\t\tfftim\t\t" ) : 0;
fp ? fprintf( fp, "dtfre\t\tdftim\n" ) : 0;
for ( k = 0; k <= n / 2; ++k )
{
REAL8 fftre = creal(fft->data[k]);
REAL8 fftim = cimag(fft->data[k]);
REAL8 dftre = creal(dft->data[k]);
REAL8 dftim = cimag(dft->data[k]);
REAL8 errre = fabs( dftre - fftre );
REAL8 errim = fabs( dftim - fftim );
REAL8 avere = fabs( dftre + fftre ) / 2 + eps;
REAL8 aveim = fabs( dftim + fftim ) / 2 + eps;
REAL8 ferre = errre / avere;
REAL8 ferim = errim / aveim;
fp ? fprintf( fp, "%e\t%e\t", fftre, fftim ) : 0;
fp ? fprintf( fp, "%e\t%e\n", dftre, dftim ) : 0;
/* fp ? fprintf( fp, "%e\t%e\t", errre, errim ) : 0; */
/* fp ? fprintf( fp, "%e\t%e\n", ferre, ferim ) : 0; */
if ( ferre > eps && errre > tol )
{
fputs( "FAIL: Incorrect result from forward transform\n", stderr );
fprintf( stderr, "\tdifference = %e\n", errre );
fprintf( stderr, "\ttolerance = %e\n", tol );
fprintf( stderr, "\tfrac error = %e\n", ferre );
fprintf( stderr, "\tprecision = %e\n", eps );
return 1;
}
if ( ferim > eps && errim > tol )
{
fputs( "FAIL: Incorrect result from forward transform\n", stderr );
fprintf( stderr, "\tdifference = %e\n", errim );
fprintf( stderr, "\ttolerance = %e\n", tol );
fprintf( stderr, "\tfrac error = %e\n", ferim );
fprintf( stderr, "\tprecision = %e\n", eps );
return 1;
}
}
}
/*
*
* Perform reverse FFT and check accuracy vs original data.
*
*/
LALReverseRealFFT( &status, ans, fft, rev );
TestStatus( &status, CODES( 0 ), 1 );
fp ? fprintf( fp, "\ndat->data[j]\tans->data[j] / n\n" ) : 0;
for ( j = 0; j < n; ++j )
{
REAL8 err = fabs( dat->data[j] - ans->data[j] / n );
REAL8 ave = fabs( dat->data[j] + ans->data[j] / n ) / 2 + eps;
REAL8 fer = err / ave;
fp ? fprintf( fp, "%e\t%e\n", dat->data[j], ans->data[j] / n ) : 0;
/* fp ? fprintf( fp, "%e\t%e\n", err, fer ) : 0; */
if ( fer > eps && err > tol )
{
fputs( "FAIL: Incorrect result after reverse transform\n", stderr );
fprintf( stderr, "\tdifference = %e\n", err );
fprintf( stderr, "\ttolerance = %e\n", tol );
fprintf( stderr, "\tfrac error = %e\n", fer );
fprintf( stderr, "\tprecision = %e\n", eps );
return 1;
}
}
}
LALSDestroyVector( &status, &dat );
TestStatus( &status, CODES( 0 ), 1 );
LALSDestroyVector( &status, &rfft );
TestStatus( &status, CODES( 0 ), 1 );
LALSDestroyVector( &status, &ans );
TestStatus( &status, CODES( 0 ), 1 );
LALCDestroyVector( &status, &dft );
TestStatus( &status, CODES( 0 ), 1 );
LALCDestroyVector( &status, &fft );
TestStatus( &status, CODES( 0 ), 1 );
LALDestroyRealFFTPlan( &status, &fwd );
TestStatus( &status, CODES( 0 ), 1 );
LALDestroyRealFFTPlan( &status, &rev );
TestStatus( &status, CODES( 0 ), 1 );
}
LALCheckMemoryLeaks();
return 0;
}
/* Function to generate time domain waveform for injection */
void GenerateTimeDomainWaveformForInjection (
LALStatus *status,
REAL4Vector *buff,
InspiralTemplate *param
)
{
CoherentGW waveform;
PPNParamStruc ppnParams;
INT4 nStartPad = 0;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
memset( &waveform, 0, sizeof(CoherentGW) );
ppnParams.deltaT = 1.0 / param->tSampling;
ppnParams.mTot = param->mass1 + param->mass2;
ppnParams.eta = param->eta;
ppnParams.d = param->distance;
ppnParams.inc = param->inclination;
ppnParams.phi = param->startPhase;
ppnParams.fStartIn = param->fLower;
ppnParams.fStopIn = -1.0 / (6.0 * sqrt(6.0) * LAL_PI * ppnParams.mTot * LAL_MTSUN_SI);
ppnParams.position.longitude = param->sourcePhi;
ppnParams.position.latitude = param->sourceTheta;
ppnParams.position.system = COORDINATESYSTEM_EQUATORIAL;
ppnParams.psi = param->polarisationAngle;
ppnParams.epoch.gpsSeconds = 0;
ppnParams.epoch.gpsNanoSeconds = 0;
/* the waveform generation itself */
/* Note that in the call to LALInspiralWaveForInjection,
* the param.nStartPad will be reset to zero. We do
* not want to lose the information. So we should save it
* somewhere (in a temporary variable) before the function
* call.
*/
nStartPad = param->nStartPad;
LALInspiralWaveForInjection(status->statusPtr, &waveform, param, &ppnParams);
CHECKSTATUSPTR(status);
/* Now reinstate nStartPad from saved value */
param->nStartPad = nStartPad;
/* Generate F+ and Fx and combine it with h+ and hx to get
* the correct waveform. See equation from BCV2 (Eq 29,
* 30). */
{
REAL8 t, p, s, a1, a2, phi, phi0, shift;
REAL8 fp, fc, hp, hc;
UINT4 kk;
t = cos(param->sourceTheta);
p = 2. * param->sourcePhi;
s = 2. * param->polarisationAngle;
fp = 0.5*(1 + t*t)*cos(p)*cos(s) - t*sin(p)*sin(s);
fc = 0.5*(1 + t*t)*cos(p)*sin(s) + t*sin(p)*cos(s);
phi0 = waveform.phi->data->data[0];
for (kk=0; kk < waveform.phi->data->length; kk++)
{
a1 = waveform.a->data->data[2*kk];
a2 = waveform.a->data->data[2*kk+1];
/* phi = waveform.phi->data->data[kk] - phi0 -
* param->startPhase;*/
phi = waveform.phi->data->data[kk] - phi0;
shift = waveform.shift->data->data[kk];
hp = a1*cos(shift)*cos(phi) - a2*sin(shift)*sin(phi);
hc = a1*sin(shift)*cos(phi) + a2*cos(shift)*sin(phi);
buff->data[kk + param->nStartPad] = fp*hp + fc*hc;
}
LALSDestroyVectorSequence( status->statusPtr, &(waveform.a->data) );
CHECKSTATUSPTR( status );
LALSDestroyVector( status->statusPtr, &(waveform.f->data) );
CHECKSTATUSPTR( status );
LALDDestroyVector( status->statusPtr, &(waveform.phi->data) );
CHECKSTATUSPTR( status );
LALSDestroyVector( status->statusPtr, &(waveform.shift->data) );
CHECKSTATUSPTR( status );
LALFree( waveform.a );
LALFree( waveform.f );
LALFree( waveform.phi );
LALFree( waveform.shift );
}
param->fFinal = ppnParams.fStop;
DETATCHSTATUSPTR(status);
RETURN(status);
}
void
LALCoarseFitToPulsar ( LALStatus *status,
CoarseFitOutput *output,
CoarseFitInput *input,
CoarseFitParams *params )
{
/******* DECLARE VARIABLES ************/
UINT4 n,i,j; /* integer indices */
REAL8 psi;
REAL8 h0;
REAL8 cosIota;
REAL8 phase;
REAL8 chiSquare;
LALDetector detector;
LALSource pulsar;
LALDetAndSource detAndSource;
LALDetAMResponse computedResponse;
REAL4Vector *Fp, *Fc; /* pointers to amplitude responses of the detector */
REAL8Vector *var;
REAL8 cos2phase,sin2phase;
COMPLEX16 Xp, Xc;
REAL8 Y, cosIota2;
COMPLEX16 A,B;
REAL8 sumAA, sumBB, sumAB;
REAL8 h0BestFit=0,phaseBestFit=0, psiBestFit=0, cosIotaBestFit=0;
REAL8 minChiSquare;
UINT4 iH0, iCosIota, iPhase, iPsi, arg;
LALGPSandAcc pGPSandAcc;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/******* CHECK VALIDITY OF ARGUMENTS ************/
ASSERT(output != (CoarseFitOutput *)NULL, status,
FITTOPULSARH_ENULLOUTPUT, FITTOPULSARH_MSGENULLOUTPUT);
ASSERT(params != (CoarseFitParams *)NULL, status,
FITTOPULSARH_ENULLPARAMS, FITTOPULSARH_MSGENULLPARAMS);
ASSERT(input != (CoarseFitInput *)NULL, status,
FITTOPULSARH_ENULLINPUT, FITTOPULSARH_MSGENULLINPUT);
ASSERT(input->B->length == input->var->length, status,
FITTOPULSARH_EVECSIZE , FITTOPULSARH_MSGEVECSIZE );
/******* EXTRACT INPUTS AND PARAMETERS ************/
n = input->B->length;
for (i = 0; i < n; i++)
ASSERT(input->var->data[i].re > 0.0 && input->var->data[i].im > 0.0, status,
FITTOPULSARH_EVAR, FITTOPULSARH_MSGEVAR);
detector = params->detector;
detAndSource.pDetector = &detector;
pulsar = params->pulsarSrc;
/******* ALLOCATE MEMORY TO VECTORS **************/
Fp = NULL;
LALSCreateVector(status->statusPtr, &Fp, n);
Fp->length = n;
Fc = NULL;
LALSCreateVector(status->statusPtr, &Fc, n);
Fc->length = n;
var = NULL;
LALDCreateVector(status->statusPtr, &var, n);
var->length = n;
/******* INITIALIZE VARIABLES *******************/
minChiSquare = INICHISQU;
/******* DO ANALYSIS ************/
for (iPsi = 0; iPsi < params->meshPsi[2]; iPsi++)
{
fprintf(stderr,"%d out of %f iPsi\n", iPsi+1, params->meshPsi[2]);
fflush(stderr);
psi = params->meshPsi[0] + (REAL8)iPsi*params->meshPsi[1];
pulsar.orientation = psi;
detAndSource.pSource = &pulsar;
for (i=0;i<n;i++)
{
Fp->data[i] = 0.0;
Fc->data[i] = 0.0;
for(j=0;j<input->N;j++)
{
pGPSandAcc.gps.gpsNanoSeconds = input->t[i].gpsNanoSeconds;
pGPSandAcc.gps.gpsSeconds = input->t[i].gpsSeconds + (double)j*60.0;
pGPSandAcc.accuracy = 1.0;
LALComputeDetAMResponse(status->statusPtr, &computedResponse,&detAndSource, &pGPSandAcc);
Fp->data[i] += (REAL8)computedResponse.plus;
Fc->data[i] += (REAL8)computedResponse.cross;
}
Fp->data[i] /= (double)input->N;
Fc->data[i] /= (double)input->N;
}
for (iPhase = 0; iPhase < params->meshPhase[2]; iPhase++)
{
phase = params->meshPhase[0] + (REAL8)iPhase*params->meshPhase[1];
cos2phase = cos(2.0*phase);
sin2phase = sin(2.0*phase);
for (iCosIota = 0; iCosIota < params->meshCosIota[2]; iCosIota++)
{
cosIota = params->meshCosIota[0] + (REAL8)iCosIota*params->meshCosIota[1];
cosIota2 = 1.0 + cosIota*cosIota;
Xp.re = 0.25*cosIota2 * cos2phase;
Xp.im = 0.25*cosIota2 * sin2phase;
Y = 0.5*cosIota;
Xc.re = Y*sin2phase;
Xc.im = -Y*cos2phase;
sumAB = 0.0;
sumAA = 0.0;
sumBB = 0.0;
for (i = 0; i < n; i++)
{
B.re = input->B->data[i].re;
B.im = input->B->data[i].im;
A.re = Fp->data[i]*Xp.re + Fc->data[i]*Xc.re;
A.im = Fp->data[i]*Xp.im + Fc->data[i]*Xc.im;
sumBB += B.re*B.re/input->var->data[i].re +
B.im*B.im/input->var->data[i].im;
sumAA += A.re*A.re/input->var->data[i].re +
A.im*A.im/input->var->data[i].im;
sumAB += B.re*A.re/input->var->data[i].re +
B.im*A.im/input->var->data[i].im;
}
for (iH0 = 0; iH0 < params->meshH0[2]; iH0++)
{
h0 = params->meshH0[0] + (float)iH0*params->meshH0[1];
chiSquare = sumBB - 2.0*h0*sumAB + h0*h0*sumAA;
if (chiSquare<minChiSquare)
{
minChiSquare = chiSquare;
h0BestFit = h0;
cosIotaBestFit = cosIota;
psiBestFit = psi;
phaseBestFit = phase;
}
arg = iH0 + params->meshH0[2]*(iCosIota + params->meshCosIota[2]*(iPhase + params->meshPhase[2]*iPsi));
output->mChiSquare->data[arg] = chiSquare;
}
}
}
}
/******* CONSTRUCT OUTPUT ************/
output->h0 = h0BestFit;
output->cosIota = cosIotaBestFit;
output->phase = phaseBestFit;
output->psi = psiBestFit;
output->chiSquare = minChiSquare;
ASSERT(minChiSquare < INICHISQU, status,
FITTOPULSARH_EMAXCHI , FITTOPULSARH_MSGEMAXCHI);
LALSDestroyVector(status->statusPtr, &Fp);
LALSDestroyVector(status->statusPtr, &Fc);
LALDDestroyVector(status->statusPtr, &var);
DETATCHSTATUSPTR(status);
RETURN(status);
}
void LALTfrWv (LALStatus *stat, REAL4Vector* sig, TimeFreqRep *tfr, TimeFreqParam *param)
{
INT4 nf;
INT4 time;
INT4 column, row;
INT4 taumax, tau;
REAL4Vector *lacf = NULL; /* local autocorrelation function */
COMPLEX8Vector *vtmp = NULL;
RealFFTPlan *plan = NULL;
INITSTATUS(stat);
ATTATCHSTATUSPTR (stat);
/* Make sure the arguments are not NULL: */
ASSERT (sig, stat, TFR_ENULL, TFR_MSGENULL);
ASSERT (tfr, stat, TFR_ENULL, TFR_MSGENULL);
ASSERT (param, stat, TFR_ENULL, TFR_MSGENULL);
/* Make sure the data pointers are not NULL: */
ASSERT (sig->data, stat, TFR_ENULL, TFR_MSGENULL);
ASSERT (tfr->timeInstant, stat, TFR_ENULL, TFR_MSGENULL);
ASSERT (tfr->freqBin, stat, TFR_ENULL, TFR_MSGENULL);
ASSERT (tfr->map, stat, TFR_ENULL, TFR_MSGENULL);
/* Make sure the requested TFR type corresponds to what will be done */
ASSERT (tfr->type == WignerVille , stat, TFR_ENAME, TFR_MSGENAME);
ASSERT (param->type == WignerVille , stat, TFR_ENAME, TFR_MSGENAME);
/* Make sure the number of freq bins is a positive number: */
nf = tfr->fRow;
ASSERT (nf > 0 , stat, TFR_EFROW, TFR_MSGEFROW);
/* Make sure the number of freq bins is a power of 2: */
while(!(nf & 1))
nf = nf>>1;
ASSERT (nf == 1, stat, TFR_EFROW, TFR_MSGEFROW);
/* Make sure the timeInstant indicates existing time instants */
for (column=0 ; column<tfr->tCol ; column++)
{
if ((tfr->timeInstant[column] < 0) || (tfr->timeInstant[column] > (INT4)(sig->length-1)))
{
ASSERT (tfr->timeInstant[column] > 0, stat, TFR_EBADT, TFR_MSGEBADT);
ASSERT (tfr->timeInstant[column] < (INT4)sig->length, stat, TFR_EBADT, TFR_MSGEBADT);
}
}
TRY(LALCreateForwardRealFFTPlan(stat->statusPtr, &plan,(UINT4)tfr->fRow,0),stat);
TRY(LALSCreateVector(stat->statusPtr, &lacf, tfr->fRow), stat);
TRY(LALCCreateVector(stat->statusPtr, &vtmp, tfr->fRow/2+1), stat);
for (column = 0; column < tfr->tCol; column++)
{
for (row = 0; row < tfr->fRow; row++)
lacf->data[row] = 0.0;
time = tfr->timeInstant[column];
taumax = MIN (time, (INT4)(sig->length -1 - time));
taumax = MIN (taumax, (tfr->fRow / 2 - 1));
for (tau = -taumax; tau <= taumax; tau++)
{
row = (tfr->fRow+tau)%tfr->fRow;
lacf->data[row] = sig->data[time + tau]*sig->data[time - tau];
}
tau=tfr->fRow/2;
if ((time<=(INT4)sig->length-tau-1)&(time>=tau))
lacf->data[tau] = sig->data[time+tau]*sig->data[time-tau];
LALForwardRealFFT(stat->statusPtr, vtmp, lacf, plan);
for (row = 0; row < (tfr->fRow/2+1); row++)
tfr->map[column][row] = crealf(vtmp->data[row]);
}
/* Reflecting frequency halfing in WV distrob so multiply by 1/2 */
for (row = 0; row < (tfr->fRow/2+1) ; row++)
tfr->freqBin[row] = (REAL4) row / (2 *tfr->fRow);
TRY(LALSDestroyVector(stat->statusPtr, &lacf), stat);
TRY(LALCDestroyVector(stat->statusPtr, &vtmp), stat);
TRY(LALDestroyRealFFTPlan(stat->statusPtr, &plan), stat);
DETATCHSTATUSPTR (stat);
(void)param;
/* normal exit */
RETURN (stat);
}
/**
* \author Creighton, T. D.
*
* \brief Computes a continuous waveform with frequency drift and Doppler
* modulation from an elliptical orbital trajectory.
*
* This function computes a quaiperiodic waveform using the spindown and
* orbital parameters in <tt>*params</tt>, storing the result in
* <tt>*output</tt>.
*
* In the <tt>*params</tt> structure, the routine uses all the "input"
* fields specified in \ref GenerateSpinOrbitCW_h, and sets all of the
* "output" fields. If <tt>params-\>f</tt>=\c NULL, no spindown
* modulation is performed. If <tt>params-\>oneMinusEcc</tt>\f$\notin(0,1]\f$
* (an open orbit), or if
* <tt>params-\>rPeriNorm</tt>\f$\times\f$<tt>params-\>angularSpeed</tt>\f$\geq1\f$
* (faster-than-light speed at periapsis), an error is returned.
*
* In the <tt>*output</tt> structure, the field <tt>output-\>h</tt> is
* ignored, but all other pointer fields must be set to \c NULL. The
* function will create and allocate space for <tt>output-\>a</tt>,
* <tt>output-\>f</tt>, and <tt>output-\>phi</tt> as necessary. The
* <tt>output-\>shift</tt> field will remain set to \c NULL.
*
* ### Algorithm ###
*
* For elliptical orbits, we combine \eqref{eq_spinorbit-tr},
* \eqref{eq_spinorbit-t}, and \eqref{eq_spinorbit-upsilon} to get \f$t_r\f$
* directly as a function of the eccentric anomaly \f$E\f$:
* \f{eqnarray}{
* \label{eq_tr-e1}
* t_r = t_p & + & \left(\frac{r_p \sin i}{c}\right)\sin\omega\\
* & + & \left(\frac{P}{2\pi}\right) \left( E +
* \left[v_p(1-e)\cos\omega - e\right]\sin E
* + \left[v_p\sqrt{\frac{1-e}{1+e}}\sin\omega\right]
* [\cos E - 1]\right) \;,
* \f}
* where \f$v_p=r_p\dot{\upsilon}_p\sin i/c\f$ is a normalized velocity at
* periapsis and \f$P=2\pi\sqrt{(1+e)/(1-e)^3}/\dot{\upsilon}_p\f$ is the
* period of the orbit. For simplicity we write this as:
* \f{equation}{
* \label{eq_tr-e2}
* t_r = T_p + \frac{1}{n}\left( E + A\sin E + B[\cos E - 1] \right) \;,
* \f}
*
* \figure{inject_eanomaly,eps,0.23,Function to be inverted to find eccentric anomaly}
*
* where \f$T_p\f$ is the \e observed time of periapsis passage and
* \f$n=2\pi/P\f$ is the mean angular speed around the orbit. Thus the key
* numerical procedure in this routine is to invert the expression
* \f$x=E+A\sin E+B(\cos E - 1)\f$ to get \f$E(x)\f$. We note that
* \f$E(x+2n\pi)=E(x)+2n\pi\f$, so we only need to solve this expression in
* the interval \f$[0,2\pi)\f$, sketched to the right.
*
* We further note that \f$A^2+B^2<1\f$, although it approaches 1 when
* \f$e\rightarrow1\f$, or when \f$v_p\rightarrow1\f$ and either \f$e=0\f$ or
* \f$\omega=\pi\f$. Except in this limit, Newton-Raphson methods will
* converge rapidly for any initial guess. In this limit, though, the
* slope \f$dx/dE\f$ approaches zero at the point of inflection, and an
* initial guess or iteration landing near this point will send the next
* iteration off to unacceptably large or small values. However, by
* restricting all initial guesses and iterations to the domain
* \f$E\in[0,2\pi)\f$, one will always end up on a trajectory branch that
* will converge uniformly. This should converge faster than the more
* generically robust technique of bisection. (Note: the danger with Newton's method
* has been found to be unstable for certain binary orbital parameters. So if
* Newton's method fails to converge, a bisection algorithm is employed.)
*
* In this algorithm, we start the computation with an arbitrary initial
* guess of \f$E=0\f$, and refine it until the we get agreement to within
* 0.01 parts in part in \f$N_\mathrm{cyc}\f$ (where \f$N_\mathrm{cyc}\f$ is the
* larger of the number of wave cycles in an orbital period, or the
* number of wave cycles in the entire waveform being generated), or one
* part in \f$10^{15}\f$ (an order of magnitude off the best precision
* possible with \c REAL8 numbers). The latter case indicates that
* \c REAL8 precision may fail to give accurate phasing, and one
* should consider modeling the orbit as a set of Taylor frequency
* coefficients \'{a} la <tt>LALGenerateTaylorCW()</tt>. On subsequent
* timesteps, we use the previous timestep as an initial guess, which is
* good so long as the timesteps are much smaller than an orbital period.
* This sequence of guesses will have to readjust itself once every orbit
* (as \f$E\f$ jumps from \f$2\pi\f$ down to 0), but this is relatively
* infrequent; we don't bother trying to smooth this out because the
* additional tests would probably slow down the algorithm overall.
*
* Once a value of \f$E\f$ is found for a given timestep in the output
* series, we compute the system time \f$t\f$ via \eqref{eq_spinorbit-t},
* and use it to determine the wave phase and (non-Doppler-shifted)
* frequency via \eqref{eq_taylorcw-freq}
* and \eqref{eq_taylorcw-phi}. The Doppler shift on the frequency is
* then computed using \eqref{eq_spinorbit-upsilon}
* and \eqref{eq_orbit-rdot}. We use \f$\upsilon\f$ as an intermediate in
* the Doppler shift calculations, since expressing \f$\dot{R}\f$ directly in
* terms of \f$E\f$ results in expression of the form \f$(1-e)/(1-e\cos E)\f$,
* which are difficult to simplify and face precision losses when
* \f$E\sim0\f$ and \f$e\rightarrow1\f$. By contrast, solving for \f$\upsilon\f$ is
* numerically stable provided that the system <tt>atan2()</tt> function is
* well-designed.
*
* The routine does not account for variations in special relativistic or
* gravitational time dilation due to the elliptical orbit, nor does it
* deal with other gravitational effects such as Shapiro delay. To a
* very rough approximation, the amount of phase error induced by
* gravitational redshift goes something like \f$\Delta\phi\sim
* fT(v/c)^2\Delta(r_p/r)\f$, where \f$f\f$ is the typical wave frequency, \f$T\f$
* is either the length of data or the orbital period (whichever is
* \e smaller), \f$v\f$ is the \e true (unprojected) speed at
* periapsis, and \f$\Delta(r_p/r)\f$ is the total range swept out by the
* quantity \f$r_p/r\f$ over the course of the observation. Other
* relativistic effects such as special relativistic time dilation are
* comparable in magnitude. We make a crude estimate of when this is
* significant by noting that \f$v/c\gtrsim v_p\f$ but
* \f$\Delta(r_p/r)\lesssim 2e/(1+e)\f$; we take these approximations as
* equalities and require that \f$\Delta\phi\lesssim\pi\f$, giving:
* \f{equation}{
* \label{eq_relativistic-orbit}
* f_0Tv_p^2\frac{4e}{1+e}\lesssim1 \;.
* \f}
* When this critereon is violated, a warning is generated. Furthermore,
* as noted earlier, when \f$v_p\geq1\f$ the routine will return an error, as
* faster-than-light speeds can cause the emission and reception times to
* be non-monotonic functions of one another.
*/
void
LALGenerateEllipticSpinOrbitCW( LALStatus *stat,
PulsarCoherentGW *output,
SpinOrbitCWParamStruc *params )
{
UINT4 n, i; /* number of and index over samples */
UINT4 nSpin = 0, j; /* number of and index over spindown terms */
REAL8 t, dt, tPow; /* time, interval, and t raised to a power */
REAL8 phi0, f0, twopif0; /* initial phase, frequency, and 2*pi*f0 */
REAL8 f, fPrev; /* current and previous values of frequency */
REAL4 df = 0.0; /* maximum difference between f and fPrev */
REAL8 phi; /* current value of phase */
REAL8 p, vDotAvg; /* orbital period, and 2*pi/(period) */
REAL8 vp; /* projected speed at periapsis */
REAL8 upsilon, argument; /* true anomaly, and argument of periapsis */
REAL8 eCosOmega; /* eccentricity * cosine of argument */
REAL8 tPeriObs; /* time of observed periapsis */
REAL8 spinOff; /* spin epoch - orbit epoch */
REAL8 x; /* observed mean anomaly */
REAL8 dx, dxMax; /* current and target errors in x */
REAL8 a, b; /* constants in equation for x */
REAL8 ecc; /* orbital eccentricity */
REAL8 oneMinusEcc, onePlusEcc; /* 1 - ecc and 1 + ecc */
REAL8 e = 0.0; /* eccentric anomaly */
REAL8 de = 0.0; /* eccentric anomaly step */
REAL8 sine = 0.0, cose = 0.0; /* sine of e, and cosine of e minus 1 */
REAL8 *fSpin = NULL; /* pointer to Taylor coefficients */
REAL4 *fData; /* pointer to frequency data */
REAL8 *phiData; /* pointer to phase data */
INITSTATUS(stat);
ATTATCHSTATUSPTR( stat );
/* Make sure parameter and output structures exist. */
ASSERT( params, stat, GENERATESPINORBITCWH_ENUL,
GENERATESPINORBITCWH_MSGENUL );
ASSERT( output, stat, GENERATESPINORBITCWH_ENUL,
GENERATESPINORBITCWH_MSGENUL );
/* Make sure output fields don't exist. */
ASSERT( !( output->a ), stat, GENERATESPINORBITCWH_EOUT,
GENERATESPINORBITCWH_MSGEOUT );
ASSERT( !( output->f ), stat, GENERATESPINORBITCWH_EOUT,
GENERATESPINORBITCWH_MSGEOUT );
ASSERT( !( output->phi ), stat, GENERATESPINORBITCWH_EOUT,
GENERATESPINORBITCWH_MSGEOUT );
ASSERT( !( output->shift ), stat, GENERATESPINORBITCWH_EOUT,
GENERATESPINORBITCWH_MSGEOUT );
/* If Taylor coeficients are specified, make sure they exist. */
if ( params->f ) {
ASSERT( params->f->data, stat, GENERATESPINORBITCWH_ENUL,
GENERATESPINORBITCWH_MSGENUL );
nSpin = params->f->length;
fSpin = params->f->data;
}
/* Set up some constants (to avoid repeated calculation or
dereferencing), and make sure they have acceptable values. */
oneMinusEcc = params->oneMinusEcc;
ecc = 1.0 - oneMinusEcc;
onePlusEcc = 1.0 + ecc;
if ( ecc < 0.0 || oneMinusEcc <= 0.0 ) {
ABORT( stat, GENERATESPINORBITCWH_EECC,
GENERATESPINORBITCWH_MSGEECC );
}
vp = params->rPeriNorm*params->angularSpeed;
n = params->length;
dt = params->deltaT;
f0 = fPrev = params->f0;
vDotAvg = params->angularSpeed
*sqrt( oneMinusEcc*oneMinusEcc*oneMinusEcc/onePlusEcc );
if ( vp >= 1.0 ) {
ABORT( stat, GENERATESPINORBITCWH_EFTL,
GENERATESPINORBITCWH_MSGEFTL );
}
if ( vp <= 0.0 || dt <= 0.0 || f0 <= 0.0 || vDotAvg <= 0.0 ||
n == 0 ) {
ABORT( stat, GENERATESPINORBITCWH_ESGN,
GENERATESPINORBITCWH_MSGESGN );
}
/* Set up some other constants. */
twopif0 = f0*LAL_TWOPI;
phi0 = params->phi0;
argument = params->omega;
p = LAL_TWOPI/vDotAvg;
a = vp*oneMinusEcc*cos( argument ) + oneMinusEcc - 1.0;
b = vp*sqrt( oneMinusEcc/( onePlusEcc ) )*sin( argument );
eCosOmega = ecc*cos( argument );
if ( n*dt > p )
dxMax = 0.01/( f0*n*dt );
else
dxMax = 0.01/( f0*p );
if ( dxMax < 1.0e-15 ) {
dxMax = 1.0e-15;
#ifndef NDEBUG
LALWarning( stat, "REAL8 arithmetic may not have sufficient"
" precision for this orbit" );
#endif
}
#ifndef NDEBUG
if ( lalDebugLevel & LALWARNING ) {
REAL8 tau = n*dt;
if ( tau > p )
tau = p;
if ( f0*tau*vp*vp*ecc/onePlusEcc > 0.25 )
LALWarning( stat, "Orbit may have significant relativistic"
" effects that are not included" );
}
#endif
/* Compute offset between time series epoch and observed periapsis,
and betweem true periapsis and spindown reference epoch. */
tPeriObs = (REAL8)( params->orbitEpoch.gpsSeconds -
params->epoch.gpsSeconds );
tPeriObs += 1.0e-9 * (REAL8)( params->orbitEpoch.gpsNanoSeconds -
params->epoch.gpsNanoSeconds );
tPeriObs += params->rPeriNorm*sin( params->omega );
spinOff = (REAL8)( params->orbitEpoch.gpsSeconds -
params->spinEpoch.gpsSeconds );
spinOff += 1.0e-9 * (REAL8)( params->orbitEpoch.gpsNanoSeconds -
params->spinEpoch.gpsNanoSeconds );
/* Allocate output structures. */
if ( ( output->a = (REAL4TimeVectorSeries *)
LALMalloc( sizeof(REAL4TimeVectorSeries) ) ) == NULL ) {
ABORT( stat, GENERATESPINORBITCWH_EMEM,
GENERATESPINORBITCWH_MSGEMEM );
}
memset( output->a, 0, sizeof(REAL4TimeVectorSeries) );
if ( ( output->f = (REAL4TimeSeries *)
LALMalloc( sizeof(REAL4TimeSeries) ) ) == NULL ) {
LALFree( output->a ); output->a = NULL;
ABORT( stat, GENERATESPINORBITCWH_EMEM,
GENERATESPINORBITCWH_MSGEMEM );
}
memset( output->f, 0, sizeof(REAL4TimeSeries) );
if ( ( output->phi = (REAL8TimeSeries *)
LALMalloc( sizeof(REAL8TimeSeries) ) ) == NULL ) {
LALFree( output->a ); output->a = NULL;
LALFree( output->f ); output->f = NULL;
ABORT( stat, GENERATESPINORBITCWH_EMEM,
GENERATESPINORBITCWH_MSGEMEM );
}
memset( output->phi, 0, sizeof(REAL8TimeSeries) );
/* Set output structure metadata fields. */
output->position = params->position;
output->psi = params->psi;
output->a->epoch = output->f->epoch = output->phi->epoch
= params->epoch;
output->a->deltaT = n*params->deltaT;
output->f->deltaT = output->phi->deltaT = params->deltaT;
output->a->sampleUnits = lalStrainUnit;
output->f->sampleUnits = lalHertzUnit;
output->phi->sampleUnits = lalDimensionlessUnit;
snprintf( output->a->name, LALNameLength, "CW amplitudes" );
snprintf( output->f->name, LALNameLength, "CW frequency" );
snprintf( output->phi->name, LALNameLength, "CW phase" );
/* Allocate phase and frequency arrays. */
LALSCreateVector( stat->statusPtr, &( output->f->data ), n );
BEGINFAIL( stat ) {
LALFree( output->a ); output->a = NULL;
LALFree( output->f ); output->f = NULL;
LALFree( output->phi ); output->phi = NULL;
} ENDFAIL( stat );
LALDCreateVector( stat->statusPtr, &( output->phi->data ), n );
BEGINFAIL( stat ) {
TRY( LALSDestroyVector( stat->statusPtr, &( output->f->data ) ),
stat );
LALFree( output->a ); output->a = NULL;
LALFree( output->f ); output->f = NULL;
LALFree( output->phi ); output->phi = NULL;
} ENDFAIL( stat );
/* Allocate and fill amplitude array. */
{
CreateVectorSequenceIn in; /* input to create output->a */
in.length = 2;
in.vectorLength = 2;
LALSCreateVectorSequence( stat->statusPtr, &(output->a->data), &in );
BEGINFAIL( stat ) {
TRY( LALSDestroyVector( stat->statusPtr, &( output->f->data ) ),
stat );
TRY( LALDDestroyVector( stat->statusPtr, &( output->phi->data ) ),
stat );
LALFree( output->a ); output->a = NULL;
LALFree( output->f ); output->f = NULL;
LALFree( output->phi ); output->phi = NULL;
} ENDFAIL( stat );
output->a->data->data[0] = output->a->data->data[2] = params->aPlus;
output->a->data->data[1] = output->a->data->data[3] = params->aCross;
}
/* Fill frequency and phase arrays. */
fData = output->f->data->data;
phiData = output->phi->data->data;
for ( i = 0; i < n; i++ ) {
INT4 nOrb; /* number of orbits since the specified orbit epoch */
/* First, find x in the range [0,2*pi]. */
x = vDotAvg*( i*dt - tPeriObs );
nOrb = (INT4)( x/LAL_TWOPI );
if ( x < 0.0 )
nOrb -= 1;
x -= LAL_TWOPI*nOrb;
/* Newton-Raphson iteration to find E(x). Maximum of 100 iterations. */
INT4 maxiter = 100, iter = 0;
while ( iter<maxiter && fabs( dx = e + a*sine + b*cose - x ) > dxMax ) {
iter++;
//Make a check on the step-size so we don't step too far
de = dx/( 1.0 + a*cose + a - b*sine );
if ( de > LAL_PI )
de = LAL_PI;
else if ( de < -LAL_PI )
de = -LAL_PI;
e -= de;
if ( e < 0.0 )
e = 0.0;
else if ( e > LAL_TWOPI )
e = LAL_TWOPI;
sine = sin( e );
cose = cos( e ) - 1.0;
}
/* Bisection algorithm from GSL if Newton's method (above) fails to converge. */
if (iter==maxiter && fabs( dx = e + a*sine + b*cose - x ) > dxMax ) {
//Initialize solver
const gsl_root_fsolver_type *T = gsl_root_fsolver_bisection;
gsl_root_fsolver *s = gsl_root_fsolver_alloc(T);
REAL8 e_lo = 0.0, e_hi = LAL_TWOPI;
gsl_function F;
struct E_solver_params pars = {a, b, x};
F.function = &gsl_E_solver;
F.params = &pars;
if (gsl_root_fsolver_set(s, &F, e_lo, e_hi) != 0) {
LALFree( output->a ); output->a = NULL;
LALFree( output->f ); output->f = NULL;
LALFree( output->phi ); output->phi = NULL;
ABORT( stat, -1, "GSL failed to set initial points" );
}
INT4 keepgoing = 1;
INT4 success = 0;
INT4 root_status = keepgoing;
e = 0.0;
iter = 0;
while (root_status==keepgoing && iter<maxiter) {
iter++;
root_status = gsl_root_fsolver_iterate(s);
if (root_status!=keepgoing && root_status!=success) {
LALFree( output->a ); output->a = NULL;
LALFree( output->f ); output->f = NULL;
LALFree( output->phi ); output->phi = NULL;
ABORT( stat, -1, "gsl_root_fsolver_iterate() failed" );
}
e = gsl_root_fsolver_root(s);
sine = sin(e);
cose = cos(e) - 1.0;
if (fabs( dx = e + a*sine + b*cose - x ) > dxMax) root_status = keepgoing;
else root_status = success;
}
if (root_status!=success) {
LALFree( output->a ); output->a = NULL;
LALFree( output->f ); output->f = NULL;
LALFree( output->phi ); output->phi = NULL;
gsl_root_fsolver_free(s);
ABORT( stat, -1, "Could not converge using bisection algorithm" );
}
gsl_root_fsolver_free(s);
}
/* Compute source emission time, phase, and frequency. */
phi = t = tPow =
( e + LAL_TWOPI*nOrb - ecc*sine )/vDotAvg + spinOff;
f = 1.0;
for ( j = 0; j < nSpin; j++ ) {
f += fSpin[j]*tPow;
phi += fSpin[j]*( tPow*=t )/( j + 2.0 );
}
/* Appy frequency Doppler shift. */
upsilon = 2.0 * atan2 ( sqrt(onePlusEcc/oneMinusEcc) * sin(0.5*e), cos(0.5*e) );
f *= f0 / ( 1.0 + vp*( cos( argument + upsilon ) + eCosOmega ) /onePlusEcc );
phi *= twopif0;
if ( (i > 0) && (fabs( f - fPrev ) > df) )
df = fabs( f - fPrev );
*(fData++) = fPrev = f;
*(phiData++) = phi + phi0;
} /* for i < n */
/* Set output field and return. */
params->dfdt = df*dt;
DETATCHSTATUSPTR( stat );
RETURN( stat );
}
