29#include <lal/FITSFileIO.h>
30#include <lal/LALPulsarVCSInfo.h>
31#include <lal/LALString.h>
32#include <lal/StringVector.h>
34#include <lal/UserInput.h>
35#include <lal/GSLHelpers.h>
37#if !defined(HAVE_LIBCFITSIO)
41 fprintf( stderr,
"CFITSIO library is not available; skipping test\n" );
47const CHAR *longstring_ref = \
48 "This is a long string #1. This is a long string #2. " \
49 "This is a long string #3. This is a long string #4. " \
50 "This is a long string #5. This is a long string #6. " \
51 "This is a long string #7. This is a long string #8. " \
52 "This is a long string #9. This is a long string #10." ;
75 const TestSubRecord *sub;
78REAL4 testarray[3][1824] = { { 0 }, { 0 }, { 0 } };
80const TestSubRecord testsub[3][2] = {
81 { { .n = 0, .v = 1.23, .desc =
"A1", .idx = 3 }, { .n = 1, .v = 2.34, .desc =
"X9", .idx =
LAL_UINT8_MAX >> 0 } },
82 { { .n = 0, .v = 3.45, .desc =
"B3", .idx = 7 }, { .n = 1, .v = 4.56, .desc =
"Y7", .idx =
LAL_UINT8_MAX >> 1 } },
83 { { .n = 0, .v = 5.67, .desc =
"C5", .idx = 11 }, { .n = 1, .v = 6.78, .desc =
"Z5", .idx =
LAL_UINT8_MAX >> 5 } },
86const TestRecord testtable[3] = {
88 .index = 3, .flag = 1, .name =
"CasA", .epoch = {123456789, 5}, .pos = {.sky = 5.4321, .freq = 100.999, .fkdot = {1
e-9, 5
e-20}}, .values = {13.24, 43.234},
89 .phasef =
crectf( 1.2, 3.4 ), .phase =
crect( 4.5, 0.2 ), .array = testarray[0], .sub = testsub[0]
92 .index = 2, .flag = 0, .name =
"Vela", .epoch = {452456245, 9}, .pos = {.sky = 34.454, .freq = 1345.34, .fkdot = {2
e-8, 6
e-21}}, .values = {14.35, 94.128},
93 .phasef =
crectf( 3.6, 9.3 ), .phase =
crect( 8.3, 4.0 ), .array = testarray[1], .sub = testsub[1]
96 .index = 1, .flag = 1, .name =
"Crab", .epoch = {467846774, 4}, .pos = {.sky = 64.244, .freq = 15.6463, .fkdot = {4
e-6, 0}}, .values = {153.4, 3.0900},
97 .phasef =
crectf( 6.7, 4.4 ), .phase =
crect( 5.6, 6.3 ), .array = testarray[2], .sub = testsub[2]
101int main(
int argc,
char *argv[] )
131 fprintf( stderr,
"PASSED: opened 'FITSFileIOTest.fits' for writing\n" );
134 fprintf( stderr,
"PASSED: wrote a BOOLEAN\n" );
137 fprintf( stderr,
"PASSED: wrote a UINT2\n" );
140 fprintf( stderr,
"PASSED: wrote a UINT4\n" );
143 fprintf( stderr,
"PASSED: wrote a UINT8\n" );
146 fprintf( stderr,
"PASSED: wrote a INT2\n" );
149 fprintf( stderr,
"PASSED: wrote a INT4\n" );
152 fprintf( stderr,
"PASSED: wrote a INT8\n" );
155 fprintf( stderr,
"PASSED: wrote a REAL4\n" );
158 fprintf( stderr,
"PASSED: wrote a REAL8\n" );
161 fprintf( stderr,
"PASSED: wrote a COMPLEX8\n" );
164 fprintf( stderr,
"PASSED: wrote a COMPLEX16\n" );
167 fprintf( stderr,
"PASSED: wrote a string\n" );
170 fprintf( stderr,
"PASSED: wrote a long string\n" );
176 fprintf( stderr,
"PASSED: wrote a string vector\n" );
180 fprintf( stderr,
"PASSED: wrote a GPS time\n" );
183 const size_t dims[4] = {1, 2, 3, 4};
186 for ( idx[0] = 0; idx[0] < dims[0]; ++idx[0] ) {
187 for ( idx[1] = 0; idx[1] < dims[1]; ++idx[1] ) {
188 for ( idx[2] = 0; idx[2] < dims[2]; ++idx[2] ) {
189 for ( idx[3] = 0; idx[3] < dims[3]; ++idx[3] ) {
190 const INT4 value = idx[0] + 2 * idx[1] + 3 * idx[2] + 4 * idx[3];
197 fprintf( stderr,
"PASSED: wrote a INT4 array\n" );
200 for (
size_t i = 0;
i < 2; ++
i ) {
201 for (
size_t j = 0;
j < 2; ++
j ) {
202 const size_t idx[] = {
i,
j };
207 fprintf( stderr,
"PASSED: wrote a UINT8 array\n" );
210 for (
size_t i = 0;
i < 14; ++
i ) {
211 const size_t idx[] = {
i };
212 const REAL4 value = 21 + 0.5 *
i;
215 fprintf( stderr,
"PASSED: wrote a REAL4 array\n" );
218 const size_t m = 2,
n = 3;
219 gsl_matrix *GAMAT( elems,
m, n );
220 for (
size_t i = 0;
i <
m; ++
i ) {
221 for (
size_t j = 0;
j <
n; ++
j ) {
222 const double value = 7.0 + 2.5 *
i + 3.0 *
j;
223 gsl_matrix_set( elems,
i, j, value );
230 fprintf( stderr,
"PASSED: wrote a gsl_matrix\n" );
262 fprintf( stderr,
"PASSED: wrote a table\n" );
269 fprintf( stderr,
"PASSED: HDU seeking in write mode\n" );
272 fprintf( stderr,
"PASSED: closed 'FITSFileIOTest.fits'\n" );
282 fprintf( stderr,
"PASSED: opened 'FITSFileIOTest.fits' for reading\n" );
319 for (
size_t s = 0;
s < 2; ++
s ) {
321 snprintf( col_name,
sizeof( col_name ),
"n%zu",
s + 1 );
323 snprintf( col_name,
sizeof( col_name ),
"v%zu",
s + 1 );
325 snprintf( col_name,
sizeof( col_name ),
"desc%zu",
s + 1 );
327 snprintf( col_name,
sizeof( col_name ),
"idx%zu",
s + 1 );
334 record.array = record_array;
336 record.sub = record_sub;
338 while ( nrows > 0 ) {
358 for (
size_t s = 0;
s < 2; ++
s ) {
371 fprintf( stderr,
"PASSED: read and verified a table\n" );
378 gsl_matrix *elems = NULL;
380 for (
size_t i = 0;
i <
m; ++
i ) {
381 for (
size_t j = 0;
j <
n; ++
j ) {
382 const double value_ref = 7.0 + 2.5 *
i + 3.0 *
j;
383 double value = gsl_matrix_get( elems,
i, j );
389 fprintf( stderr,
"PASSED: read and verified a gsl_matrix\n" );
395 for (
size_t i = 0;
i < dim; ++
i ) {
396 const size_t idx[] = {
i };
397 const REAL4 value_ref = 21 + 0.5 *
i;
403 fprintf( stderr,
"PASSED: read and verified a REAL4 array\n" );
406 size_t dim_i = 0, dim_j = 0;
410 for (
size_t i = 0;
i < dim_i; ++
i ) {
411 for (
size_t j = 0;
j < dim_j; ++
j ) {
412 const size_t idx[] = {
i,
j };
416 XLAL_CHECK_MAIN( value == value_ref,
XLAL_EFAILED,
"value[%zu,%zu] = %" LAL_UINT8_FORMAT
" != %" LAL_UINT8_FORMAT,
i, j, value, value_ref );
420 fprintf( stderr,
"PASSED: read and verified a UINT8 array\n" );
427 for ( idx[0] = 0; idx[0] < dims[0]; ++idx[0] ) {
428 for ( idx[1] = 0; idx[1] < dims[1]; ++idx[1] ) {
429 for ( idx[2] = 0; idx[2] < dims[2]; ++idx[2] ) {
430 for ( idx[3] = 0; idx[3] < dims[3]; ++idx[3] ) {
431 const INT4 value_ref = idx[0] + 2 * idx[1] + 3 * idx[2] + 4 * idx[3];
434 XLAL_CHECK_MAIN( value == value_ref,
XLAL_EFAILED,
"value[%zu,%zu,%zu,%zu] = %i != %i", idx[0], idx[1], idx[2], idx[3], value, value_ref );
440 fprintf( stderr,
"PASSED: read and verified a INT4 array\n" );
449 fprintf( stderr,
"PASSED: read and verified a BOOLEAN\n" );
452 const UINT2 testushrt_ref = 1234;
457 fprintf( stderr,
"PASSED: read and verified a UINT2\n" );
460 const UINT4 testuint_ref = 34567;
465 fprintf( stderr,
"PASSED: read and verified a UINT4\n" );
468 UINT4 testuint2_too_small;
477 XLAL_CHECK_MAIN( testuint2 == testuint2_ref,
XLAL_EFAILED,
"testuint = %" LAL_UINT8_FORMAT
" != %" LAL_UINT8_FORMAT, testuint2, testuint2_ref );
479 fprintf( stderr,
"PASSED: read and verified a UINT8\n" );
482 const INT2 testshrt_ref = -1234;
487 fprintf( stderr,
"PASSED: read and verified a INT2\n" );
490 const INT4 testint_ref = -2345;
495 fprintf( stderr,
"PASSED: read and verified a INT4\n" );
498 INT4 testint2_too_small;
507 XLAL_CHECK_MAIN( testint2 == testint2_ref,
XLAL_EFAILED,
"testint = %" LAL_INT8_FORMAT
" != %" LAL_INT8_FORMAT, testint2, testint2_ref );
509 fprintf( stderr,
"PASSED: read and verified a INT8\n" );
515 const REAL4 err = fabsf( testflt - testflt_ref ), err_tol = 5 * FLT_EPSILON;
516 XLAL_CHECK_MAIN( err < err_tol, XLAL_EFAILED, "|testflt - testflt_ref| = |%0.*g - %0.*g| = %0.*g >= %0.*g
",
517 FLT_DIG, testflt, FLT_DIG, testflt_ref, FLT_DIG, err, FLT_DIG, err_tol );
519 fprintf( stderr, "PASSED: read and verified
a REAL4\n
" );
522 const REAL8 testdbl_ref = LAL_E;
524 XLAL_CHECK_MAIN( XLALFITSHeaderReadREAL8( file, "testdbl
", &testdbl ) == XLAL_SUCCESS, XLAL_EFUNC );
525 const REAL8 err = fabs( testdbl - testdbl_ref ), err_tol = 5 * DBL_EPSILON;
526 XLAL_CHECK_MAIN( err < err_tol, XLAL_EFAILED, "|testdbl - testdbl_ref| = |%0.*g - %0.*g| = %0.*g >= %0.*g
",
527 DBL_DIG, testdbl, DBL_DIG, testdbl_ref, DBL_DIG, err, DBL_DIG, err_tol );
529 fprintf( stderr, "PASSED: read and verified
a REAL8\n
" );
532 const COMPLEX8 testcmp_ref = crectf( LAL_PI_2, LAL_PI_4 );
534 XLAL_CHECK_MAIN( XLALFITSHeaderReadCOMPLEX8( file, "testcmp
", &testcmp ) == XLAL_SUCCESS, XLAL_EFUNC );
535 const REAL4 err = cabsf( testcmp - testcmp_ref ), err_tol = 5 * FLT_EPSILON;
536 XLAL_CHECK_MAIN( err < err_tol, XLAL_EFAILED, "|testcmp - testcmp_ref| = |(%0.*g,%0.*g) - (%0.*g,%0.*g)| = %0.*g >= %0.*g
",
537 FLT_DIG, crealf( testcmp ), FLT_DIG, cimagf( testcmp ), FLT_DIG, crealf( testcmp_ref ), FLT_DIG, cimagf( testcmp_ref ), FLT_DIG, err, FLT_DIG, err_tol );
539 fprintf( stderr, "PASSED: read and verified
a COMPLEX8\n
" );
542 const COMPLEX16 testdblcmp_ref = crect( LAL_LOG2E, LAL_LOG10E );
543 COMPLEX16 testdblcmp;
544 XLAL_CHECK_MAIN( XLALFITSHeaderReadCOMPLEX16( file, "testdblcmp
", &testdblcmp ) == XLAL_SUCCESS, XLAL_EFUNC );
545 const REAL8 err = cabs( testdblcmp - testdblcmp_ref ), err_tol = 5 * DBL_EPSILON;
546 XLAL_CHECK_MAIN( err < err_tol, XLAL_EFAILED, "|testdblcmp - testdblcmp_ref| = |(%0.*g,%0.*g) - (%0.*g,%0.*g)| = %0.*g >= %0.*g
",
547 DBL_DIG, creal( testdblcmp ), DBL_DIG, cimag( testdblcmp ), DBL_DIG, creal( testdblcmp_ref ), DBL_DIG, cimag( testdblcmp_ref ), DBL_DIG, err, DBL_DIG, err_tol );
549 fprintf( stderr, "PASSED: read and verified
a COMPLEX16\n
" );
552 const CHAR *teststr_ref = "This is
a short string";
553 CHAR *teststr = NULL;
554 XLAL_CHECK_MAIN( XLALFITSHeaderReadString( file, "teststr
", &teststr ) == XLAL_SUCCESS, XLAL_EFUNC );
555 XLAL_CHECK_MAIN( strcmp( teststr, teststr_ref ) == 0, XLAL_EFAILED, "teststr =
'%s' !=
'%s'", teststr, teststr_ref );
558 fprintf( stderr, "PASSED: read and verified
a string\n
" );
561 CHAR *longstring = NULL;
562 XLAL_CHECK_MAIN( XLALFITSHeaderReadString( file, "longstring
", &longstring ) == XLAL_SUCCESS, XLAL_EFUNC );
563 XLAL_CHECK_MAIN( strcmp( longstring, longstring_ref ) == 0, XLAL_EFAILED, "longstring =
'%s' !=
'%s'", longstring, longstring_ref );
564 XLALFree( longstring );
566 fprintf( stderr, "PASSED: read and verified
a long string\n
" );
569 LALStringVector *testsv = NULL;
570 XLAL_CHECK_MAIN( XLALFITSHeaderReadStringVector( file, "testsv
", &testsv ) == XLAL_SUCCESS, XLAL_EFUNC );
571 XLAL_CHECK_MAIN( testsv->length == 3, XLAL_EFAILED, "testsv->
length = %u != 3
", testsv->length );
572 XLAL_CHECK_MAIN( strcmp( testsv->data[0], "abc
" ) == 0, XLAL_EFAILED, "testsv->
data[0] =
'%s' !=
'abc'", testsv->data[0] );
573 XLAL_CHECK_MAIN( strcmp( testsv->data[1], "def
" ) == 0, XLAL_EFAILED, "testsv->
data[1] =
'%s' !=
'def'", testsv->data[1] );
574 XLAL_CHECK_MAIN( strcmp( testsv->data[2], "ghij
" ) == 0, XLAL_EFAILED, "testsv->
data[2] =
'%s' !=
'ghij'", testsv->data[2] );
575 XLALDestroyStringVector( testsv );
577 fprintf( stderr, "PASSED: read and verified
a string vector\n
" );
580 LIGOTimeGPS ref_time = LIGOTIMEGPSZERO;
581 XLAL_CHECK_MAIN( XLALFITSHeaderReadGPSTime( file, "date-obs
", &ref_time ) == XLAL_SUCCESS, XLAL_EFUNC );
582 XLAL_CHECK_MAIN( ref_time.gpsSeconds == 987654321 && ref_time.gpsNanoSeconds == 123456789, XLAL_EFAILED,
583 "ref_time = %
" LAL_GPS_FORMAT " != 987654321.123456789
", LAL_GPS_PRINT( ref_time ) );
585 fprintf( stderr, "PASSED: read and verified
a GPS
time\n
" );
591 } keys[] = { { 1, "date-obs
" }, { 1, "testdbl
" }, { 0, "banana
" }, { 1, "longstring
" } };
592 for ( size_t i = 0; i < XLAL_NUM_ELEM( keys ); ++i ) {
594 XLAL_CHECK_MAIN( XLALFITSHeaderQueryKeyExists( file, keys[i].key, &exists ) == XLAL_SUCCESS, XLAL_EFUNC );
595 XLAL_CHECK_MAIN( exists == keys[i].exists, XLAL_EFAILED, "Failed to query key
'%s': %
i != %
i", keys[i].key, exists, keys[i].exists );
598 fprintf( stderr, "PASSED: HDU key queries in read
mode\n
" );
600 XLAL_CHECK_MAIN( XLALFITSFileSeekNamedHDU( file, "table1
" ) == XLAL_SUCCESS, XLAL_EFUNC );
601 XLAL_CHECK_MAIN( XLALFITSFileSeekNamedHDU( file, "array3
" ) == XLAL_SUCCESS, XLAL_EFUNC );
602 XLAL_CHECK_MAIN( XLALFITSFileSeekNamedHDU( file, "array1
" ) == XLAL_SUCCESS, XLAL_EFUNC );
603 fprintf( stderr, "PASSED: HDU seeking in read
mode\n
" );
605 XLALFITSFileClose( file );
606 fprintf( stderr, "PASSED: closed
'FITSFileIOTest.fits'\n
" );
608 fprintf( stderr, "\n
" );
612 XLALDestroyUserVars();
613 LALCheckMemoryLeaks();
619#endif // !defined(HAVE_LIBCFITSIO)
622// c-file-style: "linux
"
int XLALFITSArrayReadINT4(FITSFile UNUSED *file, const size_t UNUSED idx[], INT4 UNUSED *elem)
int XLALFITSArrayOpenWrite1(FITSFile UNUSED *file, const CHAR UNUSED *name, const size_t UNUSED dim0, const CHAR UNUSED *comment)
int XLALFITSHeaderWriteUINT4(FITSFile UNUSED *file, const CHAR UNUSED *key, const UINT4 UNUSED value, const CHAR UNUSED *comment)
int XLALFITSArrayOpenWrite(FITSFile UNUSED *file, const CHAR UNUSED *name, const size_t UNUSED ndim, const size_t UNUSED dims[], const CHAR UNUSED *comment)
int XLALFITSFileSeekNamedHDU(FITSFile UNUSED *file, const CHAR UNUSED *name)
int XLALFITSTableWriteRow(FITSFile UNUSED *file, const void UNUSED *record)
int XLALFITSHeaderWriteStringVector(FITSFile UNUSED *file, const CHAR UNUSED *key, const LALStringVector UNUSED *values, const CHAR UNUSED *comment)
int XLALFITSFileSeekPrimaryHDU(FITSFile UNUSED *file)
int XLALFITSHeaderWriteGPSTime(FITSFile UNUSED *file, const CHAR UNUSED *key, const LIGOTimeGPS UNUSED *value, const CHAR UNUSED *comment)
int XLALFITSHeaderWriteBOOLEAN(FITSFile UNUSED *file, const CHAR UNUSED *key, const BOOLEAN UNUSED value, const CHAR UNUSED *comment)
int XLALFITSTableReadRow(FITSFile UNUSED *file, void UNUSED *record, UINT8 UNUSED *rem_nrows)
int XLALFITSArrayReadGSLMatrix(FITSFile UNUSED *file, const size_t UNUSED idx[], gsl_matrix UNUSED **elems)
int XLALFITSHeaderReadINT2(FITSFile UNUSED *file, const CHAR UNUSED *key, INT2 UNUSED *value)
int XLALFITSHeaderReadBOOLEAN(FITSFile UNUSED *file, const CHAR UNUSED *key, BOOLEAN UNUSED *value)
int XLALFITSHeaderReadREAL4(FITSFile UNUSED *file, const CHAR UNUSED *key, REAL4 UNUSED *value)
FITSFile * XLALFITSFileOpenWrite(const CHAR UNUSED *file_name)
int XLALFITSArrayWriteUINT8(FITSFile UNUSED *file, const size_t UNUSED idx[], const UINT8 UNUSED elem)
int XLALFITSArrayOpenRead2(FITSFile UNUSED *file, const CHAR UNUSED *name, size_t UNUSED *dim0, size_t UNUSED *dim1)
int XLALFITSHeaderReadINT8(FITSFile UNUSED *file, const CHAR UNUSED *key, INT8 UNUSED *value)
int XLALFITSHeaderWriteComment(FITSFile UNUSED *file, const CHAR UNUSED *format,...)
int XLALFITSFileWriteVCSInfo(FITSFile UNUSED *file, const LALVCSInfoList UNUSED vcs_list)
int XLALFITSFileWriteUVarCmdLine(FITSFile UNUSED *file)
int XLALFITSArrayOpenRead(FITSFile UNUSED *file, const CHAR UNUSED *name, size_t UNUSED *ndim, size_t UNUSED dims[])
int XLALFITSHeaderWriteINT2(FITSFile UNUSED *file, const CHAR UNUSED *key, const INT2 UNUSED value, const CHAR UNUSED *comment)
int XLALFITSHeaderWriteCOMPLEX16(FITSFile UNUSED *file, const CHAR UNUSED *key, const COMPLEX16 UNUSED value, const CHAR UNUSED *comment)
int XLALFITSTableOpenWrite(FITSFile UNUSED *file, const CHAR UNUSED *name, const CHAR UNUSED *comment)
int XLALFITSHeaderWriteUINT2(FITSFile UNUSED *file, const CHAR UNUSED *key, const UINT2 UNUSED value, const CHAR UNUSED *comment)
int XLALFITSArrayWriteREAL4(FITSFile UNUSED *file, const size_t UNUSED idx[], const REAL4 UNUSED elem)
FITSFile * XLALFITSFileOpenRead(const CHAR UNUSED *file_name)
int XLALFITSHeaderWriteINT8(FITSFile UNUSED *file, const CHAR UNUSED *key, const INT8 UNUSED value, const CHAR UNUSED *comment)
int XLALFITSArrayReadREAL4(FITSFile UNUSED *file, const size_t UNUSED idx[], REAL4 UNUSED *elem)
int XLALFITSHeaderReadINT4(FITSFile UNUSED *file, const CHAR UNUSED *key, INT4 UNUSED *value)
int XLALFITSArrayOpenRead1(FITSFile UNUSED *file, const CHAR UNUSED *name, size_t UNUSED *dim0)
int XLALFITSArrayOpenWrite2(FITSFile UNUSED *file, const CHAR UNUSED *name, const size_t UNUSED dim0, const size_t UNUSED dim1, const CHAR UNUSED *comment)
int XLALFITSHeaderWriteUINT8(FITSFile UNUSED *file, const CHAR UNUSED *key, const UINT8 UNUSED value, const CHAR UNUSED *comment)
int XLALFITSHeaderReadUINT2(FITSFile UNUSED *file, const CHAR UNUSED *key, UINT2 UNUSED *value)
void XLALFITSFileClose(FITSFile UNUSED *file)
int XLALFITSArrayWriteGSLMatrix(FITSFile UNUSED *file, const size_t UNUSED idx[], const gsl_matrix UNUSED *elems)
int XLALFITSHeaderWriteINT4(FITSFile UNUSED *file, const CHAR UNUSED *key, const INT4 UNUSED value, const CHAR UNUSED *comment)
int XLALFITSHeaderWriteREAL4(FITSFile UNUSED *file, const CHAR UNUSED *key, const REAL4 UNUSED value, const CHAR UNUSED *comment)
int XLALFITSHeaderWriteREAL8(FITSFile UNUSED *file, const CHAR UNUSED *key, const REAL8 UNUSED value, const CHAR UNUSED *comment)
int XLALFITSHeaderReadUINT8(FITSFile UNUSED *file, const CHAR UNUSED *key, UINT8 UNUSED *value)
int XLALFITSHeaderWriteCOMPLEX8(FITSFile UNUSED *file, const CHAR UNUSED *key, const COMPLEX8 UNUSED value, const CHAR UNUSED *comment)
int XLALFITSArrayWriteINT4(FITSFile UNUSED *file, const size_t UNUSED idx[], const INT4 UNUSED elem)
int XLALFITSArrayReadUINT8(FITSFile UNUSED *file, const size_t UNUSED idx[], UINT8 UNUSED *elem)
int XLALFITSHeaderReadUINT4(FITSFile UNUSED *file, const CHAR UNUSED *key, UINT4 UNUSED *value)
int XLALFITSTableOpenRead(FITSFile UNUSED *file, const CHAR UNUSED *name, UINT8 UNUSED *nrows)
int XLALFITSHeaderWriteString(FITSFile UNUSED *file, const CHAR UNUSED *key, const CHAR UNUSED *value, const CHAR UNUSED *comment)
int XLALFITSFileWriteHistory(FITSFile UNUSED *file, const CHAR UNUSED *format,...)
const LALVCSInfoList lalPulsarVCSInfoList
NULL-terminated list of VCS and build information for LALPulsar and its dependencies
#define XLAL_FITS_TABLE_COLUMN_ADD_PTR_ARRAY(file, type, length, field)
#define XLAL_FITS_TABLE_COLUMN_BEGIN(record_type)
#define XLAL_FITS_TABLE_COLUMN_ADD_NAMED(file, type, field, col_name)
#define XLAL_FITS_TABLE_COLUMN_ADD_PTR_STRUCT_NAMED(file, index, type, field, col_name)
#define XLAL_FITS_TABLE_COLUMN_PTR_STRUCT_BEGIN(field, ptr_record_type, length)
#define XLAL_FITS_TABLE_COLUMN_ADD_PTR_STRUCT_ARRAY_NAMED(file, index, type, field, col_name)
#define XLAL_FITS_TABLE_COLUMN_ADD_ARRAY(file, type, field)
#define FFIO_MAX
Maximum possible number of FITS array dimensions, and FITS table columns.
#define XLAL_FITS_TABLE_COLUMN_ADD(file, type, field)
#define XLAL_FITS_TABLE_COLUMN_ADD_PTR_ARRAY_NAMED(file, type, length, field, col_name)
struct tagFITSFile FITSFile
Representation of a FITS file.
#define XLAL_FITS_TABLE_COLUMN_ADD_ARRAY_NAMED(file, type, field, col_name)
#define XLAL_INIT_DECL(var,...)
char char * XLALStringDuplicate(const char *s)
void XLALDestroyStringVector(LALStringVector *vect)
LALStringVector * XLALCreateStringVector(const CHAR *str1,...)
#define XLAL_TRY_SILENT(statement, errnum)
#define XLAL_CHECK_MAIN(assertion,...)
int XLALGPSCmp(const LIGOTimeGPS *t0, const LIGOTimeGPS *t1)
def phase(point, coeffs, params, ignoreintcheck=False)