PmaNode3D.h

Go to the documentation of this file.

#ifndef PmaNode3D_h
#define PmaNode3D_h

#include "larreco/RecoAlg/PMAlg/PmaElement3D.h"
#include "larreco/RecoAlg/PMAlg/SortedObjects.h"
#include "larreco/RecoAlg/PMAlg/Utilities.h"
namespace detinfo {
  class DetectorPropertiesData;
}

#include "TVector2.h"
#include "TVector3.h"

#include <vector>

namespace geo {
  class TPCGeo;
}

namespace pma {
  class Node3D;
}

class pma::Node3D final : public pma::Element3D, public pma::SortedBranchBase {
public:
  Node3D();
  Node3D(detinfo::DetectorPropertiesData const& detProp,
         const TVector3& p3d,
         unsigned int tpc,
         unsigned int cryo,
         bool vtx = false,
         double xshift = 0);

  TVector3 const& Point3D() const { return fPoint3D; }

  bool SetPoint3D(const TVector3& p3d);

  TVector2 const& Projection2D(unsigned int view) const { return fProj2D[view]; }

  double GetDistToWall() const;

  bool SameTPC(const TVector3& p3d, float margin = 0.0F) const;
  bool SameTPC(const pma::Vector3D& p3d, float margin = 0.0F) const;

  bool IsBranching() const;

  bool IsTPCEdge() const;

  bool IsVertex() const { return fIsVertex; }
  void SetVertex(bool state) { fIsVertex = state; }
  void SetVertexToBranching(bool setAllNodes)
  {
    if (setAllNodes || !fIsVertex) fIsVertex = IsBranching();
  }

  std::vector<pma::Track3D*> GetBranches() const;

  double GetDistance2To(const TVector3& p3d) const override;

  double GetDistance2To(const TVector2& p2d, unsigned int view) const override;

  pma::Vector3D GetDirection3D() const override;

  TVector3 GetUnconstrainedProj3D(const TVector2&, unsigned int) const override { return fPoint3D; }

  void SetProjection(pma::Hit3D& h) const override;

  double Length2() const override;

  double SegmentCos() const;
  double SegmentCosWirePlane() const;
  double SegmentCosTransverse() const;

  double GetObjFunction(float penaltyValue, float endSegWeight) const;

  void Optimize(float penaltyValue, float endSegWeight);

  void ClearAssigned(pma::Track3D* trk = 0) override;

  void ApplyDriftShift(double dx)
  {
    fPoint3D[0] += dx;
    fDriftOffset += dx;
  }
  double GetDriftShift() const { return fDriftOffset; }

  static void SetMargin(double m)
  {
    if (m >= 0.0) fMargin = m;
  }

private:
  bool LimitPoint3D();
  void UpdateProj2D();

  double EndPtCos2Transverse() const;
  double PiInWirePlane() const;
  double PenaltyInWirePlane() const;

  double Pi(float endSegWeight, bool doAsymm) const;
  double Penalty(float endSegWeight) const;
  double Mse() const;

  double MakeGradient(float penaltyValue, float endSegWeight);
  double StepWithGradient(float alfa, float tol, float penalty, float weight);

  double SumDist2Hits() const override;

  geo::TPCGeo const& fTpcGeo;

  double fMinX, fMaxX, fMinY, fMaxY, fMinZ,
    fMaxZ; // TPC boundaries to limit the node position (+margin)

  TVector3 fPoint3D;   // node position in 3D space in [cm]
  TVector2 fProj2D[3]; // node projections to 2D views, scaled to [cm], updated
                       // on each change of 3D position
  double fDriftOffset; // the offset due to t0

  TVector3 fGradient;
  bool fIsVertex; // no penalty on segments angle if branching or kink detected

  static bool fGradFixed[3];
  static double fMargin;
};

#endif