mcshower.hh

Go to the documentation of this file.

#ifndef MCSHOWER_HH
#define MCSHOWER_HH

#include "data_base.hh"

namespace larlight {
  class mcshower : public data_base {
    
  public:

     mcshower(DATA::DATA_TYPE type=DATA::MCShower);

    virtual ~mcshower(){}

    mcshower(const mcshower& origin) : data_base(origin),
                       fMotherPDGID(origin.fMotherPDGID),
                       fMotherTrackID(origin.fMotherTrackID),
                       fMotherVtx(origin.fMotherVtx),
                       fMotherMomentum(origin.fMotherMomentum),
                       fMotherPhi(origin.fMotherPhi),
                       fMotherTheta(origin.fMotherTheta),
                       fMotherAngleU(origin.fMotherAngleU),
                       fMotherAngleV(origin.fMotherAngleV),
                       fMotherAngleW(origin.fMotherAngleW),
                       fDaughterTrackID(origin.fDaughterTrackID),
                       fDaughterVtx(origin.fDaughterVtx),
                       fDaughterMomentum(origin.fDaughterMomentum),
                                       fDaughterPhi(origin.fDaughterPhi),
                                       fDaughterTheta(origin.fDaughterTheta),
                       fDaughterAngleU(origin.fDaughterAngleU),
                       fDaughterAngleV(origin.fDaughterAngleV),
                                       fDaughterAngleW(origin.fDaughterAngleW),
                                       fChargeU(origin.fChargeU),
                                       fChargeV(origin.fChargeV),
                                       fChargeW(origin.fChargeW),
                                       fEdepVtx(origin.fEdepVtx)
    {}

    virtual void clear_data();

    //--- Getters ---//

    Int_t  MotherPDGID()   const { return fMotherPDGID;   }

    UInt_t MotherTrackID() const { return fMotherTrackID; }

    const std::vector<Double_t>& MotherPosition() const { return fMotherVtx;      }

    const std::vector<Double_t>& MotherMomentum() const { return fMotherMomentum; }

    void MotherAngle3D (Double_t &phi, Double_t &theta) const
    { phi = fMotherPhi; theta = fMotherTheta;}

    Double_t MotherAngle2D(const GEO::View_t view) const;

    const std::vector<UInt_t>&  DaughterTrackID() const
    { return fDaughterTrackID; }

    const std::vector<Float_t>& DaughterPosition() const
    { return fDaughterVtx; }

    const std::vector<Float_t>& DaughterMomentum() const
    { return fDaughterMomentum; }

    void DaughterAngle3D(Float_t &phi, Float_t &theta) const
    { phi = fDaughterPhi; theta = fDaughterTheta; }

    Float_t DaughterAngle2D(const GEO::View_t view) const;

    Float_t Charge(const GEO::View_t view) const;

    const std::vector<std::vector<Float_t> >& DaughterPoints() const
    { return fEdepVtx; }
    

    //--- Setters ---//

    void SetMotherID(Int_t pdgid, UInt_t trackid)
    { fMotherPDGID = pdgid; fMotherTrackID = trackid; }

    void SetMotherAngles(Double_t phi, Double_t theta, Double_t u, Double_t v, Double_t w)
    { fMotherPhi = phi; fMotherTheta = theta; fMotherAngleU = u; fMotherAngleV = v; fMotherAngleW = w; }

    void SetMotherPoint(const std::vector<Double_t> &vtx);

    void SetMotherMomentum(const std::vector<Double_t> &mom);

    void SetDaughterPosition(const std::vector<Float_t> &vtx);

    void SetDaughterMomentum(const std::vector<Float_t> &mom);
    
    void SetDaughterTrackList(const std::vector<UInt_t> &list)
    { fDaughterTrackID = list; }

    void SetDaughterAngles(Double_t phi, Double_t theta, Double_t u, Double_t v, Double_t w)
    { fDaughterPhi = phi; fDaughterTheta = theta; fDaughterAngleU = u; fDaughterAngleV = v; fDaughterAngleW = w; }

    void SetPlaneCharge(Float_t qU, Float_t qV, Float_t qW)
    { fChargeU = qU; fChargeV = qV; fChargeW = qW; }

    void AddEdepVtx(const std::vector<Float_t>& vtx);

    void SetEdepVtx(const std::vector<std::vector<Float_t> >& vtx);

  private:

    //---- Mother info ----//
    Int_t  fMotherPDGID;                   
    UInt_t fMotherTrackID;                 
    std::vector<Double_t> fMotherVtx;      
    std::vector<Double_t> fMotherMomentum; 

    Double_t fMotherPhi;
    Double_t fMotherTheta;
    Double_t fMotherAngleU;
    Double_t fMotherAngleV;
    Double_t fMotherAngleW;

    //---- Daughter info ----//
    std::vector<UInt_t>  fDaughterTrackID;  
    std::vector<Float_t> fDaughterVtx;      
    std::vector<Float_t> fDaughterMomentum; 

    Float_t fDaughterPhi;
    Float_t fDaughterTheta;
    Float_t fDaughterAngleU;
    Float_t fDaughterAngleV;
    Float_t fDaughterAngleW;

    //---- Charge per plane ----//
    Float_t fChargeU; 
    Float_t fChargeV; 
    Float_t fChargeW; 

    std::vector<std::vector<Float_t> > fEdepVtx;

    ClassDef(mcshower,2)
      
  };

  class event_mcshower : public std::vector<larlight::mcshower>,
             public event_base {
    
  public:
    
    event_mcshower(DATA::DATA_TYPE type=DATA::MCShower);
    
    event_mcshower(const event_mcshower& original) : std::vector<larlight::mcshower>(original),
                             event_base(original)
    {}
    
    ~event_mcshower(){}
    
    virtual void clear_data(){event_base::clear_data(); clear();}
    
  private:
    
    ClassDef(event_mcshower,1)
  };
  
}
#endif
 // end of doxygen group 

---