Tracking.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef O2_TRD_TRACKINGQC_H
#define O2_TRD_TRACKINGQC_H
 
#include "DataFormatsTRD/TrackTRD.h"
#include "DataFormatsTRD/Tracklet64.h"
#include "TRDBase/PadCalibrationsAliases.h"
#include "DataFormatsTRD/CalibratedTracklet.h"
#include "DataFormatsTRD/Constants.h"
#include "ReconstructionDataFormats/TrackTPCITS.h"
#include "ReconstructionDataFormats/GlobalTrackID.h"
#include "DataFormatsTRD/TrackTriggerRecord.h"
#include "DataFormatsTPC/TrackTPC.h"
#include "DetectorsBase/Propagator.h"
#include "GPUTRDRecoParam.h"
 
#include "Rtypes.h"
#include "TH1.h"
 
#include <gsl/span>
#include <bitset>
 
using GTrackID = o2::dataformats::GlobalTrackID;
 
namespace o2
{
 
namespace globaltracking
{
class RecoContainer;
}
 
namespace trd
{
 
struct TrackQC {
 
  GTrackID refGlobalTrackId;         
  TrackTRD trackTRD;                 
  o2::track::TrackParCov trackSeed;  
  float dEdxTotTPC;                  
 
  std::array<o2::track::TrackPar, constants::NLAYER> trackProp{}; 
  std::array<Tracklet64, constants::NLAYER> trklt64{};            
  std::array<CalibratedTracklet, constants::NLAYER> trkltCalib{}; 
 
  std::array<float, constants::NLAYER> trackletY{};            
  std::array<float, constants::NLAYER> trackletZ{};            
  std::array<float, constants::NLAYER> trackletChi2{};         
  std::array<std::array<float, constants::NCHARGES>, constants::NLAYER> trackletCorCharges{}; 
 
  ClassDefNV(TrackQC, 6);
};
 
class Tracking
{
  using MatCorrType = o2::base::Propagator::MatCorrType;
 
 public:
  Tracking() = default;
  Tracking(const Tracking&) = delete;
  ~Tracking() = default;
 
  void init();
 
  void setInput(const o2::globaltracking::RecoContainer& input);
 
  void setApplyShift(bool f) { mApplyShift = f; }
 
  void run();
 
  void reset() { mTrackQC.clear(); }
 
  void checkTrack(const TrackTRD& trk, bool isTPCTRD);
 
  void disablePID() { mPID = false; }
 
  // Make output accessible to DPL processor
  std::vector<TrackQC>& getTrackQC() { return mTrackQC; }
 
  // Set the local gain factors with values from the ccdb
  void setLocalGainFactors(const o2::trd::LocalGainFactor& localGain)
  {
    mLocalGain = localGain;
  }
 
  // quantities necessary for pile-up correction
  void setTriggeredBCFT0(std::vector<int> t) { mTriggeredBCFT0 = t; }
  void setFirstOrbit(uint32_t o) { mFirstOrbit = o; }
 
 private:
  float mMaxSnp{o2::base::Propagator::MAX_SIN_PHI};  
  float mMaxStep{o2::base::Propagator::MAX_STEP};    
  MatCorrType mMatCorr{MatCorrType::USEMatCorrNONE}; 
  o2::gpu::GPUTRDRecoParam mRecoParam;               
  bool mPID{true};                                   
  bool mApplyShift{true};
 
  // QA results
  std::vector<TrackQC> mTrackQC;
 
  // input from DPL
  gsl::span<const o2::dataformats::TrackTPCITS> mTracksITSTPC;       
  gsl::span<const o2::tpc::TrackTPC> mTracksTPC;                     
  gsl::span<const TrackTRD> mTracksITSTPCTRD;                        
  gsl::span<const TrackTRD> mTracksTPCTRD;                           
  gsl::span<const TrackTriggerRecord> mTrackTriggerRecordsITSTPCTRD; 
  gsl::span<const TrackTriggerRecord> mTrackTriggerRecordsTPCTRD;    
  gsl::span<const Tracklet64> mTrackletsRaw;                         
  gsl::span<const CalibratedTracklet> mTrackletsCalib;               
 
  // quantities necessary for pile-up correction
  std::vector<int> mTriggeredBCFT0; 
  int mCurrentTriggerRecord;
  uint32_t mFirstOrbit;
  int mCurrentTrackId;
 
  // corrections from ccdb, some need to be loaded only once hence an init flag
  o2::trd::LocalGainFactor mLocalGain; 
 
  ClassDefNV(Tracking, 2);
};
 
} // namespace trd
 
namespace framework
{
template <typename T>
struct is_messageable;
template <>
struct is_messageable<o2::trd::TrackQC> : std::true_type {
};
} // namespace framework
 
} // namespace o2
 
#endif // O2_TRD_TRACKINGQC_H