TrackInterpolation.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 ALICEO2_TPC_TRACKINTERPOLATION_H_
#define ALICEO2_TPC_TRACKINTERPOLATION_H_
 
#include <gsl/span>
#include "CommonDataFormat/EvIndex.h"
#include "CommonDataFormat/RangeReference.h"
#include "ReconstructionDataFormats/Track.h"
#include "ReconstructionDataFormats/TrackTPCITS.h"
#include "ReconstructionDataFormats/MatchInfoTOF.h"
#include "ReconstructionDataFormats/GlobalTrackID.h"
#include "DataFormatsITSMFT/Cluster.h"
#include "DataFormatsITSMFT/TrkClusRef.h"
#include "DataFormatsITSMFT/TopologyDictionary.h"
#include "DataFormatsITS/TrackITS.h"
#include "DataFormatsTPC/TrackTPC.h"
#include "DataFormatsTPC/Constants.h"
#include "DataFormatsTOF/Cluster.h"
#include "DataFormatsTRD/TrackTRD.h"
#include "DataFormatsTRD/Tracklet64.h"
#include "DataFormatsTRD/CalibratedTracklet.h"
#include "SpacePoints/SpacePointsCalibParam.h"
#include "SpacePoints/SpacePointsCalibConfParam.h"
#include "TPCReconstruction/TPCFastTransformHelperO2.h"
#include "DetectorsBase/Propagator.h"
#include "DataFormatsGlobalTracking/RecoContainer.h"
#include "TRDBase/RecoParam.h"
#include "TRDBase/Geometry.h"
 
class TTree;
 
namespace o2
{
 
namespace tpc
{
class VDriftCorrFact;
 
struct TPCClusterResiduals {
  float dy{};           
  float dz{};           
  float y{};            
  float z{};            
  float snp{};          
  unsigned char sec{};  
  unsigned char dRow{}; 
  ClassDefNV(TPCClusterResiduals, 4);
};
 
struct UnbinnedResid {
  UnbinnedResid() = default;
  UnbinnedResid(float dyIn, float dzIn, float tgSlpIn, float yIn, float zIn, unsigned char rowIn, unsigned char secIn, short chanIn = -1) : dy(static_cast<short>(dyIn * 0x7fff / param::MaxResid)),
                                                                                                                                            dz(static_cast<short>(dzIn * 0x7fff / param::MaxResid)),
                                                                                                                                            tgSlp(static_cast<short>(tgSlpIn * 0x7fff / param::MaxTgSlp)),
                                                                                                                                            y(static_cast<short>(yIn * 0x7fff / param::MaxY)),
                                                                                                                                            z(static_cast<short>(zIn * 0x7fff / param::MaxZ)),
                                                                                                                                            row(rowIn),
                                                                                                                                            sec(secIn),
                                                                                                                                            channel(chanIn) {}
  short dy{0};          
  short dz{0};          
  short tgSlp{0};       
  short y{0};           
  short z{0};           
  unsigned char row{0}; 
  unsigned char sec{0}; 
  short channel{-1};    
 
  bool isTPC() const { return row < constants::MAXGLOBALPADROW; }
  bool isTRD() const { return row >= 160 && row < 166; }
  bool isTOF() const { return row == 170; }
  bool isITS() const { return row >= 180; }
  int getDetID() const { return isTPC() ? 1 : (isITS() ? 0 : (isTRD() ? 2 : (isTOF() ? 3 : -1))); }
  int getITSLayer() const { return row - 180; }
  int getTRDLayer() const { return row - 170; }
  float getAlpha() const;
  float getX() const;
 
  static void init(long timestamp = -1);
  static void checkInitDone();
  static bool gInitDone;
 
  ClassDefNV(UnbinnedResid, 2);
};
 
struct TrackDataCompact {
  TrackDataCompact() = default;
  TrackDataCompact(uint32_t idx, uint8_t nRes, uint8_t source, uint8_t nextraRes = 0) : idxFirstResidual(idx), nResiduals(nRes), sourceId(source), nExtDetResid(nextraRes) {}
  uint32_t idxFirstResidual; 
  uint8_t nResiduals;        
  uint8_t nExtDetResid = 0;  
  uint8_t sourceId;          
  ClassDefNV(TrackDataCompact, 2);
};
 
// TODO add to UnbinnedResid::sec flag if cluster was used or not
// TODO add to TrackDataCompact::sourceId flag if track was used or not (if possible)
 
struct TrackDataExtended {
  o2::dataformats::GlobalTrackID gid{};              
  o2::its::TrackITS trkITS{};                        
  o2::tpc::TrackTPC trkTPC{};                        
  o2::trd::TrackTRD trkTRD{};                        
  o2::track::TrackPar trkOuter{};                    
  o2::dataformats::MatchInfoTOF matchTOF{};          
  std::vector<o2::BaseCluster<float>> clsITS{};      
  std::vector<o2::trd::Tracklet64> trkltTRD{};       
  std::vector<o2::trd::CalibratedTracklet> clsTRD{}; 
  o2::tof::Cluster clsTOF{};                         
  o2::dataformats::RangeReference<> clIdx{};         
  uint8_t nExtDetResid = 0;                          
  ClassDefNV(TrackDataExtended, 3);
};
 
struct TrackData {
  o2::dataformats::GlobalTrackID gid{};      
  o2::track::TrackPar par{};                 
  float dEdxTPC{};                           
  float chi2TPC{};                           
  float chi2ITS{};                           
  float chi2TRD{};                           
  float deltaTOF{};                          
 
