Tools/CIC/cic/Event.h

Go to the documentation of this file.

// \author Darko Veberic
// \date 2014

#ifndef _cic_Event_h_
#define _cic_Event_h_

#include <iostream>
#include <vector>
#include <cmath>
#include <limits>


namespace cic {

  struct Event {

    Event() { }

    Event(const double sin2Theta, const double sin2ThetaErr,
          const double lnS1000, const double lnS1000Err) :
      fSin2Theta(sin2Theta),
      fThetaErr(sin2ThetaErr),
      fLnS1000(lnS1000),
      fLnS1000Err(lnS1000Err)
    { }

    static bool LessSin2Theta(const Event& a, const Event& b)
    { return a.fSin2Theta < b.fSin2Theta; }

    static bool LessLnS1000(const Event& a, const Event& b)
    { return a.fLnS1000 < b.fLnS1000; }

    double GetTheta() const { return std::asin(GetSinTheta()); }
    double GetSinTheta() const { return std::sqrt(fSin2Theta); }
    double GetCosTheta() const { return std::sqrt(GetCos2Theta()); }
    double GetCos2Theta() const { return 1 - fSin2Theta; }

    explicit
    operator bool()
      const
    {
      return
        0 <= fSin2Theta && fSin2Theta <= 1 &&
        fThetaErr > 0 &&
        -std::numeric_limits<double>::infinity() < fLnS1000 &&
        fLnS1000 < std::numeric_limits<double>::infinity() &&
        fLnS1000Err > 0;
    }

    double fSin2Theta = -1;
    double fThetaErr = 0;
    double fLnS1000 = -std::numeric_limits<double>::infinity();
    double fLnS1000Err = 0;

  };


  inline
  std::ostream&
  operator<<(std::ostream& os, const Event& e)
  {
    return os << e.fSin2Theta << ' ' << e.fThetaErr << ' '
              << e.fLnS1000 << ' ' << e.fLnS1000Err;
  }


  inline
  std::istream&
  operator>>(std::istream& is, Event& e)
  {
    return is >> std::ws >> e.fSin2Theta >> std::ws >> e.fThetaErr
              >> std::ws >> e.fLnS1000 >> std::ws >> e.fLnS1000Err;
  }


  std::vector<Event> Bootstrap(const std::vector<Event>& events);

  std::vector<Event> ResampleWithErrors(const std::vector<Event>& events);

}


#endif