hitXP.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
 
#include <TObject.h>
#include <TVector3.h>
 
namespace Belle2 {
  class hitXP: public TObject {
 
  public:
    TVector3 m_positionMid; 
    TVector3 m_positionEntry; 
    TVector3 m_positionExit; 
    TVector3 m_momentumMid; 
    TVector3 m_momentumEntry; 
    TVector3 m_momentumExit; 
    TVector3 m_positionLocalMid; 
    TVector3 m_positionLocalEntry; 
    TVector3 m_positionLocalExit; 
    TVector3 m_momentumLocalMid; 
    TVector3 m_momentumLocalEntry; 
    TVector3 m_momentumLocalExit; 
    int m_PDGID = 0; 
    TVector3 m_position0; 
    TVector3 m_momentum0; 
    double m_time = 0; 
    int m_sensorSensor = 0; 
    int m_sensorLayer = 0; 
    int m_sensorLadder = 0; 
    double m_info_d0 = 0; 
    double m_info_z0 = 0; 
    double m_info_phi0 = 0; 
    double m_info_tanlambda = 0; 
    double m_info_omega = 0; 
    int m_clusterU = 0; 
    int m_clusterV = 0; 
    bool m_reconstructed = 0; 
    double m_charge = 0; 
    hitXP() {}
 
    TVector3 getPositionMid() const { return m_positionMid; }
 
    TVector3 getPositionEntry() const { return m_positionEntry; }
 
    TVector3 getPositionExit() const { return m_positionExit; }
 
    TVector3 getMomentumMid() const { return m_momentumMid; }
 
    TVector3 getMomentumEntry() const { return m_momentumEntry; }
 
    TVector3 getMomentumExit() const { return m_momentumExit; }
 
    TVector3 getPositionLocalMid() const { return m_positionLocalMid; }
 
    TVector3 getPositionLocalEntry() const { return m_positionLocalEntry; }
 
    TVector3 getPositionLocalExit() const { return m_positionLocalExit; }
 
    TVector3 getMomentumLocalMid() const { return m_momentumLocalMid; }
 
    TVector3 getMomentumLocalEntry() const { return m_momentumLocalEntry; }
 
    TVector3 getMomentumLocalExit() const { return m_momentumLocalExit; }
 
    int getPDGID() const { return m_PDGID; }
 
    TVector3 getPosition0() const { return m_position0; }
 
    TVector3 getMomentum0() const { return m_momentum0; }
 
    double getTime() const { return m_time; }
 
    int getSensorSensor() const { return m_sensorSensor; }
 
    int getSensorLadder() const { return m_sensorLadder; }
 
    int getSensorLayer() const { return m_sensorLayer; }
 
    int getClusterU() const { return m_clusterU; }
 
    int getClusterV() const { return m_clusterV; }
 
    bool isReconstructed() const { return m_reconstructed; }
 
    double getCharge() const { return m_charge; }
 
    void setPositionMid(TVector3 position)
    {
      m_positionMid.SetX(position.X());
      m_positionMid.SetY(position.Y());
      m_positionMid.SetZ(position.Z());
    }
 
    void setPositionEntry(TVector3 position)
    {
      m_positionEntry.SetX(position.X());
      m_positionEntry.SetY(position.Y());
      m_positionEntry.SetZ(position.Z());
    }
 
    void setPositionExit(TVector3 position)
    {
      m_positionExit.SetX(position.X());
      m_positionExit.SetY(position.Y());
      m_positionExit.SetZ(position.Z());
    }
 
    void setMomentumMid(TVector3 momentum)
    {
      m_momentumMid.SetX(momentum.X());
      m_momentumMid.SetY(momentum.Y());
      m_momentumMid.SetZ(momentum.Z());
    }
 
    void setMomentumEntry(TVector3 momentum)
    {
      m_momentumEntry.SetX(momentum.X());
      m_momentumEntry.SetY(momentum.Y());
      m_momentumEntry.SetZ(momentum.Z());
    }
 
    void setMomentumExit(TVector3 momentum)
    {
      m_momentumExit.SetX(momentum.X());
      m_momentumExit.SetY(momentum.Y());
      m_momentumExit.SetZ(momentum.Z());
    }
 
    void setPositionLocalMid(TVector3 position)
    {
      m_positionLocalMid.SetX(position.X());
      m_positionLocalMid.SetY(position.Y());
      m_positionLocalMid.SetZ(position.Z());
    }
 
    void setPositionLocalEntry(TVector3 position)
    {
      m_positionLocalEntry.SetX(position.X());
      m_positionLocalEntry.SetY(position.Y());
      m_positionLocalEntry.SetZ(position.Z());
    }
 
