24 #include <lal/LALInference.h>
25 #include <lal/Units.h>
26 #include <lal/FrequencySeries.h>
27 #include <lal/TimeFreqFFT.h>
28 #include <lal/VectorOps.h>
30 #include <lal/XLALError.h>
31 #include <lal/TimeSeries.h>
32 #include <lal/Sequence.h>
33 #include <lal/StringInput.h>
34 #include <lal/LIGOLwXMLRead.h>
35 #include <lal/LALInferenceInit.h>
36 #include <lal/LALInferenceReadData.h>
37 #include <lal/LALInferenceLikelihood.h>
38 #include <lal/LALInferenceTemplate.h>
39 #include <lal/LALInferencePrior.h>
44 #define UNUSED __attribute__ ((unused))
80 printf(
"Test results: %i failure(s).\n", failureCount);
95 char** list=(
char**)
XLALCalloc(3,
sizeof(
char*));
100 strcpy(list[0],
"foo");
101 strcpy(list[1],
"bar");
102 strcpy(list[2],
"baz");
109 TEST_FAIL(
"Did not use double dash on fist input, should fail; XLAL error code: %i.", errnum);
123 char** list=(
char**)
XLALCalloc(3,
sizeof(
char*));
128 strcpy(list[0],
"filename");
129 strcpy(list[1],
"--bar");
130 strcpy(list[2],
"--baz");
135 printf(
"Standard input woking ... \n ");
138 TEST_FAIL(
"Input error; XLAL error code: %i.", errnum);
152 char** list=(
char**)
XLALCalloc(3,
sizeof(
char*));
157 strcpy(list[0],
"foo");
158 strcpy(list[1],
"-bar");
159 strcpy(list[2],
"-baz");
185 const int argLength=10;
222 const int argLength=10;
241 TEST_FAIL(
"Reading empty file succeeded but should have failed!.");
276 TEST_FAIL(
"Should not pass; non-numeric characters in file!.");
336 testIFOData->
window=window;
342 for (
i=0;
i<length; ++
i){
347 if (testIFOData!=NULL && testModel!=NULL){
351 TEST_FAIL(
"Should not pass; timeToFreqFFTPlan is NULL!");
389 void MCMCAlgorithm (
struct tagLALInferenceRunState *runState);
391 char **names,
REAL8 *values,
int dim,
429 unsigned long int randomseed;
438 fprintf(stdout,
" LALInferenceReadData(): started.\n");
443 fprintf(stdout,
" LALInferenceReadData(): finished.\n");
445 if (irs->
data != NULL) {
446 fprintf(stdout,
" initialize(): successfully read data.\n");
448 fprintf(stdout,
" LALInferenceInjectInspiralSignal(): started.\n");
450 fprintf(stdout,
" LALInferenceInjectInspiralSignal(): finished.\n");
456 fprintf(stdout,
" initialize(): no data read.\n");
460 irs->
GSLrandom = gsl_rng_alloc(gsl_rng_mt19937);
470 if ((devrandom = fopen(
"/dev/urandom",
"r")) == NULL) {
471 gettimeofday(&tv, 0);
472 randomseed = tv.tv_sec + tv.tv_usec;
475 if(!fread(&randomseed,
sizeof(randomseed), 1, devrandom))
480 fprintf(stdout,
" initialize(): random seed: %lu\n", randomseed);
493 REAL8 logPriorCurrent, logPriorProposed;
494 REAL8 logLikelihoodCurrent, logLikelihoodProposed;
496 REAL8 logProposalRatio = 0.0;
497 REAL8 logAcceptanceProbability;
505 proposedParams.
head = NULL;
510 logPriorProposed = runState->
prior(runState, &proposedParams, thread->
model);
511 if (logPriorProposed > -HUGE_VAL)
512 logLikelihoodProposed = runState->
likelihood(&proposedParams, runState->
data, thread->
model);
514 logLikelihoodProposed = -HUGE_VAL;
517 logAcceptanceProbability = (logLikelihoodProposed - logLikelihoodCurrent)
518 + (logPriorProposed - logPriorCurrent)
522 if ((logAcceptanceProbability > 0)
523 || (log(gsl_rng_uniform(thread->
GSLrandom)) < logAcceptanceProbability)) {
540 printf(
" MCMCAlgorithm(); starting parameter values:\n");
545 for(
i=0;
i<100;
i++) {
546 printf(
" MCMC iteration: %d\n",
i+1);
548 runState->evolve(runState);
550 printf(
" accepted! new parameter values:\n");
558 char **names,
REAL8 *values,
int dim,
568 for (
i=0;
i<dim; ++
i)
572 if (*logprior > -HUGE_VAL)
573 *loglikelihood = runState->likelihood(thread->
currentParams, runState->data, thread->
model);
575 *loglikelihood = -HUGE_VAL;
610 REAL8 epsilon = 0.001;
622 REAL8 logprior, loglikelihood;
623 REAL8 *centroid, *reflected, *expanded, *contracted;
624 REAL8 val_reflected, val_expanded, val_contracted;
631 printf(
" NelderMeadAlgorithm(); current parameter values:\n");
643 fprintf(stderr,
" ERROR in NelderMeadAlgorithm(): no \"thread->currentParams\" vector provided.\n");
648 fprintf(stderr,
" ERROR in NelderMeadAlgorithm(): empty \"thread->currentParams\" vector provided.\n");
651 for (
j=1;
j<=
i; ++
j) {
659 fprintf(stderr,
" ERROR in NelderMeadAlgorithm(): \"subset\" feature not yet implemented.\n"); exit(0);
666 nameVec = (
char**)
XLALMalloc(
sizeof(
char*) * nmDim);
667 for (
i=0;
i<nmDim; ++
i) {
681 for (
j=0;
j<nmDim; ++
j)
683 NelderMeadEval(runState, nameVec, &simplex[0], nmDim, &logprior, &loglikelihood);
684 if (!(loglikelihood>-HUGE_VAL)) {
685 fprintf(stderr,
" ERROR in NelderMeadAlgorithm(): invalid starting value provided.\n");
688 val_simplex[0] = ML ? loglikelihood : logprior+loglikelihood;
690 for (
i=1;
i<(nmDim+1); ++
i) {
691 logprior = -HUGE_VAL;
692 while (!(logprior > -HUGE_VAL)) {
696 for (
j=0;
j<nmDim; ++
j)
699 NelderMeadEval(runState, nameVec, &simplex[
i*nmDim], nmDim, &logprior, &loglikelihood);
700 val_simplex[
i] = ML ? loglikelihood : logprior+loglikelihood;
705 for (
i=1;
i<(nmDim+1); ++
i) {
706 if (val_simplex[
i] < val_simplex[mini]) mini =
i;
707 if (val_simplex[
i] > val_simplex[maxi]) maxi =
i;
715 for (
i=0;
i<nmDim; ++
i) {
717 for (
j=0;
j<(nmDim+1); ++
j)
718 centroid[
i] += (
j==mini) ? 0.0 : (1.0/((double)nmDim)) * simplex[
j*nmDim+
i];
720 NelderMeadEval(runState, nameVec, centroid, nmDim, &logprior, &loglikelihood);
724 for (
i=0;
i<nmDim; ++
i)
725 reflected[
i] = centroid[
i] + 1.0*(centroid[
i] - simplex[mini*nmDim +
i]);
726 NelderMeadEval(runState, nameVec, reflected, nmDim, &logprior, &loglikelihood);
727 val_reflected = ML ? loglikelihood : logprior+loglikelihood;
728 if (val_reflected > val_simplex[maxi]) {
730 for (
i=0;
i<nmDim; ++
i)
731 expanded[
i] = centroid[
i] + 2.9*(reflected[
i] - centroid[
i]);
732 NelderMeadEval(runState, nameVec, expanded, nmDim, &logprior, &loglikelihood);
733 val_expanded = ML ? loglikelihood : logprior+loglikelihood;
734 if (val_expanded > val_simplex[maxi]) {
735 for (
i=0;
i<nmDim; ++
i)
736 simplex[mini*nmDim+
i] = expanded[
i];
737 val_simplex[mini] = val_expanded;
740 for (
i=0;
i<nmDim; ++
i)
741 simplex[mini*nmDim+
i] = reflected[
i];
742 val_simplex[mini] = val_reflected;
748 for (
i=0;
i<(nmDim+1); ++
i)
749 j += ((
i!=mini) && (val_reflected > val_simplex[
i]));
751 for (
i=0;
i<nmDim; ++
i)
752 simplex[mini*nmDim+
i] = reflected[
i];
753 val_simplex[mini] = val_reflected;
756 if (val_reflected > val_simplex[mini]) {
757 for (
i=0;
i<nmDim; ++
i)
758 simplex[mini*nmDim+
i] = reflected[
i];
759 val_simplex[mini] = val_reflected;
762 for (
i=0;
i<nmDim; ++
i)
763 contracted[
i] = centroid[
i] + 0.5*(simplex[mini*nmDim+
i] - centroid[
i]);
764 NelderMeadEval(runState, nameVec, contracted, nmDim, &logprior, &loglikelihood);
765 val_contracted = ML ? loglikelihood : logprior+loglikelihood;
766 if (val_contracted > val_simplex[mini]) {
767 for (
i=0;
i<nmDim; ++
i)
768 simplex[mini*nmDim+
i] = contracted[
i];
769 val_simplex[mini] = val_contracted;
772 for (
i=0;
i<(nmDim+1); ++
i)
774 for (
j=0;
j<nmDim; ++
j)
775 simplex[
i*nmDim+
j] += 0.5 * (simplex[maxi*nmDim+
j] - simplex[
i*nmDim+
j]);
776 NelderMeadEval(runState, nameVec, &simplex[
i*nmDim], nmDim, &logprior, &loglikelihood);
777 val_simplex[
i] = ML ? loglikelihood : logprior+loglikelihood;
784 for (
i=1;
i<(nmDim+1); ++
i) {
785 if (val_simplex[
i] < val_simplex[mini]) mini =
i;
786 if (val_simplex[
i] > val_simplex[maxi]) maxi =
i;
788 printf(
" iter=%d, maxi=%f, range=%f\n",
789 iteration, val_simplex[maxi], val_simplex[maxi]-val_simplex[mini]);
791 terminate = ((val_simplex[maxi]-val_simplex[mini]<epsilon) || (iteration>=maxiter));
794 for (
j=0;
j<nmDim; ++
j)
798 printf(
" NelderMeadAlgorithm(); done.\n");
846 fprintf(stdout,
"LALInferenceCompareVariables?: %i\n",
850 fprintf(stdout,
"LALInferenceCompareVariables?: %i\n",
854 fprintf(stdout,
"LALInferenceCompareVariables?: %i\n",
860 fprintf(stdout,
"LALInferenceCompareVariables?: %i\n",
866 fprintf(stdout,
" ----------\n");
871 fprintf(stdout,
" data found --> trying some template computations etc.\n");
877 fprintf(stdout,
" [%d] timeData (\"%s\"): length=%d, deltaT=%f, epoch=%.3f\n",
881 fprintf(stdout,
" freqData (\"%s\"): length=%d, deltaF=%f\n",
883 fprintf(stdout,
" fLow=%.1f Hz, fHigh=%.1f Hz (%d freq bins w/in range)\n",
886 fprintf(stdout,
" detector location: (%.1f, %.1f, %.1f)\n",
888 fprintf(stdout,
" detector response matrix:\n");
975 fprintf(stdout,
" ----------\n");
983 fprintf(stdout,
"Single IFO likelihood test\n");
1011 fprintf(stdout,
"undecomposed likelihood %g \n",
1013 fprintf(stdout,
"null likelihood %g decomposed null likelihood %g\n",
1028 fprintf(stdout,
" generating templates & writing to files...:\n");
1034 fprintf(stdout,
" ----------\n");
1040 double spin1x = 0.5;
1041 double spin1y = 0.1;
1042 double spin1z = 0.0;
1043 double spin2x = 0.2;
1044 double spin2y = 0.0;
1045 double spin2z = 0.3;
1052 double shift0 = 0.3;
1054 double coa_phase = 0.1;
1056 double PNorder = 3.5;
1105 fprintf(stdout,
" ----------\n");
1126 fprintf(stdout,
" ----------\n");
1131 fprintf(stdout,
"PTMCMC test\n");
1185 fprintf(stdout,
"End of PTMCMC test\n");
ProcessParamsTable * LALInferenceParseCommandLine(int argc, char *argv[])
void LALInferenceInitCBCThreads(LALInferenceRunState *run_state, INT4 nthreads)
void LALInferenceInjectInspiralSignal(LALInferenceIFOData *IFOdata, ProcessParamsTable *commandLine)
void NelderMeadAlgorithm(struct tagLALInferenceRunState *runState, LALInferenceVariables *subset)
void TemplateDumpTest(void)
LALInferenceVariables currentParams
int LALInferenceParseCommandLineTEST_STDINPUT(void)
LALInferenceVariables variables2
LALInferenceVariables variables
int LALInferenceProcessParamLine_TEST_CHARFILE(void)
void NelderMeadEval(struct tagLALInferenceRunState *runState, char **names, REAL8 *values, int dim, REAL8 *logprior, REAL8 *loglikelihood)
void LALVariablesTest(void)
void BasicMCMCOneStep(LALInferenceRunState *runState)
int LALInferenceParseCommandLineTEST_DASHINPUT(void)
int LALInferenceExecuteFTTEST_NULLPLAN(void)
LALInferenceIFOData * IfoPtr
LALInferenceRunState * runstate
int LALInferenceProcessParamLine_TEST_EMPTYFILE(void)
int LALInferenceParseCommandLineTEST_NODBLDASH(void)
LALInferenceRunState * initialize(ProcessParamsTable *commandLine)
*Idential to FreqDomainNullLogLikelihood */
int LALInferenceProcessParamLine_TEST(void)
void SingleIFOLikelihoodTest(void)
void MCMCAlgorithm(struct tagLALInferenceRunState *runState)
SimInspiralTable * XLALSimInspiralTableFromLIGOLw(const char *fileName)
void LALInferenceAddVariable(LALInferenceVariables *vars, const char *name, const void *value, LALInferenceVariableType type, LALInferenceParamVaryType vary)
Add a variable named name to vars with initial value referenced by value.
void LALInferenceExecuteFT(LALInferenceModel *model)
Execute FFT for data in IFOdata.
int LALInferenceCompareVariables(LALInferenceVariables *var1, LALInferenceVariables *var2)
Check for equality in two variables.
char * LALInferenceGetVariableName(LALInferenceVariables *vars, int idx)
Get the name of the idx-th variable Indexing starts at 1.
void LALInferenceRemoveVariable(LALInferenceVariables *vars, const char *name)
Remove name from vars Frees the memory for the name structure and its contents.
INT4 LALInferenceGetVariableTypeByIndex(LALInferenceVariables *vars, int idx)
Get the LALInferenceVariableType of the idx -th item in the vars Indexing starts at 1.
void LALInferenceCopyVariables(LALInferenceVariables *origin, LALInferenceVariables *target)
Deep copy the variables from one to another LALInferenceVariables structure.
void LALInferenceProcessParamLine(FILE *inp, char **headers, LALInferenceVariables *vars)
Reads one line from the given file and stores the values there into the variable structure,...
INT4 LALInferenceGetVariableDimension(LALInferenceVariables *vars)
Get number of dimensions in variable vars.
void LALInferenceClearVariables(LALInferenceVariables *vars)
Delete the variables in this structure.
ProcessParamsTable * LALInferenceGetProcParamVal(ProcessParamsTable *procparams, const char *name)
Returns the element of the process params table with "name".
void * LALInferenceGetVariable(const LALInferenceVariables *vars, const char *name)
Return a pointer to the memory the variable vars is stored in specified by name User must cast this p...
void LALInferencePrintVariables(LALInferenceVariables *var)
output contents of a 'LALInferenceVariables' structure * / / * (by now only prints names and types,...
int LALInferenceCheckVariable(LALInferenceVariables *vars, const char *name)
Checks for name being present in vars returns 1(==true) or 0.
void LALInferenceSetVariable(LALInferenceVariables *vars, const char *name, const void *value)
Set a variable named name in vars with a value.
@ LALINFERENCE_PARAM_FIXED
A parameter that is cyclic, such as an angle between 0 and 2pi.
@ LALINFERENCE_PARAM_CIRCULAR
A parameter that simply has a maximum and a minimum.
@ LALINFERENCE_PARAM_LINEAR
@ LALINFERENCE_COMPLEX16_t
@ LALINFERENCE_COMPLEX8_t
REAL8 LALInferenceNullLogLikelihood(LALInferenceIFOData *data)
Identical to LALInferenceFreqDomainNullLogLikelihood, but returns the likelihood of a null template.
REAL8 LALInferenceUndecomposedFreqDomainLogLikelihood(LALInferenceVariables *currentParams, LALInferenceIFOData *data, LALInferenceModel *model)
(log-) likelihood function.
LALInferenceIFOData * LALInferenceReadData(ProcessParamsTable *commandLine)
Read IFO data according to command line arguments.
void LALInferenceDumptemplateFreqDomain(LALInferenceVariables *currentParams, LALInferenceModel *model, const char *filename)
De-bugging function writing a (frequency-domain) signal template to a CSV file.
void LALInferenceDumptemplateTimeDomain(LALInferenceVariables *currentParams, LALInferenceModel *model, const char *filename)
De-bugging function writing a (time-domain) signal template to a CSV file.
void LALInferenceTemplateSineGaussian(LALInferenceModel *model)
Sine-Gaussian (burst) template.
void LALInferenceTemplateXLALSimInspiralChooseWaveform(LALInferenceModel *model)
"XLALSimInspiralChooseWaveform{TD,FD}" wrapper.
void LALInferenceTemplateSinc(LALInferenceModel *model)
Sinc function (burst) template.
void LALInferenceTemplateDampedSinusoid(LALInferenceModel *model)
Damped Sinusoid template.
void * XLALCalloc(size_t m, size_t n)
void * XLALMalloc(size_t n)
REAL8Sequence * XLALCreateREAL8Sequence(size_t length)
COMPLEX16Sequence * XLALCreateCOMPLEX16Sequence(size_t length)
REAL8TimeSeries * XLALCreateREAL8TimeSeries(const CHAR *name, const LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaT, const LALUnit *sampleUnits, size_t length)
const LALUnit lalDimensionlessUnit
const char * XLALErrorString(int errnum)
#define XLAL_TRY(statement, errnum)
REAL8 XLALGPSGetREAL8(const LIGOTimeGPS *epoch)
Structure to contain IFO data.
REAL8TimeSeries * timeData
Detector name.
LALDetector * detector
integration limits for overlap integral in F-domain
REAL8Window * window
(one-sided Noise Power Spectrum)^{-1/2}
COMPLEX16FrequencySeries * freqData
What is this?
struct tagLALInferenceIFOData * next
ROQ data.
REAL8 fLow
FFT plan needed for time/time-and-phase marginalisation.
Structure to constain a model and its parameters.
REAL8FFTPlan * timeToFreqFFTPlan
Burst Waveform cache for LIB.
REAL8TimeSeries * timehCross
REAL8TimeSeries * timehPlus
LALInferenceTemplateFunction templt
Domain of model.
Structure containing inference run state This includes pointers to the function types required to run...
LALInferenceVariables * proposalArgs
The data from the interferometers.
struct tagLALInferenceIFOData * data
Log sample, i.e.
LALInferenceThreadState * threads
LALInferencePriorFunction prior
The algorithm's single iteration function.
LALInferenceLikelihoodFunction likelihood
MultiNest prior for the parameters.
Structure containing chain-specific variables.
LALInferenceVariables * currentParams
Prior boundaries, etc.
LALInferenceModel * model
Cycle of proposals to call.
LALInferenceProposalFunction proposal
Step counter for this thread.
REAL8 * currentIFOLikelihoods
Array storing single-IFO SNRs of current sample.
The LALInferenceVariables structure to contain a set of parameters Implemented as a linked list of LA...
LALInferenceVariableItem * head
CHAR value[LIGOMETA_VALUE_MAX]
LIGOTimeGPS geocent_end_time