/******************************************************************************/
/*                                                                            */
/*                           COINCIDENTEVENTLIST.HH                           */
/*                                                                            */
/******************************************************************************/

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

/*                      Protect against double inclusion                      */
/*                      --------------------------------                      */

#ifndef COINCIDENTEVENTLIST_HH
#define COINCIDENTEVENTLIST_HH

/*                            Include header files                            */
/*                            --------------------                            */

#include <vector>
#include <string>
#include <fstream>
#include <iostream>
#include <algorithm>
#include "eventlist.hh"
#include "coincidentevent.hh"
#include "coincidenteventcriteria.hh"

/*                           Begin namespace event                            */
/*                           ---------------------                            */

namespace event {

/*                      Begin class CoincidentEventList                       */
/*                      -------------------------------                       */

class CoincidentEventList {

/*               Public interface of class CoincidentEventList                */
/*               ---------------------------------------------                */

public:

  /*                Constructor and destructor declarations                   */
  /*                ---------------------------------------                   */

  // default coincident event list constructor
  CoincidentEventList();

  // default coincident event list destructor
  ~CoincidentEventList();

  // coincident event list constructor from event list
  CoincidentEventList(const EventList& eventList);

  /*                      Mutator method declarations                         */
  /*                      ---------------------------                         */

  // empty contents of coincident event list
  void clear();

  // cut coincident event list by requested criterion
  template <class CutCriterion>
  void cut(CutCriterion cutCriterion);

  // sort coincident event list by requested criterion
  template <class SortCriterion>
  void sort(SortCriterion sortCriterion);

  // time shift coincident event list
  void timeShift(double timeShift);

  /*                      Accessor method declarations                        */
  /*                      ----------------------------                        */

  // get number of coincident events
  std::vector<CoincidentEvent>::size_type getNumberOfEvents() const;

  /*                    Input/output method declarations                      */
  /*                    --------------------------------                      */

  // write coincident event list to file
  void write(std::string file) const;

  // read coincident event list from file
  void read(std::string file);

  /*			  Friend function declarations                        */
  /*			  ----------------------------                        */

  // write coincident event list to output stream
  friend std::ostream& operator<<(std::ostream& ostream,
                                  const CoincidentEventList&
				  coincidentEventList);

  // read coincident event list from input stream
  friend std::istream& operator>>(std::istream& istream,
                                  CoincidentEventList& coincidentEventList);

  // coincide two event lists
  template <class CoincidenceCriterion>
  friend void coincide(EventList& inputEventList1,
                       EventList& inputEventList2,
                       CoincidentEventList& outputCoincidentEventList,
                       CoincidenceCriterion coincidenceCriterion);

  // coincide a coincident event list with an event list
  template <class CoincidenceCriterion>
  friend void coincide(CoincidentEventList& inputCoincidentEventList,
                       EventList& inputEventList,
                       CoincidentEventList& outputCoincidentEventList,
                       std::vector<CoincidenceCriterion> coincidenceCriteria);

  // coincide multiple event lists
  template <class CoincidenceCriterion>
  friend void coincide(std::vector<EventList> inputEventLists,
                       CoincidentEventList& outputCoincidentEventList,
                       std::vector<CoincidenceCriterion> coincidenceCriteria);

  /*			   Friend class declarations                          */
  /*			   -------------------------                          */

  // allow event lists to access private interface
  friend class EventList;

/*              Protected interface of class CoincidentEventList              */
/*              ------------------------------------------------              */

protected:

/*               Private interface of class CoincidentEventList               */
/*               ----------------------------------------------               */

private:

/*                       Prevent copying and assignment                       */
/*                       ------------------------------                       */

  // coincident event list copy constructor
  CoincidentEventList(const CoincidentEventList&);

  // coincident event list assignment operator
  CoincidentEventList& operator=(const CoincidentEventList&);

  /*                            State variables                               */
  /*                            ---------------                               */

