TPCFastSpaceChargeCorrectionMap.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_GPUCOMMON_TPCFASTTRANSFORMATION_TPCFASTSPACECHARGECORRECTIONMAP_H
#define ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_TPCFASTSPACECHARGECORRECTIONMAP_H
 
#include "GPUCommonDef.h"
#include "GPUCommonRtypes.h"
#include <vector>
 
namespace o2::gpu
{
 
class TPCFastSpaceChargeCorrectionMap
{
 public:
  struct CorrectionPoint {
    double mY{0.}, mZ{0.};            // not-distorted local coordinates
    double mDx{0.}, mDy{0.}, mDz{0.}; // corrections to the local coordinates
    double mWeight{0.};               // weight of the point
  };
 
 
  TPCFastSpaceChargeCorrectionMap(int32_t nSectors, int32_t nRows)
  {
    init(nSectors, nRows);
  }
 
  ~TPCFastSpaceChargeCorrectionMap() = default;
 
  void init(int32_t nSectors, int32_t nRows)
  {
    mNsectors = nSectors;
    mNrows = nRows;
    int32_t n = mNsectors * mNrows;
    fDataPoints.resize(n);
    for (uint32_t i = 0; i < fDataPoints.size(); ++i) {
      fDataPoints[i].clear();
    }
  }
 
  void addCorrectionPoint(int32_t iSector, int32_t iRow,
                          double y, double z,
                          double dx, double dy, double dz, double weight)
  {
    int32_t ind = mNrows * iSector + iRow;
    fDataPoints.at(ind).push_back(CorrectionPoint{y, z,
                                                  dx, dy, dz, weight});
  }
 
  const std::vector<CorrectionPoint>& getPoints(int32_t iSector, int32_t iRow) const
  {
    int32_t ind = mNrows * iSector + iRow;
    return fDataPoints.at(ind);
  }
 
  int32_t getNsectors() const { return mNsectors; }
 
  int32_t getNrows() const { return mNrows; }
 
  bool isInitialized() const { return mNsectors > 0 && mNrows > 0; }
 
 private:
  int32_t mNsectors{0};
  int32_t mNrows{0};
  std::vector<std::vector<CorrectionPoint>> fDataPoints; 
 
  ClassDefNV(TPCFastSpaceChargeCorrectionMap, 0);
};
 
} // namespace o2::gpu
 
#endif