static int __init__(PyObject *self, PyObject *args, PyObject *kwds)
{
LIGOTimeGPS *gps = &((pylal_LIGOTimeGPS *) self)->gps;
PyObject *seconds;
long long nanoseconds = 0;
if(!PyArg_ParseTuple(args, "O|L", &seconds, &nanoseconds))
return -1;
if(PyUnicode_Check(seconds)) {
/* convert to ascii string */
PyObject *str = PyUnicode_AsASCIIString(seconds);
if(!str)
return -1;
seconds = str;
}
if(PyString_Check(seconds)) {
char *end, *str = PyString_AsString(seconds);
int result = XLALStrToGPS(gps, str, &end);
if((result < 0) || (end == str)) {
PyErr_SetObject(PyExc_ValueError, seconds);
return -1;
}
} else if(!pyobject_to_ligotimegps(seconds, gps)) {
PyErr_SetObject(PyExc_ValueError, seconds);
return -1;
}
XLALINT8NSToGPS(gps, XLALGPSToINT8NS(gps) + nanoseconds);
return 0;
}
static int runtest(const struct TESTCASE *testcase)
{
int retval;
LIGOTimeGPS gps;
LIGOTimeGPS gpsCorrect;
char *endptr;
int failure = 0;
XLALGPSSet(&gpsCorrect, testcase->sec, testcase->ns);
XLALClearErrno();
retval = XLALStrToGPS(&gps, testcase->string, &endptr);
if(retval == 0 && testcase->xlal_errno == 0) {
if(XLALGPSCmp(&gps, &gpsCorrect) || strcmp(endptr, testcase->remainder))
failure = 1;
} else if(XLALGetBaseErrno() != testcase->xlal_errno)
failure = 1;
if(lalDebugLevel || failure)
fprintf(stdout, "Input = \"%s\"\n\tOutput =\t%" LAL_INT8_FORMAT " ns with \"%s\" remainder, errno %d\n\tCorrect =\t%" LAL_INT8_FORMAT " ns with \"%s\" remainder, errno %d\n\t\t===> %s\n", testcase->string, XLALGPSToINT8NS(&gps), endptr, XLALGetBaseErrno(), XLALGPSToINT8NS(&gpsCorrect), testcase->remainder, testcase->xlal_errno, failure ? "*** FAIL ***" : "Pass");
return failure;
}
static struct options parse_command_line(int *argc, char **argv[], const ProcessTable *process, ProcessParamsTable **paramaddpoint)
{
struct options options = options_defaults();
int c;
int option_index;
struct LALoption long_options[] = {
{"gps-end-time", required_argument, NULL, 'A'},
{"gps-start-time", required_argument, NULL, 'B'},
{"help", no_argument, NULL, 'C'},
{"max-amplitude", required_argument, NULL, 'D'},
{"min-amplitude", required_argument, NULL, 'E'},
{"max-bandwidth", required_argument, NULL, 'F'},
{"min-bandwidth", required_argument, NULL, 'G'},
{"max-duration", required_argument, NULL, 'H'},
{"min-duration", required_argument, NULL, 'I'},
{"max-e-over-r2", required_argument, NULL, 'S'},
{"min-e-over-r2", required_argument, NULL, 'T'},
{"max-frequency", required_argument, NULL, 'J'},
{"min-frequency", required_argument, NULL, 'K'},
{"max-hrss", required_argument, NULL, 'L'},
{"min-hrss", required_argument, NULL, 'M'},
{"output", required_argument, NULL, 'V'},
{"population", required_argument, NULL, 'N'},
{"q", required_argument, NULL, 'O'},
{"ra-dec", required_argument, NULL, 'U'},
{"seed", required_argument, NULL, 'P'},
{"time-step", required_argument, NULL, 'Q'},
{"time-slide-file", required_argument, NULL, 'W'},
{"jitter", required_argument, NULL, 'X'},
{"user-tag", required_argument, NULL, 'R'},
{NULL, 0, NULL, 0}
};
do switch(c = LALgetopt_long(*argc, *argv, "", long_options, &option_index)) {
case 'A':
XLALClearErrno();
{
LIGOTimeGPS tmp;
XLALStrToGPS(&tmp, LALoptarg, NULL);
options.gps_end_time = XLALGPSToINT8NS(&tmp);
}
if(xlalErrno) {
fprintf(stderr, "invalid --%s (%s specified)\n", long_options[option_index].name, LALoptarg);
exit(1);
}
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'B':
XLALClearErrno();
{
LIGOTimeGPS tmp;
XLALStrToGPS(&tmp, LALoptarg, NULL);
options.gps_start_time = XLALGPSToINT8NS(&tmp);
}
if(xlalErrno) {
fprintf(stderr, "invalid --%s (%s specified)\n", long_options[option_index].name, LALoptarg);
exit(1);
}
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'C':
print_usage();
exit(0);
case 'D':
options.maxA = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'E':
options.minA = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'F':
options.maxbandwidth = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'G':
options.minbandwidth = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'H':
options.maxduration = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'I':
options.minduration = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'J':
options.maxf = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'K':
options.minf = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'L':
options.maxhrss = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'M':
options.minhrss = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'N':
if(!strcmp(LALoptarg, "targeted"))
options.population = POPULATION_TARGETED;
else if(!strcmp(LALoptarg, "string_cusp"))
options.population = POPULATION_STRING_CUSP;
else if(!strcmp(LALoptarg, "all_sky_sinegaussian"))
options.population = POPULATION_ALL_SKY_SINEGAUSSIAN;
else if(!strcmp(LALoptarg, "all_sky_btlwnb"))
options.population = POPULATION_ALL_SKY_BTLWNB;
else {
fprintf(stderr, "error: unrecognized population \"%s\"", LALoptarg);
exit(1);
}
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'O':
options.q = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'P':
options.seed = atol(LALoptarg);
ADD_PROCESS_PARAM(process, "int_8u");
break;
case 'Q':
options.time_step = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'R':
options.user_tag = LALoptarg;
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'S':
options.maxEoverr2 = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'T':
options.minEoverr2 = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'U':
{
char *end;
options.ra = strtod(LALoptarg, &end);
while(isspace(*end))
end++;
if(*end != ',') {
fprintf(stderr, "error: cannot parse --ra-dec \"%s\"\n", LALoptarg);
exit(1);
}
options.dec = strtod(end + 1, &end);
while(isspace(*end))
end++;
if(*end != '\0') {
fprintf(stderr, "error: cannot parse --ra-dec \"%s\"\n", LALoptarg);
exit(1);
}
}
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'V':
options.output = LALoptarg;
break;
case 'W':
options.time_slide_file = LALoptarg;
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'X':
options.jitter = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "lstring");
break;
case 0:
/* option sets a flag */
break;
case -1:
/* end of arguments */
break;
case '?':
/* unrecognized option */
print_usage();
exit(1);
case ':':
/* missing argument for an option */
print_usage();
exit(1);
} while(c != -1);
/* check some of the input parameters for consistency */
if(options.maxA < options.minA) {
fprintf(stderr, "error: --max-amplitude < --min-amplitude\n");
exit(1);
}
if(options.maxbandwidth < options.minbandwidth) {
fprintf(stderr, "error: --max-bandwidth < --min-bandwidth\n");
exit(1);
}
if(options.maxduration < options.minduration) {
fprintf(stderr, "error: --max-duration < --min-duration\n");
exit(1);
}
if(options.maxf < options.minf) {
fprintf(stderr, "error: --max-frequency < --min-frequency\n");
exit(1);
}
if(options.maxhrss < options.minhrss) {
fprintf(stderr, "error: --max-hrss < --min-hrss\n");
exit(1);
}
if(options.gps_start_time == -1 || options.gps_end_time == -1) {
fprintf(stderr, "--gps-start-time and --gps-end-time are both required\n");
exit(1);
}
if(options.gps_end_time < options.gps_start_time) {
fprintf(stderr, "error: --gps-end-time < --gps-start-time\n");
exit(1);
}
if(!options.time_slide_file) {
fprintf(stderr, "--time-slide-file is required\n");
exit(1);
}
switch(options.population) {
case POPULATION_TARGETED:
case POPULATION_ALL_SKY_SINEGAUSSIAN:
case POPULATION_ALL_SKY_BTLWNB:
case POPULATION_STRING_CUSP:
break;
default:
fprintf(stderr, "error: --population is required\n");
exit(1);
}
if(!options.output) {
int max_length = 100; /* ARGH: ugly */
options.output = calloc(max_length + 1, sizeof(*options.output));
if(options.user_tag)
snprintf(options.output, max_length, "HL-INJECTIONS_%s-%d-%d.xml", options.user_tag, (int) (options.gps_start_time / LAL_INT8_C(1000000000)), (int) ((options.gps_end_time - options.gps_start_time) / LAL_INT8_C(1000000000)));
else
snprintf(options.output, max_length, "HL-INJECTIONS-%d-%d.xml", (int) (options.gps_start_time / LAL_INT8_C(1000000000)), (int) ((options.gps_end_time - options.gps_start_time) / LAL_INT8_C(1000000000)));
}
return options;
}
int parseargs( int argc, char **argv )
{
struct LALoption long_options[] = {
{ "help", no_argument, 0, 'h' },
{ "verbose", no_argument, 0, 1 },
{ "0noise", no_argument, 0, '0' },
{ "aligo-nosrm", no_argument, 0, 'A' },
{ "aligo-zerodet-lowpower", no_argument, 0, 'B' },
{ "aligo-zerodet-highpower", no_argument, 0, 'C' },
{ "aligo-nsnsopt", no_argument, 0, 'D' },
{ "aligo-bhbh20deg", no_argument, 0, 'E' },
{ "aligo-highfreq", no_argument, 0, 'F' },
{ "iligo-srd", no_argument, 0, 'I' },
{ "virgo", no_argument, 0, 'v' },
{ "advvirgo", no_argument, 0, 'V' },
{ "geo", no_argument, 0, 'g' },
{ "geohf", no_argument, 0, 'G' },
{ "tama", no_argument, 0, 'T' },
{ "kagra", no_argument, 0, 'K' },
{ "official", no_argument, 0, 'O' },
{ "psd-only", no_argument, 0, 'P' },
{ "psd-file", no_argument, 0, 'p' },
{ "start-time", required_argument, 0, 's' },
{ "duration", required_argument, 0, 't' },
{ "sample-rate", required_argument, 0, 'r' },
{ "segment-duration", required_argument, 0, 'd' },
{ "low-frequency", required_argument, 0, 'f' },
{ 0, 0, 0, 0 }
};
char args[] = "h\1I0ABCDEFOPvVgGTKa:s:t:r:d:f:";
while (1) {
int option_index = 0;
int c;
c = LALgetopt_long_only(argc, argv, args, long_options, &option_index);
if (c == -1) /* end of options */
break;
switch (c) {
case 0: /* if option set a flag, nothing else to do */
if (long_options[option_index].flag)
break;
else {
fprintf(stderr, "error parsing option %s with argument %s\n", long_options[option_index].name, LALoptarg);
exit(1);
}
case 'h': /* help */
usage(argv[0]);
exit(0);
case 1: /* verbose */
verbose = 1;
break;
case '0': /* 0noise */
/* psdfunc and opsdfunc are ignored so just choose anything */
psdfunc = XLALSimNoisePSDaLIGONoSRMLowPower;
opsdfunc = XLALSimNoisePSDaLIGONoSRMLowPowerGWINC;
flow = 9.0;
detector = "0noise";
break;
case 'A': /* aligo-nosrm */
psdfunc = XLALSimNoisePSDaLIGONoSRMLowPower;
opsdfunc = XLALSimNoisePSDaLIGONoSRMLowPowerGWINC;
flow = 9.0;
detector = "aLIGO_NoSRM";
break;
case 'B': /* aligo-zerodet-lowpower */
psdfunc = XLALSimNoisePSDaLIGOZeroDetLowPower;
opsdfunc = XLALSimNoisePSDaLIGOZeroDetLowPowerGWINC;
flow = 9.0;
detector = "aLIGO_ZeroDet_LowPower";
break;
case 'C': /* aligo-zerodet-highpower */
psdfunc = XLALSimNoisePSDaLIGOZeroDetHighPower;
opsdfunc = XLALSimNoisePSDaLIGOZeroDetHighPowerGWINC;
flow = 9.0;
detector = "aLIGO_ZeroDet_HighPower";
break;
case 'D': /* aligo-nsnsopt */
psdfunc = XLALSimNoisePSDaLIGONSNSOpt;
opsdfunc = XLALSimNoisePSDaLIGONSNSOptGWINC;
flow = 9.0;
detector = "aLIGO_NSNSopt";
break;
case 'E': /* aligo-bhbh20deg */
psdfunc = XLALSimNoisePSDaLIGOBHBH20Deg;
opsdfunc = XLALSimNoisePSDaLIGOBHBH20DegGWINC;
flow = 9.0;
detector = "aLIGO_BHBH20deg";
break;
case 'F': /* aligo-highfreq */
psdfunc = XLALSimNoisePSDaLIGOHighFrequency;
opsdfunc = XLALSimNoisePSDaLIGOHighFrequencyGWINC;
flow = 9.0;
detector = "aLIGO_HighFreq";
break;
case 'I': /* iligo-srd */
psdfunc = XLALSimNoisePSDiLIGOSRD;
flow = 30.0;
detector = "LIGO_SRD";
break;
case 'v': /* initial Virgo */
psdfunc = XLALSimNoisePSDVirgo;
flow = 5.0;
detector = "Virgo";
break;
case 'V': /* Advanced Virgo */
psdfunc = XLALSimNoisePSDAdvVirgo;
flow = 1.0;
detector = "AdvVirgo";
break;
case 'g': /* GEO600 */
psdfunc = XLALSimNoisePSDGEO;
flow = 30.0;
detector = "GEO600";
break;
case 'G': /* GEO-HF */
psdfunc = XLALSimNoisePSDGEOHF;
flow = 50.0;
detector = "GEOHF";
break;
case 'T': /* TAMA300 */
psdfunc = XLALSimNoisePSDTAMA;
flow = 30.0;
detector = "TAMA300";
break;
case 'K': /* KAGRA (formerly LCGT) */
psdfunc = XLALSimNoisePSDKAGRA;
flow = 5.0;
detector = "KAGRA";
break;
case 'O': /* official */
official = 1;
break;
case 'P': /* start-time */
psdonly = 1;
break;
case 'a': /* asd-file */
flow = 0.0;
asdfile = LALoptarg;
detector = LALoptarg;
break;
case 's': /* start-time */
{
char *endp = NULL;
if (XLALStrToGPS(&tstart, LALoptarg, &endp) < 0 || strlen(endp)) {
fprintf(stderr, "could not parse GPS string `%s'\n", LALoptarg);
exit(1);
}
break;
}
case 't': /* duration */
duration = atof(LALoptarg);
break;
case 'r': /* sample-rate */
srate = atof(LALoptarg);
break;
case 'd': /* segment duration */
segdur = atof(LALoptarg);
break;
case 'f': /* low frequency */
overrideflow = atof(LALoptarg);
break;
case '?':
default:
fprintf(stderr, "unknown error while parsing options\n");
exit(1);
}
}
if ( LALoptind < argc ) {
fprintf(stderr, "extraneous command line arguments:\n");
while (LALoptind < argc)
fprintf(stderr, "%s\n", argv[LALoptind++]);
exit(1);
}
if ((!psdfunc && !asdfile) || (!psdonly && duration == 0.0)) {
fprintf(stderr, "must select a noise model and a duration\n");
usage(argv[0]);
exit(1);
}
return 0;
}
