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>
#include <TH2F.h>
 
namespace Belle2 {

  class VXDDedxTrack : public RelationsObject {
    friend class VXDDedxPIDModule;
 
  public:

    VXDDedxTrack() = default;

    void addHit(int sid, int layer, int adcCount, double dx, double dEdx);

    void addDedx(int layer, double distance, double dedxValue);

    double getDedx(Const::EDetector detector) const;

    double getDedxError(Const::EDetector detector) const;

    double getDedxMean(Const::EDetector detector) const;

    int eventID() const { return m_eventID; }

    int trackID() const { return m_trackID; }

    double getCosTheta() const { return m_cosTheta; }

    double getMomentum() const { return m_p; }

    double getTrueMomentum() const { return m_pTrue; }

    int size() const { return m_nHits; }

    int 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 getDedxOfHit(int i) const { return m_dEdx[i]; }

    const std::vector<double>& getDedxList() const { return m_dEdx; }

    void clearLogLikelihoods();

    void addLogLikelihoods(const std::vector<const TH2F*>& PDFs, Dedx::Detector detector, bool truncated);

    bool areLogLikelihoodsAvailable() const {return m_numAdded > 0;}

    const double* getLogLikelihoods() const {return m_vxdLogl;}
 
  private:

    void addLogLikelihoods(const std::vector<const TH2F*>& PDFs, double dedxValue, double minPDFValue);
 
    // 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; 
 
    double m_vxdLogl[Const::ChargedStable::c_SetSize] = {0}; 
 
    // dEdx information
    double m_dedxAvg[2] = {0};            
    double m_dedxAvgTruncated[2] = {0};   
    double m_dedxAvgTruncatedErr[2] = {0}; 
 
    // track level information
    double m_p = 0;        
    double m_cosTheta = 0; 
    double m_length = 0;   
    short m_charge = 0;    
 
    // MC information
    double m_pdg = 0;       
    double m_motherPDG = 0; 
    double m_pTrue = 0;     
 
    int m_numAdded = 0; 
    int m_eventID = 0; 
    int m_trackID = 0; 
    short m_nHits = 0;     
    short m_nHitsUsed = 0; 
 
 
    ClassDef(VXDDedxTrack, 4); 
  };

}