    void setPositionLocalExit(TVector3 position)
    {
      m_positionLocalExit.SetX(position.X());
      m_positionLocalExit.SetY(position.Y());
      m_positionLocalExit.SetZ(position.Z());
    }
 
    void setMomentumLocalMid(TVector3 momentum)
    {
      m_momentumLocalMid.SetX(momentum.X());
      m_momentumLocalMid.SetY(momentum.Y());
      m_momentumLocalMid.SetZ(momentum.Z());
    }
 
    void setMomentumLocalEntry(TVector3 momentum)
    {
      m_momentumLocalEntry.SetX(momentum.X());
      m_momentumLocalEntry.SetY(momentum.Y());
      m_momentumLocalEntry.SetZ(momentum.Z());
    }
 
    void setMomentumLocalExit(TVector3 momentum)
    {
      m_momentumLocalExit.SetX(momentum.X());
      m_momentumLocalExit.SetY(momentum.Y());
      m_momentumLocalExit.SetZ(momentum.Z());
    }
 
    void setPDGID(int pdgid) { m_PDGID = pdgid; }
 
    void setPosition0(TVector3 position)
    {
      m_position0.SetX(position.X());
      m_position0.SetY(position.Y());
      m_position0.SetZ(position.Z());
    }
 
    void setMomentum0(TVector3 momentum)
    {
      m_momentum0.SetX(momentum.X());
      m_momentum0.SetY(momentum.Y());
      m_momentum0.SetZ(momentum.Z());
    }
 
    void setTime(double Time) { m_time = Time; }
 
    void setSensorSensor(int sensor) { m_sensorSensor = sensor; }
 
    void setSensorLayer(int layer) { m_sensorLayer = layer; }
 
    void setSensorLadder(int ladder) { m_sensorLadder = ladder; }
 
    void setClusterU(int cluster)
    {
      m_clusterU = cluster;
    }
 
    void setClusterV(int cluster)
    {
      m_clusterV = cluster;
    }
 
    void setReconstructed(bool isReconstructed) { m_reconstructed = isReconstructed; }
 
    void setCharge(double charge) { m_charge = charge; }
 
    double omega(TVector3 xx, TVector3 p, double charge) const;
 
 
    double tanLambda(TVector3 xx, TVector3 p) const;
 
 
    double d0(TVector3 xx, TVector3 p, double charge) const;
 
 
    double phi0(const TVector3& xx, TVector3 p, double charge) const;
 
 
    double z0(TVector3 xx, TVector3 p, double charge) const;
 
 
    double getOmegaMid() const { return omega(m_positionMid, m_momentumMid, m_charge); }
 
    double getOmegaEntry() const { return omega(m_positionEntry, m_momentumEntry, m_charge); }
 
    double getOmegaExit() const { return omega(m_positionExit, m_momentumExit, m_charge); }
 
    double getOmega0() const { return omega(m_position0, m_momentum0, m_charge); }
 
    double getTanLambdaMid() const { return tanLambda(m_positionMid, m_momentumMid); }
 
    double getTanLambdaEntry() const { return tanLambda(m_positionEntry, m_momentumEntry); }
 
    double getTanLambdaExit() const { return tanLambda(m_positionExit, m_momentumExit); }
 
    double getTanLambda0() const { return tanLambda(m_position0, m_momentum0); }
 
    double getD0Mid() const { return d0(m_positionMid, m_momentumMid, m_charge); }
 
    double getD0Entry() const { return d0(m_positionEntry, m_momentumEntry, m_charge); }
 
    double getD0Exit() const { return d0(m_positionExit, m_momentumExit, m_charge); }
 
    double getD00() const { return d0(m_position0, m_momentum0, m_charge); }
 
    double getPhi0Mid() const { return phi0(m_positionMid, m_momentumMid, m_charge); }
 
    double getPhi0Entry() const { return phi0(m_positionEntry, m_momentumEntry, m_charge); }
 
    double getPhi0Exit() const { return phi0(m_positionExit, m_momentumExit, m_charge); }
 
    double getPhi00() const { return phi0(m_position0, m_momentum0, m_charge); }
 
    double getZ0Mid() const { return z0(m_positionMid, m_momentumMid, m_charge); }
 
    double getZ0Entry() const { return z0(m_positionEntry, m_momentumEntry, m_charge); }
 
    double getZ0Exit() const { return z0(m_positionExit, m_momentumExit, m_charge); }
 
    double getZ00() const { return z0(m_position0, m_momentum0, m_charge); }
 
 
    struct timeCompare {
      bool operator()(hitXP v, hitXP u) const
      {return v.m_time < u.m_time;}
    };
 
    ClassDef(hitXP, 1);
  };
}