AVFactories.h   AVFactories.h 
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
File Name: AVFactories.h File Name: AVFactories.h
<lalVerbatim file="AVFactoriesHV"> <lalVerbatim file="AVFactoriesHV">
Revision: $Id: AVFactories.h,v 1.7 2000/11/09 23:37:19 jolien Exp $ Revision: $Id: AVFactoriesH.m4,v 1.2 2004/11/04 22:48:56 jolien Exp $
</lalVerbatim> </lalVerbatim>
-------------------------------------------------------------------------*/ -------------------------------------------------------------------------*/
/* <lalLaTeX> /* <lalLaTeX>
\section{Header \texttt{AVFactories.h}} \section{Header \texttt{AVFactories.h}}
\label{s:AVFactories.h} \label{s:AVFactories.h}
Provides prototype and status code information for use of CreateVector, Provides prototype and status code information for use of CreateVector,
CreateArray, LALDestroyVector and DestroyArray CreateArray, ResizeVector, ResizeArray, DestroyVector and DestroyArray
\subsection*{Synopsis} \subsection*{Synopsis}
\begin{verbatim} \begin{verbatim}
#include <lal/AVFactories.h> #include <lal/AVFactories.h>
\end{verbatim} \end{verbatim}
</lalLaTeX> */ </lalLaTeX> */
#ifndef _AVFACTORIES_H #ifndef _AVFACTORIES_H
#define _AVFACTORIES_H #define _AVFACTORIES_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <stdarg.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (AVFACTORIESH, "$Id: AVFactories.h,v 1.7 2000/11/09 23:37:19 jolien Exp $"); NRCSID (AVFACTORIESH, "$Id: AVFactoriesH.m4,v 1.2 2004/11/04 22:48:56 jolie n Exp $");
/* <lalLaTeX> /* <lalLaTeX>
\subsection*{Error conditions} \subsection*{Error conditions}
\input{AVFactoriesHErrTab} \input{AVFactoriesHErrTab}
</lalLaTeX> */ </lalLaTeX> */
/* /*
<lalErrTable file="AVFactoriesHErrTab"> <lalErrTable file="AVFactoriesHErrTab">
skipping to change at line 65 skipping to change at line 66
#define AVFACTORIESH_MSGEDPTR "Null vector/array data." #define AVFACTORIESH_MSGEDPTR "Null vector/array data."
#define AVFACTORIESH_MSGEMALLOC "Malloc failure." #define AVFACTORIESH_MSGEMALLOC "Malloc failure."
/* /*
</lalErrTable> </lalErrTable>
*/ */
/* Function prototypes. */ /* Function prototypes. */
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{VectorFactoriesC} \newpage\input{VectorFactoriesC}
\newpage\input{ArrayFactoriesC} \newpage\input{ArrayFactoriesC}
\newpage
\subsection{XLAL Functions}
\subsubsection*{Synopsis}
\begin{verbatim}
#include <lal/AVFactories.h>
REAL4Vector * XLALCreateVector(UINT4 length);
REAL4Vector * XLALResizeVector(REAL4Vector *vector, UINT4 length);
void XLALDestroyVector(REAL4Vector *vector, UINT4 length);
<vectype> * XLALCreate<vectype>(UINT4 length );
<vectype> * XLALResize<vectype>(<vectype> *vector, UINT4 length );
void XLALDestroy<vectype>(<vectype> *vector);
REAL4Array * XLALCreateArrayL(UINT4 ndim, ...);
REAL4Array * XLALCreateArrayV(UINT4 ndim, UINT4 *dims);
REAL4Array * XLALCreateArray(UINT4Vector *dimLength);
REAL4Array * XLALResizeArrayL(REAL4Array *array, UINT4 ndim, ...);
REAL4Array * XLALResizeArrayV(REAL4Array *array, UINT4 ndim, UINT4 *dims);
REAL4Array * XLALResizeArray(REAL4Array *array, UINT4Vector *dimLength);
void XLALDestroyArray(REAL4Array *array);
<arrtype> * XLALCreate<arrtype>L(UINT4 ndim, ...);
<arrtype> * XLALCreate<arrtype>V(UINT4 ndim, UINT4 *dims);
<arrtype> * XLALCreate<arrtype>(UINT4Vector *dimLength);
<arrtype> * XLALResize<arrtype>L(<arrtype> *array, UINT4 ndim, ...);
<arrtype> * XLALResize<arrtype>V(<arrtype> *array, UINT4 ndim, UINT4 *dims)
;
<arrtype> * XLALResize<arrtype>(<arrtype> *array, UINT4Vector *dimLength);
void XLALDestroy<arrtype>(<arrtype> *array);
\end{verbatim}
\idx{XLALCreateVector}
\idx{XLALResizeVector}
\idx{XLALDestroyVector}
\idx{XLALCreateArrayL}
\idx{XLALCreateArrayV}
\idx{XLALCreateArray}
\idx{XLALResizeArrayL}
\idx{XLALResizeArrayV}
\idx{XLALResizeArray}
\idx{XLALDestroyArray}
\idx{XLALCreate<type>Vector}
\idx{XLALResize<type>Vector}
\idx{XLALDestroy<type>Vector}
\idx{XLALCreate<type>ArrayL}
\idx{XLALCreate<type>ArrayV}
\idx{XLALCreate<type>Array}
\idx{XLALResize<type>ArrayL}
\idx{XLALResize<type>ArrayV}
\idx{XLALResize<type>Array}
\idx{XLALDestroy<type>Array}
Here \verb+<vectype>+ is one of
\verb+COMPLEX16Vector+,
\verb+COMPLEX8Vector+,
\verb+REAL8Vector+,
\verb+REAL4Vector+,
\verb+INT8Vector+,
\verb+INT4Vector+,
\verb+INT2Vector+,
\verb+UINT8Vector+,
\verb+UINT4Vector+,
\verb+UINT2Vector+, or
\verb+CHARVector+,
and \verb+<arrtype>+ is one of
\verb+COMPLEX16Array+,
\verb+COMPLEX8Array+,
\verb+REAL8Array+,
\verb+REAL4Array+,
\verb+INT8Array+,
\verb+INT4Array+,
\verb+INT2Array+,
\verb+UINT8Array+,
\verb+UINT4Array+, or
\verb+UINT2Array+.
\subsubsection*{Description}
The \verb+XLALCreate<type>Vector+ functions create vectors of the specified
\verb+length+ number of objects of type \verb+<type>+. The function
\verb+XLALCreateVector+ is the same as \verb+XLALCreateREAL4Vector+.
The \verb+XLALDestroy<type>Vector+ functions deallocate the memory allocati
on
pointed to by \verb+vector+ including its contents. The function
\verb+XLALDestroyVector+ is the same as \verb+XLALDestroyREAL4Vector+.
The \verb+XLALResize<type>Vector+ functions resize the supplied vector
\verb+vector+ to the new size \verb+length+. If \verb+vector+ is \verb+NUL
L+
then this is equivalent to \verb+XLALCreate<type>Vector+. If \verb+length+
is zero then this is equivalent to \verb+XLALDestroy<type>Vector+ and the
routine returns \verb+NULL+. Otherwise, the amount of data in the vector
is realloced using \verb+LALRealloc+. The function
\verb+XLALResizeVector+ is the same as \verb+XLALResizeREAL4Vector+.
The \verb+XLALCreate<type>Array+
\verb+XLALCreate<type>ArrayL+
\verb+XLALCreate<type>ArrayV+
all create an object of type \verb+<type>Array+. They differ in the way
that the dimensions of the array are specified. The function
\verb+XLALCreate<type>Array+ allocates an array with dimensions specified
by the \verb+UINT4Vector+ \verb+dimLength+ which is a vector of dimension
lengths for the array. The function
\verb+XLALCreate<type>ArrayV+ provides these dimensions with two arguments:
\verb+ndim+ is the number of dimensions and \verb+dims+ is an array of
\verb+UINT4+ values for the dimensions. The function
\verb+XLALCreate<type>ArrayL+ also specifies the dimensions as arguments.
Here, the first argument, \verb+ndim+, is the number of dimensions, and
this is followed by \verb+ndim+ arguments that provide the dimensions.
Note that for this function, a maximum of 16 dimensions can be provided
(that is, \verb+ndim+ cannot be more than 16 and there cannot be more than
16 arguments after the first).
The \verb+XLALCreateArray+
\verb+XLALCreateArrayL+
\verb+XLALCreateArrayV+
functions are equivalent to the
\verb+XLALCreateREAL4Array+
\verb+XLALCreateREAL4ArrayL+
\verb+XLALCreateREAL4ArrayV+
functions respectively.
The \verb+XLALDestroy<type>Array+ functions deallocate the memory allocatio
n
pointed to by \verb+array+ including its contents. The function
\verb+XLALDestroyArray+ is the same as \verb+XLALDestroyREAL4Array+.
The \verb+XLALResize<type>Array+
\verb+XLALResize<type>ArrayL+
\verb+XLALResize<type>ArrayV+
functions resize the provided array \verb+array+. The arguments after the
first are interpreted in the same way as for the
\verb+XLALCreate<type>Array+
\verb+XLALCreate<type>ArrayL+
\verb+XLALCreate<type>ArrayV+
functions. If \verb+array+ is \verb+NULL+, the resize functions are equiva
lent
to the corresponding create function. If \verb+ndim+ is zero for
\verb+XLALResize<type>ArrayL+ or
\verb+XLALResize<type>ArrayV+, or if \verb+dimLength+ is \verb+NULL+ for
\verb+XLALResize<type>Array+, then these functions are equivalent to
\verb+XLALDestroy<type>Array+.
The \verb+XLALResizeArray+
\verb+XLALResizeArrayL+
\verb+XLALResizeArrayV+
functions are equivalent to the
\verb+XLALResizeREAL4Array+
\verb+XLALResizeREAL4ArrayL+
\verb+XLALResizeREAL4ArrayV+
functions respectively.
\subsubsection*{Return Values}
If successful, the create and resize functions return a pointer to the same
data that was passed to the function. The resize functions will return
a \verb+NULL+ pointer if the size of the new object was zero. Upon failure
these routines will return \verb+NULL+ and will set \verb+xlalErrno+ to
one of these values: \verb+XLAL_ENOMEM+ if a memory allocation failed,
\verb+XLAL_EBADLEN+ if an invalid length was provided (for example, a
zero-size allocation with a create function), \verb+XLAL_EINVAL+ if an
invalid argument is provided (for example, if the pointer to an
array of dimensions is \verb+NULL+).
The destroy function does not return any value. If the function is passed
a
\verb+NULL+ pointer, it will set \verb+xlalErrno+ to \verb+XLAL_EFAULT+.
If the function is passed an object that appears corrupted (e.g., a
vector with zero length or will a \verb+NULL+ data pointer) it will set
\verb+xlalErrno+ to \verb+XLAL_EINVAL+.
</lalLaTeX> */ </lalLaTeX> */
void LALCHARCreateVector(LALStatus *, CHARVector **, UINT4); /*
void LALI2CreateVector(LALStatus *, INT2Vector **, UINT4);
void LALI4CreateVector(LALStatus *, INT4Vector **, UINT4); * CHAR
void LALI8CreateVector(LALStatus *, INT8Vector **, UINT4); */
void LALU2CreateVector(LALStatus *, UINT2Vector **, UINT4); CHARVector * XLALCreateCHARVector ( UINT4 length );
void LALU4CreateVector(LALStatus *, UINT4Vector **, UINT4); CHARVector * XLALResizeCHARVector ( CHARVector * vector, UINT4 length );
void LALU8CreateVector(LALStatus *, UINT8Vector **, UINT4); void XLALDestroyCHARVector ( CHARVector * vector );
void LALCreateVector(LALStatus *, REAL4Vector **, UINT4); void LALCHARCreateVector ( LALStatus *, CHARVector **, UINT4 );
void LALSCreateVector(LALStatus *, REAL4Vector **, UINT4); void LALCHARResizeVector ( LALStatus *, CHARVector **, UINT4 );
void LALDCreateVector(LALStatus *, REAL8Vector **, UINT4); void LALCHARDestroyVector ( LALStatus *, CHARVector ** );
void LALCCreateVector(LALStatus *, COMPLEX8Vector **, UINT4);
void LALZCreateVector(LALStatus *, COMPLEX16Vector **, UINT4); /*
void LALI2CreateArray(LALStatus *, INT2Array **, UINT4Vector *); * INT2
void LALI4CreateArray(LALStatus *, INT4Array **, UINT4Vector *); */
void LALI8CreateArray(LALStatus *, INT8Array **, UINT4Vector *); INT2Vector * XLALCreateINT2Vector ( UINT4 length );
void LALU2CreateArray(LALStatus *, UINT2Array **, UINT4Vector *); INT2Vector * XLALResizeINT2Vector ( INT2Vector * vector, UINT4 length );
void LALU4CreateArray(LALStatus *, UINT4Array **, UINT4Vector *); void XLALDestroyINT2Vector ( INT2Vector * vector );
void LALU8CreateArray(LALStatus *, UINT8Array **, UINT4Vector *); void LALI2CreateVector ( LALStatus *, INT2Vector **, UINT4 );
void LALCreateArray(LALStatus *, REAL4Array **, UINT4Vector *); void LALI2ResizeVector ( LALStatus *, INT2Vector **, UINT4 );
void LALSCreateArray(LALStatus *, REAL4Array **, UINT4Vector *); void LALI2DestroyVector ( LALStatus *, INT2Vector ** );
void LALDCreateArray(LALStatus *, REAL8Array **, UINT4Vector *);
void LALCCreateArray(LALStatus *, COMPLEX8Array **, UINT4Vector *); /*
void LALZCreateArray(LALStatus *, COMPLEX16Array **, UINT4Vector *);
* INT2
void LALCHARDestroyVector(LALStatus *, CHARVector **); */
void LALI2DestroyVector(LALStatus *, INT2Vector **); INT2Array * XLALCreateINT2ArrayL ( UINT4, ... );
void LALI4DestroyVector(LALStatus *, INT4Vector **); INT2Array * XLALCreateINT2ArrayV ( UINT4, UINT4 * );
void LALI8DestroyVector(LALStatus *, INT8Vector **); INT2Array * XLALCreateINT2Array ( UINT4Vector * );
void LALU2DestroyVector(LALStatus *, UINT2Vector **); INT2Array * XLALResizeINT2ArrayL ( INT2Array *, UINT4, ... );
void LALU4DestroyVector(LALStatus *, UINT4Vector **); INT2Array * XLALResizeINT2ArrayV ( INT2Array *, UINT4, UINT4 * );
void LALU8DestroyVector(LALStatus *, UINT8Vector **); INT2Array * XLALResizeINT2Array ( INT2Array *, UINT4Vector * );
void LALDestroyVector(LALStatus *, REAL4Vector **); void XLALDestroyINT2Array ( INT2Array * );
void LALSDestroyVector(LALStatus *, REAL4Vector **); void LALI2CreateArray ( LALStatus *, INT2Array **, UINT4Vector * );
void LALDDestroyVector(LALStatus *, REAL8Vector **); void LALI2ResizeArray ( LALStatus *, INT2Array **, UINT4Vector * );
void LALCDestroyVector(LALStatus *, COMPLEX8Vector **); void LALI2DestroyArray ( LALStatus *, INT2Array ** );
void LALZDestroyVector(LALStatus *, COMPLEX16Vector **);
/*
void LALI2DestroyArray(LALStatus *, INT2Array **);
void LALI4DestroyArray(LALStatus *, INT4Array **); * INT4
void LALI8DestroyArray(LALStatus *, INT8Array **); */
void LALU2DestroyArray(LALStatus *, UINT2Array **); INT4Vector * XLALCreateINT4Vector ( UINT4 length );
void LALU4DestroyArray(LALStatus *, UINT4Array **); INT4Vector * XLALResizeINT4Vector ( INT4Vector * vector, UINT4 length );
void LALU8DestroyArray(LALStatus *, UINT8Array **); void XLALDestroyINT4Vector ( INT4Vector * vector );
void LALDestroyArray(LALStatus *, REAL4Array **); void LALI4CreateVector ( LALStatus *, INT4Vector **, UINT4 );
void LALSDestroyArray(LALStatus *, REAL4Array **); void LALI4ResizeVector ( LALStatus *, INT4Vector **, UINT4 );
void LALDDestroyArray(LALStatus *, REAL8Array **); void LALI4DestroyVector ( LALStatus *, INT4Vector ** );
void LALCDestroyArray(LALStatus *, COMPLEX8Array **);
void LALZDestroyArray(LALStatus *, COMPLEX16Array **); /*
* INT4
*/
INT4Array * XLALCreateINT4ArrayL ( UINT4, ... );
INT4Array * XLALCreateINT4ArrayV ( UINT4, UINT4 * );
INT4Array * XLALCreateINT4Array ( UINT4Vector * );
INT4Array * XLALResizeINT4ArrayL ( INT4Array *, UINT4, ... );
INT4Array * XLALResizeINT4ArrayV ( INT4Array *, UINT4, UINT4 * );
INT4Array * XLALResizeINT4Array ( INT4Array *, UINT4Vector * );
void XLALDestroyINT4Array ( INT4Array * );
void LALI4CreateArray ( LALStatus *, INT4Array **, UINT4Vector * );
void LALI4ResizeArray ( LALStatus *, INT4Array **, UINT4Vector * );
void LALI4DestroyArray ( LALStatus *, INT4Array ** );
/*
* INT8
*/
INT8Vector * XLALCreateINT8Vector ( UINT4 length );
INT8Vector * XLALResizeINT8Vector ( INT8Vector * vector, UINT4 length );
void XLALDestroyINT8Vector ( INT8Vector * vector );
void LALI8CreateVector ( LALStatus *, INT8Vector **, UINT4 );
void LALI8ResizeVector ( LALStatus *, INT8Vector **, UINT4 );
void LALI8DestroyVector ( LALStatus *, INT8Vector ** );
/*
* INT8
*/
INT8Array * XLALCreateINT8ArrayL ( UINT4, ... );
INT8Array * XLALCreateINT8ArrayV ( UINT4, UINT4 * );
INT8Array * XLALCreateINT8Array ( UINT4Vector * );
INT8Array * XLALResizeINT8ArrayL ( INT8Array *, UINT4, ... );
INT8Array * XLALResizeINT8ArrayV ( INT8Array *, UINT4, UINT4 * );
INT8Array * XLALResizeINT8Array ( INT8Array *, UINT4Vector * );
void XLALDestroyINT8Array ( INT8Array * );
void LALI8CreateArray ( LALStatus *, INT8Array **, UINT4Vector * );
void LALI8ResizeArray ( LALStatus *, INT8Array **, UINT4Vector * );
void LALI8DestroyArray ( LALStatus *, INT8Array ** );
/*
* UINT2
*/
UINT2Vector * XLALCreateUINT2Vector ( UINT4 length );
UINT2Vector * XLALResizeUINT2Vector ( UINT2Vector * vector, UINT4 length );
void XLALDestroyUINT2Vector ( UINT2Vector * vector );
void LALU2CreateVector ( LALStatus *, UINT2Vector **, UINT4 );
void LALU2ResizeVector ( LALStatus *, UINT2Vector **, UINT4 );
void LALU2DestroyVector ( LALStatus *, UINT2Vector ** );
/*
* UINT2
*/
UINT2Array * XLALCreateUINT2ArrayL ( UINT4, ... );
UINT2Array * XLALCreateUINT2ArrayV ( UINT4, UINT4 * );
UINT2Array * XLALCreateUINT2Array ( UINT4Vector * );
UINT2Array * XLALResizeUINT2ArrayL ( UINT2Array *, UINT4, ... );
UINT2Array * XLALResizeUINT2ArrayV ( UINT2Array *, UINT4, UINT4 * );
UINT2Array * XLALResizeUINT2Array ( UINT2Array *, UINT4Vector * );
void XLALDestroyUINT2Array ( UINT2Array * );
void LALU2CreateArray ( LALStatus *, UINT2Array **, UINT4Vector * );
void LALU2ResizeArray ( LALStatus *, UINT2Array **, UINT4Vector * );
void LALU2DestroyArray ( LALStatus *, UINT2Array ** );
/*
* UINT4
*/
UINT4Vector * XLALCreateUINT4Vector ( UINT4 length );
UINT4Vector * XLALResizeUINT4Vector ( UINT4Vector * vector, UINT4 length );
void XLALDestroyUINT4Vector ( UINT4Vector * vector );
void LALU4CreateVector ( LALStatus *, UINT4Vector **, UINT4 );
void LALU4ResizeVector ( LALStatus *, UINT4Vector **, UINT4 );
void LALU4DestroyVector ( LALStatus *, UINT4Vector ** );
/*
* UINT4
*/
UINT4Array * XLALCreateUINT4ArrayL ( UINT4, ... );
UINT4Array * XLALCreateUINT4ArrayV ( UINT4, UINT4 * );
UINT4Array * XLALCreateUINT4Array ( UINT4Vector * );
UINT4Array * XLALResizeUINT4ArrayL ( UINT4Array *, UINT4, ... );
UINT4Array * XLALResizeUINT4ArrayV ( UINT4Array *, UINT4, UINT4 * );
UINT4Array * XLALResizeUINT4Array ( UINT4Array *, UINT4Vector * );
void XLALDestroyUINT4Array ( UINT4Array * );
void LALU4CreateArray ( LALStatus *, UINT4Array **, UINT4Vector * );
void LALU4ResizeArray ( LALStatus *, UINT4Array **, UINT4Vector * );
void LALU4DestroyArray ( LALStatus *, UINT4Array ** );
/*
* UINT8
*/
UINT8Vector * XLALCreateUINT8Vector ( UINT4 length );
UINT8Vector * XLALResizeUINT8Vector ( UINT8Vector * vector, UINT4 length );
void XLALDestroyUINT8Vector ( UINT8Vector * vector );
void LALU8CreateVector ( LALStatus *, UINT8Vector **, UINT4 );
void LALU8ResizeVector ( LALStatus *, UINT8Vector **, UINT4 );
void LALU8DestroyVector ( LALStatus *, UINT8Vector ** );
/*
* UINT8
*/
UINT8Array * XLALCreateUINT8ArrayL ( UINT4, ... );
UINT8Array * XLALCreateUINT8ArrayV ( UINT4, UINT4 * );
UINT8Array * XLALCreateUINT8Array ( UINT4Vector * );
UINT8Array * XLALResizeUINT8ArrayL ( UINT8Array *, UINT4, ... );
UINT8Array * XLALResizeUINT8ArrayV ( UINT8Array *, UINT4, UINT4 * );
UINT8Array * XLALResizeUINT8Array ( UINT8Array *, UINT4Vector * );
void XLALDestroyUINT8Array ( UINT8Array * );
void LALU8CreateArray ( LALStatus *, UINT8Array **, UINT4Vector * );
void LALU8ResizeArray ( LALStatus *, UINT8Array **, UINT4Vector * );
void LALU8DestroyArray ( LALStatus *, UINT8Array ** );
/*
* REAL4
*/
REAL4Vector * XLALCreateREAL4Vector ( UINT4 length );
REAL4Vector * XLALResizeREAL4Vector ( REAL4Vector * vector, UINT4 length );
void XLALDestroyREAL4Vector ( REAL4Vector * vector );
void LALSCreateVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALSResizeVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALSDestroyVector ( LALStatus *, REAL4Vector ** );
/*
* REAL4
*/
REAL4Array * XLALCreateREAL4ArrayL ( UINT4, ... );
REAL4Array * XLALCreateREAL4ArrayV ( UINT4, UINT4 * );
REAL4Array * XLALCreateREAL4Array ( UINT4Vector * );
REAL4Array * XLALResizeREAL4ArrayL ( REAL4Array *, UINT4, ... );
REAL4Array * XLALResizeREAL4ArrayV ( REAL4Array *, UINT4, UINT4 * );
REAL4Array * XLALResizeREAL4Array ( REAL4Array *, UINT4Vector * );
void XLALDestroyREAL4Array ( REAL4Array * );
void LALSCreateArray ( LALStatus *, REAL4Array **, UINT4Vector * );
void LALSResizeArray ( LALStatus *, REAL4Array **, UINT4Vector * );
void LALSDestroyArray ( LALStatus *, REAL4Array ** );
/*
* REAL8
*/
REAL8Vector * XLALCreateREAL8Vector ( UINT4 length );
REAL8Vector * XLALResizeREAL8Vector ( REAL8Vector * vector, UINT4 length );
void XLALDestroyREAL8Vector ( REAL8Vector * vector );
void LALDCreateVector ( LALStatus *, REAL8Vector **, UINT4 );
void LALDResizeVector ( LALStatus *, REAL8Vector **, UINT4 );
void LALDDestroyVector ( LALStatus *, REAL8Vector ** );
/*
* REAL8
*/
REAL8Array * XLALCreateREAL8ArrayL ( UINT4, ... );
REAL8Array * XLALCreateREAL8ArrayV ( UINT4, UINT4 * );
REAL8Array * XLALCreateREAL8Array ( UINT4Vector * );
REAL8Array * XLALResizeREAL8ArrayL ( REAL8Array *, UINT4, ... );
REAL8Array * XLALResizeREAL8ArrayV ( REAL8Array *, UINT4, UINT4 * );
REAL8Array * XLALResizeREAL8Array ( REAL8Array *, UINT4Vector * );
void XLALDestroyREAL8Array ( REAL8Array * );
void LALDCreateArray ( LALStatus *, REAL8Array **, UINT4Vector * );
void LALDResizeArray ( LALStatus *, REAL8Array **, UINT4Vector * );
void LALDDestroyArray ( LALStatus *, REAL8Array ** );
/*
* COMPLEX8
*/
COMPLEX8Vector * XLALCreateCOMPLEX8Vector ( UINT4 length );
COMPLEX8Vector * XLALResizeCOMPLEX8Vector ( COMPLEX8Vector * vector, UINT4
length );
void XLALDestroyCOMPLEX8Vector ( COMPLEX8Vector * vector );
void LALCCreateVector ( LALStatus *, COMPLEX8Vector **, UINT4 );
void LALCResizeVector ( LALStatus *, COMPLEX8Vector **, UINT4 );
void LALCDestroyVector ( LALStatus *, COMPLEX8Vector ** );
/*
* COMPLEX8
*/
COMPLEX8Array * XLALCreateCOMPLEX8ArrayL ( UINT4, ... );
COMPLEX8Array * XLALCreateCOMPLEX8ArrayV ( UINT4, UINT4 * );
COMPLEX8Array * XLALCreateCOMPLEX8Array ( UINT4Vector * );
COMPLEX8Array * XLALResizeCOMPLEX8ArrayL ( COMPLEX8Array *, UINT4, ... );
COMPLEX8Array * XLALResizeCOMPLEX8ArrayV ( COMPLEX8Array *, UINT4, UINT4 *
);
COMPLEX8Array * XLALResizeCOMPLEX8Array ( COMPLEX8Array *, UINT4Vector * );
void XLALDestroyCOMPLEX8Array ( COMPLEX8Array * );
void LALCCreateArray ( LALStatus *, COMPLEX8Array **, UINT4Vector * );
void LALCResizeArray ( LALStatus *, COMPLEX8Array **, UINT4Vector * );
void LALCDestroyArray ( LALStatus *, COMPLEX8Array ** );
/*
* COMPLEX16
*/
COMPLEX16Vector * XLALCreateCOMPLEX16Vector ( UINT4 length );
COMPLEX16Vector * XLALResizeCOMPLEX16Vector ( COMPLEX16Vector * vector, UIN
T4 length );
void XLALDestroyCOMPLEX16Vector ( COMPLEX16Vector * vector );
void LALZCreateVector ( LALStatus *, COMPLEX16Vector **, UINT4 );
void LALZResizeVector ( LALStatus *, COMPLEX16Vector **, UINT4 );
void LALZDestroyVector ( LALStatus *, COMPLEX16Vector ** );
/*
* COMPLEX16
*/
COMPLEX16Array * XLALCreateCOMPLEX16ArrayL ( UINT4, ... );
COMPLEX16Array * XLALCreateCOMPLEX16ArrayV ( UINT4, UINT4 * );
COMPLEX16Array * XLALCreateCOMPLEX16Array ( UINT4Vector * );
COMPLEX16Array * XLALResizeCOMPLEX16ArrayL ( COMPLEX16Array *, UINT4, ... )
;
COMPLEX16Array * XLALResizeCOMPLEX16ArrayV ( COMPLEX16Array *, UINT4, UINT4
* );
COMPLEX16Array * XLALResizeCOMPLEX16Array ( COMPLEX16Array *, UINT4Vector *
);
void XLALDestroyCOMPLEX16Array ( COMPLEX16Array * );
void LALZCreateArray ( LALStatus *, COMPLEX16Array **, UINT4Vector * );
void LALZResizeArray ( LALStatus *, COMPLEX16Array **, UINT4Vector * );
void LALZDestroyArray ( LALStatus *, COMPLEX16Array ** );
/*
* REAL4
*/
REAL4Vector * XLALCreateVector ( UINT4 length );
REAL4Vector * XLALResizeVector ( REAL4Vector * vector, UINT4 length );
void XLALDestroyVector ( REAL4Vector * vector );
void LALCreateVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALResizeVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALDestroyVector ( LALStatus *, REAL4Vector ** );
/*
* REAL4
*/
REAL4Array * XLALCreateArrayL ( UINT4, ... );
REAL4Array * XLALCreateArrayV ( UINT4, UINT4 * );
REAL4Array * XLALCreateArray ( UINT4Vector * );
REAL4Array * XLALResizeArrayL ( REAL4Array *, UINT4, ... );
REAL4Array * XLALResizeArrayV ( REAL4Array *, UINT4, UINT4 * );
REAL4Array * XLALResizeArray ( REAL4Array *, UINT4Vector * );
void XLALDestroyArray ( REAL4Array * );
void LALCreateArray ( LALStatus *, REAL4Array **, UINT4Vector * );
void LALResizeArray ( LALStatus *, REAL4Array **, UINT4Vector * );
void LALDestroyArray ( LALStatus *, REAL4Array ** );
/* Test program. */ /* Test program. */
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{VectorFactoriesTestC} \newpage\input{VectorFactoriesTestC}
\newpage\input{ArrayFactoriesTestC} \newpage\input{ArrayFactoriesTestC}
</lalLaTeX> */ </lalLaTeX> */
#ifdef __cplusplus #ifdef __cplusplus
} }
 End of changes. 6 change blocks. 
