CalibLaserTracks.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 TPC_CalibLaserTracks_H_
#define TPC_CalibLaserTracks_H_
 
#include <gsl/span>
#include <string_view>
 
#include "CommonUtils/TreeStreamRedirector.h"
#include "DataFormatsTPC/TrackTPC.h"
#include "DataFormatsTPC/LaserTrack.h"
#include "DataFormatsTPC/LtrCalibData.h"
 
namespace o2::tpc
{
 
using o2::track::TrackPar;
using o2::track::TrackParCov;
 
struct TimePair {
  float x1{0.f};
  float x2{0.f};
  uint64_t time{0};
};
 
class CalibLaserTracks
{
 public:
  static constexpr size_t MinTrackPerSidePerTF = 50;
 
  CalibLaserTracks()
  {
    mLaserTracks.loadTracksFromFile();
    updateParameters();
  }
 
  CalibLaserTracks(const CalibLaserTracks& other) : mTriggerPos{other.mTriggerPos},
                                                    mBz{other.mBz},
                                                    mDriftV{other.mDriftV},
                                                    mZbinWidth{other.mZbinWidth},
                                                    mTFstart{other.mTFstart},
                                                    mTFend{other.mTFend},
                                                    mCalibDataTF{other.mCalibDataTF},
                                                    mCalibData{other.mCalibData},
                                                    mZmatchPairsTFA{other.mZmatchPairsTFA},
                                                    mZmatchPairsTFC{other.mZmatchPairsTFC},
                                                    mZmatchPairsA{other.mZmatchPairsA},
                                                    mZmatchPairsC{other.mZmatchPairsC},
                                                    mWriteDebugTree{other.mWriteDebugTree},
                                                    mFinalized{other.mFinalized}
  {
  }
 
  ~CalibLaserTracks() = default;
 
  void fill(const gsl::span<const TrackTPC> tracks, float tp = 0);
 
  void fill(std::vector<TrackTPC> const& tracks, float tp = 0);
 
  void processTrack(const TrackTPC& track);
 
  int findLaserTrackID(TrackPar track, int side = -1);
 
  static float getPhiNearbyLaserRod(const TrackPar& param, int side);
 
  static bool hasNearbyLaserRod(const TrackPar& param, int side);
 
  void setTriggerPos(int triggerPos) { mTriggerPos = triggerPos; }
 
  void merge(const CalibLaserTracks* other);
 
  void endTF();
 
  void finalize();
 
  void print() const;
 
  bool hasEnoughData(size_t numTFs = 1) const { return mCalibData.processedTFs >= numTFs && mZmatchPairsA.size() > MinTrackPerSidePerTF * numTFs && mZmatchPairsC.size() > MinTrackPerSidePerTF * numTFs; }
 
  size_t getMatchedPairs() const { return getMatchedPairsA() + getMatchedPairsC(); }
 
  size_t getMatchedPairsA() const { return mZmatchPairsA.size(); }
 
  size_t getMatchedPairsC() const { return mZmatchPairsC.size(); }
 
  size_t getMatchedPairsTFA() const { return mZmatchPairsTFA.size(); }
 
  size_t getMatchedPairsTFC() const { return mZmatchPairsTFC.size(); }
 
  void setTFtimes(uint64_t tfStart, uint64_t tfEnd = 0)
  {
    mTFstart = tfStart;
    mTFend = tfEnd;
  }
 
  uint64_t getTFstart() const { return mTFstart; }
  uint64_t getTFend() const { return mTFend; }
 
  void setWriteDebugTree(bool write) { mWriteDebugTree = write; }
  bool getWriteDebugTree() const { return mWriteDebugTree; }
 
  TimePair fit(const std::vector<TimePair>& trackMatches, std::string_view info) const;
 
  void sort(std::vector<TimePair>& trackMatches);
 
  const LtrCalibData& getCalibDataTF() { return mCalibDataTF; }
 
  const LtrCalibData& getCalibData() { return mCalibData; }
 
  void setDebugOutputName(std::string_view name) { mDebugOutputName = name; }
 
  void setVDriftRef(float v) { mDriftV = v; }
 
 private:
  int mTriggerPos{0};                                          
  float mBz{0.5};                                              
  float mDriftV{0};                                            
  float mTOffsetMUS{0};                                        
  float mZbinWidth{0};                                         
  float mAvgTP{0};                                             
  float mAvgDriftV{0};                                         
  uint64_t mTFstart{0};                                        
  uint64_t mTFend{0};                                          
  LtrCalibData mCalibDataTF{};                                 
  LtrCalibData mCalibData{};                                   
  std::vector<TimePair> mZmatchPairsTFA;                       
  std::vector<TimePair> mZmatchPairsTFC;                       
  std::vector<TimePair> mZmatchPairsA;                         
  std::vector<TimePair> mZmatchPairsC;                         
  bool mWriteDebugTree{false};                                 
  bool mFinalized{false};                                      
  std::string mDebugOutputName{"CalibLaserTracks_debug.root"}; 
 
  LaserTrackContainer mLaserTracks;                              
  std::unique_ptr<o2::utils::TreeStreamRedirector> mDebugStream; 
 
  void updateParameters();
 
  void fillCalibData(LtrCalibData& calibData, const std::vector<TimePair>& pairsA, const std::vector<TimePair>& pairsC);
 
  ClassDefNV(CalibLaserTracks, 2);
};
 
} // namespace o2::tpc
#endif