void
LALInspiralSiteTimeAndDist(
LALStatus *status,
SimInspiralTable *output,
LALDetector *detector,
LIGOTimeGPS *endTime,
REAL4 *effDist,
SkyPosition *skyPos
)
{
LALSource source;
LALDetAndSource detAndSource;
LALDetAMResponse resp;
REAL8 time_diff;
REAL4 splus, scross, cosiota;
INITSTATUS(status);
ATTATCHSTATUSPTR( status );
/* check that the arguments are not null */
ASSERT( output, status,
LIGOMETADATAUTILSH_ENULL, LIGOMETADATAUTILSH_MSGENULL );
ASSERT( detector, status,
LIGOMETADATAUTILSH_ENULL, LIGOMETADATAUTILSH_MSGENULL );
ASSERT( endTime, status,
LIGOMETADATAUTILSH_ENULL, LIGOMETADATAUTILSH_MSGENULL );
ASSERT( effDist, status,
LIGOMETADATAUTILSH_ENULL, LIGOMETADATAUTILSH_MSGENULL );
ASSERT( skyPos, status,
LIGOMETADATAUTILSH_ENULL, LIGOMETADATAUTILSH_MSGENULL );
memset( &source, 0, sizeof(LALSource) );
memset( &detAndSource, 0, sizeof(LALDetAndSource) );
source.equatorialCoords = *skyPos;
source.orientation = output->polarization;
detAndSource.pSource = &source;
detAndSource.pDetector = detector;
/* initialize end time with geocentric value */
*endTime = output->geocent_end_time;
/* calculate the detector end time */
time_diff = XLALTimeDelayFromEarthCenter( detector->location, skyPos->longitude, skyPos->latitude, &(output->geocent_end_time) );
XLALGPSAdd(endTime, time_diff);
/* initialize distance with real distance and compute splus and scross */
*effDist = 2.0 * output->distance;
cosiota = cos( output->inclination );
splus = -( 1.0 + cosiota * cosiota );
scross = -2.0 * cosiota;
/* compute the response of the detector */
LALComputeDetAMResponse( status->statusPtr, &resp, &detAndSource,
&output->geocent_end_time );
CHECKSTATUSPTR( status );
/* compute the effective distance */
*effDist /= sqrt(
splus*splus*resp.plus*resp.plus + scross*scross*resp.cross*resp.cross );
/* normal exit */
DETATCHSTATUSPTR (status);
RETURN (status);
}
/**
* Original antenna-pattern function by S Berukoff
*/
void LALComputeAM (LALStatus *status,
AMCoeffs *coe,
LIGOTimeGPS *ts,
AMCoeffsParams *params)
{
REAL4 zeta; /* sine of angle between detector arms */
INT4 i; /* temporary loop index */
LALDetAMResponse response; /* output of LALComputeDetAMResponse */
REAL4 sumA2=0.0;
REAL4 sumB2=0.0;
REAL4 sumAB=0.0; /* variables to store scalar products */
INT4 length=coe->a->length; /* length of input time series */
REAL4 cos2psi;
REAL4 sin2psi; /* temp variables */
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/* Must put an ASSERT checking that ts vec and coe vec are same length */
/* Compute the angle between detector arms, then the reciprocal */
{
LALFrDetector det = params->das->pDetector->frDetector;
zeta = 1.0/(sin(det.xArmAzimuthRadians - det.yArmAzimuthRadians));
if(params->das->pDetector->type == LALDETECTORTYPE_CYLBAR) zeta=1.0;
}
cos2psi = cos(2.0 * params->polAngle);
sin2psi = sin(2.0 * params->polAngle);
/* Note the length is the same for the b vector */
for(i=0; i<length; ++i)
{
REAL4 *a = coe->a->data;
REAL4 *b = coe->b->data;
/* Compute F_plus, F_cross */
LALComputeDetAMResponse(status->statusPtr, &response, params->das, &ts[i]);
/* Compute a, b from JKS eq 10,11
* a = zeta * (F_plus*cos(2\psi)-F_cross*sin(2\psi))
* b = zeta * (F_cross*cos(2\psi)+Fplus*sin(2\psi))
*/
a[i] = zeta * (response.plus*cos2psi-response.cross*sin2psi);
b[i] = zeta * (response.cross*cos2psi+response.plus*sin2psi);
/* Compute scalar products */
sumA2 += SQ(a[i]); /* A */
sumB2 += SQ(b[i]); /* B */
sumAB += (a[i]) * (b[i]); /* C */
}
{
/* Normalization factor */
REAL8 L = 2.0/(REAL8)length;
/* Assign output values and normalise */
coe->A = L*sumA2;
coe->B = L*sumB2;
coe->C = L*sumAB;
coe->D = ( coe->A * coe->B - SQ(coe->C) );
/* protection against case when AB=C^2 */
if(coe->D == 0) coe->D=1.0e-9;
}
/* Normal exit */
DETATCHSTATUSPTR(status);
RETURN(status);
} /* LALComputeAM() */
void
LALGalacticInspiralParamsToSimInspiralTable(
LALStatus *status,
SimInspiralTable *output,
GalacticInspiralParamStruc *input,
RandomParams *params
)
{
PPNParamStruc ppnParams;
SkyPosition skyPos;
LALSource source;
LALDetector lho = lalCachedDetectors[LALDetectorIndexLHODIFF];
LALDetector llo = lalCachedDetectors[LALDetectorIndexLLODIFF];
LALDetAndSource detAndSource;
LALDetAMResponse resp;
REAL8 time_diff;
REAL4 splus, scross, cosiota;
INITSTATUS(status);
ATTATCHSTATUSPTR( status );
ASSERT( output, status,
LIGOMETADATAUTILSH_ENULL, LIGOMETADATAUTILSH_MSGENULL );
ASSERT( input, status,
LIGOMETADATAUTILSH_ENULL, LIGOMETADATAUTILSH_MSGENULL );
ASSERT( params, status,
LIGOMETADATAUTILSH_ENULL, LIGOMETADATAUTILSH_MSGENULL );
/*
*
* compute sky position and inspiral params
*
*/
/* generate the ppn inspiral params */
memset( &ppnParams, 0, sizeof(PPNParamStruc) );
LALGetInspiralParams( status->statusPtr, &ppnParams, input, params );
CHECKSTATUSPTR( status );
if ( ppnParams.position.system != COORDINATESYSTEM_EQUATORIAL )
{
ABORT( status, LIGOMETADATAUTILSH_ECOOR, LIGOMETADATAUTILSH_MSGECOOR );
}
/* copy the inspiral data into sim_inspiral table */
output->mass1 = input->m1;
output->mass2 = input->m2;
output->eta = ppnParams.eta;
output->distance = ppnParams.d / (1.0e6 * LAL_PC_SI); /* Mpc */
output->longitude = ppnParams.position.longitude;
output->latitude = ppnParams.position.latitude;
output->inclination = ppnParams.inc;
output->coa_phase = ppnParams.phi;
output->polarization = ppnParams.psi;
/* populate geocentric end time */
output->geocent_end_time = input->geocentEndTime;
/* populate gmst field (hours) */
output->end_time_gmst = fmod(XLALGreenwichMeanSiderealTime(
&output->geocent_end_time), LAL_TWOPI) * 24.0 / LAL_TWOPI; /* hours*/
ASSERT( !XLAL_IS_REAL8_FAIL_NAN(output->end_time_gmst), status, LAL_FAIL_ERR, LAL_FAIL_MSG );
/* set up params for the site end times and detector response */
memset( &skyPos, 0, sizeof(SkyPosition) );
memset( &source, 0, sizeof(LALSource) );
memset( &detAndSource, 0, sizeof(LALDetAndSource) );
skyPos.longitude = output->longitude;
skyPos.latitude = output->latitude;
skyPos.system = COORDINATESYSTEM_EQUATORIAL;
source.equatorialCoords = skyPos;
source.orientation = output->polarization;
detAndSource.pSource = &source;
/*
*
* compute site end times
*
*/
/* initialize end times with geocentric value */
output->h_end_time = output->l_end_time = input->geocentEndTime;
/* ligo hanford observatory */
time_diff = XLALTimeDelayFromEarthCenter( lho.location, skyPos.longitude, skyPos.latitude, &(output->geocent_end_time) );
XLALGPSAdd(&(output->h_end_time), time_diff);
/* ligo livingston observatory */
time_diff = XLALTimeDelayFromEarthCenter( llo.location, skyPos.longitude, skyPos.latitude, &(output->geocent_end_time) );
XLALGPSAdd(&(output->l_end_time), time_diff);
/*
*
* compute the effective distance of the inspiral
*
*/
/* initialize distances with real distance and compute splus and scross */
output->eff_dist_h = output->eff_dist_l = 2.0 * output->distance;
cosiota = cos( output->inclination );
splus = -( 1.0 + cosiota * cosiota );
scross = -2.0 * cosiota;
/* compute the response of the LHO detectors */
detAndSource.pDetector = &lho;
LALComputeDetAMResponse( status->statusPtr, &resp, &detAndSource,
&output->geocent_end_time );
CHECKSTATUSPTR( status );
/* compute the effective distance for LHO */
output->eff_dist_h /= sqrt(
splus*splus*resp.plus*resp.plus + scross*scross*resp.cross*resp.cross );
/* compute the response of the LLO detector */
detAndSource.pDetector = &llo;
LALComputeDetAMResponse( status->statusPtr, &resp, &detAndSource,
&output->geocent_end_time );
CHECKSTATUSPTR( status );
/* compute the effective distance for LLO */
output->eff_dist_l /= sqrt(
splus*splus*resp.plus*resp.plus + scross*scross*resp.cross*resp.cross );
/*
*
* normal exit
*
*/
DETATCHSTATUSPTR (status);
RETURN (status);
}
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
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
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);
}
/**
* 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);
}
