int test_skip_1(bitfile* bf, int* truevals)
{
int i, vi=0;
// instead of
//CHECKVAL(vi, bitfile_read_int(bf,10), truevals);
//CHECKVAL(vi, bitfile_read_int(bf,3), truevals);
//CHECKVAL(vi, bitfile_read_int(bf,3), truevals);
bitfile_skip(bf, 16); vi += 3;
CHECKVAL(vi, bitfile_read_int(bf,16), truevals);
//CHECKVAL(vi, bitfile_read_int(bf,30), truevals);
bitfile_skip(bf, 30); vi += 1;
for (i = 0; i < 64; i++) {
CHECKVAL(vi, bitfile_read_unary(bf), truevals);
}
for (i = 0; i < 64; i++) {
int n = 1, v;
if ((i+n)<(64-1)) { bitfile_skip_gammas(bf,n); i+=n; vi+=n; }
v = bitfile_read_gamma(bf); // printf("vi = %4i; v = %5i\n", vi, v);
CHECKVAL(vi, v, truevals);
}
for (i = 0; i < 64; i++) {
CHECKVAL(vi, bitfile_read_zeta(bf,3), truevals);
}
return (vi);
}
static int run_test(const char *aliases, const char *nodes, const char *expect)
{
int list[MAX_NODES];
const char *s;
void *blob;
int i;
blob = malloc(FDT_SIZE);
if (!blob) {
printf("%s: out of memory\n", __func__);
return 1;
}
printf("aliases=%s, nodes=%s, expect=%s: ", aliases, nodes, expect);
CHECKVAL(make_fdt(blob, FDT_SIZE, aliases, nodes), 0);
CHECKVAL(fdtdec_find_aliases_for_id(blob, "i2c",
COMPAT_UNKNOWN,
list, ARRAY_SIZE(list)), strlen(expect));
/* Check we got the right ones */
for (i = 0, s = expect; *s; s++, i++) {
int want = *s;
const char *name;
int got = ' ';
name = list[i] ? fdt_get_name(blob, list[i], NULL) : NULL;
if (name)
got = name[3] + 'a' - '0';
if (got != want) {
printf("Position %d: Expected '%c', got '%c' ('%s')\n",
i, want, got, name);
return 1;
}
}
printf("pass\n");
return 0;
}
int test_read_1(bitfile *bf, int* truevals)
{
int i, vi=0;
CHECKVAL(vi, bitfile_read_int(bf,10), truevals);
CHECKVAL(vi, bitfile_read_int(bf,3), truevals);
CHECKVAL(vi, bitfile_read_int(bf,3), truevals);
CHECKVAL(vi, bitfile_read_int(bf,16), truevals);
CHECKVAL(vi, bitfile_read_int(bf,30), truevals);
for (i = 0; i < 64; i++) {
CHECKVAL(vi, bitfile_read_unary(bf), truevals);
}
for (i = 0; i < 64; i++) {
CHECKVAL(vi, bitfile_read_gamma(bf), truevals);
}
for (i = 0; i < 64; i++) {
CHECKVAL(vi, bitfile_read_zeta(bf,3), truevals);
}
return (vi);
}
int
main(int argc, char **argv)
{
/* Command-line parsing variables. */
int arg; /* command-line argument counter */
static LALStatus stat; /* status structure */
CHAR *sourcefile = NULL; /* name of sourcefile */
CHAR *respfile = NULL; /* name of respfile */
CHAR *infile = NULL; /* name of infile */
CHAR *outfile = NULL; /* name of outfile */
INT4 seed = 0; /* random number seed */
INT4 sec = SEC; /* ouput epoch.gpsSeconds */
INT4 nsec = NSEC; /* ouput epoch.gpsNanoSeconds */
INT4 npt = NPT; /* number of output points */
REAL8 dt = DT; /* output sampling interval */
REAL4 sigma = SIGMA; /* noise amplitude */
/* File reading variables. */
FILE *fp = NULL; /* generic file pointer */
BOOLEAN ok = 1; /* whether input format is correct */
UINT4 i; /* generic index over file lines */
INT8 epoch; /* epoch stored as an INT8 */
/* Other global variables. */
RandomParams *params = NULL; /* parameters of pseudorandom sequence */
DetectorResponse detector; /* the detector in question */
INT2TimeSeries output; /* detector ACD output */
/*******************************************************************
* PARSE ARGUMENTS (arg stores the current position) *
*******************************************************************/
/* Exit gracefully if no arguments were given.
if ( argc <= 1 ) {
INFO( "No testing done." );
return 0;
} */
arg = 1;
while ( arg < argc ) {
/* Parse source file option. */
if ( !strcmp( argv[arg], "-s" ) ) {
if ( argc > arg + 1 ) {
arg++;
sourcefile = argv[arg++];
}else{
ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BASICINJECTTESTC_EARG;
}
}
/* Parse response file option. */
else if ( !strcmp( argv[arg], "-r" ) ) {
if ( argc > arg + 1 ) {
arg++;
respfile = argv[arg++];
}else{
ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BASICINJECTTESTC_EARG;
}
}
/* Parse input file option. */
else if ( !strcmp( argv[arg], "-i" ) ) {
if ( argc > arg + 1 ) {
arg++;
infile = argv[arg++];
}else{
ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BASICINJECTTESTC_EARG;
}
}
/* Parse noise output option. */
else if ( !strcmp( argv[arg], "-n" ) ) {
if ( argc > arg + 5 ) {
arg++;
sec = atoi( argv[arg++] );
nsec = atoi( argv[arg++] );
npt = atoi( argv[arg++] );
dt = atof( argv[arg++] );
sigma = atof( argv[arg++] );
}else{
ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BASICINJECTTESTC_EARG;
}
}
/* Parse output file option. */
else if ( !strcmp( argv[arg], "-o" ) ) {
if ( argc > arg + 1 ) {
arg++;
outfile = argv[arg++];
}else{
ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BASICINJECTTESTC_EARG;
}
}
/* Parse debug level option. */
else if ( !strcmp( argv[arg], "-d" ) ) {
if ( argc > arg + 1 ) {
arg++;
}else{
ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BASICINJECTTESTC_EARG;
}
}
/* Parse random seed option. */
else if ( !strcmp( argv[arg], "-e" ) ) {
if ( argc > arg + 1 ) {
arg++;
seed = atoi( argv[arg++] );
}else{
ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BASICINJECTTESTC_EARG;
}
}
/* Check for unrecognized options. */
else if ( argv[arg][0] == '-' ) {
ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BASICINJECTTESTC_EARG;
}
} /* End of argument parsing loop. */
/* Check for redundant or bad argument values. */
CHECKVAL( npt, 0, 2147483647 );
CHECKVAL( dt, 0, LAL_REAL4_MAX );
/*******************************************************************
* SETUP *
*******************************************************************/
/* Set up output, detector, and random parameter structures. */
output.data = NULL;
detector.transfer = (COMPLEX8FrequencySeries *)
LALMalloc( sizeof(COMPLEX8FrequencySeries) );
if ( !(detector.transfer) ) {
ERROR( BASICINJECTTESTC_EMEM, BASICINJECTTESTC_MSGEMEM, 0 );
return BASICINJECTTESTC_EMEM;
}
detector.transfer->data = NULL;
detector.site = NULL;
SUB( LALCreateRandomParams( &stat, ¶ms, seed ), &stat );
/* Set up units. */
output.sampleUnits = lalADCCountUnit;
if (XLALUnitDivide( &(detector.transfer->sampleUnits),
&lalADCCountUnit, &lalStrainUnit ) == NULL) {
return LAL_EXLAL;
}
/* Read response function. */
if ( respfile ) {
REAL4VectorSequence *resp = NULL; /* response as vector sequence */
COMPLEX8Vector *response = NULL; /* response as complex vector */
COMPLEX8Vector *unity = NULL; /* vector of complex 1's */
if ( ( fp = fopen( respfile, "r" ) ) == NULL ) {
ERROR( BASICINJECTTESTC_EFILE, BASICINJECTTESTC_MSGEFILE,
respfile );
return BASICINJECTTESTC_EFILE;
}
/* Read header. */
ok &= ( fscanf( fp, "# epoch = %" LAL_INT8_FORMAT "\n", &epoch ) == 1 );
I8ToLIGOTimeGPS( &( detector.transfer->epoch ), epoch );
ok &= ( fscanf( fp, "# f0 = %lf\n", &( detector.transfer->f0 ) )
== 1 );
ok &= ( fscanf( fp, "# deltaF = %lf\n",
&( detector.transfer->deltaF ) ) == 1 );
if ( !ok ) {
ERROR( BASICINJECTTESTC_EINPUT, BASICINJECTTESTC_MSGEINPUT,
respfile );
return BASICINJECTTESTC_EINPUT;
}
/* Read and convert body to a COMPLEX8Vector. */
SUB( LALSReadVectorSequence( &stat, &resp, fp ), &stat );
fclose( fp );
if ( resp->vectorLength != 2 ) {
ERROR( BASICINJECTTESTC_EINPUT, BASICINJECTTESTC_MSGEINPUT,
respfile );
return BASICINJECTTESTC_EINPUT;
}
SUB( LALCCreateVector( &stat, &response, resp->length ), &stat );
memcpy( response->data, resp->data, 2*resp->length*sizeof(REAL4) );
SUB( LALSDestroyVectorSequence( &stat, &resp ), &stat );
/* Convert response function to a transfer function. */
SUB( LALCCreateVector( &stat, &unity, response->length ), &stat );
for ( i = 0; i < response->length; i++ ) {
unity->data[i] = 1.0;
}
SUB( LALCCreateVector( &stat, &( detector.transfer->data ),
response->length ), &stat );
SUB( LALCCVectorDivide( &stat, detector.transfer->data, unity,
response ), &stat );
SUB( LALCDestroyVector( &stat, &response ), &stat );
SUB( LALCDestroyVector( &stat, &unity ), &stat );
}
/* No response file, so generate a unit response. */
else {
I8ToLIGOTimeGPS( &( detector.transfer->epoch ), EPOCH );
detector.transfer->f0 = 0.0;
detector.transfer->deltaF = 1.5*FSTOP;
SUB( LALCCreateVector( &stat, &( detector.transfer->data ), 2 ),
&stat );
detector.transfer->data->data[0] = 1.0;
detector.transfer->data->data[1] = 1.0;
}
/* Read input data. */
if ( infile ) {
REAL4VectorSequence *input = NULL; /* input as vector sequence */
if ( ( fp = fopen( infile, "r" ) ) == NULL ) {
ERROR( BASICINJECTTESTC_EFILE, BASICINJECTTESTC_MSGEFILE,
infile );
return BASICINJECTTESTC_EFILE;
}
/* Read header. */
ok &= ( fscanf( fp, "# epoch = %" LAL_INT8_FORMAT "\n", &epoch ) == 1 );
I8ToLIGOTimeGPS( &( output.epoch ), epoch );
ok &= ( fscanf( fp, "# deltaT = %lf\n", &( output.deltaT ) )
== 1 );
if ( !ok ) {
ERROR( BASICINJECTTESTC_EINPUT, BASICINJECTTESTC_MSGEINPUT,
infile );
return BASICINJECTTESTC_EINPUT;
}
/* Read and convert body. */
SUB( LALSReadVectorSequence( &stat, &input, fp ), &stat );
fclose( fp );
if ( input->vectorLength != 1 ) {
ERROR( BASICINJECTTESTC_EINPUT, BASICINJECTTESTC_MSGEINPUT,
infile );
return BASICINJECTTESTC_EINPUT;
}
SUB( LALI2CreateVector( &stat, &( output.data ), input->length ),
&stat );
for ( i = 0; i < input->length; i++ )
output.data->data[i] = (INT2)( input->data[i] );
SUB( LALSDestroyVectorSequence( &stat, &input ), &stat );
}
/* No input file, so generate one randomly. */
else {
output.epoch.gpsSeconds = sec;
output.epoch.gpsNanoSeconds = nsec;
output.deltaT = dt;
SUB( LALI2CreateVector( &stat, &( output.data ), npt ), &stat );
if ( sigma == 0 ) {
memset( output.data->data, 0, npt*sizeof(INT2) );
} else {
REAL4Vector *deviates = NULL; /* unit Gaussian deviates */
SUB( LALSCreateVector( &stat, &deviates, npt ), &stat );
SUB( LALNormalDeviates( &stat, deviates, params ), &stat );
for ( i = 0; i < (UINT4)( npt ); i++ )
output.data->data[i] = (INT2)
floor( sigma*deviates->data[i] + 0.5 );
SUB( LALSDestroyVector( &stat, &deviates ), &stat );
}
}
/*******************************************************************
* INJECTION *
*******************************************************************/
/* Open sourcefile. */
if ( sourcefile ) {
if ( ( fp = fopen( sourcefile, "r" ) ) == NULL ) {
ERROR( BASICINJECTTESTC_EFILE, BASICINJECTTESTC_MSGEFILE,
sourcefile );
return BASICINJECTTESTC_EFILE;
}
}
/* For each line in the sourcefile... */
while ( ok ) {
PPNParamStruc ppnParams; /* wave generation parameters */
REAL4 m1, m2, dist, inc, phic; /* unconverted parameters */
CoherentGW waveform; /* amplitude and phase structure */
REAL4TimeSeries signalvec; /* GW signal */
REAL8 time; /* length of GW signal */
CHAR timeCode; /* code for signal time alignment */
CHAR message[MSGLEN]; /* warning/info messages */
/* Read and convert input line. */
if ( sourcefile ) {
ok &= ( fscanf( fp, "%c %" LAL_INT8_FORMAT " %f %f %f %f %f\n", &timeCode,
&epoch, &m1, &m2, &dist, &inc, &phic ) == 7 );
ppnParams.mTot = m1 + m2;
ppnParams.eta = m1*m2/( ppnParams.mTot*ppnParams.mTot );
ppnParams.d = dist*LAL_PC_SI*1000.0;
ppnParams.inc = inc*LAL_PI/180.0;
ppnParams.phi = phic*LAL_PI/180.0;
} else {
timeCode = 'i';
ppnParams.mTot = M1 + M2;
ppnParams.eta = M1*M2/( ppnParams.mTot*ppnParams.mTot );
ppnParams.d = DIST;
ppnParams.inc = INC;
ppnParams.phi = PHIC;
epoch = EPOCH;
}
if ( ok ) {
/* Set up other parameter structures. */
ppnParams.epoch.gpsSeconds = ppnParams.epoch.gpsNanoSeconds = 0;
ppnParams.position.latitude = ppnParams.position.longitude = 0.0;
ppnParams.position.system = COORDINATESYSTEM_EQUATORIAL;
ppnParams.psi = 0.0;
ppnParams.fStartIn = FSTART;
ppnParams.fStopIn = FSTOP;
ppnParams.lengthIn = 0;
ppnParams.ppn = NULL;
ppnParams.deltaT = DELTAT;
memset( &waveform, 0, sizeof(CoherentGW) );
/* Generate waveform at zero epoch. */
SUB( LALGeneratePPNInspiral( &stat, &waveform, &ppnParams ),
&stat );
snprintf( message, MSGLEN, "%d: %s", ppnParams.termCode,
ppnParams.termDescription );
INFO( message );
if ( ppnParams.dfdt > 2.0 ) {
snprintf( message, MSGLEN,
"Waveform sampling interval is too large:\n"
"\tmaximum df*dt = %f", ppnParams.dfdt );
WARNING( message );
}
/* Compute epoch for waveform. */
time = waveform.a->data->length*DELTAT;
if ( timeCode == 'f' )
epoch -= (INT8)( 1000000000.0*time );
else if ( timeCode == 'c' )
epoch -= (INT8)( 1000000000.0*ppnParams.tc );
I8ToLIGOTimeGPS( &( waveform.a->epoch ), epoch );
waveform.f->epoch = waveform.phi->epoch = waveform.a->epoch;
/* Generate and inject signal. */
signalvec.epoch = waveform.a->epoch;
signalvec.epoch.gpsSeconds -= 1;
signalvec.deltaT = output.deltaT/4.0;
signalvec.f0 = 0;
signalvec.data = NULL;
time = ( time + 2.0 )/signalvec.deltaT;
SUB( LALSCreateVector( &stat, &( signalvec.data ), (UINT4)time ),
&stat );
SUB( LALSimulateCoherentGW( &stat, &signalvec, &waveform,
&detector ), &stat );
SUB( LALSI2InjectTimeSeries( &stat, &output, &signalvec, params ),
&stat );
SUB( LALSDestroyVectorSequence( &stat, &( waveform.a->data ) ),
&stat );
SUB( LALSDestroyVector( &stat, &( waveform.f->data ) ), &stat );
SUB( LALDDestroyVector( &stat, &( waveform.phi->data ) ), &stat );
LALFree( waveform.a );
LALFree( waveform.f );
LALFree( waveform.phi );
SUB( LALSDestroyVector( &stat, &( signalvec.data ) ), &stat );
}
/* If there is no source file, inject only one source. */
if ( !sourcefile )
ok = 0;
}
/* Input file is exhausted (or has a badly-formatted line ). */
if ( sourcefile )
fclose( fp );
/*******************************************************************
* CLEANUP *
*******************************************************************/
/* Print output file. */
if ( outfile ) {
if ( ( fp = fopen( outfile, "w" ) ) == NULL ) {
ERROR( BASICINJECTTESTC_EFILE, BASICINJECTTESTC_MSGEFILE,
outfile );
return BASICINJECTTESTC_EFILE;
}
epoch = 1000000000LL*(INT8)( output.epoch.gpsSeconds );
epoch += (INT8)( output.epoch.gpsNanoSeconds );
fprintf( fp, "# epoch = %" LAL_INT8_FORMAT "\n", epoch );
fprintf( fp, "# deltaT = %23.16e\n", output.deltaT );
for ( i = 0; i < output.data->length; i++ )
fprintf( fp, "%8.1f\n", (REAL4)( output.data->data[i] ) );
fclose( fp );
}
/* Destroy remaining memory. */
SUB( LALDestroyRandomParams( &stat, ¶ms ), &stat );
SUB( LALI2DestroyVector( &stat, &( output.data ) ), &stat );
SUB( LALCDestroyVector( &stat, &( detector.transfer->data ) ),
&stat );
LALFree( detector.transfer );
/* Done! */
LALCheckMemoryLeaks();
INFO( BASICINJECTTESTC_MSGENORM );
return BASICINJECTTESTC_ENORM;
}
int
main(int argc, char **argv)
{
/* Variables for parsing command-line arguments. */
INT4 arg; /* argument list counter */
CHAR *metricfile = NULL; /* metric output filename */
CHAR *rangefile = NULL; /* parameter range output filename */
UINT4 n = NSTACKS; /* number of stacks */
REAL8 dt = STACKLENGTH; /* length of each stack (s) */
REAL8 t0 = STARTTIME; /* start time of first stack (GPS s) */
REAL8 f0 = FREQUENCY; /* maximum frequency of search */
REAL8 lat = LATITUDE; /* latitude of detector (degrees N) */
REAL8 lon = LONGITUDE; /* longitude of detector (degrees E) */
REAL8 ra[2], dec[2]; /* RA and dec ranges (degrees) */
/* Other variables. */
UINT4 i, j, k; /* indecies */
UINT4 nRA, nDec; /* sizes of metric grid in RA and dec */
REAL8 dRA, dDec; /* grid intervals in RA and dec */
UINT4 warnings = 0; /* points with large uncertainties */
UINT4 errors = 0; /* points with bad metrics */
static LALStatus stat; /* top-level status structure */
static LIGOTimeGPS start; /* GPS start time of first stack */
REAL4Grid *metricGrid = NULL; /* grid of metric values */
REAL4 *gData; /* pointer to metricGrid->data->data */
REAL4Grid *rangeGrid = NULL; /* grid of range delimiters */
REAL4 *rData; /* pointer to rangeGrid->data->data */
REAL4 propVol = 0.0; /* average proper volume element */
UINT4 nVol = 0; /* number of points used in average */
UINT4Vector *dimLength = NULL; /* used to allocate metricGrid */
REAL8Vector *lambda = NULL; /* metric parameter space vector */
REAL8Vector *metric = NULL; /* metric components */
REAL8 *mData; /* pointer to metric->data */
INT4 *topRange, *botRange; /* preliminary grid range limits */
INT4 *topRange2, *botRange2; /* adjusted grid range limits */
static MetricParamStruc params; /* metric computation parameters */
static PulsarTimesParamStruc baryParams; /* barycentring parameters */
/* Some more initializations. */
ra[0] = RA_MIN; dec[0] = DEC_MIN;
ra[1] = RA_MAX; dec[1] = DEC_MAX;
/******************************************************************
* ARGUMENT PARSING *
******************************************************************/
/* Parse argument list. arg stores the current position. */
arg = 1;
while ( arg < argc ) {
/* Parse output file option. */
if ( !strcmp( argv[arg], "-o" ) ) {
if ( argc > arg + 2 ) {
arg++;
metricfile = argv[arg++];
rangefile = argv[arg++];
} else {
ERROR( SKYMETRICTESTC_EARG, SKYMETRICTESTC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return SKYMETRICTESTC_EARG;
}
}
/* Parse search parameter option. */
else if ( !strcmp( argv[arg], "-p" ) ) {
if ( argc > arg + 4 ) {
arg++;
n = atoi( argv[arg++] );
dt = atof( argv[arg++] );
t0 = atof( argv[arg++] );
f0 = atof( argv[arg++] );
} else {
ERROR( SKYMETRICTESTC_EARG, SKYMETRICTESTC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return SKYMETRICTESTC_EARG;
}
}
/* Parse detector position option. */
else if ( !strcmp( argv[arg], "-l" ) ) {
if ( argc > arg + 2 ) {
arg++;
lat = atof( argv[arg++] );
lon = atof( argv[arg++] );
} else {
ERROR( SKYMETRICTESTC_EARG, SKYMETRICTESTC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return SKYMETRICTESTC_EARG;
}
}
/* Parse parameter space range option. */
else if ( !strcmp( argv[arg], "-r" ) ) {
if ( argc > arg + 4 ) {
arg++;
ra[0] = atof( argv[arg++] );
ra[1] = atof( argv[arg++] );
dec[0] = atof( argv[arg++] );
dec[1] = atof( argv[arg++] );
} else {
ERROR( SKYMETRICTESTC_EARG, SKYMETRICTESTC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return SKYMETRICTESTC_EARG;
}
}
/* Parse debug level option. */
else if ( !strcmp( argv[arg], "-d" ) ) {
if ( argc > arg + 1 ) {
arg++;
} else {
ERROR( SKYMETRICTESTC_EARG, SKYMETRICTESTC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return SKYMETRICTESTC_EARG;
}
}
/* Check for unrecognized options. */
else if ( argv[arg][0] == '-' ) {
ERROR( SKYMETRICTESTC_EARG, SKYMETRICTESTC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return SKYMETRICTESTC_EARG;
}
} /* End of argument parsing loop. */
/* Do error trapping on input parameters. */
if ( lalDebugLevel & LALERROR ) {
CHECKVAL( n, 0, NMAX );
CHECKVAL( f0, 0.0, F0MAX );
CHECKVAL( dt, 1.0/f0, DTMAX );
CHECKVAL( lat, -90.0, 90.0 );
CHECKVAL( lon, -360.0, 360.0 );
}
/******************************************************************
* METRIC COMPUTATION *
******************************************************************/
/* Set up start time. */
start.gpsSeconds = (INT4)t0;
start.gpsNanoSeconds = (INT4)( 1.0e9*( t0 - start.gpsSeconds ) );
t0 = 0.0;
/* Set up constant parameters for barycentre transformation. */
baryParams.epoch = start;
baryParams.latitude = LAL_PI_180*lat;
baryParams.longitude = LAL_PI_180*lon;
SUB( LALGetEarthTimes( &stat, &baryParams ), &stat );
/* Set up constant parameters for metric calculation. */
params.dtCanon = LALDTBaryPtolemaic;
params.constants = &baryParams;
params.start = t0;
params.deltaT = dt;
params.n = n;
params.errors = 1;
/* Set up the metric vector, metric grid, and parameter vector. */
if ( params.errors )
SUB( LALDCreateVector( &stat, &metric, 12 ), &stat );
else
SUB( LALDCreateVector( &stat, &metric, 6 ), &stat );
mData = metric->data;
SUB( LALU4CreateVector( &stat, &dimLength, 3 ), &stat );
nRA = (UINT4)( ( ra[1] - ra[0] )/SPACING ) + 2;
nDec = (UINT4)( ( dec[1] - dec[0] )/SPACING ) + 2;
dimLength->data[0] = nDec;
dimLength->data[1] = nRA;
dimLength->data[2] = 3;
SUB( LALSCreateGrid( &stat, &metricGrid, dimLength, 2 ), &stat );
SUB( LALU4DestroyVector( &stat, &dimLength ), &stat );
metricGrid->offset->data[0] = dec[0];
metricGrid->offset->data[1] = ra[0];
metricGrid->interval->data[0] = dDec = ( dec[1] - dec[0] )/( nDec - 1.0 );
metricGrid->interval->data[1] = dRA = ( ra[1] - ra[0] )/( nRA - 1.0 );
gData = metricGrid->data->data;
SUB( LALDCreateVector( &stat, &lambda, 3 ), &stat );
lambda->data[0] = f0;
/* Set up preliminary range delimiters. */
topRange = (INT4 *)LALMalloc( nRA*sizeof( INT4 ) );
botRange = (INT4 *)LALMalloc( nRA*sizeof( INT4 ) );
if ( !topRange || !botRange ) {
ERROR( SKYMETRICTESTC_EMEM, SKYMETRICTESTC_MSGEMEM, 0 );
return SKYMETRICTESTC_EMEM;
}
for ( i = 0; i < nRA; i++ ) {
topRange[i] = 0;
botRange[i] = nRA;
}
/* Fill the metric grid with the projected metric. */
k = 0;
fprintf( stdout, "Computing metric on %ix%i grid:\n", nDec, nRA );
for ( i = 0; i < nDec; i++ ) {
BOOLEAN bottom = 1, top = 0; /* whether we're at the bottom or top
of the grid column */
lambda->data[2] = LAL_PI_180*( dec[0] + i*dDec );
for ( j = 0; j < nRA; j++ ) {
if ( top )
fprintf( stdout, "o" );
else {
REAL4 gxx, gyy, gxy; /* metric components */
lambda->data[1] = LAL_PI_180*( ra[0] + j*dRA );
SUB( LALStackMetric( &stat, metric, lambda, ¶ms ), &stat );
SUB( LALProjectMetric( &stat, metric, params.errors ), &stat );
/* If uncertainties are given, generate conservative metric. */
if ( params.errors ) {
INT2 sign = 1; /* sign of xy metric component */
gxx = mData[10] + mData[11];
gyy = mData[4] + mData[5];
gxy = mData[8];
if ( gxy < 0.0 )
sign = -1;
if ( fabs( gxy ) <= fabs( mData[9] ) )
gxy = 0.0;
else
gxy = sign*( fabs( gxy ) - fabs( mData[9] ) );
if ( gxx < 0.0 || gyy < 0.0 || gxx*gyy - gxy*gxy < 0.0 ) {
errors++;
fprintf( stdout, "o" );
} else if ( fabs( mData[4]*mData[11] ) +
fabs( mData[5]*mData[10] ) +
fabs( mData[8]*mData[9] )*2.0 >=
mData[4]*mData[10] - mData[8]*mData[8] ) {
warnings++;
fprintf( stdout, "*" );
} else
fprintf( stdout, "+" );
}
/* If uncertainties are not given, just use best estimate. */
else {
gxx = mData[5];
gxy = mData[4];
gyy = mData[2];
if ( gxx < 0.0 || gyy < 0.0 || gxx*gyy - gxy*gxy < 0.0 ) {
errors++;
fprintf( stdout, "o" );
} else
fprintf( stdout, "+" );
}
/* See whether we've crossed a range boundary. */
if ( gxx > 0.0 && gyy > 0.0 && gxx*gyy - gxy*gxy > 0.0 ) {
if ( bottom ) {
bottom = 0;
botRange[i] = j - 1;
}
propVol += LAL_PI_180*LAL_PI_180*sqrt( gxx*gyy - gxy*gxy );
nVol++;
} else {
if ( !bottom ) {
top = 1;
topRange[i] = j;
}
}
*(gData++) = LAL_PI_180*LAL_PI_180*gxx;
*(gData++) = LAL_PI_180*LAL_PI_180*gyy;
*(gData++) = LAL_PI_180*LAL_PI_180*gxy;
}
fflush( stdout );
}
if ( !top )
topRange[i] = j;
fprintf( stdout, "\n" );
}
/* Free memory that's no longer needed. */
SUB( LALDDestroyVector( &stat, &metric ), &stat );
SUB( LALDDestroyVector( &stat, &lambda ), &stat );
/* Warn if any points had bad values or large uncertainties. */
if ( errors ) {
CHAR msg[MSGLEN];
snprintf( msg, MSGLEN, "%i of %i points had"
" non-positive-definite metric", warnings,
nRA*nDec );
WARNING( msg );
}
if ( warnings ) {
CHAR msg[MSGLEN];
snprintf( msg, MSGLEN, "%i of %i points had metric component"
" errors larger than values", warnings, nRA*nDec );
WARNING( msg );
}
/* Write the proper volume element. */
fprintf( stdout, "Average proper volume element: %10.3e per square"
" degree\n", propVol /= nVol );
/******************************************************************
* RANGE COMPUTATION *
******************************************************************/
/* Each bad metric point affects the four squares adjoining it, so
top and bottom ranges need to be adjusted down or up one point
based on the adjoining columns. */
topRange2 = (INT4 *)LALMalloc( nDec*sizeof(INT4) );
botRange2 = (INT4 *)LALMalloc( nDec*sizeof(INT4) );
if ( !topRange2 || !botRange2 ) {
ERROR( SKYMETRICTESTC_EMEM, SKYMETRICTESTC_MSGEMEM, 0 );
return SKYMETRICTESTC_EMEM;
}
topRange2[0] = topRange[1] < topRange[0] ?
topRange[1] - 1 : topRange[0] - 1;
botRange2[0] = botRange[1] > botRange[0] ?
botRange[1] + 1 : botRange[0] + 1;
topRange2[nDec-1] = topRange[nDec] < topRange[nDec-1] ?
topRange[nDec] - 1 : topRange[nDec-1] - 1;
botRange2[nDec-1] = botRange[nDec] > botRange[nDec-1] ?
botRange[nDec] + 1 : botRange[nDec-1] + 1;
for ( i = 1; i < nDec - 1; i++ ) {
INT4 topMin = topRange[i-1], botMax = botRange[i-1];
if ( topRange[i] < topMin )
topMin = topRange[i];
if ( topRange[i+1] < topMin )
topMin = topRange[i+1];
if ( botRange[i] > botMax )
botMax = botRange[i];
if ( botRange[i+1] > botMax )
botMax = botRange[i+1];
topRange2[i] = topMin - 1;
botRange2[i] = botMax + 1;
}
LALFree( topRange );
LALFree( botRange );
/* Determine the contiguous domain with open range intervals. */
if ( topRange2[0] > botRange2[0] && topRange2[1] > botRange2[1] )
i = 0;
else {
i = 1;
while ( i < nDec - 1 && topRange2[i] <= botRange2[i] &&
topRange2[i+1] <= botRange2[i+1] )
i++;
}
j = i;
while ( j < nDec - 1 && topRange2[j+1] > botRange2[j+1] )
j++;
if ( j == i ) {
ERROR( SKYMETRICTESTC_ERNG, SKYMETRICTESTC_MSGERNG, 0 );
return SKYMETRICTESTC_ERNG;
}
/* Set up range grid. */
j = j - i + 1;
SUB( LALU4CreateVector( &stat, &dimLength, 2 ), &stat );
dimLength->data[0] = j;
dimLength->data[1] = 2;
SUB( LALSCreateGrid( &stat, &rangeGrid, dimLength, 1 ), &stat );
SUB( LALU4DestroyVector( &stat, &dimLength ), &stat );
rangeGrid->offset->data[0] = dec[0] + i*dDec;
rangeGrid->interval->data[0] = dDec;
rData = rangeGrid->data->data;
nVol = 0;
for ( k = 0; k < j; k++ ) {
*(rData++) = ra[0] + botRange2[k]*dRA;
*(rData++) = ra[0] + topRange2[k]*dRA;
nVol += topRange2[k] - botRange2[k] - 1;
}
nVol -= topRange2[j-1] - botRange2[j-1] - 1;
LALFree( topRange2 );
LALFree( botRange2 );
/* Write the total proper volume of the covered range. */
fprintf( stdout, "Total proper volume: %10.3e\n",
propVol*nVol*dRA*dDec );
/******************************************************************
* FINISH *
******************************************************************/
/* Write the output files, if requested. */
if ( metricfile ) {
FILE *fp = fopen( metricfile, "w" ); /* output file pointer */
if ( !fp ) {
ERROR( SKYMETRICTESTC_EFILE, "- " SKYMETRICTESTC_MSGEFILE,
metricfile );
return SKYMETRICTESTC_EFILE;
}
SUB( LALSWriteGrid( &stat, fp, metricGrid ), &stat );
fclose( fp );
}
if ( rangefile ) {
FILE *fp = fopen( rangefile, "w" ); /* output file pointer */
if ( !fp ) {
ERROR( SKYMETRICTESTC_EFILE, "- " SKYMETRICTESTC_MSGEFILE,
rangefile );
return SKYMETRICTESTC_EFILE;
}
SUB( LALSWriteGrid( &stat, fp, rangeGrid ), &stat );
fclose( fp );
}
/* Clean up and exit. */
SUB( LALSDestroyGrid( &stat, &metricGrid ), &stat );
SUB( LALSDestroyGrid( &stat, &rangeGrid ), &stat );
LALCheckMemoryLeaks();
INFO( SKYMETRICTESTC_MSGENORM );
return SKYMETRICTESTC_ENORM;
}
int test_position_1(bitfile* bf, int* truevals)
{
int i, off=0, vi=0;
CHECKVAL(vi, bitfile_read_int(bf,10), truevals);
CHECKVAL(vi, bitfile_read_int(bf,3), truevals);
CHECKVAL(vi, bitfile_read_int(bf,3), truevals);
CHECKVAL(vi, bitfile_read_int(bf,16), truevals);
CHECKVAL(vi, bitfile_read_int(bf,30), truevals);
for (i = 0; i < 64; i++) {
// each unary takes (i+1) bytes, so we just always position the stream
bitfile_position(bf, 62+off); off+=(i+1);
CHECKVAL(vi, bitfile_read_unary(bf), truevals);
}
// reset the stream
bitfile_position(bf, 0);
vi=0;
CHECKVAL(vi, bitfile_read_int(bf,10), truevals);
CHECKVAL(vi, bitfile_read_int(bf,3), truevals);
CHECKVAL(vi, bitfile_read_int(bf,3), truevals);
CHECKVAL(vi, bitfile_read_int(bf,16), truevals);
CHECKVAL(vi, bitfile_read_int(bf,30), truevals);
// position after all the unary values
bitfile_position(bf,62+off);
vi += 64;
for (i = 0; i < 64; i++) {
CHECKVAL(vi, bitfile_read_gamma(bf), truevals);
}
for (i = 0; i < 64; i++) {
CHECKVAL(vi, bitfile_read_zeta(bf,3), truevals);
}
return (vi);
}