52 lines changed or deleted 478 lines changed or added


 AstroOmega.h   AstroOmega.h 
/*<lalVerbatim file="AstroOmegaHV"> /*<lalVerbatim file="AstroOmegaHV">
Author: Regimbau Tania Author: Regimbau Tania
$Id: AstroOmega.h,v 1.1 2002/03/13 16:39:11 jolien Exp $ $Id: AstroOmega.h,v 1.6 2004/10/19 09:49:41 ram Exp $
</lalVerbatim> */ </lalVerbatim> */
/*<lalLaTeX> /*<lalLaTeX>
\section{Header \texttt{AstroOmega.h}} \section{Header \texttt{AstroOmega.h}}
\label{s:AstroOmega.h} \label{s:AstroOmega.h}
compute the energy density spectrum of stochastic backgrounds produced compute the energy density spectrum of stochastic backgrounds produced
by cosmological population of astrophysical sources. by cosmological population of astrophysical sources.
skipping to change at line 31 skipping to change at line 31
#define _ASTROOMEGA_H #define _ASTROOMEGA_H
#include <stdio.h> #include <stdio.h>
#include <math.h> #include <math.h>
#include <lal/LALConfig.h> #include <lal/LALConfig.h>
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/Integrate.h> #include <lal/Integrate.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (ASTROOMEGAH, "$Id: AstroOmega.h,v 1.1 2002/03/13 16:39:11 jolien Ex p $"); NRCSID (ASTROOMEGAH, "$Id: AstroOmega.h,v 1.6 2004/10/19 09:49:41 ram Exp $ ");
/*<lalLaTeX> /*<lalLaTeX>
\subsection*{Error conditions} \subsection*{Error conditions}
the errors that may occurs in this module are integration errors already de finein Integrate.h the errors that may occur in this module are integration errors already def ined in Integrate.h
\subsection*{Structures} \subsection*{Structures}
These are function pointer corresponding to the spectral energy density of a single source These are function pointers corresponding to the spectral energy density of a single source.
\begin{verbatim} \begin{verbatim}
typedef void (REAL8LALSDensity) (REAL8 *output, REAL8 input); typedef void (REAL8LALSDensity) (REAL8 *output, REAL8 input);
\end{verbatim} \end{verbatim}
These are input structures corresponding to the model parameters (the cosmo logical model parameters and the source model parameters) These are input structures corresponding to the model parameters (the cosmo logical model parameters and the source model parameters)
cosmological model parameters: cosmological model parameters:
\begin{verbatim} \begin{verbatim}
typedef struct typedef struct
tagAstroOmegaCosmoParams tagAstroOmegaCosmoParams
{ {
REAL8 ho; Hubble parameter REAL8 ho; Hubble parameter
REAL8 density_matter; density parameter of matter REAL8 density_matter; density parameter of matter
REAL8 density_vacuum; density parameter of vacuum REAL8 density_vacuum; density parameter of vacuum
REAL8 density_k; density parameter of curvature REAL8 density_k; density parameter of curvature
} }
AstroOmegaCosmoParams; AstroOmegaCosmoParams;
\end{verbatim} \end{verbatim}
source model parameters
In the general case, the user should define previously the single spectral source parameters
energy density
\begin{verbatim} \begin{verbatim}
typedef struct typedef struct
tagAstroOmegaGeneralSourceParams tagAstroOmegaSourceParams
{ {
REAL8LALSDensity *SDensitySource; single spectral energy density REAL8LALSDensity *SDensitySource; single spectral energy density
REAL8 numax; frequency cutoff in the source frame REAL8 numax; frequency cutoff in the source frame
REAL8 fact; groupes various factors, see AstroOmegatemplate REAL8 lambda; mass fraction of source progenitors expressed
s.c for details in inverse solar masses.
}
AstroOmegaGeneralSourceParams;
typedef struct
tagAstroOmegaTemplateSourceParams
{
REAL8 numax;
REAL8 fact;
} }
AstroOmegaTemplateSourceParams; AstroOmegaSourceParams;
\end{verbatim} \end{verbatim}
model parameters (cosmological + source model)
model parameters (cosmological + source)
\begin{verbatim} \begin{verbatim}
typedef struct typedef struct
tagAstroOmegaGeneralParams tagAstroOmegaParams
{ {
AstroOmegaCosmoParams cosmoparams; AstroOmegaCosmoParams cosmoparams;
AstroOmegaGeneralSourceParams gsourceparams; AstroOmegaSourceParams sourceparams;
void *extraparams; void *extraparams;
} }
AstroOmegaGeneralParams; AstroOmegaParams;
typedef struct
tagAstroOmegaTemplatesParams
{
AstroOmegaCosmoParams cosmoparams;
TemplatesSourceParams tsourceparams;
void *extraparams;
}
AstroOmegaTemplatesParams;
\end{verbatim} \end{verbatim}
\vfill{\footnotesize\input{AstroOmegaHV}} \vfill{\footnotesize\input{AstroOmegaHV}}
%\newpage\input{AstroOmegaC} \newpage\input{AstroOmegaC}
\newpage\input{AstroOmegaGeneralC}
\newpage\input{AstroOmegaTemplatesC}
</lalLaTeX> */ </lalLaTeX> */
/*type corresponding to the spectral energy density of a single source*/ /*type corresponding to the spectral energy density of a single source*/
typedef void (REAL8LALSDensity) (REAL8 *output, REAL8 input); typedef void (REAL8LALSDensity) (REAL8 *output, REAL8 input);
/*MODEL PARAMETERS*/ /*MODEL PARAMETERS*/
/*cosmological model*/ /*cosmological model*/
typedef struct typedef struct
tagAstroOmegaCosmoParams tagAstroOmegaCosmoParams
{ {
REAL8 ho; REAL8 ho;
REAL8 density_matter; REAL8 density_matter;
REAL8 density_vacuum; REAL8 density_vacuum;
REAL8 density_k; REAL8 density_k;
} }
AstroOmegaCosmoParams; AstroOmegaCosmoParams;
/*source model*/ /*source model*/
/*in the general case, the user should define previously the single spectra l energy density*/ /*in the general case, the user should define previously the single spectra l energy density*/
typedef struct typedef struct
tagAstroOmegaGeneralSourceParams tagAstroOmegaSourceParams
{ {
REAL8LALSDensity *SDensitySource; REAL8LALSDensity *SDensitySource;
REAL8 numax; REAL8 numax;
REAL8 fact; REAL8 lambda;
}
AstroOmegaGeneralSourceParams;
typedef struct
tagAstroOmegaTemplateSourceParams
{
REAL8 numax;
REAL8 fact;
} }
AstroOmegaTemplatesSourceParams; AstroOmegaSourceParams;
typedef struct typedef struct
tagAstroOmegaGeneralParams tagAstroOmegaParams
{ {
AstroOmegaCosmoParams cosmoparams; AstroOmegaCosmoParams cosmoparams;
AstroOmegaGeneralSourceParams gsourceparams; AstroOmegaSourceParams sourceparams;
void *extraparams; void *extraparams;
} }
AstroOmegaGeneralParams; AstroOmegaParams;
typedef struct
tagAstroOmegaTemplatesParams
{
AstroOmegaCosmoParams cosmoparams;
AstroOmegaTemplatesSourceParams tsourceparams;
void *extraparams;
}
AstroOmegaTemplatesParams;
/*functions returning $\Omega _{gw}(\nu _{o})$*/ /*functions returning $\Omega _{gw}(\nu _{o})$*/
void void
LALAstroOmegaSource ( LALAstroOmega (
LALStatus *status,
REAL8 *result,
REAL8 nu,
void *params
);
/*for rotating pulsars, r and bar modes or binary system,the following func
tions for which the single spectral density has already been intruduced can
be used directly*/
void
LALAstroOmegaPulsar (
LALStatus *status, LALStatus *status,
REAL8 *result, REAL8 *result,
REAL8 nu, REAL8 nu,
void *params void *params
); );
void
LALAstroOmegaModes (
LALStatus *status,
REAL8 *result,
REAL8 nu,
void *params
);
void
LALAstroOmegaBinary (
LALStatus *status,
REAL8 *result,
REAL8 nu,
void *params
);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _ASTROOMEGA_H */ #endif /* _ASTROOMEGA_H */
 End of changes. 24 change blocks. 
88 lines changed or deleted 30 lines changed or added


 BandPassTimeSeries.h   BandPassTimeSeries.h 
/*************************** <lalVerbatim file="BandPassTimeSeriesHV"> /*************************** <lalVerbatim file="BandPassTimeSeriesHV">
Author: Creighton, T. D. Author: Creighton, T. D.
$Id: BandPassTimeSeries.h,v 1.8 2001/08/21 04:19:53 jolien Exp $ $Id: BandPassTimeSeries.h,v 1.11 2005/06/24 22:11:01 jolien Exp $
**************************************************** </lalVerbatim> */ **************************************************** </lalVerbatim> */
/********************************************************** <lalLaTeX> /********************************************************** <lalLaTeX>
\section{Header \texttt{BandPassTimeSeries.h}} \section{Header \texttt{BandPassTimeSeries.h}}
\label{s:BandPassTimeSeries.h} \label{s:BandPassTimeSeries.h}
Provides routines to low- or high-pass filter a time series. Provides routines to low- or high-pass filter a time series.
\subsection*{Synopsis} \subsection*{Synopsis}
skipping to change at line 36 skipping to change at line 36
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/IIRFilter.h> #include <lal/IIRFilter.h>
#include <lal/ZPGFilter.h> #include <lal/ZPGFilter.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#pragma } #pragma }
#endif #endif
NRCSID(BANDPASSTIMESERIESH,"$Id: BandPassTimeSeries.h,v 1.8 2001/08/21 04:1 9:53 jolien Exp $"); NRCSID(BANDPASSTIMESERIESH,"$Id: BandPassTimeSeries.h,v 1.11 2005/06/24 22: 11:01 jolien Exp $");
/********************************************************** <lalLaTeX> /********************************************************** <lalLaTeX>
\subsection*{Error conditions} \subsection*{Error conditions}
****************************************** </lalLaTeX><lalErrTable> */ ****************************************** </lalLaTeX><lalErrTable> */
#define BANDPASSTIMESERIESH_ENUL 1 #define BANDPASSTIMESERIESH_ENUL 1
#define BANDPASSTIMESERIESH_EBAD 2 #define BANDPASSTIMESERIESH_EBAD 2
#define BANDPASSTIMESERIESH_MSGENUL "Unexpected null pointer in arguments" #define BANDPASSTIMESERIESH_MSGENUL "Unexpected null pointer in arguments"
#define BANDPASSTIMESERIESH_MSGEBAD "Bad filter parameters" #define BANDPASSTIMESERIESH_MSGEBAD "Bad filter parameters"
/******************************************** </lalErrTable><lalLaTeX> /******************************************** </lalErrTable><lalLaTeX>
skipping to change at line 92 skipping to change at line 92
/* <lalLaTeX> /* <lalLaTeX>
\vfill{\footnotesize\input{BandPassTimeSeriesHV}} \vfill{\footnotesize\input{BandPassTimeSeriesHV}}
</lalLaTeX> */ </lalLaTeX> */
/* Function prototypes. */ /* Function prototypes. */
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{ButterworthTimeSeriesC} \newpage\input{ButterworthTimeSeriesC}
</lalLaTeX> */ </lalLaTeX> */
int XLALButterworthREAL4TimeSeries( REAL4TimeSeries *series, PassBandParamS
truc *params );
int XLALButterworthREAL8TimeSeries( REAL8TimeSeries *series, PassBandParamS
truc *params );
int XLALLowPassREAL4TimeSeries( REAL4TimeSeries *series,
REAL8 frequency, REAL8 amplitude, INT4 filtorder );
int XLALLowPassREAL8TimeSeries( REAL8TimeSeries *series,
REAL8 frequency, REAL8 amplitude, INT4 filtorder );
int XLALHighPassREAL4TimeSeries( REAL4TimeSeries *series,
REAL8 frequency, REAL8 amplitude, INT4 filtorder );
int XLALHighPassREAL8TimeSeries( REAL8TimeSeries *series,
REAL8 frequency, REAL8 amplitude, INT4 filtorder );
void void
LALButterworthREAL4TimeSeries( LALStatus *stat, LALButterworthREAL4TimeSeries( LALStatus *status,
REAL4TimeSeries *series, REAL4TimeSeries *series,
PassBandParamStruc *params ); PassBandParamStruc *params );
void void
LALButterworthREAL8TimeSeries( LALStatus *stat, LALButterworthREAL8TimeSeries( LALStatus *status,
REAL8TimeSeries *series, REAL8TimeSeries *series,
PassBandParamStruc *params ); PassBandParamStruc *params );
void
LALDButterworthREAL4TimeSeries( LALStatus *status,
REAL4TimeSeries *series,
PassBandParamStruc *params );
/* Chebyshev filters should also be added, but I'm too busy to write /* Chebyshev filters should also be added, but I'm too busy to write
the routines now. */ the routines now. */
/* Test program. */ /* Test program. */
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{BandPassTestC} \newpage\input{BandPassTestC}
</lalLaTeX> */ </lalLaTeX> */
#ifdef __cplusplus #ifdef __cplusplus
 End of changes. 6 change blocks. 
4 lines changed or deleted 23 lines changed or added


 BinaryPulsarTiming.h   BinaryPulsarTiming.h 
/********************************* <lalVerbatim file="BinaryPulsarTimingHV" > /********************************* <lalVerbatim file="BinaryPulsarTimingHV" >
Author: Dupuis, R. J. Author: Dupuis, R. J.
$Id: BinaryPulsarTiming.h,v 1.1 2002/08/02 19:09:35 jolien Exp $ $Id: BinaryPulsarTiming.h,v 1.2 2005/07/15 18:34:15 jolien Exp $
********************************** </lalVerbatim> */ ********************************** </lalVerbatim> */
/********************************* <lalLaTeX> /********************************* <lalLaTeX>
\section{Header \texttt{BinaryPulsarTiming.h}} \section{Header \texttt{BinaryPulsarTiming.h}}
Provides routines to calculated time delay in binaries... Provides routines to calculated time delay in binaries...
\subsection*{Synopsis} \subsection*{Synopsis}
\begin{verbatim} \begin{verbatim}
skipping to change at line 124 skipping to change at line 124
#ifndef _BinaryPulsarTiming_H #ifndef _BinaryPulsarTiming_H
#define _BinaryPulsarTiming_H #define _BinaryPulsarTiming_H
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
/******* INCLUDE ANY OTHER LAL HEADERS needed for header (NOT module) ****/ /******* INCLUDE ANY OTHER LAL HEADERS needed for header (NOT module) ****/
#include <lal/IIRFilter.h> #include <lal/IIRFilter.h>
#include <lal/ZPGFilter.h> #include <lal/ZPGFilter.h>
#include <lal/LALBarycenter.h> #include <lal/LALBarycenter.h>
#include <lal/LALInitBarycenter.h>
#include <lal/SkyCoordinates.h> #include <lal/SkyCoordinates.h>
#include <lal/AVFactories.h> #include <lal/AVFactories.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (BinaryPulsarTimingH, "$Id: BinaryPulsarTiming.h,v 1.1 2002/08/02 19 :09:35 jolien Exp $"); NRCSID (BinaryPulsarTimingH, "$Id: BinaryPulsarTiming.h,v 1.2 2005/07/15 18 :34:15 jolien Exp $");
/******************************** <lalErrTable file="BinaryPulsarTimingHE"> */ /******************************** <lalErrTable file="BinaryPulsarTimingHE"> */
#define BINARYPULSARTIMINGH_ENULLINPUT 1 #define BINARYPULSARTIMINGH_ENULLINPUT 1
#define BINARYPULSARTIMINGH_ENULLOUTPUT 2 #define BINARYPULSARTIMINGH_ENULLOUTPUT 2
#define BINARYPULSARTIMINGH_ENULLPARAMS 3 #define BINARYPULSARTIMINGH_ENULLPARAMS 3
#define BINARYPULSARTIMINGH_ERFACTOR 4 #define BINARYPULSARTIMINGH_ERFACTOR 4
#define BINARYPULSARTIMINGH_EINVALIDF0 5 #define BINARYPULSARTIMINGH_EINVALIDF0 5
#define BINARYPULSARTIMINGH_ELENGTH 6 #define BINARYPULSARTIMINGH_ELENGTH 6
#define BINARYPULSARTIMINGH_MSGENULLINPUT "Input was Null" #define BINARYPULSARTIMINGH_MSGENULLINPUT "Input was Null"
 End of changes. 3 change blocks. 
3 lines changed or deleted 2 lines changed or added


 Calibration.h   Calibration.h 
/**** <lalVerbatim file="CalibrationHV"> /**** <lalVerbatim file="CalibrationHV">
* Author: P. R. Brady, J. D. E. Creighton * Author: P. R. Brady, J. D. E. Creighton
* $Id: Calibration.h,v 1.2 2001/12/20 20:31:25 patrick Exp $ * $Id: Calibration.h,v 1.17 2005/05/01 15:02:17 patrick Exp $
**** </lalVerbatim> */ **** </lalVerbatim> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* \section{Header \texttt{Calibration.h}} * \section{Header \texttt{Calibration.h}}
* *
* \subsection*{Synopsis} * \subsection*{Synopsis}
* \begin{verbatim} * \begin{verbatim}
* #include <lal/Calibration.h> * #include <lal/Calibration.h>
* \end{verbatim} * \end{verbatim}
* *
**** </lalLaTeX> */ **** </lalLaTeX> */
#ifndef _CALIBRATION_H #ifndef _CALIBRATION_H
#define _CALIBRATION_H #define _CALIBRATION_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/BandPassTimeSeries.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#pragma } /** to match the previous brace **/ #pragma } /** to match the previous brace **/
#endif #endif
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* \subsection*{Error conditions} * \subsection*{Error conditions}
* *
**** </lalLaTeX> */ **** </lalLaTeX> */
/**** <lalErrTable> */ /**** <lalErrTable> */
#define CALIBRATIONH_ENULL 001 #define CALIBRATIONH_ENULL 001
#define CALIBRATIONH_ESIZE 002
#define CALIBRATIONH_ESZMM 004
#define CALIBRATIONH_EZERO 010
#define CALIBRATIONH_ETIME 020
#define CALIBRATIONH_EUNIT 040
#define CALIBRATIONH_MSGENULL "Null pointer" #define CALIBRATIONH_MSGENULL "Null pointer"
#define CALIBRATIONH_MSGESIZE "Invalid size"
#define CALIBRATIONH_MSGESZMM "Size mismatch"
#define CALIBRATIONH_MSGEZERO "Zero factor"
#define CALIBRATIONH_MSGETIME "Time out of range"
#define CALIBRATIONH_MSGEUNIT "Incompatible units"
/**** </lalErrTable> */ /**** </lalErrTable> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* \subsection*{Structures} * \subsection*{Structures}
* \idx[Type]{CalibrationType} * \idx[Type]{CalibrationType}
* \idx[Type]{CalibrationRecord} * \idx[Type]{CalibrationRecord}
* \idx[Type]{CalibrationFunctions}
* \idx[Type]{CalibrationUpdateParams}
*
* \subsubsection*{Type \texttt{CalibrationType}}
* *
**** </lalLaTeX> */ **** </lalLaTeX> */
/**** <lalVerbatim> */ /**** <lalVerbatim> */
typedef enum typedef enum
{ {
CalibrationAmplitude = 001, CalibrationAmplitude = 001,
CalibrationOffset = 002, CalibrationOffset = 002,
CalibrationDelay = 004, CalibrationDelay = 004,
CalibrationTransfer = 010, CalibrationTransfer = 010,
CalibrationZPG = 020 CalibrationZPG = 020
} }
CalibrationType; CalibrationType;
/**** </lalVerbatim> */ /**** </lalVerbatim> */
/**** <lalLaTeX>
*
* Document \verb+CalibrationType+
*
* \subsubsection*{Type \texttt{CalFactors}}
*
**** </lalLaTeX> */
/**** <lalVerbatim> */
typedef struct
tagCalFactors
{
COMPLEX16 alpha;
COMPLEX16 alphabeta;
COMPLEX16 beta;
COMPLEX16 exc;
COMPLEX16 asq;
COMPLEX16 darm;
}
CalFactors;
/**** </lalVerbatim> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* Document \verb+CalibrationType+ * Document \verb+CalibrationType+
* *
* \subsubsection*{Type \texttt{UpdateFactorsParams}}
*
**** </lalLaTeX> */
/**** <lalVerbatim> */
typedef struct
tagUpdateFactorsParams
{
REAL8 lineFrequency;
COMPLEX16 openloop;
COMPLEX16 digital;
REAL4TimeSeries *darmCtrl;
REAL4TimeSeries *asQ;
REAL4TimeSeries *exc;
}
UpdateFactorsParams;
/**** </lalVerbatim> */
/**** <lalLaTeX>
*
* Document \verb+CalibrationType+
*
* \subsubsection*{Type \texttt{CalibrationRecord}}
*
**** </lalLaTeX> */ **** </lalLaTeX> */
/**** <lalVerbatim> */ /**** <lalVerbatim> */
typedef struct typedef struct
tagCalibrationRecord tagCalibrationRecord
{ {
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LIGOTimeGPS epoch; LIGOTimeGPS epoch;
REAL8 duration; REAL8 duration;
CHAR reference[LALNameLength]; CHAR reference[LALNameLength];
LALUnit units; LALUnit units;
skipping to change at line 81 skipping to change at line 141
REAL8 conversion; REAL8 conversion;
REAL8 offset; REAL8 offset;
REAL8 delay; REAL8 delay;
COMPLEX8FrequencySeries *transfer; COMPLEX8FrequencySeries *transfer;
REAL8Vector *zeros; REAL8Vector *zeros;
REAL8Vector *poles; REAL8Vector *poles;
REAL8 gain; REAL8 gain;
} }
CalibrationRecord; CalibrationRecord;
/**** </lalVerbatim> */ /**** </lalVerbatim> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* Document \verb+CalibrationRecord+ * Document \verb+CalibrationRecord+
* *
* \subsubsection*{Type \texttt{CalibrationFunctions}}
*
**** </lalLaTeX> */
/**** <lalVerbatim> */
typedef struct
tagCalibrationFunctions
{
COMPLEX8FrequencySeries *responseFunction;
COMPLEX8FrequencySeries *sensingFunction;
}
CalibrationFunctions;
/**** </lalVerbatim> */
/**** <lalLaTeX>
* The type \texttt{CalibrationFunctions} contains two calibration function
s,
* the sensing function $C(f)$ and the response function $R(f)$. While the
* response function is the function that is most often wanted, the sensing
* function is needed in updating calibration from one epoch to another.
*
* \subsubsection*{Type \texttt{CalibrationUpdateParams}}
*
**** </lalLaTeX> */
/**** <lalVerbatim> */
typedef struct
tagCalibrationUpdateParams
{
LIGOTimeGPS epoch;
LIGOTimeGPS duration;
CHAR *ifo;
COMPLEX8 alpha;
COMPLEX8 alphabeta;
COMPLEX8TimeSeries *openLoopFactor;
COMPLEX8TimeSeries *sensingFactor;
}
CalibrationUpdateParams;
/**** </lalVerbatim> */
/**** <lalLaTeX>
* The type \texttt{CalibrationUpdateParams} contains two time series
* representing an overall gain factor for the open-loop gain function $H(f
)$
* and the sensing function $C(f)$. These transfer functions are known to
* change (by an overall factor) with time, and these two factors can be
* tracked using the injected calibration lines. The factors are stored
* in this structure as (very-slowly varying) time series, and are to be
* used in updating the calibration functions described previously.
* (The response function can be computed from the open-loop gain and the
* sensing function. It is simply $R(f)=[1+H(f)]/C(f)$.) In addition, thi
s
* structure contains the present epoch and the duration of the data to be
* calibrated to identify the particular set of
* factors (from those recorded in the time series) to use.
*
* \vfill{\footnotesize\input{CalibrationHV}} * \vfill{\footnotesize\input{CalibrationHV}}
* \newpage\input{ComputeTransferC} * \newpage\input{ComputeTransferC}
* *
**** </lalLaTeX> */ **** </lalLaTeX> */
typedef
struct StrainOutTag {
REAL8TimeSeries h; /* timeseries containing h(t) */
REAL8TimeSeries hC; /* timeseries containing the control signal *
/
REAL8TimeSeries hR; /* timeseries containing the residual signal
*/
COMPLEX16TimeSeries alpha; /* alpha time series */
COMPLEX16TimeSeries beta; /* beta time series */
COMPLEX16TimeSeries alphabeta; /* alpha time series */
} StrainOut;
typedef
struct StrainInTag {
REAL4TimeSeries AS_Q ; /* timeseries containing ASQ */
REAL4TimeSeries DARM_ERR;/* timeseries containing DARM_ERR */
REAL4TimeSeries DARM ; /* timeseries containing DARM_CTRL */
REAL4TimeSeries EXC ; /* timeseries containing the excitation */
COMPLEX16 Do; /* digital filter at cal line frequency */
COMPLEX16 Go; /* OLG at cal line frequency */
REAL8 f; /* calibration line frequency */
REAL4 To; /* factors integration time */
REAL8IIRFilter *Cinv; /* Filters for inverse of sensing function */
INT4 CinvUSF; /* Upsampling factor for sensing function */
INT4 CinvDelay; /* Overall inverse sensing function delay */
REAL8IIRFilter *AA; /* Filters for analog actuation function */
INT4 AADelay; /* Overall analog actuation function delay */
REAL8IIRFilter *AX; /* Digital filters for x arm actuation function
*/
REAL8IIRFilter *AY; /* Digital filters for y arm actuation function
*/
INT4 NCinv; /* Numbers of filters of each type */
INT4 NAA;
INT4 NAX;
INT4 NAY;
INT4 delta;
INT4 usefactors;
INT4 wings; /* size of wings in seconds */
INT4 fftconv;
INT4 outalphas;
} StrainIn;
typedef
struct MyIIRFilter {
INT4 yOrder;
INT4 xOrder;
REAL8 a[20];
REAL8 b[20];
REAL8 yhist[20];
REAL8 xhist[20];
} MyIIRFilter;
void LALComputeTransfer( LALStatus *status, CalibrationRecord *calrec ); void LALComputeTransfer( LALStatus *status, CalibrationRecord *calrec );
void
LALUpdateCalibration(
LALStatus *status,
CalibrationFunctions *output,
CalibrationFunctions *input,
CalibrationUpdateParams *params
);
void
LALResponseConvert(
LALStatus *status,
COMPLEX8FrequencySeries *output,
COMPLEX8FrequencySeries *input
);
INT4
XLALResponseConvert(
COMPLEX8FrequencySeries *output,
COMPLEX8FrequencySeries *input
);
void LALComputeCalibrationFactors(
LALStatus *status,
CalFactors *output,
UpdateFactorsParams *input
);
void LALComputeStrain(
LALStatus *status,
StrainOut *output,
StrainIn *input
);
void LALGetFactors(
LALStatus *status,
StrainOut *output,
StrainIn *input
);
void LALFIRFilter(LALStatus *status,
REAL8TimeSeries *tseries,
REAL8IIRFilter *FIR);
void LALMakeFIRLP(LALStatus *status,
REAL8IIRFilter *G,
int USF);
void LALMakeFIRLPALPHAS(LALStatus *status,
REAL8IIRFilter *G);
void LALMakeFIRHP(LALStatus *status,
REAL8IIRFilter *G);
void LALCopyFilter(LALStatus *status,
REAL8IIRFilter **F2,
REAL8IIRFilter *F1,
int ORDER);
void LALFreeFilter(LALStatus *status,
REAL8IIRFilter *F2,
int ORDER);
int XLALDivideTimeSeries(REAL8TimeSeries *hR, REAL8TimeSeries *ALPHAS);
int XLALUpsample(REAL8TimeSeries *uphR, REAL8TimeSeries *hR, int up_factor)
;
int XLALUpsampleLinear(REAL8TimeSeries *uphR, REAL8TimeSeries *hR, int up_f
actor);
#ifdef __cplusplus #ifdef __cplusplus
#pragma { /** to match the next brace **/ #pragma { /** to match the next brace **/
} }
#endif #endif
#endif /* _CALIBRATION_H */ #endif /* _CALIBRATION_H */
 End of changes. 11 change blocks. 
