MatchCosmics.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_MATCH_COSMICS
#define ALICEO2_MATCH_COSMICS
 
#include <Rtypes.h>
#include <array>
#include <cstdint>
#include <MathUtils/Primitive2D.h>
#include "ReconstructionDataFormats/TrackCosmics.h"
#include "ReconstructionDataFormats/GlobalTrackID.h"
#include "ReconstructionDataFormats/GlobalTrackAccessor.h"
#include "ReconstructionDataFormats/BaseCluster.h"
#include "DataFormatsITSMFT/TopologyDictionary.h"
#include "DataFormatsITSMFT/ClustersPerLayer.h"
#include "SimulationDataFormat/MCCompLabel.h"
#include "GlobalTracking/MatchCosmicsParams.h"
#include "CommonUtils/TreeStreamRedirector.h"
 
#define _ALLOW_DEBUG_TREES_COSM // to allow debug and control tree output
 
namespace o2
{
namespace tpc
{
class VDriftCorrFact;
}
namespace gpu
{
class TPCFastTransformPOD;
class GPUO2InterfaceRefit;
} // namespace gpu
namespace globaltracking
{
 
namespace o2d = o2::dataformats;
 
using GTrackID = o2d::GlobalTrackID;
using TBracket = o2::math_utils::Bracketf_t;
class RecoContainer;
 
class MatchCosmics
{
 public:
  static constexpr int Zero = 0;
  static constexpr int MinusOne = -1;
  static constexpr int MinusTen = -10;
  static constexpr int Validated = -2;
  static constexpr int Reject = MinusTen;
  enum RejFlag {
    Accept = 0,
    RejY,
    RejZ,
    RejSnp,
    RejTgl,
    RejQ2Pt,
    RejTime,
    RejProp,
    RejChi2,
    RejOther,
    RejSameHalf,
    RejNoTOF 
  };
 
  using InfoAccessor = o2d::AbstractRefAccessor<int, GTrackID::NSources>; // there is no unique <Info> structure, so the default return type is dummy (int)
 
  struct MatchRecord {
    int id0 = MinusOne;  
    int id1 = MinusOne;  
    float chi2 = -1.f;   
    int next = MinusOne; 
    float tCommon = 0.f; 
    float tCommonErr = -1.f;      
    float tofScore = -1.f;        
    float tCommonNoTOF = 0.f;     
    float tCommonErrNoTOF = -1.f; 
  };
 
  struct TOFCandidate { 
    int index = -1;     
    double timeNS = 0.; 
    float dy = 0.f;     
    float dz = 0.f;     
    float gx = 0.f;     
    float gy = 0.f;
    float gz = 0.f;
  };
 
  struct TrackSeed : public o2::track::TrackParCov {
    TBracket tBracket;      
    GTrackID origID;        
    int matchID = MinusOne; 
    short vtIDMin = -1;     
    short vtIDMax = -1;     
    float tRef = 0.f;       
    int8_t tpcSide = 0;     
    std::array<float, 3> xyzRef{}; 
    bool nearBeam = false;         
  };
  void setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph);
  void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
  void setITSROFrameLengthMUS(float fums) { mITSROFrameLengthMUS = fums; }
  void setITSDict(const o2::itsmft::TopologyDictionary* dict) { mITSDict = dict; }
  void process(const o2::globaltracking::RecoContainer& data);
  void setUseMC(bool mc) { mUseMC = mc; }
  void setUsePVInfo(bool v) { mUsePVInfo = v; }
  void setSeedSources(GTrackID::mask_t src) { mSeedSources = src; }     
  void setPVVetoSources(GTrackID::mask_t src) { mPVVetoSources = src; } 
  void init();
  void end();
 
  auto getCosmicTracks() const { return mCosmicTracks; }
  auto getCosmicTracksLbl() const { return mCosmicTracksLbl; }
 
#ifdef _ALLOW_DEBUG_TREES_COSM
  enum DebugFlagTypes : UInt_t {
    MatchTreeAll = 0x1,         
    MatchTreeAccOnly = 0x1 << 1 
  };
  bool isDebugFlag(UInt_t flags) const { return mDBGFlags & flags; }
 
