IrregularSpline2D3DCalibrator.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_IRREGULARSPLINE2D3DCALIBRATOR_H
#define ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_IRREGULARSPLINE2D3DCALIBRATOR_H
 
#include "GPUCommonDef.h"
#include "IrregularSpline2D3D.h"
#include <memory>
#include <list>
#include <functional>
 
namespace o2
{
namespace gpu
{
 
class IrregularSpline2D3DCalibrator
{
 public:
  struct KnotData {
    int32_t uv;         // is the knot on U or V coordinate axis
    int32_t rasterKnot; // index of the raster knot
  };
 
  struct Action {
    enum Move { No,
                Remove,
                Up,
                Down };
    Move action;                        // action type
    float cost;                         // deviation between the input function and the spline, which happens when applying this action
    std::list<KnotData>::iterator iter; // pointer to the knot data
    bool operator<(const Action& a)
    {
      return (cost < a.cost);
    }
  };
 
 
  IrregularSpline2D3DCalibrator();
 
  ~IrregularSpline2D3DCalibrator() = default;
 
  void setRasterSize(int32_t nKnotsU, int32_t nKnotsV);
 
  void setMaxNKnots(int32_t nKnotsU, int32_t nKnotsV);
 
  void setMaximalDeviation(float maxDeviation)
  {
    mMaxDeviation = maxDeviation;
  }
 
 
  std::unique_ptr<float[]> calibrateSpline(IrregularSpline2D3D& spline_uv, std::function<void(float, float, float&, float&, float&)> F);
 
  // some getters and step-by-step calibration methods. Only for debugging.
 
  const IrregularSpline2D3D& getRaster() const
  {
    return mRaster;
  }
  const float* getRasterData() const
  {
    return mRasterData.data();
  }
 
  const IrregularSpline2D3D& getSpline() const
  {
    return mSpline;
  }
 
  const float* getSplineData() const
  {
    return mSplineData.data();
  }
 
  void startCalibration(std::function<void(float, float, float&, float&, float&)> F);
  bool doCalibrationStep();
 
 private:
 
  void createCurrentSpline();
  void createActionSpline();
  void createSpline(IrregularSpline2D3D& sp, std::vector<float>& data);
 
  Action checkActionShift(std::list<KnotData>::iterator& knot);
 
  Action checkActionRemove(std::list<KnotData>::iterator& knot);
 
  void getRegionOfInfluence(std::list<KnotData>::iterator knot, int32_t& regionKnotFirst, int32_t& regionKnotLast) const;
 
  double getMaxDeviationLine(const IrregularSpline2D3D& spline, const std::vector<float>& data, int32_t axis, int32_t knot) const;
  double getMaxDeviationArea(const IrregularSpline2D3D& spline, const std::vector<float>& data,
                             int32_t axis, int32_t knotFirst, int32_t knotLast) const;
  double getIntegralDeviationLine(const IrregularSpline2D3D& spline, const std::vector<float>& data, int32_t axis, int32_t knot) const;
  double getIntegralDeviationArea(const IrregularSpline2D3D& spline, const std::vector<float>& data,
                                  int32_t axis, int32_t knotFirst, int32_t knotLast) const;
 
 
  int32_t mMaxNKnots[2] = {5, 5}; 
 
  std::list<KnotData> mKnots[2]; 
 
  IrregularSpline2D3D mRaster;    
  std::vector<float> mRasterData; 
 
  IrregularSpline2D3D mSpline;    
  std::vector<float> mSplineData; 
 
  IrregularSpline2D3D mActionSpline;    
  std::vector<float> mActionSplineData; 
 
  std::vector<float> mTemp[2]; 
 
  float mMaxDeviation = 0.1; 
};
 
} // namespace gpu
} // namespace o2
 
#endif