/******************************************************************************/
/*                                                                            */
/*                                 DETECT.CC                                  */
/*                                                                            */
/******************************************************************************/

// Compares a list of observed events with a list of injected events to produce
// lists of detected injections, missed injections, true observations, and false
// observations.  Detection requires time only coincidence with a specified time
// window.  Three forms are provided.  The more limited forms are
// computationally more efficient, but provides only a list of detected
// injections.
//
//   detect observedEventList injectedEventList detectedInjections
//
//   detect windowDuration observedEventList injectedEventList
//          detectedInjections
//
//   detect windowDuration observedEventList injectedEventList
//          trueEventList falseEventList detectedEventList missedEventList

// Shourov K. Chatterji
// shourov@ligo.caltech.edu
// $Id: detect.cc,v 1.1 2006/11/03 15:33:59 shourov Exp $

#include <string>
#include <iostream>
#include "eventlist.hh"

int
main(int argc, char **argv) {

  double coincidenceWindowDuration;
  double coincidenceWindowBandwidth = event::ignore;

  double durationInflation = 1.0;
  double bandwidthInflation = 1.0;

  std::string observedEventListFile;
  std::string injectedEventListFile;
  std::string trueEventListFile;
  std::string falseEventListFile;
  std::string detectedEventListFile;
  std::string missedEventListFile;

  if (argc == 4) {
    coincidenceWindowDuration = 0.0;
    bandwidthInflation = 1.0;
    observedEventListFile= argv[1];
    injectedEventListFile= argv[2];
    trueEventListFile= "";
    falseEventListFile= "";
    detectedEventListFile= argv[3];
    missedEventListFile= "";
  }
  else if (argc == 5) {
    coincidenceWindowDuration = atof(argv[1]);
    observedEventListFile= argv[2];
    injectedEventListFile= argv[3];
    trueEventListFile= "";
    falseEventListFile= "";
    detectedEventListFile= argv[4];
    missedEventListFile= "";
  }
  else if (argc == 8) {
    coincidenceWindowDuration = atof(argv[1]);
    observedEventListFile= argv[2];
    injectedEventListFile= argv[3];
    trueEventListFile= argv[4];
    falseEventListFile= argv[5];
    detectedEventListFile= argv[6];
    missedEventListFile= argv[7];
  }
  else {
    std::cerr << "error: incorrect number of arguments"
              << std::endl;
    std::cerr << std::endl;
    std::cerr << "usage: detect observedEventList injectedEventList \\"
              << std::endl;
    std::cerr << "              detectedEventList"
              << std::endl;
    std::cerr << std::endl;
    std::cerr << "       detect durationInflation bandwidthInflation \\"
              << std::endl;
    std::cerr << "              observedEventList injectedEventList \\"
              << std::endl;
    std::cerr << "              detectedEventList"
              << std::endl;
    std::cerr << std::endl;
    std::cerr << "       detect durationInflation bandwidthInflation \\"
              << std::endl;
    std::cerr << "              observedEventList injectedEventList \\"
              << std::endl;
    std::cerr << "              trueEventList falseEventList \\"
              << std::endl;
    std::cerr << "              detectedEventList missedEventList"
              << std::endl;
    return 1;
  }

  event::EventAlternateTimeFrequencyCoincidenceCriterion
    coincidenceCriterion(coincidenceWindowDuration, coincidenceWindowBandwidth,
                         durationInflation, bandwidthInflation);

  event::EventList observedEventList;
  event::EventList injectedEventList;
  event::EventList trueEventList;
  event::EventList falseEventList;
  event::EventList detectedEventList;
  event::EventList missedEventList;

  observedEventList.read(observedEventListFile);
  injectedEventList.read(injectedEventListFile);

  if (argc == 8) {
    event::detect(observedEventList, injectedEventList,
                  trueEventList, falseEventList,
                  detectedEventList, missedEventList,
                  coincidenceCriterion);
    trueEventList.write(trueEventListFile);
    falseEventList.write(falseEventListFile);
    detectedEventList.write(detectedEventListFile);
    missedEventList.write(missedEventListFile);
  }
  else {
    event::detect(observedEventList, injectedEventList,
                  detectedEventList, coincidenceCriterion);
    detectedEventList.write(detectedEventListFile);
  }

  return 0;

}