Header LALInspiralBank.h

Detailed Description

Header file for the template placement codes.

Author

Churches, D.K. and Sathyaprakash, B.S., Cokelaer, T.

Synopsis

#include <lal/LALInspiralBank.h>

This header file covers routines that are used in template placement.

Modules
	Module LALInspiralBankUtils.c
	NONE.
	Module LALInspiralBCVBank.c
	BCV template bank.
	Module LALInspiralCreateCoarseBank.c
	Functions to create a coarse grid of templates.
	Module LALInspiralHybridHexagonalBank.c
	Hybrid hexagonal template bank.
	Module LALInspiralMoments.c
	Functions to calculate the moment of the noise power spectral density.

Prototypes
void	LALInspiralSpinBank (LALStatus *status, SnglInspiralTable **tiles, INT4 *ntiles, InspiralCoarseBankIn *coarseIn)
	This function creates a bank of BCVSpin templates to search for precessing binaries. More...
void	LALInsidePolygon (LALStatus *status, REAL4 *inputx, REAL4 *inputy, INT4 n, REAL4 x, REAL4 y, INT4 *valid)
	Module to check whether a point with coordinates (x,y) is inside a polygon defined by the vectors (vx, vy), which size (n) must be provided. More...
void	LALInspiralCreateCoarseBank (LALStatus *status, InspiralTemplateList **list, INT4 *nlist, InspiralCoarseBankIn bankIn)
void	LALInspiralCreatePNCoarseBank (LALStatus *status, InspiralTemplateList **list, INT4 *nlist, InspiralCoarseBankIn coarseIn)
void	LALInspiralCreateBCVBank (LALStatus *status, InspiralTemplateList **list, INT4 *nlist, InspiralCoarseBankIn coarseIn)
	Lay a flat grid of BCV templates in the user specified range of the parameters \((\psi_0, \psi_3)\) in coarseIn structure. More...
void	LALInspiralCreateFlatBankS3S4 (LALStatus *status, REAL4VectorSequence *list, InspiralBankParams *bankParams, InspiralCoarseBankIn coarseIn)
	UNDOCUMENTED. More...
void	LALExcludeTemplate (LALStatus *status, INT4 *valid, InspiralBankParams *bankParams, REAL4 x, REAL4 y)
void	LALInspiralBCVBankFcutS3S4 (LALStatus *status, InspiralTemplateList **list, INT4 *NList, InspiralCoarseBankIn coarseIn)
	UNDOCUMENTED. More...
void	LALInspiralBCVFcutBank (LALStatus *status, InspiralTemplateList **list, INT4 *NList, InspiralCoarseBankIn coarseIn)
	Given a grid of templates with distinct values of \((\psi_0, \psi_3)\) this routine returns a new grid in which every template has numFcutTemplates partners differing from one another in the ending frequency fendBCV. More...
void	LALEmpiricalPSItoMassesConversion (LALStatus *status, InspiralTemplate *params, UINT4 *valid, REAL4 lightring)
	UNDOCUMENTED. More...
void	LALPSItoMasses (LALStatus *status, InspiralTemplate *params, UINT4 *valid, REAL4 thisfreq)
	UNDOCUMENTED. More...
void	LALInspiralBCVRegularFcutBank (LALStatus *status, InspiralTemplateList **list, INT4 *NList, InspiralCoarseBankIn coarseIn)
	UNDOCUMENTED. More...
void	LALNudgeTemplatesToConstantTotalMassLine (LALStatus *status, InspiralTemplateList **list, INT4 nlist, InspiralCoarseBankIn coarseIn)
	Anand: 26 October 2006 This function nudges the templates in the list to the (max-total-mass = constant) line. More...
REAL4	XLALInspiralTau3FromTau0AndEqualMassLine (REAL4 tau0, REAL4 fL)
REAL4	XLALInspiralTau3FromNonEqualMass (REAL4 m1, REAL4 m2, REAL4 fL)
REAL4	XLALInspiralTau0FromMEta (REAL4 M, REAL4 eta, REAL4 fL)
REAL8	XLALInspiralBissectionLine (REAL8 x, REAL8 fL, REAL8 mMin, REAL8 mMax)
REAL8	XLALInspiralMFromTau0AndNonEqualMass (REAL8 tau0, REAL8 extremMass, REAL8 fL)
void	LALInspiralBankGeneration (LALStatus *status, InspiralCoarseBankIn *in, SnglInspiralTable **out, INT4 *count)
void	LALInspiralCreateFlatBank (LALStatus *status, REAL4VectorSequence *list, InspiralBankParams *bankParams)
	The code expects list->vectorLength=2 and allocates just the requisite amount of memory to list and returns the number of grid points in list->length. More...
void	LALInspiralCreateFineBank (LALStatus *status, InspiralTemplateList **outlist, INT4 *nlist, InspiralFineBankIn fineIn)
	Function to create a fine grid of templates. More...
void	LALInspiralComputeMetric (LALStatus *status, InspiralMetric *metric, InspiralTemplate *params, InspiralMomentsEtc *moments)
int	XLALInspiralComputeMetric (InspiralMetric *metric, InspiralMomentsEtc *moments, REAL8 fLower, LALPNOrder order, REAL8 t0, REAL8 t3)
	Function to compute the components of the metric which is used to describe distances on the signal manifold. More...
void	LALInspiralComputeMetricBCV (LALStatus *status, InspiralMetric *metric, REAL8FrequencySeries *psd, InspiralTemplate *params)
	UNDOCUMENTED. More...
void	LALInspiralLongestTemplateInBank (LALStatus *status, UINT4 *templateLength, InspiralCoarseBankIn *coarseIn)
	Function to find the longest template in a template bank. More...
void	LALGetInspiralMoments (LALStatus *status, InspiralMomentsEtc *moments, REAL8FrequencySeries *psd, InspiralTemplate *params)
int	XLALGetInspiralMoments (InspiralMomentsEtc *moments, REAL8 fLower, REAL8 fCutoff, REAL8FrequencySeries *psd)
void	LALGetInspiralMomentsBCV (LALStatus *status, InspiralMomentsEtcBCV *moments, REAL8FrequencySeries *psd, InspiralTemplate *params)
void	LALInspiralMoments (LALStatus *status, REAL8 *moment, InspiralMomentsIn pars)
REAL8	XLALInspiralMoments (REAL8 xmin, REAL8 xmax, REAL8 ndx, REAL8 norm, REAL8FrequencySeries *shf)
void	LALInspiralSetSearchLimits (LALStatus *status, InspiralBankParams *bankParams, InspiralCoarseBankIn coarseIn)
	Function which calculates the minimum and maximum values of \(\tau_{0}\) and \(\tau_{3}\). More...
void	LALInspiralNextTemplate (LALStatus *status, InspiralBankParams *bankPars, InspiralMetric metric)
	Routine to compute the parameters of the template next to the current template, but in the positive \(\tau_{2(3)}\) axis. More...
void	LALInspiralComputeParams (LALStatus *status, InspiralTemplate *pars, InspiralBankParams bankParams, InspiralCoarseBankIn coarseIn)
	This function takes as input \(\tau_{0}\), \(\tau_{3}\) and \(f_a\) (the lower frequency of the detectors sensitivity), it then calculates \(m\) (the total mass of the binary), \(\eta\) (the symmetric mass ratio) and the individual mass of the compact objects. More...
void	LALInspiralValidParams (LALStatus *status, INT4 *valid, InspiralBankParams bankParams, InspiralCoarseBankIn coarseIn)
	Function which checks whether or not a pair of parameter values are consistent with the search space. More...
void	LALInspiralValidTemplate (LALStatus *status, INT4 *valid, InspiralBankParams bankParams, InspiralCoarseBankIn coarseIn)
	Function which checks whether or not a given template should be kept in the template list. More...
void	LALInspiralUpdateParams (LALStatus *status, InspiralBankParams *bankParams, InspiralMetric metric, REAL8 minimalmatch)
	Function to update the parameters used in creating a coarse bank based on a square lattice. More...
void	LALInspiralSetParams (LALStatus *status, InspiralTemplate *tempPars, InspiralCoarseBankIn coarseIn)
	A routine that fills an InspiralTemplate structure based on the values in the InspiralCoarseBankIn structure. More...
void	LALRectangleVertices (LALStatus *status, RectangleOut *out, RectangleIn *in)
	Function to find the vertices of a rectangle given its centre, half side-lengths and orientation angle. More...
void	LALHexagonVertices (LALStatus *status, HexagonOut *out, RectangleIn *in)
void	LALInspiralCreatePNCoarseBankHexa (LALStatus *status, InspiralTemplateList **list, INT4 *nlist, InspiralCoarseBankIn coarseIn)
void	LALInspiralCreatePNCoarseBankHybridHexa (LALStatus *status, InspiralTemplateList **list, INT4 *nlist, InspiralCoarseBankIn coarseIn)
void	LALInitHexagonalBank (LALStatus *status, InspiralCell **cell, INT4 id, InspiralMomentsEtc *moments, InspiralTemplate *paramsIn, HexaGridParam *gridParam, CellEvolution *cellEvolution, CellList **cellList)
void	LALPopulateCell (LALStatus *status, InspiralMomentsEtc *moments, InspiralCell **cell, INT4 l, InspiralTemplate *paramsIn, HexaGridParam *gridParam, CellEvolution *cellEvolution, CellList **cellList)
void	LALFindPosition (LALStatus *status, REAL4 dx0, REAL4 dx1, Position *position, InspiralTemplate *paramsIn, HexaGridParam *gridParam)
void	LALSPAValidPosition (LALStatus *status, InspiralCell **cell, INT4 id1, InspiralMomentsEtc *moments, CellEvolution *cellEvolution, CellList **list)
void	GetPositionRectangle (LALStatus *status, InspiralCell **cell, INT4 id, InspiralTemplate *params, HexaGridParam *gridParam, CellEvolution *cellEvolution, CellList **cellList, INT4 *valid)
void	LALListAppend (CellList **headRef, INT4 id)
void	LALListDelete (CellList **headRef, INT4 id)
UINT4	LALListLength (CellList *head)
void	LALSPAF (LALStatus *status, REAL4 *result, REAL4 x, void *t3)
INT4	XLALInspiralComputePTFIntrinsicMetric (InspiralMetric *metric, REAL8Vector *fullmetric, REAL8FrequencySeries *psd, InspiralTemplate *params)
INT4	XLALInspiralComputePTFWaveform (REAL8Vector *ptfwave, InspiralTemplate *params)
INT4	XLALInspiralComputePTFWDeriv (COMPLEX16Vector *Wderiv, REAL8FrequencySeries *psd, InspiralTemplate *params, INT4 paramid, REAL8 initdelta, REAL8 tolerance)

