/******************************************************************************/
/*                                                                            */
/*                             COINCIDENTEVENT.HH                             */
/*                                                                            */
/******************************************************************************/

// Shourov K. Chatterji
// shourov@ligo.caltech.edu
// $Id: coincidentevent.hh,v 1.2 2007/06/04 10:42:53 shourov Exp $

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

#ifndef COINCIDENTEVENT_HH
#define COINCIDENTEVENT_HH

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

#include <cmath>
#include <vector>
#include <sstream>
#include <iostream>
#include "event.hh"

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

namespace event {

/*                        Begin class CoincidentEvent                         */
/*                        ---------------------------                         */

class CoincidentEvent {

/*                 Public interface of class CoincidentEvent                  */
/*                 -----------------------------------------                  */

public:

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

  // default coincident event constructor
  CoincidentEvent();

  // default coincident event destructor
  ~CoincidentEvent();

  // coincident event copy constructor
  CoincidentEvent(const CoincidentEvent&);

  // coincident event assignment operator
  CoincidentEvent& operator=(const CoincidentEvent&);

  // coincident event constructor from event
  CoincidentEvent(const Event& event);

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

  // clear single detector events
  void clear();

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

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

  // get number of single detector events
  std::vector<Event>::size_type getNumberOfEvents() const;

  // get representative center time of coincident event
  double getCenterTime() const;

  // get representative center frequency of coincident event
  double getCenterFrequency() const;

  // get representative duration of coincident event
  double getDuration(double durationInflation = 1.0) const;

  // get representative bandwidth of coincident event
  double getBandwidth(double bandwidthInflation = 1.0) const;

  // get representative normalized energy of coincident event
  double getNormalizedEnergy() const;

  // get representative incoherent energy of coincident event
  double getIncoherentEnergy() const;

  // get miscellaneous properties of coincident event
  std::string getMiscellaneous() const;

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

  // write coincident event to output stream
  friend std::ostream& operator<<(std::ostream& ostream,
                                  const CoincidentEvent& coincidentEvent);

  // read coincident event from input stream
  friend std::istream& operator>>(std::istream& istream,
                                  CoincidentEvent& coincidentEvent);

  // 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);

/*                Protected interface of class CoincidentEvent                */
/*                --------------------------------------------                */

protected:

/*                 Private interface of class CoincidentEvent                 */
/*                 ------------------------------------------                 */

private:

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

