AtPattern.h

Go to the documentation of this file.

#ifndef ATPATTERN_H
#define ATPATTERN_H
 
#include <Math/Point3D.h>
#include <Math/Point3Dfwd.h> // for XYZPoint
#include <Rtypes.h>          // for Double_t, Int_t, THashConsistencyHolder, ClassDef
#include <TObject.h>
 
#include <algorithm> // for max
#include <cmath>     // for NAN
#include <memory>
#include <utility> // for move
#include <vector>  // for vector
 
class TBuffer;
class TClass;
class TMemberInspector;
class TEveLine;
class TEveElement;
class AtHit;
 
namespace AtPatterns {
 
class AtPattern : public TObject {
public:
   using XYZPoint = ROOT::Math::XYZPoint;
 
protected:
   std::vector<Double_t> fPatternPar; //< Description of pattern
   Double_t fChi2{NAN};               //< How good the pattern is at describing the data
   Int_t fNFree{0};                   //< Degrees of freedom in the fit to the pattern
   const Int_t fNumPoints;            //< Number of 3D points that define the pattern (i.e. size of fIndices)
   Double_t fTotCharge{0};            //< Total charge of the pattern
 
   using TEveLineVec = std::vector<std::unique_ptr<TEveLine>>;
 
public:
   AtPattern(Int_t numPoints = 0);
   AtPattern(const AtPattern &) = default;
   AtPattern(AtPattern &&) = default;
   virtual ~AtPattern() = default;
 
   Double_t FitPattern(const std::vector<AtHit> &pointsToFit, Double_t qThreshold = -1);
   Double_t FitPattern(const std::vector<const AtHit *> &pointsToFit, Double_t qThreshold = -1);
   Double_t FitPattern(const std::vector<XYZPoint> &pointsToFit);
 
   virtual void DefinePattern(const std::vector<XYZPoint> &points) = 0;
 
   virtual void DefinePattern(std::vector<double> par) { fPatternPar = std::move(par); }
 
   virtual Double_t DistanceToPattern(const XYZPoint &point) const = 0;
   virtual XYZPoint ClosestPointOnPattern(const XYZPoint &point) const = 0;
   virtual XYZPoint GetPointAt(double t) const = 0;
 
   TEveLine *GetEveLine(double tMin, double tMax, int n) const;
 
   virtual TEveElement *GetEveElement() const = 0;
 
   virtual std::unique_ptr<AtPattern> Clone() const = 0;
 
   Int_t GetNumPoints() const { return fNumPoints; }
   Double_t GetChi2() const { return fChi2; }
   Int_t GetNFree() const { return fNFree; }
 
   virtual std::vector<double> GetPatternPar() const { return fPatternPar; }
 
   Double_t GetTotCharge() const { return fTotCharge; }
   void SetPatternPar(std::vector<double> par) { fPatternPar = std::move(par); }
   void SetChi2(double chi2) { fChi2 = chi2; }
 
protected:
   virtual void FitPattern(const std::vector<XYZPoint> &pointsToFit, const std::vector<double> &pointCharge) = 0;
 
   ClassDef(AtPattern, 1)
};
} // namespace AtPatterns
#endif //#ifndef ATTRACKPATTERN_H