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()