CorrectionMapsHelper.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_CORRECTION_MAPS_HELPER_H_
#define TPC_CORRECTION_MAPS_HELPER_H_
 
#include "TPCFastTransform.h"
#include "CorrectionMapsTypes.h"
 
namespace o2::gpu
{
 
class CorrectionMapsHelper
{
 public:
  CorrectionMapsHelper() = default;
  ~CorrectionMapsHelper() { clear(); }
  CorrectionMapsHelper(const CorrectionMapsHelper&) = delete;
  void updateLumiScale(bool report = false);
  void clear();
 
  const o2::gpu::TPCFastTransform* getCorrMap() const { return mCorrMap; }
  const o2::gpu::TPCFastTransform* getCorrMapRef() const { return mCorrMapRef; }
  const o2::gpu::TPCFastTransform* getCorrMapMShape() const { return mCorrMapMShape.get(); }
 
  void setCorrMap(o2::gpu::TPCFastTransform* m) { mCorrMap = m; }
  void setCorrMapRef(o2::gpu::TPCFastTransform* m) { mCorrMapRef = m; }
  void setCorrMapMShape(std::unique_ptr<o2::gpu::TPCFastTransform>&& m);
 
  void reportScaling();
  void setInstLumiCTP(float v)
  {
    if (v != mInstLumiCTP) {
      mInstLumiCTP = v;
    }
  }
 
  void setInstLumi(float v, bool report = false)
  {
    if (v != mInstLumi) {
      mInstLumi = v;
      updateLumiScale(report);
    }
  }
 
  void setMeanLumi(float v, bool report = false)
  {
    if (v != mMeanLumi) {
      mMeanLumi = v;
      updateLumiScale(report);
    }
  }
 
  void setMeanLumiRef(float v, bool report = false)
  {
    if (v != mMeanLumiRef) {
      mMeanLumiRef = v;
      updateLumiScale(report);
    }
  }
 
  void setLumiScaleMode(tpc::LumiScaleMode v)
  {
    if (v != mLumiScaleMode) {
      mLumiScaleMode = v;
      updateLumiScale(false);
    }
  }
 
  void setCheckCTPIDCConsistency(bool v) { mCheckCTPIDCConsistency = v; }
  bool getCheckCTPIDCConsistency() const { return mCheckCTPIDCConsistency; }
 
  float getInstLumiCTP() const { return mInstLumiCTP; }
  float getInstLumi() const { return mInstLumi; }
  float getMeanLumi() const { return mMeanLumi; }
  float getMeanLumiRef() const { return mMeanLumiRef; }
 
  float getLumiScale() const { return mLumiScale; }
  tpc::LumiScaleMode getLumiScaleMode() const { return mLumiScaleMode; }
 
  bool isUpdated() const { return mUpdatedFlags != 0; }
  bool isUpdatedMap() const { return (mUpdatedFlags & UpdateFlags::MapBit) != 0; }
  bool isUpdatedMapRef() const { return (mUpdatedFlags & UpdateFlags::MapRefBit) != 0; }
  bool isUpdatedMapMShape() const { return (mUpdatedFlags & UpdateFlags::MapMShapeBit) != 0; }
  bool isUpdatedLumi() const { return (mUpdatedFlags & UpdateFlags::LumiBit) != 0; }
  void setUpdatedMap() { mUpdatedFlags |= UpdateFlags::MapBit; }
  void setUpdatedMapRef() { mUpdatedFlags |= UpdateFlags::MapRefBit; }
  void setUpdatedMapMShape() { mUpdatedFlags |= UpdateFlags::MapMShapeBit; }
  void setUpdatedLumi() { mUpdatedFlags |= UpdateFlags::LumiBit; }
  void acknowledgeUpdate() { mUpdatedFlags = 0; }
  void setLumiCTPAvailable(bool v) { mLumiCTPAvailable = v; }
  bool getLumiCTPAvailable() const { return mLumiCTPAvailable; }
  void setLumiScaleType(tpc::LumiScaleType v) { mLumiScaleType = v; }
  tpc::LumiScaleType getLumiScaleType() const { return mLumiScaleType; }
  void enableMShapeCorrection(bool v) { mEnableMShape = v; }
  bool getUseMShapeCorrection() const { return mEnableMShape; }
  bool canUseCorrections() const { return mMeanLumi >= 0.; }
  void setMeanLumiOverride(float f) { mMeanLumiOverride = f; }
  void setMeanLumiRefOverride(float f) { mMeanLumiRefOverride = f; }
  float getMeanLumiOverride() const { return mMeanLumiOverride; }
  float getMeanLumiRefOverride() const { return mMeanLumiRefOverride; }
 
  void setInstCTPLumiOverride(float f) { mInstCTPLumiOverride = f; }
  float getInstCTPLumiOverride() const { return mInstCTPLumiOverride; }
 
  int32_t getUpdateFlags() const { return mUpdatedFlags; }
 
  bool isCorrMapMShapeDummy() const
  {
    if (mCorrMapMShape) {
      // just check for the first spline the number of knots which are 4 in case of default spline object
      return mCorrMapMShape->getCorrection().getSplineForRow(0).getNumberOfKnots() == 4;
    }
    return true;
  }
 
 protected:
  enum UpdateFlags { MapBit = 0x1,
                     MapRefBit = 0x2,
                     LumiBit = 0x4,
                     MapMShapeBit = 0x10 };
  bool mLumiCTPAvailable = false; // is CTP Lumi available
  // these 2 are global options, must be set by the workflow global options
  tpc::LumiScaleType mLumiScaleType = tpc::LumiScaleType::Unset; // use CTP Lumi (1) or TPCScaler (2) for the correction scaling, 0 - no scaling
  tpc::LumiScaleMode mLumiScaleMode = tpc::LumiScaleMode::Unset; // scaling-mode of the correction maps: 0 = linear scaling, 1 = using the derivative map, 2 = using the derivative map for MC (i.e. only apply the scaled derivative on top of the reference map)
  int32_t mUpdatedFlags = 0;
  float mInstLumiCTP = 0.;                                            // instanteneous luminosity from CTP (a.u)
  float mInstLumi = 0.;                                               // instanteneous luminosity (a.u) used for TPC corrections scaling
  float mMeanLumi = 0.;                                               // mean luminosity of the map (a.u) used for TPC corrections scaling
  float mMeanLumiRef = 0.;                                            // mean luminosity of the ref map (a.u) used for TPC corrections scaling reference
  float mLumiScale = 0.;                                              // precalculated mInstLumi/mMeanLumi
  float mMeanLumiOverride = -1.f;                                     // optional value to override mean lumi
  float mMeanLumiRefOverride = -1.f;                                  // optional value to override ref mean lumi
  float mInstCTPLumiOverride = -1.f;                                  // optional value to override inst lumi from CTP
  bool mEnableMShape = false;                                         
  bool mCheckCTPIDCConsistency{true};                                 // check of selected CTP or IDC scaling source being consistent with the map
  o2::gpu::TPCFastTransform* mCorrMap{nullptr};                       // current transform
  o2::gpu::TPCFastTransform* mCorrMapRef{nullptr};                    // reference transform
  std::unique_ptr<o2::gpu::TPCFastTransform> mCorrMapMShape{nullptr}; // correction map for M-shape distortions on A-side
  ClassDefNV(CorrectionMapsHelper, 6);
};
 
} // namespace o2::gpu
 
#endif