1 lines changed or deleted 234 lines changed or added


 CoarseGrainFrequencySeries.h   CoarseGrainFrequencySeries.h 
/*********************** <lalVerbatim file="CoarseGrainFrequencySeriesHV"> /*********************** <lalVerbatim file="CoarseGrainFrequencySeriesHV">
Author: UTB Relativity Group; contact whelan@phys.utb.edu (original by S. D rasco) Author: UTB Relativity Group; contact whelan@phys.utb.edu (original by S. D rasco)
$Id: CoarseGrainFrequencySeries.h,v 1.1 2002/06/10 08:15:46 whelan Exp $ $Id: CoarseGrainFrequencySeries.h,v 1.2 2005/06/14 20:04:48 jolien Exp $
*********************************************************** </lalVerbatim> */ *********************************************************** </lalVerbatim> */
/********************************************************** <lalLaTeX> /********************************************************** <lalLaTeX>
\section{Header \texttt{CoarseGrainFrequencySeries.h}} \section{Header \texttt{CoarseGrainFrequencySeries.h}}
\label{utilities:s:CoarseGrainFrequencySeries.h} \label{utilities:s:CoarseGrainFrequencySeries.h}
Provides prototype, structure and error code information for routines Provides prototype, structure and error code information for routines
which coarse-grain a frequency series. which coarse-grain a frequency series.
\subsection*{Synopsis} \subsection*{Synopsis}
skipping to change at line 29 skipping to change at line 29
\subsection*{Error conditions} \subsection*{Error conditions}
\input{CoarseGrainFrequencySeriesHE} \input{CoarseGrainFrequencySeriesHE}
\subsection*{Structures} \subsection*{Structures}
*********************************************************** </lalLaTeX> */ *********************************************************** </lalLaTeX> */
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#ifndef _COARSEGRAINFREQUENCYSERIES_H
#define _COARSEGRAINFREQUENCYSERIES_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID( COARSEGRAINFREQUENCYSERIESH, NRCSID( COARSEGRAINFREQUENCYSERIESH,
"$Id: CoarseGrainFrequencySeries.h,v 1.1 2002/06/10 08:15:46 whelan Exp $" ); "$Id: CoarseGrainFrequencySeries.h,v 1.2 2005/06/14 20:04:48 jolien Exp $" );
/****************** <lalErrTable file="CoarseGrainFrequencySeriesHE"> */ /****************** <lalErrTable file="CoarseGrainFrequencySeriesHE"> */
#define COARSEGRAINFREQUENCYSERIESH_ENULLPTR 1 #define COARSEGRAINFREQUENCYSERIESH_ENULLPTR 1
#define COARSEGRAINFREQUENCYSERIESH_ESAMEPTR 2 #define COARSEGRAINFREQUENCYSERIESH_ESAMEPTR 2
#define COARSEGRAINFREQUENCYSERIESH_EZEROLEN 3 #define COARSEGRAINFREQUENCYSERIESH_EZEROLEN 3
#define COARSEGRAINFREQUENCYSERIESH_ENONPOSDELTAF 4 #define COARSEGRAINFREQUENCYSERIESH_ENONPOSDELTAF 4
#define COARSEGRAINFREQUENCYSERIESH_ENEGFMIN 5 #define COARSEGRAINFREQUENCYSERIESH_ENEGFMIN 5
#define COARSEGRAINFREQUENCYSERIESH_EMMHETERO 7 #define COARSEGRAINFREQUENCYSERIESH_EMMHETERO 7
#define COARSEGRAINFREQUENCYSERIESH_EMMFMIN 8 #define COARSEGRAINFREQUENCYSERIESH_EMMFMIN 8
skipping to change at line 139 skipping to change at line 142
\vfill{\footnotesize\input{CoarseGrainFrequencySeriesHV}} \vfill{\footnotesize\input{CoarseGrainFrequencySeriesHV}}
\newpage\input{CoarseGrainFrequencySeriesC} \newpage\input{CoarseGrainFrequencySeriesC}
\newpage\input{SCoarseGrainFrequencySeriesTestC} \newpage\input{SCoarseGrainFrequencySeriesTestC}
\newpage\input{DCoarseGrainFrequencySeriesTestC} \newpage\input{DCoarseGrainFrequencySeriesTestC}
\newpage\input{CCoarseGrainFrequencySeriesTestC} \newpage\input{CCoarseGrainFrequencySeriesTestC}
\newpage\input{ZCoarseGrainFrequencySeriesTestC} \newpage\input{ZCoarseGrainFrequencySeriesTestC}
*********************************************************** </lalLaTeX> */ *********************************************************** </lalLaTeX> */
#endif /* _COARSEGRAINFREQUENCYSERIES_H */
 End of changes. 4 change blocks. 
2 lines changed or deleted 5 lines changed or added


 ComplexFFT.h   ComplexFFT.h 
/**** <lalVerbatim file="ComplexFFTHV"> /**** <lalVerbatim file="ComplexFFTHV">
* $Id: ComplexFFT.h,v 1.10 2002/05/01 16:39:03 jolien Exp $ * $Id: ComplexFFT.h,v 1.12 2004/11/05 23:19:26 jolien Exp $
**** </lalVerbatim> */ **** </lalVerbatim> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* \section{Header \texttt{ComplexFFT.h}} * \section{Header \texttt{ComplexFFT.h}}
* \label{s:ComplexFFT.h} * \label{s:ComplexFFT.h}
* *
* Performs complex-to-complex FFTs. * Performs complex-to-complex FFTs.
* *
* \subsection*{Synopsis} * \subsection*{Synopsis}
skipping to change at line 32 skipping to change at line 32
#ifndef _COMPLEXFFT_H #ifndef _COMPLEXFFT_H
#define _COMPLEXFFT_H #define _COMPLEXFFT_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#pragma } #pragma }
#endif #endif
NRCSID( COMPLEXFFTH, "$Id: ComplexFFT.h,v 1.10 2002/05/01 16:39:03 jolien E xp $" ); NRCSID( COMPLEXFFTH, "$Id: ComplexFFT.h,v 1.12 2004/11/05 23:19:26 jolien E xp $" );
/**** <lalLaTeX> /**** <lalLaTeX>
* \subsection*{Error conditions} * \subsection*{Error conditions}
**** </lalLaTeX> */ **** </lalLaTeX> */
/**** <lalErrTable> */ /**** <lalErrTable> */
#define COMPLEXFFTH_ENULL 1 #define COMPLEXFFTH_ENULL 1
#define COMPLEXFFTH_ENNUL 2 #define COMPLEXFFTH_ENNUL 2
#define COMPLEXFFTH_ESIZE 4 #define COMPLEXFFTH_ESIZE 4
#define COMPLEXFFTH_ESZMM 8 #define COMPLEXFFTH_ESZMM 8
#define COMPLEXFFTH_ESLEN 16 #define COMPLEXFFTH_ESLEN 16
#define COMPLEXFFTH_ESAME 32 #define COMPLEXFFTH_ESAME 32
#define COMPLEXFFTH_EALOC 64 #define COMPLEXFFTH_EALOC 64
#define COMPLEXFFTH_EFFTW 128 #define COMPLEXFFTH_EFFTW 128
#define COMPLEXFFTH_ESNGL 256 #define COMPLEXFFTH_ESNGL 256
#define COMPLEXFFTH_EINTL 512
#define COMPLEXFFTH_ESIGN 1024
#define COMPLEXFFTH_MSGENULL "Null pointer" #define COMPLEXFFTH_MSGENULL "Null pointer"
#define COMPLEXFFTH_MSGENNUL "Non-null pointer" #define COMPLEXFFTH_MSGENNUL "Non-null pointer"
#define COMPLEXFFTH_MSGESIZE "Invalid input size" #define COMPLEXFFTH_MSGESIZE "Invalid input size"
#define COMPLEXFFTH_MSGESZMM "Size mismatch" #define COMPLEXFFTH_MSGESZMM "Size mismatch"
#define COMPLEXFFTH_MSGESLEN "Invalid/mismatched sequence lengths" #define COMPLEXFFTH_MSGESLEN "Invalid/mismatched sequence lengths"
#define COMPLEXFFTH_MSGESAME "Input/Output data vectors are the same" #define COMPLEXFFTH_MSGESAME "Input/Output data vectors are the same"
#define COMPLEXFFTH_MSGEFFTW "Error in FFTW" #define COMPLEXFFTH_MSGEFFTW "Error in FFTW"
#define COMPLEXFFTH_MSGEALOC "Memory allocation failed" #define COMPLEXFFTH_MSGEALOC "Memory allocation failed"
#define COMPLEXFFTH_MSGESNGL "FFTW library is not single-precision" #define COMPLEXFFTH_MSGESNGL "FFTW library is not single-precision"
#define COMPLEXFFTH_MSGEINTL "Error in Intel FFT library"
#define COMPLEXFFTH_MSGESIGN "Unknown sign of transform in plan"
/**** </lalErrTable> */ /**** </lalErrTable> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* \subsection*{Structures} * \subsection*{Structures}
* *
**** </lalLaTeX> */ **** </lalLaTeX> */
/**** <lalVerbatim> */ /**** <lalVerbatim> */
typedef struct tagComplexFFTPlan ComplexFFTPlan; typedef struct tagCOMPLEX8FFTPlan COMPLEX8FFTPlan;
typedef struct tagCOMPLEX16FFTPlan COMPLEX16FFTPlan;
#define tagComplexFFTPlan tagCOMPLEX8FFTPlan
#define ComplexFFTPlan COMPLEX8FFTPlan
/**** </lalVerbatim> */ /**** </lalVerbatim> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* This structure contains the parameters necessary for performing an FFT o f a * This structure contains the parameters necessary for performing an FFT o f a
* given size and direction. The contents should not be manually adjusted. * given size and direction. The contents should not be manually adjusted.
* *
* \newpage\input{ComplexFFTC} * \newpage\input{ComplexFFTC}
* \newpage\input{ComplexFFTTestC} * \newpage\input{ComplexFFTTestC}
**** </lalLaTeX> */ **** </lalLaTeX> */
/* #define KEEP_OLD_COMPLEX_FFT */ /*
*
* XLAL COMPLEX8 functions
*
*/
COMPLEX8FFTPlan * XLALCreateCOMPLEX8FFTPlan( UINT4 size, int fwdflg, int me
asurelvl );
COMPLEX8FFTPlan * XLALCreateForwardCOMPLEX8FFTPlan( UINT4 size, int measure
lvl );
COMPLEX8FFTPlan * XLALCreateReverseCOMPLEX8FFTPlan( UINT4 size, int measure
lvl );
void XLALDestroyCOMPLEX8FFTPlan( COMPLEX8FFTPlan *plan );
int XLALCOMPLEX8VectorFFT( COMPLEX8Vector *output, COMPLEX8Vector *input,
COMPLEX8FFTPlan *plan );
/*
*
* XLAL COMPLEX16 functions
*
*/
COMPLEX16FFTPlan * XLALCreateCOMPLEX16FFTPlan( UINT4 size, int fwdflg, int
measurelvl );
COMPLEX16FFTPlan * XLALCreateForwardCOMPLEX16FFTPlan( UINT4 size, int measu
relvl );
COMPLEX16FFTPlan * XLALCreateReverseCOMPLEX16FFTPlan( UINT4 size, int measu
relvl );
void XLALDestroyCOMPLEX16FFTPlan( COMPLEX16FFTPlan *plan );
int XLALCOMPLEX16VectorFFT( COMPLEX16Vector *output, COMPLEX16Vector *input
,
COMPLEX16FFTPlan *plan );
/*
*
* LAL COMPLEX8 functions
*
*/
void void
LALCreateForwardComplexFFTPlan( LALCreateForwardCOMPLEX8FFTPlan(
LALStatus *status, LALStatus *status,
ComplexFFTPlan **plan, COMPLEX8FFTPlan **plan,
UINT4 size, UINT4 size,
INT4 measure INT4 measure
); );
#define LALCreateForwardComplexFFTPlan LALCreateForwardCOMPLEX8FFTPlan
void void
LALCreateReverseComplexFFTPlan( LALCreateReverseCOMPLEX8FFTPlan(
LALStatus *status, LALStatus *status,
ComplexFFTPlan **plan, COMPLEX8FFTPlan **plan,
UINT4 size, UINT4 size,
INT4 measure INT4 measure
); );
#define LALCreateReverseComplexFFTPlan LALCreateReverseCOMPLEX8FFTPlan
void void
LALDestroyComplexFFTPlan ( LALDestroyCOMPLEX8FFTPlan (
LALStatus *status, LALStatus *status,
ComplexFFTPlan **plan COMPLEX8FFTPlan **plan
); );
#define LALDestroyComplexFFTPlan LALDestroyCOMPLEX8FFTPlan
void void
LALCOMPLEX8VectorFFT ( LALCOMPLEX8VectorFFT (
LALStatus *status, LALStatus *status,
COMPLEX8Vector *output, COMPLEX8Vector *output,
COMPLEX8Vector *input, COMPLEX8Vector *input,
ComplexFFTPlan *plan COMPLEX8FFTPlan *plan
); );
#ifdef KEEP_OLD_FFT /*
#define KEEP_OLD_COMPLEX_FFT *
#endif * LAL COMPLEX8 functions
*
#ifdef KEEP_OLD_COMPLEX_FFT */
void void
LALEstimateFwdComplexFFTPlan ( LALCreateForwardCOMPLEX16FFTPlan(
LALStatus *stat, LALStatus *status,
ComplexFFTPlan **plan, COMPLEX16FFTPlan **plan,
UINT4 size UINT4 size,
INT4 measure
); );
void void
LALEstimateInvComplexFFTPlan ( LALCreateReverseCOMPLEX16FFTPlan(
LALStatus *stat, LALStatus *status,
ComplexFFTPlan **plan, COMPLEX16FFTPlan **plan,
UINT4 size UINT4 size,
INT4 measure
); );
void void
LALMeasureFwdComplexFFTPlan ( LALDestroyCOMPLEX16FFTPlan (
LALStatus *stat, LALStatus *status,
ComplexFFTPlan **plan, COMPLEX16FFTPlan **plan
UINT4 size
); );
void void
LALMeasureInvComplexFFTPlan ( LALCOMPLEX16VectorFFT (
LALStatus *stat, LALStatus *status,
ComplexFFTPlan **plan, COMPLEX16Vector *output,
UINT4 size COMPLEX16Vector *input,
COMPLEX16FFTPlan *plan
); );
#endif /* KEEP_OLD_COMPLEX_FFT */
#ifdef __cplusplus #ifdef __cplusplus
#pragma { #pragma {
} }
#endif #endif
#endif /* _COMPLEXFFT_H */ #endif /* _COMPLEXFFT_H */
 End of changes. 22 change blocks. 
34 lines changed or deleted 81 lines changed or added


 ComputeSky.h   ComputeSky.h 
/************************************ <lalVerbatim file="ComputeSkyHV"> /************************************ <lalVerbatim file="ComputeSkyHV">
Author: Berukoff, S.J., Papa, M.A. Author: Berukoff, S.J., Papa, M.A.
$Id: ComputeSky.h,v 1.8 2002/05/13 16:06:28 sberukoff Exp $ $Id: ComputeSky.h,v 1.9 2005/06/17 20:14:52 jolien Exp $
************************************* </lalVerbatim> */ ************************************* </lalVerbatim> */
/* <lalLaTeX> /* <lalLaTeX>
\section{Header \texttt{ComputeSky.h}} \section{Header \texttt{ComputeSky.h}}
\label{s:ComputeSky.h} \label{s:ComputeSky.h}
Computes phase coefficients necessary for a correct demodulation. Computes phase coefficients necessary for a correct demodulation.
\subsection*{Synopsis} \subsection*{Synopsis}
\begin{verbatim} \begin{verbatim}
#include <lal/ComputeSky.h> #include <lal/ComputeSky.h>
skipping to change at line 155 skipping to change at line 155
EarthState *earth; EarthState *earth;
EphemerisData *edat; EphemerisData *edat;
} }
CSParams; CSParams;
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{ComputeSkyHV} \newpage\input{ComputeSkyHV}
\newpage\input{ComputeSkyC} \newpage\input{ComputeSkyC}
</lalLaTeX> */ </lalLaTeX> */
void ComputeSky (LALStatus *status, void LALComputeSky (LALStatus *status,
REAL8 *skyConst, REAL8 *skyConst,
INT8 iSkyCoh, INT8 iSkyCoh,
CSParams *params); CSParams *params);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _COMPUTESKY_H */ #endif /* _COMPUTESKY_H */
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added


 DataBuffer.h   DataBuffer.h 
