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 "larcore/Geometry/Geometry.h"

#include "TVectorT.h"
#include "TMatrixT.h"

namespace pma
{
        class Node3D;
}

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

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

        bool SetPoint3D(const TVector3& p3d);

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

        double GetDistToWall(void) const;

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

        bool IsBranching(void) const;

        bool IsTPCEdge(void) const;

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

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

        double GetDistance2To(const TVector3& p3d) const override;

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

        pma::Vector3D GetDirection3D(void) const override;

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

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

        double Length2(void) const override;

        double SegmentCos(void) const;
        double SegmentCosWirePlane(void) const;
        double SegmentCosTransverse(void) 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(void) const { return fDriftOffset; }

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

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

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

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

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

    double SumDist2Hits(void) 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