  unsigned short nClsTPC{};                  
  unsigned short nClsITS{};                  
  unsigned short nTrkltsTRD{};               
  unsigned short clAvailTOF{};               
  uint8_t nExtDetResid = 0;                  
  o2::dataformats::RangeReference<> clIdx{}; 
 
  float getT0Error() const { return float(clAvailTOF); }
  bool isTOFAvail() const { return clAvailTOF != 0; }
 
  ClassDefNV(TrackData, 8);
};
 
class TrackInterpolation
{
 public:
  using MatCorrType = o2::base::Propagator::MatCorrType;
 
  TrackInterpolation() = default;
 
  // since this class has pointer members, we should explicitly delete copy and assignment operators
  TrackInterpolation(const TrackInterpolation&) = delete;
  TrackInterpolation& operator=(const TrackInterpolation&) = delete;
 
  enum {
    ExtOut = 0, 
    ExtIn,      
    Int,        
    NIndices    
  };
 
  struct CacheStruct {
    std::array<float, NIndices> y{};
    std::array<float, NIndices> z{};
    std::array<float, NIndices> sy2{};
    std::array<float, NIndices> szy{};
    std::array<float, NIndices> sz2{};
    std::array<float, NIndices> snp{};
    float clY{0.f};
    float clZ{0.f};
    float clAngle{0.f};
    unsigned short clAvailable{0};
    unsigned char clSec{0};
  };
 
  struct TrackParams {
    TrackParams() = default;
    float qpt{0.f};
    float tgl{0.f};
    std::array<float, param::NPadRows> zTrk{};
    std::array<float, param::NPadRows> xTrk{};
    std::array<float, param::NPadRows> dy{};
    std::array<float, param::NPadRows> dz{};
    std::array<float, param::NPadRows> tglArr{};
    std::bitset<param::NPadRows> flagRej{};
  };
 
  // -------------------------------------- processing functions --------------------------------------------------
 
  void init(o2::dataformats::GlobalTrackID::mask_t src, o2::dataformats::GlobalTrackID::mask_t srcMap);
 
  bool isInputTrackAccepted(const o2::dataformats::GlobalTrackID& gid, const o2::globaltracking::RecoContainer::GlobalIDSet& gidTable, const o2::dataformats::PrimaryVertex& pv) const;
 
  o2::dataformats::GlobalTrackID::Source findValidSource(const o2::dataformats::GlobalTrackID::mask_t mask, const o2::dataformats::GlobalTrackID::Source src) const;
 
  void prepareInputTrackSample(const o2::globaltracking::RecoContainer& inp);
 
  bool isTrackSelected(const o2::track::TrackParCov& trk) const;
 
  void process();
 
  void extrapolateTrack(int iSeed);
 
  void interpolateTrack(int iSeed);
 
  void reset();
 
  // -------------------------------------- outlier rejection --------------------------------------------------
 
  bool validateTrack(const TrackData& trk, TrackParams& params, const std::vector<TPCClusterResiduals>& clsRes) const;
 
  bool outlierFiltering(const TrackData& trk, TrackParams& params, const std::vector<TPCClusterResiduals>& clsRes) const;
 
  float checkResiduals(const TrackData& trk, TrackParams& params, const std::vector<TPCClusterResiduals>& clsRes) const;
 
  bool compareToHelix(const TrackData& trk, TrackParams& params, const std::vector<TPCClusterResiduals>& clsRes) const;
 
  void diffToLocLine(const int np, int idxOffset, const std::array<float, param::NPadRows>& x, const std::array<float, param::NPadRows>& y, std::array<float, param::NPadRows>& diffY) const;
 
  void diffToMA(const int np, const std::array<float, param::NPadRows>& y, std::array<float, param::NPadRows>& diffMA) const;
 
  // -------------------------------------- settings --------------------------------------------------
  void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
 