Data Structures
struct	InspiralMetric
	Structure to store metric at various points the signal manifold. More...
struct	InspiralTemplateList
	A grid of inspiral templates (ie a template list). More...
struct	HexaGridParam
	This is a structure needed in the inner workings of the LALInspiralHexagonalBank code. More...
struct	CellEvolution
	This is a structure needed in the inner workings of the LALInspiralHexagonalBank code. More...
struct	CellList
	This is a structure needed in the inner workings of the LALInspiralHexagonalBank code. More...
struct	InspiralCell
	This is a structure needed in the inner workings of the LALInspiralHexagonalBank code. More...
struct	InspiralBankParams
	This is a structure needed in the inner workings of the LALInspiralCreateCoarseBank code. More...
struct	InspiralCoarseBankIn
	Input for choosing a template bank. More...
struct	InspiralMomentsIn
	Inputs to the function that computes the moments of the PSD. More...
struct	InspiralFineBankIn
	Structure needed by the function LALInspiralCreateFineBank. More...
struct	InspiralMomentsEtc
	Parameter structure that holds the moments of the PSD and other useful constants required in the computation of the metric. More...
struct	InspiralMomentsEtcBCV
	UNDOCUMENTED. More...
struct	RectangleIn
	Input structure to function LALRectangleVertices() More...
struct	RectangleOut
	Output structure to function LALRectangleVertices(). More...
struct	HexagonOut
	UNDOCUMENTED. More...
struct	PRIN
	UNDOCUMENTED. More...

Enumerations
enum	ComputeMoments { disable , enable }
	UNDOCUMENTED. More...
enum	CoordinateSpace {   Tau0Tau2 , Tau0Tau3 , Psi0Psi3 , PTFIntrinsic ,   PTFFull }
	Choose templates either in the \((\tau_0,\tau_2)\) or \((\tau_0,\tau_3)\) space. More...
enum	GridSpacing {   SquareNotOriented , Square , HexagonalNotOriented , Hexagonal ,   HybridHexagonal , S2BCV }
	This enum is set by the user to specify the type of placement requested. More...
enum	Position {   In , Above , Below , Out ,   Edge }
	This enum can take the following values In, Out, Below, Edge, Above and is used only by the Hexagonal placement. More...
enum	InsidePolygonEnum { False , True }
	This enum is set to true or false, it is just a boolean variable for the purpose of BCV placement but can be used in an other context. More...
enum	Generation { Sterile , Fertile }
	This enum is either fertile,sterile, and is a boolean expression used only by the Hexagonal placement. More...
enum	InspiralBankMassRange { MinComponentMassMaxTotalMass , MinMaxComponentMass , MinMaxComponentTotalMass }
	An enum that appears in the InspiralCoarseBankIn structure which fixes the way templates are chosen: The choice MinComponentMassMaxTotalMass means the minimum of the component masses will be given by mMin and maximum total mass is given by MMax of the InspiralBankCoarseIn structure. More...
enum	FreqCut {   FreqCut_SchwarzISCO , FreqCut_BKLISCO , FreqCut_LightRing , FreqCut_ERD ,   FreqCut_FRD , FreqCut_LRD }
	An enum that lists all the formulas that can be used to specify an upper frequency cutoff. More...

Files
file	LALInspiralComputePTFMetric.c
	Module to compute the components of the metric which is used to describe distances on Physical Template Family signal manifold.
file	CoarseTest.c
	Test code for the inspiral modules.
file	CoarseTest2.c
	Test code for the bank modules.
file	GetOrientationEllipse.c
	Test code for the bank modules.
file	InspiralSpinBankTest.c
	Tests InpsiralSpinBank().

Error Codes
#define	LALINSPIRALBANKH_ENULL   1
	Null pointer. More...
#define	LALINSPIRALBANKH_EMEM   2
	Memory allocation failure. More...
#define	LALINSPIRALBANKH_ECHOICE   3
	Invalid choice for an input parameter. More...
#define	LALINSPIRALBANKH_EDIV0   4
	Division by zero. More...
#define	LALINSPIRALBANKH_ESIZE   8
	Invalid input range. More...
#define	LALINSPIRALBANKH_EFRANGE   16
	Limits outside range of frequency series. More...
#define	LALINSPIRALBANKH_EORDER   32
	Inappropriate PN order. More...
#define	LALINSPIRALBANKH_EGRIDSPACING   64
	Inappropriate grid spacing parameter [SquareNotOriented or Hexagonal]. More...
#define	LALINSPIRALBANKH_EHEXAINIT   128
	Empty bank. More...
#define	LALINSPIRALBANKH_EFCUT   5
	Inappropriate cutoff frequency [SchwarzISCO, BKLISCO, LightRing, ERD, FRD or LRD]. More...
#define	LALINSPIRALBANKH_EFHIGH   6
	Final frequency is less than the low frequency cutoff. More...
#define	LALINSPIRALBANKH_ENUMFCUT   7
	Number of fcut must be greater or equal to 1. More...

Function Documentation

LALInspiralSpinBank()

void LALInspiralSpinBank	(	LALStatus *	status,
		SnglInspiralTable **	tiles,
		INT4 *	ntiles,
		InspiralCoarseBankIn *	coarseIn
	)

This function creates a bank of BCVSpin templates to search for precessing binaries.

Author

Hanna, C. R. and Owen, B. J.

Algorithm

The code checks coarseIn->mMin to determine whether the limits on the target region are in terms of masses or phenomenological parameters. A positive value indicates that mass limits are being used.