  // vector of events
  std::vector<Event> eventVector;

/*                         End class CoincidentEvent                          */
/*                         -------------------------                          */

};

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

std::ostream& operator<<(std::ostream& os,
                         const CoincidentEvent& coincidentEvent);
std::istream& operator>>(std::istream& is,
                         CoincidentEvent& coincidentEvent);

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

// default coincident event constructor
CoincidentEvent::CoincidentEvent()
  : eventVector()
{
}

// default coincident event destructor
CoincidentEvent::~CoincidentEvent()
{
}

// coincident event copy constructor
CoincidentEvent::CoincidentEvent(const CoincidentEvent& coincidentEvent)
  : eventVector(coincidentEvent.eventVector)
{
}

// coincident event assignment operator
CoincidentEvent&
CoincidentEvent::operator=(const CoincidentEvent& coincidentEvent)
{
  if (this != &coincidentEvent) {
    eventVector = coincidentEvent.eventVector;
  }
  return *this;
}

// coincident event constructor from event
CoincidentEvent::CoincidentEvent(const Event& event)
  : eventVector()
{
  eventVector.push_back(event);
}

// event constructor from coincident event
Event::Event(const CoincidentEvent& coincidentEvent)
{
  centerTime = coincidentEvent.getCenterTime();
  centerFrequency = coincidentEvent.getCenterFrequency();
  duration = coincidentEvent.getDuration();
  bandwidth = coincidentEvent.getBandwidth();
  normalizedEnergy = coincidentEvent.getNormalizedEnergy();
  incoherentEnergy = coincidentEvent.getIncoherentEnergy();
  miscellaneous = coincidentEvent.getMiscellaneous();
}

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

// clear single detector events
void
CoincidentEvent::clear()
{
  eventVector.clear();
}

// time shift coincident event
void
CoincidentEvent::timeShift(double timeShift)
{
  std::vector<Event>::iterator eventIterator;
  eventIterator = eventVector.begin();
  while (eventIterator < eventVector.end()) {
    eventIterator->timeShift(timeShift);
    eventIterator++;
  }
}

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

// get number of single detector events
std::vector<Event>::size_type
CoincidentEvent::getNumberOfEvents() const
{
  return eventVector.size();
}

// get representative center time of coincident event
double
CoincidentEvent::getCenterTime() const
{
  double centerTime = 0.0;
  if (eventVector.empty()) {
    return centerTime;
  }
  if (eventVector.size() == 1) {
    return eventVector[0].getCenterTime();
  }
  std::vector<Event>::const_iterator eventIterator;
  eventIterator = eventVector.begin();
  while (eventIterator < eventVector.end()) {
    centerTime += eventIterator->getCenterTime();
    eventIterator++;
  }
  centerTime /= static_cast<double>(eventVector.size());
  return centerTime;
}

// get representative center frequency of coincident event
double
CoincidentEvent::getCenterFrequency() const
{
  double centerFrequency = 1.0;
  if (eventVector.empty()) {
    return centerFrequency;
  }
  if (eventVector.size() == 1) {
    return eventVector[0].getCenterFrequency();
  }
  std::vector<Event>::const_iterator eventIterator;
  eventIterator = eventVector.begin();
  while (eventIterator < eventVector.end()) {
    centerFrequency *= eventIterator->getCenterFrequency();
    eventIterator++;
  }
  centerFrequency = pow(centerFrequency,
			1.0 / static_cast<double>(eventVector.size()));
  return centerFrequency;
}

// get representative duration of coincident event
double
CoincidentEvent::getDuration(double durationInflation) const
{
  double duration = 1.0;
  if (eventVector.empty()) {
    return duration;
  }
  if (eventVector.size() == 1) {
    return eventVector[0].getDuration(durationInflation);
  }
  std::vector<Event>::const_iterator eventIterator;
  eventIterator = eventVector.begin();
  while (eventIterator < eventVector.end()) {
    duration *= eventIterator->getDuration(durationInflation);
    eventIterator++;
  }
  duration = pow(duration, 1.0 / static_cast<double>(eventVector.size()));
  return duration;
}

// get representative bandwidth of coincident event
double
CoincidentEvent::getBandwidth(double bandwidthInflation) const
{
  double bandwidth = 1.0;
  if (eventVector.empty()) {
    return bandwidth;
  }
  if (eventVector.size() == 1) {
    return eventVector[0].getBandwidth(bandwidthInflation);
  }
  std::vector<Event>::const_iterator eventIterator;
  eventIterator = eventVector.begin();
  while (eventIterator < eventVector.end()) {
    bandwidth *= eventIterator->getBandwidth(bandwidthInflation);
    eventIterator++;
  }
  bandwidth = pow(bandwidth, 1.0 / static_cast<double>(eventVector.size()));
  return bandwidth;
}

// get representative normalized energy of coincident event
double
CoincidentEvent::getNormalizedEnergy() const
{
  double normalizedEnergy = 1.0;
  if (eventVector.empty()) {
    return normalizedEnergy;
  }
  if (eventVector.size() == 1) {
    return eventVector[0].getNormalizedEnergy();
  }
  std::vector<Event>::const_iterator eventIterator;
  eventIterator = eventVector.begin();
  while (eventIterator < eventVector.end()) {
    normalizedEnergy *= eventIterator->getNormalizedEnergy();
    eventIterator++;
  }
  normalizedEnergy = pow(normalizedEnergy,
			 1.0 / static_cast<double>(eventVector.size()));
  return normalizedEnergy;
}

// get representative incoherent energy of coincident event
double
CoincidentEvent::getIncoherentEnergy() const
{
  double incoherentEnergy = 1.0;
  if (eventVector.empty()) {
    return incoherentEnergy;
  }
  if (eventVector.size() == 1) {
    return eventVector[0].getIncoherentEnergy();
  }
  std::vector<Event>::const_iterator eventIterator;
  eventIterator = eventVector.begin();
  while (eventIterator < eventVector.end()) {
    incoherentEnergy *= eventIterator->getIncoherentEnergy();
    eventIterator++;
  }
  incoherentEnergy = pow(incoherentEnergy,
			 1.0 / static_cast<double>(eventVector.size()));
  return incoherentEnergy;
}

// get miscellaneous properties of coincident event
std::string
CoincidentEvent::getMiscellaneous() const
{
  std::ostringstream ostringstream("");
  if (eventVector.empty()) {
    return ostringstream.str();
  }
  if (eventVector.size() == 1) {
    return eventVector[0].getMiscellaneous();
  }
  std::vector<Event>::const_iterator eventIterator;
  eventIterator = eventVector.begin();
  while (eventIterator < eventVector.end() - 1) {
    ostringstream << *eventIterator << " ";
    eventIterator++;
  }
  ostringstream << *eventIterator;
  return ostringstream.str();
}

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

// write coincident event to output stream
std::ostream& operator<<(std::ostream& ostream,
                         const CoincidentEvent& coincidentEvent)
{
  ostream << "{" << std::endl;
  std::vector<Event>::const_iterator eventIterator;
  eventIterator = coincidentEvent.eventVector.begin();
  while (eventIterator < coincidentEvent.eventVector.end()) {
    ostream << "  " << *eventIterator;
    eventIterator++;
  }
  ostream << "}" << std::endl;
  return ostream;
}

// read coincident event from output stream
std::istream& operator>>(std::istream& istream,
                         CoincidentEvent& coincidentEvent)
{
  coincidentEvent.eventVector.clear();
  std::string string;
  std::getline(istream, string, '\n');
  if (string != "{") {
    istream.setstate(std::ios_base::failbit);
    return istream;
  }
  Event event;
  while (istream.peek() != '}') {
    istream >> event;
    coincidentEvent.eventVector.push_back(event);
  }
  std::getline(istream, string, '\n');
  if (string != "{") {
    istream.setstate(std::ios_base::failbit);
    return istream;
  }
  return istream;
}

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

}

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

#endif