int main( int argc, char *argv[] )
{
LALFILE *outfile = NULL;
LALCache *cache;
int arg = 1;
XLALSetErrorHandler( XLALExitErrorHandler );
if ( argc > 1 && ! strcmp(argv[1],"-o") ) {
outfile = XLALFileOpen( argv[2], "w" );
arg += 2;
}
cache = XLALCacheGlob( NULL, argc == 1 ? NULL : argv[arg] );
for ( ; arg < argc; ++arg ) {
LALCache *tmp = cache;
LALCache *add;
add = XLALCacheGlob( NULL, argv[arg] );
cache = XLALCacheMerge( tmp, add );
XLALDestroyCache( add );
XLALDestroyCache( tmp );
}
XLALCacheFileWrite( outfile ? outfile : LALSTDOUT, cache );
XLALFileClose( outfile );
XLALDestroyCache( cache );
LALCheckMemoryLeaks();
return 0;
}
int main(void)
{
XLALSetErrorHandler(XLALAbortErrorHandler);
test_orf();
LALCheckMemoryLeaks();
return 0;
}
int main(int argc, char *argv[])
{
LALFrStream *stream;
REAL8TimeSeries *series;
LIGOTimeGPS start;
XLALSetErrorHandler(XLALAbortErrorHandler);
parseargs(argc, argv);
/* get the data */
stream = XLALFrStreamCacheOpen(cache);
XLALGPSSetREAL8(&start, t0 - pad);
series = XLALFrStreamInputREAL8TimeSeries(stream, channel, &start, dt + 2.0 * pad, 0);
XLALFrStreamClose(stream);
/* manipulate the data */
if (srate > 0)
XLALResampleREAL8TimeSeries(series, 1.0 / srate);
if (minfreq > 0)
XLALHighPassREAL8TimeSeries(series, minfreq, 0.9, 8);
if (maxfreq > 0)
XLALLowPassREAL8TimeSeries(series, maxfreq, 0.9, 8);
if (pad > 0)
series = XLALResizeREAL8TimeSeries(series, pad / series->deltaT, dt / series->deltaT);
if (df > 0) { /* we are computing a spectrum */
REAL8FrequencySeries *spectrum;
REAL8FFTPlan *plan;
REAL8Window *window;
size_t seglen = 1.0 / (df * series->deltaT);
/* make sure that the time series length is commensurate with seglen */
if (((2 * series->data->length) % seglen) != 0) {
size_t newlen = ((2 * series->data->length) / seglen) * seglen;
series = XLALResizeREAL8TimeSeries(series, 0, newlen);
}
spectrum = XLALCreateREAL8FrequencySeries(series->name, &series->epoch, 0.0, df, &lalDimensionlessUnit, seglen/2 + 1);
plan = XLALCreateForwardREAL8FFTPlan(seglen, 0);
window = XLALCreateHannREAL8Window(seglen);
XLALREAL8AverageSpectrumWelch(spectrum, series, seglen, seglen/2, window, plan);
if (minfreq > 0 || maxfreq > 0) {
size_t first = minfreq / spectrum->deltaF;
size_t last = maxfreq > 0 ? maxfreq / spectrum->deltaF : spectrum->data->length;
spectrum = XLALResizeREAL8FrequencySeries(spectrum, first, last - first);
}
output_fs(outfile, spectrum);
XLALDestroyREAL8Window(window);
XLALDestroyREAL8FFTPlan(plan);
XLALDestroyREAL8FrequencySeries(spectrum);
} else { /* we are outputting a time series */
output_ts(outfile, series);
}
XLALDestroyREAL8TimeSeries(series);
return 0;
}
int main(int argc, char *argv[])
{
char tstr[32]; // string to hold GPS time -- 31 characters is enough
const double H0 = 0.72 * LAL_H0FAC_SI; // Hubble's constant in seconds
const size_t length = 65536; // number of points in a segment
const size_t stride = length / 2; // number of points in a stride
size_t i, n;
REAL8FrequencySeries *OmegaGW = NULL;
REAL8TimeSeries **seg = NULL;
LIGOTimeGPS epoch;
gsl_rng *rng;
XLALSetErrorHandler(XLALAbortErrorHandler);
parseargs(argc, argv);
XLALGPSSetREAL8(&epoch, tstart);
gsl_rng_env_setup();
rng = gsl_rng_alloc(gsl_rng_default);
OmegaGW = XLALSimSGWBOmegaGWFlatSpectrum(Omega0, flow, srate/length, length/2 + 1);
n = duration * srate;
seg = LALCalloc(numDetectors, sizeof(*seg));
printf("# time (s)");
for (i = 0; i < numDetectors; ++i) {
char name[LALNameLength];
snprintf(name, sizeof(name), "%s:STRAIN", detectors[i].frDetector.prefix);
seg[i] = XLALCreateREAL8TimeSeries(name, &epoch, 0.0, 1.0/srate, &lalStrainUnit, length);
printf("\t%s (strain)", name);
}
printf("\n");
XLALSimSGWB(seg, detectors, numDetectors, 0, OmegaGW, H0, rng); // first time to initilize
while (1) { // infinite loop
size_t j;
for (j = 0; j < stride; ++j, --n) { // output first stride points
LIGOTimeGPS t = seg[0]->epoch;
if (n == 0) // check if we're done
goto end;
printf("%s", XLALGPSToStr(tstr, XLALGPSAdd(&t, j * seg[0]->deltaT)));
for (i = 0; i < numDetectors; ++i)
printf("\t%e", seg[i]->data->data[j]);
printf("\n");
}
XLALSimSGWB(seg, detectors, numDetectors, stride, OmegaGW, H0, rng); // make more data
}
end:
for (i = 0; i < numDetectors; ++i)
XLALDestroyREAL8TimeSeries(seg[i]);
XLALFree(seg);
XLALDestroyREAL8FrequencySeries(OmegaGW);
LALCheckMemoryLeaks();
return 0;
}
int main(int argc, char *argv[])
{
const double H0 = 0.72 * LAL_H0FAC_SI; // Hubble's constant in seconds
const double srate = 16384.0; // sampling rate in Hertz
const size_t length = 65536; // number of points in a segment
const size_t stride = length / 2; // number of points in a stride
size_t i, n;
REAL8FrequencySeries *OmegaGW = NULL;
REAL8TimeSeries **seg = NULL;
LIGOTimeGPS epoch;
gsl_rng *rng;
XLALSetErrorHandler(XLALAbortErrorHandler);
parseargs(argc, argv);
XLALGPSSetREAL8(&epoch, tstart);
gsl_rng_env_setup();
rng = gsl_rng_alloc(gsl_rng_default);
OmegaGW = XLALSimSGWBOmegaGWFlatSpectrum(Omega0, flow, srate/length, length/2 + 1);
n = duration * srate;
seg = LALCalloc(numDetectors, sizeof(*seg));
for (i = 0; i < numDetectors; ++i)
seg[i] = XLALCreateREAL8TimeSeries("STRAIN", &epoch, 0.0, 1.0/srate, &lalStrainUnit, length);
XLALSimSGWB(seg, detectors, numDetectors, 0, OmegaGW, H0, rng); // first time to initilize
while (1) { // infinite loop
double t0 = XLALGPSGetREAL8(&seg[0]->epoch);
size_t j;
for (j = 0; j < stride; ++j, --n) { // output first stride points
if (n == 0) // check if we're done
goto end;
printf("%.9f", t0 + j * seg[0]->deltaT);
for (i = 0; i < numDetectors; ++i)
printf("\t%e", seg[i]->data->data[j]);
printf("\n");
}
XLALSimSGWB(seg, detectors, numDetectors, stride, OmegaGW, H0, rng); // make more data
}
end:
for (i = 0; i < numDetectors; ++i)
XLALDestroyREAL8TimeSeries(seg[i]);
XLALFree(seg);
XLALDestroyREAL8FrequencySeries(OmegaGW);
LALCheckMemoryLeaks();
return 0;
}
int main(void)
{
XLALSetErrorHandler(XLALAbortErrorHandler);
test_CHARVector();
test_INT2Vector();
test_INT4Vector();
test_INT8Vector();
test_UINT2Vector();
test_UINT4Vector();
test_UINT8Vector();
test_REAL4Vector();
test_REAL8Vector();
test_COMPLEX8Vector();
test_COMPLEX16Vector();
test_INT2Array();
test_INT4Array();
test_INT8Array();
test_UINT2Array();
test_UINT4Array();
test_UINT8Array();
test_REAL4Array();
test_REAL8Array();
test_COMPLEX8Array();
test_COMPLEX16Array();
test_INT2TimeSeries();
test_INT4TimeSeries();
test_INT8TimeSeries();
test_UINT2TimeSeries();
test_UINT4TimeSeries();
test_UINT8TimeSeries();
test_REAL4TimeSeries();
test_REAL8TimeSeries();
test_COMPLEX8TimeSeries();
test_COMPLEX16TimeSeries();
test_REAL4FrequencySeries();
test_REAL8FrequencySeries();
test_COMPLEX8FrequencySeries();
test_COMPLEX16FrequencySeries();
LALCheckMemoryLeaks();
return 0;
}
int main( int argc, char *argv[] )
{
XLALSetErrorHandler(XLALBacktraceErrorHandler);
parseargs(argc, argv);
if (theta == theta_invalid) { /* make a table */
fprintf(stdout, "# theta(deg)\t Re(S) \t Im(S)\n");
for (theta = 0.0; theta <= 180.0; theta += 10.0) {
COMPLEX16 sphwf = XLALSimBlackHoleRingdownSpheroidalWaveFunction(LAL_PI_180 * theta, a, l, m, s);
fprintf(stdout, "%8g\t%e\t%e\n", theta, creal(sphwf), cimag(sphwf));
}
} else { /* evaluate at specified value */
COMPLEX16 sphwf = XLALSimBlackHoleRingdownSpheroidalWaveFunction(LAL_PI_180 * theta, a, l, m, s);
fprintf(stdout, "Spheroidal wave function (s)S(l,m)(cos(theta),a):\n");
fprintf(stdout, "(%d)S(%d,%d)(cos(%g deg),%g) = %g + %g i\n", s, l, m, theta, a, creal(sphwf), cimag(sphwf));
}
return 0;
}
int main(int argc, char *argv[])
{
LIGOTimeGPS epoch = {0, 0};
REAL8TimeSeries *hplus;
REAL8TimeSeries *hcross;
size_t j;
XLALSetErrorHandler(XLALBacktraceErrorHandler);
parseargs(argc, argv);
XLALSimBlackHoleRingdown(&hplus, &hcross, &epoch, q, dt, M, a, e, r, i, l, m);
fprintf(stdout, "# time (s)\th_plus \th_cross\n");
for (j = 0; j < hplus->data->length; ++j)
fprintf(stdout, "%.9f\t%e\t%e\n", j*dt, hplus->data->data[j], hcross->data->data[j]);
XLALDestroyREAL8TimeSeries(hcross);
XLALDestroyREAL8TimeSeries(hplus);
LALCheckMemoryLeaks();
return 0;
}
int main(int argc, char *argv[])
{
struct params p;
int istd, isfd;
XLALSetErrorHandler(XLALBacktraceErrorHandler);
p = parseargs(argc, argv);
print_params(p);
/* sanity check on domain; set to natural value if unspecified */
istd = XLALSimInspiralImplementedTDApproximants(p.approx);
isfd = XLALSimInspiralImplementedFDApproximants(p.approx);
if (!istd && !isfd) {
fprintf(stderr, "error: approximant not supported\n");
exit(1);
}
switch (p.domain) {
case LAL_SIM_DOMAIN_TIME:
if (!istd) {
fprintf(stderr, "error: approximant not supported in time domain\n");
exit(1);
}
break;
case LAL_SIM_DOMAIN_FREQUENCY:
if (!isfd) {
fprintf(stderr, "error: approximant not supported in frequency domain\n");
exit(1);
}
break;
default:
switch (p.freq_dom) {
case 0:
p.domain = istd ? LAL_SIM_DOMAIN_TIME : LAL_SIM_DOMAIN_FREQUENCY;
break;
case 1:
p.domain = isfd ? LAL_SIM_DOMAIN_FREQUENCY : LAL_SIM_DOMAIN_TIME;
break;
}
break;
}
/* generate and output the waveform in appropriate domain */
if (p.freq_dom) {
COMPLEX16FrequencySeries *htilde_plus = NULL;
COMPLEX16FrequencySeries *htilde_cross = NULL;
create_fd_waveform(&htilde_plus, &htilde_cross, p);
output_fd_waveform(htilde_plus, htilde_cross, p);
XLALDestroyCOMPLEX16FrequencySeries(htilde_cross);
XLALDestroyCOMPLEX16FrequencySeries(htilde_plus);
} else {
REAL8TimeSeries *h_plus = NULL;
REAL8TimeSeries *h_cross = NULL;
create_td_waveform(&h_plus, &h_cross, p);
output_td_waveform(h_plus, h_cross, p);
XLALDestroyREAL8TimeSeries(h_cross);
XLALDestroyREAL8TimeSeries(h_plus);
}
/* cleanup */
XLALDestroyDict(p.params);
LALCheckMemoryLeaks();
return 0;
}
/*
* main
*/
int main (int argc , char **argv) {
FILE *f;
int status;
int start_time;
COMPLEX16FrequencySeries *hptilde = NULL, *hctilde = NULL;
REAL8TimeSeries *hplus = NULL;
REAL8TimeSeries *hcross = NULL;
GSParams *params;
/* set us up to fail hard */
XLALSetErrorHandler(XLALAbortErrorHandler);
/* parse commandline */
params = parse_args(argc, argv);
/* generate waveform */
start_time = time(NULL);
switch (params->domain) {
case LAL_SIM_DOMAIN_FREQUENCY:
XLALSimInspiralChooseFDWaveform(&hptilde, &hctilde, params->phiRef,
params->deltaF, params->m1, params->m2, params->s1x,
params->s1y, params->s1z, params->s2x, params->s2y,
params->s2z, params->f_min, params->f_max, params->fRef,
params->distance, params->inclination, params->lambda1,
params->lambda2, params->waveFlags, params->nonGRparams,
params->ampO, params->phaseO, params->approximant);
break;
case LAL_SIM_DOMAIN_TIME:
XLALSimInspiralChooseTDWaveform(&hplus, &hcross, params->phiRef,
params->deltaT, params->m1, params->m2, params->s1x,
params->s1y, params->s1z, params->s2x, params->s2y,
params->s2z, params->f_min, params->fRef,
params->distance, params->inclination, params->lambda1,
params->lambda2, params->waveFlags,
params->nonGRparams, params->ampO, params->phaseO,
params->approximant);
break;
default:
XLALPrintError("Error: domain must be either TD or FD\n");
}
if (params->verbose)
XLALPrintInfo("Generation took %.0f seconds\n",
difftime(time(NULL), start_time));
if (((params->domain == LAL_SIM_DOMAIN_FREQUENCY) && (!hptilde || !hctilde)) ||
((params->domain == LAL_SIM_DOMAIN_TIME) && (!hplus || !hcross))) {
XLALPrintError("Error: waveform generation failed\n");
goto fail;
}
/* dump file */
if ( strlen(params->outname) > 0 ) {
f = fopen(params->outname, "w");
if (f==NULL) {
printf("**ERROR** Impossible to write file %s\n",params->outname);
exit(1);
}
else {
if (params->domain == LAL_SIM_DOMAIN_FREQUENCY)
if (params->ampPhase == 1)
status = dump_FD2(f, hptilde, hctilde);
else
status = dump_FD(f, hptilde, hctilde);
else if (params->ampPhase == 1)
status = dump_TD2(f, hplus, hcross);
else
status = dump_TD(f, hplus, hcross);
fclose(f);
}
if (status) goto fail;
}
/* clean up */
XLALSimInspiralDestroyWaveformFlags(params->waveFlags);
XLALSimInspiralDestroyTestGRParam(params->nonGRparams);
XLALFree(params);
XLALDestroyCOMPLEX16FrequencySeries(hptilde);
XLALDestroyCOMPLEX16FrequencySeries(hctilde);
return 0;
fail:
XLALSimInspiralDestroyWaveformFlags(params->waveFlags);
XLALSimInspiralDestroyTestGRParam(params->nonGRparams);
XLALFree(params);
XLALDestroyCOMPLEX16FrequencySeries(hptilde);
XLALDestroyCOMPLEX16FrequencySeries(hctilde);
return 1;
}
int main(int argc, char **argv)
{
REAL8TimeSeries *hplus = NULL;
REAL8TimeSeries *hcross = NULL;
struct params p;
int status = 0;
gsl_rng *rng = NULL;
XLALSetErrorHandler(XLALAbortErrorHandler);
p = parseargs(argc, argv);
if ((int)(p.waveform) < 0 || (int)(p.waveform) >= NumWaveforms) {
fprintf(stderr, "error: must specify valid waveform\n");
exit(1);
}
if (p.waveform == BLTWNB) { /* set up gsl random number generator */
gsl_rng_env_setup();
rng = gsl_rng_alloc(gsl_rng_default);
}
if (IS_INVALID_DOUBLE(p.srate) || p.srate <= 0.0) {
fprintf(stderr, "error: must specify valid sample rate\n");
status = 1;
}
verbose_output("Input parameters:\n");
verbose_output("%-31s `%s' - %s\n", "waveform:", waveform_names[p.waveform], waveform_long_names[p.waveform]);
verbose_output("%-31s %g (Hz)\n", "sample rate:", p.srate);
switch (p.waveform) {
case BLTWNB:
/* sanity check relevant parameters */
if (IS_INVALID_DOUBLE(p.duration) || p.duration < 0.0) {
fprintf(stderr, "error: must specify valid duration for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
if (IS_INVALID_DOUBLE(p.frequency) || p.frequency < 0.0) {
fprintf(stderr, "error: must specify valid frequency for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
if (IS_INVALID_DOUBLE(p.bandwidth) || p.bandwidth < 0.0) {
fprintf(stderr, "error: must specify valid bandwidth for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
if (IS_INVALID_DOUBLE(p.eccentricity) || p.eccentricity < 0.0 || p.eccentricity > 1.0) {
fprintf(stderr, "error: must specify valid eccentricity in domain [0,1] for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
if (IS_INVALID_DOUBLE(p.fluence) || p.fluence < 0.0) {
fprintf(stderr, "error: must specify valid fluence for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
/* detect set but ignored parameters */
if (!IS_INVALID_DOUBLE(p.q))
fprintf(stderr, "warning: quality-factor parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (p.phase != DEFAULT_PHASE)
fprintf(stderr, "warning: phase parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.amplitude))
fprintf(stderr, "warning: amplitude parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.hrss))
fprintf(stderr, "warning: hrss parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!status) {
double int_hdot_squared_dt;
int_hdot_squared_dt = p.fluence * LAL_GMSUN_SI * 4 / LAL_C_SI / LAL_PC_SI / LAL_PC_SI;
verbose_output("%-31s %g (s)\n", "duration:", p.duration);
verbose_output("%-31s %g (Hz)\n", "frequency:", p.frequency);
verbose_output("%-31s %g (Hz)\n", "bandwidth:", p.bandwidth);
verbose_output("%-31s %g\n", "eccentricity:", p.eccentricity);
verbose_output("%-31s %g (Msun c^2 pc^-2)\n", "fluence:", p.fluence);
verbose_output("%-31s %g (s^-1)\n", "integral (dh/dt)^2 dt:", int_hdot_squared_dt);
verbose_output("%-31s GSL_RNG_TYPE=%s\n", "GSL random number generator:", gsl_rng_name(rng));
verbose_output("%-31s GSL_RNG_SEED=%lu\n", "GSL random number seed:", gsl_rng_default_seed);
status = XLALGenerateBandAndTimeLimitedWhiteNoiseBurst(&hplus, &hcross, p.duration, p.frequency, p.bandwidth, p.eccentricity, int_hdot_squared_dt, 1.0/p.srate, rng);
}
break;
case StringCusp:
/* sanity check relevant parameters */
if (IS_INVALID_DOUBLE(p.amplitude) || p.amplitude < 0.0) {
fprintf(stderr, "error: must specify valid amplitude for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
if (IS_INVALID_DOUBLE(p.frequency) || p.frequency < 0.0) {
fprintf(stderr, "error: must specify valid frequency for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
/* detect set but ignored parameters */
if (!IS_INVALID_DOUBLE(p.duration))
fprintf(stderr, "warning: duration parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.bandwidth))
fprintf(stderr, "warning: bandwidth parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.q))
fprintf(stderr, "warning: quality-factor parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (p.eccentricity != DEFAULT_ECCENTRICITY)
fprintf(stderr, "warning: eccentricity parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (p.phase != DEFAULT_PHASE)
fprintf(stderr, "warning: phase parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.hrss))
fprintf(stderr, "warning: hrss parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.fluence))
fprintf(stderr, "warning: fluence parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!status) {
verbose_output("%-31s %g (s^-1/3)\n", "amplitude:", p.amplitude);
verbose_output("%-31s %g (Hz)\n", "frequency:", p.frequency);
status = XLALGenerateStringCusp(&hplus, &hcross, p.amplitude, p.frequency, 1.0/p.srate);
}
break;
case SineGaussian:
/* sanity check relevant parameters */
if (IS_INVALID_DOUBLE(p.q) || p.q < 0.0) {
fprintf(stderr, "error: must specify valid quality factor for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
if (IS_INVALID_DOUBLE(p.frequency) || p.frequency < 0.0) {
fprintf(stderr, "error: must specify valid frequency for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
if (IS_INVALID_DOUBLE(p.hrss) || p.hrss < 0.0) {
fprintf(stderr, "error: must specify valid hrss for waveform `%s\n", waveform_names[p.waveform]);
status = 1;
}
if (IS_INVALID_DOUBLE(p.eccentricity) || p.eccentricity < 0.0 || p.eccentricity > 1.0) {
fprintf(stderr, "error: must specify valid eccentricity in domain [0,1] for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
if (IS_INVALID_DOUBLE(p.phase)) {
fprintf(stderr, "error: must specify valid phase for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
/* detect set but ignored parameters */
if (!IS_INVALID_DOUBLE(p.duration))
fprintf(stderr, "warning: duration parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.bandwidth))
fprintf(stderr, "warning: bandwidth parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.amplitude))
fprintf(stderr, "warning: amplitude parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.fluence))
fprintf(stderr, "warning: fluence parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!status) {
verbose_output("%-31s %g\n", "quality-factor:", p.q);
verbose_output("%-31s %g (Hz)\n", "frequency:", p.frequency);
verbose_output("%-31s %g (Hz^-1/2)\n", "root-sum-squared strain:", p.hrss);
verbose_output("%-31s %g\n", "eccentricity:", p.eccentricity);
verbose_output("%-31s %g (degrees)\n", "phase:", p.phase / LAL_PI_180);
status = XLALSimBurstSineGaussian(&hplus, &hcross, p.q, p.frequency, p.hrss, p.eccentricity, p.phase, 1.0/p.srate);
}
break;
case Gaussian:
/* sanity check relevant parameters */
if (IS_INVALID_DOUBLE(p.duration) || p.duration < 0.0) {
fprintf(stderr, "error: must specify valid duration for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
if (IS_INVALID_DOUBLE(p.hrss) || p.hrss < 0.0) {
fprintf(stderr, "error: must specify valid hrss for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
/* detect set but ignored parameters */
if (!IS_INVALID_DOUBLE(p.frequency))
fprintf(stderr, "warning: frequency parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.bandwidth))
fprintf(stderr, "warning: bandwidth parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.q))
fprintf(stderr, "warning: quality-factor parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (p.eccentricity != DEFAULT_ECCENTRICITY)
fprintf(stderr, "warning: eccentricity parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (p.phase != DEFAULT_PHASE)
fprintf(stderr, "warning: phase parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.amplitude))
fprintf(stderr, "warning: amplitude parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.fluence))
fprintf(stderr, "warning: fluence parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!status) {
verbose_output("%-31s %g (s)\n", "duration:", p.duration);
verbose_output("%-31s %g (Hz^-1/2)\n", "root-sum-squared strain:", p.hrss);
status = XLALSimBurstGaussian(&hplus, &hcross, p.duration, p.hrss, 1.0/p.srate);
}
break;
case Impulse:
/* sanity check relevant parameters */
if (IS_INVALID_DOUBLE(p.amplitude) || p.amplitude < 0.0) {
fprintf(stderr, "error: must specify valid amplitude for waveform `%s'\n", waveform_names[p.waveform]);
status = 1;
}
/* detect set but ignored parameters */
if (!IS_INVALID_DOUBLE(p.duration))
fprintf(stderr, "warning: duration parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.frequency))
fprintf(stderr, "warning: frequency parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.bandwidth))
fprintf(stderr, "warning: bandwidth parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.q))
fprintf(stderr, "warning: quality-factor parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (p.eccentricity != DEFAULT_ECCENTRICITY)
fprintf(stderr, "warning: eccentricity parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (p.phase != DEFAULT_PHASE)
fprintf(stderr, "warning: phase parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.hrss))
fprintf(stderr, "warning: hrss parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!IS_INVALID_DOUBLE(p.fluence))
fprintf(stderr, "warning: fluence parameter is set but ignored for waveform `%s'\n", waveform_names[p.waveform]);
if (!status) {
verbose_output("%-31s %g (dimensionless)\n", "amplitude:", p.amplitude);
status = XLALGenerateImpulseBurst(&hplus, &hcross, p.amplitude, 1.0/p.srate);
}
break;
default:
fprintf(stderr, "error: unrecognized waveform\n");
exit(1);
};
if (status)
exit(1);
if (verbose) {
char peak_time[32]; // GPS time string - 31 characters is enough
LIGOTimeGPS tpeak;
COMPLEX16 hpeak;
double hrss;
double fluence;
unsigned ipeak;
hpeak = XLALMeasureHPeak(hplus, hcross, &ipeak);
tpeak = hplus->epoch;
XLALGPSAdd(&tpeak, ipeak * hplus->deltaT);
XLALGPSToStr(peak_time, &tpeak);
hrss = XLALMeasureHrss(hplus, hcross);
fluence = XLALMeasureEoverRsquared(hplus, hcross);
verbose_output("Measured parameters:\n");
verbose_output("%-31s %s (s)\n", "peak time:", peak_time);
verbose_output("%-31s (h+, hx) = (%g, %g)\n", "peak strain amplitude:", creal(hpeak), cimag(hpeak));
verbose_output("%-31s abs(h+, hx) = %g\n", "peak strain amplitude:", cabs(hpeak));
verbose_output("%-31s arg(h+, hx) = %g (rad)\n", "peak strain amplitude:", carg(hpeak));
verbose_output("%-31s %g (Hz^-1/2)\n", "root-sum-squared strain:", hrss);
verbose_output("%-31s %g (J m^-2)\n", "isotropic energy fluence:", fluence);
verbose_output("%-31s %g (Msun c^2 pc^-2)\n", "isotropic energy fluence:", fluence * LAL_PC_SI * LAL_PC_SI / LAL_MSUN_SI / LAL_C_SI / LAL_C_SI);
}
output(hplus, hcross);
XLALDestroyREAL8TimeSeries(hcross);
XLALDestroyREAL8TimeSeries(hplus);
LALCheckMemoryLeaks();
return 0;
}
int
main(int argc, char **argv)
{
static LALStatus stat; /* LALStatus pointer */
CHAR *infile = NULL; /* The input filename */
CHAR *outfile = NULL; /* The output filename */
INT4 arg; /* Argument counter */
UINT4 npts = NPTS; /* Number of points in time series */
UINT4 offset = OFFSET; /* Position of delta function */
REAL8 dt = DT; /* Sampling interval. */
static REAL4TimeSeries series; /* Time series */
static PassBandParamStruc params; /* Filter parameters */
XLALSetErrorHandler( XLALAbortErrorHandler );
/* Set up the default filter parameters. */
params.f1 = F1;
params.f2 = F2;
params.a1 = A1;
params.a2 = A2;
params.nMax = ORDER;
/* Parse argument list. i stores the current position. */
arg = 1;
while ( arg < argc ) {
/* Parse debuglevel option. */
if ( !strcmp( argv[arg], "-d" ) ) {
if ( argc > arg + 1 ) {
arg++;
} else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
}
/* Parse input file option. */
else if ( !strcmp( argv[arg], "-i" ) ) {
if ( argc > arg + 1 ) {
arg++;
infile = argv[arg++];
} else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
}
/* Parse output file option. */
else if ( !strcmp( argv[arg], "-o" ) ) {
if ( argc > arg + 1 ) {
arg++;
outfile = argv[arg++];
} else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
}
/* Parse filter options. */
else if ( !strcmp( argv[arg], "-f" ) ) {
if ( argc > arg + 5 ) {
arg++;
params.f1=atof(argv[arg++]);
params.f2=atof(argv[arg++]);
params.a1=atof(argv[arg++]);
params.a2=atof(argv[arg++]);
params.nMax=atoi(argv[arg++]);
} else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
}
/* Parse time series options. */
else if ( !strcmp( argv[arg], "-n" ) ) {
if ( argc > arg + 3 ) {
arg++;
npts=atoi(argv[arg++]);
dt=atof(argv[arg++]);
offset=atoi(argv[arg++]);
} else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
}
/* Unrecognized option. */
else {
ERROR( BANDPASSTESTC_EARG, BANDPASSTESTC_MSGEARG, 0 );
LALPrintError( USAGE, *argv );
return BANDPASSTESTC_EARG;
}
} /* End of argument parsing loop. */
/* Check input values. */
if ( !infile ) {
if ( offset >= npts ) {
ERROR( BANDPASSTESTC_EBAD, BANDPASSTESTC_MSGEBAD, 0 );
LALPrintError( "\toffset=%i must be less than npts=%i\n", offset,
npts );
return BANDPASSTESTC_EBAD;
}
}
/* Create the time series. */
if ( infile ) {
FILE *fp = fopen( infile, "r" );
if ( !fp ) {
ERROR( BANDPASSTESTC_EFILE, BANDPASSTESTC_MSGEFILE, infile );
return BANDPASSTESTC_EFILE;
}
SUB( LALSReadTSeries( &stat, &series, fp ), &stat );
fclose( fp );
} else {
snprintf( series.name, LALNameLength, "%s", "Impulse" );
series.deltaT = dt;
SUB( LALSCreateVector( &stat, &(series.data), npts ), &stat );
memset( series.data->data, 0, npts*sizeof(REAL4) );
series.data->data[offset] = 1.0;
}
/* Filter the time series. */
SUB( LALDButterworthREAL4TimeSeries( &stat, &series, ¶ms ),
&stat );
/* Print the output, if the -o option was given. */
if ( outfile ) {
FILE *fp = fopen( outfile, "w" );
if ( !fp ){
ERROR( BANDPASSTESTC_EFILE, BANDPASSTESTC_MSGEFILE, outfile );
return BANDPASSTESTC_EFILE;
}
SUB( LALSWriteTSeries( &stat, fp, &series ), &stat );
fclose( fp );
}
/* Free memory and exit. */
SUB( LALSDestroyVector( &stat, &(series.data) ), &stat );
LALCheckMemoryLeaks();
INFO( BANDPASSTESTC_MSGENORM );
return BANDPASSTESTC_ENORM;
}
int main(int argc, char *argv[])
{
char tstr[32]; // string to hold GPS time -- 31 characters is enough
size_t length;
size_t stride;
size_t n;
REAL8FrequencySeries *psd = NULL;
REAL8TimeSeries *seg = NULL;
gsl_rng *rng;
XLALSetErrorHandler(XLALAbortErrorHandler);
parseargs(argc, argv);
if (overrideflow > 0.0)
flow = overrideflow;
length = segdur * srate;
stride = length / 2;
/* handle 0noise case first */
if (strcmp(detector, "0noise") == 0) {
/* just print out a bunch of zeros */
if (psdonly) {
double deltaF = srate / length;
size_t klow = flow / deltaF;
size_t k;
fprintf(stdout, "# freq (s^-1)\tPSD (strain^2 s)\n");
for (k = klow; k < length/2 - 1; ++k)
fprintf(stdout, "%e\t%e\n", k * deltaF, 0.0);
} else {
size_t j;
fprintf(stdout, "# time (s)\tNOISE (strain)\n");
n = duration * srate;
for (j = 0; j < n; ++j) {
LIGOTimeGPS t = tstart;
fprintf(stdout, "%s\t%e\n", XLALGPSToStr(tstr, XLALGPSAdd(&t, j/srate)), 0.0);
}
}
return 0;
}
gsl_rng_env_setup();
rng = gsl_rng_alloc(gsl_rng_default);
psd = XLALCreateREAL8FrequencySeries(detector, &tstart, 0.0, srate/length, &strainSquaredPerHertzUnit, length/2 + 1);
if (asdfile)
XLALSimNoisePSDFromFile(psd, flow, asdfile);
else if (official && opsdfunc)
opsdfunc(psd, flow);
else
XLALSimNoisePSD(psd, flow, psdfunc);
if (verbose) {
double Mpc = 1e6 * LAL_PC_SI;
double horizon_distance;
fprintf(stderr, "%-39s %s\n", "detector: ", detector);
fprintf(stderr, "%-39s %g Hz\n", "low-frequency cutoff: ", flow);
horizon_distance = XLALMeasureStandardSirenHorizonDistance(psd, flow, -1.0);
fprintf(stderr, "%-39s %g Mpc\n", "standard siren horizon distance: ", horizon_distance / Mpc);
fprintf(stderr, "%-39s %g Mpc\n", "sense-monitor range: ", horizon_distance / Mpc / LAL_HORIZON_DISTANCE_OVER_SENSEMON_RANGE);
fprintf(stderr, "%-39s GSL_RNG_TYPE=%s\n", "GSL random number generator:", gsl_rng_name(rng));
fprintf(stderr, "%-39s GSL_RNG_SEED=%lu\n", "GSL random number seed:", gsl_rng_default_seed);
}
if (psdonly) { // output PSD and exit
size_t klow = flow / psd->deltaF;
size_t k;
fprintf(stdout, "# freq (s^-1)\tPSD (strain^2 s)\n");
for (k = klow; k < length/2 - 1; ++k)
fprintf(stdout, "%e\t%e\n", k * psd->deltaF, sqrt(psd->data->data[k]));
goto end;
}
n = duration * srate;
seg = XLALCreateREAL8TimeSeries("STRAIN", &tstart, 0.0, 1.0/srate, &lalStrainUnit, length);
XLALSimNoise(seg, 0, psd, rng); // first time to initialize
fprintf(stdout, "# time (s)\tNOISE (strain)\n");
while (1) { // infinite loop
size_t j;
for (j = 0; j < stride; ++j, --n) { // output first stride points
LIGOTimeGPS t = seg->epoch;
if (n == 0) // check if we're done
goto end;
fprintf(stdout, "%s\t%e\n", XLALGPSToStr(tstr, XLALGPSAdd(&t, j * seg->deltaT)), seg->data->data[j]);
}
XLALSimNoise(seg, stride, psd, rng); // make more data
}
end:
XLALDestroyREAL8TimeSeries(seg);
XLALDestroyREAL8FrequencySeries(psd);
LALCheckMemoryLeaks();
return 0;
}
