TPCFastSpaceChargeCorrectionHelper.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_TPCFastSpaceChargeCorrectionHelper_H_
#define ALICEO2_TPC_TPCFastSpaceChargeCorrectionHelper_H_
 
#include "Rtypes.h"
#include <functional>
#include "TPCFastSpaceChargeCorrectionMap.h"
#include "TPCFastSpaceChargeCorrection.h"
#include "TPCFastTransformGeo.h"
#include "SpacePoints/TrackResiduals.h"
 
class TTree;
 
namespace o2
{
namespace tpc
{
 
class TrackResiduals;
 
using namespace o2::gpu;
 
class TPCFastSpaceChargeCorrectionHelper
{
 public:
  using SectorScales = std::array<double, TPCFastTransformGeo::getNumberOfSectors()>;
 
 public:
 
  TPCFastSpaceChargeCorrectionHelper() = default;
 
  TPCFastSpaceChargeCorrectionHelper(const TPCFastSpaceChargeCorrectionHelper&) = delete;
 
  TPCFastSpaceChargeCorrectionHelper& operator=(const TPCFastSpaceChargeCorrectionHelper&) = delete;
 
  ~TPCFastSpaceChargeCorrectionHelper() = default;
 
  static TPCFastSpaceChargeCorrectionHelper* instance();
 
 
  void setNthreads(int n);
 
  void setNthreadsToMaximum();
 
  int getNthreads() const { return mNthreads; }
 
 
  std::unique_ptr<TPCFastSpaceChargeCorrection> createFromLocalCorrection(
    std::function<void(int roc, int irow, double y, double z, double& dx, double& dy, double& dz)> correctionLocal,
    const int nKnotsY = 10, const int nKnotsZ = 20);
 
  std::unique_ptr<TPCFastSpaceChargeCorrection> createFromLocalCorrection(
    std::function<void(int roc, int irow, double y, double z, double& dx, double& dy, double& dz)> correctionLocal,
    const std::vector<double>& knotsY, const std::vector<double>& knotsZ);
 
  std::unique_ptr<TPCFastSpaceChargeCorrection> createFromGlobalCorrection(
    std::function<void(int roc, double gx, double gy, double gz,
                       double& dgx, double& dgy, double& dgz)>
      correctionGlobal,
    const int nKnotsY = 10, const int nKnotsZ = 20);
 
  std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> createFromTrackResiduals(
    const o2::tpc::TrackResiduals& trackResiduals, TTree* voxResTree, TTree* voxResTreeInverse, //
    bool useSmoothed, bool invertSigns,                                                         //
    TPCFastSpaceChargeCorrectionMap* fitPointsDirect = nullptr,
    TPCFastSpaceChargeCorrectionMap* fitPointsInverse = nullptr);
 
 
  const TPCFastTransformGeo& getGeometry() { return mGeo; }
 
  TPCFastSpaceChargeCorrectionMap& getCorrectionMap() { return mCorrectionMap; }
 
  void testGeometry(const TPCFastTransformGeo& geo) const;
 
  void initInverse(o2::gpu::TPCFastSpaceChargeCorrection& correction, bool prn);
 
  void initInverse(std::vector<o2::gpu::TPCFastSpaceChargeCorrection*>& corrections, const std::vector<float>& scaling, bool prn);
 
  void addCorrections(
    o2::gpu::TPCFastSpaceChargeCorrection& mainCorrection, double scale,
    const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, double>>& additionalCorrections);
 
  void addCorrections(
    o2::gpu::TPCFastSpaceChargeCorrection& mainCorrection, SectorScales scale,
    const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, SectorScales>>& additionalCorrections);
 
  void mergeCorrections(
    o2::gpu::TPCFastSpaceChargeCorrection& destinationCorrection, const o2::gpu::TPCFastSpaceChargeCorrection& sourceCorrection,
    const std::vector<int>& sectors);
 
  void setVoxelMeanValidityRange(double range)
  {
    mVoxelMeanValidityRange = range;
  }
 
  double getVoxelMeanValidityRange() const { return mVoxelMeanValidityRange; }
 
  void setDebugUseVoxelCenters();
 
  bool isDebugUseVoxelCenters() const { return mDebugUseVoxelCenters; }
 
  void setDebugMirrorAdata2C();
 
  bool isDebugMirrorAdata2C() const { return mDebugMirrorAdata2C; }
 
 private:
  void initGeometry();
 
  void fillSpaceChargeCorrectionFromMap(TPCFastSpaceChargeCorrection& correction, bool processingInverseCorrection);
 
  static TPCFastSpaceChargeCorrectionHelper* sInstance; 
  bool mIsInitialized = 0;                              
  int mNthreads = 1;                                    
  TPCFastTransformGeo mGeo;                             
 
  TPCFastSpaceChargeCorrectionMap mCorrectionMap{0, 0};
 
  double mVoxelMeanValidityRange{1.1}; 
 
  bool mDebugUseVoxelCenters{false}; 
  bool mDebugMirrorAdata2C{false};   
 
  ClassDefNV(TPCFastSpaceChargeCorrectionHelper, 0);
};
 
} // namespace tpc
} // namespace o2
#endif