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:
 
  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> 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, bool useSmoothed = false, bool invertSigns = false);
 
  const TPCFastTransformGeo& getGeometry() { return mGeo; }
 
  TPCFastSpaceChargeCorrectionMap& getCorrectionMap() { return mCorrectionMap; }
 
  void fillSpaceChargeCorrectionFromMap(TPCFastSpaceChargeCorrection& correction);
 
  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);
 
 private:
  void initGeometry();
 
  void getSpaceChargeCorrection(const TPCFastSpaceChargeCorrection& correction, int slice, int row, o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint p, double& su, double& sv, double& dx, double& du, double& dv);
 
  void initMaxDriftLength(o2::gpu::TPCFastSpaceChargeCorrection& correction, bool prn);
 
  static TPCFastSpaceChargeCorrectionHelper* sInstance; 
  bool mIsInitialized = 0;                              
  int mNthreads = 1;                                    
  TPCFastTransformGeo mGeo;                             
 
  TPCFastSpaceChargeCorrectionMap mCorrectionMap{0, 0};
 
  ClassDefNV(TPCFastSpaceChargeCorrectionHelper, 0);
};
 
} // namespace tpc
} // namespace o2
#endif