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


 Audio.h   Audio.h 
skipping to change at line 42 skipping to change at line 42
* *
*/ */
#ifndef AUDIO_H #ifndef AUDIO_H
#define AUDIO_H #define AUDIO_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
NRCSID( AUDIOH, "$Id$" ); NRCSID( AUDIOH, "$Id$" );
#ifdef __cplusplus #if defined(__cplusplus)
extern "C" { extern "C" {
#pragma } #elif 0
} /* so that editors will match preceding brace */
#endif #endif
/** Records a time series as a .wav audio file */ /** Records a time series as a .wav audio file */
int XLALAudioWAVRecordREAL4TimeSeries( FILE *fp, REAL4TimeSeries *series ); int XLALAudioWAVRecordREAL4TimeSeries( FILE *fp, REAL4TimeSeries *series );
/** Records a time series as a .wav audio file */ /** Records a time series as a .wav audio file */
int XLALAudioWAVRecordREAL8TimeSeries( FILE *fp, REAL8TimeSeries *series ); int XLALAudioWAVRecordREAL8TimeSeries( FILE *fp, REAL8TimeSeries *series );
/** Records a time series as a .au audio file */ /** Records a time series as a .au audio file */
int XLALAudioAURecordREAL4TimeSeries( FILE *fp, REAL4TimeSeries *series ); int XLALAudioAURecordREAL4TimeSeries( FILE *fp, REAL4TimeSeries *series );
/** Records a time series as a .au audio file */ /** Records a time series as a .au audio file */
int XLALAudioAURecordREAL8TimeSeries( FILE *fp, REAL8TimeSeries *series ); int XLALAudioAURecordREAL8TimeSeries( FILE *fp, REAL8TimeSeries *series );
#ifdef __cplusplus #if 0
#pragma { { /* so that editors will match succeeding brace */
#elif defined(__cplusplus)
} }
#endif #endif
#endif /* AUDIO_H */ #endif /* AUDIO_H */
 End of changes. 3 change blocks. 
4 lines changed or deleted 6 lines changed or added


 BandPassTimeSeries.h   BandPassTimeSeries.h 
skipping to change at line 46 skipping to change at line 46
\noindent This header covers routines that apply a time-domain low- or \noindent This header covers routines that apply a time-domain low- or
high-pass filter to a data series of type \verb@<datatype>TimeSeries@. high-pass filter to a data series of type \verb@<datatype>TimeSeries@.
Further documentation is given in the individual routines' modules. Further documentation is given in the individual routines' modules.
******************************************************* </lalLaTeX> */ ******************************************************* </lalLaTeX> */
#ifndef _BANDPASSTIMESERIES_H #ifndef _BANDPASSTIMESERIES_H
#define _BANDPASSTIMESERIES_H #define _BANDPASSTIMESERIES_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#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 #if defined(__cplusplus)
extern "C" { extern "C" {
#pragma } #elif 0
} /* so that editors will match preceding brace */
#endif #endif
NRCSID(BANDPASSTIMESERIESH,"$Id$"); NRCSID(BANDPASSTIMESERIESH,"$Id$");
/********************************************************** <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
skipping to change at line 94 skipping to change at line 100
\item[\texttt{REAL8 f1}, \texttt{f2}] The reference frequencies of the \item[\texttt{REAL8 f1}, \texttt{f2}] The reference frequencies of the
transition band. transition band.
\item[\texttt{REAL8 a1}, \texttt{a2}] The minimal desired attenuation \item[\texttt{REAL8 a1}, \texttt{a2}] The minimal desired attenuation
factors at the reference frequencies. factors at the reference frequencies.
\end{description} \end{description}
******************************************************* </lalLaTeX> */ ******************************************************* </lalLaTeX> */
typedef struct tagPassBandParamStruc{ typedef struct tagPassBandParamStruc{
SWIGLAL_STRUCT(PassBandParamStruc);
CHAR *name; CHAR *name;
INT4 nMax; INT4 nMax;
REAL8 f1; REAL8 f1;
REAL8 f2; REAL8 f2;
REAL8 a1; REAL8 a1;
REAL8 a2; REAL8 a2;
} PassBandParamStruc; } PassBandParamStruc;
/* <lalLaTeX> /* <lalLaTeX>
\vfill{\footnotesize\input{BandPassTimeSeriesHV}} \vfill{\footnotesize\input{BandPassTimeSeriesHV}}
skipping to change at line 147 skipping to change at line 154
/* 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 #if 0
#pragma { { /* so that editors will match succeeding brace */
#elif defined(__cplusplus)
} }
#endif #endif
#endif /* _BANDPASSTIMESERIES_H */ #endif /* _BANDPASSTIMESERIES_H */
 End of changes. 5 change blocks. 
4 lines changed or deleted 12 lines changed or added


 BitField.h   BitField.h 
skipping to change at line 23 skipping to change at line 23
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/** /**
* \author Karl Wette * \author Karl Wette
* \file * \file
* \brief Macros for manipulating bit field * \brief Macros for manipulating integers as bit fields
*/ */
#ifndef _BITFIELD_H #ifndef _BITFIELD_H
#define _BITFIELD_H #define _BITFIELD_H
#include <lal/LALAtomicDatatypes.h> #include <lal/LALAtomicDatatypes.h>
NRCSID(BITFIELDH, "$Id$"); NRCSID(BITFIELDH, "$Id$");
/** /**
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 Calibration.h   Calibration.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/**** <lalVerbatim file="CalibrationHV">
* Author: P. R. Brady, J. D. E. Creighton
* $Id$
**** </lalVerbatim> */
/**** <lalLaTeX>
*
* \section{Header \texttt{Calibration.h}}
*
* \subsection*{Synopsis}
* \begin{verbatim}
* #include <lal/Calibration.h>
* \end{verbatim}
*
**** </lalLaTeX> */
#ifndef _CALIBRATION_H #ifndef _CALIBRATION_H
#define _CALIBRATION_H #define _CALIBRATION_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/BandPassTimeSeries.h> #include <lal/BandPassTimeSeries.h>
NRCSID (CALIBRATIONH,"$Id$"); NRCSID (CALIBRATIONH,"$Id$");
#ifdef __cplusplus #if defined(__cplusplus)
extern "C" { extern "C" {
#pragma } /** to match the previous brace **/ #elif 0
} /* so that editors will match preceding brace */
#endif #endif
/**** <lalLaTeX> /**
* \author P. R. Brady, J. D. E. Creighton
* \addtogroup Calibration_h
* *
* \subsection*{Error conditions} * \heading{Synopsis}
* \code
* #include <lal/Calibration.h>
* \endcode
* *
**** </lalLaTeX> */ */
/**** <lalErrTable> */ /** @{ */
#define CALIBRATIONH_ENULL 001
#define CALIBRATIONH_ESIZE 002
#define CALIBRATIONH_ESZMM 004
#define CALIBRATIONH_EZERO 010
#define CALIBRATIONH_ETIME 020
#define CALIBRATIONH_EUNIT 040
/**\name Error Codes */ /*@{*/
#define CALIBRATIONH_ENULL 001 /**< Null pointer */
#define CALIBRATIONH_ESIZE 002 /**< Invalid size */
#define CALIBRATIONH_ESZMM 004 /**< Size mismatch */
#define CALIBRATIONH_EZERO 010 /**< Zero factor */
#define CALIBRATIONH_ETIME 020 /**< Time out of range */
#define CALIBRATIONH_EUNIT 040 /**< Incompatible units */
/*@}*/
/** \cond DONT_DOXYGEN */
#define CALIBRATIONH_MSGENULL "Null pointer" #define CALIBRATIONH_MSGENULL "Null pointer"
#define CALIBRATIONH_MSGESIZE "Invalid size" #define CALIBRATIONH_MSGESIZE "Invalid size"
#define CALIBRATIONH_MSGESZMM "Size mismatch" #define CALIBRATIONH_MSGESZMM "Size mismatch"
#define CALIBRATIONH_MSGEZERO "Zero factor" #define CALIBRATIONH_MSGEZERO "Zero factor"
#define CALIBRATIONH_MSGETIME "Time out of range" #define CALIBRATIONH_MSGETIME "Time out of range"
#define CALIBRATIONH_MSGEUNIT "Incompatible units" #define CALIBRATIONH_MSGEUNIT "Incompatible units"
/**** </lalErrTable> */ /** \endcond */
/**** <lalLaTeX> /** UNDOCUMENTED */
*
* \subsection*{Structures}
* \idx[Type]{CalibrationType}
* \idx[Type]{CalibrationRecord}
* \idx[Type]{CalibrationFunctions}
* \idx[Type]{CalibrationUpdateParams}
*
* \subsubsection*{Type \texttt{CalibrationType}}
*
**** </lalLaTeX> */
/**** <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> */
/**** <lalLaTeX> /** UNDOCUMENTED */
*
* Document \verb+CalibrationType+
*
* \subsubsection*{Type \texttt{CalFactors}}
*
**** </lalLaTeX> */
/**** <lalVerbatim> */
typedef struct typedef struct
tagCalFactors tagCalFactors
{ {
SWIGLAL_STRUCT(CalFactors);
COMPLEX16 alpha; COMPLEX16 alpha;
COMPLEX16 alphabeta; COMPLEX16 alphabeta;
COMPLEX16 beta; COMPLEX16 beta;
COMPLEX16 exc; COMPLEX16 exc;
COMPLEX16 asq; COMPLEX16 asq;
COMPLEX16 darm; COMPLEX16 darm;
} }
CalFactors; CalFactors;
/**** </lalVerbatim> */
/**** <lalLaTeX> /** UNDOCUMENTED */
*
* Document \verb+CalibrationType+
*
* \subsubsection*{Type \texttt{UpdateFactorsParams}}
*
**** </lalLaTeX> */
/**** <lalVerbatim> */
typedef struct typedef struct
tagUpdateFactorsParams tagUpdateFactorsParams
{ {
SWIGLAL_STRUCT(UpdateFactorsParams);
REAL8 lineFrequency; REAL8 lineFrequency;
COMPLEX16 openloop; COMPLEX16 openloop;
COMPLEX16 digital; COMPLEX16 digital;
COMPLEX16 whitener; COMPLEX16 whitener;
REAL4TimeSeries *darmCtrl; REAL4TimeSeries *darmCtrl;
REAL4TimeSeries *asQ; REAL4TimeSeries *asQ;
REAL4TimeSeries *exc; REAL4TimeSeries *exc;
} }
UpdateFactorsParams; UpdateFactorsParams;
/**** </lalVerbatim> */
/**** <lalLaTeX> /** UNDOCUMENTED */
*
* Document \verb+CalibrationType+
*
* \subsubsection*{Type \texttt{CalibrationRecord}}
*
**** </lalLaTeX> */
/**** <lalVerbatim> */
typedef struct typedef struct
tagCalibrationRecord tagCalibrationRecord
{ {
SWIGLAL_STRUCT(CalibrationRecord);
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LIGOTimeGPS epoch; LIGOTimeGPS epoch;
REAL8 duration; REAL8 duration;
CHAR reference[LALNameLength]; CHAR reference[LALNameLength];
LALUnit units; LALUnit units;
UINT4 type; UINT4 type;
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> */
/**** <lalLaTeX> /** The type CalibrationFunctions contains two calibration functions,
* * the sensing function \f$C(f)\f$ and the response function \f$R(f)\f$. W
* Document \verb+CalibrationRecord+ hile the
* * response function is the function that is most often wanted, the sensing
* \subsubsection*{Type \texttt{CalibrationFunctions}} * function is needed in updating calibration from one epoch to another.
* */
**** </lalLaTeX> */
/**** <lalVerbatim> */
typedef struct typedef struct
tagCalibrationFunctions tagCalibrationFunctions
{ {
SWIGLAL_STRUCT(CalibrationFunctions);
COMPLEX8FrequencySeries *responseFunction; COMPLEX8FrequencySeries *responseFunction;
COMPLEX8FrequencySeries *sensingFunction; COMPLEX8FrequencySeries *sensingFunction;
} }
CalibrationFunctions; CalibrationFunctions;
/**** </lalVerbatim> */
/**** <lalLaTeX> /** The type \c CalibrationUpdateParams contains two time series
* The type \texttt{CalibrationFunctions} contains two calibration function * representing an overall gain factor for the open-loop gain function \f$H
s, (f)\f$
* the sensing function $C(f)$ and the response function $R(f)$. While the * and the sensing function \f$C(f)\f$. These transfer functions are known
* response function is the function that is most often wanted, the sensing to
* function is needed in updating calibration from one epoch to another. * change (by an overall factor) with time, and these two factors can be
* * tracked using the injected calibration lines. The factors are stored
* \subsubsection*{Type \texttt{CalibrationUpdateParams}} * in this structure as (very-slowly varying) time series, and are to be
* * used in updating the calibration functions described previously.
**** </lalLaTeX> */ * (The response function can be computed from the open-loop gain and the
/**** <lalVerbatim> */ * sensing function. It is simply \f$R(f)=[1+H(f)]/C(f)\f$.) In addition,
this
* 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.
*/
typedef struct typedef struct
tagCalibrationUpdateParams tagCalibrationUpdateParams
{ {
SWIGLAL_STRUCT(CalibrationUpdateParams);
LIGOTimeGPS epoch; LIGOTimeGPS epoch;
LIGOTimeGPS duration; LIGOTimeGPS duration;
CHAR *ifo; CHAR *ifo;
COMPLEX8 alpha; COMPLEX8 alpha;
COMPLEX8 alphabeta; COMPLEX8 alphabeta;
COMPLEX8TimeSeries *openLoopFactor; COMPLEX8TimeSeries *openLoopFactor;
COMPLEX8TimeSeries *sensingFactor; COMPLEX8TimeSeries *sensingFactor;
} }
CalibrationUpdateParams; 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}}
* \newpage\input{ComputeTransferC}
*
**** </lalLaTeX> */
/** UNDOCUMENTED */
typedef typedef
struct StrainOutTag { struct tagStrainOut {
REAL8TimeSeries h; /* timeseries containing h(t) */ SWIGLAL_STRUCT(StrainOut);
REAL8TimeSeries hC; /* timeseries containing the control signal * REAL8TimeSeries h; /**< timeseries containing h(t) */
/ REAL8TimeSeries hC; /**< timeseries containing the control signa
REAL8TimeSeries hR; /* timeseries containing the residual signal l */
*/ REAL8TimeSeries hR; /**< timeseries containing the residual sign
COMPLEX16TimeSeries alpha; /* alpha time series */ al */
COMPLEX16TimeSeries beta; /* beta time series */ COMPLEX16TimeSeries alpha; /**< alpha time series */
COMPLEX16TimeSeries alphabeta; /* alpha time series */ COMPLEX16TimeSeries beta; /**< beta time series */
INT2TimeSeries science_mode; /* flag = 1 for science mode, 0 otherwise COMPLEX16TimeSeries alphabeta;/**< alpha time series */
*/ INT2TimeSeries science_mode; /**< flag = 1 for science mode, 0 otherwise
*/
} StrainOut; } StrainOut;
/** UNDOCUMENTED */
typedef typedef
struct StrainInTag { struct tagStrainIn {
REAL4TimeSeries AS_Q ; /* timeseries containing ASQ */ SWIGLAL_STRUCT(StrainIn);
REAL4TimeSeries DARM_ERR;/* timeseries containing DARM_ERR */ REAL4TimeSeries AS_Q ; /**< timeseries containing ASQ */
REAL4TimeSeries DARM ; /* timeseries containing DARM_CTRL */ REAL4TimeSeries DARM_ERR;/**< timeseries containing DARM_ERR */
REAL4TimeSeries EXC ; /* timeseries containing the excitation */ REAL4TimeSeries DARM ; /**< timeseries containing DARM_CTRL */
REAL4TimeSeries StateVector; /* timeseries containing the State Vector ( REAL4TimeSeries EXC ; /**< timeseries containing the excitation */
IFO-SV_STATE_VECTOR) */ REAL4TimeSeries StateVector; /**< timeseries containing the State Vector
REAL4TimeSeries LAX; /* timeseries containing the Light-in-X-arm (LSC (IFO-SV_STATE_VECTOR) */
-LA_PTRX_NORM) */ REAL4TimeSeries LAX; /**< timeseries containing the Light-in-X-arm (L
REAL4TimeSeries LAY; /* timeseries containing the Light-in-Y-arm (LSC SC-LA_PTRX_NORM) */
-LA_PTRY_NORM) */ REAL4TimeSeries LAY; /**< timeseries containing the Light-in-Y-arm (L
COMPLEX16 Do; /* digital filter at cal line frequency */ SC-LA_PTRY_NORM) */
COMPLEX16 Go; /* OLG at cal line frequency */ COMPLEX16 Do; /**< digital filter at cal line frequency */
COMPLEX16 Wo; /* Whitening filter at cal line frequency */ COMPLEX16 Go; /**< OLG at cal line frequency */
REAL8 f; /* calibration line frequency */ COMPLEX16 Wo; /**< Whitening filter at cal line frequency */
REAL4 To; /* factors integration time */ REAL8 f; /**< calibration line frequency */
char filter_vc_info[1024]; /* version control information in the filters REAL4 To; /**< factors integration time */
file */ char filter_vc_info[1024]; /**< version control information in the filter
char filter_chksum[64]; /* checksum of the contents of the filters file s file */
*/ char filter_chksum[64]; /**< checksum of the contents of the filters fil
REAL8IIRFilter *Cinv; /* Filters for inverse of sensing function */ e */
INT4 CinvUSF; /* Upsampling factor for sensing function */ REAL8IIRFilter *Cinv; /**< Filters for inverse of sensing function */
INT4 CinvDelay; /* Overall inverse sensing function delay */ INT4 CinvUSF; /**< Upsampling factor for sensing function */
REAL8IIRFilter *A; /* Filters for analog actuation function */ INT4 CinvDelay; /**< Overall inverse sensing function delay */
REAL8IIRFilter *D; /* Filters for analog actuation function */ REAL8IIRFilter *A; /**< Filters for analog actuation function */
REAL8IIRFilter *AW; /* Filters for analog actuation function */ REAL8IIRFilter *D; /**< Filters for analog actuation function */
REAL8 gamma_fudgefactor; REAL8IIRFilter *AW; /**< Filters for analog actuation function */
INT4 delta; REAL8 gamma_fudgefactor; /**< UNDOCUMENTED */
INT4 usefactors; INT4 delta; /**< UNDOCUMENTED */
INT4 wings; /* size of wings in seconds */ INT4 usefactors; /**< UNDOCUMENTED */
INT4 fftconv; INT4 wings; /**< size of wings in seconds */
INT4 outalphas; INT4 fftconv; /**< UNDOCUMENTED */
INT4 darmctrl; INT4 outalphas;/**< UNDOCUMENTED */
INT4 darmctrl;/**< UNDOCUMENTED */
/* Stuff needed to run old IIR code */ /* Stuff needed to run old IIR code */
REAL8IIRFilter *AA; /* Filters for analog actuation function */ REAL8IIRFilter *AA; /**< Filters for analog actuation function */
INT4 AADelay; /* Overall analog actuation function delay */ INT4 AADelay; /**< Overall analog actuation function delay */
REAL8IIRFilter *AX; /* Digital filters for x arm actuation function REAL8IIRFilter *AX; /**< Digital filters for x arm actuation functio
*/ n */
REAL8IIRFilter *AY; /* Digital filters for y arm actuation function REAL8IIRFilter *AY; /**< Digital filters for y arm actuation functio
*/ n */
INT4 NCinv; /* Numbers of filters of each type */ INT4 NCinv; /**< Numbers of filters of each type */
INT4 ND; INT4 ND;/**< UNDOCUMENTED */
INT4 NAA; INT4 NAA;/**< UNDOCUMENTED */
INT4 NAX; INT4 NAX;/**< UNDOCUMENTED */
INT4 NAY; INT4 NAY;/**< UNDOCUMENTED */
} StrainIn; } StrainIn;
/** UNDOCUMENTED */
typedef typedef
struct MyIIRFilter { struct tagMyIIRFilter {
SWIGLAL_STRUCT(MyIIRFilter);
INT4 yOrder; INT4 yOrder;
INT4 xOrder; INT4 xOrder;
REAL8 a[20]; REAL8 a[20];
REAL8 b[20]; REAL8 b[20];
REAL8 yhist[20]; REAL8 yhist[20];
REAL8 xhist[20]; REAL8 xhist[20];
} MyIIRFilter; } MyIIRFilter;
/** @} */
/* ----- Prototypes ----- */
void LALComputeTransfer( LALStatus *status, CalibrationRecord *calrec ); void LALComputeTransfer( LALStatus *status, CalibrationRecord *calrec );
void void
LALUpdateCalibration( LALUpdateCalibration(
LALStatus *status, LALStatus *status,
CalibrationFunctions *output, CalibrationFunctions *output,
CalibrationFunctions *input, CalibrationFunctions *input,
CalibrationUpdateParams *params CalibrationUpdateParams *params
); );
skipping to change at line 347 skipping to change at line 305
void LALMakeFIRLP(LALStatus *status, void LALMakeFIRLP(LALStatus *status,
REAL8IIRFilter *G, REAL8IIRFilter *G,
int USF); int USF);
void LALMakeFIRLPALPHAS(LALStatus *status, void LALMakeFIRLPALPHAS(LALStatus *status,
REAL8IIRFilter *G); REAL8IIRFilter *G);
void LALMakeFIRHP(LALStatus *status, void LALMakeFIRHP(LALStatus *status,
REAL8IIRFilter *G); REAL8IIRFilter *G);
int XALFIRFilter(REAL8TimeSeries *tseries, int XLALFIRFilter(REAL8TimeSeries *tseries,
REAL8IIRFilter *FIR); REAL8IIRFilter *FIR);
void LALFFTFIRFilter(LALStatus *status, void LALFFTFIRFilter(LALStatus *status,
REAL8TimeSeries *tseries, REAL8TimeSeries *tseries,
REAL8IIRFilter *FIR); REAL8IIRFilter *FIR);
void LALFIRFilter(LALStatus *status,
REAL8TimeSeries *tseries,
REAL8IIRFilter *FIR);
void LALFreeFilter(LALStatus *status, REAL8IIRFilter *F2, int ORDER); void LALFreeFilter(LALStatus *status, REAL8IIRFilter *F2, int ORDER);
void LALCopyFilter(LALStatus *status, REAL8IIRFilter **F2, REAL8IIRFilter * F1, int ORDER); void LALCopyFilter(LALStatus *status, REAL8IIRFilter **F2, REAL8IIRFilter * F1, int ORDER);
int XLALDivideTimeSeries(REAL8TimeSeries *hR, REAL8TimeSeries *ALPHAS); int XLALDivideTimeSeries(REAL8TimeSeries *hR, REAL8TimeSeries *ALPHAS);
int XLALUpsample(REAL8TimeSeries *uphR, REAL8TimeSeries *hR, int up_factor) ; int XLALUpsample(REAL8TimeSeries *uphR, REAL8TimeSeries *hR, int up_factor) ;
int XLALUpsampleLinear(REAL8TimeSeries *uphR, REAL8TimeSeries *hR, int up_f actor); int XLALUpsampleLinear(REAL8TimeSeries *uphR, REAL8TimeSeries *hR, int up_f actor);
#ifdef __cplusplus #if 0
#pragma { /** to match the next brace **/ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus)
} }
#endif #endif
#endif /* _CALIBRATION_H */ #endif /* _CALIBRATION_H */
 End of changes. 36 change blocks. 
174 lines changed or deleted 130 lines changed or added


 CoarseGrainFrequencySeries.h   CoarseGrainFrequencySeries.h 
