static int MismatchAgeBrakeTest(
const char *lattice_name,
const double freq,
const double freqband,
const UINT8 total_ref,
const double mism_hist_ref[MISM_HIST_BINS]
)
{
// Create lattice tiling
LatticeTiling *tiling = XLALCreateLatticeTiling(3);
XLAL_CHECK(tiling != NULL, XLAL_EFUNC);
// Add bounds
printf("Bounds: freq=%0.3g, freqband=%0.3g\n", freq, freqband);
XLAL_CHECK(XLALSetLatticeTilingConstantBound(tiling, 0, freq, freq + freqband) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK(XLALSetLatticeTilingF1DotAgeBrakingBound(tiling, 0, 1, 1e11, 2, 5) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK(XLALSetLatticeTilingF2DotBrakingBound(tiling, 0, 1, 2, 2, 5) == XLAL_SUCCESS, XLAL_EFUNC);
// Set metric to the spindown metric
const double max_mismatch = 0.3;
gsl_matrix *GAMAT(metric, 3, 3);
for (size_t i = 0; i < metric->size1; ++i) {
for (size_t j = i; j < metric->size2; ++j) {
const double Tspan = 1036800;
const double metric_i_j_num = 4.0 * LAL_PI * LAL_PI * pow(Tspan, i + j + 2) * (i + 1) * (j + 1);
const double metric_i_j_denom = LAL_FACT[i + 1] * LAL_FACT[j + 1] * (i + 2) * (j + 2) * (i + j + 3);
gsl_matrix_set(metric, i, j, metric_i_j_num / metric_i_j_denom);
gsl_matrix_set(metric, j, i, gsl_matrix_get(metric, i, j));
}
}
printf("Lattice type: %s\n", lattice_name);
XLAL_CHECK(XLALSetTilingLatticeAndMetric(tiling, lattice_name, metric, max_mismatch) == XLAL_SUCCESS, XLAL_EFUNC);
// Perform mismatch test
XLAL_CHECK(MismatchTest(tiling, metric, max_mismatch, total_ref, mism_hist_ref) == XLAL_SUCCESS, XLAL_EFUNC);
return XLAL_SUCCESS;
}
/**
* Set up a full multi-dimensional grid-scan.
* Currently this only emulates a 'factored' grid-scan with 'sky x Freq x f1dot ...' , but
* keeps all details within the DopplerScan module for future extension to real multidimensional
* grids.
*
* NOTE: Use 'XLALNextDopplerPos()' to step through this template grid.
*
*/
DopplerFullScanState *
XLALInitDopplerFullScan ( const DopplerFullScanInit *init /**< [in] initialization parameters */
)
{
XLAL_CHECK_NULL ( init != NULL, XLAL_EINVAL );
DopplerFullScanState *thisScan;
XLAL_CHECK_NULL ( (thisScan = LALCalloc (1, sizeof(*thisScan) )) != NULL, XLAL_ENOMEM );
thisScan->gridType = init->gridType;
/* store the user-input spinRange (includes refTime) in DopplerFullScanState */
thisScan->spinRange.refTime = init->searchRegion.refTime;
memcpy ( thisScan->spinRange.fkdot, init->searchRegion.fkdot, sizeof(PulsarSpins) );
memcpy ( thisScan->spinRange.fkdotBand, init->searchRegion.fkdotBand, sizeof(PulsarSpins) );
// check that some old metric-codes aren't used with refTime!=startTime, which they don't handle correctly
switch ( thisScan->gridType )
{
case GRID_METRIC:
case GRID_METRIC_SKYFILE:
case GRID_SPINDOWN_SQUARE: /* square parameter space */
case GRID_SPINDOWN_AGEBRK: /* age-braking index parameter space */
XLAL_CHECK_NULL ( XLALGPSDiff ( &init->startTime, &init->searchRegion.refTime ) == 0, XLAL_EINVAL,
"NOTE: gridType={metric,4,spin-square,spin-age-brk} only work for refTime (%f) == startTime (%f)!\n",
XLALGPSGetREAL8(&(init->searchRegion.refTime)), XLALGPSGetREAL8(&(init->startTime)) );;
break;
default:
break;
}
/* which "class" of template grid to generate?: factored, or full-multidim ? */
switch ( thisScan->gridType )
{
/* emulate old 'factored' grids 'sky x f0dot x f1dot x f2dot x f3dot': */
case GRID_FLAT:
case GRID_ISOTROPIC:
case GRID_METRIC:
case GRID_FILE_SKYGRID:
case GRID_METRIC_SKYFILE:
/* backwards-compatibility mode */
XLAL_CHECK_NULL ( XLALInitFactoredGrid ( thisScan, init ) == XLAL_SUCCESS, XLAL_EFUNC );
break;
/* ----- multi-dimensional covering of full parameter space ----- */
case GRID_FILE_FULLGRID:
XLAL_CHECK_NULL ( XLALLoadFullGridFile ( thisScan, init ) == XLAL_SUCCESS, XLAL_EFUNC );
break;
case GRID_SPINDOWN_SQUARE: /* square parameter space */
case GRID_SPINDOWN_AGEBRK: /* age-braking index parameter space */
{
const size_t n = 2 + PULSAR_MAX_SPINS;
/* Check that the reference time is the same as the start time */
XLAL_CHECK_NULL ( XLALGPSCmp ( &thisScan->spinRange.refTime, &init->startTime) == 0, XLAL_EINVAL,
"\nGRID_SPINDOWN_{SQUARE,AGEBRK}: This option currently restricts the reference time to be the same as the start time.\n");
/* Create a vector to hold lattice tiling parameter-space points */
XLAL_CHECK_NULL ( (thisScan->spindownTilingPoint = gsl_vector_alloc(n)) != NULL, XLAL_ENOMEM,
"\nGRID_SPINDOWN_{SQUARE,AGEBRK}: gsl_vector_alloc failed\n");
/* Create a lattice tiling */
XLAL_CHECK_NULL ( (thisScan->spindownTiling = XLALCreateLatticeTiling(n)) != NULL, XLAL_EFUNC );
/* Parse the sky region string and check that it consists of only one point, and set bounds on it */
SkyRegion XLAL_INIT_DECL(sky);
XLAL_CHECK_NULL ( XLALParseSkyRegionString ( &sky, init->searchRegion.skyRegionString ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK_NULL ( sky.numVertices == 1, XLAL_EINVAL, "\nGRID_SPINDOWN_{SQUARE,AGEBRK}: This option can only handle a single sky position.\n");
XLAL_CHECK_NULL ( sky.vertices[0].system == COORDINATESYSTEM_EQUATORIAL, XLAL_EINVAL, "\nGRID_SPINDOWN_{SQUARE,AGEBRK}: This option only understands COORDINATESYSTEM_EQUATORIAL\n");
XLAL_CHECK_NULL ( XLALSetLatticeTilingConstantBound(thisScan->spindownTiling, 0, sky.vertices[0].longitude, sky.vertices[0].longitude) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK_NULL ( XLALSetLatticeTilingConstantBound(thisScan->spindownTiling, 1, sky.vertices[0].latitude, sky.vertices[0].latitude) == XLAL_SUCCESS, XLAL_EFUNC );
if (sky.vertices) {
XLALFree (sky.vertices);
}
/* Set up parameter space */
if (thisScan->gridType == GRID_SPINDOWN_SQUARE) { /* square parameter space */
/* Set square bounds on the frequency and spindowns */
for (size_t i = 0; i < PULSAR_MAX_SPINS; ++i) {
XLAL_CHECK_NULL ( XLALSetLatticeTilingConstantBound(thisScan->spindownTiling, 2 + i, init->searchRegion.fkdot[i], init->searchRegion.fkdot[i] + init->searchRegion.fkdotBand[i]) == XLAL_SUCCESS, XLAL_EFUNC );
}
} else if (thisScan->gridType == GRID_SPINDOWN_AGEBRK) { /* age-braking index parameter space */
/* Get age and braking index from extra arguments */
const REAL8 spindownAge = init->extraArgs[0];
const REAL8 minBraking = init->extraArgs[1];
const REAL8 maxBraking = init->extraArgs[2];
/* Set age-braking index parameter space */
XLAL_CHECK_NULL ( XLAL_SUCCESS == XLALSetLatticeTilingConstantBound(thisScan->spindownTiling, 2, init->searchRegion.fkdot[0], init->searchRegion.fkdot[0] + init->searchRegion.fkdotBand[0]), XLAL_EFUNC );
XLAL_CHECK_NULL ( XLAL_SUCCESS == XLALSetLatticeTilingF1DotAgeBrakingBound(thisScan->spindownTiling, 2, 3, spindownAge, minBraking, maxBraking), XLAL_EFUNC );
XLAL_CHECK_NULL ( XLAL_SUCCESS == XLALSetLatticeTilingF2DotBrakingBound(thisScan->spindownTiling, 2, 3, 4, minBraking, maxBraking), XLAL_EFUNC );
/* This current only goes up to second spindown, so bound higher dimensions */
for (size_t i = 3; i < PULSAR_MAX_SPINS; ++i) {
XLAL_CHECK_NULL ( XLAL_SUCCESS == XLALSetLatticeTilingConstantBound(thisScan->spindownTiling, 2 + i, init->searchRegion.fkdot[i], init->searchRegion.fkdot[i] + init->searchRegion.fkdotBand[i]), XLAL_EFUNC );
}
}
/* Create a lattice tiling with Anstar lattice and spindown metric */
gsl_matrix* metric;
XLAL_CHECK_NULL ( (metric = gsl_matrix_alloc(n, n)) != NULL, XLAL_ENOMEM );
gsl_matrix_set_identity(metric);
gsl_matrix_view spin_metric = gsl_matrix_submatrix(metric, 2, 2, PULSAR_MAX_SPINS, PULSAR_MAX_SPINS);
XLAL_CHECK_NULL ( XLALSpindownMetric(&spin_metric.matrix, init->Tspan) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK_NULL ( XLALSetTilingLatticeAndMetric(thisScan->spindownTiling, "Ans", metric, init->metricMismatch) == XLAL_SUCCESS, XLAL_EFUNC );
/* Create iterator over flat lattice tiling */
XLAL_CHECK_NULL ( (thisScan->spindownTilingItr = XLALCreateLatticeTilingIterator(thisScan->spindownTiling, n)) != NULL, XLAL_EFUNC );
/* Cleanup */
gsl_matrix_free(metric);
}
break;
default:
XLAL_ERROR_NULL ( XLAL_EINVAL, "\nInvalid grid type '%d'\n\n", init->gridType );
break;
} /* switch gridType */
/* we're ready */
thisScan->state = STATE_READY;
/* return result */
return thisScan;
} // XLALInitDopplerFullScan()
