/** * This function is largely based on/copied from * XLALAdaptiveRungeKutta4(), which exists inside the * lal/src/utilities/LALAdaptiveRungeKutta4.c file * subroutine. It reads in an array of timeseries that * contain data *not* evenly spaced in time * and performs cubic spline interpolations to resample * the data to uniform time sampling. Interpolations use * GSL's built-in routines, which recompute interpolation * coefficients each time the itnerpolator is called. * This can be extremely inefficient; in case of SEOBNRv4, * first data points exist at very large dt, and * interp. coefficients might be needlessly recomputed * 10,000+ times or more. We also made the optimization * that assumes the data are sampled at points monotone * in time. * tinit and deltat specify the desired initial time and * time spacing for the output interpolated data, * num_input_times denotes the number of points yin arrays * are sampled in time. * yout is the output array. */ UNUSED static int SEOBNRv2OptimizedInterpolatorNoAmpPhase (REAL8Array * yin, REAL8 tinit, REAL8 deltat, UINT4 num_input_times, REAL8Array ** yout) { int errnum = 0; /* needed for the final interpolation */ gsl_spline *interp = NULL; gsl_interp_accel *accel = NULL; int outputlen = 0; REAL8Array *output = NULL; REAL8 *times, *vector; /* aliases */ /* needed for the integration */ size_t dim = 4; interp = gsl_spline_alloc (gsl_interp_cspline, num_input_times); accel = gsl_interp_accel_alloc (); outputlen = (int) (yin->data[num_input_times - 1] / deltat) + 1; output = XLALCreateREAL8ArrayL (2, dim + 1, outputlen); /* Only dim + 1 rather than dim + 3 since we're not adding amp & phase */ if (!interp || !accel || !output) { errnum = XLAL_ENOMEM; /* ouch again, ran out of memory */ if (output) XLALDestroyREAL8Array (output); outputlen = 0; goto bail_out; } /* make an array of times */ times = output->data; for (int j = 0; j < outputlen; j++) times[j] = tinit + deltat * j; /* interpolate! */ for (unsigned int i = 1; i <= dim; i++) { /* only up to dim (4) because we are not interpolating amplitude and phase */ //gsl_spline_init(interp, &yin->data[0], &yin->data[num_input_times * i], num_input_times + 1); gsl_spline_init (interp, &yin->data[0], &yin->data[num_input_times * i], num_input_times); vector = output->data + outputlen * i; unsigned int index_old = 0; double x_lo_old = 0, y_lo_old = 0, b_i_old = 0, c_i_old = 0, d_i_old = 0; for (int j = 0; j < outputlen; j++) { optimized_gsl_spline_eval_e (interp, times[j], accel, &(vector[j]), &index_old, &x_lo_old, &y_lo_old, &b_i_old, &c_i_old, &d_i_old); } } /* deallocate stuff and return */ bail_out: if (interp) XLAL_CALLGSL (gsl_spline_free (interp)); if (accel) XLAL_CALLGSL (gsl_interp_accel_free (accel)); if (errnum) XLAL_ERROR (errnum); *yout = output; return outputlen; }
/*------------------------------------------------------------------------------------------ * * Definitions of functions (only one in this file, so no prototypes needed). * *------------------------------------------------------------------------------------------ */ static int SEOBNRv3OptimizedInterpolatorGeneral( REAL8 * yin, /**<< Data to be interpolated; time first */ REAL8 tinit, /**<< time at which to begin interpolating */ REAL8 deltat, /**<< Spacing between interpolated times */ UINT4 num_input_times, /**<< The number of input times */ REAL8Array ** yout, /**<< Interpolation output */ size_t dim /**<< Number of quantities interpolated (e.g. if yin = {t,x,y,z} then dim 3) */ ) { int errnum = 0; /* needed for the final interpolation */ gsl_spline *interp = NULL; gsl_interp_accel *accel = NULL; int outputlen = 0; REAL8Array *output = NULL; REAL8 *times, *vector; /* aliases */ /* note: for speed, this replaces the single CALLGSL wrapper applied before each GSL call */ interp = gsl_spline_alloc(gsl_interp_cspline, num_input_times); accel = gsl_interp_accel_alloc(); outputlen = (int)(yin[num_input_times-1] / deltat) + 1; output = XLALCreateREAL8ArrayL(2, dim+1, outputlen);/* Original (dim+1)*/ if (!interp || !accel || !output) { errnum = XLAL_ENOMEM; /* ouch again, ran out of memory */ if (output) XLALDestroyREAL8Array(output); outputlen = 0; goto bail_out; } /* make an array of times */ times = output->data; for (int j = 0; j < outputlen; j++) times[j] = tinit + deltat * j; /* interpolate! */ for (unsigned int i = 1; i <= dim; i++) { /* Original (dim) */ //gsl_spline_init(interp, &yin->data[0], &yin->data[num_input_times * i], num_input_times + 1); gsl_spline_init(interp, yin, &(yin[num_input_times * i]), num_input_times); vector = output->data + outputlen * i; unsigned int index_old=0; double x_lo_old=0,y_lo_old=0,b_i_old=0,c_i_old=0,d_i_old=0; for (int j = 0; j < outputlen; j++) { optimized_gsl_spline_eval_e(interp,times[j],accel, &(vector[j]),&index_old,&x_lo_old,&y_lo_old,&b_i_old,&c_i_old,&d_i_old); } } /* deallocate stuff and return */ bail_out: if (interp) XLAL_CALLGSL(gsl_spline_free(interp)); if (accel) XLAL_CALLGSL(gsl_interp_accel_free(accel)); if (errnum) XLAL_ERROR(errnum); *yout = output; return outputlen; }
int main( int argc, char **argv ) { INT4 i,j; struct coh_PTF_params *params = NULL; ProcessParamsTable *procpar = NULL; REAL4FFTPlan *fwdplan = NULL; REAL4FFTPlan *psdplan = NULL; REAL4FFTPlan *revplan = NULL; COMPLEX8FFTPlan *invPlan = NULL; REAL4TimeSeries *channel[LAL_NUM_IFO+1]; REAL4FrequencySeries *invspec[LAL_NUM_IFO+1]; RingDataSegments *segments[LAL_NUM_IFO+1]; INT4 numTmplts = 0; INT4 startTemplate = -1; /* index of first template */ INT4 stopTemplate = -1; /* index of last template */ INT4 numSegments = 0; InspiralTemplate *PTFtemplate = NULL; InspiralTemplate *PTFbankhead = NULL; SnglInspiralTable *PTFSpinTmplt = NULL; SnglInspiralTable *PTFSpinTmpltHead = NULL; SnglInspiralTable *PTFNoSpinTmplt = NULL; SnglInspiralTable *PTFNoSpinTmpltHead = NULL; SnglInspiralTable *PTFLastTmplt = NULL; FindChirpTemplate *fcTmplt = NULL; FindChirpTmpltParams *fcTmpltParams = NULL; FindChirpInitParams *fcInitParams = NULL; UINT4 numPoints,ifoNumber,spinTemplate; REAL8Array *PTFM[LAL_NUM_IFO+1]; REAL8Array *PTFN[LAL_NUM_IFO+1]; COMPLEX8VectorSequence *PTFqVec[LAL_NUM_IFO+1]; time_t startTime; LALDetector *detectors[LAL_NUM_IFO+1]; REAL4 *timeOffsets; REAL4 *Fplus; REAL8 FplusTmp; REAL4 *Fcross; REAL8 FcrossTmp; REAL8 detLoc[3]; REAL4TimeSeries UNUSED *pValues[10]; REAL4TimeSeries UNUSED *gammaBeta[2]; LIGOTimeGPS segStartTime; MultiInspiralTable *eventList = NULL; UINT4 numDetectors = 0; UINT4 singleDetector = 0; char bankFileName[256]; startTime = time(NULL); /* set error handlers to abort on error */ set_abrt_on_error(); /* options are parsed and debug level is set here... */ /* no lal mallocs before this! */ params = coh_PTF_get_params( argc, argv ); /* create process params */ procpar = create_process_params( argc, argv, PROGRAM_NAME ); verbose("Read input params %ld \n", time(NULL)-startTime); /* create forward and reverse fft plans */ fwdplan = coh_PTF_get_fft_fwdplan( params ); psdplan = coh_PTF_get_fft_psdplan( params ); revplan = coh_PTF_get_fft_revplan( params ); verbose("Made fft plans %ld \n", time(NULL)-startTime); /* Determine if we are analyzing single or multiple ifo data */ for( ifoNumber = 0; ifoNumber < LAL_NUM_IFO; ifoNumber++) { if ( params->haveTrig[ifoNumber] ) { numDetectors++; } } /* NULL out the pValues pointer array */ for ( i = 0 ; i < 10 ; i++ ) { pValues[i] = NULL; } gammaBeta[0] = NULL; gammaBeta[1] = NULL; if (numDetectors == 0 ) { fprintf(stderr,"You have not specified any detectors to analyse"); return 1; } else if (numDetectors == 1 ) { fprintf(stdout,"You have only specified one detector, why are you using the coherent code? \n"); singleDetector = 1; } /* Convert the file names */ if ( params->bankFile ) strncpy(bankFileName,params->bankFile,sizeof(bankFileName)-1); REAL4 *timeSlideVectors; timeSlideVectors=LALCalloc(1, (LAL_NUM_IFO+1)* params->numOverlapSegments*sizeof(REAL4)); memset(timeSlideVectors, 0, (LAL_NUM_IFO+1) * params->numOverlapSegments * sizeof(REAL4)); for( ifoNumber = 0; ifoNumber < LAL_NUM_IFO; ifoNumber++) { /* Initialize some of the structures */ channel[ifoNumber] = NULL; invspec[ifoNumber] = NULL; segments[ifoNumber] = NULL; PTFM[ifoNumber] = NULL; PTFN[ifoNumber] = NULL; PTFqVec[ifoNumber] = NULL; if ( params->haveTrig[ifoNumber] ) { /* Read in data from the various ifos */ channel[ifoNumber] = coh_PTF_get_data(params,params->channel[ifoNumber],\ params->dataCache[ifoNumber],ifoNumber ); coh_PTF_rescale_data (channel[ifoNumber],1E20); /* compute the spectrum */ invspec[ifoNumber] = coh_PTF_get_invspec( channel[ifoNumber], fwdplan,\ revplan, psdplan, params ); /* create the segments */ segments[ifoNumber] = coh_PTF_get_segments( channel[ifoNumber],\ invspec[ifoNumber], fwdplan, ifoNumber, timeSlideVectors, params ); numSegments = segments[ifoNumber]->numSgmnt; verbose("Created segments for one ifo %ld \n", time(NULL)-startTime); } } /* Determine time delays and response functions */ timeOffsets = LALCalloc(1, numSegments*LAL_NUM_IFO*sizeof( REAL4 )); Fplus = LALCalloc(1, numSegments*LAL_NUM_IFO*sizeof( REAL4 )); Fcross = LALCalloc(1, numSegments*LAL_NUM_IFO*sizeof( REAL4 )); for( ifoNumber = 0; ifoNumber < LAL_NUM_IFO; ifoNumber++) { detectors[ifoNumber] = LALCalloc( 1, sizeof( *detectors[ifoNumber] )); XLALReturnDetector(detectors[ifoNumber] ,ifoNumber); for ( i = 0; i < 3; i++ ) { detLoc[i] = (double) detectors[ifoNumber]->location[i]; } for ( j = 0; j < numSegments; ++j ) { /* Despite being called segStartTime we use the time at the middle * of a segment */ segStartTime = params->startTime; /*XLALGPSAdd(&segStartTime,(j+1)*params->segmentDuration/2.0);*/ XLALGPSAdd(&segStartTime,8.5*params->segmentDuration/2.0); /*XLALGPSMultiply(&segStartTime,0.); XLALGPSAdd(&segStartTime,874610713.072549154);*/ timeOffsets[j*LAL_NUM_IFO+ifoNumber] = (REAL4) XLALTimeDelayFromEarthCenter(detLoc,params->rightAscension, params->declination,&segStartTime); XLALComputeDetAMResponse(&FplusTmp, &FcrossTmp, (const REAL4 (*)[3])detectors[ifoNumber]->response,params->rightAscension, params->declination,0.,XLALGreenwichMeanSiderealTime(&segStartTime)); Fplus[j*LAL_NUM_IFO + ifoNumber] = (REAL4) FplusTmp; Fcross[j*LAL_NUM_IFO + ifoNumber] = (REAL4) FcrossTmp; } LALFree(detectors[ifoNumber]); } numPoints = floor( params->segmentDuration * params->sampleRate + 0.5 ); /* Initialize some of the structures */ ifoNumber = LAL_NUM_IFO; channel[ifoNumber] = NULL; invspec[ifoNumber] = NULL; segments[ifoNumber] = NULL; PTFM[ifoNumber] = NULL; PTFN[ifoNumber] = NULL; PTFqVec[ifoNumber] = NULL; /* Create the relevant structures that will be needed */ fcInitParams = LALCalloc( 1, sizeof( *fcInitParams )); fcTmplt = LALCalloc( 1, sizeof( *fcTmplt ) ); fcTmpltParams = LALCalloc ( 1, sizeof( *fcTmpltParams ) ); fcTmpltParams->approximant = FindChirpPTF; fcTmplt->PTFQtilde = XLALCreateCOMPLEX8VectorSequence( 5, numPoints / 2 + 1 ); /* fcTmplt->PTFBinverse = XLALCreateArrayL( 2, 5, 5 ); fcTmplt->PTFB = XLALCreateArrayL( 2, 5, 5 );*/ fcTmplt->PTFQ = XLALCreateVectorSequence( 5, numPoints ); fcTmpltParams->PTFphi = XLALCreateVector( numPoints ); fcTmpltParams->PTFomega_2_3 = XLALCreateVector( numPoints ); fcTmpltParams->PTFe1 = XLALCreateVectorSequence( 3, numPoints ); fcTmpltParams->PTFe2 = XLALCreateVectorSequence( 3, numPoints ); fcTmpltParams->fwdPlan = XLALCreateForwardREAL4FFTPlan( numPoints, 1 ); fcTmpltParams->deltaT = 1.0/params->sampleRate; for( ifoNumber = 0; ifoNumber < LAL_NUM_IFO; ifoNumber++) { if ( params->haveTrig[ifoNumber] ) { PTFM[ifoNumber] = XLALCreateREAL8ArrayL( 2, 5, 5 ); PTFN[ifoNumber] = XLALCreateREAL8ArrayL( 2, 5, 5 ); PTFqVec[ifoNumber] = XLALCreateCOMPLEX8VectorSequence ( 5, numPoints ); } } /* Create an inverser FFT plan */ invPlan = XLALCreateReverseCOMPLEX8FFTPlan( numPoints, 1 ); /* Read in the tmpltbank xml file */ numTmplts = InspiralTmpltBankFromLIGOLw( &PTFtemplate,bankFileName, startTemplate, stopTemplate ); PTFbankhead = PTFtemplate; /*fake_template (PTFtemplate);*/ for (i = 0; (i < numTmplts); PTFtemplate = PTFtemplate->next, i++) { /* Determine if we can model this template as non-spinning */ spinTemplate = 1; if (PTFtemplate->chi < 0.1) spinTemplate = 0; PTFtemplate->approximant = FindChirpPTF; PTFtemplate->order = LAL_PNORDER_TWO; PTFtemplate->fLower = 38.; /* Generate the Q freq series of the template */ coh_PTF_template(fcTmplt,PTFtemplate,fcTmpltParams); verbose("Generated template %d at %ld \n", i, time(NULL)-startTime); for ( ifoNumber = 0; ifoNumber < LAL_NUM_IFO; ifoNumber++) { if ( params->haveTrig[ifoNumber] ) { memset( PTFM[ifoNumber]->data, 0, 25 * sizeof(REAL8) ); memset( PTFN[ifoNumber]->data, 0, 25 * sizeof(REAL8) ); memset( PTFqVec[ifoNumber]->data, 0, 5 * numPoints * sizeof(COMPLEX8) ); coh_PTF_normalize(params,fcTmplt,invspec[ifoNumber],PTFM[ifoNumber], PTFN[ifoNumber],PTFqVec[ifoNumber], &segments[ifoNumber]->sgmnt[0],invPlan,1); } } spinTemplate = coh_PTF_spin_checker(PTFM,PTFN,params,singleDetector,Fplus,Fcross,numSegments/2); if (spinTemplate) verbose("Template %d treated as spin at %ld \n",i,time(NULL)-startTime); else verbose("Template %d treated as non spin at %ld \n",i,time(NULL)-startTime); if (spinTemplate) { if ( !PTFSpinTmplt ) { PTFSpinTmpltHead = conv_insp_tmpl_to_sngl_table(PTFtemplate,i); PTFSpinTmplt = PTFSpinTmpltHead; } else { PTFLastTmplt = PTFSpinTmplt; PTFSpinTmplt = conv_insp_tmpl_to_sngl_table(PTFtemplate,i); PTFLastTmplt->next = PTFSpinTmplt; } } else { if ( !PTFNoSpinTmplt ) { PTFNoSpinTmpltHead = conv_insp_tmpl_to_sngl_table(PTFtemplate,i); PTFNoSpinTmplt = PTFNoSpinTmpltHead; } else { PTFLastTmplt = PTFNoSpinTmplt; PTFNoSpinTmplt = conv_insp_tmpl_to_sngl_table(PTFtemplate,i); PTFLastTmplt->next = PTFNoSpinTmplt; } } if (! PTFtemplate->event_id) { PTFtemplate->event_id = (EventIDColumn *) LALCalloc(1, sizeof(EventIDColumn) ); PTFtemplate->event_id->id = i; } } coh_PTF_output_tmpltbank(params->spinBankName,PTFSpinTmpltHead,procpar,params); coh_PTF_output_tmpltbank(params->noSpinBankName,PTFNoSpinTmpltHead,procpar,params); verbose("Generated output xml files, cleaning up and exiting at %ld \n", time(NULL)-startTime); LALFree(timeSlideVectors); coh_PTF_cleanup(params,procpar,fwdplan,psdplan,revplan,invPlan,channel, invspec,segments,eventList,NULL,PTFbankhead,fcTmplt,fcTmpltParams, fcInitParams,PTFM,PTFN,PTFqVec,timeOffsets,NULL,Fplus,Fcross,NULL,NULL,\ NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL); while ( PTFSpinTmpltHead ) { PTFSpinTmplt = PTFSpinTmpltHead; PTFSpinTmpltHead = PTFSpinTmplt->next; if ( PTFSpinTmplt->event_id ) { LALFree( PTFSpinTmplt->event_id ); } LALFree( PTFSpinTmplt ); } while ( PTFNoSpinTmpltHead ) { PTFNoSpinTmplt = PTFNoSpinTmpltHead; PTFNoSpinTmpltHead = PTFNoSpinTmplt->next; if ( PTFNoSpinTmplt->event_id ) { LALFree( PTFNoSpinTmplt->event_id ); } LALFree( PTFNoSpinTmplt ); } LALCheckMemoryLeaks(); return 0; }