VXDDedxTrack.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 <reconstruction/dataobjects/DedxConstants.h>
 
#include <framework/datastore/RelationsObject.h>
#include <framework/gearbox/Const.h>
 
#include <vector>
 
namespace Belle2 {
  class VXDDedxTrack : public RelationsObject {
    friend class VXDDedxPIDModule;
 
  public:
 
    VXDDedxTrack() :
      RelationsObject(),
      m_eventID(0), m_trackID(0),
      m_p(0), m_cosTheta(0), m_charge(0),
      m_length(0.0), m_nHits(0), m_nHitsUsed(0),
      m_pdg(0), m_motherPDG(0), m_pTrue(0)
    {
      // set default values for all detectors
      for (int i = 0; i <= Dedx::c_SVD; i++)
        m_dedxAvg[i] = m_dedxAvgTruncated[i] = m_dedxAvgTruncatedErr[i] = 0.0;
 
      // set default values for all particles
      for (unsigned int i = 0; i < Const::ChargedStable::c_SetSize; i++)
        m_vxdLogl[i] = 0.0;
    }
 
    void addHit(int sid, int layer, int adcCount, double dx, double dEdx)
    {
      m_sensorID.push_back(sid);
      m_layer.push_back(layer);
      m_adcCount.push_back(adcCount);
      m_dx.push_back(dx);
      m_dEdx.push_back(dEdx);
    }
 
    void addDedx(int layer, double distance, double dedxValue)
    {
      dedxLayer.push_back(layer);
      dist.push_back(distance);
      dedx.push_back(dedxValue);
      m_length += distance;
    }
 
    double getDedx(Const::EDetector detector) const
    {
      int iDet = (int)(detector - Const::PXD);
      if (iDet < 0 or iDet > Dedx::c_SVD)
        return 0.0;
      return m_dedxAvgTruncated[iDet];
    }
 
    double getDedxError(Const::EDetector detector) const
    {
      int iDet = (int)(detector - Const::PXD);
      if (iDet < 0 or iDet > Dedx::c_SVD)
        return 0.0;
      return m_dedxAvgTruncatedErr[iDet];
    }
 
    double getDedxMean(Const::EDetector detector) const
    {
      int iDet = (int)(detector - Const::PXD);
      if (iDet < 0 or iDet > Dedx::c_SVD)
        return 0.0;
      return m_dedxAvg[iDet];
    }
 
    double eventID() const { return m_eventID; }
    double trackID() const { return m_trackID; }
    double getCosTheta() const { return m_cosTheta; }
 
    double getMomentum() const { return m_p; }
    double getTrueMomentum() const { return m_pTrue; }
    double size() const { return m_nHits; }
    double getNHitsUsed() const { return m_nHitsUsed; }
 
    int getLayer(int i) const { return m_layer[i]; }
    int getSensorID(int i) const { return m_sensorID[i]; }
    int getADCCount(int i) const { return m_adcCount[i]; }
    double getDx(int i) const { return m_dx[i]; }
    double getDedx(int i) const { return m_dEdx[i]; }
 
    std::vector< double > getDedxList() const { return m_dEdx; }
 
  private:
 
    int m_eventID; 
    int m_trackID; 
    // hit level information
    std::vector<int> m_layer;    
    std::vector<int> m_sensorID; 
    std::vector<int> m_adcCount; 
    std::vector<double> m_dx;    
    std::vector<double> m_dEdx;  
    // one entry per layer (just don't mix with the hit arrays)
    std::vector<double> dedx;      
    std::vector<double> dist;      
    std::vector<double> dedxLayer; 
    // track level information
    double m_p;        
    double m_cosTheta; 
    short m_charge;    
    double m_length;   
    short m_nHits;     
    short m_nHitsUsed; 
    double m_pdg;        
    double m_motherPDG; 
    double m_pTrue;     
    double m_dedxAvg[2];               
    double m_dedxAvgTruncated[2];     
    double m_dedxAvgTruncatedErr[2]; 
    double m_vxdLogl[Const::ChargedStable::c_SetSize]; 
    ClassDef(VXDDedxTrack, 2); 
  };
}