/** * Write given REAL8FrequencySeries into file */ int XLALWriteREAL8FrequencySeries_to_file ( const REAL8FrequencySeries *series, /**< [in] frequency-series to write to file */ const char *fname /**< [in] filename to write into */ ) { /* check input consistency */ if ( !series || !fname ) { XLALPrintError ("%s: invalid NULL input.\n", __func__ ); XLAL_ERROR ( XLAL_EINVAL ); } FILE *fp; if ( ( fp = fopen ( fname, "wb" )) == NULL ) { XLALPrintError ("%s: failed to open file '%s' for writing.\n", __func__, fname ); XLAL_ERROR ( XLAL_ESYS ); } /* write header info in comments */ if ( XLAL_SUCCESS != XLALOutputVersionString ( fp, 0 ) ) XLAL_ERROR ( XLAL_EFUNC ); fprintf ( fp, "%%%% name = '%s'\n", series->name ); fprintf ( fp, "%%%% epoch = {%d, %d}\n", series->epoch.gpsSeconds, series->epoch.gpsNanoSeconds ); fprintf ( fp, "%%%% f0 = %f Hz\n", series->f0 ); fprintf ( fp, "%%%% deltaF = %g Hz\n", series->deltaF ); CHAR unitStr[1024]; if ( XLALUnitAsString( &unitStr[0], sizeof(unitStr)-1, &series->sampleUnits ) == NULL ) { XLALPrintError ("%s: XLALUnitAsString() failed with xlalErrno = %d.\n", __func__, xlalErrno ); XLAL_ERROR ( XLAL_EFUNC ); } fprintf ( fp, "%%%% Units = %s\n", unitStr ); fprintf ( fp, "%%%% Freq [Hz] Data(Freq)\n"); UINT4 numBins = series->data->length; UINT4 iFreq; for ( iFreq = 0; iFreq < numBins; iFreq ++ ) { REAL8 thisFreq = series->f0 + iFreq * series->deltaF; fprintf (fp, "%20.16f %20.16g\n", thisFreq, series->data->data[iFreq] ); } fclose ( fp ); return XLAL_SUCCESS; } /* XLALWriteREAL8FrequencySeries_to_file() */
/* parse command line arguments using LALgetopt_long to get ring params */ int coh_PTF_parse_options(struct coh_PTF_params *params,int argc,char **argv ) { CHAR ifo[LIGOMETA_IFO_MAX]; UINT4 ifoNumber; static struct coh_PTF_params localparams; memset( &localparams.haveTrig, 0, LAL_NUM_IFO * sizeof(int) ); struct LALoption long_options[] = { { "verbose", no_argument, &vrbflg, 1 }, { "strain-data", no_argument, &localparams.strainData, 1 }, { "zero-data", no_argument, &localparams.zeroData, 1 }, { "theoretical-spectrum", no_argument, &localparams.whiteSpectrum, 1 }, { "write-raw-data", no_argument, &localparams.writeRawData, 1 }, { "write-data", no_argument, &localparams.writeProcessedData, 1 }, { "write-inv-spectrum", no_argument, &localparams.writeInvSpectrum, 1 }, { "write-segment", no_argument, &localparams.writeSegment, 1 }, { "write-filter-output",no_argument, &localparams.writeFilterOutput, 1 }, { "analyze-inj-segs-only",no_argument, &localparams.analyzeInjSegsOnly, 1 }, { "do-null-stream", no_argument, &localparams.doNullStream, 1 }, { "do-trace-snr", no_argument, &localparams.doTraceSNR, 1 }, { "do-bank-veto", no_argument, &localparams.doBankVeto, 1 }, { "do-auto-veto", no_argument, &localparams.doAutoVeto, 1 }, { "do-chi-square", no_argument, &localparams.doChiSquare, 1 }, { "do-sngl-chi-tests", no_argument, &localparams.doSnglChiSquared, 1}, { "do-clustering", no_argument, &localparams.clusterFlag, 1}, /* {"g1-data", no_argument, &(haveTrig[LAL_IFO_G1]), 1 },*/ {"h1-data", no_argument, &(localparams.haveTrig[LAL_IFO_H1]),1}, {"h2-data", no_argument, &(localparams.haveTrig[LAL_IFO_H2]),1}, {"l1-data", no_argument, &(localparams.haveTrig[LAL_IFO_L1]),1}, /* {"t1-data", no_argument, &(haveTrig[LAL_IFO_T1]), 1 },*/ {"v1-data", no_argument, &(localparams.haveTrig[LAL_IFO_V1]),1}, {"face-on-analysis", no_argument, &(localparams.faceOnAnalysis),1}, {"face-away-analysis", no_argument, &(localparams.faceAwayAnalysis),1}, {"dynamic-template-length",no_argument, &(localparams.dynTempLength),1}, {"store-amplitude-params",no_argument, &(localparams.storeAmpParams),1}, {"analyse-segment-end", no_argument, &(localparams.analSegmentEnd),1}, {"do-short-slides", no_argument, &(localparams.doShortSlides),1}, { "write-sngl-inspiral-table", no_argument, &(localparams.writeSnglInspiralTable),1}, { "help", no_argument, 0, 'h' }, { "version", no_argument, 0, 'V' }, { "simulated-data", required_argument, 0, '6' }, { "gps-start-time", required_argument, 0, 'a' }, { "gps-start-time-ns", required_argument, 0, 'A' }, { "gps-end-time", required_argument, 0, 'b' }, { "gps-end-time-ns", required_argument, 0, 'B' }, { "trigger-time", required_argument, 0, '<' }, { "trigger-time-ns", required_argument, 0, '>' }, { "h1-channel-name", required_argument, 0, 'c' }, { "h1-frame-cache", required_argument, 0, 'D' }, { "h2-channel-name", required_argument, 0, 'x' }, { "h2-frame-cache", required_argument, 0, 'X' }, { "l1-channel-name", required_argument, 0, 'y' }, { "l1-frame-cache", required_argument, 0, 'Y' }, { "v1-channel-name", required_argument, 0, 'z' }, { "v1-frame-cache", required_argument, 0, 'Z' }, { "low-template-freq", required_argument, 0, 'e' }, { "low-filter-freq", required_argument, 0, 'H' }, { "high-filter-freq", required_argument, 0, 'I' }, { "highpass-frequency", required_argument, 0, 'E' }, { "injection-file", required_argument, 0, 'i' }, { "snr-threshold", required_argument, 0, 'j' }, { "spin-snr-threshold", required_argument, 0, '2' }, { "sngl-snr-threshold", required_argument, 0, '1' }, { "trig-time-window", required_argument, 0, 'J' }, { "user-tag", required_argument, 0, 'k' }, { "ifo-tag", required_argument, 0, 'K' }, { "non-spin-snr2-threshold", required_argument, 0, 'l' }, { "spin-snr2-threshold", required_argument, 0, 'L' }, { "spin-bank", required_argument, 0, 'm' }, { "non-spin-bank", required_argument, 0, 'M' }, { "only-segment-numbers", required_argument, 0, 'n' }, { "only-template-numbers", required_argument, 0, 'N' }, { "output-file", required_argument, 0, 'o' }, { "bank-file", required_argument, 0, 'O' }, { "num-auto-chisq-points", required_argument, 0, 'p' }, { "auto-veto-time-step", required_argument, 0, 'P' }, { "num-chi-square-bins", required_argument, 0, 'q' }, { "chi-square-threshold", required_argument, 0, 'Q' }, { "random-seed", required_argument, 0, 'r' }, { "dynamic-range-factor", required_argument, 0, 'R' }, { "sample-rate", required_argument, 0, 's' }, { "segment-duration", required_argument, 0, 'S' }, { "psd-segment-duration", required_argument, 0, '9' }, { "bank-veto-templates", required_argument, 0, 't' }, { "inverse-spec-length", required_argument, 0, 'T' }, { "trig-start-time", required_argument, 0, 'u' }, { "trig-end-time", required_argument, 0, 'U' }, { "block-duration", required_argument, 0, 'w' }, { "pad-data", required_argument, 0, 'W' }, { "right-ascension", required_argument, 0, 'f' }, { "declination", required_argument, 0, 'F' }, { "sky-error", required_argument, 0, 'g' }, { "timing-accuracy", required_argument, 0, 'G' }, { "approximant", required_argument, 0, 'C' }, { "order", required_argument, 0, 'v' }, { "h1-slide-segment", required_argument, 0, '!' }, { "h2-slide-segment", required_argument, 0, '&' }, { "l1-slide-segment", required_argument, 0, '(' }, { "v1-slide-segment", required_argument, 0, ')' }, { "sky-positions-file", required_argument, 0, '#' }, { "fft-level", required_argument, 0, '|' }, { "cluster-window", required_argument, 0, '4' }, { "inj-search-window", required_argument, 0, '3' }, { "inj-mchirp-window", required_argument, 0, '5' }, { "ligo-calibrated-data", required_argument, 0, '7' }, { "virgo-calibrated-data", required_argument, 0, '8' }, { "short-slide-offset", required_argument, 0, '@' }, { 0, 0, 0, 0 } }; char args[] = "a:A:b:B:c:C:D:e:E:f:F:g:G:h:H:i:I:j:J:k:K:l:L:m:M:n:N:o:O:p:P:q:Q:r:R:s:S:t:T:u:U:v:V:w:W:x:X:y:Y:z:Z:1:2:3:4:5:6:7:8:9:<:>:!:&:(:):#:|:@"; char *program = argv[0]; /* set default values for parameters before parsing arguments */ coh_PTF_default_params( &localparams ); 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 error( "error parsing option %s with argument %s\n", long_options[option_index].name, LALoptarg ); case 'a': /* gps-start-time */ localparams.startTime.gpsSeconds = atol( LALoptarg ); break; case 'A': /* gps-start-time-ns */ localparams.startTime.gpsNanoSeconds = atol( LALoptarg ); break; case 'b': /* gps-end-time */ localparams.endTime.gpsSeconds = atol( LALoptarg ); break; case 'B': /* gps-end-time-ns */ localparams.endTime.gpsNanoSeconds = atol( LALoptarg ); break; case '<': /* trigger-time */ localparams.trigTime.gpsSeconds = atol( LALoptarg ); break; case '>': /* trigger-time-ns */ localparams.trigTime.gpsNanoSeconds = atol( LALoptarg ); break; case 'c': /* h1 channel-name */ localparams.channel[LAL_IFO_H1] = LALoptarg; break; case 'D': /* h1 frame-cache */ localparams.dataCache[LAL_IFO_H1] = LALoptarg; break; case 'y': /* l1 channel-name */ localparams.channel[LAL_IFO_L1] = LALoptarg; break; case 'Y': /* l1 frame-cache */ localparams.dataCache[LAL_IFO_L1] = LALoptarg; break; case 'z': /* v1 channel-name */ localparams.channel[LAL_IFO_V1] = LALoptarg; break; case 'Z': /* v1 frame-cache */ localparams.dataCache[LAL_IFO_V1] = LALoptarg; break; case 'x': /* h2 channel-name */ localparams.channel[LAL_IFO_H2] = LALoptarg; break; case 'X': /* h2 frame-cache */ localparams.dataCache[LAL_IFO_H2] = LALoptarg; break; case 'e': /* start frequency of template generation */ localparams.lowTemplateFrequency = atof( LALoptarg ); break; case 'H': /* start frequency of matched filter */ localparams.lowFilterFrequency = atof( LALoptarg ); break; case 'I': /* End frequency of matched filter */ localparams.highFilterFrequency = atof( LALoptarg ); break; case 'E': /* highpass-frequency */ localparams.highpassFrequency = atof( LALoptarg ); break; case 'C': /* waveform approximant */ /* This will directly fail if the approximant is not a valid one. However the user may get to a call to FindChirpTDTemplate and find out only then that the approximant is not supported in there. */ localparams.approximant = XLALSimInspiralGetApproximantFromString(LALoptarg); break; case '6': /* Simulated data option */ localparams.simData = 1; if ( ! strcmp( "WhiteNoise",LALoptarg)) { localparams.simDataType = WHITE_PSD; } else if ( ! strcmp( "ILIGONoise",LALoptarg)) { localparams.simDataType = ILIGO_PSD; } else if ( ! strcmp( "ALIGONoise",LALoptarg)) { localparams.simDataType = ALIGO_PSD; } else { fprintf( stderr, "invalid argument to --%s:\n" "unknown data type specified:" "%s valid options are WhiteNoise, ILIGONoise or ALIGONoise", long_options[option_index].name, LALoptarg ); exit(1); } break; case 'v': /* PN order of waveform */ if ( ! strcmp( "twoPN", LALoptarg ) ) { localparams.order = LAL_PNORDER_TWO; } else if ( ! strcmp( "twoPointFivePN", LALoptarg ) ) { localparams.order = LAL_PNORDER_TWO_POINT_FIVE; } else if ( ! strcmp( "threePN", LALoptarg ) ) { localparams.order = LAL_PNORDER_THREE; } else if ( ! strcmp( "threePointFivePN", LALoptarg ) ) { localparams.order = LAL_PNORDER_THREE_POINT_FIVE; } else if ( ! strcmp( "pseudoFourPN", LALoptarg ) ) { localparams.order = LAL_PNORDER_PSEUDO_FOUR; } else { fprintf( stderr, "invalid argument to --%s:\n" "unknown order specified: " "%s (must be one of twoPN, twoPointFivePN, threePN, threePointFivePN, pseudoFourPN)\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } break; case 'f': /* right-ascension */ localparams.rightAscension = atof( LALoptarg ) * LAL_PI_180; break; case 'F': /* Declination */ localparams.declination = atof( LALoptarg ) * LAL_PI_180; break; case 'g': /* Error in declination */ localparams.skyError = atof( LALoptarg ) * LAL_PI_180; break; case 'G': /* timing accuracy of network */ localparams.timingAccuracy = atof( LALoptarg ); break; case 'h': /* help */ coh_PTF_usage( program ); exit( 0 ); case 'i': /* injection-file */ localparams.injectFile = LALoptarg; break; case 'j': localparams.threshold = atof(LALoptarg); break; case '2': localparams.spinThreshold = atof(LALoptarg); break; case '1': localparams.snglSNRThreshold = atof(LALoptarg); break; case 'J': localparams.timeWindow = atof(LALoptarg); break; case 'k': /* user-tag */ strncpy( localparams.userTag, LALoptarg, sizeof( localparams.userTag ) - 1 ); break; case 'K': /* ifo-tag */ strncpy( localparams.ifoTag, LALoptarg, sizeof( localparams.ifoTag ) - 1 ); break; case 'l': localparams.nonspinSNR2threshold = atof(LALoptarg); break; case 'L': localparams.spinSNR2threshold = atof(LALoptarg); break; case 'm': /* spin bank */ localparams.spinBank = 1; strncpy( localparams.spinBankName, LALoptarg, sizeof( localparams.spinBankName ) - 1 ); break; case 'M': /* non spin bank */ localparams.noSpinBank = 1; strncpy( localparams.noSpinBankName, LALoptarg, sizeof( localparams.noSpinBankName ) - 1 ); break; case 'n': /* only-segment-numbers */ localparams.segmentsToDoList = LALoptarg; break; case 'N': /* only-template-number */ localparams.templatesToDoList = LALoptarg; break; case 'o': /* output-file */ strncpy( localparams.outputFile, LALoptarg, sizeof( localparams.outputFile ) - 1 ); break; case 'O': /* bank-file */ localparams.bankFile = LALoptarg; break; case 'p': /* num auto chisq points */ localparams.numAutoPoints = atoi( LALoptarg ); break; case 'P': /* Auto veto time step */ localparams.autoVetoTimeStep = atof( LALoptarg ); break; case 'q': /* num chi square bins */ localparams.numChiSquareBins = atoi( LALoptarg ); break; case 'Q': localparams.chiSquareCalcThreshold = atof( LALoptarg ); break; case 'r': /* random seed */ localparams.randomSeed = atoi( LALoptarg ); break; case 'R': /* dynamic range factor */ localparams.dynRangeFac = atof( LALoptarg ); break; case 's': /* sample rate */ localparams.sampleRate = atof( LALoptarg ); break; case 'S': /* segment-duration */ localparams.segmentDuration = atof( LALoptarg ); break; case '9': /* PSD segment-duration */ localparams.psdSegmentDuration = atof( LALoptarg ); break; case 't': /* bank veto template bank */ localparams.bankVetoBankName = LALoptarg; break; case 'T': /* inverse-spec-length */ localparams.truncateDuration = atof( LALoptarg ); break; case 'u': /* trig-start-time */ localparams.trigStartTimeNS = (INT8) atol( LALoptarg ) * LAL_INT8_C(1000000000); break; case 'U': /* trig-end-time */ localparams.trigEndTimeNS = (INT8) atol( LALoptarg ) * LAL_INT8_C(1000000000); break; case 'w': /* block-duration */ localparams.duration = atof( LALoptarg ); break; case 'W': /* pad-data */ localparams.padData = atof( LALoptarg ); break; case '!': /* h1-slide-segment */ localparams.slideSegments[LAL_IFO_H1] = atoi( LALoptarg ); break; case '&': /* h2-slide-segments */ localparams.slideSegments[LAL_IFO_H2] = atoi( LALoptarg ); break; case '(': /* l1-slide-segments */ localparams.slideSegments[LAL_IFO_L1] = atoi( LALoptarg ); break; case ')': /* v1-slide-segments */ localparams.slideSegments[LAL_IFO_V1] = atoi( LALoptarg ); break; case '@': /* Short slide offset time */ localparams.shortSlideOffset = atoi( LALoptarg ); break; case 'V': /* version */ XLALOutputVersionString(stderr, 0); exit( 0 ); case '#': /* sky grid file */ localparams.skyPositionsFile = LALoptarg; break; case '|': /* FFT-level for plans */ localparams.fftLevel = atoi( LALoptarg ); break; case '4': /* Cluster window */ localparams.clusterWindow = atof(LALoptarg); break; case '3': /* Injection search window */ localparams.injSearchWindow = atof( LALoptarg ); break; case '5': /* Injection search window */ localparams.injMchirpWindow = atof( LALoptarg ); break; case '7': if (!strcmp("real_4", LALoptarg)) { localparams.ligoDoubleData = 0; } else if (!strcmp("real_8", LALoptarg)) { localparams.ligoDoubleData = 1; } else { fprintf(stderr, "invalid argument to --%s:\n" "unknown data type specified;\n" "%s (must be one of: real_4, real_8)\n", long_options[option_index].name, LALoptarg); } break; case '8': if (!strcmp("real_4", LALoptarg)) { localparams.virgoDoubleData = 0; } else if (!strcmp("real_8", LALoptarg)) { localparams.virgoDoubleData = 1; } else { fprintf(stderr, "invalid argument to --%s:\n" "unknown data type specified;\n" "%s (must be one of: real_4, real_8)\n", long_options[option_index].name, LALoptarg); } break; case '?': error( "unknown error while parsing options\n" ); default: error( "unknown error while parsing options\n" ); } } if ( LALoptind < argc ) { fprintf( stderr, "extraneous command line arguments:\n" ); while ( LALoptind < argc ) fprintf( stderr, "%s\n", argv[LALoptind++] ); exit( 1 ); } /* set number of ifos */ localparams.numIFO = 0; for ( ifoNumber = 0; ifoNumber < LAL_NUM_IFO; ifoNumber++ ) { if ( localparams.haveTrig[ifoNumber] ) { XLALReturnIFO(ifo,ifoNumber); snprintf( localparams.ifoName[localparams.numIFO], LIGOMETA_IFO_MAX,\ "%s", ifo ); localparams.numIFO++; } } /* check for H1H2 */ if (localparams.numIFO == 2) { if (! strcmp(localparams.ifoName[0],"H1")) { if (! strcmp(localparams.ifoName[1],"H2")) { localparams.singlePolFlag = 1; } } } /* Set the faceOn-faceAway flag */ /* Otherwise it takes default value of 0 */ if (localparams.faceOnAnalysis) { localparams.faceOnStatistic = 1; } else if (localparams.faceAwayAnalysis) { localparams.faceOnStatistic = 2; } /* Set the number of points in the time arrays */ localparams.numTimePoints = floor(\ localparams.segmentDuration * localparams.sampleRate + 0.5); /* Set the number of points in the frequency arrays */ localparams.numFreqPoints = localparams.numTimePoints / 2 + 1; /* For now we stick to only analysing half of each segment */ localparams.strideDuration = 0.5 * localparams.segmentDuration; /* FIXME: Hardcoded to 1s */ localparams.numBufferPoints = floor(localparams.sampleRate + 0.5); /* Choose the start and end point of each segment for analysis */ if (localparams.analSegmentEnd) { /* Want to analyse from the end of the segment */ /* Start from the end */ localparams.analEndPoint = localparams.numTimePoints; /* Remove the spectrum truncation */ localparams.analEndPoint -= floor(\ 0.5 * localparams.truncateDuration * localparams.sampleRate + 0.5); /* Remove the buffer points */ localparams.analEndPoint -= localparams.numBufferPoints; /* And set the start point */ localparams.analStartPoint = localparams.analEndPoint - \ 0.5*localparams.numTimePoints; } else { /* DEFAULT: Analyse the middle of the segment */ localparams.analStartPoint = 1*localparams.numTimePoints/4; localparams.analEndPoint = (3*localparams.numTimePoints)/4; } localparams.analStartTime = localparams.analStartPoint / \ localparams.sampleRate; localparams.analStartPointBuf = localparams.analStartPoint\ - localparams.numBufferPoints; localparams.analEndTime = localparams.analEndPoint / \ localparams.sampleRate; localparams.analEndPointBuf = localparams.analEndPoint\ + localparams.numBufferPoints; localparams.numAnalPoints = localparams.analEndPoint\ - localparams.analStartPoint; localparams.numAnalPointsBuf = localparams.analEndPointBuf\ - localparams.analStartPointBuf; /* Max template length is start length minus PSD truncation */ localparams.maxTempLength = localparams.analStartTime; localparams.maxTempLength -= localparams.truncateDuration/2.; /* Determine the number of short slides */ if (localparams.doShortSlides) { localparams.numShortSlides = 1 + localparams.numIFO * (int) floor( \ localparams.strideDuration / \ (localparams.shortSlideOffset * (localparams.numIFO-1)) ); } else { localparams.numShortSlides = 1; } /* Set the template correction factor */ if ( localparams.approximant == FindChirpSP) { /* Most of this gets stored in fcTmplt->fcTmpltNorm which is computed on * the fly. This is the correction needed to that. */ /* First need to add ( (df)**-7./6. )**2 */ localparams.tempCorrFac = pow(localparams.segmentDuration,14./6.); /* For some reason FindChirp multiplies by a dt factor, take this out */ localparams.tempCorrFac *= pow(localparams.sampleRate,2./6.); } else { /* Sigmasq factors are not yet available for all approximants */ /* Set values to 1 (so this factor has no effect) and warn user */ verbose("warning: Sigmasq correction factor is not yet available for this approximant: setting it to 1.\n"); localparams.tempCorrFac = 1.0; } *params = localparams; return 0; }
/* main program loop */ INT4 main(INT4 argc, CHAR *argv[]) { /* status */ LALStatus status = blank_status; /* LALgetopt flags */ static int text_flag; static int cat_flag; static int analyse_flag; static int powerlaw_flag; /* counters */ INT4 i, j; /* combined statistics variables */ REAL8 numerator = 0; REAL8 denominator = 0; REAL8 yOpt = 0; REAL8 sigmaOpt = 0; REAL8 confidence = 0.95; REAL8 zeta; REAL8 upperlimit; /* pdf */ REAL8 exponent; REAL8 pdf[100]; REAL8 min_omega; REAL8 max_omega; REAL8 min_alpha = -1; REAL8 max_alpha = 1; REAL8 omega; REAL8 alpha; /* powerlaw pdf */ REAL8 pdf_powerlaw[100][100]; REAL8 freq; REAL8 freq_ref = 100; REAL8 omega_numerator; REAL8 omega_denominator; REAL8 sigma2_denominator; REAL8 omega_hat[100]; REAL8 sigma2_omega_hat[100]; /* program option variables */ CHAR *outputFileName = NULL; /* xml data structures */ LIGOLwXMLStream xmlStream; INT4 numSegments = 0; StochasticTable *stochHead = NULL; StochasticTable *thisStoch = NULL; MetadataTable outputTable; StochasticTable **stochHandle = NULL; /* text output file */ FILE *out; FILE *pdf_out; FILE *omega_out; FILE *sigma_out; /* parse command line arguments */ while (1) { /* LALgetopt arguments */ static struct LALoption long_options[] = { /* options that set a flag */ {"verbose", no_argument, &vrbflg, 1}, {"text", no_argument, &text_flag, 1}, {"cat-only", no_argument, &cat_flag, 1}, {"analyse-only", no_argument, &analyse_flag, 1}, {"powerlaw-pdf", no_argument, &powerlaw_flag, 1}, /* options that don't set a flag */ {"help", no_argument, 0, 'h'}, {"version", no_argument, 0, 'v'}, {"output", required_argument, 0, 'o'}, {"confidence", required_argument, 0, 'c'}, {0, 0, 0, 0} }; int c; /* LALgetopt_long stores the option index here. */ int option_index = 0; size_t LALoptarg_len; c = LALgetopt_long_only(argc, argv, "hvo:c:", long_options, &option_index); /* detect the end of the options */ if (c == - 1) { /* end of options, break loop */ break; } switch (c) { case 0: /* If this option set a flag, do nothing else now. */ if (long_options[option_index].flag != 0) { break; } else { fprintf(stderr, "error parseing option %s with argument %s\n", \ long_options[option_index].name, LALoptarg); exit(1); } break; case 'h': fprintf(stdout, USAGE); exit(0); break; case 'v': /* display version info and exit */ fprintf(stdout, "Stochastic Post Processing: Bayesian\n"); XLALOutputVersionString(stderr,0); exit(0); break; case 'o': /* create storage for the output file name */ LALoptarg_len = strlen(LALoptarg) + 1; outputFileName = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(outputFileName, LALoptarg, LALoptarg_len); break; case 'c': /* confidence level */ confidence = atof(LALoptarg); if ((confidence >= 1) || (confidence <= 0)) { fprintf(stderr, "invalid argument to --%s\n" \ "confidence must be between 0 and 1, exclusive " \ "(%.2f specified)\n", long_options[option_index].name, \ confidence); exit(1); } break; case '?': exit(1); break; default: fprintf(stderr, "Unknown error while parsing options\n"); exit(1); } } /* read in the input data from the rest of the arguments */ if (LALoptind < argc) { for (i = LALoptind; i < argc; ++i) { struct stat infileStatus; /* if the named file does not exist, exit with an error */ if (stat(argv[i], &infileStatus) == -1) { fprintf(stderr, "Error opening input file \"%s\"\n", argv[i]); exit(1); } if (!stochHead) { stochHandle = &stochHead; } else { stochHandle = &thisStoch->next; } /* read in the stochastic table */ numSegments = LALStochasticTableFromLIGOLw(stochHandle, argv[i]); if (numSegments < 0) { fprintf(stderr, "Unable to read stochastic_table from \"%s\"\n", \ argv[i]); exit(1); } else if (numSegments > 0) { if (vrbflg) { fprintf(stdout, "Read in %d segments from file \"%s\"\n", \ numSegments, argv[i]); } /* scroll to end of list */ thisStoch = *stochHandle; while (thisStoch->next) { thisStoch = thisStoch->next; } } } } if (!cat_flag) { /* combine statistics */ for (thisStoch = stochHead; thisStoch; thisStoch = thisStoch->next) { numerator += thisStoch->cc_stat / (thisStoch->cc_sigma * \ thisStoch->cc_sigma); denominator += 1./(thisStoch->cc_sigma * thisStoch->cc_sigma); } yOpt = (1./stochHead->duration.gpsSeconds) * (numerator / denominator); sigmaOpt = (1./stochHead->duration.gpsSeconds) * (1./sqrt(denominator)); /* report point estimate and sigma */ fprintf(stdout, "yOpt = %e\n", yOpt); fprintf(stdout, "sigmaOpt = %e\n", sigmaOpt); /* calculate upperlimit */ zeta = yOpt / (sqrt(2) * sigmaOpt); upperlimit = yOpt + (sqrt(2) * sigmaOpt * \ stopp_erfcinv((1 - confidence) * gsl_sf_erfc(-zeta))); fprintf(stdout, "upperlimit = %e\n", upperlimit); } /* calculate pdf */ if (!powerlaw_flag) { /* pdf for constant spectra */ min_omega = 0; max_omega = yOpt + (3 * sigmaOpt); for (i = 0; i < 100; i++) { omega = min_omega + (((i - 1)/99.) * (max_omega - min_omega)); exponent = ((omega - yOpt) / sigmaOpt) * ((omega - yOpt) / sigmaOpt); pdf[i] = exp(-0.5 * exponent); } } else { /* pdf for power law spectra */ min_omega = 0; max_omega = 1; /*(10 * yOpt)/stochHead->duration.gpsSeconds;*/ min_alpha = -4; max_alpha = 4; /* loop for \Omega_R */ for (i = 0; i < 100; i++) { /* loop for \alpha */ for (j = 0; j < 100; j++) { omega = min_omega + ((i/99.) * (max_omega - min_omega)); alpha = min_alpha + ((j/99.) * (max_alpha - min_alpha)); /* initialise numerator */ omega_numerator = 0; omega_denominator = 0; sigma2_denominator = 0; /* loop over segments */ for (thisStoch = stochHead; thisStoch; thisStoch = thisStoch->next) { /* get frequency of middle of the band */ freq = thisStoch->f_min + ((thisStoch->f_max - \ thisStoch->f_min) / 2.); /* \hat{\Omega}_R */ omega_numerator += (thisStoch->cc_stat / (thisStoch->cc_sigma * \ thisStoch->cc_sigma)) * pow((freq/freq_ref), alpha); omega_denominator += (1. / (thisStoch->cc_sigma * \ thisStoch->cc_sigma)) * pow((freq/freq_ref), 2 * alpha); /* sigma^2_{\hat{\Omega}_R} */ sigma2_denominator += (1. / (thisStoch->cc_sigma * \ thisStoch->cc_sigma)) * pow((freq/freq_ref), 2 * alpha); } /* construct \hat{\Omega}_R */ omega_hat[j] = omega_numerator / (stochHead->duration.gpsSeconds * \ omega_denominator); /* construct sigma^2_{\hat{\Omega}_R} */ sigma2_omega_hat[j] = 1. / (stochHead->duration.gpsSeconds * \ stochHead->duration.gpsSeconds * sigma2_denominator); /* construct pdf */ pdf_powerlaw[i][j] = exp(-0.5 * ((omega - omega_hat[j]) / \ sqrt(sigma2_omega_hat[j])) * ((omega - omega_hat[j]) / \ sqrt(sigma2_omega_hat[j]))); } } } if (!cat_flag) { if (powerlaw_flag) { /* open omega and sigma output files */ if ((omega_out = fopen("omega.dat", "w")) == NULL) { fprintf(stderr, "Can't open file for omega output...\n"); exit(1); } if ((sigma_out = fopen("sigma.dat", "w")) == NULL) { fprintf(stderr, "Can't open file for sigma output...\n"); exit(1); } /* save out omega and sigma */ for (j = 0; j < 100; j++) { alpha = min_alpha + ((j/99.) * (max_alpha - min_alpha)); fprintf(omega_out, "%e %e\n", alpha, omega_hat[j]); fprintf(sigma_out, "%e %e\n", alpha, sqrt(sigma2_omega_hat[j])); } /* close files */ fclose(omega_out); fclose(sigma_out); } /* save out pdf */ if ((pdf_out = fopen("pdf.dat", "w")) == NULL) { fprintf(stderr, "Can't open file for pdf output...\n"); exit(1); } if (powerlaw_flag) { for (i = 0; i < 100; i++) { for (j = 0; j < 100; j++) { omega = min_omega + ((i/99.) * (max_omega - min_omega)); alpha = min_alpha + ((j/99.) * (max_alpha - min_alpha)); fprintf(pdf_out, "%e %e %e\n", omega, alpha, pdf_powerlaw[i][j]); } /* gnuplot */ fprintf(pdf_out, "\n"); } } else { for (i = 0; i < 100; i++) { omega = min_omega + (((i - 1)/99.) * (max_omega - min_omega)); fprintf(pdf_out, "%e %e\n", omega, pdf[i]); } } fclose(pdf_out); } if (!analyse_flag) { /* output as text file */ if (text_flag) { /* open output file */ if ((out = fopen(outputFileName, "w")) == NULL) { fprintf(stderr, "Can't open file \"%s\" for output...\n", \ outputFileName); exit(1); } /* write details of events */ for (thisStoch = stochHead; thisStoch; thisStoch = thisStoch->next) { fprintf(out, "%d %e %e\n", thisStoch->start_time.gpsSeconds, \ thisStoch->cc_stat, thisStoch->cc_sigma); } /* close output file */ fclose(out); } /* output as xml file */ else { /* open xml file stream */ memset(&xmlStream, 0, sizeof(LIGOLwXMLStream)); LAL_CALL(LALOpenLIGOLwXMLFile(&status, &xmlStream, outputFileName), \ &status); /* write stochastic table */ if (stochHead) { outputTable.stochasticTable = stochHead; LAL_CALL(LALBeginLIGOLwXMLTable(&status, &xmlStream, \ stochastic_table), &status); LAL_CALL(LALWriteLIGOLwXMLTable(&status, &xmlStream, outputTable, \ stochastic_table), &status); LAL_CALL(LALEndLIGOLwXMLTable(&status, &xmlStream), &status); } /* close xml file */ LAL_CALL(LALCloseLIGOLwXMLFile(&status, &xmlStream), &status); } } /* check for memory leaks and exit */ LALCheckMemoryLeaks(); exit(0); }
/*============================================================ * FUNCTION definitions *============================================================*/ int main(int argc, char *argv[]) { static LALStatus status; /* LALStatus pointer */ UserVariables_t XLAL_INIT_DECL(uvar); ConfigVariables_t XLAL_INIT_DECL(cfg); UINT4 k, numBins, numIFOs, maxNumSFTs, X, alpha; REAL8 Freq0, dFreq, normPSD; UINT4 finalBinSize, finalBinStep, finalNumBins; REAL8Vector *overSFTs = NULL; /* one frequency bin over SFTs */ REAL8Vector *overIFOs = NULL; /* one frequency bin over IFOs */ REAL8Vector *finalPSD = NULL; /* math. operation PSD over SFTs and IFOs */ REAL8Vector *finalNormSFT = NULL; /* normalised SFT power */ vrbflg = 1; /* verbose error-messages */ /* set LAL error-handler */ lal_errhandler = LAL_ERR_EXIT; /* register and read user variables */ if (initUserVars(argc, argv, &uvar) != XLAL_SUCCESS) return EXIT_FAILURE; MultiSFTVector *inputSFTs = NULL; if ( ( inputSFTs = XLALReadSFTs ( &cfg, &uvar ) ) == NULL ) { XLALPrintError ("Call to XLALReadSFTs() failed with xlalErrno = %d\n", xlalErrno ); return EXIT_FAILURE; } /* clean sfts if required */ if ( XLALUserVarWasSet( &uvar.linefiles ) ) { RandomParams *randPar=NULL; FILE *fpRand=NULL; INT4 seed, ranCount; if ( (fpRand = fopen("/dev/urandom", "r")) == NULL ) { fprintf(stderr,"Error in opening /dev/urandom" ); return EXIT_FAILURE; } if ( (ranCount = fread(&seed, sizeof(seed), 1, fpRand)) != 1 ) { fprintf(stderr,"Error in getting random seed" ); return EXIT_FAILURE; } LAL_CALL ( LALCreateRandomParams (&status, &randPar, seed), &status ); LAL_CALL( LALRemoveKnownLinesInMultiSFTVector ( &status, inputSFTs, uvar.maxBinsClean, uvar.blocksRngMed, uvar.linefiles, randPar), &status); LAL_CALL ( LALDestroyRandomParams (&status, &randPar), &status); fclose(fpRand); } /* end cleaning */ LogPrintf (LOG_DEBUG, "Computing spectrogram and PSD ... "); /* get power running-median rngmed[ |data|^2 ] from SFTs */ MultiPSDVector *multiPSD = NULL; XLAL_CHECK_MAIN( ( multiPSD = XLALNormalizeMultiSFTVect ( inputSFTs, uvar.blocksRngMed, NULL ) ) != NULL, XLAL_EFUNC); /* restrict this PSD to just the "physical" band if requested using {--Freq, --FreqBand} */ if ( ( XLALCropMultiPSDandSFTVectors ( multiPSD, inputSFTs, cfg.firstBin, cfg.lastBin )) != XLAL_SUCCESS ) { XLALPrintError ("%s: XLALCropMultiPSDandSFTVectors (inputPSD, inputSFTs, %d, %d) failed with xlalErrno = %d\n", __func__, cfg.firstBin, cfg.lastBin, xlalErrno ); return EXIT_FAILURE; } /* start frequency and frequency spacing */ Freq0 = multiPSD->data[0]->data[0].f0; dFreq = multiPSD->data[0]->data[0].deltaF; /* number of raw bins in final PSD */ numBins = multiPSD->data[0]->data[0].data->length; if ( (finalPSD = XLALCreateREAL8Vector ( numBins )) == NULL ) { LogPrintf (LOG_CRITICAL, "Out of memory!\n"); return EXIT_FAILURE; } /* number of IFOs */ numIFOs = multiPSD->length; if ( (overIFOs = XLALCreateREAL8Vector ( numIFOs )) == NULL ) { LogPrintf (LOG_CRITICAL, "Out of memory!\n"); return EXIT_FAILURE; } /* maximum number of SFTs */ maxNumSFTs = 0; for (X = 0; X < numIFOs; ++X) { maxNumSFTs = GSL_MAX(maxNumSFTs, multiPSD->data[X]->length); } if ( (overSFTs = XLALCreateREAL8Vector ( maxNumSFTs )) == NULL ) { LogPrintf (LOG_CRITICAL, "Out of memory!\n"); return EXIT_FAILURE; } /* normalize rngmd(power) to get proper *single-sided* PSD: Sn = (2/Tsft) rngmed[|data|^2]] */ normPSD = 2.0 * dFreq; /* loop over frequency bins in final PSD */ for (k = 0; k < numBins; ++k) { /* loop over IFOs */ for (X = 0; X < numIFOs; ++X) { /* number of SFTs for this IFO */ UINT4 numSFTs = multiPSD->data[X]->length; /* copy PSD frequency bins and normalise multiPSD for later use */ for (alpha = 0; alpha < numSFTs; ++alpha) { multiPSD->data[X]->data[alpha].data->data[k] *= normPSD; overSFTs->data[alpha] = multiPSD->data[X]->data[alpha].data->data[k]; } /* compute math. operation over SFTs for this IFO */ overIFOs->data[X] = math_op(overSFTs->data, numSFTs, uvar.PSDmthopSFTs); if ( isnan( overIFOs->data[X] ) ) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in overIFOs->data[X=%d] = NAN ... exiting\n", X ); } /* for IFOs X */ /* compute math. operation over IFOs for this frequency */ finalPSD->data[k] = math_op(overIFOs->data, numIFOs, uvar.PSDmthopIFOs); if ( isnan ( finalPSD->data[k] ) ) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in finalPSD->data[k=%d] = NAN ... exiting\n", k ); } /* for freq bins k */ LogPrintfVerbatim ( LOG_DEBUG, "done.\n"); /* compute normalised SFT power */ if (uvar.outputNormSFT) { LogPrintf (LOG_DEBUG, "Computing normalised SFT power ... "); if ( (finalNormSFT = XLALCreateREAL8Vector ( numBins )) == NULL ) { LogPrintf (LOG_CRITICAL, "Out of memory!\n"); return EXIT_FAILURE; } /* loop over frequency bins in SFTs */ for (k = 0; k < numBins; ++k) { /* loop over IFOs */ for (X = 0; X < numIFOs; ++X) { /* number of SFTs for this IFO */ UINT4 numSFTs = inputSFTs->data[X]->length; /* compute SFT power */ for (alpha = 0; alpha < numSFTs; ++alpha) { COMPLEX8 bin = inputSFTs->data[X]->data[alpha].data->data[k]; overSFTs->data[alpha] = crealf(bin)*crealf(bin) + cimagf(bin)*cimagf(bin); } /* compute math. operation over SFTs for this IFO */ overIFOs->data[X] = math_op(overSFTs->data, numSFTs, uvar.nSFTmthopSFTs); if ( isnan ( overIFOs->data[X] )) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in overIFOs->data[X=%d] = NAN ... exiting\n", X ); } /* over IFOs */ /* compute math. operation over IFOs for this frequency */ finalNormSFT->data[k] = math_op(overIFOs->data, numIFOs, uvar.nSFTmthopIFOs); if ( isnan( finalNormSFT->data[k] ) ) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in bin finalNormSFT->data[k=%d] = NAN ... exiting\n", k ); } /* over freq bins */ LogPrintfVerbatim ( LOG_DEBUG, "done.\n"); } /* output spectrograms */ if ( uvar.outputSpectBname ) { LAL_CALL ( LALfwriteSpectrograms ( &status, uvar.outputSpectBname, multiPSD ), &status ); } /* ---------- if user requested it, output complete MultiPSDVector over IFOs X, timestamps and freq-bins into ASCI file(s) */ if ( uvar.dumpMultiPSDVector ) { if ( XLALDumpMultiPSDVector ( uvar.outputPSD, multiPSD ) != XLAL_SUCCESS ) { XLALPrintError ("%s: XLALDumpMultiPSDVector() failed, xlalErrnor = %d\n", __func__, xlalErrno ); return EXIT_FAILURE; } } /* if uvar.dumpMultiPSDVector */ /* ----- if requested, compute data-quality factor 'Q' -------------------- */ if ( uvar.outputQ ) { REAL8FrequencySeries *Q; if ( (Q = XLALComputeSegmentDataQ ( multiPSD, cfg.dataSegment )) == NULL ) { XLALPrintError ("%s: XLALComputeSegmentDataQ() failed with xlalErrno = %d\n", __func__, xlalErrno ); return EXIT_FAILURE; } if ( XLAL_SUCCESS != XLALWriteREAL8FrequencySeries_to_file ( Q, uvar.outputQ ) ) { return EXIT_FAILURE; } XLALDestroyREAL8FrequencySeries ( Q ); } /* if outputQ */ /* ---------- BINNING if requested ---------- */ /* work out bin size */ if (XLALUserVarWasSet(&uvar.binSize)) { finalBinSize = uvar.binSize; } else if (XLALUserVarWasSet(&uvar.binSizeHz)) { finalBinSize = (UINT4)floor(uvar.binSizeHz / dFreq + 0.5); /* round to nearest bin */ } else { finalBinSize = 1; } /* work out bin step */ if (XLALUserVarWasSet(&uvar.binStep)) { finalBinStep = uvar.binStep; } else if (XLALUserVarWasSet(&uvar.binStepHz)) { finalBinStep = (UINT4)floor(uvar.binStepHz / dFreq + 0.5); /* round to nearest bin */ } else { finalBinStep = finalBinSize; } /* work out total number of bins */ finalNumBins = (UINT4)floor((numBins - finalBinSize) / finalBinStep) + 1; /* write final PSD to file */ if (XLALUserVarWasSet(&uvar.outputPSD)) { FILE *fpOut = NULL; if ((fpOut = fopen(uvar.outputPSD, "wb")) == NULL) { LogPrintf ( LOG_CRITICAL, "Unable to open output file %s for writing...exiting \n", uvar.outputPSD ); return EXIT_FAILURE; } /* write header info in comments */ if ( XLAL_SUCCESS != XLALOutputVersionString ( fpOut, 0 ) ) XLAL_ERROR ( XLAL_EFUNC ); /* write the command-line */ for (int a = 0; a < argc; a++) fprintf(fpOut,"%%%% argv[%d]: '%s'\n", a, argv[a]); /* write column headings */ fprintf(fpOut,"%%%% columns:\n%%%% FreqBinStart"); if (uvar.outFreqBinEnd) fprintf(fpOut," FreqBinEnd"); fprintf(fpOut," PSD"); if (uvar.outputNormSFT) fprintf(fpOut," normSFTpower"); fprintf(fpOut,"\n"); LogPrintf(LOG_DEBUG, "Printing PSD to file ... "); for (k = 0; k < finalNumBins; ++k) { UINT4 b = k * finalBinStep; REAL8 f0 = Freq0 + b * dFreq; REAL8 f1 = f0 + finalBinStep * dFreq; fprintf(fpOut, "%f", f0); if (uvar.outFreqBinEnd) fprintf(fpOut, " %f", f1); REAL8 psd = math_op(&(finalPSD->data[b]), finalBinSize, uvar.PSDmthopBins); if ( isnan ( psd )) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in psd[k=%d] = NAN ... exiting\n", k ); fprintf(fpOut, " %e", psd); if (uvar.outputNormSFT) { REAL8 nsft = math_op(&(finalNormSFT->data[b]), finalBinSize, uvar.nSFTmthopBins); if ( isnan ( nsft )) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in nsft[k=%d] = NAN ... exiting\n", k ); fprintf(fpOut, " %f", nsft); } fprintf(fpOut, "\n"); } // k < finalNumBins LogPrintfVerbatim ( LOG_DEBUG, "done.\n"); fclose(fpOut); } /* we are now done with the psd */ XLALDestroyMultiPSDVector ( multiPSD); XLALDestroyMultiSFTVector ( inputSFTs); XLALDestroyUserVars(); XLALDestroyREAL8Vector ( overSFTs ); XLALDestroyREAL8Vector ( overIFOs ); XLALDestroyREAL8Vector ( finalPSD ); XLALDestroyREAL8Vector ( finalNormSFT ); LALCheckMemoryLeaks(); return EXIT_SUCCESS; } /* main() */
int main(int argc, char *argv[]) { LALStatus status = blank_status; ConfigVariables XLAL_INIT_DECL(config); UserVariables_t XLAL_INIT_DECL(uvar); /* register user-variables */ XLAL_CHECK ( XLALInitUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC ); /* read cmdline & cfgfile */ BOOLEAN should_exit = 0; XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC ); if ( should_exit ) { exit(1); } if ( uvar.version ) { XLALOutputVersionString ( stdout, lalDebugLevel ); exit(0); } /* basic setup and initializations */ XLAL_CHECK ( XLALInitCode( &config, &uvar, argv[0] ) == XLAL_SUCCESS, XLAL_EFUNC ); /* ----- allocate memory for AM-coeffs ----- */ AMCoeffs AMold, AMnew1, AMnew2; /**< containers holding AM-coefs computed by 3 different AM functions */ AMold.a = XLALCreateREAL4Vector ( 1 ); AMold.b = XLALCreateREAL4Vector ( 1 ); AMnew1.a = XLALCreateREAL4Vector ( 1 ); AMnew1.b = XLALCreateREAL4Vector ( 1 ); AMnew2.a = XLALCreateREAL4Vector ( 1 ); AMnew2.b = XLALCreateREAL4Vector ( 1 ); XLAL_CHECK ( AMold.a && AMold.b && AMnew1.a && AMnew1.b && AMnew2.a && AMnew2.a, XLAL_ENOMEM, "Failed to XLALCreateREAL4Vector ( 1 )\n" ); /* ----- get detector-state series ----- */ DetectorStateSeries *detStates = NULL; XLAL_CHECK ( (detStates = XLALGetDetectorStates ( config.timestamps, config.det, config.edat, 0 )) != NULL, XLAL_EFUNC ); /* ----- compute associated SSB timing info ----- */ SSBtimes *tSSB = XLALGetSSBtimes ( detStates, config.skypos, config.timeGPS, SSBPREC_RELATIVISTIC ); XLAL_CHECK ( tSSB != NULL, XLAL_EFUNC, "XLALGetSSBtimes() failed with xlalErrno = %d\n", xlalErrno ); /* ===== 1) compute AM-coeffs the 'old way': [used in CFSv1] ===== */ BarycenterInput XLAL_INIT_DECL(baryinput); AMCoeffsParams XLAL_INIT_DECL(amParams); EarthState earth; baryinput.site.location[0] = config.det->location[0]/LAL_C_SI; baryinput.site.location[1] = config.det->location[1]/LAL_C_SI; baryinput.site.location[2] = config.det->location[2]/LAL_C_SI; baryinput.alpha = config.skypos.longitude; baryinput.delta = config.skypos.latitude; baryinput.dInv = 0.e0; /* amParams structure to compute a(t) and b(t) */ amParams.das = XLALMalloc(sizeof(*amParams.das)); amParams.das->pSource = XLALMalloc(sizeof(*amParams.das->pSource)); amParams.baryinput = &baryinput; amParams.earth = &earth; amParams.edat = config.edat; amParams.das->pDetector = config.det; amParams.das->pSource->equatorialCoords.longitude = config.skypos.longitude; amParams.das->pSource->equatorialCoords.latitude = config.skypos.latitude; amParams.das->pSource->orientation = 0.0; amParams.das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL; amParams.polAngle = 0; LAL_CALL ( LALComputeAM ( &status, &AMold, config.timestamps->data, &amParams), &status); XLALFree ( amParams.das->pSource ); XLALFree ( amParams.das ); /* ===== 2) compute AM-coeffs the 'new way' using LALNewGetAMCoeffs() */ LALGetAMCoeffs ( &status, &AMnew1, detStates, config.skypos ); if ( status.statusCode ) { XLALPrintError ("%s: call to LALGetAMCoeffs() failed, status = %d\n\n", __func__, status.statusCode ); XLAL_ERROR ( status.statusCode & XLAL_EFUNC ); } /* ===== 3) compute AM-coeffs the 'newer way' using LALNewGetAMCoeffs() [used in CFSv2] */ LALNewGetAMCoeffs ( &status, &AMnew2, detStates, config.skypos ); if ( status.statusCode ) { XLALPrintError ("%s: call to LALNewGetAMCoeffs() failed, status = %d\n\n", __func__, status.statusCode ); XLAL_ERROR ( status.statusCode & XLAL_EFUNC ); } /* ===== 4) use standalone version of the above [used in FstatMetric_v2] */ REAL8 a0,b0; if ( XLALComputeAntennaPatternCoeffs ( &a0, &b0, &config.skypos, &config.timeGPS, config.det, config.edat ) != XLAL_SUCCESS ) { XLALPrintError ("%s: XLALComputeAntennaPatternCoeffs() failed.\n", __func__ ); XLAL_ERROR ( XLAL_EFUNC ); } /* ==================== output the results ==================== */ printf ("\n"); printf ("----- Input parameters:\n"); printf ("tGPS = { %d, %d }\n", config.timeGPS.gpsSeconds, config.timeGPS.gpsNanoSeconds ); printf ("Detector = %s\n", config.det->frDetector.name ); printf ("Sky position: longitude = %g rad, latitude = %g rad [equatorial coordinates]\n", config.skypos.longitude, config.skypos.latitude ); printf ("\n"); printf ("----- Antenna pattern functions (a,b):\n"); printf ("LALComputeAM: ( %-12.8g, %-12.8g) [REAL4]\n", AMold.a->data[0], AMold.b->data[0] ); printf ("LALGetAMCoeffs: ( %-12.8g, %-12.8g) [REAL4]\n", AMnew1.a->data[0], AMnew1.b->data[0] ); printf ("LALNewGetAMCoeffs: ( %-12.8g, %-12.8g) [REAL4]\n", AMnew2.a->data[0]/config.sinzeta, AMnew2.b->data[0]/config.sinzeta ); printf ("XLALComputeAntennaPatternCoeffs: ( %-12.8g, %-12.8g) [REAL8]\n", a0/config.sinzeta, b0/config.sinzeta ); printf ("\n"); printf ("----- Detector & Earth state:\n"); REAL8 *pos = detStates->data[0].rDetector; printf ("Detector position [ICRS J2000. Units=sec]: rDet = {%g, %g, %g}\n", pos[0], pos[1], pos[2] ); REAL8 *vel = detStates->data[0].vDetector; printf ("Detector velocity [ICRS J2000. Units=c]: vDet = {%g, %g, %g}\n", vel[0], vel[1], vel[2] ); printf ("Local mean sideral time: LMST = %g rad\n", detStates->data[0].LMST); printf ("\n"); printf ("----- SSB timing data:\n"); printf ("TOA difference tSSB - tDet = %g s\n", tSSB->DeltaT->data[0] ); printf ("TOA rate of change dtSSB/dtDet - 1 = %g\n", tSSB->Tdot->data[0] - 1.0 ); printf ("\n\n"); /* ----- done: free all memory */ XLAL_CHECK ( XLALDestroyConfig( &config ) == XLAL_SUCCESS, XLAL_EFUNC ); XLALDestroyDetectorStateSeries ( detStates ); XLALDestroyREAL4Vector ( AMold.a ); XLALDestroyREAL4Vector ( AMold.b ); XLALDestroyREAL4Vector ( AMnew1.a ); XLALDestroyREAL4Vector ( AMnew1.b ); XLALDestroyREAL4Vector ( AMnew2.a ); XLALDestroyREAL4Vector ( AMnew2.b ); XLALDestroyREAL8Vector ( tSSB->DeltaT ); XLALDestroyREAL8Vector ( tSSB->Tdot ); XLALFree (tSSB); LALCheckMemoryLeaks(); return 0; } /* main */
int main( int argc, char *argv[] ) { static LALStatus status; LALPlaygroundDataMask dataType = unspecified_data_type; SnglInspiralParameterTest test = unspecified_test; INT4 startTime = -1; LIGOTimeGPS startTimeGPS = {0,0}; INT4 endTime = -1; LIGOTimeGPS endTimeGPS = {0,0}; INT4 startChunkTime = -1; LIGOTimeGPS startChunkTimeGPS = {0,0}; INT4 endChunkTime = -1; LIGOTimeGPS endChunkTimeGPS = {0,0}; int coherentRun = 0; INT4 coherentBuffer = 64; CHAR inputIFO[LIGOMETA_IFO_MAX]; CHAR outputIFO[LIGOMETA_IFO_MAX]; CHAR comment[LIGOMETA_COMMENT_MAX]; CHAR *userTag = NULL; CHAR *ifoTag = NULL; CHAR fileName[FILENAME_MAX]; INT4 numTriggers = 0; SnglInspiralTable *inspiralEventList=NULL; SnglInspiralTable *currentTrigger = NULL; SearchSummvarsTable *inputFiles = NULL; SearchSummvarsTable *thisInputFile = NULL; SearchSummaryTable *searchSummList = NULL; SearchSummaryTable *thisSearchSumm = NULL; MetadataTable proctable; MetadataTable processParamsTable; MetadataTable searchsumm; MetadataTable searchSummvarsTable; MetadataTable inspiralTable; ProcessParamsTable *this_proc_param = NULL; LIGOLwXMLStream xmlStream; INT4 outCompress = 0; INT4 i; /* LALgetopt arguments */ struct LALoption long_options[] = { {"verbose", no_argument, &vrbflg, 1 }, {"check-times", no_argument, &checkTimes, 1 }, {"write-compress", no_argument, &outCompress, 1 }, {"input-ifo", required_argument, 0, 'a'}, {"output-ifo", required_argument, 0, 'b'}, {"parameter-test", required_argument, 0, 'A'}, {"data-type", required_argument, 0, 'D'}, {"gps-start-time", required_argument, 0, 'q'}, {"gps-end-time", required_argument, 0, 'r'}, {"comment", required_argument, 0, 's'}, {"coherent-run", no_argument, &coherentRun, 1 }, {"coherent-buffer", required_argument, &coherentBuffer, 't'}, {"user-tag", required_argument, 0, 'Z'}, {"userTag", required_argument, 0, 'Z'}, {"ifo-tag", required_argument, 0, 'I'}, {"help", no_argument, 0, 'h'}, {"version", no_argument, 0, 'V'}, {0, 0, 0, 0} }; int c; /* * * initialize things * */ lal_errhandler = LAL_ERR_EXIT; setvbuf( stdout, NULL, _IONBF, 0 ); /* create the process and process params tables */ proctable.processTable = (ProcessTable *) calloc( 1, sizeof(ProcessTable) ); XLALGPSTimeNow(&(proctable.processTable->start_time)); XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME, lalAppsVCSIdentId, lalAppsVCSIdentStatus, lalAppsVCSIdentDate, 0); this_proc_param = processParamsTable.processParamsTable = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); memset( comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR) ); /* create the search summary and zero out the summvars table */ searchsumm.searchSummaryTable = (SearchSummaryTable *) calloc( 1, sizeof(SearchSummaryTable) ); /* parse the arguments */ while ( 1 ) { /* LALgetopt_long stores long option here */ int option_index = 0; long int gpstime; size_t LALoptarg_len; c = LALgetopt_long_only( argc, argv, "a:b:hq:r:s:t:A:I:VZ:", long_options, &option_index ); /* detect the end of the options */ if ( c == -1 ) { break; } switch ( c ) { case 0: /* if this option set a flag, do nothing else now */ if ( long_options[option_index].flag != 0 ) { break; } else { fprintf( stderr, "Error parsing option %s with argument %s\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } break; case 'a': /* name of input ifo*/ strncpy( inputIFO, LALoptarg, LIGOMETA_IFO_MAX ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'b': /* name of output ifo */ strncpy( outputIFO, LALoptarg, LIGOMETA_IFO_MAX ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'A': /* comparison used to test for uniqueness of triggers */ if ( ! strcmp( "m1_and_m2", LALoptarg ) ) { test = m1_and_m2; } else if ( ! strcmp( "psi0_and_psi3", LALoptarg ) ) { test = psi0_and_psi3; } else if ( ! strcmp( "mchirp_and_eta", LALoptarg ) ) { fprintf( stderr, "invalid argument to --%s:\n" "mchirp_and_eta test specified, not implemented for trigbank: " "%s (must be m1_and_m2, psi0_and_psi3, no_test)\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } else if ( ! strcmp( "no_test", LALoptarg ) ) { test = no_test; } else { fprintf( stderr, "invalid argument to --%s:\n" "unknown test specified: " "%s (must be m1_and_m2, psi0_and_psi3,no_test, or mchirp_and_eta)\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'D': /* type of data to analyze */ if ( ! strcmp( "playground_only", LALoptarg ) ) { dataType = playground_only; } else if ( ! strcmp( "exclude_play", LALoptarg ) ) { dataType = exclude_play; } else if ( ! strcmp( "all_data", LALoptarg ) ) { dataType = all_data; } else { fprintf( stderr, "invalid argument to --%s:\n" "unknown data type, %s, specified: " "(must be playground_only, exclude_play or all_data)\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'q': /* start time */ gpstime = atol( LALoptarg ); if ( gpstime < 441417609 ) { fprintf( stderr, "invalid argument to --%s:\n" "GPS start time is prior to " "Jan 01, 1994 00:00:00 UTC:\n" "(%ld specified)\n", long_options[option_index].name, gpstime ); exit( 1 ); } startTime = (INT4) gpstime; startTimeGPS.gpsSeconds = startTime; ADD_PROCESS_PARAM( "int", "%" LAL_INT4_FORMAT, startTime ); break; case 'r': /* end time */ gpstime = atol( LALoptarg ); if ( gpstime < 441417609 ) { fprintf( stderr, "invalid argument to --%s:\n" "GPS start time is prior to " "Jan 01, 1994 00:00:00 UTC:\n" "(%ld specified)\n", long_options[option_index].name, gpstime ); exit( 1 ); } endTime = (INT4) gpstime; endTimeGPS.gpsSeconds = endTime; ADD_PROCESS_PARAM( "int", "%" LAL_INT4_FORMAT, endTime ); break; case 's': if ( strlen( LALoptarg ) > LIGOMETA_COMMENT_MAX - 1 ) { fprintf( stderr, "invalid argument to --%s:\n" "comment must be less than %d characters\n", long_options[option_index].name, LIGOMETA_COMMENT_MAX ); exit( 1 ); } else { snprintf( comment, LIGOMETA_COMMENT_MAX, "%s", LALoptarg); } break; case 't': coherentBuffer = (INT4) atoi( LALoptarg ); if ( coherentBuffer < 0 ) { fprintf( stderr, "invalid argument to --%s:\n" "coherent-buffer duration (sec) must be positive or zero: " "(%d specified)\n", long_options[option_index].name, coherentBuffer ); exit( 1 ); } ADD_PROCESS_PARAM( "int", "%d", coherentBuffer ); break; case 'h': /* help message */ print_usage(argv[0]); exit( 1 ); break; case 'Z': /* create storage for the usertag */ LALoptarg_len = strlen(LALoptarg) + 1; userTag = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR) ); memcpy( userTag, LALoptarg, LALoptarg_len ); this_proc_param = this_proc_param->next = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "-userTag" ); snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%s", LALoptarg ); break; case 'I': /* create storage for the ifo-tag */ LALoptarg_len = strlen(LALoptarg) + 1; ifoTag = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR) ); memcpy( ifoTag, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'V': /* print version information and exit */ fprintf( stdout, "Inspiral Triggered Bank Generator\n" "Patrick Brady, Duncan Brown and Steve Fairhurst\n"); XLALOutputVersionString(stderr, 0); exit( 0 ); break; case '?': print_usage(argv[0]); exit( 1 ); break; default: fprintf( stderr, "Error: Unknown error while parsing options\n" ); print_usage(argv[0]); exit( 1 ); } } /* check the values of the arguments */ if ( startTime < 0 ) { fprintf( stderr, "Error: --gps-start-time must be specified\n" ); exit( 1 ); } if ( endTime < 0 ) { fprintf( stderr, "Error: --gps-end-time must be specified\n" ); exit( 1 ); } if ( dataType == unspecified_data_type ) { fprintf( stderr, "Error: --data-type must be specified\n"); exit(1); } if ( test == unspecified_test ) { fprintf( stderr, "Error: --parameter-test must be specified\n"); exit(1); } /* fill the comment, if a user has specified one, or leave it blank */ if ( ! *comment ) { snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " ); snprintf( searchsumm.searchSummaryTable->comment, LIGOMETA_COMMENT_MAX, " " ); } else { snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, "%s", comment ); snprintf( searchsumm.searchSummaryTable->comment, LIGOMETA_COMMENT_MAX, "%s", comment ); } /* store the check-times in the process_params table */ if ( checkTimes ) { this_proc_param = this_proc_param->next = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "--check-times"); snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( this_proc_param->value, LIGOMETA_TYPE_MAX, " " ); } /* delete the first, empty process_params entry */ this_proc_param = processParamsTable.processParamsTable; processParamsTable.processParamsTable = processParamsTable.processParamsTable->next; free( this_proc_param ); /* * * read in the input data from the rest of the arguments * */ if ( LALoptind < argc ) { for( i = LALoptind; i < argc; ++i ) { INT4 numFileTriggers = 0; numFileTriggers = XLALReadInspiralTriggerFile( &inspiralEventList, ¤tTrigger, &searchSummList, &inputFiles, argv[i] ); if (numFileTriggers < 0) { fprintf(stderr, "Error reading triggers from file %s", argv[i]); exit( 1 ); } numTriggers += numFileTriggers; } } else { fprintf( stderr, "Error: No trigger files specified.\n" ); exit( 1 ); } if ( vrbflg ) fprintf( stdout, "Read in a total of %d triggers.\n", numTriggers ); /* check that we have read in data for all the requested time */ if ( checkTimes ) { if ( vrbflg ) fprintf( stdout, "Checking that we have data for all times from %s\n", inputIFO); LAL_CALL( LALCheckOutTimeFromSearchSummary ( &status, searchSummList, inputIFO, &startTimeGPS, &endTimeGPS ), &status); } if ( ! inspiralEventList ) { /* no triggers read in so triggered bank will be empty */ fprintf( stdout, "No triggers read in\n"); /* set numTriggers in case any cuts are made in future */ numTriggers = 0; goto cleanexit; } /* keep only triggers from input ifo */ LAL_CALL( LALIfoCutSingleInspiral( &status, &inspiralEventList, inputIFO ), &status ); /* time sort the triggers */ if ( vrbflg ) fprintf( stdout, "Sorting triggers\n" ); LAL_CALL( LALSortSnglInspiral( &status, &inspiralEventList, LALCompareSnglInspiralByTime ), &status ); /* keep only triggers within the requested interval */ if ( vrbflg ) fprintf( stdout, "Discarding triggers outside requested interval\n" ); if ( coherentRun ) { startChunkTime = startTimeGPS.gpsSeconds + coherentBuffer; startChunkTimeGPS.gpsSeconds = startChunkTime; endChunkTime = endTimeGPS.gpsSeconds - coherentBuffer; endChunkTimeGPS.gpsSeconds = endChunkTime; LAL_CALL( LALTimeCutSingleInspiral( &status, &inspiralEventList, &startChunkTimeGPS, &endChunkTimeGPS), &status ); } else { LAL_CALL( LALTimeCutSingleInspiral( &status, &inspiralEventList, &startTimeGPS, &endTimeGPS), &status ); } /* keep play/non-play/all triggers */ if ( dataType == playground_only && vrbflg ) fprintf( stdout, "Keeping only playground triggers\n" ); else if ( dataType == exclude_play && vrbflg ) fprintf( stdout, "Keeping only non-playground triggers\n" ); else if ( dataType == all_data && vrbflg ) fprintf( stdout, "Keeping all triggers\n" ); LAL_CALL( LALPlayTestSingleInspiral( &status, &inspiralEventList, &dataType ), &status ); if( !inspiralEventList ) { if ( vrbflg ) fprintf( stdout, "No triggers remain after time and playground cuts.\n" ); /* set numTriggers after cuts were applied */ numTriggers = 0; goto cleanexit; } /* Generate the triggered bank */ if( test != no_test ) { LAL_CALL( LALCreateTrigBank( &status, &inspiralEventList, &test ), &status ); } /* count the number of triggers */ for( currentTrigger = inspiralEventList, numTriggers = 0; currentTrigger; currentTrigger = currentTrigger->next, ++numTriggers); if ( vrbflg ) fprintf( stdout, "%d triggers to be written to trigbank.\n", numTriggers ); /* * * write the output xml file * */ cleanexit: /* search summary entries: */ searchsumm.searchSummaryTable->in_start_time = startTimeGPS; searchsumm.searchSummaryTable->in_end_time = endTimeGPS; searchsumm.searchSummaryTable->out_start_time = startTimeGPS; searchsumm.searchSummaryTable->out_end_time = endTimeGPS; searchsumm.searchSummaryTable->nevents = numTriggers; if ( vrbflg ) fprintf( stdout, "writing output file... " ); /* set the file name correctly */ if ( userTag && ifoTag && !outCompress ) { snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s_%s-%d-%d.xml", outputIFO, ifoTag, userTag, startTime, endTime - startTime ); } else if ( userTag && !ifoTag && !outCompress ) { snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s-%d-%d.xml", outputIFO, userTag, startTime, endTime - startTime ); } else if ( !userTag && ifoTag && !outCompress ) { snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s-%d-%d.xml", outputIFO, ifoTag, startTime, endTime - startTime ); } else if ( userTag && ifoTag && outCompress ) { snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s_%s-%d-%d.xml.gz", outputIFO, ifoTag, userTag, startTime, endTime - startTime ); } else if ( userTag && !ifoTag && outCompress ) { snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s-%d-%d.xml.gz", outputIFO, userTag, startTime, endTime - startTime ); } else if ( !userTag && ifoTag && outCompress ) { snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s-%d-%d.xml.gz", outputIFO, ifoTag, startTime, endTime - startTime ); } else if ( !userTag && !ifoTag && outCompress ) { snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK-%d-%d.xml.gz", outputIFO, startTime, endTime - startTime ); } else { snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK-%d-%d.xml", outputIFO, startTime, endTime - startTime ); } memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) ); LAL_CALL( LALOpenLIGOLwXMLFile( &status , &xmlStream, fileName ), &status ); /* write process table */ snprintf( proctable.processTable->ifos, LIGOMETA_IFOS_MAX, "%s", inputIFO ); XLALGPSTimeNow(&(proctable.processTable->end_time)); LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, proctable, process_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* write process_params table */ LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_params_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, processParamsTable, process_params_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* write search_summary table */ LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, search_summary_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, searchsumm, search_summary_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* write the search_summvars tabls */ LAL_CALL( LALBeginLIGOLwXMLTable( &status ,&xmlStream, search_summvars_table), &status ); searchSummvarsTable.searchSummvarsTable = inputFiles; LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, searchSummvarsTable, search_summvars_table), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream), &status ); /* write the sngl_inspiral table */ if ( inspiralEventList ) { LAL_CALL( LALBeginLIGOLwXMLTable( &status ,&xmlStream, sngl_inspiral_table), &status ); inspiralTable.snglInspiralTable = inspiralEventList; LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, inspiralTable, sngl_inspiral_table), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream), &status ); } LAL_CALL( LALCloseLIGOLwXMLFile( &status, &xmlStream), &status ); if ( vrbflg ) fprintf( stdout, "done\n" ); /* * * clean up the memory that has been allocated * */ if ( vrbflg ) fprintf( stdout, "freeing memory... " ); free( proctable.processTable ); free( searchsumm.searchSummaryTable ); while ( processParamsTable.processParamsTable ) { this_proc_param = processParamsTable.processParamsTable; processParamsTable.processParamsTable = this_proc_param->next; free( this_proc_param ); } while ( inputFiles ) { thisInputFile = inputFiles; inputFiles = thisInputFile->next; LALFree( thisInputFile ); } while ( searchSummList ) { thisSearchSumm = searchSummList; searchSummList = searchSummList->next; LALFree( thisSearchSumm ); } while ( inspiralEventList ) { currentTrigger = inspiralEventList; inspiralEventList = inspiralEventList->next; LAL_CALL( LALFreeSnglInspiral( &status, ¤tTrigger ), &status ); } if ( userTag ) free( userTag ); if ( ifoTag ) free( ifoTag ); if ( vrbflg ) fprintf( stdout, "done\n" ); LALCheckMemoryLeaks(); exit( 0 ); }
/* parse command line options */ static void parse_options(INT4 argc, CHAR *argv[]) { int c = -1; struct stat fileStatus; /* tempory variables */ CHAR *channelOneTemp = NULL; CHAR *channelTwoTemp = NULL; while(1) { static struct LALoption long_options[] = { /* options that set a flag */ {"middle-segment", no_argument, &middle_segment_flag, 1}, {"apply-mask", no_argument, &apply_mask_flag, 1}, {"high-pass-filter", no_argument, &high_pass_flag, 1}, {"overlap-hann", no_argument, &overlap_hann_flag, 1}, {"verbose", no_argument, &vrbflg, 1}, {"recentre", no_argument, &recentre_flag, 1}, {"cc-spectra", no_argument, &cc_spectra_flag, 1}, {"debug", no_argument, &debug_flag, 1}, /* options that don't set a flag */ {"help", no_argument, 0, 'a'}, {"version", no_argument, 0, 'b'}, {"user-tag", required_argument, 0, 'd'}, {"comment", required_argument, 0, 'e'}, {"output-dir", required_argument, 0, 'f'}, {"gps-start-time", required_argument, 0, 'g'}, {"gps-end-time", required_argument, 0, 'h'}, {"interval-duration", required_argument, 0, 'i'}, {"segment-duration", required_argument, 0, 'j'}, {"resample-rate", required_argument, 0, 'k'}, {"f-min", required_argument, 0, 'l'}, {"f-max", required_argument, 0, 'm'}, {"ifo-one", required_argument, 0, 'n'}, {"ifo-two", required_argument, 0, 'o'}, {"channel-one", required_argument, 0, 'p'}, {"channel-two", required_argument, 0, 'q'}, {"frame-cache-one", required_argument, 0, 'r'}, {"frame-cache-two", required_argument, 0, 's'}, {"calibration-cache-one", required_argument, 0, 't'}, {"calibration-cache-two", required_argument, 0, 'u'}, {"calibration-offset", required_argument, 0, 'v'}, {"mask-bin", required_argument, 0, 'w'}, {"hann-duration", required_argument, 0, 'x'}, {"hpf-frequency", required_argument, 0, 'y'}, {"hpf-attenuation", required_argument, 0, 'z'}, {"hpf-order", required_argument, 0, 'A'}, {"geo-hpf-frequency", required_argument, 0, 'B'}, {"geo-hpf-attenuation", required_argument, 0, 'C'}, {"geo-hpf-order", required_argument, 0, 'D'}, {"alpha", required_argument, 0, 'E'}, {"f-ref", required_argument, 0, 'F'}, {"omega0", required_argument, 0, 'G'}, {0, 0, 0, 0} }; /* LALgetopt_long stores the option here */ int option_index = 0; size_t LALoptarg_len; c = LALgetopt_long_only(argc, argv, \ "abd:e:f:g:h:i:j:k:l:m:n:o:p:q:r:s:t:u:v:w:x:y:z:" \ "A:B:C:D:E:F:G:", long_options, &option_index); if (c == -1) { /* end of options, break loop */ break; } switch(c) { case 0: /* If this option set a flag, do nothing else now. */ if (long_options[option_index].flag != 0) { break; } else { fprintf(stderr, "error parseing option %s with argument %s\n", \ long_options[option_index].name, LALoptarg); exit(1); } break; case 'a': /* help */ display_usage(); exit(0); break; case 'b': /* display version info and exit */ fprintf(stdout, "Standalone SGWB Search Engine\n"); XLALOutputVersionString(stderr,0); exit(0); break; case 'd': /* user tag */ LALoptarg_len = strlen(LALoptarg) + 1; userTag = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(userTag, LALoptarg, LALoptarg_len); /* add to process_params table */ this_proc_param = this_proc_param->next = (ProcessParamsTable *) \ calloc(1, sizeof(ProcessParamsTable)); snprintf(this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s", prog_name); snprintf(this_proc_param->param, LIGOMETA_PARAM_MAX, "--user-tag"); snprintf(this_proc_param->type, LIGOMETA_TYPE_MAX, "string"); snprintf(this_proc_param->value, LIGOMETA_VALUE_MAX, "%s", LALoptarg); break; case 'e': /* xml comment */ if (strlen(LALoptarg) > LIGOMETA_COMMENT_MAX - 1) { fprintf(stderr, "invalid argument to --%s:\n" \ "comment must be less than %d characters\n", \ long_options[option_index].name, LIGOMETA_COMMENT_MAX); exit(1); } else { snprintf(comment, LIGOMETA_COMMENT_MAX, "%s", LALoptarg); } break; case 'f': /* directory for output files */ LALoptarg_len = strlen(LALoptarg) + 1; outputPath = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(outputPath, LALoptarg, LALoptarg_len); if (stat(outputPath, &fileStatus) == -1) { fprintf(stderr, "Invalid argument to --%s:\n" \ "Directory does not exist: (%s specified)\n", \ long_options[option_index].name, outputPath); exit(1); } ADD_PROCESS_PARAM("string", "%s", outputPath); break; case 'g': /* start time */ startTime = atoi(LALoptarg); if (startTime < 441217609) { fprintf(stderr, "Invalid argument to --%s:\n" \ "GPS start time is prior to 1 January 1994 00:00:00 UTC " \ "(%d specified)\n", long_options[option_index].name, \ startTime); exit(1); } if (startTime > 999999999) { fprintf(stderr, "Invalid argument to --%s:\n" \ "GPS start time is after 14 September 2011 01:46:26 UTC " \ "(%d specified)\n", long_options[option_index].name, \ startTime); exit(1); } ADD_PROCESS_PARAM("int", "%"LAL_INT4_FORMAT, startTime); break; case 'h': /* end time */ endTime = atoi(LALoptarg); if (endTime < 441217609) { fprintf(stderr, "Invalid argument to --%s:\n" \ "GPS end time is prior to 1 January 1994 00:00:00 UTC " \ "(%d specified)\n", long_options[option_index].name, \ endTime); exit(1); } if (endTime > 999999999) { fprintf(stderr, "Invalid argument to --%s:\n" \ "GPS end time is after 14 September 2011 01:46:26 UTC " \ "(%d specified)\n", long_options[option_index].name, \ endTime); exit(1); } ADD_PROCESS_PARAM("int", "%"LAL_INT4_FORMAT, endTime); break; case 'i': /* interval duration */ intervalDuration = atoi(LALoptarg); if (intervalDuration <= 0) { fprintf(stderr, "Invalid argument to --%s:\n" \ "Interval duration must be greater than 0: (%d specified)\n", \ long_options[option_index].name, intervalDuration); exit(1); } ADD_PROCESS_PARAM("int", "%d", intervalDuration); break; case 'j': /* segment duration */ segmentDuration = atoi(LALoptarg); if (segmentDuration <= 0) { fprintf(stderr, "Invalid argument to --%s:\n" \ "Segment duration must be greater than 0: (%d specified)\n", \ long_options[option_index].name, segmentDuration); exit(1); } ADD_PROCESS_PARAM("int", "%d", segmentDuration); break; case 'k': /* resample rate */ resampleRate = atoi(LALoptarg); if (resampleRate < 2 || resampleRate > 16384 || resampleRate % 2) { fprintf(stderr, "Invalid argument to --%s:\n" \ "Resample rate must be a power of 2 between 2 and 16384: " \ "inclusive: (%d specified)\n", long_options[option_index].name, \ resampleRate); exit(1); } ADD_PROCESS_PARAM("int", "%d", resampleRate); break; case 'l': /* minimal frequency */ fMin = atof(LALoptarg); if (fMin < 0) { fprintf(stderr, "Invalid argument to --%s:\n" \ "Minimum frequency is less than 0 Hz (%f specified)\n", \ long_options[option_index].name, fMin); exit(1); } /* check that min frequency can be represented by the * sampling rate of the data and round accordingly */ if (fMin != round(fMin * PSD_WINDOW_DURATION) / PSD_WINDOW_DURATION) { fMin = round(fMin * PSD_WINDOW_DURATION) / PSD_WINDOW_DURATION; fprintf(stderr, "warning: fMin has been rounded to %f\n", fMin); } ADD_PROCESS_PARAM("float", "%e", fMin); break; case 'm': /* maximal frequency */ fMax = atof(LALoptarg); if (fMax < 0) { fprintf(stderr, "Invalid argument to --%s:\n" \ "Maximum frequency is less than 0 Hz (%f specified)\n", \ long_options[option_index].name, fMax); exit(1); } /* check that the max frequency can be represented by the * sampling rate of the data and round accordingly */ if (fMax != round(fMax * PSD_WINDOW_DURATION) / PSD_WINDOW_DURATION) { fMax = round(fMax * PSD_WINDOW_DURATION) / PSD_WINDOW_DURATION; fprintf(stderr, "warning: fMax has been rounded to %f\n", fMax); } ADD_PROCESS_PARAM("float", "%e", fMax); break; case 'n': /* ifo for first stream */ LALoptarg_len = strlen(LALoptarg) + 1; ifoOne = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(ifoOne, LALoptarg, LALoptarg_len); /* set site id for ifo one */ if (strncmp(ifoOne, "H1", 2) == 0) siteOne = 0; else if (strncmp(ifoOne, "H2", 2) == 0) siteOne = 0; else if (strncmp(ifoOne, "L1", 2) == 0) siteOne = 1; else if (strncmp(ifoOne, "G1", 2) == 0) siteOne = 3; else { fprintf(stderr, "First IFO not recognised...\n"); exit(1); } ADD_PROCESS_PARAM("string", "%s", ifoOne); break; case 'o': /* ifo for second stream */ LALoptarg_len = strlen(LALoptarg) + 1; ifoTwo = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(ifoTwo, LALoptarg, LALoptarg_len); /* set site id for ifo two */ if (strncmp(ifoTwo, "H1", 2) == 0) siteTwo = 0; else if (strncmp(ifoTwo, "H2", 2) == 0) siteTwo = 0; else if (strncmp(ifoTwo, "L1", 2) == 0) siteTwo = 1; else if (strncmp(ifoTwo, "G1", 2) == 0) siteOne = 3; else { fprintf(stderr, "Second IFO not recognised...\n"); exit(1); } ADD_PROCESS_PARAM("string", "%s", ifoTwo); break; case 'p': /* channel one */ LALoptarg_len = strlen(LALoptarg) + 4; channelOneTemp = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); channelOne = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(channelOneTemp, LALoptarg, LALoptarg_len); ADD_PROCESS_PARAM("string", "%s", channelOneTemp); break; case 'q': /* channel two */ LALoptarg_len = strlen(LALoptarg) + 4; channelTwoTemp = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); channelTwo = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(channelTwoTemp, LALoptarg, LALoptarg_len); ADD_PROCESS_PARAM("string", "%s", channelTwoTemp); break; case 'r': /* frame cache one */ LALoptarg_len = strlen(LALoptarg) + 1; frameCacheOne = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(frameCacheOne, LALoptarg, LALoptarg_len); if (stat(frameCacheOne, &fileStatus) == -1) { fprintf(stderr, "Invalid argument to --%s:\n" \ "File does not exist: (%s specified)\n", \ long_options[option_index].name, frameCacheOne); exit(1); } ADD_PROCESS_PARAM("string", "%s", frameCacheOne); break; case 's': /* frame cache two */ LALoptarg_len = strlen(LALoptarg) + 1; frameCacheTwo = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(frameCacheTwo, LALoptarg, LALoptarg_len); if (stat(frameCacheTwo, &fileStatus) == -1) { fprintf(stderr, "Invalid argument to --%s:\n" \ "File does not exist: (%s specified)\n", \ long_options[option_index].name, frameCacheTwo); exit(1); } ADD_PROCESS_PARAM("string", "%s", frameCacheTwo); break; case 't': /* calibration cache one */ LALoptarg_len = strlen(LALoptarg) + 1; calCacheOne = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(calCacheOne, LALoptarg, LALoptarg_len); if (stat(calCacheOne, &fileStatus) == -1) { fprintf(stderr, "Invalid argument to --%s:\n" \ "File does not exist: (%s specified)\n", \ long_options[option_index].name, calCacheOne); exit(1); } ADD_PROCESS_PARAM("string", "%s", calCacheOne); break; case 'u': /* calibration cache two */ LALoptarg_len = strlen(LALoptarg) + 1; calCacheTwo = (CHAR*)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(calCacheTwo, LALoptarg, LALoptarg_len); if (stat(calCacheTwo, &fileStatus) == -1) { fprintf(stderr, "Invalid argument to --%s:\n" \ "File does not exist: (%s specified)\n", \ long_options[option_index].name, calCacheTwo); exit(1); } ADD_PROCESS_PARAM("string", "%s", calCacheTwo); break; case 'v': /* calibration time offset */ calibOffset = atoi(LALoptarg); ADD_PROCESS_PARAM("int", "%d", calibOffset); break; case 'w': /* number of bins to mask for frequency mask */ maskBin = atoi(LALoptarg); if (maskBin <= 0) { fprintf(stderr, "Invalid argument to --%s:\n" \ "Number of bins to mask must be greater than 0: " \ "(%d specified)\n", long_options[option_index].name, maskBin); exit(1); } ADD_PROCESS_PARAM("int", "%d", maskBin); break; case 'x': /* hann window duration */ hannDuration = atoi(LALoptarg); if (hannDuration < 0) { fprintf(stderr, "Invalid argument to --%s:\n" \ "Hann duartion is less than 0: (%d specified)\n", \ long_options[option_index].name, hannDuration); exit(1); } ADD_PROCESS_PARAM("int", "%d", hannDuration); break; case 'y': /* high pass knee filter frequency */ highPassFreq = atof(LALoptarg); if (highPassFreq < 0) { fprintf(stderr, "Invalid argument tp --%s:\n" \ "High pass filter knee frequency is less than 0 Hz: "\ "(%f specified)\n", long_options[option_index].name, \ highPassFreq); exit(1); } ADD_PROCESS_PARAM("float", "%e", highPassFreq); break; case 'z': /* high pass filter attenuation */ highPassAtten = atof(LALoptarg); if ((highPassAtten < 0.0) || (highPassAtten > 1.0)) { fprintf(stderr, "Invalid argument to --%s:\n" \ "High pass filter attenuation must be in the range [0:1]: " \ "(%f specified)\n", long_options[option_index].name, \ highPassAtten); exit(1); } ADD_PROCESS_PARAM("float", "%e", highPassAtten); break; case 'A': /* high pass filter order */ highPassOrder = atoi(LALoptarg); if (highPassOrder <= 0) { fprintf(stderr, "Invalid argument to --%s:\n" \ "High pass filter order must be greater than 0: " \ "(%d specified)\n", long_options[option_index].name, highPassOrder); exit(1); } ADD_PROCESS_PARAM("int", "%d", highPassOrder); break; case 'B': /* GEO high pass knee filter frequency */ geoHighPassFreq = atof(LALoptarg); if (geoHighPassFreq < 0) { fprintf(stderr, "Invalid argument tp --%s:\n" \ "GEO high pass filter knee frequency is less than 0 Hz: "\ "(%f specified)\n", long_options[option_index].name, \ geoHighPassFreq); exit(1); } ADD_PROCESS_PARAM("float", "%e", geoHighPassFreq); break; case 'C': /* GEO high pass filter attenuation */ geoHighPassAtten = atof(LALoptarg); if ((geoHighPassAtten < 0.0) || (geoHighPassAtten > 1.0)) { fprintf(stderr, "Invalid argument to --%s:\n" \ "GEO high pass filter attenuation must be in the range [0:1]: " \ "(%f specified)\n", long_options[option_index].name, \ geoHighPassAtten); exit(1); } ADD_PROCESS_PARAM("float", "%e", geoHighPassAtten); break; case 'D': /* GEO high pass filter order */ geoHighPassOrder = atoi(LALoptarg); if (geoHighPassOrder <= 0) { fprintf(stderr, "Invalid argument to --%s:\n" \ "GEO high pass filter order must be greater than 0: " \ "(%d specified)\n", long_options[option_index].name, geoHighPassOrder); exit(1); } ADD_PROCESS_PARAM("int", "%d", geoHighPassOrder); break; case 'E': /* filter spectrum exponent */ alpha = atof(LALoptarg); ADD_PROCESS_PARAM("float", "%e", alpha); break; case 'F': /* filter reference frequency */ fRef = atof(LALoptarg); if (fRef < 0) { fprintf(stderr, "Invalid argument to --%s:\n" \ "Reference frequency must be greater than 0: " \ "(%f specified)\n", long_options[option_index].name, fRef); exit(1); } ADD_PROCESS_PARAM("float", "%e", fRef); break; case 'G': /* filter reference omega */ omegaRef = atof(LALoptarg); if (omegaRef <= 0) { fprintf(stderr, "Invalid argument to --%s:\n" \ "Reference omega_0 must be positive: (%f specified)\n", \ long_options[option_index].name, omegaRef); exit(1); } ADD_PROCESS_PARAM("float", "%e", omegaRef); break; case '?': exit(1); break; 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); } /* check for required arguments */ /* start/end time */ if (startTime == 0) { fprintf(stderr, "--gps-start-time must be specified\n"); exit(1); } if (endTime == 0) { fprintf(stderr, "--gps-end-time must be specified\n"); exit(1); } /* interval duration */ if (intervalDuration == -1) { fprintf(stderr, "--interval-duration must be specified\n"); exit(1); } /* segment duration */ if (segmentDuration == -1) { fprintf(stderr, "--segment-duration must be specified\n"); exit(1); } /* min/max frequency */ if (fMin == -1) { fprintf(stderr, "--f-min must be specified\n"); exit(1); } if (fMax == -1) { fprintf(stderr, "--f-max must be specified\n"); exit(1); } /* ifos */ if (ifoOne == NULL) { fprintf(stderr, "--ifo-one must be specified\n"); exit(1); } if (ifoTwo == NULL) { fprintf(stderr, "--ifo-two must be specified\n"); exit(1); } /* channels */ if (channelOne == NULL) { fprintf(stderr, "--channel-one must be specified\n"); exit(1); } if (channelTwo == NULL) { fprintf(stderr, "--channel-two must be specified\n"); exit(1); } /* frame cache */ if (frameCacheOne == NULL) { fprintf(stderr, "--frame-cache-one must be specified\n"); exit(1); } if (siteOne != siteTwo) { /* only need second frame cache if ifos differ */ if (frameCacheTwo == NULL) { fprintf(stderr, "--frame-cache-two must be specified\n"); exit(1); } } else { /* if site ids are the same then the frames for the different * detectors are in the same frame cache */ frameCacheTwo = frameCacheOne; } /* calibration cache */ if (strncmp(ifoOne, "G1", 2) != 0) { if (calCacheOne == NULL) { fprintf(stderr, "--calibration-cache-one must be specified\n"); exit(1); } } if (strncmp(ifoTwo, "G1", 2) != 0) { if (calCacheTwo == NULL) { fprintf(stderr, "--calibration-cache-two must be specified\n"); exit(1); } } /* calibration offset */ if (calibOffset == -1) { fprintf(stderr, "--calibration-offset must be specified\n"); exit(1); } /* mask */ if (apply_mask_flag) { if (maskBin == -1) { fprintf(stderr, "--mask-bin must be specified\n"); exit(1); } } /* hann duration */ if (overlap_hann_flag) { if (hannDuration != -1) { fprintf(stderr, "Overlapping Hann windows specified, --hann-duration " \ "will be ignored\n"); } } else { if (hannDuration == -1) { fprintf(stderr, "--hann-duration must be specified\n"); exit(1); } } /* high pass filter */ if (high_pass_flag) { if (highPassFreq == -1) { fprintf(stderr, "--hpf-frequency must be specified\n"); exit(1); } if (highPassAtten == -1) { fprintf(stderr, "--hpf-attenuation must be specified\n"); exit(1); } if (highPassOrder == -1) { fprintf(stderr, "--hpf-order must be specified\n"); exit(1); } } /* GEO high pass filter */ if ((strncmp(ifoOne, "G1", 2) == 0) || (strncmp(ifoTwo, "G1", 2) == 0)) { if (geoHighPassFreq == -1) { fprintf(stderr, "--geo-hpf-frequency must be specified\n"); exit(1); } if (geoHighPassAtten == -1) { fprintf(stderr, "--geo-hpf-attenuation must be specified\n"); exit(1); } if (geoHighPassOrder == -1) { fprintf(stderr, "--geo-hpf-order must be specified\n"); exit(1); } } /* check for sensible arguments */ /* start time same as stop time */ if (startTime == endTime) { fprintf(stderr, "Start time same as end time; no analysis to perform\n"); exit(1); } /* stop time before start time */ if (startTime > endTime) { fprintf(stderr, "Invalid start/end time; end time (%d) is before " \ "start time (%d)\n", endTime, startTime); exit(1); } /* interval duration must be a least 3 times the segment duration */ if ((intervalDuration / segmentDuration) < 3) { fprintf(stderr, "Invalid interval duration (%d): must be a least 3 times " \ "the segment\nduration (%d)\n", intervalDuration, segmentDuration); exit(1); } /* interval duration must be an odd mutliple of segment duration */ if (((intervalDuration / segmentDuration) % 2) != 1) { fprintf(stderr, "Invalid interval duration (%d): must be an odd " \ "multiple of the segment\nduration (%d)\n", intervalDuration, \ segmentDuration); exit(1); } /* min frequency same as max */ if (fMin == fMax) { fprintf(stderr, "Minimum frequency same as maximum; no analysis to " \ "perform\n"); exit(1); } /* max frequency less than min */ if (fMin > fMax) { fprintf(stderr, "Invalid frequency band; maximum frequency (%f Hz) is " \ "before minimum\nfrequency (%f Hz)\n", fMax, fMin); exit(1); } /* filter reference frequency less than min */ if (fRef < fMin) { fprintf(stderr, "Reference frequency (%f Hz) is less than minimum " \ "frequency (%f Hz)\n", fRef, fMin); exit(1); } /* filter reference frequency greater than max */ if (fRef > fMax) { fprintf(stderr, "Reference frequency (%f Hz) is greater than maximum " \ "frequency (%f Hz)\n", fRef, fMax); exit(1); } /* set channels */ strcpy(channelOne, ifoOne); strcpy(channelTwo, ifoTwo); strcat(channelOne, ":"); strcat(channelTwo, ":"); strcat(channelOne, channelOneTemp); strcat(channelTwo, channelTwoTemp); free(channelOneTemp); free(channelTwoTemp); return; }
int parseinput(int argc, char **argv){ int c; const char *optionlist="hL:M:H:n:d:e:DG:TXspI:A:F:vS:r:z:"; opterr=0; double starttime_offset_req = 0; /* requested offset correction to shift start-time of signals into the future */ double starttime_offset_samples = 0; /* offset rounded to nearest sample */ /* set some defaults */ directory = strdup("."); programname=argv[0]; while (-1 != (c = LALgetopt(argc, argv, optionlist))) { char *end; double tempamp; switch (c) { case 'v': if ( XLALOutputVersionString(stdout,0) != XLAL_SUCCESS ) { XLALPrintError("XLALOutputVersionString() failed!\n"); exit(1); } exit(0); break; case 'p': printf("The calibration line frequencies are:\n" " L: %18.14f Hz\n" " M: %18.14f Hz\n" " H: %18.14f Hz\n", calfreq[0], calfreq[1], calfreq[2]); exit(0); break; case 'h': /* usage message */ usage(stdout); exit(0); break; case 'n': /* number of pulsars to simulate */ npulsars=atoi(LALoptarg); if (npulsars<0 || npulsars>MAXPULSARS){ syserror(0, "%s: Number of pulsars (-n argument = %d) must be non-negative and less than %d\n", argv[0], npulsars, MAXPULSARS+1); exit(1); } break; case 'L': case 'M': case 'H': /* calibration-line amplitude */ tempamp=strtod(LALoptarg, &end); if (*end){ syserror(1, "-%c %s is invalid. -%c takes a double-precision amplitude.\n", c, LALoptarg, c); exit(1); } /* assign amplitude to the correct line */ if (c=='L') calamp[0]=tempamp; else if (c=='M') calamp[1]=tempamp; else calamp[2]=tempamp; break; case 'd': /* directory path */ if (directory) free(directory); if (!(directory=strdup(LALoptarg))){ syserror(1, "Out of memory to duplicate -d directory path %s\n", LALoptarg); exit(1); } break; case 'e': #ifdef ONLINE /* Excitation channel into which to inject */ if (!(channel=strdup(LALoptarg))){ syserror(1, "Out of memory to duplicate -e channel name %s\n", LALoptarg); exit(1); } #else syserror(0, "The -e option to enable online signal injection requires compilation with -DONLINE\n"); exit(1); #endif break; case 'D': #ifdef ONLINE /* Turn on debugging for SIStr library routines */ SIStr_debug++; #else syserror(0, "The -D option to enable SIStr debugging requires compilation with -DONLINE\n"); exit(1); #endif break; case 'G': /* GPS time to pass as argument */ gpstime=atoi(LALoptarg); break; case 'T': /* enable text output */ do_text=1; break; case 'X': /* include x axis in text output */ do_axis=1; break; case 's': /* show commands rather than executing them */ show=1; break; case 'I': ifo_name = LALoptarg; break; case 'A': actuation = LALoptarg; break; case 'F': #ifdef HAVE_LIBLALFRAME { int how_many = atoi(LALoptarg); if (how_many < 0) { syserror(0,"%s: fatal error, argument -F %d must be non-negative.\n", argv[0], how_many); exit(1); } write_frames = 1 + how_many; } #else syserror(0,"%s: -F specified, but this binary was built without frame support.\n", argv[0] ); exit(1); #endif break; case 'S': #ifdef HAVE_LIBLALFRAME secs_per_framefile = atoi(LALoptarg); if (secs_per_framefile < 1) { syserror(0,"%s: fatal error, argument -S %d must be at least 1 second.\n", argv[0], secs_per_framefile); exit(1); } if (secs_per_framefile > 3600) { syserror(0,"%s: caution, argument -S %d seconds is more than one hour!\n", argv[0], secs_per_framefile); } #else syserror(0,"%s: -S specified, but this binary was built without frame support.\n", argv[0] ); exit(1); #endif break; case 'r': sampling_rate = atoi(LALoptarg); if ( sampling_rate <= 0 ) { syserror (0, "%s: need positive sampling rate! %d\n", argv[0], sampling_rate ); exit(1); } break; case 'z': starttime_offset_req = strtod(LALoptarg, &end); if ( end == LALoptarg ){ syserror(1, "-%c %s is invalid. -%c takes a double-precision amplitude.\n", c, LALoptarg, c); exit(1); } break; default: /* error case -- option not recognized */ syserror(0,"%s: Option argument: -%c unrecognized or missing argument.\n" "\t\tPlease use the '-h' option to print usage message\n" ,argv[0], optopt); exit(1); break; } /* switch(c) */ } /* while (LALgetopt) */ /* sanity checks on command line arguments */ if (do_axis && !do_text) { syserror(0, "The -X (axis) option only works with the -T (human readable) option\n"); exit(1); } if (do_text && channel){ syserror(0, "Can't use both '-T' and '-e' together\n"); exit(1); } if (channel && (strlen(channel) <3 || channel[2] != ':' )) { syserror(0, "Excitation channel %s not of form CC:CCC...\n", channel ); exit(1); } if ( ifo_name == NULL ) { syserror(0, "You must specify the IFO name (-I)\n"); exit(1); } /* "discretize" starttime offset to sampling rate, and * provide some debug-info about starttime shifting */ starttime_offset_samples = floor(starttime_offset_req * sampling_rate + 0.5 ); /* correctly *round*, allowing for negative offsets */ starttime_offset_eff = starttime_offset_samples / sampling_rate; if ( starttime_offset_req ) { syserror(0, "starttime OFFSET requested = %+.16g s (offset > 0 means a *delay*)\n", starttime_offset_req ); syserror(0, "effective OFFSET will be = %+.16g s (that is: %+.0f samples)\n", starttime_offset_eff, starttime_offset_samples ); } #ifndef ONLINE if (channel) { syserror(0, "Can't do exicitations. Code not compiled with ONLINE defined\n"); exit(1); } #endif return 0; }
int main ( int argc, char *argv[] ) { /* lal function variables */ LALStatus status = blank_status; /* template bank generation parameters */ CHAR *bankFileName = NULL; INT4 numOutBanks = 0; REAL4 minMatch = -1; /* output data */ MetadataTable inputBank; MetadataTable outputBank; MetadataTable proctable; MetadataTable procparams; ProcessParamsTable *this_proc_param = NULL; LIGOLwXMLStream xmlStream; /* counters and other variables */ INT4 i, j; INT4 numTmplts = 0; INT4 numTmpltsWritten = 0; INT4 numPerFile = 0; CHAR *gpsHyphen; char outBankFileName[FILENAME_MAX]; CHAR bankFileNameHead[FILENAME_MAX]; CHAR bankFileNameTail[FILENAME_MAX]; CHAR comment[LIGOMETA_COMMENT_MAX]; CHAR *userTag = NULL; SnglInspiralTable *thisTmplt = NULL; SnglInspiralTable *tmpTmplt = NULL; /* LALgetopt arguments */ struct LALoption long_options[] = { {"verbose", no_argument, &vrbflg, 1 }, {"version", no_argument, 0, 'V'}, {"user-tag", required_argument, 0, 'Z'}, {"userTag", required_argument, 0, 'Z'}, {"comment", required_argument, 0, 's'}, {"help", no_argument, 0, 'h'}, {"bank-file", required_argument, 0, 'v'}, {"number-of-banks", required_argument, 0, 'n'}, {"minimal-match", required_argument, 0, 'M'}, {0, 0, 0, 0} }; int c; /* * * initialize things * */ lal_errhandler = LAL_ERR_EXIT; setvbuf( stdout, NULL, _IONBF, 0 ); /* create the process and process params tables */ proctable.processTable = (ProcessTable *) calloc( 1, sizeof(ProcessTable) ); XLALGPSTimeNow(&(proctable.processTable->start_time)); XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME, lalAppsVCSIdentInfo.vcsId, lalAppsVCSIdentInfo.vcsStatus, lalAppsVCSIdentInfo.vcsDate, 0); this_proc_param = procparams.processParamsTable = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); memset( comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR) ); /* * * parse command line arguments * */ while ( 1 ) { /* LALgetopt_long stores long option here */ int option_index = 0; size_t LALoptarg_len; c = LALgetopt_long_only( argc, argv, "i:n:VZ:hs:M:", long_options, &option_index ); /* detect the end of the options */ if ( c == - 1 ) { break; } switch ( c ) { case 0: /* if this option set a flag, do nothing else now */ if ( long_options[option_index].flag != 0 ) { break; } else { fprintf( stderr, "error parsing option %s with argument %s\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } break; case 'v': LALoptarg_len = strlen( LALoptarg ) + 1; bankFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( bankFileName, LALoptarg, LALoptarg_len ); snprintf( procparams.processParamsTable->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( procparams.processParamsTable->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( procparams.processParamsTable->param, LIGOMETA_PARAM_MAX, "--%s", long_options[option_index].name ); snprintf( procparams.processParamsTable->value, LIGOMETA_VALUE_MAX, "%s", LALoptarg ); break; case 'n': numOutBanks = (INT4) atoi( LALoptarg ); if ( numOutBanks < 0 ) { fprintf( stderr, "invalid argument to --%s:\n" "Number of output banks must be greater than zero:" "(%d specified)\n", long_options[option_index].name, numOutBanks ); exit( 1 ); } else if ( numOutBanks > 99 ) { fprintf( stderr, "Warning: generating more than 99 banks is not reccomended!\n" ); } this_proc_param = this_proc_param->next = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "int" ); snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "--%s", long_options[option_index].name ); snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%d", numOutBanks ); break; case 's': if ( strlen( LALoptarg ) > LIGOMETA_COMMENT_MAX - 1 ) { fprintf( stderr, "invalid argument to --%s:\n" "comment must be less than %d characters\n", long_options[option_index].name, LIGOMETA_COMMENT_MAX ); exit( 1 ); } else { snprintf( comment, LIGOMETA_COMMENT_MAX, "%s", LALoptarg ); } break; case 'Z': /* create storage for the usertag */ LALoptarg_len = strlen( LALoptarg ) + 1; userTag = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR) ); memcpy( userTag, LALoptarg, LALoptarg_len ); this_proc_param = this_proc_param->next = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "-userTag" ); snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%s", LALoptarg ); break; case 'M': minMatch = (REAL4) atof( LALoptarg ); if ( minMatch <= 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "minimal match of bank must be > 0: " "(%f specified)\n", long_options[option_index].name, minMatch ); exit( 1 ); } this_proc_param = this_proc_param->next = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "float" ); snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "--%s", long_options[option_index].name ); snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%e", minMatch ); break; case 'V': /* print version information and exit */ fprintf( stdout, "Inspiral Template Bank Splitter\n" "Duncan Brown <*****@*****.**>\n"); XLALOutputVersionString(stderr, 0); exit( 0 ); break; case '?': fprintf( stderr, USAGE, argv[0] ); exit( 1 ); break; default: fprintf( stderr, "unknown error while parsing options\n" ); fprintf( stderr, USAGE, argv[0] ); exit( 1 ); } } if ( LALoptind < argc ) { fprintf( stderr, "extraneous command line arguments:\n" ); while ( LALoptind < argc ) { fprintf ( stderr, "%s\n", argv[LALoptind++] ); } exit( 1 ); } /* check the values of the arguments */ if ( ! bankFileName ) { fprintf( stderr, "Error: --bank-file must be specified\n" ); exit( 1 ); } if ( ! numOutBanks ) { fprintf( stderr, "Error: --number-of-banks must be specified\n" ); exit( 1 ); } if ( minMatch < 0 ) { fprintf( stderr, "Error: --minimal-match must be specified\n" ); exit( 1 ); } /* * * read in the template bank from the input file * */ /* read in the template bank from a ligo lw xml file */ inputBank.snglInspiralTable = NULL; numTmplts = LALSnglInspiralTableFromLIGOLw( &(inputBank.snglInspiralTable), bankFileName, 0, -1 ); if ( numTmplts < 0 ) { fprintf( stderr, "error: unable to read templates from %s\n", bankFileName ); exit( 1 ); } if ( vrbflg ) fprintf( stdout, "read %d templates from %s\n", numTmplts, bankFileName ); /* find the hypen just before the GPS start time of the bank */ gpsHyphen = NULL; gpsHyphen = strstr( bankFileName, "-" ); if ( ! gpsHyphen ) { fprintf( stderr, "Error: could not find first hypen in file name %s\n", bankFileName ); exit( 1 ); } gpsHyphen = strstr( gpsHyphen + 1, "-" ); if ( ! gpsHyphen ) { fprintf( stderr, "Error: could not find second hypen in file name %s\n", bankFileName ); exit( 1 ); } /* store the name of the template bank file */ memcpy( bankFileNameHead, bankFileName, (size_t) gpsHyphen - (size_t) bankFileName < FILENAME_MAX ? (gpsHyphen - bankFileName) * sizeof(CHAR) : FILENAME_MAX * sizeof(CHAR) ); strncpy( bankFileNameTail, gpsHyphen + 1, FILENAME_MAX - 1 ); if ( vrbflg ) { fprintf( stdout, "head of bank file name is %s\n", bankFileNameHead ); fprintf( stdout, "tail of bank file name is %s\n", bankFileNameTail ); } /* * * write out the individual tempate bank files * */ /* compute the number of templates per output file */ numPerFile = floor( ( numTmplts - 0.5 )/ numOutBanks + 1 ); thisTmplt = inputBank.snglInspiralTable; if ( vrbflg ) fprintf( stdout, "writing around %d templates per file\n", numPerFile ); for ( i = 0; i < numOutBanks; ++i ) { /* open the output xml file */ memset( outBankFileName, 0, FILENAME_MAX * sizeof(CHAR) ); if(snprintf( outBankFileName, FILENAME_MAX, "%s_%02d-%s", bankFileNameHead, i, bankFileNameTail ) >= FILENAME_MAX) abort(); memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) ); LAL_CALL( LALOpenLIGOLwXMLFile( &status , &xmlStream, outBankFileName), &status ); if ( vrbflg ) fprintf( stdout, "writing templates to %s... ", outBankFileName ); /* write process table */ XLALGPSTimeNow(&(proctable.processTable->end_time)); LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, proctable, process_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* write process_params table */ LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_params_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, procparams, process_params_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* write the templates to the file */ outputBank.snglInspiralTable = thisTmplt; numTmpltsWritten = 0; if ( thisTmplt ) { LAL_CALL( LALBeginLIGOLwXMLTable( &status ,&xmlStream, sngl_inspiral_table), &status ); for ( j = 0; j < numPerFile - 1 && thisTmplt->next; ++j ) { thisTmplt = thisTmplt->next; } tmpTmplt = thisTmplt->next; thisTmplt->next = NULL; thisTmplt = tmpTmplt; LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputBank, sngl_inspiral_table), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream), &status ); } while ( outputBank.snglInspiralTable ) { ++numTmpltsWritten; tmpTmplt = outputBank.snglInspiralTable; outputBank.snglInspiralTable = outputBank.snglInspiralTable->next; LALFree( tmpTmplt ); } LAL_CALL( LALCloseLIGOLwXMLFile( &status, &xmlStream), &status ); if ( vrbflg ) fprintf( stdout, "%d templates\n", numTmpltsWritten ); } LALCheckMemoryLeaks(); exit( 0 ); }
int main( int argc, char *argv[] ) { LALStatus status = blank_status; UINT4 k; UINT4 kLow; UINT4 kHi; INT4 numPoints = 524288; REAL4 fSampling = 2048.; REAL4 fLow = 70.; REAL4 fLowInj = 40.; REAL8 deltaT = 1./fSampling; REAL8 deltaF = fSampling / numPoints; REAL4 statValue; /* vars required to make freq series */ LIGOTimeGPS epoch = { 0, 0 }; LIGOTimeGPS gpsStartTime = {0, 0}; REAL8 f0 = 0.; REAL8 offset = 0.; INT8 waveformStartTime = 0; /* files contain PSD info */ CHAR *injectionFile = NULL; CHAR *outputFile = NULL; CHAR *specFileH1 = NULL; CHAR *specFileH2 = NULL; CHAR *specFileL1 = NULL; COMPLEX8Vector *unity = NULL; const LALUnit strainPerCount = {0,{0,0,0,0,0,1,-1},{0,0,0,0,0,0,0}}; int numInjections = 0; int numTriggers = 0; /* template bank simulation variables */ INT4 injSimCount = 0; SimInspiralTable *injectionHead = NULL; SimInspiralTable *thisInjection = NULL; SnglInspiralTable *snglHead = NULL; SearchSummaryTable *searchSummHead = NULL; /*SummValueTable *summValueHead = NULL; */ /* raw input data storage */ REAL8FrequencySeries *specH1 = NULL; REAL8FrequencySeries *specH2 = NULL; REAL8FrequencySeries *specL1 = NULL; REAL8FrequencySeries *thisSpec = NULL; COMPLEX8FrequencySeries *resp = NULL; COMPLEX8FrequencySeries *detTransDummy = NULL; REAL4TimeSeries *chan = NULL; RealFFTPlan *pfwd = NULL; COMPLEX8FrequencySeries *fftData = NULL; REAL8 thisSnrsq = 0; REAL8 thisSnr = 0; REAL8 thisCombSnr = 0; REAL8 snrVec[3]; REAL8 dynRange = 1./(3.0e-23); /* needed for inj */ CoherentGW waveform; PPNParamStruc ppnParams; DetectorResponse detector; InterferometerNumber ifoNumber = LAL_UNKNOWN_IFO; /* output data */ LIGOLwXMLStream xmlStream; MetadataTable proctable; MetadataTable outputTable; MetadataTable procparams; CHAR fname[256]; CHAR comment[LIGOMETA_COMMENT_MAX]; ProcessParamsTable *this_proc_param = NULL; CHAR chanfilename[FILENAME_MAX]; REAL4 sum = 0; REAL4 bitten_H1 = 0; REAL4 bitten_H2 = 0; REAL4 thisCombSnr_H1H2 = 0; /* create the process and process params tables */ proctable.processTable = (ProcessTable *) calloc( 1, sizeof(ProcessTable) ); XLALGPSTimeNow(&(proctable.processTable->start_time)); XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME, lalAppsVCSIdentId, lalAppsVCSIdentStatus, lalAppsVCSIdentDate, 0); this_proc_param = procparams.processParamsTable = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); memset( comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR) ); /* look at input args, write process params where required */ while ( 1 ) { /* getopt arguments */ static struct option long_options[] = { /* these options set a flag */ /* these options do not set a flag */ {"help", no_argument, 0, 'h'}, {"verbose", no_argument, &vrbflg, 1 }, {"version", no_argument, 0, 'V'}, {"spectrum-H1", required_argument, 0, 'a'}, {"spectrum-H2", required_argument, 0, 'b'}, {"spectrum-L1", required_argument, 0, 'c'}, {"inj-file", required_argument, 0, 'd'}, {"comment", required_argument, 0, 'e'}, {"output-file", required_argument, 0, 'f'}, {"coire-flag", no_argument, &coireflg, 1 }, {"ligo-srd", no_argument, &ligosrd, 1 }, {"write-chan", no_argument, &writechan, 1 }, {"inject-overhead", no_argument, &injoverhead, 1 }, {"f-lower", required_argument, 0, 'g'}, {0, 0, 0, 0} }; int c; /* * * parse command line arguments * */ /* getopt_long stores long option here */ int option_index = 0; size_t optarg_len; c = getopt_long_only( argc, argv, "a:b:c:d:e:f:g:hV", long_options, &option_index ); /* detect the end of the options */ if ( c == - 1 ) { break; } switch ( c ) { case 0: /* if this option set a flag, do nothing else now */ if ( long_options[option_index].flag != 0 ) { break; } else { fprintf( stderr, "error parsing option %s with argument %s\n", long_options[option_index].name, optarg ); exit( 1 ); } break; case 'h': fprintf( stderr, USAGE ); exit( 0 ); break; case 'a': /* create storage for the spectrum file name */ optarg_len = strlen( optarg ) + 1; specFileH1 = (CHAR *) calloc( optarg_len, sizeof(CHAR)); memcpy( specFileH1, optarg, optarg_len ); ADD_PROCESS_PARAM( "string", "%s", optarg ); break; case 'b': /* create storage for the spectrum file name */ optarg_len = strlen( optarg ) + 1; specFileH2 = (CHAR *) calloc( optarg_len, sizeof(CHAR)); memcpy( specFileH2, optarg, optarg_len ); ADD_PROCESS_PARAM( "string", "%s", optarg ); break; case 'c': /* create storage for the spectrum file name */ optarg_len = strlen( optarg ) + 1; specFileL1 = (CHAR *) calloc( optarg_len, sizeof(CHAR)); memcpy( specFileL1, optarg, optarg_len ); ADD_PROCESS_PARAM( "string", "%s", optarg ); break; case 'd': /* create storage for the injection file name */ optarg_len = strlen( optarg ) + 1; injectionFile = (CHAR *) calloc( optarg_len, sizeof(CHAR)); memcpy( injectionFile, optarg, optarg_len ); ADD_PROCESS_PARAM( "string", "%s", optarg ); break; case 'f': /* create storage for the output file name */ optarg_len = strlen( optarg ) + 1; outputFile = (CHAR *) calloc( optarg_len, sizeof(CHAR)); memcpy( outputFile, optarg, optarg_len ); ADD_PROCESS_PARAM( "string", "%s", optarg ); break; case 'g': fLow = (INT4) atof( optarg ); if ( fLow < 40 ) { fprintf( stderr, "invalid argument to --%s:\n" "f-lower must be > 40Hz (%e specified)\n", long_options[option_index].name, fLow ); exit( 1 ); } ADD_PROCESS_PARAM( "float", "%e", fLow ); break; case 'e': if ( strlen( optarg ) > LIGOMETA_COMMENT_MAX - 1 ) { fprintf( stderr, "invalid argument to --%s:\n" "comment must be less than %d characters\n", long_options[option_index].name, LIGOMETA_COMMENT_MAX ); exit( 1 ); } else { snprintf( comment, LIGOMETA_COMMENT_MAX, "%s", optarg); } break; case 'V': /* print version information and exit */ fprintf( stdout, "calculation of expected SNR of injections\n" "Gareth Jones\n"); XLALOutputVersionString(stderr, 0); exit( 0 ); break; default: fprintf( stderr, "unknown error while parsing options\n" ); fprintf( stderr, USAGE ); exit( 1 ); } } if ( optind < argc ) { fprintf( stderr, "extraneous command line arguments:\n" ); while ( optind < argc ) { fprintf ( stderr, "%s\n", argv[optind++] ); } exit( 1 ); } /* check the input arguments */ if ( injectionFile == NULL ) { fprintf( stderr, "Must specify the --injection-file\n" ); exit( 1 ); } if ( outputFile == NULL ) { fprintf( stderr, "Must specify the --output-file\n" ); exit( 1 ); } if ( !ligosrd && specFileH1 == NULL ) { fprintf( stderr, "Must specify the --spectrum-H1\n" ); exit( 1 ); } if ( !ligosrd && specFileH2 == NULL ) { fprintf( stderr, "Must specify the --spectrum-H2\n" ); exit( 1 ); } if ( !ligosrd && specFileL1 == NULL ) { fprintf( stderr, "Must specify the --spectrum-L1\n" ); exit( 1 ); } if ( ligosrd && (specFileH1 || specFileH2 || specFileL1 )) { fprintf( stdout, "WARNING: using LIGOI SRD power spectral density \n" ); } if ( vrbflg ){ fprintf( stdout, "injection file is %s\n", injectionFile ); fprintf( stdout, "output file is %s\n", outputFile ); fprintf( stdout, "H1 spec file is %s\n", specFileH1 ); fprintf( stdout, "H2 spec file is %s\n", specFileH2 ); fprintf( stdout, "L1 spec file is %s\n", specFileL1 ); } /* create vector for H1, H2 and L1 spectrums */ specH1 = XLALCreateREAL8FrequencySeries ( "",&epoch, f0, deltaF, &lalADCCountUnit, (numPoints / 2 + 1) ); specH2 = XLALCreateREAL8FrequencySeries ( "",&epoch, f0, deltaF, &lalADCCountUnit, (numPoints / 2 + 1) ); specL1 = XLALCreateREAL8FrequencySeries ( "",&epoch, f0, deltaF, &lalADCCountUnit, (numPoints / 2 + 1) ); if (!specH1 || !specH2 || !specL1){ XLALDestroyREAL8FrequencySeries ( specH1 ); XLALDestroyREAL8FrequencySeries ( specH2 ); XLALDestroyREAL8FrequencySeries ( specL1 ); XLALPrintError("failure allocating H1, H2 and L1 spectra"); exit(1); } if (!ligosrd){ /* read in H1 spectrum */ LAL_CALL( LALDReadFrequencySeries(&status, specH1, specFileH1), &status ); if ( vrbflg ){ fprintf( stdout, "read in H1 spec file\n" ); fflush( stdout ); } /* read in H2 spectrum */ LAL_CALL( LALDReadFrequencySeries(&status, specH2, specFileH2), &status ); if ( vrbflg ){ fprintf( stdout, "read in H2 spec file\n" ); fflush( stdout ); } /* read in L1 spectrum */ LAL_CALL( LALDReadFrequencySeries(&status, specL1, specFileL1), &status ); if ( vrbflg ){ fprintf( stdout, "read in L1 spec file\n" ); fflush( stdout ); } } chan = XLALCreateREAL4TimeSeries( "", &epoch, f0, deltaT, &lalADCCountUnit, numPoints ); if ( !chan ){ XLALPrintError("failure allocating chan"); exit(1); } /* * * set up the response function * */ resp = XLALCreateCOMPLEX8FrequencySeries( chan->name, &chan->epoch, f0, deltaF, &strainPerCount, (numPoints / 2 + 1) ); if ( !resp ){ XLALPrintError("failure allocating response function"); exit(1); } /* create vector that will contain detector.transfer info, since this * is constant I calculate it once outside of all the loops and pass it * in to detector.transfer when required */ detTransDummy = XLALCreateCOMPLEX8FrequencySeries( chan->name, &chan->epoch, f0, deltaF, &strainPerCount, (numPoints / 2 + 1) ); if ( !detTransDummy ){ XLALPrintError("failure allocating detector.transfer info"); exit(1); } /* invert the response function to get the transfer function */ unity = XLALCreateCOMPLEX8Vector( resp->data->length ); for ( k = 0; k < unity->length; ++k ) { unity->data[k] = 1.0; } /* set response */ for ( k = 0; k < resp->data->length; ++k ) { resp->data->data[k] = 1.0; } XLALCCVectorDivide( detTransDummy->data, unity, resp->data ); XLALDestroyCOMPLEX8Vector( unity ); /* read in injections from injection file */ /* set endtime to 0 so that we read in all events */ if ( vrbflg ) fprintf( stdout, "Reading sim_inspiral table of %s\n", injectionFile ); LAL_CALL(numInjections = SimInspiralTableFromLIGOLw( &injectionHead, injectionFile, 0, 0), &status); if ( vrbflg ) fprintf( stdout, "Read %d injections from sim_inspiral table of %s\n", numInjections, injectionFile ); if (coireflg){ if ( vrbflg ) fprintf( stdout, "Reading sngl_inspiral table of %s\n", injectionFile ); LAL_CALL(numTriggers = LALSnglInspiralTableFromLIGOLw(&snglHead, injectionFile, 0, -1), &status); if ( vrbflg ) fprintf( stdout, "Read %d triggers from sngl_inspiral table of %s\n", numTriggers, injectionFile ); if ( vrbflg ) { fprintf( stdout, "Reading search_summary table of %s ...", injectionFile ); fflush( stdout ); } searchSummHead = XLALSearchSummaryTableFromLIGOLw (injectionFile); if ( vrbflg ) fprintf( stdout, " done\n"); } /* make sure we start at head of linked list */ thisInjection = injectionHead; /* setting fixed waveform injection parameters */ memset( &ppnParams, 0, sizeof(PPNParamStruc) ); ppnParams.deltaT = deltaT; ppnParams.lengthIn = 0; ppnParams.ppn = NULL; /* loop over injections */ injSimCount = 0; do { fprintf( stdout, "injection %d/%d\n", injSimCount+1, numInjections ); /* reset waveform structure */ memset( &waveform, 0, sizeof(CoherentGW) ); /* reset chan structure */ memset( chan->data->data, 0, chan->data->length * sizeof(REAL4) ); if (thisInjection->f_lower == 0){ fprintf( stdout, "WARNING: f_lower in sim_inpiral = 0, "); fprintf( stdout, "changing this to %e\n ", fLowInj); thisInjection->f_lower = fLowInj; } /* create the waveform, amp, freq phase etc */ LAL_CALL( LALGenerateInspiral(&status, &waveform, thisInjection, &ppnParams), &status); if (vrbflg) fprintf( stdout, "ppnParams.tc %e\n ", ppnParams.tc); statValue = 0.; /* calc lower index for integration */ kLow = ceil(fLow / deltaF); if ( vrbflg ) { fprintf( stdout, "starting integration to find SNR at frequency %e ", fLow); fprintf( stdout, "at index %d \n", kLow); } /* calc upper index for integration */ kHi = floor(fSampling / (2. * deltaF)); if ( vrbflg ) { fprintf( stdout, "ending integration to find SNR at frequency %e ", fSampling / 2.); fprintf( stdout, "at index %d \n", kHi); } /* loop over ifo */ for ( ifoNumber = 1; ifoNumber < 4; ifoNumber++ ) { /* allocate memory and copy the parameters describing the freq series */ memset( &detector, 0, sizeof( DetectorResponse ) ); detector.site = (LALDetector *) LALMalloc( sizeof(LALDetector) ); if (injoverhead){ if ( vrbflg ) fprintf( stdout, "WARNING: perform overhead injections\n"); /* setting detector.site to NULL causes SimulateCoherentGW to * perform overhead injections */ detector.site = NULL; } else { /* if not overhead, set detector.site using ifonumber */ XLALReturnDetector( detector.site, ifoNumber ); } switch ( ifoNumber ) { case 1: if ( vrbflg ) fprintf( stdout, "looking at H1 \n"); thisSpec = specH1; break; case 2: if ( vrbflg ) fprintf( stdout, "looking at H2 \n"); thisSpec = specH2; break; case 3: if ( vrbflg ) fprintf( stdout, "looking at L1 \n"); thisSpec = specL1; break; default: fprintf( stderr, "Error: ifoNumber %d does not correspond to H1, H2 or L1: \n", ifoNumber ); exit( 1 ); } /* get the gps start time of the signal to inject */ waveformStartTime = XLALGPSToINT8NS( &(thisInjection->geocent_end_time) ); waveformStartTime -= (INT8) ( 1000000000.0 * ppnParams.tc ); offset = (chan->data->length / 2.0) * chan->deltaT; gpsStartTime.gpsSeconds = thisInjection->geocent_end_time.gpsSeconds - offset; gpsStartTime.gpsNanoSeconds = thisInjection->geocent_end_time.gpsNanoSeconds; chan->epoch = gpsStartTime; if (vrbflg) fprintf(stdout, "offset start time of injection by %f seconds \n", offset ); /* is this okay? copying in detector transfer which so far only contains response info */ detector.transfer = detTransDummy; XLALUnitInvert( &(detector.transfer->sampleUnits), &(resp->sampleUnits) ); /* set the start times for injection */ XLALINT8NSToGPS( &(waveform.a->epoch), waveformStartTime ); memcpy(&(waveform.f->epoch), &(waveform.a->epoch), sizeof(LIGOTimeGPS) ); memcpy(&(waveform.phi->epoch), &(waveform.a->epoch), sizeof(LIGOTimeGPS) ); /* perform the injection */ LAL_CALL( LALSimulateCoherentGW(&status, chan, &waveform, &detector ), &status); if (writechan){ /* write out channel data */ if (vrbflg) fprintf(stdout, "writing channel data to file... \n" ); switch ( ifoNumber ) { case 1: snprintf( chanfilename, FILENAME_MAX, "chanTest_H1_inj%d.dat", injSimCount+1); if (vrbflg) fprintf( stdout, "writing H1 channel time series out to %s\n", chanfilename ); LALSPrintTimeSeries(chan, chanfilename ); break; case 2: snprintf( chanfilename, FILENAME_MAX, "chanTest_H2_inj%d.dat", injSimCount+1); if (vrbflg) fprintf( stdout, "writing H2 channel time series out to %s\n", chanfilename ); LALSPrintTimeSeries(chan, chanfilename ); break; case 3: snprintf( chanfilename, FILENAME_MAX, "chanTest_L1_inj%d.dat", injSimCount+1); if (vrbflg) fprintf( stdout, "writing L1 channel time series out to %s\n", chanfilename ); LALSPrintTimeSeries(chan, chanfilename ); break; default: fprintf( stderr, "Error: ifoNumber %d does not correspond to H1, H2 or L1: \n", ifoNumber ); exit( 1 ); } } LAL_CALL( LALCreateForwardRealFFTPlan( &status, &pfwd, chan->data->length, 0), &status); fftData = XLALCreateCOMPLEX8FrequencySeries( chan->name, &chan->epoch, f0, deltaF, &lalDimensionlessUnit, (numPoints / 2 + 1) ); if ( !fftData ){ XLALPrintError("failure allocating fftData"); exit(1); } LAL_CALL( LALTimeFreqRealFFT( &status, fftData, chan, pfwd ), &status); LAL_CALL( LALDestroyRealFFTPlan( &status, &pfwd ), &status); pfwd = NULL; /* compute the SNR */ thisSnrsq = 0; /* avoid f=0 part of psd */ if (ligosrd){ if (vrbflg) fprintf( stdout, "using LIGOI PSD \n"); for ( k = kLow; k < kHi; k++ ) { REAL8 freq; REAL8 sim_psd_value; freq = fftData->deltaF * k; LALLIGOIPsd( NULL, &sim_psd_value, freq ); thisSnrsq += ((crealf(fftData->data->data[k]) * dynRange) * (crealf(fftData->data->data[k]) * dynRange)) / sim_psd_value; thisSnrsq += ((cimagf(fftData->data->data[k]) * dynRange) * (cimagf(fftData->data->data[k]) * dynRange)) / sim_psd_value; } } else { if (vrbflg) fprintf( stdout, "using input spectra \n"); for ( k = kLow; k < kHi; k++ ) { thisSnrsq += ((crealf(fftData->data->data[k]) * dynRange) * (crealf(fftData->data->data[k]) * dynRange)) / (thisSpec->data->data[k] * dynRange * dynRange); thisSnrsq += ((cimagf(fftData->data->data[k]) * dynRange) * (cimagf(fftData->data->data[k]) * dynRange)) / (thisSpec->data->data[k] * dynRange * dynRange); } } thisSnrsq *= 4*fftData->deltaF; thisSnr = pow(thisSnrsq, 0.5); /* Note indexing on snrVec, ifoNumber runs from 1..3 to get source correct, * we must index snrVec 0..2 */ snrVec[ifoNumber-1] = thisSnr; XLALDestroyCOMPLEX8FrequencySeries(fftData); if ( vrbflg ){ fprintf( stdout, "thisSnrsq %e\n", thisSnrsq ); fprintf( stdout, "snrVec %e\n", snrVec[ifoNumber-1] ); fflush( stdout ); } /* sum thisSnrsq to eventually get combined snr*/ statValue += thisSnrsq; /* free some memory */ if (detector.transfer) detector.transfer = NULL; if ( detector.site ) {LALFree( detector.site); detector.site = NULL;} } /* end loop over ifo */ destroyCoherentGW( &waveform ); /* store inverse eff snrs in eff_dist columns */ thisInjection->eff_dist_h = 1./snrVec[0]; thisInjection->eff_dist_g = 1./snrVec[1]; thisInjection->eff_dist_l = 1./snrVec[2]; /* store inverse sum of squares snr in eff_dist_t */ thisCombSnr = pow(statValue, 0.5); if ( vrbflg ) fprintf( stdout, "thisCombSnr %e\n", thisCombSnr); thisInjection->eff_dist_t = 1./thisCombSnr; /* calc inverse bittenL snr for H1H2 and store in eff_dist_v */ thisCombSnr_H1H2 = 0.; sum = snrVec[0] * snrVec[0] + snrVec[1] * snrVec[1]; bitten_H1 = 3 * snrVec[0] -3; bitten_H2 = 3 * snrVec[1] -3; if (sum < bitten_H1){ thisCombSnr_H1H2 = sum; } else { thisCombSnr_H1H2 = bitten_H1; } if (bitten_H2 < thisCombSnr_H1H2){ thisCombSnr_H1H2 = bitten_H2; } thisInjection->eff_dist_v = 1./thisCombSnr_H1H2; /* increment the bank sim sim_inspiral table if necessary */ if ( injectionHead ) { thisInjection = thisInjection->next; } } while ( ++injSimCount < numInjections ); /* end loop over injections */ /* try opening, writing and closing an xml file */ /* open the output xml file */ memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) ); snprintf( fname, sizeof(fname), "%s", outputFile); LAL_CALL( LALOpenLIGOLwXMLFile ( &status, &xmlStream, fname), &status); /* write out the process and process params tables */ if ( vrbflg ) fprintf( stdout, "process... " ); XLALGPSTimeNow(&(proctable.processTable->end_time)); LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, proctable, process_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); free( proctable.processTable ); /* Just being pedantic here ... */ proctable.processTable = NULL; /* free the unused process param entry */ this_proc_param = procparams.processParamsTable; procparams.processParamsTable = procparams.processParamsTable->next; free( this_proc_param ); this_proc_param = NULL; /* write the process params table */ if ( vrbflg ) fprintf( stdout, "process_params... " ); LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_params_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, procparams, process_params_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* write the search summary table */ if ( coireflg ){ if ( vrbflg ) fprintf( stdout, "search_summary... " ); outputTable.searchSummaryTable = searchSummHead; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, search_summary_table), &status); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, search_summary_table), &status); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream), &status); } /* write the sim inspiral table */ if ( vrbflg ) fprintf( stdout, "sim_inspiral... " ); outputTable.simInspiralTable = injectionHead; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, sim_inspiral_table), &status); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, sim_inspiral_table), &status); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream), &status); /* write the sngl inspiral table */ if ( coireflg ){ if ( vrbflg ) fprintf( stdout, "sngl_inspiral... " ); outputTable.snglInspiralTable = snglHead; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, sngl_inspiral_table), &status); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, sngl_inspiral_table), &status); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream), &status); } /* close the xml file */ LAL_CALL( LALCloseLIGOLwXMLFile ( &status, &xmlStream), &status); /* Freeing memory */ XLALDestroyREAL4TimeSeries(chan); XLALDestroyCOMPLEX8FrequencySeries(resp); XLALDestroyCOMPLEX8FrequencySeries(detTransDummy); XLALDestroyREAL8FrequencySeries ( specH1 ); XLALDestroyREAL8FrequencySeries ( specH2 ); XLALDestroyREAL8FrequencySeries ( specL1 ); free( specFileH1 ); specFileH1 = NULL; free( specFileH2 ); specFileH2 = NULL; free( specFileL1 ); specFileL1 = NULL; free( injectionFile ); injectionFile = NULL; /* free the process params */ while( procparams.processParamsTable ) { this_proc_param = procparams.processParamsTable; procparams.processParamsTable = this_proc_param->next; free( this_proc_param ); this_proc_param = NULL; } /* free the sim inspiral tables */ while ( injectionHead ) { thisInjection = injectionHead; injectionHead = injectionHead->next; LALFree( thisInjection ); } /*check for memory leaks */ LALCheckMemoryLeaks(); exit( 0 ); }
int main(int argc, char *argv[]) { ConfigVariables config = empty_ConfigVariables; UserVariables_t uvar = empty_UserVariables; /* register user-variables */ XLAL_CHECK ( XLALInitUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC ); /* read cmdline & cfgfile */ XLAL_CHECK ( XLALUserVarReadAllInput ( argc,argv ) == XLAL_SUCCESS, XLAL_EFUNC ); if (uvar.help) { /* help requested: we're done */ exit(0); } if ( uvar.version ) { XLALOutputVersionString ( stdout, lalDebugLevel ); exit(0); } /* basic setup and initializations */ XLAL_CHECK ( XLALInitCode( &config, &uvar, argv[0] ) == XLAL_SUCCESS, XLAL_EFUNC ); /* prepare output files */ FILE *fpOutab = NULL; if ( uvar.outab ) { XLAL_CHECK ( (fpOutab = fopen (uvar.outab, "wb")) != NULL, XLAL_EIO, "Error opening file '%s' for writing...", uvar.outab ); /* write header info in comments */ XLAL_CHECK ( XLAL_SUCCESS == XLALOutputVersionString ( fpOutab, 0 ), XLAL_EFUNC ); /* write the command-line */ for (int a = 0; a < argc; a++) { fprintf(fpOutab,"%%%% argv[%d]: '%s'\n", a, argv[a]); } /* write column headings */ fprintf(fpOutab, "%%%% columns:\n%%%% Alpha Delta tGPS "); if ( config.numDetectors == 1 ) { fprintf(fpOutab, " a(t) b(t)"); } else { for ( UINT4 X=0; X < config.numDetectors; X++ ) { fprintf(fpOutab, " a[%d](t) b[%d](t)", X, X); } } fprintf(fpOutab, "\n"); } FILE *fpOutABCD = NULL; if ( uvar.outABCD ) { XLAL_CHECK ( (fpOutABCD = fopen (uvar.outABCD, "wb")) != NULL, XLAL_EIO, "Error opening file '%s' for writing...", uvar.outABCD ); /* write header info in comments */ XLAL_CHECK ( XLAL_SUCCESS == XLALOutputVersionString ( fpOutABCD, 0 ), XLAL_EFUNC ); /* write the command-line */ for (int a = 0; a < argc; a++) { fprintf(fpOutABCD,"%%%% argv[%d]: '%s'\n", a, argv[a]); } /* write column headings */ fprintf(fpOutABCD, "%%%% columns:\n%%%% Alpha Delta"); fprintf(fpOutABCD, " A B C D"); if ( config.numDetectors > 1 ) { fprintf(fpOutABCD, " "); for ( UINT4 X=0; X < config.numDetectors; X++ ) { fprintf(fpOutABCD, " A[%d] B[%d] C[%d] D[%d]", X, X, X, X); } } fprintf(fpOutABCD, "\n"); } /* loop over sky positions (outer loop, could allow for buffering if necessary) */ for (UINT4 n = 0; n < config.numSkyPoints; n++) { SkyPosition skypos; skypos.system = COORDINATESYSTEM_EQUATORIAL; skypos.longitude = config.Alpha->data[n]; skypos.latitude = config.Delta->data[n]; /* do the actual computation of the antenna pattern functions */ MultiAMCoeffs *multiAM; XLAL_CHECK ( ( multiAM = XLALComputeMultiAMCoeffs ( config.multiDetStates, config.multiNoiseWeights, skypos ) ) != NULL, XLAL_EFUNC, "XLALComputeAMCoeffs() failed." ); /* for multi-IFO run with weights, do it again, without weights, to get single-IFO quantities consistent with single-IFO runs * FIXME: remove this temporary hack when MultiAmCoeffs have been changed to include non-weighted single-IFO quantities */ MultiAMCoeffs *multiAMforSingle = NULL; MultiAMCoeffs *multiAMunweighted = NULL; if ( ( config.numDetectors > 1 ) && ( config.multiNoiseWeights != NULL ) ) { XLAL_CHECK ( ( multiAMunweighted = XLALComputeMultiAMCoeffs ( config.multiDetStates, NULL, skypos ) ) != NULL, XLAL_EFUNC, "XLALComputeAMCoeffs() failed." ); multiAMforSingle = multiAMunweighted; } else { multiAMforSingle = multiAM; } /* write out the data for this sky point */ if ( uvar.outab ) { // output a(t), b(t) at each timestamp for (UINT4 t = 0; t < config.numTimeStamps; t++) { // FIXME: does not work for different multi-IFO numTimeStampsX fprintf (fpOutab, "%.7f %.7f %d", config.Alpha->data[n], config.Delta->data[n], config.multiTimestamps->data[0]->data[t].gpsSeconds ); for ( UINT4 X=0; X < config.numDetectors; X++ ) { fprintf(fpOutab, " %12.8f %12.8f", multiAMforSingle->data[X]->a->data[t], multiAMforSingle->data[X]->b->data[t]); } // for ( UINT4 X=0; X < config.numDetectors; X++ ) fprintf(fpOutab, "\n"); } // for (UINT4 t = 0; t < config.numTimeStamps; t++) } // if ( uvar.outab ) if ( uvar.outABCD ) { // output ABCD averaged over all timestamps // FIXME: stop doing average manually when AMCoeffs is changed to contain averaged values REAL8 A = multiAM->Mmunu.Ad/config.numTimeStamps; REAL8 B = multiAM->Mmunu.Bd/config.numTimeStamps; REAL8 C = multiAM->Mmunu.Cd/config.numTimeStamps; REAL8 D = A*B-SQ(C); fprintf (fpOutABCD, "%.7f %.7f %12.8f %12.8f %12.8f %12.8f", config.Alpha->data[n], config.Delta->data[n], A, B, C, D ); if ( config.numDetectors > 1 ) { for ( UINT4 X=0; X < config.numDetectors; X++ ) { REAL4 AX = multiAMforSingle->data[X]->A/config.numTimeStampsX->data[X]; REAL4 BX = multiAMforSingle->data[X]->B/config.numTimeStampsX->data[X]; REAL4 CX = multiAMforSingle->data[X]->C/config.numTimeStampsX->data[X]; REAL4 DX = AX*BX-SQ(CX); fprintf(fpOutABCD, " %12.8f %12.8f %12.8f %12.8f", AX, BX, CX, DX); } } fprintf(fpOutABCD, "\n"); } // if ( uvar.outABCD ) XLALDestroyMultiAMCoeffs ( multiAM ); if ( multiAMunweighted ) { XLALDestroyMultiAMCoeffs ( multiAMunweighted ); } } // for (UINT4 n = 0; n < config.numSkyPoints; n++) /* ----- close output files ----- */ if ( fpOutab ) { fprintf (fpOutab, "\n"); fclose ( fpOutab ); } if ( fpOutABCD ) { fprintf (fpOutABCD, "\n"); fclose ( fpOutABCD ); } /* ----- done: free all memory */ XLAL_CHECK ( XLALDestroyConfig( &config ) == XLAL_SUCCESS, XLAL_EFUNC ); LALCheckMemoryLeaks(); return 0; } /* main */
int main( int argc, char *argv[] ) { /* lal initialization variables */ LALStatus status = blank_status; /* program option variables */ CHAR *userTag = NULL; CHAR comment[LIGOMETA_COMMENT_MAX]; char *ifoName = NULL; char *inputGlob = NULL; char *inputFileName = NULL; char *outputFileName = NULL; char *tamaFileName = NULL; char *summFileName = NULL; REAL4 snrStar = -1; SnglInspiralClusterChoice clusterchoice = none; INT8 cluster_dt = -1; char *injectFileName = NULL; INT8 inject_dt = -1; char *missedFileName = NULL; INT4 hardware = 0; int enableTrigStartTime = 1; int j; FILE *fp = NULL; glob_t globbedFiles; int numInFiles = 0; char **inFileNameList; char line[MAX_PATH]; int errnum; UINT8 triggerInputTimeNS = 0; MetadataTable proctable; MetadataTable procparams; ProcessParamsTable *this_proc_param; UINT4 numSimEvents = 0; UINT4 numSimInData = 0; UINT4 numSimFound = 0; UINT4 numSimMissed = 0; UINT4 numSimDiscard = 0; UINT4 numSimProcessed = 0; SimRingdownTable *simEventHead = NULL; SimRingdownTable *thisSimEvent = NULL; SimRingdownTable *missedSimHead = NULL; SimRingdownTable *thisMissedSim = NULL; SimRingdownTable *tmpSimEvent = NULL; SimRingdownTable *prevSimEvent = NULL; SearchSummaryTable *searchSummaryTable = NULL; UINT4 numEvents = 0; UINT4 numEventsKept = 0; UINT4 numEventsInIFO = 0; UINT4 numEventsCoinc = 0; UINT4 numEventsDiscard = 0; UINT4 numEventsProcessed = 0; UINT4 numClusteredEvents = 0; SnglRingdownTable **eventHandle = NULL; SnglRingdownTable *eventHead = NULL; SnglRingdownTable *thisEvent = NULL; SnglRingdownTable *tmpEvent = NULL; SnglRingdownTable *prevEvent = NULL; LIGOLwXMLStream xmlStream; MetadataTable outputTable; /* * * initialization * */ /* set up inital debugging values */ lal_errhandler = LAL_ERR_EXIT; /* create the process and process params tables */ proctable.processTable = (ProcessTable *) calloc( 1, sizeof(ProcessTable) ); XLALGPSTimeNow(&(proctable.processTable->start_time)); XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME, lalAppsVCSIdentId, lalAppsVCSIdentStatus, lalAppsVCSIdentDate, 0); this_proc_param = procparams.processParamsTable = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); memset( comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR) ); /* * * parse command line arguments * */ while (1) { /* LALgetopt arguments */ static struct LALoption long_options[] = { {"verbose", no_argument, &vrbflg, 1 }, {"sort-triggers", no_argument, &sortTriggers, 1 }, {"help", no_argument, 0, 'h'}, {"user-tag", required_argument, 0, 'Z'}, {"userTag", required_argument, 0, 'Z'}, {"comment", required_argument, 0, 'c'}, {"version", no_argument, 0, 'V'}, {"glob", required_argument, 0, 'g'}, {"input", required_argument, 0, 'i'}, {"output", required_argument, 0, 'o'}, {"data-type", required_argument, 0, 'k'}, {"tama-output", required_argument, 0, 'j'}, {"summary-file", required_argument, 0, 'S'}, {"snr-threshold", required_argument, 0, 's'}, {"cluster-algorithm", required_argument, 0, 'C'}, {"cluster-time", required_argument, 0, 't'}, {"ifo-cut", required_argument, 0, 'd'}, {"injection-file", required_argument, 0, 'I'}, {"injection-coincidence", required_argument, 0, 'T'}, {"missed-injections", required_argument, 0, 'm'}, {"hardware-injections", required_argument, 0, 'H'}, {"disable-trig-start-time", no_argument, 0, 'D'}, {0, 0, 0, 0} }; int c; /* LALgetopt_long stores the option index here. */ int option_index = 0; size_t LALoptarg_len; c = LALgetopt_long_only ( argc, argv, "hZ:c:d:g:i:o:j:S:s:C:Vt:I:T:m:H:D", long_options, &option_index ); /* detect the end of the options */ if ( c == - 1 ) break; switch ( c ) { case 0: /* if this option set a flag, do nothing else now */ if ( long_options[option_index].flag != 0 ) { break; } else { fprintf( stderr, "error parsing option %s with argument %s\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } break; case 'h': fprintf( stdout, USAGE ); exit( 0 ); break; case 'Z': /* create storage for the usertag */ LALoptarg_len = strlen( LALoptarg ) + 1; userTag = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR) ); memcpy( userTag, LALoptarg, LALoptarg_len ); this_proc_param = this_proc_param->next = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "-userTag" ); snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%s", LALoptarg ); break; case 'c': if ( strlen( LALoptarg ) > LIGOMETA_COMMENT_MAX - 1 ) { fprintf( stderr, "invalid argument to --%s:\n" "comment must be less than %d characters\n", long_options[option_index].name, LIGOMETA_COMMENT_MAX ); exit( 1 ); } else { snprintf( comment, LIGOMETA_COMMENT_MAX, "%s", LALoptarg); } break; case 'V': fprintf( stdout, "Single Ringdown Reader and Injection Analysis\n" "Patrick Brady, Duncan Brown and Steve Fairhurst\n"); XLALOutputVersionString(stderr, 0); exit( 0 ); break; case 'g': /* create storage for the input file glob */ LALoptarg_len = strlen( LALoptarg ) + 1; inputGlob = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( inputGlob, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "'%s'", LALoptarg ); break; case 'i': /* create storage for the input file name */ LALoptarg_len = strlen( LALoptarg ) + 1; inputFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( inputFileName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'o': /* create storage for the output file name */ LALoptarg_len = strlen( LALoptarg ) + 1; outputFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( outputFileName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'j': /* create storage of the TAMA file name */ LALoptarg_len = strlen( LALoptarg ) + 1; tamaFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( tamaFileName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'S': /* create storage for the summ file name */ LALoptarg_len = strlen( LALoptarg ) + 1; summFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( summFileName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 's': snrStar = (REAL4) atof( LALoptarg ); if ( snrStar < 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "threshold must be >= 0: " "(%f specified)\n", long_options[option_index].name, snrStar ); exit( 1 ); } ADD_PROCESS_PARAM( "float", "%e", snrStar ); break; case 'k': /* type of data to analyze */ if ( ! strcmp( "playground_only", LALoptarg ) ) { dataType = playground_only; } else if ( ! strcmp( "exclude_play", LALoptarg ) ) { dataType = exclude_play; } else if ( ! strcmp( "all_data", LALoptarg ) ) { dataType = all_data; } else { fprintf( stderr, "invalid argument to --%s:\n" "unknown data type, %s, specified: " "(must be playground_only, exclude_play or all_data)\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'C': /* choose the clustering algorithm */ { if ( ! strcmp( "snr_and_chisq", LALoptarg ) ) { clusterchoice = snr_and_chisq; } else if ( ! strcmp( "snrsq_over_chisq", LALoptarg) ) { clusterchoice = snrsq_over_chisq; } else if ( ! strcmp( "snr", LALoptarg) ) { clusterchoice = snr; } else { fprintf( stderr, "invalid argument to --%s:\n" "unknown clustering specified:\n " "%s (must be one of: snr_and_chisq, \n" " snrsq_over_chisq or snr)\n", long_options[option_index].name, LALoptarg); exit( 1 ); } ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); } break; case 't': /* cluster time is specified on command line in ms */ cluster_dt = (INT8) atoi( LALoptarg ); if ( cluster_dt <= 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "custer window must be > 0: " "(%" LAL_INT8_FORMAT " specified)\n", long_options[option_index].name, cluster_dt ); exit( 1 ); } ADD_PROCESS_PARAM( "int", "%" LAL_INT8_FORMAT "", cluster_dt ); /* convert cluster time from ms to ns */ cluster_dt *= LAL_INT8_C(1000000); break; case 'I': /* create storage for the injection file name */ LALoptarg_len = strlen( LALoptarg ) + 1; injectFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( injectFileName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'd': LALoptarg_len = strlen( LALoptarg ) + 1; ifoName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( ifoName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'T': /* injection coincidence time is specified on command line in ms */ inject_dt = (INT8) atoi( LALoptarg ); if ( inject_dt < 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "injection coincidence window must be >= 0: " "(%" LAL_INT8_FORMAT " specified)\n", long_options[option_index].name, inject_dt ); exit( 1 ); } ADD_PROCESS_PARAM( "int", "%" LAL_INT8_FORMAT " ", inject_dt ); /* convert inject time from ms to ns */ inject_dt *= LAL_INT8_C(1000000); break; case 'm': /* create storage for the missed injection file name */ LALoptarg_len = strlen( LALoptarg ) + 1; missedFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( missedFileName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'H': hardware = (INT4) atoi( LALoptarg ); if ( hardware <= 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "GPS start time of hardware injections must be > 0: " "(%d specified)\n", long_options[option_index].name, hardware ); exit( 1 ); } ADD_PROCESS_PARAM( "int", "%" LAL_INT4_FORMAT " ", hardware ); break; case 'D': enableTrigStartTime = 0; ADD_PROCESS_PARAM( "string", "%s", " " ); break; case '?': exit( 1 ); break; 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 ); } /* * * can use LALCalloc() / LALMalloc() from here * */ /* don't buffer stdout if we are in verbose mode */ if ( vrbflg ) setvbuf( stdout, NULL, _IONBF, 0 ); /* fill the comment, if a user has specified it, or leave it blank */ if ( ! *comment ) { snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " ); } else { snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, "%s", comment ); } /* check that the input and output file names have been specified */ if ( (! inputGlob && ! inputFileName) || (inputGlob && inputFileName) ) { fprintf( stderr, "exactly one of --glob or --input must be specified\n" ); exit( 1 ); } if ( ! outputFileName ) { fprintf( stderr, "--output must be specified\n" ); exit( 1 ); } /* check that Data Type has been specified */ if ( dataType == unspecified_data_type ) { fprintf( stderr, "Error: --data-type must be specified\n"); exit(1); } /* check that if clustering is being done that we have all the options */ if ( clusterchoice && cluster_dt < 0 ) { fprintf( stderr, "--cluster-time must be specified if --cluster-algorithm " "is given\n" ); exit( 1 ); } else if ( ! clusterchoice && cluster_dt >= 0 ) { fprintf( stderr, "--cluster-algorithm must be specified if --cluster-time " "is given\n" ); exit( 1 ); } /* check that we have all the options to do injections */ if ( injectFileName && inject_dt < 0 ) { fprintf( stderr, "--injection-coincidence must be specified if " "--injection-file is given\n" ); exit( 1 ); } else if ( ! injectFileName && inject_dt >= 0 ) { fprintf( stderr, "--injection-file must be specified if " "--injection-coincidence is given\n" ); exit( 1 ); } /* save the sort triggers flag */ if ( sortTriggers ) { this_proc_param = this_proc_param->next = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "--sort-triggers" ); snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, " " ); } switch ( dataType ) { case playground_only: if ( vrbflg ) fprintf( stdout, "using data from playground times only\n" ); snprintf( procparams.processParamsTable->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( procparams.processParamsTable->param, LIGOMETA_PARAM_MAX, "--playground-only" ); snprintf( procparams.processParamsTable->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( procparams.processParamsTable->value, LIGOMETA_TYPE_MAX, " " ); break; case exclude_play: if ( vrbflg ) fprintf( stdout, "excluding all triggers in playground times\n" ); snprintf( procparams.processParamsTable->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( procparams.processParamsTable->param, LIGOMETA_PARAM_MAX, "--exclude-play" ); snprintf( procparams.processParamsTable->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( procparams.processParamsTable->value, LIGOMETA_TYPE_MAX, " " ); break; case all_data: if ( vrbflg ) fprintf( stdout, "using all input data\n" ); snprintf( procparams.processParamsTable->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( procparams.processParamsTable->param, LIGOMETA_PARAM_MAX, "--all-data" ); snprintf( procparams.processParamsTable->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( procparams.processParamsTable->value, LIGOMETA_TYPE_MAX, " " ); break; default: fprintf( stderr, "data set not defined\n" ); exit( 1 ); } /* * * read in the injection XML file, if we are doing an injection analysis * */ if ( injectFileName ) { if ( vrbflg ) fprintf( stdout, "reading injections from %s... ", injectFileName ); simEventHead = XLALSimRingdownTableFromLIGOLw( injectFileName, 0, 0 ); if ( vrbflg ) fprintf( stdout, "got %d injections\n", numSimEvents ); if ( ! simEventHead ) { fprintf( stderr, "error: unable to read sim_ringdown table from %s\n", injectFileName ); exit( 1 ); } /* if we are doing hardware injections, increment all the start times */ if ( hardware ) { if ( vrbflg ) fprintf( stdout, "incrementing GPS times of injections by %d seconds\n", hardware ); for ( thisSimEvent = simEventHead; thisSimEvent; thisSimEvent = thisSimEvent->next ) { thisSimEvent->geocent_start_time.gpsSeconds += hardware; thisSimEvent->h_start_time.gpsSeconds += hardware; thisSimEvent->l_start_time.gpsSeconds += hardware; } } /* discard all injection events that are not in the data we want */ if ( dataType != all_data ) { numSimDiscard = 0; thisSimEvent = simEventHead; simEventHead = NULL; prevSimEvent = NULL; if ( vrbflg ) fprintf( stdout, "discarding injections not in data\n" ); while ( thisSimEvent ) { INT4 isPlayground = XLALINT8NanoSecIsPlayground(XLALGPSToINT8NS(&(thisSimEvent->geocent_start_time))); if ( (dataType == playground_only && isPlayground) || (dataType == exclude_play && ! isPlayground) ) { /* store the head of the linked list */ if ( ! simEventHead ) simEventHead = thisSimEvent; /* keep this event */ prevSimEvent = thisSimEvent; thisSimEvent = thisSimEvent->next; ++numSimInData; if ( vrbflg ) fprintf( stdout, "+" ); } else { /* throw this event away */ tmpSimEvent = thisSimEvent; if ( prevSimEvent ) prevSimEvent->next = thisSimEvent->next; thisSimEvent = thisSimEvent->next; LALFree( tmpSimEvent ); ++numSimDiscard; if ( vrbflg ) fprintf( stdout, "-" ); } } if ( vrbflg ) fprintf( stdout, "\nusing %d (discarded %d) of %d injections\n", numSimInData, numSimDiscard, numSimEvents ); } else { if ( vrbflg ) fprintf( stdout, "using all %d injections\n", numSimInData ); numSimInData = numSimEvents; } } /* * * read in the input triggers from the xml files * */ if ( inputGlob ) { /* use glob() to get a list of the input file names */ if ( glob( inputGlob, GLOB_ERR, NULL, &globbedFiles ) ) { fprintf( stderr, "error globbing files from %s\n", inputGlob ); perror( "error:" ); exit( 1 ); } numInFiles = globbedFiles.gl_pathc; inFileNameList = (char **) LALCalloc( numInFiles, sizeof(char *) ); for ( j = 0; j < numInFiles; ++j ) { inFileNameList[j] = globbedFiles.gl_pathv[j]; } } else if ( inputFileName ) { /* read the list of input filenames from a file */ fp = fopen( inputFileName, "r" ); if ( ! fp ) { fprintf( stderr, "could not open file containing list of xml files\n" ); perror( "error:" ); exit( 1 ); } /* count the number of lines in the file */ while ( get_next_line( line, sizeof(line), fp ) ) { ++numInFiles; } rewind( fp ); /* allocate memory to store the input file names */ inFileNameList = (char **) LALCalloc( numInFiles, sizeof(char *) ); /* read in the input file names */ for ( j = 0; j < numInFiles; ++j ) { inFileNameList[j] = (char *) LALCalloc( MAX_PATH, sizeof(char) ); get_next_line( line, sizeof(line), fp ); strncpy( inFileNameList[j], line, strlen(line) - 1); } fclose( fp ); } else { fprintf( stderr, "no input file mechanism specified\n" ); exit( 1 ); } if ( vrbflg ) { fprintf( stdout, "reading input triggers from:\n" ); for ( j = 0; j < numInFiles; ++j ) { fprintf( stdout, "%s\n", inFileNameList[j] ); } } /* * * read in the triggers from the input xml files * */ if ( injectFileName ) { thisSimEvent = simEventHead; simEventHead = NULL; prevSimEvent = NULL; numSimDiscard = 0; numSimInData = 0; if ( vrbflg ) fprintf( stdout, "discarding injections not in input data\n" ); } for ( j = 0; j < numInFiles; ++j ) { LIGOTimeGPS inPlay, outPlay; UINT8 outPlayNS, outStartNS, outEndNS, triggerTimeNS; INT4 trigStartTimeArg = 0; searchSummaryTable = XLALSearchSummaryTableFromLIGOLw( inFileNameList[j] ); if ( ( ! searchSummaryTable ) || searchSummaryTable->next ) { fprintf( stderr, "error: zero or multiple search_summary tables in %s\n", inFileNameList[j] ); exit( 1 ); } if ( enableTrigStartTime ) { /* override the value of out_start_time if there is a non-zero */ /* --trig-start-time option in the process_params table */ /* this is necessary to get round a bug in early versions of */ /* the ringdown code */ int mioStatus; int pParParam; int pParValue; struct MetaioParseEnvironment parseEnv; const MetaioParseEnv env = &parseEnv; /* open the procress_params table from the input file */ mioStatus = MetaioOpenTable( env, inFileNameList[j], "process_params" ); if ( mioStatus ) { fprintf( stderr, "error opening process_params table from file %s\n", inFileNameList[j] ); exit( 1 ); } /* figure out where the param and value columns are */ if ( (pParParam = MetaioFindColumn( env, "param" )) < 0 ) { fprintf( stderr, "unable to find column param in process_params\n" ); MetaioClose(env); exit( 1 ); } if ( (pParValue = MetaioFindColumn( env, "value" )) < 0 ) { fprintf( stderr, "unable to find column value in process_params\n" ); MetaioClose(env); exit( 1 ); } /* get the trigger start time from the process params */ while ( (mioStatus = MetaioGetRow(env)) == 1 ) { if ( ! strcmp( env->ligo_lw.table.elt[pParParam].data.lstring.data, "--trig-start-time" ) ) { trigStartTimeArg = (INT4) atoi( env->ligo_lw.table.elt[pParValue].data.lstring.data ); } } MetaioClose( env ); if ( trigStartTimeArg ) { searchSummaryTable->out_start_time.gpsSeconds = trigStartTimeArg; searchSummaryTable->out_start_time.gpsNanoSeconds = 0; if ( vrbflg ) fprintf( stdout, "file %s has --trig-start-time %d\n", inFileNameList[j], trigStartTimeArg ); } } /* compute the out time from the search summary table */ outStartNS = XLALGPSToINT8NS ( &(searchSummaryTable->out_start_time) ); outEndNS = XLALGPSToINT8NS ( &(searchSummaryTable->out_end_time) ); triggerTimeNS = outEndNS - outStartNS; /* check for events and playground */ if ( dataType != all_data ) { LAL_CALL( LALPlaygroundInSearchSummary( &status, searchSummaryTable, &inPlay, &outPlay ), &status ); outPlayNS = XLALGPSToINT8NS ( &outPlay ); if ( dataType == playground_only ) { if ( outPlayNS ) { /* increment the total trigger time by the amount of playground */ triggerInputTimeNS += outPlayNS; } else { /* skip this file as it does not contain any playground data */ if ( vrbflg ) { fprintf( stdout, "file %s not in playground, continuing\n", inFileNameList[j] ); } LALFree( searchSummaryTable ); searchSummaryTable = NULL; continue; } } else if ( dataType == exclude_play ) { /* increment the total trigger time by the out time minus */ /* the time that is in the playground */ triggerInputTimeNS += triggerTimeNS - outPlayNS; } } else { /* increment the total trigger time by the out time minus */ triggerInputTimeNS += triggerTimeNS; } if ( injectFileName ) { if ( vrbflg ) fprintf( stdout, "discarding injections not in file: " ); /* throw away injections that are outside analyzed times */ while ( thisSimEvent && thisSimEvent->geocent_start_time.gpsSeconds < searchSummaryTable->out_end_time.gpsSeconds ) { /* check if injection is before file start time */ if ( thisSimEvent->geocent_start_time.gpsSeconds < searchSummaryTable->out_start_time.gpsSeconds ) { /* discard the current injection */ if ( prevSimEvent ) prevSimEvent->next = thisSimEvent->next; tmpSimEvent = thisSimEvent; thisSimEvent = thisSimEvent->next; LALFree( tmpSimEvent ); ++numSimDiscard; if ( vrbflg ) fprintf( stdout, "-" ); } else { /* store the head of the linked list */ if ( ! simEventHead ) simEventHead = thisSimEvent; /* keep this injection */ prevSimEvent = thisSimEvent; thisSimEvent = thisSimEvent->next; ++numSimInData; if ( vrbflg ) fprintf( stdout, "+" ); } } if ( vrbflg ) fprintf( stdout, "\n" ); } /* * * if there are any events in the file, read them in * */ if ( searchSummaryTable->nevents ) { INT4 isPlay; if ( vrbflg ) fprintf( stdout, "file %s contains %d events, processing\n", inFileNameList[j], searchSummaryTable->nevents ); if ( ! prevEvent ) { eventHandle = &thisEvent; } else { eventHandle = &(prevEvent->next); } /* read the events from the file into a temporary list */ XLAL_TRY( *eventHandle = XLALSnglRingdownTableFromLIGOLw( inFileNameList[j] ), errnum); if ( ! *eventHandle ) switch ( errnum ) { case XLAL_EDATA: XLALPrintError("Unable to read sngl_ringdown table from %s\n", inFileNameList[j] ); /*LALFree(thisInputFile);*/ XLALClearErrno(); break; default: XLALSetErrno( errnum ); XLAL_ERROR(XLAL_EFUNC ); } /* only keep triggers from the data that we want to analyze */ thisEvent = *eventHandle; while ( thisEvent ) { numEvents++; isPlay = XLALINT8NanoSecIsPlayground( XLALGPSToINT8NS( &(thisEvent->start_time) ) ); if ( (dataType == all_data || (dataType == playground_only && isPlay) || (dataType == exclude_play && ! isPlay)) && ( snrStar < 0 || thisEvent->snr > snrStar) ) { /* keep the trigger and increment the count of triggers */ if ( ! eventHead ) eventHead = thisEvent; prevEvent = thisEvent; thisEvent = thisEvent->next; ++numEventsKept; } else { /* discard the trigger and move to the next one */ if ( prevEvent ) prevEvent->next = thisEvent->next; tmpEvent = thisEvent; thisEvent = thisEvent->next; LAL_CALL ( LALFreeSnglRingdown ( &status, &tmpEvent ), &status); } } /* make sure that the linked list is properly terminated */ if ( prevEvent && prevEvent->next ) prevEvent->next->next = NULL; } else { if ( vrbflg ) fprintf( stdout, "file %s contains no events, skipping\n", inFileNameList[j] ); } LALFree( searchSummaryTable ); searchSummaryTable = NULL; } /* discard the remaining injections which occured after the last file */ if ( injectFileName ) { if ( vrbflg ) fprintf( stdout, "kept %d injections, discarded %d\n", numSimInData, numSimDiscard ); if ( prevSimEvent ) prevSimEvent->next = NULL; numSimDiscard = 0; while ( thisSimEvent ) { tmpSimEvent = thisSimEvent; thisSimEvent = thisSimEvent->next; LALFree( tmpSimEvent ); ++numSimDiscard; if ( vrbflg ) fprintf( stdout, "-" ); } if ( vrbflg ) fprintf( stdout, "\ndiscarded %d injections at end of list\n", numSimDiscard ); } /* * * sort the ringdown events by time * */ if ( injectFileName || sortTriggers ) { if ( vrbflg ) fprintf( stdout, "sorting ringdown trigger list..." ); LAL_CALL( LALSortSnglRingdown( &status, &eventHead, *LALCompareSnglRingdownByTime ), &status ); if ( vrbflg ) fprintf( stdout, "done\n" ); } /* * * keep only event from requested ifo * */ if ( ifoName ) { if ( vrbflg ) fprintf( stdout, "keeping only triggers from %s, discarding others...", ifoName ); LAL_CALL( LALIfoCutSingleRingdown( &status, &eventHead, ifoName ), &status ); LALIfoCountSingleRingdown( &status, &numEventsInIFO, eventHead, XLALIFONumber(ifoName) ); if ( vrbflg ) fprintf( stdout, "done\n" ); } /* * * check for events that are coincident with injections * */ if ( injectFileName ) { int coincidence = 0; UINT8 simTime, ringdownTime; if ( vrbflg ) fprintf( stdout, "checking for events that are coincident with injections\n" ); /* Note: we are assuming that both the ringdown and */ /* injection events are time sorted */ thisSimEvent = simEventHead; thisEvent = eventHead; simEventHead = NULL; eventHead = NULL; prevSimEvent = NULL; prevEvent = NULL; numSimFound = 0; numSimDiscard = 0; numEventsDiscard = 0; numEventsCoinc = 0; if ( ! thisEvent ) { /* no triggers in the input data, so all injections are missed */ if ( vrbflg ) fprintf( stdout, "no triggers in input data\n" ); thisMissedSim = missedSimHead = thisSimEvent; while ( thisMissedSim ) { /* count the number of injections just stuck in the missed list */ if ( vrbflg ) fprintf( stdout, "M" ); ++numSimMissed; ++numSimProcessed; thisMissedSim = thisMissedSim->next; } } else { /* begin loop over the sim_ringdown events */ while ( thisSimEvent ) { /* compute the end time in nanosec for the injection */ /* at the relevant detector */ if ( ! strcmp( "L1", thisEvent->ifo ) ) { simTime = XLALGPSToINT8NS ( &(thisSimEvent->l_start_time) ); } else if ( ! strcmp( "H1", thisEvent->ifo ) || ! strcmp( "H2", thisEvent->ifo ) ) { simTime = XLALGPSToINT8NS ( &(thisSimEvent->h_start_time) ); } else { fprintf( stderr, "unknown detector found in event list: %s\n", thisEvent->ifo ); fprintf( stderr, "Detector must be one of (G1|H1|H2|L1|T1|V1)\n"); exit( 1 ); } /* find the first ringdown event after the current sim event */ while ( thisEvent ) { coincidence = 0; /* compute the time in nanosec for the ringdown */ ringdownTime = XLALGPSToINT8NS ( &(thisEvent->start_time) ); if ( ringdownTime < (simTime - inject_dt) ) { /* discard this event and move on to the next one */ if ( prevEvent ) prevEvent->next = thisEvent->next; tmpEvent = thisEvent; thisEvent = thisEvent->next; LAL_CALL ( LALFreeSnglRingdown ( &status, &tmpEvent ), &status); ++numEventsProcessed; ++numEventsDiscard; if ( vrbflg ) fprintf( stdout, "-" ); } else { /* we have reached the negative coincincidence window */ break; } } while ( thisEvent ) { /* compute the time in nanosec for the ringdown */ ringdownTime = XLALGPSToINT8NS ( &(thisEvent->start_time) ); if ( ringdownTime < (simTime + inject_dt) ) { /* this event is within the coincidence window */ /* store this event and move on to the next one */ if ( ! eventHead ) eventHead = thisEvent; prevEvent = thisEvent; thisEvent = thisEvent->next; coincidence = 1; ++numEventsProcessed; ++numEventsCoinc; if ( vrbflg ) fprintf( stdout, "+" ); } else { /* we have reached the end of the positive coincincidence window */ break; } } if ( coincidence ) { /* keep this event in the list and move to the next sim event */ if ( ! simEventHead ) simEventHead = thisSimEvent; prevSimEvent = thisSimEvent; ++numSimFound; ++numSimProcessed; thisSimEvent = thisSimEvent->next; if ( vrbflg ) fprintf( stdout, "F" ); } else { /* save this sim event in the list of missed events... */ if ( ! missedSimHead ) { missedSimHead = thisMissedSim = thisSimEvent; } else { thisMissedSim = thisMissedSim->next = thisSimEvent; } /* ...and remove it from the list of found events */ if ( prevSimEvent ) prevSimEvent->next = thisSimEvent->next; ++numSimMissed; if ( vrbflg ) fprintf( stdout, "M" ); /* move to the next sim in the list */ ++numSimProcessed; thisSimEvent = thisSimEvent->next; /* make sure the missed sim list is terminated */ thisMissedSim->next = NULL; } if ( ! thisEvent ) { /* these are no more events to process so all the rest of the */ /* injections must be put in the missed injections list */ if ( ! missedSimHead ) { /* this and any subsequent events are in the missed sim list */ if ( thisSimEvent ) thisMissedSim = missedSimHead = thisSimEvent; } else { if ( thisSimEvent ) { /* append the rest of the list to the list of missed injections */ thisMissedSim = thisMissedSim->next = thisSimEvent; } else { /* there are no injections after this one */ thisMissedSim = thisMissedSim->next = NULL; } } /* terminate the list of found injections correctly */ if ( prevSimEvent ) prevSimEvent->next = NULL; while ( thisMissedSim ) { /* count the number of injections just stuck in the missed list */ if ( vrbflg ) fprintf( stdout, "M" ); ++numSimMissed; ++numSimProcessed; thisMissedSim = thisMissedSim->next; } thisSimEvent = NULL; break; } } if ( thisEvent ) { /* discard any remaining ringdown triggers -- including thisEvent */ /* as we have run out of injections */ tmpEvent = thisEvent; if ( prevEvent ) prevEvent->next = NULL; while ( tmpEvent ) { thisEvent = tmpEvent; tmpEvent = tmpEvent->next; LAL_CALL ( LALFreeSnglRingdown ( &status, &thisEvent ), &status); ++numEventsDiscard; ++numEventsProcessed; if ( vrbflg ) fprintf( stdout, "-" ); } } } if ( vrbflg ) { fprintf( stdout, "\nfound %d injections, missed %d injections " "(%d injections processed)\n", numSimFound, numSimMissed, numSimProcessed ); fprintf( stdout, "found %d coincident events, %d events discarded " "(%d events processed)\n", numEventsCoinc, numEventsDiscard, numEventsProcessed ); } } /* end if ( injectFileName ) */ /* * * cluster the remaining events * */ if ( eventHead && clusterchoice ) { if ( vrbflg ) fprintf( stdout, "clustering remaining triggers... " ); LAL_CALL( LALClusterSnglRingdownTable( &status, eventHead, cluster_dt, clusterchoice ), &status ); if ( vrbflg ) fprintf( stdout, "done\n" ); /* count the number of triggers surviving the clustering */ thisEvent = eventHead; numClusteredEvents = 0; while ( thisEvent ) { ++numClusteredEvents; thisEvent = thisEvent->next; } } /* * * write output data * */ /* write the main output file containing found injections */ if ( vrbflg ) fprintf( stdout, "writing output xml files... " ); memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) ); LAL_CALL( LALOpenLIGOLwXMLFile( &status, &xmlStream, outputFileName ), &status ); /* write out the process and process params tables */ if ( vrbflg ) fprintf( stdout, "process... " ); XLALGPSTimeNow(&(proctable.processTable->start_time)); LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, proctable, process_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); free( proctable.processTable ); /* write the process params table */ if ( vrbflg ) fprintf( stdout, "process_params... " ); LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_params_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, procparams, process_params_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* Write the found injections to the sim table */ if ( simEventHead ) { if ( vrbflg ) fprintf( stdout, "sim_ringdown... " ); outputTable.simRingdownTable = simEventHead; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, sim_ringdown_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, sim_ringdown_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status ); } /* Write the results to the ringdown table */ if ( eventHead ) { if ( vrbflg ) fprintf( stdout, "sngl_ringdown... " ); outputTable.snglRingdownTable = eventHead; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, sngl_ringdown_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, sngl_ringdown_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status); } /* close the output file */ LAL_CALL( LALCloseLIGOLwXMLFile(&status, &xmlStream), &status); if ( vrbflg ) fprintf( stdout, "done\n" ); /* write out the TAMA file if it is requested */ if ( tamaFileName ) { /* FIXME */ REAL8 UNUSED trigtime; fp = fopen( tamaFileName, "w" ); if ( ! fp ) { perror( "TAMA file" ); exit( 1 ); } fprintf( fp, "IFO trigger time snr chisq " " total mass eta eff dist (kpc)\n" ); for ( thisEvent = eventHead; thisEvent; thisEvent = thisEvent->next ) { trigtime = XLALGPSGetREAL8(&(thisEvent->start_time)); } fclose( fp ); } if ( missedFileName ) { /* open the missed injections file and write the missed injections to it */ if ( vrbflg ) fprintf( stdout, "writing missed injections... " ); memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) ); LAL_CALL( LALOpenLIGOLwXMLFile( &status, &xmlStream, missedFileName ), &status ); if ( missedSimHead ) { outputTable.simRingdownTable = missedSimHead; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, sim_ringdown_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, sim_ringdown_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status ); } LAL_CALL( LALCloseLIGOLwXMLFile( &status, &xmlStream ), &status ); if ( vrbflg ) fprintf( stdout, "done\n" ); } if ( summFileName ) { LIGOTimeGPS triggerTime; /* write out a summary file */ fp = fopen( summFileName, "w" ); switch ( dataType ) { case playground_only: fprintf( fp, "using data from playground times only\n" ); break; case exclude_play: fprintf( fp, "excluding all triggers in playground times\n" ); break; case all_data: fprintf( fp, "using all input data\n" ); break; default: fprintf( stderr, "data set not defined\n" ); exit( 1 ); } fprintf( fp, "read triggers from %d files\n", numInFiles ); fprintf( fp, "number of triggers in input files: %d \n", numEvents ); if ( snrStar >= 0 ) { fprintf( fp, "number of triggers in input data with snr above %f: %d \n", snrStar, numEventsKept ); } else { fprintf( fp, "number of triggers in input data %d \n", numEventsKept ); } if ( ifoName ) { fprintf( fp, "number of triggers from %s ifo %d \n", ifoName, numEventsInIFO ); } XLALINT8NSToGPS( &triggerTime, triggerInputTimeNS ); fprintf( fp, "amount of time analysed for triggers %d sec %d ns\n", triggerTime.gpsSeconds, triggerTime.gpsNanoSeconds ); if ( injectFileName ) { fprintf( fp, "read %d injections from file %s\n", numSimEvents, injectFileName ); fprintf( fp, "number of injections in input data: %d\n", numSimInData ); fprintf( fp, "number of injections found in input data: %d\n", numSimFound ); fprintf( fp, "number of triggers found within %" LAL_INT8_FORMAT "msec of injection: %d\n", (inject_dt / LAL_INT8_C(1000000) ), numEventsCoinc ); fprintf( fp, "efficiency: %f \n", (REAL4) numSimFound / (REAL4) numSimInData ); } if ( clusterchoice ) { fprintf( fp, "number of event clusters with %" LAL_INT8_FORMAT " msec window: %d\n", cluster_dt/ LAL_INT8_C(1000000), numClusteredEvents ); } fclose( fp ); } /* * * free memory and exit * */ /* free the ringdown events we saved */ while ( eventHead ) { thisEvent = eventHead; eventHead = eventHead->next; LAL_CALL ( LALFreeSnglRingdown ( &status, &thisEvent ), &status); } /* free the process params */ while( procparams.processParamsTable ) { this_proc_param = procparams.processParamsTable; procparams.processParamsTable = this_proc_param->next; free( this_proc_param ); } /* free the found injections */ while ( simEventHead ) { thisSimEvent = simEventHead; simEventHead = simEventHead->next; LALFree( thisSimEvent ); } /* free the temporary memory containing the missed injections */ while ( missedSimHead ) { tmpSimEvent = missedSimHead; missedSimHead = missedSimHead->next; LALFree( tmpSimEvent ); } /* free the input file name data */ if ( inputGlob ) { LALFree( inFileNameList ); globfree( &globbedFiles ); } else { for ( j = 0; j < numInFiles; ++j ) { LALFree( inFileNameList[j] ); } LALFree( inFileNameList ); } if ( vrbflg ) fprintf( stdout, "checking memory leaks and exiting\n" ); LALCheckMemoryLeaks(); exit( 0 ); }
int main( int argc, char *argv[] ) { static LALStatus status; INT4 startTime = -1; LIGOTimeGPS startTimeGPS = {0,0}; INT4 endTime = -1; LIGOTimeGPS endTimeGPS = {0,0}; CHAR inputIFO[LIGOMETA_IFO_MAX]; CHAR outputIFO[LIGOMETA_IFO_MAX]; CHAR comment[LIGOMETA_COMMENT_MAX]; CHAR *userTag = NULL; CHAR *ifoTag = NULL; CHAR fileName[FILENAME_MAX]; INT4 numTriggers = 0; SnglInspiralTable *inspiralEventList=NULL; SnglInspiralTable *currentTrigger = NULL; SearchSummvarsTable *inputFiles = NULL; SearchSummvarsTable *thisInputFile = NULL; SearchSummaryTable *searchSummList = NULL; SearchSummaryTable *thisSearchSumm = NULL; MetadataTable proctable; MetadataTable processParamsTable; MetadataTable searchsumm; MetadataTable searchSummvarsTable; MetadataTable inspiralTable; ProcessParamsTable *this_proc_param = NULL; LIGOLwXMLStream xmlStream; INT4 outCompress = 0; long int gpstime; trigScanType trigScanMethod = trigScanNone; /* Switch for clustering */ /* triggers in template */ /* parameters and end time */ REAL8 trigScanMetricScalingFac = -1.0; /* Use this scaling factor for the volume spanned by a trigger in the */ /* parameter space. When set to x, the volume is taken to be that of the*/ /* ambiguity ellipsoid at a 'minimal match' of (1.0-x). */ /* original bank entered at the */ /* command line */ INT2 trigScanAppendStragglers = -1; /* Switch to append cluster */ /* out-liers (stragglers) */ INT4 i; /* LALgetopt arguments */ struct LALoption long_options[] = { {"verbose", no_argument, &vrbflg, 1 }, {"write-compress", no_argument, &outCompress, 1 }, {"gps-start-time", required_argument, 0, 'q'}, {"gps-end-time", required_argument, 0, 'r'}, {"help", no_argument, 0, 'h'}, {"version", no_argument, 0, 'V'}, {"user-tag", required_argument, 0, 'Z'}, {"ifo", required_argument, 0, 'I'}, {"ts-cluster", required_argument, 0, '*'}, {"ts-metric-scaling", required_argument, 0, '>'}, {0, 0, 0, 0} }; int c; /* * * initialize things * */ lal_errhandler = LAL_ERR_EXIT; setvbuf( stdout, NULL, _IONBF, 0 ); /* create the process and process params tables */ proctable.processTable = (ProcessTable *) calloc( 1, sizeof(ProcessTable) ); XLALGPSTimeNow(&(proctable.processTable->start_time)); XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME, lalAppsVCSIdentId, lalAppsVCSIdentStatus, lalAppsVCSIdentDate, 0); this_proc_param = processParamsTable.processParamsTable = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); memset( comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR) ); /* create the search summary and zero out the summvars table */ searchsumm.searchSummaryTable = (SearchSummaryTable *) calloc( 1, sizeof(SearchSummaryTable) ); /* parse the arguments */ while ( 1 ) { /* LALgetopt_long stores long option here */ int option_index = 0; size_t LALoptarg_len; c = LALgetopt_long_only( argc, argv, "a:b:hq:r:s:A:I:VZ:", long_options, &option_index ); /* detect the end of the options */ if ( c == -1 ) { break; } switch ( c ) { case 0: /* if this option set a flag, do nothing else now */ if ( long_options[option_index].flag != 0 ) { break; } else { fprintf( stderr, "Error parsing option %s with argument %s\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } break; case 's': if ( strlen( LALoptarg ) > LIGOMETA_COMMENT_MAX - 1 ) { fprintf( stderr, "invalid argument to --%s:\n" "comment must be less than %d characters\n", long_options[option_index].name, LIGOMETA_COMMENT_MAX ); exit( 1 ); } else { snprintf( comment, LIGOMETA_COMMENT_MAX, "%s", LALoptarg); } break; case 'h': /* help message */ print_usage(argv[0]); exit( 1 ); break; case 'Z': /* create storage for the usertag */ LALoptarg_len = strlen(LALoptarg) + 1; userTag = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR) ); memcpy( userTag, LALoptarg, LALoptarg_len ); this_proc_param = this_proc_param->next = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "-userTag" ); snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%s", LALoptarg ); break; case 'I': /* create storage for the ifo-tag */ LALoptarg_len = strlen(LALoptarg) + 1; ifoTag = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR) ); memcpy( ifoTag, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); snprintf(inputIFO, LIGOMETA_IFO_MAX, "%s", LALoptarg); snprintf(outputIFO, LIGOMETA_IFO_MAX, "%s", LALoptarg); break; case 'V': /* print version information and exit */ fprintf( stdout, "TrigScan Cluster \n" "Larne Pekowsky\n" "Based on trigbank and inspiral by Patrick Brady, Duncan Brown and Steve Fairhurst\n"); XLALOutputVersionString(stderr, 0); exit( 0 ); break; case '?': print_usage(argv[0]); exit( 1 ); break; case 'q': /* start time */ gpstime = atol( LALoptarg ); if ( gpstime < 441417609 ) { fprintf( stderr, "invalid argument to --%s:\n" "GPS start time is prior to " "Jan 01, 1994 00:00:00 UTC:\n" "(%ld specified)\n", long_options[option_index].name, gpstime ); exit( 1 ); } startTime = (INT4) gpstime; startTimeGPS.gpsSeconds = startTime; ADD_PROCESS_PARAM( "int", "%" LAL_INT4_FORMAT, startTime ); break; case 'r': /* end time */ gpstime = atol( LALoptarg ); if ( gpstime < 441417609 ) { fprintf( stderr, "invalid argument to --%s:\n" "GPS start time is prior to " "Jan 01, 1994 00:00:00 UTC:\n" "(%ld specified)\n", long_options[option_index].name, gpstime ); exit( 1 ); } endTime = (INT4) gpstime; endTimeGPS.gpsSeconds = endTime; ADD_PROCESS_PARAM( "int", "%" LAL_INT4_FORMAT, endTime ); break; case '*': /* store trigSanClustering method */ if ( ! strcmp( "T0T3Tc", LALoptarg ) ) { trigScanMethod = T0T3Tc; trigScanAppendStragglers = 0; } else if ( ! strcmp( "T0T3TcAS", LALoptarg ) ) { trigScanMethod = T0T3Tc; trigScanAppendStragglers = 1; } else if ( ! strcmp( "Psi0Psi3Tc", LALoptarg ) ) { trigScanMethod = Psi0Psi3Tc; trigScanAppendStragglers = 0; } else if ( ! strcmp( "Psi0Psi3TcAS", LALoptarg ) ) { trigScanMethod = Psi0Psi3Tc; trigScanAppendStragglers = 1; } else { fprintf( stderr, "invalid argument to --%s:\n" "unknown scan method specified: %s\n" "(Must be one of T0T3Tc, T0T3TcAS, Psi0Psi3Tc, Psi0Psi3TcAS)\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case '>': /* TrigScan Template Metric Scaling Factor */ trigScanMetricScalingFac = atof( LALoptarg ); if ( trigScanMetricScalingFac <= 0.0 ) { fprintf( stderr, "invalid argument to --%s:\n" "ts-volume-safety must be > 0.0 : " "(%f specified)\n", long_options[option_index].name, trigScanMetricScalingFac ); exit( 1 ); } ADD_PROCESS_PARAM( "float", "%s", LALoptarg ); break; default: fprintf( stderr, "Error: Unknown error while parsing options\n" ); print_usage(argv[0]); exit( 1 ); } } /* check the values of the arguments */ if ( startTime < 0 ) { fprintf( stderr, "Error: --gps-start-time must be specified\n" ); exit( 1 ); } if ( endTime < 0 ) { fprintf( stderr, "Error: --gps-end-time must be specified\n" ); exit( 1 ); } /* Check the trigScan input parameters */ if ( ! trigScanMethod ) { fprintf ( stderr, "You must specify --ts-method\n" ); exit(1); } if ( trigScanMetricScalingFac <= 0.0 ) { fprintf ( stderr, "You must specify --ts-metric-scaling\n" ); exit(1); } /* fill the comment, if a user has specified one, or leave it blank */ if ( ! *comment ) { snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " ); snprintf( searchsumm.searchSummaryTable->comment, LIGOMETA_COMMENT_MAX, " " ); } else { snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, "%s", comment ); snprintf( searchsumm.searchSummaryTable->comment, LIGOMETA_COMMENT_MAX, "%s", comment ); } /* delete the first, empty process_params entry */ this_proc_param = processParamsTable.processParamsTable; processParamsTable.processParamsTable = processParamsTable.processParamsTable->next; free( this_proc_param ); /* * * read in the input data from the rest of the arguments * */ if ( LALoptind < argc ) { for( i = LALoptind; i < argc; ++i ) { INT4 numFileTriggers = 0; numFileTriggers = XLALReadInspiralTriggerFile( &inspiralEventList, ¤tTrigger, &searchSummList, &inputFiles, argv[i] ); if (numFileTriggers < 0) { fprintf(stderr, "Error reading triggers from file %s", argv[i]); exit( 1 ); } numTriggers += numFileTriggers; } } else { fprintf( stderr, "Error: No trigger files specified.\n" ); exit( 1 ); } if ( vrbflg ) fprintf( stdout, "Read in a total of %d triggers.\n", numTriggers ); if ( ! inspiralEventList ) { /* no triggers read in so triggered bank will be empty */ fprintf( stdout, "No triggers read in\n"); exit( 0 ); } /* trigScanClustering */ /* Call the clustering routine */ if (XLALTrigScanClusterTriggers( &(inspiralEventList), trigScanMethod, trigScanMetricScalingFac, trigScanAppendStragglers ) == XLAL_FAILURE ) { fprintf( stderr, "New trig scan has failed!!\n" ); exit(1); } /* time sort the triggers */ if ( vrbflg ) fprintf( stdout, "Sorting triggers\n" ); LAL_CALL( LALSortSnglInspiral( &status, &inspiralEventList, LALCompareSnglInspiralByTime ), &status ); if( !inspiralEventList ) { if ( vrbflg ) fprintf( stdout, "No triggers remain after time and playground cuts.\n" ); /* set numTriggers after cuts were applied */ numTriggers = 0; } /* * * write the output xml file * */ /* search summary entries: */ searchsumm.searchSummaryTable->in_start_time = startTimeGPS; searchsumm.searchSummaryTable->in_end_time = endTimeGPS; searchsumm.searchSummaryTable->out_start_time = startTimeGPS; searchsumm.searchSummaryTable->out_end_time = endTimeGPS; searchsumm.searchSummaryTable->nevents = numTriggers; if ( vrbflg ) fprintf( stdout, "writing output file... " ); /* set the file name correctly */ if ( userTag && !outCompress ) { snprintf( fileName, FILENAME_MAX, "%s-TRIGSCAN_%s-%d-%d.xml", outputIFO, userTag, startTime, endTime - startTime ); } else if ( !userTag && !outCompress ) { snprintf( fileName, FILENAME_MAX, "%s-TRIGSCAN_%d-%d.xml", outputIFO, startTime, endTime - startTime ); } else if ( userTag && outCompress ) { snprintf( fileName, FILENAME_MAX, "%s-TRIGSCAN_%s-%d-%d.xml.gz", outputIFO, userTag, startTime, endTime - startTime ); } else { snprintf( fileName, FILENAME_MAX, "%s-TRIGSCAN_%d-%d.xml.gz", outputIFO, startTime, endTime - startTime ); } memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) ); LAL_CALL( LALOpenLIGOLwXMLFile( &status , &xmlStream, fileName ), &status ); /* write process table */ snprintf( proctable.processTable->ifos, LIGOMETA_IFOS_MAX, "%s", inputIFO ); XLALGPSTimeNow(&(proctable.processTable->end_time)); LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, proctable, process_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* write process_params table */ LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_params_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, processParamsTable, process_params_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* write search_summary table */ LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, search_summary_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, searchsumm, search_summary_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* write the search_summvars tabls */ LAL_CALL( LALBeginLIGOLwXMLTable( &status ,&xmlStream, search_summvars_table), &status ); searchSummvarsTable.searchSummvarsTable = inputFiles; LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, searchSummvarsTable, search_summvars_table), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream), &status ); /* write the sngl_inspiral table */ if ( inspiralEventList ) { LAL_CALL( LALBeginLIGOLwXMLTable( &status ,&xmlStream, sngl_inspiral_table), &status ); inspiralTable.snglInspiralTable = inspiralEventList; LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, inspiralTable, sngl_inspiral_table), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream), &status ); } LAL_CALL( LALCloseLIGOLwXMLFile( &status, &xmlStream), &status ); if ( vrbflg ) fprintf( stdout, "done\n" ); /* * * clean up the memory that has been allocated * */ if ( vrbflg ) fprintf( stdout, "freeing memory... " ); free( proctable.processTable ); free( searchsumm.searchSummaryTable ); while ( processParamsTable.processParamsTable ) { this_proc_param = processParamsTable.processParamsTable; processParamsTable.processParamsTable = this_proc_param->next; free( this_proc_param ); } while ( inputFiles ) { thisInputFile = inputFiles; inputFiles = thisInputFile->next; LALFree( thisInputFile ); } while ( searchSummList ) { thisSearchSumm = searchSummList; searchSummList = searchSummList->next; LALFree( thisSearchSumm ); } while ( inspiralEventList ) { currentTrigger = inspiralEventList; inspiralEventList = inspiralEventList->next; LAL_CALL( LALFreeSnglInspiral( &status, ¤tTrigger ), &status ); } if ( userTag ) free( userTag ); if ( ifoTag ) free( ifoTag ); if ( vrbflg ) fprintf( stdout, "done\n" ); LALCheckMemoryLeaks(); exit( 0 ); }
/* * main program entry point */ INT4 main(INT4 argc, CHAR **argv) { /* status */ LALStatus status = blank_status; /* counters */ int c; UINT4 i; /* mode counters */ UINT4 l, m; /* metadata file/directory */ CHAR *nrMetaFile = NULL; CHAR *nrDataDir = NULL; CHAR file_path[FILENAME_MAX]; /* metadata format */ CHAR *metadata_format = NULL; /* metadata parsing variables */ LALParsedDataFile *meta_file = NULL; BOOLEAN wasRead = 0; CHAR field[HISTORY_COMMENT]; CHAR *wf_name[MAX_L+1][(2*MAX_L) + 1]; /* common metadata */ CHAR *md_mass_ratio = NULL; CHAR *md_spin1x = NULL; CHAR *md_spin1y = NULL; CHAR *md_spin1z = NULL; CHAR *md_spin2x = NULL; CHAR *md_spin2y = NULL; CHAR *md_spin2z = NULL; CHAR *md_freq_start_22 = NULL; /* NINJA1 metadata */ CHAR *md_simulation_details = NULL; CHAR *md_nr_group = NULL; CHAR *md_email = NULL; /* NINJA2 metadata */ CHAR *md_waveform_name = NULL; CHAR *md_initial_separation = NULL; CHAR *md_eccentricity = NULL; CHAR *md_number_of_cycles_22 = NULL; CHAR *md_code = NULL; CHAR *md_submitter_email = NULL; CHAR *md_authors_emails = NULL; /* common metadata strings */ CHAR str_mass_ratio[HISTORY_COMMENT]; CHAR str_spin1x[HISTORY_COMMENT]; CHAR str_spin1y[HISTORY_COMMENT]; CHAR str_spin1z[HISTORY_COMMENT]; CHAR str_spin2x[HISTORY_COMMENT]; CHAR str_spin2y[HISTORY_COMMENT]; CHAR str_spin2z[HISTORY_COMMENT]; CHAR str_freq_start_22[HISTORY_COMMENT]; CHAR str_creator[HISTORY_COMMENT]; /* NINJA1 metadata strings */ CHAR str_simulation_details[HISTORY_COMMENT]; CHAR str_nr_group[HISTORY_COMMENT]; CHAR str_email[HISTORY_COMMENT]; /* NINJA2 metadata strings */ CHAR str_waveform_name[HISTORY_COMMENT]; CHAR str_initial_separation[HISTORY_COMMENT]; CHAR str_eccentricity[HISTORY_COMMENT]; CHAR str_number_of_cycles_22[HISTORY_COMMENT]; CHAR str_code[HISTORY_COMMENT]; CHAR str_submitter_email[HISTORY_COMMENT]; CHAR str_authors_emails[HISTORY_COMMENT]; /* channel names */ CHAR *plus_channel[MAX_L+1][(2*MAX_L) + 1]; CHAR *cross_channel[MAX_L+1][(2*MAX_L) + 1]; /* waveforms */ UINT4 wf_length; REAL4TimeVectorSeries *waveforms[MAX_L][(2*MAX_L) + 1]; REAL4TimeSeries *hplus[MAX_L+1][(2*MAX_L) + 1]; REAL4TimeSeries *hcross[MAX_L+1][(2*MAX_L) + 1]; REAL8TimeVectorSeries *waveformsREAL8[MAX_L][(2*MAX_L) + 1]; REAL8TimeSeries *hplusREAL8[MAX_L+1][(2*MAX_L) + 1]; REAL8TimeSeries *hcrossREAL8[MAX_L+1][(2*MAX_L) + 1]; /* frame variables */ LALFrameH *frame; CHAR *frame_name = NULL; LIGOTimeGPS epoch; INT4 duration; INT4 detector_flags; INT4 generatingREAL8 = 0; /* LALgetopt arguments */ struct LALoption long_options[] = { /* options that set a flag */ {"verbose", no_argument, &vrbflg, 1}, /* options that don't set a flag */ {"format", required_argument, 0, 'f'}, {"nr-meta-file", required_argument, 0, 'm'}, {"nr-data-dir", required_argument, 0, 'd'}, {"output", required_argument, 0, 'o'}, {"double-precision", no_argument, 0, 'p'}, {"help", no_argument, 0, 'h'}, {"version", no_argument, 0, 'V'}, {0, 0, 0, 0} }; /* default debug level */ lal_errhandler = LAL_ERR_EXIT; /* parse the arguments */ while(1) { /* LALgetopt_long stores long option here */ int option_index = 0; size_t LALoptarg_len; c = LALgetopt_long_only(argc, argv, "f:m:d:o:phV", long_options, &option_index); /* detect the end of the options */ if (c == -1) break; switch(c) { case 0: /* if this option sets a flag, do nothing else for now */ if (long_options[option_index].flag != 0) break; else { fprintf(stderr, "Error parsing option %s with argument %s\n", long_options[option_index].name, LALoptarg); exit(1); } break; case 'h': /* help message */ print_usage(stdout, argv[0]); exit(0); break; case 'V': /* print version information and exit */ fprintf(stdout, "Numerical Relativity Frame Generation\n"); XLALOutputVersionString(stderr, 0); exit(0); break; case 'f': /* create storage for the metadata format */ LALoptarg_len = strlen(LALoptarg) + 1; metadata_format = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(metadata_format, LALoptarg, LALoptarg_len); break; case 'm': /* create storage for the meta file name */ LALoptarg_len = strlen(LALoptarg) + 1; nrMetaFile = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(nrMetaFile, LALoptarg, LALoptarg_len); break; case 'd': /* create storage for the meta data directory name */ LALoptarg_len = strlen(LALoptarg) + 1; nrDataDir = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(nrDataDir, LALoptarg, LALoptarg_len); break; case 'o': /* create storage for the output frame file name */ LALoptarg_len = strlen(LALoptarg) + 1; frame_name = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR)); memcpy(frame_name, LALoptarg, LALoptarg_len); break; case 'p': /* We're generating a double-precision frame */ generatingREAL8 = 1; break; case '?': print_usage(stderr, argv[0]); exit(1); break; default: fprintf(stderr, "Unknown error while parsing arguments\n"); print_usage(stderr, argv[0]); exit(1); break; } } /* check for extraneous command line arguments */ if (LALoptind < argc) { fprintf(stderr, "Extraneous command line arguments:\n"); while(LALoptind < argc) fprintf(stderr, "%s\n", argv[LALoptind++]); exit(1); } /* * check validity of arguments */ /* metadata format specified */ if (metadata_format == NULL) { fprintf(stderr, "warning: --format not specified, assuming NINJA1\n"); metadata_format = (CHAR *)calloc(7, sizeof(CHAR)); memcpy(metadata_format, "NINJA1", 7); } /* check for supported metadata format */ if (strcmp(metadata_format, "NINJA1") == 0); else if (strcmp(metadata_format, "NINJA2") == 0); else { fprintf(stderr, "Supported metadata formats are NINJA1 and NINJA2 (%s specified)\n", metadata_format); exit(1); } /* meta file specified */ if (nrMetaFile == NULL) { fprintf(stderr, "--nr-meta-file must be specified\n"); exit(1); } /* data directory specified */ if (nrDataDir == NULL) { fprintf(stderr, "--nr-data-dir must be specified\n"); exit(1); } /* output frame filename specified */ if (frame_name == NULL) { fprintf(stderr, "--output must be specified\n"); exit(1); } /* * main code */ /* frame metadata */ /* TODO: set these to something sensible */ duration = 0; epoch.gpsSeconds = 0; epoch.gpsNanoSeconds = 0; detector_flags = 0; if (vrbflg) fprintf(stdout, "reading metadata: %s\n", nrMetaFile); /* open metadata file */ XLAL_CHECK ( XLALParseDataFile(&meta_file, nrMetaFile) == XLAL_SUCCESS, XLAL_EFUNC ); /* * get metadata */ /* common metadata */ XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_mass_ratio, meta_file, NULL, "mass-ratio", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin1x, meta_file, NULL, "spin1x", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin1y, meta_file, NULL, "spin1y", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin1z, meta_file, NULL, "spin1z", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin2x, meta_file, NULL, "spin2x", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin2y, meta_file, NULL, "spin2y", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin2z, meta_file, NULL, "spin2z", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); /* format specific metadata */ if (strcmp(metadata_format, "NINJA1") == 0) { /* NINJA1 */ XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_simulation_details, meta_file, NULL, "simulation-details", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_nr_group, meta_file, NULL, "nr-group", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_email, meta_file, NULL, "email", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_freq_start_22, meta_file, NULL, "freqStart22", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); } else if (strcmp(metadata_format, "NINJA2") == 0) { /* NINJA2 */ XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_waveform_name, meta_file, NULL, "waveform-name", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_initial_separation, meta_file, NULL, "initial-separation", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_eccentricity, meta_file, NULL, "eccentricity", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_number_of_cycles_22, meta_file, NULL, "number-of-cycles-22", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_code, meta_file, NULL, "code", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_submitter_email, meta_file, NULL, "submitter-email", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_authors_emails, meta_file, NULL, "authors-emails", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_freq_start_22, meta_file, NULL, "freq-start-22", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); } else { /* unknown metadata format - should not be executed */ fprintf(stderr, "error: unsupported metadata format: %s\n", metadata_format); exit(1); } /* * set metadata strings */ /* common waveform */ snprintf(str_mass_ratio, HISTORY_COMMENT, "mass-ratio:%s", md_mass_ratio); snprintf(str_spin1x, HISTORY_COMMENT, "spin1x:%s", md_spin1x); snprintf(str_spin1y, HISTORY_COMMENT, "spin1y:%s", md_spin1y); snprintf(str_spin1z, HISTORY_COMMENT, "spin1z:%s", md_spin1z); snprintf(str_spin2x, HISTORY_COMMENT, "spin2x:%s", md_spin2x); snprintf(str_spin2y, HISTORY_COMMENT, "spin2y:%s", md_spin2y); snprintf(str_spin2z, HISTORY_COMMENT, "spin2z:%s", md_spin2z); snprintf(str_creator, HISTORY_COMMENT, "creator:%s(git:%s)", PROGRAM_NAME, lalAppsVCSId); /* format specific metadata */ if (strcmp(metadata_format, "NINJA1") == 0) { /* NINJA1 */ snprintf(str_freq_start_22, HISTORY_COMMENT, "freqStart22:%s", md_freq_start_22); snprintf(str_simulation_details, HISTORY_COMMENT, "simulation-details:%s", md_simulation_details); snprintf(str_nr_group, HISTORY_COMMENT, "nr-group:%s", md_nr_group); snprintf(str_email, HISTORY_COMMENT, "email:%s", md_email); } else if (strcmp(metadata_format, "NINJA2") == 0) { /* NINJA2 */ snprintf(str_waveform_name, HISTORY_COMMENT, "waveform-name:%s", md_waveform_name); snprintf(str_initial_separation, HISTORY_COMMENT, "inital-separation:%s", md_initial_separation); snprintf(str_eccentricity, HISTORY_COMMENT, "eccentricity:%s", md_eccentricity); snprintf(str_freq_start_22, HISTORY_COMMENT, "freq_start_22:%s", md_freq_start_22); snprintf(str_number_of_cycles_22, HISTORY_COMMENT, "number-of-cycles-22:%s", md_number_of_cycles_22); snprintf(str_code, HISTORY_COMMENT, "code:%s", md_code); snprintf(str_submitter_email, HISTORY_COMMENT, "submitter-email:%s", md_submitter_email); snprintf(str_authors_emails, HISTORY_COMMENT, "authors-emails:%s", md_authors_emails); } else { /* unknown metadata format - should not be executed */ fprintf(stderr, "error: unsupported metadata format: %s\n", metadata_format); exit(1); } /* define frame */ frame = XLALFrameNew(&epoch, duration, "NR", 0, 1, detector_flags); /* * add metadata as FrHistory structures */ /* common metadata */ XLALFrameAddFrHistory(frame, "creator", str_creator); XLALFrameAddFrHistory(frame, "mass-ratio", str_mass_ratio); XLALFrameAddFrHistory(frame, "spin1x", str_spin1x); XLALFrameAddFrHistory(frame, "spin1y", str_spin1y); XLALFrameAddFrHistory(frame, "spin1z", str_spin1z); XLALFrameAddFrHistory(frame, "spin2x", str_spin2x); XLALFrameAddFrHistory(frame, "spin2y", str_spin2y); XLALFrameAddFrHistory(frame, "spin2z", str_spin2z); /* format specific metadata */ if (strcmp(metadata_format, "NINJA1") == 0) { /* NINJA1 */ XLALFrameAddFrHistory(frame, "simulation-details", str_simulation_details); XLALFrameAddFrHistory(frame, "nr-group", str_nr_group); XLALFrameAddFrHistory(frame, "email", str_email); XLALFrameAddFrHistory(frame, "freqStart22", str_freq_start_22); } else if (strcmp(metadata_format, "NINJA2") == 0) { /* NINJA2 */ XLALFrameAddFrHistory(frame, "waveform-name", str_waveform_name); XLALFrameAddFrHistory(frame, "initial-separation", str_initial_separation); XLALFrameAddFrHistory(frame, "eccentricity", str_eccentricity); XLALFrameAddFrHistory(frame, "freq_start_22", str_freq_start_22); XLALFrameAddFrHistory(frame, "number-of-cycles-22", str_number_of_cycles_22); XLALFrameAddFrHistory(frame, "code", str_code); XLALFrameAddFrHistory(frame, "submitter-email", str_code); XLALFrameAddFrHistory(frame, "authors-emails", str_authors_emails); } else { /* unknown metadata format - should not be executed */ fprintf(stderr, "error: unsupported metadata format: %s\n", metadata_format); exit(1); } /* loop over l & m values */ for (l = MIN_L; l <= MAX_L; l++) { for (m = (MAX_L - l); m <= MAX_L + l; m++) { /* ensure pointers are NULL */ wf_name[l][m] = NULL; plus_channel[l][m] = NULL; cross_channel[l][m] = NULL; /* generate channel names */ plus_channel[l][m] = XLALGetNinjaChannelName("plus", l, m - MAX_L); cross_channel[l][m] = XLALGetNinjaChannelName("cross", l, m - MAX_L); if (generatingREAL8) { hplusREAL8[l][m] = NULL; hcrossREAL8[l][m] = NULL; waveformsREAL8[l][m] = NULL; /* initilise waveform time series */ hplusREAL8[l][m] = XLALCreateREAL8TimeSeries(plus_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0); hcrossREAL8[l][m] = XLALCreateREAL8TimeSeries(cross_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0); } else { hplus[l][m] = NULL; hcross[l][m] = NULL; waveforms[l][m] = NULL; /* initilise waveform time series */ hplus[l][m] = XLALCreateREAL4TimeSeries(plus_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0); hcross[l][m] = XLALCreateREAL4TimeSeries(cross_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0); } /* read ht-data section of metadata file */ snprintf(field, HISTORY_COMMENT, "%d,%d", l, m - MAX_L); XLAL_CHECK ( XLALReadConfigSTRINGVariable( &wf_name[l][m], meta_file, NULL, field, &wasRead) == XLAL_SUCCESS, XLAL_EFUNC ); /* read waveform */ if (wf_name[l][m] != NULL) { /* get full path to waveform data file */ snprintf(file_path, FILENAME_MAX, "%s/%s", nrDataDir, wf_name[l][m]); if (vrbflg) fprintf(stdout, "reading waveform: %s\n", file_path); /* read waveforms */ if (generatingREAL8) { LAL_CALL(LALReadNRWave_raw_real8(&status, &waveformsREAL8[l][m], file_path), &status); } else { LAL_CALL(LALReadNRWave_raw(&status, &waveforms[l][m], file_path), &status); } } /* generate waveform time series from vector series */ /* TODO: should use pointer arithmetic here and update the data * pointer in the REAL4TimeSeries to point to the appropriate * location within the REAL4TimeVector Series */ if (generatingREAL8) { if (waveformsREAL8[l][m]) { /* get length of waveform */ wf_length = waveformsREAL8[l][m]->data->vectorLength; /* allocate memory for waveform */ XLALResizeREAL8TimeSeries(hplusREAL8[l][m], 0, wf_length); XLALResizeREAL8TimeSeries(hcrossREAL8[l][m], 0, wf_length); /* set time spacing */ hplusREAL8[l][m]->deltaT = waveformsREAL8[l][m]->deltaT; hcrossREAL8[l][m]->deltaT = waveformsREAL8[l][m]->deltaT; /* copy waveforms into appropriate series */ for (i = 0; i < wf_length; i ++) { hplusREAL8[l][m]->data->data[i] = waveformsREAL8[l][m]->data->data[i]; hcrossREAL8[l][m]->data->data[i] = waveformsREAL8[l][m]->data->data[wf_length + i]; } /* Done with waveformsREAL8, clean up here to limit memory usage */ LALFree(waveformsREAL8[l][m]->data->data); LALFree(waveformsREAL8[l][m]->data); LALFree(waveformsREAL8[l][m]); } } else /* REAL4 */ { if (waveforms[l][m]) { /* get length of waveform */ wf_length = waveforms[l][m]->data->vectorLength; /* allocate memory for waveform */ XLALResizeREAL4TimeSeries(hplus[l][m], 0, wf_length); XLALResizeREAL4TimeSeries(hcross[l][m], 0, wf_length); /* set time spacing */ hplus[l][m]->deltaT = waveforms[l][m]->deltaT; hcross[l][m]->deltaT = waveforms[l][m]->deltaT; /* copy waveforms into appropriate series */ for (i = 0; i < wf_length; i ++) { hplus[l][m]->data->data[i] = waveforms[l][m]->data->data[i]; hcross[l][m]->data->data[i] = waveforms[l][m]->data->data[wf_length + i]; } } } /* add channels to frame */ if (generatingREAL8) { if ((hplusREAL8[l][m]->data->length) && (hcrossREAL8[l][m]->data->length)) { XLALFrameAddREAL8TimeSeriesSimData(frame, hplusREAL8[l][m]); XLALFrameAddREAL8TimeSeriesSimData(frame, hcrossREAL8[l][m]); } } else { if ((hplus[l][m]->data->length) && (hcross[l][m]->data->length)) { XLALFrameAddREAL4TimeSeriesSimData(frame, hplus[l][m]); XLALFrameAddREAL4TimeSeriesSimData(frame, hcross[l][m]); } } } } if (vrbflg) fprintf(stdout, "writing frame: %s\n", frame_name); /* write frame */ if (XLALFrameWrite(frame, frame_name) != 0 ) { fprintf(stderr, "Error: Cannot save frame file '%s'\n", frame_name); exit(1); } /* * clear memory */ /* strings */ if(nrMetaFile) free(nrMetaFile); if(nrDataDir) free(nrDataDir); if(frame_name) free(frame_name); if(metadata_format) free(metadata_format); /* common metadata */ if(md_mass_ratio) LALFree(md_mass_ratio); if(md_spin1x) LALFree(md_spin1x); if(md_spin1y) LALFree(md_spin1y); if(md_spin1z) LALFree(md_spin1z); if(md_spin2x) LALFree(md_spin2x); if(md_spin2y) LALFree(md_spin2y); if(md_spin2z) LALFree(md_spin2z); if(md_freq_start_22) LALFree(md_freq_start_22); /* NINJA1 metadata */ if(md_simulation_details) LALFree(md_simulation_details); if(md_nr_group) LALFree(md_nr_group); if(md_email) LALFree(md_email); /* NINJA2 metadata */ if(md_waveform_name) LALFree(md_waveform_name); if(md_initial_separation) LALFree(md_initial_separation); if(md_eccentricity) LALFree(md_eccentricity); if(md_number_of_cycles_22) LALFree(md_number_of_cycles_22); if(md_code) LALFree(md_code); if(md_submitter_email) LALFree(md_submitter_email); if(md_authors_emails) LALFree(md_authors_emails); /* config file */ if(meta_file->lines->list->data) LALFree(meta_file->lines->list->data); if(meta_file->lines->list) LALFree(meta_file->lines->list); if(meta_file->lines->tokens) LALFree(meta_file->lines->tokens); if(meta_file->lines) LALFree(meta_file->lines); if(meta_file->wasRead) LALFree(meta_file->wasRead); if(meta_file) LALFree(meta_file); /* waveforms */ if (generatingREAL8) { for (l = MIN_L; l <= MAX_L; l++) { for (m = (MAX_L - l); m <= MAX_L + l; m++) { /* channel names */ if (plus_channel[l][m]) LALFree(plus_channel[l][m]); if (cross_channel[l][m]) LALFree(cross_channel[l][m]); if (wf_name[l][m]) LALFree(wf_name[l][m]); /* hplus */ if (hplusREAL8[l][m]) XLALDestroyREAL8TimeSeries(hplusREAL8[l][m]); /* hcross */ if (hcrossREAL8[l][m]) XLALDestroyREAL8TimeSeries(hcrossREAL8[l][m]); } } } else { for (l = MIN_L; l <= MAX_L; l++) { for (m = (MAX_L - l); m <= MAX_L + l; m++) { /* channel names */ if (plus_channel[l][m]) LALFree(plus_channel[l][m]); if (cross_channel[l][m]) LALFree(cross_channel[l][m]); if (wf_name[l][m]) LALFree(wf_name[l][m]); /* raw waveforms */ if (waveforms[l][m]) { LALFree(waveforms[l][m]->data->data); LALFree(waveforms[l][m]->data); LALFree(waveforms[l][m]); } /* hplus */ if (hplus[l][m]) XLALDestroyREAL4TimeSeries(hplus[l][m]); /* hcross */ if (hcross[l][m]) XLALDestroyREAL4TimeSeries(hcross[l][m]); } } } /* clear frame */ XLALFrameFree(frame); /* check for memory leaks */ LALCheckMemoryLeaks(); exit(0); }
int main( int argc, char *argv[] ) { /* lal initialization variables */ LALStatus status = blank_status; /* program option variables */ CHAR *userTag = NULL; CHAR comment[LIGOMETA_COMMENT_MAX]; char *ifos = NULL; char *ifoName = NULL; char *outputFileName = NULL; char *summFileName = NULL; char *injectFileName = NULL; char *vetoFileName = NULL; char *missedFileName = NULL; REAL4 snrStar = -1; REAL4 rsqVetoThresh = -1; REAL4 rsqMaxSnr = -1; REAL4 rsqAboveSnrCoeff = -1; REAL4 rsqAboveSnrPow = -1; LALSegList vetoSegs; MultiInspiralClusterChoice clusterchoice = no_statistic; INT8 cluster_dt = -1; INT8 injectWindowNS = -1; int j; FILE *fp = NULL; int numInFiles = 0; UINT8 triggerInputTimeNS = 0; MetadataTable proctable; MetadataTable procparams; ProcessParamsTable *this_proc_param; SimInspiralTable *simEventHead = NULL; SimInspiralTable *thisSimEvent = NULL; SimInspiralTable *missedSimHead = NULL; SimInspiralTable *tmpSimEvent = NULL; SearchSummvarsTable *inputFiles = NULL; SearchSummaryTable *searchSummList = NULL; SearchSummaryTable *thisSearchSumm = NULL; SummValueTable *summValueList = NULL; int extractSlide = 0; int numSlides = 0; int numEvents = 0; int numEventsKept = 0; int numEventsInIFO = 0; int numEventsAboveSNRThresh = 0; int numEventsBelowRsqThresh = 0; int numEventsSurvivingVeto = 0; int numClusteredEvents = 0; int numEventsInIfos = 0; int numSimEvents = 0; int numSimInData = 0; int numSimFound = 0; int numMultiFound = 0; MultiInspiralTable *missedHead = NULL; MultiInspiralTable *thisEvent = NULL; MultiInspiralTable *thisInspiralTrigger = NULL; MultiInspiralTable *inspiralEventList = NULL; MultiInspiralTable *slideEvent = NULL; LIGOLwXMLStream xmlStream; MetadataTable outputTable; MetadataTable UNUSED savedEvents; MetadataTable searchSummvarsTable; /* * * initialization * */ /* set up inital debugging values */ lal_errhandler = LAL_ERR_EXIT; /* create the process and process params tables */ proctable.processTable = (ProcessTable *) calloc( 1, sizeof(ProcessTable) ); XLALGPSTimeNow(&(proctable.processTable->start_time)); XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME, lalAppsVCSIdentId, lalAppsVCSIdentStatus, lalAppsVCSIdentDate, 0); this_proc_param = procparams.processParamsTable = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); memset( comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR) ); savedEvents.multiInspiralTable = NULL; /* * * parse command line arguments * */ while (1) { /* LALgetopt arguments */ static struct LALoption long_options[] = { {"verbose", no_argument, &vrbflg, 1 }, {"sort-triggers", no_argument, &sortTriggers, 1 }, {"help", no_argument, 0, 'h'}, {"user-tag", required_argument, 0, 'Z'}, {"userTag", required_argument, 0, 'Z'}, {"comment", required_argument, 0, 'c'}, {"version", no_argument, 0, 'V'}, {"data-type", required_argument, 0, 'k'}, {"output", required_argument, 0, 'o'}, {"summary-file", required_argument, 0, 'S'}, {"extract-slide", required_argument, 0, 'e'}, {"num-slides", required_argument, 0, 'N'}, {"snr-threshold", required_argument, 0, 's'}, {"rsq-threshold", required_argument, 0, 'r'}, {"rsq-max-snr", required_argument, 0, 'R'}, {"rsq-coeff", required_argument, 0, 'p'}, {"rsq-power", required_argument, 0, 'P'}, {"cluster-algorithm", required_argument, 0, 'C'}, {"cluster-time", required_argument, 0, 't'}, {"ifo-cut", required_argument, 0, 'd'}, {"coinc-cut", required_argument, 0, 'D'}, {"veto-file", required_argument, 0, 'v'}, {"injection-file", required_argument, 0, 'I'}, {"injection-window", required_argument, 0, 'T'}, {"missed-injections", required_argument, 0, 'm'}, {0, 0, 0, 0} }; int c; /* LALgetopt_long stores the option index here. */ int option_index = 0; size_t LALoptarg_len; c = LALgetopt_long_only ( argc, argv, "c:d:D:hj:k:m:o:r:s:t:v:C:DH:I:R:ST:VZ:", long_options, &option_index ); /* detect the end of the options */ if ( c == - 1 ) break; switch ( c ) { case 0: /* if this option set a flag, do nothing else now */ if ( long_options[option_index].flag != 0 ) { break; } else { fprintf( stderr, "error parsing option %s with argument %s\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } break; case 'h': print_usage(argv[0]); exit( 0 ); break; case 'Z': /* create storage for the usertag */ LALoptarg_len = strlen( LALoptarg ) + 1; userTag = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR) ); memcpy( userTag, LALoptarg, LALoptarg_len ); this_proc_param = this_proc_param->next = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "-userTag" ); snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%s", LALoptarg ); break; case 'c': if ( strlen( LALoptarg ) > LIGOMETA_COMMENT_MAX - 1 ) { fprintf( stderr, "invalid argument to --%s:\n" "comment must be less than %d characters\n", long_options[option_index].name, LIGOMETA_COMMENT_MAX ); exit( 1 ); } else { snprintf( comment, LIGOMETA_COMMENT_MAX, "%s", LALoptarg); } break; case 'V': fprintf( stdout, "Coherent Inspiral Reader and Injection Analysis\n" "Sukanta Bose\n"); XLALOutputVersionString(stderr, 0); exit( 0 ); break; case 'o': /* create storage for the output file name */ LALoptarg_len = strlen( LALoptarg ) + 1; outputFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( outputFileName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'e': /* store the number of slides */ extractSlide = atoi( LALoptarg ); if ( extractSlide == 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "extractSlide must be non-zero: " "(%d specified)\n", long_options[option_index].name, extractSlide ); exit( 1 ); } ADD_PROCESS_PARAM( "int", "%d", extractSlide ); break; case 'N': /* store the number of slides */ numSlides = atoi( LALoptarg ); if ( numSlides < 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "numSlides >= 0: " "(%d specified)\n", long_options[option_index].name, numSlides ); exit( 1 ); } ADD_PROCESS_PARAM( "int", "%d", numSlides ); break; case 'S': /* create storage for the summ file name */ LALoptarg_len = strlen( LALoptarg ) + 1; summFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( summFileName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'k': /* type of data to analyze */ if ( ! strcmp( "playground_only", LALoptarg ) ) { dataType = playground_only; } else if ( ! strcmp( "exclude_play", LALoptarg ) ) { dataType = exclude_play; } else if ( ! strcmp( "all_data", LALoptarg ) ) { dataType = all_data; } else { fprintf( stderr, "invalid argument to --%s:\n" "unknown data type, %s, specified: " "(must be playground_only, exclude_play or all_data)\n", long_options[option_index].name, LALoptarg ); exit( 1 ); } ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 's': snrStar = (REAL4) atof( LALoptarg ); if ( snrStar < 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "threshold must be >= 0: " "(%f specified)\n", long_options[option_index].name, snrStar ); exit( 1 ); } ADD_PROCESS_PARAM( "float", "%e", snrStar ); break; case 'r': rsqVetoThresh = (REAL4) atof( LALoptarg ); if ( rsqVetoThresh < 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "threshold must be >= 0: " "(%f specified)\n", long_options[option_index].name, rsqVetoThresh ); exit( 1 ); } ADD_PROCESS_PARAM( "float", "%e", rsqVetoThresh ); break; case 'R': rsqMaxSnr = (REAL4) atof( LALoptarg ); if ( rsqMaxSnr < 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "threshold must be >= 0: " "(%f specified)\n", long_options[option_index].name, rsqMaxSnr ); exit( 1 ); } ADD_PROCESS_PARAM( "float", "%e", rsqMaxSnr ); break; case 'p': rsqAboveSnrCoeff = (REAL4) atof( LALoptarg ); if ( rsqAboveSnrCoeff < 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "coefficient must be >= 0: " "(%f specified)\n", long_options[option_index].name, rsqAboveSnrCoeff ); exit( 1 ); } ADD_PROCESS_PARAM( "float", "%e", rsqAboveSnrCoeff ); break; case 'P': rsqAboveSnrPow = (REAL4) atof( LALoptarg ); if ( rsqAboveSnrPow < 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "power must be >= 0: " "(%f specified)\n", long_options[option_index].name, rsqAboveSnrPow ); exit( 1 ); } ADD_PROCESS_PARAM( "float", "%e", rsqAboveSnrPow ); break; case 'C': /* choose the clustering algorithm */ { if ( ! strcmp( "nullstat", LALoptarg) ) { clusterchoice = nullstat; } else if ( ! strcmp( "cohsnr", LALoptarg) ) { clusterchoice = cohsnr; } else if ( ! strcmp( "effCohSnr", LALoptarg) ) { clusterchoice = effCohSnr; } else if ( ! strcmp( "snrByNullstat", LALoptarg) ) { clusterchoice = snrByNullstat; } else if ( ! strcmp( "autoCorrCohSqByNullstat", LALoptarg) ) { clusterchoice = autoCorrCohSqByNullstat; } else if ( ! strcmp( "crossCorrCohSqByNullstat", LALoptarg) ) { clusterchoice = autoCorrCohSqByNullstat; } else if ( ! strcmp( "autoCorrNullSqByNullstat", LALoptarg) ) { clusterchoice = autoCorrCohSqByNullstat; } else if ( ! strcmp( "crossCorrNullSqByNullstat", LALoptarg) ) { clusterchoice = crossCorrCohSqByNullstat; } else { fprintf( stderr, "invalid argument to --%s:\n" "unknown clustering specified:\n " "%s (must be one of: cohsnr, effCohSnr, nullstat, snrByNullstat, autoCorrCohSqByNullstat, \n" "crossCorrCohSqByNullstat, autoCorrNullSqByNullstat, or crossCorrNullSqByNullstat)\n", long_options[option_index].name, LALoptarg); exit( 1 ); } ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); } break; case 't': /* cluster time is specified on command line in ms */ cluster_dt = (INT8) atoi( LALoptarg ); if ( cluster_dt <= 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "cluster window must be > 0: " "(%" LAL_INT8_FORMAT " specified)\n", long_options[option_index].name, cluster_dt ); exit( 1 ); } ADD_PROCESS_PARAM( "int", "%" LAL_INT8_FORMAT, cluster_dt ); /* convert cluster time from ms to ns */ cluster_dt *= 1000000LL; break; case 'v': /* create storage for the injection file name */ LALoptarg_len = strlen( LALoptarg ) + 1; vetoFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( vetoFileName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'I': /* create storage for the injection file name */ LALoptarg_len = strlen( LALoptarg ) + 1; injectFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( injectFileName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'd': LALoptarg_len = strlen( LALoptarg ) + 1; ifoName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( ifoName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'D': /* keep only coincs found in ifos */ LALoptarg_len = strlen( LALoptarg ) + 1; ifos = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( ifos, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case 'T': /* injection coincidence time is specified on command line in ms */ injectWindowNS = (INT8) atoi( LALoptarg ); if ( injectWindowNS < 0 ) { fprintf( stdout, "invalid argument to --%s:\n" "injection coincidence window must be >= 0: " "(%" LAL_INT8_FORMAT " specified)\n", long_options[option_index].name, injectWindowNS ); exit( 1 ); } ADD_PROCESS_PARAM( "int", "%" LAL_INT8_FORMAT, injectWindowNS ); /* convert inject time from ms to ns */ injectWindowNS *= 1000000LL; break; case 'm': /* create storage for the missed injection file name */ LALoptarg_len = strlen( LALoptarg ) + 1; missedFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR)); memcpy( missedFileName, LALoptarg, LALoptarg_len ); ADD_PROCESS_PARAM( "string", "%s", LALoptarg ); break; case '?': exit( 1 ); break; default: fprintf( stderr, "unknown error while parsing options\n" ); exit( 1 ); } } /* * * can use LALCalloc() / LALMalloc() from here * */ /* don't buffer stdout if we are in verbose mode */ if ( vrbflg ) setvbuf( stdout, NULL, _IONBF, 0 ); /* fill the comment, if a user has specified it, or leave it blank */ if ( ! *comment ) { snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " ); } else { snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, "%s", comment ); } /* check that the output file name has been specified */ if ( ! outputFileName ) { fprintf( stderr, "--output must be specified\n" ); exit( 1 ); } /* check that Data Type has been specified */ if ( dataType == unspecified_data_type ) { fprintf( stderr, "Error: --data-type must be specified\n"); exit(1); } /* check that if clustering is being done that we have all the options */ if ( clusterchoice && cluster_dt < 0 ) { fprintf( stderr, "--cluster-time must be specified if --cluster-algorithm " "is given\n" ); exit( 1 ); } else if ( ! clusterchoice && cluster_dt >= 0 ) { fprintf( stderr, "--cluster-algorithm must be specified if --cluster-time " "is given\n" ); exit( 1 ); } /* check that if the rsq veto is being preformed, we have the required options */ if ( ( (rsqVetoThresh > 0) || (rsqMaxSnr > 0) ) && ( (rsqVetoThresh < 0) || (rsqMaxSnr < 0) ) ) { fprintf( stderr, "--rsq-threshold and --rsq-max-snr and must be " "specified together" ); exit( 1 ); } else if ( (rsqAboveSnrCoeff > 0) && ( (rsqMaxSnr < 0) || (rsqVetoThresh < 0) || (rsqAboveSnrPow < 0) ) ) { fprintf( stderr, "--rsq-max-snr --rsq-threshold and --rsq-power " "must be specified if --rsq-coeff is given\n" ); exit( 1 ); } else if ( (rsqAboveSnrPow > 0) && ( (rsqMaxSnr < 0) || (rsqVetoThresh < 0) || (rsqAboveSnrCoeff < 0) ) ) { fprintf( stderr, "--rsq-max-snr --rsq-threshold and --rsq-coeff " "must be specified if --rsq-power is given\n" ); exit( 1 ); } /* check that we have all the options to do injections */ if ( injectFileName && injectWindowNS < 0 ) { fprintf( stderr, "--injection-coincidence must be specified if " "--injection-file is given\n" ); exit( 1 ); } else if ( ! injectFileName && injectWindowNS >= 0 ) { fprintf( stderr, "--injection-file must be specified if " "--injection-coincidence is given\n" ); exit( 1 ); } if ( numSlides && extractSlide ) { fprintf( stderr, "--num-slides and --extract-slide both specified\n" "this doesn't make sense\n" ); exit( 1 ); } /* save the sort triggers flag */ if ( sortTriggers ) { this_proc_param = this_proc_param->next = (ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) ); snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME ); snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "--sort-triggers" ); snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" ); snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, " " ); } /* read in the veto file (if specified */ if ( vetoFileName ) { XLALSegListInit( &vetoSegs ); LAL_CALL( LALSegListRead( &status, &vetoSegs, vetoFileName, NULL ), &status ); XLALSegListCoalesce( &vetoSegs ); } /* * * read in the input triggers from the xml files * */ /* if we have run out of arguments on the command line, throw an error */ if ( ! (LALoptind < argc) ) { fprintf( stderr, "Error: No input trigger files specified.\n" ); exit( 1 ); } /* read in the triggers */ for( j = LALoptind; j < argc; ++j ) { INT4 numFileTriggers = 0; MultiInspiralTable *inspiralFileList = NULL; MultiInspiralTable *thisFileTrigger = NULL; numInFiles++; numFileTriggers = XLALReadMultiInspiralTriggerFile( &inspiralFileList, &thisFileTrigger, &searchSummList, &inputFiles, argv[j] ); numEvents += numFileTriggers; if (numFileTriggers < 0) { fprintf(stderr, "Error reading triggers from file %s\n", argv[j]); exit( 1 ); } else { if ( vrbflg ) { fprintf(stdout, "Read %d reading triggers from file %s\n", numFileTriggers, argv[j]); } } /* read the summ value table as well. */ XLALReadSummValueFile(&summValueList, argv[j]); /* * * keep only relevant triggers * */ if( ifos ) { numFileTriggers = XLALMultiInspiralIfosCut( &inspiralFileList, ifos ); if ( vrbflg ) fprintf( stdout, "Kept %d coincs from %s instruments\n", numFileTriggers, ifos ); numEventsInIfos += numFileTriggers; } /* Do playground_only or exclude_play cut */ if ( dataType != all_data ) { inspiralFileList = XLALPlayTestMultiInspiral( inspiralFileList, &dataType ); /* count the triggers */ numFileTriggers = XLALCountMultiInspiralTable( inspiralFileList ); if ( dataType == playground_only && vrbflg ) fprintf( stdout, "Have %d playground triggers\n", numFileTriggers ); else if ( dataType == exclude_play && vrbflg ) fprintf( stdout, "Have %d non-playground triggers\n", numFileTriggers ); } numEventsKept += numFileTriggers; /* Do snr cut */ if ( snrStar > 0 ) { inspiralFileList = XLALSNRCutMultiInspiral( inspiralFileList, snrStar ); /* count the triggers */ numFileTriggers = XLALCountMultiInspiral( inspiralFileList ); if ( vrbflg ) fprintf( stdout, "Have %d triggers after snr cut\n", numFileTriggers ); numEventsAboveSNRThresh += numFileTriggers; } /* NOTE: Add vetoing: if ( vetoFileName ) { inspiralFileList = XLALVetoMultiInspiral( inspiralFileList, &vetoSegs , ifoName); count the triggers numFileTriggers = XLALCountMultiInspiral( inspiralFileList ); if ( vrbflg ) fprintf( stdout, "Have %d triggers after applying veto\n", numFileTriggers ); numEventsSurvivingVeto += numFileTriggers; } */ /* If there are any remaining triggers ... */ if ( inspiralFileList ) { /* add inspirals to list */ if ( thisInspiralTrigger ) { thisInspiralTrigger->next = inspiralFileList; } else { inspiralEventList = thisInspiralTrigger = inspiralFileList; } for( ; thisInspiralTrigger->next; thisInspiralTrigger = thisInspiralTrigger->next); } } for ( thisSearchSumm = searchSummList; thisSearchSumm; thisSearchSumm = thisSearchSumm->next ) { UINT8 outPlayNS, outStartNS, outEndNS, triggerTimeNS; LIGOTimeGPS inPlay, outPlay; outStartNS = XLALGPSToINT8NS( &(thisSearchSumm->out_start_time) ); outEndNS = XLALGPSToINT8NS( &(thisSearchSumm->out_end_time) ); triggerTimeNS = outEndNS - outStartNS; /* check for events and playground */ if ( dataType != all_data ) { XLALPlaygroundInSearchSummary( thisSearchSumm, &inPlay, &outPlay ); outPlayNS = XLALGPSToINT8NS( &outPlay ); if ( dataType == playground_only ) { /* increment the total trigger time by the amount of playground */ triggerInputTimeNS += outPlayNS; } else if ( dataType == exclude_play ) { /* increment the total trigger time by the out time minus */ /* the time that is in the playground */ triggerInputTimeNS += triggerTimeNS - outPlayNS; } } else { /* increment the total trigger time by the out time minus */ triggerInputTimeNS += triggerTimeNS; } } /* * * sort the inspiral events by time * */ if ( injectFileName || sortTriggers ) { inspiralEventList = XLALSortMultiInspiral( inspiralEventList, *LALCompareMultiInspiralByTime ); } /* * * read in the injection XML file, if we are doing an injection analysis * */ if ( injectFileName ) { if ( vrbflg ) fprintf( stdout, "reading injections from %s... ", injectFileName ); numSimEvents = SimInspiralTableFromLIGOLw( &simEventHead, injectFileName, 0, 0 ); if ( vrbflg ) fprintf( stdout, "got %d injections\n", numSimEvents ); if ( numSimEvents < 0 ) { fprintf( stderr, "error: unable to read sim_inspiral table from %s\n", injectFileName ); exit( 1 ); } /* keep play/non-play/all injections */ if ( dataType == playground_only && vrbflg ) fprintf( stdout, "Keeping only playground injections\n" ); else if ( dataType == exclude_play && vrbflg ) fprintf( stdout, "Keeping only non-playground injections\n" ); else if ( dataType == all_data && vrbflg ) fprintf( stdout, "Keeping all injections\n" ); XLALPlayTestSimInspiral( &simEventHead, &dataType ); /* keep only injections in times analyzed */ numSimInData = XLALSimInspiralInSearchedData( &simEventHead, &searchSummList ); if ( vrbflg ) fprintf( stdout, "%d injections in analyzed data\n", numSimInData ); /* check for events that are coincident with injections */ numSimFound = XLALMultiSimInspiralTest( &simEventHead, &inspiralEventList, &missedSimHead, &missedHead, injectWindowNS ); if ( vrbflg ) fprintf( stdout, "%d injections found in the ifos\n", numSimFound ); if ( numSimFound ) { for ( thisEvent = inspiralEventList; thisEvent; thisEvent = thisEvent->next, numMultiFound++ ); if ( vrbflg ) fprintf( stdout, "%d triggers found at times of injection\n", numMultiFound ); } /* free the missed singles */ while ( missedHead ) { thisEvent = missedHead; missedHead = missedHead->next; XLALFreeMultiInspiral( &thisEvent ); } } /* * * extract specified slide * */ if ( extractSlide ) { slideEvent = XLALMultiInspiralSlideCut( &inspiralEventList, extractSlide ); /* free events from other slides */ while ( inspiralEventList ) { thisEvent = inspiralEventList; inspiralEventList = inspiralEventList->next; XLALFreeMultiInspiral( &thisEvent ); } /* move events to inspiralEventList */ inspiralEventList = slideEvent; slideEvent = NULL; } /* * * cluster the remaining events * */ if ( inspiralEventList && clusterchoice ) { if ( vrbflg ) fprintf( stdout, "clustering remaining triggers... " ); if ( !numSlides ) { numClusteredEvents = XLALClusterMultiInspiralTable( &inspiralEventList, cluster_dt, clusterchoice ); } else { int slide = 0; int numClusteredSlide = 0; MultiInspiralTable *tmp_slideEvent = NULL; MultiInspiralTable *slideClust = NULL; if ( vrbflg ) fprintf( stdout, "splitting events by slide\n" ); for( slide = -numSlides; slide < (numSlides + 1); slide++) { if ( vrbflg ) fprintf( stdout, "slide number %d; ", slide ); /* extract the slide */ tmp_slideEvent = XLALMultiInspiralSlideCut( &inspiralEventList, slide ); /* run clustering */ numClusteredSlide = XLALClusterMultiInspiralTable( &tmp_slideEvent, cluster_dt, clusterchoice); if ( vrbflg ) fprintf( stdout, "%d clustered events \n", numClusteredSlide ); numClusteredEvents += numClusteredSlide; /* add clustered triggers */ if( tmp_slideEvent ) { if( slideClust ) { thisEvent = thisEvent->next = tmp_slideEvent; } else { slideClust = thisEvent = tmp_slideEvent; } /* scroll to end of list */ for( ; thisEvent->next; thisEvent = thisEvent->next); } } /* free inspiralEventList -- although we expect it to be empty */ while ( inspiralEventList ) { thisEvent = inspiralEventList; inspiralEventList = inspiralEventList->next; XLALFreeMultiInspiral( &thisEvent ); } /* move events to coincHead */ inspiralEventList = slideClust; slideClust = NULL; } if ( vrbflg ) fprintf( stdout, "done\n" ); if ( vrbflg ) fprintf( stdout, "%d clustered events \n", numClusteredEvents ); } /* * * update search_summary->nevents with an authoritative count of triggers * */ searchSummList->nevents = 0; thisEvent = inspiralEventList; while (thisEvent) { searchSummList->nevents += 1; thisEvent = thisEvent->next; } /* * * write output data * */ /* write the main output file containing found injections */ if ( vrbflg ) fprintf( stdout, "writing output xml files... " ); memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) ); LAL_CALL( LALOpenLIGOLwXMLFile( &status, &xmlStream, outputFileName ), &status ); /* write out the process and process params tables */ if ( vrbflg ) fprintf( stdout, "process... " ); XLALGPSTimeNow(&(proctable.processTable->end_time)); LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, proctable, process_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); free( proctable.processTable ); /* erase the first empty process params entry */ { ProcessParamsTable *emptyPPtable = procparams.processParamsTable; procparams.processParamsTable = procparams.processParamsTable->next; free( emptyPPtable ); } /* write the process params table */ if ( vrbflg ) fprintf( stdout, "process_params... " ); LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_params_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, procparams, process_params_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* write search_summary table */ if ( vrbflg ) fprintf( stdout, "search_summary... " ); outputTable.searchSummaryTable = searchSummList; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, search_summary_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, search_summary_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); /* write the search_summvars table */ if ( vrbflg ) fprintf( stdout, "search_summvars... " ); LAL_CALL( LALBeginLIGOLwXMLTable( &status ,&xmlStream, search_summvars_table), &status ); searchSummvarsTable.searchSummvarsTable = inputFiles; LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, searchSummvarsTable, search_summvars_table), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream), &status ); /* write summ_value table */ if ( summValueList ) { if ( vrbflg ) fprintf( stdout, "search_summary... " ); outputTable.summValueTable = summValueList; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, summ_value_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, summ_value_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status ); } /* Write the found injections to the sim table */ if ( simEventHead ) { if ( vrbflg ) fprintf( stdout, "sim_inspiral... " ); outputTable.simInspiralTable = simEventHead; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, sim_inspiral_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, sim_inspiral_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status ); } /* Write the results to the inspiral table */ if ( inspiralEventList ) { if ( vrbflg ) fprintf( stdout, "multi_inspiral... " ); outputTable.multiInspiralTable = inspiralEventList; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, multi_inspiral_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, multi_inspiral_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status); } /* close the output file */ LAL_CALL( LALCloseLIGOLwXMLFile(&status, &xmlStream), &status); if ( vrbflg ) fprintf( stdout, "done\n" ); if ( missedFileName ) { /* open the missed injections file and write the missed injections to it */ if ( vrbflg ) fprintf( stdout, "writing missed injections... " ); memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) ); LAL_CALL( LALOpenLIGOLwXMLFile( &status, &xmlStream, missedFileName ), &status ); if ( missedSimHead ) { outputTable.simInspiralTable = missedSimHead; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, sim_inspiral_table ), &status ); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, sim_inspiral_table ), &status ); LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status ); } LAL_CALL( LALCloseLIGOLwXMLFile( &status, &xmlStream ), &status ); if ( vrbflg ) fprintf( stdout, "done\n" ); } if ( summFileName ) { LIGOTimeGPS triggerTime; /* write out a summary file */ fp = fopen( summFileName, "w" ); switch ( dataType ) { case playground_only: fprintf( fp, "using data from playground times only\n" ); break; case exclude_play: fprintf( fp, "excluding all triggers in playground times\n" ); break; case all_data: fprintf( fp, "using all input data\n" ); break; default: fprintf( stderr, "data set not defined\n" ); exit( 1 ); } fprintf( fp, "read triggers from %d files\n", numInFiles ); fprintf( fp, "number of triggers in input files: %d \n", numEvents ); fprintf( fp, "number of triggers in input data %d \n", numEventsKept ); if ( ifoName ) { fprintf( fp, "number of triggers from %s ifo %d \n", ifoName, numEventsInIFO ); } if ( snrStar > 0 ) { fprintf( fp, "number of triggers in input data with snr above %f: %d \n", snrStar, numEventsAboveSNRThresh ); } if ( rsqVetoThresh > 0 ) { fprintf( fp, "performed R-squared veto on triggers with snr < %f\n", rsqMaxSnr); fprintf( fp, "with rsqveto_duration below %f\n", rsqVetoThresh); if ( (rsqAboveSnrCoeff > 0) && (rsqAboveSnrPow > 0) ) { fprintf( fp, "and on triggers with snr > %f\n", rsqMaxSnr); fprintf( fp, "with rsqveto_duration above %f * snr ^ %f\n", rsqAboveSnrCoeff, rsqAboveSnrPow ); } fprintf( fp, "the number of triggers below the R-squared veto are: %d \n", numEventsBelowRsqThresh); } if ( vetoFileName ) { fprintf( fp, "number of triggers not vetoed by %s: %d \n", vetoFileName, numEventsSurvivingVeto ); } XLALINT8NSToGPS( &triggerTime, triggerInputTimeNS ); fprintf( fp, "amount of time analysed for triggers %d sec %d ns\n", triggerTime.gpsSeconds, triggerTime.gpsNanoSeconds ); if ( injectFileName ) { fprintf( fp, "read %d injections from file %s\n", numSimEvents, injectFileName ); fprintf( fp, "number of injections in input data: %d\n", numSimInData ); fprintf( fp, "number of injections found in input data: %d\n", numSimFound ); fprintf( fp, "number of triggers found within %lld msec of injection: %d\n", (injectWindowNS / 1000000LL), numMultiFound ); fprintf( fp, "efficiency: %f \n", (REAL4) numSimFound / (REAL4) numSimInData ); } if ( extractSlide ) { fprintf( fp, "kept only triggers from slide %d\n", extractSlide ); } if ( clusterchoice ) { if ( numSlides ) { fprintf( fp, "clustering triggers from %d slides separately\n", numSlides ); } fprintf( fp, "number of event clusters with %lld msec window: %d\n", cluster_dt/ 1000000LL, numClusteredEvents ); } fclose( fp ); } /* * * free memory and exit * */ /* free the inspiral events we saved */ while ( inspiralEventList ) { thisEvent = inspiralEventList; inspiralEventList = inspiralEventList->next; LAL_CALL ( LALFreeMultiInspiral ( &status, &thisEvent ), &status); } /* free the process params */ while( procparams.processParamsTable ) { this_proc_param = procparams.processParamsTable; procparams.processParamsTable = this_proc_param->next; free( this_proc_param ); } /* free the found injections */ while ( simEventHead ) { thisSimEvent = simEventHead; simEventHead = simEventHead->next; LALFree( thisSimEvent ); } /* free the temporary memory containing the missed injections */ while ( missedSimHead ) { tmpSimEvent = missedSimHead; missedSimHead = missedSimHead->next; LALFree( tmpSimEvent ); } /* free search summaries read in */ while ( searchSummList ) { thisSearchSumm = searchSummList; searchSummList = searchSummList->next; LALFree( thisSearchSumm ); } while ( summValueList ) { SummValueTable *thisSummValue; thisSummValue = summValueList; summValueList = summValueList->next; LALFree( thisSummValue ); } if ( vetoFileName ) { XLALSegListClear( &vetoSegs ); } if ( vrbflg ) fprintf( stdout, "checking memory leaks and exiting\n" ); LALCheckMemoryLeaks(); exit( 0 ); }