ResidualAggregator.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_TPC_RESIDUALAGGREGATOR_H
#define O2_TPC_RESIDUALAGGREGATOR_H
 
#include "DetectorsCalibration/TimeSlotCalibration.h"
#include "DetectorsCalibration/TimeSlot.h"
#include "DataFormatsCTP/LumiInfo.h"
#include "DataFormatsTPC/Defs.h"
#include "SpacePoints/TrackResiduals.h"
#include "CommonUtils/StringUtils.h"
#include "Framework/DataTakingContext.h"
#include <vector>
#include <array>
#include <string>
 
#include "TFile.h"
#include "TTree.h"
 
namespace o2
{
namespace tpc
{
 
struct ResidualsContainer {
 
  using TFType = o2::calibration::TFType;
 
  ResidualsContainer() = default;
  ResidualsContainer(ResidualsContainer&& rhs);
  ResidualsContainer(const ResidualsContainer&); // no copying allowed, this will yield an error message
  ResidualsContainer& operator=(const ResidualsContainer& src) = delete;
  ~ResidualsContainer();
 
  void init(const TrackResiduals* residualsEngine, std::string outputDir, bool wFile, bool wBinnedResid, bool wUnbinnedResid, bool wTrackData, int autosave, int compression, long orbitResetTime);
  void fillStatisticsBranches();
  uint64_t getNEntries() const { return nResidualsTotal; }
 
  void fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const UnbinnedResid> resid, const gsl::span<const o2::tpc::TrackDataCompact> trkRefsIn, const gsl::span<const o2::tpc::TrackData>* trkDataIn, const o2::ctp::LumiInfo* lumiInput);
  void merge(ResidualsContainer* prev);
  void print();
  void writeToFile(bool closeFileAfterwards);
 
  const TrackResiduals* trackResiduals{nullptr};
  std::array<std::vector<TrackResiduals::LocalResid>, SECTORSPERSIDE * SIDES> residuals{}; 
  std::array<std::vector<TrackResiduals::LocalResid>*, SECTORSPERSIDE * SIDES> residualsPtr{};
  std::array<std::vector<TrackResiduals::VoxStats>, SECTORSPERSIDE * SIDES> stats{}; 
  std::array<std::vector<TrackResiduals::VoxStats>*, SECTORSPERSIDE * SIDES> statsPtr{};
  std::vector<uint32_t> tfOrbits, *tfOrbitsPtr{&tfOrbits};                   
  std::vector<uint32_t> sumBinnedResid, *sumBinnedResidPtr{&sumBinnedResid}; 
  std::vector<uint32_t> sumUnbinnedResid, *sumUnbinnedResidPtr{&sumUnbinnedResid}; 
  std::vector<o2::ctp::LumiInfo> lumi, *lumiPtr{&lumi};                      
  std::vector<UnbinnedResid> unbinnedRes, *unbinnedResPtr{&unbinnedRes};     
  std::vector<TrackData> trkData, *trkDataPtr{&trkData};                     
  std::vector<TrackDataCompact> trackInfo, *trackInfoPtr{&trackInfo};        
  o2::ctp::LumiInfo lumiTF;                                                  
  uint64_t timeMS;                                                           
 
  std::string fileName{"o2tpc_residuals"};
  std::unique_ptr<TFile> fileOut{nullptr};
  std::unique_ptr<TTree> treeOutResidualsUnbinned{nullptr};
  std::unique_ptr<TTree> treeOutTrackData{nullptr};
  std::unique_ptr<TTree> treeOutResiduals{nullptr};
  std::unique_ptr<TTree> treeOutStats{nullptr};
  std::unique_ptr<TTree> treeOutRecords{nullptr};
 
  // settings
  bool writeToRootFile{true};         
  bool writeBinnedResid{false};       
  bool writeUnbinnedResiduals{false}; 
  bool writeTrackData{false};         
  int autosaveInterval{0};            
 
  // additional info
  long orbitReset{0};                               
  uint32_t firstTForbit{0};                         
  TFType firstSeenTF{o2::calibration::INFINITE_TF}; 
  TFType lastSeenTF{0};                             
  uint64_t nResidualsTotal{0};                      
  float TPCVDriftRef{-1.};                          
  float TPCDriftTimeOffsetRef{0.};                  
 
  ClassDefNV(ResidualsContainer, 5);
};
 
class ResidualAggregator final : public o2::calibration::TimeSlotCalibration<ResidualsContainer>
{
  using Slot = o2::calibration::TimeSlot<ResidualsContainer>;
 
 public:
  ResidualAggregator(size_t nMin = 1000) : mMinEntries(nMin) { mTrackResiduals.init(); }
  ~ResidualAggregator() final;
 
  void setDataTakingContext(o2::framework::DataTakingContext& dtc) { mDataTakingContext = dtc; }
  void setOrbitResetTime(long t) { mOrbitResetTime = t; }
  void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
  void setOutputDir(std::string dir)
  {
    mOutputDir = dir;
    mWriteOutput = true;
  }
  void setMetaFileOutputDir(std::string dir)
  {
    mMetaOutputDir = dir;
    mStoreMetaData = true;
  }
  void setLHCPeriod(std::string period) { mLHCPeriod = period; }
  void setWriteBinnedResiduals(bool f) { mWriteBinnedResiduals = f; }
  void setWriteUnbinnedResiduals(bool f) { mWriteUnbinnedResiduals = f; }
  void setWriteTrackData(bool f) { mWriteTrackData = f; }
  void setAutosaveInterval(int n) { mAutosaveInterval = n; }
  void setCompression(int c) { mCompressionSetting = c; }
 
  bool hasEnoughData(const Slot& slot) const final;
  void initOutput() final;
  void finalizeSlot(Slot& slot) final;
  Slot& emplaceNewSlot(bool front, TFType tStart, TFType tEnd) final;
 
 private:
  o2::framework::DataTakingContext mDataTakingContext{};
  TrackResiduals mTrackResiduals; 
  std::string mOutputDir{"./"};   
  std::string mMetaOutputDir{"none"}; 
  std::string mLHCPeriod{""};         
  bool mStoreMetaData{false};         
  bool mWriteOutput{false};           
  bool mWriteBinnedResiduals{false};  
  bool mWriteUnbinnedResiduals{false}; 
  bool mWriteTrackData{false};         
  int mAutosaveInterval{0};            
  int mCompressionSetting{101};        
  size_t mMinEntries;             
  long mOrbitResetTime;           
  float mTPCVDriftRef = -1.;      
  float mTPCDriftTimeOffsetRef = 0.; 
 
  ClassDefOverride(ResidualAggregator, 4);
};
 
} // namespace tpc
} // namespace o2
 
#endif // O2_TPC_RESIDUALAGGREGATOR_H