CDCDedxTrack.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 <framework/datastore/RelationsObject.h>
#include <framework/gearbox/Const.h>
 
#include <vector>
 
namespace Belle2 {
  class CDCDedxTrack : public RelationsObject {
    friend class CDCDedxPIDModule;
    friend class CDCDedxScanModule;
    friend class CDCDedxCorrectionModule;
    friend class CDCDedxPIDCreatorModule;
 
  public:

    CDCDedxTrack() :
      RelationsObject(),
      m_cosTheta(0), m_p(0), m_pCDC(0), m_length(0.0), m_injring(-1), m_injtime(-1),
      m_track(0), m_charge(0), m_pdg(-999), m_mcmass(0), m_motherPDG(0), m_pTrue(0), m_cosThetaTrue(0),
      m_scale(0), m_cosCor(0), m_cosEdgeCor(0), m_runGain(0), m_timeGain(0), m_timeReso(0),
      m_lNHitsUsed(0)
    {
      m_simDedx = m_dedxAvg = m_dedxAvgTruncated = m_dedxAvgTruncatedNoSat = m_dedxAvgTruncatedErr = 0.0;
 
      // set default values for all particles
      for (unsigned int i = 0; i < Const::ChargedStable::c_SetSize; i++) {
        m_predmean[i] = 0.0;
        m_predres[i] = 0.0;
        m_cdcChi[i] = -999.;
        m_cdcLogl[i] = 0.0;
      }
    }

    void addDedx(int nhitscombined, int wirelongesthit, int layer, double distance, double dedxValue)
    {
      m_lNHitsCombined.push_back(nhitscombined);
      m_lWireLongestHit.push_back(wirelongesthit);
      m_lLayer.push_back(layer);
      m_lPath.push_back(distance);
      m_lDedx.push_back(dedxValue);
 
      m_length += distance;
    }

    void addHit(int lwire, int wire, int layer, double doca, double docaRS, double enta, double entaRS,
                int adcCount, int adcbaseCount, double dE, double path, double dedx, double cellHeight, double cellHalfWidth,
                int driftT, double driftD, double driftDRes, double wiregain, double twodcor,
                double onedcor, int foundByTrackFinder, double weightPionHypo, double weightKaonHypo, double weightProtHypo)
    {
 
      m_hLWire.push_back(lwire);
      m_hWire.push_back(wire);
      m_hLayer.push_back(layer);
      m_hPath.push_back(path);
      m_hDedx.push_back(dedx);
      m_hADCCount.push_back(adcCount);
      m_hADCBaseCount.push_back(adcbaseCount);
      m_hDoca.push_back(doca);
      m_hDocaRS.push_back(docaRS);
      m_hEnta.push_back(enta);
      m_hEntaRS.push_back(entaRS);
      m_hDriftT.push_back(driftT);
      m_hdE.push_back(dE);
      m_hCellHeight.push_back(cellHeight);
      m_hCellHalfWidth.push_back(cellHalfWidth);
      m_hDriftD.push_back(driftD);
      m_hDriftDRes.push_back(driftDRes);
      m_hWireGain.push_back(wiregain);
      m_hTwodCor.push_back(twodcor);
      m_hOnedCor.push_back(onedcor);
      m_hFoundByTrackFinder.push_back(foundByTrackFinder);
      m_hWeightPionHypo.push_back(weightPionHypo);
      m_hWeightKaonHypo.push_back(weightKaonHypo);
      m_hWeightProtHypo.push_back(weightProtHypo);
    }

    double trackID() const { return m_track; }

    double getPDG() const { return m_pdg; }

    double getDedx() const { return m_dedxAvgTruncated; }

    double getDedxNoSat() const { return m_dedxAvgTruncatedNoSat; }

    double getDedxError() const { return m_dedxAvgTruncatedErr; }

    double getDedxMean() const { return m_dedxAvg; }

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

    double getMomentum() const { return m_pCDC; }

    double getCosTheta() const { return m_cosTheta; }

    int getCharge() const { return m_charge; }

    double getInjectionTime() const { return m_injtime; }

    double getInjectionRing() const { return m_injring; }

    double getLength() const { return m_length; }

    double getCosineCorrection() const { return m_cosCor; }

    double getCosEdgeCorrection() const { return m_cosEdgeCor; }

    double getRunGain() const { return m_runGain; }

    double getScaleFactor() const { return m_scale; }

    double getTimeMean() const { return m_timeGain; }

    double getTimeReso() const { return m_timeReso; }

    double getSimulatedDedx() const { return m_simDedx; }

    void setDedx(double mean) { m_dedxAvgTruncated = mean; }

    void setDedxNoSat(double mean) { m_dedxAvgTruncatedNoSat = mean; }

    void setDedxError(double error) { m_dedxAvgTruncatedErr = error; }

    void setDedxMean(double mean) { m_dedxAvg = mean; }

    void setSimulatedDedx(double dedx) { m_simDedx = dedx; }
 
 
    // Layer level
    int getNLayerHits() const { return m_lDedx.size(); }

    double getNLayerHitsUsed() const { return m_lNHitsUsed; }

    int getNHitsCombined(int i) const { return m_lNHitsCombined[i]; }

    int getWireLongestHit(int i) const { return m_lWireLongestHit[i]; }