  // vector of coincident events
  std::vector<CoincidentEvent> coincidentEventVector;

/*                       End class CoincidentEventList                        */
/*                       -----------------------------                        */

};

/*			Non-member function declarations                      */
/*			--------------------------------                      */

// write coincident event list to output stream
std::ostream& operator<<(std::ostream& ostream,
			 const CoincidentEventList& coincidentEventList);

// read coincident event list from input stream
std::istream& operator>>(std::istream& istream,
			 CoincidentEventList& coincidentEventList);

// coincide two event lists
template <class CoincidenceCriterion>
void coincide(EventList& inputEventList1,
              EventList& inputEventList2,
              CoincidentEventList& outputCoincidentEventList,
              CoincidenceCriterion coincidenceCriterion);

// coincide a coincident event list with an event list
template <class CoincidenceCriterion>
void coincide(CoincidentEventList& inputCoincidentEventList,
              EventList& inputEventList,
              CoincidentEventList& outputCoincidentEventList,
              std::vector<CoincidenceCriterion> coincidenceCriteria);

// coincide multiple event lists
template <class CoincidenceCriterion>
void coincide(std::vector<EventList> inputEventLists,
              CoincidentEventList& outputCoincidentEventList,
              std::vector<CoincidenceCriterion> coincidenceCriteria);

/*                   Constructor and destructor definitions                   */
/*                   --------------------------------------                   */

// default coincident event list constructor
CoincidentEventList::CoincidentEventList()
{
}

// default coincident event list destructor
CoincidentEventList::~CoincidentEventList()
{
}

// coincident event list constructor from event list
CoincidentEventList::CoincidentEventList(const EventList& eventList)
{
  std::vector<Event>::const_iterator eventIterator;
  eventIterator = eventList.eventVector.begin();
  while (eventIterator < eventList.eventVector.end()) {
    coincidentEventVector.push_back(*eventIterator);
    eventIterator++;
  }
}

// event list constructor from coincident event list
EventList::EventList(const CoincidentEventList& coincidentEventList)
{
  std::vector<CoincidentEvent>::const_iterator coincidentEventIterator;
  coincidentEventIterator = coincidentEventList.coincidentEventVector.begin();
  while (coincidentEventIterator <
	 coincidentEventList.coincidentEventVector.end()) {
    eventVector.push_back(*coincidentEventIterator);
    coincidentEventIterator++;
  }
}

/*                         Mutator method definitions                         */
/*                         --------------------------                         */


// empty contents of coincident event list
void
CoincidentEventList::clear()
{
  coincidentEventVector.clear();
}

// cut coincident event list by requested criterion
template <class CutCriterion>
void
CoincidentEventList::cut(CutCriterion cutCriterion)
{
  std::vector<CoincidentEvent>::iterator removeIterator;
  removeIterator = std::remove_if(coincidentEventVector.begin(),
				  coincidentEventVector.end(),
                                  cutCriterion);
  coincidentEventVector.erase(removeIterator, coincidentEventVector.end());
}

// sort coincident event list by requested criterion
template <class SortCriterion>
void
CoincidentEventList::sort(SortCriterion sortCriterion)
{
  std::sort(coincidentEventVector.begin(), coincidentEventVector.end(),
	    sortCriterion);
}

// time shift coincident event list
void
CoincidentEventList::timeShift(double timeShift)
{
  std::vector<CoincidentEvent>::iterator coincidentEventIterator;
  coincidentEventIterator = coincidentEventVector.begin();
  while (coincidentEventIterator < coincidentEventVector.end()) {
    coincidentEventIterator->timeShift(timeShift);
    coincidentEventIterator++;
  }
}

/*                        Accessor method definitions                         */
/*                        ---------------------------                         */

// get number of coincident events
std::vector<CoincidentEvent>::size_type
CoincidentEventList::getNumberOfEvents() const
{
  return coincidentEventVector.size();
}

/*                      Input/output method definitions                       */
/*                      -------------------------------                       */

// write coincident event list to file
void
CoincidentEventList::write(std::string file) const
{
  std::ofstream ofstream(file.c_str());
  ofstream << *this;
}

// read coincident event list from file
void
CoincidentEventList::read(std::string file)
{
  std::ifstream ifstream(file.c_str());
  ifstream >> *this;
  if (ifstream.fail()) {
    std::cerr << "error: syntax error in coincident event list " << file
	      << std::endl;
    coincidentEventVector.clear();
  }
}

/*			Non-member function definitions                       */
/*			-------------------------------                       */

// write coincident event list to output stream
std::ostream&
operator<<(std::ostream& ostream,
	   const CoincidentEventList& coincidentEventList)
{
  std::vector<CoincidentEvent>::const_iterator coincidentEventIterator;
  coincidentEventIterator = coincidentEventList.coincidentEventVector.begin();
  while (coincidentEventIterator <
	 coincidentEventList.coincidentEventVector.end()) {
    ostream << *coincidentEventIterator;
    coincidentEventIterator++;
  }
  return ostream;
}

// read coincident event list from input stream
std::istream&
operator>>(std::istream& istream, CoincidentEventList& coincidentEventList)
{
  CoincidentEvent coincidentEvent;
  while (istream.peek() != EOF) {
    istream >> coincidentEvent;
    if (istream.fail()) {
      return istream;
    }
    coincidentEventList.coincidentEventVector.push_back(coincidentEvent);
  }
  return istream;
}

// coincide two event lists
template <class CoincidenceCriterion>
void
coincide(EventList& inputEventList1,
	 EventList& inputEventList2,
	 CoincidentEventList& coincidentEventList,
	 CoincidenceCriterion coincidenceCriterion)
{
  if ((inputEventList1.eventVector.size() == 0) ||
      (inputEventList2.eventVector.size() == 0)) {
    coincidentEventList.coincidentEventVector.clear();
    return;
  }
  std::sort(inputEventList1.eventVector.begin(),
            inputEventList1.eventVector.end(),
            IncreasingEventCenterTimeSortCriterion());
  std::sort(inputEventList2.eventVector.begin(),
            inputEventList2.eventVector.end(),
            IncreasingEventCenterTimeSortCriterion());
  std::vector<Event>::iterator maximumDurationEventIterator1 =
    std::max_element(inputEventList1.eventVector.begin(),
                     inputEventList1.eventVector.end(),
                     IncreasingEventDurationSortCriterion());
  std::vector<Event>::iterator maximumDurationEventIterator2 =
    std::max_element(inputEventList2.eventVector.begin(),
                     inputEventList2.eventVector.end(),
                     IncreasingEventDurationSortCriterion());
  double maximumEventDuration1 =
    maximumDurationEventIterator1->
    getDuration(coincidenceCriterion.durationInflation);
  double maximumEventDuration2 =
    maximumDurationEventIterator2->
    getDuration(coincidenceCriterion.durationInflation);
  std::vector<Event>::iterator eventIterator1;
  std::vector<Event>::iterator eventIterator2;
  std::vector<Event>::iterator startIterator;
  std::vector<Event>::iterator stopIterator;
  eventIterator1 = inputEventList1.eventVector.begin();
  eventIterator2 = inputEventList2.eventVector.begin();
  startIterator = inputEventList2.eventVector.begin();
  stopIterator = inputEventList2.eventVector.begin();
  while (eventIterator1 < inputEventList1.eventVector.end()) {
    double startTime = eventIterator1->getCenterTime() -
      (maximumEventDuration1 + maximumEventDuration2) / 2.0 -
      coincidenceCriterion.coincidenceWindowDuration;
    double stopTime = eventIterator1->getCenterTime() +
      (maximumEventDuration1 + maximumEventDuration2) / 2.0 +
      coincidenceCriterion.coincidenceWindowDuration;
    startIterator = std::find_if(startIterator, inputEventList2.eventVector.end(),
                                 EventCenterTimeGreaterThanCutCriterion(startTime));
    stopIterator = std::find_if(stopIterator, inputEventList2.eventVector.end(),
                                EventCenterTimeGreaterThanCutCriterion(stopTime));
    eventIterator2 = startIterator;
    while (eventIterator2 < stopIterator) {
      if (coincidenceCriterion(*eventIterator1, *eventIterator2)) {
	CoincidentEvent coincidentEvent;
	coincidentEvent.eventVector.push_back(*eventIterator1);
	coincidentEvent.eventVector.push_back(*eventIterator2);
	coincidentEventList.coincidentEventVector.push_back(coincidentEvent);
      }
      eventIterator2++;
    }
    eventIterator1++;
  }
}

// coincide a coincident event list with an event list
template <class CoincidenceCriterion>
void
coincide(CoincidentEventList& inputCoincidentEventList,
	 EventList& inputEventList,
	 CoincidentEventList& outputCoincidentEventList,
	 std::vector<CoincidenceCriterion> coincidenceCriteria)
{
  // ********** UNDER CONSTRUCTION **********
  std::cerr << "error: coincidence of coincidence events with single "
	    << "detector events is not yet implemented."
	    << std::endl;
  outputCoincidentEventList.clear();
}

// coincide multiple event lists
template <class CoincidenceCriterion>
void
coincide(std::vector<EventList> eventLists,
	 CoincidentEventList& coincidentEventList,
	 std::vector<CoincidenceCriterion> coincidenceCriteria)
{
  // ********** UNDER CONSTRUCTION **********
  std::cerr << "error: coincidence of multiple event lists is not yet "
	    << "implemented."
	    << std::endl;
  coincidentEventList.clear();
}

/*                            End namespace event                             */
/*                            -------------------                             */

}

/*                  End protection against double inclusion                   */
/*                  ---------------------------------------                   */

#endif