lal » packages » std » src

Grid.c

Go to the documentation of this file.
00001 /***************************************** <lalVerbatim file="GridCV">
00002 Author: Creighton, T. D.
00003 $Id: Grid.m4,v 1.1 2004/05/27 02:25:47 jolien Exp $
00004 **************************************************** </lalVerbatim> */
00005 
00006 /********************************************************** <lalLaTeX>
00007 
00008 \subsection{Module \texttt{Grid.c}}
00009 \label{ss:Grid.c}
00010 
00011 Creates or destroys a LAL grid structure.
00012 
00013 \subsubsection*{Prototypes}
00014 \vspace{0.1in}
00015 \begin{verbatim}
00016 void
00017 LAL<typecode>CreateGrid( LALStatus      *stat,
00018                          <datatype>Grid **grid,
00019                          UINT4Vector    *dimLength,
00020                          UINT4          dimension )
00021 
00022 void
00023 LAL<typecode>DestroyGrid( LALStatus      *stat,
00024                           <datatype>Grid **grid )
00025 \end{verbatim}
00026 
00027 \idx{LALI2CreateGrid()}
00028 \idx{LALI4CreateGrid()}
00029 \idx{LALI8CreateGrid()}
00030 \idx{LALU2CreateGrid()}
00031 \idx{LALU4CreateGrid()}
00032 \idx{LALU8CreateGrid()}
00033 \idx{LALSCreateGrid()}
00034 \idx{LALDCreateGrid()}
00035 \idx{LALCCreateGrid()}
00036 \idx{LALZCreateGrid()}
00037 \idx{LALI2DestroyGrid()}
00038 \idx{LALI4DestroyGrid()}
00039 \idx{LALI8DestroyGrid()}
00040 \idx{LALU2DestroyGrid()}
00041 \idx{LALU4DestroyGrid()}
00042 \idx{LALU8DestroyGrid()}
00043 \idx{LALSDestroyGrid()}
00044 \idx{LALDDestroyGrid()}
00045 \idx{LALCDestroyGrid()}
00046 \idx{LALZDestroyGrid()}
00047 
00048 \subsubsection*{Description}
00049 
00050 These routines create or destroy a \verb@<datatype>Grid@ structure.
00051 The input vector \verb@dimLength@ stores the lengths of each dimension
00052 of the grid \emph{and} of the array at each grid point: in the
00053 notation defined in \verb@Grid.h@, \verb@dimLength->length@$=M$.  The
00054 parameter \verb@dimension@ gives the dimension $m$ of the physical
00055 grid space; if $M>m$, then the remaining dimensions refer to a tangent
00056 space at each grid point.  When creating a grid, the routines allocate
00057 space for all the internal vectors and arrays, but no data are filled
00058 in, with the exception of the \verb@(*grid)->data->dimLength@ vector
00059 (which will contain exactly the same data as the \verb@dimLength@
00060 input parameter).  When calling the \verb@LAL<typecode>CreateGrid()@
00061 routines, or on returning from the \verb@LAL<typecode>DestroyGrid()@
00062 routines, \verb@grid@ should be a non-\verb@NULL@ handle to a
00063 \verb@NULL@-valued pointer.
00064 
00065 For each of these prototype templates there are in fact 10 separate
00066 routines corresponding to all the numerical atomic datatypes
00067 \verb@<datatype>@ referred to by \verb@<typecode>@:
00068 \begin{center}
00069 \begin{tabular}{|c@{\qquad}c|c@{\qquad}c|}
00070 \hline
00071 \tt <typecode> & \tt <datatype> & \tt <typecode> & \tt <datatype> \\
00072 \hline
00073 \tt I2 & \tt  INT2 & \tt U2 & \tt    UINT2  \\
00074 \tt I4 & \tt  INT4 & \tt U4 & \tt    UINT4  \\
00075 \tt I8 & \tt  INT8 & \tt U8 & \tt    UINT8  \\
00076 \tt  S & \tt REAL4 & \tt  C & \tt COMPLEX8  \\
00077 \tt  D & \tt REAL8 & \tt  Z & \tt COMPLEX16 \\
00078 \hline
00079 \end{tabular}
00080 \end{center}
00081 
00082 \subsubsection*{Algorithm}
00083 
00084 \subsubsection*{Uses}
00085 \begin{verbatim}
00086 lalDebugLevel
00087 LALMalloc()                     LALFree()
00088 LALDCreateVector()              LALDDestroyVector()
00089 LAL<typecode>CreateArray()      LAL<typecode>DestroyArray()
00090 \end{verbatim}
00091 
00092 \subsubsection*{Notes}
00093 
00094 \vfill{\footnotesize\input{GridCV}}
00095 
00096 ******************************************************* </lalLaTeX> */
00097 
00098 #include <lal/LALStdlib.h>
00099 #include <lal/AVFactories.h>
00100 #include <lal/Grid.h>
00101 
00102 NRCSID( GRIDC, "$Id: Grid.m4,v 1.1 2004/05/27 02:25:47 jolien Exp $" );
00103 
00104 
00105 void
00106 LALI2CreateGrid ( LALStatus *stat, INT2Grid **grid, UINT4Vector *dimLength, UINT4 dimension )
00107 {
00108   INITSTATUS( stat, "LALI2CreateGrid", GRIDC );
00109   ATTATCHSTATUSPTR( stat );
00110 
00111   /* Check for valid input arguments. */
00112   ASSERT( dimLength, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00113   ASSERT( dimLength->data, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00114   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00115   ASSERT( !*grid, stat, GRIDH_EOUT, GRIDH_MSGEOUT );
00116   ASSERT( dimension <= dimLength->length, stat, GRIDH_ENUL,
00117           GRIDH_MSGENUL );
00118 
00119   /* Allocate the grid. */
00120   if ( !( *grid = ( INT2Grid *)LALMalloc( sizeof( INT2Grid ) ) ) ) {
00121     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00122   }
00123   memset( *grid, 0, sizeof( INT2Grid ) );
00124 
00125   /* Allocate the dimension units array. */
00126   if ( !( (*grid)->dimUnits = (LALUnit *)
00127           LALMalloc( dimension*sizeof(LALUnit) ) ) ) {
00128     LALFree( *grid );
00129     *grid = NULL;
00130     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00131   }
00132   memset( (*grid)->dimUnits, 0, dimension*sizeof(LALUnit) );
00133 
00134   /* Allocate the offset and interval vectors. */
00135   LALDCreateVector( stat->statusPtr, &((*grid)->offset), dimension );
00136   BEGINFAIL( stat ) {
00137     LALFree( (*grid)->dimUnits );
00138     LALFree( *grid );
00139     *grid = NULL;
00140   } ENDFAIL( stat );
00141   LALDCreateVector( stat->statusPtr, &((*grid)->interval), dimension );
00142   BEGINFAIL( stat ) {
00143     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00144     LALFree( (*grid)->dimUnits );
00145     LALFree( *grid );
00146     *grid = NULL;
00147   } ENDFAIL( stat );
00148 
00149   /* Allocate the data array. */
00150   LALI2CreateArray ( stat->statusPtr, &((*grid)->data), dimLength );
00151   BEGINFAIL( stat ) {
00152     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00153     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00154     LALFree( (*grid)->dimUnits );
00155     LALFree( *grid );
00156     *grid = NULL;
00157   } ENDFAIL( stat );
00158 
00159   /* Done. */
00160   DETATCHSTATUSPTR( stat );
00161   RETURN( stat );
00162 }
00163 
00164 
00165 void
00166 LALI2DestroyGrid ( LALStatus *stat, INT2Grid **grid )
00167 {
00168   INITSTATUS( stat, "LALI2DestroyGrid", GRIDC );
00169   ATTATCHSTATUSPTR( stat );
00170 
00171   /* Check for valid input argument. */
00172   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00173   ASSERT( *grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00174 
00175   /* Destroy the internal arrays and vectors. */
00176   TRY( LALI2DestroyArray ( stat->statusPtr, &((*grid)->data) ), stat );
00177   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00178   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00179   LALFree( (*grid)->dimUnits );
00180 
00181   /* Destroy the structure itself, and exit. */
00182   LALFree( *grid );
00183   *grid = NULL;
00184   DETATCHSTATUSPTR( stat );
00185   RETURN( stat );
00186 }
00187 
00188 
00189 void
00190 LALI4CreateGrid ( LALStatus *stat, INT4Grid **grid, UINT4Vector *dimLength, UINT4 dimension )
00191 {
00192   INITSTATUS( stat, "LALI4CreateGrid", GRIDC );
00193   ATTATCHSTATUSPTR( stat );
00194 
00195   /* Check for valid input arguments. */
00196   ASSERT( dimLength, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00197   ASSERT( dimLength->data, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00198   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00199   ASSERT( !*grid, stat, GRIDH_EOUT, GRIDH_MSGEOUT );
00200   ASSERT( dimension <= dimLength->length, stat, GRIDH_ENUL,
00201           GRIDH_MSGENUL );
00202 
00203   /* Allocate the grid. */
00204   if ( !( *grid = ( INT4Grid *)LALMalloc( sizeof( INT4Grid ) ) ) ) {
00205     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00206   }
00207   memset( *grid, 0, sizeof( INT4Grid ) );
00208 
00209   /* Allocate the dimension units array. */
00210   if ( !( (*grid)->dimUnits = (LALUnit *)
00211           LALMalloc( dimension*sizeof(LALUnit) ) ) ) {
00212     LALFree( *grid );
00213     *grid = NULL;
00214     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00215   }
00216   memset( (*grid)->dimUnits, 0, dimension*sizeof(LALUnit) );
00217 
00218   /* Allocate the offset and interval vectors. */
00219   LALDCreateVector( stat->statusPtr, &((*grid)->offset), dimension );
00220   BEGINFAIL( stat ) {
00221     LALFree( (*grid)->dimUnits );
00222     LALFree( *grid );
00223     *grid = NULL;
00224   } ENDFAIL( stat );
00225   LALDCreateVector( stat->statusPtr, &((*grid)->interval), dimension );
00226   BEGINFAIL( stat ) {
00227     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00228     LALFree( (*grid)->dimUnits );
00229     LALFree( *grid );
00230     *grid = NULL;
00231   } ENDFAIL( stat );
00232 
00233   /* Allocate the data array. */
00234   LALI4CreateArray ( stat->statusPtr, &((*grid)->data), dimLength );
00235   BEGINFAIL( stat ) {
00236     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00237     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00238     LALFree( (*grid)->dimUnits );
00239     LALFree( *grid );
00240     *grid = NULL;
00241   } ENDFAIL( stat );
00242 
00243   /* Done. */
00244   DETATCHSTATUSPTR( stat );
00245   RETURN( stat );
00246 }
00247 
00248 
00249 void
00250 LALI4DestroyGrid ( LALStatus *stat, INT4Grid **grid )
00251 {
00252   INITSTATUS( stat, "LALI4DestroyGrid", GRIDC );
00253   ATTATCHSTATUSPTR( stat );
00254 
00255   /* Check for valid input argument. */
00256   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00257   ASSERT( *grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00258 
00259   /* Destroy the internal arrays and vectors. */
00260   TRY( LALI4DestroyArray ( stat->statusPtr, &((*grid)->data) ), stat );
00261   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00262   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00263   LALFree( (*grid)->dimUnits );
00264 
00265   /* Destroy the structure itself, and exit. */
00266   LALFree( *grid );
00267   *grid = NULL;
00268   DETATCHSTATUSPTR( stat );
00269   RETURN( stat );
00270 }
00271 
00272 
00273 void
00274 LALI8CreateGrid ( LALStatus *stat, INT8Grid **grid, UINT4Vector *dimLength, UINT4 dimension )
00275 {
00276   INITSTATUS( stat, "LALI8CreateGrid", GRIDC );
00277   ATTATCHSTATUSPTR( stat );
00278 
00279   /* Check for valid input arguments. */
00280   ASSERT( dimLength, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00281   ASSERT( dimLength->data, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00282   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00283   ASSERT( !*grid, stat, GRIDH_EOUT, GRIDH_MSGEOUT );
00284   ASSERT( dimension <= dimLength->length, stat, GRIDH_ENUL,
00285           GRIDH_MSGENUL );
00286 
00287   /* Allocate the grid. */
00288   if ( !( *grid = ( INT8Grid *)LALMalloc( sizeof( INT8Grid ) ) ) ) {
00289     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00290   }
00291   memset( *grid, 0, sizeof( INT8Grid ) );
00292 
00293   /* Allocate the dimension units array. */
00294   if ( !( (*grid)->dimUnits = (LALUnit *)
00295           LALMalloc( dimension*sizeof(LALUnit) ) ) ) {
00296     LALFree( *grid );
00297     *grid = NULL;
00298     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00299   }
00300   memset( (*grid)->dimUnits, 0, dimension*sizeof(LALUnit) );
00301 
00302   /* Allocate the offset and interval vectors. */
00303   LALDCreateVector( stat->statusPtr, &((*grid)->offset), dimension );
00304   BEGINFAIL( stat ) {
00305     LALFree( (*grid)->dimUnits );
00306     LALFree( *grid );
00307     *grid = NULL;
00308   } ENDFAIL( stat );
00309   LALDCreateVector( stat->statusPtr, &((*grid)->interval), dimension );
00310   BEGINFAIL( stat ) {
00311     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00312     LALFree( (*grid)->dimUnits );
00313     LALFree( *grid );
00314     *grid = NULL;
00315   } ENDFAIL( stat );
00316 
00317   /* Allocate the data array. */
00318   LALI8CreateArray ( stat->statusPtr, &((*grid)->data), dimLength );
00319   BEGINFAIL( stat ) {
00320     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00321     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00322     LALFree( (*grid)->dimUnits );
00323     LALFree( *grid );
00324     *grid = NULL;
00325   } ENDFAIL( stat );
00326 
00327   /* Done. */
00328   DETATCHSTATUSPTR( stat );
00329   RETURN( stat );
00330 }
00331 
00332 
00333 void
00334 LALI8DestroyGrid ( LALStatus *stat, INT8Grid **grid )
00335 {
00336   INITSTATUS( stat, "LALI8DestroyGrid", GRIDC );
00337   ATTATCHSTATUSPTR( stat );
00338 
00339   /* Check for valid input argument. */
00340   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00341   ASSERT( *grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00342 
00343   /* Destroy the internal arrays and vectors. */
00344   TRY( LALI8DestroyArray ( stat->statusPtr, &((*grid)->data) ), stat );
00345   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00346   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00347   LALFree( (*grid)->dimUnits );
00348 
00349   /* Destroy the structure itself, and exit. */
00350   LALFree( *grid );
00351   *grid = NULL;
00352   DETATCHSTATUSPTR( stat );
00353   RETURN( stat );
00354 }
00355 
00356 
00357 void
00358 LALU2CreateGrid ( LALStatus *stat, UINT2Grid **grid, UINT4Vector *dimLength, UINT4 dimension )
00359 {
00360   INITSTATUS( stat, "LALU2CreateGrid", GRIDC );
00361   ATTATCHSTATUSPTR( stat );
00362 
00363   /* Check for valid input arguments. */
00364   ASSERT( dimLength, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00365   ASSERT( dimLength->data, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00366   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00367   ASSERT( !*grid, stat, GRIDH_EOUT, GRIDH_MSGEOUT );
00368   ASSERT( dimension <= dimLength->length, stat, GRIDH_ENUL,
00369           GRIDH_MSGENUL );
00370 
00371   /* Allocate the grid. */
00372   if ( !( *grid = ( UINT2Grid *)LALMalloc( sizeof( UINT2Grid ) ) ) ) {
00373     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00374   }
00375   memset( *grid, 0, sizeof( UINT2Grid ) );
00376 
00377   /* Allocate the dimension units array. */
00378   if ( !( (*grid)->dimUnits = (LALUnit *)
00379           LALMalloc( dimension*sizeof(LALUnit) ) ) ) {
00380     LALFree( *grid );
00381     *grid = NULL;
00382     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00383   }
00384   memset( (*grid)->dimUnits, 0, dimension*sizeof(LALUnit) );
00385 
00386   /* Allocate the offset and interval vectors. */
00387   LALDCreateVector( stat->statusPtr, &((*grid)->offset), dimension );
00388   BEGINFAIL( stat ) {
00389     LALFree( (*grid)->dimUnits );
00390     LALFree( *grid );
00391     *grid = NULL;
00392   } ENDFAIL( stat );
00393   LALDCreateVector( stat->statusPtr, &((*grid)->interval), dimension );
00394   BEGINFAIL( stat ) {
00395     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00396     LALFree( (*grid)->dimUnits );
00397     LALFree( *grid );
00398     *grid = NULL;
00399   } ENDFAIL( stat );
00400 
00401   /* Allocate the data array. */
00402   LALU2CreateArray ( stat->statusPtr, &((*grid)->data), dimLength );
00403   BEGINFAIL( stat ) {
00404     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00405     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00406     LALFree( (*grid)->dimUnits );
00407     LALFree( *grid );
00408     *grid = NULL;
00409   } ENDFAIL( stat );
00410 
00411   /* Done. */
00412   DETATCHSTATUSPTR( stat );
00413   RETURN( stat );
00414 }
00415 
00416 
00417 void
00418 LALU2DestroyGrid ( LALStatus *stat, UINT2Grid **grid )
00419 {
00420   INITSTATUS( stat, "LALU2DestroyGrid", GRIDC );
00421   ATTATCHSTATUSPTR( stat );
00422 
00423   /* Check for valid input argument. */
00424   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00425   ASSERT( *grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00426 
00427   /* Destroy the internal arrays and vectors. */
00428   TRY( LALU2DestroyArray ( stat->statusPtr, &((*grid)->data) ), stat );
00429   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00430   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00431   LALFree( (*grid)->dimUnits );
00432 
00433   /* Destroy the structure itself, and exit. */
00434   LALFree( *grid );
00435   *grid = NULL;
00436   DETATCHSTATUSPTR( stat );
00437   RETURN( stat );
00438 }
00439 
00440 
00441 void
00442 LALU4CreateGrid ( LALStatus *stat, UINT4Grid **grid, UINT4Vector *dimLength, UINT4 dimension )
00443 {
00444   INITSTATUS( stat, "LALU4CreateGrid", GRIDC );
00445   ATTATCHSTATUSPTR( stat );
00446 
00447   /* Check for valid input arguments. */
00448   ASSERT( dimLength, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00449   ASSERT( dimLength->data, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00450   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00451   ASSERT( !*grid, stat, GRIDH_EOUT, GRIDH_MSGEOUT );
00452   ASSERT( dimension <= dimLength->length, stat, GRIDH_ENUL,
00453           GRIDH_MSGENUL );
00454 
00455   /* Allocate the grid. */
00456   if ( !( *grid = ( UINT4Grid *)LALMalloc( sizeof( UINT4Grid ) ) ) ) {
00457     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00458   }
00459   memset( *grid, 0, sizeof( UINT4Grid ) );
00460 
00461   /* Allocate the dimension units array. */
00462   if ( !( (*grid)->dimUnits = (LALUnit *)
00463           LALMalloc( dimension*sizeof(LALUnit) ) ) ) {
00464     LALFree( *grid );
00465     *grid = NULL;
00466     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00467   }
00468   memset( (*grid)->dimUnits, 0, dimension*sizeof(LALUnit) );
00469 
00470   /* Allocate the offset and interval vectors. */
00471   LALDCreateVector( stat->statusPtr, &((*grid)->offset), dimension );
00472   BEGINFAIL( stat ) {
00473     LALFree( (*grid)->dimUnits );
00474     LALFree( *grid );
00475     *grid = NULL;
00476   } ENDFAIL( stat );
00477   LALDCreateVector( stat->statusPtr, &((*grid)->interval), dimension );
00478   BEGINFAIL( stat ) {
00479     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00480     LALFree( (*grid)->dimUnits );
00481     LALFree( *grid );
00482     *grid = NULL;
00483   } ENDFAIL( stat );
00484 
00485   /* Allocate the data array. */
00486   LALU4CreateArray ( stat->statusPtr, &((*grid)->data), dimLength );
00487   BEGINFAIL( stat ) {
00488     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00489     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00490     LALFree( (*grid)->dimUnits );
00491     LALFree( *grid );
00492     *grid = NULL;
00493   } ENDFAIL( stat );
00494 
00495   /* Done. */
00496   DETATCHSTATUSPTR( stat );
00497   RETURN( stat );
00498 }
00499 
00500 
00501 void
00502 LALU4DestroyGrid ( LALStatus *stat, UINT4Grid **grid )
00503 {
00504   INITSTATUS( stat, "LALU4DestroyGrid", GRIDC );
00505   ATTATCHSTATUSPTR( stat );
00506 
00507   /* Check for valid input argument. */
00508   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00509   ASSERT( *grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00510 
00511   /* Destroy the internal arrays and vectors. */
00512   TRY( LALU4DestroyArray ( stat->statusPtr, &((*grid)->data) ), stat );
00513   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00514   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00515   LALFree( (*grid)->dimUnits );
00516 
00517   /* Destroy the structure itself, and exit. */
00518   LALFree( *grid );
00519   *grid = NULL;
00520   DETATCHSTATUSPTR( stat );
00521   RETURN( stat );
00522 }
00523 
00524 
00525 void
00526 LALU8CreateGrid ( LALStatus *stat, UINT8Grid **grid, UINT4Vector *dimLength, UINT4 dimension )
00527 {
00528   INITSTATUS( stat, "LALU8CreateGrid", GRIDC );
00529   ATTATCHSTATUSPTR( stat );
00530 
00531   /* Check for valid input arguments. */
00532   ASSERT( dimLength, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00533   ASSERT( dimLength->data, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00534   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00535   ASSERT( !*grid, stat, GRIDH_EOUT, GRIDH_MSGEOUT );
00536   ASSERT( dimension <= dimLength->length, stat, GRIDH_ENUL,
00537           GRIDH_MSGENUL );
00538 
00539   /* Allocate the grid. */
00540   if ( !( *grid = ( UINT8Grid *)LALMalloc( sizeof( UINT8Grid ) ) ) ) {
00541     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00542   }
00543   memset( *grid, 0, sizeof( UINT8Grid ) );
00544 
00545   /* Allocate the dimension units array. */
00546   if ( !( (*grid)->dimUnits = (LALUnit *)
00547           LALMalloc( dimension*sizeof(LALUnit) ) ) ) {
00548     LALFree( *grid );
00549     *grid = NULL;
00550     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00551   }
00552   memset( (*grid)->dimUnits, 0, dimension*sizeof(LALUnit) );
00553 
00554   /* Allocate the offset and interval vectors. */
00555   LALDCreateVector( stat->statusPtr, &((*grid)->offset), dimension );
00556   BEGINFAIL( stat ) {
00557     LALFree( (*grid)->dimUnits );
00558     LALFree( *grid );
00559     *grid = NULL;
00560   } ENDFAIL( stat );
00561   LALDCreateVector( stat->statusPtr, &((*grid)->interval), dimension );
00562   BEGINFAIL( stat ) {
00563     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00564     LALFree( (*grid)->dimUnits );
00565     LALFree( *grid );
00566     *grid = NULL;
00567   } ENDFAIL( stat );
00568 
00569   /* Allocate the data array. */
00570   LALU8CreateArray ( stat->statusPtr, &((*grid)->data), dimLength );
00571   BEGINFAIL( stat ) {
00572     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00573     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00574     LALFree( (*grid)->dimUnits );
00575     LALFree( *grid );
00576     *grid = NULL;
00577   } ENDFAIL( stat );
00578 
00579   /* Done. */
00580   DETATCHSTATUSPTR( stat );
00581   RETURN( stat );
00582 }
00583 
00584 
00585 void
00586 LALU8DestroyGrid ( LALStatus *stat, UINT8Grid **grid )
00587 {
00588   INITSTATUS( stat, "LALU8DestroyGrid", GRIDC );
00589   ATTATCHSTATUSPTR( stat );
00590 
00591   /* Check for valid input argument. */
00592   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00593   ASSERT( *grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00594 
00595   /* Destroy the internal arrays and vectors. */
00596   TRY( LALU8DestroyArray ( stat->statusPtr, &((*grid)->data) ), stat );
00597   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00598   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00599   LALFree( (*grid)->dimUnits );
00600 
00601   /* Destroy the structure itself, and exit. */
00602   LALFree( *grid );
00603   *grid = NULL;
00604   DETATCHSTATUSPTR( stat );
00605   RETURN( stat );
00606 }
00607 
00608 
00609 void
00610 LALSCreateGrid ( LALStatus *stat, REAL4Grid **grid, UINT4Vector *dimLength, UINT4 dimension )
00611 {
00612   INITSTATUS( stat, "LALSCreateGrid", GRIDC );
00613   ATTATCHSTATUSPTR( stat );
00614 
00615   /* Check for valid input arguments. */
00616   ASSERT( dimLength, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00617   ASSERT( dimLength->data, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00618   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00619   ASSERT( !*grid, stat, GRIDH_EOUT, GRIDH_MSGEOUT );
00620   ASSERT( dimension <= dimLength->length, stat, GRIDH_ENUL,
00621           GRIDH_MSGENUL );
00622 
00623   /* Allocate the grid. */
00624   if ( !( *grid = ( REAL4Grid *)LALMalloc( sizeof( REAL4Grid ) ) ) ) {
00625     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00626   }
00627   memset( *grid, 0, sizeof( REAL4Grid ) );
00628 
00629   /* Allocate the dimension units array. */
00630   if ( !( (*grid)->dimUnits = (LALUnit *)
00631           LALMalloc( dimension*sizeof(LALUnit) ) ) ) {
00632     LALFree( *grid );
00633     *grid = NULL;
00634     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00635   }
00636   memset( (*grid)->dimUnits, 0, dimension*sizeof(LALUnit) );
00637 
00638   /* Allocate the offset and interval vectors. */
00639   LALDCreateVector( stat->statusPtr, &((*grid)->offset), dimension );
00640   BEGINFAIL( stat ) {
00641     LALFree( (*grid)->dimUnits );
00642     LALFree( *grid );
00643     *grid = NULL;
00644   } ENDFAIL( stat );
00645   LALDCreateVector( stat->statusPtr, &((*grid)->interval), dimension );
00646   BEGINFAIL( stat ) {
00647     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00648     LALFree( (*grid)->dimUnits );
00649     LALFree( *grid );
00650     *grid = NULL;
00651   } ENDFAIL( stat );
00652 
00653   /* Allocate the data array. */
00654   LALSCreateArray ( stat->statusPtr, &((*grid)->data), dimLength );
00655   BEGINFAIL( stat ) {
00656     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00657     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00658     LALFree( (*grid)->dimUnits );
00659     LALFree( *grid );
00660     *grid = NULL;
00661   } ENDFAIL( stat );
00662 
00663   /* Done. */
00664   DETATCHSTATUSPTR( stat );
00665   RETURN( stat );
00666 }
00667 
00668 
00669 void
00670 LALSDestroyGrid ( LALStatus *stat, REAL4Grid **grid )
00671 {
00672   INITSTATUS( stat, "LALSDestroyGrid", GRIDC );
00673   ATTATCHSTATUSPTR( stat );
00674 
00675   /* Check for valid input argument. */
00676   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00677   ASSERT( *grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00678 
00679   /* Destroy the internal arrays and vectors. */
00680   TRY( LALSDestroyArray ( stat->statusPtr, &((*grid)->data) ), stat );
00681   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00682   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00683   LALFree( (*grid)->dimUnits );
00684 
00685   /* Destroy the structure itself, and exit. */
00686   LALFree( *grid );
00687   *grid = NULL;
00688   DETATCHSTATUSPTR( stat );
00689   RETURN( stat );
00690 }
00691 
00692 
00693 void
00694 LALDCreateGrid ( LALStatus *stat, REAL8Grid **grid, UINT4Vector *dimLength, UINT4 dimension )
00695 {
00696   INITSTATUS( stat, "LALDCreateGrid", GRIDC );
00697   ATTATCHSTATUSPTR( stat );
00698 
00699   /* Check for valid input arguments. */
00700   ASSERT( dimLength, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00701   ASSERT( dimLength->data, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00702   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00703   ASSERT( !*grid, stat, GRIDH_EOUT, GRIDH_MSGEOUT );
00704   ASSERT( dimension <= dimLength->length, stat, GRIDH_ENUL,
00705           GRIDH_MSGENUL );
00706 
00707   /* Allocate the grid. */
00708   if ( !( *grid = ( REAL8Grid *)LALMalloc( sizeof( REAL8Grid ) ) ) ) {
00709     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00710   }
00711   memset( *grid, 0, sizeof( REAL8Grid ) );
00712 
00713   /* Allocate the dimension units array. */
00714   if ( !( (*grid)->dimUnits = (LALUnit *)
00715           LALMalloc( dimension*sizeof(LALUnit) ) ) ) {
00716     LALFree( *grid );
00717     *grid = NULL;
00718     ABORT( stat, GRIDH_EMEM, GRIDH_MSGEMEM );
00719   }
00720   memset( (*grid)->dimUnits, 0, dimension*sizeof(LALUnit) );
00721 
00722   /* Allocate the offset and interval vectors. */
00723   LALDCreateVector( stat->statusPtr, &((*grid)->offset), dimension );
00724   BEGINFAIL( stat ) {
00725     LALFree( (*grid)->dimUnits );
00726     LALFree( *grid );
00727     *grid = NULL;
00728   } ENDFAIL( stat );
00729   LALDCreateVector( stat->statusPtr, &((*grid)->interval), dimension );
00730   BEGINFAIL( stat ) {
00731     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00732     LALFree( (*grid)->dimUnits );
00733     LALFree( *grid );
00734     *grid = NULL;
00735   } ENDFAIL( stat );
00736 
00737   /* Allocate the data array. */
00738   LALDCreateArray ( stat->statusPtr, &((*grid)->data), dimLength );
00739   BEGINFAIL( stat ) {
00740     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00741     TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00742     LALFree( (*grid)->dimUnits );
00743     LALFree( *grid );
00744     *grid = NULL;
00745   } ENDFAIL( stat );
00746 
00747   /* Done. */
00748   DETATCHSTATUSPTR( stat );
00749   RETURN( stat );
00750 }
00751 
00752 
00753 void
00754 LALDDestroyGrid ( LALStatus *stat, REAL8Grid **grid )
00755 {
00756   INITSTATUS( stat, "LALDDestroyGrid", GRIDC );
00757   ATTATCHSTATUSPTR( stat );
00758 
00759   /* Check for valid input argument. */
00760   ASSERT( grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00761   ASSERT( *grid, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00762 
00763   /* Destroy the internal arrays and vectors. */
00764   TRY( LALDDestroyArray ( stat->statusPtr, &((*grid)->data) ), stat );
00765   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->interval) ), stat );
00766   TRY( LALDDestroyVector( stat->statusPtr, &((*grid)->offset) ), stat );
00767   LALFree( (*grid)->dimUnits );
00768 
00769   /* Destroy the structure itself, and exit. */
00770   LALFree( *grid );
00771   *grid = NULL;
00772   DETATCHSTATUSPTR( stat );
00773   RETURN( stat );
00774 }
00775 
00776 
00777 void
00778 LALCCreateGrid ( LALStatus *stat, COMPLEX8Grid **grid, UINT4Vector *dimLength, UINT4 dimension )
00779 {
00780   INITSTATUS( stat, "LALCCreateGrid", GRIDC );
00781   ATTATCHSTATUSPTR( stat );
00782 
00783   /* Check for valid input arguments. */
00784   ASSERT( dimLength, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00785   ASSERT( dimLength->data, stat, GRIDH_ENUL, GRIDH_MSGENUL );
00786   ASSERT(