PhysicsNtuple/Event.h

Go to the documentation of this file.

#ifndef ANP_EVENT_H
#define ANP_EVENT_H

// $Id: Event.h,v 1.21 2009/10/15 18:30:13 jyuko Exp $
//
// Reconstucted neutrino event
//

// C++
#include <vector>

// ROOT
#include "Rtypes.h"

// Local
#include "PhysicsNtuple/DataItem.h"
#include "PhysicsNtuple/Basic.h"
#include "PhysicsNtuple/RecoNu.h"
#include "PhysicsNtuple/Vertex.h"

namespace Anp
{
   class Shower;
   class Track;

   class Event
   {
   public:
      
      Event();
      ~Event();
      
      bool Add(int key, float data);

      void SetNu(const RecoNu &value);
      void SetPid(float value);
      void SetWeight(double value);

      void Clear();
      void ClearData();
      
      DataIterator DataBegIterator();
      DataIterator DataEndIterator();
      DataIterator Erase(DataIterator it);
      DataIterator Erase(DataIterator ibeg, DataIterator iend);

      RecoNu& GetRecoNu();

      const Basic&  GetBasic() const;
      const RecoNu& GetNu()    const;
      const Vertex& GetVtx()   const;

      short GetNShowers() const;
      short GetNTracks()  const;

      short EventIndex() const;
      float Gev() const;
      float Pid() const;

      double Weight() const;

      bool MatchTrack (short index) const;
      bool MatchShower(short index) const;
      bool FirstShower(short index) const;

      DataIter DataBeg() const;
      DataIter DataEnd() const;

      bool KeyExists(short key) const;
      float operator[](short key) const;
      float DataAt(short key) const;

      void Print(std::ostream &os = std::cout) const;

   private:
      
      friend class FillEvent;

      Basic    fBasic;
      RecoNu   fNu;
      Vertex   fVtx;

      Short_t  index;    // event index in a snarl
      Float_t  gev;      // default event energy
      Float_t  pid;      // classification decision value

      DataVec  fData;    // vector of DataItem<short,float>

      std::vector<Short_t> fShower;
      std::vector<Short_t> fTrack;      
   };

   bool operator==(short index, const Event &event);
   bool operator==(const Event &event, short index);
   bool operator==(const Event &lhs, const Event &rhs);

   bool operator==(const Event  &event,  const Shower &shower);
   bool operator==(const Shower &shower, const Event  &event);

   bool operator==(const Track &track, const Event &event);
   bool operator==(const Event &event, const Track &track);

   //
   // Inlined member functions
   //
   inline void Event::SetNu(const RecoNu &value)    { fNu = value; }
   inline void Event::SetPid(const float value)     { pid = value; }
   inline void Event::SetWeight(const double value) { fNu.SetWeight(value); }

   inline DataIterator Event::DataBegIterator() { return fData.begin(); }
   inline DataIterator Event::DataEndIterator() { return fData.end(); }

   inline DataIterator Event::Erase(DataIterator it) { return fData.erase(it); }
   inline DataIterator Event::Erase(DataIterator ibeg, DataIterator iend)
   {
      return fData.erase(ibeg, iend);
   }

   inline DataIter Event::DataBeg() const { return fData.begin(); }
   inline DataIter Event::DataEnd() const { return fData.end(); }
   
   inline bool Event::MatchTrack(const short index) const
   {
      return (std::find(fTrack.begin(), fTrack.end(), index) != fTrack.end());
   }
   inline bool Event::MatchShower(const short index) const
   {
      return (std::find(fShower.begin(), fShower.end(), index) != fShower.end());
   }

   inline RecoNu& Event::GetRecoNu() { return fNu; }

   inline const Basic&  Event::GetBasic() const { return fBasic; }
   inline const RecoNu& Event::GetNu()    const { return fNu; }
   inline const Vertex& Event::GetVtx()   const { return fVtx; }

   inline short Event::GetNShowers() const { return fShower.size(); }
   inline short Event::GetNTracks()  const { return fTrack.size(); }

   inline short Event::EventIndex() const { return index; }
   inline float Event::Gev() const { return gev; }
   inline float Event::Pid() const { return pid; }

   inline double Event::Weight() const { return fNu.Weight(); }

   inline bool Event::KeyExists(const short key) const
   {
      return (std::find(fData.begin(), fData.end(), key) != fData.end());
   }
   inline float Event::operator[](const short key) const
   {
      return DataAt(key);
   }

   //
   // Inlined global operators
   //
   inline bool operator==(const short index, const Event &event)
   {
      return (index == event.EventIndex());
   }
   inline bool operator==(const Event &event, const short index)
   {
      return (index == event.EventIndex());
   }
   inline bool operator==(const Event &lhs, const Event &rhs)
   {
      return (lhs.EventIndex() == rhs.EventIndex());
   }
}

#endif

---