If mass limits are used, the target region of parameter space is a distorted box in the coordinates \((x=\psi_0, y=\psi_3, z=\beta)\). The metric at high values of \(\beta\) is constant. It is convenient to rotate to coordinates \((x',y',z')\) which lie along eigenvectors of the metric.

The algorithm first draws a rectilinear box in the primed coordinates which includes the target region, then steps through along the directions of the primed coordinates. At each point it tests if the point lies within the target region. If the point is inside the target region, the algorithm adds a template to the linked list. If not, it continues through the box containing the target region.

The tiling is done with a body-centered cubic lattice. People usually solve the non-overlapping bcc problem rather than the overlapping one here, so it's worth mentioning how we do it. I don't have time to stick in the 3D figures you need to show it properly, but you can figure out the spacing by finding the smallest sphere that contains the Wigner-Seitz cell. When you do that you find that the lattice constant (spacing between templates in the plane, in proper distance) is \((4/3)\sqrt{2\mu}\). So the coordinate spacing is that divided by the square root of the corresponding eigenvalue of the metric. (The vertical spacing in the bcc lattice is multiplied by a further 1/2.)

If \((\psi_0, \psi_3, \beta)\) limits are used, the tiling is done in the given box with a bcc lattice.

Notes

Currently we use a static function for the metric based on an approximation that is good only for large \(\beta\). We should update it and put it out in the LAL namespace.

The metric relies on approximations that make it valid only for a binary system with a total mass \(<15M\odot\) where the larger body's minimum mass is at least twice the smaller body's maximum mass. If the parameter range is specified with physical parameters rather than the phenomenological parameters \((\psi_0, \psi_3, \beta)\) then using mass values that violate these conditions will result in an error message.

Definition at line 273 of file InspiralSpinBank.c.

LALInsidePolygon()

void LALInsidePolygon	(	LALStatus *	status,
		REAL4 *	inputx,
		REAL4 *	inputy,
		INT4	n,
		REAL4	x,
		REAL4	y,
		INT4 *	valid
	)

Module to check whether a point with coordinates (x,y) is inside a polygon defined by the vectors (vx, vy), which size (n) must be provided.

The functions returns 1 if the point is inside or 0 otherwise.

Author

Cokelaer. T

Notes

Tested in matlab codes and some BCV tests within lal/lalapps.

Parameters

	status	LAL status pointer
[in]	inputx	two arrays of floats defining the polygon
[in]	inputy	two arrays of floats defining the polygon
[in]	n	the size of the vectors
[in]	x	the coordinate of the point
[in]	y	the coordinate of the point
[out]	valid	0 if outside and 1 if inside

Definition at line 35 of file LALInsidePolygon.c.

LALInspiralCreateCoarseBank()

void LALInspiralCreateCoarseBank	(	LALStatus *	status,
		InspiralTemplateList **	list,
		INT4 *	nlist,
		InspiralCoarseBankIn	coarseIn
	)

See also

See Module LALInspiralCreateCoarseBank.c for documentation

Parameters

	status	LAL-status pointer
[out]	list	an array containing the template bank parameters
[out]	nlist	the number of templates found by the function
[in]	coarseIn	specifies the search space, range of masses, etc

Definition at line 180 of file LALInspiralCreateCoarseBank.c.

LALInspiralCreatePNCoarseBank()

void LALInspiralCreatePNCoarseBank	(	LALStatus *	status,
		InspiralTemplateList **	list,
		INT4 *	nlist,
		InspiralCoarseBankIn	coarseIn
	)

See also

See Module LALInspiralCreateCoarseBank.c for documentation

Definition at line 407 of file LALInspiralCreateCoarseBank.c.

LALInspiralCreateBCVBank()

void LALInspiralCreateBCVBank	(	LALStatus *	status,
		InspiralTemplateList **	list,
		INT4 *	nlist,
		InspiralCoarseBankIn	coarseIn
	)

Lay a flat grid of BCV templates in the user specified range of the parameters \((\psi_0, \psi_3)\) in coarseIn structure.

Author

Cokelaer, T

Description

Given the range of the parameters \((\psi_0, \psi_3),\) the number of templates in the fCut direction, minimalMatch, noise spectral density, upper and lower frequency cutoffs (all in the input structure coarseIn) this routine outputs the list of templates in the BCV bank for the parameters \((\psi_0, \psi_3, f_{\mathrm{cut}}).\)

Algorithm

A flat signal manifold is assumed and templates are laid uniform in the three dimensions. See below for an explanation of how templates are chosen in the fcut direction.

Parameters

	status	LAL status pointer
[out]	list	an array containing the template bank parameters.
[out]	nlist	the number of templates in bank
	coarseIn	UNDOCUMENTED

Definition at line 61 of file LALInspiralBCVBank.c.

LALInspiralCreateFlatBankS3S4()

void LALInspiralCreateFlatBankS3S4	(	LALStatus *	status,
		REAL4VectorSequence *	list,
		InspiralBankParams *	bankParams,
		InspiralCoarseBankIn	coarseIn
	)

UNDOCUMENTED.

Definition at line 743 of file LALInspiralBCVBank.c.

LALExcludeTemplate()

void LALExcludeTemplate	(	LALStatus *	status,
		INT4 *	valid,
		InspiralBankParams *	bankParams,
		REAL4	x,
		REAL4	y
	)

LALInspiralBCVBankFcutS3S4()

void LALInspiralBCVBankFcutS3S4	(	LALStatus *	status,
		InspiralTemplateList **	list,
		INT4 *	NList,
		InspiralCoarseBankIn	coarseIn
	)

UNDOCUMENTED.

Definition at line 541 of file LALInspiralBCVBank.c.

LALInspiralBCVFcutBank()

void LALInspiralBCVFcutBank	(	LALStatus *	status,
		InspiralTemplateList **	list,
		INT4 *	NList,
		InspiralCoarseBankIn	coarseIn
	)

Given a grid of templates with distinct values of \((\psi_0, \psi_3)\) this routine returns a new grid in which every template has numFcutTemplates partners differing from one another in the ending frequency fendBCV.

A call to this function should be preceeded by a call to LALInspiralCreateFlatBank() or a similar function, that gives a grid in \((\psi_0, \psi_3)\) space.

Description

A lattice of templates for BCV models should include, in addition to the values of \((\psi_0, \psi_3)\) a range of \(f_{\mathrm{cut}}\) – the cutoff frequency. The right approach would be to compute the metric in the three-dimensional space of \((\psi_0, \psi_3, f_{\mathrm{cut}})\) and to choose templates as dictated by the metric. However, analytic computation of the metric has not been easy. Therefore, it has become necessary (at least for the time being) to make alternate choice of the cutoff frequencies.

In this routine we implement a simple choice based on physical grounds: The post-Newtonian models predict an ending frequency that is larger than, but close to, the Schwarzschild last-stable orbit frequency \(f_{\mathrm{lso}} = (6^{3/2} \pi M )^{-1}\) where \(M\) is the total mass, while the effective one-body model has an ending frequency close to the light-ring, whose Schwarzschild value is \(f_{\mathrm{lr}} = (3^{3/2} \pi M )^{-1}\). It is necessary to know the total mass of the system in both cases. However, not all pairs of \((\psi_0, \psi_3)\) can be inverted to get a positive \(M\) but only when \(\psi_0 > 0\) and \(\psi_3 < 0\). Even then it is not guaranteed that the symmetric mass ratio will be less than \(1/4,\) a necessary condition so that the component masses are found to be real. However, we do not demand that the symmetric mass ratio is less than a quarter. If the total mass is non-negative then we compute the \((f_{\mathrm{lso}}, f_{\mathrm{lr}})\) and choose a user specified numFcutTemplates number of templates with their cutoff frequency list->fFinal defined uniformly spaced in the range \([f_{\mathrm{lso}},\ f_{\mathrm{lr}}]\).

Furthermore, this routine discards all templates for which either the mass is not defined or, when defined, list->fFinal is smaller than the user defined lower frequency cutoff or larger than the Nyquist frequency of templates. Thus, the number of templates returned by this routine could be larger or fewer than the input number of templates.

Algorithm

Given \((\psi_0, \psi_3)\) one can solve for \((M, \eta)\) using:

\begin{equation} M = \frac{-\psi_3}{16 \pi^2 \psi_0},\ \ \eta = \frac{3}{128 \psi_0 (\pi M)^{5/3}}. \end{equation}

Given the total mass compute the last stable orbit and light-ring frequencies using

\begin{equation} f_{\mathrm{lso}} = (6^{3/2} \pi M)^{-1},\ \ f_{\mathrm{lr}} = (3^{3/2} \pi M)^{-1}. \end{equation}

Divide the range \((f_{\mathrm{lso}}, f_{\mathrm{lr}})\) so as to have \(n_{\mathrm{cut}}= \mathtt{numFcutTemplates}\) templates over this range:

\begin{equation} df = f_{\mathrm{lr}} \frac {\left( 1 - 2^{-3/2} \right) }{ (n_{\mathrm{cut}} -1) }. \end{equation}

Next, choose templates at \(f_k = f_\mathrm{lr} - k \times df,\) where \(k=0, \ldots, n_\mathrm{cut}-1\). Note that by definition \(f_0 = f_\mathrm{lr}\) and \(f_{n_\mathrm{cut}-1} = f_\mathrm{lso}\); there are exatly \(n_\mathrm{cut}\) templates in the range \((f_\mathrm{lso}, f_\mathrm{lr})\). We discard a template if either \(M\) is not defined or if \(f_\mathrm{cut}\) is smaller than the lower frequency cutoff specified in list[j]->fLower.

Parameters

	status	LAL status pointer
[in,out]	list	an array initially containing the template bank with the values of list[j]->psi0, list[j]->psi3, list[j]->fLower, specified, is replaced on return with a re-sized array specifying also list->fFinal.
[in,out]	NList	the number of templates in the Input bank is replaced by the number of templates in the output bank.
	coarseIn	UNDOCUMENTED

Definition at line 389 of file LALInspiralBCVBank.c.

LALEmpiricalPSItoMassesConversion()

void LALEmpiricalPSItoMassesConversion	(	LALStatus *	status,
		InspiralTemplate *	params,
		UINT4 *	valid,
		REAL4	lightring
	)

UNDOCUMENTED.

Definition at line 706 of file LALInspiralBCVBank.c.

LALPSItoMasses()

void LALPSItoMasses	(	LALStatus *	status,
		InspiralTemplate *	params,
		UINT4 *	valid,
		REAL4	thisfreq
	)

UNDOCUMENTED.

Definition at line 489 of file LALInspiralBCVBank.c.

LALInspiralBCVRegularFcutBank()

void LALInspiralBCVRegularFcutBank	(	LALStatus *	status,
		InspiralTemplateList **	list,
		INT4 *	NList,
		InspiralCoarseBankIn	coarseIn
	)

UNDOCUMENTED.

Definition at line 648 of file LALInspiralBCVBank.c.

LALNudgeTemplatesToConstantTotalMassLine()

void LALNudgeTemplatesToConstantTotalMassLine	(	LALStatus *	status,
		InspiralTemplateList **	list,
		INT4	nlist,
		InspiralCoarseBankIn	coarseIn
	)

Anand: 26 October 2006 This function nudges the templates in the list to the (max-total-mass = constant) line.

This is done only for those templates whose total mass exceeds the desired max-total-mass value. The templates are nudged along the metric eigen direction until they lie on the said line.

Definition at line 298 of file LALInspiralCreateCoarseBank.c.

XLALInspiralTau3FromTau0AndEqualMassLine()

REAL4 XLALInspiralTau3FromTau0AndEqualMassLine	(	REAL4	tau0,
		REAL4	fL
	)

See also

See Module LALInspiralBankUtils.c for documentation

Definition at line 94 of file LALInspiralBankUtils.c.

XLALInspiralTau3FromNonEqualMass()

REAL4 XLALInspiralTau3FromNonEqualMass	(	REAL4	M,
		REAL4	eta,
		REAL4	fL
	)

See also

See Module LALInspiralBankUtils.c for documentation

Definition at line 113 of file LALInspiralBankUtils.c.

XLALInspiralTau0FromMEta()

REAL4 XLALInspiralTau0FromMEta	(	REAL4	M,
		REAL4	eta,
		REAL4	fL
	)

See also

See Module LALInspiralBankUtils.c for documentation

Definition at line 130 of file LALInspiralBankUtils.c.

XLALInspiralBissectionLine()

REAL8 XLALInspiralBissectionLine	(	REAL8	tau0,
		REAL8	fL,
		REAL8	mMin,
		REAL8	mMax
	)

See also

See Module LALInspiralHybridHexagonalBank.c for documentation

Definition at line 507 of file LALInspiralHybridHexagonalBank.c.

XLALInspiralMFromTau0AndNonEqualMass()

REAL8 XLALInspiralMFromTau0AndNonEqualMass	(	REAL8	tau0,
		REAL8	extremMass,
		REAL8	fL
	)

See also

See Module LALInspiralBankUtils.c for documentation

Definition at line 150 of file LALInspiralBankUtils.c.

LALInspiralBankGeneration()

void LALInspiralBankGeneration	(	LALStatus *	status,
		InspiralCoarseBankIn *	in,
		SnglInspiralTable **	out,
		INT4 *	count
	)

Definition at line 29 of file InspiralBankGeneration.c.

LALInspiralCreateFlatBank()

void LALInspiralCreateFlatBank	(	LALStatus *	status,
		REAL4VectorSequence *	list,
		InspiralBankParams *	bankParams
	)

The code expects list->vectorLength=2 and allocates just the requisite amount of memory to list and returns the number of grid points in list->length.

The data points list->data[2j], j=1,2, ... list->length, contain the \(x_0\)-coordinates of the grid and data points list->data[2j+1], contain the \(x_1\)-coordinates of the grid.

Description

Given the metric and the minimalMatch this routine calls bank/LALInspiralUpdateParams to get the spacings in user coordinates (which are not necessarily the eigen-directions) and lays a uniform grid of templates in the range specified in (bankParams->x0Min, bankParams->x0Max) and (bankParams->x1Min, bankParams->x1Max).

Algorithm

The algorithm to lay templates is as follows: Given the increments \(Dx_0\) and \(Dx_1\) found from calling bank/LALInspiralUpdateParams lay a rectangular grid in the space of \((x_0, x_1).\)

• \(x_1 = x_1^{\mathrm{min}}\)
• do while ( \(x_1 \le x_1^{\mathrm{max}}\))
  
  • \(x_0 = x_0^{\mathrm{min}}\)
  • do while ( \(x_0 \le x_0^{\mathrm{max}}\))
    
    • Add ( \(x_0, x_1\)) to list
    • numTemplates++
    • Increment \(x_0: \; x_0 = x_0 + Dx_0\)
  • Increment \(x_1: \; x_1 = x_1 + Dx_1\)

Parameters

	status	LAL status pointer
[out]	list	an array containing the template bank parameters
[in]	bankParams	It is necessary and sufficient to input the eigenvalues of the metric and the angle between the \(x_0\) axis and the semi-major axis of the ambiguity ellipse, that is, bankParams.metric.g00, bankParams.metric.g11, bankParams.metric.theta, the minimal match, bankParams.minimalMatch and the range of the two coordinates over which templates must be chosen: (bankParams->x0Min, bankParams->x0Max) and (bankParams->x1Min, bankParams->x1Max)

Definition at line 266 of file LALInspiralBCVBank.c.

LALInspiralCreateFineBank()

void LALInspiralCreateFineBank	(	LALStatus *	status,
		InspiralTemplateList **	outlist,
		INT4 *	nlist,
		InspiralFineBankIn	fineIn
	)

Function to create a fine grid of templates.

Author

Sathyaprakash, B.S. and Churches, D. K.

The fine grid algorithm is a very simple algorithm that computes a uniform grid of templates around a given coordinate point – which can in particular be a coarse grid point – from a knowledge of the metric at the coordinate point and the coarse and fine grid minimal matches, \(D\tau_{0,3}\) and \(d\tau_{0,3},\) respectively. Since \(D\tau\) is not necessarily an integral multiple of \(d\tau\) the rectangular fine grid about the point in question will be larger than required. The algorithm chooses templates symmetrically about the given coarse grid point. It does so by laying a rectangular lattice of templates with spacings \(d\tau_0\) and \(d\tau_3,\) in the rectangular region defined by \((\tau_0 - \Delta \tau_0, \tau_3 - \Delta \tau_3),\) \((\tau_0 + \Delta \tau_0, \tau_3 - \Delta \tau_3),\) \((\tau_0 + \Delta \tau_0, \tau_3 + \Delta \tau_3)\) and \((\tau_0 - \Delta \tau_0, \tau_3 + \Delta \tau_3),\) where

\[\Delta\tau_0 = d\tau_0 \left [ \frac{D\tau_0}{2d\tau_0} \right ], \]

and for any \(x\), \([x]\) denotes the smallest integer greater than or equal to \(x\).

Algorithm sketching the construction of a rectangular fine grid around a given coordinate point

The algorithm takes as input a structure of type InspiralFineBankIn and returns a pointer-to-a-pointer of type InspiralTemplateList as well as the number of fine grid templates int around the lattice point in question.

The spacing between fine grid templates is chosen to be a constant determined by the metric at the coarse grid point; for example,

\[d\tau_0 = \sqrt{\frac{2 (1 - MM_\textrm{Fine})}{g_{00}} }.\]

Only those grid points that are within the parameter space boundary, or have the vertices of the ambiguity rectangle inside the parameter space, are kept and others are discarded.

Algorithm

The Fine grid algorithm works as follows:

• From input structure extract coordinates of the grid point \((\tau_0^G, \tau_3^G).\)
• Compute coarse and fine grid spacings \((D\tau_0, D\tau_3)\) and \((d\tau_0, d\tau_3)\)
• Compute half-sides of the smallest symmetric rectangle about \((\tau_0, \tau_3)\):
  • \(\Delta\tau_0 = d\tau_0 \,\mathrm{ceil}[D\tau_0/(2d\tau_0)],\) \(\Delta\tau_3 = d\tau_3 \,\mathrm{ceil}[D\tau_3/(2d\tau_3)],\)
• Begin at \(\tau_3 = \tau_3^G - \Delta \tau_3,\)
• do while ( \(\tau_3 <= \tau_3^G+\Delta \tau_3\))
  {
  
  • Begin at \(\tau_0 = \tau_0^G - \Delta \tau_0,\)
  • do while ( \(\tau_0 <= \tau_0^G+\Delta \tau_0\))
    {
    
    • if ( \((\tau_0, \tau_3)\) is inside the parameter space)
      {
      
      • Add ( \(\tau_0, \tau_3\)) to InspiralTemplateList
      • numTemplates++
      }
      
    • Increment \(\tau_0:\) \(\tau_0 = \tau_0 + d\tau_0\)
    }
    
  • Increment \(\tau_3:\) \(\tau_3 = \tau_3 + d\tau_3\)
  }

Parameters

	status	LAL status pointer
[out]	outlist	containing an array of template bank parameters
[out]	nlist	the number of fine bank templates around a given coarse-mesh point
[in]	fineIn	the parameters required to find the fine bank

Definition at line 98 of file LALInspiralCreateFineBank.c.

LALInspiralComputeMetric()

void LALInspiralComputeMetric	(	LALStatus *	status,
		InspiralMetric *	metric,
		InspiralTemplate *	params,
		InspiralMomentsEtc *	moments
	)

Deprecated:

Use XLALInspiralComputeMetric() instead.

Parameters

	status	LAL status pointer
[out]	metric	the metric at the lattice point defined by params
[in]	params	the parameters where metric must be computed
[in]	moments	moments \(J(1), \ldots, J(17),\) of the PSD and other constants needed in the computation of the metric

Definition at line 63 of file LALInspiralComputeMetric.c.

XLALInspiralComputeMetric()

int XLALInspiralComputeMetric	(	InspiralMetric *	metric,
		InspiralMomentsEtc *	moments,
		REAL8	fLower,
		LALPNOrder	order,
		REAL8	t0,
		REAL8	t3
	)

Function to compute the components of the metric which is used to describe distances on the signal manifold.

Author

Churches, D. K., Cokelaer, T., Sathyaprakash, B. S.

We calculate the components of the metric using the procedure outlined in Owen [20] . This uses the moments of the noise curve,

\begin{equation} I(q) \equiv S_{h}(f_{0}) \int^{f_{c}/f_{0}}_{f_{s}/f_{0}} \frac{x^{-q/3}}{S_{h}(x)} \, dx \end{equation}

and

\begin{equation} J(q) \equiv \frac{I(q)}{I(7)} \,. \end{equation}

(Please note that the function LALInspiralMoments doesn't compute \(I(q)\) defined here; the index \(q\) is definted differently there and the normalisation is supplied by the user. For ease of writing, here we shall follow the standard notation.) Then the moment functional \(\mathcal{J}\) is defined such that, for a function \(a\),

\begin{equation} \mathcal{J} [a] \equiv \frac{1}{I(7)} \int^{f_{c}/f_{0}}_{f_{s}/f_{0}} \frac{x^{-7/3}}{S_{h}(x)} a(x) \, dx \end{equation}

which gives us

\begin{equation} \mathcal{J} = \left[ \sum_{n} a_{n} x^{n} \right] = \sum_{n} a_{n} J(7-3n). \end{equation}

The above equation is used to calculate the components of the metric using the following formula:

\begin{equation} \gamma_{\alpha \beta} = \frac{1}{2} \left( \mathcal{J} [ \psi_{\alpha} \psi_{\beta} ] - \mathcal{J} [ \psi_{\alpha} ] \mathcal{J} [ \psi_{\beta} ] \right) \end{equation}

where \(\psi_\alpha\) is the derivative of the Fourier phase of the inspiral waveform with respect to the parameter \(\lambda^\alpha,\) that is \(\psi_\alpha \equiv \Psi_{,\alpha}.\) Writing the derivative index as \(\alpha=0,j,\) with \(j=1,\ldots,n\) we have

\begin{equation} \psi_{0} \equiv 2 \pi f, \ \ \ \psi_{j} \equiv \frac{\partial \Delta \Psi}{\partial \Delta \lambda^{j}}. \end{equation}

The phase \(\Psi\) is that which appears in the usual stationary-phase formula for the Fourier transform:

\begin{equation} \tilde{h}(f) \propto f^{-7/6} e^{i[-\pi/4 - \Phi_{0} + 2 \pi f t_{0} + \Psi(f;\vec{\lambda}]}. \end{equation}

If we take the usual chirp times and multiply each by \((\pi f_{0})\) then we get dimensionless chirp times \(\tau_{k}\), and then the phase \(\Psi\) may be written in the form

\begin{equation} \Psi = 2 \pi f t_{c} + \sum_{k} \Psi_{k}(f) \tau_{k} \end{equation}

where, defining \(v_0 = (\pi m f_0)^{1/3}\) ( \(m\) being total mass and \(f_0\) a fiducial starting frequency), the chirptimes \(\tau_{k},\) up to 2nd PN order, are given by

\[ \tau_{0} = \frac{5}{256 \eta v_{0}^{5}},\ \ \tau_{2} = \frac{5}{192 \eta v_{0}^{3}} \left( \frac{743}{336} + \frac{11}{4} \eta \right), \]

\begin{equation} \tau_{3} = \frac{\pi}{8 \eta v_{0}^{2}},\ \ \tau_{4} = \frac{5}{128 \eta v_{0}} \left( \frac{3\,058\,673}{1\,016\,064} + \frac{5429}{1008} \eta + \frac{617}{144} \eta^{2} \right). \end{equation}

Up to second post-Newtonian approximation the \(\Psi_{k}\) are given by

\begin{equation} \Psi_{0} = \frac{6}{5 \nu^{5/3}},\ \ \Psi_{2} = \frac{2}{\nu},\ \ \Psi_{3} = - \frac{3}{\nu^{2/3}},\ \ \Psi_{4} = \frac{6}{\nu^{1/3}}. \end{equation}

where \(\nu = f/f_{0}\).

If we now make the substitution \(f = v^{3}/\pi m\) we then the find that the phase may be expressed in a simpler form

\begin{equation} \Psi(v) = 2 \pi f t_{c} + \sum_{k} \theta_{k} v^{k-5} \end{equation}

where the chirp parameters \(\theta_{k}\) are given by

\[ \theta_{0} = \frac{3}{128 \eta}, \ \ \theta_{2} = \frac{5}{96 \eta} \left( \frac{743}{336} + \frac{11}{4} \eta \right), \]

\begin{equation} \theta_{3} = - \frac{3 \pi}{8 \eta},\ \ \theta_{4} = \frac{15}{64 \eta} \left( \frac{3\,058\,673}{1\,016\,064} + \frac{5429}{1008} \eta + \frac{617}{144} \eta^{2} \right). \end{equation}

If we want to express \(\Psi\) in terms of \(f\) rather than \(v\) we simply substitute \(v = (\pi m f)^{1/3}\) to obtain

\begin{equation} \label{phaselabel} \Psi(f) = 2 \pi f t_{c} + \sum_{k} \theta^{\prime}_{k} f^{(k-5)/3} \end{equation}

where

\begin{equation} \theta^{\prime}_{k} = (\pi m)^{(k-5)/3} \theta_{k}. \end{equation}

We are now in a position to start calculating components of \(\gamma_{\alpha \beta}\). We had

\begin{equation} \psi_{j} \equiv \frac{\partial \Delta \Psi}{\partial \Delta \lambda^{j}} \end{equation}

where \(\Psi\) is given by Eq. \eqref{phaselabel}. Therefore we may write

\begin{equation} \Delta \Psi = \Delta \theta^{\prime}_{0} f^{-5/3} + \Delta \theta^{\prime}_{2} f^{-1} + \Delta \theta^{\prime}_{3} f^{-2/3} + \Delta \theta^{\prime}_{4} f^{-1/3} \end{equation}

All we need to do now is specify the coordinates \(\lambda^{j}\) with respect to which the derivatives will be taken. In general, the template placement algorithm works in \((\tau_{0},\tau_{3})\) coordinates. It is simplest for us to calculate the components of \(\gamma_{\alpha \beta}\) in the \((m,\eta)\) coordinate system and then perform a coordinate transformation to get the components in the \((\tau_{0},\tau_{3})\) system. So, we first of all calculate the components of \(\gamma_{\alpha \beta}\) in the \((m,\eta)\) system.

This involves calculating the following:

\begin{equation} \frac{\partial \Delta \Psi}{\partial \Delta m} = \frac{\Delta \theta^{\prime}_{0}}{\Delta m} f^{-5/3} + \frac{\Delta \theta^{\prime}_{2}}{\Delta m} f^{-1} - \frac{\Delta \theta^{\prime}_{3}}{\Delta m} f^{-2/3} + \frac{\delta \theta^{\prime}_{4}}{\Delta m} f^{-1/3} \end{equation}

and

\begin{equation} \frac{\partial \Delta \Psi}{\partial \Delta \eta} = \frac{\Delta \theta^{\prime}_{0}}{\Delta \eta} f^{-5/3} + \frac{\Delta \theta^{\prime}_{2}}{\Delta \eta} f^{-1} - \frac{\Delta \theta^{\prime}_{3}}{\Delta \eta} f^{-2/3} + \frac{\delta \theta^{\prime}_{4}}{\Delta \eta} f^{-1/3} \end{equation}

where all of the derivatives are easily calculable. This gives us the terms \(\psi_{j}\) as a power series in \(f\). These are then used in the formula

\begin{equation} \gamma_{\alpha \beta} = \frac{1}{2} \left( \mathcal{J} [ \psi_{\alpha} \psi_{\beta} ] - \mathcal{J} [ \psi_{\alpha}] \mathcal{J} [\psi_{\beta}] \right) \end{equation}

to calculate the components of \(\gamma_{\alpha \beta}\). The fact that each of the \(\psi_{j}\) is in the form of a power series in \(f\) allows us to calculate \(\gamma_{\alpha \beta}\) using

\begin{equation} \mathcal{J} \left[ \sum_{n} a_{n} x^{n} \right] = \sum_{n} J(7-3n). \end{equation}

i.e. we can express all the \(\mathcal{J}[]\) in terms of the integral \(J(q)\) which we calculate numerically at the outset for the required values of \(q\).

Once we have obtained \(\gamma_{\alpha \beta}\) in this way, we take the inverse of this matrix to give us \(\gamma^{\alpha \beta}\) in the \((m,\eta)\) system. Then we perform the following coordinate transformation to give us the components of \(\gamma^{\alpha^{\prime} \beta^{\prime}}\) in our chosen system,

\begin{equation} \gamma^{\alpha^{\prime} \beta^{\prime}} = \Lambda^{\alpha^{\prime}}_{\,\,\sigma} \Lambda^{\beta^{\prime}}_{\,\,\delta} \gamma^{\sigma \delta} \end{equation}

where the transformation matrix \(\Lambda^{\alpha^{\prime}}_{\,\,\beta}\) is defined by

\begin{equation} \Lambda^{\alpha^{\prime}}_{\,\,\beta} = \frac{\partial x^{\alpha^{\prime}}}{\partial x^{\beta}} \end{equation}

Finally, we take the inverse of this matrix to obtain \(\gamma_{\alpha^{\prime} \beta^{\prime}}\) in the chosen system. Since the unprimed system corresponds to \((t_{c},m,\eta)\) coordinates and the primed system to \((t_{c},\tau_{0},\tau_{3})\) coordinates, the matrix \(\Lambda^{\alpha^{\prime}}_{\,\,\beta^{\prime}}\) has element

\begin{equation} \Lambda^{\alpha^{\prime}}_{\,\,\beta} = \left( \begin{array}{ccc} 1 & 0 & 0 \\ 0 & \frac{\partial \tau_{0}}{\partial m} & \frac{\partial \tau_{0}}{\partial \eta} \\ 0 & \frac{\partial \tau_{3}}{\partial m} & \frac{\partial \tau_{3}}{\partial \eta} \end{array} \right) = \left( \begin{array}{ccc} 1 & 0 & 0 \\ 0 & -\frac{5 \tau_{0}}{3m} & -\frac{\tau_{0}}{\eta} \\ 0 & -\frac{2 \tau_{3}}{3m} & -\frac{\tau_{3}}{\eta} \end{array} \right) \end{equation}

Finally, what is needed in laying a lattice in the space of dynamical parameters (also referred to as intrinsic parameters) is the metric with the kinematical parameter (also called extrinsic parameter) projected out: In other words one defines the 2-dimensional metric \(g_{mn}\) by

\begin{equation} g_{mn} = \gamma_{mn} - \frac{\gamma_{0m} \gamma_{0n}}{\gamma_{00}}. \end{equation}

Metric computation in the \f$\tau_0-\tau_3\f$ space

The metric cannot be directly computed in the \((\tau_0,\tau_2)\) space. Therefore, in the previous Section we first computed the metric in the \((m,\eta)\) space and then transformed to \((\tau_0,\tau_2)\) space. The same method can also be used to find the metric in the \((\tau_0,\tau_3)\) space. However, in \((\tau_0,\tau_3)\) space one can directly compute the metric without recourse to \((m,\eta)\) coordinates. It is of interest to see whether this yields the same results as the previous method.

The starting point of our derivation is Eq. (3.7) of Owen and Sathyaprakash (Phys. Rev. D 60, 022002, 1999) for the Fourier domain phase which we shall write as:

\begin{eqnarray} \Psi(f; \theta_1, \theta_2) & = & a_{01}\theta_1 v^{-5} + \left [a_{21} \frac {\theta_1}{\theta_2} + a_{22} \left ( \theta_1 \theta_2^2 \right )^{1/3} \right ] v^{-3} + a_{31} \theta_2 v^{-2} \\ & + & \left [a_{41} \frac {\theta_1}{\theta_2^2} + a_{42} \left ( \frac {\theta_1}{\theta_2} \right )^{1/3} + a_{43} \left ( \frac{\theta_2^4}{\theta_1} \right )^{1/3} \right ] v^{-1}, \end{eqnarray}

to 2nd post-Newtonain order. Here \(v=(f/f_0)^{1/3},\) \(\theta_1\) and \(\theta_2\) are identical to the \(\theta^1\) and \(\theta^2\) parameters of Owen and Sathyaprakash defined in Eq. (3.3) there and the \(a\) coefficients are given by:

\begin{eqnarray} a_{01} = \frac{3}{5}, \ \ a_{21} = \frac{11\pi}{12}, \ \ a_{22} = \frac{743}{2016} \left ( \frac {25}{2\pi^2} \right )^{1/3}, \ \ a_{31} = -\frac{3}{2}, \\ a_{41} = \frac {617}{384} \pi^2, \ \ a_{42} = \frac{5429}{5376} \left ( \frac{25 \pi}{2} \right )^{1/3},\ \ a_{43} = \frac {15293365}{10838016} \left ( \frac{5}{4\pi^4} \right )^{1/3}. \end{eqnarray}

Differentials of the phase with respect to the coordinates \(\theta_1\) and \(\theta_2\) appear in the metric which we write as:

\begin{equation} \psi_m \equiv \frac{\partial \Psi}{\partial \theta_m} = \sum_0^N \Psi_{mk} v^{k-5}. \end{equation}

where \(N\) is the post-Newtonian order up to which the phase is known, or the post-Newtonian order at which the metric is desired. Expansion coefficients \(\Psi_{mn}\) can be considered be \((2\times N)\) matrix which to second post-Newtonian order is given by:

\begin{equation} \Psi = \left [ \begin{matrix} a_{01} & 0 & {a_{21}}/{\theta_2} + ({a_{22}}/{3}) \left ( {\theta_2}/{\theta_1} \right )^{2/3} & 0 & {a_{41}}/{\theta_2^2} + {a_{42}}/\left ({3 \left ( \theta_1^2\theta_2 \right )^{1/3} } \right ) - ({a_{43}}/{3}) \left ( {\theta_2}/{\theta_1} \right )^{4/3} \cr 0 & 0 & - {a_{21}\theta_1}/{\theta_2^2} + (2 {a_{22}}/{3}) \left ( {\theta_1}/{\theta_2} \right )^{1/3} & a_{31} & - {2a_{41} \theta_1}/{\theta_2^3} - ({a_{42}}/{3}) \left ( {\theta_1}/{\theta_2^4} \right )^{1/3} + ({4a_{43}}/{3}) \left ( {\theta_2}/{\theta_1} \right )^{1/3} \end{matrix} \right ]. \end{equation}

Using the definition of the metric introduced earlier and projecting out the \(t_c\) coordinate, one finds that

\begin{eqnarray} g_{mn} & = & \frac{1}{2}\sum_{k,l=0}^N \Psi_{mk} \Psi_{nl} \biggl [ J(17-k-l) - J(12-k) J(12-l) \biggr . \\ & - & \biggl . \frac { \left ( J(9-k) - J(4)J(12-k) \right ) \left ( J(9-l) - J(4)J(12-l) \right )} {\left (J(1) - J(4)^2 \right)} \biggr ] \end{eqnarray}

where \(J\)'s are the moments introduced earlier.

Definition at line 349 of file LALInspiralComputeMetric.c.

LALInspiralComputeMetricBCV()

void LALInspiralComputeMetricBCV	(	LALStatus *	status,
		InspiralMetric *	metric,
		REAL8FrequencySeries *	psd,
		InspiralTemplate *	params
	)

UNDOCUMENTED.

See also

See LALInspiralComputeMetric() for documentation

Definition at line 529 of file LALInspiralComputeMetric.c.

LALInspiralLongestTemplateInBank()

void LALInspiralLongestTemplateInBank	(	LALStatus *	status,
		UINT4 *	templateLength,
		InspiralCoarseBankIn *	coarseIn
	)

Function to find the longest template in a template bank.

Author

Sathyaprakash, B.S.

Given the parameters of a template bank find the longest template in the bank. This is done by looking at the duration for which a signal corresponding to smallest masses lasts. One simply calls the LALInspiralWaveLength code for a system consisting of two stars each of mass mMin.

Definition at line 34 of file LALInspiralLongestTemplateInBank.c.

LALGetInspiralMoments()

void LALGetInspiralMoments	(	LALStatus *	status,
		InspiralMomentsEtc *	moments,
		REAL8FrequencySeries *	psd,
		InspiralTemplate *	params
	)

See also

See Module LALInspiralMoments.c for documentation

Definition at line 66 of file LALInspiralMoments.c.

XLALGetInspiralMoments()

int XLALGetInspiralMoments	(	InspiralMomentsEtc *	moments,
		REAL8	fLower,
		REAL8	fCutoff,
		REAL8FrequencySeries *	psd
	)

Definition at line 86 of file LALInspiralMoments.c.

LALGetInspiralMomentsBCV()

void LALGetInspiralMomentsBCV	(	LALStatus *	status,
		InspiralMomentsEtcBCV *	moments,
		REAL8FrequencySeries *	psd,
		InspiralTemplate *	params
	)

See also

See Module LALInspiralMoments.c for documentation

Definition at line 155 of file LALInspiralMoments.c.

LALInspiralMoments()

void LALInspiralMoments	(	LALStatus *	status,
		REAL8 *	moment,
		InspiralMomentsIn	pars
	)

See also

See Module LALInspiralMoments.c for documentation

Parameters

	status	LAL status pointer
[out]	moment	the value of the moment
[in]	pars	input parameters

Definition at line 276 of file LALInspiralMoments.c.

XLALInspiralMoments()

REAL8 XLALInspiralMoments	(	REAL8	xmin,
		REAL8	xmax,
		REAL8	ndx,
		REAL8	norm,
		REAL8FrequencySeries *	shf
	)

Definition at line 294 of file LALInspiralMoments.c.

LALInspiralSetSearchLimits()

void LALInspiralSetSearchLimits	(	LALStatus *	status,
		InspiralBankParams *	bankParams,
		InspiralCoarseBankIn	coarseIn
	)

Function which calculates the minimum and maximum values of \(\tau_{0}\) and \(\tau_{3}\).

Author

Churches, D. K.

This Function calculates the minimum and maximum values of \(\tau_{0}\) and \(\tau_{3}\) as determined by the total mass of the binary \(m\) and the symmetric mass ratio \(\eta\). The function also calulates the coordinates of the first template in the bank. These coordinates are \(\tau_{0}=\tau_{0min}\), \(\tau_{3}=\tau_{3min}\).

Description

We start with the definition of the chirp times \(\tau_{0}\) and \(\tau_{3}\),

\begin{equation} \tau_{0} = \frac{5}{256 (\pi f_{a} )^{8/3} m^{5/3} \eta} \end{equation}

and

\begin{equation} \tau_{3} = \frac{1}{8 (\pi^{2} f_{a}^{5} )^{1/3} m^{2/3} \eta} \end{equation}

\(\tau_{0}\) is minimised when \(\eta=1/4\) and \(\mathtt{m=MMax}\). \(\tau_{0}\) is maximised when \(\eta=1/4\) and \(\mathtt{m=2mMin}\). \(\tau_{3}\) is minimised when \(\eta=1/4\) and \(\mathtt{m=MMax}\). \(\tau_{3}\) is maximised when \(\eta=\mathtt{ mMin(MMax-mMin)/MMax^{2} }\).

Parameters

	status	LAL status pointer
[out]	bankParams	containing the boundary of search, current lattice point, etc.
[in]	coarseIn	specifies the parameters of the search space

Definition at line 54 of file LALInspiralSetSearchLimits.c.

LALInspiralNextTemplate()

void LALInspiralNextTemplate	(	LALStatus *	status,
		InspiralBankParams *	bankPars,
		InspiralMetric	metric
	)

Routine to compute the parameters of the template next to the current template, but in the positive \(\tau_{2(3)}\) axis.

Author

Sathyaprakash, B. S.

The coarse grid algorithm works by starting at one corner of the parameter space, incrementing along positive \(\tau_0\) direction, with increments determined by the local value of the metric, till the boundary of the parameter space is reached. It then gets back to the starting point and increments along positive \(\tau_{2(3)}\) direction, with an increment defined by the metric defined locally; it starts at the first point inside the parameter space but consistent with a square lattice. This routine is called each time a translation along the \(\tau_{2(3)}\) direction is required.

Parameters

	status	LAL status pointer
[out]	bankPars	the parameters of the bank at the next grid point; the point may, indeed, lay outside
[in]	metric	the value of the metric which would allow computation of the next lattice point (in the \(\tau_{2(3)}\) direction)

Definition at line 38 of file LALInspiralNextTemplate.c.

LALInspiralComputeParams()

void LALInspiralComputeParams	(	LALStatus *	status,
		InspiralTemplate *	pars,
		InspiralBankParams	bankParams,
		InspiralCoarseBankIn	coarseIn
	)

This function takes as input \(\tau_{0}\), \(\tau_{3}\) and \(f_a\) (the lower frequency of the detectors sensitivity), it then calculates \(m\) (the total mass of the binary), \(\eta\) (the symmetric mass ratio) and the individual mass of the compact objects.

Author

Churches, D. K.

We start with the definition of the chirp times \(\tau_{0}\) and \(\tau_{3}\),

\begin{equation} \tau_{0} = \frac{5}{256 (\pi f_{a} )^{8/3} m^{5/3} \eta} \end{equation}

and

\begin{equation} \tau_{3} = \frac{1}{8 (\pi^{2} f_{a}^{5} )^{1/3} m^{2/3} \eta} \end{equation}

These equations may be inverted to yield

\begin{equation} m = \frac{5}{32 \pi^{2} f_{a}} \frac{\tau_{3}}{\tau_{0}} \end{equation}

and

\begin{equation} \eta = \left( \frac{2 \pi^{2}}{25 f_{a}^{3}} \frac{\tau_{0}^{2}}{\tau_{3}^{5}} \right)^{1/3}\end{equation}

The individual masses may be calculated as follows. We have

\begin{equation} \label{mass1} m = m_{1} + m_{2} \end{equation}

and

\begin{equation} \label{eta1} \eta = \frac{m_{1} m_{2}}{(m_{1} + m_{2})^{2}} \end{equation}

From Eq. \eqref{mass1} we may eliminate either \(m_{1}\) or \(m_{2}\),

\begin{equation} m_{1} = m - m_{2} \end{equation}

This may be substituted into Eq. \eqref{eta1} to give

\begin{equation} \eta = \frac{(m - m_{2}) m_{2}}{\left[ (m - m{2}) + m_{2} \right]^{2}} \end{equation}

which may be re–arranged to give

\begin{equation} m_{2}^{2} - m m_{2} + \eta m^{2} = 0 \end{equation}

i.e. \

\begin{equation} m_{2} = \frac{ m \pm \sqrt{m^{2}(1 - 4 \eta) }}{2} \end{equation}

Therefore, since we know that \(\eta \leq 1/4\), real roots are guaranteed. If we had eliminated \(m_{2}\) rather than \(m_{1}\) then we would have arrived at an identical expression for \(m_{1}\), and so of one object has mass

\begin{equation} m_{1} = \frac{m + \sqrt{m^{2}(1-4 \eta)}}{2} \end{equation}

then the other object must have mass

\begin{equation} m_{2} = \frac{m - \sqrt{m^{2}(1-4 \eta)}}{2} \end{equation}

Parameters

	status	LAL status pointer
[out]	pars	inspiral wave parameter structure
[in]	bankParams	the parameters of the template bank
[in]	coarseIn	input parameters specifying the coarse bank

Definition at line 84 of file LALInspiralComputeParams.c.

LALInspiralValidParams()

void LALInspiralValidParams	(	LALStatus *	status,
		INT4 *	valid,
		InspiralBankParams	bankParams,
		InspiralCoarseBankIn	coarseIn
	)

Function which checks whether or not a pair of parameter values are consistent with the search space.

Author

Churches, D. K. and Sathyaprakash, B.S.

Module which checks whether or not a pair of parameter values \(\tau_{0}\) and \(\tau_{2(3)}\) correspond to a user specified range of component masses (mMin,mMax) OR to a minimum value of the component masses mMin and maximum total mass MMax. In the first case chirptimes satisfying the constraint mMin \(\le m_1, m_2 \le\)mMax are accepted as valid systems. In the second cases chirptimes satisfying the constraint mMin \(\le m_1, m_2,\) and MMax \(\le m=m_1+m_2\) are treated as valid.

Description

We start with the definition of the chirp times \(\tau_{0}\) and \(\tau_{3}\),

\begin{equation} \tau_{0} = \frac{5}{256 (\pi f_{a} )^{8/3} m^{5/3} \eta} \end{equation}

and

\begin{equation} \tau_{3} = \frac{1}{8 (\pi^{2} f_{a}^{5} )^{1/3} m^{2/3} \eta} \end{equation}

These equations may be inverted to yield

\begin{equation} m = \frac{5}{32 \pi^{2} f_{a}} \frac{\tau_{3}}{\tau_{0}} \end{equation}

and

\begin{equation} \eta = \left( \frac{2 \pi^{2}}{25 f_{a}^{3}} \frac{\tau_{0}^{2}}{\tau_{3}^{1/3}} \right)^{5}\end{equation}

The individual masses may be calculated as follows. We have

\begin{equation} \label{eq_mass} m = m_{1} + m_{2} \end{equation}

and

\begin{equation} \label{eq_eta} \eta = \frac{m_{1} m_{2}}{(m_{1} + m_{2})^{2}} \end{equation}

From Eq. \eqref{eq_mass} we may eliminate either \(m_{1}\) or \(m_{2}\),

\begin{equation} m_{1} = m - m_{2} \end{equation}

This may be substituted into Eq. \eqref{eq_eta} to give

\begin{equation} \eta = \frac{(m - m_{2}) m_{2}}{\left[ (m - m_{2}) + m_{2} \right]^{2}} = \frac{(m - m_{2}) m_{2}}{m^{2}} \end{equation}

which may be re–arranged to give

\begin{equation} m_{2}^{2} - m m_{2} + \eta m^{2} = 0, \end{equation}

i.e.

\begin{equation} m_{2} = \frac{ m \pm \sqrt{m^{2}(1 - 4 \eta) }}{2} \end{equation}

Therefore, since we know that \(\eta \leq 1/4\), real roots are guaranteed. If we had eliminated \(m_{2}\) rather than \(m_{1}\) then we would have arrived at an identical expression for \(m_{1}\), and so of one object has mass

\begin{equation} m_{1} = \frac{m + \sqrt{m^{2}(1-4 \eta)}}{2} \end{equation}

then the other object must have mass

\begin{equation} m_{2} = \frac{m - \sqrt{m^{2}(1-4 \eta)}}{2} \end{equation}

This function is also given mMin and MMax as inputs, which it may use to calculate the minimum value of \(\eta\) which is possible with those inputs,

\begin{equation} \eta_{min} = \mathtt{ \frac{mMin(MMax - mMin)}{MMax^{2}} } \end{equation}

To recap, the function calculates \(m\), \(\eta\), \(\eta_{min}\) and \(m_{1,2}\). It then checks that

\begin{equation} \eta_{min} \leq \eta \leq 1/4 \end{equation}

and that

\begin{equation} m_{1} \geq \mathtt{mMin} \end{equation}

and

\begin{equation} m_{2} \geq \mathtt{mMin} \end{equation}

Parameters

	status	LAL status pointer
[out]	valid	0 means invalid template, 1 means valid
[in]	bankParams	Input
[in]	coarseIn	Input

Definition at line 116 of file LALInspiralValidParams.c.

LALInspiralValidTemplate()

void LALInspiralValidTemplate	(	LALStatus *	status,
		INT4 *	valid,
		InspiralBankParams	bankParams,
		InspiralCoarseBankIn	coarseIn
	)

Function which checks whether or not a given template should be kept in the template list.

Author

Churches, D. K. and Sathyaprakash, B.S.

Description

Given the parameter values \(\tau_{0}\) and \(\tau_{2(3)}\) this code checks to see if they correspond to physical values of the masses of a binary and their symmetric mass ratio \(\eta.\) The parameter values will be accepted as valid parameters {even though} they may not lie within the search space but their span does, as described below. At the moment the code allows extra templates only in the positive- \(\tau_{2(3)}\) direction only. We have found that placing templates in other directions is redundant.

Algorithm

Consider the point \((\tau_0,\tau_{2(3)})\) describing the template, and also a point at \((\tau_0,\tau_{2(3)}\mbox{bankParams.dx1/2})\) , i.e.\ displaced in the negative \(\tau_{2(3)}\) direction. bankParams.dx1 is calculated from the metric and corresponds to the vertical spacing between the horizontal rows of templates being considered. Accept the template if at least one of those points is within the search space.

Parameters

	status	LAL status pointer
[out]	valid	0 means invalid template, 1 means valid
[in]	bankParams	Input
[in]	coarseIn	Input

Definition at line 50 of file LALInspiralValidTemplate.c.

LALInspiralUpdateParams()

void LALInspiralUpdateParams	(	LALStatus *	status,
		InspiralBankParams *	bankParams,
		InspiralMetric	metric,
		REAL8	minimalmatch
	)

Function to update the parameters used in creating a coarse bank based on a square lattice.

Author

Sathyaprakash, B. S., T. Cokelaer

While scanning the \(\tau_0\)-direction after reaching the boundary of the parameter space, we have to return to the starting point of the same line and use the metric there to increment one step upwards in the direction of \(\tau_{2(3)}.\) to a template list.

The \(dx_i\) returned by this function gives the spacing for a square lattice (e.g., \(dx_i\) as given in [20] .

Algorithm

Copy the parameters in the temporary parameter structure to the current parameter structure.

Parameters

	status	LAL status pointer
[out]	bankParams	refreshed to get the next location
[in]	metric	metric at the current location
[in]	minimalmatch	the minimal match

Definition at line 41 of file LALInspiralUpdateParams.c.

LALInspiralSetParams()

void LALInspiralSetParams	(	LALStatus *	status,
		InspiralTemplate *	tempPars,
		InspiralCoarseBankIn	coarseIn
	)

A routine that fills an InspiralTemplate structure based on the values in the InspiralCoarseBankIn structure.

Author

Churches, D. K and Sathyaprakash, B.S.

This function takes as an input a structure of type InspiralCoarseBankIn and it fills up the elements of a structure of type InspiralTemplate. The function sets the fields massChoice, ieta, signalAmplitude, tSampling, fLower, fCutoff, order, approximant, nStartPad, nEndPad.

Parameters

	status	LAL status pointer
[out]	tempPars	Output
[in]	coarseIn	Input

Definition at line 37 of file LALInspiralSetParams.c.

LALRectangleVertices()

void LALRectangleVertices	(	LALStatus *	status,
		RectangleOut *	out,
		RectangleIn *	in
	)

Function to find the vertices of a rectangle given its centre, half side-lengths and orientation angle.

Author

Sathyaprakash, B. S.

This code computes the vertices of a rectangle for plotting a grid of templates with xmgr, useful when looking at the minimal-match-rectangles around mesh points in a template bank.

Algorithm

Given the centre \((x_0,y_0)\) and half-sides \((dx,dy),\) the vertices of a rectangle in a diagonal coordinate system are given by

\begin{eqnarray} x_1 & = & x_0 - dx, \quad y_1 = y_0 - dy, \\ x_2 & = & x_0 + dx, \quad y_2 = y_0 - dy, \\ x_3 & = & x_0 + dx, \quad y_3 = y_0 + dy, \\ x_4 & = & x_0 - dx, \quad y_4 = y_0 + dy. \end{eqnarray}

The coordinates of a rectangle oriented at an angle \(\theta\) is found by using the formulas

\begin{eqnarray} x' = x \cos(\theta) - y \sin(\theta), \\ y' = y \cos(\theta) + x \sin(\theta). \end{eqnarray}

The function returns five coordinate points (1,2,3,4,1), and not just the four verticies, to help a plotting programme to complete the rectangle.

Parameters

status	LAL status pointer
out	Output
in	Input

Definition at line 53 of file LALRectangleVertices.c.

LALHexagonVertices()

void LALHexagonVertices	(	LALStatus *	status,
		HexagonOut *	out,
		RectangleIn *	in
	)

Definition at line 74 of file LALHexagonVertices.c.

LALInspiralCreatePNCoarseBankHexa()

void LALInspiralCreatePNCoarseBankHexa	(	LALStatus *	status,
		InspiralTemplateList **	list,
		INT4 *	nlist,
		InspiralCoarseBankIn	coarseIn
	)

Definition at line 58 of file LALInspiralHexagonalBank.c.

LALInspiralCreatePNCoarseBankHybridHexa()

void LALInspiralCreatePNCoarseBankHybridHexa	(	LALStatus *	status,
		InspiralTemplateList **	list,
		INT4 *	nlist,
		InspiralCoarseBankIn	coarseIn
	)

See also

See Module LALInspiralHybridHexagonalBank.c for documentation

Definition at line 110 of file LALInspiralHybridHexagonalBank.c.

LALInitHexagonalBank()

void LALInitHexagonalBank	(	LALStatus *	status,
		InspiralCell **	cell,
		INT4	id,
		InspiralMomentsEtc *	moments,
		InspiralTemplate *	paramsIn,
		HexaGridParam *	gridParam,
		CellEvolution *	cellEvolution,
		CellList **	cellList
	)

Definition at line 569 of file LALInspiralHexagonalBank.c.

LALPopulateCell()

void LALPopulateCell	(	LALStatus *	status,
		InspiralMomentsEtc *	moments,
		InspiralCell **	cell,
		INT4	l,
		InspiralTemplate *	paramsIn,
		HexaGridParam *	gridParam,
		CellEvolution *	cellEvolution,
		CellList **	cellList
	)

Definition at line 381 of file LALInspiralHexagonalBank.c.

LALFindPosition()

void LALFindPosition	(	LALStatus *	status,
		REAL4	dx0,
		REAL4	dx1,
		Position *	position,
		InspiralTemplate *	paramsIn,
		HexaGridParam *	gridParam
	)

Definition at line 935 of file LALInspiralHexagonalBank.c.

LALSPAValidPosition()

void LALSPAValidPosition	(	LALStatus *	status,
		InspiralCell **	cell,
		INT4	id1,
		InspiralMomentsEtc *	moments,
		CellEvolution *	cellEvolution,
		CellList **	list
	)

GetPositionRectangle()

void GetPositionRectangle	(	LALStatus *	status,
		InspiralCell **	cell,
		INT4	id,
		InspiralTemplate *	params,
		HexaGridParam *	gridParam,
		CellEvolution *	cellEvolution,
		CellList **	cellList,
		INT4 *	valid
	)

LALListAppend()

void LALListAppend	(	CellList **	headRef,
		INT4	id
	)

Definition at line 59 of file LALInspiralBankList.c.

LALListDelete()

void LALListDelete	(	CellList **	headRef,
		INT4	id
	)

Definition at line 94 of file LALInspiralBankList.c.

LALListLength()

UINT4 LALListLength

(

CellList *

head

)

Definition at line 47 of file LALInspiralBankList.c.

LALSPAF()

void LALSPAF	(	LALStatus *	status,
		REAL4 *	result,
		REAL4	x,
		void *	t3
	)

Definition at line 1084 of file LALInspiralHexagonalBank.c.

XLALInspiralComputePTFIntrinsicMetric()

INT4 XLALInspiralComputePTFIntrinsicMetric	(	InspiralMetric *	metric,
		REAL8Vector *	fullmetric,
		REAL8FrequencySeries *	psd,
		InspiralTemplate *	params
	)

Definition at line 103 of file LALInspiralComputePTFMetric.c.

XLALInspiralComputePTFWaveform()

INT4 XLALInspiralComputePTFWaveform	(	REAL8Vector *	ptfwave,
		InspiralTemplate *	params
	)

Definition at line 512 of file LALInspiralComputePTFMetric.c.

XLALInspiralComputePTFWDeriv()

INT4 XLALInspiralComputePTFWDeriv	(	COMPLEX16Vector *	Wderiv,
		REAL8FrequencySeries *	psd,
		InspiralTemplate *	params,
		INT4	paramid,
		REAL8	initdelta,
		REAL8	tolerance
	)

Definition at line 658 of file LALInspiralComputePTFMetric.c.

Enumeration Type Documentation

ComputeMoments

enum ComputeMoments

UNDOCUMENTED.

Enumerator
disable
enable

Definition at line 87 of file LALInspiralBank.h.

CoordinateSpace

enum CoordinateSpace

Choose templates either in the \((\tau_0,\tau_2)\) or \((\tau_0,\tau_3)\) space.

This is one of the members of the InspiralCoarseBankIn structure.

This enum allows users to choose template bank either in the \((\tau_0, \tau_2)\) space of chirptimes (the choice made by Tau0Tau2) or in the \((\tau_0, \tau_3)\) space of chirptimes (the choice made by Tau0Tau3). This was implemented in releases before May 25, 2002. On May 25 we migrated to a new, slightly faster, computation of the metric in which, at present, only the choice Tau0Tau3 can be made. Since October 2003 a new choice Psi0Psi3 was added to handle BCV templates. In November 2007 two new choices were addded: PTFIntrinctic is a PTF metric in only the intrinsic parameters (a \(4 \times 4\) matrix), and PTFFull is the PTF metric in the full parameter space (intrinsic and extrinsic parameters).

Enumerator
Tau0Tau2	\((\tau_0, \tau_2)\) space of chirptimes
Tau0Tau3	\((\tau_0, \tau_3)\) space of chirptimes
Psi0Psi3	for BCV templates
PTFIntrinsic	a PTF metric in only the intrinsic parameters (a \(4\times 4\) matrix)
PTFFull	PTF metric in the full parameter space (intrinsic and extrinsic parameters).

Definition at line 111 of file LALInspiralBank.h.

GridSpacing

enum GridSpacing

This enum is set by the user to specify the type of placement requested.

It can be Square, Hexagonal, SquareNotOriented, HexagonalNotOriented, S2BCV. The two first align the ellipse along the eigen-vectors whereas the two next do not. The last is a square placement which was being used during S2 and is therefore obsolete and should not be used (feel free to remove it). Historically, we used the SquareNotOriented placement until S4. Then, in S5, we switched to the Hexagonal placement, which should be used for future searches.

Enumerator
SquareNotOriented	UNDOCUMENTED.
Square	UNDOCUMENTED.
HexagonalNotOriented	UNDOCUMENTED.
Hexagonal	UNDOCUMENTED.
HybridHexagonal	UNDOCUMENTED.
S2BCV	UNDOCUMENTED.

Definition at line 131 of file LALInspiralBank.h.

Position

enum Position

This enum can take the following values In, Out, Below, Edge, Above and is used only by the Hexagonal placement.

It simply specifies the place of a point with respect to the parameter space. Edge, means that the ellipse covers two boundaries(upper and lower).

Enumerator
In	UNDOCUMENTED.
Above	UNDOCUMENTED.
Below	UNDOCUMENTED.
Out	UNDOCUMENTED.
Edge	UNDOCUMENTED.

Definition at line 149 of file LALInspiralBank.h.

InsidePolygonEnum

enum InsidePolygonEnum

This enum is set to true or false, it is just a boolean variable for the purpose of BCV placement but can be used in an other context.

Enumerator
False
True

Definition at line 164 of file LALInspiralBank.h.

Generation

enum Generation

This enum is either fertile,sterile, and is a boolean expression used only by the Hexagonal placement.

Enumerator
Sterile
Fertile

Definition at line 176 of file LALInspiralBank.h.

InspiralBankMassRange

enum InspiralBankMassRange

An enum that appears in the InspiralCoarseBankIn structure which fixes the way templates are chosen: The choice MinComponentMassMaxTotalMass means the minimum of the component masses will be given by mMin and maximum total mass is given by MMax of the InspiralBankCoarseIn structure.

The choice MinMaxComponentMass means the minimum of the components masses will be again fixed by mMin and the maximum of the component masses is fixed by mMax of the InspiralCoarseIn structure below.

Enumerator
MinComponentMassMaxTotalMass
MinMaxComponentMass
MinMaxComponentTotalMass

Definition at line 195 of file LALInspiralBank.h.

FreqCut

enum FreqCut

An enum that lists all the formulas that can be used to specify an upper frequency cutoff.

Enumerator
FreqCut_SchwarzISCO	the innermost stable circular orbit (ISCO) for a test particle orbiting a Schwarzschild black hole
FreqCut_BKLISCO	a mass ratio dependent ISCO derived from estimates of the final spin of a merged black found in a paper by Buonanno, Kidder, and Lehner (arXiv:0709.3839)
FreqCut_LightRing	the unstable circular orbit for photons orbiting a Schwarzschild black hole
FreqCut_ERD	an effective ringdown frequency studied in Pan et al (arXiv:0704.1964) that was found to give good fit between stationary-phase templates and numerical relativity waveforms
FreqCut_FRD	the "Fundamental RingDown" frequency which is calculated from the Berti, Cardoso and Will (arXiv:gr-qc/0512160) value for the \(\omega_{220}\) QNM frequency using mass ratio dependent fits to the final BH mass and spin from Buonanno et al (arXiv:0706.3732)
FreqCut_LRD	the "Lorentzian RingDown" frequency = 1.2*FRD which captures part of the Lorentzian tail from the decay of the QNMs

Definition at line 209 of file LALInspiralBank.h.

Macro Definition Documentation

LALINSPIRALBANKH_ENULL

#define LALINSPIRALBANKH_ENULL   1

Null pointer.

Definition at line 57 of file LALInspiralBank.h.

LALINSPIRALBANKH_EMEM

#define LALINSPIRALBANKH_EMEM   2

Memory allocation failure.

Definition at line 58 of file LALInspiralBank.h.

LALINSPIRALBANKH_ECHOICE

#define LALINSPIRALBANKH_ECHOICE   3

Invalid choice for an input parameter.

Definition at line 59 of file LALInspiralBank.h.

LALINSPIRALBANKH_EDIV0

#define LALINSPIRALBANKH_EDIV0   4

Division by zero.

Definition at line 60 of file LALInspiralBank.h.

LALINSPIRALBANKH_ESIZE

#define LALINSPIRALBANKH_ESIZE   8

Invalid input range.

Definition at line 61 of file LALInspiralBank.h.

LALINSPIRALBANKH_EFRANGE

#define LALINSPIRALBANKH_EFRANGE   16

Limits outside range of frequency series.

Definition at line 62 of file LALInspiralBank.h.

LALINSPIRALBANKH_EORDER

#define LALINSPIRALBANKH_EORDER   32

Inappropriate PN order.

Definition at line 63 of file LALInspiralBank.h.

LALINSPIRALBANKH_EGRIDSPACING

#define LALINSPIRALBANKH_EGRIDSPACING   64

Inappropriate grid spacing parameter [SquareNotOriented or Hexagonal].

Definition at line 64 of file LALInspiralBank.h.

LALINSPIRALBANKH_EHEXAINIT

#define LALINSPIRALBANKH_EHEXAINIT   128

Empty bank.

abnormal behaviour in HexaBank generation.

Definition at line 65 of file LALInspiralBank.h.

LALINSPIRALBANKH_EFCUT

#define LALINSPIRALBANKH_EFCUT   5

Inappropriate cutoff frequency [SchwarzISCO, BKLISCO, LightRing, ERD, FRD or LRD].

Definition at line 66 of file LALInspiralBank.h.

LALINSPIRALBANKH_EFHIGH

#define LALINSPIRALBANKH_EFHIGH   6

Final frequency is less than the low frequency cutoff.

Definition at line 67 of file LALInspiralBank.h.

LALINSPIRALBANKH_ENUMFCUT

#define LALINSPIRALBANKH_ENUMFCUT   7

Number of fcut must be greater or equal to 1.

Definition at line 68 of file LALInspiralBank.h.