  UInt_t getDebugFlags() const { return mDBGFlags; }
 
  void setDebugFlag(UInt_t flag, bool on = true);
 
  void setDebugTreeFileName(std::string name)
  {
    if (!name.empty()) {
      mDebugTreeFileName = name;
    }
  }
 
  const std::string& getDebugTreeFileName() const { return mDebugTreeFileName; }
#endif
 
 private:
  void updateTimeDependentParams();
  RejFlag checkPair(int i, int j);
  bool refitSeedAtTime(const TrackSeed& seed, float timeMUS, TrackSeed& out);
  void registerMatch(int i, int j, float chi2, float tCommon = 0.f, float tCommonErr = -1.f, float tofScore = -1.f, float tCommonNoTOF = 0.f, float tCommonErrNoTOF = -1.f);
  void prepareTOFClusters(const o2::globaltracking::RecoContainer& data);
  const std::vector<TOFCandidate>& getTOFCandidates(int iseed);
  float findTOFFlightPair(int i, int j, float tMinMUS, float tMaxMUS, float& tofTimeMUS);
  void suppressMatch(int partner0, int partner1);
  void createSeeds(const o2::globaltracking::RecoContainer& data);
  bool validateMatch(int partner0);
  void selectWinners();
  void refitWinners(const o2::globaltracking::RecoContainer& data);
  o2::itsmft::ClustersPerLayer<o2::BaseCluster<float>> prepareITSClusters(const o2::globaltracking::RecoContainer& data) const;
 
  std::vector<TrackSeed> mSeeds;
  std::vector<MatchRecord> mRecords;
  std::vector<int> mWinners;
  const o2::itsmft::TopologyDictionary* mITSDict = nullptr; // cluster patterns dictionary
  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps = nullptr;
  int mTFCount = 0;
  float mTPCVDriftRef = -1.;      
  float mTPCVDriftCorrFact = 1.;  
  float mTPCVDrift = -1.;         
  float mTPCDriftTimeOffset = 0.; 
  float mTPCTBinMUS = 0.;         
  float mBz = 0;                  
  bool mFieldON = true;
  bool mUsePVInfo = false;
  bool mUseMC = true;
  GTrackID::mask_t mSeedSources{GTrackID::MASK_ALL};    
  GTrackID::mask_t mPVVetoSources{GTrackID::MASK_NONE}; 
  float mITSROFrameLengthMUS = 0.;
  float mQ2PtCutoff = 1e9;
  float mQ2PtCutoffOppositeSides = 1e9;
  const MatchCosmicsParams* mMatchParams = nullptr;
  const o2::globaltracking::RecoContainer* mRecoData = nullptr; 
  o2::gpu::GPUO2InterfaceRefit* mTPCRefitter = nullptr;         
  size_t mNRefitsCommonTime = 0;                                
  std::vector<int> mTOFClusterOrder;                            
  std::vector<float> mTOFClusterTimeMUS;                        
  std::vector<std::vector<TOFCandidate>> mSeedTOFCandidates;    
  std::vector<bool> mSeedTOFDone;                               
  size_t mNTOFConfirmed = 0;                                    
  size_t mNTOFFallbacks = 0;                                    
  size_t mNSeedsNearBeam = 0;                                   
  size_t mNNearBeamConfirmed = 0;                               
  size_t mNSeedsPVContributors = 0;                             
 
  std::vector<o2d::TrackCosmics> mCosmicTracks;
  std::vector<o2::MCCompLabel> mCosmicTracksLbl;
 
#ifdef _ALLOW_DEBUG_TREES_COSM
  std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
  UInt_t mDBGFlags = 0;
  std::string mDebugTreeFileName = "dbg_cosmics_match.root"; 
#endif
 
  ClassDefNV(MatchCosmics, 1);
};
 
} // namespace globaltracking
} // namespace o2
 
#endif