    int getLayer(int i) const { return m_lLayer[i]; }

    double getLayerPath(int i) const { return m_lPath[i]; }

    double getLayerDedx(int i) const { return m_lDedx[i]; }

    void setLayerDedx(int i, double dedx) { m_lDedx[i] = dedx; }
 
 
    // Hit level
    int size() const { return m_hDedx.size(); }

    int getWireInLayer(int i) const { return m_hLWire[i]; }

    int getWire(int i) const { return m_hWire[i]; }

    int getHitLayer(int i) const { return m_hLayer[i]; }

    double getPath(int i) const { return m_hPath[i]; }

    double getDedx(int i) const { return m_hDedx[i]; }

    int getADCCount(int i) const { return m_hADCCount[i]; }

    int getADCBaseCount(int i) const { return m_hADCBaseCount[i]; }

    double getNonLADCCorrection(int i) const { return (m_hADCBaseCount[i] * 1.0) / m_hADCCount[i]; }

    double getDoca(int i) const { return m_hDoca[i]; }

    double getEnta(int i) const { return m_hEnta[i]; }

    double getDocaRS(int i) const { return m_hDocaRS[i]; }

    double getEntaRS(int i) const { return m_hEntaRS[i]; }

    int getDriftT(int i) const { return m_hDriftT[i]; }

    double getDE(int i) const { return m_hdE[i]; }

    double getCellHeight(int i) const { return m_hCellHeight[i]; }

    double getCellHalfWidth(int i) const { return m_hCellHalfWidth[i]; }

    double getDriftD(int i) const { return m_hDriftD[i]; }

    double getDriftDRes(int i) const { return m_hDriftDRes[i]; }

    double getWireGain(int i) const { return m_hWireGain[i]; }

    double getTwoDCorrection(int i) const { return m_hTwodCor[i]; }

    double getOneDCorrection(int i) const { return m_hOnedCor[i]; }

    int getFoundByTrackFinder(int i) const { return m_hFoundByTrackFinder[i]; }

    double getWeightPionHypo(int i) const { return m_hWeightPionHypo[i]; }

    double getWeightKaonHypo(int i) const { return m_hWeightKaonHypo[i]; }

    double getWeightProtonHypo(int i) const { return m_hWeightProtHypo[i]; }

    double getChi(int i) const { return m_cdcChi[i]; }

    double getPmean(int i) const { return m_predmean[i]; }

    double getPreso(int i) const { return m_predres[i]; }

    void setDedx(int i, double dedx) { m_hDedx[i] = dedx; }
 
  private:
 
    // hit level information
    std::vector<int> m_hLWire;     
    std::vector<int> m_hWire;     
    std::vector<int> m_hLayer;    
    std::vector<double> m_hPath;    
    std::vector<double> m_hDedx;  
    std::vector<int> m_hADCCount; 
    std::vector<int> m_hADCBaseCount; 
    std::vector<double> m_hDoca;  
    std::vector<double> m_hEnta;  
    std::vector<double> m_hDocaRS;
    std::vector<double> m_hEntaRS;
    std::vector<double> m_hdE;    
    std::vector<int> m_hDriftT;       
    std::vector<double> m_hDriftD;    
    std::vector<double> m_hDriftDRes; 
    std::vector<int> m_hFoundByTrackFinder; 
    std::vector<double> m_hWeightPionHypo;  
    std::vector<double> m_hWeightKaonHypo; 
    std::vector<double> m_hWeightProtHypo; 
 
    std::vector<double> m_hCellHeight;    
    std::vector<double> m_hCellHalfWidth; 
 
    // track level information
    double m_cosTheta; 
    double m_p;        
    double m_pCDC;    
    double m_length;   
    double m_injring; 
    double m_injtime;  
    int m_track; 
    int m_charge;    
 
    // dE/dx simulation
    double m_pdg;        
    double m_mcmass;     
    double m_motherPDG; 
    double m_pTrue;     
    double m_cosThetaTrue;     
    double m_simDedx;    
 
    // calibration constants
    double m_predmean[Const::ChargedStable::c_SetSize]; 
    double m_predres[Const::ChargedStable::c_SetSize];  
    std::vector<double> m_hWireGain; 
    std::vector<double> m_hTwodCor;  
    std::vector<double> m_hOnedCor;  
 
    double m_scale; 
    double m_cosCor;  
    double m_cosEdgeCor;  
    double m_runGain; 
    double m_timeGain; 
    double m_timeReso; 
 
    // track level dE/dx measurements
    double m_cdcChi[Const::ChargedStable::c_SetSize];  
    double m_cdcLogl[Const::ChargedStable::c_SetSize]; 
    double m_dedxAvg;             
    double m_dedxAvgTruncated;    
    double m_dedxAvgTruncatedNoSat;    
    double m_dedxAvgTruncatedErr; 
 
 
    // layer level information (just don't mix with the hit arrays)
    std::vector<int> m_lNHitsCombined; 
    std::vector<int> m_lWireLongestHit; 
    std::vector<int> m_lLayer; 
    std::vector<double> m_lPath;   
    std::vector<double> m_lDedx;   
    int m_lNHitsUsed; 
 
    ClassDef(CDCDedxTrack, 18); 
  };

}