KLMSimHit.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
/* KLM headers. */
#include <klm/dataobjects/bklm/BKLMElementNumbers.h>
#include <klm/dataobjects/KLMElementNumbers.h>
 
/* Basf2 headers. */
#include <simulation/dataobjects/SimHitBase.h>
 
/* ROOT headers. */
#include <Math/Vector4D.h>
#include <Math/Vector3D.h>
 
namespace Belle2 {
  class KLMSimHit : public SimHitBase {
 
  public:
 
    KLMSimHit()
    {
    }
 
    ~KLMSimHit()
    {
    }
 
    int getPDG() const
    {
      return m_PDG;
    }
 
    void setPDG(int pdg)
    {
      m_PDG = pdg;
    }
 
    int getTrackID() const
    {
      return m_trackID;
    }
 
    void setTrackID(int track)
    {
      m_trackID = track;
    }
 
    int getParentTrackID() const
    {
      return m_parentTrackID;
    }
 
    void setParentTrackID(int track)
    {
      m_parentTrackID = track;
    }
 
    int getVolumeID() const
    {
      return m_volid;
    }
 
    int getSubdetector() const
    {
      return m_Subdetector;
    }
 
    void setSubdetector(int subdetector)
    {
      m_Subdetector = subdetector;
    }
 
    int getSection() const
    {
      return m_Section;
    }
 
    void setSection(int Section)
    {
      m_Section = Section;
    }
 
    int getLayer() const
    {
      return m_Layer;
    }
 
    void setLayer(int layer)
    {
      m_Layer = layer;
    }
 
    int getSector() const
    {
      return m_Sector;
    }
 
    void setSector(int sector)
    {
      m_Sector = sector;
    }
 
    int getPlane() const
    {
      return m_Plane;
    }
 
    bool isPhiReadout() const
    {
      return (m_Plane == BKLMElementNumbers::c_PhiPlane);
    }
 
    void setPlane(int plane)
    {
      m_Plane = plane;
    }
 
    int getStrip() const
    {
      return m_Strip;
    }
 
    void setStrip(int strip)
    {
      m_Strip = strip;
    }
 
    int getLastStrip() const
    {
      return m_LastStrip;
    }
 
    void setLastStrip(int lastStrip)
    {
      m_LastStrip = lastStrip;
    }
 
    bool inRPC() const
    {
      return (m_Subdetector == KLMElementNumbers::c_BKLM &&
              m_Layer >= BKLMElementNumbers::c_FirstRPCLayer);
    }
 
    float getEnergyDeposit() const
    {
      return m_EDep;
    }
 
    void setEnergyDeposit(float eDep)
    {
      m_EDep = eDep;
    }
 
    float getTime() const
    {
      return m_Time;
    }
 
    void setTime(float time)
    {
      m_Time = time;
    }
 
    float getPropagationTime() const
    {
      return m_PropagationTime;
    }
 
    void setPropagationTime(float propagationTime)
    {
      m_PropagationTime = propagationTime;
    }
 
    void setLocalPosition(float x, float y, float z)
    {
      m_localX = x;
      m_localY = y;
      m_localZ = z;
    }
 
    float getLocalPositionX() const
    {
      return m_localX;
    }
 
    float getLocalPositionY() const
    {
      return m_localY;
    }
 
    float getLocalPositionZ() const
    {
      return m_localZ;
    }
 
    ROOT::Math::XYZVector getLocalPosition() const
    {
      return ROOT::Math::XYZVector(m_localX, m_localY, m_localZ);
    }
 
    void setPosition(float x, float y, float z)
    {
      m_globalX = x;
      m_globalY = y;
      m_globalZ = z;
    }
 
    void setPosition(const ROOT::Math::XYZVector& pos)
    {
      m_globalX = pos.X();
      m_globalY = pos.Y();
      m_globalZ = pos.Z();
    }
 
    float getPositionX() const
    {
      return m_globalX;
    }
 
    float getPositionY() const
    {
      return m_globalY;
    }
 
    float getPositionZ() const
    {
      return m_globalZ;
    }
 
    ROOT::Math::XYZVector getPosition() const
    {
      return ROOT::Math::XYZVector(m_globalX, m_globalY, m_globalZ);
    }
 
    void setMomentum(const ROOT::Math::PxPyPzEVector& p)
    {
      m_e = p.E();
      m_pX = p.Px();
      m_pY = p.Py();
      m_pZ = p.Pz();
    }
 
    ROOT::Math::PxPyPzEVector getMomentum() const
    {
      return ROOT::Math::PxPyPzEVector(m_pX, m_pY, m_pZ, m_e);
    }
 
    void setVolumeID(int id)
    {
      m_volid = id;
    }
 
    float getGlobalTime() const override
    {
      return getTime();
    }
 
    void shiftInTime(float delta) override
    {
      setTime(getTime() + delta);
    }
 
  private:
 
    int m_PDG = -1;
 
    int m_trackID = -1;
 
    int m_parentTrackID = -1;
 
    int m_volid = -1;
 
    int m_Subdetector = 0;
 
    int m_Section = 0;
 
    int m_Layer = 0;
 
    int m_Sector = 0;
 
    int m_Plane = 0;
 
    int m_Strip = 0;
 
    int m_LastStrip;
 
    float m_Time = -1;
 
    float m_EDep = -1;
 
    float m_PropagationTime = 0;
 
    float m_localX = 0;
 
    float m_localY = 0;
 
    float m_localZ = 0;
 
    float m_globalX;
 
    float m_globalY;
 
    float m_globalZ;
 
    float m_e = 0;
 
    float m_pX = 0;
 
    float m_pY = 0;
 
    float m_pZ = 0;
 
    ClassDefOverride(Belle2::KLMSimHit, 1);
 
  };
 
}