  void setMatCorr(MatCorrType matCorr) { mMatCorr = matCorr; }
 
  void setMaxTracksPerTF(int n) { mMaxTracksPerTF = n; }
 
  void setAddTracksForMapPerTF(int n) { mAddTracksForMapPerTF = n; }
 
  void setDumpTrackPoints() { mDumpTrackPoints = true; }
 
  void setITSClusterDictionary(const o2::itsmft::TopologyDictionary* dict) { mITSDict = dict; }
 
  void setProcessSeeds() { mProcessSeeds = true; }
 
  void setProcessITSTPConly() { mProcessITSTPConly = true; }
 
  void setSqrtS(float s) { mSqrtS = s; }
 
  void setExtDetResid(bool v) { mExtDetResid = v; }
 
  int processTRDLayer(const o2::trd::TrackTRD& trkTRD, int iLayer, o2::track::TrackParCov& trkWork, std::array<float, 2>* trkltTRDYZ = nullptr, std::array<float, 3>* trkltTRDCov = nullptr);
 
  // --------------------------------- output ---------------------------------------------
  std::vector<UnbinnedResid>& getClusterResiduals() { return mClRes; }
  std::vector<TrackDataCompact>& getTrackDataCompact() { return mTrackDataCompact; }
  std::vector<TrackDataExtended>& getTrackDataExtended() { return mTrackDataExtended; }
  std::vector<TrackData>& getReferenceTracks() { return mTrackData; }
  std::vector<TPCClusterResiduals>& getClusterResidualsUnfiltered() { return mClResUnfiltered; }
  std::vector<TrackData>& getReferenceTracksUnfiltered() { return mTrackDataUnfiltered; }
 
 private:
  static constexpr float sFloatEps{1.e-7f}; 
  // parameters + settings
  const SpacePointsCalibConfParam* mParams = nullptr;
  float mTPCTimeBinMUS{.2f};                                    
  float mTPCVDriftRef = -1.;                                    
  float mTPCDriftTimeOffsetRef = 0.;                            
  float mSqrtS{13600.f};                                        
  MatCorrType mMatCorr{MatCorrType::USEMatCorrNONE};            
  int mMaxTracksPerTF{-1};                                      
  int mAddTracksForMapPerTF{0};                                 
  bool mDumpTrackPoints{false};                                 
  bool mExtDetResid{true};                                      
  bool mProcessSeeds{false};                                    
  bool mProcessITSTPConly{false};                               
  o2::dataformats::GlobalTrackID::mask_t mSourcesConfigured;    
  o2::dataformats::GlobalTrackID::mask_t mSourcesConfiguredMap; 
  bool mSingleSourcesConfigured{true};                          
 
  // input
  const o2::globaltracking::RecoContainer* mRecoCont = nullptr;             
  std::vector<o2::dataformats::GlobalTrackID> mGIDs{};                      
  std::vector<o2::globaltracking::RecoContainer::GlobalIDSet> mGIDtables{}; 
  std::vector<float> mTrackTimes{};                                         
  std::vector<o2::track::TrackParCov> mSeeds{};                             
  std::vector<int> mParentID{};                                             
  std::map<int, int> mTrackTypes;                                           
  std::array<std::vector<uint32_t>, 4> mTrackIndices;                       
  gsl::span<const TPCClRefElem> mTPCTracksClusIdx;                          
  const ClusterNativeAccess* mTPCClusterIdxStruct = nullptr;                
  // ITS specific input only needed for debugging
  gsl::span<const int> mITSTrackClusIdx;                    
  std::vector<o2::BaseCluster<float>> mITSClustersArray;    
  const o2::itsmft::TopologyDictionary* mITSDict = nullptr; 
 
  // output
  std::vector<TrackData> mTrackData{};                 
  std::vector<TrackDataCompact> mTrackDataCompact{};   
  std::vector<TrackDataExtended> mTrackDataExtended{}; 
  std::vector<UnbinnedResid> mClRes{};                 
  std::vector<TrackData> mTrackDataUnfiltered{};       
  std::vector<TPCClusterResiduals> mClResUnfiltered{}; 
 
  // cache
  std::array<CacheStruct, constants::MAXGLOBALPADROW> mCache{{}}; 
  std::vector<o2::dataformats::GlobalTrackID> mGIDsSuccess;       
 
  // helpers
  o2::trd::RecoParam mRecoParam;                      
  o2::trd::Geometry* mGeoTRD;                         
  std::unique_ptr<TPCFastTransform> mFastTransform{}; 
  float mBz;                                          
  bool mInitDone{false};                              
  size_t mRejectedResiduals{};                        
 
  ClassDefNV(TrackInterpolation, 1);
};
 
} // namespace tpc
 
} // namespace o2
 
#endif