skipping to change at line 51 skipping to change at line 51
\subsection*{Structures} \subsection*{Structures}
*********************************************************** </lalLaTeX> */ *********************************************************** </lalLaTeX> */
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#ifndef _COARSEGRAINFREQUENCYSERIES_H #ifndef _COARSEGRAINFREQUENCYSERIES_H
#define _COARSEGRAINFREQUENCYSERIES_H #define _COARSEGRAINFREQUENCYSERIES_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID( COARSEGRAINFREQUENCYSERIESH, NRCSID( COARSEGRAINFREQUENCYSERIESH,
"$Id$" ); "$Id$" );
/****************** <lalErrTable file="CoarseGrainFrequencySeriesHE"> */ /****************** <lalErrTable file="CoarseGrainFrequencySeriesHE"> */
#define COARSEGRAINFREQUENCYSERIESH_ENULLPTR 1 #define COARSEGRAINFREQUENCYSERIESH_ENULLPTR 1
skipping to change at line 116 skipping to change at line 121
\item[\texttt{REAL8 deltaF}] \item[\texttt{REAL8 deltaF}]
The frequency spacing of the frequency series. The frequency spacing of the frequency series.
\end{description} \end{description}
*********************************************************** </lalLaTeX> */ *********************************************************** </lalLaTeX> */
typedef struct typedef struct
tagFrequencySamplingParams tagFrequencySamplingParams
{ {
SWIGLAL_STRUCT(FrequencySamplingParams);
REAL8 f0; REAL8 f0;
REAL8 deltaF; REAL8 deltaF;
UINT4 length; UINT4 length;
} }
FrequencySamplingParams; FrequencySamplingParams;
void void
LALSCoarseGrainFrequencySeries(LALStatus *status, LALSCoarseGrainFrequencySeries(LALStatus *status,
REAL4FrequencySeries *output, REAL4FrequencySeries *output,
const REAL4FrequencySeries *input, const REAL4FrequencySeries *input,
 End of changes. 2 change blocks. 
0 lines changed or deleted 6 lines changed or added


 CoherentEstimation.h   CoherentEstimation.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/*************************** <lalVerbatim file="CoherentEstimation">
Author: Sylvestre, J.
$Id$
**************************************************** </lalVerbatim> */
#ifndef _COHERENTESTIMATION_H #ifndef _COHERENTESTIMATION_H
#define _COHERENTESTIMATION_H #define _COHERENTESTIMATION_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/DetectorSite.h> #include <lal/DetectorSite.h>
#include <lal/SkyCoordinates.h> #include <lal/SkyCoordinates.h>
#include <lal/IIRFilter.h> #include <lal/IIRFilter.h>
#ifdef __cplusplus #if defined(__cplusplus)
extern "C" { extern "C" {
#pragma } #elif 0
} /* so that editors will match preceding brace */
#endif #endif
NRCSID( COHERENTESTIMATION, "$Id$" ); NRCSID( COHERENTESTIMATION, "$Id$" );
#define COHERENTESTIMATIONH_EMEM 1 #define COHERENTESTIMATIONH_EMEM 1
#define COHERENTESTIMATIONH_ENULL 2 #define COHERENTESTIMATIONH_ENULL 2
#define COHERENTESTIMATIONH_E0DEC 3 #define COHERENTESTIMATIONH_E0DEC 3
#define COHERENTESTIMATIONH_EDST 4 #define COHERENTESTIMATIONH_EDST 4
#define COHERENTESTIMATIONH_EICE 5 #define COHERENTESTIMATIONH_EICE 5
#define COHERENTESTIMATIONH_ENUM 6 #define COHERENTESTIMATIONH_ENUM 6
skipping to change at line 57 skipping to change at line 58
#define COHERENTESTIMATIONH_MSGEMEM "Memory allocation error" #define COHERENTESTIMATIONH_MSGEMEM "Memory allocation error"
#define COHERENTESTIMATIONH_MSGENULL "NULL pointer" #define COHERENTESTIMATIONH_MSGENULL "NULL pointer"
#define COHERENTESTIMATIONH_MSGE0DEC "invalid DetectorsData structure" #define COHERENTESTIMATIONH_MSGE0DEC "invalid DetectorsData structure"
#define COHERENTESTIMATIONH_MSGEDST "input time series don't all have same start time" #define COHERENTESTIMATIONH_MSGEDST "input time series don't all have same start time"
#define COHERENTESTIMATIONH_MSGEICE "invalid CoherentEstimation structure" #define COHERENTESTIMATIONH_MSGEICE "invalid CoherentEstimation structure"
#define COHERENTESTIMATIONH_MSGENUM "Numerical erorr" #define COHERENTESTIMATIONH_MSGENUM "Numerical erorr"
#define COHERENTESTIMATIONH_MSGEUIMP "Implemented only for 3 detectors" #define COHERENTESTIMATIONH_MSGEUIMP "Implemented only for 3 detectors"
typedef struct tagDetectorsData { typedef struct tagDetectorsData {
SWIGLAL_STRUCT(DetectorsData);
UINT4 Ndetectors; /* number of detectors */ UINT4 Ndetectors; /* number of detectors */
REAL4TimeSeries *data; /* data time series from all detectors */ REAL4TimeSeries *data; /* data time series from all detectors */
} DetectorsData; } DetectorsData;
typedef struct tagCoherentEstimation { typedef struct tagCoherentEstimation {
SWIGLAL_STRUCT(CoherentEstimation);
UINT4 Ndetectors; /* number of detectors */ UINT4 Ndetectors; /* number of detectors */
LALDetector *detectors; /* vector of detectors info */ LALDetector *detectors; /* vector of detectors info */
REAL8IIRFilter **filters; /* vector of pre-processing filters */ REAL8IIRFilter **filters; /* vector of pre-processing filters */
BOOLEAN preProcessed; /* set to 0 to for pre-processing */ BOOLEAN preProcessed; /* set to 0 to for pre-processing */
UINT2 nPreProcessed; /* number of times to apply pre-proc filters */ UINT2 nPreProcessed; /* number of times to apply pre-proc filters */
SkyPosition *position; /* position of source (equatorial celestial coor dinates) */ SkyPosition *position; /* position of source (equatorial celestial coor dinates) */
REAL8 polAngle; /* polarization angle: counter-clockwise angle x -axis makes with a line per- pendicular to meridian of source in Westward d irection (i.e. North of West), in decimal radians. */ REAL8 polAngle; /* polarization angle: counter-clockwise angle x -axis makes with a line per- pendicular to meridian of source in Westward d irection (i.e. North of West), in decimal radians. */
skipping to change at line 103 skipping to change at line 106
LALStatus *status, LALStatus *status,
DetectorsData *dat DetectorsData *dat
); );
void void
LALClearCoherentInfo ( LALClearCoherentInfo (
LALStatus *status, LALStatus *status,
CoherentEstimation *dat CoherentEstimation *dat
); );
#if 0
{ /* so that editors will match succeeding brace */
#elif defined(__cplusplus)
}
#endif #endif
#endif /* _COHERENTESTIMATION_H */
 End of changes. 8 change blocks. 
7 lines changed or deleted 14 lines changed or added


 ComplexFFT.h   ComplexFFT.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/**** <lalVerbatim file="ComplexFFTHV">
* $Id$
**** </lalVerbatim> */
/**** <lalLaTeX>
*
* \section{Header \texttt{ComplexFFT.h}}
* \label{s:ComplexFFT.h}
*
* Performs complex-to-complex FFTs.
*
* \subsection*{Synopsis}
* \begin{verbatim}
* #include <lal/ComplexFFT.h>
* \end{verbatim}
*
* Perform complex-to-complex fast Fourier transforms of vectors using the
* package FFTW~\cite{fj:1998}.
*
**** </lalLaTeX> */
#ifndef _COMPLEXFFT_H #ifndef _COMPLEXFFT_H
#define _COMPLEXFFT_H #define _COMPLEXFFT_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #if defined(__cplusplus)
extern "C" { extern "C" {
#pragma } #elif 0
} /* so that editors will match preceding brace */
#endif
#ifdef __cplusplus
#ifdef __GNUC__
#define RESTRICT __restrict__
#else
#define RESTRICT
#endif
#else
#define RESTRICT restrict
#endif #endif
NRCSID( COMPLEXFFTH, "$Id$" ); NRCSID( COMPLEXFFTH, "$Id$" );
/**** <lalLaTeX> /**
* \subsection*{Error conditions} * \addtogroup ComplexFFT_h
**** </lalLaTeX> */ *
/**** <lalErrTable> */ * \brief Performs complex-to-complex FFTs.
*
* \heading{Synopsis}
* \code
* #include <lal/ComplexFFT.h>
* \endcode
*
* Perform complex-to-complex fast Fourier transforms of vectors using the
* package FFTW [\ref fj_1998].
*
*/
/*@{*/
#define COMPLEXFFTH_ENULL 1 /** \name Error Codes */ /*@{*/
#define COMPLEXFFTH_ENNUL 2 #define COMPLEXFFTH_ENULL 1 /**< Null pointer */
#define COMPLEXFFTH_ESIZE 4 #define COMPLEXFFTH_ENNUL 2 /**< Non-null pointer */
#define COMPLEXFFTH_ESZMM 8 #define COMPLEXFFTH_ESIZE 4 /**< Invalid input size */
#define COMPLEXFFTH_ESLEN 16 #define COMPLEXFFTH_ESZMM 8 /**< Size mismatch */
#define COMPLEXFFTH_ESAME 32 #define COMPLEXFFTH_ESLEN 16 /**< Invalid/mismatched sequence lengths */
#define COMPLEXFFTH_EALOC 64 #define COMPLEXFFTH_ESAME 32 /**< Input/Output data vectors are the same
#define COMPLEXFFTH_EFFTW 128 */
#define COMPLEXFFTH_ESNGL 256 #define COMPLEXFFTH_EALOC 64 /**< Memory allocation failed */
#define COMPLEXFFTH_EINTL 512 #define COMPLEXFFTH_EFFTW 128 /**< Error in FFTW */
#define COMPLEXFFTH_ESIGN 1024 #define COMPLEXFFTH_ESNGL 256 /**< FFTW library is not single-precision */
#define COMPLEXFFTH_EINTL 512 /**< Error in Intel FFT library */
#define COMPLEXFFTH_ESIGN 1024 /**< Unknown sign of transform in plan */
/*@}*/
/** \cond DONT_DOXYGEN */
#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_MSGEALOC "Memory allocation failed" #define COMPLEXFFTH_MSGEALOC "Memory allocation failed"
#define COMPLEXFFTH_MSGEFFTW "Error in FFTW"
#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_MSGEINTL "Error in Intel FFT library"
#define COMPLEXFFTH_MSGESIGN "Unknown sign of transform in plan" #define COMPLEXFFTH_MSGESIGN "Unknown sign of transform in plan"
/** \endcond */
/**** </lalErrTable> */
/**** <lalLaTeX>
*
* \subsection*{Structures}
*
**** </lalLaTeX> */
/**** <lalVerbatim> */
/** Plan to perform FFT of COMPLEX8 data */ /** Plan to perform FFT of COMPLEX8 data */
typedef struct tagCOMPLEX8FFTPlan COMPLEX8FFTPlan; typedef struct tagCOMPLEX8FFTPlan COMPLEX8FFTPlan;
/** Plan to perform FFT of COMPLEX16 data */ /** Plan to perform FFT of COMPLEX16 data */
typedef struct tagCOMPLEX16FFTPlan COMPLEX16FFTPlan; typedef struct tagCOMPLEX16FFTPlan COMPLEX16FFTPlan;
#define tagComplexFFTPlan tagCOMPLEX8FFTPlan #define tagComplexFFTPlan tagCOMPLEX8FFTPlan
#define ComplexFFTPlan COMPLEX8FFTPlan #define ComplexFFTPlan COMPLEX8FFTPlan
/**** </lalVerbatim> */
/**** <lalLaTeX>
*
* This structure contains the parameters necessary for performing an FFT o
f a
* given size and direction. The contents should not be manually adjusted.
*
* \newpage\input{ComplexFFTC}
* \newpage\input{ComplexFFTTestC}
**** </lalLaTeX> */
/* /*
* *
* XLAL COMPLEX8 functions * XLAL COMPLEX8 functions
* *
*/ */
/** Returns a new COMPLEX8FFTPlan /** Returns a new COMPLEX8FFTPlan
* *
* A COMPLEX8FFTPlan is required to perform a FFT that involves complex dat a. * A COMPLEX8FFTPlan is required to perform a FFT that involves complex dat a.
skipping to change at line 234 skipping to change at line 223
* @par Errors: * @par Errors:
* The \c XLALCOMPLEX8VectorFFT() function shall fail if: * The \c XLALCOMPLEX8VectorFFT() function shall fail if:
* - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s. * - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s.
* - [\c XLAL_EINVAL] A argument is invalid or the input and output data * - [\c XLAL_EINVAL] A argument is invalid or the input and output data
* vectors are the same. * vectors are the same.
* - [\c XLAL_EBADLEN] The input vector, output vector, and plan size are * - [\c XLAL_EBADLEN] The input vector, output vector, and plan size are
* incompatible. * incompatible.
* - [\c XLAL_ENOMEM] Insufficient storage space is available. * - [\c XLAL_ENOMEM] Insufficient storage space is available.
* . * .
*/ */
int XLALCOMPLEX8VectorFFT( COMPLEX8Vector * restrict output, COMPLEX8Vector * restrict input, int XLALCOMPLEX8VectorFFT( COMPLEX8Vector * RESTRICT output, COMPLEX8Vector * RESTRICT input,
const COMPLEX8FFTPlan *plan ); const COMPLEX8FFTPlan *plan );
/* /*
* *
* XLAL COMPLEX16 functions * XLAL COMPLEX16 functions
* *
*/ */
/** Returns a new COMPLEX16FFTPlan /** Returns a new COMPLEX16FFTPlan
* *
skipping to change at line 366 skipping to change at line 355
* @par Errors: * @par Errors:
* The \c XLALCOMPLEX16VectorFFT() function shall fail if: * The \c XLALCOMPLEX16VectorFFT() function shall fail if:
* - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s. * - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s.
* - [\c XLAL_EINVAL] A argument is invalid or the input and output data * - [\c XLAL_EINVAL] A argument is invalid or the input and output data
* vectors are the same. * vectors are the same.
* - [\c XLAL_EBADLEN] The input vector, output vector, and plan size are * - [\c XLAL_EBADLEN] The input vector, output vector, and plan size are
* incompatible. * incompatible.
* - [\c XLAL_ENOMEM] Insufficient storage space is available. * - [\c XLAL_ENOMEM] Insufficient storage space is available.
* . * .
*/ */
int XLALCOMPLEX16VectorFFT( COMPLEX16Vector * restrict output, COMPLEX16Vec tor * restrict input, int XLALCOMPLEX16VectorFFT( COMPLEX16Vector * RESTRICT output, COMPLEX16Vec tor * RESTRICT input,
const COMPLEX16FFTPlan *plan ); const COMPLEX16FFTPlan *plan );
/* /*
* *
* LAL COMPLEX8 functions * LAL COMPLEX8 functions
* *
*/ */
/** \b DEPRECATED /** \b DEPRECATED
* @deprecated Use XLALCreateForwardCOMPLEX8FFTPlan instead. * @deprecated Use XLALCreateForwardCOMPLEX8FFTPlan() instead.
* @see XLALCreateForwardCOMPLEX8FFTPlan
*/ */
void void
LALCreateForwardCOMPLEX8FFTPlan( LALCreateForwardCOMPLEX8FFTPlan(
LALStatus *status, LALStatus *status,
COMPLEX8FFTPlan **plan, COMPLEX8FFTPlan **plan,
UINT4 size, UINT4 size,
INT4 measure INT4 measure
); );
/** \b DEPRECATED /** \b DEPRECATED
* @deprecated Use XLALCreateForwardCOMPLEX8FFTPlan instead. * @deprecated Use XLALCreateForwardCOMPLEX8FFTPlan() instead.
* @see XLALCreateForwardCOMPLEX8FFTPlan
*/ */
#define LALCreateForwardComplexFFTPlan LALCreateForwardCOMPLEX8FFTPlan #define LALCreateForwardComplexFFTPlan LALCreateForwardCOMPLEX8FFTPlan
/** \b DEPRECATED /** \b DEPRECATED
* @deprecated Use XLALCreateReverseCOMPLEX8FFTPlan instead. * @deprecated Use XLALCreateReverseCOMPLEX8FFTPlan() instead.
* @see XLALCreateReverseCOMPLEX8FFTPlan
*/ */
void void
LALCreateReverseCOMPLEX8FFTPlan( LALCreateReverseCOMPLEX8FFTPlan(
LALStatus *status, LALStatus *status,
COMPLEX8FFTPlan **plan, COMPLEX8FFTPlan **plan,
UINT4 size, UINT4 size,
INT4 measure INT4 measure
); );
/** \b DEPRECATED /** \b DEPRECATED
* @deprecated Use XLALCreateReverseCOMPLEX8FFTPlan instead. * @deprecated Use XLALCreateReverseCOMPLEX8FFTPlan() instead.
* @see XLALCreateReverseCOMPLEX8FFTPlan
*/ */
#define LALCreateReverseComplexFFTPlan LALCreateReverseCOMPLEX8FFTPlan #define LALCreateReverseComplexFFTPlan LALCreateReverseCOMPLEX8FFTPlan
/** \b DEPRECATED /** \b DEPRECATED
* @deprecated Use XLALDestroyCOMPLEX8FFTPlan instead. * @deprecated Use XLALDestroyCOMPLEX8FFTPlan() instead.
* @see XLALDestroyCOMPLEX8FFTPlan
*/ */
void void
LALDestroyCOMPLEX8FFTPlan ( LALDestroyCOMPLEX8FFTPlan (
LALStatus *status, LALStatus *status,
COMPLEX8FFTPlan **plan COMPLEX8FFTPlan **plan
); );
/** \b DEPRECATED /** \b DEPRECATED
* @deprecated Use XLALDestroyCOMPLEX8FFTPlan instead. * @deprecated Use XLALDestroyCOMPLEX8FFTPlan() instead.
* @see XLALDestroyCOMPLEX8FFTPlan
*/ */
#define LALDestroyComplexFFTPlan LALDestroyCOMPLEX8FFTPlan #define LALDestroyComplexFFTPlan LALDestroyCOMPLEX8FFTPlan
/** \b DEPRECATED /** \b DEPRECATED
* @deprecated Use XLALCOMPLEX8VectorFFT instead. * @deprecated Use XLALCOMPLEX8VectorFFT() instead.
* @see XLALCOMPLEX8VectorFFT
*/ */
void void
LALCOMPLEX8VectorFFT ( LALCOMPLEX8VectorFFT (
LALStatus *status, LALStatus *status,
COMPLEX8Vector *output, COMPLEX8Vector *output,
COMPLEX8Vector *input, COMPLEX8Vector *input,
COMPLEX8FFTPlan *plan COMPLEX8FFTPlan *plan
); );
/* /*
* *
* LAL COMPLEX16 functions * LAL COMPLEX16 functions
* *
*/ */
/** \b DEPRECATED /** \b DEPRECATED
* @deprecated Use XLALCreateForwardCOMPLEX16FFTPlan instead. * @deprecated Use XLALCreateForwardCOMPLEX16FFTPlan() instead.
* @see XLALCreateForwardCOMPLEX16FFTPlan
*/ */
void void
LALCreateForwardCOMPLEX16FFTPlan( LALCreateForwardCOMPLEX16FFTPlan(
LALStatus *status, LALStatus *status,
COMPLEX16FFTPlan **plan, COMPLEX16FFTPlan **plan,
UINT4 size, UINT4 size,
INT4 measure INT4 measure
); );
/** \b DEPRECATED /** \b DEPRECATED
* @deprecated Use XLALCreateReverseCOMPLEX16FFTPlan instead. * @deprecated Use XLALCreateReverseCOMPLEX16FFTPlan() instead.
* @see XLALCreateReverseCOMPLEX16FFTPlan
*/ */
void void
LALCreateReverseCOMPLEX16FFTPlan( LALCreateReverseCOMPLEX16FFTPlan(
LALStatus *status, LALStatus *status,
COMPLEX16FFTPlan **plan, COMPLEX16FFTPlan **plan,
UINT4 size, UINT4 size,
INT4 measure INT4 measure
); );
/** \b DEPRECATED /** \b DEPRECATED
* @deprecated Use XLALDestroyCOMPLEX16FFTPlan instead. * @deprecated Use XLALDestroyCOMPLEX16FFTPlan() instead.
* @see XLALDestroyCOMPLEX16FFTPlan
*/ */
void void
LALDestroyCOMPLEX16FFTPlan ( LALDestroyCOMPLEX16FFTPlan (
LALStatus *status, LALStatus *status,
COMPLEX16FFTPlan **plan COMPLEX16FFTPlan **plan
); );
/** \b DEPRECATED /** \b DEPRECATED
* @deprecated Use XLALCOMPLEX16VectorFFT instead. * @deprecated Use XLALCOMPLEX16VectorFFT() instead.
* @see XLALCOMPLEX16VectorFFT
*/ */
void void
LALCOMPLEX16VectorFFT ( LALCOMPLEX16VectorFFT (
LALStatus *status, LALStatus *status,
COMPLEX16Vector *output, COMPLEX16Vector *output,
COMPLEX16Vector *input, COMPLEX16Vector *input,
COMPLEX16FFTPlan *plan COMPLEX16FFTPlan *plan
); );
#ifdef __cplusplus /*@} */
#pragma { #undef RESTRICT
#if 0
{ /* so that editors will match succeeding brace */
#elif defined(__cplusplus)
} }
#endif #endif
#endif /* _COMPLEXFFT_H */ #endif /* _COMPLEXFFT_H */
 End of changes. 25 change blocks. 
82 lines changed or deleted 64 lines changed or added


 ComputeDataQualityVector.h   ComputeDataQualityVector.h 
skipping to change at line 28 skipping to change at line 28
*/ */
#ifndef _COMPUTE_DATA_QUALITY_VECTOR_H #ifndef _COMPUTE_DATA_QUALITY_VECTOR_H
#define _COMPUTE_DATA_QUALITY_VECTOR_H #define _COMPUTE_DATA_QUALITY_VECTOR_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/BandPassTimeSeries.h> #include <lal/BandPassTimeSeries.h>
NRCSID (COMPUTE_DATA_QUALITY_VECTORH,"$Id$"); NRCSID (COMPUTE_DATA_QUALITY_VECTORH,"$Id$");
#ifdef __cplusplus #if defined(__cplusplus)
extern "C" { extern "C" {
#pragma } /** to match the previous brace **/ #elif 0
} /* so that editors will match preceding brace */
#endif #endif
int XLALComputeDQ(REAL4* sv_data, int r_sv, int XLALComputeDQ(REAL4* sv_data, int r_sv,
REAL4* lax_data, REAL4* lay_data, int r_light, REAL4* lax_data, REAL4* lay_data, int r_light,
COMPLEX16* gamma_data, int r_gamma, COMPLEX16* gamma_data, int r_gamma,
int t_bad_left, int t_bad_right, int wings, int t_bad_left, int t_bad_right, int wings,
int missing, int missing,
int* dq_data, int n_dq); int* dq_data, int n_dq);
#ifdef __cplusplus #if 0
#pragma { /** to match the next brace **/ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus)
} }
#endif #endif
#endif /* _COMPUTE_DATA_QUALITY_VECTOR_H */ #endif /* _COMPUTE_DATA_QUALITY_VECTOR_H */
 End of changes. 3 change blocks. 
4 lines changed or deleted 6 lines changed or added


 ConfigFile.h   ConfigFile.h 
skipping to change at line 38 skipping to change at line 38
/** \file /** \file
* \ingroup ConfigFile * \ingroup ConfigFile
* \author Reinhard Prix * \author Reinhard Prix
* \date $Date$ * \date $Date$
* \brief Header file defining the API for ConfigFile.c. * \brief Header file defining the API for ConfigFile.c.
*/ */
#ifndef _CONFIGFILE_H /* Double-include protection. */ #ifndef _CONFIGFILE_H /* Double-include protection. */
#define _CONFIGFILE_H #define _CONFIGFILE_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/StringInput.h> #include <lal/StringInput.h>
/* C++ protection. */ /* C++ protection. */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID( CONFIGFILEH, "$Id$"); NRCSID( CONFIGFILEH, "$Id$");
/** Levels of strictness for config-file parsing. */ /** Levels of strictness for config-file parsing. */
typedef enum { typedef enum {
CONFIGFILE_IGNORE = 0, /**< ignore missing config-variable or unpar sed config-entries */ CONFIGFILE_IGNORE = 0, /**< ignore missing config-variable or unpar sed config-entries */
CONFIGFILE_WARN, /**< issue a warning but don't report an err or. */ CONFIGFILE_WARN, /**< issue a warning but don't report an err or. */
CONFIGFILE_ERROR, /**< issue an error-message and report a LAL -error */ CONFIGFILE_ERROR, /**< issue an error-message and report a LAL -error */
CONFIGFILE_LAST CONFIGFILE_LAST
} ConfigStrictness; } ConfigStrictness;
/** This structure defines a config-variable to be read in using the /** This structure defines a config-variable to be read in using the
* general-purpose reading function LALReadConfigVariable(). */ * general-purpose reading function LALReadConfigVariable(). */
typedef struct { #ifdef SWIG /* SWIG interface directives */
%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagLALConfigVar::secName;
%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagLALConfigVar::varName;
%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagLALConfigVar::fmt;
#endif /* SWIG */
typedef struct tagLALConfigVar {
SWIGLAL_STRUCT(LALConfigVar);
const CHAR *secName; /**< Section name within which to find varN ame. May be NULL */ const CHAR *secName; /**< Section name within which to find varN ame. May be NULL */
const CHAR *varName; /**< Variable-name to be read in the config- file */ const CHAR *varName; /**< Variable-name to be read in the config- file */
const CHAR *fmt; /**< Format string for reading (<tt>sscanf() </tt>-style) */ const CHAR *fmt; /**< Format string for reading (<tt>sscanf() </tt>-style) */
ConfigStrictness strictness; /**< what to do if variable not found: ignor e, warn, error */ ConfigStrictness strictness; /**< what to do if variable not found: ignor e, warn, error */
} LALConfigVar; } LALConfigVar;
/** This structure is returned by LALParseDataFile() and holds the contents of an /** This structure is returned by LALParseDataFile() and holds the contents of an
* ASCII data-file in a pre-parsed form, namely stripped from all comments ('#', ';'+), * ASCII data-file in a pre-parsed form, namely stripped from all comments ('#', ';'+),
* spurious whitespaces, and separated into lines (taking into account line -continuation * spurious whitespaces, and separated into lines (taking into account line -continuation
* by '\' at the end of lines). * by '\' at the end of lines).
* This is used as the input structure in the config-variable reading routi nes. * This is used as the input structure in the config-variable reading routi nes.
*/ */
typedef struct { typedef struct tagLALParsedDataFile {
SWIGLAL_STRUCT(LALParsedDataFile);
TokenList *lines; /**< list of pre-parsed data-file lines */ TokenList *lines; /**< list of pre-parsed data-file lines */
BOOLEAN *wasRead; /**< keep track of successfully read lines for stric tness-checking */ BOOLEAN *wasRead; /**< keep track of successfully read lines for stric tness-checking */
} LALParsedDataFile; } LALParsedDataFile;
/* Function prototypes */ /* Function prototypes */
int XLALParseDataFile (LALParsedDataFile **cfgdata, const CHAR *fname); int XLALParseDataFile (LALParsedDataFile **cfgdata, const CHAR *fname);
int XLALDestroyParsedDataFile (LALParsedDataFile **cfgdata); int XLALDestroyParsedDataFile (LALParsedDataFile **cfgdata);
int XLALConfigSectionExists(const LALParsedDataFile *, const CHAR *); int XLALConfigSectionExists(const LALParsedDataFile *, const CHAR *);
 End of changes. 3 change blocks. 
2 lines changed or deleted 14 lines changed or added


 Date.h   Date.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/** \file /**
* \ingroup std * \defgroup Date_h Time Conversions
* \author Chin, D. W. and Creighton, J. D. E. * \ingroup date
* \brief Routines for converting between various time representations. * \author D.W. Chin, J.D.E. Creighton and Kipp Cannon
* * \brief Provides routines for manipulating date and time information.
*/
/* <lalVerbatim file="DateHV">
Author: David Chin <dwchin@umich.edu> +1-734-709-9119
</lalVerbatim> */
/* <lalLaTeX>
\section{Header \texttt{Date.h}}
\label{s:Date.h}
Provides routines for manipulating date and time information.
\subsection*{Synopsis} \heading{Synopsis}
\begin{verbatim} \code
#include <lal/Date.h> #include <lal/Date.h>
\end{verbatim} \endcode
This header covers routines for manipulating date and time This header covers routines for manipulating date and time
information. The various time systems are discussed in~\cite{esaa:1992}. information. The various time systems are discussed in [\ref esaa1992].
</lalLaTeX> */ */
#ifndef _DATE_H #ifndef _DATE_H
#define _DATE_H #define _DATE_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
/* the following two preprocessor defines are to include the prototypes for /* the following two preprocessor defines are to include the prototypes for
* gmtime_r() and asctime_r() from /usr/include/time.h * gmtime_r() and asctime_r() from /usr/include/time.h
* HOWEVER, they do no good if -ansi is used in gcc: warnings are generated * HOWEVER, they do no good if -ansi is used in gcc: warnings are generated
* that the prototypes have not been seen */ * that the prototypes have not been seen */
/* HP-UX and Solaris */ /* HP-UX and Solaris */
#ifndef _REENTRANT #ifndef _REENTRANT
# define _REENTRANT # define _REENTRANT
#endif #endif
skipping to change at line 88 skipping to change at line 80
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.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
#define XLAL_BILLION_INT4 1000000000
#define XLAL_BILLION_INT8 LAL_INT8_C( 1000000000 )
#define XLAL_BILLION_REAL8 1e9
/** \ingroup Date_h *//*@{*/
/** The UNIX time of the GPS origin epoch. /** The UNIX time of the GPS origin epoch.
* *
* 1980 6 JAN 0h UTC is 3657 days after 1970 1 JAN 0h UTC: * 1980 6 JAN 0h UTC is 3657 days after 1970 1 JAN 0h UTC:
* 8 standard years of 365 days = 2920 days * 8 standard years of 365 days = 2920 days
* 2 leap years of 366 days = 734 days * 2 leap years of 366 days = 734 days
* 5 extra days. * 5 extra days.
* Hence 3657*86400=315964800. * Hence 3657*86400=315964800.
* *
* Note that this deliberately does not account for any leap seconds in the * Note that this deliberately does not account for any leap seconds in the
* interval. POSIX:2001 defines the relation between the UNIX time * interval. POSIX:2001 defines the relation between the UNIX time
skipping to change at line 117 skipping to change at line 114
* \c t=315964800. That is what this is. * \c t=315964800. That is what this is.
*/ */
#define XLAL_EPOCH_UNIX_GPS 315964800 #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_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_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_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_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_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_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. */ #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. */ /* Converts GPS time to nano seconds stored as an INT8. */
INT8 XLALGPSToINT8NS( const LIGOTimeGPS *epoch ); INT8 XLALGPSToINT8NS( const LIGOTimeGPS *epoch );
/** Converts nano seconds stored as an INT8 to GPS time. */ /* Converts nano seconds stored as an INT8 to GPS time. */
LIGOTimeGPS * XLALINT8NSToGPS( LIGOTimeGPS *epoch, INT8 ns ); LIGOTimeGPS * XLALINT8NSToGPS( LIGOTimeGPS *epoch, INT8 ns );
/** Sets GPS time given GPS integer seconds and residual nanoseconds. */ /* Sets GPS time given GPS integer seconds and residual nanoseconds. */
LIGOTimeGPS * XLALGPSSet( LIGOTimeGPS *epoch, INT4 gpssec, INT4 gpsnan ); LIGOTimeGPS * XLALGPSSet( LIGOTimeGPS *epoch, INT4 gpssec, INT4 gpsnan );
/** Sets GPS time given GPS seconds as a REAL8. */ /* Sets GPS time given GPS seconds as a REAL8. */
LIGOTimeGPS * XLALGPSSetREAL8( LIGOTimeGPS *epoch, REAL8 t ); LIGOTimeGPS * XLALGPSSetREAL8( LIGOTimeGPS *epoch, REAL8 t );
/** Returns GPS time as a REAL8. */ /* Returns GPS time as a REAL8. */
REAL8 XLALGPSGetREAL8( const LIGOTimeGPS *epoch ); REAL8 XLALGPSGetREAL8( const LIGOTimeGPS *epoch );
/** Adds dt to a GPS time. */ /* Adds dt to a GPS time. */
LIGOTimeGPS * XLALGPSAdd( LIGOTimeGPS *epoch, REAL8 dt ); LIGOTimeGPS * XLALGPSAdd( LIGOTimeGPS *epoch, REAL8 dt );
/** Adds two GPS times. */ /* Adds two GPS times. */
LIGOTimeGPS * XLALGPSAddGPS( LIGOTimeGPS *epoch, const LIGOTimeGPS *dt ); LIGOTimeGPS * XLALGPSAddGPS( LIGOTimeGPS *epoch, const LIGOTimeGPS *dt );
/** Difference between two GPS times. */ /* Difference between two GPS times. */
REAL8 XLALGPSDiff( const LIGOTimeGPS *t1, const LIGOTimeGPS *t0 ); REAL8 XLALGPSDiff( const LIGOTimeGPS *t1, const LIGOTimeGPS *t0 );
/** Compares two GPS times. /* 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 ); int XLALGPSCmp( const LIGOTimeGPS *t0, const LIGOTimeGPS *t1 );
/** Multiply a GPS time by a REAL8 */ /* Multiply a GPS time by a REAL8 */
LIGOTimeGPS *XLALGPSMultiply( LIGOTimeGPS *gps, REAL8 x ); LIGOTimeGPS *XLALGPSMultiply( LIGOTimeGPS *gps, REAL8 x );
/** Divide a GPS time by a REAL8 */ /* Divide a GPS time by a REAL8 */
LIGOTimeGPS *XLALGPSDivide( LIGOTimeGPS *gps, REAL8 x ); LIGOTimeGPS *XLALGPSDivide( LIGOTimeGPS *gps, REAL8 x );
/** Returns the leap seconds TAI-UTC at a given GPS second. */ /* Returns the leap seconds TAI-UTC at a given GPS second. */
int XLALLeapSeconds( INT4 gpssec /**< [In] Seconds relative to GPS epoch.*/ ); int XLALLeapSeconds( INT4 gpssec /**< [In] Seconds relative to GPS epoch.*/ );
/** Returns the leap seconds GPS-UTC at a given GPS second. */ /* Returns the leap seconds GPS-UTC at a given GPS second. */
int XLALGPSLeapSeconds( INT4 gpssec /**< [In] Seconds relative to GPS epoch .*/ ); int XLALGPSLeapSeconds( INT4 gpssec /**< [In] Seconds relative to GPS epoch .*/ );
/** Returns the leap seconds TAI-UTC for a given UTC broken down time. */ /* 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.*/ ); int XLALLeapSecondsUTC( const struct tm *utc /**< [In] UTC as a broken down time.*/ );
/** Returns the GPS seconds since the GPS epoch for a /* Returns the GPS seconds since the GPS epoch for a specified UTC time str
* specified UTC time structure. */ ucture. */
INT4 XLALUTCToGPS( const struct tm *utc /**< [In] UTC time in a broken down 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 /* Returns a pointer to a tm structure representing the time
* specified in seconds since the GPS epoch. */ * specified in seconds since the GPS epoch. */
struct tm * XLALGPSToUTC( struct tm * XLALGPSToUTC(
struct tm *utc, /**< [Out] Pointer to tm struct where result is stored. */ struct tm *utc, /**< [Out] Pointer to tm struct where result is stored. */
INT4 gpssec /**< [In] Seconds since the GPS epoch. */ INT4 gpssec /**< [In] Seconds since the GPS epoch. */
); );
/** Returns the Julian Day (JD) corresponding to the date given in a broken /* Returns the Julian Day (JD) corresponding to the date given in a broken
* down time structure. */ * down time structure. */
REAL8 XLALJulianDay( const struct tm *utc /**< [In] UTC time in a broken do wn 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 /* Returns the Modified Julian Day (MJD) corresponding to the date given in
* in a broken down time structure. 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. */ ); INT4 XLALModifiedJulianDay( const struct tm *utc /**< [In] UTC time in a br oken down time structure. */ );
/** Returns the Greenwich mean or aparent sideral time in radians. /* Returns the Greenwich mean or aparent sideral time in radians. */
*/
REAL8 XLALGreenwichSiderealTime( REAL8 XLALGreenwichSiderealTime(
const LIGOTimeGPS *gpstime, const LIGOTimeGPS *gpstime,
REAL8 equation_of_equinoxes REAL8 equation_of_equinoxes
); );
/** Returns the Greenwich Mean Sidereal Time in RADIANS for a specified GPS /* Returns the Greenwich Mean Sidereal Time in RADIANS for a specified GPS
* time. */ time. */
REAL8 XLALGreenwichMeanSiderealTime( REAL8 XLALGreenwichMeanSiderealTime(
const LIGOTimeGPS *gpstime const LIGOTimeGPS *gpstime
); );
/** Returns the GPS time for the given Greenwich mean sidereal time (in /* Returns the GPS time for the given Greenwich mean sidereal time (in radi
* radians). */ ans). */
LIGOTimeGPS *XLALGreenwichMeanSiderealTimeToGPS( LIGOTimeGPS *XLALGreenwichMeanSiderealTimeToGPS(
REAL8 gmst, REAL8 gmst,
LIGOTimeGPS *gps LIGOTimeGPS *gps
); );
/** Returns the GPS time for the given Greenwich sidereal time (in /* Returns the GPS time for the given Greenwich sidereal time (in radians).
* radians). */ */
LIGOTimeGPS *XLALGreenwichSiderealTimeToGPS( LIGOTimeGPS *XLALGreenwichSiderealTimeToGPS(
REAL8 gmst, REAL8 gmst,
REAL8 equation_of_equinoxes, REAL8 equation_of_equinoxes,
LIGOTimeGPS *gps LIGOTimeGPS *gps
); );
/* <lalLaTeX> /** \ingroup Date_h
* This structure is just the standard Unix \c tm structure, described
\subsection*{Structures} * in the man page for <tt>ctime(3)</tt>. We shall
* {\em always} ignore the daylight savings time field, \c tm_isdst.
\vfill{\footnotesize\input{DateHV}}
\subsubsection*{Structure \texttt{LALUnixDate}}
\idx[Type]{LALUnixDate}
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+.
</lalLaTeX> */
/*
* The standard Unix tm structure
*/ */
typedef struct typedef struct
tm tm
LALUnixDate; LALUnixDate;
/* <lalLaTeX> /** \ingroup Date_h
* This structure stores pointers to a ::LALDetector and a
\subsubsection{Structure \texttt{LALPlaceAndGPS}} * ::LIGOTimeGPS. Its sole purpose is to aggregate these
\idx[Type]{LALPlaceAndGPS} * structures for passing to functions.
This structure stores pointers to a \texttt{LALDetector} and a
\texttt{LIGOTimeGPS}. Its sole purpose is to aggregate these
structures for passing to functions. The fields are:
\begin{description}
\item{\verb+LALDetector *p_detector+} Pointer to a detector
\item{\verb+LIGOTimeGPS *p_gps+} Pointer to a GPS time structure
\end{description}
</lalLaTeX> */
/*
* Place and time structures
*/ */
/* First, with GPS */
typedef struct typedef struct
tagLALPlaceAndGPS tagLALPlaceAndGPS
{ {
LALDetector *p_detector; /* pointer to a detector */ SWIGLAL_STRUCT(LALPlaceAndGPS);
LIGOTimeGPS *p_gps; /* pointer to GPS time */ LALDetector *p_detector; /**< pointer to a detector */
LIGOTimeGPS *p_gps; /**< Pointer to a GPS time structure */
} }
LALPlaceAndGPS; LALPlaceAndGPS;
/* /*
* Function prototypes * Function prototypes
*/ */
int XLALStrToGPS(LIGOTimeGPS *t, const char *nptr, char **endptr); int XLALStrToGPS(LIGOTimeGPS *t, const char *nptr, char **endptr);
char *XLALGPSToStr(char *, const LIGOTimeGPS *t); char *XLALGPSToStr(char *, const LIGOTimeGPS *t);
/* This function returns the current GPS time according to the system clock */ /* This function returns the current GPS time according to the system clock */
LIGOTimeGPS * LIGOTimeGPS *
XLALGPSTimeNow ( XLALGPSTimeNow (
LIGOTimeGPS *gpstime LIGOTimeGPS *gpstime
); );
/* <lalLaTeX>
\newpage\input{PlaygroundC}
</lalLaTeX> */
int int
XLALINT8NanoSecIsPlayground ( XLALINT8NanoSecIsPlayground (
INT8 ns INT8 ns
); );
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _DATE_H */ #endif /* _DATE_H */
 End of changes. 35 change blocks. 
107 lines changed or deleted 59 lines changed or added


 DetResponse.h   DetResponse.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/* <lalVerbatim file="DetResponseHV">
Author: David Chin <dwchin@umich.edu> +1-734-709-9119
$Id$
</lalVerbatim>*/
/*
<lalLaTeX>
\section{Header \texttt{DetResponse.h}}
\label{sec:DetResponse.h}
Provides routines to compute gravitational wave detector response to
polarized planar gravitational wave originating from a given source,
detected at a given time.
\subsection{Synopsis}
\label{ss:Synopsis}
\begin{verbatim}
#include <lal/DetResponse.h>
\end{verbatim}
</lalLaTeX>
*/
#ifndef _DETRESPONSE_H #ifndef _DETRESPONSE_H
#define _DETRESPONSE_H #define _DETRESPONSE_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#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> #include <lal/Date.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
{ {
#endif #endif
NRCSID( DETRESPONSEH, "$Id$" ); NRCSID( DETRESPONSEH, "$Id$" );
/* /**
<lalLaTeX> \author David Chin <dwchin@umich.edu>, Kipp Cannon <kipp@gravity.phys.uwm.e
\subsection*{Error conditions} du>
</lalLaTeX> \addtogroup DetResponse_h
*/
/* \brief Provides routines to compute gravitational wave detector response to
<lalErrTable> polarized planar gravitational wave originating from a given source,
*/ detected at a given time.
#define DETRESPONSEH_ENULLINPUT 1
#define DETRESPONSEH_ENULLOUTPUT 2
#define DETRESPONSEH_ESRCNOTEQUATORIAL 3
#define DETRESPONSEH_MSGENULLINPUT "Input is NULL" \heading{Synopsis}
#define DETRESPONSEH_MSGENULLOUTPUT "Output is NULL"
#define DETRESPONSEH_MSGESRCNOTEQUATORIAL "Source coordinates not in Equato
rial system"
/* \code
</lalErrTable> #include <lal/DetResponse.h>
*/ \endcode
/* \heading{Description}
<lalLaTeX>
\subsection*{Types and Structures}
</lalLaTeX>
*/
/* <lalLaTeX> These routines compute the antenna beam pattern for all supported detector
types. <tt>XLALComputeDetAMResponse()</tt> computes the response at one
instance in time, and <tt>XLALComputeDetAMResponseSeries()</tt> computes a
vector of response for some length of time.
\vfill{\footnotesize\input{DetResponseHV}} \heading{Algorithm}
</lalLaTeX> */ This code is a translation of the algorithm in the Maple worksheet by
Anderson, <em>et al.</em> [\ref Anderson_2000]. We compute the \f$h\f$-ten
sors for
\f$+\f$- and \f$\times\f$-polarized in the Earth-fixed frame, and then cont
ract
them (take the scalar product) with the detector response tensors as
described in the \ref LALDetectors_h section of the \c tools package.
/* <lalLaTeX> \ref LALDetectors_h in the \c tools package provides predefined
\subsubsection*{Structure \texttt{LALSource}} \c LALDetector structures representing most current detectors,
\idx[Type]{LALSource} including LIGO (Hanford and Livingston), and GEO.
This structure contains gravitational wave source position (in Equatorial \heading{Uses}
co\"{o}rdinates), and orientation angle. The orientation is measured LALGPStoGMST1()
counter-clockwise with respect to the ``line of ascending nodes'',
\textit{i.e.} counter-clockwise with respect to a line perpendicular to the
source's meridian and extending westwards. For a source in the Northern
celestial hemisphere, and an observer in the Northern hemisphere standing
such that they are facing South, this angle is measured counter-clockwise
from a 3 o'clock position (pointing West) at the source. The polarization
convention is chosen such that if the source orientation were zero, the
source would be a pure $+$-polarized source.
The fields are: \heading{Notes}
\begin{description}
\item[\texttt{CHAR *name}] Name of source
\item[\texttt{SkyPosition equatorialCoords}] Equatorial co\"{o}rdinates of
source
\item[\texttt{REAL8 orientation}] Orientation angle ($\psi$) of source:
counter-clockwise angle $x$-axis makes with a line perpendicular to
meridian of source in Westward direction (\textit{i.e.} North of West),
in decimal radians.
\end{description}
</lalLaTeX> */ For examples of usage, please see the test programs in the \c test
directory.
*/
/** @{ */
/** \name Error Codes */
/*@{*/
#define DETRESPONSEH_ENULLINPUT 1 /**< Input is NULL */
#define DETRESPONSEH_ENULLOUTPUT 2 /**< Output is NULL */
#define DETRESPONSEH_ESRCNOTEQUATORIAL 3 /**< Source coordinates not
in Equatorial system */
/*@}*/
/** \cond DONT_DOXYGEN */
#define DETRESPONSEH_MSGENULLINPUT "Input is NULL"
#define DETRESPONSEH_MSGENULLOUTPUT "Output is NULL"
#define DETRESPONSEH_MSGESRCNOTEQUATORIAL "Source coordinates not in Equato
rial system"
/** \endcond */
/** This structure contains gravitational wave source position (in Equatori
al
* coördinates), and orientation angle.
* The orientation is measured counter-clockwise with respect to the "line
of ascending nodes",
* i.e. counter-clockwise with respect to a line perpendicular to the
* source's meridian and extending westwards. For a source in the Northern
* celestial hemisphere, and an observer in the Northern hemisphere standin
g
* such that they are facing South, this angle is measured counter-clockwis
e
* from a 3 o'clock position (pointing West) at the source. The polarizati
on
* convention is chosen such that if the source orientation were zero, the
* source would be a pure \f$+\f$-polarized source.
*/
typedef struct typedef struct
tagLALSource tagLALSource
{ {
CHAR name[LALNameLength]; /* name of source, e.g. catalog number SWIGLAL_STRUCT(LALSource);
*/ CHAR name[LALNameLength]; /**< name of source, eg catalog number
SkyPosition equatorialCoords; /* equatorial coordinates of source, */
in decimal RADIANS */ SkyPosition equatorialCoords; /**< equatorial coordinates of source,
REAL8 orientation; /* counter-clockwise angle x-axis make in decimal RADIANS */
s REAL8 orientation; /**< Orientation angle (\f$\psi\f$) of
with a line perpendicular to meridi source:
an * counter-clockwise angle \f$x\f$-axi
of object in Westward direction, in s makes with a line perpendicular to
decimal RADIANS (i.e. North of West * meridian of source in Westward dire
) */ ction (i.e. North of West),
* in decimal radians.
*/
} }
LALSource; LALSource;
/* <lalLaTeX> /** This structure aggregates a pointer to a \c LALDetector and a
\subsubsection*{Structure \texttt{LALDetAndSource}} * \c LALSource. Its sole function is to allow the user to pass
\idx[Type]{LALDetAndSource} * detector and source parameters to the functions
* LALComputeDetAMResponse() and
This structure aggregates a pointer to a \texttt{LALDetector} and a * LALComputeDetAMResponseSeries().
\texttt{LALSource}. Its sole function is to allow the user to pass */
detector and source parameters to the functions
\texttt{LALComputeDetAMResponse()} and
\texttt{LALComputeDetAMResponseSeries()}.
The fields are:
\begin{description}
\item[\texttt{LALDetector *pDetector}] Pointer to \texttt{LALDetector}
object containing information about the detector
\item[\texttt{LALSource *pSource}] Pointer to \texttt{LALSource} object
containing information about the source
\end{description}
</lalLaTeX> */
typedef struct typedef struct
tagLALDetAndSource tagLALDetAndSource
{ {
LALDetector *pDetector; SWIGLAL_STRUCT(LALDetAndSource);
LALSource *pSource; LALDetector *pDetector; /**< Pointer to ::LALDetector object contain
ing information about the detector */
LALSource *pSource; /**< Pointer to ::LALSource object containin
g information about the source */
} }
LALDetAndSource; LALDetAndSource;
/* <lalLaTeX> /** This structure encapsulates the detector AM (beam pattern) coefficients
\subsubsection{Structure \texttt{LALDetAMResponse}} for
\idx[Type]{LALDetAMResponse} * one source at one instance in time.
*/
This structure encapsulates the detector AM (beam pattern) coefficients for
one source at one instance in time. The fields are:
\begin{description}
\item[\texttt{REAL4 plus}] Detector response to $+$-polarized gravitational
radiation
\item[\texttt{REAL4 cross}] Detector response to $\times$-polarized
gravitational radiation
\item[\texttt{REAL4 scalar}] Detector response to scalar gravitational
radiation (NB: ignored at present -- scalar response computation is not
yet implemented)
\end{description}
</lalLaTeX> */
typedef struct typedef struct
tagLALDetAMResponse tagLALDetAMResponse
{ {
REAL4 plus; SWIGLAL_STRUCT(LALDetAMResponse);
REAL4 cross; REAL4 plus; /**< Detector response to \f$+\f$-polarized gravitational ra
REAL4 scalar; diation */
REAL4 cross; /**< Detector response to \f$\times\f$-polarized gravitation
al radiation */
REAL4 scalar; /**< Detector response to scalar gravitational radia
tion (NB: ignored at present -- scalar response computation not yet impleme
nted) */
} }
LALDetAMResponse; LALDetAMResponse;
/* <lalLaTeX> /** This structure aggregates together three ::REAL4TimeSeries objects cont
\subsubsection{Structure \texttt{LALDetAMResponseSeries}} aining
\idx[Type]{LALDetAMResponseSeries} * time series of detector AM response.
*/
This structure aggregates together three \texttt{REAL4Vector}s containing
time series of detector AM response. Since these quantities are
dimensionless, they cannot be accurately stored in a \texttt{TimeSeries}
structure. However, \texttt{REAL4Vector}s may be conveniently converted to
\texttt{TimeSeries} format.
\begin{description}
\item[\texttt{REAL4TimeSeries *pPlus}] Pointer to a \texttt{REAL4TimeSeries
}
containing detector response to $+$-polarized gravitational radiation
over a span of time
\item[\texttt{REAL4TimeSeries *pCross}] Pointer to a \texttt{REAL4TimeSerie
s}
containing detector response to $\times$-polarized gravitational radiatio
n
over a span of time
\item[\texttt{REAL4TimeSeries *pScalar}] Pointer to a \texttt{REAL4TimeSeri
es}
containing detector response to scalar gravitational radiation
over a span of time. (NB: This is unused for the moment. Response to
scalar gravitational radiation is not yet implemented.)
\end{description}
</lalLaTeX> */
typedef struct typedef struct
tagLALDetAMResponseSeries tagLALDetAMResponseSeries
{ {
REAL4TimeSeries *pPlus; SWIGLAL_STRUCT(LALDetAMResponseSeries);
REAL4TimeSeries *pCross; REAL4TimeSeries *pPlus; /**< timeseries of detector response to \f$+
REAL4TimeSeries *pScalar; \f$-polarized gravitational radiation */
REAL4TimeSeries *pCross; /**< timeseries of detector response to \f$\
times\f$-polarized gravitational radiation */
REAL4TimeSeries *pScalar; /**< timeseries of detector response to scal
ar gravitational radiation (NB: not yet implemented.) */
} }
LALDetAMResponseSeries; LALDetAMResponseSeries;
/* <lalLaTeX> /** This structure encapsulates time and sampling information for computing
\subsubsection*{Structure \texttt{LALTimeIntervalAndNSample}} a
\idx[Type]{LALTimeIntervalAndNSample} * ::LALDetAMResponseSeries. Its fields correspond to some fields of the
* TimeSeries structures for easy conversion.
This structure encapsulates time and sampling information for computing a */
\texttt{LALDetAMResponseSeries}. Its fields correspond to some fields of th
e
\texttt{TimeSeries} structures for easy conversion.
\begin{description}
\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{UINT4 nSample}] The total number of samples to be computed
\item[\texttt{LALLeapSecAccuracy accuracy}] The required accuracy for handl
ing leap seconds
\end{description}
</lalLaTeX> */
typedef struct typedef struct
tagLALTimeIntervalAndNSample tagLALTimeIntervalAndNSample
{ {
LIGOTimeGPS epoch; SWIGLAL_STRUCT(LALTimeIntervalAndNSample);
REAL8 deltaT; /* sampling interval */ LIGOTimeGPS epoch; /**< The start time \f$t_0\f$ of the time se
UINT4 nSample; /* number of samples */ ries */
REAL8 deltaT; /**< The sampling interval \f$\Delta t\f$, i
n seconds */
UINT4 nSample; /**< The total number of samples to be compu
ted */
} }
LALTimeIntervalAndNSample; LALTimeIntervalAndNSample;
/* /*
<lalLaTeX>
\vfill{\footnotesize\input{DetResponseHV}}
</lalLaTeX>
*/
/*
* Function prototypes * Function prototypes
*/ */
/*
<lalLaTeX>
\newpage\input{DetResponseC}
</lalLaTeX>
*/
void void
LALComputeDetAMResponse( LALStatus *status, LALComputeDetAMResponse( LALStatus *status,
LALDetAMResponse *pResponse, LALDetAMResponse *pResponse,
const LALDetAndSource *pDetAndSrc, const LALDetAndSource *pDetAndSrc,
const LIGOTimeGPS *gps); const LIGOTimeGPS *gps);
void XLALComputeDetAMResponse( void XLALComputeDetAMResponse(
double *fplus, double *fplus,
double *fcross, double *fcross,
REAL4 D[3][3], REAL4 D[3][3],
skipping to change at line 306 skipping to change at line 222
REAL4TimeSeries **fcross, REAL4TimeSeries **fcross,
REAL4 D[3][3], REAL4 D[3][3],
const double ra, const double ra,
const double dec, const double dec,
const double psi, const double psi,
const LIGOTimeGPS *start, const LIGOTimeGPS *start,
const double deltaT, const double deltaT,
const int n const int n
); );
/** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* !defined _DETRESPONSE_H */ #endif /* !defined _DETRESPONSE_H */
 End of changes. 27 change blocks. 
196 lines changed or deleted 133 lines changed or added


 DetectorSite.h   DetectorSite.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/********************************* <lalVerbatim file="DetectorSiteHV"> /*
Author: J. T. Whelan <john.whelan@ligo.org> * author John T. Whelan
$Id$ * date 2007
********************************** </lalVerbatim> */ * Dummy header file which includes LALDetectors.h for backwards compatibil
ity
/********************************* <lalLaTeX>
\section{Header \texttt{DetectorSite.h}}
\label{tools:s:DetectorSite.h}
This is a dummy header which includes \texttt{LALDetectors.h}, for
backwards compatibility.
******************************************************* </lalLaTeX> */
/**
* \author John T. Whelan
* \date 2007
* \file
* \ingroup tools
* \brief Dummy header file which includes LALDetectors.h for backwards com
patibility
*
* $Id$
* *
*/ */
#ifndef _DETECTORSITE_H #ifndef _DETECTORSITE_H
#define _DETECTORSITE_H #define _DETECTORSITE_H
#include <lal/LALDetectors.h> #include <lal/LALDetectors.h>
/* C++ protection. */ /* C++ protection. */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (DETECTORSITEH, "$Id$"); NRCSID (DETECTORSITEH, "$Id$");
/********************************** <lalVerbatim> */
/** Legacy code: should now use data in LALDetectors.h */ /** Legacy code: should now use data in LALDetectors.h */
enum enum
{ {
LALDetectorIndexLHODIFF = LAL_LHO_4K_DETECTOR, LALDetectorIndexLHODIFF = LAL_LHO_4K_DETECTOR,
LALDetectorIndexLLODIFF = LAL_LLO_4K_DETECTOR, LALDetectorIndexLLODIFF = LAL_LLO_4K_DETECTOR,
LALDetectorIndexVIRGODIFF = LAL_VIRGO_DETECTOR, LALDetectorIndexVIRGODIFF = LAL_VIRGO_DETECTOR,
LALDetectorIndexGEO600DIFF = LAL_GEO_600_DETECTOR, LALDetectorIndexGEO600DIFF = LAL_GEO_600_DETECTOR,
LALDetectorIndexTAMA300DIFF = LAL_TAMA_300_DETECTOR, LALDetectorIndexTAMA300DIFF = LAL_TAMA_300_DETECTOR,
LALDetectorIndexCIT40DIFF = LAL_CIT_40_DETECTOR, LALDetectorIndexCIT40DIFF = LAL_CIT_40_DETECTOR,
LALNumCachedDetectors = LAL_NUM_DETECTORS LALNumCachedDetectors = LAL_NUM_DETECTORS
}; };
/********************************** </lalVerbatim> */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _DETECTORSITE_H */ #endif /* _DETECTORSITE_H */
 End of changes. 3 change blocks. 
26 lines changed or deleted 5 lines changed or added


 Dirichlet.h   Dirichlet.h 
skipping to change at line 72 skipping to change at line 72
\vfill{\footnotesize\input{DirichletHV}} \vfill{\footnotesize\input{DirichletHV}}
\newpage\input{DirichletC} \newpage\input{DirichletC}
\newpage\input{DirichletTestC} \newpage\input{DirichletTestC}
*********************************************************** </lalLaTeX> */ *********************************************************** </lalLaTeX> */
#ifndef _DIRICHLET_H #ifndef _DIRICHLET_H
#define _DIRICHLET_H #define _DIRICHLET_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (DIRICHLETH, "$Id$"); NRCSID (DIRICHLETH, "$Id$");
/******************************** <lalErrTable file="DirichletHErrTable"> * / /******************************** <lalErrTable file="DirichletHErrTable"> * /
skipping to change at line 101 skipping to change at line 106
#define DIRICHLETH_MSGENVALUE "Dirichlet parameter N less than or equal to zero" #define DIRICHLETH_MSGENVALUE "Dirichlet parameter N less than or equal to zero"
#define DIRICHLETH_MSGESIZE "Length parameter less than or equal to ze ro" #define DIRICHLETH_MSGESIZE "Length parameter less than or equal to ze ro"
#define DIRICHLETH_MSGEDELTAX "Spacing of x values less than or equal to zero" #define DIRICHLETH_MSGEDELTAX "Spacing of x values less than or equal to zero"
#define DIRICHLETH_MSGENULLPOUT "Null pointer to ouput vector" #define DIRICHLETH_MSGENULLPOUT "Null pointer to ouput vector"
#define DIRICHLETH_MSGESIZEMM "Length of data member of output vector do es not equal length specified in input parameters" #define DIRICHLETH_MSGESIZEMM "Length of data member of output vector do es not equal length specified in input parameters"
#define DIRICHLETH_MSGENULLPDOUT "Null pointer to data member of output vec tor" #define DIRICHLETH_MSGENULLPDOUT "Null pointer to data member of output vec tor"
/************************************ </lalErrTable> */ /************************************ </lalErrTable> */
typedef struct tagDirichletParameters{ typedef struct tagDirichletParameters{
SWIGLAL_STRUCT(DirichletParameters);
UINT4 n; /* LALDirichlet parameter N */ UINT4 n; /* LALDirichlet parameter N */
UINT4 length; /* specified length of output vector */ UINT4 length; /* specified length of output vector */
REAL8 deltaX; /* spacing of x values */ REAL8 deltaX; /* spacing of x values */
} DirichletParameters; } DirichletParameters;
void void
LALDirichlet(LALStatus*, LALDirichlet(LALStatus*,
REAL4Vector*, REAL4Vector*,
const DirichletParameters*); const DirichletParameters*);
 End of changes. 2 change blocks. 
0 lines changed or deleted 6 lines changed or added


 EllipsoidOverlapTools.h   EllipsoidOverlapTools.h 
skipping to change at line 32 skipping to change at line 32
* File Name: EllipsoidOverlapTools.h * File Name: EllipsoidOverlapTools.h
* *
* Author: Robinson, C. A., and Sengupta, A. * Author: Robinson, C. A., and Sengupta, A.
* *
* Revision: $Id$ * Revision: $Id$
* *
*----------------------------------------------------------------------- *-----------------------------------------------------------------------
*/ */
#if 0 #if 0
<lalVerbatim file="EllipsoidOverlapToolsHV">
Author: Robinson, C. A. and Sengupta, A. S. Author: Robinson, C. A. and Sengupta, A. S.
$Id$
</lalVerbatim>
#endif #endif
#ifndef _ELLIPSOIDOVERLAPTOOLS_H #ifndef _ELLIPSOIDOVERLAPTOOLS_H
#define _ELLIPSOIDOVERLAPTOOLS_H #define _ELLIPSOIDOVERLAPTOOLS_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <math.h> #include <math.h>
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/LALGSL.h> #include <lal/LALGSL.h>
#include <lal/LALError.h> #include <lal/LALError.h>
#include <gsl/gsl_errno.h> #include <gsl/gsl_errno.h>
#include <gsl/gsl_math.h> #include <gsl/gsl_math.h>
#include <gsl/gsl_min.h> #include <gsl/gsl_min.h>
#include <gsl/gsl_vector.h> #include <gsl/gsl_vector.h>
#include <gsl/gsl_matrix.h> #include <gsl/gsl_matrix.h>
skipping to change at line 62 skipping to change at line 64
#include <gsl/gsl_linalg.h> #include <gsl/gsl_linalg.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID( ELLIPSOIDOVERLAPTOOLSH, "$Id$" ); NRCSID( ELLIPSOIDOVERLAPTOOLSH, "$Id$" );
typedef struct tagfContactWorkSpace typedef struct tagfContactWorkSpace
{ {
SWIGLAL_STRUCT(fContactWorkSpace);
/* Dimension of the matrices & vectors */ /* Dimension of the matrices & vectors */
UINT4 n; UINT4 n;
/* Vector r_AB = r_B - r_A and */ /* Vector r_AB = r_B - r_A and */
/* shape matrices for ellipsoid centered */ /* shape matrices for ellipsoid centered */
/* at points A and B */ /* at points A and B */
gsl_vector *r_AB; gsl_vector *r_AB;
const gsl_matrix *invQ1, *invQ2; const gsl_matrix *invQ1, *invQ2;
/* Parameters for minimizing the contact function */ /* Parameters for minimizing the contact function */
 End of changes. 4 change blocks. 
3 lines changed or deleted 6 lines changed or added


 FileIO.h   FileIO.h 
skipping to change at line 45 skipping to change at line 45
\noindent Only use \texttt{FileIO.h} in test code that links to \noindent Only use \texttt{FileIO.h} in test code that links to
the \texttt{lalsupport} library. the \texttt{lalsupport} library.
\vfill{\footnotesize\input{FileIOHV}} \vfill{\footnotesize\input{FileIOHV}}
\newpage\input{FileIOC} \newpage\input{FileIOC}
</lalLaTeX> */ </lalLaTeX> */
#ifndef _FILEIO_H #ifndef _FILEIO_H
#define _FILEIO_H #define _FILEIO_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
#include <lal/LALRCSID.h> #include <lal/LALRCSID.h>
#include <lal/LALStdio.h> #include <lal/LALStdio.h>
NRCSID( FILEIOH, "$Id$" ); NRCSID( FILEIOH, "$Id$" );
/* maximum string size to print with LAL Printf routines */ /* maximum string size to print with LAL Printf routines */
#define LAL_PRINTF_BUFSIZE 4096 #define LAL_PRINTF_BUFSIZE 4096
FILE * FILE *
LALOpenDataFile( const char * ); LALOpenDataFile( const char * );
typedef struct tagLALFILE { int compression; void *fp; } LALFILE; typedef struct tagLALFILE {
SWIGLAL_STRUCT(LALFILE);
int compression;
void *fp;
} LALFILE;
LALFILE *lalstdin(void); LALFILE *lalstdin(void);
LALFILE *lalstdout(void); LALFILE *lalstdout(void);
LALFILE *lalstderr(void); LALFILE *lalstderr(void);
#define lalstdin (lalstdin()) #define LALSTDIN (lalstdin())
#define lalstdout (lalstdout()) #define LALSTDOUT (lalstdout())
#define lalstderr (lalstderr()) #define LALSTDERR (lalstderr())
int XLALFileIsCompressed( const char *path ); int XLALFileIsCompressed( const char *path );
LALFILE * XLALFileOpenRead( const char *path ); LALFILE * XLALFileOpenRead( const char *path );
LALFILE * XLALFileOpenWrite( const char *path, int compression ); LALFILE * XLALFileOpenWrite( const char *path, int compression );
LALFILE * XLALFileOpenAppend( const char *path, int compression ); LALFILE * XLALFileOpenAppend( const char *path, int compression );
LALFILE * XLALFileOpen( const char *path, const char *mode ); LALFILE * XLALFileOpen( const char *path, const char *mode );
int XLALFileClose( LALFILE * file ); int XLALFileClose( LALFILE * file );
size_t XLALFileRead( void *ptr, size_t size, size_t nobj, LALFILE *file ); size_t XLALFileRead( void *ptr, size_t size, size_t nobj, LALFILE *file );
size_t XLALFileWrite( const void *ptr, size_t size, size_t nobj, LALFILE *f ile ); size_t XLALFileWrite( const void *ptr, size_t size, size_t nobj, LALFILE *f ile );
int XLALFileGetc( LALFILE *file ); int XLALFileGetc( LALFILE *file );
int XLALFilePutc( int c, LALFILE *file ); int XLALFilePutc( int c, LALFILE *file );
char * XLALFileGets( char * s, int size, LALFILE *file ); char * XLALFileGets( char * s, int size, LALFILE *file );
int XLALFilePuts( const char * s, LALFILE *file ); int XLALFilePuts( const char * s, LALFILE *file );
#ifndef SWIG /* exclude from SWIG interface */
int XLALFileVPrintf( LALFILE *file, const char *fmt, va_list ap ); int XLALFileVPrintf( LALFILE *file, const char *fmt, va_list ap );
#endif /* SWIG */
int XLALFilePrintf( LALFILE *file, const char *fmt, ... ); int XLALFilePrintf( LALFILE *file, const char *fmt, ... );
int XLALFileFlush( LALFILE *file ); int XLALFileFlush( LALFILE *file );
int XLALFileSeek( LALFILE *file, long offset, int whence ); int XLALFileSeek( LALFILE *file, long offset, int whence );
long XLALFileTell( LALFILE *file ); long XLALFileTell( LALFILE *file );
void XLALFileRewind( LALFILE *file ); void XLALFileRewind( LALFILE *file );
int XLALFileEOF( LALFILE *file ); int XLALFileEOF( LALFILE *file );
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
 End of changes. 5 change blocks. 
4 lines changed or deleted 15 lines changed or added


 FindRoot.h   FindRoot.h 
skipping to change at line 47 skipping to change at line 47
\noindent This header covers the routines for root finding. \noindent This header covers the routines for root finding.
</lalLaTeX> </lalLaTeX>
#endif /* autodoc block */ #endif /* autodoc block */
#ifndef _FINDROOT_H #ifndef _FINDROOT_H
#define _FINDROOT_H #define _FINDROOT_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (FINDROOTH, "$Id$"); NRCSID (FINDROOTH, "$Id$");
#if 0 /* autodoc block */ #if 0 /* autodoc block */
skipping to change at line 129 skipping to change at line 134
\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 struct typedef struct
tagSFindRootIn tagSFindRootIn
{ {
SWIGLAL_STRUCT(SFindRootIn);
void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p); 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
{ {
SWIGLAL_STRUCT(DFindRootIn);
void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p); 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>
 End of changes. 3 change blocks. 
0 lines changed or deleted 7 lines changed or added


 FlatLatticeTiling.h   FlatLatticeTiling.h 
skipping to change at line 22 skipping to change at line 22
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/** /**
* \author Karl Wette * \author Karl Wette
* \file * \ingroup pulsarTODO
* \brief Lattice-based template generation for flat metric parameter space s * \brief Lattice-based template generation for flat metric parameter space s
*/ */
#ifndef _FLATLATTICETILING_H #ifndef _FLATLATTICETILING_H
#define _FLATLATTICETILING_H #define _FLATLATTICETILING_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <gsl/gsl_vector.h> #include <gsl/gsl_vector.h>
#include <gsl/gsl_matrix.h> #include <gsl/gsl_matrix.h>
#include <lal/LALRCSID.h> #include <lal/LALRCSID.h>
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/Random.h> #include <lal/Random.h>
#include <lal/GSLSupport.h> #include <lal/GSLSupport.h>
#ifdef __cplusplus #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0
} /* so that editors will match preceding brace */
#endif #endif
NRCSID(FLATLATTICETILINGH, "$Id$"); NRCSID(FLATLATTICETILINGH, "$Id$");
/**
* Flat lattice tiling bound
*/
typedef BOOLEAN (*FlatLatticeTilingBoundFunc)(
void *data, /**< Arbi
trary data describing parameter space */
INT4 dimension, /**< Dime
nsion on which bound applies */
gsl_vector *point, /**< Poin
t on which to find bounds */
REAL8 *lower, /**< Lowe
r bound on point in dimension */
REAL8 *upper /**< Uppe
r bound on point in dimension */
);
typedef void (*FlatLatticeTilingBoundFree)(
void *data /**< Arbitrary data
describing parameter space */
);
typedef struct tagFlatLatticeTilingBound {
/* Number of bound dimensions */
INT4 dimensions;
/* Dimensions which are bound */
UINT8 is_bound;
/* Parameter space bound function */
FlatLatticeTilingBoundFunc func;
/* Arbitrary data describing parameter space */
void *data;
/* Cleanup function */
FlatLatticeTilingBoundFree free;
} FlatLatticeTilingBound;
/**
* Flat lattice tiling subspace
*/
typedef struct tagFlatLatticeTilingSubspace {
/* Total number of tiled (non-flat) dimensions */
INT4 dimensions;
/* Dimensions which are tiled (non-flat) */
UINT8 is_tiled;
/* Padding of bounds along each dimension */
gsl_vector *padding;
/* Increment vectors of the lattice tiling generator */ /**
gsl_matrix *increment; * Flat lattice tiling bound
*/
typedef BOOLEAN (*FlatLatticeTilingBoundFunc)(
void *data, /**< Arbit
rary data describing parameter space */
INT4 dimension, /**< Dimen
sion on which bound applies */
gsl_vector *point, /**< Point
on which to find bounds */
REAL8 *lower, /**< Lower
bound on point in dimension */
REAL8 *upper /**< Upper
bound on point in dimension */
);
typedef void (*FlatLatticeTilingBoundFree)(
void *data /**< Arbitrary data d
escribing parameter space */
);
typedef struct tagFlatLatticeTilingBound FlatLatticeTilingBound;
} FlatLatticeTilingSubspace; /**
* Flat lattice tiling subspace
*/
typedef struct tagFlatLatticeTilingSubspace FlatLatticeTilingSubspace;
/** /**
* Flat tiling lattice generator * Flat tiling lattice generator
*/ */
typedef int (*FlatTilingLatticeGenerator)( typedef int (*FlatTilingLatticeGenerator)(
INT4 dimensions, /**< Num INT4 dimensions, /**< Numb
ber of dimensions */ er of dimensions */
gsl_matrix** generator, /**< Gen gsl_matrix** generator, /**< Gene
erator matrix */ rator matrix */
REAL8* norm_thickness /**< Nor REAL8* norm_thickness /**< Norm
malised thickness */ alised thickness */
); );
/** /**
* State of the flat lattice tiling algorithm * Flat lattice tiling state/input structure
*/ */
typedef enum tagFlatLatticeTilingState { typedef struct tagFlatLatticeTiling {
FLT_S_NotInitialised, SWIGLAL_STRUCT(FlatLatticeTiling);
FLT_S_NotStarted,
FLT_S_InProgress,
FLT_S_Finished
} FlatLatticeTilingState;
typedef struct tagFlatLatticeTiling {
/* Dimension of the parameter space */ /* Dimension of the parameter space */
INT4 dimensions; INT4 dimensions;
/* Parameter space bounds */ /* Parameter space bounds */
INT4 num_bounds; INT4 num_bounds;
FlatLatticeTilingBound **bounds; FlatLatticeTilingBound **bounds;
gsl_vector_int *bound_map; gsl_vector_int *bound_map;
gsl_vector *bound_point; gsl_vector *bound_point;
/* Metric of the parameter space in normalised coordinates */ /* Metric of the parameter space in normalised coordinates */
gsl_matrix *metric; gsl_matrix *metric;
/* Normalised to real parameter coordinates scaling and offset */ /* Normalised to real parameter coordinates scaling and offset */
gsl_vector *real_scale; gsl_vector *real_scale;
gsl_vector *real_offset; gsl_vector *real_offset;
/* Maximum metric mismatch between the templates */ /* Maximum metric mismatch between the templates */
REAL8 max_mismatch; REAL8 max_mismatch;
/* Flat tiling lattice generator */ /* Flat tiling lattice generator */
FlatTilingLatticeGenerator generator; FlatTilingLatticeGenerator generator;
/* Cache of generated tiling subspaces */ /* Cache of generated tiling subspaces */
INT4 num_subspaces; INT4 num_subspaces;
FlatLatticeTilingSubspace **subspaces; FlatLatticeTilingSubspace **subspaces;
/* Scaling of the padding of bounds (for testing) */ /* Scaling of the padding of bounds (for testing) */
REAL8 scale_padding; REAL8 scale_padding;
/* Current dimensions which are tiled (non-flat) */ /* Current dimensions which are tiled (non-flat) */
UINT8 curr_is_tiled; UINT8 curr_is_tiled;
/* Current tiling subspace */ /* Current tiling subspace */
FlatLatticeTilingSubspace *curr_subspace; FlatLatticeTilingSubspace *curr_subspace;
/* Current lattice point */ /* Current lattice point */
gsl_vector *curr_point; gsl_vector *curr_point;
/* Bounds on current point */ /* Bounds on current point */
gsl_vector *curr_lower; gsl_vector *curr_lower;
gsl_vector *curr_upper; gsl_vector *curr_upper;
/* Current template */ /* Current template */
gsl_vector *current; gsl_vector *current;
/* Total number of points generated so far */ /* Total number of points generated so far */
UINT4 count; UINT4 count;
/* State of the tiling */ /* State of the tiling */
FlatLatticeTilingState state; int state;
} FlatLatticeTiling; } FlatLatticeTiling;
/** /**
* Core functions * Core functions
*/ */
FlatLatticeTiling* XLALCreateFlatLatticeTiling(INT4); FlatLatticeTiling* XLALCreateFlatLatticeTiling(INT4);
void XLALFreeFlatLatticeTiling(FlatLatticeTiling*); void XLALFreeFlatLatticeTiling(FlatLatticeTiling*);
int XLALAddFlatLatticeTilingBound(FlatLatticeTiling*, UINT8, FlatLatticeT int XLALAddFlatLatticeTilingBound(FlatLatticeTiling*, UINT8, FlatLatticeTil
ilingBoundFunc, void*, FlatLatticeTilingBoundFree); ingBoundFunc, void*, FlatLatticeTilingBoundFree);
int XLALSetFlatLatticeTilingMetric(FlatLatticeTiling*, gsl_matrix*, REAL8 int XLALSetFlatLatticeTilingMetric(FlatLatticeTiling*, gsl_matrix*, REAL8,
, gsl_vector*); gsl_vector*);
int XLALSetFlatTilingLattice(FlatLatticeTiling*, FlatTilingLatticeGenerat int XLALSetFlatTilingLattice(FlatLatticeTiling*, FlatTilingLatticeGenerator
or); );
int XLALNextFlatLatticePoint(FlatLatticeTiling*); int XLALNextFlatLatticePoint(FlatLatticeTiling*);
UINT4 XLALTotalFlatLatticePointCount(FlatLatticeTiling*); UINT4 XLALTotalFlatLatticePointCount(FlatLatticeTiling*);
int XLALRandomPointInFlatLatticeParamSpace(FlatLatticeTiling*, RandomPara int XLALRandomPointInFlatLatticeParamSpace(FlatLatticeTiling*, RandomParams
ms*, gsl_vector*, gsl_vector*, REAL8*); *, gsl_vector*, gsl_vector*, REAL8*);
/** /**
* Support functions * Support functions
*/ */
gsl_matrix* XLALMetricEllipsePrincipalAxes(gsl_matrix*, REAL8); gsl_matrix* XLALMetricEllipsePrincipalAxes(gsl_matrix*, REAL8);
gsl_vector* XLALMetricEllipseBoundingBox(gsl_matrix*, REAL8); gsl_vector* XLALMetricEllipseBoundingBox(gsl_matrix*, REAL8);
int XLALOrthonormaliseWRTMetric(gsl_matrix*, gsl_matrix*); int XLALOrthonormaliseWRTMetric(gsl_matrix*, gsl_matrix*);
gsl_matrix* XLALSquareLowerTriangularLatticeGenerator(gsl_matrix*); gsl_matrix* XLALSquareLowerTriangularLatticeGenerator(gsl_matrix*);
int XLALNormaliseLatticeGenerator(gsl_matrix*, REAL8, REAL8); int XLALNormaliseLatticeGenerator(gsl_matrix*, REAL8, REAL8);
/** /**
* Specific lattices and parameter spaces * Specific lattices and parameter spaces
*/ */
int XLALSetFlatTilingCubicLattice(FlatLatticeTiling*); int XLALSetFlatTilingCubicLattice(FlatLatticeTiling*);
int XLALSetFlatTilingAnstarLattice(FlatLatticeTiling*); int XLALSetFlatTilingAnstarLattice(FlatLatticeTiling*);
int XLALAddFlatLatticeTilingConstantBound(FlatLatticeTiling*, INT4, REAL8 int XLALAddFlatLatticeTilingConstantBound(FlatLatticeTiling*, INT4, REAL8,
, REAL8); REAL8);
#ifdef __cplusplus #if 0
{ /* so that editors will match succeeding brace */
#elif defined(__cplusplus)
} }
#endif #endif
#endif #endif
 End of changes. 29 change blocks. 
147 lines changed or deleted 120 lines changed or added


 FrequencySeries.h   FrequencySeries.h 
skipping to change at line 26 skipping to change at line 26
* You should have received a copy of the GNU General Public License along * You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc., * with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/ */
#ifndef _FREQUENCYSERIES_H #ifndef _FREQUENCYSERIES_H
#define _FREQUENCYSERIES_H #define _FREQUENCYSERIES_H
#include <stddef.h> #include <stddef.h>
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/LALRCSID.h> #include <lal/LALRCSID.h>
#if defined(__cplusplus)
extern "C" {
#elif 0
} /* so that editors will match preceding brace */
#endif
NRCSID(FREQUENCYSERIESH, "$Id:"); NRCSID(FREQUENCYSERIESH, "$Id:");
/* <lalLaTeX file="FrequencySeriesDestroyP"> /* COMPLEX8 prototypes */
\idx{XLALDestroyCOMPLEX8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
void XLALDestroyCOMPLEX8FrequencySeries ( void XLALDestroyCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *series COMPLEX8FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCreateP">
\idx{XLALCreateCOMPLEX8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
COMPLEX8FrequencySeries *XLALCreateCOMPLEX8FrequencySeries ( COMPLEX8FrequencySeries *XLALCreateCOMPLEX8FrequencySeries (
const CHAR *name, const CHAR *name,
const LIGOTimeGPS *epoch, const LIGOTimeGPS *epoch,
REAL8 f0, REAL8 f0,
REAL8 deltaF, REAL8 deltaF,
const LALUnit *sampleUnits, const LALUnit *sampleUnits,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCutP">
\idx{XLALCutCOMPLEX8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
COMPLEX8FrequencySeries *XLALCutCOMPLEX8FrequencySeries ( COMPLEX8FrequencySeries *XLALCutCOMPLEX8FrequencySeries (
const COMPLEX8FrequencySeries *series, const COMPLEX8FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALResizeCOMPLEX8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
COMPLEX8FrequencySeries *XLALResizeCOMPLEX8FrequencySeries ( COMPLEX8FrequencySeries *XLALResizeCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *series, COMPLEX8FrequencySeries *series,
int first, int first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALShrinkCOMPLEX8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
COMPLEX8FrequencySeries *XLALShrinkCOMPLEX8FrequencySeries ( COMPLEX8FrequencySeries *XLALShrinkCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *series, COMPLEX8FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesAddP">
\idx{XLALAddCOMPLEX8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
COMPLEX8FrequencySeries *XLALAddCOMPLEX8FrequencySeries ( COMPLEX8FrequencySeries *XLALAddCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *arg1, COMPLEX8FrequencySeries *arg1,
const COMPLEX8FrequencySeries *arg2 const COMPLEX8FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesConjugateP">
\idx{XLALConjugateCOMPLEX8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesConjugateP"> */
COMPLEX8FrequencySeries *XLALConjugateCOMPLEX8FrequencySeries ( COMPLEX8FrequencySeries *XLALConjugateCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *series COMPLEX8FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesMultiplyP">
\idx{XLALMultiplyCOMPLEX8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
COMPLEX8FrequencySeries *XLALMultiplyCOMPLEX8FrequencySeries ( COMPLEX8FrequencySeries *XLALMultiplyCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *arg1, COMPLEX8FrequencySeries *arg1,
const COMPLEX8FrequencySeries *arg2 const COMPLEX8FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesDestroyP"> /* COMPLEX 16 prototypes */
\idx{XLALDestroyCOMPLEX16FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
void XLALDestroyCOMPLEX16FrequencySeries ( void XLALDestroyCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *series COMPLEX16FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCreateP">
\idx{XLALCreateCOMPLEX16FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
COMPLEX16FrequencySeries *XLALCreateCOMPLEX16FrequencySeries ( COMPLEX16FrequencySeries *XLALCreateCOMPLEX16FrequencySeries (
const CHAR *name, const CHAR *name,
const LIGOTimeGPS *epoch, const LIGOTimeGPS *epoch,
REAL8 f0, REAL8 f0,
REAL8 deltaF, REAL8 deltaF,
const LALUnit *sampleUnits, const LALUnit *sampleUnits,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCutP">
\idx{XLALCutCOMPLEX16FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
COMPLEX16FrequencySeries *XLALCutCOMPLEX16FrequencySeries ( COMPLEX16FrequencySeries *XLALCutCOMPLEX16FrequencySeries (
const COMPLEX16FrequencySeries *series, const COMPLEX16FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALResizeCOMPLEX16FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
COMPLEX16FrequencySeries *XLALResizeCOMPLEX16FrequencySeries ( COMPLEX16FrequencySeries *XLALResizeCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *series, COMPLEX16FrequencySeries *series,
int first, int first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALShrinkCOMPLEX16FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
COMPLEX16FrequencySeries *XLALShrinkCOMPLEX16FrequencySeries ( COMPLEX16FrequencySeries *XLALShrinkCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *series, COMPLEX16FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesAddP">
\idx{XLALAddCOMPLEX16FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
COMPLEX16FrequencySeries *XLALAddCOMPLEX16FrequencySeries ( COMPLEX16FrequencySeries *XLALAddCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *arg1, COMPLEX16FrequencySeries *arg1,
const COMPLEX16FrequencySeries *arg2 const COMPLEX16FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesConjugateP">
\idx{XLALConjugateCOMPLEX16FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesConjugateP"> */
COMPLEX16FrequencySeries *XLALConjugateCOMPLEX16FrequencySeries ( COMPLEX16FrequencySeries *XLALConjugateCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *series COMPLEX16FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesMultiplyP">
\idx{XLALMultiplyCOMPLEX16FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
COMPLEX16FrequencySeries *XLALMultiplyCOMPLEX16FrequencySeries ( COMPLEX16FrequencySeries *XLALMultiplyCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *arg1, COMPLEX16FrequencySeries *arg1,
const COMPLEX16FrequencySeries *arg2 const COMPLEX16FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesDestroyP"> /* REAL4 prototypes */
\idx{XLALDestroyREAL4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
void XLALDestroyREAL4FrequencySeries ( void XLALDestroyREAL4FrequencySeries (
REAL4FrequencySeries *series REAL4FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCreateP">
\idx{XLALCreateREAL4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
REAL4FrequencySeries *XLALCreateREAL4FrequencySeries ( REAL4FrequencySeries *XLALCreateREAL4FrequencySeries (
const CHAR *name, const CHAR *name,
const LIGOTimeGPS *epoch, const LIGOTimeGPS *epoch,
REAL8 f0, REAL8 f0,
REAL8 deltaF, REAL8 deltaF,
const LALUnit *sampleUnits, const LALUnit *sampleUnits,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCutP">
\idx{XLALCutREAL4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
REAL4FrequencySeries *XLALCutREAL4FrequencySeries ( REAL4FrequencySeries *XLALCutREAL4FrequencySeries (
const REAL4FrequencySeries *series, const REAL4FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALResizeREAL4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
REAL4FrequencySeries *XLALResizeREAL4FrequencySeries ( REAL4FrequencySeries *XLALResizeREAL4FrequencySeries (
REAL4FrequencySeries *series, REAL4FrequencySeries *series,
int first, int first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALShrinkREAL4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
REAL4FrequencySeries *XLALShrinkREAL4FrequencySeries ( REAL4FrequencySeries *XLALShrinkREAL4FrequencySeries (
REAL4FrequencySeries *series, REAL4FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesAddP">
\idx{XLALAddREAL4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
REAL4FrequencySeries *XLALAddREAL4FrequencySeries ( REAL4FrequencySeries *XLALAddREAL4FrequencySeries (
REAL4FrequencySeries *arg1, REAL4FrequencySeries *arg1,
const REAL4FrequencySeries *arg2 const REAL4FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesMultiplyP">
\idx{XLALMultiplyREAL4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
REAL4FrequencySeries *XLALMultiplyREAL4FrequencySeries ( REAL4FrequencySeries *XLALMultiplyREAL4FrequencySeries (
REAL4FrequencySeries *arg1, REAL4FrequencySeries *arg1,
const REAL4FrequencySeries *arg2 const REAL4FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesDestroyP"> /* REAL8 prototypes */
\idx{XLALDestroyREAL8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
void XLALDestroyREAL8FrequencySeries ( void XLALDestroyREAL8FrequencySeries (
REAL8FrequencySeries *series REAL8FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCreateP">
\idx{XLALCreateREAL8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
REAL8FrequencySeries *XLALCreateREAL8FrequencySeries ( REAL8FrequencySeries *XLALCreateREAL8FrequencySeries (
const CHAR *name, const CHAR *name,
const LIGOTimeGPS *epoch, const LIGOTimeGPS *epoch,
REAL8 f0, REAL8 f0,
REAL8 deltaF, REAL8 deltaF,
const LALUnit *sampleUnits, const LALUnit *sampleUnits,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCutP">
\idx{XLALCutREAL8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
REAL8FrequencySeries *XLALCutREAL8FrequencySeries ( REAL8FrequencySeries *XLALCutREAL8FrequencySeries (
const REAL8FrequencySeries *series, const REAL8FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALResizeREAL8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
REAL8FrequencySeries *XLALResizeREAL8FrequencySeries ( REAL8FrequencySeries *XLALResizeREAL8FrequencySeries (
REAL8FrequencySeries *series, REAL8FrequencySeries *series,
int first, int first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALShrinkREAL8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
REAL8FrequencySeries *XLALShrinkREAL8FrequencySeries ( REAL8FrequencySeries *XLALShrinkREAL8FrequencySeries (
REAL8FrequencySeries *series, REAL8FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesAddP">
\idx{XLALAddREAL8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
REAL8FrequencySeries *XLALAddREAL8FrequencySeries ( REAL8FrequencySeries *XLALAddREAL8FrequencySeries (
REAL8FrequencySeries *arg1, REAL8FrequencySeries *arg1,
const REAL8FrequencySeries *arg2 const REAL8FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesMultiplyP">
\idx{XLALMultiplyREAL8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
REAL8FrequencySeries *XLALMultiplyREAL8FrequencySeries ( REAL8FrequencySeries *XLALMultiplyREAL8FrequencySeries (
REAL8FrequencySeries *arg1, REAL8FrequencySeries *arg1,
const REAL8FrequencySeries *arg2 const REAL8FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesDestroyP"> /* INT2 prototypes */
\idx{XLALDestroyINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
void XLALDestroyINT2FrequencySeries ( void XLALDestroyINT2FrequencySeries (
INT2FrequencySeries *series INT2FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCreateP">
\idx{XLALCreateINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
INT2FrequencySeries *XLALCreateINT2FrequencySeries ( INT2FrequencySeries *XLALCreateINT2FrequencySeries (
const CHAR *name, const CHAR *name,
const LIGOTimeGPS *epoch, const LIGOTimeGPS *epoch,
REAL8 f0, REAL8 f0,
REAL8 deltaF, REAL8 deltaF,
const LALUnit *sampleUnits, const LALUnit *sampleUnits,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCutP">
\idx{XLALCutINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
INT2FrequencySeries *XLALCutINT2FrequencySeries ( INT2FrequencySeries *XLALCutINT2FrequencySeries (
const INT2FrequencySeries *series, const INT2FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALResizeINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
INT2FrequencySeries *XLALResizeINT2FrequencySeries ( INT2FrequencySeries *XLALResizeINT2FrequencySeries (
INT2FrequencySeries *series, INT2FrequencySeries *series,
int first, int first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALShrinkINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
INT2FrequencySeries *XLALShrinkINT2FrequencySeries ( INT2FrequencySeries *XLALShrinkINT2FrequencySeries (
INT2FrequencySeries *series, INT2FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesAddP">
\idx{XLALAddINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
INT2FrequencySeries *XLALAddINT2FrequencySeries ( INT2FrequencySeries *XLALAddINT2FrequencySeries (
INT2FrequencySeries *arg1, INT2FrequencySeries *arg1,
const INT2FrequencySeries *arg2 const INT2FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesMultiplyP">
\idx{XLALMultiplyINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
INT2FrequencySeries *XLALMultiplyINT2FrequencySeries ( INT2FrequencySeries *XLALMultiplyINT2FrequencySeries (
INT2FrequencySeries *arg1, INT2FrequencySeries *arg1,
const INT2FrequencySeries *arg2 const INT2FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesDestroyP"> /* INT4 prototypes */
\idx{XLALDestroyINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
void XLALDestroyINT4FrequencySeries ( void XLALDestroyINT4FrequencySeries (
INT4FrequencySeries *series INT4FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCreateP">
\idx{XLALCreateINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
INT4FrequencySeries *XLALCreateINT4FrequencySeries ( INT4FrequencySeries *XLALCreateINT4FrequencySeries (
const CHAR *name, const CHAR *name,
const LIGOTimeGPS *epoch, const LIGOTimeGPS *epoch,
REAL8 f0, REAL8 f0,
REAL8 deltaF, REAL8 deltaF,
const LALUnit *sampleUnits, const LALUnit *sampleUnits,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCutP">
\idx{XLALCutINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
INT4FrequencySeries *XLALCutINT4FrequencySeries ( INT4FrequencySeries *XLALCutINT4FrequencySeries (
const INT4FrequencySeries *series, const INT4FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALResizeINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
INT4FrequencySeries *XLALResizeINT4FrequencySeries ( INT4FrequencySeries *XLALResizeINT4FrequencySeries (
INT4FrequencySeries *series, INT4FrequencySeries *series,
int first, int first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALShrinkINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
INT4FrequencySeries *XLALShrinkINT4FrequencySeries ( INT4FrequencySeries *XLALShrinkINT4FrequencySeries (
INT4FrequencySeries *series, INT4FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesAddP">
\idx{XLALAddINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
INT4FrequencySeries *XLALAddINT4FrequencySeries ( INT4FrequencySeries *XLALAddINT4FrequencySeries (
INT4FrequencySeries *arg1, INT4FrequencySeries *arg1,
const INT4FrequencySeries *arg2 const INT4FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesMultiplyP">
\idx{XLALMultiplyINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
INT4FrequencySeries *XLALMultiplyINT4FrequencySeries ( INT4FrequencySeries *XLALMultiplyINT4FrequencySeries (
INT4FrequencySeries *arg1, INT4FrequencySeries *arg1,
const INT4FrequencySeries *arg2 const INT4FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesDestroyP"> /* INT8 prototypes */
\idx{XLALDestroyINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
void XLALDestroyINT8FrequencySeries ( void XLALDestroyINT8FrequencySeries (
INT8FrequencySeries *series INT8FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCreateP">
\idx{XLALCreateINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
INT8FrequencySeries *XLALCreateINT8FrequencySeries ( INT8FrequencySeries *XLALCreateINT8FrequencySeries (
const CHAR *name, const CHAR *name,
const LIGOTimeGPS *epoch, const LIGOTimeGPS *epoch,
REAL8 f0, REAL8 f0,
REAL8 deltaF, REAL8 deltaF,
const LALUnit *sampleUnits, const LALUnit *sampleUnits,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCutP">
\idx{XLALCutINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
INT8FrequencySeries *XLALCutINT8FrequencySeries ( INT8FrequencySeries *XLALCutINT8FrequencySeries (
const INT8FrequencySeries *series, const INT8FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALResizeINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
INT8FrequencySeries *XLALResizeINT8FrequencySeries ( INT8FrequencySeries *XLALResizeINT8FrequencySeries (
INT8FrequencySeries *series, INT8FrequencySeries *series,
int first, int first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALShrinkINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
INT8FrequencySeries *XLALShrinkINT8FrequencySeries ( INT8FrequencySeries *XLALShrinkINT8FrequencySeries (
INT8FrequencySeries *series, INT8FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesAddP">
\idx{XLALAddINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
INT8FrequencySeries *XLALAddINT8FrequencySeries ( INT8FrequencySeries *XLALAddINT8FrequencySeries (
INT8FrequencySeries *arg1, INT8FrequencySeries *arg1,
const INT8FrequencySeries *arg2 const INT8FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesMultiplyP">
\idx{XLALMultiplyINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
INT8FrequencySeries *XLALMultiplyINT8FrequencySeries ( INT8FrequencySeries *XLALMultiplyINT8FrequencySeries (
INT8FrequencySeries *arg1, INT8FrequencySeries *arg1,
const INT8FrequencySeries *arg2 const INT8FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesDestroyP"> /* UINT2 prototypes */
\idx{XLALDestroyUINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
void XLALDestroyUINT2FrequencySeries ( void XLALDestroyUINT2FrequencySeries (
UINT2FrequencySeries *series UINT2FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCreateP">
\idx{XLALCreateUINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
UINT2FrequencySeries *XLALCreateUINT2FrequencySeries ( UINT2FrequencySeries *XLALCreateUINT2FrequencySeries (
const CHAR *name, const CHAR *name,
const LIGOTimeGPS *epoch, const LIGOTimeGPS *epoch,
REAL8 f0, REAL8 f0,
REAL8 deltaF, REAL8 deltaF,
const LALUnit *sampleUnits, const LALUnit *sampleUnits,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCutP">
\idx{XLALCutUINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
UINT2FrequencySeries *XLALCutUINT2FrequencySeries ( UINT2FrequencySeries *XLALCutUINT2FrequencySeries (
const UINT2FrequencySeries *series, const UINT2FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALResizeUINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
UINT2FrequencySeries *XLALResizeUINT2FrequencySeries ( UINT2FrequencySeries *XLALResizeUINT2FrequencySeries (
UINT2FrequencySeries *series, UINT2FrequencySeries *series,
int first, int first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALShrinkUINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
UINT2FrequencySeries *XLALShrinkUINT2FrequencySeries ( UINT2FrequencySeries *XLALShrinkUINT2FrequencySeries (
UINT2FrequencySeries *series, UINT2FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesAddP">
\idx{XLALAddUINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
UINT2FrequencySeries *XLALAddUINT2FrequencySeries ( UINT2FrequencySeries *XLALAddUINT2FrequencySeries (
UINT2FrequencySeries *arg1, UINT2FrequencySeries *arg1,
const UINT2FrequencySeries *arg2 const UINT2FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesMultiplyP">
\idx{XLALMultiplyUINT2FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
UINT2FrequencySeries *XLALMultiplyUINT2FrequencySeries ( UINT2FrequencySeries *XLALMultiplyUINT2FrequencySeries (
UINT2FrequencySeries *arg1, UINT2FrequencySeries *arg1,
const UINT2FrequencySeries *arg2 const UINT2FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesDestroyP"> /* UINT4 prototypes */
\idx{XLALDestroyUINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
void XLALDestroyUINT4FrequencySeries ( void XLALDestroyUINT4FrequencySeries (
UINT4FrequencySeries *series UINT4FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCreateP">
\idx{XLALCreateUINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
UINT4FrequencySeries *XLALCreateUINT4FrequencySeries ( UINT4FrequencySeries *XLALCreateUINT4FrequencySeries (
const CHAR *name, const CHAR *name,
const LIGOTimeGPS *epoch, const LIGOTimeGPS *epoch,
REAL8 f0, REAL8 f0,
REAL8 deltaF, REAL8 deltaF,
const LALUnit *sampleUnits, const LALUnit *sampleUnits,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCutP">
\idx{XLALCutUINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
UINT4FrequencySeries *XLALCutUINT4FrequencySeries ( UINT4FrequencySeries *XLALCutUINT4FrequencySeries (
const UINT4FrequencySeries *series, const UINT4FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALResizeUINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
UINT4FrequencySeries *XLALResizeUINT4FrequencySeries ( UINT4FrequencySeries *XLALResizeUINT4FrequencySeries (
UINT4FrequencySeries *series, UINT4FrequencySeries *series,
int first, int first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALShrinkUINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
UINT4FrequencySeries *XLALShrinkUINT4FrequencySeries ( UINT4FrequencySeries *XLALShrinkUINT4FrequencySeries (
UINT4FrequencySeries *series, UINT4FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesAddP">
\idx{XLALAddUINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
UINT4FrequencySeries *XLALAddUINT4FrequencySeries ( UINT4FrequencySeries *XLALAddUINT4FrequencySeries (
UINT4FrequencySeries *arg1, UINT4FrequencySeries *arg1,
const UINT4FrequencySeries *arg2 const UINT4FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesMultiplyP">
\idx{XLALMultiplyUINT4FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
UINT4FrequencySeries *XLALMultiplyUINT4FrequencySeries ( UINT4FrequencySeries *XLALMultiplyUINT4FrequencySeries (
UINT4FrequencySeries *arg1, UINT4FrequencySeries *arg1,
const UINT4FrequencySeries *arg2 const UINT4FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesDestroyP"> /* UINT8 prototypes */
\idx{XLALDestroyUINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
void XLALDestroyUINT8FrequencySeries ( void XLALDestroyUINT8FrequencySeries (
UINT8FrequencySeries *series UINT8FrequencySeries *series
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCreateP">
\idx{XLALCreateUINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
UINT8FrequencySeries *XLALCreateUINT8FrequencySeries ( UINT8FrequencySeries *XLALCreateUINT8FrequencySeries (
const CHAR *name, const CHAR *name,
const LIGOTimeGPS *epoch, const LIGOTimeGPS *epoch,
REAL8 f0, REAL8 f0,
REAL8 deltaF, REAL8 deltaF,
const LALUnit *sampleUnits, const LALUnit *sampleUnits,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesCutP">
\idx{XLALCutUINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
UINT8FrequencySeries *XLALCutUINT8FrequencySeries ( UINT8FrequencySeries *XLALCutUINT8FrequencySeries (
const UINT8FrequencySeries *series, const UINT8FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALResizeUINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
UINT8FrequencySeries *XLALResizeUINT8FrequencySeries ( UINT8FrequencySeries *XLALResizeUINT8FrequencySeries (
UINT8FrequencySeries *series, UINT8FrequencySeries *series,
int first, int first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesShrinkP">
\idx{XLALShrinkUINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
UINT8FrequencySeries *XLALShrinkUINT8FrequencySeries ( UINT8FrequencySeries *XLALShrinkUINT8FrequencySeries (
UINT8FrequencySeries *series, UINT8FrequencySeries *series,
size_t first, size_t first,
size_t length size_t length
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesAddP">
\idx{XLALAddUINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
UINT8FrequencySeries *XLALAddUINT8FrequencySeries ( UINT8FrequencySeries *XLALAddUINT8FrequencySeries (
UINT8FrequencySeries *arg1, UINT8FrequencySeries *arg1,
const UINT8FrequencySeries *arg2 const UINT8FrequencySeries *arg2
); );
/* </lalVerbatim> */
/* <lalLaTeX file="FrequencySeriesMultiplyP">
\idx{XLALMultiplyUINT8FrequencySeries ()}
</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
UINT8FrequencySeries *XLALMultiplyUINT8FrequencySeries ( UINT8FrequencySeries *XLALMultiplyUINT8FrequencySeries (
UINT8FrequencySeries *arg1, UINT8FrequencySeries *arg1,
const UINT8FrequencySeries *arg2 const UINT8FrequencySeries *arg2
); );
/* </lalVerbatim> */
#if 0
{ /* so that editors will match succeeding brace */
#elif defined(__cplusplus)
}
#endif
#endif /* _FREQUENCYSERIES_H */ #endif /* _FREQUENCYSERIES_H */
 End of changes. 146 change blocks. 
289 lines changed or deleted 33 lines changed or added


 GSLSupport.h   GSLSupport.h 
skipping to change at line 61 skipping to change at line 61
} }
#endif #endif
#endif #endif
/** /**
* Macros * Macros
*/ */
/* Allocate, print, and free 1D things */ /* Allocate, print, and free 1D things */
#define ALLOC_GSL_1D(type, var, n, xlalerr) #define ALLOC_GSL_1D(type, var, n, errval)
\ \
if ((var = gsl_ ## type ## _alloc(n)) == NULL) if ((var = gsl_ ## type ## _alloc(n)) == NULL) {
\ \
xlalerr("Could not allocate '" #var "'", XLAL_ENOMEM); XLALPrintError("%s: Could not allocate '%s'", __func__, #var);
\
XLAL_ERROR_VAL(errval, XLAL_ENOMEM);
\
}
#define PRINT_GSL_1D(type, var, format) \ #define PRINT_GSL_1D(type, var, format) \
{ \ { \
size_t GSLSUPPORT_i; \ size_t GSLSUPPORT_i; \
printf("%s: ", #var); \ printf("%s: ", #var); \
if (var) \ if (var) \
for (GSLSUPPORT_i = 0; GSLSUPPORT_i < var->size; ++GSLSUPPORT_i) \ for (GSLSUPPORT_i = 0; GSLSUPPORT_i < var->size; ++GSLSUPPORT_i) \
printf(format, gsl_ ## type ## _get(var, GSLSUPPORT_i)); \ printf(format, gsl_ ## type ## _get(var, GSLSUPPORT_i)); \
else \ else \
printf("NULL"); \ printf("NULL"); \
printf("\n"); \ printf("\n"); \
} }
#define FREE_GSL_1D(type, var) \ #define FREE_GSL_1D(type, var) \
if (var != NULL) \ if (var != NULL) \
gsl_ ## type ## _free(var); gsl_ ## type ## _free(var);
/* Allocate, print, and free 2D things */ /* Allocate, print, and free 2D things */
#define ALLOC_GSL_2D(type, var, m, n, xlalerr) #define ALLOC_GSL_2D(type, var, m, n, errval)
\ \
if ((var = gsl_ ## type ## _alloc(m, n)) == NULL) if ((var = gsl_ ## type ## _alloc(m, n)) == NULL) {
\ \
xlalerr("Could not allocate '" #var "'", XLAL_ENOMEM); XLALPrintError("%s: Could not allocate '%s'", __func__, #var);
\
XLAL_ERROR_VAL(errval, XLAL_ENOMEM);
\
}
#define PRINT_GSL_2D(type, var, format) \ #define PRINT_GSL_2D(type, var, format) \
{ \ { \
size_t GSLSUPPORT_i, GSLSUPPORT_j; \ size_t GSLSUPPORT_i, GSLSUPPORT_j; \
printf("%s:\n", #var); \ printf("%s:\n", #var); \
if (var) \ if (var) \
for (GSLSUPPORT_i = 0; GSLSUPPORT_i < var->size1; ++GSLSUPPORT_i) { \ for (GSLSUPPORT_i = 0; GSLSUPPORT_i < var->size1; ++GSLSUPPORT_i) { \
for (GSLSUPPORT_j = 0; GSLSUPPORT_j < var->size2; ++GSLSUPPORT_j) \ for (GSLSUPPORT_j = 0; GSLSUPPORT_j < var->size2; ++GSLSUPPORT_j) \
printf(format, gsl_ ## type ## _get(var, GSLSUPPORT_i, GSLSUPPORT_j )); \ printf(format, gsl_ ## type ## _get(var, GSLSUPPORT_i, GSLSUPPORT_j )); \
printf("\n"); \ printf("\n"); \
} \ } \
else \ else \
printf("NULL\n"); \ printf("NULL\n"); \
} }
#define FREE_GSL_2D(type, var) \ #define FREE_GSL_2D(type, var) \
if (var != NULL) \ if (var != NULL) \
gsl_ ## type ## _free(var); gsl_ ## type ## _free(var);
/* Allocate, print, and free gsl_vector */ /* Allocate, print, and free gsl_vector */
#define ALLOC_GSL_VECTOR(var, n, xlalerr) ALLOC_GSL_1D(vector, var, n, xlal #define ALLOC_GSL_VECTOR(var, n, errval) ALLOC_GSL_1D(vector, var, n, errva
err) l)
#define PRINT_GSL_VECTOR(var) PRINT_GSL_1D(vector, var, "%g ") #define PRINT_GSL_VECTOR(var) PRINT_GSL_1D(vector, var, "%g ")
#define FREE_GSL_VECTOR(var) FREE_GSL_1D(vector, var) #define FREE_GSL_VECTOR(var) FREE_GSL_1D(vector, var)
/* Allocate, print, and free gsl_vector_int */ /* Allocate, print, and free gsl_vector_int */
#define ALLOC_GSL_VECTOR_INT(var, n, xlalerr) ALLOC_GSL_1D(vector_int, var, #define ALLOC_GSL_VECTOR_INT(var, n, errval) ALLOC_GSL_1D(vector_int, var,
n, xlalerr) n, errval)
#define PRINT_GSL_VECTOR_INT(var) PRINT_GSL_1D(vector_int, var, #define PRINT_GSL_VECTOR_INT(var) PRINT_GSL_1D(vector_int, var,
"%i ") "%i ")
#define FREE_GSL_VECTOR_INT(var) FREE_GSL_1D(vector_int, var) #define FREE_GSL_VECTOR_INT(var) FREE_GSL_1D(vector_int, var)
/* Allocate, print, and free gsl_matrix */ /* Allocate, print, and free gsl_matrix */
#define ALLOC_GSL_MATRIX(var, m, n, xlalerr) ALLOC_GSL_2D(matrix, var, m, n #define ALLOC_GSL_MATRIX(var, m, n, errval) ALLOC_GSL_2D(matrix, var, m, n,
, xlalerr) errval)
#define PRINT_GSL_MATRIX(var) PRINT_GSL_2D(matrix, var, "%g #define PRINT_GSL_MATRIX(var) PRINT_GSL_2D(matrix, var, "%g "
") )
#define FREE_GSL_MATRIX(var) FREE_GSL_2D(matrix, var) #define FREE_GSL_MATRIX(var) FREE_GSL_2D(matrix, var)
/* Allocate, print, and free gsl_matrix_int */ /* Allocate, print, and free gsl_matrix_int */
#define ALLOC_GSL_MATRIX_INT(var, m, n, xlalerr) ALLOC_GSL_2D(matrix_int, v #define ALLOC_GSL_MATRIX_INT(var, m, n, errval) ALLOC_GSL_2D(matrix_int, va
ar, m, n, xlalerr) r, m, n, errval)
#define PRINT_GSL_MATRIX_INT(var) PRINT_GSL_2D(matrix_int, v #define PRINT_GSL_MATRIX_INT(var) PRINT_GSL_2D(matrix_int, va
ar, "%i ") r, "%i ")
#define FREE_GSL_MATRIX_INT(var) FREE_GSL_2D(matrix_int, va #define FREE_GSL_MATRIX_INT(var) FREE_GSL_2D(matrix_int, var
r) )
/* Allocate, print, and free gsl_combination */ /* Allocate, print, and free gsl_combination */
#define ALLOC_GSL_COMBINATION(var, n, xlalerr) ALLOC_GSL_1D(combination, va #define ALLOC_GSL_COMBINATION(var, n, errval) ALLOC_GSL_1D(combination, var
r, n, xlalerr) , n, errval)
#define PRINT_GSL_COMBINATION(var) PRINT_GSL_1D(combination, va #define PRINT_GSL_COMBINATION(var) PRINT_GSL_1D(combination, var
r, "%i ") , "%i ")
#define FREE_GSL_COMBINATION(var) FREE_GSL_1D(combination, var #define FREE_GSL_COMBINATION(var) FREE_GSL_1D(combination, var)
)
/* Allocate, print, and free gsl_permutation */ /* Allocate, print, and free gsl_permutation */
#define ALLOC_GSL_PERMUTATION(var, n, xlalerr) ALLOC_GSL_1D(permutation, va #define ALLOC_GSL_PERMUTATION(var, n, errval) ALLOC_GSL_1D(permutation, var
r, n, xlalerr) , n, errval)
#define PRINT_GSL_PERMUTATION(var) PRINT_GSL_1D(permutation, va #define PRINT_GSL_PERMUTATION(var) PRINT_GSL_1D(permutation, var
r, "%i ") , "%i ")
#define FREE_GSL_PERMUTATION(var) FREE_GSL_1D(permutation, var #define FREE_GSL_PERMUTATION(var) FREE_GSL_1D(permutation, var)
)
 End of changes. 8 change blocks. 
36 lines changed or deleted 43 lines changed or added


 Grid.h   Grid.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/***************************************** <lalVerbatim file="GridHV"> /**
Author: Creighton, T. D. \author Creighton, T. D.
$Id$ \file
**************************************************** </lalVerbatim> */
/********************************************************** <lalLaTeX>
\section{Header \texttt{Grid.h}}
\label{s:Grid.h}
Provides a structured datatype for a multidimensional rectilinear \brief Provides a structured datatype for a multidimensional rectilinear gr
grid. id.
\subsection*{Synopsis} \heading{Synopsis}
\begin{verbatim} \code
#include <lal/Grid.h> #include <lal/Grid.h>
\end{verbatim} \endcode
\noindent This header provides a new structured datatype storing data This header provides a new structured datatype storing data
on a multidimensional rectilinear grid. It is in some sense a on a multidimensional rectilinear grid. It is in some sense a
generalization of the series datatypes (frequency series, time series, generalization of the series datatypes (frequency series, time series,
etc.), representing evenly-sampled data over some physical parameter etc.), representing evenly-sampled data over some physical parameter
space. space.
******************************************************* </lalLaTeX> */ */
#ifndef _GRID_H #ifndef _GRID_H
#define _GRID_H #define _GRID_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID( GRIDH, "$Id$" ); NRCSID( GRIDH, "$Id$" );
/********************************************************** <lalLaTeX> /**
\subsection*{Error conditions} \heading{Error conditions}
****************************************** </lalLaTeX><lalErrTable> */ \name Error Codes */ /*@{*/
#define GRIDH_ENUL 1 #define GRIDH_ENUL 1
#define GRIDH_EOUT 2 #define GRIDH_EOUT 2
#define GRIDH_EMEM 3 #define GRIDH_EMEM 3
#define GRIDH_MSGENUL "Unexpected null pointer in arguments" #define GRIDH_MSGENUL "Unexpected null pointer in arguments"
#define GRIDH_MSGEOUT "Output handle points to a non-null pointer" #define GRIDH_MSGEOUT "Output handle points to a non-null pointer"
#define GRIDH_MSGEMEM "Memory allocation error" #define GRIDH_MSGEMEM "Memory allocation error"
/******************************************** </lalErrTable><lalLaTeX> /*@}*//**
\subsection*{Types} \heading{Types}
\subsubsection*{Structure \texttt{<datatype>Grid}} \heading{Structure <tt>\<datatype\>Grid</tt>}
\idx[Type]{INT2Grid}
\idx[Type]{INT4Grid}
\idx[Type]{INT8Grid}
\idx[Type]{UINT2Grid}
\idx[Type]{UINT4Grid}
\idx[Type]{UINT8Grid}
\idx[Type]{REAL4Grid}
\idx[Type]{REAL8Grid}
\idx[Type]{COMPLEX8Grid}
\idx[Type]{COMPLEX16Grid}
\noindent This structure is a generalization of the LAL series types, This structure is a generalization of the LAL series types,
storing data on an $m$-dimensional rectangular grid on a physical storing data on an \f$m\f$-dimensional rectangular grid on a physical
parameter space. The values on the grid are of type \verb@<datatype>@ parameter space. The values on the grid are of type <tt>\<datatype\></tt>
which can be any LAL primitive \emph{numerical} datatype (\verb@INT2@, which can be any LAL primitive \e numerical datatype (\c INT2,
\verb@INT4@, \verb@INT8@, \verb@UINT2@, \verb@UINT4@, \verb@UINT8@, \c INT4, \c INT8, \c UINT2, \c UINT4, \c UINT8,
\verb@REAL4@, \verb@REAL8@, \verb@COMPLEX8@, \verb@COMPLEX16@). The \c REAL4, \c REAL8, \c COMPLEX8, \c COMPLEX16). The
data are stored in an array of dimension $M\geq m$: if $M=m$, then the data are stored in an array of dimension \f$M\geq m\f$: if \f$M=m\f$, then
structure stores a single value for each grid point; if $M>m$, then the
structure stores a single value for each grid point; if \f$M>m\f$, then
the structure stores a vector or array of values on the ``tangent the structure stores a vector or array of values on the ``tangent
space'' of each grid point. We refer to $m$ as the \emph{grid} space'' of each grid point. We refer to \f$m\f$ as the \e grid
dimension and $M$ as the \emph{data} dimension. The fields of the dimension and \f$M\f$ as the \e data dimension. The fields of the
structure are: structure are:
\begin{description} <dl>
\item[\texttt{CHAR name[LALNameLength]}] A name identifying the grid <dt><tt>CHAR name[LALNameLength]</tt></dt><dd> A name identifying the grid
and/or the data being sampled. and/or the data being sampled.</dd>
\item[\texttt{LALUnit sampleUnits}] The physical units of the <dt><tt>LALUnit sampleUnits</tt></dt><dd> The physical units of the
quantities on the grid. quantities on the grid.</dd>
\item[\texttt{LALUnit *dimUnits}] The physical units of the grid axes. <dt><tt>LALUnit *dimUnits</tt></dt><dd> The physical units of the grid axes
This must be allocated as an array of length $m$. .
This must be allocated as an array of length \f$m\f$.</dd>
\item[\texttt{REAL8Vector *offset}] A vector $\mathbf{p}_0$ <dt><tt>REAL8Vector *offset</tt></dt><dd> A vector \f$\mathbf{p}_0\f$
specifying the location of the grid point indexed by $(0,\ldots,0)$. specifying the location of the grid point indexed by \f$(0,\ldots,0)\f$.
Must have dimensionality $m$. Must have dimensionality \f$m\f$.</dd>
\item[\texttt{REAL8Vector *interval}] The vector $\Delta\mathbf{p}$ <dt><tt>REAL8Vector *interval</tt></dt><dd> The vector \f$\Delta\mathbf{p}\ f$
specifying the grid spacing in each dimension. Must have specifying the grid spacing in each dimension. Must have
dimensionality $m$. dimensionality \f$m\f$.</dd>
\item[\texttt{<datatype>Array *data}] Pointer to an array storing the <dt><tt>\<datatype\>Array *data</tt></dt><dd> Pointer to an array storing t he
data values at the corresponding grid points. The data dimension data values at the corresponding grid points. The data dimension
$M=$\verb@data->dimLength->length@ must be greater than or equal to \f$M=\f$<tt>data->dimLength->length</tt> must be greater than or equal to
the grid dimension $m=$\verb@offset->length@=\verb@interval->length@. the grid dimension \f$m=\f$<tt>offset->length</tt>=<tt>interval->length</tt
An index $\mathbf{i}=(i_0,\ldots,i_{M-1})$, where $i_k$ are integers >.
from 0 to \verb@data->dimLength->data@${}_k$, specifies a grid point An index \f$\mathbf{i}=(i_0,\ldots,i_{M-1})\f$, where \f$i_k\f$ are integer
located at $\mathbf{p}=\mathbf{p}_0+\sum_{k=0}^{n-1}\hat{\mathbf{e}}_k s
i_k \Delta p_k$ if $M=m$, or an array element $\mathsf{A}_{i_m\cdots from 0 to <tt>data->dimLength->data</tt>\f${}_k\f$, specifies a grid point
i_{M-1}}$ at that grid point if $M>m$. The values in located at \f$\mathbf{p}=\mathbf{p}_0+\sum_{k=0}^{n-1}\hat{\mathbf{e}}_k
\verb@data->data@ are the value stored at each grid point (or array i_k \Delta p_k\f$ if \f$M=m\f$, or an array element \f$\mathsf{A}_{i_m\cdot
s
i_{M-1}}\f$ at that grid point if \f$M>m\f$. The values in
<tt>data->data</tt> are the value stored at each grid point (or array
element at each grid point), arranged in the manner discussed in element at each grid point), arranged in the manner discussed in
\verb@LALDatatypes.h@. \ref LALDatatypes.h.</dd>
\end{description} </dl>
******************************************************* </lalLaTeX> */ */
typedef struct tagINT2Grid { typedef struct tagINT2Grid {
SWIGLAL_STRUCT(INT2Grid);
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LALUnit sampleUnits; LALUnit sampleUnits;
LALUnit *dimUnits; LALUnit *dimUnits;
REAL8Vector *offset; REAL8Vector *offset;
REAL8Vector *interval; REAL8Vector *interval;
INT2Array *data; INT2Array *data;
} INT2Grid; } INT2Grid;
typedef struct tagINT4Grid { typedef struct tagINT4Grid {
SWIGLAL_STRUCT(INT4Grid);
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LALUnit sampleUnits; LALUnit sampleUnits;
LALUnit *dimUnits; LALUnit *dimUnits;
REAL8Vector *offset; REAL8Vector *offset;
REAL8Vector *interval; REAL8Vector *interval;
INT4Array *data; INT4Array *data;
} INT4Grid; } INT4Grid;
typedef struct tagINT8Grid { typedef struct tagINT8Grid {
SWIGLAL_STRUCT(INT8Grid);
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LALUnit sampleUnits; LALUnit sampleUnits;
LALUnit *dimUnits; LALUnit *dimUnits;
REAL8Vector *offset; REAL8Vector *offset;
REAL8Vector *interval; REAL8Vector *interval;
INT8Array *data; INT8Array *data;
} INT8Grid; } INT8Grid;
typedef struct tagUINT2Grid { typedef struct tagUINT2Grid {
SWIGLAL_STRUCT(UINT2Grid);
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LALUnit sampleUnits; LALUnit sampleUnits;
LALUnit *dimUnits; LALUnit *dimUnits;
REAL8Vector *offset; REAL8Vector *offset;
REAL8Vector *interval; REAL8Vector *interval;
UINT2Array *data; UINT2Array *data;
} UINT2Grid; } UINT2Grid;
typedef struct tagUINT4Grid { typedef struct tagUINT4Grid {
SWIGLAL_STRUCT(UINT4Grid);
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LALUnit sampleUnits; LALUnit sampleUnits;
LALUnit *dimUnits; LALUnit *dimUnits;
REAL8Vector *offset; REAL8Vector *offset;
REAL8Vector *interval; REAL8Vector *interval;
UINT4Array *data; UINT4Array *data;
} UINT4Grid; } UINT4Grid;
typedef struct tagUINT8Grid { typedef struct tagUINT8Grid {
SWIGLAL_STRUCT(UINT8Grid);
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LALUnit sampleUnits; LALUnit sampleUnits;
LALUnit *dimUnits; LALUnit *dimUnits;
REAL8Vector *offset; REAL8Vector *offset;
REAL8Vector *interval; REAL8Vector *interval;
UINT8Array *data; UINT8Array *data;
} UINT8Grid; } UINT8Grid;
typedef struct tagREAL4Grid { typedef struct tagREAL4Grid {
SWIGLAL_STRUCT(REAL4Grid);
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LALUnit sampleUnits; LALUnit sampleUnits;
LALUnit *dimUnits; LALUnit *dimUnits;
REAL8Vector *offset; REAL8Vector *offset;
REAL8Vector *interval; REAL8Vector *interval;
REAL4Array *data; REAL4Array *data;
} REAL4Grid; } REAL4Grid;
typedef struct tagREAL8Grid { typedef struct tagREAL8Grid {
SWIGLAL_STRUCT(REAL8Grid);
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LALUnit sampleUnits; LALUnit sampleUnits;
LALUnit *dimUnits; LALUnit *dimUnits;
REAL8Vector *offset; REAL8Vector *offset;
REAL8Vector *interval; REAL8Vector *interval;
REAL8Array *data; REAL8Array *data;
} REAL8Grid; } REAL8Grid;
typedef struct tagCOMPLEX8Grid { typedef struct tagCOMPLEX8Grid {
SWIGLAL_STRUCT(COMPLEX8Grid);
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LALUnit sampleUnits; LALUnit sampleUnits;
LALUnit *dimUnits; LALUnit *dimUnits;
REAL8Vector *offset; REAL8Vector *offset;
REAL8Vector *interval; REAL8Vector *interval;
COMPLEX8Array *data; COMPLEX8Array *data;
} COMPLEX8Grid; } COMPLEX8Grid;
typedef struct tagCOMPLEX16Grid { typedef struct tagCOMPLEX16Grid {
SWIGLAL_STRUCT(COMPLEX16Grid);
CHAR name[LALNameLength]; CHAR name[LALNameLength];
LALUnit sampleUnits; LALUnit sampleUnits;
LALUnit *dimUnits; LALUnit *dimUnits;
REAL8Vector *offset; REAL8Vector *offset;
REAL8Vector *interval; REAL8Vector *interval;
COMPLEX16Array *data; COMPLEX16Array *data;
} COMPLEX16Grid; } COMPLEX16Grid;
/* <lalLaTeX>
\vfill{\footnotesize\input{GridHV}}
</lalLaTeX> */
/* Function prototypes. */ /* Function prototypes. */
/* <lalLaTeX>
\newpage\input{GridC}
</lalLaTeX> */
void void
LALI2CreateGrid( LALStatus *status, INT2Grid **grid, UINT4Vector *dimLength , UINT4 dimension ); LALI2CreateGrid( LALStatus *status, INT2Grid **grid, UINT4Vector *dimLength , UINT4 dimension );
void void
LALI4CreateGrid( LALStatus *status, INT4Grid **grid, UINT4Vector *dimLength , UINT4 dimension ); LALI4CreateGrid( LALStatus *status, INT4Grid **grid, UINT4Vector *dimLength , UINT4 dimension );
void void
LALI8CreateGrid( LALStatus *status, INT8Grid **grid, UINT4Vector *dimLength , UINT4 dimension ); LALI8CreateGrid( LALStatus *status, INT8Grid **grid, UINT4Vector *dimLength , UINT4 dimension );
void void
skipping to change at line 288 skipping to change at line 279
void void
LALDDestroyGrid( LALStatus *status, REAL8Grid **grid ); LALDDestroyGrid( LALStatus *status, REAL8Grid **grid );
void void
LALCDestroyGrid( LALStatus *status, COMPLEX8Grid **grid ); LALCDestroyGrid( LALStatus *status, COMPLEX8Grid **grid );
void void
LALZDestroyGrid( LALStatus *status, COMPLEX16Grid **grid ); LALZDestroyGrid( LALStatus *status, COMPLEX16Grid **grid );
/* <lalLaTeX> /**
%\newpage\input{GridTestC} %
</lalLaTeX> */ */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _GRID_H */ #endif /* _GRID_H */
 End of changes. 35 change blocks. 
76 lines changed or deleted 73 lines changed or added


 IIRFilter.h   IIRFilter.h 
skipping to change at line 109 skipping to change at line 109
I have adopted the convention of including a redundant recursive I have adopted the convention of including a redundant recursive
coefficient $d_0$, in order to make the indexing more intuitive. For coefficient $d_0$, in order to make the indexing more intuitive. For
formal correctness $d_0$ should be set to $-1$, although the filtering formal correctness $d_0$ should be set to $-1$, although the filtering
routines never actually use this coefficient. routines never actually use this coefficient.
******************************************************* </lalLaTeX> */ ******************************************************* </lalLaTeX> */
#ifndef _IIRFILTER_H #ifndef _IIRFILTER_H
#define _IIRFILTER_H #define _IIRFILTER_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/ZPGFilter.h> #include <lal/ZPGFilter.h>
#ifdef __cplusplus #if defined(__cplusplus)
extern "C" { extern "C" {
#pragma } #elif 0
} /* so that editors will match preceding brace */
#endif #endif
NRCSID(IIRFILTERH,"$Id$"); NRCSID(IIRFILTERH,"$Id$");
/********************************************************** <lalLaTeX> /********************************************************** <lalLaTeX>
\subsection*{Error conditions} \subsection*{Error conditions}
****************************************** </lalLaTeX><lalErrTable> */ ****************************************** </lalLaTeX><lalErrTable> */
#define IIRFILTERH_ENUL 1 #define IIRFILTERH_ENUL 1
#define IIRFILTERH_EOUT 2 #define IIRFILTERH_EOUT 2
#define IIRFILTERH_EMEM 3 #define IIRFILTERH_EMEM 3
skipping to change at line 162 skipping to change at line 168
coefficients. coefficients.
\item[\texttt{<datatype>Vector *recursCoef}] The recursive filter \item[\texttt{<datatype>Vector *recursCoef}] The recursive filter
coefficients. coefficients.
\item[\texttt{<datatype>Vector *history}] The previous values of $w$. \item[\texttt{<datatype>Vector *history}] The previous values of $w$.
\end{description} \end{description}
******************************************************* </lalLaTeX> */ ******************************************************* </lalLaTeX> */
#ifdef SWIG /* SWIG interface directives */
%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagREAL4IIRFilter::name;
#endif /* SWIG */
typedef struct tagREAL4IIRFilter{ typedef struct tagREAL4IIRFilter{
SWIGLAL_STRUCT(REAL4IIRFilter);
const CHAR *name; /* User assigned name. */ const CHAR *name; /* User assigned name. */
REAL8 deltaT; /* Sampling time interval. */ REAL8 deltaT; /* Sampling time interval. */
REAL4Vector *directCoef; /* The direct filter coefficients. */ REAL4Vector *directCoef; /* The direct filter coefficients. */
REAL4Vector *recursCoef; /* The recursive filter coefficients. */ REAL4Vector *recursCoef; /* The recursive filter coefficients. */
REAL4Vector *history; /* The previous values of w. */ REAL4Vector *history; /* The previous values of w. */
} REAL4IIRFilter; } REAL4IIRFilter;
#ifdef SWIG /* SWIG interface directives */
%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagREAL8IIRFilter::name;
#endif /* SWIG */
typedef struct tagREAL8IIRFilter{ typedef struct tagREAL8IIRFilter{
SWIGLAL_STRUCT(REAL8IIRFilter);
const CHAR *name; /* User assigned name. */ const CHAR *name; /* User assigned name. */
REAL8 deltaT; /* Sampling time interval. */ REAL8 deltaT; /* Sampling time interval. */
REAL8Vector *directCoef; /* The direct filter coefficients. */ REAL8Vector *directCoef; /* The direct filter coefficients. */
REAL8Vector *recursCoef; /* The recursive filter coefficients. */ REAL8Vector *recursCoef; /* The recursive filter coefficients. */
REAL8Vector *history; /* The previous values of w. */ REAL8Vector *history; /* The previous values of w. */
} REAL8IIRFilter; } REAL8IIRFilter;
/* <lalLaTeX> /* <lalLaTeX>
\vfill{\footnotesize\input{IIRFilterHV}} \vfill{\footnotesize\input{IIRFilterHV}}
</lalLaTeX> */ </lalLaTeX> */
skipping to change at line 280 skipping to change at line 294
void void
LALDIIRFilterREAL4VectorR( LALStatus *status, LALDIIRFilterREAL4VectorR( LALStatus *status,
REAL4Vector *vector, REAL4Vector *vector,
REAL8IIRFilter *filter ); REAL8IIRFilter *filter );
/* <lalLaTeX> /* <lalLaTeX>
\newpage\input{IIRFilterTestC} \newpage\input{IIRFilterTestC}
</lalLaTeX> */ </lalLaTeX> */
#ifdef __cplusplus #if 0
#pragma { { /* so that editors will match succeeding brace */
#elif defined(__cplusplus)
} }
#endif #endif
#endif /* _IIRFILTER_H */ #endif /* _IIRFILTER_H */
 End of changes. 8 change blocks. 
4 lines changed or deleted 19 lines changed or added


 Inject.h   Inject.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/*************************************** <lalVerbatim file="InjectHV"> #ifndef _INJECT_H
Author: Creighton, T. D. #define _INJECT_H
$Id$
**************************************************** </lalVerbatim> */
/********************************************************** <lalLaTeX> #include <lal/LALStdlib.h>
#include <lal/Random.h>
\section{Header \texttt{Inject.h}} #if defined(__cplusplus)
\label{s:Inject.h} extern "C" {
#elif 0
} /* so that editors will match preceding brace */
#endif
Provides routines to inject a signal into detector output. NRCSID( INJECTH, "$Id$" );
\subsection*{Synopsis} /**
\begin{verbatim} \author Creighton, T. D.
\addtogroup Inject_h
\brief Provides routines to inject a signal into detector output.
\heading{Synopsis}
\code
#include <lal/Inject.h> #include <lal/Inject.h>
\end{verbatim} \endcode
This header provides simple routines to inject a signal, stored as a This header provides simple routines to inject a signal, stored as a
floating-point time series, into an integer time series that floating-point time series, into an integer time series that
represents the ADC output of a detector channel. represents the ADC output of a detector channel.
The basic concept at work here is that of \emph{dithering}. That is, The basic concept at work here is that of \e dithering. That is,
to add a real signal $x(t_k)$ to the integer output $n(t_k)$ of an to add a real signal \f$x(t_k)\f$ to the integer output \f$n(t_k)\f$ of an
ADC, we cannot simply compute $x+n$ at each time $t_k$ and round to ADC, we cannot simply compute \f$x+n\f$ at each time \f$t_k\f$ and round to
the nearest integer. To see this, consider injecting a sinusoid with the nearest integer. To see this, consider injecting a sinusoid with
an amplitude less than half the ADC resolution, $|x|<0.5$. Then an amplitude less than half the ADC resolution, \f$|x|<0.5\f$. Then
adding $x+n$ and rounding will always give back $n$, and the signal adding \f$x+n\f$ and rounding will always give back \f$n\f$, and the signal
injection will have no effect on the output. injection will have no effect on the output.
Instead, what we would like to do is to add $x$ to the ADC Instead, what we would like to do is to add \f$x\f$ to the ADC
\emph{input} before rounding occurs, and then round to an integer. \e input before rounding occurs, and then round to an integer.
That is, the ADC input was actually $n+d$, where $d\in[-0.5,0.5)$; we That is, the ADC input was actually \f$n+d\f$, where \f$d\in[-0.5,0.5)\f$;
want to compute the rounded value of $n+d+x$, which may occasionally we
be different from $n$. In principle, a Fourier transforms can detect want to compute the rounded value of \f$n+d+x\f$, which may occasionally
be different from \f$n\f$. In principle, a Fourier transforms can detect
a sinusoidal signal with an output much smaller than the ADC a sinusoidal signal with an output much smaller than the ADC
resolution: by integrating enough data, one can eventually detect a resolution: by integrating enough data, one can eventually detect a
statistically significant phase correlation between the occasional statistically significant phase correlation between the occasional
increments and decrements in $n$. increments and decrements in \f$n\f$.
Of course given the output time series $n(t_k)$ we can only guess at Of course given the output time series \f$n(t_k)\f$ we can only guess at
the input series $n(t_k)+d(t_k)$ that produced it. The simplest guess the input series \f$n(t_k)+d(t_k)\f$ that produced it. The simplest guess
is to assume that each $d(t_k)$ is an independent random variable with is to assume that each \f$d(t_k)\f$ is an independent random variable with
a flat distribution over the range $[-0.5,0.5)$. This is a reasonable a flat distribution over the range \f$[-0.5,0.5)\f$. This is a reasonable
guess to make if the root mean square variation between succesive guess to make if the root mean square variation between succesive
output values $n$ is a few or more ADC counts; i.e. if the output values \f$n\f$ is a few or more ADC counts; i.e. if the
dimensionless power spectral density $\sqrt{fS(f)}$ has a value of a dimensionless power spectral density \f$\sqrt{fS(f)}\f$ has a value of a
few or more around the sampling freqeuncy $f$. This is almost always few or more around the sampling freqeuncy \f$f\f$. This is almost always
true of any detector designed to work at or near its noise limit: the true of any detector designed to work at or near its noise limit: the
input to the ADC will first be whitened so that $\sqrt{fS(f)}$ is input to the ADC will first be whitened so that \f$\sqrt{fS(f)}\f$ is
nearly flat, and then amplified so that $\sqrt{fS(f)}$ is on the order nearly flat, and then amplified so that \f$\sqrt{fS(f)}\f$ is on the order
of several (or more) ADC counts. of several (or more) ADC counts.
In the routines covered by this header we will take it for granted In the routines covered by this header we will take it for granted
that the above is a reasonable approximation, and will not check for that the above is a reasonable approximation, and will not check for
it. We will further assume that the signal to be injected has already it. We will further assume that the signal to be injected has already
been subjected to the same whitening and amplification, so that the been subjected to the same whitening and amplification, so that the
units of $x(t_k)$ are normalized ADC counts (although it is still a units of \f$x(t_k)\f$ are normalized ADC counts (although it is still a
real number, not an integer). real number, not an integer).
The dithering routines should be used whenever one is injecting a The dithering routines should be used whenever one is injecting a
signal into a time series representing raw digitized data. In some signal into a time series representing raw digitized data. In some
data storage specifications, ADC output is not stored as an integer, data storage specifications, ADC output is not stored as an integer,
but as a floating-point number representing an integer value. Such but as a floating-point number representing an integer value. Such
data must be cast to integers before being passed to the digitizing data must be cast to integers before being passed to the digitizing
routines. routines.
This header also provides even simpler routines for injecting a signal This header also provides even simpler routines for injecting a signal
into floating-point data, without dithering. These should only be into floating-point data, without dithering. These should only be
used when the data is genuinely continuous in character. This can used when the data is genuinely continuous in character. This can
include data derived by applying floating-point operations on ADC include data derived by applying floating-point operations on ADC
channels (e.g.\ digital filters, linear combinations of channels, channels (e.g.\ digital filters, linear combinations of channels,
etc.), but not data that simply represents ADC output in etc.), but not data that simply represents ADC output in
floating-point format. The assumption here is that the numerical floating-point format. The assumption here is that the numerical
post-processing of the ADC data completely masks any statistical post-processing of the ADC data completely masks any statistical
signiatures of the digitization. signiatures of the digitization.
******************************************************* </lalLaTeX> */ @{
\defgroup InjectVector_c Module InjectVector.c
#ifndef _INJECT_H \defgroup InjectTimeSeries_c Module InjectTimeSeries.c
#define _INJECT_H */
/** \name Error Codes */ /**@{*/
#include <lal/LALStdlib.h> #define INJECTH_ENUL 1 /**< Unexpected null pointer in arguments. *
#include <lal/Random.h> /
#define INJECTH_EBAD 2 /**< A sampling interval is (effectively) zero */
#ifdef __cplusplus #define INJECTH_EUNIT 3 /**< Input or output is not in units of ADC
extern "C" { counts */
#pragma } /** @}*/
#endif /** @}*/
NRCSID( INJECTH, "$Id$" );
/********************************************************** <lalLaTeX>
\subsection*{Error conditions}
****************************************** </lalLaTeX><lalErrTable> */
#define INJECTH_ENUL 1
#define INJECTH_EBAD 2
#define INJECTH_EUNIT 3
#define INJECTH_MSGENUL "Unexpected null pointer in arguments" #define INJECTH_MSGENUL "Unexpected null pointer in arguments"
#define INJECTH_MSGEBAD "A sampling interval is (effectively) zero" #define INJECTH_MSGEBAD "A sampling interval is (effectively) zero"
#define INJECTH_MSGEUNIT "Input or output is not in units of ADC counts" #define INJECTH_MSGEUNIT "Input or output is not in units of ADC counts"
/******************************************** </lalErrTable><lalLaTeX>
\subsection*{Types}
******************************************************* </lalLaTeX> */
/* <lalLaTeX>
\vfill{\footnotesize\input{InjectHV}}
</lalLaTeX> */
/* Function prototypes. */ /* Function prototypes. */
/* <lalLaTeX>
\newpage\input{InjectVectorC}
</lalLaTeX> */
void void
LALSI2InjectVector( LALStatus *, LALSI2InjectVector( LALStatus *,
INT2Vector *output, INT2Vector *output,
REAL4Vector *signalvec, REAL4Vector *signalvec,
RandomParams *params ); RandomParams *params );
void void
LALSSInjectVector( LALStatus *, LALSSInjectVector( LALStatus *,
REAL4Vector *output, REAL4Vector *output,
REAL4Vector *signalvec ); REAL4Vector *signalvec );
/* <lalLaTeX>
\newpage\input{InjectTimeSeriesC}
</lalLaTeX> */
void void
LALSI2InjectTimeSeries( LALStatus *, LALSI2InjectTimeSeries( LALStatus *,
INT2TimeSeries *output, INT2TimeSeries *output,
REAL4TimeSeries *signalvec, REAL4TimeSeries *signalvec,
RandomParams *params ); RandomParams *params );
void void
LALSSInjectTimeSeries( LALStatus *, LALSSInjectTimeSeries( LALStatus *,
REAL4TimeSeries *output, REAL4TimeSeries *output,
REAL4TimeSeries *signalvec ); REAL4TimeSeries *signalvec );
#ifdef __cplusplus #if 0
#pragma { { /* so that editors will match succeeding brace */
#elif defined(__cplusplus)
} }
#endif #endif
#endif /* _INJECT_H */ #endif /* _INJECT_H */
 End of changes. 19 change blocks. 
69 lines changed or deleted 56 lines changed or added


 Integrate.h   Integrate.h 
/* /*
* Copyright (C) 2007 Jolien Creighton * Copyright (C) 2007 Jolien Creighton, Drew Keppel
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
skipping to change at line 47 skipping to change at line 47
\noindent This header covers the routines for integrating a function. \noindent This header covers the routines for integrating a function.
</lalLaTeX> </lalLaTeX>
#endif /* autodoc block */ #endif /* autodoc block */
#ifndef _INTEGRATE_H #ifndef _INTEGRATE_H
#define _INTEGRATE_H #define _INTEGRATE_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (INTEGRATEH, "$Id$"); NRCSID (INTEGRATEH, "$Id$");
#if 0 /* autodoc block */ #if 0 /* autodoc block */
skipping to change at line 175 skipping to change at line 180
SingularLowerLimit, /* integrate an inv sqrt singularity at lower limit */ SingularLowerLimit, /* integrate an inv sqrt singularity at lower limit */
SingularUpperLimit, /* integrate an inv sqrt singularity at upper limit */ SingularUpperLimit, /* integrate an inv sqrt singularity at upper limit */
InfiniteDomainPow, /* integrate infinite domain with power-law falloff */ InfiniteDomainPow, /* integrate infinite domain with power-law falloff */
InfiniteDomainExp /* integrate infinite domain with exponential falloff */ InfiniteDomainExp /* integrate infinite domain with exponential falloff */
} }
IntegralType; IntegralType;
typedef struct typedef struct
tagSIntegrateIn tagSIntegrateIn
{ {
SWIGLAL_STRUCT(SIntegrateIn);
void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p); void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p);
REAL4 xmax; REAL4 xmax;
REAL4 xmin; REAL4 xmin;
IntegralType type; IntegralType type;
} }
SIntegrateIn; SIntegrateIn;
typedef struct typedef struct
tagDIntegrateIn tagDIntegrateIn
{ {
SWIGLAL_STRUCT(DIntegrateIn);
void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p); void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p);
REAL8 xmax; REAL8 xmax;
REAL8 xmin; REAL8 xmin;
IntegralType type; IntegralType type;
} }
DIntegrateIn; DIntegrateIn;
#if 0 /* autodoc block */ #if 0 /* autodoc block */
<lalLaTeX> <lalLaTeX>
skipping to change at line 216 skipping to change at line 223
); );
void void
LALDRombergIntegrate ( LALDRombergIntegrate (
LALStatus *status, LALStatus *status,
REAL8 *result, REAL8 *result,
DIntegrateIn *input, DIntegrateIn *input,
void *params void *params
); );
REAL8
XLALREAL8RombergIntegrate (
REAL8 (*f)(REAL8 x, void *params),
void *params,
REAL8 xmin,
REAL8 xmax,
IntegralType type
);
#if 0 /* autodoc block */ #if 0 /* autodoc block */
<lalLaTeX> <lalLaTeX>
\newpage\input{IntegrateTestC} \newpage\input{IntegrateTestC}
</lalLaTeX> </lalLaTeX>
#endif /* autodoc block */ #endif /* autodoc block */
#ifdef __cplusplus #ifdef __cplusplus
} }
 End of changes. 5 change blocks. 
1 lines changed or deleted 17 lines changed or added


 Interpolate.h   Interpolate.h 
/* /*
* Copyright (C) 2007 Jolien Creighton * Copyright (C) 2007 Jolien Creighton, Drew Keppel
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
skipping to change at line 47 skipping to change at line 47
\noindent This header covers the routines for interpolation. \noindent This header covers the routines for interpolation.
</lalLaTeX> </lalLaTeX>
#endif /* autodoc block */ #endif /* autodoc block */
#ifndef _INTERPOLATE_H #ifndef _INTERPOLATE_H
#define _INTERPOLATE_H #define _INTERPOLATE_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (INTERPOLATEH, "$Id: Interpolate.h"); NRCSID (INTERPOLATEH, "$Id: Interpolate.h");
#if 0 /* autodoc block */ #if 0 /* autodoc block */
skipping to change at line 143 skipping to change at line 148
\item[\texttt{y}] The array of values to interpolate. \item[\texttt{y}] The array of values to interpolate.
\end{description} \end{description}
</lalLaTeX> </lalLaTeX>
#endif /* autodoc block */ #endif /* autodoc block */
typedef struct typedef struct
tagSInterpolateOut tagSInterpolateOut
{ {
SWIGLAL_STRUCT(SInterpolateOut);
REAL4 y; REAL4 y;
REAL4 dy; REAL4 dy;
} }
SInterpolateOut; SInterpolateOut;
typedef struct typedef struct
tagDInterpolateOut tagDInterpolateOut
{ {
SWIGLAL_STRUCT(DInterpolateOut);
REAL8 y; REAL8 y;
REAL8 dy; REAL8 dy;
} }
DInterpolateOut; DInterpolateOut;
typedef struct typedef struct
tagSInterpolatePar tagSInterpolatePar
{ {
SWIGLAL_STRUCT(SInterpolatePar);
UINT4 n; UINT4 n;
REAL4 *x; REAL4 *x;
REAL4 *y; REAL4 *y;
} }
SInterpolatePar; SInterpolatePar;
typedef struct typedef struct
tagDInterpolatePar tagDInterpolatePar
{ {
SWIGLAL_STRUCT(DInterpolatePar);
UINT4 n; UINT4 n;
REAL8 *x; REAL8 *x;
REAL8 *y; REAL8 *y;
} }
DInterpolatePar; DInterpolatePar;
#if 0 /* autodoc block */ #if 0 /* autodoc block */
<lalLaTeX> <lalLaTeX>
\newpage\input{InterpolateC} \newpage\input{InterpolateC}
skipping to change at line 198 skipping to change at line 207
); );
void void
LALDPolynomialInterpolation ( LALDPolynomialInterpolation (
LALStatus *status, LALStatus *status,
DInterpolateOut *output, DInterpolateOut *output,
REAL8 target, REAL8 target,
DInterpolatePar *params DInterpolatePar *params
); );
REAL8
XLALREAL8PolynomialInterpolation (
REAL8 *yout,
REAL8 xtarget,
REAL8 *y,
REAL8 *x,
UINT4 n
);
#if 0 /* autodoc block */ #if 0 /* autodoc block */
<lalLaTeX> <lalLaTeX>
\newpage\input{InterpolateTestC} \newpage\input{InterpolateTestC}
</lalLaTeX> </lalLaTeX>
#endif /* autodoc block */ #endif /* autodoc block */
#ifdef __cplusplus #ifdef __cplusplus
} }
 End of changes. 7 change blocks. 
1 lines changed or deleted 19 lines changed or added


 LALAtomicDatatypes.h   LALAtomicDatatypes.h 
skipping to change at line 284 skipping to change at line 284
This structure stores a double-precision complex number in 16~bytes of This structure stores a double-precision complex number in 16~bytes of
memory. The fields are: memory. The fields are:
\begin{description} \begin{description}
\item[\texttt{REAL8 re}] The real part. \item[\texttt{REAL8 re}] The real part.
\item[\texttt{REAL8 im}] The imaginary part. \item[\texttt{REAL8 im}] The imaginary part.
\end{description} \end{description}
</lalLaTeX> */ </lalLaTeX> */
/** Single-precision floating-point complex number (8 bytes total) */ /** Single-precision floating-point complex number (8 bytes total) */
#ifndef SWIG /* exclude from SWIG interface */
typedef struct typedef struct
tagCOMPLEX8 tagCOMPLEX8
{ {
REAL4 re; /**< The real part. */ REAL4 re; /**< The real part. */
REAL4 im; /**< The imaginary part. */ REAL4 im; /**< The imaginary part. */
} }
COMPLEX8; COMPLEX8;
#endif /* SWIG */
/** Double-precision floating-point complex number (16 bytes total) */ /** Double-precision floating-point complex number (16 bytes total) */
#ifndef SWIG /* exclude from SWIG interface */
typedef struct typedef struct
tagCOMPLEX16 tagCOMPLEX16
{ {
REAL8 re; /**< The real part. */ REAL8 re; /**< The real part. */
REAL8 im; /**< The imaginary part. */ REAL8 im; /**< The imaginary part. */
} }
COMPLEX16; COMPLEX16;
#endif /* SWIG */
/* <lalLaTeX> /* <lalLaTeX>
\vfill{\footnotesize\input{LALAtomicDatatypesHV}} \vfill{\footnotesize\input{LALAtomicDatatypesHV}}
</lalLaTeX> */ </lalLaTeX> */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _LALATOMICDATATYPES_H */ #endif /* _LALATOMICDATATYPES_H */
 End of changes. 4 change blocks. 
0 lines changed or deleted 4 lines changed or added


 LALBarycenter.h   LALBarycenter.h 
skipping to change at line 23 skipping to change at line 23
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
#ifndef _LALBARYCENTER_H /* Protect against double-inclusion */ #ifndef _LALBARYCENTER_H /* Protect against double-inclusion */
#define _LALBARYCENTER_H #define _LALBARYCENTER_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <stdio.h> #include <stdio.h>
#include <math.h> #include <math.h>
#include <lal/LALStdio.h> #include <lal/LALStdio.h>
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/LALConstants.h> #include <lal/LALConstants.h>
#include <lal/DetectorSite.h> #include <lal/DetectorSite.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
skipping to change at line 44 skipping to change at line 49
/** \cond DONT_DOXYGEN */ /** \cond DONT_DOXYGEN */
NRCSID (LALBARYCENTERH,"$Id$"); NRCSID (LALBARYCENTERH,"$Id$");
/** \endcond */ /** \endcond */
/** \name Error codes */ /** \name Error codes */
/*@{*/ /** \ingroup Barycenter_h */ /*@{*/ /** \ingroup Barycenter_h */
#define LALBARYCENTERH_ENULL 2 #define LALBARYCENTERH_ENULL 2
#define LALBARYCENTERH_EOUTOFRANGEE 4 #define LALBARYCENTERH_EOUTOFRANGEE 4
#define LALBARYCENTERH_EOUTOFRANGES 8 #define LALBARYCENTERH_EOUTOFRANGES 8
#define LALBARYCENTERH_EBADSOURCEPOS 16 #define LALBARYCENTERH_EBADSOURCEPOS 16
#define LALBARYCENTERH_EXLAL 32
#define LALBARYCENTERH_MSGENULL "Null input to Barycenter routine." #define LALBARYCENTERH_MSGENULL "Null input to Barycenter routine."
#define LALBARYCENTERH_MSGEOUTOFRANGEE "tgps not in range of earth.dat fil e" #define LALBARYCENTERH_MSGEOUTOFRANGEE "tgps not in range of earth.dat fil e"
#define LALBARYCENTERH_MSGEOUTOFRANGES "tgps not in range of sun.dat file" #define LALBARYCENTERH_MSGEOUTOFRANGES "tgps not in range of sun.dat file"
#define LALBARYCENTERH_MSGEBADSOURCEPOS "source position not in standard ra nge" #define LALBARYCENTERH_MSGEBADSOURCEPOS "source position not in standard ra nge"
#define LALBARYCENTERH_MSGEXLAL "XLAL function failed."
/*@}*/ /*@}*/
/** /**
* \defgroup LALBarycenter_h Barycentering * \defgroup LALBarycenter_h Barycentering
* \author Curt Cutler * \author Curt Cutler
* \date 2001 * \date 2001
* \ingroup pulsarCommon * \ingroup pulsarCommon
* \brief Provides routines for transforming from arrival time at detector (GPS) to pulse emission time (TDB); ie * \brief Provides routines for transforming from arrival time at detector (GPS) to pulse emission time (TDB); ie
* for ``barycentering'' the measured astronomical time series. * for ``barycentering'' the measured astronomical time series.
* *
skipping to change at line 85 skipping to change at line 92
* (actually, a little more than one year, to deal * (actually, a little more than one year, to deal
* with overlaps). The first line of each table summarizes * with overlaps). The first line of each table summarizes
* what is in it. Subsequent lines give the time (GPS) and the * what is in it. Subsequent lines give the time (GPS) and the
* Earth's position \f$(x,y,z)\f$, * Earth's position \f$(x,y,z)\f$,
* velocity \f$(v_x, v_y, v_z)\f$, and acceleration \f$(a_x, a_y, a_z)\f$ * velocity \f$(v_x, v_y, v_z)\f$, and acceleration \f$(a_x, a_y, a_z)\f$
* at that instant. All in units of seconds; e.g. positions have * at that instant. All in units of seconds; e.g. positions have
* units of seconds, and accelerations have units 1/sec. * units of seconds, and accelerations have units 1/sec.
* *
* \deprecated Use XLALInitBarycenter() instead. * \deprecated Use XLALInitBarycenter() instead.
*/ */
typedef struct typedef struct tagEphemerisFilenames
{ {
SWIGLAL_STRUCT(EphemerisFilenames);
CHAR *earthEphemeris; /**< File containing Earth's position. */ CHAR *earthEphemeris; /**< File containing Earth's position. */
CHAR *sunEphemeris; /**< File containing Sun's position. */ CHAR *sunEphemeris; /**< File containing Sun's position. */
} }
EphemerisFilenames; EphemerisFilenames;
/** Structure holding a REAL8 time, and a position, velocity and /** Structure holding a REAL8 time, and a position, velocity and
* acceleration vector. */ * acceleration vector. */
typedef struct typedef struct tagPosVelAcc
{ {
SWIGLAL_STRUCT(PosVelAcc);
REAL8 gps; /**< REAL8 timestamp */ REAL8 gps; /**< REAL8 timestamp */
REAL8 pos[3]; /**< position-vector */ REAL8 pos[3]; /**< position-vector */
REAL8 vel[3]; /**< velocity-vector */ REAL8 vel[3]; /**< velocity-vector */
REAL8 acc[3]; /**< acceleration-vector */ REAL8 acc[3]; /**< acceleration-vector */
} }
PosVelAcc; PosVelAcc;
/** This structure contains all information about the /** This structure contains all information about the
* center-of-mass positions of the Earth and Sun, listed at regular * center-of-mass positions of the Earth and Sun, listed at regular
* time intervals. * time intervals.
*/ */
typedef struct typedef struct tagEphemerisData
{ {
SWIGLAL_STRUCT(EphemerisData);
EphemerisFilenames ephiles; /**< Names of the two files containing positi ons of EphemerisFilenames ephiles; /**< Names of the two files containing positi ons of
* Earth and Sun, respectively at evenly spac ed times. */ * Earth and Sun, respectively at evenly spac ed times. */
INT4 nentriesE; /**< The number of entries in Earth ephemeris table . */ INT4 nentriesE; /**< The number of entries in Earth ephemeris table . */
INT4 nentriesS; /**< The number of entries in Sun ephemeris table. */ INT4 nentriesS; /**< The number of entries in Sun ephemeris table. */
REAL8 dtEtable; /**< The spacing in sec between consecutive intants in Earth ephemeris table.*/ REAL8 dtEtable; /**< The spacing in sec between consecutive intants in Earth ephemeris table.*/
REAL8 dtStable; /**< The spacing in sec between consecutive intants in Sun ephemeris table.*/ REAL8 dtStable; /**< The spacing in sec between consecutive intants in Sun ephemeris table.*/
PosVelAcc *ephemE; /**< Array containing pos,vel,acc of earth, as extr acted from earth PosVelAcc *ephemE; /**< Array containing pos,vel,acc of earth, as extr acted from earth
* ephem file. Units are sec, 1, 1/sec respectively */ * ephem file. Units are sec, 1, 1/sec respectively */
PosVelAcc *ephemS; /**< Array with pos, vel and acc for the sun (see e phemE) */ PosVelAcc *ephemS; /**< Array with pos, vel and acc for the sun (see e phemE) */
} }
EphemerisData; EphemerisData;
/** Basic output structure of LALBarycenterEarth.c. /** Basic output structure of LALBarycenterEarth.c.
*/ */
typedef struct typedef struct tagEarthState
{ {
SWIGLAL_STRUCT(EarthState);
REAL8 einstein; /**< the einstein delay equiv TDB - TDT */ REAL8 einstein; /**< the einstein delay equiv TDB - TDT */
REAL8 deinstein; /**< d(einstein)/d(tgps) */ REAL8 deinstein; /**< d(einstein)/d(tgps) */
REAL8 posNow[3]; /**< Cartesian coords of Earth's center at tgps, REAL8 posNow[3]; /**< Cartesian coords of Earth's center at tgps,
* extrapolated from JPL DE405 ephemeris; units= se c */ * extrapolated from JPL DE405 ephemeris; units= se c */
REAL8 velNow[3]; /**< dimensionless velocity of Earth's center at tg ps, REAL8 velNow[3]; /**< dimensionless velocity of Earth's center at tg ps,
* extrapolated from JPL DE405 ephemeris */ * extrapolated from JPL DE405 ephemeris */
REAL8 gmstRad; /**< Greenwich Mean Sidereal Time (GMST) in radians , at tgps */ REAL8 gmstRad; /**< Greenwich Mean Sidereal Time (GMST) in radians , at tgps */
REAL8 gastRad; /**< Greenwich Apparent Sidereal Time, in radians, at tgps; REAL8 gastRad; /**< Greenwich Apparent Sidereal Time, in radians, at tgps;
skipping to change at line 155 skipping to change at line 166
REAL8 se[3]; /**< vector that points from Sun to Earth at instan t tgps, REAL8 se[3]; /**< vector that points from Sun to Earth at instan t tgps,
* in DE405 coords; units = sec */ * in DE405 coords; units = sec */
REAL8 dse[3]; /**< d(se[3])/d(tgps); Dimensionless */ REAL8 dse[3]; /**< d(se[3])/d(tgps); Dimensionless */
REAL8 rse; /**< length of vector se[3]; units = sec */ REAL8 rse; /**< length of vector se[3]; units = sec */
REAL8 drse; /**< d(rse)/d(tgps); dimensionless */ REAL8 drse; /**< d(rse)/d(tgps); dimensionless */
} }
EarthState; EarthState;
/** Basic input structure to LALBarycenter.c. /** Basic input structure to LALBarycenter.c.
*/ */
typedef struct typedef struct tagBarycenterInput
{ {
SWIGLAL_STRUCT(BarycenterInput);
LIGOTimeGPS tgps; /**< input GPS arrival time. I use tgps (lower case ) LIGOTimeGPS tgps; /**< input GPS arrival time. I use tgps (lower case )
* to remind that here the LAL structure is a * to remind that here the LAL structure is a
* field in the larger structure BarycenterInput. * field in the larger structure BarycenterInput.
* I use tGPS as an input structure (by itself) to * I use tGPS as an input structure (by itself) to
* LALBarycenterEarth */ * LALBarycenterEarth */
LALDetector site; /**< detector site info. <b>NOTE:</b> LALDetector site; /**< detector site info. <b>NOTE:</b>
* the <tt>site.location</tt> field must be modifie d * the <tt>site.location</tt> field must be modifie d
* to give the detector location in units of * to give the detector location in units of
* <em>seconds</em> (i.e. divide the values normall y * <em>seconds</em> (i.e. divide the values normall y
skipping to change at line 180 skipping to change at line 192
REAL8 delta; /**< Source declination in ICRS J2000 coords (radia ns) */ REAL8 delta; /**< Source declination in ICRS J2000 coords (radia ns) */
REAL8 dInv; /**< 1/(distance to source), in 1/sec. REAL8 dInv; /**< 1/(distance to source), in 1/sec.
* This is needed to correct Roemer delay for very * This is needed to correct Roemer delay for very
* nearby sources; correction is about 10 microsec for * nearby sources; correction is about 10 microsec for
* source at 100 pc */ * source at 100 pc */
} }
BarycenterInput; BarycenterInput;
/** Basic output structure produced by LALBarycenter.c. /** Basic output structure produced by LALBarycenter.c.
*/ */
typedef struct typedef struct tagEmissionTime
{ {
SWIGLAL_STRUCT(EmissionTime);
REAL8 deltaT; /**< \f$t_e\f$(TDB) - \f$t_a\f$(GPS) REAL8 deltaT; /**< \f$t_e\f$(TDB) - \f$t_a\f$(GPS)
* + (light-travel-time from source to SSB) */ * + (light-travel-time from source to SSB) */
LIGOTimeGPS te; /**< pulse emission time (TDB); also sometimes call ed LIGOTimeGPS te; /**< pulse emission time (TDB); also sometimes call ed
* ``arrival time (TDB) of same wavefront at SSB'' */ * ``arrival time (TDB) of same wavefront at SSB'' */
REAL8 tDot; /**< d(emission time in TDB)/d(arrival time in GPS) */ REAL8 tDot; /**< d(emission time in TDB)/d(arrival time in GPS) */
REAL8 rDetector[3]; /**< Cartesian coords (0=x,1=y,2=z) of detector pos ition REAL8 rDetector[3]; /**< Cartesian coords (0=x,1=y,2=z) of detector pos ition
* at $t_a$ (GPS), in ICRS J2000 coords. Units = se c. */ * at $t_a$ (GPS), in ICRS J2000 coords. Units = se c. */
skipping to change at line 209 skipping to change at line 222
/*Curt: probably best to take 1.0 OUT of tDot--ie., output tDot-1. /*Curt: probably best to take 1.0 OUT of tDot--ie., output tDot-1.
But most users would immediately add back the one anyway. But most users would immediately add back the one anyway.
*/ */
/*Curt: rem te is ``time pulse would arrive at a GPS clock /*Curt: rem te is ``time pulse would arrive at a GPS clock
way out in empty space, if you renormalized and zero-ed the latter way out in empty space, if you renormalized and zero-ed the latter
to give, on average, the same arrival time as the GPS clock on Earth'' */ to give, on average, the same arrival time as the GPS clock on Earth'' */
/* Function prototypes. */ /* Function prototypes. */
void LALBarycenterEarth(LALStatus *, EarthState *, const LIGOTimeGPS *, con int XLALBarycenterEarth ( EarthState *earth, const LIGOTimeGPS *tGPS, const
st EphemerisData *); EphemerisData *edat);
int XLALBarycenter ( EmissionTime *emit, const BarycenterInput *baryinput,
const EarthState *earth);
void LALBarycenter(LALStatus *, EmissionTime *, const BarycenterInput *, co void LALBarycenterEarth ( LALStatus *status, EarthState *earth, const LIGOT
nst EarthState *); imeGPS *tGPS, const EphemerisData *edat);
void LALBarycenter ( LALStatus *status, EmissionTime *emit, const Barycente
rInput *baryinput, const EarthState *earth);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* Close C++ protection */ #endif /* Close C++ protection */
#endif /* Close double-include protection */ #endif /* Close double-include protection */
 End of changes. 17 change blocks. 
10 lines changed or deleted 27 lines changed or added


 LALCache.h   LALCache.h 
skipping to change at line 31 skipping to change at line 31
* \ingroup support * \ingroup support
* \author Creighton, J. D. E. * \author Creighton, J. D. E.
* \date 2007 * \date 2007
* \brief This header covers routines to create and manipulate LALCache * \brief This header covers routines to create and manipulate LALCache
* structures and to read LAL cache files. * structures and to read LAL cache files.
* *
*/ */
#ifndef _LALCACHE_H_ #ifndef _LALCACHE_H_
#define _LALCACHE_H_ #define _LALCACHE_H_
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include <stdio.h> #include <stdio.h>
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/FileIO.h> #include <lal/FileIO.h>
NRCSID( LALCACHEH, "$Id$" ); NRCSID( LALCACHEH, "$Id$" );
/** An entry in a LAL cache */ /** An entry in a LAL cache */
typedef struct tagLALCacheEntry { typedef struct tagLALCacheEntry {
CHAR *src; /**< File source field */ SWIGLAL_STRUCT(LALCacheEntry);
CHAR *dsc; /**< File description field */ CHAR *src; /**< File source field */
INT4 t0; /**< GPS time (seconds) of beginning of data in f CHAR *dsc; /**< File description field */
ile */ INT4 t0; /**< GPS time (seconds) of beginning of data in file */
INT4 dt; /**< Duration (seconds) of data in file */ INT4 dt; /**< Duration (seconds) of data in file */
CHAR *url; /**< URL of file */ CHAR *url; /**< URL of file */
} LALCacheEntry; } LALCacheEntry;
/** The LALCache structure is an array of entries */ /** The LALCache structure is an array of entries */
typedef struct tagLALCache { UINT4 length; LALCacheEntry *list; } LALCache; typedef struct tagLALCache {
SWIGLAL_STRUCT(LALCache);
UINT4 length;
LALCacheEntry *list;
} LALCache;
/** Creates a LALCache structure */ /** Creates a LALCache structure */
LALCache * XLALCreateCache( UINT4 length ); LALCache * XLALCreateCache( UINT4 length );
/** Destroys a LALCache structure */ /** Destroys a LALCache structure */
void XLALDestroyCache( LALCache *cache ); void XLALDestroyCache( LALCache *cache );
/** Duplicates a LALCache structure */ /** Duplicates a LALCache structure */