#if 0 /* autodoc block */ #if 0 /* autodoc block */
<lalVerbatim file="DataBufferHV"> <lalVerbatim file="DataBufferHV">
$Id: DataBuffer.h,v 1.9 2001/12/21 21:11:46 duncan Exp $ $Id: DataBuffer.h,v 1.10 2005/04/29 13:46:03 patrick Exp $
</lalVerbatim> </lalVerbatim>
<lalLaTeX> <lalLaTeX>
\section{Header \texttt{DataBuffer.h}} \section{Header \texttt{DataBuffer.h}}
\label{s:DataBuffer.h} \label{s:DataBuffer.h}
Root finding routines. Root finding routines.
\subsection*{Synopsis} \subsection*{Synopsis}
skipping to change at line 37 skipping to change at line 37
#define _DATABUFFER_H #define _DATABUFFER_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/FrameData.h> #include <lal/FrameData.h>
#include <lal/SpecBuffer.h> #include <lal/SpecBuffer.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (DATABUFFERH, "$Id: DataBuffer.h,v 1.9 2001/12/21 21:11:46 duncan Ex p $"); NRCSID (DATABUFFERH, "$Id: DataBuffer.h,v 1.10 2005/04/29 13:46:03 patrick Exp $");
#if 0 /* autodoc block */ #if 0 /* autodoc block */
<lalLaTeX> <lalLaTeX>
\subsection*{Error conditions} \subsection*{Error conditions}
\input{DataBufferHErrTab} \input{DataBufferHErrTab}
</lalLaTeX> </lalLaTeX>
<lalErrTable file="DataBufferHErrTab"> <lalErrTable file="DataBufferHErrTab">
skipping to change at line 76 skipping to change at line 76
\subsection*{Structures} \subsection*{Structures}
\begin{verbatim} \begin{verbatim}
typedef struct typedef struct
tagDataSegment tagDataSegment
{ {
REAL4TimeSeries *chan; REAL4TimeSeries *chan;
REAL4FrequencySeries *spec; REAL4FrequencySeries *spec;
COMPLEX8FrequencySeries *resp; COMPLEX8FrequencySeries *resp;
INT4 number; INT4 number;
UINT4 analyzeSegment;
} }
DataSegment; DataSegment;
\end{verbatim} \end{verbatim}
%\begin{verbatim} %\begin{verbatim}
%typedef struct %typedef struct
%tagDataSegment %tagDataSegment
%{ %{
% INT2TimeSeries *data; % INT2TimeSeries *data;
% REAL4FrequencySeries *spec; % REAL4FrequencySeries *spec;
skipping to change at line 220 skipping to change at line 221
} }
DataBufferPar; DataBufferPar;
typedef struct typedef struct
tagDataSegment tagDataSegment
{ {
REAL4TimeSeries *chan; REAL4TimeSeries *chan;
REAL4FrequencySeries *spec; REAL4FrequencySeries *spec;
COMPLEX8FrequencySeries *resp; COMPLEX8FrequencySeries *resp;
INT4 number; INT4 number;
UINT4 analyzeSegment;
} }
DataSegment; DataSegment;
#if 0 #if 0
/* this is the old data segment structure */ /* this is the old data segment structure */
typedef struct typedef struct
tagDataSegment tagDataSegment
{ {
INT2TimeSeries *data; INT2TimeSeries *data;
REAL4TimeSeries *real4Data; REAL4TimeSeries *real4Data;
 End of changes. 4 change blocks. 
2 lines changed or deleted 4 lines changed or added


 Date.h   Date.h 
/** \file
* \ingroup std
* \author Chin, D. W. and Creighton, J. D. E.
* \brief Routines for converting between various time representations.
*
*/
/* <lalVerbatim file="DateHV"> /* <lalVerbatim file="DateHV">
Author: David Chin <dwchin@umich.edu> +1-734-730-1274 Author: David Chin <dwchin@umich.edu> +1-734-709-9119
$Id: Date.h,v 1.36 2002/05/13 21:06:05 dwchin Exp $ $Id: Date.h,v 1.57 2005/08/30 21:32:40 jolien Exp $
</lalVerbatim> */ </lalVerbatim> */
/* <lalLaTeX> /* <lalLaTeX>
\section{Header \texttt{Date.h}} \section{Header \texttt{Date.h}}
\label{s:Date.h} \label{s:Date.h}
Provides routines for manipulating date and time information. Provides routines for manipulating date and time information.
skipping to change at line 67 skipping to change at line 73
#include <lal/LALStatusMacros.h> #include <lal/LALStatusMacros.h>
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/DetectorSite.h> #include <lal/DetectorSite.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
{ {
#endif #endif
NRCSID (DATEH, "$Id: Date.h,v 1.36 2002/05/13 21:06:05 dwchin Exp $"); NRCSID (DATEH, "$Id: Date.h,v 1.57 2005/08/30 21:32:40 jolien Exp $");
/* <lalLaTeX> /* <lalLaTeX>
\subsection*{Error conditions} \subsection*{Error conditions}
</lalLaTeX> */ </lalLaTeX> */
/* <lalErrTable> */ /* <lalErrTable> */
#define DATEH_ENULLINPUT 1 #define DATEH_ENULLINPUT 1
#define DATEH_ENULLOUTPUT 2 #define DATEH_ENULLOUTPUT 2
#define DATEH_EDATETOOEARLY 3 #define DATEH_EDATETOOEARLY 3
#define DATEH_ERANGEGPSABS 4 #define DATEH_ERANGEGPSABS 4
#define DATEH_EBUFFTOOSMALL 5 #define DATEH_EBUFFTOOSMALL 5
#define DATEH_EASCTIMEFAIL 6 #define DATEH_EASCTIMEFAIL 6
#define DATEH_EGPSDATETOOEARLY 7 #define DATEH_EGPSDATETOOEARLY 7
#define DATEH_EFORMATPARAMOUTOFRANGE 8 #define DATEH_EFORMATPARAMOUTOFRANGE 8
#define DATEH_EACCPARAMOUTOFRANGE 9 #define DATEH_EACCPARAMOUTOFRANGE 9
#define DATEH_EDECRTIMETOOLARGE 10
#define DATEH_MSGENULLINPUT "Input is NULL" #define DATEH_MSGENULLINPUT "Input is NULL"
#define DATEH_MSGENULLOUTPUT "Output is NULL" #define DATEH_MSGENULLOUTPUT "Output is NULL"
#define DATEH_MSGEDATETOOEARLY "Date too early: Julian Day can only be comp uted for dates >= 1900-03-01" #define DATEH_MSGEDATETOOEARLY "Date too early: Julian Day can only be comp uted for dates >= 1900-03-01"
#define DATEH_MSGERANGEGPSABS "Input time out of range: only able to accura /* UPDATEME */
tely convert times between 1980-Jan-06 00:00:00 UTC (GPS 0) and 2002-Sep-30 #define DATEH_MSGERANGEGPSABS "Input time out of range: only able to accura
23:59:00 UTC (GPS 717465553)" tely convert times between 1980-Jan-06 00:00:00 UTC (GPS 0) and 2006-Jun-30
23:59:59 UTC (GPS 835747212)"
#define DATEH_MSGEBUFFTOOSMALL "Output timestamp string too small: min. siz e = 26" #define DATEH_MSGEBUFFTOOSMALL "Output timestamp string too small: min. siz e = 26"
#define DATEH_MSGEASCTIMEFAIL "asctimeUNDERSCOREr() failed" #define DATEH_MSGEASCTIMEFAIL "asctimeUNDERSCOREr() failed"
#define DATEH_MSGEGPSDATETOOEARLY "Date too early: GPS time only defined fo r times on or after 1980-Jan-06 00:00:00 UTC" #define DATEH_MSGEGPSDATETOOEARLY "Date too early: GPS time only defined fo r times on or after 1980-Jan-06 00:00:00 UTC"
#define DATEH_MSGEFORMATPARAMOUTOFRANGE "Format parameter out of range: mus t be one of LALLEAPSECunderscoreTAIUTC or LALLEAPSECunderscoreGPSUTC" #define DATEH_MSGEFORMATPARAMOUTOFRANGE "Format parameter out of range: mus t be one of LALLEAPSECunderscoreTAIUTC or LALLEAPSECunderscoreGPSUTC"
#define DATEH_MSGEACCPARAMOUTOFRANGE "Accuracy parameter out of range: must be one of LALLEAPSECunderscoreSTRICT or LALLEAPSECunderscoreLOOSE" #define DATEH_MSGEACCPARAMOUTOFRANGE "Accuracy parameter out of range: must be one of LALLEAPSECunderscoreSTRICT or LALLEAPSECunderscoreLOOSE"
#define DATEH_MSGEDECRTIMETOOLARGE "Decrement amount too large: GPS time ca
nnot be decremented to before the start of the GPS epoch."
/* </lalErrTable> */
/** The UNIX time of the GPS origin epoch.
*
* 1980 6 JAN 0h UTC is 3657 days after 1970 1 JAN 0h UTC:
* 8 standard years of 365 days = 2920 days
* 2 leap years of 366 days = 734 days
* 5 extra days.
* Hence 3657*86400=315964800.
*
* Note that this deliberately does not account for any leap seconds in the
* interval. POSIX:2001 defines the relation between the UNIX time
* \c time_t \c t and a broken down time \c struct \c tm \c utc as
* \code
* t = utc.tm_sec + utc.tm_min*60 + utc.tm_hour*3600
* + utc.tm_yday*86400 + (utc.tm_year-70)*31536000
* + ((utc.tm_year-69)/4)*86400 - ((utc.tm_year-1)/100)*86400
* + ((utc.tm_year+299)/400)*86400;
* \endcode
* so if you were to set \c utc.tm_sec=utc.tm_min=utc.tm_hour=0,
* \c utc.tm_yday=5, and \c utc.tm_year=80, then you get
* \c t=315964800. That is what this is.
*/
#define XLAL_EPOCH_UNIX_GPS 315964800
#define XLAL_EPOCH_J2000_0_JD 2451545.0 /**< Julian Day of the J2000.0 epoc
h (2000 JAN 1 12h UTC). */
#define XLAL_EPOCH_J2000_0_TAI_UTC 32 /**< Leap seconds (TAI-UTC) on the J2
000.0 epoch (2000 JAN 1 12h UTC). */
#define XLAL_EPOCH_J2000_0_GPS 630763213 /**< GPS seconds of the J2000.0 ep
och (2000 JAN 1 12h UTC). */
#define XLAL_EPOCH_GPS_JD 2444244.5 /**< Julian Day of the GPS epoch (1980
JAN 6 0h UTC) */
#define XLAL_EPOCH_GPS_TAI_UTC 19 /**< Leap seconds (TAI-UTC) on the GPS ep
och (1980 JAN 6 0h UTC) */
#define XLAL_MJD_REF 2400000.5 /**< Reference Julian Day for Mean Julian Da
y. */
#define XLAL_MODIFIED_JULIEN_DAY(utc) (XLALJulianDay(utc)-XLAL_MJD_REF) /**
< Modified Julian Day for specified civil time structure. */
/** Converts GPS time to nano seconds stored as an INT8. */
INT8 XLALGPSToINT8NS( const LIGOTimeGPS *epoch );
/** Converts nano seconds stored as an INT8 to GPS time. */
LIGOTimeGPS * XLALINT8NSToGPS( LIGOTimeGPS *epoch, INT8 ns );
/** Sets GPS time given GPS integer seconds and residual nanoseconds. */
LIGOTimeGPS * XLALGPSSet( LIGOTimeGPS *epoch, INT4 gpssec, INT4 gpsnan );
/** Sets GPS time given GPS seconds as a REAL8. */
LIGOTimeGPS * XLALGPSSetREAL8( LIGOTimeGPS *epoch, REAL8 t );
/** Adds dt to a GPS time. */
LIGOTimeGPS * XLALGPSAdd( LIGOTimeGPS *epoch, REAL8 dt );
/** Difference between two GPS times. */
REAL8 XLALGPSDiff( const LIGOTimeGPS *t0, const LIGOTimeGPS *t1 );
/** Compares two GPS times.
* Returns:
* - -1 if t0 < t1
* - 0 if t0 == t1
* - 1 if t0 > t1.
*/
int XLALGPSCmp( const LIGOTimeGPS *t0, const LIGOTimeGPS *t1 );
/** Returns the leap seconds TAI-UTC at a given GPS second. */
int XLALLeapSeconds( INT4 gpssec /**< [In] Seconds relative to GPS epoch.*/
);
/** Returns the leap seconds TAI-UTC for a given UTC broken down time. */
int XLALLeapSecondsUTC( const struct tm *utc /**< [In] UTC as a broken down
time.*/ );
/** Returns the GPS seconds since the GPS epoch for a
* specified UTC time structure. */
INT4 XLALUTCToGPS( const struct tm *utc /**< [In] UTC time in a broken down
time structure. */ );
/** Returns a pointer to a tm structure representing the time
* specified in seconds since the GPS epoch. */
struct tm * XLALGPSToUTC(
struct tm *utc, /**< [Out] Pointer to tm struct where result is stored.
*/
INT4 gpssec /**< [In] Seconds since the GPS epoch. */
);
/** Returns the Julian Day (JD) corresponding to the date given in a broken
* down time structure. */
REAL8 XLALJulianDay( const struct tm *utc /**< [In] UTC time in a broken do
wn time structure. */ );
/** Returns the Modified Julian Day (MJD) corresponding to the date given
* in a broken down time structure.
*
* Note:
* - By convention, MJD is an integer.
* - MJD number starts at midnight rather than noon.
*
* If you want a Modified Julian Day that has a fractional part, simply use
* the macro:
*
* #define XLAL_MODIFIED_JULIAN_DAY(utc) (XLALJulianDay(utc)-XLAL_MJD_REF)
*/
INT4 XLALModifiedJulianDay( const struct tm *utc /**< [In] UTC time in a br
oken down time structure. */ );
/* </lalErrTable> /** Returns the Greenwich Mean Sidereal Time in RADIANS for a specified GPS
* epoch. */
REAL8 XLALGreenwichMeanSiderealTime(
const LIGOTimeGPS *epoch /**< [In] GPS time. */
);
<lalLaTeX> /* <lalLaTeX>
\subsection*{Structures} \subsection*{Structures}
</lalLaTeX> */ </lalLaTeX> */
/* <lalLaTeX> /* <lalLaTeX>
\vfill{\footnotesize\input{DateHV}} \vfill{\footnotesize\input{DateHV}}
</lalLaTeX> */ </lalLaTeX> */
skipping to change at line 139 skipping to change at line 245
typedef enum typedef enum
{ {
MST_SEC, /* arc seconds */ MST_SEC, /* arc seconds */
MST_HRS, /* arc hours (i.e. units of Right Ascension) */ MST_HRS, /* arc hours (i.e. units of Right Ascension) */
MST_DEG, /* degrees */ MST_DEG, /* degrees */
MST_RAD /* radians */ MST_RAD /* radians */
} LALMSTUnits; } LALMSTUnits;
/* <lalLaTeX> /* <lalLaTeX>
\subsubsection*{Enumeration \texttt{LALMonth}}
\idx[Type]{LALMonth}
This enumerated type is used to define mnemonic symbols for the
\texttt{LALUnixDate} month field (\texttt{tm\_mon}). The allowed values are
:
\medskip\noindent
\begin{tabular}{ll}
\verb+LALMONTH_JAN+ & January \\
\verb+LALMONTH_FEB+ & February \\
\verb+LALMONTH_MAR+ & March \\
\verb+LALMONTH_APR+ & April \\
\verb+LALMONTH_MAY+ & May \\
\verb+LALMONTH_JUN+ & June \\
\verb+LALMONTH_JUL+ & July \\
\verb+LALMONTH_AUG+ & August \\
\verb+LALMONTH_SEP+ & September \\
\verb+LALMONTH_OCT+ & October \\
\verb+LALMONTH_NOV+ & November \\
\verb+LALMONTH_DEC+ & December
\end{tabular}
\bigskip
</lalLaTeX> */
typedef enum
{
LALMONTH_JAN = 0,
LALMONTH_FEB = 1,
LALMONTH_MAR = 2,
LALMONTH_APR = 3,
LALMONTH_MAY = 4,
LALMONTH_JUN = 5,
LALMONTH_JUL = 6,
LALMONTH_AUG = 7,
LALMONTH_SEP = 8,
LALMONTH_OCT = 9,
LALMONTH_NOV = 10,
LALMONTH_DEC = 11
} LALMonth;
/* <lalLaTeX>
\subsubsection*{Enumeration \texttt{LALLeapSecAccuracy}} \subsubsection*{Enumeration \texttt{LALLeapSecAccuracy}}
\idx[Type]{LALLeapSecAccuracy} \idx[Type]{LALLeapSecAccuracy}
This enumerated type is used as a parameter for \texttt{LALGPStoUTC()}, This enumerated type is used as a parameter for \texttt{LALGPStoUTC()},
\texttt{LALUTCtoGPS()}, and \texttt{LALLeapSecs()} to specify if complete \texttt{LALUTCtoGPS()}, and \texttt{LALLeapSecs()} to specify if complete
accuracy is required in use of leap seconds. The allowed values are: accuracy is required in use of leap seconds. The allowed values are:
\medskip\noindent \medskip\noindent
\begin{tabular}{ll} \begin{tabular}{ll}
\verb+LALLEAPSEC_LOOSE+ & may miss leap seconds \\ \verb+LALLEAPSEC_LOOSE+ & may miss leap seconds \\
skipping to change at line 165 skipping to change at line 313
will continue execution. will continue execution.
</lalLaTeX> */ </lalLaTeX> */
typedef enum typedef enum
{ {
LALLEAPSEC_LOOSE, LALLEAPSEC_LOOSE,
LALLEAPSEC_STRICT LALLEAPSEC_STRICT
} LALLeapSecAccuracy; } LALLeapSecAccuracy;
/* <lalLaTeX> /* <lalLaTeX>
\subsubsection*{Enumeration \texttt{LALGPSCompareResult}}
\idx[Type]{LALGPSCompareResult}
This enumerated type is used as the output type for
\texttt{LALCompareGPS()}. The allowed values are:
\medskip\noindent
\begin{tabular}{ll}
\verb+LALGPS_EARLIER+ & GPS1 < GPS2 \\
\verb+LALGPS_EQUAL+ & GPS1 = GPS2 \\
\verb+LALGPS_LATER+ & GPS1 > GPS2
\end{tabular}
\bigskip
</lalLaTeX> */
typedef enum
{
LALGPS_EARLIER = -1,
LALGPS_EQUAL = 0,
LALGPS_LATER = 1
} LALGPSCompareResult;
/* <lalLaTeX>
\subsubsection*{Enumeration \texttt{LALLeapSecFormat}} \subsubsection*{Enumeration \texttt{LALLeapSecFormat}}
\idx[Type]{LALLeapSecFormat} \idx[Type]{LALLeapSecFormat}
This enumerated type is used as a parameter for \texttt{LALLeapSecs()} to This enumerated type is used as a parameter for \texttt{LALLeapSecs()} to
specify whether TAI-UTC or GPS-UTC should be returned. TAI-UTC is the specify whether TAI-UTC or GPS-UTC should be returned. TAI-UTC is the
total number of leap seconds added to UTC since the TAI epoch. GPS-UTC is total number of leap seconds added to UTC since the TAI epoch. GPS-UTC is
the total number of leap seconds added since the GPS epoch. These two the total number of leap seconds added since the GPS epoch. These two
quantities are related by: TAI-UTC = GPS-UTC + 19. quantities are related by: TAI-UTC = GPS-UTC + 19.
skipping to change at line 195 skipping to change at line 365
{ {
LALLEAPSEC_TAIUTC, LALLEAPSEC_TAIUTC,
LALLEAPSEC_GPSUTC LALLEAPSEC_GPSUTC
} LALLeapSecFormat; } LALLeapSecFormat;
/* <lalLaTeX> /* <lalLaTeX>
\subsubsection*{Structure \texttt{LALUnixDate}} \subsubsection*{Structure \texttt{LALUnixDate}}
\idx[Type]{LALUnixDate} \idx[Type]{LALUnixDate}
This structure is just the standard Unix \texttt{tm} structure. We shall This structure is just the standard Unix \texttt{tm} structure, described
in the man page for \texttt{ctime(3)}. We shall
{\em always} ignore the daylight savings time field, \verb+tm_isdst+. {\em always} ignore the daylight savings time field, \verb+tm_isdst+.
</lalLaTeX> */ </lalLaTeX> */
/* /*
* The standard Unix tm structure * The standard Unix tm structure
*/ */
typedef struct typedef struct
tm tm
LALUnixDate; LALUnixDate;
skipping to change at line 217 skipping to change at line 388
/* <lalLaTeX> /* <lalLaTeX>
\subsubsection{Structure \texttt{LALTimeInterval}} \subsubsection{Structure \texttt{LALTimeInterval}}
\idx[Type]{LALTimeInterval} \idx[Type]{LALTimeInterval}
This structure is used for storing intervals of \texttt{LIGOTimeGPS} This structure is used for storing intervals of \texttt{LIGOTimeGPS}
and \texttt{LIGOTimeUnix} times. The fields are: and \texttt{LIGOTimeUnix} times. The fields are:
\begin{description} \begin{description}
\item{\texttt{INT4 seconds}} Integral part of the time interval \item{\texttt{INT4 seconds}} Integral part of the time interval
\item{\texttt{INT8 nanoSeconds}} Residual nanoseconds (\textit{i.e.} \item{\texttt{INT4 nanoSeconds}} Residual nanoseconds (\textit{i.e.}
fractional part, in nanoseconds) fractional part, in nanoseconds)
\end{description} \end{description}
</lalLaTeX> */ </lalLaTeX> */
/* /*
* This time object is for time intervals, i.e. no reference epoch implied * This time object is for time intervals, i.e. no reference epoch implied
*/ */
typedef struct typedef struct
tagLALTimeInterval tagLALTimeInterval
{ {
INT4 seconds; INT4 seconds;
INT8 nanoSeconds; INT4 nanoSeconds;
} }
LALTimeInterval; LALTimeInterval;
/* <lalLaTeX> /* <lalLaTeX>
\subsubsection{Structure \texttt{LALDate}} \subsubsection{Structure \texttt{LALDate}}
\idx[Type]{LALDate} \idx[Type]{LALDate}
This structure is an extension of \texttt{LALUnixDate} to include residual This structure is an extension of \texttt{LALUnixDate} to include residual
nanosecond information. The fields are: nanosecond information. The fields are:
skipping to change at line 337 skipping to change at line 508
</lalLaTeX> */ </lalLaTeX> */
typedef struct typedef struct
tagLALLeapSecFormatAndAcc tagLALLeapSecFormatAndAcc
{ {
LALLeapSecFormat format; LALLeapSecFormat format;
LALLeapSecAccuracy accuracy; LALLeapSecAccuracy accuracy;
} }
LALLeapSecFormatAndAcc; LALLeapSecFormatAndAcc;
/* <lalLaTeX>
\subsubsection{Structure \texttt{LALMSTUnitsAndAcc}}
\index[Type]{LALMSTUnitsAndAcc}
This structure aggregates the \texttt{LALMSTUnits} and
\texttt{LALLeapSecAccuracy} parameters for passing to
\texttt{LALGPStoGMST1()} and \texttt{LALGPStoLMST1()}.
</lalLaTeX> */
typedef struct
tagLALMSTUnitsAndAcc
{
LALMSTUnits units;
LALLeapSecAccuracy accuracy;
}
LALMSTUnitsAndAcc;
/* /*
* Function prototypes * Function prototypes
*/ */
int XLALStrToGPS(LIGOTimeGPS *epoch, const char *nptr, char **endptr);
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{JulianC} \newpage\input{JulianC}
</lalLaTeX> */ </lalLaTeX> */
void LALJulianDay(LALStatus *status, void LALJulianDay(LALStatus *status,
INT4 *jDay, INT4 *jDay,
const LALDate *date); const LALDate *date);
void LALJulianDate (LALStatus *status, void LALJulianDate (LALStatus *status,
REAL8 *jDateOut, REAL8 *jDateOut,
skipping to change at line 377 skipping to change at line 566
</lalLaTeX> */ </lalLaTeX> */
void LALGMST1 (LALStatus *status, void LALGMST1 (LALStatus *status,
REAL8 *gmst, /* output - GMST1 */ REAL8 *gmst, /* output - GMST1 */
const LALDate *date, /* input - date and time */ const LALDate *date, /* input - date and time */
LALMSTUnits outunits); /* GMST1 units */ LALMSTUnits outunits); /* GMST1 units */
void LALGPStoGMST1( LALStatus *status, void LALGPStoGMST1( LALStatus *status,
REAL8 *gmst, /* output - GMST1 */ REAL8 *gmst, /* output - GMST1 */
const LIGOTimeGPS *gps, /* input - GPS time */ const LIGOTimeGPS *gps, /* input - GPS time */
LALMSTUnits outunits); /* GMST1 units */ const LALMSTUnitsAndAcc *pUnitsAndAcc); /* GMST1 units
and
leapsec accuracy */
void LALLMST1 (LALStatus *status, void LALLMST1 (LALStatus *status,
REAL8 *lmst, /* output - LMST1 */ REAL8 *lmst, /* output - LMST1 */
const LALPlaceAndDate *placeAndDate, /* input - location const LALPlaceAndDate *placeAndDate, /* input - location
and date */ and date */
LALMSTUnits outunits); /* LMST1 units */ LALMSTUnits outunits); /* LMST1 units */
void LALGPStoLMST1( LALStatus *status, void LALGPStoLMST1( LALStatus *status,
REAL8 *lmst, /* output - LMST1 * / REAL8 *lmst, /* output - LMST1 * /
const LALPlaceAndGPS *placeAndGps, /* input - location and const LALPlaceAndGPS *placeAndGps, /* input - location and
GPS */ GPS */
LALMSTUnits outunits); /* LMST1 units */ const LALMSTUnitsAndAcc *pUnitsAndAcc); /* LMST1
units
and leapsec
accuracy */
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{SecsToLALDateC} \newpage\input{SecsToLALDateC}
</lalLaTeX> */ </lalLaTeX> */
void LALSecsToLALDate(LALStatus *status, void LALSecsToLALDate(LALStatus *status,
LALDate *date, LALDate *date,
REAL8 ); REAL8 );
/* <lalLaTeX> /* <lalLaTeX>
skipping to change at line 428 skipping to change at line 620
const LALLeapSecFormatAndAcc *p_formatAndAcc); const LALLeapSecFormatAndAcc *p_formatAndAcc);
/* The following 2 functions are from S.J. Berukoff, included at his reques t */ /* The following 2 functions are from S.J. Berukoff, included at his reques t */
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{GPStoFloatC} \newpage\input{GPStoFloatC}
</lalLaTeX> */ </lalLaTeX> */
void LALGPStoFloat (LALStatus *status, void LALGPStoFloat (LALStatus *status,
REAL8 *output, REAL8 *output,
const LIGOTimeGPS *input); const LIGOTimeGPS *input);
void XLALFloatToGPS(LIGOTimeGPS *output,
const REAL8 input);
void LALFloatToGPS(LALStatus *status, void LALFloatToGPS(LALStatus *status,
LIGOTimeGPS *output, LIGOTimeGPS *output,
const REAL8 *input); const REAL8 *input);
void LALFloatToInterval(LALStatus *status,
LALTimeInterval *pInterval,
const REAL8 *pDeltaT);
void LALIntervalToFloat(LALStatus *status,
REAL8 *pDeltaT,
const LALTimeInterval *pInterval);
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{GPStoINT8C} \newpage\input{GPStoINT8C}
</lalLaTeX> */ </lalLaTeX> */
LIGOTimeGPS *
XLALINT8toGPS (
LIGOTimeGPS *output,
INT8 input
);
void void
LALINT8toGPS ( LALINT8toGPS (
LALStatus *status, LALStatus *status,
LIGOTimeGPS *output, LIGOTimeGPS *output,
const INT8 *input const INT8 *input
); );
INT8
XLALGPStoINT8 (
const LIGOTimeGPS *input
);
void void
LALGPStoINT8 ( LALGPStoINT8 (
LALStatus *status, LALStatus *status,
INT8 *output, INT8 *output,
const LIGOTimeGPS *input const LIGOTimeGPS *input
); );
/* This next function is to facilitate writing loops that increment time
* by a time interval */
/* <lalLaTeX>
\newpage\input{IncrementGPSC}
</lalLaTeX> */
void
LALIncrementGPS (LALStatus *status,
LIGOTimeGPS *pIncrementedGPS,
const LIGOTimeGPS *pInitialGPS,
const LALTimeInterval *pDeltaT);
void
LALDecrementGPS (LALStatus *status,
LIGOTimeGPS *pDecrementedGPS,
const LIGOTimeGPS *pInitialGPS,
const LALTimeInterval *pDeltaT);
/* This function takes the difference between two GPS times, GPS1 - GPS2 */
void
LALDeltaGPS (LALStatus *status,
LALTimeInterval *pDeltaGPS, /* output: GPS1 - GPS2*/
const LIGOTimeGPS *pGPS1, /* input: GPS1 */
const LIGOTimeGPS *pGPS2); /* input: GPS2 */
/* This function compares GPS1 to GPS2; returns 0 if GPS1 == GPS2,
returns -1 if GPS1 < GPS2, +1 if GPS1 > GPS2 */
void
LALCompareGPS (LALStatus *status,
LALGPSCompareResult *pResult, /* output: -1 => GPS1 < GPS2
0 => GPS1 = GPS2
1 => GPS1 > GPS2 *
/
const LIGOTimeGPS *pGPS1, /* input: GPS1 */
const LIGOTimeGPS *pGPS2); /* input: GPS2 */
LIGOTimeGPS *
XLALAddFloatToGPS(
LIGOTimeGPS *gps,
REAL8 deltaT
);
void
LALAddFloatToGPS (LALStatus *status,
LIGOTimeGPS *outputGPS, /* outputGPS = start
GPS + deltaT */
const LIGOTimeGPS *startGPS, /* input: GPS time *
/
REAL8 deltaT); /* input: interval t
o increment by in seconds*/
REAL8
XLALDeltaFloatGPS(
const LIGOTimeGPS *GPS1,
const LIGOTimeGPS *GPS2
);
void
LALDeltaFloatGPS (LALStatus *status,
REAL8 *deltaT, /* tGPS1 - tGPS2 */
const LIGOTimeGPS *tGPS1, /* input: tGPS1 */
const LIGOTimeGPS *tGPS2);
/* This function returns the current GPS time according to the system clock
*/
/* <lalLaTeX>
\newpage\input{GPSTimeNowC}
</lalLaTeX> */
void
LALGPSTimeNow (
LALStatus *status,
LIGOTimeGPS *gpstime,
const LALLeapSecAccuracy *accuracy
);
/* <lalLaTeX>
\newpage\input{PlaygroundC}
</lalLaTeX> */
void
LALINT8NanoSecIsPlayground (
LALStatus *status,
INT4 *playground,
INT8 *ns
);
void
LALGPSIsPlayground (
LALStatus *status,
INT4 *playground,
LIGOTimeGPS *gpstime
);
void
LALSegmentIsPlayground (
LALStatus *status,
INT4 *playground,
LIGOTimeGPS *gpsStart,
LIGOTimeGPS *gpsEnd
);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _DATE_H */ #endif /* _DATE_H */
 End of changes. 22 change blocks. 
13 lines changed or deleted 343 lines changed or added


 DetResponse.h   DetResponse.h 
/* <lalVerbatim file="DetResponseHV"> /* <lalVerbatim file="DetResponseHV">
Author: David Chin <dwchin@umich.edu> +1-734-730-1274 Author: David Chin <dwchin@umich.edu> +1-734-709-9119
$Id: DetResponse.h,v 1.5 2002/06/07 01:57:10 dwchin Exp $ $Id: DetResponse.h,v 1.8 2003/08/14 15:08:36 dwchin Exp $
</lalVerbatim>*/ </lalVerbatim>*/
/* /*
<lalLaTeX> <lalLaTeX>
\section{Header \texttt{DetResponse.h}} \section{Header \texttt{DetResponse.h}}
\label{sec:DetResponse.h} \label{sec:DetResponse.h}
Provides routines to compute gravitational wave detector response to Provides routines to compute gravitational wave detector response to
skipping to change at line 36 skipping to change at line 36
*/ */
#ifndef _DETRESPONSE_H #ifndef _DETRESPONSE_H
#define _DETRESPONSE_H #define _DETRESPONSE_H
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/LALStdio.h> #include <lal/LALStdio.h>
#include <lal/LALConstants.h> #include <lal/LALConstants.h>
#include <lal/DetectorSite.h> #include <lal/DetectorSite.h>
#include <lal/SkyCoordinates.h> #include <lal/SkyCoordinates.h>
#include <lal/Date.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
{ {
#endif #endif
NRCSID( DETRESPONSEH, "$Id: DetResponse.h,v 1.5 2002/06/07 01:57:10 dwchin Exp $" ); NRCSID( DETRESPONSEH, "$Id: DetResponse.h,v 1.8 2003/08/14 15:08:36 dwchin Exp $" );
/* /*
<lalLaTeX> <lalLaTeX>
\subsection*{Error conditions} \subsection*{Error conditions}
</lalLaTeX> </lalLaTeX>
*/ */
/* /*
<lalErrTable> <lalErrTable>
*/ */
skipping to change at line 197 skipping to change at line 198
\item[\texttt{REAL4TimeSeries *pCross}] Pointer to a \texttt{REAL4TimeSerie s} \item[\texttt{REAL4TimeSeries *pCross}] Pointer to a \texttt{REAL4TimeSerie s}
containing detector response to $\times$-polarized gravitational radiatio n containing detector response to $\times$-polarized gravitational radiatio n
over a span of time over a span of time
\item[\texttt{REAL4TimeSeries *pScalar}] Pointer to a \texttt{REAL4TimeSeri es} \item[\texttt{REAL4TimeSeries *pScalar}] Pointer to a \texttt{REAL4TimeSeri es}
containing detector response to scalar gravitational radiation containing detector response to scalar gravitational radiation
over a span of time. (NB: This is unused for the moment. Response to over a span of time. (NB: This is unused for the moment. Response to
scalar gravitational radiation is not yet implemented.) scalar gravitational radiation is not yet implemented.)
\end{description} \end{description}
</lalLaTeX> */ </lalLaTeX> */
/* I would like to use REAL4TimeSeries here, but the F's are dimensionless,
and there seems to be no provision for not providing units in the
LALUnit structure. I'll still call this a ``Series'' because that's
what it really is. */
typedef struct typedef struct
tagLALDetAMResponseSeries tagLALDetAMResponseSeries
{ {
REAL4TimeSeries *pPlus; REAL4TimeSeries *pPlus;
REAL4TimeSeries *pCross; REAL4TimeSeries *pCross;
REAL4TimeSeries *pScalar; REAL4TimeSeries *pScalar;
} }
LALDetAMResponseSeries; LALDetAMResponseSeries;
/* <lalLaTeX> /* <lalLaTeX>
\subsubsection*{Structure \texttt{LALGPSandAcc}}
\idx[Type]{LALGPSandAcc}
This structure aggregates GPS time and leap second accuracy requirement
for converting GPS time to sidereal time (implicitly used in
\texttt{LALComputeDetAMResponse()}).
\begin{description}
\item[\texttt{LIGOTimeGPS gps}] The GPS time
\item[\texttt{LALLeapSecAccuracy accuracy}] The accuracy parameter
\end{description}
</lalLaTeX> */
typedef struct
tagLALGPSandAcc
{
LIGOTimeGPS gps; /* GPS time */
LALLeapSecAccuracy accuracy; /* required accuracy in leap second
handling */
}
LALGPSandAcc;
/* <lalLaTeX>
\subsubsection*{Structure \texttt{LALTimeIntervalAndNSample}} \subsubsection*{Structure \texttt{LALTimeIntervalAndNSample}}
\idx[Type]{LALTimeIntervalAndNSample} \idx[Type]{LALTimeIntervalAndNSample}
This structure encapsulates time and sampling information for computing a This structure encapsulates time and sampling information for computing a
\texttt{LALDetAMResponseSeries}. Its fields correspond to some fields of th e \texttt{LALDetAMResponseSeries}. Its fields correspond to some fields of th e
\texttt{TimeSeries} structures for easy conversion. \texttt{TimeSeries} structures for easy conversion.
\begin{description} \begin{description}
\item[\texttt{LIGOTimeGPS epoch}] The start time $t_0$ of the time series \item[\texttt{LIGOTimeGPS epoch}] The start time $t_0$ of the time series
\item[\texttt{REAL8 deltaT}] The sampling interval $\Delta t$, in seconds \item[\texttt{REAL8 deltaT}] The sampling interval $\Delta t$, in seconds
\item[\texttt{UINT4 nSample}] The total number of samples to be computed \item[\texttt{UINT4 nSample}] The total number of samples to be computed
\item[\texttt{LALLeapSecAccuracy accuracy}] The required accuracy for handl ing leap seconds
\end{description} \end{description}
</lalLaTeX> */ </lalLaTeX> */
typedef struct typedef struct
tagLALTimeIntervalAndNSample tagLALTimeIntervalAndNSample
{ {
LIGOTimeGPS epoch; LIGOTimeGPS epoch;
REAL8 deltaT; /* sampling interval */ REAL8 deltaT; /* sampling interval */
UINT4 nSample; /* number of samples */ UINT4 nSample; /* number of samples */
LALLeapSecAccuracy accuracy; /* accuracy for handling leap-seconds */
} }
LALTimeIntervalAndNSample; LALTimeIntervalAndNSample;
/* /*
<lalLaTeX> <lalLaTeX>
\vfill{\footnotesize\input{DetResponseHV}} \vfill{\footnotesize\input{DetResponseHV}}
</lalLaTeX> </lalLaTeX>
*/ */
/* /*
skipping to change at line 255 skipping to change at line 277
/* /*
<lalLaTeX> <lalLaTeX>
\newpage\input{DetResponseC} \newpage\input{DetResponseC}
</lalLaTeX> </lalLaTeX>
*/ */
void void
LALComputeDetAMResponse( LALStatus *status, LALComputeDetAMResponse( LALStatus *status,
LALDetAMResponse *pResponse, LALDetAMResponse *pResponse,
const LALDetAndSource *pDetAndSrc, const LALDetAndSource *pDetAndSrc,
const LIGOTimeGPS *pGPS); const LALGPSandAcc *pGPSandAcc);
/* /*
* Gives a time series of the detector's response to plus and cross * Gives a time series of the detector's response to plus and cross
* polarization * polarization
*/ */
void void
LALComputeDetAMResponseSeries( LALStatus *status, LALComputeDetAMResponseSeries( LALStatus *status,
LALDetAMResponseSeries *pResponseSer ies, LALDetAMResponseSeries *pResponseSer ies,
const LALDetAndSource *pDetAndSourc e, const LALDetAndSource *pDetAndSourc e,
const LALTimeIntervalAndNSample *pTimeInfo); const LALTimeIntervalAndNSample *pTimeInfo);
 End of changes. 8 change blocks. 
8 lines changed or deleted 30 lines changed or added


 DetectorSite.h   DetectorSite.h 
/********************************* <lalVerbatim file="DetectorSiteHV"> /********************************* <lalVerbatim file="DetectorSiteHV">
Author: J. T. Whelan <whelan@oates.utb.edu> Author: J. T. Whelan <jtwhelan@loyno.edu>
$Id: DetectorSite.h,v 1.9 2002/08/02 23:01:24 whelan Exp $ $Id: DetectorSite.h,v 1.11 2003/04/16 21:17:13 whelan Exp $
********************************** </lalVerbatim> */ ********************************** </lalVerbatim> */
/********************************* <lalLaTeX> /********************************* <lalLaTeX>
\section{Header \texttt{DetectorSite.h}} \section{Header \texttt{DetectorSite.h}}
\label{tools:s:DetectorSite.h} \label{tools:s:DetectorSite.h}
This header defines structures to hold the basic data describing This header defines structures to hold the basic data describing
a gravitational wave detector. a gravitational wave detector.
skipping to change at line 144 skipping to change at line 144
#ifndef _DETECTORSITE_H #ifndef _DETECTORSITE_H
#define _DETECTORSITE_H #define _DETECTORSITE_H
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (DETECTORSITEH, "$Id: DetectorSite.h,v 1.9 2002/08/02 23:01:24 whela n Exp $"); NRCSID (DETECTORSITEH, "$Id: DetectorSite.h,v 1.11 2003/04/16 21:17:13 whel an Exp $");
/******************************** <lalErrTable file="DetectorSiteHE"> */ /******************************** <lalErrTable file="DetectorSiteHE"> */
#define DETECTORSITEH_ENULLP 1 #define DETECTORSITEH_ENULLP 1
#define DETECTORSITEH_ETYPE 2 #define DETECTORSITEH_ETYPE 2
#define DETECTORSITEH_MSGENULLP "Null pointer" #define DETECTORSITEH_MSGENULLP "Null pointer"
#define DETECTORSITEH_MSGETYPE "Unsupported detector type" #define DETECTORSITEH_MSGETYPE "Unsupported detector type"
/************************************ </lalErrTable> */ /************************************ </lalErrTable> */
skipping to change at line 290 skipping to change at line 290
\begin{description} \begin{description}
\item[\texttt{CHAR name[LALNameLength]}] A unique identifying string. \item[\texttt{CHAR name[LALNameLength]}] A unique identifying string.
\item[\texttt{REAL8 vertexLongitudeRadians}] The geodetic longitude \item[\texttt{REAL8 vertexLongitudeRadians}] The geodetic longitude
$\lambda$ of the vertex, in radians. $\lambda$ of the vertex, in radians.
\item[\texttt{REAL8 vertexLatitudeRadians}] The geodetic latitude \item[\texttt{REAL8 vertexLatitudeRadians}] The geodetic latitude
$\beta$ of the vertex, in radians. $\beta$ of the vertex, in radians.
\item[\texttt{REAL4 vertexElevation}] The height of the vertex above \item[\texttt{REAL4 vertexElevation}] The height of the vertex above
the reference ellipsoid, in meters. the reference ellipsoid, in meters.
\item[\texttt{REAL4 xArmAltitudeRadians}] The angle ${\mathcal{A}}_X$ up from the \item[\texttt{REAL4 xArmAltitudeRadians}] The angle ${\mathcal{A}}_X$ up from the
local tangent plane of the reference ellipsoid to the X arm, in radians. local tangent plane of the reference ellipsoid to the X arm, in radians.
\item[\texttt{REAL4 xArmAzimuthRadians}] The angle $\zeta_X$ counterclock \item[\texttt{REAL4 xArmAzimuthRadians}] The angle $\zeta_X$ clockwise
wise from North to the projection of the X arm into the local tangent plane of
from East to the projection of the X arm into the local tangent plane of
the reference ellipsoid, in radians. the reference ellipsoid, in radians.
\item[\texttt{REAL4 yArmAltitudeRadians}] The angle ${\mathcal{A}}_Y$ up from the \item[\texttt{REAL4 yArmAltitudeRadians}] The angle ${\mathcal{A}}_Y$ up from the
local tangent plane of the reference ellipsoid to the Y arm, in radians. local tangent plane of the reference ellipsoid to the Y arm, in radians.
\item[\texttt{REAL4 yArmAzimuthRadians}] The angle $\zeta_Y$ counterclock \item[\texttt{REAL4 yArmAzimuthRadians}] The angle $\zeta_Y$ clockwise
wise from North to the projection of the Y arm into the local tangent plane of
from East to the projection of the Y arm into the local tangent plane of
the reference ellipsoid, in radians. the reference ellipsoid, in radians.
\end{description} \end{description}
********************************** </lalLaTeX> */ ********************************** </lalLaTeX> */
typedef struct tagLALFrDetector typedef struct tagLALFrDetector
{ {
CHAR name[LALNameLength]; CHAR name[LALNameLength];
REAL8 vertexLongitudeRadians; REAL8 vertexLongitudeRadians;
REAL8 vertexLatitudeRadians; REAL8 vertexLatitudeRadians;
 End of changes. 4 change blocks. 
9 lines changed or deleted 7 lines changed or added


 EPSearch.h   EPSearch.h 
/********************************** <lalVerbatim file="ExcessPowerHV"> /********************************** <lalVerbatim file="ExcessPowerHV">
Author: Flanagan, E Author: Flanagan, E
$Id: EPSearch.h,v 1.3 2002/07/25 20:19:42 msw Exp $ $Id: EPSearch.h,v 1.59 2005/10/22 20:56:43 kipp Exp $
**************************************************** </lalVerbatim> */ **************************************************** </lalVerbatim> */
#ifndef _EPSEARCH_H #ifndef _EPSEARCH_H
#define _EPSEARCH_H #define _EPSEARCH_H
#include <lal/LALStdlib.h>
#include <lal/LALDatatypes.h>
#include <lal/TFTransform.h>
#include <lal/ExcessPower.h> #include <lal/ExcessPower.h>
#include <lal/BurstSearch.h> #include <lal/LALDatatypes.h>
#include <lal/LALRCSID.h> #include <lal/LALRCSID.h>
#include <lal/LIGOMetadataTables.h>
#include <lal/ResampleTimeSeries.h>
#include <lal/TimeFreqFFT.h>
#include <lal/TFTransform.h>
#include <lal/Window.h>
#ifdef __cplusplus /* C++ protection. */ #ifdef __cplusplus /* C++ protection. */
extern "C" { extern "C" {
#endif #endif
NRCSID (EPSEARCHH, "$Id: EPSearch.h,v 1.3 2002/07/25 20:19:42 msw Exp $"); NRCSID(EPSEARCHH, "$Id: EPSearch.h,v 1.59 2005/10/22 20:56:43 kipp Exp $");
/******** <lalErrTable file="ExcessPowerHErrTab"> ********/
#define EPSEARCHH_ENULLP 1
#define EPSEARCHH_EPOSARG 2
#define EPSEARCHH_EPOW2 4
#define EPSEARCHH_EMALLOC 8
#define EPSEARCHH_EINCOMP 16
#define EPSEARCHH_EORDER 32
#define EPSEARCHH_ENONNULL 64
#define EPSEARCHH_ETILES 65
#define EPSEARCHH_EDELF 128
#define EPSEARCHH_MSGENULLP "Null pointer"
#define EPSEARCHH_MSGEPOSARG "Arguments must be non-negative"
#define EPSEARCHH_MSGEPOW2 "Length of supplied data must be a power of
2"
#define EPSEARCHH_MSGEMALLOC "Malloc failure"
#define EPSEARCHH_MSGEINCOMP "Incompatible arguments"
#define EPSEARCHH_MSGEORDER "Routines called in illegal order"
#define EPSEARCHH_MSGENONNULL "Null pointer expected"
#define EPSEARCHH_MSGETILES "Malloc failed while assigning memory for a
tile"
#define EPSEARCHH_MSGEDELF "Inconsistent deltaF in spectrum and data"
/******** </lalErrTable> ********/
typedef struct typedef struct
tagEPDataSegment tagEPSearchParams {
{ BOOLEAN printSpectrum;
REAL4TimeSeries *data; BOOLEAN useOverWhitening;
REAL4FrequencySeries *spec; REAL4Window *window;
COMPLEX8FrequencySeries *resp; UINT4 windowShift;
INT4 endOfData; REAL8 lnalphaThreshold;
INT4 newLock; AvgSpecMethod method;
INT4 newCal; CreateTFTilingIn tfTilingInput;
INT4 number; TFPlaneParams tfPlaneParams;
} } EPSearchParams;
EPDataSegment;
SnglBurstTable *
typedef struct XLALEPSearch(
tagEPDataSegmentVector const COMPLEX8FrequencySeries *hrssresponse,
{ const REAL4TimeSeries *tseries,
UINT4 length; EPSearchParams *params
EPDataSegment *data; );
}
EPDataSegmentVector; int
XLALEPConditionData(
/* enum added to control search method 7/18/02 MSW */ REAL4TimeSeries *series,
typedef enum REAL8 flow,
{ REAL8 resampledeltaT,
useMean, INT4 corruption
useMedian, );
useUnity
} EPMethod;
typedef struct
tagEPInitParams
{
UINT4 numPoints;
UINT4 numSegments;
UINT4 segDutyCycle;
EPMethod method;
}
EPInitParams;
typedef struct
tagEPSearchParams
{
BOOLEAN searchMaster;
BOOLEAN haveData;
UINT4 *numSlaves;
UINT4 simType;
UINT4 currentSegment;
INT4 ntotT;
INT4 numEvents;
UINT4 ovrlap;
REAL8 lambda;
REAL8 alphaThreshold;
INT4 events2Master; /* Added Erik Kats */
CHAR *channelName; /* Added Erik Kats */
EPInitParams *initParams;
EPDataSegmentVector *epSegVec;
CreateTFTilingIn *tfTilingInput;
TFTiling *tfTiling;
ComputeExcessPowerIn *compEPInput;
LALWindowParams winParams;
}
EPSearchParams;
void
EPSearch (
LALStatus *status,
EPSearchParams *params,
BurstEvent **burstEvent,
UINT4 tmpDutyCyle
);
/************************************************************/
/* new method added to obtain median of power spectrum data */
/* M. Williamsen 7/17/02 */
/************************************************************/
REAL4
EPMedian (
REAL4 *p,
INT4 j,
INT4 flength,
INT4 numSegs,
LALStatus *status
);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* C++ protection. */ #endif /* C++ protection. */
#endif #endif
 End of changes. 6 change blocks. 
113 lines changed or deleted 33 lines changed or added


 ExcessPower.h   ExcessPower.h 
/********************************** <lalVerbatim file="ExcessPowerHV"> /********************************** <lalVerbatim file="ExcessPowerHV">
Author: Flanagan, E Author: Flanagan, E
$Id: ExcessPower.h,v 1.8 2002/04/10 22:35:43 patrick Exp $ $Id: ExcessPower.h,v 1.37 2005/10/06 23:53:36 kipp Exp $
**************************************************** </lalVerbatim> */ **************************************************** </lalVerbatim> */
#ifndef _EXCESSPOWER_H #ifndef _EXCESSPOWER_H
#define _EXCESSPOWER_H #define _EXCESSPOWER_H
#include <lal/LALStdlib.h> #include <stdio.h>
#include <stdlib.h>
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/TFTransform.h> #include <lal/TFTransform.h>
#include <lal/LALRCSID.h> #include <lal/LALRCSID.h>
#ifdef __cplusplus /* C++ protection. */ #ifdef __cplusplus /* C++ protection. */
extern "C" { extern "C" {
#endif #endif
NRCSID (EXCESSPOWERH, "$Id: ExcessPower.h,v 1.8 2002/04/10 22:35:43 patrick Exp $"); NRCSID(EXCESSPOWERH, "$Id: ExcessPower.h,v 1.37 2005/10/06 23:53:36 kipp Ex p $");
/******** <lalErrTable file="ExcessPowerHErrTab"> ********/ typedef struct tagTFTile {
#define EXCESSPOWERH_ENULLP 1 INT4 fstart;
#define EXCESSPOWERH_EPOSARG 2 INT4 fbins;
#define EXCESSPOWERH_EPOW2 4 INT4 tstart;
#define EXCESSPOWERH_EMALLOC 8 INT4 tbins;
#define EXCESSPOWERH_EINCOMP 16 REAL8 deltaT;
#define EXCESSPOWERH_EORDER 32 REAL8 deltaF;
#define EXCESSPOWERH_ENONNULL 64 REAL8 excessPower;
#define EXCESSPOWERH_ETILES 65 REAL8 hrss;
#define EXCESSPOWERH_EDELF 128 REAL8 lnalpha;
REAL8 lnweight;
#define EXCESSPOWERH_MSGENULLP "Null pointer" } TFTile;
#define EXCESSPOWERH_MSGEPOSARG "Arguments must be non-negative"
#define EXCESSPOWERH_MSGEPOW2 "Length of supplied data must be a power typedef struct tagTFTiling {
of 2" TFTile *tile;
#define EXCESSPOWERH_MSGEMALLOC "Malloc failure" size_t numtiles;
#define EXCESSPOWERH_MSGEINCOMP "Incompatible arguments" } TFTiling;
#define EXCESSPOWERH_MSGEORDER "Routines called in illegal order"
#define EXCESSPOWERH_MSGENONNULL "Null pointer expected" typedef struct tagCreateTFTilingIn {
#define EXCESSPOWERH_MSGETILES "Malloc failed while assigning memory for INT4 inv_fractional_stride;
a tile" REAL8 maxTileBandwidth;
#define EXCESSPOWERH_MSGEDELF "Inconsistent deltaF in spectrum and data REAL8 maxTileDuration;
" } CreateTFTilingIn;
/******** </lalErrTable> ********/
int
typedef struct XLALAddWhiteNoise(
tagTFTile COMPLEX8Vector *v,
{ REAL8 noiseLevel
INT4 fstart; );
INT4 fend;
INT4 tstart; void
INT4 tend; LALAddWhiteNoise(
INT4 whichPlane; LALStatus *status,
REAL8 deltaT; /* deltaF will always be 1/ COMPLEX8Vector *v,
deltaT */ REAL8 noiseLevel
REAL8 excessPower; );
REAL8 alpha;
REAL8 weight; REAL8
BOOLEAN firstCutFlag; XLALTFTileDegreesOfFreedom(
struct tagTFTile *nextTile; const TFTile *tile
} );
TFTile;
TFTiling *
typedef struct XLALCreateTFTiling(
tagTFTiling const CreateTFTilingIn *input,
{ const TFPlaneParams *planeparams
TFTile *firstTile; /* linked list of Tiles */ );
INT4 numTiles;
COMPLEX8TimeFrequencyPlane **tfp; /* Vector of pointers */ void
ComplexDFTParams **dftParams; /* Vector of pointers */ XLALDestroyTFTiling(
INT4 numPlanes; TFTiling *tiling
BOOLEAN planesComputed; );
BOOLEAN excessPowerComputed;
BOOLEAN tilesSorted; int
} XLALComputeExcessPower(
TFTiling; TFTiling *tiling,
const REAL4TimeFrequencyPlane *plane,
typedef struct const REAL8 *hrssfactor,
tagCreateTFTilingIn const REAL4 *norm
{ );
INT4 overlapFactor;
INT4 minFreqBins; void
INT4 minTimeBins; XLALSortTFTilingByAlpha(
REAL8 flow; /* lowest freq to search TFTiling *tiling
*/ );
REAL8 deltaF;
INT4 length; REAL8
} XLALComputeLikelihood(
CreateTFTilingIn; TFTiling *tiling
);
typedef struct
tagComputeExcessPowerIn void
{ XLALPrintTFTileList(
REAL8 numSigmaMin; FILE *fp,
REAL8 alphaDefault; const TFTiling *tiling,
} const REAL4TimeFrequencyPlane *plane,
ComputeExcessPowerIn; size_t maxTiles
);
void
LALAddWhiteNoise (
LALStatus *status,
COMPLEX8Vector *v,
REAL8 noiseLevel
);
void
LALCreateTFTiling (
LALStatus *status,
TFTiling **tfTiling,
CreateTFTilingIn *input
);
void
LALDestroyTFTiling (
LALStatus *status,
TFTiling **tfTiling
);
void
LALComputeTFPlanes (
LALStatus *status,
TFTiling *tfTiling,
COMPLEX8FrequencySeries *freqSeries
);
void
LALComputeExcessPower (
LALStatus *status,
TFTiling *tfTiling,
ComputeExcessPowerIn *input
);
void
LALSortTFTiling (
LALStatus *status,
TFTiling *tfTiling
);
void
LALCountEPEvents (
LALStatus *status,
INT4 *numEvents,
TFTiling *tfTiling,
REAL8 alphaThreshold
);
void
LALComputeLikelihood (
LALStatus *status,
REAL8 *lambda,
TFTiling *tfTiling
);
void
LALPrintTFTileList (
LALStatus *status,
FILE *fp,
TFTiling *tfTiling,
INT4 maxTiles
);
void
PrintTFTileList1 (
LALStatus *status,
FILE *fp,
TFTiling *tfTiling,
INT4 maxTiles
);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* C++ protection. */ #endif /* C++ protection. */
#endif #endif
 End of changes. 6 change blocks. 
154 lines changed or deleted 84 lines changed or added


 FileIO.h   FileIO.h 
/* <lalVerbatim file="FileIOHV">
$Id: FileIO.h,v 1.2 2004/05/27 02:25:47 jolien Exp $
</lalVerbatim> */
/* <lalLaTeX>
\section{Header \texttt{FileIO.h}}
\label{s:FileIO.h}
Provides standard LAL support IO functions.
\subsection*{Synopsis}
\begin{verbatim}
#include <lal/LALStdio.h>
#include <lal/FileIO.h>
\end{verbatim}
\noindent Only use \texttt{FileIO.h} in test code that links to
the \texttt{lalsupport} library.
\vfill{\footnotesize\input{FileIOHV}}
\newpage\input{FileIOC}
</lalLaTeX> */
#ifndef _FILEIO_H #ifndef _FILEIO_H
#define _FILEIO_H #define _FILEIO_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include <stdio.h> #include <stdio.h>
#include <lal/LALRCSID.h> #include <lal/LALRCSID.h>
NRCSID( FILEIOH, "$Id: FileIO.h,v 1.1 2001/05/28 02:12:07 jolien Exp $" ); NRCSID( FILEIOH, "$Id: FileIO.h,v 1.2 2004/05/27 02:25:47 jolien Exp $" );
#ifndef LALFopen #ifndef LALFopen
#define LALFopen fopen #define LALFopen fopen
#endif #endif
#ifndef LALFclose #ifndef LALFclose
#define LALFclose fclose #define LALFclose fclose
#endif #endif
FILE * FILE *
 End of changes. 2 change blocks. 
1 lines changed or deleted 23 lines changed or added


 FindChirp.h   FindChirp.h 
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
* *
* File Name: FindChirp.h * File Name: FindChirp.h
* *
* Author: Allen, B., Brown, D. A. and Creighton, J. D. E. * Author: Allen, B., Brown, D. A. and Creighton, J. D. E.
* *
* Revision: $Id: FindChirp.h,v 1.21 2002/05/23 20:12:40 duncan Exp $ * Revision: $Id: FindChirp.h,v 1.80 2005/09/06 03:40:29 duncan Exp $
* *
*----------------------------------------------------------------------- *-----------------------------------------------------------------------
*/ */
#if 0 #if 0
<lalVerbatim file="FindChirpHV"> <lalVerbatim file="FindChirpHV">
Author: Allen, B., Brown, D. A. and Creighton, J. D. E. Author: Allen, B., Brown, D. A. and Creighton, J. D. E.
$Id: FindChirp.h,v 1.21 2002/05/23 20:12:40 duncan Exp $ $Id: FindChirp.h,v 1.80 2005/09/06 03:40:29 duncan Exp $
</lalVerbatim> </lalVerbatim>
<lalLaTeX> <lalLaTeX>
\section{Header \texttt{FindChirp.h}} \section{Header \texttt{FindChirp.h}}
\label{s:FindChirp.h} \label{s:FindChirp.h}
Provides core protypes, structures and functions to filter interferometer d \noindent This header provides core prototypes, structures and functions to
ata filter interferometer data for binary inspiral chirps.
for binary inspiral chirps.
\subsection*{Synopsis} \subsubsection*{Synopsis}
\begin{verbatim} \begin{verbatim}
#include <lal/FindChirp.h> #include <lal/FindChirp.h>
\end{verbatim} \end{verbatim}
\input{FindChirpHDoc} \noindent Each function in findchirp falls into one of four classes:
\begin{enumerate}
\item Generate management functions which are independent of the type of
filtering implemented. The prototypes for these functions are provided by
this header file.
\item Functions for filtering data for time domain and frequency domain
templates with an unknown amplitude and phase. These are the functions
that implement matched filtering for time domain templates (TaylorT1,
TaylorT2, TaylorT2, PadeT1, EOB and GeneratePPN) and matched filtering
for post-Newtonian frequency domain templates (FindChirpSP). The main
filter function \texttt{FindChirpFilterSegment()} is prototyped in
this header file. The template generation and data conditioning functions
are prototyped in \texttt{FindChirpSP.h} and \texttt{FindChirpTD.h}.
Full documentation of the filtering algorithm used can be found in the
documentation of the module \texttt{FindChirpFilter.c}.
\item Functions to filter interferometer data for using the frequency
domain non-spinning black hole detection template family known as BCV.
These functions are protoyped by the header \texttt{FindChirpBCV.h}
which contains documentation of the algorithms used.
\item Functions to filter interferometer data for using the frequency domai
n
spinning black hole detection template family known as BCVSpin. These
functions are protoyped by the header \texttt{FindChirpBCVSpin.h} which
contains documentation of the algorithms used.
\end{enumerate}
\noindent The goal of all the filtering functions is to determine if the
(calibrated) output of the interferometer $s(t)$ contains a gravitational w
ave
$h(t)$ in the presence of the detector noise $n(t)$. When the interferomete
r
is operating properly
\begin{equation}
s(t) = \left\{ \begin{array}{ll}
n(t) + h(t) & \textrm{signal present},\\
n(t) & \textrm{signal absent}.
\end{array}\right.
\end{equation}
The detection of signals of known form in noise is a classic problem of sig
nal
processing\cite{wainstein:1962} and can be answered by the construction of
a
\emph{detection statistic} and a test to see if the statistic is above some
pre-assigned threshold. The construction of the various detection
statistics used for each the three types of search are described in the mod
ules
that implement the search.
</lalLaTeX> </lalLaTeX>
#endif #endif
#ifndef _FINDCHIRPH_H #ifndef _FINDCHIRPH_H
#define _FINDCHIRPH_H #define _FINDCHIRPH_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/ComplexFFT.h> #include <lal/ComplexFFT.h>
#include <lal/DataBuffer.h> #include <lal/DataBuffer.h>
#ifdef LAL_ENABLE_MPI #include <lal/LIGOMetadataTables.h>
#include <lal/Comm.h>
#endif
#include <lal/LALInspiral.h> #include <lal/LALInspiral.h>
#include <lal/LALInspiralBank.h>
#include <lal/GeneratePPNInspiral.h>
#include <lal/FindChirpDatatypes.h>
#include <lal/FindChirpChisq.h> #include <lal/FindChirpChisq.h>
#include <lal/FindChirpFilterOutputVeto.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#pragma } #pragma }
#endif #endif
NRCSID (FINDCHIRPH, "$Id: FindChirp.h,v 1.21 2002/05/23 20:12:40 duncan Exp $"); NRCSID (FINDCHIRPH, "$Id: FindChirp.h,v 1.80 2005/09/06 03:40:29 duncan Exp $");
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsection*{Error codes} \subsection*{Error codes}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* <lalErrTable> */ /* <lalErrTable> */
#define FINDCHIRPH_ENULL 1 #define FINDCHIRPH_ENULL 1
#define FINDCHIRPH_ENNUL 2 #define FINDCHIRPH_ENNUL 2
#define FINDCHIRPH_EALOC 3 #define FINDCHIRPH_EALOC 3
#define FINDCHIRPH_ENUMZ 5 #define FINDCHIRPH_ENUMZ 5
#define FINDCHIRPH_ESEGZ 6 #define FINDCHIRPH_ESEGZ 6
#define FINDCHIRPH_ECHIZ 7 #define FINDCHIRPH_ECHIZ 7
#define FINDCHIRPH_EDTZO 8 #define FINDCHIRPH_EDTZO 8
#define FINDCHIRPH_ETRNC 10 #define FINDCHIRPH_ETRNC 10
#define FINDCHIRPH_EFLOW 11 #define FINDCHIRPH_EFLOW 11
#define FINDCHIRPH_EFREE 12 #define FINDCHIRPH_EFREE 12
#define FINDCHIRPH_ERHOT 15 #define FINDCHIRPH_ERHOT 15
#define FINDCHIRPH_ECHIT 16 #define FINDCHIRPH_ECHIT 16
#define FINDCHIRPH_ECRUP 17 #define FINDCHIRPH_ECRUP 17
#define FINDCHIRPH_ESMSM 18
#define FINDCHIRPH_EHETR 19
#define FINDCHIRPH_EDFDT 20
#define FINDCHIRPH_EAPRX 21
#define FINDCHIRPH_EUAPX 22
#define FINDCHIRPH_ECHTZ 23
#define FINDCHIRPH_EMASS 24
#define FINDCHIRPH_EWVFM 25
#define FINDCHIRPH_EBCVC 25
#define FINDCHIRPH_MSGENULL "Null pointer" #define FINDCHIRPH_MSGENULL "Null pointer"
#define FINDCHIRPH_MSGENNUL "Non-null pointer" #define FINDCHIRPH_MSGENNUL "Non-null pointer"
#define FINDCHIRPH_MSGEALOC "Memory allocation error" #define FINDCHIRPH_MSGEALOC "Memory allocation error"
#define FINDCHIRPH_MSGENUMZ "Invalid number of points in segment" #define FINDCHIRPH_MSGENUMZ "Invalid number of points in segment"
#define FINDCHIRPH_MSGESEGZ "Invalid number of segments" #define FINDCHIRPH_MSGESEGZ "Invalid number of segments"
#define FINDCHIRPH_MSGECHIZ "Invalid number of chi squared bins" #define FINDCHIRPH_MSGECHIZ "Invalid number of chi squared bins"
#define FINDCHIRPH_MSGEDTZO "deltaT is zero or negative" #define FINDCHIRPH_MSGEDTZO "deltaT is zero or negative"
#define FINDCHIRPH_MSGETRNC "Duration of inverse spectrum in time domain is negative" #define FINDCHIRPH_MSGETRNC "Duration of inverse spectrum in time domain is negative"
#define FINDCHIRPH_MSGEFLOW "Inverse spectrum low frequency cutoff is negat ive" #define FINDCHIRPH_MSGEFLOW "Inverse spectrum low frequency cutoff is negat ive"
#define FINDCHIRPH_MSGEFREE "Error freeing memory" #define FINDCHIRPH_MSGEFREE "Error freeing memory"
#define FINDCHIRPH_MSGERHOT "Rhosq threshold is zero or negative" #define FINDCHIRPH_MSGERHOT "Rhosq threshold is negative"
#define FINDCHIRPH_MSGECHIT "Chisq threshold is zero or negative" #define FINDCHIRPH_MSGECHIT "Chisq threshold is negative"
#define FINDCHIRPH_MSGECRUP "Chirp length or invSpecTrunc too long for leng th of data segment" #define FINDCHIRPH_MSGECRUP "Chirp length or invSpecTrunc too long for leng th of data segment"
#define FINDCHIRPH_MSGESMSM "Size mismatch between vectors"
#define FINDCHIRPH_MSGEHETR "Attempting to simulate heterodyned GW"
#define FINDCHIRPH_MSGEDFDT "Waveform sampling interval is too large"
#define FINDCHIRPH_MSGEAPRX "Incorrect waveform approximant"
#define FINDCHIRPH_MSGEUAPX "Unknown waveform approximant"
#define FINDCHIRPH_MSGECHTZ "Length of chirp is zero or negative"
#define FINDCHIRPH_MSGEMASS "Invalid mass parameters for template generatio
n"
#define FINDCHIRPH_MSGEWVFM "Unknown injection waveform"
#define FINDCHIRPH_MSGEBCVC "BCVC code: thetav not in [-pi, pi]."
/* </lalErrTable> */ /* </lalErrTable> */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsection*{Types} \subsection*{Types}
</lalLaTeX>
#endif
/* --- enumeraion type for simulations -----------------------------------
*/
#pragma <lalVerbatim file="FindChirpHWaveformGenerator">
typedef enum
{
findchirpSP,
injectGenPPN
}
WaveformGenerator;
#pragma </lalVerbatim>
#if 0
<lalLaTeX>
\subsubsection*{Enumeration Type \texttt{WaveformGenerator}}
\idx[Type]{WaveformGenerator}
\input{FindChirpHWaveformGenerator}
\noindent This enumaration type lists the possible methods of generating
inspiral waveforms. The types in the enum should be of the form
\texttt{packagenameGenType}, where \texttt{packagename} is the name of the
LAL package that the particular waveform generator resides and \texttt{GenT
ype}
is a unique identifier for that waveform generator. The choices are:
\begin{description}
\item[\texttt{findchirpSP}] The \texttt{findchirp} built in stationary phas
e
waveform generator.
\item[\texttt{injectGenPPN}] The \texttt{LALGeneratePPNInspiral()} function
from the \texttt{inject} package.
\item[\texttt{fctFCT}] The \texttt{fct} algorithm was used to find the chir \subsubsection*{Structure \texttt{FindChirpInitParams}}
p. \idx[Type]{FindChirpInitParams}
\end{description}
</lalLaTeX>
#endif
/* \noindent This structure provides the essential information for the
* filter initialisation and memory allocation functions used by findchirp.
* typedefs of structures used by the findchirp functions
*
*/
#if 0
<lalLaTeX>
\subsubsection*{Input and output data structures}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* <lalVerbatim> */
/* --- structure for describing a binary insipral event ------------------
*/
#pragma <lalVerbatim file="FindChirpHInspiralEvent">
typedef struct typedef struct
tagInspiralEvent tagFindChirpInitParams
{ {
UINT4 id; UINT4 numSegments;
UINT4 segmentNumber; UINT4 numPoints;
LIGOTimeGPS time; UINT4 ovrlap;
LIGOTimeGPS impulseTime;
UINT4 timeIndex;
InspiralTemplate tmplt;
REAL4 snrsq;
REAL4 chisq;
REAL4 sigma;
REAL4 effDist;
REAL4 coaPhase;
UINT4 numChisqBins; UINT4 numChisqBins;
CHAR ifoName[2]; BOOLEAN createRhosqVec;
CHAR channel[LALNameLength]; BOOLEAN createCVec;
WaveformGenerator wavGen; Approximant approximant;
struct tagInspiralEvent *next;
} }
InspiralEvent; FindChirpInitParams;
#pragma </lalVerbatim> /* </lalVerbatim> */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsubsection*{Structure \texttt{InspiralEvent}}
\idx[Type]{InspiralEvent}
\input{FindChirpHInspiralEvent}
\noindent This structure describes inspiral events found by \texttt{findchi
rp}.
The fields are:
\begin{description} \begin{description}
\item[\texttt{UINT4 id}] A unique number assigned by the filter routine to \item[\texttt{UINT4 numSegments}] The number of data segments in the input
each event it finds. \texttt{DataSegmentVector} and a the \texttt{FindChirpSegmentVector}.
\item[\texttt{UINT4 segmentNumber}] The id number of the
\texttt{FindChirpDataSegment} in which the event was found.
\item[\texttt{LIGOTimeGPS time}] The GPS time at which the event occoured.
\item[\texttt{UINT4 timeIndex}] The index at which the event occoured in \item[\texttt{UINT4 numPoints}] The number of discrete data points $N$ in e
the array containing the filter output. ach
data segment.
\item[\texttt{InspiralTemplate tmplt}] The parameters of the inspiral templ
ate
for the event.
\item[\texttt{REAL4 snrsq}] The value of $\rho^2$ for the event.
\item[\texttt{REAL4 chisq}] The value of the $\chi^2$ veto for the event, i
f
it has been computed.
\item[\texttt{REAL4 sigma}] The value of the normalisation constant $\sigma
$
for the event.
\item[\texttt{REAL4 effDist}] The effective distance in megaparsecs to the
event.
\item[\texttt{REAL4 coaPhase}] The coalescence phase of the chirp. \item[\texttt{UINT4 ovrlap}] The number of sample points by which each
data segment overlaps.
\item[\texttt{WaveformGenerator wavGen}] The particular waveform generator \item[\texttt{UINT4 numChisqBins}] The number of bins $p$ used to contruct
that was used in the matched filter for this chirp. the
$\chi^2$ veto.
\item[\texttt{CHAR ifoName[2]}] Array for storing the two character \item[\texttt{BOOLEAN createRhosqVec}] Flag that controls whether or not th
interferometer name (e.g. L1, H2, etc.) e
filter function should store the output of the matched filter, $\rho^2(t)$,
as
well as the events. Memory is allocated for this vector if the flag is set
to
1.
\item[\texttt{BOOLEAN createCVec}] Flag that controls whether or not the
filter function should store the complex filter output $x(t) + i y(t)$ need
ed
by the coherent inspiral code. Memory is allocated for this vector if the
flag is set to 1.
\item[\texttt{Approximant approximant}] Initialize the findchirp routines
to fiter with templates of type \texttt{approximant}. Valid approximants ar
e
TaylorT1, TaylorT2, TaylorT3, PadeT1, EOB, FindChirpSP, BCV and BCVSpin.
\item[\texttt{struct tagInspiralEvent *next}] A pointer to a structure of t
ype
\texttt{InspiralEvent} to allow the construction of a linked list of events
.
\end{description} \end{description}
</lalLaTeX>
#endif
/* --- vector of DataSegment, as defined the framedata package -----------
*/
#pragma <lalVerbatim file="FindChirpHDataSegmentVector">
typedef struct
tagDataSegmentVector
{
UINT4 length;
DataSegment *data;
}
DataSegmentVector;
#pragma </lalVerbatim>
#if 0
<lalLaTeX>
\subsubsection*{Structure \texttt{DataSegmentVector}}
\idx[Type]{DataSegmentVector}
\input{FindChirpHDataSegmentVector} \subsubsection*{Structure \texttt{FindChirpDataParams}}
\idx[Type]{FindChirpDataParams}
\noindent This structure provides a LAL like vector structure for the \noindent This structure contains the parameters needed to call the data
\texttt{DataSegment} structure defined in the package \texttt{framedata} conditioning functions \texttt{FindChirpSPData()}, \texttt{FindChirpTDData(
)},
\texttt{FindChirpBCVData()} or \texttt{FindChirpBCVSpinData()}. It should b
e
initialized by \texttt{FindChirpDataInit()} and destroyed by
\texttt{FindChirpDataFinalize()}.
\begin{description}
\item[\texttt{UINT4 length}] Number of \texttt{DataSegment} structres in th
e
vector
\item[\texttt{DataSegment *data}] Pointer to the data.
\end{description}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* <lalVerbatim> */
/* --- processed data segment used by FindChirp filter routine -----------
*/
#pragma <lalVerbatim file="FindChirpHFindChirpSegment">
typedef struct typedef struct
tagFindChirpSegment tagFindChirpDataParams
{ {
COMPLEX8FrequencySeries *data; REAL4Vector *ampVec;
UINT4Vector *chisqBinVec; REAL4Vector *ampVecBCV;
REAL8 deltaT; REAL8Vector *ampVecBCVSpin1;
REAL4 segNorm; REAL8Vector *ampVecBCVSpin2;
RealFFTPlan *fwdPlan;
RealFFTPlan *invPlan;
REAL4Vector *wVec;
COMPLEX8Vector *wtildeVec;
REAL4Vector *tmpltPowerVec;
REAL4Vector *tmpltPowerVecBCV;
REAL4 fLow; REAL4 fLow;
REAL4 dynRange;
UINT4 invSpecTrunc; UINT4 invSpecTrunc;
UINT4 number; Approximant approximant;
} }
FindChirpSegment; FindChirpDataParams;
#pragma </lalVerbatim> /* </lalVerbatim> */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsubsection*{Structure \texttt{FindChirpSegment}}
\idx[Type]{FindChirpSegment}
\input{FindChirpHFindChirpSegment} \begin{description}
\item[\texttt{REAL4Vector *ampVec}] A vector containing the frequency domai
n
quantity $(k/N)^{-7/6}$, where $k$ is the frequency series index and $N$ is
the
number of points in a data segment. NB: for time domain templates, this is
set
to unity by the function \texttt{FindChirpTDData()}.
\item[\texttt{REAL4Vector *ampVecBCV}] A vector containing the frequency do
main
quantity $(k/N)^{-1/2}$, where $k$ is the frequency series index and $N$ is
the
number of points in a data segment.
\item[\texttt{REAL4Vector *ampVecBCVSpin1}] Undocumented spinning BCV
amplitude vector.
\item[\texttt{REAL4Vector *ampVecBCVSpin2}] Undocumented spinning BCV
amplitude vector.
\item[\texttt{REAL4Vector *fwdPlan}] An FFTW plan used to transform the
time domain interferometer data $v(t_j)$ into its DFT $\tilde{v}_k$.
\item[\texttt{REAL4Vector *invPlan}] An FFTW plan used to transform the
dimensionless frequency domain interferometer strain $\tilde{w}_k$ into
the quantity $N w(t_j)$ to allow time domain trunction of the inverse
power spectrum.
\item[\texttt{REAL4Vector *wVec}] A vector used as workspace when truncatin
g
the imverse power spectrum in the time domain.
\item[\texttt{COMPLEX8Vector *wtildeVec}] A vector which on exit from
the data conditioning function contains the inverse of the strain one sided
power spectral density, after trunction in the time domain, \emph{for the l
ast
data segment conditioned.} Typically all the data segments are conditioned
using the same power spectrum, so this quantity is identical for all data
segments. It contains:
\begin{equation}
\tilde{w}_k = {1}/{\ospsd}.
\end{equation}
\noindent This structure contains the conditioned input data and its \item[\texttt{REAL4Vector *tmpltPowerVec}] A vector which on exit from
parameters for the \texttt{FindChirpFilter()} function. \texttt{FindChirpSPData()} or from \texttt{FindChirpBCVData()}
contains the quantity
\begin{equation}
\mathtt{tmpltPower[k]} = \frac{f^{-7/3}}{\ospsd}
\end{equation}
\begin{description} \item[\texttt{REAL4Vector *tmpltPowerVecBCV}] A vector which on exit from
\item[\texttt{COMPLEX8FrequencySeries *data}] The conditioned input data. \texttt{FindChirpBCVData()}
The conditioneing performed is as described in the documentation for the contains the quantity
module \texttt{FindChirpSPData.c} \begin{equation}
\mathtt{tmpltPowerBCV[k]} = \frac{f^{-1}}{\ospsd}
\item[\texttt{UINT4Vector *chisqBinVec}] A vector containing the indices of \end{equation}
the boundaries of the bins of equal power for the $\chi^2$ veto created by
\texttt{FindChirpSPData()}
\item[\texttt{REAL8 deltaT}] The time step $\Delta$ of the time series
input data.
\item[\texttt{REAL4 segNorm}] The template independent part of the
normalisation constant $\sigma$.
\item[\texttt{UINT4 invSpecTrunc}] The number of points to which the invers
e
power spectrum \ospsd is truncated to in the time domain in order to smooth
out high $Q$ features in the power spectrum.
\item[\texttt{UINT4 number}] A unique identification number for the
\texttt{FindChirpDataSegment}. This will generally correspond to the number
in
the \texttt{DataSegment} from which the conditioned data was computed.
\end{description}
</lalLaTeX>
#endif
/* --- vector of FindChirpSegment defined above -------------------------- \item[\texttt{REAL4 fLow}] The frequency domain low frequency cutoff
*/ $f_\mathrm{low}$. All frequency domain data is set to zero below this
#pragma <lalVerbatim file="FindChirpHFindChirpSegmentVector"> frequency.
typedef struct
tagFindChirpSegmentVector \item[\texttt{REAL4 dynRange}] A dynamic range factor $d$ which cancels fro
{ m
UINT4 length; the filter output. This allows quantities to be stored in the range of
FindChirpSegment *data; \texttt{REAL4} rather than \texttt{REAL8}. This must be set to the same val
} ue
FindChirpSegmentVector; as \texttt{dynRange} in the \texttt{FindChirpTmpltParams}. For LIGO data a
#pragma </lalVerbatim> value of $d = 2^{69}$ is appropriate.
#if 0
<lalLaTeX> \item[\texttt{UINT4 invSpecTrunc}] The length to which to truncate the inve
\subsubsection*{Structure \texttt{FindChirpSegmentVector}} rse
\idx[Type]{FindChirpSegmentVector} power spectral density of the data in the time domain. If set to zero, no
truncation is performed.
\item[\texttt{Approximant approximant}] Condition the data for templates of
type \texttt{approximant}. Valid approximants are TaylorT1, TaylorT2,
TaylorT3, PadeT1, EOB, FindChirpSP, BCV and BCVSpin.
\input{FindChirpHFindChirpSegmentVector} \end{description}
\noindent This structure provides a LAL like vector structure for the \subsubsection*{Structure \texttt{FindChirpTmpltParams}}
\texttt{FindChirpSegment} structure defined above. \idx[Type]{FindChirpTmpltParams}
\begin{description} \noindent This structure contains the parameters for generation of template
\item[\texttt{UINT4 length}] Number of \texttt{FindChirpSegment} structres s
in by the various template generation functions provided in finchirp.
the vector
\item[\texttt{DataSegment *data}] Pointer to the data.
\end{description}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* <lalVerbatim> */
/* --- structure to contain an inspiral template -------------------------
*/
#pragma <lalVerbatim file="FindChirpHFindChirpTemplate">
typedef struct typedef struct
tagFindChirpTemplate tagFindChirpTmpltParams
{ {
COMPLEX8Vector *data; REAL8 deltaT;
REAL4 tmpltNorm; REAL4 fLow;
REAL4 dynRange;
REAL4Vector *xfacVec;
RealFFTPlan *fwdPlan;
Approximant approximant;
} }
FindChirpTemplate; FindChirpTmpltParams;
#pragma </lalVerbatim> /* </lalVerbatim> */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsubsection*{Structure \texttt{FindChirpTemplate}}
\idx[Type]{FindChirpTemplate}
\input{FindChirpHFindChirpTemplate} \begin{description}
\item[\texttt{REAL8 deltaT}] The sampling interval $\Delta t$ of the input
data channel.
\noindent This structure provides contains the frequency domain representat \item[\texttt{REAL4 fLow}] The frequency domain low frequency cutoff
ion $f_\mathrm{low}$. All frequency domain data is zero below this frequency.
of the cosine phase inspiral template $\tilde{h_c}(f)$.
\begin{description} \item[\texttt{REAL4 dynRange}] A dynamic range factor $d$ which cancels fro
\item[\texttt{COMPLEX8Vector *data}] A vector containing $\tilde{h_c}(f)$. m
Note the filter output. This allows quantities to be stored in the range of
that in the future, this will be changed to a \texttt{COMPLEX8FrequencySeri \texttt{REAL4} rather than \texttt{REAL8}. This must be set to the same val
es}. ue
as \texttt{dynRange} in the \texttt{FindChirpDataParams}. For LIGO data a
value of $d = 2^{69}$ is appropriate.
\item[\texttt{REAL4Vector *xfacVec}] For frequency domain templates, this i
s a
vector of length $N/2+1$ which contains the quantity $k^{-7/6}$. For time
domain templates, this is a workspace vector of length $N$ which contains t
he
time domain template generated by the inspiral package, shifted so that the
end of the template is at the end of the vector. This vector is Fourier
transformed to obtain the quantity findchirp template $\tilde{T}_k$.
\item[\texttt{REAL4Vector *fwdPlan}] For time domain templates, an FFTW pla
n
used to transform the time domain data stored in \texttt{xfacVec} into its
DFT
which is stored in the findchirp template.
\item[\texttt{Approximant approximant}] Generate templates of type
\texttt{approximant}. Valid approximants are TaylorT1, TaylorT2, TaylorT3,
PadeT1, EOB, FindChirpSP, BCV and BCVSpin. For time domain and stationary
phase templates the post-Newtonian order is always two.
\item[\texttt{REAL4 tmpltNorm}] The template dependent part of the
normalisation constant $\sigma$.
\end{description} \end{description}
</lalLaTeX>
#endif
/* \subsubsection*{Structure \texttt{Clustering}}
* \idx[Type]{Clustering}
* typedefs of parameter structures used by functions in findchirp
*
*/
#if 0 \noindent This structure contains the possible methods by which
<lalLaTeX> to maximize over a chirp in a data segment.
\subsubsection*{Initalisation and parameter structures}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* --- parameter structure for all init funtions ------------------------- /* <lalVerbatim> */
*/ typedef enum {
#pragma <lalVerbatim file="FindChirpHFindChirpInitParams"> noClustering,
typedef struct tmplt,
tagFindChirpInitParams window
{ }
UINT4 numSegments; Clustering;
UINT4 numPoints; /* </lalVerbatim> */
UINT4 numChisqBins;
BOOLEAN createRhosqVec;
}
FindChirpInitParams;
#pragma </lalVerbatim>
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsubsection*{Structure \texttt{FindChirpInitParams}}
\idx[Type]{FindChirpInitParams}
\input{FindChirpHFindChirpInitParams}
\noindent This structure provides the essential information for the
filter initialisation and memory allocation functions used in the
\texttt{FindChirp} package.
\begin{description} \begin{description}
\item[\texttt{UINT4 numSegments}] The number of data segments to allocate \item[\texttt{noClustering}] The decision to do no clustering
storage for. of events.
\item[\texttt{UINT4 numPoints}] The number of discrete data points in each \item[\texttt{tmplt}] Cluster over the length of the data segment.
data segment.
\item[\texttt{UINT4 numChisqBins}] The number of bins used to contruct the \item[\texttt{window}] Cluster over a given number of seconds
$\chi^2$ veto. given by the argument to the flag \texttt{--cluster-window}
(required to be less than the length of the data segment).
\item[\texttt{BOOLEAN createRhosqVec}] Debugging flag that controls whether
or not the function \texttt{FindChirpFilterSegment()} should store the outp
ut
of the filter, $\rho^2(t)$, as well as the events. Memory is only allocated
for this vector if the flag is set to 1.
\end{description} \end{description}
\subsubsection*{Structure \texttt{FindChirpFilterParams}}
\idx[Type]{FindChirpFilterParams}
\noindent This structure provides the parameters used by the
\texttt{FindChirpFilterSegment()} function.
</lalLaTeX> </lalLaTeX>
#endif #endif
/* <lalVerbatim> */
/* --- parameter structure for the filtering function --------------------
*/
#pragma <lalVerbatim file="FindChirpHFindChirpFilterParams">
typedef struct typedef struct
tagFindChirpFilterParams tagFindChirpFilterParams
{ {
REAL4 deltaT; REAL8 deltaT;
REAL4 clusterWindow;
REAL4 rhosqThresh; REAL4 rhosqThresh;
REAL4 chisqThresh; REAL4 chisqThresh;
REAL4 norm; REAL4 norm;
UINT4 maximiseOverChirp; UINT4 maximiseOverChirp;
BOOLEAN computeNegFreq; Clustering clusterMethod;
Approximant approximant;
COMPLEX8Vector *qVec; COMPLEX8Vector *qVec;
COMPLEX8Vector *qVecBCV;
COMPLEX8Vector *qVecBCVSpin1;
COMPLEX8Vector *qVecBCVSpin2;
COMPLEX8Vector *qtildeVec; COMPLEX8Vector *qtildeVec;
COMPLEX8Vector *qtildeVecBCV;
COMPLEX8Vector *qtildeVecBCVSpin1;
COMPLEX8Vector *qtildeVecBCVSpin2;
ComplexFFTPlan *invPlan; ComplexFFTPlan *invPlan;
REAL4Vector *rhosqVec; REAL4TimeSeries *rhosqVec;
COMPLEX8TimeSeries *cVec;
REAL4Vector *chisqVec; REAL4Vector *chisqVec;
FindChirpChisqParams *chisqParams; FindChirpChisqParams *chisqParams;
FindChirpChisqInput *chisqInput; FindChirpChisqInput *chisqInput;
FindChirpChisqInput *chisqInputBCV;
FindChirpFilterOutputVetoParams *filterOutputVetoParams;
} }
FindChirpFilterParams; FindChirpFilterParams;
#pragma </lalVerbatim> /* </lalVerbatim> */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsubsection*{Structure \texttt{FindChirpFilterParams}}
\idx[Type]{FindChirpFilterParams}
\input{FindChirpHFindChirpFilterParams}
\noindent This structure provides the parameters used by the
\texttt{FindChirpFilterSegment()} function.
\begin{description} \begin{description}
\item[\texttt{REAL4 deltaT}] The timestep for the sampled data. Must be \item[\texttt{REAL8 deltaT}] The sampling interval $\Delta t$.
set on entry. {FIXME: This should be a \texttt{REAL8}}
\item[\texttt{REAL4 rhosqThresh}] The value to threshold signal to noise \item[\texttt{REAL4 rhosqThresh}] The signal-to-noise ratio squared thresho
ratio square, $\rho^2$, on. If the signal to noise exceeds this value, then ld
a $\rho^2_\ast$. If the matched filter output exceeds this value, that is
candidate event is generated. A $\chi^2$ veto is performed, if requested, $\rho^2(t_j) > \rho^2_\ast$, the event processing algorithm is entered and
otherwise an \texttt{InspiralEvent} is generated. Must be $\ge 0$ on entry. triggers may be generated (subject to addition vetoes such as the $\chi^2$
veto). The value of $\rho^2_\ast0$ must be greater than or equal to zero.
\item[\texttt{REAL4 chisqThresh}] The value to threshold the $\chi^2$ veto
on. \item[\texttt{REAL4 chisqThresh}] The $\chi^2$ veto threshold on. This
If the $chi^2$ veto is below this threshold the candidate event an threshold is described in details in the documentation for the $\chi^2$
\texttt{InspiralEvent} is generated. Must be $\ge 0$ on entry. veto.
\item[\texttt{REAL4 norm}] On exit this contains the normalisation constant \item[\texttt{REAL4 norm}] On exit this contains the normalisation constant
that relates the quantity $q_j$ with the signal to noise squared, that relates the quantity $|q_j|^2$ with the signal to noise squared,
$\rho^2(t_j)$ by $\rho^2(t_j)$ by
\begin{equation} \begin{equation}
\rho^2(t_j) = \textrm{norm} \times \left|q_j\right|^2. \rho^2(t_j) = \textrm{norm} \times \left|q_j\right|^2.
\end{equation} \end{equation}
\item[\texttt{UINT4 maximiseOverChirp}] If not zero, use algorithm that \item[\texttt{UINT4 maximiseOverChirp}] If not zero, use the
maximised over chirp lengths. Otherwise record all points that pass maximise over chirp length algorithm to decide which time $t_j$ should
the $\rho^2$ threshold as events. have an inspiral trigger generated. Otherwise record all points that pass t
he
\item[\texttt{BOOLEAN computeNegFreq}] Currently unused. Must be set to $\rho^2$ and $\chi^2$ threshold as triggers (this may generate may triggers
$0$ on entry. ).
\item[\texttt{COMPLEX8Vector *qVec}] Pointer to vector allocated by \item[\texttt{Approximant approximant}] Filter the data using templates of
\texttt{FindChirpFilterInit()} to store the quantity $q_j$. Set to the type \texttt{approximant}. Valid approximants are TaylorT1, TaylorT2,
value of $q_j$ on exit. Must not be NULL. TaylorT3, PadeT1, EOB, FindChirpSP, BCV and BCVSpin. The value of
\texttt{approximant} here must match that in the findchirp data segment and
\item[\texttt{COMPLEX8Vector *qtildeVec}] Pointer to vector allocated by findchirp template used as input.
\texttt{FindChirpFilterInit()} to store the quantity $\tilde{q}_k$. Set to
the \item[\texttt{COMPLEX8Vector *qVec}] Pointer to vector of length $N$ alloca
value of $\tilde{q}_k$ on exit. Must not be NULL ted
by \texttt{FindChirpFilterInit()} to store the quantity $q_j$. The pointer
must not be NULL on entry, but the vetor may contain garbage which will be
overwritten with the value of $q_j$ for the segment filtered on exit.
\item[\texttt{COMPLEX8Vector *qVecBCV}] Pointer to the additional vector
required for the BCV templates, allocated by \texttt{FindChirpFilterInit()}
.
\item[\texttt{COMPLEX8Vector *qVecBCVSpin1}] Pointer to the additional vect
or
required for filtering spinning BCV templates, allocated by
\texttt{FindChirpFilterInit()}.
\item[\texttt{COMPLEX8Vector *qVecBCVSpin2}] Pointer to the additional vect
or
required for filtering spinning BCV templates, allocated by
\texttt{FindChirpFilterInit()}.
\item[\texttt{COMPLEX8Vector *qtildeVec}] Pointer to vector of length $N$
allocated by \texttt{FindChirpFilterInit()} to store the quantity
$\tilde{q}_k$, given by
\begin{equation}
\tilde{q}_k = \left\{
\begin{array}{ll}
\tilde{F}_k \tilde{T}_k^\ast & \quad 0 < k < \frac{N}{2} \\,
0 & \quad \textrm{otherwise}.
\end{array}
\right.
\end{equation}
The pointer must not be NULL on entry, but the vetor may contain garbage wh
ich
will be overwritten with the value of $\tilde{q}_k$ for the segment filtere
d
on exit.
\item[\texttt{COMPLEX8Vector *qtildeVecBCV}] Pointer to the additional
vector required for filtering BCV templates, allocated by
\texttt{FindChirpFilterInit()}.
\item[\texttt{COMPLEX8Vector *qtildeVecBCVSpin1}] Pointer to the additional
vector required for filtering spinning BCV templates, allocated by
\texttt{FindChirpFilterInit()}.
\item[\texttt{COMPLEX8Vector *qtildeVecBCVSpin2}] Pointer to the additional
vector required for filtering spinning BCV templates, allocated by
\texttt{FindChirpFilterInit()}.
\item[\texttt{ComplexFFTPlan *invPlan}] Pointer to FFTW plan created by \item[\texttt{ComplexFFTPlan *invPlan}] Pointer to FFTW plan created by
\texttt{FindChirpFilterInit()} to transform the quantity $\tilde{q}_k$ to \texttt{FindChirpFilterInit()} to transform the quantity $\tilde{q}_k$ to
${q}_j$ usimg the inverse DFT. Must not be NULL. ${q}_j$ usimg the inverse DFT. Must not be NULL.
\item[\texttt{REAL4Vector *rhosqVec}] Pointer to a vector that is set to \item[\texttt{REAL4TimeSeries *rhosqVec}] Pointer to a time series which
$\rho^2(t_j)$ on exit. If NULL $\rho^2(t_j)$ is not stored. contains a vector of length $N$. If this is not NULL, the filter output $\r
ho^2(t_j)$
\item[\texttt{REAL4Vector *chisqVec}] Workspace vector used to compute and is stored in the vector.
store $\chi^2(t_j)$. Must not be NULL if \texttt{numChisqBins} is greater t
han \item[\texttt{COMPLEX8Vector *rhosqVec}] Pointer to a time series which
zero. Contains $\chi^2(t_j)$ on exit. contains a vector of length $N$. If this is not NULL, the complex filter
output $\rho(t_j) = x(t_j) + iy(t_j)$ is stored in the vector. This
quantity can be used by the coherent filtering code.
\item[\texttt{REAL4Vector *chisqVec}] Workspace vector of length $N$ used t
o
compute and store $\chi^2(t_j)$. Must not be NULL if \texttt{numChisqBins}
is
greater than zero. Contains $\chi^2(t_j)$ on exit.
\item[\texttt{FindChirpChisqParams *chisqParams}] Pointer to parameter \item[\texttt{FindChirpChisqParams *chisqParams}] Pointer to parameter
structure for \texttt{FindChirpChisqVeto()} function. Must not be NULL if structure for the $\chi^2$ veto. Must not be NULL if \texttt{numChisqBins}
\texttt{numChisqBins} is greater than zero. is
greater than zero.
\item[\texttt{FindChirpChisqInput *chisqInput}] Pointer to input data \item[\texttt{FindChirpChisqInput *chisqInput}] Pointer to input data
structure for \texttt{FindChirpChisqVeto()} function. Must not be NULL if structure for the $\chi^2$ veto. Must not be NULL if \texttt{numChisqBins}
\texttt{numChisqBins} is greater than zero. is
greater than zero.
\item[\texttt{FindChirpChisqInput *chisqInputBCV}] Pointer to input data
structure for the BCV $\chi^2$ veto. Must not be NULL if the approximant is
BCV and \texttt{numChisqBins} is greater than zero.
\item[\texttt{FindChirpFilterOutputVetoParams *filterOutputVetoParams}]
Pointer to the parameter structure for the additional signal based veto
function.
\end{description} \end{description}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* /*
* *
* typedefs of input structures used by functions in findchirp * typedefs of input structures used by functions in findchirp
* *
*/ */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsubsection*{Filter function input structures} \subsubsection*{Structure \texttt{FindChirpFilterInput}}
\idx[Type]{FindChirpFilterInput}
\noindent This structure groups the input data required for the
\texttt{FindChirpFilterSegment()} function into a single structure.
</lalLaTeX> </lalLaTeX>
#endif #endif
/* <lalVerbatim> */
/* --- input to the filtering functions --------------------------------- *
/
#pragma <lalVerbatim file="FindChirpHFindChirpFilterInput">
typedef struct typedef struct
tagFindChirpFilterInput tagFindChirpFilterInput
{ {
InspiralTemplate *tmplt;
FindChirpTemplate *fcTmplt; FindChirpTemplate *fcTmplt;
FindChirpSegment *segment; FindChirpSegment *segment;
} }
FindChirpFilterInput; FindChirpFilterInput;
#pragma </lalVerbatim> /* </lalVerbatim> */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsubsection*{Structure \texttt{FindChirpFilterInput}}
\idx[Type]{FindChirpSegmentVector}
\input{FindChirpHFindChirpFilterInput}
\noindent This structure groups the input data required for the
\texttt{FindChirpFilterSegment()} function into a single structure.
\begin{description} \begin{description}
\item[\texttt{InspiralTemplate *tmplt}] Pointer the structure that contains
the parameters of the template chirp.
\item[\texttt{FindChirpTemplate *fcTmplt}] Pointer to the input template \item[\texttt{FindChirpTemplate *fcTmplt}] Pointer to the input template
in a form that can be used by \texttt{FindChirpFilterSegment()} in a form that can be used by \texttt{FindChirpFilterSegment()}
\item[\texttt{FindChirpSegment *segment}] Pointer to the input data segment \item[\texttt{FindChirpSegment *segment}] Pointer to the input data segment
in a form that can be used by \texttt{FindChirpFilterSegment()} in a form that can be used by \texttt{FindChirpFilterSegment()}
\end{description} \end{description}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* <lalVerbatim> */
typedef struct
tagFindChirpBankSimParams
{
Approximant approx;
Order order;
REAL4 minMass;
REAL4 maxMass;
RandomParams *randParams;
INT4 maxMatch;
CHAR *frameName;
CHAR *frameChan;
}
FindChirpBankSimParams;
/* </lalVerbatim> */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\begin{description}
\item[\texttt{Approximant approx}] Waveform pproximant to use for injection
.
\item[\texttt{Approximant order}] Waveform order to use for injection.
\item[\texttt{REAL4 minMass}] Minimum mass of injected signals.
\item[\texttt{REAL4 maxMass}] Maximum mass of injected signals.
\end{description}
\vfill{\footnotesize\input{FindChirpHV}} \vfill{\footnotesize\input{FindChirpHV}}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* /*
* *
* function prototypes for memory management functions * function prototypes for memory management functions
* *
*/ */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\newpage\input{FindChirpLinkedListC}
</lalLaTeX>
#endif
void
LALFindChirpCreateTmpltNode (
LALStatus *status,
InspiralTemplate *thistmplt,
InspiralTemplateNode **tmpltNode
);
void
LALFindChirpDestroyTmpltNode (
LALStatus *status,
InspiralTemplateNode **tmpltNode
);
#if 0
<lalLaTeX>
\newpage\input{FindChirpMemoryC} \newpage\input{FindChirpMemoryC}
</lalLaTeX> </lalLaTeX>
#endif #endif
void void
LALInitializeDataSegmentVector (
LALStatus *status,
DataSegmentVector **dataSegVec,
REAL4TimeSeries *chan,
REAL4FrequencySeries *spec,
COMPLEX8FrequencySeries *resp,
FindChirpInitParams *params
);
void
LALFinalizeDataSegmentVector (
LALStatus *status,
DataSegmentVector **vector
);
void
LALCreateDataSegmentVector ( LALCreateDataSegmentVector (
LALStatus *status, LALStatus *status,
DataSegmentVector **vector, DataSegmentVector **vector,
FindChirpInitParams *params FindChirpInitParams *params
); );
void void
LALDestroyDataSegmentVector ( LALDestroyDataSegmentVector (
LALStatus *status, LALStatus *status,
DataSegmentVector **vector DataSegmentVector **vector
skipping to change at line 585 skipping to change at line 703
); );
void void
LALDestroyFindChirpSegmentVector ( LALDestroyFindChirpSegmentVector (
LALStatus *status, LALStatus *status,
FindChirpSegmentVector **vector FindChirpSegmentVector **vector
); );
/* /*
* *
* function prototypes for initialization, finalization of data functions
*
*/
#if 0
<lalLaTeX>
\newpage\input{FindChirpDataC}
</lalLaTeX>
#endif
void
LALFindChirpDataInit (
LALStatus *status,
FindChirpDataParams **output,
FindChirpInitParams *params
);
void
LALFindChirpDataFinalize (
LALStatus *status,
FindChirpDataParams **output
);
/*
*
* function prototypes for initialization, finalization of template functio
ns
*
*/
#if 0
<lalLaTeX>
\newpage\input{FindChirpTemplateC}
</lalLaTeX>
#endif
void
LALFindChirpTemplateInit (
LALStatus *status,
FindChirpTmpltParams **output,
FindChirpInitParams *params
);
void
LALFindChirpTemplateFinalize (
LALStatus *status,
FindChirpTmpltParams **output
);
/*
*
* function prototypes for initialization, finalization and filter function s * function prototypes for initialization, finalization and filter function s
* *
*/ */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\newpage\input{FindChirpFilterC} \newpage\input{FindChirpFilterC}
</lalLaTeX> </lalLaTeX>
#endif #endif
skipping to change at line 622 skipping to change at line 790
FindChirpInitParams *params FindChirpInitParams *params
); );
void void
LALDestroyFindChirpInput ( LALDestroyFindChirpInput (
LALStatus *status, LALStatus *status,
FindChirpFilterInput **output FindChirpFilterInput **output
); );
void void
LALFindChirpCreateCoherentInput(
LALStatus *status,
COMPLEX8TimeSeries **coherentInputData,
COMPLEX8TimeSeries *input,
SnglInspiralTable *templt,
REAL4 coherentSegmentLength,
INT4 corruptedDataLength
);
void
LALFindChirpFilterSegment ( LALFindChirpFilterSegment (
LALStatus *status, LALStatus *status,
InspiralEvent **eventList, SnglInspiralTable **eventList,
FindChirpFilterInput *input, FindChirpFilterInput *input,
FindChirpFilterParams *params FindChirpFilterParams *params
); );
void
LALFindChirpStoreEvent (
LALStatus *status,
FindChirpFilterInput *input,
FindChirpFilterParams *params,
SnglInspiralTable *thisEvent,
COMPLEX8 *q,
UINT4 kmax,
REAL4 norm,
UINT4 eventStartIdx,
UINT4 numChisqBins,
CHAR searchName[LIGOMETA_SEARCH_MAX]
);
void
LALFindChirpClusterEvents (
LALStatus *status,
SnglInspiralTable **eventList,
FindChirpFilterInput *input,
FindChirpFilterParams *params,
COMPLEX8 *q,
UINT4 kmax,
UINT4 numPoints,
UINT4 ignoreIndex,
REAL4 norm,
REAL4 modqsqThresh,
REAL4 chisqThreshFac,
UINT4 numChisqBins,
CHAR searchName[LIGOMETA_SEARCH_MAX]
);
#if 0
<lalLaTeX>
\newpage\input{FindChirpSimulationC}
</lalLaTeX>
#endif
void
LALFindChirpInjectSignals (
LALStatus *status,
REAL4TimeSeries *chan,
SimInspiralTable *events,
COMPLEX8FrequencySeries *resp
);
INT4
XLALFindChirpSetAnalyzeSegment (
DataSegmentVector *dataSegVec,
SimInspiralTable *injections
);
void
LALFindChirpSetAnalyseTemplate (
LALStatus *status,
UINT4 *analyseThisTmplt,
REAL4 mmFast,
REAL8 deltaF,
INT4 sampleRate,
FindChirpDataParams *fcDataParams,
int numTmplts,
InspiralTemplateNode *tmpltHead,
int numInjections,
SimInspiralTable *injections
);
UINT4
XLALCmprSgmntTmpltFlags (
UINT4 numInjections,
UINT4 TmpltFlag,
UINT4 SgmntFlag
);
UINT4
XLALFindChirpBankSimInitialize (
REAL4FrequencySeries *spec,
COMPLEX8FrequencySeries *resp,
REAL8 fLow
);
SimInspiralTable *
XLALFindChirpBankSimInjectSignal (
DataSegmentVector *dataSegVec,
COMPLEX8FrequencySeries *resp,
SimInspiralTable *injParams,
FindChirpBankSimParams *simParams
);
REAL4
XLALFindChirpBankSimSignalNorm(
FindChirpDataParams *fcDataParams,
FindChirpSegmentVector *fcSegVec,
UINT4 cut
);
SimInstParamsTable *
XLALFindChirpBankSimMaxMatch (
SnglInspiralTable **bestTmplt,
REAL4 matchNorm
);
SimInstParamsTable *
XLALFindChirpBankSimComputeMatch (
SnglInspiralTable *tmplt,
REAL4 matchNorm
);
#ifdef __cplusplus #ifdef __cplusplus
#pragma { #pragma {
} }
#endif #endif
#endif /* _FINDCHIRPH_H */ #endif /* _FINDCHIRPH_H */
 End of changes. 97 change blocks. 
358 lines changed or deleted 659 lines changed or added


 FindChirpChisq.h   FindChirpChisq.h 
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
* *
* File Name: FindChirpChisq.h * File Name: FindChirpChisq.h
* *
* Author: Anderson, W. G., and Brown, D. A. * Author: Anderson, W. G., and Brown, D. A.
* *
* Revision: $Id: FindChirpChisq.h,v 1.5 2002/01/18 01:47:31 duncan Exp $ * Revision: $Id: FindChirpChisq.h,v 1.19 2005/01/11 00:32:27 duncan Exp $
* *
*----------------------------------------------------------------------- *-----------------------------------------------------------------------
*/ */
#if 0 #if 0
<lalVerbatim file="FindChirpChisqHV"> <lalVerbatim file="FindChirpChisqHV">
Author: Anderson, W. G., and Brown, D. A. Author: Anderson, W. G., and Brown, D. A.
$Id: FindChirpChisq.h,v 1.5 2002/01/18 01:47:31 duncan Exp $ $Id: FindChirpChisq.h,v 1.19 2005/01/11 00:32:27 duncan Exp $
</lalVerbatim> </lalVerbatim>
<lalLaTeX> <lalLaTeX>
\section{Header \texttt{FindChirpChisq.h}} \section{Header \texttt{FindChirpChisq.h}}
\label{s:FindChirpChisq.h} \label{s:FindChirpChisq.h}
Provides prototypes and functions to perform a $\chi^2$ veto on binary Provides prototypes and functions to perform a $\chi^2$ veto on binary
inspiral chirps using data generated by the \texttt{FindChirpFilter()} inspiral chirps using data generated by the \texttt{FindChirpFilter()}
function. function.
skipping to change at line 40 skipping to change at line 40
\end{verbatim} \end{verbatim}
\input{FindChirpChisqHDoc} \input{FindChirpChisqHDoc}
</lalLaTeX> </lalLaTeX>
#endif #endif
#ifndef _FINDCHIRPCHISQH_H #ifndef _FINDCHIRPCHISQH_H
#define _FINDCHIRPCHISQH_H #define _FINDCHIRPCHISQH_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/FindChirpDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#pragma } #pragma }
#endif #endif
NRCSID (SPFINDCHIRPCHISQH, "$Id: FindChirpChisq.h,v 1.5 2002/01/18 01:47:31 duncan Exp $"); NRCSID (SPFINDCHIRPCHISQH, "$Id: FindChirpChisq.h,v 1.19 2005/01/11 00:32:2 7 duncan Exp $");
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsection*{Error codes} \subsection*{Error codes}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* <lalErrTable> */ /* <lalErrTable> */
#define FINDCHIRPCHISQH_ENULL 1 #define FINDCHIRPCHISQH_ENULL 1
#define FINDCHIRPCHISQH_ENNUL 2 #define FINDCHIRPCHISQH_ENNUL 2
#define FINDCHIRPCHISQH_ENUMZ 3 #define FINDCHIRPCHISQH_ENUMZ 3
#define FINDCHIRPCHISQH_ECHIZ 4 #define FINDCHIRPCHISQH_ECHIZ 4
#define FINDCHIRPCHISQH_EALOC 5 #define FINDCHIRPCHISQH_EALOC 5
#define FINDCHIRPCHISQH_EUAPX 6
#define FINDCHIRPCHISQH_EIAPX 7
#define FINDCHIRPCHISQH_EBINS 8
#define FINDCHIRPCHISQH_MSGENULL "Null pointer" #define FINDCHIRPCHISQH_MSGENULL "Null pointer"
#define FINDCHIRPCHISQH_MSGENNUL "Non-null pointer" #define FINDCHIRPCHISQH_MSGENNUL "Non-null pointer"
#define FINDCHIRPCHISQH_MSGENUMZ "Number of points is zero or negative" #define FINDCHIRPCHISQH_MSGENUMZ "Number of points is zero or negative"
#define FINDCHIRPCHISQH_MSGECHIZ "Number of chisq bins is zero or negative" #define FINDCHIRPCHISQH_MSGECHIZ "Number of chisq bins is zero or negative"
#define FINDCHIRPCHISQH_MSGEALOC "Memory allocation error" #define FINDCHIRPCHISQH_MSGEALOC "Memory allocation error"
#define FINDCHIRPCHISQH_MSGEUAPX "Unknown waveform approximant"
#define FINDCHIRPCHISQH_MSGEIAPX "Incorrect waveform approximant"
#define FINDCHIRPCHISQH_MSGEBINS "Error computing chisq bin boundaries"
/* </lalErrTable> */ /* </lalErrTable> */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsection*{Types} \subsection*{Types}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* --- structure for storing input to the chisq veto --------------------- */ /* --- structure for storing input to the chisq veto --------------------- */
#pragma <lalVerbatim file="FindChirpChisqHFindChirpChisqInput"> /* <lalVerbatim file="FindChirpChisqHFindChirpChisqInput"> */
typedef struct typedef struct
tagFindChirpChisqInput tagFindChirpChisqInput
{ {
COMPLEX8Vector *qtildeVec; COMPLEX8Vector *qtildeVec;
COMPLEX8Vector *qVec; COMPLEX8Vector *qVec;
} }
FindChirpChisqInput; FindChirpChisqInput;
#pragma </lalVerbatim> /* </lalVerbatim> */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsubsection*{Structure \texttt{FindChirpChisqInput}} \subsubsection*{Structure \texttt{FindChirpChisqInput}}
\idx[Type]{FindChirpChisqInput} \idx[Type]{FindChirpChisqInput}
\input{FindChirpChisqHFindChirpChisqInput} \input{FindChirpChisqHFindChirpChisqInput}
\noindent This structure contains the input to the $\chi^2$ veto function. \noindent This structure contains the input to the $\chi^2$ veto function.
The quantities should be populated by \texttt{FindChirpFilter()} on entry. The quantities should be populated by \texttt{FindChirpFilter()} on entry.
The fields are: The fields are:
skipping to change at line 104 skipping to change at line 111
\item[\texttt{COMPLEX8Vector *qtildeVec}] A vector containing the frequncy \item[\texttt{COMPLEX8Vector *qtildeVec}] A vector containing the frequncy
domain quantity $\tilde{q}_k$ as defined in \texttt{FindChirpFilter()}. domain quantity $\tilde{q}_k$ as defined in \texttt{FindChirpFilter()}.
\item[\texttt{COMPLEX8Vector *qVec}] A vector containing the time \item[\texttt{COMPLEX8Vector *qVec}] A vector containing the time
domain quantity $q_j$ as defined in \texttt{FindChirpFilter()}. domain quantity $q_j$ as defined in \texttt{FindChirpFilter()}.
\end{description} \end{description}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* --- parameter structure for the chisq veto ---------------------------- */ /* --- parameter structure for the chisq veto ---------------------------- */
#pragma <lalVerbatim file="FindChirpChisqHFindChirpChisqParams"> /* <lalVerbatim file="FindChirpChisqHFindChirpChisqParams"> */
typedef struct typedef struct
tagFindChirpChisqParams tagFindChirpChisqParams
{ {
REAL4 chisqNorm; REAL4 norm;
REAL4 a1;
REAL4 b1;
REAL4 b2;
UINT4Vector *chisqBinVec; UINT4Vector *chisqBinVec;
UINT4Vector *chisqBinVecBCV;
ComplexFFTPlan *plan; ComplexFFTPlan *plan;
COMPLEX8Vector *qtildeBinVec; COMPLEX8Vector *qtildeBinVec;
COMPLEX8Vector *qtildeBinVecBCV;
COMPLEX8Vector **qBinVecPtr; COMPLEX8Vector **qBinVecPtr;
COMPLEX8Vector **qBinVecPtrBCV;
Approximant approximant;
} }
FindChirpChisqParams; FindChirpChisqParams;
#pragma </lalVerbatim> /* </lalVerbatim> */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsubsection*{Structure \texttt{FindChirpChisqParams}} \subsubsection*{Structure \texttt{FindChirpChisqParams}}
\idx[Type]{FindChirpChisqParams} \idx[Type]{FindChirpChisqParams}
\input{FindChirpChisqHFindChirpChisqParams} \input{FindChirpChisqHFindChirpChisqParams}
\noindent This structure contains the parameters used by the $\chi^2$ veto \noindent This structure contains the parameters used by the $\chi^2$ veto
function \texttt{FindChirpChisqVeto()}. It is created and destroyed by the function \texttt{FindChirpChisqVeto()}. It is created and destroyed by the
\texttt{FindChirpChisqVetoInit()} and \texttt{FindChirpChisqVetoFinalize()} \texttt{FindChirpChisqVetoInit()} and \texttt{FindChirpChisqVetoFinalize()}
functions. The fields are: functions. The fields are:
\begin{description} \begin{description}
\item[\texttt{REAL4 chisqNorm}] The normalization... \item[\texttt{REAL4 norm}] The normalization factor for the SP templates.
Equals $4 \Delta t / (N segNorm)$.
\item[\texttt{UINT4Vector *chisqBinVec}] A vector containing the... \item[\texttt{REAL4 a1}] BCV-template normalization parameter.
\item[\texttt{REAL4 b1}] BCV-template normalization parameter.
\item[\texttt{REAL4 b2}] BCV-template normalization parameter.
\item[\texttt{REAL4 bankMatch}] Template bank match...
\item[\texttt{UINT4Vector *chisqBinVec}] A vector containing the boundaries
of the bins for the chi-squared veto for the stationary phase chirps, or th
e
boundaries of the bins for the first sum of the chi-squared veto for the
BCV templates.
\item[\texttt{UINT4Vector *chisqBinVecBCV}] A vector containing the boundar
ies
of the bins for the second part of the chi-squared statistic, for the BCV
templates.
\item[\texttt{ComplexFFTPlan *plan}] The FFTW plan used by the inverse DFT. \item[\texttt{ComplexFFTPlan *plan}] The FFTW plan used by the inverse DFT.
\item[\texttt{COMPLEX8Vector *qtildeBinVec}] ... \item[\texttt{COMPLEX8Vector *qtildeBinVec}] ...
\item[\texttt{COMPLEX8Vector **qBinVecPtr}] ... \item[\texttt{COMPLEX8Vector *qtildeBinVecBCV}] ...
\item[\texttt{COMPLEX8Vector **qBinVecPtr}] Pointer to an array of pointers
.
Corresponds to $q^{(1)}_l(t_j)$, which is the contribution of the $l$-th
frequency
bin to the signal-to-noise ratio at the time $t_j$ (up to the appropriate
normalization). It is used for both the stationary phase chirps and the
BCV templates.
\item[\texttt{COMPLEX8Vector **qBinVecPtrBCV}] Pointer to an array of point
ers.
Corresponds to $q^{(2)}_l(t_j)$, which is the contribution of the $l$-th
frequency
bin to the signal-to-noise ratio at the time $t_j$ (up to the appropriate
normalization). It is used only for the BCV templates.
\end{description} \end{description}
</lalLaTeX> </lalLaTeX>
#endif #endif
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\vfill{\footnotesize\input{FindChirpChisqHV}} \vfill{\footnotesize\input{FindChirpChisqHV}}
</lalLaTeX> </lalLaTeX>
#endif #endif
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\newpage\input{FindChirpChisqC} \newpage\input{FindChirpChisqInitC}
</lalLaTeX> </lalLaTeX>
#endif #endif
void void
LALFindChirpChisqVetoInit ( LALFindChirpChisqVetoInit (
LALStatus *status, LALStatus *status,
FindChirpChisqParams *params, FindChirpChisqParams *params,
UINT4 numChisqBins, UINT4 numChisqBins,
UINT4 numPoints UINT4 numPoints
); );
void void
LALFindChirpChisqVetoFinalize ( LALFindChirpChisqVetoFinalize (
LALStatus *status, LALStatus *status,
FindChirpChisqParams *params, FindChirpChisqParams *params,
UINT4 numChisqBins UINT4 numChisqBins
); );
#if 0
<lalLaTeX>
\newpage\input{FindChirpChisqC}
</lalLaTeX>
#endif
void
LALFindChirpComputeChisqBins(
LALStatus *status,
UINT4Vector *chisqBinVec,
FindChirpSegment *fcSeg,
UINT4 kmax
);
void void
LALFindChirpChisqVeto ( LALFindChirpChisqVeto (
LALStatus *status, LALStatus *status,
REAL4Vector *chisqVec, REAL4Vector *chisqVec,
FindChirpChisqInput *input, FindChirpChisqInput *input,
FindChirpChisqParams *params FindChirpChisqParams *params
); );
#ifdef __cplusplus #ifdef __cplusplus
#pragma { #pragma {
 End of changes. 19 change blocks. 
12 lines changed or deleted 74 lines changed or added


 FindChirpSP.h   FindChirpSP.h 
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
* *
* File Name: FindChirpSP.h * File Name: FindChirpSP.h
* *
* Author: Brown, D. A. * Author: Brown, D. A.
* *
* Revision: $Id: FindChirpSP.h,v 1.6 2002/01/18 01:47:31 duncan Exp $ * Revision: $Id: FindChirpSP.h,v 1.22 2005/11/05 02:48:30 duncan Exp $
* *
*----------------------------------------------------------------------- *-----------------------------------------------------------------------
*/ */
#if 0 #if 0
<lalVerbatim file="FindChirpSPHV"> <lalVerbatim file="FindChirpSPHV">
Author: Brown, D. A. Author: Brown, D. A.
$Id: FindChirpSP.h,v 1.6 2002/01/18 01:47:31 duncan Exp $ $Id: FindChirpSP.h,v 1.22 2005/11/05 02:48:30 duncan Exp $
</lalVerbatim> </lalVerbatim>
<lalLaTeX> <lalLaTeX>
\section{Header \texttt{FindChirpSP.h}} \section{Header \texttt{FindChirpSP.h}}
\label{s:FindChirpSP.h} \label{s:FindChirpSP.h}
Provides structures and functions to condition interferometer data Provides structures and functions to condition interferometer data
and generate binary inspiral chirps using the stationary phase approximatio n. and generate binary inspiral chirps using the stationary phase approximatio n.
\subsection*{Synopsis} \subsection*{Synopsis}
skipping to change at line 43 skipping to change at line 43
#endif #endif
#ifndef _FINDCHIRPSPH_H #ifndef _FINDCHIRPSPH_H
#define _FINDCHIRPSPH_H #define _FINDCHIRPSPH_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/RealFFT.h> #include <lal/RealFFT.h>
#include <lal/DataBuffer.h> #include <lal/DataBuffer.h>
#include <lal/LALInspiral.h> #include <lal/LALInspiral.h>
#include <lal/FindChirp.h> #include <lal/FindChirp.h>
#include <lal/FindChirpChisq.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#pragma } #pragma }
#endif #endif
NRCSID (FINDCHIRPSPH, "$Id: FindChirpSP.h,v 1.6 2002/01/18 01:47:31 duncan Exp $"); NRCSID (FINDCHIRPSPH, "$Id: FindChirpSP.h,v 1.22 2005/11/05 02:48:30 duncan Exp $");
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsection*{Error codes} \subsection*{Error codes}
</lalLaTeX> </lalLaTeX>
#endif #endif
/* <lalErrTable> */ /* <lalErrTable> */
#define FINDCHIRPSPH_ENULL 1 #define FINDCHIRPSPH_ENULL 1
#define FINDCHIRPSPH_ENNUL 2 #define FINDCHIRPSPH_ENNUL 2
#define FINDCHIRPSPH_EALOC 3 #define FINDCHIRPSPH_EALOC 3
#define FINDCHIRPSPH_ENUMZ 4 #define FINDCHIRPSPH_ENUMZ 4
#define FINDCHIRPSPH_ESEGZ 5 #define FINDCHIRPSPH_ESEGZ 5
#define FINDCHIRPSPH_EMISM 6 #define FINDCHIRPSPH_EMISM 6
#define FINDCHIRPSPH_EDELT 7 #define FINDCHIRPSPH_EDELT 7
#define FINDCHIRPSPH_EFLOW 8 #define FINDCHIRPSPH_EFLOW 8
#define FINDCHIRPSPH_EDYNR 9 #define FINDCHIRPSPH_EDYNR 9
#define FINDCHIRPSPH_EISTN 10 #define FINDCHIRPSPH_EISTN 10
#define FINDCHIRPSPH_EDIVZ 11
#define FINDCHIRPSPH_EMAPX 12
#define FINDCHIRPSPH_EUAPX 13
#define FINDCHIRPSPH_MSGENULL "Null pointer" #define FINDCHIRPSPH_MSGENULL "Null pointer"
#define FINDCHIRPSPH_MSGENNUL "Non-null pointer" #define FINDCHIRPSPH_MSGENNUL "Non-null pointer"
#define FINDCHIRPSPH_MSGEALOC "Memory allocation error" #define FINDCHIRPSPH_MSGEALOC "Memory allocation error"
#define FINDCHIRPSPH_MSGENUMZ "Invalid number of segments" #define FINDCHIRPSPH_MSGENUMZ "Invalid number of segments"
#define FINDCHIRPSPH_MSGESEGZ "Invalid number of points in segments" #define FINDCHIRPSPH_MSGESEGZ "Invalid number of points in segments"
#define FINDCHIRPSPH_MSGEMISM "Mismatch between number of points in segment s" #define FINDCHIRPSPH_MSGEMISM "Mismatch between number of points in segment s"
#define FINDCHIRPSPH_MSGEDELT "deltaT is zero or negative" #define FINDCHIRPSPH_MSGEDELT "deltaT is zero or negative"
#define FINDCHIRPSPH_MSGEFLOW "Low frequency cutoff is negative" #define FINDCHIRPSPH_MSGEFLOW "Low frequency cutoff is negative"
#define FINDCHIRPSPH_MSGEDYNR "Dynamic range scaling is zero or negative" #define FINDCHIRPSPH_MSGEDYNR "Dynamic range scaling is zero or negative"
#define FINDCHIRPSPH_MSGEISTN "Truncation of inverse power spectrum is nega tive" #define FINDCHIRPSPH_MSGEISTN "Truncation of inverse power spectrum is nega tive"
#define FINDCHIRPSPH_MSGEDIVZ "Attempting to divide by zero"
#define FINDCHIRPSPH_MSGEMAPX "Mismatch in waveform approximant"
#define FINDCHIRPSPH_MSGEUAPX "Unknown approximant"
/* </lalErrTable> */ /* </lalErrTable> */
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\subsection*{Types} \subsection*{Types}
</lalLaTeX>
#endif
/* --- the parameter structure for the data conditioning function --------
*/
#pragma <lalVerbatim file="FindChirpSPHFindChirpSPDataParams">
typedef struct
tagFindChirpSPDataParams
{
REAL4Vector *ampVec;
RealFFTPlan *fwdPlan;
RealFFTPlan *invPlan;
REAL4Vector *vVec;
REAL4Vector *wVec;
COMPLEX8Vector *wtildeVec;
REAL4Vector *tmpltPowerVec;
REAL4 deltaT;
REAL4 fLow;
REAL4 dynRange;
UINT4 invSpecTrunc;
}
FindChirpSPDataParams;
#pragma </lalVerbatim>
#if 0
<lalLaTeX>
\subsubsection*{Structure \texttt{FindChirpSPDataParams}}
\idx[Type]{FindChirpSPDataParams}
\input{FindChirpSPHFindChirpSPDataParams}
\noindent This structure contains the parameters needed to call the
\texttt{FindChirpSPData()} function. It should be initialized by
\texttt{FindChirpSPDataInit()} and destroyed by
\texttt{FindChirpSPDataFinalize()}. The fields are:
\begin{description}
\item[\texttt{REAL4Vector *ampVec}] A vector containing the frequency domai
n
quantity $k/N$, where $k$ is the frequency series index and $N$ is the numb
er
of points in a data segment.
\item[\texttt{REAL4Vector *fwdPlan}] An FFTW plan used to transform the
time domain interferometer data $v(t_j)$ into its DFT $\tilde{v}_k$.
\item[\texttt{REAL4Vector *fwdPlan}] An FFTW plan used to transform the
dimensionless frequency domain interferometer strain $\tilde{w}_k$ into
the quantity $N w(t_j)$ to allow time domain trunction of the inverse
power spectrum.
\item[\texttt{REAL4Vector *vVec}] {\color{red} FIXME} A vector to contain
the time domain interferometer output $v(t_j)$. This is obsolete since LIGO
gives us $v(t_j)$ as floats. The 40m prototype gave integers which needed t
o
be cast to floats.
\item[\texttt{REAL4Vector *wVec}] A vector used as workspace when truncatin
g
the imverse power spectrum in the time domain.
\item[\texttt{COMPLEX8Vector *wtildeVec}] A which on exit from
\texttt{FindChirpSPData()} contains the inverse of the strain one sided pow
er
spectral density, after trunction in the time domain, that is
$ \tilde{w}_k = {1}/{\ospsd}$.
\item[\texttt{REAL4Vector *tmpltPowerVec}] A vector which on exit from
\texttt{FindChirpSPData()} contains the quantity
\begin{equation}
\mathtt{tmpltPower[k]} = \frac{f^{-7/3}}{\ospsd}
\end{equation}
\item[\texttt{REAL4 deltaT}] {\color{red} FIXME} The sampling interval
$\Delta t$. Should be a \texttt{REAL8} or derived from the input time serie
s
\texttt{chan}.
\item[\texttt{REAL4 fLow}] The low frequency cutoff for the algorithm. All
data is zero below this frequency.
\item[\texttt{REAL4 dynRange}] A dynamic range factor which cancells from
the filter output (if set correctly in \texttt{FindChirpSPTmplt()} as well)
.
This allows quantities to be stored in the range of \texttt{REAL4} rather
than \texttt{REAL8}.
\item[\texttt{UINT4 invSpecTrunc}] The length to which to truncate the inve
rse
power spectral density of the data in the time domain. If set to zero, no
truncation is performed.
\end{description}
</lalLaTeX>
#endif
/* --- vector of DataSegment, as defined the framedata package -----------
*/
#pragma <lalVerbatim file="FindChirpSPHFindChirpSPTmpltParams">
typedef struct
tagFindChirpSPTmpltParams
{
REAL4 deltaT;
REAL4 fLow;
REAL4 dynRange;
REAL4Vector *xfacVec;
}
FindChirpSPTmpltParams;
#pragma </lalVerbatim>
#if 0
<lalLaTeX>
\subsubsection*{Structure \texttt{FindChirpSPTmpltParams}}
\idx[Type]{FindChirpSPTmpltParams}
\input{FindChirpSPHFindChirpSPTmpltParams} None.
\noindent This structure contains the parameters for generation of
stationary phase templates by the function \texttt{FindChirpSPTmplt()}
It should be initialized by \texttt{FindChirpSPTmpltInit()} and destroyed b
y
\texttt{FindChirpSPTmpltFinalize()}. The fields are:
\begin{description}
\item[\texttt{REAL4 *deltaT}] {\color{red} FIXME} The sampling interval
$\Delta t$. Should be a \texttt{REAL8}.
\item[\texttt{REAL4 fLow}] The low frequency cutoff for the algorithm. All
data is zero below this frequency.
\item[\texttt{REAL4 dynRange}] A dynamic range factor which cancells from
the filter output (if set correctly in \texttt{FindChirpSPData()} as well).
This allows quantities to be stored in the range of \texttt{REAL4} rather
than \texttt{REAL8}.
\item[\texttt{REAL4Vector *xfacVec}] A vector containing the frequency
domain quantity $k^{-7/6}$.
\end{description}
</lalLaTeX> </lalLaTeX>
#endif #endif
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\vfill{\footnotesize\input{FindChirpSPHV}} \vfill{\footnotesize\input{FindChirpSPHV}}
</lalLaTeX> </lalLaTeX>
#endif #endif
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\newpage\input{FindChirpSPDataC} \newpage\input{FindChirpSPDataC}
</lalLaTeX> </lalLaTeX>
#endif #endif
void void
LALFindChirpSPDataInit (
LALStatus *status,
FindChirpSPDataParams **output,
FindChirpInitParams *params
);
void
LALFindChirpSPData ( LALFindChirpSPData (
LALStatus *status, LALStatus *status,
FindChirpSegmentVector *fcSegVec, FindChirpSegmentVector *fcSegVec,
DataSegmentVector *dataSegVec, DataSegmentVector *dataSegVec,
FindChirpSPDataParams *params FindChirpDataParams *params
);
void
LALFindChirpSPDataFinalize (
LALStatus *status,
FindChirpSPDataParams **output
); );
#if 0 #if 0
<lalLaTeX> <lalLaTeX>
\newpage\input{FindChirpSPTemplateC} \newpage\input{FindChirpSPTemplateC}
</lalLaTeX> </lalLaTeX>
#endif #endif
void void
LALFindChirpSPTemplateInit (
LALStatus *status,
FindChirpSPTmpltParams **output,
FindChirpInitParams *params
);
void
LALFindChirpSPTemplate ( LALFindChirpSPTemplate (
LALStatus *status, LALStatus *status,
FindChirpTemplate *fcTmplt, FindChirpTemplate *fcTmplt,
InspiralTemplate *tmplt, InspiralTemplate *tmplt,
FindChirpSPTmpltParams *params FindChirpTmpltParams *params
);
void
LALFindChirpSPTemplateFinalize (
LALStatus *status,
FindChirpSPTmpltParams **output
); );
#ifdef __cplusplus #ifdef __cplusplus
#pragma { #pragma {
} }
#endif #endif
#endif /* _FINDCHIRPSPH_H */ #endif /* _FINDCHIRPSPH_H */
 End of changes. 12 change blocks. 
165 lines changed or deleted 13 lines changed or added


 FindRoot.h   FindRoot.h 
#if 0 /* autodoc block */ #if 0 /* autodoc block */
<lalVerbatim file="FindRootHV"> <lalVerbatim file="FindRootHV">
$Id: FindRoot.h,v 1.6 2001/02/22 00:27:07 jolien Exp $ $Id: FindRoot.h,v 1.10 2005/06/20 17:13:16 kipp Exp $
</lalVerbatim> </lalVerbatim>
<lalLaTeX> <lalLaTeX>
\section{Header \texttt{FindRoot.h}} \section{Header \texttt{FindRoot.h}}
\label{s:FindRoot.h} \label{s:FindRoot.h}
Root finding routines. Root finding routines.
\subsection*{Synopsis} \subsection*{Synopsis}
skipping to change at line 34 skipping to change at line 34
#ifndef _FINDROOT_H #ifndef _FINDROOT_H
#define _FINDROOT_H #define _FINDROOT_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (FINDROOTH, "$Id: FindRoot.h,v 1.6 2001/02/22 00:27:07 jolien Exp $" ); NRCSID (FINDROOTH, "$Id: FindRoot.h,v 1.10 2005/06/20 17:13:16 kipp Exp $") ;
#if 0 /* autodoc block */ #if 0 /* autodoc block */
<lalLaTeX> <lalLaTeX>
\subsection*{Error conditions} \subsection*{Error conditions}
\input{FindRootHErrTab} \input{FindRootHErrTab}
</lalLaTeX> </lalLaTeX>
<lalErrTable file="FindRootHErrTab"> <lalErrTable file="FindRootHErrTab">
skipping to change at line 76 skipping to change at line 76
typedef void (REAL4LALFunction) (LALStatus *s, REAL4 *y, REAL4 x, void *p); typedef void (REAL4LALFunction) (LALStatus *s, REAL4 *y, REAL4 x, void *p);
typedef void (REAL8LALFunction) (LALStatus *s, REAL8 *y, REAL8 x, void *p); typedef void (REAL8LALFunction) (LALStatus *s, REAL8 *y, REAL8 x, void *p);
\end{verbatim} \end{verbatim}
These are function pointers to functions that map real numbers to real numb ers. These are function pointers to functions that map real numbers to real numb ers.
\begin{verbatim} \begin{verbatim}
typedef struct typedef struct
tagSFindRootIn tagSFindRootIn
{ {
REAL4LALFunction *function; void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p);
REAL4 xmax; REAL4 xmax;
REAL4 xmin; REAL4 xmin;
REAL4 xacc; REAL4 xacc;
} }
SFindRootIn; SFindRootIn;
typedef struct typedef struct
tagDFindRootIn tagDFindRootIn
{ {
REAL8LALFunction *function; void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p);
REAL8 xmax; REAL8 xmax;
REAL8 xmin; REAL8 xmin;
REAL8 xacc; REAL8 xacc;
} }
DFindRootIn; DFindRootIn;
\end{verbatim} \end{verbatim}
These are the input structures to the root finding routines. The fields ar e: These are the input structures to the root finding routines. The fields ar e:
\begin{description} \begin{description}
\item[\texttt{function}] The function to find the root of. \item[\texttt{function}] The function to find the root of.
\item[\texttt{xmax}] The maximum value of the domain interval to look for t he root. \item[\texttt{xmax}] The maximum value of the domain interval to look for t he root.
\item[\texttt{xmax}] The minimum value of the domain interval to look for t he root. \item[\texttt{xmax}] The minimum value of the domain interval to look for t he root.
\item[\texttt{xacc}] The accuracy desired for the root. \item[\texttt{xacc}] The accuracy desired for the root.
\end{description} \end{description}
</lalLaTeX> </lalLaTeX>
#endif /* autodoc block */ #endif /* autodoc block */
typedef void (REAL4LALFunction) (LALStatus *s, REAL4 *y, REAL4 x, void *p);
typedef void (REAL8LALFunction) (LALStatus *s, REAL8 *y, REAL8 x, void *p);
typedef struct typedef struct
tagSFindRootIn tagSFindRootIn
{ {
REAL4LALFunction *function; void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p);
REAL4 xmax; REAL4 xmax;
REAL4 xmin; REAL4 xmin;
REAL4 xacc; REAL4 xacc;
} }
SFindRootIn; SFindRootIn;
typedef struct typedef struct
tagDFindRootIn tagDFindRootIn
{ {
REAL8LALFunction *function; void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p);
REAL8 xmax; REAL8 xmax;
REAL8 xmin; REAL8 xmin;
REAL8 xacc; REAL8 xacc;
} }
DFindRootIn; DFindRootIn;
#if 0 /* autodoc block */ #if 0 /* autodoc block */
<lalLaTeX> <lalLaTeX>
\newpage\input{FindRootC} \newpage\input{FindRootC}
</lalLaTeX> </lalLaTeX>
#endif /* autodoc block */ #endif /* autodoc block */
void void
LALSBracketRoot ( LALSBracketRoot (
LALStatus *status, LALStatus *status,
SFindRootIn *inout, SFindRootIn *inout,
void *params void *params
); );
int
XLALDBracketRoot(
REAL8 (*y)(REAL8, void *),
REAL8 *xmin,
REAL8 *xmax,
void *params
);
void void
LALDBracketRoot ( LALDBracketRoot (
LALStatus *status, LALStatus *status,
DFindRootIn *inout, DFindRootIn *inout,
void *params void *params
); );
void void
LALSBisectionFindRoot ( LALSBisectionFindRoot (
LALStatus *status, LALStatus *status,
REAL4 *root, REAL4 *root,
SFindRootIn *input, SFindRootIn *input,
void *params void *params
); );
REAL8
XLALDBisectionFindRoot (
REAL8 (*y)(REAL8, void *),
REAL8 xmin,
REAL8 xmax,
REAL8 xacc,
void *params
);
void void
LALDBisectionFindRoot ( LALDBisectionFindRoot (
LALStatus *status, LALStatus *status,
REAL8 *root, REAL8 *root,
DFindRootIn *input, DFindRootIn *input,
void *params void *params
); );
#if 0 /* autodoc block */ #if 0 /* autodoc block */
 End of changes. 9 change blocks. 
21 lines changed or deleted 35 lines changed or added


 FlatMesh.h   FlatMesh.h 
/************************************* <lalVerbatim file="FlatMeshHV"> /************************************* <lalVerbatim file="FlatMeshHV">
Author: Creighton, T. D. Author: Creighton, T. D.
$Id: FlatMesh.h,v 1.4 2001/08/24 19:20:26 teviet Exp $ $Id: FlatMesh.h,v 1.6 2005/06/17 18:38:33 jolien Exp $
**************************************************** </lalVerbatim> */ **************************************************** </lalVerbatim> */
/********************************************************** <lalLaTeX> /********************************************************** <lalLaTeX>
\section{Header \texttt{FlatMesh.h}} \section{Header \texttt{FlatMesh.h}}
\label{s:FlatMesh.h} \label{s:FlatMesh.h}
Provides routines to place search meshes for parameter spaces with Provides routines to place search meshes for parameter spaces with
constant parameter metrics. constant parameter metrics.
skipping to change at line 110 skipping to change at line 110
#ifndef _FLATMESH_H #ifndef _FLATMESH_H
#define _FLATMESH_H #define _FLATMESH_H
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID(FLATMESHH,"$Id: FlatMesh.h,v 1.4 2001/08/24 19:20:26 teviet Exp $"); NRCSID(FLATMESHH,"$Id: FlatMesh.h,v 1.6 2005/06/17 18:38:33 jolien Exp $");
/********************************************************** <lalLaTeX> /********************************************************** <lalLaTeX>
\subsection*{Error conditions} \subsection*{Error conditions}
****************************************** </lalLaTeX><lalErrTable> */ ****************************************** </lalLaTeX><lalErrTable> */
#define FLATMESHH_ENUL 1 #define FLATMESHH_ENUL 1
#define FLATMESHH_EOUT 2 #define FLATMESHH_EOUT 2
#define FLATMESHH_EMEM 3 #define FLATMESHH_EMEM 3
#define FLATMESHH_EDIM 4 #define FLATMESHH_EDIM 4
#define FLATMESHH_ELEN 5 #define FLATMESHH_ELEN 5
skipping to change at line 190 skipping to change at line 190
/* <lalLaTeX> /* <lalLaTeX>
\vfill{\footnotesize\input{FlatMeshHV}} \vfill{\footnotesize\input{FlatMeshHV}}
</lalLaTeX> */ </lalLaTeX> */
/* Function prototypes. */ /* Function prototypes. */
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{FlatMeshC} \newpage\input{FlatMeshC}
</lalLaTeX> */ </lalLaTeX> */
void void
LALCreateFlatMesh( LALStatus *stat, LALCreateFlatMesh( LALStatus *status,
REAL4VectorSequence **mesh, REAL4VectorSequence **mesh,
FlatMeshParamStruc *params ); FlatMeshParamStruc *params );
void void
LALRectIntersect( LALStatus *stat, LALRectIntersect( LALStatus *status,
REAL4VectorSequence *mesh, REAL4VectorSequence *mesh,
REAL4VectorSequence *controlPoints ); REAL4VectorSequence *controlPoints );
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{FlatMeshTestC} \newpage\input{FlatMeshTestC}
\newpage\input{DirectedMeshTestC}
</lalLaTeX> */ </lalLaTeX> */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _FLATMESH_H */ #endif /* _FLATMESH_H */
 End of changes. 5 change blocks. 
4 lines changed or deleted 6 lines changed or added


 FrameCache.h   FrameCache.h 
/**** <lalVerbatim file="FrameCacheHV"> /**** <lalVerbatim file="FrameCacheHV">
* Author: Jolien D. E. Creighton * Author: Jolien D. E. Creighton
* $Id: FrameCache.h,v 1.1 2002/05/30 16:15:16 jolien Exp $ * $Id: FrameCache.h,v 1.4 2005/01/28 23:15:09 jolien Exp $
**** </lalVerbatim> */ **** </lalVerbatim> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* \section{Header \texttt{FrameCache.h}} * \section{Header \texttt{FrameCache.h}}
* *
* Routines for manipulating a cache of available frame files. * Routines for manipulating a cache of available frame files.
* *
* \subsection*{Synopsis} * \subsection*{Synopsis}
* \begin{verbatim} * \begin{verbatim}
skipping to change at line 34 skipping to change at line 34
#ifndef _FRAMECACHE_H #ifndef _FRAMECACHE_H
#define _FRAMECACHE_H #define _FRAMECACHE_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#pragma } #pragma }
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
NRCSID( FRAMECACHEH, "$Id: FrameCache.h,v 1.1 2002/05/30 16:15:16 jolien Ex p $" ); NRCSID( FRAMECACHEH, "$Id: FrameCache.h,v 1.4 2005/01/28 23:15:09 jolien Ex p $" );
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* \subsection*{Error conditions} * \subsection*{Error conditions}
* *
**** </lalLaTeX> */ **** </lalLaTeX> */
/**** <lalErrTable> */ /**** <lalErrTable> */
#define FRAMECACHEH_ENULL 1 #define FRAMECACHEH_ENULL 1
#define FRAMECACHEH_ENNUL 2 #define FRAMECACHEH_ENNUL 2
#define FRAMECACHEH_EALOC 4 #define FRAMECACHEH_EALOC 4
#define FRAMECACHEH_EIEIO 8 #define FRAMECACHEH_EIEIO 8
#define FRAMECACHEH_ELINE 16 #define FRAMECACHEH_ELINE 16
#define FRAMECACHEH_EPATH 32 #define FRAMECACHEH_EPATH 32
#define FRAMECACHEH_ENFRM 64
#define FRAMECACHEH_MSGENULL "Null pointer" #define FRAMECACHEH_MSGENULL "Null pointer"
#define FRAMECACHEH_MSGENNUL "Non-null pointer" #define FRAMECACHEH_MSGENNUL "Non-null pointer"
#define FRAMECACHEH_MSGEALOC "Memory allocation error" #define FRAMECACHEH_MSGEALOC "Memory allocation error"
#define FRAMECACHEH_MSGEIEIO "Import/export I/O error" #define FRAMECACHEH_MSGEIEIO "Import/export I/O error"
#define FRAMECACHEH_MSGELINE "Input line too long" #define FRAMECACHEH_MSGELINE "Input line too long"
#define FRAMECACHEH_MSGEPATH "Invalid path" #define FRAMECACHEH_MSGEPATH "Unable to glob frame files to build cache"
#define FRAMECACHEH_MSGENFRM "No frame files"
/**** </lalErrTable> */ /**** </lalErrTable> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* \subsection*{Structures} * \subsection*{Structures}
* \idx[Type]{FrStat} * \idx[Type]{FrStat}
* *
**** </lalLaTeX> */ **** </lalLaTeX> */
/**** <lalVerbatim> */ /**** <lalVerbatim> */
typedef struct typedef struct
skipping to change at line 145 skipping to change at line 147
* interest. (Not used if zero or less.) * interest. (Not used if zero or less.)
* \item[\texttt{latestTime}] latest time (GPS seconds) of frame files of * \item[\texttt{latestTime}] latest time (GPS seconds) of frame files of
* interest. (Not used if zero or less.) * interest. (Not used if zero or less.)
* \end{description} * \end{description}
* *
* \vfill{\footnotesize\input{FrameCacheHV}} * \vfill{\footnotesize\input{FrameCacheHV}}
* \newpage\input{FrameCacheC} * \newpage\input{FrameCacheC}
* *
**** </lalLaTeX> */ **** </lalLaTeX> */
FrCache * XLALFrImportCache( const char *fname );
FrCache * XLALFrSieveCache( FrCache *input, FrCacheSieve *params );
FrCache * XLALFrGenerateCache( const CHAR *dirstr, const CHAR *fnptrn );
int XLALFrExportCache( FrCache *cache, const CHAR *fname );
void XLALFrDestroyCache( FrCache *cache );
void LALFrCacheImport( void LALFrCacheImport(
LALStatus *status, LALStatus *status,
FrCache **output, FrCache **output,
const CHAR *fname const CHAR *fname
); );
void LALFrCacheExport( void LALFrCacheExport(
LALStatus *status, LALStatus *status,
FrCache *cache, FrCache *cache,
const CHAR *fname const CHAR *fname
 End of changes. 5 change blocks. 
3 lines changed or deleted 11 lines changed or added


 FrameStream.h   FrameStream.h 
/**** <lalVerbatim file="FrameStreamHV"> /**** <lalVerbatim file="FrameStreamHV">
* Author: Jolien D. E. Creighton * Author: Jolien D. E. Creighton
* $Id: FrameStream.h,v 1.5 2002/06/10 22:49:29 jolien Exp $ * $Id: FrameStream.h,v 1.13 2005/04/12 22:30:21 kipp Exp $
**** </lalVerbatim> */ **** </lalVerbatim> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* \section{Header \texttt{FrameStream.h}} * \section{Header \texttt{FrameStream.h}}
* *
* Low-level routines for manupulating frame data streams. * Low-level routines for manupulating frame data streams.
* *
* \subsection*{Synopsis} * \subsection*{Synopsis}
* \begin{verbatim} * \begin{verbatim}
skipping to change at line 37 skipping to change at line 37
#include <lal/FrameCache.h> #include <lal/FrameCache.h>
#ifndef _FRAMESTREAM_H #ifndef _FRAMESTREAM_H
#define _FRAMESTREAM_H #define _FRAMESTREAM_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#pragma } #pragma }
#endif #endif
NRCSID( FRAMESTREAMH, "$Id: FrameStream.h,v 1.5 2002/06/10 22:49:29 jolien Exp $" ); NRCSID( FRAMESTREAMH, "$Id: FrameStream.h,v 1.13 2005/04/12 22:30:21 kipp E xp $" );
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* \subsection*{Error conditions} * \subsection*{Error conditions}
* *
**** </lalLaTeX> */ **** </lalLaTeX> */
/**** <lalErrTable> */ /**** <lalErrTable> */
#define FRAMESTREAMH_ENULL 00001 #define FRAMESTREAMH_ENULL 00001
#define FRAMESTREAMH_ENNUL 00002 #define FRAMESTREAMH_ENNUL 00002
#define FRAMESTREAMH_EALOC 00004 #define FRAMESTREAMH_EALOC 00004
#define FRAMESTREAMH_EFILE 00010 #define FRAMESTREAMH_EFILE 00010
#define FRAMESTREAMH_EOPEN 00020 #define FRAMESTREAMH_EOPEN 00020
#define FRAMESTREAMH_EREAD 00040 #define FRAMESTREAMH_EREAD 00040
#define FRAMESTREAMH_ETIME 00100 #define FRAMESTREAMH_ETIME 00100
#define FRAMESTREAMH_ESIZE 00200 #define FRAMESTREAMH_ESIZE 00200
#define FRAMESTREAMH_ECHAN 00400 #define FRAMESTREAMH_ECHAN 00400
#define FRAMESTREAMH_ETYPE 01000 #define FRAMESTREAMH_ETYPE 01000
#define FRAMESTREAMH_ERROR 02000 #define FRAMESTREAMH_ERROR 02000
#define FRAMESTREAMH_EDONE 04000 #define FRAMESTREAMH_EDONE 04000
#define FRAMESTREAMH_ETREQ 010000
#define FRAMESTREAMH_EDGAP 020000
#define FRAMESTREAMH_MSGENULL "Null pointer" #define FRAMESTREAMH_MSGENULL "Null pointer"
#define FRAMESTREAMH_MSGENNUL "Non-null pointer" #define FRAMESTREAMH_MSGENNUL "Non-null pointer"
#define FRAMESTREAMH_MSGEALOC "Memory allocation error" #define FRAMESTREAMH_MSGEALOC "Memory allocation error"
#define FRAMESTREAMH_MSGEFILE "Frame data files not found" #define FRAMESTREAMH_MSGEFILE "Frame data files not found"
#define FRAMESTREAMH_MSGEOPEN "Frame file open error" #define FRAMESTREAMH_MSGEOPEN "Frame file open error"
#define FRAMESTREAMH_MSGEREAD "Frame file read error" #define FRAMESTREAMH_MSGEREAD "Frame file read error"
#define FRAMESTREAMH_MSGETIME "Invalid ADC offset time" #define FRAMESTREAMH_MSGETIME "Invalid ADC offset time"
#define FRAMESTREAMH_MSGESIZE "Invalid vector length" #define FRAMESTREAMH_MSGESIZE "Invalid vector length"
#define FRAMESTREAMH_MSGECHAN "Could not find ADC channel" #define FRAMESTREAMH_MSGECHAN "Could not find ADC channel"
#define FRAMESTREAMH_MSGETYPE "Invalid ADC type" #define FRAMESTREAMH_MSGETYPE "Invalid ADC type"
#define FRAMESTREAMH_MSGERROR "Frame stream error" #define FRAMESTREAMH_MSGERROR "Frame stream error"
#define FRAMESTREAMH_MSGEDONE "End of frame data" #define FRAMESTREAMH_MSGEDONE "End of frame data"
#define FRAMESTREAMH_MSGETREQ "No data at time requested"
#define FRAMESTREAMH_MSGEDGAP "Gap in the data"
/**** </lalErrTable> */ /**** </lalErrTable> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* \subsection*{Structures} * \subsection*{Structures}
* \idx[Type]{FrState}
* \idx[Type]{FrFileInfo}
* \idx[Type]{FrStream} * \idx[Type]{FrStream}
* \idx[Type]{FrPos} * \idx[Type]{FrPos}
* \idx[Type]{ChannelType} * \idx[Type]{ChannelType}
* \idx[Type]{FrChanIn} * \idx[Type]{FrChanIn}
* \idx[Type]{FrOutPar} * \idx[Type]{FrOutPar}
* *
**** </lalLaTeX> */ **** </lalLaTeX> */
/**** <lalVerbatim> */ /**** <lalVerbatim> */
typedef struct tagFrStream FrStream; typedef enum
{
LAL_FR_OK = 0, /* nominal */
LAL_FR_ERR = 1, /* error in frame stream */
LAL_FR_END = 2, /* end of frame stream */
LAL_FR_GAP = 4, /* gap in frame stream */
LAL_FR_URL = 8, /* error opening frame URL */
LAL_FR_TOC = 16 /* error reading frame TOC */
}
FrState;
typedef enum
{
LAL_FR_SILENT_MODE = 0,
LAL_FR_TIMEWARN_MODE = 1, /* display warning for invalid time requests
*/
LAL_FR_GAPINFO_MODE = 2, /* display info for gaps in data */
LAL_FR_VERBOSE_MODE = 3, /* display warnings and info */
LAL_FR_IGNOREGAP_MODE = 4, /* ignore gaps in data */
LAL_FR_IGNORETIME_MODE = 8, /* ignore invalid times requested */
LAL_FR_DEFAULT_MODE = 15 /* ignore time/gaps but report warnings & in
fo */
}
FrMode;
struct FrFile;
typedef struct tagFrFileInfo
{
INT4 ind;
CHAR *url;
INT4 t0;
INT4 dt;
}
FrFileInfo;
typedef struct tagFrStream
{
FrState state;
INT4 mode;
LIGOTimeGPS epoch;
UINT4 nfile;
FrFileInfo *flist;
UINT4 fnum;
struct FrFile *file;
INT4 pos;
}
FrStream;
/**** </lalVerbatim> */ /**** </lalVerbatim> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* This structure details the state of the frame stream. The contents are * This structure details the state of the frame stream. The contents are
* private; you should not tamper with them! * private; you should not tamper with them!
* *
**** </lalLaTeX> */ **** </lalLaTeX> */
/**** <lalVerbatim> */ /**** <lalVerbatim> */
typedef struct typedef struct
tagFrPos tagFrPos
{ {
LIGOTimeGPS epoch; LIGOTimeGPS epoch;
UINT4 filenum; UINT4 fnum;
UINT4 frame; INT4 pos;
UINT4 run;
} }
FrPos; FrPos;
/**** </lalVerbatim> */ /**** </lalVerbatim> */
/**** <lalLaTeX> /**** <lalLaTeX>
* *
* This structure contains a record of the state of a frame stream; this * This structure contains a record of the state of a frame stream; this
* record can be used to restore the stream to the state when the record * record can be used to restore the stream to the state when the record
* was made (provided the stream has not been closed). The fields are: * was made (provided the stream has not been closed). The fields are:
* \begin{description} * \begin{description}
* \item[\texttt{epoch}] the GPS time of the open frame when the record * \item[\texttt{epoch}] the GPS time of the open frame when the record
* was made. * was made.
* \item[\texttt{filenum}] the file number of a list of frame files that wa s * \item[\texttt{fnum}] the file number of a list of frame files that was
* open when the record was made. * open when the record was made.
* \item[\texttt{frame}] the frame number of the frames within the * \item[\texttt{pos}] the position within the
* frame file that was open when the record was made.
* \item[\texttt{run}] the run number of the frames within the
* frame file that was open when the record was made. * frame file that was open when the record was made.
* \end{description} * \end{description}
*