Classes
struct	ClusterStore
	struct of temporary clusters More...

struct	CRTreeVars

struct	DebugStuff

struct	DontClusterStruct

struct	HistStuff

struct	MatchStruct

class	MCParticleListUtils

struct	PFPStruct

struct	ShowerPoint

struct	ShowerStruct

struct	ShowerStruct3D

struct	ShowerTreeVars

struct	SortEntry

struct	TCHit

struct	Tj2Pt

struct	TjStuff

class	TrajClusterAlg

struct	Trajectory

struct	TrajPoint

struct	TrajPoint3

class	TruthMatcher

struct	Vtx3Store
	struct of temporary 3D vertices More...

struct	VtxStore
	struct of temporary 2D vertices (end points) More...

Typedefs
using	Point3_t = std::array< double, 3 >

using	Vector3_t = std::array< double, 3 >

using	Point2_t = std::array< float, 2 >

using	Vector2_t = std::array< double, 2 >

typedef unsigned int	CTP_t

Enumerations
enum	HitStatus_t { kAllHits, kUsedHits, kUnusedHits }

Functions
geo::PlaneID	DecodeCTP (CTP_t CTP)

CTP_t	EncodeCTP (unsigned int cryo, unsigned int tpc, unsigned int plane)

CTP_t	EncodeCTP (const geo::PlaneID &planeID)

CTP_t	EncodeCTP (const geo::WireID &wireID)

bool	valDecreasings (SortEntry c1, SortEntry c2)

bool	valIncreasings (SortEntry c1, SortEntry c2)

void	UpdateMatchStructs (TjStuff &tjs, int oldTj, int newTj)

void	UpdateTp3s (TjStuff &tjs, PFPStruct &pfp, int oldTj, int newTj)

void	FillmAllTraj (TjStuff &tjs, const geo::TPCID &tpcid)

bool	SetStart (TjStuff &tjs, PFPStruct &pfp, bool prt)

void	FollowTp3s (TjStuff &tjs, PFPStruct &pfp, bool prt)

bool	FitTp3s (TjStuff &tjs, const std::vector< TrajPoint3 > &tp3s, Point3_t &pos, Vector3_t &dir, float &rCorr)

bool	FitTp3s (TjStuff &tjs, const std::vector< TrajPoint3 > &tp3s, unsigned short fromPt, unsigned short toPt, Point3_t &pos, Vector3_t &dir, float &rCorr)

bool	FitTp3 (TjStuff &tjs, TrajPoint3 &tp3, const std::vector< Tj2Pt > &tj2pts)

void	FindCompleteness (TjStuff &tjs, PFPStruct &pfp, bool doFit, bool fillTp3s, bool prt)

void	FindMissedTjsInTp3s (TjStuff &tjs, PFPStruct &pfp, std::vector< int > &missTjs, std::vector< float > &missFrac)

bool	SharesHighScoreVx (TjStuff &tjs, const PFPStruct &pfp, const Trajectory &tj)

void	Fit3D (unsigned short mode, Point3_t point, Vector3_t dir, Point3_t &fitPos, Vector3_t &fitDir)

unsigned short	WiresSkippedInCTP (TjStuff &tjs, std::vector< int > &tjids, CTP_t inCTP)

float	LengthInCTP (TjStuff &tjs, std::vector< int > &tjids, CTP_t inCTP)

bool	AddMissedTj (TjStuff &tjs, PFPStruct &pfp, unsigned short itj, bool looseCuts, bool prt)

bool	MergePFPTjs (TjStuff &tjs, PFPStruct &pfp, bool prt)

void	FindXMatches (TjStuff &tjs, unsigned short numPlanes, short maxScore, std::vector< MatchStruct > &matVec, bool prt)

bool	MakeTp3 (TjStuff &tjs, const TrajPoint &itp, const TrajPoint &jtp, TrajPoint3 &tp3, bool findDirection)

double	DeltaAngle (const Vector3_t v1, const Vector3_t v2)

Vector3_t	PointDirection (const Point3_t p1, const Point3_t p2)

double	PosSep (const Point3_t &pos1, const Point3_t &pos2)

double	PosSep2 (const Point3_t &pos1, const Point3_t &pos2)

bool	SetMag (Vector3_t &v1, double mag)

void	FilldEdx (TjStuff &tjs, PFPStruct &pfp)

void	FilldEdx (TjStuff &tjs, TrajPoint3 &tp3)

float	PFPDOCA (const PFPStruct &pfp1, const PFPStruct &pfp2, unsigned short &close1, unsigned short &close2)

bool	Split3DKink (TjStuff &tjs, PFPStruct &pfp, double sep, bool prt)

std::vector< unsigned short >	FindKinks (const TjStuff &tjs, PFPStruct &pfp, double sep, bool prt)

double	KinkAngle (const TjStuff &tjs, const std::vector< TrajPoint3 > &tp3s, unsigned short atPt, double sep)

PFPStruct	CreatePFP (const TjStuff &tjs, const geo::TPCID &tpcid)

void	FindPFParticles (TjStuff &tjs, const geo::TPCID &tpcid, bool prt)

bool	DefinePFP (std::string inFcnLabel, TjStuff &tjs, PFPStruct &pfp, bool prt)

bool	PFPVxTjOK (TjStuff &tjs, PFPStruct &pfp, bool prt)

bool	AnalyzePFP (TjStuff &tjs, PFPStruct &pfp, bool prt)

void	PFPVertexCheck (TjStuff &tjs)

void	DefinePFPParents (TjStuff &tjs, const geo::TPCID &tpcid, bool prt)

void	DefinePFPParentsTestBeam (TjStuff &tjs, const geo::TPCID &tpcid, bool prt)

bool	StorePFP (TjStuff &tjs, PFPStruct &pfp)

bool	InsideTPC (const TjStuff &tjs, Point3_t &pos, geo::TPCID &inTPCID)

void	FindAlongTrans (Point3_t pos1, Vector3_t dir1, Point3_t pos2, Point2_t &alongTrans)

bool	PointDirIntersect (Point3_t p1, Vector3_t p1Dir, Point3_t p2, Vector3_t p2Dir, Point3_t &intersect, float &doca)

bool	LineLineIntersect (Point3_t p1, Point3_t p2, Point3_t p3, Point3_t p4, Point3_t &intersect, float &doca)

void	ReversePFP (TjStuff &tjs, PFPStruct &pfp)

float	ChgFracBetween (TjStuff &tjs, Point3_t pos1, Point3_t pos2, geo::TPCID tpcid)

float	ChgFracNearEnd (TjStuff &tjs, PFPStruct &pfp, unsigned short end)

unsigned short	FarEnd (const TjStuff &tjs, const PFPStruct &pfp, const Point3_t &pos)

void	PrintTp3 (std::string someText, const TjStuff &tjs, const TrajPoint3 &tp3)

void	PrintTp3s (std::string someText, const TjStuff &tjs, const PFPStruct &pfp, short printPts)

float	AspectRatio (TjStuff &tjs, std::vector< int > &tjids, CTP_t inCTP)

void	CleanTjs (TjStuff &tjs, PFPStruct &pfp, bool prt)

double	DotProd (const Vector3_t &v1, const Vector3_t &v2)

void	SaveCRInfo (TjStuff &tjs, PFPStruct &pfp, bool prt, bool fIsRealData)

int	GetOrigin (TjStuff &tjs, PFPStruct &pfp)

void	ClearCRInfo (TjStuff &tjs)

void	ConfigureMVA (TjStuff &tjs, std::string fMVAShowerParentWeights)

bool	FindShowerStart (TjStuff &tjs, ShowerStruct3D &ss3, bool prt)

void	Finish3DShowers (TjStuff &tjs)

bool	FindShowers3D (TjStuff &tjs, const geo::TPCID &tpcid)

bool	Reconcile3D (std::string inFcnLabel, TjStuff &tjs, const geo::TPCID &tpcid, bool parentSearchDone, bool prt)

bool	Reconcile3D (std::string inFcnLabel, TjStuff &tjs, ShowerStruct3D &ss3, bool prt)

void	KillVerticesInShower (std::string inFcnLabel, TjStuff &tjs, ShowerStruct &ss, bool prt)

bool	CompleteIncompleteShower (std::string inFcnLabel, TjStuff &tjs, ShowerStruct3D &ss3, bool prt)

void	Match2DShowers (std::string inFcnLabel, TjStuff &tjs, const geo::TPCID &tpcid, bool prt)

bool	UpdateShower (std::string inFcnLabel, TjStuff &tjs, ShowerStruct &ss, bool prt)

bool	UpdateShower (std::string inFcnLabel, TjStuff &tjs, ShowerStruct3D &ss3, bool prt)

float	Match3DFOM (std::string inFcnLabel, TjStuff &tjs, ShowerStruct3D &ss3, bool prt)

float	Match3DFOM (std::string inFcnLabel, TjStuff &tjs, int icid, int jcid, int kcid, bool prt)

float	Match3DFOM (std::string inFcnLabel, TjStuff &tjs, int icid, int jcid, bool prt)

void	MergeTjList (std::vector< std::vector< int >> &tjList)

bool	RemovePFP (std::string inFcnLabel, TjStuff &tjs, PFPStruct &pfp, ShowerStruct3D &ss3, bool doUpdate, bool prt)

bool	AddPFP (std::string inFcnLabel, TjStuff &tjs, int pID, ShowerStruct3D &ss3, bool doUpdate, bool prt)

bool	AddTj (std::string inFcnLabel, TjStuff &tjs, int tjID, ShowerStruct &ss, bool doUpdate, bool prt)

bool	RemoveTj (std::string inFcnLabel, TjStuff &tjs, int TjID, ShowerStruct &ss, bool doUpdate, bool prt)

bool	FindParent (std::string inFcnLabel, TjStuff &tjs, ShowerStruct3D &ss3, bool prt)

bool	SetParent (std::string inFcnLabel, TjStuff &tjs, PFPStruct &pfp, ShowerStruct3D &ss3, bool prt)

PFPStruct	CreateFakePFP (const TjStuff &tjs, const ShowerStruct3D &ss3)

bool	IsShowerLike (const TjStuff &tjs, const std::vector< int > TjIDs)

void	ShowerParams (double showerEnergy, double &shMaxAlong, double &along95)

double	ShowerParamTransRMS (double showerEnergy, double along)

double	InShowerProbLong (double showerEnergy, double along)

double	InShowerProbTrans (double showerEnergy, double along, double trans)

double	InShowerProbParam (double showerEnergy, double along, double trans)

float	InShowerProb (const TjStuff &tjs, const ShowerStruct3D &ss3, const PFPStruct &pfp)

float	InShowerProb (const TjStuff &tjs, const ShowerStruct &ss, const Trajectory &tj)

float	ParentFOM (std::string inFcnLabel, TjStuff &tjs, PFPStruct &pfp, unsigned short pend, ShowerStruct3D &ss3, bool prt)

float	ParentFOM (std::string inFcnLabel, TjStuff &tjs, Trajectory &tj, unsigned short &tjEnd, ShowerStruct &ss, float &tp1Sep, float &vx2Score, bool prt)

bool	WrongSplitTj (std::string inFcnLabel, TjStuff &tjs, Trajectory &tj, unsigned short tjEnd, ShowerStruct &ss, bool prt)

void	MergeNearby2DShowers (std::string inFcnLabel, TjStuff &tjs, const CTP_t &inCTP, bool prt)

void	MergeOverlap (std::string inFcnLabel, TjStuff &tjs, const CTP_t &inCTP, bool prt)

void	MergeShowerChain (std::string inFcnLabel, TjStuff &tjs, const CTP_t &inCTP, bool prt)

void	MergeSubShowersTj (std::string inFcnLabel, TjStuff &tjs, const CTP_t &inCTP, bool prt)

void	MergeSubShowers (std::string inFcnLabel, TjStuff &tjs, const CTP_t &inCTP, bool prt)

int	MergeShowers (std::string inFcnLabel, TjStuff &tjs, std::vector< int > ssIDs, bool prt)

bool	MergeShowersAndStore (std::string inFcnLabel, TjStuff &tjs, int icotID, int jcotID, bool prt)

bool	MergeShowerTjsAndStore (TjStuff &tjs, unsigned short istj, unsigned short jstj, bool prt)

bool	AnalyzeRotPos (std::string inFcnLabel, TjStuff &tjs, ShowerStruct &ss, bool prt)

void	ReverseShower (std::string inFcnLabel, TjStuff &tjs, ShowerStruct &ss, bool prt)

void	ReverseShower (std::string inFcnLabel, TjStuff &tjs, int cotID, bool prt)

void	MakeShowerObsolete (std::string inFcnLabel, TjStuff &tjs, ShowerStruct3D &ss3, bool prt)

void	MakeShowerObsolete (std::string inFcnLabel, TjStuff &tjs, ShowerStruct &ss, bool prt)

bool	DontCluster (const TjStuff &tjs, const std::vector< int > &tjlist1, const std::vector< int > &tjlist2)

void	DefineDontCluster (TjStuff &tjs, const geo::TPCID &tpcid, bool prt)

void	FindCots (std::string inFcnLabel, TjStuff &tjs, const CTP_t &inCTP, std::vector< std::vector< int >> &tjLists, bool prt)

void	TagShowerLike (std::string inFcnLabel, TjStuff &tjs, const CTP_t &inCTP)

void	FindNearbyTjs (std::string inFcnLabel, TjStuff &tjs, ShowerStruct &ss, bool prt)

void	AddCloseTjsToList (TjStuff &tjs, unsigned short itj, std::vector< int > list)

void	DefineEnvelope (std::string inFcnLabel, TjStuff &tjs, ShowerStruct &ss, bool prt)

bool	AddTjsInsideEnvelope (std::string inFcnLabel, TjStuff &tjs, ShowerStruct &ss, bool prt)

bool	AddLooseHits (TjStuff &tjs, int cotID, bool prt)

void	FindStartChg (std::string inFcnLabel, TjStuff &tjs, int cotID, bool prt)

std::vector< float >	StartChgVec (TjStuff &tjs, int cotID, bool prt)

void	DumpShowerPts (TjStuff &tjs, int cotID)

bool	TransferTjHits (TjStuff &tjs, bool prt)

int	GetCotID (TjStuff &tjs, int ShowerTjID)

double	ShowerEnergy (const ShowerStruct3D &ss3)

float	ShowerEnergy (const TjStuff &tjs, const std::vector< int > tjIDs)

float	ChgToMeV (float chg)

bool	StoreShower (std::string inFcnLabel, TjStuff &tjs, ShowerStruct3D &ss3)

bool	StoreShower (std::string inFcnLabel, TjStuff &tjs, ShowerStruct &ss)

ShowerStruct3D	CreateSS3 (TjStuff &tjs, const geo::TPCID &tpcid)

ShowerStruct	CreateSS (TjStuff &tjs, CTP_t inCTP, const std::vector< int > &tjl)

bool	ChkAssns (std::string inFcnLabel, TjStuff &tjs)

void	PrintShowers (std::string fcnLabel, TjStuff &tjs)

void	Print2DShowers (std::string someText, const TjStuff &tjs, CTP_t inCTP, bool printKilledShowers)

void	PrintShower (std::string someText, const TjStuff &tjs, const ShowerStruct &ss, bool printHeader, bool printExtras)

bool	RemovePFP (std::string inFcnLabel, TjStuff &tjs, int pID, ShowerStruct3D &ss3, bool doUpdate, bool prt)

double	InShowerProb (double showerEnergy, double along, double trans)

bool	AddLooseHits (std::string inFcnLabel, TjStuff &tjs, int cotID, bool prt)

void	DumpShowerPts (std::string inFcnLabel, TjStuff &tjs, int cotID)

void	AddCloseTjsToList (std::string inFcnLabel, TjStuff &tjs, unsigned short itj, std::vector< int > list)

void	MergeTjList2 (std::string inFcnLabel, TjStuff &tjs, std::vector< std::vector< int >> &tjList, bool prt)

void	SaveTjInfo (TjStuff &tjs, std::vector< std::vector< int >> &tjList, std::string stageName)

void	SaveTjInfo (TjStuff &tjs, const ShowerStruct &ss, std::string stageName)

void	SaveTjInfoStuff (TjStuff &tjs, Trajectory &tj, int stageNum, std::string stageName)

void	SaveAllCots (TjStuff &tjs, const CTP_t &inCTP, std::string someText)

void	SaveAllCots (TjStuff &tjs, std::string someText)

int	GetStageNum (ShowerTreeVars &stv, std::string stageName)

void	ClearShowerTree (ShowerTreeVars &stv)

bool	valDecreasing (SortEntry c1, SortEntry c2)

bool	valIncreasing (SortEntry c1, SortEntry c2)

void	MakeJunkVertices (TjStuff &tjs, const CTP_t &inCTP)

void	Find2DVertices (TjStuff &tjs, const CTP_t &inCTP)

void	FindNeutralVertices (TjStuff &tjs, const geo::TPCID &tpcid)

bool	MergeWithVertex (TjStuff &tjs, VtxStore &vx, unsigned short oVxID, bool prt)

void	ChkVxTjs (TjStuff &tjs, const CTP_t &inCTP, bool prt)

void	FindHammerVertices2 (TjStuff &tjs, const CTP_t &inCTP)

void	FindHammerVertices (TjStuff &tjs, const CTP_t &inCTP)

void	SplitTrajCrossingVertices (TjStuff &tjs, CTP_t inCTP)

void	Find3DVertices (TjStuff &tjs, const geo::TPCID &tpcid)

void	Match3DVtxTjs (TjStuff &tjs, const geo::TPCID &tpcid, bool prt)

unsigned short	TPNearVertex (TjStuff &tjs, const TrajPoint &tp)

bool	AttachPFPToVertex (TjStuff &tjs, PFPStruct &pfp, unsigned short end, unsigned short vx3ID, bool prt)

bool	AttachAnyTrajToVertex (TjStuff &tjs, unsigned short ivx, bool prt)

bool	AttachTrajToVertex (TjStuff &tjs, Trajectory &tj, VtxStore &vx, bool prt)

float	TrajPointVertexPull (TjStuff &tjs, const TrajPoint &tp, const VtxStore &vx)

float	VertexVertexPull (TjStuff &tjs, const Vtx3Store &vx1, const Vtx3Store &vx2)

float	VertexVertexPull (TjStuff &tjs, const VtxStore &vx1, const VtxStore &vx2)

bool	StoreVertex (TjStuff &tjs, VtxStore &vx)

bool	FitVertex (TjStuff &tjs, VtxStore &vx, bool prt)

bool	FitVertex (TjStuff &tjs, VtxStore &vx, std::vector< TrajPoint > vxTp, bool prt)

bool	ChkVtxAssociations (TjStuff &tjs, const CTP_t &inCTP)

void	ScoreVertices (TjStuff &tjs, const geo::TPCID &tpcid, bool prt)

void	KillPoorVertices (TjStuff &tjs, const geo::TPCID &tpcid)

void	SetHighScoreBits (TjStuff &tjs, Vtx3Store &vx3)

void	SetVx3Score (TjStuff &tjs, Vtx3Store &vx3, bool prt)

void	SetVx2Score (TjStuff &tjs, bool prt)

void	SetVx2Score (TjStuff &tjs, VtxStore &vx2, bool prt)

unsigned short	Vx3Topo (TjStuff &tjs, Vtx3Store &vx3)

void	CompleteIncomplete3DVerticesInGaps (TjStuff &tjs, const geo::TPCID &tpcid)

void	CompleteIncomplete3DVertices (TjStuff &tjs, const geo::TPCID &tpcid)

bool	RefineVtxPosition (TjStuff &tjs, const Trajectory &tj, unsigned short &nearPt, short nPtsToChk, bool prt)

void	VtxHitsSwap (TjStuff &tjs, const CTP_t inCTP)

bool	MakeVertexObsolete (TjStuff &tjs, VtxStore &vx2, bool forceKill)

bool	MakeVertexObsolete (TjStuff &tjs, Vtx3Store &vx3)

std::vector< int >	GetVtxTjIDs (const TjStuff &tjs, const VtxStore &vx2)

std::vector< int >	GetVtxTjIDs (const TjStuff &tjs, const Vtx3Store &vx3, float &score)

std::vector< unsigned short >	GetPFPVertices (const TjStuff &tjs, const PFPStruct &pfp)

void	PosInPlane (const TjStuff &tjs, const Vtx3Store &vx3, unsigned short plane, Point2_t &pos)

unsigned short	IsCloseToVertex (TjStuff &tjs, VtxStore &inVx2)

unsigned short	IsCloseToVertex (TjStuff &tjs, Vtx3Store &vx3)

void	MakeJunkTjVertices (TjStuff &tjs, const CTP_t &inCTP)

void	DefineTjParents (TjStuff &tjs, const geo::TPCID &tpcid, bool prt)

float	MaxChargeAsymmetry (TjStuff &tjs, std::vector< int > &tjIDs)

int	PDGCodeVote (TjStuff &tjs, std::vector< int > &tjIDs, bool prt)

unsigned short	NumDeltaRays (const TjStuff &tjs, const Trajectory &tj)

unsigned short	NumDeltaRays (const TjStuff &tjs, std::vector< int > &tjIDs)

int	NeutrinoPrimaryTjID (const TjStuff &tjs, const Trajectory &tj)

int	PrimaryID (const TjStuff &tjs, const Trajectory &tj)

int	PrimaryID (const TjStuff &tjs, const PFPStruct &pfp)

bool	MergeTjIntoPFP (TjStuff &tjs, int mtjid, PFPStruct &pfp, bool prt)

bool	CompatibleMerge (TjStuff &tjs, std::vector< int > &tjIDs, bool prt)

bool	CompatibleMerge (TjStuff &tjs, const Trajectory &tj1, const Trajectory &tj2, bool prt)

float	OverlapFraction (TjStuff &tjs, const Trajectory &tj1, const Trajectory &tj2)

unsigned short	AngleRange (TjStuff &tjs, TrajPoint const &tp)

void	SetAngleCode (TjStuff &tjs, TrajPoint &tp)

unsigned short	AngleRange (TjStuff &tjs, float angle)

void	FitTraj (TjStuff &tjs, Trajectory &tj)

void	FitTraj (TjStuff &tjs, Trajectory &tj, unsigned short originPt, unsigned short npts, short fitDir, TrajPoint &tpFit)

float	TjDirFOM (const TjStuff &tjs, const Trajectory &tj, bool prt)

void	WatchHit (std::string someText, TjStuff &tjs, const unsigned int &wHit, short &wInTraj, const unsigned short &tjID)

void	Reverse3DMatchTjs (TjStuff &tjs, PFPStruct &pfp, bool prt)

unsigned short	GetPFPIndex (const TjStuff &tjs, int tjID)

unsigned short	MatchVecIndex (const TjStuff &tjs, int tjID)

void	ReleaseHits (TjStuff &tjs, Trajectory &tj)

void	UnsetUsedHits (TjStuff &tjs, TrajPoint &tp)

bool	StoreTraj (TjStuff &tjs, Trajectory &tj)

bool	InTrajOK (TjStuff &tjs, std::string someText)

void	CheckTrajBeginChg (TjStuff &tjs, unsigned short itj, bool prt)

void	TrimEndPts (std::string fcnLabel, TjStuff &tjs, Trajectory &tj, const std::vector< float > &fQualityCuts, bool prt)

void	ChkChgAsymmetry (TjStuff &tjs, Trajectory &tj, bool prt)

bool	SignalBetween (TjStuff &tjs, const TrajPoint &tp1, const TrajPoint &tp2, const float &MinWireSignalFraction, bool prt)

bool	SignalBetween (TjStuff &tjs, TrajPoint tp, float toPos0, const float &MinWireSignalFraction, bool prt)

float	ChgFracBetween (TjStuff &tjs, TrajPoint tp, float toPos0, bool prt)

bool	TrajHitsOK (TjStuff &tjs, const std::vector< unsigned int > &iHitsInMultiplet, const std::vector< unsigned int > &jHitsInMultiplet)

bool	TrajHitsOK (TjStuff &tjs, const unsigned int iht, const unsigned int jht)

float	ExpectedHitsRMS (TjStuff &tjs, const TrajPoint &tp)

bool	SignalAtTp (TjStuff &tjs, const TrajPoint &tp)

float	TpSumHitChg (TjStuff &tjs, TrajPoint const &tp)

unsigned short	NumPtsWithCharge (const TjStuff &tjs, const Trajectory &tj, bool includeDeadWires)

unsigned short	NumPtsWithCharge (const TjStuff &tjs, const Trajectory &tj, bool includeDeadWires, unsigned short firstPt, unsigned short lastPt)

float	DeadWireCount (const TjStuff &tjs, const TrajPoint &tp1, const TrajPoint &tp2)

float	DeadWireCount (const TjStuff &tjs, const float &inWirePos1, const float &inWirePos2, CTP_t tCTP)

unsigned short	PDGCodeIndex (TjStuff &tjs, int PDGCode)

void	MakeTrajectoryObsolete (TjStuff &tjs, unsigned int itj)

void	RestoreObsoleteTrajectory (TjStuff &tjs, unsigned int itj)

void	MergeGhostTjs (TjStuff &tjs, CTP_t inCTP)

bool	SplitTraj (TjStuff &tjs, unsigned short itj, float XPos, bool makeVx2, bool prt)

bool	SplitTraj (TjStuff &tjs, unsigned short itj, unsigned short pos, unsigned short ivx, bool prt)

void	TrajPointTrajDOCA (TjStuff &tjs, TrajPoint const &tp, Trajectory const &tj, unsigned short &closePt, float &minSep)

bool	TrajTrajDOCA (const TjStuff &tjs, const Trajectory &tj1, const Trajectory &tj2, unsigned short &ipt1, unsigned short &ipt2, float &minSep)

bool	TrajTrajDOCA (const TjStuff &tjs, const Trajectory &tj1, const Trajectory &tj2, unsigned short &ipt1, unsigned short &ipt2, float &minSep, bool considerDeadWires)

float	HitSep2 (TjStuff &tjs, unsigned int iht, unsigned int jht)

unsigned short	CloseEnd (TjStuff &tjs, const Trajectory &tj, const Point2_t &pos)

float	PointTrajSep2 (float wire, float time, TrajPoint const &tp)

float	PointTrajDOCA (TjStuff const &tjs, unsigned int iht, TrajPoint const &tp)

float	PointTrajDOCA (TjStuff const &tjs, float wire, float time, TrajPoint const &tp)

float	PointTrajDOCA2 (TjStuff const &tjs, float wire, float time, TrajPoint const &tp)

void	TrajIntersection (TrajPoint const &tp1, TrajPoint const &tp2, Point2_t &pos)

void	TrajIntersection (TrajPoint const &tp1, TrajPoint const &tp2, float &x, float &y)

float	MaxTjLen (TjStuff const &tjs, std::vector< int > &tjIDs)

float	TrajLength (Trajectory &tj)

float	PosSep (const Point2_t &pos1, const Point2_t &pos2)

float	PosSep2 (const Point2_t &pos1, const Point2_t &pos2)

float	TrajPointSeparation (TrajPoint &tp1, TrajPoint &tp2)

bool	TrajClosestApproach (Trajectory const &tj, float x, float y, unsigned short &closePt, float &DOCA)

float	TwoTPAngle (TrajPoint &tp1, TrajPoint &tp2)

std::vector< unsigned int >	PutTrajHitsInVector (Trajectory const &tj, HitStatus_t hitRequest)

void	TagJunkTj (TjStuff const &tjs, Trajectory &tj, bool prt)

bool	HasDuplicateHits (TjStuff const &tjs, Trajectory const &tj, bool prt)

void	MoveTPToWire (TrajPoint &tp, float wire)

std::vector< unsigned int >	FindCloseHits (TjStuff const &tjs, std::array< int, 2 > const &wireWindow, Point2_t const &timeWindow, const unsigned short plane, HitStatus_t hitRequest, bool usePeakTime, bool &hitsNear)

bool	FindCloseHits (TjStuff const &tjs, TrajPoint &tp, float const &maxDelta, HitStatus_t hitRequest)

std::vector< int >	FindCloseTjs (const TjStuff &tjs, const TrajPoint &fromTp, const TrajPoint &toTp, const float &maxDelta)

float	ChgFracNearPos (TjStuff &tjs, const Point2_t &pos, const std::vector< int > &tjIDs)

float	MaxHitDelta (TjStuff &tjs, Trajectory &tj)

void	ReverseTraj (TjStuff &tjs, Trajectory &tj)

bool	PointInsideEnvelope (const Point2_t &Point, const std::vector< Point2_t > &Envelope)

bool	SetMag (Vector2_t &v1, double mag)

void	FindAlongTrans (Point2_t pos1, Vector2_t dir1, Point2_t pos2, Point2_t &alongTrans)

double	DeltaAngle (const Point2_t &p1, const Point2_t &p2)

double	DeltaAngle2 (double Ang1, double Ang2)

double	DeltaAngle (double Ang1, double Ang2)

void	SetEndPoints (TjStuff &tjs, Trajectory &tj)

bool	TrajIsClean (TjStuff &tjs, Trajectory &tj, bool prt)

short	MCSMom (const TjStuff &tjs, const std::vector< int > &tjIDs)

short	MCSMom (TjStuff &tjs, Trajectory &tj)

short	MCSMom (TjStuff &tjs, Trajectory &tj, unsigned short firstPt, unsigned short lastPt)

unsigned short	NearestPtWithChg (TjStuff &tjs, Trajectory &tj, unsigned short thePt)

float	MCSThetaRMS (TjStuff &tjs, Trajectory &tj)

double	MCSThetaRMS (TjStuff &tjs, Trajectory &tj, unsigned short firstPt, unsigned short lastPt)

void	TjDeltaRMS (TjStuff &tjs, Trajectory &tj, unsigned short firstPt, unsigned short lastPt, double &rms, unsigned short &cnt)

void	TagDeltaRays (TjStuff &tjs, const CTP_t &inCTP)

void	TagMuonDirections (TjStuff &tjs, short debugWorkID)

void	UpdateTjChgProperties (std::string inFcnLabel, TjStuff &tjs, Trajectory &tj, bool prt)

void	UpdateVxEnvironment (std::string inFcnLabel, TjStuff &tjs, VtxStore &vx2, bool prt)

TrajPoint	MakeBareTP (TjStuff &tjs, Point3_t &pos, Vector3_t &dir, CTP_t inCTP)

bool	MakeBareTrajPoint (const TjStuff &tjs, unsigned int fromHit, unsigned int toHit, TrajPoint &tp)

bool	MakeBareTrajPoint (const TjStuff &tjs, float fromWire, float fromTick, float toWire, float toTick, CTP_t tCTP, TrajPoint &tp)

bool	MakeBareTrajPoint (const Point2_t &fromPos, const Point2_t &toPos, TrajPoint &tpOut)

bool	MakeBareTrajPoint (const TjStuff &tjs, const TrajPoint &tpIn1, const TrajPoint &tpIn2, TrajPoint &tpOut)

unsigned short	FarEnd (const TjStuff &tjs, const Trajectory &tj, const Point2_t &pos)

Vector2_t	PointDirection (const Point2_t p1, const Point2_t p2)

float	TPHitsRMSTime (TjStuff &tjs, TrajPoint &tp, HitStatus_t hitRequest)

float	TPHitsRMSTick (TjStuff &tjs, TrajPoint &tp, HitStatus_t hitRequest)

float	HitsRMSTime (TjStuff &tjs, const std::vector< unsigned int > &hitsInMultiplet, HitStatus_t hitRequest)

float	HitsRMSTick (TjStuff &tjs, const std::vector< unsigned int > &hitsInMultiplet, HitStatus_t hitRequest)

float	HitsPosTime (TjStuff &tjs, const std::vector< unsigned int > &hitsInMultiplet, float &sum, HitStatus_t hitRequest)

float	HitsPosTick (TjStuff &tjs, const std::vector< unsigned int > &hitsInMultiplet, float &sum, HitStatus_t hitRequest)

unsigned short	NumUsedHitsInTj (const TjStuff &tjs, const Trajectory &tj)

unsigned short	NumHitsInTP (const TrajPoint &tp, HitStatus_t hitRequest)

void	SetPDGCode (TjStuff &tjs, unsigned short itj)

void	SetPDGCode (TjStuff &tjs, Trajectory &tj)

bool	FillWireHitRange (TjStuff &tjs, const geo::TPCID &tpcid)

bool	CheckWireHitRange (const TjStuff &tjs)

bool	WireHitRangeOK (const TjStuff &tjs, const CTP_t &inCTP)

bool	MergeAndStore (TjStuff &tjs, unsigned int itj1, unsigned int itj2, bool doPrt)

std::vector< int >	GetAssns (const TjStuff &tjs, std::string type1Name, int id, std::string type2Name)

void	PrintAllTraj (std::string someText, const TjStuff &tjs, const DebugStuff &debug, unsigned short itj, unsigned short ipt, bool prtVtx)

void	PrintTrajectory (std::string someText, const TjStuff &tjs, const Trajectory &tj, unsigned short tPoint)

void	PrintHeader (std::string someText)

void	PrintTrajPoint (std::string someText, const TjStuff &tjs, unsigned short ipt, short dir, unsigned short pass, TrajPoint const &tp)

void	PrintPFP (std::string someText, const TjStuff &tjs, const PFPStruct &pfp, bool printHeader)

void	PrintPFPs (std::string someText, const TjStuff &tjs)

std::string	PrintStopFlag (const Trajectory &tj, unsigned short end)

std::string	PrintHitShort (const TCHit &hit)

std::string	PrintHit (const TCHit &hit)

std::string	PrintPos (const TjStuff &tjs, const TrajPoint &tp)

std::string	PrintPos (const TjStuff &tjs, const Point2_t &pos)

bool	SignalAtTp (TjStuff &tjs, TrajPoint const &tp)

double	DotProd (const Vector2_t &v1, const Vector2_t &v2)

template<typename T >
std::vector< T >	SetIntersection (const std::vector< T > &set1, const std::vector< T > &set2)

template<typename T >
std::vector< T >	SetDifference (const std::vector< T > &set1, const std::vector< T > &set2)

void	PrintClusters ()

Variables
constexpr unsigned int	Tpad = 10

constexpr unsigned int	Cpad = 10000

DebugStuff	debug

Data structures for the reconstruction results
enum	VtxBit_t { kVtxTrjTried, kFixed, kOnDeadWire, kHiVx3Score, kVtxTruMatch, kVtxMerged, kVtxBitSize }

enum	AlgBit_t { kMaskHits, kMaskBadTPs, kMichel, kDeltaRay, kCTKink, kCTStepChk, kTryWithNextPass, kRvPrp, kCHMUH, kSplit, kComp3DVx, kComp3DVxIG, kHED, kHamVx, kHamVx2, kJunkVx, kJunkTj, kKilled, kMerge, kTEP, kCHMEH, kFillGap, kUseGhostHits, kMrgGhost, kChkInTraj, kStopBadFits, kFixBegin, kFTBChg, kBeginChg, kFixEnd, kUUH, kVtxTj, kChkVxTj, kMisdVxTj, kPhoton, kNoFitToVx, kVxMerge, kVxNeutral, kNoKinkChk, kSoftKink, kChkStop, kChkStopEP, kChkChgAsym, kFTBRvProp, kStopAtTj, kMat3D, kMat3DMerge, kSplit3DKink, kTjHiVx3Score, kVtxHitsSwap, kSplitHiChgHits, kShowerLike, kKillInShowerVx, kShowerTj, kShwrParent, kMergeOverlap, kMergeSubShowers, kMergeSubShowersTj, kMergeNrShowers, kMergeShChain, kCompleteShower, kSplitTjCVx, kSetDir, kCheat, kAlgBitSize }

enum	StopFlag_t { kSignal, kAtKink, kAtVtx, kBragg, kAtTj, kOutFV, kFlagBitSize }

enum	TPEnvironment_t { kEnvNearTj, kEnvNearShower, kEnvOverlap, kEnvUnusedHits, kEnvClean, kEnvFlag }

const std::vector< std::string >	AlgBitNames

const std::vector< std::string >	StopFlagNames

const std::vector< std::string >	VtxBitNames

Typedef Documentation

typedef unsigned int tca::CTP_t

Definition at line 41 of file DataStructs.h.

using tca::Point2_t = typedef std::array<float, 2>

Definition at line 37 of file DataStructs.h.

using tca::Point3_t = typedef std::array<double, 3>

Definition at line 35 of file DataStructs.h.

using tca::Vector2_t = typedef std::array<double, 2>

Definition at line 38 of file DataStructs.h.

using tca::Vector3_t = typedef std::array<double, 3>

Definition at line 36 of file DataStructs.h.

Enumeration Type Documentation

enum tca::AlgBit_t

Enumerator
kMaskHits
kMaskBadTPs
kMichel
kDeltaRay
kCTKink	kink found in CheckTraj
kCTStepChk
kTryWithNextPass
kRvPrp
kCHMUH
kSplit
kComp3DVx
kComp3DVxIG
kHED
kHamVx
kHamVx2
kJunkVx
kJunkTj
kKilled
kMerge
kTEP
kCHMEH
kFillGap
kUseGhostHits
kMrgGhost
kChkInTraj
kStopBadFits
kFixBegin
kFTBChg
kBeginChg
kFixEnd
kUUH
kVtxTj
kChkVxTj
kMisdVxTj
kPhoton
kNoFitToVx
kVxMerge
kVxNeutral
kNoKinkChk
kSoftKink
kChkStop
kChkStopEP
kChkChgAsym
kFTBRvProp
kStopAtTj
kMat3D
kMat3DMerge
kSplit3DKink
kTjHiVx3Score
kVtxHitsSwap
kSplitHiChgHits
kShowerLike
kKillInShowerVx
kShowerTj
kShwrParent
kMergeOverlap
kMergeSubShowers
kMergeSubShowersTj
kMergeNrShowers
kMergeShChain
kCompleteShower
kSplitTjCVx
kSetDir
kCheat
kAlgBitSize	don't mess with this line

Definition at line 374 of file DataStructs.h.

                {
     kMaskHits,
     kMaskBadTPs,
     kMichel,
     kDeltaRay,
     kCTKink,        
     kCTStepChk,
     kTryWithNextPass,
     kRvPrp,
     kCHMUH,
     kSplit,
     kComp3DVx,
     kComp3DVxIG,
     kHED, // High End Delta
     kHamVx,
     kHamVx2,
     kJunkVx,
     kJunkTj,
     kKilled,
     kMerge,
     kTEP,
     kCHMEH,
     kFillGap,
     kUseGhostHits,
     kMrgGhost,
     kChkInTraj,
     kStopBadFits,
     kFixBegin,
     kFTBChg,
     kBeginChg,
     kFixEnd,
     kUUH,
     kVtxTj,
     kChkVxTj,
     kMisdVxTj,
     kPhoton,
     kNoFitToVx,
     kVxMerge,
     kVxNeutral,
     kNoKinkChk,
     kSoftKink,
     kChkStop,
     kChkStopEP,
     kChkChgAsym,
     kFTBRvProp,
     kStopAtTj,
     kMat3D,
     kMat3DMerge,
     kSplit3DKink,
     kTjHiVx3Score,
     kVtxHitsSwap,
     kSplitHiChgHits,
     kShowerLike,
     kKillInShowerVx,
     kShowerTj,
     kShwrParent,
     kMergeOverlap,
     kMergeSubShowers,
     kMergeSubShowersTj,
     kMergeNrShowers,
     kMergeShChain,
     kCompleteShower,
     kSplitTjCVx,
     kSetDir,
     kCheat,
     kAlgBitSize     
   } AlgBit_t;

enum tca::HitStatus_t

Enumerator
kAllHits
kUsedHits
kUnusedHits

Definition at line 37 of file Utils.h.

                {
     kAllHits,
     kUsedHits,
     kUnusedHits,
   } HitStatus_t ;

enum tca::StopFlag_t

Enumerator
kSignal
kAtKink
kAtVtx
kBragg
kAtTj
kOutFV
kFlagBitSize	don't mess with this line

Definition at line 443 of file DataStructs.h.

                {
     kSignal,
     kAtKink,
     kAtVtx,
     kBragg,
     kAtTj,
     kOutFV,
     kFlagBitSize     
   } StopFlag_t; 

enum tca::TPEnvironment_t

Enumerator
kEnvNearTj
kEnvNearShower
kEnvOverlap
kEnvUnusedHits
kEnvClean	the charge fraction is small near this point
kEnvFlag	a general purpose flag bit used in 3D matching

Definition at line 453 of file DataStructs.h.

                {
     kEnvNearTj,
     kEnvNearShower,
     kEnvOverlap,
     kEnvUnusedHits,
     kEnvClean,      
     kEnvFlag,       
   } TPEnvironment_t;

enum tca::VtxBit_t

Enumerator
kVtxTrjTried	FindVtxTraj algorithm tried.
kFixed	vertex position fixed manually - no fitting done
kOnDeadWire
kHiVx3Score	matched to a high-score 3D vertex
kVtxTruMatch	tagged as a vertex between Tjs that are matched to MC truth neutrino interaction particles
kVtxMerged
kVtxBitSize	don't mess with this line

Definition at line 100 of file DataStructs.h.

                {
     kVtxTrjTried,     
     kFixed,           
     kOnDeadWire,
     kHiVx3Score,      
     kVtxTruMatch,      
     kVtxMerged,
     kVtxBitSize     
   } VtxBit_t;

Function Documentation

void tca::AddCloseTjsToList	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		unsigned short	itj,
		std::vector< int >	list
	)

void tca::AddCloseTjsToList	(	TjStuff &	tjs,
		unsigned short	itj,
		std::vector< int >	list
	)

Definition at line 3907 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::fHits, tca::Trajectory::MCSMom, and tca::TjStuff::ShowerTag.

   {
     // Searches the trajectory points for hits that are used in a different trajectory and add
     // them to the list if any are found, and the MCSMomentum is not too large
     if(itj > tjs.allTraj.size() - 1) return;
     
     //short maxMom = (short)(2 * tjs.ShowerTag[1]);
     short maxMom = tjs.ShowerTag[1];
     //XL: why is maxMom is twice of the shower tag [1]? 
     for(auto& tp : tjs.allTraj[itj].Pts) {
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         // ignore hits that are used in this trajectory
         if(tp.UseHit[ii]) continue;
         unsigned int iht = tp.Hits[ii];
         // ignore if there is no hit -> Tj association
         if(tjs.fHits[iht].InTraj <= 0) continue;
         if((unsigned int)tjs.fHits[iht].InTraj > tjs.allTraj.size()) continue;
         // check the momentum
         Trajectory& tj = tjs.allTraj[tjs.fHits[iht].InTraj - 1];
         if(tj.MCSMom > maxMom) continue;
 //        if(tj.AlgMod[kTjHiVx3Score]) continue;
         // see if it is already in the list
         if(std::find(list.begin(), list.end(), tjs.fHits[iht].InTraj) != list.end()) continue;
         list.push_back(tjs.fHits[iht].InTraj);
       } // ii
     } // tp
   } // AddCloseTjsToList

bool tca::AddLooseHits	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		int	cotID,
		bool	prt
	)

bool tca::AddLooseHits	(	TjStuff &	tjs,
		int	cotID,
		bool	prt
	)

Definition at line 4069 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::cots, tca::ShowerStruct::CTP, DecodeCTP(), tca::ShowerStruct::Envelope, tca::TjStuff::fHits, tca::TrajPoint::Hits, tca::Trajectory::ID, tca::ShowerStruct::ID, tca::TjStuff::LastWire, geo::PlaneID::Plane, PointInsideEnvelope(), tca::Trajectory::Pts, tca::ShowerStruct::ShowerTjID, ss, tca::ShowerStruct::TjIDs, tca::TjStuff::UnitsPerTick, and tca::TjStuff::WireHitRange.

   {
     // Add hits that are inside the envelope to the shower if they are loose, i.e. not
     // used by any trajectory. This function returns true if the set of hits is different than
     // the current set. The calling function should update the shower if this is the case.
     
     ShowerStruct& ss = tjs.cots[cotID - 1];
     if(ss.Envelope.empty()) return false;
     if(ss.ID == 0) return false;
     if(ss.TjIDs.empty()) return false;
 
     geo::PlaneID planeID = DecodeCTP(ss.CTP);
     unsigned short ipl = planeID.Plane;
     
     Trajectory& stj = tjs.allTraj[ss.ShowerTjID - 1];
     TrajPoint& stp0 = stj.Pts[0];
     // start a list of new hits
     std::vector<unsigned int> newHits;
     
     // look for hits inside the envelope. Find the range of wires that spans the envelope
     float fLoWire = 1E6;
     float fHiWire = 0;
     // and the range of ticks
     float loTick = 1E6;
     float hiTick = 0;
     for(auto& vtx : ss.Envelope) {
       if(vtx[0] < fLoWire) fLoWire = vtx[0];
       if(vtx[0] > fHiWire) fHiWire = vtx[0];
       if(vtx[1] < loTick) loTick = vtx[1];
       if(vtx[1] > hiTick) hiTick = vtx[1];
     } // vtx
     loTick /= tjs.UnitsPerTick;
     hiTick /= tjs.UnitsPerTick;
     unsigned int loWire = std::nearbyint(fLoWire);
     unsigned int hiWire = std::nearbyint(fHiWire) + 1;
     if(hiWire > tjs.LastWire[ipl]-1) hiWire = tjs.LastWire[ipl]-1;
     std::array<float, 2> point;
     for(unsigned int wire = loWire; wire < hiWire; ++wire) {
       // skip bad wires or no hits on the wire
       if(tjs.WireHitRange[ipl][wire].first < 0) continue;
       unsigned int firstHit = (unsigned int)tjs.WireHitRange[ipl][wire].first;
       unsigned int lastHit = (unsigned int)tjs.WireHitRange[ipl][wire].second;
       for(unsigned int iht = firstHit; iht < lastHit; ++iht) {
         // used in a trajectory?
         if(tjs.fHits[iht].InTraj != 0) continue;
         // inside the tick range?
         if(tjs.fHits[iht].PeakTime < loTick) continue;
         // Note that hits are sorted by increasing time so we can break here
         if(tjs.fHits[iht].PeakTime > hiTick) break;
         // see if this hit is inside the envelope
         point[0] = tjs.fHits[iht].ArtPtr->WireID().Wire;
         point[1] = tjs.fHits[iht].PeakTime * tjs.UnitsPerTick;
         if(!PointInsideEnvelope(point, ss.Envelope)) continue;
         newHits.push_back(iht);
       } // iht
     } // wire
     
     // no new hits and no old hits. Nothing to do
     if(newHits.empty()) {
       if(prt) mf::LogVerbatim("TC")<<"ALH: No new loose hits found";
       return false;
     }
     
     // Update
     stp0.Hits.insert(stp0.Hits.end(), newHits.begin(), newHits.end());
     for(auto& iht: newHits) tjs.fHits[iht].InTraj = stj.ID;
     
     if(prt) mf::LogVerbatim("TC")<<"ALH: Added "<<stp0.Hits.size()<<" hits to stj "<<stj.ID;
     return true;
 
   } // AddLooseHits

bool tca::AddMissedTj	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		unsigned short	itj,
		bool	looseCuts,
		bool	prt
	)

Definition at line 1130 of file PFPUtils.cxx.

References tca::PFPStruct::ID, tca::TjStuff::matchVec, PFPVxTjOK(), SetIntersection(), tca::PFPStruct::TjCompleteness, and tca::PFPStruct::TjIDs.

   {
     // The Tj pfp.TjIDs[itj] has poor completeness. Search tjs.matchVec for
     // the occurrence of this tj with a large completeness AND the occurrence 
     // of another tj in pfp.TjIDs.
     if(itj > pfp.TjIDs.size() - 1) return false;
     if(tjs.matchVec.empty()) return false;
     
     int theTj = pfp.TjIDs[itj];
 //    bool pfpInShower = (pfp.PDGCode == 11);
     
     unsigned short oldSize = pfp.TjIDs.size();
     
     for(unsigned int ims = 0; ims < tjs.matchVec.size(); ++ims) {
       auto& ms = tjs.matchVec[ims];
       // look for theTj in the match struct
       unsigned short tjIndex = 0;
       for(tjIndex = 0; tjIndex < ms.TjIDs.size(); ++tjIndex) if(ms.TjIDs[tjIndex] == theTj) break;
       if(tjIndex == ms.TjIDs.size()) continue;
       auto shared = SetIntersection(pfp.TjIDs, ms.TjIDs);
       if(shared.empty()) continue;
       if(looseCuts) {
         // Look for shared size at least 2 (theTj and another tj) or size 1 and higher TjCompleteness
         bool isWorse = (ms.TjCompleteness[tjIndex] < pfp.TjCompleteness[itj]);
         if(shared.size() < 2 && isWorse) continue;
       } else {
         // Look for shared size at least 2 (theTj and another tj in pfp.TjIDs)
         if(shared.size() < 2) continue;
       }
       // Add the tjs that are not in pfp.TjIDs
       for(auto tjid : ms.TjIDs) {
         if(std::find(pfp.TjIDs.begin(), pfp.TjIDs.end(), tjid) != pfp.TjIDs.end()) continue;
         pfp.TjIDs.push_back(tjid);
         // check vertex - tj consistency
         if(PFPVxTjOK(tjs, pfp, prt)) continue;
         pfp.TjCompleteness.push_back(0);
         if(prt) mf::LogVerbatim("TC")<<"AMT: P"<<pfp.ID<<" T"<<theTj<<" Add T"<<tjid;
       } // mtjid
     } // ims
     if(pfp.TjIDs.size() > oldSize) return true;
     return false;
   } // AddMissedTj

bool tca::AddPFP	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		int	pID,
		ShowerStruct3D &	ss3,
		bool	doUpdate,
		bool	prt
	)

Definition at line 1570 of file TCShower.cxx.

References AddTj(), tca::TjStuff::allTraj, tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, tca::ShowerStruct3D::ID, tca::ShowerStruct3D::NeedsUpdate, tca::TjStuff::pfps, ss, tca::ShowerStruct3D::TPCID, and UpdateShower().

Referenced by Reconcile3D().

   {
     // Add the tjs in the pfp with id = pID to the 2D showers in ss3 and optionally update everything. This
     // function returns true if the addition was successful or if the Tjs in the pfp are already in ss3.
     // This function returns false if there was a failure. There isn't any error recovery.
     
     std::string fcnLabel = inFcnLabel + ".AddP";
 
     if(pID <= 0 || pID > (int)tjs.pfps.size()) return false;
     auto& pfp = tjs.pfps[pID - 1];
     
     if(pfp.TPCID != ss3.TPCID) {
       mf::LogVerbatim("TC")<<fcnLabel<<" P"<<pID<<" is in the wrong TPC for 3S"<<ss3.ID;
       return false;
     }
     
     for(auto tid : pfp.TjIDs) {
       auto& tj = tjs.allTraj[tid - 1];
       // is this tj in a 2D shower that is in a 3D shower that is not this shower?
       if(tj.SSID > 0) {
         auto& ss = tjs.cots[tj.SSID - 1];
         if(ss.SS3ID > 0 && ss.SS3ID != ss3.ID) {
           if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Conflict: 3S"<<ss3.ID<<" adding P"<<pfp.ID<<" -> T"<<tid<<" is in 2S"<<tj.SSID<<" that is in 3S"<<ss.SS3ID<<" that is not this shower";
           return false;
         } // conflict
         // tj is in the correct 2D shower so nothing needs to be done
         if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" adding P"<<pfp.ID<<" -> T"<<tid<<" is in the correct shower 2S"<<tj.SSID;
         continue;
       } // pfp tj is in a shower
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<fcnLabel<<" 3S"<<ss3.ID<<" adding P"<<pfp.ID<<" -> T"<<tid;
         for(unsigned short ii = 0; ii < pfp.TjIDs.size(); ++ii) {
           if(pfp.TjIDs[ii] == tid) myprt<<" pfp TjCompleteness "<<std::fixed<<std::setprecision(2)<<pfp.TjCompleteness[ii];
         } // itj
         myprt<<" tj.SSID 2S"<<tj.SSID;
       } // prt
       // add it to the shower in the correct CTP
       for(auto& cid : ss3.CotIDs) {
         auto& ss = tjs.cots[cid - 1];
         if(ss.CTP != tj.CTP) continue;
         // Add it to the shower.
         AddTj(fcnLabel, tjs, tid, ss, doUpdate, prt);
         ss3.NeedsUpdate = true;
         break;
       } // cid
     } // tid
     
     if(doUpdate && ss3.NeedsUpdate) UpdateShower(fcnLabel, tjs, ss3, prt);
     return true;
     
   } // AddPFP

bool tca::AddTj	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		int	tjID,
		ShowerStruct &	ss,
		bool	doUpdate,
		bool	prt
	)

Definition at line 1624 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TrajPoint::Chg, tca::Trajectory::CTP, tca::ShowerStruct::CTP, tca::Trajectory::EndPt, tca::TjStuff::fHits, tca::TrajPoint::Hits, tca::Trajectory::ID, tca::ShowerStruct::ID, tca::ShowerStruct::NearTjIDs, tca::ShowerStruct::NeedsUpdate, tca::Trajectory::Pts, tca::ShowerStruct::ShPts, tca::Trajectory::SSID, tca::ShowerStruct::TjIDs, tca::TjStuff::UnitsPerTick, UpdateShower(), and tca::TrajPoint::UseHit.

Referenced by AddPFP(), AddTjsInsideEnvelope(), MergeNearby2DShowers(), MergeSubShowersTj(), and SetParent().

   {
     // Adds the Tj to the shower and optionally updates the shower variables
     
     if(tjID <= 0 || tjID > (int)tjs.allTraj.size()) return false;
     
     std::string fcnLabel = inFcnLabel + ".AddT";
     
     Trajectory& tj = tjs.allTraj[tjID - 1];
     
     if(tj.CTP != ss.CTP) {
       mf::LogVerbatim("TC")<<fcnLabel<<" T"<<tjID<<" is in the wrong CTP for 2S"<<ss.ID;
       return false;
     }
     
     if(tj.SSID > 0) {
       if(tj.SSID == ss.ID) {
         if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" T"<<tjID<<" is already in 2S"<<ss.ID;
         return true;
       } else {
         if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Can't add T"<<tjID<<" to 2S"<<ss.ID<<". it is already used in 2S"<<tj.SSID;
         return false;
       }
     } // tj.SSID > 0
 
     ss.TjIDs.push_back(tjID);
     tj.SSID = ss.ID;
     std::sort(ss.TjIDs.begin(), ss.TjIDs.end());
     // remove this ID from the NearTjIDs list
     for(unsigned short ii = 0; ii < ss.NearTjIDs.size(); ++ii) {
       if(ss.NearTjIDs[ii] == tjID) ss.NearTjIDs.erase(ss.NearTjIDs.begin() + ii);
     }
     // count the hits in the TPs
     unsigned short cnt = 0;
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       TrajPoint& tp = tj.Pts[ipt];
       if(tp.Chg == 0) continue;
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) if(tp.UseHit[ii]) ++cnt;
     } // ipt
     unsigned short newSize = ss.ShPts.size() + cnt;
     cnt = ss.ShPts.size();
     ss.ShPts.resize(newSize);
     // now add them
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       TrajPoint& tp = tj.Pts[ipt];
       if(tp.Chg == 0) continue;
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         if(tp.UseHit[ii]) {
           unsigned int iht = tp.Hits[ii];
           ss.ShPts[cnt].HitIndex = iht;
           ss.ShPts[cnt].TID = tj.ID;
           ss.ShPts[cnt].Chg = tjs.fHits[iht].Integral;
           ss.ShPts[cnt].Pos[0] = tjs.fHits[iht].ArtPtr->WireID().Wire;
           ss.ShPts[cnt].Pos[1] = tjs.fHits[iht].PeakTime * tjs.UnitsPerTick;
           ++cnt;
         }
       }
     } // ipt
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Added T"<<tj.ID<<" to 2S"<<ss.ID;
     ss.NeedsUpdate = true;
     
     if(doUpdate) return UpdateShower(fcnLabel, tjs, ss, prt);
     return true;
     
   } // AddTj

bool tca::AddTjsInsideEnvelope	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3996 of file TCShower.cxx.

References AddTj(), tca::TjStuff::allTraj, tca::ShowerStruct::AngleErr, tca::ShowerStruct::CTP, DontCluster(), tca::ShowerStruct::Envelope, tca::ShowerStruct::ID, kKilled, kShowerTj, tca::ShowerStruct::NeedsUpdate, NeutrinoPrimaryTjID(), tca::ShowerStruct::ParentID, PointInsideEnvelope(), tca::ShowerStruct::TjIDs, tmp, and UpdateShower().

Referenced by FindShowers3D().

    {
     // This function adds Tjs to the shower. It updates the shower parameters.
     
      if(ss.Envelope.empty()) return false;
      if(ss.ID == 0) return false;
      if(ss.TjIDs.empty()) return false;
      
      std::string fcnLabel = inFcnLabel + ".ATIE";
 
      if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Checking 2S"<<ss.ID;
 
      std::vector<int> tmp(1);
      unsigned short nadd = 0;
      for(auto& tj : tjs.allTraj) {
        if(tj.CTP != ss.CTP) continue;
        if(tj.AlgMod[kKilled]) continue;
        if(tj.SSID > 0) continue;
        if(tj.AlgMod[kShowerTj]) continue;
        // See if this Tjs is attached to a neutrino vertex. 
        if(tj.ParentID == 0) continue;
        int neutPrimTj = NeutrinoPrimaryTjID(tjs, tj);
        if(neutPrimTj > 0 && neutPrimTj != tj.ID) {
          // The Tj is connected to a primary Tj that is associated with a neutrino primary.
          // Don't allow tjs to be added to the shower that are not connected to this neutrino primary (if
          // one exists)
          if(ss.ParentID > 0 && neutPrimTj != ss.ParentID) continue;
        } // neutrino primary tj
        // This shouldn't be necessary but ensure that the Tj ID appears only once in ss.TjIDs
        if(std::find(ss.TjIDs.begin(), ss.TjIDs.end(), tj.ID) != ss.TjIDs.end()) continue;
        // check consistency
        tmp[0] = tj.ID;
        if(DontCluster(tjs, tmp, ss.TjIDs)) continue;
        // See if both ends are outside the envelope
        bool end0Inside = PointInsideEnvelope(tj.Pts[tj.EndPt[0]].Pos, ss.Envelope);
        bool end1Inside = PointInsideEnvelope(tj.Pts[tj.EndPt[1]].Pos, ss.Envelope);
        if(!end0Inside && !end1Inside) continue;
        if(end0Inside && end1Inside) {
          // TODO: See if the Tj direction is compatible with the shower?
          if(AddTj(fcnLabel, tjs, tj.ID, ss, false, prt)) ++nadd;
          ++nadd;
          continue;
        } // both ends inside
        // Require high momentum Tjs be aligned with the shower axis
        // TODO also require high momentum Tjs close to the shower axis?
 
        if(tj.MCSMom > 200) {
          float tjAngle = tj.Pts[tj.EndPt[0]].Ang;
          float dangPull = std::abs(tjAngle - ss.AngleErr) / ss.AngleErr;
          if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" high MCSMom "<<tj.MCSMom<<" dangPull "<<dangPull;
          if(dangPull > 2) continue;
        } // high momentum
        if(AddTj(fcnLabel, tjs, tj.ID, ss, false, prt)) {
          ++nadd;
        } else {
          if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" AddTj failed to add T"<<tj.ID;
        }
     } // tj
     
     if(nadd > 0) {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Added "<<nadd<<" trajectories ";
       ss.NeedsUpdate = true;
       UpdateShower(fcnLabel, tjs, ss, prt);
       return true;
     } else {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" No new trajectories added to envelope ";
       ss.NeedsUpdate = false;
       return false;
     }
         
   } // AddTjsInsideEnvelope

bool tca::AnalyzePFP	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 2339 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, DefinePFP(), tca::PFPStruct::ID, kMat3D, tca::PFPStruct::NeedsUpdate, NumPtsWithCharge(), PFPVxTjOK(), tca::PFPStruct::TjCompleteness, tca::PFPStruct::TjIDs, and tca::PFPStruct::Tp3s.

Referenced by DotProd(), FindPFParticles(), and Match3DVtxTjs().

   {
     // Analyzes the PFP for oddities and tries to fix them
     if(pfp.ID == 0) return false;
     if(pfp.TjIDs.empty()) return false;
     if(pfp.Tp3s.empty()) return false;
     
     // don't bother analyzing this pfp has been altered
     if(pfp.NeedsUpdate) {
       if(prt) mf::LogVerbatim("TC")<<"AnalyzePFP: P"<<pfp.ID<<" needs to be updated. Skip analysis ";
       return true;
     }
     
     // check the tj completeness
     float minCompleteness = 0.95;
     for(auto tjc : pfp.TjCompleteness) if(tjc < minCompleteness) minCompleteness = tjc;
     if(prt) mf::LogVerbatim("TC")<<"inside AnalyzePFP P"<<pfp.ID<<" minCompleteness "<<minCompleteness;
     if(minCompleteness == 0.95) return true;
     
     // compare the Tjs in Tp3s with those in TjIDs
     std::vector<int> tjIDs;
     std::vector<unsigned short> tjCnt;
     for(auto& tp3 : pfp.Tp3s) {
       for(auto& tp2 : tp3.Tj2Pts) {
         // convert to int for std::find
         int itjID = tp2.id;
         unsigned short indx = 0;
         for(indx = 0; indx < tjIDs.size(); ++indx) if(tjIDs[indx] == tp2.id) break;
         if(indx == tjIDs.size()) {
           tjIDs.push_back(itjID);
           tjCnt.push_back(1);
         } else {
           ++tjCnt[indx];
         }
       } // tp2
     } // tp3
     
     // look for differences
     for(unsigned short ii = 0; ii < tjIDs.size(); ++ii) {
       if(std::find(pfp.TjIDs.begin(), pfp.TjIDs.end(), tjIDs[ii]) != pfp.TjIDs.end()) continue;
       auto& missTj = tjs.allTraj[tjIDs[ii] - 1];
       if(missTj.AlgMod[kMat3D]) continue;
       unsigned short npwc = NumPtsWithCharge(tjs, missTj, false);
       if(prt) mf::LogVerbatim("TC")<<" missed T"<<missTj.ID<<" npwc "<<npwc<<" tjCnt "<<tjCnt[ii];
       if(tjCnt[ii] < 0.5 * npwc) continue;
       // June 4, 2018. 3D merging is turned off so require the missed tj to be in
       // a missing plane
       bool skipit = false;
       for(auto tid : pfp.TjIDs) {
         auto& tj = tjs.allTraj[tid - 1];
         if(tj.CTP == missTj.CTP) skipit = true;
       } // tid
       if(skipit) continue;
       // add the missed Tj to the pfp and flag it as needing an update
       pfp.TjIDs.push_back(missTj.ID);
       if(PFPVxTjOK(tjs, pfp, prt)) pfp.NeedsUpdate = true;
     } // ii
     
     if(pfp.NeedsUpdate) DefinePFP("APFP", tjs, pfp, prt);
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"APFP: Tjs in pfp\n";
       for(auto tjid : pfp.TjIDs) {
         auto& tj = tjs.allTraj[tjid - 1];
         myprt<<"T"<<tj.ID<<" npwc "<<NumPtsWithCharge(tjs, tj, false);
         unsigned short indx = 0;
         for(indx = 0; indx < tjIDs.size(); ++indx) if(tjIDs[indx] == tjid) break;
         if(indx == tjIDs.size()) {
           myprt<<" not found in P"<<pfp.ID<<"\n";
           continue;
         }
         myprt<<" nTp3 "<<tjCnt[indx]<<"\n";
       } // tjid
     } // prt
     return true;
   } // AnalyzePFP

bool tca::AnalyzeRotPos	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3170 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::ShowerStruct::DirectionFOM, tca::ShowerStruct::ID, tca::Trajectory::Pts, tca::ShowerStruct::ShowerTjID, and tca::ShowerStruct::ShPts.

Referenced by UpdateShower().

   {
     // The RotPos vector was filled and sorted by increasing distance along the shower axis.
     // This function divides the RotPos points into 3 sections and puts the transverse rms width in the
     // three sections into the shower Tj TrajPoint DeltaRMS variable. It also calculates the charge and number of shower
     // points closest to each TrajPoint. The 
     
     if(ss.ID == 0) return false;
     if(ss.ShPts.empty()) return false;
     Trajectory& stj = tjs.allTraj[ss.ShowerTjID - 1];
     if(stj.Pts.size() != 3) return false;
     
     std::string fcnLabel = inFcnLabel + ".ARP";
     
     for(auto& tp : stj.Pts) {
       tp.Chg = 0;
       tp.DeltaRMS = 0;
       tp.NTPsFit = 0;
       tp.HitPos = {{0.0, 0.0}};
     }
     
     float minAlong = ss.ShPts[0].RotPos[0];
     float maxAlong = ss.ShPts[ss.ShPts.size()-1].RotPos[0];
     float sectionLength = (maxAlong - minAlong) / 3;
     float sec0 = minAlong + sectionLength;
     float sec2 = maxAlong - sectionLength;
     // iterate over the shower points (aka hits)
     for(auto& spt : ss.ShPts) {
       // The point on the shower Tj to which the charge will assigned
       unsigned short ipt = 0;
       if(spt.RotPos[0] < sec0) {
         // closest to point 0
         ipt = 0;
       } else if(spt.RotPos[0] > sec2) {
         // closest to point 2
         ipt = 2;
       } else {
         // closest to point 1
         ipt = 1;
       }
       stj.Pts[ipt].Chg += spt.Chg;
 /*
       if(ss.ID == 2) {
         std::cout<<"2S"<<ss.ID;
         std::cout<<" Pos "<<PrintPos(tjs, spt.Pos);
         std::cout<<" RP "<<std::fixed<<std::setprecision(1)<<spt.RotPos[0]<<" "<<spt.RotPos[1];
         std::cout<<" chg "<<(int)spt.Chg;
         std::cout<<" ipt "<<ipt;
         std::cout<<"\n";
       }
 */
       // Average the absolute value of the transverse position in lieu of
       // using the sum of the squares. The result is ~15% higher than the actual
       // rms which is OK since this is used to find the transverse size of the shower
       // which is not a precisely defined quantity anyway
       stj.Pts[ipt].DeltaRMS += spt.Chg * std::abs(spt.RotPos[1]);
       ++stj.Pts[ipt].NTPsFit;
       // Average the charge center at each point
       stj.Pts[ipt].HitPos[0] += spt.Chg * spt.Pos[0];
       stj.Pts[ipt].HitPos[1] += spt.Chg * spt.Pos[1];
     } // spt
     
     for(auto& tp : stj.Pts) {
       if(tp.Chg > 0) {
         tp.DeltaRMS /= tp.Chg;
         tp.HitPos[0] /= tp.Chg;
         tp.HitPos[1] /= tp.Chg;
       }
     } // tp
     
     // require that there is charge in point 0 and 2. Point 1 may not have charge if
     // we are constructing a sparse shower that is not yet well-defined
     if(stj.Pts[0].Chg == 0 || stj.Pts[2].Chg == 0) return false;
     
     // ensure that the charge center is defined
     if(stj.Pts[1].Chg == 0) {
       // do a simple interpolation
       stj.Pts[1].HitPos[0] = 0.5 * (stj.Pts[0].HitPos[0] + stj.Pts[2].HitPos[0]);
       stj.Pts[1].HitPos[1] = 0.5 * (stj.Pts[0].HitPos[1] + stj.Pts[2].HitPos[1]);
     }
     if(stj.Pts[2].DeltaRMS > 0) {
       ss.DirectionFOM = stj.Pts[0].DeltaRMS / stj.Pts[2].DeltaRMS;
     } else {
       ss.DirectionFOM = 10;
     }
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<fcnLabel<<" 2S"<<ss.ID;
       myprt<<" HitPos[0] "<<std::fixed<<std::setprecision(1);
       myprt<<stj.Pts[1].HitPos[0]<<" "<<stj.Pts[1].HitPos[1]<<" "<<stj.Pts[1].HitPos[2];
       myprt<<" DeltaRMS "<<std::setprecision(2);
       myprt<<stj.Pts[0].DeltaRMS<<" "<<stj.Pts[1].DeltaRMS<<" "<<stj.Pts[2].DeltaRMS;
       myprt<<" DirectionFOM "<<std::fixed<<std::setprecision(2)<<ss.DirectionFOM;
     }
     return true;
 
   } // AnalyzeRotPos

unsigned short tca::AngleRange	(	TjStuff &	tjs,
		TrajPoint const &	tp
	)

Definition at line 636 of file Utils.cxx.

References tca::TrajPoint::Ang, and AngleRange().

Referenced by tca::TrajClusterAlg::CheckHiMultUnusedHits(), and tca::TrajClusterAlg::UseUnusedHits().

   {
     return AngleRange(tjs, tp.Ang);
   }

unsigned short tca::AngleRange	(	TjStuff &	tjs,
		float	angle
	)

Definition at line 659 of file Utils.cxx.

References tca::TjStuff::AngleRanges.

Referenced by AngleRange(), FitTraj(), and SetAngleCode().

   {
     // returns the index of the angle range
     if(angle > M_PI) angle = M_PI;
     if(angle < -M_PI) angle = M_PI;
     if(angle < 0) angle = -angle;
     if(angle > M_PI/2) angle = M_PI - angle;
     for(unsigned short ir = 0; ir < tjs.AngleRanges.size(); ++ir) {
       if(angle < tjs.AngleRanges[ir]) return ir;
     }
     return tjs.AngleRanges.size() - 1;
   } // AngleRange

float tca::AspectRatio	(	TjStuff &	tjs,
		std::vector< int > &	tjids,
		CTP_t	inCTP
	)

bool tca::AttachAnyTrajToVertex	(	TjStuff &	tjs,
		unsigned short	ivx,
		bool	prt
	)

Definition at line 1689 of file TCVertex.cxx.

References tca::TjStuff::allTraj, AttachTrajToVertex(), tca::VtxStore::CTP, tca::VtxStore::ID, kKilled, tca::TjStuff::Vertex2DCuts, and tca::TjStuff::vtx.

Referenced by CompleteIncomplete3DVertices(), Find2DVertices(), FindHammerVertices(), FindHammerVertices2(), tca::TrajClusterAlg::ReconstructAllTraj(), and Split3DKink().

   {
     
     if(ivx > tjs.vtx.size() - 1) return false;
     if(tjs.vtx[ivx].ID == 0) return false;
     if(tjs.Vertex2DCuts[0] < 0) return false;
     
     VtxStore& vx = tjs.vtx[ivx];
     
     unsigned short nadd = 0;
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       if(tj.CTP != vx.CTP) continue;
       if(tj.VtxID[0] == vx.ID || tj.VtxID[1] == vx.ID) continue;
       if(AttachTrajToVertex(tjs, tj, vx, prt)) ++nadd;
     } // tj
     if(prt) mf::LogVerbatim("TC")<<" AttachAnyTrajToVertex: nadd "<<nadd;
     if(nadd == 0) return false;
     return true;
     
   } // AttachAnyTrajToVertex

bool tca::AttachPFPToVertex	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		unsigned short	end,
		unsigned short	vx3ID,
		bool	prt
	)

Definition at line 1651 of file TCVertex.cxx.

References tca::TjStuff::allTraj, DecodeCTP(), evd::details::end(), tca::PFPStruct::ID, tca::PFPStruct::PDGCode, tca::TjStuff::pfps, geo::PlaneID::Plane, PosInPlane(), tca::PFPStruct::TjIDs, tca::TjStuff::vtx3, and tca::PFPStruct::Vx3ID.

   {
     if(vx3ID > int(tjs.vtx3.size())) return false;
     if(pfp.ID > int(tjs.pfps.size())) return false;
     if(pfp.PDGCode == 22) return false;
     if(end > 1) return false;
     
     auto& vx3 = tjs.vtx3[vx3ID - 1];
     
     pfp.Vx3ID[end] = vx3.ID;
     
     // We are done if this a PFP-only vertex
     if(vx3.Wire == -2) return true;
     
     // Update the 2D and 3D vertex and tj associations
     for(auto tjid : pfp.TjIDs) {
       auto& tj = tjs.allTraj[tjid - 1];
       unsigned short plane = DecodeCTP(tj.CTP).Plane;
       // TODO: Check to see if the Tjs have been ordered correctly? 
       if(tj.VtxID[end] == 0) {
         // tj is available to be attached to a 2D vertex. See if the 3D vertex is matched to 
         // an existing 2D vertex in this plane
         if(vx3.Vx2ID[plane] == 0) {
           // not matched. Look for one
           std::array<float, 2> pos;
           PosInPlane(tjs, vx3, plane, pos);
 //          if(prt) std::cout<<" tj "<<tj.ID<<" has no 2D vertex. Look for one vertex near "<<tj.CTP<<":"<<PrintPos(tjs, pos)<<" Events processed "<<tjs.EventsProcessed<<"\n";
         } else {
           // Existing 2D vertex matched to the 3D vertex
 //          if(prt) std::cout<<" tj "<<tj.ID<<" has no 2D vertex in CTP "<<tj.CTP<<" but vx3 is matched to 2D vertex"<<vx3.Vx2ID[plane]<<". Attach it? Events processed "<<tjs.EventsProcessed<<"\n";
         }
       }
     } // tjid
     
     return true;
   } // AttachPFPToVertex

bool tca::AttachTrajToVertex	(	TjStuff &	tjs,
		Trajectory &	tj,
		VtxStore &	vx,
		bool	prt
	)

Definition at line 1712 of file TCVertex.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::VtxStore::CTP, tca::Trajectory::CTP, evd::details::end(), tca::Trajectory::EndPt, FitVertex(), tca::VtxStore::ID, tca::Trajectory::ID, kFixed, kKilled, kNoFitToVx, kPhoton, tca::VtxStore::NTraj, tca::VtxStore::Pos, PosSep2(), tca::Trajectory::Pts, SetVx2Score(), SignalBetween(), tca::VtxStore::Stat, TrajClosestApproach(), TrajLength(), TrajPointVertexPull(), tca::TjStuff::Vertex2DCuts, and tca::Trajectory::VtxID.

Referenced by AttachAnyTrajToVertex(), and tca::TrajClusterAlg::StepCrawl().

   {
     // Note that this function does not require a signal between the end of the Tj and the vertex
     
     // tjs.Vertex2DCuts fcl input usage
     // 0 = maximum length of a short trajectory
     // 1 = max vertex - trajectory separation for short trajectories
     // 2 = max vertex - trajectory separation for long trajectories
     // 3 = max position pull for adding TJs to a vertex
     // 4 = max allowed vertex position error
     // 5 = min MCSMom
     // 6 = min Pts/Wire fraction
     
     if(tj.AlgMod[kKilled]) return false;
     if(tj.CTP != vx.CTP) return false;
     // already attached?
     if(tj.VtxID[0] == vx.ID || tj.VtxID[1] == vx.ID) return false;
     
     unsigned short maxShortTjLen = tjs.Vertex2DCuts[0];
     // square the separation cut to simplify testing in the loop
     float maxSepCutShort2 = tjs.Vertex2DCuts[1] * tjs.Vertex2DCuts[1];
     float maxSepCutLong2 = tjs.Vertex2DCuts[2] * tjs.Vertex2DCuts[2];
     
     // assume that end 0 is closest to the vertex
     unsigned short end = 0;
     float vtxTjSep2 = PosSep2(vx.Pos, tj.Pts[tj.EndPt[0]].Pos);
     float sep1 = PosSep2(vx.Pos, tj.Pts[tj.EndPt[1]].Pos);
     if(sep1 < vtxTjSep2) {
       // End 1 is closer
       end = 1;
       vtxTjSep2 = sep1;
     }
     // is there a vertex already assigned to this end?
     if(tj.VtxID[end] > 0) return false;
     
     // is the trajectory short?
     bool tjShort = (tj.EndPt[1] - tj.EndPt[0] < maxShortTjLen);
     float closestApproach;
     // ignore bad separation between the closest tj end and the vertex
     if(tjShort) {
       if(vtxTjSep2 > maxSepCutShort2) return false;
       closestApproach = tjs.Vertex2DCuts[1];
     } else {
       closestApproach = tjs.Vertex2DCuts[2];
       if(vtxTjSep2 > maxSepCutLong2) return false;
     }
     
     // Calculate the pull on the vertex
     TrajPoint& tp = tj.Pts[tj.EndPt[end]];
     float tpVxPull = TrajPointVertexPull(tjs, tp, vx);
     bool signalBetween = SignalBetween(tjs, tp, vx.Pos[0], 0.8, prt);
     
     // See if the vertex position is close to an end
     unsigned short closePt;
     TrajClosestApproach(tj, vx.Pos[0], vx.Pos[1], closePt, closestApproach);
     // count the number of points between the end of the trajectory and the vertex.
     // tj     -------------   tj ------------
     // vx  *   >> dpt = 0     vx   *  >> dpt = 2
     short dpt;
     if(end == 0) {
       dpt = closePt - tj.EndPt[end];
     } else {
       dpt = tj.EndPt[end] - closePt;
     }
     
     float length = TrajLength(tj);
     // don't attach it if the tj length is shorter than the separation distance
     if(length > 2 && length < closestApproach) return false;
 
     float pullCut = tjs.Vertex2DCuts[3];
     // Dec 21, 2017 Loosen up the pull cut for short close Tjs. These are likely to
     // be poorly reconstructed. It is better to have them associated with the vertex
     // than not.
     if(tjShort) pullCut = 10;
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"ATTV: 2V"<<vx.ID;
       myprt<<" NTraj "<<vx.NTraj;
       myprt<<" oldTJs";
       for(unsigned short itj = 0; itj < tjs.allTraj.size(); ++itj) {
         Trajectory& tj = tjs.allTraj[itj];
         if(tj.AlgMod[kKilled]) continue;
         if(tj.CTP != vx.CTP) continue;
         if(tj.VtxID[0] == vx.ID) myprt<<" "<<tj.ID<<"_0";
         if(tj.VtxID[1] == vx.ID) myprt<<" "<<tj.ID<<"_1";
       }
       myprt<<" +tjID "<<tj.ID<<"_"<<end<<" vtxTjSep "<<sqrt(vtxTjSep2)<<" tpVxPull "<<tpVxPull<<" pullCut "<<pullCut<<" dpt "<<dpt;
     }
 //    if(tpVxPull > tjs.Vertex2DCuts[3]) return false;
     if(tpVxPull > pullCut) return false;
     if(dpt > 2) return true;
     
     // remove the fixed position flag if there are more than 2 tjs
     bool fixedBit = vx.Stat[kFixed];
     if(fixedBit && vx.NTraj < 2) vx.Stat[kFixed] = false;
     
     // don't allow a short Tj with a large pull to bias the fit
     if(tjShort && tpVxPull > tjs.Vertex2DCuts[3]) tj.AlgMod[kNoFitToVx] = true;
 
     // Passed all the cuts. Attach it to the vertex and try a fit
     tj.VtxID[end] = vx.ID;
     // flag as a photon Tj so it isn't included in the fit
     tj.AlgMod[kPhoton] = !signalBetween;
     // make a copy of the vertex and fit it
     auto vxTmp = vx;
     if(FitVertex(tjs, vxTmp, prt)) {
       SetVx2Score(tjs, vxTmp, prt);
       if(prt) mf::LogVerbatim("TC")<<" Success";
       vx = vxTmp;
       return true;
     }
     
     // test this again
     tj.AlgMod[kNoFitToVx] = true;
     if(prt) mf::LogVerbatim("TC")<<" Poor fit. Keep Tj "<<tj.ID<<" with kNoFitToVx";
     return true;
 /*
     // fit failed so remove the tj -> vx assignment if it is long and
     // set noFitToVtx if it is short
     if(tjShort) {
       tj.AlgMod[kNoFitToVx] = true;
       if(prt) mf::LogVerbatim("TC")<<" Poor fit. Keep short Tj "<<tj.ID<<" with kNoFitToVx";
       return true;
     } else {
       tj.VtxID[end] = 0;
       // restore the fixed flag
       vx.Stat[kFixed] = fixedBit;
       if(prt) mf::LogVerbatim("TC")<<" Poor fit. Removed Tj "<<tj.ID;
       return false;
     }
 */
   } // AttachTrajToVertex

void tca::CheckTrajBeginChg	(	TjStuff &	tjs,
		unsigned short	itj,
		bool	prt
	)

Definition at line 1272 of file Utils.cxx.

References tca::TjStuff::allTraj, tca::VtxStore::ChiDOF, tca::VtxStore::CTP, tca::VtxStore::ID, kBeginChg, kBragg, kFixed, kFTBRvProp, kKilled, MakeVertexObsolete(), tca::VtxStore::NTraj, tca::VtxStore::Pass, tca::VtxStore::Pos, PrintPos(), SetVx2Score(), SplitTraj(), tca::VtxStore::Stat, StoreVertex(), tca::VtxStore::Topo, tca::TjStuff::UseAlg, and tca::TjStuff::vtx.

Referenced by tca::TrajClusterAlg::ReconstructAllTraj().

   {
     // This function is called after the beginning of the tj has been inspected to see if
     // reverse propagation was warranted. Trajectory points at the beginning were removed by
     // this process.
     // A search has been made for a Bragg peak with nothing
     // found. Here we look for a charge pattern like the following, where C means large charge
     // and c means lower charge:
     // CCCCCCccccccc
     // The charge in the two regions should be fairly uniform. 
     
     // This function may split the trajectory so it needs to have been stored
     if(itj > tjs.allTraj.size() - 1) return;
     auto& tj = tjs.allTraj[itj];
     
     if(!tjs.UseAlg[kBeginChg]) return;
     if(tj.StopFlag[0][kBragg]) return;
     if(tj.AlgMod[kFTBRvProp]) return;
     if(tj.AlgMod[kKilled]) return;
     if(tj.Pts.size() < 20) return;
     
     // look for a large drop between the average charge near the beginning
     float chg2 = tj.Pts[tj.EndPt[0] + 2].AveChg;
     // and the average charge 15 points away
     float chg15 = tj.Pts[tj.EndPt[0] + 15].AveChg;
     if(chg2 < 3 * chg15) return;
     
     // find the point where the charge falls below the mid-point
     float midChg = 0.5 * (chg2 + chg15);
     
     unsigned short breakPt = USHRT_MAX;
     for(unsigned short ipt = tj.EndPt[0] + 3; ipt < 15; ++ipt) {
       float chgm2 = tj.Pts[ipt - 2].Chg;
       if(chgm2 == 0) continue;
       float chgm1 = tj.Pts[ipt - 1].Chg;
       if(chgm1 == 0) continue;
       float chgp1 = tj.Pts[ipt + 1].Chg;
       if(chgp1 == 0) continue;
       float chgp2 = tj.Pts[ipt + 2].Chg;
       if(chgp2 == 0) continue;
       if(chgm2 > midChg && chgm1 > midChg && chgp1 < midChg && chgp2 < midChg) {
         breakPt = ipt;
         break;
       }
     } // breakPt
     if(breakPt == USHRT_MAX) return;
     // Create a vertex at the break point
     VtxStore aVtx;
     aVtx.Pos = tj.Pts[breakPt].Pos;
     aVtx.NTraj = 2;
     aVtx.Pass = tj.Pass;
     aVtx.Topo = 8;
     aVtx.ChiDOF = 0;
     aVtx.CTP = tj.CTP;
     aVtx.ID = tjs.vtx.size() + 1;
     aVtx.Stat[kFixed] = true;
     unsigned short ivx = tjs.vtx.size();
     if(!StoreVertex(tjs, aVtx)) return;
     if(!SplitTraj(tjs, itj, breakPt, ivx, prt)) {
       if(prt) mf::LogVerbatim("TC")<<"CTBC: Failed to split trajectory";
       MakeVertexObsolete(tjs, tjs.vtx[ivx], false);
       return;
     }
     SetVx2Score(tjs, prt);
     
     if(prt) mf::LogVerbatim("TC")<<"CTBC: Split T"<<tj.ID<<" at "<<PrintPos(tjs, tj.Pts[breakPt].Pos)<<"\n";
     
   } // CheckTrajBeginChg

bool tca::CheckWireHitRange ( const TjStuff & tjs )

Definition at line 3855 of file Utils.cxx.

References tca::TjStuff::fHits, tca::TjStuff::NumPlanes, tca::TjStuff::NumWires, and tca::TjStuff::WireHitRange.

Referenced by tca::TrajClusterAlg::CreateHit(), DotProd(), tca::TrajClusterAlg::EraseHit(), and FillWireHitRange().

   {
     // do a QC check
     for(unsigned short ipl = 0; ipl < tjs.NumPlanes; ++ipl) {
       for(unsigned int wire = 0; wire < tjs.NumWires[ipl]; ++wire) {
         // No hits or dead wire
         if(tjs.WireHitRange[ipl][wire].first < 0) continue;
         unsigned int firstHit = tjs.WireHitRange[ipl][wire].first;
         unsigned int lastHit = tjs.WireHitRange[ipl][wire].second;
         if(lastHit > tjs.fHits.size()) {
           mf::LogWarning("TC")<<"CheckWireHitRange: Invalid lastHit "<<lastHit<<" > fHits.size "<<tjs.fHits.size()<<" in plane "<<ipl;
           return false;
         }
         for(unsigned int iht = firstHit; iht < lastHit; ++iht) {
           if(tjs.fHits[iht].ArtPtr->WireID().Plane != ipl) {
             mf::LogWarning("TC")<<"CheckWireHitRange: Invalid plane "<<tjs.fHits[iht].ArtPtr->WireID().Plane<<" != "<<ipl;
             return false;
           }
           if(tjs.fHits[iht].ArtPtr->WireID().Wire != wire) {
             mf::LogWarning("TC")<<"CheckWireHitRange: Invalid wire "<<tjs.fHits[iht].ArtPtr->WireID().Wire<<" != "<<wire<<" in plane "<<ipl;
             return false;
           }
         } // iht
       } // wire
     } // ipl
     
     return true;
     
   } // CheckWireHitRange

float tca::ChgFracBetween	(	TjStuff &	tjs,
		TrajPoint	tp,
		float	toPos0,
		bool	prt
	)

Definition at line 1527 of file Utils.cxx.

References tca::TrajPoint::Dir, tca::TrajPoint::Pos, and SignalAtTp().

Referenced by SignalBetween().

   {
     // Returns the fraction of wires between tp.Pos[0] and toPos0 that have a hit 
     // on the line defined by tp.Pos and tp.Dir
     
     if(tp.Pos[0] < -0.4 || toPos0 < -0.4) return 0;
     int fromWire = std::nearbyint(tp.Pos[0]);
     int toWire = std::nearbyint(toPos0);
     
     if(fromWire == toWire) {
       if(prt) mf::LogVerbatim("TC")<<" SignalBetween fromWire = toWire = "<<fromWire<<" SignalAtTp? "<<SignalAtTp(tjs, tp);
       return SignalAtTp(tjs, tp);
     }
     
     int nWires = abs(toWire - fromWire) + 1;
     
     if(std::abs(tp.Dir[0]) < 0.001) tp.Dir[0] = 0.001;
     float stepSize = std::abs(1/tp.Dir[0]);
     // ensure that we step in the right direction
     if(toWire > fromWire && tp.Dir[0] < 0) stepSize = -stepSize;
     if(toWire < fromWire && tp.Dir[0] > 0) stepSize = -stepSize;
     float nsig = 0;
     float num = 0;
     for(unsigned short cnt = 0; cnt < nWires; ++cnt) {
       ++num;
       if(SignalAtTp(tjs, tp)) ++nsig;
       tp.Pos[0] += tp.Dir[0] * stepSize;
       tp.Pos[1] += tp.Dir[1] * stepSize;
     } // cnt
     float sigFrac = nsig / num;
     if(prt) mf::LogVerbatim("TC")<<"  ChgFracBetween fromWire "<<fromWire<<" toWire "<<toWire<<" nWires "<<num<<" nsig "<<nsig<<" "<<sigFrac;
     return sigFrac;
     
   } // ChgFracBetween

float tca::ChgFracBetween	(	TjStuff &	tjs,
		Point3_t	pos1,
		Point3_t	pos2,
		geo::TPCID	tpcid
	)

Definition at line 2860 of file PFPUtils.cxx.

References detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, tca::TrajPoint::CTP, tca::TjStuff::detprop, dir, EncodeCTP(), tca::TjStuff::geom, tca::TjStuff::NumPlanes, PointDirection(), tca::TrajPoint::Pos, PosSep(), SignalAtTp(), geo::TPCID::TPC, tca::TjStuff::TPCID, tca::TjStuff::UnitsPerTick, geo::GeometryCore::WireCoordinate(), and tca::TjStuff::WirePitch.

Referenced by DotProd(), FindNeutralVertices(), FindParent(), ParentFOM(), and tca::TruthMatcher::StudyShowerParents().

   {
     // Step between pos1 and pos2 and find the fraction of the points that have nearby hits
     // in each plane. This function returns -1 if something is fishy, but this doesn't mean
     // that there is no charge. Note that there is no check for charge precisely at the pos1 and pos2
     // positions 
     if(tpcid != tjs.TPCID) return -1;
     float sep = PosSep(pos1, pos2);
     if(sep == 0) return -1;
     unsigned short nstep = sep / tjs.WirePitch;
     auto dir = PointDirection(pos1, pos2);
     float sum = 0;
     float cnt = 0;
     TrajPoint tp;
     for(unsigned short step = 0; step < nstep; ++step) {
       for(unsigned short xyz = 0; xyz < 3; ++xyz) pos1[xyz] += tjs.WirePitch * dir[xyz];
       for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
         tp.CTP = EncodeCTP(tpcid.Cryostat, tpcid.TPC, plane);
         tp.Pos[0] = tjs.geom->WireCoordinate(pos1[1], pos1[2], plane, tpcid.TPC, tpcid.Cryostat);
         tp.Pos[1] = tjs.detprop->ConvertXToTicks(pos1[0], plane, tpcid.TPC, tpcid.Cryostat) * tjs.UnitsPerTick;
         ++cnt;
         if(SignalAtTp(tjs, tp)) ++sum;
       } // plane
     } // step
     if(cnt == 0) return -1;
     return sum / cnt;
     
   } // ChgFracBetween

float tca::ChgFracNearEnd	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		unsigned short	end
	)

Definition at line 2890 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, ChgFracNearPos(), detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, tca::TjStuff::detprop, EncodeCTP(), tca::TjStuff::geom, tca::PFPStruct::ID, tca::TjStuff::NumPlanes, tca::TjStuff::NumWires, tca::PFPStruct::TjIDs, geo::TPCID::TPC, tca::PFPStruct::TPCID, tca::TjStuff::TPCID, tca::TjStuff::UnitsPerTick, geo::GeometryCore::WireCoordinate(), tca::TjStuff::WireHitRange, and tca::PFPStruct::XYZ.

Referenced by DotProd(), and FindNeutralVertices().

   {
     // returns the charge fraction near the end of the pfp. Note that this function
     // assumes that there is only one Tj in a plane.
     if(pfp.ID == 0) return 0;
     if(pfp.TjIDs.empty()) return 0;
     if(end < 0 || end > 1) return 0;
     if(pfp.TPCID != tjs.TPCID) return 0;
 
     float sum = 0;
     float cnt = 0;
     // keep track of the lowest value and maybe reject it
     float lo = 1;
     float hi = 0;
     for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
       CTP_t inCTP = EncodeCTP(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
       std::vector<int> tjids(1);
       for(auto tjid : pfp.TjIDs) {
         auto& tj = tjs.allTraj[tjid - 1];
         if(tj.CTP != inCTP) continue;
         tjids[0] = tjid;
         Point2_t pos;
         geo::PlaneID planeID = geo::PlaneID(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
         pos[0] = tjs.geom->WireCoordinate(pfp.XYZ[end][1], pfp.XYZ[end][2], planeID);
         if(pos[0] < -0.4) continue;
         // check for dead wires
         unsigned int wire = std::nearbyint(pos[0]);
         if(wire > tjs.NumWires[plane]) continue;
         if(tjs.WireHitRange[plane][wire].first == -1) continue;
         pos[1] = tjs.detprop->ConvertXToTicks(pfp.XYZ[end][0], planeID) * tjs.UnitsPerTick;
         float cf = ChgFracNearPos(tjs, pos, tjids);
         if(cf < lo) lo = cf;
         if(cf > hi) hi = cf;
         sum += cf;
         ++cnt;
       } // tjid
     } // plane
     if(cnt == 0) return 0;
     if(cnt > 1 && lo < 0.3 && hi > 0.8) {
       sum -= lo;
       --cnt;
     }
     return sum / cnt;
   } // ChgFracNearEnd

float tca::ChgFracNearPos	(	TjStuff &	tjs,
		const Point2_t &	pos,
		const std::vector< int > &	tjIDs
	)

Definition at line 2614 of file Utils.cxx.

References tca::TjStuff::allTraj, DecodeCTP(), tca::TjStuff::fHits, FindCloseHits(), kAllHits, and geo::PlaneID::Plane.

Referenced by ChgFracNearEnd(), tca::TrajClusterAlg::ChkStop(), CompleteIncomplete3DVertices(), CompleteIncomplete3DVerticesInGaps(), tca::TrajClusterAlg::EndMerge(), ParentFOM(), and SetVx2Score().

   {
     // returns the fraction of the charge in the region around pos that is associated with
     // the list of Tj IDs
     if(tjIDs.empty()) return 0;
     std::array<int, 2> wireWindow;
     Point2_t timeWindow;
     // 1/2 size of the region
     constexpr float NNDelta = 5; 
     wireWindow[0] = pos[0] - NNDelta;
     wireWindow[1] = pos[0] + NNDelta;
     timeWindow[0] = pos[1] - NNDelta;
     timeWindow[1] = pos[1] + NNDelta;
     // do some checking
     for(auto& tjID : tjIDs) if(tjID <= 0 || tjID > (int)tjs.allTraj.size()) return 0;
     // Determine which plane we are in
     geo::PlaneID planeID = DecodeCTP(tjs.allTraj[tjIDs[0]-1].CTP);
     // get a list of all hits in this region
     bool hitsNear;
     std::vector<unsigned int> closeHits = FindCloseHits(tjs, wireWindow, timeWindow, planeID.Plane, kAllHits, true, hitsNear);
     if(closeHits.empty()) return 0;
     float chg = 0;
     float tchg = 0;
     // Add the hit charge in the box
     // All hits in the box, and all hits associated with the Tjs
     for(auto& iht : closeHits) {
       chg += tjs.fHits[iht].Integral;
       if(tjs.fHits[iht].InTraj == 0) continue;
       if(std::find(tjIDs.begin(), tjIDs.end(), tjs.fHits[iht].InTraj) != tjIDs.end()) tchg += tjs.fHits[iht].Integral;
     } // iht
     if(chg == 0) return 0;
     return tchg / chg;
   } // ChgFracNearPos

float tca::ChgToMeV ( float chg )

Definition at line 4460 of file TCShower.cxx.

Referenced by FindParent(), MergeSubShowersTj(), ShowerEnergy(), tca::TruthMatcher::StudyShowerParents(), and UpdateShower().

   {
     // Conversion from shower charge to energy in MeV. The calibration factor
     // was found by processing 500 pizero events with StudyPiZeros using StudyMode
     return 0.012 * chg;
   }

bool tca::ChkAssns	(	std::string	inFcnLabel,
		TjStuff &	tjs
	)

Definition at line 4625 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::cots, kKilled, tca::TjStuff::showers, and ss.

Referenced by CompleteIncompleteShower(), FindShowers3D(), Finish3DShowers(), Match2DShowers(), MergeNearby2DShowers(), MergeOverlap(), MergeShowerChain(), MergeSubShowers(), MergeSubShowersTj(), and Reconcile3D().

   {
     // check tj - ss assns
     
     std::string fcnLabel = inFcnLabel + ".ChkAssns";
     for(auto& ss : tjs.cots) {
       if(ss.ID == 0) continue;
       for(auto tid : ss.TjIDs) {
         auto& tj = tjs.allTraj[tid - 1];
         if(tj.SSID != ss.ID) {
           std::cout<<fcnLabel<<" ***** Error: 2S"<<ss.ID<<" -> TjIDs T"<<tid<<" != tj.SSID 2S"<<tj.SSID<<"\n";
           return false;
         }
       } // tid
       // check 2S -> 3S
       if(ss.SS3ID > 0 && ss.SS3ID <= (int)tjs.showers.size()) {
         auto& ss3 = tjs.showers[ss.SS3ID - 1];
         if(std::find(ss3.CotIDs.begin(), ss3.CotIDs.end(), ss.ID) == ss3.CotIDs.end()) {
           std::cout<<fcnLabel<<" ***** Error: 2S"<<ss.ID<<" -> 3S"<<ss.SS3ID<<" but the shower says no\n";
           return false;
         }
       } // ss.SS3ID > 0
     } // ss
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       if(tj.SSID < 0) {
         std::cout<<fcnLabel<<" ***** Error: T"<<tj.ID<<" tj.SSID is fubar\n";
         tj.SSID = 0;
         return false;
       }
       if(tj.SSID == 0) continue;
       auto& ss = tjs.cots[tj.SSID - 1];
       if(std::find(ss.TjIDs.begin(), ss.TjIDs.end(), tj.ID) != ss.TjIDs.end()) continue;
       std::cout<<fcnLabel<<" ***** Error: T"<<tj.ID<<" tj.SSID = 2S"<<tj.SSID<<" but the shower says no\n";
       return false;
     } // tj
     
     for(auto& ss3 : tjs.showers) {
       if(ss3.ID == 0) continue;
       for(auto cid : ss3.CotIDs) {
         auto& ss = tjs.cots[cid - 1];
         if(ss.SS3ID != ss3.ID) {
           std::cout<<fcnLabel<<" ***** Error: 3S"<<ss3.ID<<" -> 2S"<<cid<<" but it thinks it belongs to 3S"<<ss.SS3ID<<"\n";
           return false;
         }
       } // cid
     } // ss3
     return true;
   } // ChkAssns

void tca::ChkChgAsymmetry	(	TjStuff &	tjs,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 1436 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::EndPt, tca::Trajectory::ID, kChkChgAsym, PrintTrajectory(), tca::Trajectory::Pts, SetEndPoints(), UnsetUsedHits(), and tca::TjStuff::UseAlg.

Referenced by tca::TrajClusterAlg::CheckTraj().

   {
     // looks for a high-charge point in the trajectory which may be due to the
     // trajectory crossing an interaction vertex. The properties of points on the opposite
     // sides of the high-charge point are analyzed. If significant differences are found, all points
     // near the high-charge point are removed as well as those from that point to the end
     if(!tjs.UseAlg[kChkChgAsym]) return;
     unsigned short npts = tj.EndPt[1] - tj.EndPt[0];
     if(prt) mf::LogVerbatim("TC")<<" Inside ChkChgAsymmetry T"<<tj.ID;
     // ignore long tjs
     if(npts > 50) return;
     // ignore short tjs
     if(npts < 8) return;
     // require the charge pull > 5
     float bigPull = 5;
     unsigned short atPt = 0;
     // Don't consider the first/last few points in case there is a Bragg peak
     for(unsigned short ipt = tj.EndPt[0] + 2; ipt <= tj.EndPt[1] - 2; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if(tp.ChgPull > bigPull) {
         bigPull = tp.ChgPull;
         atPt = ipt;
       }
     } // ipt
     if(atPt == 0) return;
     // require that this point be near the DS end
     if((atPt - tj.EndPt[0]) < 0.5 * npts) return;
     if(prt) mf::LogVerbatim("TC")<<"CCA: T"<<tj.ID<<" Large Chg point at "<<atPt<<". Check charge asymmetry around it.";
     unsigned short nchk = 0;
     unsigned short npos = 0;
     unsigned short nneg = 0;
     for(short ii = 1; ii < 5; ++ii) {
       short iplu = atPt + ii;
       if(iplu > tj.EndPt[1]) break;
       short ineg = atPt - ii;
       if(ineg < tj.EndPt[0]) break;
       if(tj.Pts[iplu].Chg == 0) continue;
       if(tj.Pts[ineg].Chg == 0) continue;
       float asym = (tj.Pts[iplu].Chg - tj.Pts[ineg].Chg) / (tj.Pts[iplu].Chg + tj.Pts[ineg].Chg);
       ++nchk;
       if(asym > 0.5) ++npos;
       if(asym < -0.5) ++nneg;
       if(prt) mf::LogVerbatim("TC")<<" ineg "<<ineg<<" iplu "<<iplu<<" asym "<<asym<<" nchk "<<nchk;
     } // ii
     if(nchk < 3) return;
     // require most of the points be very positive or very negative
     nchk -= 2;
     bool doTrim = (nneg > nchk) || (npos > nchk);
     if(!doTrim) return;
     // remove all the points at the end starting at the one just before the peak if the pull is not so good
     auto& prevTP = tj.Pts[atPt - 1];
     if(std::abs(prevTP.ChgPull) > 2) --atPt;
     for(unsigned short ipt = atPt; ipt <= tj.EndPt[1]; ++ipt) UnsetUsedHits(tjs, tj.Pts[ipt]);
     SetEndPoints(tjs, tj);
     tj.AlgMod[kChkChgAsym] = true;
     if(prt) PrintTrajectory("CCA", tjs, tj, USHRT_MAX);
   } // ChkChgAsymmetry

bool tca::ChkVtxAssociations	(	TjStuff &	tjs,
		const CTP_t &	inCTP
	)

Definition at line 2128 of file TCVertex.cxx.

References tca::TjStuff::allTraj, DecodeCTP(), evd::details::end(), kKilled, geo::PlaneID::Plane, tca::TjStuff::vtx, and tca::TjStuff::vtx3.

Referenced by tca::TrajClusterAlg::ReconstructAllTraj(), and tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // Check the associations
 
     // check the 2D -> 3D associations
     geo::PlaneID planeID = DecodeCTP(inCTP);
     unsigned short plane = planeID.Plane;
     for(auto& vx2 : tjs.vtx) {
       if(vx2.CTP != inCTP) continue;
       if(vx2.ID == 0) continue;
       if(vx2.Vx3ID == 0) continue;
       if(vx2.Vx3ID > int(tjs.vtx3.size())) {
         mf::LogVerbatim("TC")<<"ChkVtxAssociations: Invalid vx2.Vx3ID "<<vx2.Vx3ID<<" in 2D vtx "<<vx2.ID;
         return false;
       }
       auto& vx3 = tjs.vtx3[vx2.Vx3ID-1];
       if(vx3.ID == 0) {
         mf::LogVerbatim("TC")<<"ChkVtxAssociations: 2V"<<vx2.ID<<" thinks it is matched to 3V"<<vx3.ID<<" but vx3 is obsolete";
         return false;
       }
       if(vx3.Vx2ID[plane] != vx2.ID) {
         mf::LogVerbatim("TC")<<"ChkVtxAssociations: 2V"<<vx2.ID<<" thinks it is matched to 3V"<<vx3.ID<<" but vx3 says no!";
         return false;
       }
     } // vx2
     // check the 3D -> 2D associations
     for(auto& vx3 : tjs.vtx3) {
       if(vx3.ID == 0) continue;
       if(vx3.Vx2ID[plane] == 0) continue;
       if(vx3.Vx2ID[plane] > (int)tjs.vtx.size()) {
         mf::LogVerbatim("TC")<<"ChkVtxAssociations: Invalid vx3.Vx2ID "<<vx3.Vx2ID[plane]<<" in CTP "<<inCTP;
         return false;
       }
       auto& vx2 = tjs.vtx[vx3.Vx2ID[plane]-1];
       if(vx2.Vx3ID != vx3.ID) {
         mf::LogVerbatim("TC")<<"ChkVtxAssociations: 3V"<<vx3.ID<<" thinks it is matched to 2V"<<vx2.ID<<" but vx2 says no!";
         return false;
       }
     } // vx3
     
     // check the Tj -> 2D associations
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       for(unsigned short end = 0; end < 2; ++end) {
         if(tj.VtxID[end] == 0) continue;
         if(tj.VtxID[end] > tjs.vtx.size()) {
           mf::LogVerbatim("TC")<<"ChkVtxAssociations: T"<<tj.ID<<" thinks it is matched to 2V"<<tj.VtxID[end]<<" on end "<<end<<" but no vertex exists. Recovering";
           tj.VtxID[end] = 0;
           return false;
         }
         unsigned short ivx = tj.VtxID[end] - 1;
         auto& vx2 = tjs.vtx[ivx];
         if(vx2.ID == 0) {
           mf::LogVerbatim("TC")<<"ChkVtxAssociations: T"<<tj.ID<<" thinks it is matched to 2V"<<tj.VtxID[end]<<" on end "<<end<<" but the vertex is killed. Fixing the Tj";
           tj.VtxID[end] = 0;
           return false;
         }
       } // end
     } // tj
     
     return true;
     
   } // ChkVtxAssociations

void tca::ChkVxTjs	(	TjStuff &	tjs,
		const CTP_t &	inCTP,
		bool	prt
	)

Definition at line 715 of file TCVertex.cxx.

References tca::TjStuff::allTraj, close(), CompatibleMerge(), DeltaAngle(), FarEnd(), GetAssns(), kChkVxTj, kDeltaRay, kFixed, kKilled, MakeVertexObsolete(), MergeAndStore(), PointTrajDOCA(), PosSep(), PrintPos(), tca::TjStuff::UseAlg, and tca::TjStuff::vtx.

Referenced by tca::TrajClusterAlg::EndMerge(), and Find2DVertices().

   {
     // 
     
     if(!tjs.UseAlg[kChkVxTj]) return;
     
     for(unsigned short ivx = 0; ivx < tjs.vtx.size(); ++ivx) {
       auto& vx2 = tjs.vtx[ivx];
       if(vx2.ID == 0) continue;
       if(vx2.CTP != inCTP) continue;
       auto vxtjs = GetAssns(tjs, "2V", vx2.ID, "T");
       if(vxtjs.size() < 2) continue;
       // BB added June 4, 2018
       // find the closest separation between the vertex and the ends of the tjs
       float close = 200;
       int closeID = 0;
       unsigned short closeEnd = 0;
       for(auto tid : vxtjs) {
         auto& tj = tjs.allTraj[tid - 1];
         unsigned short nearEnd = 1 - FarEnd(tjs, tj, vx2.Pos);
         if(tj.VtxID[nearEnd] != vx2.ID) continue;
         float sep = PosSep(tj.Pts[tj.EndPt[nearEnd]].Pos, vx2.Pos);
         if(sep > close) continue;
         close = sep;
         closeID = tid;
         closeEnd = nearEnd;
       } // tid
       if(close > 1.5 && closeID > 0) {
         auto& closeTj = tjs.allTraj[closeID - 1];
         auto& closeTP = closeTj.Pts[closeTj.EndPt[closeEnd]];
         if(prt) mf::LogVerbatim("TC")<<"CVTjs: moved 2V"<<vx2.ID<<" from "<<PrintPos(tjs, vx2.Pos)<<" to "<<PrintPos(tjs, closeTP);
         vx2.Pos = closeTP.Pos;
         vx2.Stat[kFixed] = true;
       }
       for(unsigned short it1 = 0; it1 < vxtjs.size() - 1; ++it1) {
         auto& tj1 = tjs.allTraj[vxtjs[it1] - 1];
         if(tj1.AlgMod[kKilled]) continue;
         unsigned short end1 = 0;
         if(tj1.VtxID[1] == vx2.ID) end1 = 1;
         auto& vtp1 = tj1.Pts[tj1.EndPt[end1]];
         auto& otp1 = tj1.Pts[tj1.EndPt[1 - end1]];
         float tj1sep = PosSep(vtp1.Pos, vx2.Pos);
         for(unsigned short it2 = it1 + 1; it2 < vxtjs.size(); ++it2) {
           auto& tj2 = tjs.allTraj[vxtjs[it2] - 1];
           if(tj2.AlgMod[kKilled]) continue;
           unsigned short end2 = 0;
           if(tj2.VtxID[2] == vx2.ID) end2 = 1;
           auto& vtp2 = tj2.Pts[tj2.EndPt[end2]];
           auto& otp2 = tj2.Pts[tj2.EndPt[1 - end2]];
           float tj2sep = PosSep(vtp2.Pos, vx2.Pos);
           float otj1tj2 = PosSep(otp1.Pos, vtp2.Pos);
           float delta12 = PointTrajDOCA(tjs, otp1.Pos[0], otp1.Pos[1], vtp2);
           float dang12 = DeltaAngle(otp1.Ang, vtp2.Ang);
           if(otj1tj2 < tj2sep && delta12 < 1 && otj1tj2 < 4) {
             if(prt) {
               mf::LogVerbatim myprt("TC");
               myprt<<"CVTjs: "<<vx2.ID<<" tj1 "<<tj1.ID<<" tj2 "<<tj2.ID;
               myprt<<" otj1tj2 "<<otj1tj2;
               myprt<<" delta12 "<<delta12;
               myprt<<" dang12 "<<dang12;
               myprt<<" Try to merge";
             }
             // End 1 of tj1 is closer to end0 of tj2 than tj2 is to the vertex
             tj2.VtxID[end2] = 0;
             if(CompatibleMerge(tjs, tj1, tj2, prt) && MergeAndStore(tjs, vxtjs[it1], vxtjs[it2], prt)) {
               auto& newTj = tjs.allTraj[tjs.allTraj.size()-1];
               newTj.AlgMod[kChkVxTj] = true;
               if(prt) mf::LogVerbatim("TC")<<"CVTjs: Merged tjs "<<tj1.ID<<" and "<<tj2.ID<<" -> "<<newTj.ID;
             } else {
               if(prt) mf::LogVerbatim("TC")<<"CVTjs: Merge failed";
             }
             continue;
           } // other end is closer
           // now check the other end of tj2
           float tj1otj2 = PosSep(vtp1.Pos, otp2.Pos);
           if(tj1otj2 < tj1sep && delta12 < 1 && tj1otj2 < 4) {
             // End 1 of tj1 is closer to end0 of tj2 than tj2 is to the vertex
             tj1.VtxID[end1] = 0;
             if(CompatibleMerge(tjs, tj2, tj1, prt) && MergeAndStore(tjs, vxtjs[it2], vxtjs[it1], prt)) {
               auto& newTj = tjs.allTraj[tjs.allTraj.size()-1];
               newTj.AlgMod[kChkVxTj] = true;
               if(prt) mf::LogVerbatim("TC")<<"CVTjs: Merged tjs "<<tj1.ID<<" and "<<tj2.ID<<" -> "<<newTj.ID;
             } else {
               if(prt) mf::LogVerbatim("TC")<<"CVTjs: Merge failed";
             }
           } // the other end is closer
         } // it2
       } // it1
       // Check for delta-rays that have a vertex when they should have been merged
       if(vx2.Topo == 1 && vxtjs.size() == 2) {
         auto& tj1 = tjs.allTraj[vxtjs[0] - 1];
         auto& tj2 = tjs.allTraj[vxtjs[1] - 1];
         // ensure that these weren't killed above
         if(tj1.AlgMod[kKilled] || tj2.AlgMod[kKilled]) continue;
         if(tj1.AlgMod[kDeltaRay] || tj2.AlgMod[kDeltaRay]) {
           if(prt) mf::LogVerbatim("TC")<<"CVTjs: Merge delta rays "<<tj1.ID<<" and "<<tj2.ID<<" CompatibleMerge? "<<CompatibleMerge(tjs, tj1, tj2, prt);
           MakeVertexObsolete(tjs, vx2, true);
           MergeAndStore(tjs, vxtjs[0] - 1, vxtjs[1] - 1, prt);
         } // one is a tagged delta-ray
       } // delta-ray check
     } // ivx
   } // ChkVxTjs

void tca::CleanTjs	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		bool	prt
	)

void tca::ClearCRInfo ( TjStuff & tjs )

Definition at line 117 of file TCCR.cxx.

References tca::CRTreeVars::cr_origin, tca::CRTreeVars::cr_pfpxmax, tca::CRTreeVars::cr_pfpxmin, tca::CRTreeVars::cr_pfpyzmindis, and tca::TjStuff::crt.

Referenced by tca::TrajClusterAlg::ClearResults().

                                 {
     tjs.crt.cr_origin.clear();
     tjs.crt.cr_pfpxmin.clear();
     tjs.crt.cr_pfpxmax.clear();
     tjs.crt.cr_pfpyzmindis.clear();
   }

void tca::ClearShowerTree ( ShowerTreeVars & stv )

Definition at line 203 of file TCShTree.cxx.

Referenced by tca::TrajClusterAlg::ClearResults().

                                             {
     stv.BeginWir.clear();
     stv.BeginTim.clear();
     stv.BeginAng.clear();
     stv.BeginChg.clear();
     stv.BeginVtx.clear();
     stv.EndWir.clear();
     stv.EndTim.clear();
     stv.EndAng.clear();
     stv.EndChg.clear();
     stv.EndVtx.clear();
     stv.MCSMom.clear();
     stv.PlaneNum.clear();
     stv.TjID.clear();
     stv.IsShowerTj.clear();
     stv.ShowerID.clear();
     stv.IsShowerParent.clear();
     stv.StageNum.clear();
     stv.Envelope.clear();
     stv.EnvPlane.clear();
     stv.EnvStage.clear();
     stv.EnvShowerID.clear();
 
     return;
 
   } // ClearShowerTree

unsigned short tca::CloseEnd	(	TjStuff &	tjs,
		const Trajectory &	tj,
		const Point2_t &	pos
	)

Definition at line 2120 of file Utils.cxx.

References tca::Trajectory::EndPt, PosSep2(), and tca::Trajectory::Pts.

Referenced by FindNeutralVertices(), and MergeWithVertex().

   {
     unsigned short endPt = tj.EndPt[0];
     auto& tp0 = tj.Pts[endPt];
     endPt = tj.EndPt[1];
     auto& tp1 = tj.Pts[endPt];
     if(PosSep2(tp0.Pos, pos) < PosSep2(tp1.Pos, pos)) return 0;
     return 1;
   } // CloseEnd

bool tca::CompatibleMerge	(	TjStuff &	tjs,
		std::vector< int > &	tjIDs,
		bool	prt
	)

Definition at line 455 of file Utils.cxx.

References tca::TjStuff::allTraj, evd::details::end(), and TrajClosestApproach().

Referenced by ChkVxTjs(), DefinePFP(), and tca::TrajClusterAlg::EndMerge().

   {
     // Returns true if the last Tj in tjIDs has a topology consistent with it being
     // merged with other Tjs in the same plane in the list. This is done by requiring that
     // the closest TP between the last Tj and any other Tj is EndPt[0] or EndPt[1]. This is
     // shown graphically here where the numbers represent the ID of a Tj that has a TP on a wire.
     // Assume that TjIDs = {1, 2, 3, 4, 7} where T1 and T3 are in plane 0, T2 is in plane 1 and
     // T4 is in plane 2. T7, in plane 0, was added to TjIDs with the intent of merging it with
     // T1 and T3 into a single trajectory. This is a compatible merge if Tj7 has the following
     // topology:
     //  111111 333333 7777777
     // This is an incompatible topology
     //  111111 333333
     //      7777777777
     if(tjIDs.size() < 2) return false;
     unsigned short lasttj = tjIDs[tjIDs.size() - 1] - 1;
     auto& mtj = tjs.allTraj[lasttj];
     bool mtjIsShort = (mtj.Pts.size() < 5);
     // minimum separation from each end of mtj
     std::array<float, 2> minsep2 {{1000, 1000}};
     // ID of the Tj with the minimum separation
     std::array<int, 2> minsepTj {{0, 0}};
     // and the index of the point on that Tj
     std::array<unsigned short, 2> minsepPt;
     // determine the end of the closest Tj point. Start by assuming
     // the closest Tj point is not near an end (end = 0);
     std::array<unsigned short, 2> minsepEnd;
     for(auto tjid : tjIDs) {
       auto& tj = tjs.allTraj[tjid - 1];
       if(tj.CTP != mtj.CTP) continue;
       if(tj.ID == mtj.ID) continue;
       for(unsigned short mend = 0; mend < 2; ++mend) {
         Point2_t mendPos = mtj.Pts[mtj.EndPt[mend]].Pos;
         float sep2 = minsep2[mend];
         unsigned short closePt = 0;
         if(!TrajClosestApproach(tj, mendPos[0], mendPos[1], closePt, sep2)) continue;
         minsep2[mend] = sep2;
         minsepTj[mend] = tjid;
         minsepPt[mend] = closePt;
         // set the end to a bogus value (not near an end)
         minsepEnd[mend] = 2;
         short dend0 = abs((short)closePt - tj.EndPt[0]);
         short dend1 = abs((short)closePt - tj.EndPt[1]);
         if(dend0 < dend1 && dend0 < 3) minsepEnd[mend] = 0;
         if(dend1 < dend0 && dend1 < 3) minsepEnd[mend] = 1;
       } // mend
     } // tjid
 //    bool isCompatible = (minsepEnd[0] != 2 && minsepTj[0] == minsepTj[1] && minsepEnd[0] == minsepEnd[1]);
     // don't require that the minsepTjs be the same. This would reject this topology
     //  111111 333333 7777777
     // if mtj.ID = 3
     bool isCompatible = (minsepEnd[0] != 2 && minsepEnd[1] != 2);
     // check for large separation between the closest points for short Tjs
     if(isCompatible && mtjIsShort) {
       float minminsep = minsep2[0];
       if(minsep2[1] < minminsep) minminsep = minsep2[1];
       // require that the separation be less than sqrt(5)
       isCompatible = minminsep < 5;
 //      if(minminsep > 2) std::cout<<"CM: mtj T"<<mtj.ID<<" is short and the separation is large "<<minminsep<<". Check for signal between\n ";
     }
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"CompatibleMerge: T"<<mtj.ID<<" end";
       for(unsigned short end = 0; end < 2; ++end) myprt<<" T"<<minsepTj[end]<<"_I"<<minsepPt[end]<<"_E"<<minsepEnd[end]<<" minsep "<<sqrt(minsep2[end]);
       myprt<<" Compatible? "<<isCompatible;
     } // prt
     return isCompatible;
     
   } // CompatibleMerge

bool tca::CompatibleMerge	(	TjStuff &	tjs,
		const Trajectory &	tj1,
		const Trajectory &	tj2,
		bool	prt
	)

Definition at line 526 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::CTP, DeltaAngle(), tca::Trajectory::EndPt, tca::Trajectory::ID, tca::TjStuff::KinkCuts, kKilled, OverlapFraction(), PointTrajDOCA(), PosSep(), and tca::Trajectory::Pts.

   {
     // returns true if the two Tjs are compatible with and end0-end1 merge. This function has many aspects of the
     // compatibility checks done in EndMerge but with looser cuts.
     if(tj1.AlgMod[kKilled] || tj2.AlgMod[kKilled]) return false;
     if(tj1.CTP != tj2.CTP) return false;
     unsigned short end1 = -1, end2 = 0;
     float minLen = PosSep(tj1.Pts[tj1.EndPt[0]].Pos, tj1.Pts[tj1.EndPt[1]].Pos);
     float len2 = PosSep(tj2.Pts[tj2.EndPt[0]].Pos, tj2.Pts[tj2.EndPt[1]].Pos);
     if(len2 < minLen) minLen = len2;
     minLen *= 1.2;
     if(minLen > 10) minLen = 10;
     for(unsigned short e1 = 0; e1 < 2; ++e1) {
       auto& tp1 = tj1.Pts[tj1.EndPt[e1]];
       for(unsigned short e2 = 0; e2 < 2; ++e2) {
         auto& tp2 = tj2.Pts[tj2.EndPt[e2]];
         float sep = PosSep(tp1.Pos, tp2.Pos);
         if(sep < minLen) {
           minLen = sep;
           end1 = e1; end2 = e2;
         }
       } // e2
     } // e1
     if(end1 < 0) return false;
     // require end to end
     if(end2 != 1 - end1) return false;
     
     float overlapFraction = OverlapFraction(tjs, tj1, tj2);
     if(overlapFraction > 0.25) {
       if(prt) mf::LogVerbatim("TC")<<"CM: "<<tj1.ID<<" "<<tj2.ID<<" overlapFraction "<<overlapFraction<<" > 0.25 ";
       return false;
     }
     
     auto& tp1 = tj1.Pts[tj1.EndPt[end1]];
     auto& tp2 = tj2.Pts[tj2.EndPt[end2]];
 /* This causes problems with hit collections that have cosmics removed
     if(!SignalBetween(tjs, tp1, tp2, 0.8, false)) {
       if(prt) mf::LogVerbatim("TC")<<"CM: "<<tj1.ID<<" "<<tj2.ID<<" no signal between these points "<<PrintPos(tjs, tp1.Pos)<<" "<<PrintPos(tjs, tp2.Pos);
       return false;
     }
 */
     float doca1 = PointTrajDOCA(tjs, tp1.Pos[0], tp1.Pos[1], tp2);
     float doca2 = PointTrajDOCA(tjs, tp2.Pos[0], tp2.Pos[1], tp1);
     if(doca1 > 2 && doca2 > 2) {
       if(prt) mf::LogVerbatim("TC")<<"CM: "<<tj1.ID<<" "<<tj2.ID<<" Both docas > 2 "<<doca1<<" "<<doca2;
       return false;
     }
     
     float dang = DeltaAngle(tp1.Ang, tp2.Ang);
     if(dang > 2 * tjs.KinkCuts[0]) {
       if(prt) mf::LogVerbatim("TC")<<"CM: "<<tj1.ID<<" "<<tj2.ID<<" dang "<<dang<<" > "<<2 * tjs.KinkCuts[0];
       return false;
     }
     
     return true;
   } // CompatibleMerge

void tca::CompleteIncomplete3DVertices	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid
	)

Definition at line 2569 of file TCVertex.cxx.

References tca::TjStuff::allTraj, AttachAnyTrajToVertex(), ChgFracNearPos(), detinfo::DetectorProperties::ConvertXToTicks(), tca::VtxStore::CTP, debug, tca::TjStuff::detprop, EncodeCTP(), evd::details::end(), GetAssns(), tca::VtxStore::ID, kComp3DVx, kFixed, kKilled, MakeVertexObsolete(), tca::VtxStore::NTraj, tca::TjStuff::NumPlanes, NumPtsWithCharge(), tca::VtxStore::Pass, tca::DebugStuff::Plane, tca::VtxStore::Pos, tca::TrajPoint::Pos, PrintPos(), RefineVtxPosition(), SetPDGCode(), SetVx2Score(), SplitTraj(), tca::VtxStore::Stat, StoreVertex(), tca::DebugStuff::Tick, tca::VtxStore::TjChgFrac, util::flags::to_string(), tca::VtxStore::Topo, TrajPointTrajDOCA(), tca::TjStuff::UnitsPerTick, tca::TjStuff::UseAlg, tca::TjStuff::vtx, tca::TjStuff::vtx3, and tca::VtxStore::Vx3ID.

Referenced by Find3DVertices().

   {
     // Look for trajectories in a plane that lack a 2D vertex as listed in
     // 2DVtxID that are near the projected wire. This may trigger splitting trajectories,
     // assigning them to a new 2D vertex and completing 3D vertices
     
     if(!tjs.UseAlg[kComp3DVx]) return;
     if(tjs.NumPlanes != 3) return;
     
     bool prt = (debug.Plane >= 0 && debug.Tick == 33333);
     
     float maxdoca = 3;
     if(prt) mf::LogVerbatim("TC")<<"Inside CI3DV with maxdoca set to "<<maxdoca;
     unsigned short ivx3 = 0;
     for(auto& vx3 : tjs.vtx3) {
       // ignore obsolete vertices
       if(vx3.ID == 0) continue;
       if(vx3.TPCID != tpcid) continue;
       // check for a completed 3D vertex
       if(vx3.Wire < 0) continue;
       unsigned short mPlane = USHRT_MAX;
       for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
         if(vx3.Vx2ID[plane] > 0) continue;
         mPlane = plane;
       } // ipl
       if(mPlane == USHRT_MAX) continue;
       CTP_t mCTP = EncodeCTP(vx3.TPCID.Cryostat, vx3.TPCID.TPC, mPlane);
       // X position of the purported missing vertex
       // A TP for the missing 2D vertex
       TrajPoint vtp;
       vtp.Pos[0] = vx3.Wire;
       vtp.Pos[1] = tjs.detprop->ConvertXToTicks(vx3.X, mPlane, vx3.TPCID.TPC, vx3.TPCID.Cryostat) * tjs.UnitsPerTick;
       if(prt) mf::LogVerbatim("TC")<<"CI3DV 3V"<<vx3.ID<<" Pos "<<mPlane<<":"<<PrintPos(tjs, vtp.Pos);
       std::vector<int> tjIDs;
       std::vector<unsigned short> tjPts;
       for(auto& tj : tjs.allTraj) {
         if(tj.CTP != mCTP) continue;
         if(tj.AlgMod[kKilled]) continue;
         if(tj.Pts.size() < 6) continue;
         if(tj.AlgMod[kComp3DVx]) continue;
         float doca = maxdoca;
         // find the closest distance between the vertex and the trajectory
         unsigned short closePt = 0;
         TrajPointTrajDOCA(tjs, vtp, tj, closePt, doca);
         if(closePt > tj.EndPt[1]) continue;
         // try to improve the location of the vertex by looking for a distinctive feature on the
         // trajectory, e.g. high multiplicity hits or larger than normal charge
         if(RefineVtxPosition(tjs, tj, closePt, 3, false)) vtp.Pos = tj.Pts[closePt].Pos;
         if(prt) mf::LogVerbatim("TC")<<"CI3DV 3V"<<vx3.ID<<" candidate itj ID "<<tj.ID<<" vtx pos "<<PrintPos(tjs, vtp.Pos)<<" doca "<<doca;
         tjIDs.push_back(tj.ID);
         tjPts.push_back(closePt);
       } // itj
       if(tjIDs.empty()) continue;
       // compare the length of the Tjs used to make the vertex with the length of the
       // Tj that we want to split. Don't allow a vertex using very short Tjs to split a long
       // Tj in the 3rd plane
 //      float score;
 //      auto vxtjs = GetVtxTjIDs(tjs, vx3, score);
       auto vxtjs = GetAssns(tjs, "3V", vx3.ID, "T");
       unsigned short maxPts = 0;
       for(auto tjid : vxtjs) {
         auto& tj = tjs.allTraj[tjid - 1];
         unsigned short npwc = NumPtsWithCharge(tjs, tj, false);
         if(npwc > maxPts) maxPts = npwc;
       } // tjid
       // skip this operation if any of the Tjs in the split list are > 3 * maxPts
       maxPts *= 3;
       bool skipit = false;
       for(auto tjid : tjIDs) {
         auto& tj = tjs.allTraj[tjid - 1];
         if(NumPtsWithCharge(tjs, tj, false) > maxPts) skipit = true;
       } // tjid
       if(prt) mf::LogVerbatim("TC")<<"  maxPts "<<maxPts<<" skipit? "<<skipit;
       if(skipit) continue;
       // 2D vertex
       VtxStore aVtx;
       unsigned short newVtxIndx = tjs.vtx.size();
       aVtx.ID = newVtxIndx + 1;
       aVtx.CTP = mCTP;
       aVtx.Topo = 3;
       aVtx.NTraj = 0;
       // Give it a bogus pass to indicate it wasn't created while stepping
       aVtx.Pass = 9;
       aVtx.Pos = vtp.Pos;
       // ensure this isn't in a messy region
       aVtx.TjChgFrac = ChgFracNearPos(tjs, aVtx.Pos, tjIDs);
       if(prt) mf::LogVerbatim("TC")<<" charge fraction near position "<<aVtx.TjChgFrac;
       if(aVtx.TjChgFrac < 0.6) continue;
       if(!StoreVertex(tjs, aVtx)) continue;
       // make a reference to the new vertex
       VtxStore& newVtx = tjs.vtx[tjs.vtx.size()-1];
       if(prt) mf::LogVerbatim("TC")<<" Stored 2D vertex "<<newVtx.ID;
       // make a temporary copy so we can nudge it a bit if there is only one Tj
       std::array<float, 2> vpos = aVtx.Pos;
       for(unsigned short ii = 0; ii < tjIDs.size(); ++ii) {
         unsigned short itj = tjIDs[ii] - 1;
         // Don't use a reference variable since it may get scrambled after SplitTraj
 //        auto& tj = tjs.allTraj[itj];
         unsigned short closePt = tjPts[ii];
         // determine which end is the closest
         unsigned short end = 1;
         // closest to the beginning?
         if(fabs(closePt - tjs.allTraj[itj].EndPt[0]) < fabs(closePt - tjs.allTraj[itj].EndPt[1])) end = 0;
         short dpt = fabs(closePt - tjs.allTraj[itj].EndPt[end]);
         if(dpt < 3) {
           // close to an end
           if(tjs.allTraj[itj].VtxID[end] > 0) {
             if(prt) mf::LogVerbatim("TC")<<" T"<<tjs.allTraj[itj].ID<<" has a vertex "<<tjs.allTraj[itj].VtxID[end]<<" at end "<<end<<". Skip it";
             continue;
           }
           tjs.allTraj[itj].VtxID[end] = tjs.vtx[newVtxIndx].ID;
           ++newVtx.NTraj;
           if(prt) mf::LogVerbatim("TC")<<" attach Traj T"<<tjs.allTraj[itj].ID<<" at end "<<end;
           tjs.allTraj[itj].AlgMod[kComp3DVx] = true;
           vpos = tjs.allTraj[itj].Pts[tjs.allTraj[itj].EndPt[end]].Pos;
         } else {
           // closePt is not near an end, so split the trajectory
           if(SplitTraj(tjs, itj, closePt, newVtxIndx, prt)) {
             if(prt) mf::LogVerbatim("TC")<<" SplitTraj success 2V"<<tjs.vtx[newVtxIndx].ID<<" at closePt "<<closePt;
             // successfully split the Tj
             newVtx.NTraj += 2;
           } else {
             // split failed. Give up
             if(prt) mf::LogVerbatim("TC")<<" SplitTraj failed";
             newVtx.NTraj = 0;
             break;
           }
           // Update the PDGCode for the chopped trajectory
           SetPDGCode(tjs, itj);
           // and for the new trajectory
           SetPDGCode(tjs, tjs.allTraj.size()-1);
         } // closePt is not near an end, so split the trajectory
         tjs.allTraj[itj].AlgMod[kComp3DVx] = true;
         unsigned short newtj = tjs.allTraj.size() - 1;
         tjs.allTraj[newtj].AlgMod[kComp3DVx] = true;
       } // ii
       if(newVtx.NTraj == 0) {
         // A failure occurred. Recover
         if(prt) mf::LogVerbatim("TC")<<"  Failed. Recover and delete vertex "<<newVtx.ID;
         MakeVertexObsolete(tjs, newVtx, true);
       } else {
         // success
         vx3.Vx2ID[mPlane] = newVtx.ID;
         newVtx.Vx3ID = vx3.ID;
         vx3.Wire = -1;
         // set the vertex position to the start of the Tj if there is only one and fix it
         if(newVtx.NTraj == 1) {
           newVtx.Pos = vpos;
           newVtx.Stat[kFixed] = true;
         }
         AttachAnyTrajToVertex(tjs, newVtx.ID - 1, prt);
         SetVx2Score(tjs, prt);
         if(prt) {
           mf::LogVerbatim myprt("TC");
           myprt<<" Success: new 2V"<<newVtx.ID<<" at "<<(int)newVtx.Pos[0]<<":"<<(int)newVtx.Pos[1]/tjs.UnitsPerTick;
           myprt<<" points to 3V"<<vx3.ID;
           myprt<<" TjIDs:";
           for(auto& tjID : tjIDs) myprt<<" T"<<std::to_string(tjID);
         } // prt
       } // success
       ++ivx3;
     } // vx3
     
   } // CompleteIncomplete3DVertices

void tca::CompleteIncomplete3DVerticesInGaps	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid
	)

Definition at line 2478 of file TCVertex.cxx.

References tca::TjStuff::allTraj, ChgFracNearPos(), detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, tca::VtxStore::CTP, tca::TrajPoint::CTP, DeadWireCount(), debug, tca::TjStuff::detprop, EncodeCTP(), evd::details::end(), tca::VtxStore::ID, tca::Vtx3Store::ID, kComp3DVxIG, kKilled, tca::VtxStore::NTraj, tca::TjStuff::NumPlanes, tca::VtxStore::Pass, tca::DebugStuff::Plane, PointTrajDOCA(), tca::VtxStore::Pos, tca::TrajPoint::Pos, SetVx2Score(), StoreVertex(), tca::DebugStuff::Tick, tca::VtxStore::TjChgFrac, tca::VtxStore::Topo, geo::TPCID::TPC, tca::Vtx3Store::TPCID, tca::TjStuff::UnitsPerTick, tca::TjStuff::UseAlg, tca::TjStuff::vtx, tca::TjStuff::vtx3, tca::Vtx3Store::Vx2ID, tca::VtxStore::Vx3ID, tca::Vtx3Store::Wire, and tca::Vtx3Store::X.

Referenced by Find3DVertices().

   {
     
     if(!tjs.UseAlg[kComp3DVxIG]) return;
     if(tjs.NumPlanes != 3) return;
 
     bool prt = (debug.Plane >= 0 && debug.Tick == 44444);
     if(prt) mf::LogVerbatim("TC")<<"Inside CI3DVIG:";
 
     for(unsigned short iv3 = 0; iv3 < tjs.vtx3.size(); ++iv3) {
       Vtx3Store& vx3 = tjs.vtx3[iv3];
       // ignore obsolete vertices
       if(vx3.ID == 0) continue;
       if(vx3.TPCID != tpcid) continue;
       // check for a completed 3D vertex
       if(vx3.Wire < 0) continue;
       unsigned short mPlane = USHRT_MAX;
       for(unsigned short ipl = 0; ipl < tjs.NumPlanes; ++ipl) {
         if(vx3.Vx2ID[ipl] > 0) continue;
         mPlane = ipl;
         break;
       } // ipl
       if(mPlane == USHRT_MAX) continue;
 //      CTP_t mCTP = EncodeCTP(vx3.CStat, vx3.TPC, mPlane);
       CTP_t mCTP = EncodeCTP(vx3.TPCID.Cryostat, vx3.TPCID.TPC, mPlane);
       // require that the missing vertex be in a large block of dead wires
       float dwc = DeadWireCount(tjs, vx3.Wire - 4, vx3.Wire + 4, mCTP);
       if(dwc < 5) continue;
       // X position of the purported missing vertex
       // A TP for the missing 2D vertex
       VtxStore aVtx;
       aVtx.ID = tjs.vtx.size() + 1;
       aVtx.Pos[0] = vx3.Wire;
       aVtx.Pos[1] = tjs.detprop->ConvertXToTicks(vx3.X, mPlane, vx3.TPCID.TPC, vx3.TPCID.Cryostat) * tjs.UnitsPerTick;
       aVtx.CTP = mCTP;
       aVtx.Topo = 4;
       aVtx.NTraj = 0;
       // Give it a bogus pass to indicate it wasn't created while stepping
       aVtx.Pass = 9;
       if(prt) mf::LogVerbatim("TC")<<"CI3DVIG: Incomplete vertex "<<iv3<<" in plane "<<mPlane<<" wire "<<vx3.Wire<<" Made 2D vertex ";
       std::vector<int> tjIDs;
       std::vector<unsigned short> tjEnds;
       for(unsigned short itj = 0; itj < tjs.allTraj.size(); ++itj) {
         if(tjs.allTraj[itj].CTP != mCTP) continue;
         if(tjs.allTraj[itj].AlgMod[kKilled]) continue;
         for(unsigned short end = 0; end < 2; ++end) {
           unsigned short ept = tjs.allTraj[itj].EndPt[end];
           TrajPoint& tp = tjs.allTraj[itj].Pts[ept];
           unsigned short oept = tjs.allTraj[itj].EndPt[1 - end];
           TrajPoint& otp = tjs.allTraj[itj].Pts[oept];
           // ensure that this is the end closest to the vertex
           if(std::abs(tp.Pos[0] - aVtx.Pos[0]) > std::abs(otp.Pos[0] - aVtx.Pos[0])) continue;
           float doca = PointTrajDOCA(tjs, aVtx.Pos[0], aVtx.Pos[1], tp);
           if(doca > 2) continue;
           float dwc = DeadWireCount(tjs, aVtx.Pos[0], tp.Pos[0], tp.CTP);
           float ptSep;
           if(aVtx.Pos[0] > tp.Pos[0]) {
             ptSep = aVtx.Pos[0] - tp.Pos[0] - dwc;
           } else {
             ptSep = tp.Pos[0] - aVtx.Pos[0] - dwc;
           }
           if(prt) mf::LogVerbatim("TC")<<"CI3DVIG: tj ID "<<tjs.allTraj[itj].ID<<" doca "<<doca<<" ptSep "<<ptSep;
           if(ptSep < -2 || ptSep > 2) continue;
           // don't clobber an existing association
           if(tjs.allTraj[itj].VtxID[end] > 0) continue;
           tjIDs.push_back(tjs.allTraj[itj].ID);
           tjEnds.push_back(end);
         } // end
       } // itj
       if(!tjIDs.empty()) {
         // Determine how messy this region is
         aVtx.TjChgFrac = ChgFracNearPos(tjs, aVtx.Pos, tjIDs);
         if(aVtx.TjChgFrac < 0.7) continue;
         aVtx.Vx3ID = vx3.ID;
         // Save the 2D vertex
         if(!StoreVertex(tjs, aVtx)) continue;
         for(unsigned short ii = 0; ii < tjIDs.size(); ++ii) {
           unsigned short itj = tjIDs[ii] - 1;
           tjs.allTraj[itj].VtxID[tjEnds[ii]] = aVtx.ID;
           tjs.allTraj[itj].AlgMod[kComp3DVxIG] = true;
         } // ii
         SetVx2Score(tjs, prt);
         vx3.Vx2ID[mPlane] = aVtx.ID;
         vx3.Wire = -1;
         if(prt) mf::LogVerbatim("TC")<<"CI3DVIG: new vtx 2V"<<aVtx.ID<<" points to 3V"<<vx3.ID;
       }
     } // vx3
     
   } // CompleteIncomplete3DVerticesInGaps

bool tca::CompleteIncompleteShower	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 804 of file TCShower.cxx.

References tca::TjStuff::allTraj, ChkAssns(), tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, CreateSS(), DecodeCTP(), evd::details::end(), GetAssns(), tca::ShowerStruct3D::ID, kCompleteShower, MakeShowerObsolete(), tca::ShowerStruct3D::NeedsUpdate, tca::TjStuff::NumPlanes, tca::TjStuff::pfps, geo::PlaneID::Plane, SetIntersection(), ShowerEnergy(), ss, StoreShower(), UpdateShower(), tca::TjStuff::UseAlg, and tca::TjStuff::vtx.

Referenced by Match2DShowers().

   {
     // Find low-energy two-plane showers and try to complete it by making a 2D shower in the third
     // plane using 3D matched tjs
     
     if(tjs.NumPlanes != 3) return false;
     if(ss3.CotIDs.size() != 2) return false;
     
     if(!tjs.UseAlg[kCompleteShower]) return false;
     
     std::string fcnLabel = inFcnLabel + ".CIS";
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID;
     
     auto& iss = tjs.cots[ss3.CotIDs[0] - 1];
     auto& jss = tjs.cots[ss3.CotIDs[1] - 1];
     // make a list of pfps for each SS
     std::vector<int> iplist;
     for(auto tid : iss.TjIDs) {
       auto plist = GetAssns(tjs, "T", tid, "P");
       if(!plist.empty()) iplist.insert(iplist.end(), plist.begin(), plist.end());
     } // tid
     std::vector<int> jplist;
     for(auto tid : jss.TjIDs) {
       auto plist = GetAssns(tjs, "T", tid, "P");
       if(!plist.empty()) jplist.insert(jplist.end(), plist.begin(), plist.end());
     } // tid
     // look for pfps that have tjs in both showers
     auto shared = SetIntersection(iplist, jplist);
     if(shared.empty()) return false;
     // put the list of tjs for both SS into a flat vector to simplify searching
     std::vector<int> flat = iss.TjIDs;
     flat.insert(flat.end(), jss.TjIDs.begin(), jss.TjIDs.end());
     // make a list of tjs in the k plane that maybe should made into a shower if they
     // aren't already in a shower that failed the 3D match
     std::vector<int> ktlist;
     for(auto pid : shared) {
       auto& pfp = tjs.pfps[pid - 1];
       for(auto tid : pfp.TjIDs) {
         // ignore the tjs that are already in the shower in the other planes
         if(std::find(flat.begin(), flat.end(), tid) != flat.end()) continue;
         if(std::find(ktlist.begin(), ktlist.end(), tid) == ktlist.end()) ktlist.push_back(tid);
         // look for 2D vertices attached to this tj and add all attached tjs to ktlist
         auto& tj = tjs.allTraj[tid - 1];
         for(unsigned short end = 0; end < 2; ++end) {
           if(tj.VtxID[end] <= 0) continue;
           auto& vx2 = tjs.vtx[tj.VtxID[end] - 1];
           auto TIn2V = GetAssns(tjs, "2V", vx2.ID, "T");
           for(auto vtid : TIn2V) {
             if(std::find(ktlist.begin(), ktlist.end(), vtid) == ktlist.end()) ktlist.push_back(vtid);
           }
         } // end
       } // tid
     } // pid
     if(ktlist.empty()) return false;
     // list of 2D showers that include tjs in ktlist
     std::vector<int> ksslist;
     for(auto tid : ktlist) {
       auto& tj = tjs.allTraj[tid - 1];
       if(tj.SSID == 0) continue;
       // ignore showers that are 3D-matched. This case should be handled elsewhere by a merging function
       auto& ss = tjs.cots[tj.SSID - 1];
       if(ss.SS3ID > 0) {
         if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Found existing T"<<tid<<" -> 2S"<<ss.ID<<" -> 3S"<<ss.SS3ID<<" assn. Give up";
         return false;
       }
       if(std::find(ksslist.begin(), ksslist.end(), ss.ID) == ksslist.end()) ksslist.push_back(ss.ID);
     } // tid
     // find the shower energy for this list
     float ktlistEnergy = ShowerEnergy(tjs, ktlist);
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<fcnLabel<<" 3S"<<ss3.ID<<"\n";
       myprt<<" -> i2S"<<iss.ID<<" ->";
       for(auto pid : iplist) myprt<<" P"<<pid;
       myprt<<"\n";
       myprt<<" -> j2S"<<jss.ID<<" ->";
       for(auto pid : jplist) myprt<<" P"<<pid;
       myprt<<"\n";
       geo::PlaneID iPlaneID = DecodeCTP(iss.CTP);
       geo::PlaneID jPlaneID = DecodeCTP(jss.CTP);
       unsigned short kplane = 3 - iPlaneID.Plane - jPlaneID.Plane;
       myprt<<" kplane "<<kplane<<" ktlist:";
       for(auto tid : ktlist) myprt<<" T"<<tid;
       myprt<<" ktlistEnergy "<<ktlistEnergy;
       if(ksslist.empty()) {
         myprt<<"\n No matching showers in kplane";
       }  else {
         myprt<<"\n";
         myprt<<" Candidate showers:";
         for(auto ssid : ksslist) {
           myprt<<" 2S"<<ssid;
           auto& sst = tjs.cots[ssid - 1];
           if(sst.SS3ID > 0) myprt<<"_3S"<<sst.SS3ID;
         } // ssid
       } // ssList not empty
     } // prt
     if(ksslist.size() > 1) {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Found more than 1 shower. Need some better code here";
       return false;
     }
     if(ktlistEnergy > 2 * ShowerEnergy(ss3)) {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" ktlistEnergy exceeds 2 * ss3 energy. Need some better code here";
       return false;
     } // ktlistEnergy too high
     
     if(ksslist.empty()) {
       // no 2D shower so make one using ktlist
       auto kss = CreateSS(tjs, 0, ktlist);
       if(kss.ID == 0) return false;
       kss.SS3ID = ss3.ID;
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" create new 2S"<<kss.ID<<" from ktlist";
       if(!UpdateShower(fcnLabel, tjs, kss, prt)) {
         if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" UpdateShower failed 2S"<<kss.ID;
         MakeShowerObsolete(fcnLabel, tjs, kss, prt);
         return false;
       } // UpdateShower failed
       if(!StoreShower(fcnLabel, tjs, kss)) {
         if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" StoreShower failed";
         MakeShowerObsolete(fcnLabel, tjs, kss, prt);
         return false;
       } // StoreShower failed
       ss3.CotIDs.push_back(kss.ID);
       auto& stj = tjs.allTraj[kss.ShowerTjID - 1];
       stj.AlgMod[kCompleteShower] = true;
       ss3.NeedsUpdate = true;
       return true;
     } // ksslist empty
     
     // associate ksslist[0] with 3S
     auto& ss = tjs.cots[ksslist[0] - 1];
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" found pfp-matched 2S"<<ss.ID;
     ss.SS3ID = ss3.ID;
     ss3.CotIDs.push_back(ss.ID);
     auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
     stj.AlgMod[kCompleteShower] = true;
     ss3.NeedsUpdate = true;
     
     ChkAssns(fcnLabel, tjs);
     return true;
 
  } // CompleteIncompleteShower

void tca::ConfigureMVA	(	TjStuff &	tjs,
		std::string	fMVAShowerParentWeights
	)

Definition at line 15 of file TCShower.cxx.

References tca::TjStuff::ShowerParentReader, and tca::TjStuff::ShowerParentVars.

Referenced by tca::TrajClusterAlg::reconfigure().

   {
     // Define the reference in TJStuff to the MVA reader used to determine the best
     // shower parent PFParticle
     cet::search_path sp("FW_SEARCH_PATH");
     if(!tjs.ShowerParentReader) {
       std::cout<<"its not defined\n";
       return;
     }
     std::string fullFileSpec;
     sp.find_file(fMVAShowerParentWeights, fullFileSpec);
     if(fullFileSpec == "") {
       std::cout<<"ConfigureMVA: weights file "<<fMVAShowerParentWeights<<" not found in path\n";
       tjs.ShowerParentReader = 0;
       return;
     }
     tjs.ShowerParentVars.resize(9);
     tjs.ShowerParentReader->AddVariable("fShEnergy", &tjs.ShowerParentVars[0]);
     tjs.ShowerParentReader->AddVariable("fPfpEnergy", &tjs.ShowerParentVars[1]);
     tjs.ShowerParentReader->AddVariable("fMCSMom", &tjs.ShowerParentVars[2]);
     tjs.ShowerParentReader->AddVariable("fPfpLen", &tjs.ShowerParentVars[3]);
     tjs.ShowerParentReader->AddVariable("fSep", &tjs.ShowerParentVars[4]);
     tjs.ShowerParentReader->AddVariable("fDang1", &tjs.ShowerParentVars[5]);
     tjs.ShowerParentReader->AddVariable("fDang2", &tjs.ShowerParentVars[6]);
     tjs.ShowerParentReader->AddVariable("fChgFrac", &tjs.ShowerParentVars[7]);
     tjs.ShowerParentReader->AddVariable("fInShwrProb", &tjs.ShowerParentVars[8]);
     tjs.ShowerParentReader->BookMVA("BDT", fullFileSpec);
   } // ConfigureTMVA

PFPStruct tca::CreateFakePFP	(	const TjStuff &	tjs,
		const ShowerStruct3D &	ss3
	)

Definition at line 2050 of file TCShower.cxx.

References CreatePFP(), tca::ShowerStruct3D::Dir, tca::ShowerStruct3D::End, tca::ShowerStruct3D::Len, PointDirection(), tca::ShowerStruct3D::Start, and tca::ShowerStruct3D::TPCID.

   {
     // Creates a fake PFParticle on the shower axis with a TP3S point every cm. This is
     // used to find the separation between the shower core and a PFParticle or trajectory
     auto pfp = CreatePFP(tjs, ss3.TPCID);
     pfp.XYZ[0] = ss3.Start;
     pfp.Dir[0] = ss3.Dir;
     pfp.XYZ[1] = ss3.End;
     pfp.Dir[1] = ss3.Dir;
     pfp.Dir[0] = PointDirection(ss3.Start, ss3.End);
     unsigned short npts = ss3.Len;
     if(npts < 2) return pfp;
     pfp.Tp3s.resize(npts);
     pfp.Tp3s[0].Pos = ss3.Start;
     for(unsigned short ipt = 1; ipt < npts; ++ipt) {
       for(unsigned short xyz = 0; xyz < 3; ++xyz) pfp.Tp3s[ipt].Pos[xyz] = pfp.Tp3s[ipt-1].Pos[xyz] + pfp.Dir[0][xyz];
     } // ipt
     return pfp;
   } // CreateFakePFP

PFPStruct tca::CreatePFP	(	const TjStuff &	tjs,
		const geo::TPCID &	tpcid
	)

Definition at line 1943 of file PFPUtils.cxx.

References tca::PFPStruct::dEdx, tca::PFPStruct::dEdxErr, tca::PFPStruct::Dir, tca::PFPStruct::DirErr, tca::PFPStruct::ID, tca::TjStuff::NumPlanes, tca::PFPStruct::ParentID, tca::TjStuff::pfps, tca::PFPStruct::TPCID, and tca::PFPStruct::XYZ.

Referenced by CreateFakePFP(), DefineTjParents(), DotProd(), FindPFParticles(), Finish3DShowers(), and Match3DVtxTjs().

   {
     // The calling function should define the size of pfp.TjIDs
     PFPStruct pfp;
     pfp.ID = tjs.pfps.size() + 1;
     pfp.ParentID = 0;
     pfp.TPCID = tpcid;
     // initialize arrays for both ends
     if(tjs.NumPlanes < 4) {
       pfp.dEdx[0].resize(tjs.NumPlanes, 0);
       pfp.dEdx[1].resize(tjs.NumPlanes, 0);
       pfp.dEdxErr[0].resize(tjs.NumPlanes, 0);
       pfp.dEdxErr[1].resize(tjs.NumPlanes, 0);
     }
     for(unsigned short startend = 0; startend < 2; ++startend) {
       // BUG the double brace syntax is required to work around clang bug 21629
       // (https://bugs.llvm.org/show_bug.cgi?id=21629)
       pfp.Dir[startend] = {{0.0, 0.0, 0.0}};
       pfp.DirErr[startend] = {{0.0, 0.0, 0.0}};
       pfp.XYZ[startend] = {{0.0, 0.0, 0.0}};
     }
     return pfp;
   } // CreatePFP

ShowerStruct tca::CreateSS	(	TjStuff &	tjs,
		CTP_t	inCTP,
		const std::vector< int > &	tjl
	)

Definition at line 4572 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::ShowerStruct::Cheat, tca::TjStuff::cots, tca::Trajectory::CTP, tca::ShowerStruct::CTP, tca::ShowerStruct::Envelope, tca::ShowerStruct::ID, kCheat, kShowerTj, tca::ShowerStruct::ShowerTjID, ss, and tca::ShowerStruct::TjIDs.

Referenced by CompleteIncompleteShower(), FindShowers3D(), tca::MCParticleListUtils::MakeCheatShower(), and MergeShowers().

   {
     // Create a shower and shower Tj using Tjs in the list. If tjl is empty a
     // MC cheat shower is created inCTP. Note that inCTP is only used if tjl is empty.
     // A companion shower tj is created and stored but the ShowerStruct is not.
     ShowerStruct ss;
     
     if(tjl.empty()) ss.Cheat = true;
     
     // Create the shower tj
     Trajectory stj;
     if(ss.Cheat) {
       stj.CTP = inCTP;
     } else {
       stj.CTP = tjs.allTraj[tjl[0]-1].CTP;
     }
     // with three points
     stj.Pts.resize(3);
     for(auto& stp : stj.Pts) {
       stp.CTP = stj.CTP;
       // set all UseHit bits true so we don't get confused
       stp.UseHit.set();
     }
     stj.EndPt[0] = 0;
     stj.EndPt[1] = 2;
     stj.ID = tjs.allTraj.size() + 1;
     // Declare that stj is a shower Tj
     stj.AlgMod[kShowerTj] = true;
     // and maybe a cheat trajectory
     if(ss.Cheat) stj.AlgMod[kCheat] = true;
     stj.PDGCode = 1111;
     tjs.allTraj.push_back(stj);
     // define the ss
     ss.ID = tjs.cots.size() + 1;
     ss.CTP = stj.CTP;
     // assign all TJ IDs to this ShowerStruct
     ss.TjIDs = tjl;
     // declare them to be InShower
     for(auto tjid : tjl) {
       auto& tj = tjs.allTraj[tjid - 1];
       if(tj.CTP != stj.CTP) {
         ss.ID = 0;
         return ss;
       }
       tj.SSID = ss.ID;
     } // tjid
     ss.ShowerTjID = stj.ID;
     ss.Envelope.resize(4);
     return ss;
     
   } // CreateSS

ShowerStruct3D tca::CreateSS3	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid
	)

Definition at line 4553 of file TCShower.cxx.

References tca::ShowerStruct3D::dEdx, tca::ShowerStruct3D::dEdxErr, tca::ShowerStruct3D::Energy, tca::ShowerStruct3D::EnergyErr, tca::ShowerStruct3D::ID, tca::ShowerStruct3D::MIPEnergy, tca::ShowerStruct3D::MIPEnergyErr, tca::TjStuff::NumPlanes, tca::TjStuff::showers, and tca::ShowerStruct3D::TPCID.

Referenced by tca::MCParticleListUtils::MakeCheatShower(), and Match2DShowers().

   {
     // create a 3D shower and size the vectors that are indexed by plane
     
     ShowerStruct3D ss3;
     ss3.TPCID = tpcid;
     ss3.ID = tjs.showers.size() + 1;
     ss3.Energy.resize(tjs.NumPlanes);
     ss3.EnergyErr.resize(tjs.NumPlanes);
     ss3.MIPEnergy.resize(tjs.NumPlanes);
     ss3.MIPEnergyErr.resize(tjs.NumPlanes);
     ss3.dEdx.resize(tjs.NumPlanes);
     ss3.dEdxErr.resize(tjs.NumPlanes);
     
     return ss3;
     
   } // CreateSS3

float tca::DeadWireCount	(	const TjStuff &	tjs,
		const TrajPoint &	tp1,
		const TrajPoint &	tp2
	)

Definition at line 1756 of file Utils.cxx.

References tca::TrajPoint::CTP, DeadWireCount(), and tca::TrajPoint::Pos.

Referenced by tca::TrajClusterAlg::AddHits(), cluster::ClusterCrawlerAlg::CheckClusterHitFrac(), cluster::ClusterCrawlerAlg::ChkMerge(), CompleteIncomplete3DVerticesInGaps(), Find2DVertices(), tca::TrajClusterAlg::StepCrawl(), and tca::TrajClusterAlg::UpdateTraj().

   {
     return DeadWireCount(tjs, tp1.Pos[0], tp2.Pos[0], tp1.CTP);
   } // DeadWireCount

float tca::DeadWireCount	(	const TjStuff &	tjs,
		const float &	inWirePos1,
		const float &	inWirePos2,
		CTP_t	tCTP
	)

Definition at line 1762 of file Utils.cxx.

References DecodeCTP(), tca::TjStuff::NumWires, geo::PlaneID::Plane, tmp, and tca::TjStuff::WireHitRange.

Referenced by DeadWireCount(), NumPtsWithCharge(), and TrajTrajDOCA().

   {
     if(inWirePos1 < -0.4 || inWirePos2 < -0.4) return 0;
     unsigned int inWire1 = std::nearbyint(inWirePos1);
     unsigned int inWire2 = std::nearbyint(inWirePos2);
     geo::PlaneID planeID = DecodeCTP(tCTP);
     unsigned short plane = planeID.Plane;
     if(inWire1 > tjs.NumWires[plane] || inWire2 > tjs.NumWires[plane]) return 0;
     if(inWire1 > inWire2) {
       // put in increasing order
       unsigned int tmp = inWire1;
       inWire1 = inWire2;
       inWire2 = tmp;
     } // inWire1 > inWire2
     ++inWire2;
     unsigned int wire, ndead = 0;
     for(wire = inWire1; wire < inWire2; ++wire) if(tjs.WireHitRange[plane][wire].first == -1) ++ndead;
     return ndead;
   } // DeadWireCount

geo::PlaneID tca::DecodeCTP ( CTP_t CTP )

Definition at line 89 of file DataStructs.cxx.

References Cpad, and Tpad.

                                   {
     auto const cryo = (CTP / Cpad);
     return geo::PlaneID(
       /* Cryostat */ cryo,
            /* TPC */ (CTP - cryo * Cpad) / Tpad,
          /* Plane */ (CTP % 10)
       );
   }

void tca::DefineDontCluster	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid,
		bool	prt
	)

Definition at line 3397 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::DebugMode, DecodeCTP(), tca::TjStuff::dontCluster, DotProd(), GetAssns(), IsShowerLike(), PFPDOCA(), tca::TjStuff::pfps, geo::PlaneID::Plane, PointDirection(), PosSep(), t1, t2, tca::DontClusterStruct::TjIDs, tca::TjStuff::vtx3, tca::DontClusterStruct::Vx2ID, and tca::DontClusterStruct::Vx3ID.

Referenced by FindShowers3D().

   {
     // make a list of tj pairs that pass the cuts, but shouldn't be clustered for
     // different reasons, e.g. are likely parent tjs in different showers, are both attached
     // to the same high-score vertex, etc
     
     tjs.dontCluster.clear();
 
     DontClusterStruct dc;
     for(auto& vx3 : tjs.vtx3) {
       if(vx3.ID == 0) continue;
       if(vx3.TPCID != tpcid) continue;
       if(!vx3.Neutrino) continue;
       auto PIn3V = GetAssns(tjs, "3V", vx3.ID, "P");
       if(PIn3V.size() < 2) continue;
       Point3_t v3pos = {{vx3.X, vx3.Y, vx3.Z}};
       for(unsigned short ip1 = 0; ip1 < PIn3V.size() - 1; ++ip1) {
         auto& p1 = tjs.pfps[PIn3V[ip1] - 1];
         // ignore the neutrino pfp
         if(p1.TjIDs.empty()) continue;
         unsigned short p1End = 0;
         if(p1.Vx3ID[1] == vx3.ID) p1End = 1;
         bool p1ShowerLike = IsShowerLike(tjs, p1.TjIDs);
         // find the direction using the vertex position and the end that is
         // farthest away from the vertex
         auto p1Dir = PointDirection(v3pos, p1.XYZ[1 - p1End]);
         float p1Sep = PosSep(p1.XYZ[p1End], v3pos);
         for(unsigned short ip2 = ip1 + 1; ip2 < PIn3V.size(); ++ip2) {
           auto& p2 = tjs.pfps[PIn3V[ip2] - 1];
           if(p2.TjIDs.empty()) continue;
           unsigned short p2End = 0;
           if(p2.Vx3ID[1] == vx3.ID) p2End = 1;
           auto p2Dir = PointDirection(v3pos, p2.XYZ[1 - p2End]);
           float p2Sep = PosSep(p2.XYZ[p2End], v3pos);
           // Look for the case where an electron starts to shower close to the
           // vertex, creating a daughter that is also attached to the vertex. This
           // pair is OK to include in a shower. The signature is that the PFP doca between them is less
           // than the pfp - vx3 separation and both are shower like - something like this
           // where 3V is a 3D vertex
           //    \ P3 (not shower-like) -> 3V
           //     3V ----------- P1 -> 3V (shower-like or NOT shower-like)
           //            ----------- P2 (shower-like doca closer to P1 than the vertex) -> 3V
           // The tjs in the P1 - P3 pair shouldn't be clustered
           // The tjs in the P2 - P3 pair shouldn't be clustered
           // The tjs in the P1 - P2 pair can be clustered
           bool p2ShowerLike = IsShowerLike(tjs, p2.TjIDs);
           if(p1ShowerLike && p2ShowerLike) continue;
           
           float costh = DotProd(p1Dir, p2Dir);
           if(costh < 0.92) continue;
           unsigned short closePt1, closePt2;
           float doca = PFPDOCA(p1, p2, closePt1, closePt2);
           float minSep = p1Sep;
           if(p1Sep < minSep) minSep = p2Sep;
           bool allowCluster = (doca < minSep);
 
           if(tjs.DebugMode) {
             std::cout<<"DDC: P"<<p1.ID<<" p1ShowerLike "<<p1ShowerLike;
             std::cout<<" P"<<p2.ID<<" p2ShowerLike "<<p2ShowerLike;
             std::cout<<" costh "<<costh;
             std::cout<<" doca "<<doca;
             std::cout<<" minSep "<<minSep;
             std::cout<<" allowCluster? "<<allowCluster;
             std::cout<<"\n";
           }
           if(!allowCluster) continue;
           
           // now enter the Tj pairs
           for(auto tid1 : p1.TjIDs) {
             auto& t1 = tjs.allTraj[tid1 - 1];
             for(auto tid2 : p2.TjIDs) {
               auto& t2 = tjs.allTraj[tid2 - 1];
               if(t1.CTP != t2.CTP) continue;
               dc.TjIDs[0] = tid1;
               dc.TjIDs[1] = tid2;
               if(dc.TjIDs[0] > dc.TjIDs[1]) std::swap(dc.TjIDs[0], dc.TjIDs[1]);
               dc.Vx2ID = vx3.Vx2ID[DecodeCTP(t1.CTP).Plane];
               dc.Vx3ID = vx3.ID;
               tjs.dontCluster.push_back(dc);
             } // tid2
           } // tid1
         } // ip2
       } // ip1
     } // vx3
 
   } // DefineDontCluster

void tca::DefineEnvelope	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3936 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TrajPoint::Ang, tca::TrajPoint::Chg, tca::ShowerStruct::ChgDensity, tca::TrajPoint::DeltaRMS, tca::ShowerStruct::Envelope, tca::ShowerStruct::EnvelopeArea, tca::ShowerStruct::ID, SortEntry::length, tca::ShowerStruct::NeedsUpdate, tca::TrajPoint::Pos, PosSep(), tca::Trajectory::Pts, tca::TjStuff::ShowerTag, tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::TjIDs, and tca::TjStuff::UnitsPerTick.

Referenced by ReverseShower(), and UpdateShower().

   {
     
     if(ss.ID == 0) return;
     if(ss.TjIDs.empty()) return;
     Trajectory& stj = tjs.allTraj[ss.ShowerTjID - 1];
     // shower Tj isn't fully defined yet
     if(stj.Pts[0].Pos[0] == 0) return;
     
     std::string fcnLabel = inFcnLabel + ".DE";
     
     ss.Envelope.resize(4);
     TrajPoint& stp0 = stj.Pts[0];
     TrajPoint& stp1 = stj.Pts[1];
     TrajPoint& stp2 = stj.Pts[2];
     
     // construct the Envelope polygon. Start with a rectangle using the fixed 1/2 width fcl input
     // expanded by the rms width at each end to create a polygon. The polygon is constructed along
     // the Pos[0] direction and then rotated into the ShowerTj direction. Use sTp1 as the origin.
     // First vertex
     ss.Envelope[0][0] = -PosSep(stp0.Pos, stp1.Pos);
     ss.Envelope[0][1] = tjs.ShowerTag[5] + tjs.ShowerTag[4] * stp0.DeltaRMS;
     // second vertex
     ss.Envelope[1][0] = PosSep(stp1.Pos, stp2.Pos);
     ss.Envelope[1][1] = tjs.ShowerTag[5] + tjs.ShowerTag[4] * stp2.DeltaRMS;
     // third and fourth are reflections of the first and second
     ss.Envelope[2][0] =  ss.Envelope[1][0];
     ss.Envelope[2][1] = -ss.Envelope[1][1];
     ss.Envelope[3][0] =  ss.Envelope[0][0];
     ss.Envelope[3][1] = -ss.Envelope[0][1];
     
     float length = ss.Envelope[1][0] - ss.Envelope[0][0];
     float width = ss.Envelope[0][1] + ss.Envelope[1][1];
     ss.EnvelopeArea = length * width;
 
     // Rotate into the stp1 coordinate system
     float cs = cos(stp1.Ang);
     float sn = sin(stp1.Ang);
     for(auto& vtx : ss.Envelope) {
       // Rotate along the stj shower axis
       float pos0 = cs * vtx[0] - sn * vtx[1];
       float pos1 = sn * vtx[0] + cs * vtx[1];
       // translate
       vtx[0] = pos0 + stp1.Pos[0];
       vtx[1] = pos1 + stp1.Pos[1];
     } // vtx
     // Find the charge density inside the envelope
     ss.ChgDensity = (stp0.Chg + stp1.Chg + stp2.Chg) / ss.EnvelopeArea;
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<fcnLabel<<" 2S"<<ss.ID<<" Envelope";
       for(auto& vtx : ss.Envelope) myprt<<" "<<(int)vtx[0]<<":"<<(int)(vtx[1]/tjs.UnitsPerTick);
       myprt<<" Area "<<(int)ss.EnvelopeArea;
       myprt<<" ChgDensity "<<ss.ChgDensity;
     }
     // This is the last function used to update a shower
     ss.NeedsUpdate = false;
   } // DefineEnvelope  

bool tca::DefinePFP	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 2159 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, CompatibleMerge(), DecodeCTP(), FindCompleteness(), FollowTp3s(), tca::PFPStruct::ID, kKilled, kMat3D, kMat3DMerge, tca::TjStuff::Match3DCuts, tca::TjStuff::matchVec, tca::PFPStruct::MatchVecIndex, MaxTjLen(), MCSMom(), MergePFPTjs(), tca::PFPStruct::NeedsUpdate, tca::TjStuff::NumPlanes, tca::PFPStruct::PDGCode, PFPVxTjOK(), geo::PlaneID::Plane, PosSep(), SetIntersection(), SetStart(), SharesHighScoreVx(), tca::PFPStruct::TjIDs, tca::PFPStruct::Tp3s, tca::TjStuff::UseAlg, and tca::PFPStruct::Vx3ID.

Referenced by AnalyzePFP(), DotProd(), FindPFParticles(), and Match3DVtxTjs().

   {
     // This function is called after the 3D matched TjIDs have been specified and optionally
     // a start or end vertex ID. It defines the PFParticle but doesn't store it
     
     if(pfp.PDGCode == 1111) return false;
     if(pfp.TjIDs.size() < 2) return false;
     
     std::string fcnLabel = inFcnLabel + ".DPFP";
     
     // require at least one tj in at least two planes
     std::vector<unsigned short> nInPln(tjs.NumPlanes);
     for(auto tjid : pfp.TjIDs) {
       auto& tj = tjs.allTraj[tjid - 1];
       ++nInPln[DecodeCTP(tj.CTP).Plane];
       if(tj.AlgMod[kMat3D] || tj.AlgMod[kKilled]) {
         std::cout<<fcnLabel<<" P"<<pfp.ID<<" uses T"<<tj.ID<<" but kMat3D is set true\n";
         return false;
       }
     } // tjid
     unsigned short npl = 0;
     for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) if(nInPln[plane] > 0) ++npl;
     if(npl < 2) return false;
 
     if(pfp.Vx3ID[0] == 0 && pfp.Vx3ID[1] > 0) {
       std::cout<<fcnLabel<<" P"<<pfp.ID<<" end 1 has a vertex but end 0 doesn't. No endpoints defined\n";
       return false;
     }
     
     // check for vertex consistency. There should only be one tj in each plane
     // that is attached to a vertex. Remove the shorter tj from the list
     // if that is not the case 
     if(pfp.Vx3ID[0] > 0) PFPVxTjOK(tjs, pfp, prt);
     
     bool pfpTrackLike = (MaxTjLen(tjs, pfp.TjIDs) > tjs.Match3DCuts[5] && MCSMom(tjs, pfp.TjIDs) > tjs.Match3DCuts[3]);
 
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<fcnLabel<<" pfp P"<<pfp.ID;
       myprt<<" Vx3ID 3V"<<pfp.Vx3ID[0]<<" 3V"<<pfp.Vx3ID[1];
       myprt<<" Tjs";
       for(auto id : pfp.TjIDs) myprt<<" T"<<id;
       myprt<<" matchVec index "<<pfp.MatchVecIndex;
       myprt<<" max Tj len "<<MaxTjLen(tjs, pfp.TjIDs);
       myprt<<" MCSMom "<<MCSMom(tjs, pfp.TjIDs);
       myprt<<" pfpTrackLike? "<<pfpTrackLike;
     } // prt
     
     if(tjs.UseAlg[kMat3DMerge] && pfpTrackLike && pfp.MatchVecIndex < tjs.matchVec.size()) {
       // The index of tjs.matchVec has been specified for this pfp so we can look for evidence of
       // broken Tjs starting at the beginning
       for(unsigned short ims = 0; ims < pfp.MatchVecIndex + 10; ++ims) {
         if(ims >= tjs.matchVec.size()) break;
         auto& ms = tjs.matchVec[ims];
         if(ms.Count == 0) continue;
         std::vector<int> shared = SetIntersection(ms.TjIDs, pfp.TjIDs);
         if(shared.size() < 2) continue;
         // check the max length Tj and cut on MCSMom
         if(MaxTjLen(tjs, ms.TjIDs) < tjs.Match3DCuts[5]) continue;
         if(MCSMom(tjs, ms.TjIDs) < tjs.Match3DCuts[3]) continue;
         for(auto tjid : ms.TjIDs) {
           if(std::find(shared.begin(), shared.end(), tjid) != shared.end()) continue;
           auto& tj = tjs.allTraj[tjid - 1];
           if(tj.AlgMod[kKilled]) continue;
           if(tj.AlgMod[kMat3D]) continue;
           // check for PDGCode compatibility - muons and delta rays
           if(pfp.PDGCode == 13 && tj.PDGCode == 11) continue;
           if(pfp.PDGCode == 11 && tj.PDGCode == 13) continue;
           if(SharesHighScoreVx(tjs, pfp, tj)) continue;
           if(tj.MCSMom < tjs.Match3DCuts[3]) continue;
           float len = PosSep(tj.Pts[tj.EndPt[0]].Pos, tj.Pts[tj.EndPt[1]].Pos);
           if(len < tjs.Match3DCuts[5]) continue;
           // check for a compatible merge
           bool skipit = false;
           for(auto tjid : pfp.TjIDs) {
             auto& ptj = tjs.allTraj[tjid - 1];
             if(ptj.CTP != tj.CTP) continue;
             if(!CompatibleMerge(tjs, tj, ptj, prt)) {
               skipit = true;
               break;
             }
           } // tjid
           if(skipit) continue;
           if(prt) mf::LogVerbatim("TC")<<" add T"<<tjid<<" MCSMom "<<tj.MCSMom<<" length "<<len;
           pfp.TjIDs.push_back(tjid);
           PFPVxTjOK(tjs, pfp, prt);
         } // tjid
       } // ims
     } // matchVec index defined
     
 /* BB April 25. CheckAndMerge needs work. Shut it off for now.
     // check the completeness of matching points in this set of Tjs and possibly
     // merge Tjs
     if(tjs.UseAlg[kMat3DMerge] && pfpTrackLike) {
       if(!CheckAndMerge(tjs, pfp, prt)) return false;
     } else {
       // not track-like. Find completeness and fill the TP3s
       FindCompleteness(tjs, pfp, true, true, prt);
     }
 */
     // Find completeness and fill the TP3s
     FindCompleteness(tjs, pfp, true, true, prt);
     if(pfp.Tp3s.empty()) return false;
 
     // Set the starting position in 3D if it isn't already defined by a 3D vertex
     SetStart(tjs, pfp, prt);
     FollowTp3s(tjs, pfp, prt);
     // Check the list of Tjs and merge those that are in the same plane
     MergePFPTjs(tjs, pfp, prt);
 
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<fcnLabel<<" pfp P"<<pfp.ID;
       myprt<<" Vx3ID 3V"<<pfp.Vx3ID[0]<<" 3V"<<pfp.Vx3ID[1];
       myprt<<" Tjs";
       for(auto id : pfp.TjIDs) myprt<<" T"<<id;
       myprt<<" Tp3s size "<<pfp.Tp3s.size();
     }
     
     pfp.NeedsUpdate = false;
     return true;
   } // DefinePFP

void tca::DefinePFPParents	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid,
		bool	prt
	)

Definition at line 2441 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::DebugMode, DefinePFPParentsTestBeam(), GetPFPIndex(), IsShowerLike(), tca::TjStuff::NumPlanes, PDGCodeVote(), tca::TjStuff::pfps, tca::TjStuff::TestBeam, and tca::TjStuff::vtx.

Referenced by DotProd(), and tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     /*
      This function reconciles vertices, PFParticles and Tjs, then
      defines the parent (j) - daughter (i) relationship and PDGCode. Here is a
      description of the conventions:
      
      V1 is the highest score 3D vertex in this tpcid so a neutrino PFParticle P1 is defined.
      V4 is a high-score vertex that has lower score than V1. It is declared to be a
      primary vertex because its score is higher than V5 and it is not associated with the
      neutrino interaction
      V6 was created to adhere to the convention that all PFParticles, in this case P9,
      be associated with a start vertex. There is no score for V6. P9 is it's own parent 
      but is not a primary PFParticle.
      
      P1 - V1 - P2 - V2 - P4 - V3 - P5        V4 - P6                  V6 - P9
      \                                  \
      P3                                 P7 - V5 - P8
      
      The PrimaryID in this table is the ID of the PFParticle that is attached to the
      primary vertex, which may or may not be a neutrino interaction vertex.
      The PrimaryID is returned by the PrimaryID function
      PFP  parentID  DtrIDs     PrimaryID
      -----------------------------------
      P1     P1     P2, P3        P1
      P2     P1     P4            P2
      P3     P1     none          P3
      P4     P2     P5            P2
      P5     P4     none          P2
      
      P6     P6     none          P6
      P7     P7     P8            P7
      
      P9     P9     none          0
      
      */    
     if(tjs.pfps.empty()) return;
     int neutrinoPFPID = 0;
     for(auto& pfp : tjs.pfps) {
       if(pfp.ID == 0) continue;
       if(pfp.TPCID != tpcid) continue;
       if(!tjs.TestBeam && neutrinoPFPID == 0 && (pfp.PDGCode == 12 || pfp.PDGCode == 14)) {
         neutrinoPFPID = pfp.ID;
         break;
       }
     } // pfp
     
     // define the end vertex if the Tjs have end vertices
     constexpr unsigned short end1 = 1;
     for(auto& pfp : tjs.pfps) {
       if(pfp.ID == 0) continue;
       if(pfp.TPCID != tpcid) continue;
       // already done?
       if(pfp.Vx3ID[end1] > 0) continue;
       // ignore shower-like pfps
       if(IsShowerLike(tjs, pfp.TjIDs)) continue;
       // count 2D -> 3D matched vertices
       unsigned short cnt3 = 0;
       unsigned short vx3id = 0;
       // list of unmatched 2D vertices that should be merged
       std::vector<int> vx2ids;
       for(auto tjid : pfp.TjIDs) {
         auto& tj = tjs.allTraj[tjid - 1];
         if(tj.VtxID[end1] == 0) continue;
         auto& vx2 = tjs.vtx[tj.VtxID[end1] - 1];
         if(vx2.Vx3ID == 0) {
           if(vx2.Topo == 1 && vx2.NTraj == 2) vx2ids.push_back(vx2.ID);
           continue;
         }
         if(vx3id == 0) vx3id = vx2.Vx3ID;
         if(vx2.Vx3ID == vx3id) ++cnt3;
       } // tjid
       if(cnt3 > 1) {
         // ensure it isn't attached at the other end
         if(pfp.Vx3ID[1 - end1] == vx3id) continue;
         pfp.Vx3ID[end1] = vx3id;
         if(cnt3 != tjs.NumPlanes && tjs.DebugMode) {
           std::cout<<"DPFPR: Missed an end vertex for PFP "<<pfp.ID<<" Write some code\n";
         }
       } // cnt3 > 1
     } // pfp
     
     // Assign a PDGCode to each PFParticle and look for a parent
     for(auto& pfp : tjs.pfps) {
       if(pfp.ID == 0) continue;
       if(pfp.TPCID != tpcid) continue;
       // skip a neutrino PFParticle
       if(pfp.PDGCode == 12 || pfp.PDGCode == 14 || pfp.PDGCode == 22) continue;
       pfp.PDGCode = PDGCodeVote(tjs, pfp.TjIDs, prt);
       // next look for a parent
       int pfpParentID = INT_MAX;
       unsigned short nParent = 0;
       for(auto tjid : pfp.TjIDs) {
         auto& tj = tjs.allTraj[tjid - 1];
         if(tj.ParentID == 0) continue;
         unsigned short ppindex = GetPFPIndex(tjs, tj.ParentID);
         if(ppindex == USHRT_MAX) continue;
         int ppid = ppindex + 1;
         if(pfpParentID == INT_MAX) pfpParentID = ppid;
         if(ppid == pfpParentID) ++nParent;
       } // ii
       // look for a parent
       if(nParent > 1) {
         pfp.ParentID = (size_t)pfpParentID;
         auto& parpfp = tjs.pfps[pfpParentID - 1];
         parpfp.DtrIDs.push_back(pfp.ID);
       } // nParent > 1
     } // ipfp
 
     
     if(tjs.TestBeam) {
       DefinePFPParentsTestBeam(tjs, tpcid, prt);
       return;
     }
 
     // associate primary PFParticles with a neutrino PFParticle
     if(neutrinoPFPID > 0) {
       auto& neutrinoPFP = tjs.pfps[neutrinoPFPID - 1];
       int vx3id = neutrinoPFP.Vx3ID[1];
       for(auto& pfp : tjs.pfps) {
         if(pfp.ID == 0 || pfp.ID == neutrinoPFPID) continue;
         if(pfp.TPCID != tpcid) continue;
         if(pfp.Vx3ID[0] != vx3id) continue;
         pfp.ParentID = (size_t)neutrinoPFPID;
         pfp.Primary = true;
         neutrinoPFP.DtrIDs.push_back(pfp.ID);
       } // pfp
     } // neutrino PFP exists    
   } // DefinePFPParents

void tca::DefinePFPParentsTestBeam	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid,
		bool	prt
	)

Definition at line 2572 of file PFPUtils.cxx.

References GetPFPIndex(), GetVtxTjIDs(), tca::TjStuff::pfps, SetDifference(), tca::TjStuff::vtx3, and tca::TjStuff::ZLo.

Referenced by DefinePFPParents(), and DotProd().

   {
     // analog of the one above that was written for neutrino interactions. This differs in that
     // the Tj parent - daughter relationship isn't known yet. If one exists, it is ignored...
     // The assumption here is that all PFParticles that enter (end0) from upstream Z are parents and 
     // any PFParticles attached to them at end1 are daughters. 
 
     // create a list (stack) of parent ID <-> daughter IDs. The idea is similar to that
     // used in DefineTjParents. A parent-daughter association is made for each entry. After
     // it is made, 1) that entry is removed from the stack, 2) the daughter is checked to see
     // if it a parent of a grand-daughter and if so that pair is added to the stack. 
     std::vector<std::pair<unsigned short, unsigned short>> pardtr;
 
     // Fill the stack with parents that enter the TPC and have daughters attached to
     // 3D vertices at the other end
     double fidZCut = tjs.ZLo + 2;
     for(auto& parPFP : tjs.pfps) {
       if(parPFP.ID == 0) continue;
       parPFP.Primary = false;
       if(parPFP.XYZ[0][2] > fidZCut) continue;
       parPFP.Primary = true;
       // we found a pfp that entered the TPC. Call it the parent and look for a daughter
       if(prt) mf::LogVerbatim("TC")<<"DPFPTestBeam: parent "<<parPFP.ID<<" end1 vtx "<<parPFP.Vx3ID[1];
       if(parPFP.Vx3ID[1] == 0) continue;
       // There must be other Tjs attached to this vertex which are the daughters. Find them
       // and add them to the pardtr stack
       float score = 0;
       auto& vx3 = tjs.vtx3[parPFP.Vx3ID[1] - 1];
       // ensure that it is valid
       if(vx3.ID == 0) continue;
       // get a list of Tjs attached to this vertex. This will include the Tjs in the parent.
       auto vx3TjList = GetVtxTjIDs(tjs, vx3, score);
       if(vx3TjList.empty()) continue;
       // filter out the parent Tjs
       auto dtrTjlist = SetDifference(vx3TjList, parPFP.TjIDs);
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<" Dtrs:";
         for(auto dtjID : dtrTjlist) myprt<<" "<<dtjID<<"_"<<GetPFPIndex(tjs, dtjID);
       }
       // Add to the stack
       for(auto dtjID : dtrTjlist) {
         unsigned short pfpIndex = GetPFPIndex(tjs, dtjID);
         if(pfpIndex > tjs.pfps.size() - 1) continue;
         unsigned short dtrID = pfpIndex + 1;
         // See if this is a duplicate
         bool duplicate = false;
         for(auto& pd : pardtr) if(parPFP.ID == pd.first && dtrID == pd.second) duplicate = true;
         if(!duplicate) pardtr.push_back(std::make_pair(parPFP.ID, dtrID));
       } // dtjID
     } // parPFP
     
     // iterate through the parent - daughter stack, removing the last pair when a 
     // ParentID is updated and adding pairs for new daughters
     for(unsigned short nit = 0; nit < 100; ++nit) {
       if(pardtr.empty()) break;
       auto lastPair = pardtr[pardtr.size() - 1];
       auto& dtr = tjs.pfps[lastPair.second - 1];
       auto& par = tjs.pfps[lastPair.first - 1];
       dtr.ParentID = par.ID;
       par.DtrIDs.push_back(dtr.ID);
       // remove the last pair
       pardtr.pop_back();
       // Now see if the daughter is a parent. First check for a vertex at the other end.
       // To do that we need to know which end has the vertex between the parent and daughter
       unsigned short dtrEnd = USHRT_MAX;
       for(unsigned short ep = 0; ep < 2; ++ep) {
         if(par.Vx3ID[ep] == 0) continue;
         for(unsigned short ed = 0; ed < 2; ++ed) if(dtr.Vx3ID[ed] == par.Vx3ID[ep]) dtrEnd = ed;
       } // ep
       if(dtrEnd > 1) continue;
       // look at the other end of the daughter
       dtrEnd = 1 - dtrEnd;
       // check for a vertex
       if(dtr.Vx3ID[dtrEnd] == 0) continue;
       // get the list of Tjs attached to it
       auto& vx3 = tjs.vtx3[dtr.Vx3ID[dtrEnd] - 1];
       float score = 0;
       auto vx3TjList = GetVtxTjIDs(tjs, vx3, score);
       if(vx3TjList.empty()) continue;
       // filter out the new parent
       auto dtrTjlist = SetDifference(vx3TjList, dtr.TjIDs);
       // put these onto the stack
       for(auto tjid : dtrTjlist) pardtr.push_back(std::make_pair(dtr.ID, tjid));
     } // nit
   } // DefinePFPParentsTestBeam

void tca::DefineTjParents	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid,
		bool	prt
	)

Definition at line 17 of file Utils.cxx.

References tca::TjStuff::allTraj, CreatePFP(), geo::CryostatID::Cryostat, DecodeCTP(), evd::details::end(), GetVtxTjIDs(), SortEntry::index, kDeltaRay, kKilled, kSetDir, tca::TjStuff::Match3DCuts, ReverseTraj(), StorePFP(), tca::TjStuff::TestBeam, geo::TPCID::TPC, TrajTrajDOCA(), valDecreasing(), tca::TjStuff::Vertex2DCuts, tca::TjStuff::vtx, and tca::TjStuff::vtx3.

Referenced by tca::TrajClusterAlg::RunTrajClusterAlg().

   {
 /*
     This function sets the ParentID of Tjs in this tpcid to create a hierarchy. The highest Score
     3D vertex in a chain of Tjs and vertices is declared the primary vertex; vx3.Primary = true. Tjs directly attached
     to that vertex are declared Primary trajectories with ParentID = 0. All other Tjs in the chain have ParentID
     set to the next upstream Tj to which it is attached by a vertex. In the graphical description below, V1 and V4 are 
     2D vertices that are matched to a high-score 3D vertex. The V1 Score is greater than the V2 Score and V3 Score. 
     V1 and V4 are declared to be primary vertices. T1, T2, T6 and T7 are declared to be primary Tjs.
 
       V1 - T1 - V2 - T3          V4 - T6         / T8
          \                          \           /
            T2 - V3 - T4               T7
                    \
                      T5
  
     This is represented as follows. The NeutrinoPrimaryTjID is defined by a function.
      Tj   ParentID   NeutrinoPrimaryTjID
      -----------------------------------
      T1      0          T1
      T2      0          T2
      T3     T1          T2
      T4     T2          T2
      T5     T2          T2
      T6      0          -1
      T7      0          -1
      T8     -1          -1
 */
     
     // don't do anything if this is test beam data
     if(tjs.TestBeam) return;
     
     // clear old information
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       if(DecodeCTP(tj.CTP).Cryostat != tpcid.Cryostat) continue;
       if(DecodeCTP(tj.CTP).TPC != tpcid.TPC) continue;
       // ignore delta rays
       if(tj.AlgMod[kDeltaRay]) continue;
       // ignore pion-like
 //      if(tj.PDGCode == 211) continue;
       tj.ParentID = 0;
     } // tj
     
     // sort vertice by decreasing score
     std::vector<int> temp;
     for(auto& vx3 : tjs.vtx3) {
       if(vx3.ID == 0) continue;
       if(vx3.TPCID != tpcid) continue;
       // clear the Primary flag while we are here
       vx3.Primary = false;
       temp.push_back(vx3.ID);
     } // vx3
     if(temp.empty()) return;
     
     // Make a master list of all Tjs that are attached to these vertices
     std::vector<int> masterlist;
     for(auto vx3id : temp) {
       auto& vx3 = tjs.vtx3[vx3id - 1];
       float score;
       auto tjlist = GetVtxTjIDs(tjs, vx3, score);
       for(auto tjid : tjlist) {
         // Temp? Check for an existing parentID
         auto& tj = tjs.allTraj[tjid - 1];
         if(tj.ParentID != 0) {
 //          std::cout<<"**** Tj "<<tj.ID<<" Existing parent "<<tj.ParentID<<" PDGCode "<<tj.PDGCode<<". with a vertex... \n";
           tj.ParentID = 0;
         }
         if(std::find(masterlist.begin(), masterlist.end(), tjid) == masterlist.end()) masterlist.push_back(tjid);
       } // tjid
     } // vxid
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"DTP: masterlist Tjs";
       for(auto tjid : masterlist) myprt<<" "<<tjid;
     }
     
     // Do the sort
     std::vector<SortEntry> sortVec(temp.size());
     for(unsigned short indx = 0; indx < temp.size(); ++indx) {
       auto& vx3 = tjs.vtx3[temp[indx] - 1];
       sortVec[indx].index = indx;
       sortVec[indx].val = vx3.Score;
     } // indx
     if(sortVec.size() > 1) std::sort(sortVec.begin(), sortVec.end(), valDecreasing);
     // put them into order
     auto vlist = temp;
     for(unsigned short indx = 0; indx < temp.size(); ++indx) vlist[indx] = temp[sortVec[indx].index];
     
     // make a neutrino PFParticle to associate with the highest score vertex if it is high enough
     if(tjs.Match3DCuts[0] > 0) {
       auto& vx3 = tjs.vtx3[vlist[0] - 1];
       if(vx3.Score > tjs.Vertex2DCuts[7]) {
         auto neutrinoPFP = CreatePFP(tjs, tpcid);
         // call it the neutrino vertex
         vx3.Neutrino = true;
         // put the vertex at the end of the neutrino
         neutrinoPFP.XYZ[1][0] = vx3.X;
         neutrinoPFP.XYZ[1][1] = vx3.Y;
         neutrinoPFP.XYZ[1][2] = vx3.Z;
         neutrinoPFP.XYZ[0] = neutrinoPFP.XYZ[1];
         neutrinoPFP.Dir[1][2] = 1;
         neutrinoPFP.Dir[0][2] = 1;
         // This may be set to 12 later on if a primary shower is reconstructed 
         neutrinoPFP.PDGCode = 14;
         neutrinoPFP.Vx3ID[1] = vx3.ID;
         neutrinoPFP.Vx3ID[0] = vx3.ID;
         neutrinoPFP.NeedsUpdate = false;
         // the rest of this will be defined later
         if(!StorePFP(tjs, neutrinoPFP)) return;
       }
     } // User wants to make PFParticles
     // a temp vector to ensure that we only consider a vertex once
     std::vector<bool> lookedAt3(tjs.vtx3.size() + 1, false);
     std::vector<bool> lookedAt2(tjs.vtx.size() + 1, false);
     // vector of parent-daughter pairs
     std::vector<std::pair<int, int>> pardtr;
     // Start with the highest score vertex 
     for(unsigned short indx = 0; indx < vlist.size(); ++indx) {
       auto& vx3 = tjs.vtx3[vlist[indx] - 1];
       if(lookedAt3[vx3.ID]) continue;
       vx3.Primary = true;
       lookedAt3[vx3.ID] = true;
       // make a list of Tjs attached to this vertex
       float score;
       auto primTjList = GetVtxTjIDs(tjs, vx3, score);
       if(primTjList.empty()) continue;
       pardtr.clear();
       for(auto primTjID : primTjList) {
         auto& primTj = tjs.allTraj[primTjID - 1];
         // This isn't a primary tj if the parent ID isn't -1
         if(primTj.ParentID != -1) continue;
         if(prt) mf::LogVerbatim("TC")<<"Vx3 "<<vx3.ID<<" Primary tj "<<primTj.ID;
         // declare this a primary tj
         primTj.ParentID = 0;
         // look for daughter tjs = those that are attached to a 2D vertex
         // at the other end
         for(unsigned short end = 0; end < 2; ++end) {
           if(primTj.VtxID[end] == 0) continue;
           auto& vx2 = tjs.vtx[primTj.VtxID[end] - 1];
           if(vx2.Vx3ID == vx3.ID) continue;
           // found a 2D vertex. Check for daughters
           auto dtrList = GetVtxTjIDs(tjs, vx2);
           for(auto dtrID : dtrList) {
             // ignore the primary tj
             if(dtrID == primTjID) continue;
             auto& dtj = tjs.allTraj[dtrID - 1];
             if(dtj.ParentID != -1) {
 //              std::cout<<"DTP Error: dtr "<<dtrID<<" already has a parent "<<dtj.ParentID<<". Can't make it daughter of "<<primTjID<<"\n";
               continue;
             }
             pardtr.push_back(std::make_pair(primTjID, dtrID));
             if(prt) mf::LogVerbatim("TC")<<"  primTj "<<primTjID<<" dtrID "<<dtrID;
           } // tjid
         } // end
         // Ensure that end 0 of the trajectory is attached to the primary vertex
         for(unsigned short end = 0; end < 2; ++end) {
           if(primTj.VtxID[end] == 0) continue;
           auto& vx2 = tjs.vtx[primTj.VtxID[end] - 1];
           if(vx2.Vx3ID == vx3.ID && end != 0) ReverseTraj(tjs, primTj);
         } // end
       } // tjid
       if(pardtr.empty()) continue;
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<" par_dtr";
         for(auto pdtr : pardtr) myprt<<" "<<pdtr.first<<"_"<<pdtr.second;
       }
       // iterate through the parent - daughter stack, removing the last pair when a 
       // ParentID is updated and adding pairs for new daughters
       for(unsigned short nit = 0; nit < 100; ++nit) {
         auto lastPair = pardtr[pardtr.size() - 1];
         auto& dtj = tjs.allTraj[lastPair.second - 1];
         dtj.ParentID = lastPair.first;
         // reverse the daughter trajectory if necessary so that end 0 is closest to the parent
         float doca = 100;
         unsigned short dpt = 0, ppt = 0;
         auto& ptj = tjs.allTraj[lastPair.first - 1];
         // find the point on the daughter tj that is closest to the parent
         TrajTrajDOCA(tjs, dtj, ptj, dpt, ppt, doca);
         // reverse the daughter if the closest point is near end 1 of the daughter
         unsigned short midPt = (dtj.EndPt[0] + dtj.EndPt[1]) / 2;
         if(dpt > midPt && !dtj.AlgMod[kSetDir]) ReverseTraj(tjs, dtj);
         if(prt) mf::LogVerbatim("TC")<<"Set parent "<<ptj.ID<<" dtr "<<dtj.ID;
         // remove that entry
         pardtr.pop_back();
         // Add entries for new daughters
         for(unsigned short end = 0; end < 2; ++end) {
           if(dtj.VtxID[end] == 0) continue;
           auto& vx2 = tjs.vtx[dtj.VtxID[end] - 1];
           if(lookedAt2[vx2.ID]) continue;
           lookedAt2[vx2.ID] = true;
           auto tjlist = GetVtxTjIDs(tjs, vx2);
           for(auto tjid : tjlist) {
             if(tjid == dtj.ID || tjid == ptj.ID) continue;
             pardtr.push_back(std::make_pair(dtj.ID, tjid));
             if(prt) {
               mf::LogVerbatim myprt("TC");
               myprt<<" add par_dtr";
               for(auto pdtr : pardtr) myprt<<" "<<pdtr.first<<"_"<<pdtr.second;
             }
           }
         } // end
         if(pardtr.empty()) break;
       } // nit
     } // indx
     // check the master list
     for(auto tjid : masterlist) {
       auto& tj = tjs.allTraj[tjid - 1];
       if(tj.ParentID < 0) {
 //        std::cout<<"Tj "<<tj.ID<<" is in the master list but doesn't have a Parent\n";
         tj.ParentID = tj.ID;
       }
     } // tjid
 
   } // DefineTjParents

double tca::DeltaAngle	(	const Vector3_t	v1,
		const Vector3_t	v2
	)

Definition at line 1607 of file PFPUtils.cxx.

References DotProd().

Referenced by tca::TrajClusterAlg::AddLAHits(), ChkVxTjs(), DotProd(), tca::TrajClusterAlg::EndMerge(), FindHammerVertices(), FindHammerVertices2(), tca::TrajClusterAlg::FindSoftKink(), FindXMatches(), tca::TrajClusterAlg::GottaKink(), KinkAngle(), tca::TruthMatcher::MatchTruth(), ParentFOM(), PrintTp3s(), SetVx2Score(), SplitTrajCrossingVertices(), and tca::TrajClusterAlg::StepCrawl().

   {
     if(v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2]) return 0;
     return acos(DotProd(v1, v2));
   } 

double tca::DeltaAngle	(	const Point2_t &	p1,
		const Point2_t &	p2
	)

Definition at line 2763 of file Utils.cxx.

References DeltaAngle2().

   {
     // angle between two points
     double ang1 = atan2(p1[1], p1[0]);
     double ang2 = atan2(p2[1], p2[0]);
     return DeltaAngle2(ang1, ang2);
   } // DeltaAngle

double tca::DeltaAngle	(	double	Ang1,
		double	Ang2
	)

Definition at line 2782 of file Utils.cxx.

Referenced by CompatibleMerge(), PointInsideEnvelope(), and TagDeltaRays().

   {
     return std::abs(std::remainder(Ang1 - Ang2, M_PI));
   }

double tca::DeltaAngle2	(	double	Ang1,
		double	Ang2
	)

Definition at line 2772 of file Utils.cxx.

Referenced by DeltaAngle(), and DotProd().

   {
     constexpr double twopi = 2 * M_PI;
     double dang = Ang1 - Ang2;
     while(dang >  M_PI) dang -= twopi;
     while(dang < -M_PI) dang += twopi;
     return dang;
   }

bool tca::DontCluster	(	const TjStuff &	tjs,
		const std::vector< int > &	tjlist1,
		const std::vector< int > &	tjlist2
	)

Definition at line 3381 of file TCShower.cxx.

References tca::TjStuff::dontCluster.

Referenced by AddTjsInsideEnvelope(), FindCots(), FindParent(), MergeNearby2DShowers(), MergeOverlap(), MergeShowerChain(), MergeSubShowers(), MergeSubShowersTj(), and Print2DShowers().

   {
     // returns true if a pair of tjs in the two lists are in the dontCluster vector
     if(tjlist1.empty() || tjlist2.empty()) return false;
     if(tjs.dontCluster.empty()) return false;
     for(auto tid1 : tjlist1) {
       for(auto tid2 : tjlist2) {
         int ttid1 = tid1;
         if(ttid1 > tid2) std::swap(ttid1, tid2);
         for(auto& dc : tjs.dontCluster) if(dc.TjIDs[0] == ttid1 && dc.TjIDs[1] == tid2) return true;
       } // dc
     } // tid1
     return false;
   } // DontCluster

double tca::DotProd	(	const Vector3_t &	v1,
		const Vector3_t &	v2
	)

inline

Definition at line 60 of file PFPUtils.h.

References AnalyzePFP(), ChgFracBetween(), ChgFracNearEnd(), CreatePFP(), DefinePFP(), DefinePFPParents(), DefinePFPParentsTestBeam(), evd::details::end(), FarEnd(), FilldEdx(), FindAlongTrans(), FindKinks(), FindPFParticles(), InsideTPC(), KinkAngle(), LineLineIntersect(), PFPDOCA(), PFPVertexCheck(), PFPVxTjOK(), PointDirection(), PointDirIntersect(), PosSep(), PosSep2(), PrintTp3(), PrintTp3s(), ReversePFP(), SetMag(), Split3DKink(), and StorePFP().

Referenced by DefineDontCluster(), DeltaAngle(), FindAlongTrans(), FindParent(), FindShowers3D(), FindShowerStart(), recob::Seed::GetPointingSign(), InShowerProb(), MergeOverlap(), and tca::TruthMatcher::StudyShowerParents().

60 {return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2]; }

double tca::DotProd	(	const Vector2_t &	v1,
		const Vector2_t &	v2
	)

inline

Definition at line 142 of file Utils.h.

References CheckWireHitRange(), DeltaAngle(), DeltaAngle2(), dir, evd::details::end(), FarEnd(), FillWireHitRange(), GetAssns(), HitsPosTick(), HitsPosTime(), HitsRMSTick(), HitsRMSTime(), MakeBareTP(), MakeBareTrajPoint(), MCSMom(), MCSThetaRMS(), MergeAndStore(), NearestPtWithChg(), NumHitsInTP(), NumUsedHitsInTj(), PointDirection(), PrintAllTraj(), PrintClusters(), PrintHeader(), PrintHit(), PrintHitShort(), PrintPFP(), PrintPFPs(), PrintPos(), PrintStopFlag(), PrintTrajectory(), PrintTrajPoint(), SetDifference(), SetEndPoints(), SetIntersection(), SetPDGCode(), TagDeltaRays(), TagMuonDirections(), TjDeltaRMS(), TPHitsRMSTick(), TPHitsRMSTime(), TrajIsClean(), UpdateTjChgProperties(), UpdateVxEnvironment(), and WireHitRangeOK().

142 {return v1[0]*v2[0] + v1[1]*v2[1]; }

void tca::DumpShowerPts	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		int	cotID
	)

void tca::DumpShowerPts	(	TjStuff &	tjs,
		int	cotID
	)

Definition at line 4302 of file TCShower.cxx.

References tca::TjStuff::cots, tca::ShowerStruct::ID, pt, tca::ShowerStruct::ShPts, ss, and tca::ShowerStruct::TjIDs.

   {
     // Print the shower points to the screen. The user should probably pipe the output to a text file
     // then grep this file for the character string PTS which is piped to a text file which can then be
     // imported into Excel, etc
     // Finds the charge at the start of a shower
     if(cotID > (int)tjs.cots.size()) return;
     
     ShowerStruct& ss = tjs.cots[cotID - 1];
     if(ss.ID == 0) return;
     if(ss.TjIDs.empty()) return;
     std::cout<<"PTS Pos0  Pos1   RPos0 RPos1 Chg TID\n";
     for(auto& pt : ss.ShPts) {
       std::cout<<"PTS "<<std::fixed<<std::setprecision(1)<<pt.Pos[0]<<" "<<pt.Pos[1]<<" "<<pt.RotPos[0]<<" "<<pt.RotPos[1];
       std::cout<<" "<<(int)pt.Chg<<" "<<pt.TID;
       std::cout<<"\n";
     }
     
   } // DumpShowerPts

CTP_t tca::EncodeCTP	(	unsigned int	cryo,
		unsigned int	tpc,
		unsigned int	plane
	)

inline

Definition at line 45 of file DataStructs.h.

Referenced by ChgFracBetween(), ChgFracNearEnd(), CompleteIncomplete3DVertices(), CompleteIncomplete3DVerticesInGaps(), EncodeCTP(), cluster::ClusterCrawlerAlg::FindHammerClusters(), FindMissedTjsInTp3s(), tca::TrajClusterAlg::FindMissedVxTjs(), FindNeutralVertices(), FindParent(), FindPFParticles(), FindShowers3D(), FindXMatches(), MakeBareTrajPoint(), tca::MCParticleListUtils::MakeCheatShower(), tca::TruthMatcher::MatchAndSum(), tca::TruthMatcher::MatchTruth(), MergePFPTjs(), tca::MCParticleListUtils::PrimaryElectronPFPID(), PrintShowers(), tca::TrajClusterAlg::reconfigure(), cluster::ClusterCrawlerAlg::RunCrawler(), tca::TrajClusterAlg::RunTrajClusterAlg(), tca::TrajClusterAlg::StartTraj(), tca::TruthMatcher::StudyShowerParents(), cluster::ClusterCrawlerAlg::TmpStore(), cluster::ClusterCrawlerAlg::Vtx3ClusterMatch(), and cluster::ClusterCrawlerAlg::Vtx3ClusterSplit().

45 { return cryo * Cpad + tpc * Tpad + plane; }

tca::Tpad

constexpr unsigned int Tpad

Definition: DataStructs.h:42

tca::Cpad

constexpr unsigned int Cpad

Definition: DataStructs.h:43

CTP_t tca::EncodeCTP ( const geo::PlaneID & planeID )

inline

Definition at line 46 of file DataStructs.h.

References geo::CryostatID::Cryostat, EncodeCTP(), geo::PlaneID::Plane, and geo::TPCID::TPC.

46 { return EncodeCTP(planeID.Cryostat, planeID.TPC, planeID.Plane); }

geo::CryostatID::Cryostat

CryostatID_t Cryostat

Index of cryostat.

Definition: geo_types.h:130

geo::PlaneID::Plane

PlaneID_t Plane

Index of the plane within its TPC.

Definition: geo_types.h:258

tca::EncodeCTP

CTP_t EncodeCTP(const geo::WireID &wireID)

Definition: DataStructs.h:47

geo::TPCID::TPC

TPCID_t TPC

Index of the TPC within its cryostat.

Definition: geo_types.h:203

CTP_t tca::EncodeCTP ( const geo::WireID & wireID )

inline

Definition at line 47 of file DataStructs.h.

References geo::CryostatID::Cryostat, DecodeCTP(), EncodeCTP(), geo::PlaneID::Plane, and geo::TPCID::TPC.

47 { return EncodeCTP(wireID.Cryostat, wireID.TPC, wireID.Plane); }

geo::CryostatID::Cryostat

CryostatID_t Cryostat

Index of cryostat.

Definition: geo_types.h:130

geo::PlaneID::Plane

PlaneID_t Plane

Index of the plane within its TPC.

Definition: geo_types.h:258

tca::EncodeCTP

CTP_t EncodeCTP(const geo::WireID &wireID)

Definition: DataStructs.h:47

geo::TPCID::TPC

TPCID_t TPC

Index of the TPC within its cryostat.

Definition: geo_types.h:203

float tca::ExpectedHitsRMS	(	TjStuff &	tjs,
		const TrajPoint &	tp
	)

Definition at line 1627 of file Utils.cxx.

References tca::TjStuff::AveHitRMS, tca::TrajPoint::CTP, DecodeCTP(), tca::TrajPoint::Dir, geo::PlaneID::Plane, and tca::TjStuff::UnitsPerTick.

Referenced by tca::TrajClusterAlg::AddHits(), tca::TrajClusterAlg::FindUseHits(), and tca::TrajClusterAlg::StartTraj().

   {
     // returns the expected RMS of hits for the trajectory point in ticks
     if(std::abs(tp.Dir[0]) > 0.001) {
       geo::PlaneID planeID = DecodeCTP(tp.CTP);
       return 1.5 * tjs.AveHitRMS[planeID.Plane] + 2 * std::abs(tp.Dir[1]/tp.Dir[0])/tjs.UnitsPerTick;
     } else {
       return 500;
     }
   } // ExpectedHitsRMS

unsigned short tca::FarEnd	(	const TjStuff &	tjs,
		const PFPStruct &	pfp,
		const Point3_t &	pos
	)

Definition at line 2936 of file PFPUtils.cxx.

References tca::PFPStruct::ID, PosSep2(), and tca::PFPStruct::XYZ.

Referenced by ChkVxTjs(), DotProd(), FindParent(), MergeSubShowersTj(), ParentFOM(), tca::MCParticleListUtils::PrimaryElectronPFPID(), Reconcile3D(), SetParent(), tca::TruthMatcher::StudyShowerParents(), TagShowerLike(), and UpdateShower().

   {
     // Returns the end (0 or 1) of the pfp that is furthest away from the position pos
     if(pfp.ID == 0) return 0;
     if(PosSep2(pfp.XYZ[1], pos) > PosSep2(pfp.XYZ[0], pos)) return 1;
     return 0;
   } // FarEnd

unsigned short tca::FarEnd	(	const TjStuff &	tjs,
		const Trajectory &	tj,
		const Point2_t &	pos
	)

Definition at line 3554 of file Utils.cxx.

References tca::Trajectory::EndPt, tca::Trajectory::ID, PosSep2(), and tca::Trajectory::Pts.

   {
     // Returns the end (0 or 1) of the Tj that is furthest away from the position pos
     if(tj.ID == 0) return 0;
     if(PosSep2(tj.Pts[tj.EndPt[1]].Pos, pos) > PosSep2(tj.Pts[tj.EndPt[0]].Pos, pos)) return 1;
     return 0;
   } // FarEnd

void tca::FilldEdx	(	TjStuff &	tjs,
		PFPStruct &	pfp
	)

Definition at line 1654 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, tca::PFPStruct::BestPlane, tca::TjStuff::caloAlg, tca::Trajectory::ChgRMS, tca::Trajectory::CTP, DecodeCTP(), tca::Trajectory::dEdx, tca::PFPStruct::dEdx, calo::CalorimetryAlg::dEdx_AREA(), tca::PFPStruct::dEdxErr, tca::PFPStruct::Dir, tca::Trajectory::EndPt, tca::TjStuff::geom, tca::PFPStruct::ID, tca::TjStuff::NumPlanes, tca::PFPStruct::PDGCode, geo::PlaneID::Plane, geo::GeometryCore::Plane(), tca::Trajectory::Pts, geo::PlaneGeo::ThetaZ(), tca::PFPStruct::TjIDs, tca::TjStuff::UnitsPerTick, and geo::GeometryCore::WirePitch().

Referenced by DotProd(), and StorePFP().

   {
     // Fills the dEdX vector in the match struct. This function should be called after the
     // matched trajectory points are ordered so that dE/dx is calculated at the start of the PFParticle
     if(pfp.ID == 0) return;
     // error check
     bool notgood = false;
     for(unsigned short startend = 0; startend < 2; ++startend) {
       if(pfp.dEdx[startend].size() != tjs.NumPlanes) notgood = true;
       if(pfp.dEdxErr[startend].size() != tjs.NumPlanes) notgood = true;
     }
     if(notgood) {
       //      if(prt) mf::LogVerbatim("TC")<<"FilldEdx found inconsistent sizes for dEdx\n";
       return;
     }
     
     double t0 = 0;
     
     unsigned short numEnds = 2;
     // don't attempt to find dE/dx at the end of a shower
     if(pfp.PDGCode == 1111) numEnds = 1;
     
     unsigned short maxlen = 0;
     for(auto tjID : pfp.TjIDs) {
       
       Trajectory& tj = tjs.allTraj[tjID - 1];
       geo::PlaneID planeID = DecodeCTP(tj.CTP);
       double angleToVert = tjs.geom->Plane(planeID).ThetaZ() - 0.5 * ::util::pi<>();
       for(unsigned short startend = 0; startend < numEnds; ++startend) {
         pfp.dEdx[startend][planeID.Plane] = 0;
         tj.dEdx[startend] = 0;
         double cosgamma = std::abs(std::sin(angleToVert) * pfp.Dir[startend][1] + std::cos(angleToVert) * pfp.Dir[startend][2]);
         if(cosgamma == 0) continue;
         double dx = tjs.geom->WirePitch(planeID) / cosgamma;
         if(dx == 0) continue;
         double dQ = tj.Pts[tj.EndPt[startend]].AveChg;
         if(dQ == 0) continue;
         // convert to dQ/dx
         dQ /= dx;
         double time = tj.Pts[tj.EndPt[startend]].Pos[1] / tjs.UnitsPerTick;
         float dedx = tjs.caloAlg->dEdx_AREA(dQ, time, planeID.Plane, t0);
         if(dedx > 999) dedx = 999;
         pfp.dEdx[startend][planeID.Plane] = dedx;
         tj.dEdx[startend] = dedx;
         // ChgRMS is the fractional error
         pfp.dEdxErr[startend][planeID.Plane] = dedx * tj.ChgRMS;
         
       } // startend
       // Grab the best plane iusing the start f 1 < dE/dx < 50 MeV/cm
       if(pfp.dEdx[0][planeID.Plane] > 1 && pfp.dEdx[0][planeID.Plane] < 50) {
         if(tj.Pts.size() > maxlen) {
           maxlen = tj.Pts.size();
           pfp.BestPlane = planeID.Plane;
         }
       } // valid dE/dx
       
     } // tj
   } // FilldEdX

void tca::FilldEdx	(	TjStuff &	tjs,
		TrajPoint3 &	tp3
	)

Definition at line 1714 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::caloAlg, DecodeCTP(), tca::TrajPoint3::dEdx, calo::CalorimetryAlg::dEdx_AREA(), tca::TrajPoint3::Dir, tca::TjStuff::fHits, tca::TjStuff::geom, geo::PlaneID::Plane, geo::GeometryCore::Plane(), geo::PlaneGeo::ThetaZ(), tca::TrajPoint3::Tj2Pts, tca::TjStuff::UnitsPerTick, and geo::GeometryCore::WirePitch().

   {
     // fills the dEdx variables in tp3 (MeV/cm)
     tp3.dEdx = 0;
     if(tp3.Tj2Pts.empty()) return;
     double t0 = 0;
     float sum = 0;
     float sum2 = 0;
     float cnt = 0;
     for(auto& tj2pt : tp3.Tj2Pts) {
       auto& tp = tjs.allTraj[tj2pt.id - 1].Pts[tj2pt.ipt];
       if(tp.Chg <= 0) continue;
       geo::PlaneID planeID = DecodeCTP(tp.CTP);
       double angleToVert = tjs.geom->Plane(planeID).ThetaZ() - 0.5 * ::util::pi<>();
       double cosgamma = std::abs(std::sin(angleToVert) * tp3.Dir[1] + std::cos(angleToVert) * tp3.Dir[2]);
       if(cosgamma == 0) continue;
       double dx = tjs.geom->WirePitch(planeID) / cosgamma;
       // sum the hit charge
       double chg = 0;
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         if(!tp.UseHit[ii]) continue;
         unsigned int iht = tp.Hits[ii];
         chg += tjs.fHits[iht].Integral;
       }
       double dQ = chg / dx;
       double time = tp.Pos[1] / tjs.UnitsPerTick;
       float dedx = tjs.caloAlg->dEdx_AREA(dQ, time, planeID.Plane, t0);
       if(dedx > 200) continue;
       sum += dedx;
       sum2 += dedx * dedx;
       ++cnt;
     } // tj2pt
     if(cnt == 0) return;
     tp3.dEdx = sum / cnt;
 /*
     if(cnt > 1) {
       float arg = sum2 - cnt * tp3.dEdx * tp3.dEdx;
       if(arg > 0) {
         tp3.dEdxErr = sqrt(arg / (cnt - 1));
         // convert to error on the mean
         tp3.dEdxErr /= sqrt(cnt);
       }
     } // cnt > 1
 */
   } // FilldEdx

void tca::FillmAllTraj	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid
	)

Definition at line 127 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, detinfo::DetectorProperties::ConvertTicksToX(), geo::CryostatID::Cryostat, DecodeCTP(), tca::TjStuff::detprop, tca::TjStuff::geom, geo::GeometryCore::HasWire(), kKilled, kMat3D, kTjHiVx3Score, kUsedHits, tca::TjStuff::mallTraj, tca::TjStuff::Match3DCuts, tca::TjStuff::matchVec, NumPtsWithCharge(), geo::PlaneID::Plane, geo::TPCID::TPC, TPHitsRMSTime(), tca::TjStuff::UnitsPerTick, and valIncreasings().

Referenced by tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // Fills the tjs.mallTraj vector with trajectory points in the tpc and sorts
     // them by increasing X
     tjs.matchVec.clear();
     
     int cstat = tpcid.Cryostat;
     int tpc = tpcid.TPC;
     
     // count the number of TPs and clear out any old 3D match flags
     unsigned int ntp = 0;
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       if(tj.ID <= 0) continue;
       geo::PlaneID planeID = DecodeCTP(tj.CTP);
       if((int)planeID.Cryostat != cstat) continue;
       if((int)planeID.TPC != tpc) continue;
       ntp += NumPtsWithCharge(tjs, tj, false);
       tj.AlgMod[kMat3D] = false;
     } // tj
     if(ntp < 2) return;
     
     tjs.mallTraj.resize(ntp);
     
     // define mallTraj
     unsigned int icnt = 0;
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       geo::PlaneID planeID = DecodeCTP(tj.CTP);
       if((int)planeID.Cryostat != cstat) continue;
       if((int)planeID.TPC != tpc) continue;
       int plane = planeID.Plane;
       int tjID = tj.ID;
       if(tjID <= 0) continue;
       short score = 1;
       if(tj.AlgMod[kTjHiVx3Score]) score = 0;
       for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
         auto& tp = tj.Pts[ipt];
         if(tp.Chg == 0) continue;
         if(icnt > tjs.mallTraj.size() - 1) break;
         if(tp.Pos[0] < -0.4) continue;
         tjs.mallTraj[icnt].wire = std::nearbyint(tp.Pos[0]);
         bool hasWire = tjs.geom->HasWire(geo::WireID(cstat, tpc, plane, tjs.mallTraj[icnt].wire));
         // don't try matching if the wire doesn't exist
         if(!hasWire) continue;
         float xpos = tjs.detprop->ConvertTicksToX(tp.Pos[1]/tjs.UnitsPerTick, plane, tpc, cstat);
         float posPlusRMS = tp.Pos[1] + TPHitsRMSTime(tjs, tp, kUsedHits);
         float rms = tjs.detprop->ConvertTicksToX(posPlusRMS/tjs.UnitsPerTick, plane, tpc, cstat) - xpos;
         if(rms < tjs.Match3DCuts[0]) rms = tjs.Match3DCuts[0];
         if(icnt == tjs.mallTraj.size()) break;
         tjs.mallTraj[icnt].xlo = xpos - rms;
         tjs.mallTraj[icnt].xhi = xpos + rms;
         tjs.mallTraj[icnt].dir = tp.Dir;
         tjs.mallTraj[icnt].ctp = tp.CTP;
         tjs.mallTraj[icnt].id = tjID;
         tjs.mallTraj[icnt].ipt = ipt;
         tjs.mallTraj[icnt].npts = tj.EndPt[1] - tj.EndPt[0] + 1;
         tjs.mallTraj[icnt].score = score;
         ++icnt;
       } // tp
     } // tj
     
     if(icnt < tjs.mallTraj.size()) tjs.mallTraj.resize(icnt);
     
     // This is pretty self-explanatory
     std::vector<SortEntry> sortVec(tjs.mallTraj.size());
     for(unsigned int ipt = 0; ipt < tjs.mallTraj.size(); ++ipt) {
       // populate the sort vector
       sortVec[ipt].index = ipt;
       sortVec[ipt].val = tjs.mallTraj[ipt].xlo;
     } // ipt
     // sort by increasing xlo
     std::sort(sortVec.begin(), sortVec.end(), valIncreasings);
     // put tjs.mallTraj into sorted order
     auto tallTraj = tjs.mallTraj;
     for(unsigned int ii = 0; ii < sortVec.size(); ++ii) tjs.mallTraj[ii] = tallTraj[sortVec[ii].index];
     
   } // FillmAllTraj

bool tca::FillWireHitRange	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid
	)

Definition at line 3722 of file Utils.cxx.

Referenced by DotProd(), FindShowers3D(), trkf::CCTrackMaker::produce(), and tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // fills the WireHitRange vector. Slightly modified version of the one in ClusterCrawlerAlg.
     // Returns false if there was a serious error
     
     // determine the number of planes
     geo::TPCGeo const& TPC = tjs.geom->TPC(tpcid);
     unsigned int cstat = tpcid.Cryostat;
     unsigned int tpc = tpcid.TPC;
     unsigned short nplanes = TPC.Nplanes();
     tjs.NumPlanes = nplanes;
     tjs.TPCID = tpcid;
     
     // Y,Z limits of the detector
     double local[3] = {0.,0.,0.};
     double world[3] = {0.,0.,0.};
     const geo::TPCGeo &thetpc = tjs.geom->TPC(tpc, cstat);
     thetpc.LocalToWorld(local,world);
     // reduce the active area of the TPC by 1 cm to prevent wire boundary issues
     tjs.XLo = world[0]-tjs.geom->DetHalfWidth(tpc,cstat) + 1;
     tjs.XHi = world[0]+tjs.geom->DetHalfWidth(tpc,cstat) - 1;
     tjs.YLo = world[1]-tjs.geom->DetHalfHeight(tpc,cstat) + 1;
     tjs.YHi = world[1]+tjs.geom->DetHalfHeight(tpc,cstat) - 1;
     tjs.ZLo = world[2]-tjs.geom->DetLength(tpc,cstat)/2 + 1;
     tjs.ZHi = world[2]+tjs.geom->DetLength(tpc,cstat)/2 - 1;
     
     lariov::ChannelStatusProvider const& channelStatus = art::ServiceHandle<lariov::ChannelStatusService>()->GetProvider();
     
     if(!tjs.WireHitRange.empty()) tjs.WireHitRange.clear();
     
     // initialize everything
     tjs.WireHitRange.resize(nplanes);
     tjs.FirstWire.resize(nplanes);
     tjs.LastWire.resize(nplanes);
     tjs.NumWires.resize(nplanes);
     tjs.MaxPos0.resize(nplanes);
     tjs.MaxPos1.resize(nplanes);
     tjs.AveHitRMS.resize(nplanes, nplanes);
     
     std::pair<int, int> flag;
     flag.first = -2; flag.second = -2;
     
     // Calculate tjs.UnitsPerTick, the scale factor to convert a tick into
     // Wire Spacing Equivalent (WSE) units where the wire spacing in this plane = 1.
     // Strictly speaking this factor should be calculated for each plane to handle the
     // case where the wire spacing is different in each plane. Deal with this later if
     // the approximation used here fails.
     
     raw::ChannelID_t channel = tjs.geom->PlaneWireToChannel(0, 0, (int)tpc, (int)cstat);
     tjs.WirePitch = tjs.geom->WirePitch(tjs.geom->View(channel));
     float tickToDist = tjs.detprop->DriftVelocity(tjs.detprop->Efield(),tjs.detprop->Temperature());
     tickToDist *= 1.e-3 * tjs.detprop->SamplingRate(); // 1e-3 is conversion of 1/us to 1/ns
     tjs.UnitsPerTick = tickToDist / tjs.WirePitch;
     for(unsigned short ipl = 0; ipl < nplanes; ++ipl) {
       tjs.FirstWire[ipl] = INT_MAX;
       tjs.LastWire[ipl] = 0;
       tjs.NumWires[ipl] = tjs.geom->Nwires(ipl, tpc, cstat);
       tjs.WireHitRange[ipl].resize(tjs.NumWires[ipl], flag);
       tjs.MaxPos0[ipl] = (float)tjs.NumWires[ipl] - 0.5;
       tjs.MaxPos1[ipl] = (float)tjs.detprop->NumberTimeSamples() * tjs.UnitsPerTick;
     }
     
     // overwrite with the "dead wires" condition
     flag.first = -1; flag.second = -1;
     for(unsigned short ipl = 0; ipl < nplanes; ++ipl) {
       for(unsigned int wire = 0; wire < tjs.NumWires[ipl]; ++wire) {
         raw::ChannelID_t chan = tjs.geom->PlaneWireToChannel((int)ipl, (int)wire, (int)tpc, (int)cstat);
         if(!channelStatus.IsGood(chan)) tjs.WireHitRange[ipl][wire] = flag;
       } // wire
     } // ipl
     
     unsigned int lastwire = 0, lastipl = 0;
     for(unsigned int iht = 0; iht < tjs.fHits.size(); ++iht) {
       if(tjs.fHits[iht].ArtPtr->WireID().Cryostat != cstat) continue;
       if(tjs.fHits[iht].ArtPtr->WireID().TPC != tpc) continue;
       unsigned short ipl = tjs.fHits[iht].ArtPtr->WireID().Plane;
       unsigned int wire = tjs.fHits[iht].ArtPtr->WireID().Wire;
       if(wire > tjs.NumWires[ipl] - 1) {
         mf::LogWarning("TC")<<"FillWireHitRange: Invalid wire number "<<wire<<" > "<<tjs.NumWires[ipl] - 1<<" in plane "<<ipl<<" Quitting";
         return false;
       } // too large wire number
       if(ipl == lastipl && wire < lastwire) {
         mf::LogWarning("TC")<<"FillWireHitRange: Hits are not in increasing wire order. Quitting ";
         return false;
       } // hits out of order
       lastwire = wire;
       lastipl = ipl;
       if(tjs.FirstWire[ipl] == INT_MAX) tjs.FirstWire[ipl] = wire;
       if(tjs.WireHitRange[ipl][wire].first < 0) tjs.WireHitRange[ipl][wire].first = iht;
       tjs.WireHitRange[ipl][wire].second = iht + 1;
       tjs.LastWire[ipl] = wire + 1;
     } // iht
     
     if(!CheckWireHitRange(tjs)) return false;
     
     // Find the average multiplicity 1 hit RMS and calculate the expected max RMS for each range
     if(tjs.DebugMode && (int)tpc == debug.TPC) {
       std::cout<<"tpc "<<tpc<<" tjs.UnitsPerTick "<<std::setprecision(3)<<tjs.UnitsPerTick<<"\n";
       std::cout<<"Fiducial volume (";
       std::cout<<std::fixed<<std::setprecision(1)<<tjs.XLo<<" < X < "<<tjs.XHi<<") (";
       std::cout<<std::fixed<<std::setprecision(1)<<tjs.YLo<<" < Y < "<<tjs.YHi<<") (";
       std::cout<<std::fixed<<std::setprecision(1)<<tjs.ZLo<<" < Z < "<<tjs.ZHi<<")\n";
     }
     for(unsigned short ipl = 0; ipl < tjs.NumPlanes; ++ipl) {
       float sumRMS = 0;
       float sumAmp = 0;
       unsigned int cnt = 0;
       for(unsigned int wire = 0; wire < tjs.NumWires[ipl]; ++wire) {
         if(tjs.WireHitRange[ipl][wire].first < 0) continue;
         unsigned int firstHit = tjs.WireHitRange[ipl][wire].first;
         unsigned int lastHit = tjs.WireHitRange[ipl][wire].second;
         // don't let noisy wires screw up the calculation
         if(lastHit - firstHit > 100) continue;
         for(unsigned int iht = firstHit; iht < lastHit; ++iht) {
           if(tjs.fHits[iht].Multiplicity != 1) continue;
           if(tjs.fHits[iht].GoodnessOfFit < 0 || tjs.fHits[iht].GoodnessOfFit > 100) continue;
           // don't let a lot of runt hits screw up the calculation
           if(tjs.fHits[iht].PeakAmplitude < 1) continue;
           ++cnt;
           sumRMS += tjs.fHits[iht].RMS;
           sumAmp += tjs.fHits[iht].PeakAmplitude;
         } // iht
       } // wire
       if(cnt < 4) continue;
       tjs.AveHitRMS[ipl] = sumRMS/(float)cnt;
       sumAmp  /= (float)cnt;
       if(tjs.DebugMode) std::cout<<"Pln "<<ipl<<" tjs.AveHitRMS "<<tjs.AveHitRMS[ipl]<<" Ave PeakAmplitude "<<sumAmp<<"\n";
     } // ipl
     return true;
     
   } // FillWireHitRange

void tca::Find2DVertices	(	TjStuff &	tjs,
		const CTP_t &	inCTP
	)

Definition at line 114 of file TCVertex.cxx.

References tca::TjStuff::allTraj, AttachAnyTrajToVertex(), tca::VtxStore::ChiDOF, ChkVxTjs(), tca::VtxStore::CTP, tca::TrajPoint::CTP, DeadWireCount(), debug, DecodeCTP(), FindHammerVertices(), FindHammerVertices2(), FitVertex(), tca::VtxStore::ID, IsCloseToVertex(), kFixed, kKilled, kOnDeadWire, kShowerLike, tca::TjStuff::MaxPos0, tca::TjStuff::MaxPos1, MergeWithVertex(), MoveTPToWire(), NearestPtWithChg(), tca::VtxStore::NTraj, tca::VtxStore::Pass, tca::DebugStuff::Plane, geo::PlaneID::Plane, tca::VtxStore::Pos, tca::TrajPoint::Pos, PosSep(), PosSep2(), PrintAllTraj(), PrintPos(), SetVx2Score(), SignalBetween(), tca::VtxStore::Stat, tca::TjStuff::StepDir, StoreVertex(), tca::DebugStuff::Tick, tca::VtxStore::Topo, TrajClosestApproach(), TrajIntersection(), TrajLength(), TrajTrajDOCA(), tca::TjStuff::UnitsPerTick, tca::TjStuff::Vertex2DCuts, and tca::TjStuff::vtx.

Referenced by tca::TrajClusterAlg::ReconstructAllTraj().

   {
     // Find 2D vertices between pairs of tjs that have a same-end topology. Using an example
     // where StepDir = 1 (end 0 is at small wire number) vertices will be found with Topo = 0
     // with a vertex US of the ends (<) or Topo = 2 with a vertex DS of the ends (>). This is reversed
     // if StepDir = -1. Vertices with Topo = 1 (/\) and (\/) are found in EndMerge.
     
     // tjs.Vertex2DCuts fcl input usage
     // 0 = maximum length of a short trajectory
     // 1 = max vertex - trajectory separation for short trajectories
     // 2 = max vertex - trajectory separation for long trajectories
     // 3 = max position pull for adding TJs to a vertex
     // 4 = max allowed vertex position error
     // 5 = min MCSMom
     // 6 = min Pts/Wire fraction
     // 7 min Score
     // 8 Min charge fraction near a merge point (not a vertex)
     // 9 max MCSmom asymmetry for a merge
     
     if(tjs.Vertex2DCuts[0] <= 0) return;
     
     if(tjs.allTraj.size() < 2) return;
     
     geo::PlaneID planeID = DecodeCTP(inCTP);
     
     bool prt = (debug.Plane == (int)planeID.Plane && debug.Tick < 0);
     if(prt) {
       mf::LogVerbatim("TC")<<"prt set for plane "<<planeID.Plane<<" in Find2DVertices";
       PrintAllTraj("F2DVi", tjs, debug, USHRT_MAX, tjs.allTraj.size());
     }
     
     unsigned short maxShortTjLen = tjs.Vertex2DCuts[0];
     for(unsigned short it1 = 0; it1 < tjs.allTraj.size() - 1; ++it1) {
       auto& tj1 = tjs.allTraj[it1];
       if(tj1.AlgMod[kKilled]) continue;
       if(tj1.SSID > 0 || tj1.AlgMod[kShowerLike]) continue;
       if(tj1.CTP != inCTP) continue;
       bool tj1Short = (TrajLength(tj1) < maxShortTjLen);
       for(unsigned short end1 = 0; end1 < 2; ++end1) {
         // vertex assignment exists?
         if(tj1.VtxID[end1] > 0) continue;
         // default condition is to use the end point to define the trajectory and direction
         // at the end
         short endPt1 = tj1.EndPt[end1];
         float wire1 = tj1.Pts[endPt1].Pos[0];
         // unless there are few points fitted, indicating that the trajectory fit
         // may have been biased by the presence of another trajectory at the vertex or by
         // other close unresolved tracks
         if(tj1.Pts.size() > 6 && tj1.Pts[endPt1].NTPsFit < 4) {
           if(end1 == 0 && endPt1 < int(tj1.Pts.size()) - 3) {
             endPt1 += 3;
           } else if (end1 == 1 && endPt1 >=3 ) {
             endPt1 -= 3;
           }
           if(tj1.Pts[endPt1].Chg == 0) endPt1 = NearestPtWithChg(tjs, tj1, endPt1);
         } // few points fit at end1
         TrajPoint tp1 = tj1.Pts[endPt1];
         MoveTPToWire(tp1, wire1);
         // re-purpose endPt1 to reference the end point. This will be used the find the point on
         // tj1 that is closest to the vertex position
         endPt1 = tj1.EndPt[end1];
         short oendPt1 = tj1.EndPt[1-end1];
         // reference to the other end of tj1
         auto& otp1 = tj1.Pts[oendPt1];
         for(unsigned short it2 = it1 + 1; it2 < tjs.allTraj.size(); ++it2) {
           auto& tj2 = tjs.allTraj[it2];
           if(tj2.AlgMod[kKilled]) continue;
           if(tj2.SSID > 0 || tj2.AlgMod[kShowerLike]) continue;
           if(tj2.CTP != inCTP) continue;
           if(tj1.VtxID[end1] > 0) continue;
           if(tj1.MCSMom < tjs.Vertex2DCuts[5] && tj2.MCSMom < tjs.Vertex2DCuts[5]) continue;
           bool tj2Short = (TrajLength(tj2) < maxShortTjLen);
           // find the end that is closer to tp1
           unsigned short end2 = 0;
           if(PosSep2(tj2.Pts[tj2.EndPt[1]].Pos, tp1.Pos) < PosSep2(tj2.Pts[tj2.EndPt[0]].Pos, tp1.Pos)) end2 = 1;
           if(tj2.VtxID[end2] > 0) continue;
           // check for a vertex between these tjs at the other ends
           if(tj1.VtxID[1 - end1] > 0 && tj1.VtxID[1 - end1] == tj2.VtxID[1 - end2]) continue;
           // see if the other ends are closer 
           unsigned short oendPt2 = tj2.EndPt[1-end2];
           auto& otp2 = tj2.Pts[oendPt2];
           if(PosSep2(otp1.Pos, otp2.Pos) < PosSep2(tp1.Pos, tj2.Pts[tj2.EndPt[end2]].Pos)) continue;
           short endPt2 = tj2.EndPt[end2];
           float wire2 = tj2.Pts[endPt2].Pos[0];
           if(tj2.Pts.size() > 6 && tj2.Pts[endPt2].NTPsFit < 4) {
             if(end2 == 0 && endPt2 < int(tj2.Pts.size()) - 3) {
               endPt2 += 3;
             } else if (end2 == 1 && endPt2 >= 3){
               endPt2 -= 3;
             }
             if(tj2.Pts[endPt2].Chg == 0) endPt2 = NearestPtWithChg(tjs, tj2, endPt2);
           } // few points fit at end1
           TrajPoint tp2 = tj2.Pts[endPt2];
           MoveTPToWire(tp2, wire2);
           // re-purpose endPt2
           endPt2 = tj2.EndPt[end2];
           // Rough first cut on the separation between the end points of the
           // two trajectories
           float sepCut = 100;
           if(std::abs(tp1.Pos[0] - tp2.Pos[0]) > sepCut) continue;
           if(std::abs(tp1.Pos[1] - tp2.Pos[1]) > sepCut) continue;
           float wint, tint;
           TrajIntersection(tp1, tp2, wint, tint);
           // make sure this is inside the TPC
           if(wint < 0 || wint > tjs.MaxPos0[planeID.Plane]) continue;
           if(tint < 0 || tint > tjs.MaxPos1[planeID.Plane]) continue;
           // Next cut on separation between the TPs and the intersection point
           if(tj1Short || tj2Short) { sepCut = tjs.Vertex2DCuts[1]; } else { sepCut = tjs.Vertex2DCuts[2]; }
           Point2_t vPos {{wint, tint}};
           float vt1Sep = PosSep(vPos, tp1.Pos);
           float vt2Sep = PosSep(vPos, tp2.Pos);
           float dwc1 = DeadWireCount(tjs, wint, tp1.Pos[0], tp1.CTP);
           float dwc2 = DeadWireCount(tjs, wint, tp2.Pos[0], tp1.CTP);
           vt1Sep -= dwc1;
           vt2Sep -= dwc2;
           bool vtxOnDeadWire = (DeadWireCount(tjs, wint, wint, tp1.CTP) == 1);            
           if(prt && vt1Sep < 200 && vt2Sep < 200) {
             mf::LogVerbatim myprt("TC");
             myprt<<"F2DV candidate T"<<tj1.ID<<"_"<<end1<<"-T"<<tj2.ID<<"_"<<end2;
             myprt<<" vtx pos "<<(int)wint<<":"<<(int)(tint/tjs.UnitsPerTick)<<" tp1 "<<PrintPos(tjs, tp1)<<" tp2 "<<PrintPos(tjs, tp2);
             myprt<<" dwc1 "<<dwc1<<" dwc2 "<<dwc2<<" on dead wire? "<<vtxOnDeadWire;
             myprt<<" vt1Sep "<<vt1Sep<<" vt2Sep "<<vt2Sep<<" sepCut "<<sepCut;
           }
           if(vt1Sep > sepCut || vt2Sep > sepCut) continue;
           // make sure that the other end isn't closer
           if(PosSep(vPos, tjs.allTraj[it1].Pts[oendPt1].Pos) < vt1Sep) {
             if(prt) mf::LogVerbatim("TC")<<" tj1 other end "<<PrintPos(tjs, tj1.Pts[oendPt1])<<" is closer to the vertex";
             continue;
           }
           if(PosSep(vPos, tjs.allTraj[it2].Pts[oendPt2].Pos) < vt2Sep) {
             if(prt) mf::LogVerbatim("TC")<<" tj2 other end "<<PrintPos(tjs, tj2.Pts[oendPt2])<<" is closer to the vertex";
             continue;
           }
           // Ensure that the vertex position is close to the end of each Tj
           unsigned short closePt1;
           float doca1 = sepCut;
           if(!TrajClosestApproach(tj1, wint, tint, closePt1, doca1)) continue;
           // dpt1 (and dpt2) will be 0 if the vertex is at the end
           short dpt1 = tjs.StepDir * (closePt1 - endPt1);
           if(prt) mf::LogVerbatim("TC")<<" endPt1 "<<endPt1<<" closePt1 "<<closePt1<<" dpt1 "<<dpt1<<" doca1 "<<doca1;
           // BB April 19, 2018: require vertex to be near the end
           if(dpt1 < -1) continue;
           if(tjs.allTraj[it1].EndPt[1] > 4) {
             if(dpt1 > 3) continue;
           } else {
             // tighter cut for short trajectories
             if(dpt1 > 2) continue;
           }
           unsigned short closePt2;
           float doca2 = sepCut;
           if(!TrajClosestApproach(tj2, wint, tint, closePt2, doca2)) continue;
           short dpt2 = tjs.StepDir * (closePt2 - endPt2);
           if(prt) mf::LogVerbatim("TC")<<" endPt2 "<<endPt2<<" closePt2 "<<closePt2<<" dpt2 "<<dpt2<<" doca2 "<<doca2;
           // BB April 19, 2018: require vertex to be near the end
           if(dpt2 < -1) continue;
           if(tjs.allTraj[it2].EndPt[1] > 4) {
             if(dpt2 > 3) continue;
           } else {
             // tighter cut for short trajectories
             if(dpt2 > 2) continue;
           }
           if(prt) mf::LogVerbatim("TC")<<" wint:tint "<<(int)wint<<":"<<(int)(tint/tjs.UnitsPerTick);
           // ensure that there is a signal between these TPs and the vertex on most of the wires
           bool signalBetween = true;
           bool fixVxPos = false;
           short dpt = abs(wint - tp1.Pos[0]);
           if(dpt > 2 && !SignalBetween(tjs, tp1, wint, tjs.Vertex2DCuts[6], prt)) {
             if(prt) mf::LogVerbatim("TC")<<" Fails SignalBetween for tp1 "<<dpt;
             signalBetween = false;
           }
           dpt = abs(wint - tp2.Pos[0]);
           if(dpt > 2 && !SignalBetween(tjs, tp2, wint, tjs.Vertex2DCuts[6], prt)) {
             if(prt) mf::LogVerbatim("TC")<<" Fails SignalBetween for tp2 "<<dpt;
             signalBetween = false;
           }
           // consider the case where the intersection point is wrong because the
           // end TP angles are screwed up but the Tjs are close to each other near the end
           if(!signalBetween) {
             unsigned short ipt1, ipt2;
             float maxSep = 3;
             bool isClose = TrajTrajDOCA(tjs, tj1, tj2, ipt1, ipt2, maxSep, false);
             if(prt) mf::LogVerbatim("TC")<<" TrajTrajDOCA close? "<<isClose<<" minSep "<<maxSep;
             if(isClose) {
               // put the vertex at the TP that is closest to the intersection point
               Point2_t vpos = {{wint, tint}};
               if(PosSep2(tp1.Pos, vpos) < PosSep2(tp2.Pos, vpos)) {
                 wint = tp1.Pos[0];
                 tint = tp1.Pos[1];
               } else {
                 wint = tp2.Pos[0];
                 tint = tp2.Pos[1];
               }
               fixVxPos = true;
               if(prt) mf::LogVerbatim("TC")<<" new wint:tint "<<(int)wint<<":"<<(int)(tint/tjs.UnitsPerTick);
             } else {
               // closest approach > 3
               continue;
             }
           } // no signal between
           // make a new temporary vertex
           VtxStore aVtx;
           aVtx.Pos[0] = wint;
           aVtx.Pos[1] = tint;
           aVtx.NTraj = 0;
           aVtx.Pass = tj1.Pass;
           // Topo 0 has this topology (<) and Topo 2 has this (>)
           aVtx.Topo = 2 * end1;
           aVtx.ChiDOF = 0;
           aVtx.CTP = inCTP;
           aVtx.Stat[kOnDeadWire] = vtxOnDeadWire;
           // fix the vertex position if we needed to move it significantly, or if it is on a dead wire
           aVtx.Stat[kFixed] = fixVxPos;
 //          if(close2 > 1) aVtx.Stat[kFixed] = true;
           // try to fit it. We need to give it an ID to do that. Take the next
           // available ID
           unsigned short newVtxID = tjs.vtx.size() + 1;
           aVtx.ID = newVtxID;
           tj1.VtxID[end1] = newVtxID;
           tj2.VtxID[end2] = newVtxID;
           if(!FitVertex(tjs, aVtx, prt)) {
             tj1.VtxID[end1] = 0;
             tj2.VtxID[end2] = 0;
             continue;
           }
           // check proximity to nearby vertices
           unsigned short mergeMeWithVx = IsCloseToVertex(tjs, aVtx);
           if(mergeMeWithVx > 0 && MergeWithVertex(tjs, aVtx, mergeMeWithVx, prt)) {
             if(prt) mf::LogVerbatim("TC")<<" Merged with close vertex "<<mergeMeWithVx;
             continue;
           }
           // Save it
           if(!StoreVertex(tjs, aVtx)) continue;
           if(prt) {
             mf::LogVerbatim myprt("TC");
             myprt<<" New vtx 2V"<<aVtx.ID;
             myprt<<" Tjs "<<tj1.ID<<"_"<<end1<<"-"<<tj2.ID<<"_"<<end2;
             myprt<<" at "<<std::fixed<<std::setprecision(1)<<aVtx.Pos[0]<<":"<<aVtx.Pos[1]/tjs.UnitsPerTick;
           }
           AttachAnyTrajToVertex(tjs, tjs.vtx.size() - 1, prt);
           SetVx2Score(tjs, prt);
         } // it2
       } // end1
     } // it1
     
     // check the consistency of the Tjs for the newly added vertices
     ChkVxTjs(tjs, inCTP, prt);
     
     FindHammerVertices(tjs, inCTP);
     FindHammerVertices2(tjs, inCTP);
     
     if(prt) PrintAllTraj("F2DVo", tjs, debug, USHRT_MAX, USHRT_MAX);
     
   } // Find2DVertices

void tca::Find3DVertices	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid
	)

Definition at line 1215 of file TCVertex.cxx.

References tca::TjStuff::allTraj, CompleteIncomplete3DVertices(), CompleteIncomplete3DVerticesInGaps(), detinfo::DetectorProperties::ConvertTicksToX(), detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, debug, DecodeCTP(), tca::TjStuff::detprop, tca::TjStuff::fHits, FindCloseHits(), tca::TjStuff::geom, geo::GeometryCore::HasWire(), tca::SortEntry::index, geo::GeometryCore::IntersectionPoint(), kAllHits, kKilled, kTjHiVx3Score, evd::kWire, geo::kX, tca::TjStuff::NumPlanes, tca::TjStuff::NumWires, tca::DebugStuff::Plane, geo::PlaneID::Plane, PrintAllTraj(), PrintHit(), tca::Vtx3Store::Score, SetVx2Score(), SetVx3Score(), tca::DebugStuff::Tick, geo::TPCID::TPC, tca::Vtx3Store::TPCID, tca::TjStuff::UnitsPerTick, tca::SortEntry::val, valIncreasing(), tca::TjStuff::Vertex3DCuts, tca::TjStuff::vtx, tca::TjStuff::vtx3, tca::Vtx3Store::Vx2ID, tca::VtxStore::Vx3ID, tca::Vtx3Store::Wire, geo::GeometryCore::WireCoordinate(), geo::GeometryCore::WirePitch(), tca::Vtx3Store::X, tca::Vtx3Store::XErr, y, tca::Vtx3Store::Y, tca::Vtx3Store::YErr, tca::TjStuff::YHi, tca::Vtx3Store::Z, z, tca::Vtx3Store::ZErr, and tca::TjStuff::ZHi.

Referenced by tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // Create 3D vertices from 2D vertices. 3D vertices that are matched
     // in all three planes have Vtx2ID > 0 for all planes. This function re-scores all
     // 2D and 3D vertices and flags Tjs that have high-score 3D vertices    
     
     if(tjs.Vertex3DCuts[0] < 0) return;
     if(tjs.vtx.size() < 2) return;
     
     const unsigned int cstat = tpcid.Cryostat;
     const unsigned int tpc = tpcid.TPC;
     
     // create a array/vector of 2D vertex indices in each plane
     std::vector<std::vector<unsigned short>> vIndex(3);
     for(unsigned short ivx = 0; ivx < tjs.vtx.size(); ++ivx) {
       // obsolete vertex
       if(tjs.vtx[ivx].ID == 0) continue;
       geo::PlaneID planeID = DecodeCTP(tjs.vtx[ivx].CTP);
       if(planeID.TPC != tpc || planeID.Cryostat != cstat) continue;
       unsigned short plane = planeID.Plane;
       if(plane > 2) continue;
       vIndex[plane].push_back(ivx);
     }
     
     unsigned short vtxInPln = 0;
     for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) if(vIndex[plane].size() > 0) ++vtxInPln;
     if(vtxInPln < 2) return;
     
     bool prt = (debug.Plane >= 0) && (debug.Tick == 2222);
     
     float thirdPlanedXCut = 2 * tjs.Vertex3DCuts[0];
     
     if(prt) {
       mf::LogVerbatim("TC")<<"Inside Find3DVertices. dX cut "<<tjs.Vertex3DCuts[0]<<" thirdPlanedXCut "<<thirdPlanedXCut;
       PrintAllTraj("F3DV", tjs, debug, USHRT_MAX, tjs.allTraj.size());
     }
     
     // wire spacing in cm
     float wirePitch = tjs.geom->WirePitch(0, tpcid.TPC, tpcid.Cryostat);
     
     size_t vsize = tjs.vtx.size();
     // vector of 2D vertices -> 3D vertices.
     std::vector<short> vPtr(vsize, -1);
     // fill temp vectors of 2D vertex X and X errors
     std::vector<float> vX(vsize, -100);
     
     for(unsigned short ivx = 0; ivx < vsize; ++ivx) {
       if(tjs.vtx[ivx].ID == 0) continue;
       geo::PlaneID planeID = DecodeCTP(tjs.vtx[ivx].CTP);
       if(planeID.TPC != tpc || planeID.Cryostat != cstat) continue;
       int plane = planeID.Plane;
       if(tjs.vtx[ivx].Pos[0] < -0.4) continue;
       unsigned int wire = std::nearbyint(tjs.vtx[ivx].Pos[0]);
       if(!tjs.geom->HasWire(geo::WireID(cstat, tpc, plane, wire))) continue;
       // Convert 2D vertex time error to X error
       double ticks = tjs.vtx[ivx].Pos[1] / tjs.UnitsPerTick;
       vX[ivx]  = tjs.detprop->ConvertTicksToX(ticks, plane, (int)tpc, (int)cstat);
     } // ivx
     
     // temp vector of all 2D vertex matches
     std::vector<Vtx3Store> v3temp;
     
     TrajPoint tp;
     float maxScore = 0;
     constexpr float maxSep = 4;
     // i, j, k indicates 3 different wire planes
     // compare vertices in each view
     for(unsigned short ipl = 0; ipl < 2; ++ipl) {
       for(unsigned short ii = 0; ii < vIndex[ipl].size(); ++ii) {
         unsigned short ivx = vIndex[ipl][ii];
         if(vX[ivx] < 0) continue;
         auto& ivx2 = tjs.vtx[ivx];
         if(ivx2.Pos[0] < -0.4) continue;
         unsigned int iWire = std::nearbyint(ivx2.Pos[0]);
         for(unsigned short jpl = ipl + 1; jpl < 3; ++jpl) {
           for(unsigned short jj = 0; jj < vIndex[jpl].size(); ++jj) {
             unsigned short jvx = vIndex[jpl][jj];
             if(vX[jvx] < 0) continue;
             auto& jvx2 = tjs.vtx[jvx];
             if(jvx2.Pos[0] < -0.4) continue;
             unsigned int jWire = std::nearbyint(jvx2.Pos[0]);
             float dX = std::abs(vX[ivx] - vX[jvx]);
             if(dX > tjs.Vertex3DCuts[0]) continue;
             if(prt) {
               mf::LogVerbatim("TC")<<"F3DV: ipl "<<ipl<<" i2V"<<ivx2.ID<<" iX "<<vX[ivx]
               <<" jpl "<<jpl<<" j2V"<<jvx2.ID<<" jvX "<<vX[jvx]<<" W:T "<<(int)jvx2.Pos[0]<<":"<<(int)jvx2.Pos[1]<<" dX "<<dX;
             }
             double y = -1000, z = -1000;
             tjs.geom->IntersectionPoint(iWire, jWire, ipl, jpl, cstat, tpc, y, z);
             if(y < tjs.YLo || y > tjs.YHi || z < tjs.ZLo || z > tjs.ZHi) continue;
             unsigned short kpl = 3 - ipl - jpl;
             float kX = 0.5 * (vX[ivx] + vX[jvx]);
             int kWire = -1;
             if(tjs.NumPlanes > 2) {
               kWire = (int)(tjs.geom->WireCoordinate(y, z, kpl, tpc, cstat) + 0.5);
               if(kWire < 0 || (unsigned int)kWire > tjs.NumWires[kpl]) continue;
               if(!tjs.geom->HasWire(geo::WireID(cstat, tpc, kpl, kWire))) continue;
               std::array<int, 2> wireWindow;
               std::array<float, 2> timeWindow;
               wireWindow[0] = kWire - maxSep;
               wireWindow[1] = kWire + maxSep;
               float time = tjs.detprop->ConvertXToTicks(kX, kpl, (int)tpc, (int)cstat) * tjs.UnitsPerTick;
               timeWindow[0] = time - maxSep;
               timeWindow[1] = time + maxSep;
               bool hitsNear;
               std::vector<unsigned int> closeHits = FindCloseHits(tjs, wireWindow, timeWindow, kpl, kAllHits, true, hitsNear);
               if(prt) {
                 mf::LogVerbatim myprt("TC");
                 myprt<<" Hits near "<<kpl<<":"<<kWire<<":"<<(int)(time/tjs.UnitsPerTick)<<" = ";
                 for(auto iht : closeHits) myprt<<" "<<PrintHit(tjs.fHits[iht]);
               }
               if(!hitsNear) continue;
             } // 3-plane TPC
 /* Don't require a Tj near this position. Look for hits instead
             if(tjs.NumPlanes > 2) {
               kWire = (int)(tjs.geom->WireCoordinate(y, z, kpl, tpc, cstat) + 0.5);
               if(kWire < 0 || (unsigned int)kWire > tjs.NumWires[kpl]) continue;
               if(!tjs.geom->HasWire(geo::WireID(cstat, tpc, kpl, kWire))) continue;
               tp.Pos[0] = kWire;
               // See if there is a wire signal nearby in kpl
               tp.Pos[1] = tjs.detprop->ConvertXToTicks(kX, kpl, tpc, cstat) * tjs.UnitsPerTick;
               tp.CTP = EncodeCTP(cstat, tpc, kpl);
               auto tjlist = FindCloseTjs(tjs, tp, tp, maxSep);
               if(prt) {
                 mf::LogVerbatim myprt("TC");
                 myprt<<" Tjs near "<<kpl<<":"<<PrintPos(tjs, tp);
                 for(auto tjid : tjlist) myprt<<" T"<<tjid;
               }
               if(tjlist.empty()) continue;
             }
 */
             // save this incomplete 3D vertex
             Vtx3Store v3d;
             v3d.Vx2ID[ipl] = ivx + 1;
             v3d.Vx2ID[jpl] = jvx + 1;
             v3d.Vx2ID[kpl] = 0;
             // see if this is already in the list
             bool gotit = false;
             for(unsigned short i3t = 0; i3t < v3temp.size(); ++i3t) {
               if(v3temp[i3t].Vx2ID[0] == v3d.Vx2ID[0] && v3temp[i3t].Vx2ID[1] == v3d.Vx2ID[1] && v3temp[i3t].Vx2ID[2] == v3d.Vx2ID[2]) {
                 gotit = true;
                 break;
               }
             } // i3t
             if(gotit) continue;
             v3d.X = kX;
             // Use XErr to store dX
             v3d.XErr = dX;
             v3d.Y = y;
             v3d.Z = z;
             v3d.Wire = kWire;
             v3d.Score = dX / tjs.Vertex3DCuts[0];
             v3d.TPCID = tpcid;
             // push the incomplete vertex onto the list
             v3temp.push_back(v3d);
             
             if(prt) mf::LogVerbatim("TC")<<"F3DV: 2 Plane match i2V"<<tjs.vtx[ivx].ID<<" P:W:T "<<ipl<<":"<<(int)tjs.vtx[ivx].Pos[0]<<":"<<(int)tjs.vtx[ivx].Pos[1]<<" j2V"<<tjs.vtx[jvx].ID<<" P:W:T "<<jpl<<":"<<(int)tjs.vtx[jvx].Pos[0]<<":"<<(int)tjs.vtx[jvx].Pos[1]<<" dX "<<dX;
             
             if(tjs.NumPlanes == 2) continue;
             
             // look for a 3 plane match
             for(unsigned short kk = 0; kk < vIndex[kpl].size(); ++kk) {
               unsigned short kvx = vIndex[kpl][kk];
               if(vX[kvx] < 0) continue;
               float dX = std::abs(vX[kvx] - v3d.X);
               // Wire difference error
               float dW = wirePitch * std::abs(tjs.vtx[kvx].Pos[0] - kWire);
               if(prt) mf::LogVerbatim("TC")<<" k2V"<<kvx+1<<" dX "<<dX<<" dW "<<dW;
               if(dX > thirdPlanedXCut) continue;
               if(dW > tjs.Vertex3DCuts[1]) continue;
               // put the Y,Z difference in YErr and ZErr
               double y = -1000, z = -1000;
               tjs.geom->IntersectionPoint(iWire, kWire, ipl, kpl, cstat, tpc, y, z);
               v3d.YErr = y - v3d.Y;
               v3d.ZErr = z - v3d.Z;
               v3d.Vx2ID[kpl] = kvx + 1;
               v3d.Wire = -1;
               // hijack the Score variable to hold the separation^2, weighted by the
               // vertex3DCuts
               dX = (vX[kvx] - v3d.X) / tjs.Vertex3DCuts[0];
               float dY = v3d.YErr / tjs.Vertex3DCuts[1];
               float dZ = v3d.ZErr / tjs.Vertex3DCuts[1];
               v3d.Score = dX * dX + dY * dY + dZ * dZ;
               if(v3d.Score > maxScore) maxScore = v3d.Score;
               v3temp.push_back(v3d);
             } // kk
           } // jj
         } // jpl
       } // ii
     } // ipl
     
     if(v3temp.empty()) return;
     
     // We will sort this list by increasing score. First add the maxScore for 2-plane matches so that
     // they are considered after the 3-plane matches
     maxScore += 1;
     for(auto& v3 : v3temp) if(v3.Wire >= 0) v3.Score += maxScore;
     
     if(prt) {
       mf::LogVerbatim("TC")<<"v3temp list";
       for(auto& v3 : v3temp) {
         mf::LogVerbatim("TC")<<v3.Vx2ID[0]<<" "<<v3.Vx2ID[1]<<" "<<v3.Vx2ID[2]<<" wire "<<v3.Wire<<" "<<v3.Score;
       } // v3
     }
     SortEntry sEntry;
     std::vector<SortEntry> sortVec(v3temp.size());
     for(unsigned short ivx = 0; ivx < v3temp.size(); ++ivx) {
       sEntry.index = ivx;
       sEntry.val = v3temp[ivx].Score;
       sortVec[ivx] = sEntry;
     } // ivx
     if(sortVec.size() > 1) std::sort(sortVec.begin(), sortVec.end(), valIncreasing);
     // create a new vector of selected 3D vertices
     std::vector<Vtx3Store> v3sel;
     for(unsigned short ii = 0; ii < sortVec.size(); ++ii) {
       unsigned short ivx = sortVec[ii].index;
       // ensure that all 2D vertices are unique
       bool skipit = false;
       for(auto& v3 : v3sel) {
         for(unsigned short ipl = 0; ipl < tjs.NumPlanes; ++ipl) {
           if(v3temp[ivx].Vx2ID[ipl] == 0) continue;
           if(v3temp[ivx].Vx2ID[ipl] == v3.Vx2ID[ipl]) {
             skipit = true;
             break;
           }
         } // ipl
         if(skipit) break;
       } // v3
       if(skipit) continue;
       v3sel.push_back(v3temp[ivx]);
     } // ii
     v3temp.clear();
     
     if(prt) {
       mf::LogVerbatim("TC")<<"v3sel list";
       for(auto& v3d : v3sel) {
         mf::LogVerbatim("TC")<<v3d.Vx2ID[0]<<" "<<v3d.Vx2ID[1]<<" "<<v3d.Vx2ID[2]<<" wire "<<v3d.Wire<<" "<<v3d.Score;
       } // v3d
     }
     
     // Count the number of incomplete vertices and store
     unsigned short ninc = 0;
     for(auto& vx3 : v3sel) {
       if(tjs.NumPlanes == 2) {
         vx3.Vx2ID[2] = 666;
       } else {
         if(vx3.Wire >= 0) ++ninc;
       }
       vx3.ID = tjs.vtx3.size() + 1;
       if(prt) mf::LogVerbatim("TC")<<" 3V"<<vx3.ID<<"  2V"<<vx3.Vx2ID[0]<<" 2V"<<vx3.Vx2ID[1]<<" 2V"<<vx3.Vx2ID[2]
         <<" wire "<<vx3.Wire;
       tjs.vtx3.push_back(vx3);
       // make the 2D -> 3D associations
       for(unsigned short ipl = 0; ipl < tjs.NumPlanes; ++ipl) {
         if(vx3.Vx2ID[ipl] == 0) continue;
         VtxStore& vx2 = tjs.vtx[vx3.Vx2ID[ipl]-1];
         vx2.Vx3ID = vx3.ID;
       } // ipl
     } // ivx
     
     // Try to complete incomplete vertices
     if(ninc > 0) {
       CompleteIncomplete3DVerticesInGaps(tjs, tpcid);
       CompleteIncomplete3DVertices(tjs, tpcid);
     }
     
     // Score and flag Tjs that are attached to high-score vertices
     // First remove Tj vertex flags
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       geo::PlaneID planeID = DecodeCTP(tj.CTP);
       if(planeID.TPC != tpc || planeID.Cryostat != cstat) continue;
       tj.AlgMod[kTjHiVx3Score] = false;
     } // tj
     // Score the 2D vertices
     for(auto& vx2 : tjs.vtx) {
       if(vx2.ID == 0) continue;
       geo::PlaneID planeID = DecodeCTP(vx2.CTP);
       if(planeID.TPC != tpc || planeID.Cryostat != cstat) continue;
       SetVx2Score(tjs, vx2, prt);
     } // vx2
     // and the 3D vertices
     for(auto& vx3 : tjs.vtx3) {
       if(vx3.ID == 0) continue;
       if(vx3.TPCID != tpcid) continue;
       SetVx3Score(tjs, vx3, prt);
     } // vx3
 
   } // Find3DVertices

void tca::FindAlongTrans	(	Point2_t	pos1,
		Vector2_t	dir1,
		Point2_t	pos2,
		Point2_t &	alongTrans
	)

Definition at line 2741 of file Utils.cxx.

References DotProd(), E, and SetMag().

   {
     // Calculate the distance along and transverse to the direction vector dir1 from pos1 to pos2
     alongTrans[0] = 0;
     alongTrans[1] = 0;
     if(pos1[0] == pos2[0] && pos1[1] == pos2[1]) return;
     pos1[0] = pos2[0] - pos1[0];
     pos1[1] = pos2[1] - pos1[1];
     double sep = sqrt(pos1[0] * pos1[0] + pos1[1] * pos1[1]);
     if(sep < 1E-6) return;
     Vector2_t ptDir;
     ptDir[0] = pos1[0] / sep;
     ptDir[1] = pos1[1] / sep;
     SetMag(dir1, 1.0);
     double costh = DotProd(dir1, ptDir);
     if(costh > 1.0 || costh < -1.0) return;
     alongTrans[0] = costh * sep;
     double sinth = sqrt(1 - costh * costh);
     alongTrans[1] = sinth * sep;
   } // FindAlongTrans

void tca::FindAlongTrans	(	Point3_t	pos1,
		Vector3_t	dir1,
		Point3_t	pos2,
		Point2_t &	alongTrans
	)

Definition at line 2751 of file PFPUtils.cxx.

References DotProd(), E, PointDirection(), PosSep(), and SetMag().

Referenced by DotProd(), FindCompleteness(), FindParent(), FollowTp3s(), InShowerProb(), MergeSubShowers(), ParentFOM(), and tca::TruthMatcher::StudyShowerParents().

   {
     // Calculate the distance along and transvers to the direction vector from pos1 to pos2
     alongTrans[0] = 0; 
     alongTrans[1] = 0;
     if(pos1[0] == pos2[0] && pos1[1] == pos2[1] && pos1[2] == pos2[2]) return;
     auto ptDir = PointDirection(pos1, pos2);
     SetMag(dir1, 1.0);
     double costh = DotProd(dir1, ptDir);
     if(costh > 1) return;
     double sep = PosSep(pos1, pos2);
     if(sep < 1E-6) return;
     alongTrans[0] = costh * sep;
     double sinth = sqrt(1 - costh * costh);
     alongTrans[1] = sinth * sep;
   } // FindAlongTrans

std::vector< unsigned int > tca::FindCloseHits	(	TjStuff const &	tjs,
		std::array< int, 2 > const &	wireWindow,
		Point2_t const &	timeWindow,
		const unsigned short	plane,
		HitStatus_t	hitRequest,
		bool	usePeakTime,
		bool &	hitsNear
	)

Definition at line 2362 of file Utils.cxx.

References tca::TjStuff::fHits, tca::TjStuff::FirstWire, kAllHits, kUnusedHits, kUsedHits, tca::TjStuff::LastWire, tca::TjStuff::UnitsPerTick, and tca::TjStuff::WireHitRange.

Referenced by tca::TrajClusterAlg::AddLAHits(), tca::TrajClusterAlg::ChkStopEndPts(), Find3DVertices(), tca::TrajClusterAlg::FindVtxTraj(), tca::TrajClusterAlg::FixTrajBegin(), and tca::TrajClusterAlg::ReversePropagate().

   {
     // returns a vector of hits that are within the Window[Pos0][Pos1] in plane.
     // Note that hits on wire wireWindow[1] are returned as well. The definition of close
     // depends on setting of usePeakTime. If UsePeakTime is true, a hit is considered nearby if
     // the PeakTime is within the window. This is shown schematically here where
     // the time is on the horizontal axis and a "-" denotes a valid entry
     // timeWindow     -----------------
     // hit PeakTime             +         close
     // hit PeakTime  +                    not close
     // If usePeakTime is false, a hit is considered nearby if the hit StartTick and EndTick overlap with the timeWindow
     // Time window                  ---------
     // Hit StartTick-EndTick      --------        close
     // Hit StartTick - EndTick                  --------  not close
     
     hitsNear = false;
     std::vector<unsigned int> closeHits;
     if(plane > tjs.FirstWire.size() - 1) return closeHits;
     // window in the wire coordinate
     int loWire = wireWindow[0];
     if(loWire < (int)tjs.FirstWire[plane]) loWire = tjs.FirstWire[plane];
     int hiWire = wireWindow[1];
     if(hiWire > (int)tjs.LastWire[plane]-1) hiWire = tjs.LastWire[plane]-1;
     // window in the time coordinate
     float minTick = timeWindow[0] / tjs.UnitsPerTick;
     float maxTick = timeWindow[1] / tjs.UnitsPerTick;
     for(int wire = loWire; wire <= hiWire; ++wire) {
       // Set hitsNear if the wire is dead
       if(tjs.WireHitRange[plane][wire].first == -2) hitsNear = true;
       if(tjs.WireHitRange[plane][wire].first < 0) continue;
       unsigned int firstHit = (unsigned int)tjs.WireHitRange[plane][wire].first;
       unsigned int lastHit = (unsigned int)tjs.WireHitRange[plane][wire].second;
       for(unsigned int iht = firstHit; iht < lastHit; ++iht) {
         if(tjs.fHits[iht].InTraj == INT_MAX) continue;
         if(usePeakTime) {
           if(tjs.fHits[iht].PeakTime < minTick) continue;
           if(tjs.fHits[iht].PeakTime > maxTick) break;
         } else {
           int hiLo = minTick;
           if(tjs.fHits[iht].StartTick > hiLo) hiLo = tjs.fHits[iht].StartTick;
           int loHi = maxTick;
           if(tjs.fHits[iht].EndTick < loHi) loHi = tjs.fHits[iht].EndTick;
           if(loHi < hiLo) continue;
           if(hiLo > loHi) break;
         }
         hitsNear = true;
         bool takeit = (hitRequest == kAllHits);
         if(hitRequest == kUsedHits && tjs.fHits[iht].InTraj > 0) takeit = true;
         if(hitRequest == kUnusedHits && tjs.fHits[iht].InTraj == 0) takeit = true;
         if(takeit) closeHits.push_back(iht);
       } // iht
     } // wire
     return closeHits;
   } // FindCloseHits

bool tca::FindCloseHits	(	TjStuff const &	tjs,
		TrajPoint &	tp,
		float const &	maxDelta,
		HitStatus_t	hitRequest
	)

Definition at line 2418 of file Utils.cxx.

References tca::TrajPoint::CTP, DecodeCTP(), tca::TjStuff::fHits, tca::TjStuff::FirstWire, tca::TrajPoint::Hits, kAllHits, kUnusedHits, kUsedHits, tca::TjStuff::LastWire, geo::PlaneID::Plane, PointTrajDOCA(), tca::TrajPoint::Pos, tca::TjStuff::UnitsPerTick, tca::TrajPoint::UseHit, tca::TjStuff::WireHitRange, and WireHitRangeOK().

Referenced by ChgFracNearPos().

   {
     // Fills tp.Hits sets tp.UseHit true for hits that are close to tp.Pos. Returns true if there are
     // close hits OR if the wire at this position is dead
     
     tp.Hits.clear();
     tp.UseHit.reset();
     if(!WireHitRangeOK(tjs, tp.CTP)) {
 //      std::cout<<"FindCloseHits: WireHitRange not valid for CTP "<<tp.CTP<<". tjs.WireHitRange Cstat "<<tjs.TPCID.Cryostat<<" TPC "<<tjs.TPCID.TPC<<"\n";
       return false;
     }
     
     geo::PlaneID planeID = DecodeCTP(tp.CTP);
     unsigned short ipl = planeID.Plane;
     if(tp.Pos[0] < -0.4) return false;
     unsigned int wire = std::nearbyint(tp.Pos[0]);
     if(wire < tjs.FirstWire[ipl]) return false;
     if(wire > tjs.LastWire[ipl]-1) return false;
     
     // dead wire
     if(tjs.WireHitRange[ipl][wire].first == -1) return true;
     // live wire with no hits
     if(tjs.WireHitRange[ipl][wire].first == -2) return false;
     
     unsigned int firstHit = (unsigned int)tjs.WireHitRange[ipl][wire].first;
     unsigned int lastHit = (unsigned int)tjs.WireHitRange[ipl][wire].second;
 
     float fwire = wire;
     for(unsigned int iht = firstHit; iht < lastHit; ++iht) {
       if(tjs.fHits[iht].InTraj == INT_MAX) continue;
       bool useit = (hitRequest == kAllHits);
       if(hitRequest == kUsedHits && tjs.fHits[iht].InTraj > 0) useit = true;
       if(hitRequest == kUnusedHits && tjs.fHits[iht].InTraj == 0) useit = true;
       if(!useit) continue;
       float ftime = tjs.UnitsPerTick * tjs.fHits[iht].PeakTime;
       float delta = PointTrajDOCA(tjs, fwire, ftime, tp);
       if(delta < maxDelta) tp.Hits.push_back(iht);
     } // iht
     if(tp.Hits.size() > 16) {
       tp.Hits.resize(16);
     }
     // Set UseHit false. The calling routine should decide if these hits should be used
     tp.UseHit.reset();
     return true;
     
   } // FindCloseHits

std::vector< int > tca::FindCloseTjs	(	const TjStuff &	tjs,
		const TrajPoint &	fromTp,
		const TrajPoint &	toTp,
		const float &	maxDelta
	)

Definition at line 2466 of file Utils.cxx.

References tca::TjStuff::allTraj, tca::TrajPoint::CTP, DecodeCTP(), tca::TjStuff::fHits, tca::TjStuff::FirstWire, tca::TjStuff::LastWire, MakeBareTrajPoint(), MoveTPToWire(), geo::PlaneID::Plane, tca::TrajPoint::Pos, tmp, tca::TjStuff::UnitsPerTick, and tca::TjStuff::WireHitRange.

Referenced by MakeJunkVertices().

   {
     // Returns a list of Tj IDs that have hits within distance maxDelta on a line drawn between the two Tps as shown
     // graphically here, where a "*" is a Tp and "|" and "-" are the boundaries of the region that is checked 
     //
     //    ---------------
     //    |             |
     //    *             *
     //    |             |
     //    ---------------
     // If the wire positions of fromTp and toTp are the same, a different region is checked as shown here
     //
     //     -----------
     //     |         |
     //     |    *    |
     //     |         |
     //     -----------
     
     std::vector<int> tmp;
     if(fromTp.Pos[0] < -0.4 || toTp.Pos[0] < -0.4) return tmp;
     
     TrajPoint tp;
     // Make the tp so that stepping is positive
     unsigned int firstWire, lastWire;
     if(toTp.Pos[0] > fromTp.Pos[0]) {
       if(!MakeBareTrajPoint(tjs, fromTp, toTp, tp)) return tmp;
       firstWire = std::nearbyint(fromTp.Pos[0]);
       lastWire = std::nearbyint(toTp.Pos[0]);
     } else if(toTp.Pos[0] < fromTp.Pos[0]) {
       if(!MakeBareTrajPoint(tjs, toTp, fromTp, tp)) return tmp;
       firstWire = std::nearbyint(toTp.Pos[0]);
       lastWire = std::nearbyint(fromTp.Pos[0]);
     } else {
       tp.Pos = fromTp.Pos;
       float tmp = fromTp.Pos[0] - maxDelta;
       if(tmp < 0) tmp = 0;
       firstWire = std::nearbyint(tmp);
       tmp = fromTp.Pos[0] + maxDelta;
       lastWire = std::nearbyint(tmp);
     }
     
     geo::PlaneID planeID = DecodeCTP(tp.CTP);
     unsigned short ipl = planeID.Plane;
     
     if(firstWire < tjs.FirstWire[ipl]) firstWire = tjs.FirstWire[ipl];
     if(firstWire > tjs.LastWire[ipl]-1) return tmp;
     if(lastWire < tjs.FirstWire[ipl]) return tmp;
     if(lastWire > tjs.LastWire[ipl]-1) lastWire = tjs.LastWire[ipl]-1;
     
     for(unsigned int wire = firstWire; wire <= lastWire; ++wire) {
       if(tjs.WireHitRange[ipl][wire].first == -1) continue;
       if(tjs.WireHitRange[ipl][wire].first == -2) continue;
       MoveTPToWire(tp, (float)wire);
       // Find the tick range at this position
       float minTick = (tp.Pos[1] - maxDelta) / tjs.UnitsPerTick;
       float maxTick = (tp.Pos[1] + maxDelta) / tjs.UnitsPerTick;
       unsigned int firstHit = (unsigned int)tjs.WireHitRange[ipl][wire].first;
       unsigned int lastHit = (unsigned int)tjs.WireHitRange[ipl][wire].second;
       for(unsigned int iht = firstHit; iht < lastHit; ++iht) {
         if(tjs.fHits[iht].InTraj <= 0) continue;
         if((unsigned int)tjs.fHits[iht].InTraj > tjs.allTraj.size()) continue;
         if(tjs.fHits[iht].PeakTime < minTick) continue;
         // Hits are sorted by increasing time so we can break when maxTick is reached
         if(tjs.fHits[iht].PeakTime > maxTick) break;
         if(std::find(tmp.begin(), tmp.end(), tjs.fHits[iht].InTraj) != tmp.end()) continue;
         tmp.push_back(tjs.fHits[iht].InTraj);
       } // iht
     } // wire
     
     return tmp;
     
   } // FindCloseTjs

void tca::FindCompleteness	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		bool	doFit,
		bool	fillTp3s,
		bool	prt
	)

Definition at line 593 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, tca::TrajPoint3::AlongTrans, geo::CryostatID::Cryostat, DecodeCTP(), dir, tca::TrajPoint3::Dir, tca::PFPStruct::Dir, tca::PFPStruct::EffPur, trkf::fill(), FindAlongTrans(), Fit3D(), tca::TjStuff::geom, tca::PFPStruct::ID, MakeTp3(), tca::TjStuff::mallTraj, tca::TjStuff::Match3DCuts, tca::TjStuff::NumPlanes, geo::PlaneID::Plane, tca::TrajPoint3::Pos, tca::TrajPoint3::Tj2Pts, tca::PFPStruct::TjCompleteness, tca::PFPStruct::TjIDs, tmp, tca::PFPStruct::Tp3s, geo::TPCID::TPC, geo::GeometryCore::WireCoordinate(), tca::TjStuff::WireHitRange, and tca::PFPStruct::XYZ.

Referenced by DefinePFP(), and FindPFParticles().

   {
     // Calculate the 3D-matching completeness of the set of Tjs in pfp.TjIDs and store in pfp.EffPur.
     // The completeness for each Tj is put in pfp.TjCompleteness. The TP-weighted average completeness
     // is put in pfp.EffPur. This function also fits the matching points to a 3D line and puts the
     // position and direction in pfp.XYZ[0] and pfp.Dir[0]. The absolute value of the linear correlation
     // coefficients are averaged and stored in pfp.AspecRatio. The pfp.TP3s vector is optionally filled.
     
     if(pfp.TjIDs.size() < 2) return;
     if(tjs.Match3DCuts[0] <= 0) return;
     // This function uses mallTraj but it isn't necessarily a failure if it doesn't exist
     if(tjs.mallTraj.size() < 6) return;
 
     pfp.TjCompleteness.resize(pfp.TjIDs.size());
     std::fill(pfp.TjCompleteness.begin(), pfp.TjCompleteness.end(), 0);
     if(fillTp3s) pfp.Tp3s.clear();
 
     bool twoPlanes = (tjs.NumPlanes == 2);
     bool twoTjs = (pfp.TjIDs.size() == 2);
     // decide if special handling of small angle pfps is required when filling Tp3s
     bool smallAngle = false;
     if(fillTp3s) {
       smallAngle = (pfp.Dir[0][0] != 0 && std::abs(pfp.Dir[0][0]) < 0.1);
 //      if(pfp.Dir[0][0] == 0 && tjs.DebugMode) std::cout<<"P"<<pfp.ID<<" Dir[0] isn't defined\n";
     }
     double yzcut = 1.5 * tjs.Match3DCuts[0];
     
     // initialize the fit sums
     Point3_t point;
     Vector3_t dir;
     if(doFit) Fit3D(0, point, dir, point, dir);
     
     // create a vector of bools for each tj for points that are matched in 3D 
     // cast the IDs into an unsigned short for faster comparing
     std::vector<unsigned short> tjids(pfp.TjIDs.size());
     // This vector is for matches in 3 planes
     std::vector<std::vector<bool>> tjptMat3;
     // This vector is for matches in 2 planes
     std::vector<std::vector<bool>> tjptMat2;
     // and the plane index
     std::vector<unsigned short> tjplane;
     // Set a maximum size for the TP3s vector
     unsigned int maxTp3Size = 10000;
     // Initialize the vectors
     for(unsigned short itj = 0; itj < pfp.TjIDs.size(); ++itj) {
       if(pfp.TjIDs[itj] <= 0) {
         std::cout<<"FindCompleteness: Bad tjid "<<pfp.TjIDs[itj]<<"\n";
         return;
       }
       tjids[itj] = pfp.TjIDs[itj];
       auto& tj = tjs.allTraj[pfp.TjIDs[itj] - 1];
       std::vector<bool> tmp(tj.Pts.size(), false);
       tjptMat2.push_back(tmp);
       if(!twoPlanes) tjptMat3.push_back(tmp);
       tjplane.push_back(DecodeCTP(tj.CTP).Plane);
     } // tjid
     
     for(unsigned int ipt = 0; ipt < tjs.mallTraj.size() - 1; ++ipt) {
       auto& iTjPt = tjs.mallTraj[ipt];
       unsigned short indx = 0;
       for(indx = 0; indx < tjids.size(); ++indx) if(iTjPt.id == tjids[indx]) break;
       // require that the Tj ID of this point be in the list
       if(indx == tjids.size()) continue;
       auto& itj = tjs.allTraj[iTjPt.id - 1];
 //      if(itj.AlgMod[kMat3D]) continue;
       auto& itp = itj.Pts[iTjPt.ipt];
       unsigned short iplane = DecodeCTP(itp.CTP).Plane;
       unsigned short tpc = DecodeCTP(itp.CTP).TPC;
       unsigned short cstat = DecodeCTP(itp.CTP).Cryostat;
       for(unsigned int jpt = ipt + 1; jpt < tjs.mallTraj.size() - 1; ++jpt) {
         auto& jTjPt = tjs.mallTraj[jpt];
         // ensure that the planes are different
         if(jTjPt.ctp == iTjPt.ctp) continue;
         unsigned short jndx = 0;
         for(jndx = 0; jndx < tjids.size(); ++jndx) if(jTjPt.id == tjids[jndx]) break;
         // require that the Tj ID of this point be in the list
         if(jndx == tjids.size()) continue;
         // check for x range overlap. We know that jTjPt.xlo is > iTjPt.xlo because of the sort
         if(jTjPt.xlo > iTjPt.xhi) continue;
         // break out if the x range difference becomes large (5 cm)
         if(jTjPt.xlo > iTjPt.xhi + 5) break;
         auto& jtj = tjs.allTraj[jTjPt.id - 1];
 //        if(jtj.AlgMod[kMat3D]) continue;
         auto& jtp = jtj.Pts[jTjPt.ipt];
         TrajPoint3 ijtp3;
         if(!MakeTp3(tjs, itp, jtp, ijtp3, true)) continue;
         ijtp3.Tj2Pts.resize(2);
         ijtp3.Tj2Pts[0] = iTjPt;
         ijtp3.Tj2Pts[1] = jTjPt;
         // Set the 2-plane match bits
         tjptMat2[indx][iTjPt.ipt] = true;
         tjptMat2[jndx][jTjPt.ipt] = true;
         if(twoPlanes) {
           if(fillTp3s && pfp.Tp3s.size() < maxTp3Size) {
             bool saveIt = true;
             FindAlongTrans(pfp.XYZ[0], pfp.Dir[0], ijtp3.Pos, ijtp3.AlongTrans);
             // cut on transverse distance
             if(smallAngle) saveIt = ijtp3.AlongTrans[1] < 1;
             if(saveIt) pfp.Tp3s.push_back(ijtp3);
           }
           if(doFit) Fit3D(1, ijtp3.Pos, ijtp3.Dir, point, dir);
           continue;
         }
         // count it as a triple if this point is in a dead region
         unsigned short jplane = DecodeCTP(jtp.CTP).Plane;
         unsigned short kplane = 3 - iplane - jplane;
         float fwire = tjs.geom->WireCoordinate(ijtp3.Pos[1], ijtp3.Pos[2], kplane, tpc, cstat);
         if(fwire < -0.4) continue;
         unsigned int kwire = std::nearbyint(fwire);
         if(kwire < tjs.WireHitRange[kplane].size() && tjs.WireHitRange[kplane][kwire].first == -1) {
           // accumulate the fit sums
           if(doFit) Fit3D(1, ijtp3.Pos, ijtp3.Dir, point, dir);
           // fill Tp3s?
           if(fillTp3s && pfp.Tp3s.size() < maxTp3Size) {
             bool saveIt = true;
             FindAlongTrans(pfp.XYZ[0], pfp.Dir[0], ijtp3.Pos, ijtp3.AlongTrans);
             if(smallAngle) saveIt = ijtp3.AlongTrans[1] < 1;
             if(saveIt) pfp.Tp3s.push_back(ijtp3);
           }
           continue;
         } // dead wire in kplane
         for(unsigned int kpt = jpt + 1; kpt < tjs.mallTraj.size(); ++kpt) {
           auto& kTjPt = tjs.mallTraj[kpt];
           // ensure that the planes are different
           if(kTjPt.ctp == iTjPt.ctp || kTjPt.ctp == jTjPt.ctp) continue;
           // Look for this tj point in tjids
           unsigned short kndx = 0;
           for(kndx = 0; kndx < tjids.size(); ++kndx) if(kTjPt.id == tjids[kndx]) break;
           // require that the Tj ID of this point be in the list if we aren't filling the Tp3s
           if(!fillTp3s && kndx == tjids.size()) continue;
           if(kTjPt.xlo > iTjPt.xhi) continue;
           // break out if the x range difference becomes large
           if(kTjPt.xlo > iTjPt.xhi + 5) break;
           auto& ktj = tjs.allTraj[kTjPt.id - 1];
 //          if(ktj.AlgMod[kMat3D]) continue;
           auto& ktp = ktj.Pts[kTjPt.ipt];
           TrajPoint3 iktp3;
           if(!MakeTp3(tjs, itp, ktp, iktp3, true)) continue;
           if(std::abs(ijtp3.Pos[1] - iktp3.Pos[1]) > yzcut) continue;
           if(std::abs(ijtp3.Pos[2] - iktp3.Pos[2]) > yzcut) continue;
           // make a copy of ijtp3 -> ijktp3
           auto ijktp3 = ijtp3;
           // add the Tj2Pt to it
           ijktp3.Tj2Pts.push_back(kTjPt);
           // accumulate the fit sums
           if(doFit) Fit3D(1, iktp3.Pos, iktp3.Dir, point, dir);
           // fill Tp3s?
           if(fillTp3s && pfp.Tp3s.size() < maxTp3Size) {
             // update the charge
             ijktp3.dEdx = (2 * ijktp3.dEdx + ktp.Chg) / 3;
             bool saveIt = true;
             FindAlongTrans(pfp.XYZ[0], pfp.Dir[0], ijktp3.Pos, ijktp3.AlongTrans);
             if(smallAngle) saveIt = ijktp3.AlongTrans[1] < 1;
             if(saveIt) pfp.Tp3s.push_back(ijktp3);
           }
           // Set the 3-plane match bits
           if(kndx == tjids.size()) continue;
           tjptMat3[indx][iTjPt.ipt] = true;
           tjptMat3[jndx][jTjPt.ipt] = true;
           tjptMat3[kndx][kTjPt.ipt] = true;
         } // kpt
       } // jpt
     } // ipt
     // do the fit and put the results into the pfp
     Fit3D(2, point, dir, pfp.XYZ[0], pfp.Dir[0]);
     if(prt && doFit) {
       mf::LogVerbatim myprt("TC");
       myprt<<"FC: P"<<pfp.ID<<" fit pos "<<std::fixed<<std::setprecision(1)<<pfp.XYZ[0][0]<<" "<<pfp.XYZ[0][1]<<" "<<pfp.XYZ[0][2];
       myprt<<" fit dir "<<std::setprecision(2)<<pfp.Dir[0][0]<<" "<<pfp.Dir[0][1]<<" "<<pfp.Dir[0][2];
       myprt<<" Note: fit pos is the average position of all Tp3s - not the start or end.";
     }
     // now count the number of tj points were matched
     // total number of points with charge in all Tjs
     float tnpwc = 0;
     // total number that are matched in 3D in 3 planes
     float tcnt3 = 0;
     // total number that are matched in 3D in 2 planes
     float tcnt2 = 0;
     for(unsigned short itj = 0; itj < tjids.size(); ++itj) {
       auto& tj = tjs.allTraj[tjids[itj] - 1];
       // counts for each tj
       float npwc = 0;
       float cnt2 = 0;
       float cnt3 = 0;
       for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
         if(tj.Pts[ipt].Chg <= 0) continue;
         ++npwc;
         if(tjptMat2[itj][ipt]) ++cnt2;
         if(!twoPlanes && tjptMat3[itj][ipt]) ++cnt3;
       } // ipt
       if(twoTjs) {
         pfp.TjCompleteness[itj] = cnt2 / npwc;
       } else {
         pfp.TjCompleteness[itj] = cnt3 / npwc;
       }
       tnpwc += npwc;
       tcnt3 += cnt3;
       tcnt2 += cnt2;
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<"FC: P"<<pfp.ID<<" T"<<tj.ID<<" npwc "<<npwc<<" cnt2 "<<cnt2<<" cnt3 "<<cnt3<<" PDGCode "<<tj.PDGCode;
         myprt<<" MCSMom "<<tj.MCSMom<<" InShower? "<<tj.SSID;
         myprt<<" TjCompleteness "<<std::setprecision(2)<<pfp.TjCompleteness[itj];
       } // prt
     } // itj
     if(twoTjs) {
       pfp.EffPur = tcnt2 / tnpwc;
     } else {
       pfp.EffPur = tcnt3 / tnpwc;
     }
 
   } // FindCompleteness

void tca::FindCots	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		const CTP_t &	inCTP,
		std::vector< std::vector< int >> &	tjLists,
		bool	prt
	)

Definition at line 3485 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::ChargeCuts, DontCluster(), GetAssns(), greaterThan(), tca::Trajectory::ID, kKilled, kMat3D, kShowerLike, kShowerTj, tca::Trajectory::MCSMom, MCSMom(), NumPtsWithCharge(), PFPDOCA(), tca::TjStuff::pfps, PosSep(), SetIntersection(), ShowerEnergy(), tca::TjStuff::ShowerTag, t1, t2, tmp, TrajTrajDOCA(), and tca::TjStuff::WirePitch.

Referenced by FindShowers3D().

   {
     // Version 2 of TagShowerLike to try to improve the separation between close showers, e.g. from pi-zeros
     tjLists.clear();    
     if(tjs.ShowerTag[0] <= 0) return;
 
     // take the average of the low and high charge RMS range to use as a cut
     float typicalChgRMS = 0.5 * (tjs.ChargeCuts[1] + tjs.ChargeCuts[2]);
 
     // clear out old tags and make a list of Tjs to consider
     std::vector<int> tjids;
     for(auto& tj : tjs.allTraj) {
       if(tj.CTP != inCTP) continue;
       if(tj.AlgMod[kKilled]) continue;
       tj.AlgMod[kShowerLike] = false;
       if(tj.AlgMod[kShowerTj]) continue;
       short npwc = NumPtsWithCharge(tjs, tj, false);
       // Don't expect any (primary) electron to be reconstructed as a single trajectory for
       // more than ~2 radiation lengths ~ 30 cm for uB ~ 100 wires 
       if(npwc > 100) continue;
       // check MCSMom for longish Tjs
       if(npwc > 5) {
         // Increase the MCSMom cut if the Tj is long and the charge RMS is high to reduce sensitivity 
         // to the fcl configuration. A primary electron may be reconstructed as one long Tj with large
         // charge rms and possibly high MCSMom or as several nearby shorter Tjs with lower charge rms
         float momCut = tjs.ShowerTag[1];
         if(tj.ChgRMS > typicalChgRMS) momCut *= tj.ChgRMS / typicalChgRMS;
         if(tj.MCSMom > momCut) continue;
       }
       // see if this tj is in a muon pfparticle that looks shower-like in this view
       if(tj.AlgMod[kMat3D]) {
         auto TInP = GetAssns(tjs, "T", tj.ID, "P");
         if(!TInP.empty()) {
           auto& pfp = tjs.pfps[TInP[0] - 1];
           if(pfp.PDGCode == 13 && MCSMom(tjs, pfp.TjIDs) > 500) continue;
         } // TInP not empty
       } // 3D-matched
       tjids.push_back(tj.ID);
     } // tj
     
     if(tjids.size() < 2) return;
     
     struct ClosePair {
       float doca;               // distance of closest approach between the tj pair
       int id1;       // id of the first tj
       int id2;       // id of the second tj
       unsigned short closePt1;  // index of the closest point on tj1
       unsigned short closePt2;  // index of the closest point on tj2
       bool used;                // set true when this pair is used
     };
     // min separation between tjs
     std::vector<ClosePair> cps;    
     // list of tjs that are close
     std::vector<int> closeTjs;
     for(unsigned short it1 = 0; it1 < tjids.size() - 1; ++it1) {
       Trajectory& t1 = tjs.allTraj[tjids[it1] - 1];
       bool t1TrackLike = (t1.MCSMom > tjs.ShowerTag[1]);
       auto T1InP = GetAssns(tjs, "T", t1.ID, "P");
       for(unsigned short it2 = it1 + 1; it2 < tjids.size(); ++it2) {
         Trajectory& t2 = tjs.allTraj[tjids[it2] - 1];
         // require one of them to be not tracklike
         bool t2TrackLike = (t2.MCSMom > tjs.ShowerTag[1]);
         if(t1TrackLike && t2TrackLike) continue;
         unsigned short ipt1, ipt2;
         float doca = tjs.ShowerTag[2];
         // Find the separation between Tjs without considering dead wires
         TrajTrajDOCA(tjs, t1, t2, ipt1, ipt2, doca, false);
         if(doca == tjs.ShowerTag[2]) continue;
         // see if they are close in 3D if that information exists
         if(!T1InP.empty()) {
           auto T2InP = GetAssns(tjs, "T", t2.ID, "P");
           if(!T2InP.empty()) {
             auto& p1 = tjs.pfps[T1InP[0] - 1];
             auto& p2 = tjs.pfps[T2InP[0] - 1];
             unsigned short closePt1, closePt2;
             float doca = PFPDOCA(p1, p2, closePt1, closePt2);
 //            float costh = DotProd(p1.Dir[0], p2.Dir[0]);
 //            std::cout<<"chk T"<<t1.ID<<" T"<<t2.ID<<" doca "<<doca<<" costh "<<costh<<"\n";
             if(doca > tjs.ShowerTag[2] * tjs.WirePitch) continue;
           } // !T2InP.empty()
         } // !T1InP.empty()
 
         // add a new one
         ClosePair cp;
         cp.doca = doca;
         cp.id1 = t1.ID;
         cp.closePt1 = ipt1;
         cp.id2 = t2.ID;
         cp.closePt2 = ipt2;
         cp.used = false;
         cps.push_back(cp);
         if(std::find(closeTjs.begin(), closeTjs.end(), t1.ID) == closeTjs.end()) closeTjs.push_back(t1.ID);
         if(std::find(closeTjs.begin(), closeTjs.end(), t2.ID) == closeTjs.end()) closeTjs.push_back(t2.ID);
       } // it2 (t2)
     } // it1 (t1)
     
     if(cps.empty()) return;
 
     // sort tjList by decreasing length
     std::vector<SortEntry> sortVec(closeTjs.size());
     for(unsigned short ii = 0; ii < closeTjs.size(); ++ii) {
       sortVec[ii].index = ii;
       auto& tj = tjs.allTraj[closeTjs[ii] - 1];
       sortVec[ii].length = PosSep(tj.Pts[tj.EndPt[0]].Pos, tj.Pts[tj.EndPt[1]].Pos);
     } // ii
     std::sort(sortVec.begin(), sortVec.end(), greaterThan);
 
 
     // cluster them starting with the longest
     // a temp vector for DontCluster
     std::vector<int> tmp(1);
     for(unsigned short ii = 0; ii < sortVec.size(); ++ii) {
       unsigned short indx = sortVec[ii].index;
       auto& t1 = tjs.allTraj[closeTjs[indx] - 1];
       // already tagged?
       if(t1.AlgMod[kShowerLike]) continue;
 //      float t1Len = sortVec[ii].length;
       // get the general direction
 //      auto t1Dir = PointDirection(t1.Pts[t1.EndPt[0]].Pos, t1.Pts[t1.EndPt[1]].Pos);
       // start a list of clustered tjs
       std::vector<int> tlist;
       tlist.push_back(t1.ID);
       // try to add other close tjs
       bool added = true;
       while(added) {
         added = false;
         for(auto& cp : cps) {
           if(cp.used) continue;
           // is any ID in tlist equal to cp.id1 or cp.id2?
           bool isID1 = (std::find(tlist.begin(), tlist.end(), cp.id1) != tlist.end());
           bool isID2 = (std::find(tlist.begin(), tlist.end(), cp.id2) != tlist.end());
           if(!(isID1 || isID2)) continue;
           // determine which one is not in tlist and call it t2
           unsigned short t2id = cp.id1;
           if(isID1) t2id = cp.id2;
           auto& t2 = tjs.allTraj[t2id - 1];
           // already tagged?
           if(t2.AlgMod[kShowerLike]) continue;
           tmp[0] = t2.ID;
           if(DontCluster(tjs, tmp, tlist)) continue;
           // don't cluster if this tj is closer to another long tj
           bool isCloser = false;
           for(auto& pcp : cps) {
             if(t1.ID == pcp.id1 || t1.ID == pcp.id2) continue;
             if(!(t2.ID == pcp.id1 || t2.ID == pcp.id2)) continue;
             unsigned short oid = pcp.id1;
             if(oid == t2.ID) oid = pcp.id2;
             auto otj = tjs.allTraj[oid - 1];
             float otjLen = PosSep(otj.Pts[otj.EndPt[0]].Pos, otj.Pts[otj.EndPt[1]].Pos);
 //            std::cout<<"tid1 T"<<t1.ID<<" tid2 T"<<t2.ID<<" oid T"<<oid<<"\n";
             if(pcp.doca < cp.doca && otjLen > 10) isCloser = true;
           } // pcp
           if(isCloser) continue;
           if(std::find(tlist.begin(), tlist.end(), t2.ID) != tlist.end()) continue;
 //          std::cout<<"  add T"<<t2.ID<<" to "<<tjLists.size()<<"\n";
           tlist.push_back(t2.ID);
           // call it used
           cp.used = true;
           added = true;
         } // cp
       } // added
       if(tlist.size() > 1) {
         // tag them
         for(auto tjid : tlist) {
           auto& tj = tjs.allTraj[tjid - 1];
           tj.AlgMod[kShowerLike] = true;
         } // tjid
         // ignore wimpy cots (< 10 MeV)
         if(ShowerEnergy(tjs, tlist) < 10) continue;
         tjLists.push_back(tlist);
       } // tlist.size() > 1
     } // ii
 /* This causes  problems later on
     // Check for leftover tjs and add them if they are shower-like
     for(auto tjid : closeTjs) {
       auto& tj = tjs.allTraj[tjid - 1];
       if(tj.AlgMod[kShowerLike]) continue;
       std::vector<int> tlist(1, tjid);
       tj.AlgMod[kShowerLike] = true;
       // ignore wimpy cots (< 10 MeV)
       if(ShowerEnergy(tjs, tlist) < 10) continue;
       tjLists.push_back(tlist);
     } // tjid
 */
     if(tjLists.size() < 2) return;
     // check consistency
     for(unsigned short ip = 0; ip < tjLists.size() - 1; ++ip) {
       auto& ilist = tjLists[ip];
       for(unsigned short jp = ip + 1; jp < tjLists.size(); ++jp) {
         auto& jlist = tjLists[jp];
         auto sij = SetIntersection(ilist, jlist);
         if(!sij.empty()) {
           std::cout<<"******** FindCots conflict:";
           for(auto tid : sij) std::cout<<" T"<<tid;
           std::cout<<" appears in multiple lists\n";
         }
       } // jp
     } // ip
 /*
     std::cout<<"FindCots inCTP "<<inCTP<<" tjLists size "<<tjLists.size()<<"\n";
     for(unsigned short ip = 0; ip < tjLists.size(); ++ip) {
       auto& tlist = tjLists[ip];
       std::cout<<"ip "<<ip;
       for(auto tid : tlist) {
         std::cout<<" T"<<tid;
         auto plist = GetAssns(tjs, "T", tid, "P");
         if(!plist.empty()) std::cout<<"_P"<<plist[0];
       }
       std::cout<<"\n";
     } // ip
 */
 
   } // FindCots

void tca::FindHammerVertices	(	TjStuff &	tjs,
		const CTP_t &	inCTP
	)

Definition at line 995 of file TCVertex.cxx.

References tca::TjStuff::allTraj, AttachAnyTrajToVertex(), tca::VtxStore::ChiDOF, tca::VtxStore::CTP, debug, DeltaAngle(), tca::VtxStore::ID, kHamVx, kJunkTj, kKilled, kShowerLike, tca::VtxStore::NTraj, tca::VtxStore::Pass, tca::DebugStuff::Plane, tca::VtxStore::Pos, SetPDGCode(), SetVx2Score(), SplitTraj(), StoreVertex(), tca::DebugStuff::Tick, tca::VtxStore::Topo, TrajPointTrajDOCA(), tca::TjStuff::UseAlg, and tca::TjStuff::vtx.

Referenced by Find2DVertices().

   {
     // Look for a trajectory that intersects another. Split
     // the trajectory and make a vertex. The convention used
     // is shown pictorially here. Trajectory tj1 must be longer
     // than tj2
     // tj2       ------
     // tj1         /
     // tj1        /
     // tj1       /
     
     if(!tjs.UseAlg[kHamVx]) return;
     
     bool prt = (debug.Plane >= 0 && debug.Tick == 55555);
 
     for(unsigned short it1 = 0; it1 < tjs.allTraj.size(); ++it1) {
       if(tjs.allTraj[it1].CTP != inCTP) continue;
       if(tjs.allTraj[it1].AlgMod[kKilled]) continue;
       if(tjs.allTraj[it1].AlgMod[kShowerLike]) continue;
       if(tjs.allTraj[it1].AlgMod[kJunkTj]) continue;
       // minimum length requirements
       unsigned short tj1len = tjs.allTraj[it1].EndPt[1] - tjs.allTraj[it1].EndPt[0];
       if(tj1len < 6) continue;
       // Check each end of tj1
       bool didaSplit = false;
       for(unsigned short end1 = 0; end1 < 2; ++end1) {
         // vertex assignment exists?
         if(tjs.allTraj[it1].VtxID[end1] > 0) continue;
         unsigned short endPt1 = tjs.allTraj[it1].EndPt[end1];
         for(unsigned short it2 = 0; it2 < tjs.allTraj.size(); ++it2) {
           if(tjs.allTraj[it2].CTP != inCTP) continue;
           if(it1 == it2) continue;
           if(tjs.allTraj[it2].AlgMod[kKilled]) continue;
           if(tjs.allTraj[it2].AlgMod[kJunkTj]) continue;
           // length of tj2 cut
           unsigned short tj2len = tjs.allTraj[it2].EndPt[1] - tjs.allTraj[it2].EndPt[0];
           if(tj2len < 10) continue;
           // ignore if tj1 is a lot shorter than tj2
           if(tj1len < 0.5 * tj2len) continue;
           // ignore very long straight trajectories (probably a cosmic muon)
           unsigned short end20 = tjs.allTraj[it2].EndPt[0];
           unsigned short end21 = tjs.allTraj[it2].EndPt[1];
           if(tj2len > 100 && DeltaAngle(tjs.allTraj[it2].Pts[end20].Ang, tjs.allTraj[it2].Pts[end21].Ang) < 0.2) continue;
           // Require no vertex associated with itj2
           if(tjs.allTraj[it2].VtxID[0] > 0 || tjs.allTraj[it2].VtxID[1] > 0) continue;
           float minDOCA = 3;
           float doca = minDOCA;
           unsigned short closePt2 = 0;
           TrajPointTrajDOCA(tjs, tjs.allTraj[it1].Pts[endPt1], tjs.allTraj[it2], closePt2, doca);
           if(doca == minDOCA) continue;
           // ensure that the closest point is not near an end
           if(prt) mf::LogVerbatim("TC")<<"FindHammerVertices: Candidate "<<tjs.allTraj[it1].ID<<"  "<<tjs.allTraj[it2].ID<<" doca "<<doca<<" tj2.EndPt[0] "<<tjs.allTraj[it2].EndPt[0]<<" closePt2 "<<closePt2<<" tj2.EndPt[1] "<<tjs.allTraj[it2].EndPt[1];
           if(closePt2 < tjs.allTraj[it2].EndPt[0] + 3) continue;
           if(closePt2 > tjs.allTraj[it2].EndPt[1] - 3) continue;
           // make an angle cut
           float dang = DeltaAngle(tjs.allTraj[it1].Pts[endPt1].Ang, tjs.allTraj[it2].Pts[closePt2].Ang);
           if(prt) mf::LogVerbatim("TC")<<" dang "<<dang<<" imposing a hard cut of 0.4 for now ";
           if(dang < 0.4) continue;
           // we have a winner
           // create a new vertex
           VtxStore aVtx;
           aVtx.Pos = tjs.allTraj[it2].Pts[closePt2].Pos;
           aVtx.NTraj = 3;
           aVtx.Pass = tjs.allTraj[it2].Pass;
           aVtx.Topo = 5;
           aVtx.ChiDOF = 0;
           aVtx.CTP = inCTP;
           aVtx.ID = tjs.vtx.size() + 1;
           unsigned short ivx = tjs.vtx.size();
           if(!StoreVertex(tjs, aVtx)) continue;
           if(!SplitTraj(tjs, it2, closePt2, ivx, prt)) {
             if(prt) mf::LogVerbatim("TC")<<"FindHammerVertices: Failed to split trajectory";
             tjs.vtx.pop_back();
             continue;
           }
           tjs.allTraj[it1].VtxID[end1] = tjs.vtx[ivx].ID;
           tjs.allTraj[it1].AlgMod[kHamVx] = true;
           tjs.allTraj[it2].AlgMod[kHamVx] = true;
           unsigned short newTjIndex = tjs.allTraj.size() - 1;
           tjs.allTraj[newTjIndex].AlgMod[kHamVx] = true;
           AttachAnyTrajToVertex(tjs, ivx, prt);
           SetVx2Score(tjs, prt);
           // Update the PDGCode for the chopped trajectory
           SetPDGCode(tjs, it2);
           // and for the new trajectory
           SetPDGCode(tjs, newTjIndex);
           didaSplit = true;
           break;
         } // tj2
         if(didaSplit) break;
       } // end1
     } // tj1
     
   } // FindHammerVertices

void tca::FindHammerVertices2	(	TjStuff &	tjs,
		const CTP_t &	inCTP
	)

Definition at line 819 of file TCVertex.cxx.

References tca::TjStuff::allTraj, AttachAnyTrajToVertex(), tca::VtxStore::ChiDOF, tca::VtxStore::CTP, debug, DeltaAngle(), dir, tca::VtxStore::ID, kHamVx, kHamVx2, kJunkTj, kKilled, kShowerLike, MCSMom(), MoveTPToWire(), tca::VtxStore::NTraj, NumPtsWithCharge(), tca::VtxStore::Pass, tca::DebugStuff::Plane, PointTrajDOCA(), tca::VtxStore::Pos, PosSep(), PrintPos(), SetPDGCode(), SetVx2Score(), SignalAtTp(), SplitTraj(), StoreVertex(), tca::DebugStuff::Tick, tmp, tca::VtxStore::Topo, TrajClosestApproach(), TrajIntersection(), TrajPointTrajDOCA(), tca::TjStuff::UnitsPerTick, tca::TjStuff::UseAlg, and tca::TjStuff::vtx.

Referenced by Find2DVertices().

   {
     // Variant of FindHammerVertices with slightly different requirements:
     // 1) tj1 is a straight trajectory with most of the points fit
     // 2) No angle requirement between tj1 and tj2
     // 3) Large charge near the intersection point X on tj2
     // tj2       ---X---
     // tj1         /
     // tj1        /
     // tj1       /
     // minimum^2 DOCA of tj1 endpoint with tj2
     
     if(!tjs.UseAlg[kHamVx2]) return;
     
     bool prt = (debug.Plane >= 0 && debug.Tick == 66666);
     if(prt) mf::LogVerbatim("TC")<<"Inside FindHammerVertices2";
     
     for(unsigned short it1 = 0; it1 < tjs.allTraj.size(); ++it1) {
       if(tjs.allTraj[it1].CTP != inCTP) continue;
       if(tjs.allTraj[it1].AlgMod[kKilled]) continue;
       if(tjs.allTraj[it1].AlgMod[kHamVx]) continue;
       if(tjs.allTraj[it1].AlgMod[kHamVx2]) continue;
       if(tjs.allTraj[it1].AlgMod[kJunkTj]) continue;
       unsigned short numPtsWithCharge1 = NumPtsWithCharge(tjs, tjs.allTraj[it1], false);
       if(numPtsWithCharge1 < 6) continue;
       // Check each end of tj1
       bool didaSplit = false;
       for(unsigned short end1 = 0; end1 < 2; ++end1) {
         // vertex assignment exists?
         if(tjs.allTraj[it1].VtxID[end1] > 0) continue;
         unsigned short endPt1 = tjs.allTraj[it1].EndPt[end1];
         for(unsigned short it2 = 0; it2 < tjs.allTraj.size(); ++it2) {
           if(it1 == it2) continue;
           if(tjs.allTraj[it2].AlgMod[kKilled]) continue;
           if(tjs.allTraj[it2].AlgMod[kHamVx]) continue;
           if(tjs.allTraj[it2].AlgMod[kHamVx2]) continue;
           // require that both be in the same CTP
           if(tjs.allTraj[it2].CTP != inCTP) continue;
           if(tjs.allTraj[it2].AlgMod[kShowerLike]) continue;
           if(tjs.allTraj[it2].AlgMod[kJunkTj]) continue;
           unsigned short numPtsWithCharge2 = NumPtsWithCharge(tjs, tjs.allTraj[it2], true);
           if(numPtsWithCharge2 < 6) continue;
           // ignore if tj1 is a lot shorter than tj2
           // ignore if ChgRMS isn't known
           // Jan 22. Try this
 //          if(tjs.allTraj[it2].ChgRMS == 0) continue;
 //          if(numPtsWithCharge1 < 0.2 * numPtsWithCharge2) continue;
           // Find the minimum separation between tj1 and tj2
           float minDOCA = 5;
           float doca = minDOCA;
           unsigned short closePt2 = 0;
           TrajPointTrajDOCA(tjs, tjs.allTraj[it1].Pts[endPt1], tjs.allTraj[it2], closePt2, doca);
           if(doca == minDOCA) continue;
           if(prt) {
             mf::LogVerbatim myprt("TC");
             auto& tj1 = tjs.allTraj[it1];
             auto& tj2 = tjs.allTraj[it2];
             myprt<<" FHV2 CTP"<<tj1.CTP;
             myprt<<" T"<<tj1.ID<<"_"<<end1<<" MCSMom "<<tj1.MCSMom<<" ChgRMS "<<tj1.ChgRMS;
             myprt<<" split T"<<tj2.ID<<"? MCSMom "<<tj2.MCSMom<<" ChgRMS "<<tj2.ChgRMS;
             myprt<<" doca "<<doca<<" tj2.EndPt[0] "<<tj2.EndPt[0]<<" closePt2 "<<closePt2;
             myprt<<" tj2.EndPt[1] "<<tj2.EndPt[1];
           } // prt
           // ensure that the closest point is not near an end
           if(closePt2 < tjs.allTraj[it2].EndPt[0] + 3) continue;
           if(closePt2 > tjs.allTraj[it2].EndPt[1] - 3) continue;
           // Find the intersection point between the tj1 end and tj2 closest Pt
           float wint, tint;
           TrajIntersection(tjs.allTraj[it1].Pts[endPt1], tjs.allTraj[it2].Pts[closePt2], wint, tint);
           // make an angle cut
           float dang = DeltaAngle(tjs.allTraj[it1].Pts[endPt1].Ang, tjs.allTraj[it2].Pts[closePt2].Ang);
           if(dang < 0.2) continue;
           // ensure that tj1 doesn't cross tj2 but ensuring that the closest point on tj1 is at closePt1
           doca = 5;
           unsigned short closePt1 = 0;
           TrajPointTrajDOCA(tjs, tjs.allTraj[it2].Pts[closePt2], tjs.allTraj[it1], closePt1, doca);
           if(closePt1 != endPt1) continue;
           if(prt) mf::LogVerbatim("TC")<<" intersection W:T "<<(int)wint<<":"<<(int)(tint/tjs.UnitsPerTick)<<" dang "<<dang;
           // Find the point on tj2 that is closest to this point, overwriting closePt
           doca = minDOCA;
           // the point on tj2 that is closest to the intersection point
           unsigned short intPt2;
           TrajClosestApproach(tjs.allTraj[it2], wint, tint, intPt2, doca);
           if(prt) mf::LogVerbatim("TC")<<" intPt2 on tj2 "<<intPt2<<" at Pos "<<PrintPos(tjs, tjs.allTraj[it2].Pts[intPt2])<<" doca "<<doca;
           if(doca == minDOCA) continue;
           // find the MCSMom for both sections of tj2
           float mcsmom = tjs.allTraj[it2].MCSMom;
           float mcsmom1 = MCSMom(tjs, tjs.allTraj[it2], tjs.allTraj[it2].EndPt[0], intPt2);
           float mcsmom2 = MCSMom(tjs, tjs.allTraj[it2], intPt2, tjs.allTraj[it2].EndPt[1]);
           // require that the both MCSMoms be greater than 
           if(prt) mf::LogVerbatim("TC")<<" Check MCSMom after split: mcsmom1 "<<mcsmom1<<" mcsmom2 "<<mcsmom2;
           if(mcsmom1 < mcsmom || mcsmom2 < mcsmom) continue;
           // start scanning for the point on tj2 that has the best IP with the end of tj1 in the direction
           // from closePt2 -> endPt2
           short dir = 1;
           if(intPt2 < closePt2) dir = -1;
           unsigned short nit = 0;
           unsigned short ipt = intPt2;
           float mostChg = tjs.allTraj[it2].Pts[ipt].Chg;
           if(prt) mf::LogVerbatim("TC")<<" ipt "<<ipt<<" at Pos "<<PrintPos(tjs, tjs.allTraj[it2].Pts[ipt])<<" chg "<<mostChg;
           while(nit < 20) {
             ipt += dir;
             if(ipt < 3 || ipt > tjs.allTraj[it2].Pts.size() - 4) break;
             float delta = PointTrajDOCA(tjs, tjs.allTraj[it2].Pts[ipt].Pos[0], tjs.allTraj[it2].Pts[ipt].Pos[1], tjs.allTraj[it1].Pts[endPt1]);
             float sep = PosSep(tjs.allTraj[it2].Pts[ipt].Pos, tjs.allTraj[it1].Pts[endPt1].Pos);
             float dang = delta / sep;
             float pull = dang / tjs.allTraj[it1].Pts[endPt1].DeltaRMS;
             //            if(prt) mf::LogVerbatim("TC")<<" intPt2 "<<intPt2<<" at Pos "<<PrintPos(tjs, tjs.allTraj[it2].Pts[ipt])<<" delta "<<delta<<" chg "<<tjs.allTraj[it2].Pts[ipt].Chg<<" pull "<<pull;
             if(pull < 2 && tjs.allTraj[it2].Pts[ipt].Chg > mostChg) {
               mostChg = tjs.allTraj[it2].Pts[ipt].Chg;
               intPt2 = ipt;
             }
           }
           // require a lot of charge in tj2 in this vicinity compared with the average.
           float chgPull = (mostChg - tjs.allTraj[it2].AveChg) / tjs.allTraj[it2].ChgRMS;
           if(prt) mf::LogVerbatim("TC")<<" chgPull at intersection point "<<chgPull;
           if(chgPull < 10) continue;
           // require a signal on every wire between it1 and intPt2
           TrajPoint ltp = tjs.allTraj[it1].Pts[endPt1];
           if(tjs.allTraj[it1].Pts[endPt1].Pos[0] < -0.4) continue;
           unsigned int fromWire = std::nearbyint(tjs.allTraj[it1].Pts[endPt1].Pos[0]);
           if(tjs.allTraj[it2].Pts[intPt2].Pos[0] < -0.4) continue;
           unsigned int toWire =   std::nearbyint(tjs.allTraj[it2].Pts[intPt2].Pos[0]);
           if(fromWire > toWire) {
             unsigned int tmp = fromWire;
             fromWire = toWire;
             toWire = tmp;
           }
           bool skipIt = false;
           for(unsigned int wire = fromWire + 1; wire < toWire; ++wire) {
             MoveTPToWire(ltp, (float)wire);
             if(!SignalAtTp(tjs, ltp)) {
               skipIt = true;
               break;
             }
           } // wire
           if(skipIt) continue;
           // we have a winner
           // create a new vertex
           VtxStore aVtx;
           aVtx.Pos = tjs.allTraj[it2].Pts[intPt2].Pos;
           aVtx.NTraj = 3;
           aVtx.Pass = tjs.allTraj[it2].Pass;
           aVtx.Topo = 6;
           aVtx.ChiDOF = 0;
           aVtx.CTP = inCTP;
           aVtx.ID = tjs.vtx.size() + 1;
           unsigned short ivx = tjs.vtx.size();
           if(!StoreVertex(tjs, aVtx)) continue;
           if(!SplitTraj(tjs, it2, intPt2, ivx, prt)) {
             if(prt) mf::LogVerbatim("TC")<<"FHV2: Failed to split trajectory";
             // we can just remove the vertex since no Tj VtxID association has been made yet
             tjs.vtx.pop_back();
             continue;
           }
           tjs.allTraj[it1].VtxID[end1] = tjs.vtx[ivx].ID;
           tjs.allTraj[it1].AlgMod[kHamVx2] = true;
           tjs.allTraj[it2].AlgMod[kHamVx2] = true;
           unsigned short newTjIndex = tjs.allTraj.size() - 1;
           tjs.allTraj[newTjIndex].AlgMod[kHamVx2] = true;
           AttachAnyTrajToVertex(tjs, ivx, prt);
           SetVx2Score(tjs, prt);
           // Update the PDGCode for the chopped trajectory
           SetPDGCode(tjs, it2);
           // and for the new trajectory
           SetPDGCode(tjs, newTjIndex);
           if(prt) mf::LogVerbatim("TC")<<" FHV2: New vtx 2V"<<tjs.vtx[ivx].ID<<" Score "<<tjs.vtx[ivx].Score;
           didaSplit = true;
           break;
         } // it2
         if(didaSplit) break;
       } // end1
     } // it1
   } // FindHammerVertices2

std::vector< unsigned short > tca::FindKinks	(	const TjStuff &	tjs,
		PFPStruct &	pfp,
		double	sep,
		bool	prt
	)

Definition at line 1870 of file PFPUtils.cxx.

References KinkAngle(), PosSep2(), and tca::PFPStruct::Tp3s.

Referenced by DotProd(), and Split3DKink().

   {
     // returns a vector of indices in pfp.Tp3s where kinks exist. The kink angle is calculated using
     // Tp3s separated by +/- sep (cm)
     std::vector<unsigned short> kinkPts;
 //    double kang = tjs.KinkCuts[0];
     // look for a kink angle greater than angCut
     double angCut = 0.3;
     double kang = 0;
     unsigned short kStart = USHRT_MAX;
     // foundKink is set true after a kink is found to skip past some number of points after the kink
     bool foundKink = false;
     double kinkSep2 = 2 * sep * sep;
     for(unsigned short ipt = 1; ipt < pfp.Tp3s.size(); ++ipt) {
       // skip ahead after a kink?
       if(foundKink) {
         // location of the previously found kink
         unsigned short kpt = kinkPts[kinkPts.size() - 1];
         if(foundKink && PosSep2(pfp.Tp3s[ipt].Pos, pfp.Tp3s[kpt].Pos) < kinkSep2) continue;
       }
       foundKink = false;
       double dang = KinkAngle(tjs, pfp.Tp3s, ipt, sep);
       if(dang < angCut && kStart == USHRT_MAX) continue;
       // found a kink larger than the cut. See if this is the onset of a kink
       if(kStart == USHRT_MAX) {
         // onset of a kink
         kStart = ipt;
       } else {
         // a kink was found. Keep scanning until delta angle (dang) is less than the maximum (kang)
         if(dang < kang) {
           unsigned short klen = ipt - kStart;
           if(prt) mf::LogVerbatim("TC")<<" findKinks: kink angle "<<kang<<" at point "<<ipt<<" klen "<<klen;
           kinkPts.push_back(ipt - 1);
           foundKink = true;
           kStart = USHRT_MAX;
         } // dang < kang
       } // kink found
       kang = dang;
     } // ipt
     return kinkPts;
   } // findKinks

void tca::FindMissedTjsInTp3s	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		std::vector< int > &	missTjs,
		std::vector< float > &	missFrac
	)

Definition at line 807 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, geo::CryostatID::Cryostat, DecodeCTP(), tca::PFPStruct::Dir, EncodeCTP(), kKilled, kMat3D, MakeBareTP(), mat, tca::TjStuff::NumPlanes, geo::PlaneID::Plane, PosSep(), SharesHighScoreVx(), tca::PFPStruct::TjIDs, tca::PFPStruct::Tp3s, geo::TPCID::TPC, tca::PFPStruct::TPCID, and tca::PFPStruct::XYZ.

   {
     // compare the Tjs in pfp.TjIDs with the Tjs in Tp3s and return a list of Tjs
     // in Tp3s that aren't in pfp.TjIDs
     missTjs.clear();
     missFrac.clear();
     if(pfp.TjIDs.empty() || pfp.Tp3s.empty()) return;
     
     // determine the projection of the pfp direction vector in each plane.
     // Don't try to merge if the projection is small
     std::vector<float> projInPlane(tjs.NumPlanes);
     for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
       CTP_t inCTP = EncodeCTP(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
       auto tp = MakeBareTP(tjs, pfp.XYZ[0], pfp.Dir[0], inCTP);
       projInPlane[plane] = tp.Delta;
     } // plane
     
     std::vector<unsigned short> pfpTjs;
     std::vector<unsigned short> usMissTjs;
     std::vector<std::vector<bool>> misTjPtMat;
     for(auto tjid : pfp.TjIDs) pfpTjs.push_back((unsigned short)tjid);
     for(auto& tp3 : pfp.Tp3s) {
       for(auto& tj2pt : tp3.Tj2Pts) {
         if(std::find(pfpTjs.begin(), pfpTjs.end(), tj2pt.id) != pfpTjs.end()) continue;
         // Tj isn't in pfp.TjIDs. See if we have it in the missed list
         unsigned short mtjIndx = 0;
         for(mtjIndx = 0; mtjIndx < usMissTjs.size(); ++mtjIndx) if(tj2pt.id == usMissTjs[mtjIndx]) break;
         if(mtjIndx == usMissTjs.size()) {
           // not in the misTjs list. Ensure that it isn't matched
           auto& mtj = tjs.allTraj[tj2pt.id - 1];
           if(mtj.AlgMod[kKilled] || mtj.AlgMod[kMat3D]) continue;
           // add it to the list
           usMissTjs.push_back(tj2pt.id);
           // create the point match vector
           std::vector<bool> ptMat(mtj.Pts.size(), false);
           ptMat[tj2pt.ipt] = true;
           misTjPtMat.push_back(ptMat);
         } else {
           if(tj2pt.ipt < misTjPtMat[mtjIndx].size()) misTjPtMat[mtjIndx][tj2pt.ipt] = true;
         }
       } // tj2pt
     } // tp3
     for(unsigned short im = 0; im < usMissTjs.size(); ++im) {
       int mtjid = usMissTjs[im];
       // calculate the fraction of points that are in Tp3s
       float cnt = 0;
       float mat = 0;
       auto& mtj = tjs.allTraj[mtjid - 1];
       // ignore if there is a high-score vertex between the missed tj and those in the pfp list
       if(SharesHighScoreVx(tjs, pfp, mtj)) continue;
       for(unsigned short ipt = mtj.EndPt[0]; ipt <= mtj.EndPt[1]; ++ipt) {
         auto& mtp = mtj.Pts[ipt];
         if(mtp.Chg <= 0) continue;
         ++cnt;
         if(misTjPtMat[im][ipt]) ++mat;
       } // ipt
       float frac = mat / cnt;
       // ignore if low fraction matched
       if(frac < 0.1) continue;
       // ignore if this would only extend the tj in this plane by a small amount
       float lenInPlane = 0;
       for(auto tjid : pfp.TjIDs) {
         auto& tj = tjs.allTraj[tjid - 1];
         if(tj.CTP != mtj.CTP) continue;
         float len = PosSep(tj.Pts[tj.EndPt[0]].Pos, tj.Pts[tj.EndPt[1]].Pos);
         if(len > lenInPlane) lenInPlane = len;
       } // tjid
       if(cnt < 0.05 * lenInPlane) continue;
       // check the direction vector projection in this plane
       if(projInPlane[DecodeCTP(mtj.CTP).Plane] < 0.1) continue;
       missTjs.push_back(mtjid);
       missFrac.push_back(frac);
     } // im
   } // FindMissedTjsInTp3s

void tca::FindNearbyTjs	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3829 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::ShowerStruct::CTP, tca::ShowerStruct::Envelope, GetAssns(), tca::ShowerStruct::ID, kKilled, kShowerTj, tca::ShowerStruct::NearTjIDs, PointInsideEnvelope(), PointTrajDOCA(), tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::TjIDs, TrajTrajDOCA(), and tca::TjStuff::vtx.

Referenced by FindShowers3D().

   {
     // Find Tjs that are near the shower but are not included in it
     ss.NearTjIDs.clear();
     
     // check for a valid envelope
     if(ss.Envelope.empty()) return;
     auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
     
     std::string fcnLabel = inFcnLabel + ".FNTj";
     
     std::vector<int> ntj;
     
     // set max distance of closest approach ~ 5 radiation lengths ~200 WSE 
     constexpr float fiveRadLen = 200;
     
     // look for vertices inside the envelope
     for(auto vx : tjs.vtx) {
       if(vx.CTP != ss.CTP) continue;
       if(vx.ID == 0) continue;
       if(!PointInsideEnvelope(vx.Pos, ss.Envelope)) continue;
 //      auto vxTjIDs = GetVtxTjIDs(tjs, vx);
       auto vxTjIDs = GetAssns(tjs, "2V", vx.ID, "T");
       for(auto tjID : vxTjIDs) {
         // ignore those that are in the shower
         if(std::find(ss.TjIDs.begin(), ss.TjIDs.end(), tjID) != ss.TjIDs.end()) continue;
         // or already in the list
         if(std::find(ntj.begin(), ntj.end(), tjID) != ntj.end()) continue;
         ntj.push_back(tjID);
       } // tjID
     } // vx
 
     // Check for tj points inside the envelope
     for(auto& tj : tjs.allTraj) {
       if(tj.CTP != ss.CTP) continue;
       if(tj.AlgMod[kKilled]) continue;
       // not a showerTj
       if(tj.AlgMod[kShowerTj]) continue;
       // make sure it's not in the shower
       if(std::find(ss.TjIDs.begin(), ss.TjIDs.end(), tj.ID) != ss.TjIDs.end()) continue;
       // or already in the list
       if(std::find(ntj.begin(), ntj.end(), tj.ID) != ntj.end()) continue;
       // check proximity of long high MCSMom Tjs to the shower center
       if(tj.Pts.size() > 40 && tj.MCSMom > 200) {
         float delta = PointTrajDOCA(tjs, stj.Pts[1].Pos[0], stj.Pts[1].Pos[1], tj.Pts[tj.EndPt[0]]);
         // TODO: This could be done much better
         if(delta < 20) {
           float doca = fiveRadLen;
           unsigned short spt = 0, ipt = 0;
           TrajTrajDOCA(tjs, stj, tj, spt, ipt, doca);
           if(doca < fiveRadLen) {
             ntj.push_back(tj.ID);
             continue;
           }
         }
       } // long hi-MCSMom tj
       // don't need to check every point. Every third should be enough
       bool isInside = false;
       for(unsigned short ipt = tj.EndPt[0]; ipt < tj.EndPt[1]; ipt += 3) {
         if(PointInsideEnvelope(tj.Pts[ipt].Pos, ss.Envelope)) {
           isInside = true;
           break;
         }
       } // ipt
       // check the last point which was probably missed above
       if(!isInside) {
         unsigned short ipt = tj.EndPt[1];
         isInside = PointInsideEnvelope(tj.Pts[ipt].Pos, ss.Envelope);
       }
       if(isInside) ntj.push_back(tj.ID);
     } // tj
     if(ntj.size() > 1) std::sort(ntj.begin(), ntj.end());
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Found "<<ntj.size()<<" Tjs near ss.ID "<<ss.ID;
     ss.NearTjIDs = ntj;
     
   } // FindNearbyTjs

void tca::FindNeutralVertices	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid
	)

Definition at line 369 of file TCVertex.cxx.

References tca::TjStuff::allTraj, ChgFracBetween(), ChgFracNearEnd(), CloseEnd(), tca::VtxStore::CTP, debug, dir, EncodeCTP(), evd::details::end(), FitVertex(), tca::VtxStore::ID, tca::Vtx3Store::ID, kVxNeutral, MakeBareTP(), tca::TjStuff::NeutralVxCuts, tca::TjStuff::NumPlanes, tca::TjStuff::pfps, tca::DebugStuff::Plane, PointDirIntersect(), tca::VtxStore::Pos, PosSep(), tca::Vtx3Store::Primary, PrintPos(), SetVx2Score(), SetVx3Score(), StoreVertex(), tca::DebugStuff::Tick, tca::VtxStore::Topo, tca::Vtx3Store::TPCID, geo::TPCID::TPCID(), tca::TjStuff::TPCID, tca::TjStuff::UseAlg, tca::TjStuff::vtx, tca::TjStuff::vtx3, tca::Vtx3Store::Vx2ID, tca::VtxStore::Vx3ID, tca::Vtx3Store::X, tca::TjStuff::XHi, tca::TjStuff::XLo, tca::Vtx3Store::Y, tca::TjStuff::YHi, tca::TjStuff::YLo, tca::Vtx3Store::Z, tca::TjStuff::ZHi, and tca::TjStuff::ZLo.

Referenced by tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // Look for 2D neutral vertices between Tjs 
     if(!tjs.UseAlg[kVxNeutral]) return;
     if(tjs.NeutralVxCuts.size() < 4) return;
     if(tjs.NumPlanes < 3) return;
     if(tjs.pfps.size() < 2) return;
     
     bool prt = (debug.Plane >= 0 && debug.Tick == 88888);
     
     struct CandVx {
       unsigned short ip1;
       unsigned short end1;
       unsigned short ip2;
       unsigned short end2;
       Point3_t intersect;
       float sepSum;
       bool isValid;
     };
     std::vector<CandVx> candVxs;
 
     for(unsigned short ip1 = 0; ip1 < tjs.pfps.size() - 1; ++ip1) {
       auto& p1 = tjs.pfps[ip1];
       if(p1.ID == 0) continue;
       if(p1.Tp3s.empty()) continue;
       if(p1.TPCID != tpcid) continue;
       float len1 = PosSep(p1.XYZ[0], p1.XYZ[1]);
       if(len1 < tjs.NeutralVxCuts[3]) continue;
       for(unsigned short end1 = 0; end1 < 2; ++end1) {
         float cfne1 = ChgFracNearEnd(tjs, p1, end1);
         if(cfne1 < tjs.NeutralVxCuts[0]) continue;
         for(unsigned short ip2 = ip1 + 1; ip2 < tjs.pfps.size(); ++ip2) {
           auto& p2 = tjs.pfps[ip2];
           if(p2.ID == 0) continue;
           if(p2.Tp3s.empty()) continue;
           if(p2.TPCID != tpcid) continue;
           float len2 = PosSep(p2.XYZ[0], p2.XYZ[1]);
           if(len2 < tjs.NeutralVxCuts[3]) continue;
           for(unsigned short end2 = 0; end2 < 2; ++end2) {
             float cfne2 = ChgFracNearEnd(tjs, p2, end2);
             if(cfne2 < tjs.NeutralVxCuts[0]) continue;
             float vxDOCA = 1E6;
             Point3_t intersect;
             if(!PointDirIntersect(p1.XYZ[end1], p1.Dir[end1], p2.XYZ[end2], p2.Dir[end2], intersect, vxDOCA)) continue;
             if(intersect[0] < tjs.XLo || intersect[0] > tjs.XHi) continue;
             if(intersect[1] < tjs.YLo || intersect[1] > tjs.YHi) continue;
             if(intersect[2] < tjs.ZLo || intersect[2] > tjs.ZHi) continue;
             // ensure that the pfp end and the vertex are consistent
             float sep1 = PosSep(intersect, p1.XYZ[end1]);
             if(PosSep(intersect, p1.XYZ[1-end1]) < sep1) continue;
             float sep2 = PosSep(intersect, p2.XYZ[end2]);
             if(PosSep(intersect, p2.XYZ[1-end2]) < sep2) continue;
             if(vxDOCA > tjs.NeutralVxCuts[1]) continue;
 /*
             // find the DOCA between these two
             unsigned short closePt1, closePt2;
             float pfpDOCA = PFPDOCA(p1, p2, closePt1, closePt2);
             if(closePt1 == USHRT_MAX) continue;
 */
             // ensure that there isn't a lot of charge between the end of each pfp and the intersection point
             float cfb1 = ChgFracBetween(tjs, p1.XYZ[end1], intersect, p1.TPCID);
             float cfb2 = ChgFracBetween(tjs, p2.XYZ[end2], intersect, p2.TPCID);
             if(prt) {
               mf::LogVerbatim myprt("TC");
               myprt<<"FNV: P"<<p1.ID<<"_"<<end1<<" sep1 "<<std::fixed<<std::setprecision(2)<<sep1;
               myprt<<" cfne1 "<<cfne1<<" cfb1 "<<cfb1;
               myprt<<" P"<<p2.ID<<"_"<<end2<<" sep2 "<<sep2<<" cfne2 "<<cfne2<<" cfb2 "<<cfb2;
               myprt<<" intersect "<<intersect[0]<<" "<<intersect[1]<<" "<<intersect[2];
               myprt<<" vxDOCA "<<vxDOCA;
             } // prt
             if(cfb1 > tjs.NeutralVxCuts[2]) continue;
             if(cfb2 > tjs.NeutralVxCuts[2]) continue;
             // check existing candidates
             float sepSum = sep1 + sep2;
             bool skipit = false;
             for(auto& candVx : candVxs) {
               if(!candVx.isValid) continue;
               if(candVx.ip1 != ip1 && candVx.ip2 != ip2) continue;
               // see if the separation sum is smaller
               if(sepSum < candVx.sepSum) {
                 // flag the saved one as not valid
                 candVx.isValid = false;
               } else {
                 skipit = true;
                 break;
               }
             } // candVx
             if(skipit) continue;
             CandVx candVx;
             candVx.ip1 = ip1;
             candVx.end1 = end1;
             candVx.ip2 = ip2;
             candVx.end2 = end2;
             candVx.intersect = intersect;
             candVx.sepSum = sep1 + sep2;
             candVx.isValid = true;
             candVxs.push_back(candVx);
             if(prt) mf::LogVerbatim("TC")<<" candidate";
           } // end2
         } // ip2
       } // end1
     } // ip1
     
     if(candVxs.empty()) return;
     
     // Make vertices with the valid candidates
     for(auto& candVx : candVxs) {
       if(!candVx.isValid) continue;
       Vtx3Store vx3;
       auto& p1 = tjs.pfps[candVx.ip1];
       auto& p2 = tjs.pfps[candVx.ip2];
       vx3.TPCID = p1.TPCID;
       vx3.ID = tjs.vtx3.size() + 1;
       // try to improve the vertex position by fitting the Tjs in 2D
       std::vector<TrajPoint> vxTps;
       Vector3_t dir = {{0, 0, 0}};
       for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
         vxTps.clear();
         CTP_t inCTP = EncodeCTP(p1.TPCID.Cryostat, p1.TPCID.TPC, plane);
         // Need the position in this plane to find the closest end
         auto vtp = MakeBareTP(tjs, candVx.intersect, dir, inCTP);
         if(vtp.Pos[0] < 0) continue;
         for(auto tid : p1.TjIDs) {
           auto& tj = tjs.allTraj[tid - 1];
           if(tj.CTP != vtp.CTP) continue;
           unsigned short end = CloseEnd(tjs, tj, vtp.Pos);
           auto vxTp = tj.Pts[tj.EndPt[end]];
           vxTp.Step = tid;
           vxTp.AngleCode = end;
           vxTps.push_back(vxTp);
         } // tid
         for(auto tid : p2.TjIDs) {
           auto& tj = tjs.allTraj[tid - 1];
           if(tj.CTP != vtp.CTP) continue;
           unsigned short end = CloseEnd(tjs, tj, vtp.Pos);
           auto vxTp = tj.Pts[tj.EndPt[end]];
           vxTp.Step = tid;
           vxTp.AngleCode = end;
           vxTps.push_back(vxTp);
         } // tid
         if(vxTps.size() < 2) continue;
         VtxStore vx2;
         vx2.CTP = inCTP;
         vx2.Topo = 11;
         if(!FitVertex(tjs, vx2, vxTps, prt)) {
           if(prt) mf::LogVerbatim("TC")<<"FNV: vertex fit failed";
           continue;
         } // fit failed
         vx2.ID = tjs.vtx.size() + 1;
         for(auto& vxTp : vxTps) {
           int tid = vxTp.Step;
           auto& tj = tjs.allTraj[tid - 1];
           tj.VtxID[vxTp.AngleCode] = vx2.ID;
         }
         if(prt) mf::LogVerbatim("TC")<<"FNV: 2V fit inCTP "<<inCTP<<" pos "<<PrintPos(tjs, vx2.Pos);
         vx2.Vx3ID = vx3.ID;
         vx3.Vx2ID[plane] = vx2.ID;
         SetVx2Score(tjs, vx2, prt);
         if(!StoreVertex(tjs, vx2)) {
           if(prt) mf::LogVerbatim("TC")<<"FNV: store vertex failed";
           continue;
         } // StoreVertex failed
       } // plane
       vx3.X = candVx.intersect[0];
       vx3.Y = candVx.intersect[1];
       vx3.Z = candVx.intersect[2];
       vx3.Primary = true;
       SetVx3Score(tjs, vx3, prt);
       tjs.vtx3.push_back(vx3);
       if(prt) mf::LogVerbatim("TC")<<"FNV: P"<<p1.ID<<"_"<<candVx.end1<<" P"<<p2.ID<<"_"<<candVx.end2<<" -> 3V"<<vx3.ID;
     } // candVx
     
   } // FindNeutralVertices

bool tca::FindParent	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 1739 of file TCShower.cxx.

References tca::TjStuff::allTraj, ChgFracBetween(), tca::ShowerStruct3D::ChgPos, ChgToMeV(), tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, geo::CryostatID::Cryostat, tca::ShowerStruct3D::Dir, DontCluster(), DotProd(), EncodeCTP(), tca::ShowerStruct3D::End, energy, FarEnd(), FindAlongTrans(), GetAssns(), tca::ShowerStruct3D::ID, InShowerProbLong(), kShwrParent, MakeBareTP(), MCSMom(), tca::TjStuff::NumPlanes, tca::ShowerStruct3D::ParentID, tca::TjStuff::pfps, PointDirection(), PosSep(), PosSep2(), SetParent(), ShowerEnergy(), ShowerParams(), tca::TjStuff::ShowerParentReader, tca::TjStuff::ShowerParentVars, tca::TjStuff::showers, ss, tca::ShowerStruct3D::Start, geo::TPCID::TPC, tca::ShowerStruct3D::TPCID, UpdateShower(), tca::TjStuff::UseAlg, and tca::ShowerStruct3D::Vx3ID.

Referenced by FindShowers3D().

   {
     // look for a parent pfp for the shower.The 2D showers associated with it 
     // The parent should be at the start of the shower (shend = 0) if it is well-defined
     // (has small AspectRatio and small DirectionFOM). A search is also made for a parent at
     // the "wrong" end of the shower (shend = 1). The best one at the wrong end is used if
     // no parent is found at the shower start and the shower is poorly defined.
     //
     // This function returns false if there was a failure. Not finding a parent is not a failure
     
     if(ss3.ID == 0) return false;
     if(ss3.CotIDs.size() < 2) return false;
     // Use the MVA reader
     if(!tjs.ShowerParentReader) return false;
     if(tjs.ShowerParentVars.size() != 9) return false;
     // don't call this function when studying this function. See TCTruth StudyShowerParents
     if(!tjs.UseAlg[kShwrParent]) return false;
     
     std::string fcnLabel = inFcnLabel + ".FPar";
     MCParticleListUtils mcpu{tjs};
     int truPFP = mcpu.PrimaryElectronPFPID(ss3.TPCID);
     
     double energy = ShowerEnergy(ss3);
     // the energy is probably under-estimated since there isn't a parent yet.
     energy *= 1.2;
     double shMaxAlong, along95;
     ShowerParams(energy, shMaxAlong, along95);
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" Estimated energy "<<(int)energy<<" MeV shMaxAlong "<<shMaxAlong<<" along95 "<<along95<<" truPFP "<<truPFP;
     
     // look for the pfp that has a reasonable probability of being in the shower but with the
     // minimum along distance from the shower center. 
     // This image explains the concept. The *'s represents the points in 2D showers that define
     // the charge center in 3D, ChgPos. We are looking for a pfp parent denoted by ----. The end 
     // that is farthest from ChgPos is labeled P (pfp.XYZ[pend] in the code). The expected distance
     // from the shower start to shower Max, shMaxAlong, is found from ShowerParams. The longitudinal
     // and transverse distance of P relative to the shower center is alongTrans. The first cut on a
     // candidate parent is made requiring that D (alongTrans[0]) > 0.5 * shMaxAlong.
     //
     //       __________shend = 0________________      __________shend = 1________________
     //                                **********
     //                    ******  ******                   ******  ******
     //       P-----*****ChgPos******   **                *****ChgPos******-------P
     //                     ********     *******              *******
     //                     |----> along                          |---> along
     //       |<----D------>|                                     |<----D------>|
     // |<----shMaxAlong--->|                                     |<----shMaxAlong--->|
     //
     // Candidate parent ID for each end and the FOM 
     std::array<int, 2> parID {{0, 0}};
     std::array<float, 2> parFOM {{-1E6, -1E6}};
     
     // temp vector to flag pfps that are already parents - indexed by ID
     std::vector<bool> isParent(tjs.pfps.size() + 1, false);
     for(auto& oldSS3 : tjs.showers) {
       if(oldSS3.ID == 0) continue;
       isParent[oldSS3.ParentID] = true;
     } // pfp
     
     // put the tjs associated with this shower in a flat vector
     auto TjsInSS3 = GetAssns(tjs, "3S", ss3.ID, "T");
     if(TjsInSS3.empty()) return false;
     
     for(auto& pfp : tjs.pfps) {
       if(pfp.ID == 0) continue;
       bool dprt = (pfp.ID == truPFP);
       if(pfp.TPCID != ss3.TPCID) continue;
       // ignore neutrinos
       if(pfp.PDGCode == 14 || pfp.PDGCode == 14) continue;
       // ignore shower pfps
       if(pfp.PDGCode == 1111) continue;
       // ignore existing parents
       if(isParent[pfp.ID]) continue;
       // check for inconsistent pfp - shower tjs 
       if(DontCluster(tjs, pfp.TjIDs, TjsInSS3)) continue;
       // ignore if the pfp energy is larger than the shower energy
       float pfpEnergy = 0;
       float minEnergy = 1E6;
       for(auto tid : pfp.TjIDs) {
         auto& tj = tjs.allTraj[tid - 1];
         float energy = ChgToMeV(tj.TotChg);
         pfpEnergy += energy;
         if(energy < minEnergy) minEnergy = energy;
       }
       pfpEnergy -= minEnergy;
       pfpEnergy /= (float)(pfp.TjIDs.size() - 1);
       if(dprt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" P"<<pfp.ID<<" E "<<pfpEnergy;
       if(pfpEnergy > energy) continue;
       // find the end that is farthest away
       unsigned short pEnd = FarEnd(tjs, pfp, ss3.ChgPos);
       auto pToS = PointDirection(pfp.XYZ[pEnd], ss3.ChgPos);
       double costh1 = std::abs(DotProd(pToS, ss3.Dir));
       if(costh1 < 0.4) continue;
       float costh2 = DotProd(pToS, pfp.Dir[pEnd]);
       // distance^2 between the pfp end and the shower start, charge center, and shower end
       float distToStart2 = PosSep2(pfp.XYZ[pEnd], ss3.Start);
       float distToChgPos2 = PosSep2(pfp.XYZ[pEnd], ss3.ChgPos);
       float distToEnd2 = PosSep2(pfp.XYZ[pEnd], ss3.End);
       if(dprt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" P"<<pfp.ID<<"_"<<pEnd<<" distToStart "<<sqrt(distToStart2)<<" distToChgPos "<<sqrt(distToChgPos2)<<" distToEnd "<<sqrt(distToEnd2);
       // find the end of the shower closest to the pfp
       unsigned short shEnd = 0;
       if(distToEnd2 < distToStart2) shEnd = 1;
       // This can't be a parent if the pfp end is closer to the shower center than the start or the end
       if(shEnd == 0 && distToChgPos2 < distToStart2) continue;
       if(shEnd == 1 && distToChgPos2 < distToEnd2) continue;
       if(dprt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<"_"<<shEnd<<" P"<<pfp.ID<<"_"<<pEnd<<" costh1 "<<costh1;
       Point2_t alongTrans;
       // find the longitudinal and transverse components of the pfp start point relative to the
       // shower center
       FindAlongTrans(ss3.ChgPos, ss3.Dir, pfp.XYZ[pEnd], alongTrans);
       if(dprt) mf::LogVerbatim("TC")<<fcnLabel<<"   alongTrans "<<alongTrans[0]<<" "<<alongTrans[1];
       // find the probability this point is inside the shower. Offset by the expected
       // shower max distance. distToShowerMax will be > 0 if the pfp end is closer to
       // ChgPos than expected from the parameterization
       float distToShowerMax = shMaxAlong - std::abs(alongTrans[0]);
       float prob = InShowerProbLong(energy, distToShowerMax);
       if(dprt) mf::LogVerbatim("TC")<<fcnLabel<<"        prob "<<prob;
       if(prob < 0.1) continue;
       float chgFrac = 0;
       float totSep = 0;
       // find the charge fraction btw the pfp start and the point that is 
       // half the distance to the charge center in each plane
       for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
         CTP_t inCTP = EncodeCTP(ss3.TPCID.Cryostat, ss3.TPCID.TPC, plane);
         int ssid = 0;
         for(auto cid : ss3.CotIDs) {
           auto& ss = tjs.cots[cid - 1];
           if(ss.CTP != inCTP) continue;
           ssid = ss.ID;
           break;
         } // cid
         if(ssid == 0) continue;
         auto tpFrom = MakeBareTP(tjs, pfp.XYZ[pEnd], pToS, inCTP);
         auto& ss = tjs.cots[ssid - 1];
         auto& stp1 = tjs.allTraj[ss.ShowerTjID - 1].Pts[1];
         float sep = PosSep(tpFrom.Pos, stp1.Pos);
         float toPos = tpFrom.Pos[0] + 0.5 * tpFrom.Dir[0] * sep;
         float cf = ChgFracBetween(tjs, tpFrom, toPos, false);
         // weight by the separation in the plane
         totSep += sep;
         chgFrac += sep * cf;
       } // plane
       if(totSep > 0) chgFrac /= totSep;
 /*
       tjs.ShowerParentReader->AddVariable("fShEnergy", &tjs.ShowerParentVars[0]);
       tjs.ShowerParentReader->AddVariable("fPfpEnergy", &tjs.ShowerParentVars[1]);
       tjs.ShowerParentReader->AddVariable("fMCSMom", &tjs.ShowerParentVars[2]);
       tjs.ShowerParentReader->AddVariable("fPfpLen", &tjs.ShowerParentVars[3]);
       tjs.ShowerParentReader->AddVariable("fSep", &tjs.ShowerParentVars[4]);
       tjs.ShowerParentReader->AddVariable("fDang1", &tjs.ShowerParentVars[5]);
       tjs.ShowerParentReader->AddVariable("fDang2", &tjs.ShowerParentVars[6]);
       tjs.ShowerParentReader->AddVariable("fChgFrac", &tjs.ShowerParentVars[7]);
       tjs.ShowerParentReader->AddVariable("fInShwrProb", &tjs.ShowerParentVars[8]);
 */
       // load the MVA variables
       tjs.ShowerParentVars[0] = energy;
       tjs.ShowerParentVars[1] = pfpEnergy;
       tjs.ShowerParentVars[2] = MCSMom(tjs, pfp.TjIDs);
       tjs.ShowerParentVars[3] = PosSep(pfp.XYZ[0], pfp.XYZ[1]);
       tjs.ShowerParentVars[4] = sqrt(distToChgPos2);
       tjs.ShowerParentVars[5] = acos(costh1);
       tjs.ShowerParentVars[6] = acos(costh2);
       tjs.ShowerParentVars[7] = chgFrac;
       tjs.ShowerParentVars[8] = prob;
       float candParFOM = tjs.ShowerParentReader->EvaluateMVA("BDT");
 /*
       // use the overall pfp direction instead of the starting direction. It may not be so
       // good if the shower develops quickly
       auto pfpDir = PointDirection(pfp.XYZ[pEnd], pfp.XYZ[1 - pEnd]);
       costh = DotProd(pfpDir, ss3.Dir);
       if(dprt) mf::LogVerbatim("TC")<<fcnLabel<<" pfpDir "<<pfpDir[0]<<" "<<pfpDir[1]<<" "<<pfpDir[2]<<" costh "<<costh;
       if(std::abs(costh) < 0.6) continue;
 */
       // find the parentFOM
 //      float candParFOM = ParentFOM(fcnLabel, tjs, pfp, pEnd, ss3, prt);
       
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<fcnLabel;
         myprt<<" 3S"<<ss3.ID<<"_"<<shEnd;
         myprt<<" P"<<pfp.ID<<"_"<<pEnd<<" ParentVars";
         for(auto var : tjs.ShowerParentVars) myprt<<" "<<std::fixed<<std::setprecision(2)<<var;
         myprt<<" candParFOM "<<candParFOM;
       } // prt
       if(candParFOM > parFOM[shEnd]) {
         parFOM[shEnd] = candParFOM;
         parID[shEnd] = pfp.ID;
       } 
     } // pfp
     
     if(parID[0] == 0 && parID[1] == 0) return true;
 
     // decide which to use
     int bestPFP = 0;
     // find the average DirectionFOM to help decide
     float aveDirFOM = 0;
     float fom3D = 0;
     for(auto cid : ss3.CotIDs) aveDirFOM += tjs.cots[cid - 1].DirectionFOM;
     aveDirFOM /= (float)ss3.CotIDs.size();
     if(prt) {
       mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" parID[0] "<<parID[0]<<" fom "<<parFOM[0]<<" parID[1] "<<parID[1]<<" fom "<<parFOM[1]<<" aveDirFOM "<<aveDirFOM;
     }
     if(parID[0] > 0 && parID[1] > 0 && aveDirFOM > 0.3) {
       // candidates at both ends and the direction is not well known. Take
       // the one with the best FOM
       bestPFP = parID[0];
       fom3D = parFOM[0];
       if(parFOM[1] > parFOM[0]) {
         bestPFP = parID[1];
         fom3D = parFOM[1];
       }
     } else if(parID[0] > 0) {
       bestPFP = parID[0];
       fom3D = parFOM[0];
     } else {
       bestPFP = parID[1];
       fom3D = parFOM[1];
     }
     if(bestPFP == 0) return true;
 
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" setting P"<<bestPFP<<" as the parent "<<fom3D;
     
     // make local copies so we can recover from a failure
     auto oldSS3 = ss3;
     std::vector<ShowerStruct> oldSS(ss3.CotIDs.size());
     for(unsigned short ii = 0; ii < ss3.CotIDs.size(); ++ii) {
       oldSS[ii] = tjs.cots[ss3.CotIDs[ii] - 1];
     }
     
     ss3.ParentID = bestPFP;
     auto& pfp = tjs.pfps[bestPFP - 1];
     unsigned short pend = FarEnd(tjs, pfp, ss3.ChgPos);
     ss3.Vx3ID = pfp.Vx3ID[pend];
     
     if(SetParent(fcnLabel, tjs, pfp, ss3, prt) && UpdateShower(fcnLabel, tjs, ss3, prt)) {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" successful update";
       return true;
     }
 
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" Failed. Recovering...";
     ss3 = oldSS3;
     for(unsigned short ii = 0; ii < oldSS.size(); ++ii) {
       auto& ss = oldSS[ii];
       tjs.cots[ss.ID - 1] = ss;
     } // ii
     return false;
     
   } // FindParent

void tca::FindPFParticles	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid,
		bool	prt
	)

Definition at line 1968 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, AnalyzePFP(), CreatePFP(), geo::CryostatID::Cryostat, DefinePFP(), tca::PFPStruct::Dir, EncodeCTP(), FindCompleteness(), FindXMatches(), tca::PFPStruct::ID, tca::SortEntry::index, kEnvFlag, kKilled, kMat3D, MakeBareTP(), tca::TjStuff::Match3DCuts, Match3DVtxTjs(), tca::TjStuff::matchVec, tca::PFPStruct::MatchVecIndex, MaxTjLen(), MCSMom(), tca::TjStuff::NumPlanes, tca::PFPStruct::PDGCode, PDGCodeVote(), SetIntersection(), Split3DKink(), StorePFP(), tca::TjStuff::TestBeam, tca::PFPStruct::TjCompleteness, tca::PFPStruct::TjIDs, geo::TPCID::TPC, tca::PFPStruct::TPCID, tca::SortEntry::val, valDecreasings(), and tca::PFPStruct::XYZ.

Referenced by DotProd(), and tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // Match Tjs in 3D and create PFParticles
     
     if(tjs.Match3DCuts[0] <= 0) return;
     
     if(prt) mf::LogVerbatim("TC")<<" inside FindPFParticles";
     // clear matchVec
     tjs.matchVec.clear();
     // clear the kEnvFlag bits on all Tjs. The bit will be set true when a TP is
     // used in a PFParticle Tp3
     for(auto& tj : tjs.allTraj) {
       for(auto& tp : tj.Pts) tp.Environment[kEnvFlag] = false;
     } // tj
     
     // Match these points in 3D and put the results in tjs.matchVec
     std::vector<MatchStruct> matVec;
     // first look for 3-plane matches in a 3-plane TPC
     if(tjs.NumPlanes == 3) {
       // Match Tjs with high quality vertices first and the leftovers next
       for(short maxScore = 0; maxScore < 2; ++maxScore) FindXMatches(tjs, 3, maxScore, matVec, prt);
     } // 3-plane TPC
     // Make 2-plane matches if we haven't hit the user-defined size limit
     if(matVec.size() < tjs.Match3DCuts[4]) {
       // 2-plane TPC or 2-plane matches in a 3-plane TPC
       if(tjs.NumPlanes == 2) {
         for(short maxScore = 0; maxScore < 2; ++maxScore) FindXMatches(tjs, 2, maxScore, matVec, prt);
       } else {
         // Make one attempt at 2-plane matches in a 3-plane TPC, setting maxScore large
         FindXMatches(tjs, 2, 3, matVec, prt);
       }
     } // can add more combinations
     
     if(matVec.empty()) return;
     
     // sort by decreasing number of matched points
     if(matVec.size() > 1) {
       PFPStruct pfp = CreatePFP(tjs, tpcid);
       std::vector<int> dum1;
       std::vector<float> dum2;
       std::vector<SortEntry> sortVec(matVec.size());
       for(unsigned int ii = 0; ii < matVec.size(); ++ii) {
         sortVec[ii].index = ii;
         auto& ms = matVec[ii];
         sortVec[ii].val = ms.Count;
         // de-weight two-plane matches
         if(ms.TjIDs.size() == 2) sortVec[ii].val /= 2;
       } // ii
       std::sort(sortVec.begin(), sortVec.end(), valDecreasings);
       std::vector<MatchStruct> tmpVec;
       tmpVec.reserve(matVec.size());
       for(unsigned int ii = 0; ii < matVec.size(); ++ii) {
         tmpVec.push_back(matVec[sortVec[ii].index]);
       } // ii
       matVec = tmpVec;
     } // sort matVec
     
     // put the maybe OK matches into tjs
     PFPStruct pfp = CreatePFP(tjs, tpcid);
     for(auto& ms : matVec) {
       if(ms.Count < 2) continue;
       // check for duplicates
       bool skipit = false;
       for(auto& oms : tjs.matchVec) {
         if(ms.TjIDs == oms.TjIDs) {
           skipit = true;
           break;
         }
       } // oms
       if(skipit) continue;
       // Find completeness, do the fit, don't fill Tp3s, don't print
       pfp.TjIDs = ms.TjIDs;
       FindCompleteness(tjs, pfp, true, false, false);
       // save the info in matchStruct
       ms.TjCompleteness = pfp.TjCompleteness;
       ms.Pos = pfp.XYZ[0];
       ms.Dir = pfp.Dir[0];
       tjs.matchVec.push_back(ms);
     }
     if(tjs.matchVec.empty()) return;
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"FPFP: tjs.matchVec\n";
       unsigned short cnt = 0;
       PFPStruct pfp = CreatePFP(tjs, tpcid);
       std::vector<int> dum1;
       std::vector<float> dum2;
       for(unsigned int ii = 0; ii < tjs.matchVec.size(); ++ii) {
         auto& ms = tjs.matchVec[ii];
         if(ms.Count == 0) continue;
         myprt<<std::setw(4)<<ii<<" Count "<<std::setw(5)<<(int)ms.Count;
         myprt<<" TjIDs:";
         for(auto& tjid : ms.TjIDs) myprt<<" T"<<tjid;
         myprt<<" Comp ";
         for(unsigned short itj = 0; itj < ms.TjCompleteness.size(); ++itj) {
           myprt<<std::setprecision(2)<<std::setw(6)<<ms.TjCompleteness[itj];
         }
         myprt<<" Pos ("<<std::setprecision(0)<<std::fixed;
         myprt<<ms.Pos[0]<<", "<<ms.Pos[1]<<", "<<ms.Pos[2];
         myprt<<") Dir "<<std::setprecision(2)<<std::setw(6)<<ms.Dir[0]<<std::setw(6)<<ms.Dir[1]<<std::setw(6)<<ms.Dir[2];
         myprt<<" projInPlane";
         for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
           CTP_t inCTP = EncodeCTP(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
           auto tp = MakeBareTP(tjs, ms.Pos, ms.Dir, inCTP);
           myprt<<" "<<std::setprecision(2)<<tp.Delta;
         } // plane
         myprt<<" maxTjLen "<<(int)MaxTjLen(tjs, ms.TjIDs);
         myprt<<" MCSMom "<<MCSMom(tjs, ms.TjIDs);
         myprt<<" PDGCodeVote "<<PDGCodeVote(tjs, ms.TjIDs, false);
         myprt<<"\n";
         ++cnt;
         if(cnt == 1000 || ms.Count < 2) {
           myprt<<"...stopped printing after 500 entries or Count < 2";
           break;
         }
       } // ii
     } // prt
 
     // create the list of associations to matches that will be converted to PFParticles
     // Start with Tjs attached to 3D vertices. This is only done when reconstructing neutrino events
     if(!tjs.TestBeam) {
       Match3DVtxTjs(tjs, tpcid, prt);
     }
 
     // define the PFParticleList
     for(unsigned int indx = 0; indx < tjs.matchVec.size(); ++indx) {
       auto& ms = tjs.matchVec[indx];
       // ignore dead matches
       if(ms.Count == 0) continue;
       // skip this match if any of the trajectories is already matched or merged and killed
       bool skipit = false;
       // check for muons and delta rays or InShower Tjs
       bool has13 = false;
       bool has11 = false;
       for(unsigned short itj = 0; itj < ms.TjIDs.size(); ++itj) {
         if(ms.TjIDs[itj] <= 0 || ms.TjIDs[itj] > (int)tjs.allTraj.size()) {
           std::cout<<"FindPFParticles: bogus ms TjID "<<ms.TjIDs[itj]<<"\n";
           return;
         }
         auto& tj = tjs.allTraj[ms.TjIDs[itj] - 1];
         if(tj.AlgMod[kMat3D] || tj.AlgMod[kKilled]) skipit = true;
         // skip low TjCompleteness
         if(ms.TjCompleteness.empty()) {
           std::cout<<"FindPFParticles: ms.TjCompleteness is empty\n";
           return;
         }
         if(ms.TjCompleteness[itj] < 0.1) skipit = true;
         if(tj.PDGCode == 13) has13 = true;
         if(tj.PDGCode == 11) has11 = true;
       } // tjID
       if(skipit) continue;
       if(has13 && has11) continue;
       int pdgCode = PDGCodeVote(tjs, ms.TjIDs, prt);
       PFPStruct pfp = CreatePFP(tjs, tpcid);
       pfp.TjIDs = ms.TjIDs;
       // note that the ms position is the average position of all 3D matched Tp3s at this point.
       // It is not the start position. This will be determined in DefinePFP.
       pfp.XYZ[0] = ms.Pos;
       pfp.Dir[0] = ms.Dir;
       pfp.MatchVecIndex = indx;
       // Set the PDGCode so DefinePFP can ignore incompatible matches
       pfp.PDGCode = pdgCode;
       // set the PDGCode to ensure that delta rays aren't merged with muons. PDGCodeVote
       // returns 0 if the vote is mixed
       if(has13) pfp.PDGCode = 13;
       if(has11) pfp.PDGCode = 11;
       if(!DefinePFP("FPFP", tjs, pfp, prt)) {
         if(prt) mf::LogVerbatim("TC")<<" DefinePFP failed";
         continue;
       }
       double sep = 1;
       Split3DKink(tjs, pfp, sep, prt);
       if(!AnalyzePFP(tjs, pfp, prt)) continue;
       if(!StorePFP(tjs, pfp)) {
         if(prt) mf::LogVerbatim("TC")<<" StorePFP failed P"<<pfp.ID;
         if(prt) std::cout<<" StorePFP failed P"<<pfp.ID<<"\n";
         continue;
       }
       ms.Count = 0;
       // clobber MatchStructs that use the Tjs in this pfp
       for(auto& allms : tjs.matchVec) {
         auto shared = SetIntersection(allms.TjIDs, pfp.TjIDs);
         if(!shared.empty()) allms.Count = 0;
       } // allms
     } // indx
     //    CheckNoMatchTjs(tjs, tpcid, prt);
 
   } // FindPFParticles

bool tca::FindShowers3D	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid
	)

Definition at line 286 of file TCShower.cxx.

References AddTjsInsideEnvelope(), ChkAssns(), tca::TjStuff::cots, CreateSS(), geo::CryostatID::Cryostat, debug, DecodeCTP(), DefineDontCluster(), DotProd(), EncodeCTP(), energy, FillWireHitRange(), FindCots(), FindNearbyTjs(), FindParent(), tca::TjStuff::geom, MakeShowerObsolete(), Match2DShowers(), tca::TjStuff::MCPartList, MergeNearby2DShowers(), MergeOverlap(), MergeShowerChain(), MergeSubShowers(), MergeSubShowersTj(), geo::TPCGeo::Nplanes(), tca::TjStuff::NumPlanes, PosSep(), Print2DShowers(), PrintAllTraj(), PrintPFPs(), Reconcile3D(), SaveAllCots(), tca::TjStuff::SaveShowerTree, SaveTjInfo(), ShowerEnergy(), tca::TjStuff::showers, tca::TjStuff::ShowerTag, ss, StoreShower(), geo::TPCID::TPC, geo::GeometryCore::TPC(), tca::TjStuff::TPCID, and UpdateShower().

Referenced by tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // Find 2D showers using 3D-matched trajectories. This returns true if showers were found
     // which requires re-doing the 3D trajectory match
     
     bool reconstruct = (tjs.ShowerTag[0] == 2) || (tjs.ShowerTag[0] == 4);
     if(!reconstruct) return false;
     
     bool prt = tjs.ShowerTag[12] >= 0;
     // Add 10 for more detailed printing 
     short dbgPlane = ((int)tjs.ShowerTag[12] % 10);
     CTP_t dbgCTP = UINT_MAX;
     if(dbgPlane >= 0 && dbgPlane <= tjs.NumPlanes) dbgCTP = EncodeCTP(tpcid.Cryostat, tpcid.TPC, dbgPlane);
     
     std::string fcnLabel = "FS";
 
     geo::TPCGeo const& TPC = tjs.geom->TPC(tpcid);
     // check for already-existing showers
     for(unsigned short plane = 0; plane < TPC.Nplanes(); ++plane) {
       CTP_t inCTP = EncodeCTP(tpcid.Cryostat, tpcid.TPC, plane);
       for(auto& ss : tjs.cots) if(ss.CTP == inCTP) return false;
     }
     
     // rebuild the hit range references if necessary
     if(tpcid != tjs.TPCID && !FillWireHitRange(tjs, tpcid)) return false;
 
     if(prt) {
       PrintPFPs("FSi", tjs);
       PrintAllTraj("FSi", tjs, debug, USHRT_MAX, 0);
     }
     
     // define a list of tjs that shouldn't be clustered in the same shower because
     // they are matched to pfp particles that are likely parents of 3D showers
     DefineDontCluster(tjs, tpcid, prt);
 
     // lists of Tj IDs in plane, (list1, list2, list3, ...)
     std::vector<std::vector<std::vector<int>>> bigList(tjs.NumPlanes);
     for(unsigned short plane = 0; plane < TPC.Nplanes(); ++plane) {
       CTP_t inCTP = EncodeCTP(tpcid.Cryostat, tpcid.TPC, plane);
       std::vector<std::vector<int>> tjList;
       // Make lists of lists of ShowerLike tjs that will become showers
       FindCots(fcnLabel, tjs, inCTP, tjList, prt);
       SaveTjInfo(tjs, tjList, "TJL");
       if(tjList.empty()) continue;
       bigList[plane] = tjList;
     } // plane
     unsigned short nPlanesWithShowers = 0;
     for(unsigned short plane = 0; plane < TPC.Nplanes(); ++plane) if(!bigList.empty()) ++nPlanesWithShowers;
     if(nPlanesWithShowers < 2) return false;
     for(unsigned short plane = 0; plane < TPC.Nplanes(); ++plane) {
       CTP_t inCTP = EncodeCTP(tpcid.Cryostat, tpcid.TPC, plane);
       // print detailed debug info for one plane
       prt = (inCTP == dbgCTP);
       // Create a shower for each one
       for(auto& tjl : bigList[plane]) {
         if(tjl.empty()) continue;
         if(prt) {
           mf::LogVerbatim myprt("TC");
           myprt<<"Plane "<<plane<<" tjList";
           for(auto& tjID : tjl) myprt<<" "<<tjID;
         }
         auto ss = CreateSS(tjs, 0, tjl);
         if(ss.ID == 0) continue;
         if(!UpdateShower(fcnLabel, tjs, ss, prt)) continue;
         SaveTjInfo(tjs, ss, "DS");
         FindNearbyTjs(fcnLabel, tjs, ss, prt);
         // don't try to do anything else here until all of the showers are defined
         if(!StoreShower(fcnLabel, tjs, ss)) {
           std::cout<<fcnLabel<<" StoreShower failed 2S"<<ss.ID<<"\n";
           MakeShowerObsolete(fcnLabel, tjs, ss, prt);
         }
       } // tjl
       ChkAssns(fcnLabel, tjs);
       // try to merge showers in this plane using the lists of nearby Tjs
       if(inCTP == UINT_MAX) continue;
       if(tjs.cots.empty()) continue;
       prt = (inCTP == dbgCTP || dbgPlane == 3);
       if(prt) Print2DShowers("tjl", tjs, inCTP, false);
       MergeShowerChain(fcnLabel, tjs, inCTP, prt);
       SaveAllCots(tjs, inCTP, "MSC");
       if(prt) Print2DShowers("MSCo", tjs, inCTP, false);
       MergeOverlap(fcnLabel, tjs, inCTP, prt);
       SaveAllCots(tjs, inCTP, "MO");
       if(prt) Print2DShowers("MO", tjs, inCTP, false);
       MergeNearby2DShowers(fcnLabel, tjs, inCTP, prt);
       SaveAllCots(tjs, inCTP, "MSS");
       // merge sub-showers with other showers
       MergeSubShowers(fcnLabel, tjs, inCTP, prt);
       // merge sub-showers with shower-like tjs
       MergeSubShowersTj(fcnLabel, tjs, inCTP, prt);
       SaveAllCots(tjs, inCTP, "MNrby");
       if(prt) Print2DShowers("Nrby", tjs, inCTP, false);
       bool tryMerge = false;
       for(unsigned short ii = 0; ii < tjs.cots.size(); ++ii) {
         auto& ss = tjs.cots[ii];
         if(ss.ID == 0) continue;
         if(ss.CTP != inCTP) continue;
         if(AddTjsInsideEnvelope(fcnLabel, tjs, ss, prt)) tryMerge = true;
         if (tjs.SaveShowerTree) SaveAllCots(tjs, inCTP, "Merge");
       }
       if(tryMerge) MergeNearby2DShowers(fcnLabel, tjs, inCTP, prt);
       SaveAllCots(tjs, inCTP, "ATj2");
       if(prt) Print2DShowers("ATIE", tjs, inCTP, false);
     } // plane
     if(tjs.cots.empty()) return false;
     prt = (dbgPlane > 2);
     if(prt) Print2DShowers("B4", tjs, USHRT_MAX, false);
     // Match in 3D, make 3D showers and define them
     Match2DShowers(fcnLabel, tjs, tpcid, prt);
     SaveAllCots(tjs, "M2DS");
     // Reconcile pfp and shower assns before the Parent search
     Reconcile3D(fcnLabel, tjs, tpcid, false, prt);
     SaveAllCots(tjs, "R3D");
 //    std::cout<<"Add function to check for neutrino vertex inside showers\n";
     for(auto& ss3 : tjs.showers) {
       if(ss3.ID == 0) continue;
       if(ss3.TPCID != tpcid) continue;
       FindParent(fcnLabel, tjs, ss3, prt);
     } // ss3
     // Reconcile pfp and shower assns again
     Reconcile3D(fcnLabel, tjs, tpcid, true, prt);
     if(prt) Print2DShowers("M2DS", tjs, USHRT_MAX, false);
     SaveAllCots(tjs, "FP");
     
     // kill low energy 3D showers
     for(auto& ss3 : tjs.showers) {
       if(ss3.ID == 0) continue;
       if(ss3.TPCID != tpcid) continue;
       bool killMe = (ShowerEnergy(ss3) < tjs.ShowerTag[3]);
       if(killMe) MakeShowerObsolete(fcnLabel, tjs, ss3, prt);
     } // ss3
     
     // kill 2D showers that are either below threshold or have only one tj
     for(auto& ss : tjs.cots) {
       if(ss.ID == 0) continue;
       if(ss.SS3ID > 0) continue;
       bool killMe = (ss.TjIDs.size() == 1 || ss.Energy < tjs.ShowerTag[3]);
       // too small aspect ratio -> something track-like with some shower-like fuzz
       if(ss.AspectRatio < tjs.ShowerTag[10]) killMe = true;
       if(killMe) MakeShowerObsolete(fcnLabel, tjs, ss, prt);
     } // ss
      
     unsigned short nNewShowers = 0;
     for(auto& ss : tjs.cots) {
       if(ss.ID == 0) continue;
       if(ss.TjIDs.empty()) continue;
       geo::PlaneID planeID = DecodeCTP(ss.CTP);
       if(planeID.Cryostat != tpcid.Cryostat) continue;
       if(planeID.TPC != tpcid.TPC) continue;
       SaveTjInfo(tjs, ss, "Done");
      ++nNewShowers;
     } // ss
 
     // temp for testing with MC
     if(!tjs.MCPartList.empty()) {
       // get some truth information
       MCParticleListUtils mcpu{tjs};
       for(unsigned short plane = 0; plane < TPC.Nplanes(); ++plane) {
         CTP_t inCTP = EncodeCTP(tpcid.Cryostat, tpcid.TPC, plane);
         int truElectronTID = mcpu.PrimaryElectronTjID(inCTP);
         std::cout<<"Plane "<<plane<<" trueElectron T"<<truElectronTID;
         for(auto& ss : tjs.cots) {
           if(ss.ID == 0) continue;
           if(ss.CTP != inCTP) continue;
           if(std::find(ss.TjIDs.begin(), ss.TjIDs.end(), truElectronTID) == ss.TjIDs.end()) continue;
           std::cout<<" in 2S"<<ss.ID<<" with Parent T"<<ss.ParentID;
           if(ss.SS3ID > 0) std::cout<<" -> 3S"<<ss.SS3ID;
         } // ss
         std::cout<<"\n";
       } // plane
       Point3_t truStart;
       Vector3_t truDir;
       float truE;
       if(mcpu.PrimaryElectronStart(truStart, truDir, truE)) {
         // assume that the highest energy shower is from the primary electron
         float big = 0;
         int imBig = 0;
         for(auto& ss3 : tjs.showers) {
           float energy = ShowerEnergy(ss3);
           if(energy < big) continue;
           big = energy;
           imBig = ss3.ID;
         } // ss3
         if(imBig > 0) {
           auto& ss3 = tjs.showers[imBig - 1];
           float shMaxSep = PosSep(truStart, ss3.ChgPos);
           float dang = acos(DotProd(truDir, ss3.Dir));
           float energy = ShowerEnergy(ss3);
           std::cout<<"Big 3S"<<ss3.ID<<" E "<<(int)energy<<" truE "<<(int)truE;
           std::cout<<" truStart "<<std::fixed<<std::setprecision(1)<<truStart[0]<<" "<<truStart[1]<<" "<<truStart[2];
           std::cout<<" tru P"<<mcpu.PrimaryElectronPFPID(tpcid);
           std::cout<<" rec P"<<ss3.ParentID;
           std::cout<<" shMax "<<(int)shMaxSep<<" cm.";
           std::cout<<" dang "<<std::fixed<<std::setprecision(2)<<dang<<"\n";
         } // imBig > 0
       } // PrimaryElectronStart success
     } // !tjs.MCPartList.empty()
 
 //    if(prt) Print2DShowers("FSo", tjs, USHRT_MAX, false);
     
     return (nNewShowers > 0);
     
   } // FindShowers3D

bool tca::FindShowerStart	(	TjStuff &	tjs,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 45 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::ShowerStruct3D::ChgPos, tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, tca::ShowerStruct3D::Dir, DotProd(), tca::ShowerStruct3D::End, tca::ShowerStruct3D::ID, tca::ShowerStruct3D::Len, MakeBareTP(), tca::ShowerStruct3D::OpenAngle, PosSep(), ReverseShower(), ss, tca::ShowerStruct3D::Start, tca::TjStuff::vtx3, tca::ShowerStruct3D::Vx3ID, and tca::TjStuff::WirePitch.

   {
     // The shower ChgPos and Dir were found by the calling function but Dir 
     // may be inconsistent with the 2D shower directions
     if(ss3.ID == 0) return false;
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"Inside FSS: 3S"<<ss3.ID<<" ->";
       for(auto cid : ss3.CotIDs) myprt<<" 2S"<<cid;
       myprt<<" Vx 3V"<<ss3.Vx3ID;
     } // prt
     
     // find a parent Tj in the list of 2D showers that is the farthest away from the
     // shower center
     unsigned short useParentCID = 0;
     float maxParentSep = 0;
     unsigned short usePtSepCID = 0;
     float maxPtSep = 0;
     // assume that the 2D shower direction is consistent with the 3D shower direction. This
     // variable is only used when no parent exists
     bool dirOK = true;
     for(auto cid : ss3.CotIDs) {
       auto& ss = tjs.cots[cid - 1];
       // Find the position, direction and projection in this plane
       auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
       auto chgCtrTP = MakeBareTP(tjs, ss3.ChgPos, ss3.Dir, stj.CTP);
       // projection too small in this view?
       if(chgCtrTP.Delta < 0.5) continue;
       auto& startTP = stj.Pts[0];
       float sep = PosSep(startTP.Pos, chgCtrTP.Pos);
       if(ss.ParentID > 0) {
         if(sep > maxParentSep) {
           maxParentSep = sep;
           useParentCID = cid;
         }
       } else if(sep > maxPtSep) {
         // no parent exists.
         maxPtSep = sep;
         usePtSepCID = cid;
         float costh = DotProd(chgCtrTP.Dir, startTP.Dir);
         if(costh < 0) dirOK = false;
       }
     } // ci
     if(useParentCID == 0 && usePtSepCID == 0) return false;
     
     unsigned short useCID = useParentCID;
     if(useCID == 0) {
       useCID = usePtSepCID;
       if(!dirOK) ReverseShower("FSS", tjs, useCID, prt);
     }
 
     // now define the start and length
     auto& ss = tjs.cots[useCID - 1];
     auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
 
     auto chgCtrTP = MakeBareTP(tjs, ss3.ChgPos, ss3.Dir, stj.CTP);
     if(ss3.Vx3ID > 0) {
       auto& vx3 = tjs.vtx3[ss3.Vx3ID - 1];
       ss3.Start[0] = vx3.X;
       ss3.Start[1] = vx3.Y;
       ss3.Start[2] = vx3.Z;
     } else {
       // no start vertex
       auto& startTP = stj.Pts[0];
       // The 2D separation btw the shower start and the shower center, converted
       // to the 3D separation
 //      std::cout<<"useCI "<<useCID<<" sep "<<PosSep(startTP.Pos, stj.Pts[1].Pos)<<" projInPln "<<chgCtrTP.Delta<<"\n";
       float sep = tjs.WirePitch * PosSep(startTP.Pos, stj.Pts[1].Pos) / chgCtrTP.Delta;
       // set the start position
       for(unsigned short xyz = 0; xyz < 3; ++xyz) ss3.Start[xyz] = ss3.ChgPos[xyz] - sep * ss3.Dir[xyz];
     }
     // now do the end position
     auto& endTP = stj.Pts[2];
     float sep = tjs.WirePitch * PosSep(endTP.Pos, chgCtrTP.Pos) / chgCtrTP.Delta;
     for(unsigned short xyz = 0; xyz < 3; ++xyz) ss3.End[xyz] = ss3.ChgPos[xyz] + sep * ss3.Dir[xyz];
     ss3.Len = PosSep(ss3.Start, ss3.End);
     auto& startTP = stj.Pts[0];
     sep = PosSep(startTP.Pos, endTP.Pos);
     ss3.OpenAngle = (endTP.DeltaRMS - startTP.DeltaRMS) / sep;
     ss3.OpenAngle /= chgCtrTP.Delta;
     return true;
     
   } // FindShowerStart

void tca::FindStartChg	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		int	cotID,
		bool	prt
	)

Definition at line 4142 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::ShowerStruct::AspectRatio, tca::TjStuff::cots, tca::ShowerStruct::DirectionFOM, tca::ShowerStruct::ID, tca::ShowerStruct::ParentID, tca::TjStuff::ShowerTag, tca::ShowerStruct::ShowerTjID, ss, StartChgVec(), and tca::ShowerStruct::TjIDs.

   {
     // Finds the charge at the start of a shower and puts it in AveChg of the first
     // point of the shower Tj. This is only done when there is no parent.
     if(cotID > (int)tjs.cots.size()) return;
     
     ShowerStruct& ss = tjs.cots[cotID - 1];
     if(ss.ID == 0) return;
     if(ss.TjIDs.empty()) return;
     if(ss.ShowerTjID == 0) return;
     if(ss.ParentID > 0) return;
     auto& stp0 = tjs.allTraj[ss.ShowerTjID - 1].Pts[0];
     
     std::string fcnLabel = inFcnLabel + ".FSC";
     
     stp0.AveChg = 0;
     
     if(ss.AspectRatio > tjs.ShowerTag[10] || ss.DirectionFOM > tjs.ShowerTag[9]) {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Not possible due to poor AspectRatio "<<ss.AspectRatio<<" or ss.DirectionFOM "<<ss.DirectionFOM;
       return;
     }
 
     // Create and fill a vector of the charge at the beginning of the shower in 1 WSE bins
     auto schg = StartChgVec(tjs, cotID, prt);
     if(schg.empty()) return;
 
     // Look for two consecutive charge entries. Use the second one
     // for the initial guess at the charge
     unsigned short startPt = USHRT_MAX;
     float chg = 0;
     for(unsigned short ii = 0; ii < schg.size() - 1; ++ii) {
       if(schg[ii] > 0 && schg[ii + 1] > 0) {
         startPt = ii + 1;
         chg = schg[ii + 1];
         break;
       }
     }
     if(startPt == USHRT_MAX) return;
     
     // get an initial average and rms using all the points
     float ave = 0;
     float rms = 0;
     float cnt = 0;
     for(unsigned short ii = startPt; ii < schg.size() - 1; ++ii) {
       ave += schg[ii];
       rms += schg[ii] * schg[ii];
       ++cnt;
     } // ii
     ave /= cnt;
     rms = rms - cnt * ave * ave;
     if(rms < 0) return;
     rms = sqrt(rms / (cnt - 1));
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<fcnLabel<<" schg:";
       for(unsigned short ii = 0; ii < 20; ++ii) myprt<<" "<<(int)schg[ii];
       myprt<<"\n First guess at the charge "<<(int)chg<<" average charge of all bins "<<(int)ave<<" rms "<<(int)rms;
     }
     
     // initial guess at the charge rms
     rms = 0.8 * chg;
     
     // Correct for dead wires in this region - maybe later...
 //    unsigned short nDeadWires = DeadWireCount();
     
     unsigned short nBinsAverage = 5;
     double maxChg = 2 * chg;
     for(unsigned short nit = 0; nit < 2; ++nit) {
       double sum = 0;
       double sum2 = 0;
       double cnt = 0;
       for(unsigned short ii = startPt; ii < schg.size() - 1; ++ii) {
         // break if we find 2 consecutive high charge points
         if(schg[ii] > maxChg && schg[ii + 1] > maxChg) break;
         // or two zeros
         if(schg[ii] == 0 && schg[ii + 1] == 0) break;
         if(schg[ii] > maxChg) continue;
         sum += schg[ii];
         sum2 += schg[ii] * schg[ii];
         ++cnt;
         if(cnt == nBinsAverage) break;
       } // ii
       // check for a failure
       if(cnt < 3) {
         if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" nit "<<nit<<" cnt "<<cnt<<" is too low. sum "<<(int)sum<<" maxChg "<<(int)maxChg;
         // try to recover. Pick the next point
         ++startPt;
         chg = schg[startPt];
         maxChg = 2 * chg;
         continue;
       }
       // convert sum to the average charge
       chg = sum / cnt;
       double arg = sum2 - cnt * chg * chg;
       if(arg < 0) break;
       rms = sqrt(arg / (cnt - 1));
       // don't allow the rms to get crazy
       double maxrms = 0.5 * sum;
       if(rms > maxrms) rms = maxrms;
       maxChg = chg + 2 * rms;
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" nit "<<nit<<" cnt "<<cnt<<" chg "<<(int)chg<<" rms "<<(int)rms<<" maxChg "<<(int)maxChg<<" nBinsAverage "<<nBinsAverage;
       nBinsAverage = 20;
     } // nit
     
     stp0.AveChg = chg;
     
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 2S"<<cotID<<" Starting charge "<<(int)stp0.AveChg<<" startPt  "<<startPt;
     
   } // FindStartChg

void tca::FindXMatches	(	TjStuff &	tjs,
		unsigned short	numPlanes,
		short	maxScore,
		std::vector< MatchStruct > &	matVec,
		bool	prt
	)

Definition at line 1326 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, detinfo::DetectorProperties::ConvertXToTicks(), tca::MatchStruct::Count, geo::CryostatID::Cryostat, tca::TrajPoint::CTP, DecodeCTP(), DeltaAngle(), tca::TjStuff::detprop, tca::TrajPoint3::Dir, EncodeCTP(), tca::TjStuff::geom, tca::SortEntry::index, MakeTp3(), tca::TjStuff::mallTraj, tca::TjStuff::Match3DCuts, tca::TjStuff::MaxPos0, tca::TjStuff::NumPlanes, geo::PlaneID::Plane, tca::TrajPoint::Pos, tca::TrajPoint3::Pos, SignalAtTp(), tca::MatchStruct::TjIDs, geo::TPCID::TPC, tca::TjStuff::UnitsPerTick, valDecreasings(), and geo::GeometryCore::WireCoordinate().

Referenced by FindPFParticles().

   {
     // This function matches trajectory points in tjs.mallTraj using the X position. These points should
     // have already been sorted by increasing X by the function that created mallTraj. 
     
     if(tjs.mallTraj.empty()) return;
     if(tjs.Match3DCuts[0] <= 0) return;
     if(numPlanes < 2) return;
     
     int cstat = DecodeCTP(tjs.mallTraj[0].ctp).Cryostat;
     int tpc = DecodeCTP(tjs.mallTraj[0].ctp).TPC;
     constexpr float twopi = 2 * M_PI;
     constexpr float piOver2 = M_PI / 2;
     
     // create a temp vector to check for duplicates
     auto inMatVec = matVec;
     std::vector<MatchStruct> temp;
     
     // the minimum number of points for matching
     unsigned short minPts = 2;
     // override this with the user minimum for 2-plane matches
     if(numPlanes == 2) minPts = tjs.Match3DCuts[2];
     
     // max number of match combos left
     unsigned int nAvailable = 0;
     if(matVec.size() < tjs.Match3DCuts[4]) nAvailable = tjs.Match3DCuts[4] - matVec.size();
     if(nAvailable == 0 || nAvailable > tjs.Match3DCuts[4]) return;
     
     // these cuts presume that the resolution in X is better than it is in Y and Z
     float xcut = tjs.Match3DCuts[0];
     double yzcut = 1.5 * xcut;
     for(unsigned int ipt = 0; ipt < tjs.mallTraj.size() - 1; ++ipt) {
       auto& iTjPt = tjs.mallTraj[ipt];
       // length cut
       if(iTjPt.npts < minPts) continue;
       // look for matches using Tjs that have the correct score
       if(iTjPt.score < 0 || iTjPt.score > maxScore) continue;
       auto& itp = tjs.allTraj[iTjPt.id - 1].Pts[iTjPt.ipt];
       unsigned short iplane = DecodeCTP(itp.CTP).Plane;
       for(unsigned int jpt = ipt + 1; jpt < tjs.mallTraj.size() - 1; ++jpt) {
         auto& jTjPt = tjs.mallTraj[jpt];
         // ensure that the planes are different
         if(jTjPt.ctp == iTjPt.ctp) continue;
         // length cut
         if(jTjPt.npts < minPts) continue;
         // score cut
         if(jTjPt.score < 0 || jTjPt.score > maxScore) continue;
         // check for x range overlap. We know that jTjPt.xlo is >= iTjPt.xlo because of the sort
         if(jTjPt.xlo > iTjPt.xhi) continue;
         // break out if the x range difference becomes large (5 cm)
         if(jTjPt.xlo > iTjPt.xhi + 5) break;
         auto& jtp = tjs.allTraj[jTjPt.id - 1].Pts[jTjPt.ipt];
         unsigned short jplane = DecodeCTP(jtp.CTP).Plane;
         TrajPoint3 tp3;
         if(!MakeTp3(tjs, itp, jtp, tp3, false)) continue;
         // count weight is one for a two-plane match
         float cntWght = 1;
         if(numPlanes == 3) {
           // numPlanes == 3
           for(unsigned int kpt = jpt + 1; kpt < tjs.mallTraj.size(); ++kpt) {
             auto& kTjPt = tjs.mallTraj[kpt];
             // ensure that the planes are different
             if(kTjPt.ctp == iTjPt.ctp || kTjPt.ctp == jTjPt.ctp) continue;
             if(kTjPt.score < 0 || kTjPt.score > maxScore) continue;
             if(kTjPt.xlo > iTjPt.xhi) continue;
             // break out if the x range difference becomes large
             if(kTjPt.xlo > iTjPt.xhi + 5) break;
             auto& ktp = tjs.allTraj[kTjPt.id - 1].Pts[kTjPt.ipt];
             unsigned short kplane = DecodeCTP(ktp.CTP).Plane;
             TrajPoint3 iktp3;
             if(!MakeTp3(tjs, itp, ktp, iktp3, false)) continue;
             if(std::abs(tp3.Pos[1] - iktp3.Pos[1]) > yzcut) continue;
             if(std::abs(tp3.Pos[2] - iktp3.Pos[2]) > yzcut) continue;
             float dang = 0;
             if(tjs.Match3DCuts[1] > 0) {
               dang = std::abs(DeltaAngle(tp3.Dir, iktp3.Dir));
               while(dang >  M_PI) dang -= twopi;
               if(dang >  piOver2) dang = M_PI - dang;
               float mcsmom = tjs.allTraj[iTjPt.id - 1].MCSMom + tjs.allTraj[jTjPt.id - 1].MCSMom + tjs.allTraj[kTjPt.id - 1].MCSMom;
               mcsmom /= 3;
               if(mcsmom > 150 && dang > tjs.Match3DCuts[1]) continue;
             }
             // we have a match.
             // Just fill temp. See if the Tj IDs are in the match list.
             // first check the input matVec
             bool gotit = false;
             for(auto& ms : inMatVec) {
               if(ms.TjIDs.size() != 3) continue;
               if(iTjPt.id == ms.TjIDs[iplane] && jTjPt.id == ms.TjIDs[jplane] && kTjPt.id == ms.TjIDs[kplane]) {
                 gotit = true;
                 break;
               } 
             } // ms
             if(gotit) continue;
             // Triple match count = 2 de-weighted by delta angle
             cntWght = 2 - dang;
             if(cntWght <= 0) continue;
             // next check the temp vector
             unsigned short indx = 0;
             for(indx = 0; indx < temp.size(); ++indx) {
               auto& ms = temp[indx];
               if(iTjPt.id != ms.TjIDs[iplane]) continue;
               if(jTjPt.id != ms.TjIDs[jplane]) continue;
               if(kTjPt.id != ms.TjIDs[kplane]) continue;
               ms.Count += cntWght;
               break;
             } // indx
             if(indx == temp.size()) {
               // not found in the match vector so add it
               MatchStruct ms;
               ms.TjIDs.resize(3);
               // Note that we can put the Tj IDs in plane-order since there are 3 of them
               // This is not the case when there are 2 planes
               ms.TjIDs[iplane] = iTjPt.id;
               ms.TjIDs[jplane] = jTjPt.id;
               ms.TjIDs[kplane] = kTjPt.id;
               ms.Count = cntWght;
               temp.push_back(ms);
               // give up if there are too many
               if(temp.size() > nAvailable) break;
             } // not found in the list
           } // kpt
           // numPlanes == 3
         } else {
           // 2-plane TPC or 2-plane match in a 3-plane TPC
           if(tjs.NumPlanes == 3) {
             // See if there is a signal at this point.
             unsigned short kplane = 3 - iplane - jplane;
             float fkwire = tjs.geom->WireCoordinate(tp3.Pos[1], tp3.Pos[2], kplane, tpc, cstat);
             if(fkwire < 0 || fkwire > tjs.MaxPos0[kplane]) continue;
             TrajPoint tpk;
             tpk.CTP = EncodeCTP(cstat, tpc, kplane);
             tpk.Pos[0] = fkwire;
             float xp = 0.5 * (iTjPt.xlo + iTjPt.xhi);
             tpk.Pos[1] = tjs.detprop->ConvertXToTicks(xp, kplane, tpc, cstat) * tjs.UnitsPerTick;
             // Note that SignalAtTp assumes that a signal exists if the wire is dead
             if(!SignalAtTp(tjs, tpk)) continue;
           }
           // Just fill temp. See if the Tj IDs are in the match list
           bool gotit = false;
           for(auto& ms : inMatVec) {
             if(std::find(ms.TjIDs.begin(), ms.TjIDs.end(), iTjPt.id) != ms.TjIDs.end() && 
                std::find(ms.TjIDs.begin(), ms.TjIDs.end(), jTjPt.id) != ms.TjIDs.end()) {
               gotit = true;
               break;
             } 
           } // ms
           if(gotit) continue;
           unsigned short indx = 0;
           for(indx = 0; indx < temp.size(); ++indx) {
             auto& ms = temp[indx];
             if(std::find(ms.TjIDs.begin(), ms.TjIDs.end(), iTjPt.id) != ms.TjIDs.end() &&
                std::find(ms.TjIDs.begin(), ms.TjIDs.end(), jTjPt.id) != ms.TjIDs.end()) break;
           } // indx
           if(indx == temp.size()) {
             MatchStruct ms;
             ms.TjIDs.resize(2);
             // Here we put the Tj IDs in no particular order
             ms.TjIDs[0] = iTjPt.id;
             ms.TjIDs[1] = jTjPt.id;
             ms.Count = 1;
             temp.push_back(ms);
           } // not found in the list
           else {
             ++temp[indx].Count;
           }
         } // 2-plane TPC
         // give up if there are too many
         if(temp.size() > nAvailable) break;
       } // jpt
       // give up if there are too many
       if(temp.size() > nAvailable) break;
     } // ipt
     
     // temp
     
     if(temp.empty()) return;
 
     if(temp.size() == 1) {
       matVec.push_back(temp[0]);
     } else {
       // multiple entries - need to sort by decreasing match count
       std::vector<SortEntry> sortVec(temp.size());
       for(unsigned int indx = 0; indx < sortVec.size(); ++indx) {
         sortVec[indx].index = indx;
         sortVec[indx].val = temp[indx].Count;
       } // indx
       std::sort(sortVec.begin(), sortVec.end(), valDecreasings);
       // Re-order temp
       auto tmpVec = temp;
       for(unsigned int ii = 0; ii < sortVec.size(); ++ii) temp[ii] = tmpVec[sortVec[ii].index];
       // insert it after the triple matches
       matVec.insert(matVec.end(), temp.begin(), temp.end());
     } // temp size > 1
     
     if(prt) mf::LogVerbatim("TC")<<"FindXMatches: Found "<<temp.size()<<" matches";
     
   } // FindXMatches

void tca::Finish3DShowers ( TjStuff & tjs )

Definition at line 131 of file TCShower.cxx.

References tca::TjStuff::allTraj, ChkAssns(), tca::TjStuff::cots, CreatePFP(), DecodeCTP(), evd::details::end(), GetAssns(), kKilled, kUsedHits, tca::TjStuff::pfps, geo::PlaneID::Plane, PutTrajHitsInVector(), tca::TjStuff::showers, ss, tca::TjStuff::TPCID, TransferTjHits(), tca::TjStuff::vtx, tca::TjStuff::vtx3, and tca::Trajectory::VtxID.

Referenced by tca::TrajClusterAlg::MakeAllTrajClusters().

   {
     // Finish defining the showers, create a companion PFParticle for each one.
     // Note to the reader: This code doesn't use MakeVertexObsolete to kill vertices using the assumption
     // that Finish3DShowers is being called after reconstruction is complete, in which case there is no
     // need to re-calculate the 2D and 3D vertex score which could potentially screw up the decisions that have
     // already been made.
     
     // See if any need to be finished
     bool noShowers = true;
     for(auto& ss3 : tjs.showers) {
       if(ss3.ID == 0) continue;
       noShowers = false;
     }
     if(noShowers) return;
     
     ChkAssns("Fin3D", tjs);
     
     // create a pfp and define the mother-daughter relationship. At this point, the shower parent PFP (if
     // one exists) is a track-like pfp that might be the daughter of another pfp, e.g. the neutrino. This
     // association is changed from shower ParentID -> parent pfp, to shower PFP -> parent pfp
     for(auto& ss3 : tjs.showers) {
       if(ss3.ID == 0) continue;
       if(ss3.Cheat) continue;
       if(ss3.PFPIndex != USHRT_MAX) {
         std::cout<<"Finish3DShowers 3S"<<ss3.ID<<" already has a pfp associated with it...\n";
         continue;
       }
       auto showerPFP = CreatePFP(tjs, ss3.TPCID);
       showerPFP.TjIDs.resize(ss3.CotIDs.size());
       for(unsigned short ii = 0; ii < ss3.CotIDs.size(); ++ii) {
         unsigned short cid = ss3.CotIDs[ii];
         if(cid == 0 || cid > tjs.cots.size()) {
           std::cout<<"Finish3DShowers 3S"<<ss3.ID<<" has an invalid cots ID"<<cid<<"\n";
           return;
         }
         auto& ss = tjs.cots[cid - 1];
         auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
         showerPFP.TjIDs[ii] = stj.ID;
       } // ci
       showerPFP.PDGCode = 1111;
       showerPFP.XYZ[0] = ss3.Start;
       showerPFP.Dir[0] = ss3.Dir;
       showerPFP.DirErr[0] = ss3.DirErr;
       showerPFP.Vx3ID[0] = ss3.Vx3ID;
       showerPFP.XYZ[1] = ss3.End;
       showerPFP.Dir[1] = ss3.Dir;
       // dEdx is indexed by plane for pfps and by 2D shower index for 3D showers
       for(auto cid : ss3.CotIDs) {
         auto& ss = tjs.cots[cid - 1];
         unsigned short plane = DecodeCTP(ss.CTP).Plane;
         auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
         showerPFP.dEdx[0][plane] = stj.dEdx[0];
         showerPFP.dEdxErr[0][plane] = 0.3 * stj.dEdx[0];
       } // ci
       ss3.PFPIndex = tjs.pfps.size();
       if(ss3.ParentID > 0) {
         // see if this is a daughter
         auto& dtrPFP = tjs.pfps[ss3.ParentID - 1];
         if(dtrPFP.ParentID > 0) {
           // Transfer the daughter <-> parent assn
           auto& parPFP = tjs.pfps[dtrPFP.ParentID - 1];
           showerPFP.ParentID = parPFP.ID;
           std::replace(parPFP.DtrIDs.begin(), parPFP.DtrIDs.end(), dtrPFP.ID, showerPFP.ID);
           dtrPFP.ParentID = 0;
         } // dtrPFP.ParentID > 0
       } // ss3.ParentID > 0
       tjs.pfps.push_back(showerPFP);
     } // ss3
 
     // Transfer Tj hits from InShower Tjs to the shower Tj. This kills the InShower Tjs but doesn't consider how
     // this action affects vertices
     if(!TransferTjHits(tjs, false)) return;
     
     // Associate shower Tj hits with 3D showers
     for(auto& ss3 : tjs.showers) {
       if(ss3.ID == 0) continue;
       for(unsigned short ii = 0; ii < ss3.CotIDs.size(); ++ii) {
         unsigned short cid = ss3.CotIDs[ii];
         auto& ss = tjs.cots[cid - 1];
         for(auto tjid : ss.TjIDs) {
           Trajectory& tj = tjs.allTraj[tjid - 1];
           auto tjHits = PutTrajHitsInVector(tj, kUsedHits);
           ss3.Hits.insert(ss3.Hits.end(), tjHits.begin(), tjHits.end());
           // kill vertices associated with the Tj unless it is the neutrino primary vtx
           for(unsigned short end = 0; end < 2; ++end) {
             if(tj.VtxID[end] == 0) continue;
             auto& vx2 = tjs.vtx[tj.VtxID[end] - 1];
             if(vx2.Vx3ID <= 0) {
               // This is a 2D vertex that is not matched in 3D. Kill it. Shouldn't need to
               // use MakeVertexObsolete here...
               vx2.ID = 0;
               continue;
             }
             // vx2 is matched in 3D. Kill it if it is NOT the neutrino primary
             auto& vx3 = tjs.vtx3[vx2.Vx3ID - 1];
             if(vx3.Neutrino) continue;
             vx3.ID = 0;
           } // end
         } // tjid
       } // ii
     } // ss3
     
     // kill PFParticles
     if(!tjs.pfps.empty()) {
       for(auto& pfp : tjs.pfps) {
         if(pfp.ID == 0) continue;
         if(pfp.TjIDs.empty()) continue;
         unsigned short ndead = 0;
         for(auto tjid : pfp.TjIDs) {
           auto& tj = tjs.allTraj[tjid - 1];
           if(tj.AlgMod[kKilled]) ++ndead;
         } // tjid
         if(ndead == 0) continue;
         if(ndead != pfp.TjIDs.size()) {
           std::cout<<"Finish3DShowers: Not all Tjs in P"<<pfp.ID<<" are killed";
           for(auto tid : pfp.TjIDs) {
             auto& tj = tjs.allTraj[tid - 1];
             std::cout<<" T"<<tid<<" dead? "<<tj.AlgMod[kKilled];
           }
           std::cout<<"\n";
         } // ndead
         pfp.ID = 0;
       } // pfp
     } // pfps not empty
     
     // kill orphan 2D vertices
     for(auto& vx2 : tjs.vtx) {
       if(vx2.ID == 0) continue;
       auto vxtjs = GetAssns(tjs, "2V", vx2.ID, "T");
       if(vxtjs.empty()) vx2.ID = 0;
     } // vx2
     
     // kill orphan vertices
     for(auto& vx3 : tjs.vtx3) {
       if(vx3.ID == 0) continue;
       auto vxtjs = GetAssns(tjs, "3V", vx3.ID, "T");
       if(vxtjs.empty()) {
         vx3.ID = 0;
         continue;
       }
     } // vx3
     
     // check
     for(auto& pfp : tjs.pfps) {
       if(pfp.ID == 0) continue;
       if(pfp.PDGCode != 1111) continue;
       if(pfp.Vx3ID[0] > 0 && tjs.vtx3[pfp.Vx3ID[0] - 1].ID == 0) {
         std::cout<<"Finish3DShowers shower P"<<pfp.ID<<" has Vx3ID[0] = "<<pfp.Vx3ID[0]<<" but the vertex is killed\n";
       } // Vx3 check
     } // pfp
 
   } // Finish3DShowers

void tca::Fit3D	(	unsigned short	mode,
		Point3_t	point,
		Vector3_t	dir,
		Point3_t &	fitPos,
		Vector3_t &	fitDir
	)

Definition at line 899 of file PFPUtils.cxx.

References SetMag().

Referenced by FindCompleteness().

   {
     // initialize, accumulate and fit the points. The code to fit the direction using the positions
     // of the points is commented out and replaced with a simple average of the directions of the points
     
     // 3D fit sum variables
     static double fSum, fSumx, fSumy, fSumz;
 //    static double fSumx2, fSumy2, fSumz2, fSumxz, fSumyz;
     // average the direction vectors
     static double fSumDir0, fSumDir1, fSumDir2;
 
     if(mode == 0) {
       fSum = 0; fSumx = 0; fSumy = 0; fSumz = 0; 
 //      fSumx2 = 0; fSumy2 = 0; fSumz2 = 0; fSumxz = 0; fSumyz = 0;
       fSumDir0 = 0; fSumDir1 = 0; fSumDir2 = 0;
       return;
     }
     // accumulate
     if(mode == 1) {
       fSum += 1;
       fSumx += point[0];
       fSumy += point[1];
       fSumz += point[2];
 /*
       fSumx2 += point[0] * point[0];
       fSumy2 += point[1] * point[1];
       fSumz2 += point[2] * point[2];
       fSumxz += point[0] * point[2];
       fSumyz += point[1] * point[2];
 */
       fSumDir0 += dir[0];
       fSumDir1 += dir[1];
       fSumDir2 += dir[2];
       return;
     }
     
     if(fSum < 2) return;
     // just use the average for the position
     fitPos[0] = fSumx / fSum;
     fitPos[1] = fSumy / fSum;
     fitPos[2] = fSumz / fSum;
     // and for the direction
     fitDir = {{fSumDir0, fSumDir1, fSumDir2}};
     SetMag(fitDir, 1);
 /*
     std::cout<<"fitDir"<<std::fixed<<std::setprecision(2);
     std::cout<<" "<<fitDir[0]<<" "<<fitDir[1]<<" "<<fitDir[2];
     
     // calculate the direction
     double delta = fSum * fSumz2 - fSumz * fSumz;
     if(delta == 0) return;
     double Bx = (fSumxz * fSum - fSumz * fSumx) / delta;
     double By = (fSumyz * fSum - fSumz * fSumy) / delta;
     double norm = sqrt(1 + Bx * Bx + By * By);
     Vector3_t tmpDir;
     tmpDir[0] = Bx / norm;
     tmpDir[1] = By / norm;
     tmpDir[2] = 1 / norm;
     std::cout<<" tmpDir"<<std::fixed<<std::setprecision(2);
     std::cout<<" "<<tmpDir[0]<<" "<<tmpDir[1]<<" "<<tmpDir[2]<<"\n";
 */
   } // Fit3D

bool tca::FitTp3	(	TjStuff &	tjs,
		TrajPoint3 &	tp3,
		const std::vector< Tj2Pt > &	tj2pts
	)

Definition at line 502 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, detinfo::DetectorProperties::ConvertTicksToX(), geo::CryostatID::Cryostat, DecodeCTP(), tca::TjStuff::detprop, tca::TrajPoint3::Dir, tca::TjStuff::geom, norm, geo::PlaneID::Plane, tca::TrajPoint3::Pos, PosSep(), PosSep2(), sw, geo::TPCID::TPC, tca::TjStuff::UnitsPerTick, w, geo::GeometryCore::WireCoordinate(), and x.

   {
     // Fits the vector of Tj2Pts points and puts the results into tp3. This code is adapted
     // from TrackLineFitAlg: SVD fit adapted from $ROOTSYS/tutorials/matrix/solveLinear.C
     // Fit equation is w = A(X)v, where w is a vector of hit wires, A is
     // a matrix to calculate a track projected to a point at X, and v is
     // a vector (Yo, Zo, dY/dX, dZ/dX).
     if(tj2pts.size() < 4) return false;
 
     const unsigned int nvars = 4;
     unsigned int npts = tj2pts.size();
     TMatrixD A(npts, nvars);
     // vector holding the Wire number
     TVectorD w(npts);
     
     double x0 = 0;
     for(auto& tj2pt : tj2pts) {
       auto& tp = tjs.allTraj[tj2pt.id - 1].Pts[tj2pt.ipt];
       geo::PlaneID planeID = DecodeCTP(tp.CTP);
       x0 += tjs.detprop->ConvertTicksToX(tp.Pos[1]/tjs.UnitsPerTick, planeID);
     }
     x0 /= (double)tj2pts.size();
     
     unsigned short ninpl[3] = {0};
     unsigned short nok = 0;
     double wght = 1;
     for(unsigned short ipt = 0; ipt < tj2pts.size(); ++ipt) {
       auto& tj2pt = tj2pts[ipt];
       auto& tp = tjs.allTraj[tj2pt.id - 1].Pts[tj2pt.ipt];
       geo::PlaneID planeID = DecodeCTP(tp.CTP);
       unsigned int cstat = planeID.Cryostat;
       unsigned int tpc = planeID.TPC;
       unsigned int plane = planeID.Plane;
       // get the wire plane offset
       double off = tjs.geom->WireCoordinate(0, 0, plane, tpc, cstat);
       // get the "cosine-like" component
       double cw = tjs.geom->WireCoordinate(1, 0, plane, tpc, cstat) - off;
       // the "sine-like" component
       double sw = tjs.geom->WireCoordinate(0, 1, plane, tpc, cstat) - off;
       double x = tjs.detprop->ConvertTicksToX(tp.Pos[1]/tjs.UnitsPerTick, planeID) - x0;
       A[ipt][0] = wght * cw;
       A[ipt][1] = wght * sw;
       A[ipt][2] = wght * cw * x;
       A[ipt][3] = wght * sw * x;
       w[ipt] = wght * (tp.Pos[0] - off);
       ++ninpl[plane];
       // need at least two points in a plane
       if(ninpl[plane] == 2) ++nok;
     } // ipt
 
     // need at least 2 planes with at least two points
     if(nok < 2) return false;
     
     TDecompSVD svd(A);
     bool ok;
     TVectorD tVec = svd.Solve(w, ok);
     
     // Calculate Chi/DOF here
 //    tp3.ChiDOF = 1;
     
     Vector3_t fitDir;
     double norm = sqrt(1 + tVec[2] * tVec[2] + tVec[3] * tVec[3]);
     fitDir[0] = 1 / norm;
     fitDir[1] = tVec[2] / norm;
     fitDir[2] = tVec[3] / norm;
     
     Point3_t fitPos;
     fitPos[0] = x0;
     fitPos[1] = tVec[0];
     fitPos[2] = tVec[1];
     // move it to the same Z position as tp3.Pos
     if(tp3.Pos[2] != 0) {
       double dz = tp3.Pos[2] - fitPos[2];
       fitPos[0] += dz * fitDir[0] / fitDir[2];
       fitPos[1] += dz * fitDir[1] / fitDir[2];
       fitPos[2] += dz;
     }
     
     if(PosSep2(fitPos, tp3.Pos) > 5) {
       std::cout<<"Crazy fitPos "<<PosSep(fitPos, tp3.Pos)<<"\n";
 //      tp3.ChiDOF = 10;
       return false;
     }
     
     tp3.Pos = fitPos;
     tp3.Dir = fitDir;
 
     return true;
   } // FitTp3

bool tca::FitTp3s	(	TjStuff &	tjs,
		const std::vector< TrajPoint3 > &	tp3s,
		Point3_t &	pos,
		Vector3_t &	dir,
		float &	rCorr
	)

Definition at line 412 of file PFPUtils.cxx.

References dir.

   {
     return FitTp3s(tjs, tp3s, 0, tp3s.size(), pos, dir, rCorr);
   } // FitTp3s

bool tca::FitTp3s	(	TjStuff &	tjs,
		const std::vector< TrajPoint3 > &	tp3s,
		unsigned short	fromPt,
		unsigned short	toPt,
		Point3_t &	pos,
		Vector3_t &	dir,
		float &	rCorr
	)

Definition at line 418 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, detinfo::DetectorProperties::ConvertTicksToX(), geo::CryostatID::Cryostat, DecodeCTP(), tca::TjStuff::detprop, tca::TjStuff::geom, norm, tca::TjStuff::NumPlanes, geo::PlaneID::Plane, sw, geo::TPCID::TPC, tca::TjStuff::UnitsPerTick, w, geo::GeometryCore::WireCoordinate(), and x.

   {
     // Fits the Tj2Pts points in Tp3s to a line
     if(tp3s.size() < 3) return false;
     if(fromPt >= toPt) return false;
     if(toPt > tp3s.size()) return false;
 
     // temp vectors to ensure that a TP is only used once
     std::vector<unsigned short> useID;
     std::vector<unsigned short> useIpt;
     std::vector<unsigned short> cntInPln(tjs.NumPlanes);
     for(unsigned short ipt = fromPt; ipt < toPt; ++ipt) {
       auto& tp3 = tp3s[ipt];
       for(auto& tj2pt : tp3.Tj2Pts) {
         bool isUsed = false;
         for(unsigned short ii = 0; ii < useID.size(); ++ii) {
           if(tj2pt.id == useID[ii] && tj2pt.ipt == useIpt[ii]) isUsed = true;
         } // ii
         if(isUsed) continue;
         // add it to the list
         useID.push_back(tj2pt.id);
         useIpt.push_back(tj2pt.ipt);
         auto& tj = tjs.allTraj[tj2pt.id - 1];
         ++cntInPln[DecodeCTP(tj.CTP).Plane];
       } // tj2pt
     } // ipt
     // ensure there are at least two points in at least two planes
     unsigned short enufInPlane = 0;
     for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) if(cntInPln[plane] > 1) ++enufInPlane;
     if(enufInPlane < 2) return false;
     
     const unsigned int nvars = 4;
     unsigned int npts = useID.size();
     TMatrixD A(npts, nvars);
     // vector holding the Wire number
     TVectorD w(npts);
     
     // X origin
     double x0 = 0;
     for(unsigned short ipt = 0; ipt < useID.size(); ++ipt) {
       auto& tp = tjs.allTraj[useID[ipt] - 1].Pts[useIpt[ipt]];
       geo::PlaneID planeID = DecodeCTP(tp.CTP);
       x0 += tjs.detprop->ConvertTicksToX(tp.Pos[1]/tjs.UnitsPerTick, planeID);
     }
     x0 /= (double)useID.size();
 
     double wght = 1;
     for(unsigned short ipt = 0; ipt < useID.size(); ++ipt) {
       auto& tp = tjs.allTraj[useID[ipt] - 1].Pts[useIpt[ipt]];
       geo::PlaneID planeID = DecodeCTP(tp.CTP);
       unsigned int cstat = planeID.Cryostat;
       unsigned int tpc = planeID.TPC;
       unsigned int plane = planeID.Plane;
       // get the wire plane offset
       double off = tjs.geom->WireCoordinate(0, 0, plane, tpc, cstat);
       // get the "cosine-like" component
       double cw = tjs.geom->WireCoordinate(1, 0, plane, tpc, cstat) - off;
       // the "sine-like" component
       double sw = tjs.geom->WireCoordinate(0, 1, plane, tpc, cstat) - off;
       double x = tjs.detprop->ConvertTicksToX(tp.Pos[1]/tjs.UnitsPerTick, planeID) - x0;
       A[ipt][0] = wght * cw;
       A[ipt][1] = wght * sw;
       A[ipt][2] = wght * cw * x;
       A[ipt][3] = wght * sw * x;
       w[ipt] = wght * (tp.Pos[0] - off);
     } // ipt
     
     TDecompSVD svd(A);
     bool ok;
     TVectorD tVec = svd.Solve(w, ok);
     double norm = sqrt(1 + tVec[2] * tVec[2] + tVec[3] * tVec[3]);
     dir[0] = 1 / norm;
     dir[1] = tVec[2] / norm;
     dir[2] = tVec[3] / norm;
     pos[0] = x0;
     pos[1] = tVec[0];
     pos[2] = tVec[1];
     rCorr = 1;
     std::cout<<"FTP3s: "<<useID.size()<<" cntInPln "<<cntInPln[0]<<" "<<cntInPln[1]<<" "<<cntInPln[2]<<"\n";
     return true;
 
   } // FitTp3s

void tca::FitTraj	(	TjStuff &	tjs,
		Trajectory &	tj
	)

Definition at line 673 of file Utils.cxx.

References tca::Trajectory::EndPt, FitTraj(), and tca::Trajectory::Pts.

Referenced by tca::TrajClusterAlg::EndMerge(), tca::TrajClusterAlg::GottaKink(), tca::TrajClusterAlg::HiEndDelta(), tca::TrajClusterAlg::MaskBadTPs(), tca::TrajClusterAlg::MaskedHitsOK(), tca::TrajClusterAlg::PrepareForNextPass(), and tca::TrajClusterAlg::UpdateTraj().

   {
     // Jacket around FitTraj to fit the leading edge of the supplied trajectory
     unsigned short originPt = tj.EndPt[1];
     unsigned short npts = tj.Pts[originPt].NTPsFit;
     TrajPoint tpFit;
     unsigned short fitDir = -1;
     FitTraj(tjs, tj, originPt, npts, fitDir, tpFit);
     tj.Pts[originPt] = tpFit;
     
   } // FitTraj

void tca::FitTraj	(	TjStuff &	tjs,
		Trajectory &	tj,
		unsigned short	originPt,
		unsigned short	npts,
		short	fitDir,
		TrajPoint &	tpFit
	)

Definition at line 686 of file Utils.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::AngErr, tca::TrajPoint::AngleCode, AngleRange(), B, dir, tca::TrajPoint::Dir, tca::Trajectory::EndPt, tca::TrajPoint::FitChi, MoveTPToWire(), NumPtsWithCharge(), geo::origin(), tca::TrajPoint::Pos, tca::Trajectory::Pts, SetAngleCode(), w, x, xx, and y.

Referenced by FitTraj().

   {
     // Fit the supplied trajectory using HitPos positions with the origin at originPt.
     // The npts is interpreted as the number of points on each side of the origin
     // The allowed modes are as follows, where i denotes a TP that is included, . denotes
     // a TP with no hits, and x denotes a TP that is not included
     //TP 012345678  fitDir  originPt npts
     //   Oiiixxxxx   1        0       4 << npts in the fit
     //   xi.iiOxxx  -1        5       4
     //   xiiiOiiix   0        4       4 << 2 * npts + 1 points in the fit
     //   xxxiO.ixx   0        4       1
     //   0iiixxxxx   0        0       4
     // This routine puts the results into tp if the fit is successfull. The
     // fit "direction" is in increasing order along the trajectory from 0 to tj.Pts.size() - 1.
     
     //    static const float twoPi = 2 * M_PI;
     
     if(originPt > tj.Pts.size() - 1) {
       mf::LogWarning("TC")<<"FitTraj: Requesting fit of invalid TP "<<originPt;
       return;
     }
     
     // copy the origin TP into the fit TP
     tpFit = tj.Pts[originPt];
     // Assume that the fit will fail
     tpFit.FitChi = 999;
     if(fitDir < -1 || fitDir > 1) return;
     
     std::vector<double> x, y;
     Point2_t origin = tj.Pts[originPt].HitPos;
     // Use TP position if there aren't any hits on it
     if(tj.Pts[originPt].Chg == 0) origin = tj.Pts[originPt].Pos;
     
     // simple two point case
     if(NumPtsWithCharge(tjs, tj, false) == 2) {
       for(unsigned short ipt = tj.EndPt[0]; ipt < tj.EndPt[1]; ++ipt) {
         if(tj.Pts[ipt].Chg == 0) continue;
         double xx = tj.Pts[ipt].HitPos[0] - origin[0];
         double yy = tj.Pts[ipt].HitPos[1] - origin[1];
         x.push_back(xx);
         y.push_back(yy);
       } // ii
       if(x.size() != 2) return;
       if(x[0] == x[1]) {
         // Either + or - pi/2
         tpFit.Ang = M_PI/2;
         if(y[1] < y[0]) tpFit.Ang = -tpFit.Ang;
       } else {
         double dx = x[1] - x[0];
         double dy = y[1] - y[0];
         tpFit.Ang = atan2(dy, dx);
       }
       tpFit.Dir[0] = cos(tpFit.Ang);
       tpFit.Dir[1] = sin(tpFit.Ang);
       tpFit.Pos[0] += origin[0];
       tpFit.Pos[1] += origin[1];
       tpFit.AngErr = 0.01;
       tpFit.FitChi = 0.01;
       SetAngleCode(tjs, tpFit);
       return;
     } // two points
     
     std::vector<double> w, q;
     std::array<double, 2> dir;
     double xx, yy, xr, yr;
     double chgWt;
     
     // Rotate the traj hit position into the coordinate system defined by the
     // originPt traj point, where x = along the trajectory, y = transverse
     double rotAngle = tj.Pts[originPt].Ang;
     double cs = cos(-rotAngle);
     double sn = sin(-rotAngle);
     
     // enter the originPT hit info if it exists
     if(tj.Pts[originPt].Chg > 0) {
       xx = tj.Pts[originPt].HitPos[0] - origin[0];
       yy = tj.Pts[originPt].HitPos[1] - origin[1];
       xr = cs * xx - sn * yy;
       yr = sn * xx + cs * yy;
       x.push_back(xr);
       y.push_back(yr);
       chgWt = tj.Pts[originPt].ChgPull;
       if(chgWt < 1) chgWt = 1;
       chgWt *= chgWt;
       w.push_back(chgWt * tj.Pts[originPt].HitPosErr2);
     }
     
     // correct npts to account for the origin point
     if(fitDir != 0) --npts;
     
     // step in the + direction first
     if(fitDir != -1) {
       unsigned short cnt = 0;
       for(unsigned short ipt = originPt + 1; ipt < tj.Pts.size(); ++ipt) {
         if(tj.Pts[ipt].Chg == 0) continue;
         xx = tj.Pts[ipt].HitPos[0] - origin[0];
         yy = tj.Pts[ipt].HitPos[1] - origin[1];
         xr = cs * xx - sn * yy;
         yr = sn * xx + cs * yy;
         x.push_back(xr);
         y.push_back(yr);
         chgWt = tj.Pts[ipt].ChgPull;
         if(chgWt < 1) chgWt = 1;
         chgWt *= chgWt;
         w.push_back(chgWt * tj.Pts[ipt].HitPosErr2);
         ++cnt;
         if(cnt == npts) break;
       } // ipt
     } // fitDir != -1
     
     // step in the - direction next
     if(fitDir != 1 && originPt > 0) {
       unsigned short cnt = 0;
       for(unsigned short ii = 1; ii < tj.Pts.size(); ++ii) {
         unsigned short ipt = originPt - ii;
         if(ipt > tj.Pts.size() - 1) continue;
         if(tj.Pts[ipt].Chg == 0) continue;
         xx = tj.Pts[ipt].HitPos[0] - origin[0];
         yy = tj.Pts[ipt].HitPos[1] - origin[1];
         xr = cs * xx - sn * yy;
         yr = sn * xx + cs * yy;
         x.push_back(xr);
         y.push_back(yr);
         chgWt = tj.Pts[ipt].ChgPull;
         if(chgWt < 1) chgWt = 1;
         chgWt *= chgWt;
         w.push_back(chgWt * tj.Pts[ipt].HitPosErr2);
         ++cnt;
         if(cnt == npts) break;
         if(ipt == 0) break;
       } // ipt
     } // fitDir != -1
     
     // Not enough points to define a line?
     if(x.size() < 2) return;
     
     double sum = 0.;
     double sumx = 0.;
     double sumy = 0.;
     double sumxy = 0.;
     double sumx2 = 0.;
     double sumy2 = 0.;
     
     // weight by the charge ratio and accumulate sums
     double wght;
     for(unsigned short ipt = 0; ipt < x.size(); ++ipt) {
       if(w[ipt] < 0.00001) w[ipt] = 0.00001;
       wght = 1 / w[ipt];
       sum   += wght;
       sumx  += wght * x[ipt];
       sumy  += wght * y[ipt];
       sumx2 += wght * x[ipt] * x[ipt];
       sumy2 += wght * y[ipt] * y[ipt];
       sumxy += wght * x[ipt] * y[ipt];
     }
     // calculate coefficients and std dev
     double delta = sum * sumx2 - sumx * sumx;
     if(delta == 0) return;
     // A is the intercept
     double A = (sumx2 * sumy - sumx * sumxy) / delta;
     // B is the slope
     double B = (sumxy * sum  - sumx * sumy) / delta;
     
     // The chisq will be set below if there are enough points. Don't allow it to be 0
     // so we can take Chisq ratios later
     tpFit.FitChi = 0.01;
     double newang = atan(B);
     dir[0] = cos(newang);
     dir[1] = sin(newang);
     // rotate back into the (w,t) coordinate system
     cs = cos(rotAngle);
     sn = sin(rotAngle);
     tpFit.Dir[0] = cs * dir[0] - sn * dir[1];
     tpFit.Dir[1] = sn * dir[0] + cs * dir[1];
     // ensure that the direction is consistent with the originPt direction
     bool flipDir = false;
     if(AngleRange(tjs, tj.Pts[originPt]) > 0) {
       flipDir = std::signbit(tpFit.Dir[1]) != std::signbit(tj.Pts[originPt].Dir[1]);
     } else {
       flipDir = std::signbit(tpFit.Dir[0]) != std::signbit(tj.Pts[originPt].Dir[0]);
     }
     if(flipDir) {
       tpFit.Dir[0] = -tpFit.Dir[0];
       tpFit.Dir[1] = -tpFit.Dir[1];
     }
     tpFit.Ang = atan2(tpFit.Dir[1], tpFit.Dir[0]);
     SetAngleCode(tjs, tpFit);
     //    if(prt) mf::LogVerbatim("TC")<<"FitTraj "<<originPt<<" originPt Dir "<<tj.Pts[originPt].Dir[0]<<" "<<tj.Pts[originPt].Dir[1]<<" rotAngle "<<rotAngle<<" tpFit.Dir "<<tpFit.Dir[0]<<" "<<tpFit.Dir[1]<<" Ang "<<tpFit.Ang<<" flipDir "<<flipDir<<" fit vector size "<<x.size();
     
     // rotate (0, intcpt) into (W,T) coordinates
     tpFit.Pos[0] = -sn * A + origin[0];
     tpFit.Pos[1] =  cs * A + origin[1];
     // force the origin to be at origin[0]
     if(tpFit.AngleCode < 2) MoveTPToWire(tpFit, origin[0]);
     
     if(x.size() < 3) return;
     
     // Calculate chisq/DOF
     double ndof = x.size() - 2;
     double varnce = (sumy2 + A*A*sum + B*B*sumx2 - 2 * (A*sumy + B*sumxy - A*B*sumx)) / ndof;
     if(varnce > 0.) {
       // Intercept error is not used
       //      InterceptError = sqrt(varnce * sumx2 / delta);
       double slopeError = sqrt(varnce * sum / delta);
       tpFit.AngErr = std::abs(atan(slopeError));
     } else {
       tpFit.AngErr = 0.01;
     }
     sum = 0;
     // calculate chisq
     double arg;
     for(unsigned short ii = 0; ii < y.size(); ++ii) {
       arg = y[ii] - A - B * x[ii];
       sum += arg * arg / w[ii];
     }
     tpFit.FitChi = sum / ndof;
     
   } // FitTraj

bool tca::FitVertex	(	TjStuff &	tjs,
		VtxStore &	vx,
		bool	prt
	)

Definition at line 1946 of file TCVertex.cxx.

References tca::TjStuff::allTraj, tca::VtxStore::CTP, tca::VtxStore::ID, kFixed, kKilled, kNoFitToVx, kPhoton, and tca::VtxStore::Stat.

Referenced by AttachTrajToVertex(), tca::TrajClusterAlg::EndMerge(), Find2DVertices(), FindNeutralVertices(), MergeWithVertex(), and SplitTrajCrossingVertices().

   {
     // A poor-mans fitting scheme. If the fitted vertex position error is within the supplied
     // value, the position and errors are updated and we return true, otherwise the vertex is
     // left unchanged and we return false
     
     // tjs.Vertex2DCuts fcl input usage
     // 0 = maximum length of a short trajectory
     // 1 = max vertex - trajectory separation for short trajectories
     // 2 = max vertex - trajectory separation for long trajectories
     // 3 = max position pull for adding TJs to a vertex
     // 4 = max allowed vertex position error
     // 5 = min MCSMom
     // 6 = min Pts/Wire fraction
     
     if(vx.Stat[kFixed]) {
       if(prt) mf::LogVerbatim("TC")<<" vertex position fixed. No fit allowed";
       return true;
     }
     
     
     // Create a vector of trajectory points that will be used to fit the vertex position
     std::vector<TrajPoint> vxTp;
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       if(tj.CTP != vx.CTP) continue;
       if(tj.AlgMod[kPhoton]) continue;
       if(tj.AlgMod[kNoFitToVx]) continue;
       if(tj.VtxID[0] == vx.ID) vxTp.push_back(tj.Pts[tj.EndPt[0]]);
       if(tj.VtxID[1] == vx.ID) vxTp.push_back(tj.Pts[tj.EndPt[1]]);
     } // tj
     
     bool success = FitVertex(tjs, vx, vxTp, prt);
     
     if(!success) return false;
     return true;
     
   } // FitVertex

bool tca::FitVertex	(	TjStuff &	tjs,
		VtxStore &	vx,
		std::vector< TrajPoint >	vxTp,
		bool	prt
	)

Definition at line 1986 of file TCVertex.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::AngErr, tca::VtxStore::ChiDOF, tca::VtxStore::CTP, tca::TrajPoint::CTP, tca::TrajPoint::Dir, tca::VtxStore::ID, kOnDeadWire, tca::VtxStore::NTraj, tca::VtxStore::Pos, tca::TrajPoint::Pos, tca::VtxStore::PosErr, PrintHeader(), PrintPos(), PrintTrajPoint(), tca::VtxStore::Stat, tmp, tca::VtxStore::Topo, TrajIntersection(), TrajPointVertexPull(), tca::TjStuff::UnitsPerTick, and tca::TjStuff::Vertex2DCuts.

   {
     // Variant of FitVertex that fits the passed trajectory points to a vertex position but doesn't
     // require using information in TJStuff
 
     // tjs.Vertex2DCuts fcl input usage
     // 0 = maximum length of a short trajectory
     // 1 = max vertex - trajectory separation for short trajectories
     // 2 = max vertex - trajectory separation for long trajectories
     // 3 = max position pull for adding TJs to a vertex
     // 4 = max allowed vertex position error
     // 5 = min MCSMom
     // 6 = min Pts/Wire fraction
     // 7 min Score
     // 8 Min charge fraction near a merge point (not a vertex)
     // 9 max MCSmom asymmetry for a merge
 
     
     vx.NTraj = vxTp.size();
     
     if(vxTp.size() < 2) return false;
     
     if(prt) {
       PrintHeader("FV");
       for(auto& tp : vxTp) PrintTrajPoint("FV", tjs, 0, 1, 1, tp);
     }
     
     // Find trajectory intersections pair-wise tweaking the angle and position(?) within
     // +/- 1 sigma
     double sum0 = 0, sum02 = 0;
     double sum1 = 0, sum12 = 0;
     double sumw = 0;
     double wgt;
     double cnt = 0;
     // a temporary TP for tweaking the angle
     TrajPoint tmp;
     // another point to check for a signal at each intersection
     TrajPoint intTp;
     intTp.CTP = vxTp[0].CTP;
     for(unsigned short itj = 0; itj < vxTp.size() - 1; ++itj) {
       for(unsigned short jtj = itj + 1; jtj < vxTp.size(); ++jtj) {
         float p0, p1;
         TrajIntersection(vxTp[itj], vxTp[jtj], p0, p1);
         intTp.Pos[0] = p0; intTp.Pos[1] = p1;
         wgt = 1;
         // accumulate
         sum0 += wgt * p0; sum02 += wgt * p0 * p0; 
         sum1 += wgt * p1; sum12 += wgt * p1 * p1; sumw += wgt; ++cnt;
         // tweak the itj angle +
         tmp = vxTp[itj];
         tmp.Ang += tmp.AngErr;
         tmp.Dir[0] = cos(tmp.Ang); tmp.Dir[1] = sin(tmp.Ang);
         TrajIntersection(tmp, vxTp[jtj], p0, p1);
         intTp.Pos[0] = p0; intTp.Pos[1] = p1;
         // adjust the weight for 4 points at +/1 1 sigma = 0.607 / 4
         wgt = 0.152;
         // accumulate
         sum0 += wgt * p0; sum02 += wgt * p0 * p0; 
         sum1 += wgt * p1; sum12 += wgt * p1 * p1; sumw += wgt; ++cnt;
         // tweak the itj angle -
         tmp = vxTp[itj];
         tmp.Ang -= 2 * tmp.AngErr;
         tmp.Dir[0] = cos(tmp.Ang); tmp.Dir[1] = sin(tmp.Ang);
         TrajIntersection(tmp, vxTp[jtj], p0, p1);
         intTp.Pos[0] = p0; intTp.Pos[1] = p1;
         // accumulate
         sum0 += wgt * p0; sum02 += wgt * p0 * p0; 
         sum1 += wgt * p1; sum12 += wgt * p1 * p1; sumw += wgt; ++cnt;
         // Repeat this process with jtj
         // tweak the jtj angle +
         tmp = vxTp[jtj];
         tmp.Ang += tmp.AngErr;
         tmp.Dir[0] = cos(tmp.Ang); tmp.Dir[1] = sin(tmp.Ang);
         TrajIntersection(vxTp[itj], tmp, p0, p1);
         intTp.Pos[0] = p0; intTp.Pos[1] = p1;
         // accumulate
         sum0 += wgt * p0; sum02 += wgt * p0 * p0; 
         sum1 += wgt * p1; sum12 += wgt * p1 * p1; sumw += wgt; ++cnt;
         // tweak the itj angle -
         tmp = vxTp[itj];
         tmp.Ang -= 2 * tmp.AngErr;
         tmp.Dir[0] = cos(tmp.Ang); tmp.Dir[1] = sin(tmp.Ang);
         TrajIntersection(vxTp[itj], tmp, p0, p1);
         intTp.Pos[0] = p0; intTp.Pos[1] = p1;
         // accumulate
         sum0 += wgt * p0; sum02 += wgt * p0 * p0; 
         sum1 += wgt * p1; sum12 += wgt * p1 * p1; sumw += wgt; ++cnt;
       } // jtj
     } // itj
     
     if(sumw == 0) return false;
     
     double vxP0 = sum0 / sumw;
     double vxP1 = sum1 / sumw;
     double vxP0rms = sqrt((sum02 - sumw * vxP0 * vxP0) / sumw);
     double vxP1rms = sqrt((sum12 - sumw * vxP1 * vxP1) / sumw);
     double rootN = sqrt(cnt);
     vxP0rms /= rootN;
     vxP1rms /= rootN;
     // don't let the errors get too small
     if(vxP0rms < 0.5) vxP0rms = 0.5;
     if(vxP1rms < 0.5) vxP1rms = 0.5;
     
     if(prt) mf::LogVerbatim("TC")<<"FitVertex 2V"<<vx.ID<<" CTP "<<vx.CTP<<" NTraj "<<vx.NTraj<<" in "<<std::fixed<<std::setprecision(1)<<vx.Pos[0]<<":"<<vx.Pos[1]/tjs.UnitsPerTick<<" out wire "<<vxP0<<" +/- "<<vxP0rms<<" ticks "<<vxP1/tjs.UnitsPerTick<<"+/-"<<vxP1rms/tjs.UnitsPerTick;
     
     // apply Vertex2DCuts if this isn't a neutral vertex (which is expected to have very large
     // errors)
     if(vx.Topo != 11) {
       float inflate = 1;
       if(vx.Stat[kOnDeadWire]) inflate = 1.5;
       if(vxP0rms > inflate * tjs.Vertex2DCuts[4] || vxP1rms > inflate * tjs.Vertex2DCuts[4]) {
         if(prt) mf::LogVerbatim("TC")<<" fit failed. Max allowed position error "<<inflate * tjs.Vertex2DCuts[4];
         return false;
       }
     } // not a neutral vertex
     
     vx.Pos[0] = vxP0;
     vx.PosErr[0] = vxP0rms;
     vx.Pos[1] = vxP1;
     vx.PosErr[1] = vxP1rms;
     
     // Calculate chisq
     vx.ChiDOF = 0;
     for(unsigned short itj = 0; itj < vxTp.size(); ++itj) {
       vx.ChiDOF += TrajPointVertexPull(tjs, vxTp[itj], vx);
     } // itj
     vx.ChiDOF /= (float)vxTp.size();
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"Pull";
       for(unsigned short itj = 0; itj < vxTp.size(); ++itj) {
         float pull = TrajPointVertexPull(tjs, vxTp[itj], vx);
         myprt<<" "<<PrintPos(tjs, vxTp[itj])<<" - "<<std::fixed<<std::setprecision(2)<<pull;
       } // itj
       myprt<<" ChiDOF "<<vx.ChiDOF;
     }
     return true;
 
   } // FitVertex

void tca::FollowTp3s	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 261 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, DecodeCTP(), tca::TjStuff::detprop, tca::PFPStruct::Dir, FindAlongTrans(), tca::TjStuff::geom, kEnvFlag, tca::TjStuff::NumPlanes, geo::PlaneID::Plane, PointDirection(), PosSep(), PosSep2(), SetMag(), tca::PFPStruct::TjIDs, tca::PFPStruct::Tp3s, geo::TPCID::TPC, tca::PFPStruct::TPCID, tca::TjStuff::UnitsPerTick, tca::TjStuff::vtx3, tca::PFPStruct::Vx3ID, geo::GeometryCore::WireCoordinate(), tca::TjStuff::WirePitch, and tca::PFPStruct::XYZ.

Referenced by DefinePFP().

   {
     // Step through the set of Tp3s on this pfp to create a trajectory. The start and end points
     // are assumed to be Tp3s[0] and Tp3s[Tp3s.size()-1] respectively. 
     
     if(pfp.Tp3s.size() < 2) return;
     
     unsigned short startPt = 0;
     unsigned short endPt = pfp.Tp3s.size() - 1;
     // divide the trajectory in 5 cm long sections. The average position of the Tp3s in
     // each section will be found. Tp3s 
     constexpr float sectionLen = 5;
     float endAlong = pfp.Tp3s[0].AlongTrans[0] + sectionLen;
     std::vector<Vector3_t> sectionPos;
     sectionPos.push_back(pfp.Tp3s[0].Pos);
     std::vector<unsigned short> sectionPt;
     sectionPt.push_back(0);
     for(unsigned short section = 0; section < 100; ++section) {
       // a point to find the average position in this section
       Point3_t avePos {{0,0,0}};
       Vector3_t aveDir {{0,0,0}};
       unsigned short cnt = 0;
       for(unsigned short ipt = startPt; ipt < endPt; ++ipt) {
         auto& tp3 = pfp.Tp3s[ipt];
         // The path length along the direction vector from the start point to the end
         // point was stashed in dEdxErr 
         // remove outliers
         if(tp3.AlongTrans[1] > 2) continue;
         if(tp3.AlongTrans[0] < endAlong) {
           // still in the same section - sum and continue
           for(unsigned short xyz = 0; xyz < 3; ++xyz) {
             avePos[xyz] += tp3.Pos[xyz];
             aveDir[xyz] += tp3.Dir[xyz];
           }
           ++cnt;
           continue;
         }
         // entered the next section. Check for a failure
         if(cnt == 0) continue;
         // calculate the average position
         for(unsigned short xyz = 0; xyz < 3; ++xyz) avePos[xyz] /= cnt;
         SetMag(aveDir, 1);
 /*
         std::cout<<"Section "<<section<<" cnt "<<cnt<<" avePos"<<std::fixed<<std::setprecision(1);
         std::cout<<" "<<avePos[0]<<" "<<avePos[1]<<" "<<avePos[2];
         std::cout<<" aveDir "<<std::setprecision(2)<<aveDir[0]<<" "<<aveDir[1]<<" "<<aveDir[2]<<"\n";
 */
         sectionPos.push_back(avePos);
         sectionPt.push_back(ipt);
         startPt = ipt;
         endAlong += sectionLen;
         break;
       } // ipt
     } // section
     sectionPos.push_back(pfp.Tp3s[endPt].Pos);
     sectionPt.push_back(pfp.Tp3s.size() - 1);
 /*
     for(unsigned short ipt = 0; ipt < sectionPos.size(); ++ipt) {
       std::cout<<ipt<<" sectionPt "<<sectionPt[ipt]<<" sectionPos "<<" "<<sectionPos[ipt][0]<<" "<<sectionPos[ipt][1]<<" "<<sectionPos[ipt][2]<<"\n";
     } // ipt
 */
     // set the general purpose flag bit false (unused) for all Tj Pts. This will be set true
     // when a Tp is used in a Tp3
     for(auto tjid : pfp.TjIDs) {
       auto& tj = tjs.allTraj[tjid - 1];
       for(auto& tp : tj.Pts) tp.Environment[kEnvFlag] = false;
     } // tjid
     // set the bits true for the first point
     for(auto tj2pt : pfp.Tp3s[0].Tj2Pts) {
       tjs.allTraj[tj2pt.id - 1].Pts[tj2pt.ipt].Environment[kEnvFlag] = true;
     }
     // create a vector of new Tp3s that will replace pfp.Tp3s
     std::vector<TrajPoint3> ntp3;
     ntp3.push_back(pfp.Tp3s[0]);
     // 2D position (WSE units) of the TPs at the start of this section. We will require that all 2D TPs are
     // less than sectionLen (in WSE units) from this point.
     std::vector<Point2_t> startPos2D(tjs.NumPlanes);
     // collect Tp3s in each section
     unsigned short lastPtAdded = 0;
     for(unsigned short section = 1; section < sectionPt.size(); ++section) {
       Point3_t startPos = sectionPos[section - 1];
       Point3_t endPos = sectionPos[section];
       auto startDir = PointDirection(startPos, endPos);
       // define the pfp start direction
       if(section == 1) pfp.Dir[0] = startDir;
       // and the end direction
       pfp.Dir[1] = startDir;
 //      std::cout<<"Section "<<section<<" startDir "<<std::fixed<<std::setprecision(2)<<startDir[0]<<" "<<startDir[1]<<" "<<startDir[2]<<"\n";
       // define the 2D positions for this point in each plane
       for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
         geo::PlaneID planeID = geo::PlaneID(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
         startPos2D[plane][0] = tjs.geom->WireCoordinate(sectionPos[section - 1][1], sectionPos[section - 1][2], planeID);
         startPos2D[plane][1] = tjs.detprop->ConvertXToTicks(sectionPos[section - 1][0], planeID) * tjs.UnitsPerTick;
       } // plane
       for(unsigned short ipt = sectionPt[section - 1]; ipt < sectionPt[section]; ++ipt) {
         auto& tp3 = pfp.Tp3s[ipt];
         // count the number of Tps in this Tp3 that are already used in the trajectory
         unsigned short nused = 0;
         bool big2DSep = false;
         for(auto tj2pt : pfp.Tp3s[ipt].Tj2Pts) {
           auto& tp = tjs.allTraj[tj2pt.id - 1].Pts[tj2pt.ipt];
           if(tp.Environment[kEnvFlag]) ++nused;
           unsigned short plane = DecodeCTP(tp.CTP).Plane;
           float sep2D = PosSep(startPos2D[plane], tp.Pos) * tjs.WirePitch;
           if(sep2D > sectionLen) big2DSep = true;
         } // tj2pt
         if(big2DSep || nused > 1) continue;
         Point2_t alongTrans;
         FindAlongTrans(startPos, startDir, tp3.Pos, alongTrans);
         if(alongTrans[1] > 0.5) continue;
 /*
         std::cout<<section<<" ipt "<<ipt<<" trans "<<alongTrans[1]<<" tj_ipt";
         for(auto tj2pt : tp3.Tj2Pts) std::cout<<" "<<tj2pt.id - 1<<"_"<<tj2pt.ipt;
         std::cout<<"\n";
 */
         tp3.AlongTrans = alongTrans;
         // don't clobber the original direction
 //        tp3.Dir = dir;
         ntp3.push_back(tp3);
         // set the flag
         for(auto tj2pt : tp3.Tj2Pts) tjs.allTraj[tj2pt.id - 1].Pts[tj2pt.ipt].Environment[kEnvFlag] = true;
         lastPtAdded = ipt;
       } // ipt
     } // section
     
     if(lastPtAdded != endPt) ntp3.push_back(pfp.Tp3s[endPt]);
     
     if(prt) {
       float len = PosSep(ntp3[0].Pos, ntp3[ntp3.size()-1].Pos);
       mf::LogVerbatim("TC")<<"FollowTp3s: Tp3s size in "<<pfp.Tp3s.size()<<" size out "<<ntp3.size()<<" len "<<std::fixed<<std::setprecision(2)<<len;
     }
     
     // reverse if necessary to be consistent with a vertex
     if(pfp.Vx3ID[0] > 0) {
       auto& vx3 = tjs.vtx3[pfp.Vx3ID[0] - 1];
       Point3_t vpos = {{vx3.X, vx3.Y, vx3.Z}};
       auto& firstTp3Pos = ntp3[0].Pos;
       auto& lastTp3Pos = ntp3[ntp3.size() - 1].Pos;
       if(PosSep2(lastTp3Pos, vpos) < PosSep2(firstTp3Pos, vpos)) std::reverse(ntp3.begin(), ntp3.end());
     } // pfp.Vx3ID[0] > 0
     
     pfp.Tp3s = ntp3;
     // The directions were set above. Set the start and end positions. Note that the start position
     // may have been previously determined by a vertex but that is now superseded by the actual start
     // of the pfp
     pfp.XYZ[0] = ntp3[0].Pos;
     pfp.XYZ[1] = ntp3[ntp3.size()-1].Pos;
 //    if(prt) PrintTp3s("FTp3o", tjs, pfp, -1);
 
   } // FollowTp3s

std::vector< int > tca::GetAssns	(	const TjStuff &	tjs,
		std::string	type1Name,
		int	id,
		std::string	type2Name
	)

Definition at line 4079 of file Utils.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::cots, evd::details::end(), kKilled, kMat3D, tca::TjStuff::pfps, SetIntersection(), tca::TjStuff::showers, ss, tmp, tca::TjStuff::vtx, and tca::TjStuff::vtx3.

Referenced by ChkVxTjs(), CompleteIncomplete3DVertices(), CompleteIncompleteShower(), DefineDontCluster(), DotProd(), FindCots(), FindNearbyTjs(), FindParent(), Finish3DShowers(), KillVerticesInShower(), tca::MCParticleListUtils::MakeCheatShower(), MergeNearby2DShowers(), ParentFOM(), tca::MCParticleListUtils::PrimaryElectronPFPID(), PrintAllTraj(), Reconcile3D(), SetParent(), and TagShowerLike().

   {
     // returns a list of IDs of objects (tjs, vertices, pfps, etc) with type1Name that are in TJStuff with
     // type2Name. This is intended to be a general purpose replacement for specific functions like GetVtxTjIDs, etc
     
     std::vector<int> tmp;
     if(id <= 0) return tmp;
     unsigned int uid = id;
     
     if(type1Name == "T" && uid <= tjs.allTraj.size() && type2Name == "P") {
       // return a list of PFPs that have the tj in TjIDs, P -> T<ID>
       for(auto& pfp : tjs.pfps) {
         if(pfp.ID <= 0) continue;
         if(std::find(pfp.TjIDs.begin(), pfp.TjIDs.end(), id) != pfp.TjIDs.end()) tmp.push_back(pfp.ID);
       } // pf
       return tmp;
     } // P -> T
     
     if(type1Name == "P" && uid <= tjs.pfps.size() && (type2Name == "2S" || type2Name == "3S")) {
       // return a list of 3D or 2D showers with the assn 3S -> 2S -> T -> P<ID> or 2S -> T -> P.
       auto& pfp = tjs.pfps[uid - 1];
       // First form a list of 2S -> T -> P<ID>
       std::vector<int> ssid;
       for(auto& ss : tjs.cots) {
         if(ss.ID <= 0) continue;
         auto shared = SetIntersection(ss.TjIDs, pfp.TjIDs);
         if(!shared.empty() && std::find(ssid.begin(), ssid.end(), ss.ID) == ssid.end()) ssid.push_back(ss.ID);
       } // ss
       if(type2Name == "2S") return ssid;
       for(auto& ss3 : tjs.showers) {
         if(ss3.ID <= 0) continue;
         auto shared = SetIntersection(ss3.CotIDs, ssid);
         if(!shared.empty() && std::find(tmp.begin(), tmp.end(), ss3.ID) == tmp.end()) tmp.push_back(ss3.ID);
       } // ss3
       return tmp;
     } // 3S -> 2S -> T -> P
     
     if(type1Name == "2V" && uid <= tjs.vtx.size() && type2Name == "T" ) {
       // 2V -> T
       for(auto& tj : tjs.allTraj) {
         if(tj.AlgMod[kKilled]) continue;
         for(unsigned short end = 0; end < 2; ++end) {
           if(tj.VtxID[end] != id) continue;
           if(std::find(tmp.begin(), tmp.end(), tj.ID) == tmp.end()) tmp.push_back(tj.ID);
         } // end
       } // tj
       return tmp;
     } // 2V -> T
 
     if(type1Name == "3V" && uid <= tjs.vtx3.size() && type2Name == "P") {
       for(auto& pfp : tjs.pfps) {
         if(pfp.ID == 0) continue;
         for(unsigned short end = 0; end < 2; ++end) {
           if(pfp.Vx3ID[end] != id) continue;
           // encode the end with the ID
           if(std::find(tmp.begin(), tmp.end(), pfp.ID) == tmp.end()) tmp.push_back(pfp.ID);
         } // end
       } // pfp
       return tmp;
     } // 3V -> P
     
     if(type1Name == "3V" && uid <= tjs.vtx3.size() && type2Name == "T") {
       // 3V -> T
       for(auto& tj : tjs.allTraj) {
         if(tj.AlgMod[kKilled]) continue;
         for(unsigned short end = 0; end < 2; ++end) {
           if(tj.VtxID[end] > 0 && tj.VtxID[end] <= tjs.vtx.size()) {
             auto& vx2 = tjs.vtx[tj.VtxID[end] - 1];
             if(vx2.Vx3ID != id) continue;
             if(std::find(tmp.begin(), tmp.end(), tj.ID) == tmp.end()) tmp.push_back(tj.ID);
           }
         } // end
       } // tj
       return tmp;
     } // 3V -> T
     
     if(type1Name == "3V" && uid <= tjs.vtx3.size() && type2Name == "2V") {
       // 3V -> 2V
       for(auto& vx2 : tjs.vtx) {
         if(vx2.ID == 0) continue;
         if(vx2.Vx3ID == id) tmp.push_back(vx2.ID);
       } // vx2
       return tmp;
     } // 3V -> 2V
 
     if(type1Name == "3S" && uid <= tjs.showers.size() && type2Name == "T") {
       // 3S -> T
       auto& ss3 = tjs.showers[uid - 1];
       if(ss3.ID == 0) return tmp;
       for(auto cid : ss3.CotIDs) {
         auto& ss = tjs.cots[cid - 1];
         if(ss.ID == 0) continue;
         tmp.insert(tmp.end(), ss.TjIDs.begin(), ss.TjIDs.end());
       } // cid
       return tmp;
     }  // 3S -> T
     
     // This isn't strictly necessary but do it for consistency
     if(type1Name == "2S" && uid <= tjs.cots.size() && type2Name == "T") {
       // 2S -> T
       auto& ss = tjs.cots[uid - 1];
       return ss.TjIDs;
     }  // 2S -> T
     
     if(type1Name == "3S" && uid <= tjs.showers.size() && type2Name == "P") {
       // 3S -> P
       auto& ss3 = tjs.showers[uid - 1];
       if(ss3.ID == 0) return tmp;
       for(auto cid : ss3.CotIDs) {
         auto& ss = tjs.cots[cid - 1];
         if(ss.ID == 0) continue;
         for(auto tid : ss.TjIDs) {
           auto& tj = tjs.allTraj[tid - 1];
           if(tj.AlgMod[kKilled]) continue;
           if(!tj.AlgMod[kMat3D]) continue;
           for(auto& pfp : tjs.pfps) {
             if(pfp.ID <= 0) continue;
             if(std::find(pfp.TjIDs.begin(), pfp.TjIDs.end(), tj.ID) == pfp.TjIDs.end()) continue;
             if(std::find(tmp.begin(), tmp.end(), pfp.ID) == tmp.end()) tmp.push_back(pfp.ID);
           } // pf
         } // tid
       } // cid
       return tmp;
     } // 3S -> P
 
     if(type1Name == "T" && uid <= tjs.allTraj.size() && type2Name == "2S") {
       // T -> 2S
       for(auto& ss : tjs.cots) {
         if(ss.ID == 0) continue;
         if(std::find(ss.TjIDs.begin(), ss.TjIDs.end(), id) != ss.TjIDs.end()) tmp.push_back(ss.ID);
       } // ss
       return tmp;
     } // T -> 2S
     
     if(type1Name == "T" && uid <= tjs.allTraj.size() && type2Name == "3S") {
       // T -> 3S
       for(auto& ss : tjs.cots) {
         if(ss.ID == 0) continue;
         if(std::find(ss.TjIDs.begin(), ss.TjIDs.end(), id) == ss.TjIDs.end()) continue;
         if(ss.SS3ID > 0) tmp.push_back(ss.SS3ID);
       } // ss
       return tmp;
     } // T -> 3S
     
     std::cout<<"GetAssns doesn't know about "<<type1Name<<" -> "<<type2Name<<" assns, or id "<<id<<" is not valid.\n";
 
     return tmp;
     
   } // GetAssns

int tca::GetCotID	(	TjStuff &	tjs,
		int	ShowerTjID
	)

Definition at line 4424 of file TCShower.cxx.

References tca::TjStuff::cots.

Referenced by MergeShowerTjsAndStore().

   {
     for(unsigned short ii = 0; ii < tjs.cots.size(); ++ii) {
       if(ShowerTjID == tjs.cots[ii].ShowerTjID) return ii + 1;
     } // iii
     return 0;
     
   } // GetCotID

int tca::GetOrigin	(	TjStuff &	tjs,
		PFPStruct &	pfp
	)

Definition at line 77 of file TCCR.cxx.

References tca::TjStuff::allTraj, tca::TCHit::ArtPtr, cheat::BackTrackerService::ChannelToTrackIDEs(), geo::CryostatID::Cryostat, tca::TjStuff::fHits, tca::TjStuff::geom, simb::MCTruth::Origin(), geo::origin(), tca::TCHit::PeakTime, geo::PlaneID::Plane, geo::GeometryCore::PlaneWireToChannel(), tca::Trajectory::Pts, tca::TCHit::RMS, tca::PFPStruct::TjIDs, geo::TPCID::TPC, cheat::ParticleInventoryService::TrackIdToMCTruth_P(), geo::WireID::Wire, and recob::Hit::WireID().

Referenced by SaveCRInfo().

                                              {
 
     art::ServiceHandle<cheat::BackTrackerService> bt_serv;    
     art::ServiceHandle<cheat::ParticleInventoryService> pi_serv;    
 
     std::map<int, float> omap; //<origin, energy>
 
     for(auto& tjID : pfp.TjIDs) {
       
       Trajectory& tj = tjs.allTraj[tjID - 1];
       for(auto& tp : tj.Pts) {
         for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
           if(!tp.UseHit[ii]) continue;
           unsigned int iht = tp.Hits[ii];
           TCHit& hit = tjs.fHits[iht];
           raw::ChannelID_t channel = tjs.geom->PlaneWireToChannel((int)hit.ArtPtr->WireID().Plane, (int)hit.ArtPtr->WireID().Wire, (int)hit.ArtPtr->WireID().TPC, (int)hit.ArtPtr->WireID().Cryostat);
           double startTick = hit.PeakTime - hit.RMS;
           double endTick = hit.PeakTime + hit.RMS;
           // get a list of track IDEs that are close to this hit
           std::vector<sim::TrackIDE> tides;
           tides = bt_serv->ChannelToTrackIDEs(channel, startTick, endTick);          
           for(auto itide = tides.begin(); itide != tides.end(); ++itide) {
             omap[pi_serv->TrackIdToMCTruth_P(itide->trackID)->Origin()] += itide->energy;
           }
         }
       }
     }
     
     float maxe = -1;
     int origin = 0;
     for (auto & i : omap){
       if (i.second > maxe){
         maxe = i.second;
         origin = i.first;
       }
     }
     return origin;
   }

unsigned short tca::GetPFPIndex	(	const TjStuff &	tjs,
		int	tjID
	)

Definition at line 1045 of file Utils.cxx.

References tca::TjStuff::pfps.

Referenced by DefinePFPParents(), DefinePFPParentsTestBeam(), and MergeAndStore().

   {
     // returns the index into the tjs.matchVec vector of the first 3D match that
     // includes tjID
     if(tjs.pfps.empty()) return USHRT_MAX;
     for(unsigned int ipfp = 0; ipfp < tjs.pfps.size(); ++ipfp) {
       const auto& pfp = tjs.pfps[ipfp];
       if(std::find(pfp.TjIDs.begin(), pfp.TjIDs.end(), tjID) != pfp.TjIDs.end()) return ipfp;
     } // indx
     return USHRT_MAX;
   } // GetPFPIndex

std::vector< unsigned short > tca::GetPFPVertices	(	const TjStuff &	tjs,
		const PFPStruct &	pfp
	)

Definition at line 3063 of file TCVertex.cxx.

References tca::TjStuff::allTraj, evd::details::end(), tca::PFPStruct::TjIDs, tmp, and tca::TjStuff::vtx.

   {
     // returns a list of 3D vertices that are attached to Tjs in this pfp. No check is
     // made of the actual vertex attachment of the pfp.
     std::vector<unsigned short> tmp;
     if(pfp.TjIDs.empty()) return tmp;
     for(auto tjid : pfp.TjIDs) {
       auto& tj = tjs.allTraj[tjid - 1];
       for(unsigned short end = 0; end < 2; ++end) {
         if(tj.VtxID[end] == 0) continue;
         auto& vx2 = tjs.vtx[tj.VtxID[end] - 1];
         if(vx2.Vx3ID == 0) continue;
         if(std::find(tmp.begin(), tmp.end(), vx2.Vx3ID) != tmp.end()) continue;
         tmp.push_back(vx2.Vx3ID);
       } // end
     } // tjid
     return tmp;
   } // GetPFPVertices

int tca::GetStageNum	(	ShowerTreeVars &	stv,
		std::string	stageName
	)

Definition at line 185 of file TCShTree.cxx.

References tca::ShowerTreeVars::StageName.

Referenced by SaveTjInfo().

                                                             {
     int stageNum;
     bool existingStage = false;
     for (unsigned short i = 0; i < stv.StageName.size(); ++i) {
       if (stv.StageName.at(i) == stageName) {
         existingStage = true;
         stageNum = i+1;
       }
     }
 
     if (!existingStage) {
       stv.StageName.push_back(stageName);
       stageNum = stv.StageName.size();
     }
 
     return stageNum;
   }

std::vector< int > tca::GetVtxTjIDs	(	const TjStuff &	tjs,
		const VtxStore &	vx2
	)

Definition at line 3022 of file TCVertex.cxx.

References tca::TjStuff::allTraj, tca::VtxStore::CTP, evd::details::end(), tca::VtxStore::ID, kKilled, and tmp.

Referenced by DefinePFPParentsTestBeam(), DefineTjParents(), GetVtxTjIDs(), Match3DVtxTjs(), MergeWithVertex(), PFPVxTjOK(), SetHighScoreBits(), SetVx2Score(), SharesHighScoreVx(), and SplitTrajCrossingVertices().

   {
     // returns a list of trajectory IDs that are attached to vx2
     std::vector<int> tmp;
     if(vx2.ID == 0) return tmp;
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       if(tj.CTP != vx2.CTP) continue;
       for(unsigned short end = 0; end < 2; ++end) {
         if(tj.VtxID[end] == vx2.ID) tmp.push_back(tj.ID);
       } // end
     } // tj
     return tmp;
   } // GetVtxTjIDs

std::vector< int > tca::GetVtxTjIDs	(	const TjStuff &	tjs,
		const Vtx3Store &	vx3,
		float &	score
	)

Definition at line 3039 of file TCVertex.cxx.

References GetVtxTjIDs(), tca::Vtx3Store::ID, tmp, and tca::TjStuff::vtx.

   {
     // returns a list of Tjs in all planes that are attached to vx3
     std::vector<int> tmp;
     if(vx3.ID == 0) return tmp;
     float nvx2 = 0;
     score = 0;
     for(auto& vx2 : tjs.vtx) {
       if(vx2.ID == 0) continue;
       if(vx2.Vx3ID != vx3.ID) continue;
       auto vtxTjID2 = GetVtxTjIDs(tjs, vx2);
       tmp.insert(tmp.end(), vtxTjID2.begin(), vtxTjID2.end());
       score += vx2.Score;
       ++nvx2;
     } // vx2
     if(nvx2 < 1) return tmp;
     // find the average score
     score /= nvx2;
     // sort by increasing ID
     std::sort(tmp.begin(), tmp.end());
     return tmp;
   } // GetVtxTjIDs

bool tca::HasDuplicateHits	(	TjStuff const &	tjs,
		Trajectory const &	tj,
		bool	prt
	)

Definition at line 2335 of file Utils.cxx.

References tca::TjStuff::fHits, kAllHits, PrintHit(), and PutTrajHitsInVector().

Referenced by tca::TrajClusterAlg::CheckTraj(), and MergeAndStore().

   {
     // returns true if a hit is associated with more than one TP
     auto tjHits = PutTrajHitsInVector(tj, kAllHits);
     for(unsigned short ii = 0; ii < tjHits.size() - 1; ++ii) {
       for(unsigned short jj = ii + 1; jj < tjHits.size(); ++jj) {
         if(tjHits[ii] == tjHits[jj]) {
           if(prt) mf::LogVerbatim("TC")<<"HDH: Hit "<<PrintHit(tjs.fHits[ii])<<" is a duplicate "<<ii<<" "<<jj;
           return true;
         }
       } // jj
     } // ii
     return false;
   } // HasDuplicateHits

float tca::HitSep2	(	TjStuff &	tjs,
		unsigned int	iht,
		unsigned int	jht
	)

Definition at line 2110 of file Utils.cxx.

References tca::TjStuff::fHits, and tca::TjStuff::UnitsPerTick.

Referenced by tca::TrajClusterAlg::FindJunkTraj().

   {
     // returns the separation^2 between two hits in WSE units
     if(iht > tjs.fHits.size()-1 || jht > tjs.fHits.size()-1) return 1E6;
     float dw = (float)tjs.fHits[iht].ArtPtr->WireID().Wire - (float)tjs.fHits[jht].ArtPtr->WireID().Wire;
     float dt = (tjs.fHits[iht].PeakTime - tjs.fHits[jht].PeakTime) * tjs.UnitsPerTick;
     return dw * dw + dt * dt;
   } // HitSep2

float tca::HitsPosTick	(	TjStuff &	tjs,
		const std::vector< unsigned int > &	hitsInMultiplet,
		float &	sum,
		HitStatus_t	hitRequest
	)

Definition at line 3645 of file Utils.cxx.

References tca::TjStuff::fHits, kAllHits, kUnusedHits, and kUsedHits.

Referenced by DotProd(), HitsPosTime(), tca::TrajClusterAlg::ReconstructAllTraj(), and TrajHitsOK().

   {
     // returns the position and the charge
     float pos = 0;
     sum = 0;
     for(unsigned short ii = 0; ii < hitsInMultiplet.size(); ++ii) {
       unsigned int iht = hitsInMultiplet[ii];
       bool useit = (hitRequest == kAllHits);
       if(hitRequest == kUsedHits && tjs.fHits[iht].InTraj > 0) useit = true;
       if(hitRequest == kUnusedHits && tjs.fHits[iht].InTraj == 0) useit = true;
       if(!useit) continue;
       float chg = tjs.fHits[iht].Integral;
       pos += chg * tjs.fHits[iht].PeakTime;
       sum += chg;
     } // ii
     if(sum == 0) return 0;
     return pos / sum;
   } // HitsPosTick

float tca::HitsPosTime	(	TjStuff &	tjs,
		const std::vector< unsigned int > &	hitsInMultiplet,
		float &	sum,
		HitStatus_t	hitRequest
	)

Definition at line 3639 of file Utils.cxx.

References HitsPosTick(), and tca::TjStuff::UnitsPerTick.

Referenced by DotProd().

   {
     return tjs.UnitsPerTick * HitsPosTick(tjs, hitsInMultiplet, sum, hitRequest);
   } // HitsPosTime

float tca::HitsRMSTick	(	TjStuff &	tjs,
		const std::vector< unsigned int > &	hitsInMultiplet,
		HitStatus_t	hitRequest
	)

Definition at line 3613 of file Utils.cxx.

References tca::TjStuff::fHits, kAllHits, kUnusedHits, and kUsedHits.

Referenced by DotProd(), tca::TrajClusterAlg::FindUseHits(), HitsRMSTime(), and tca::TrajClusterAlg::ReconstructAllTraj().

   {
     if(hitsInMultiplet.empty()) return 0;
     
     if(hitsInMultiplet.size() == 1) return tjs.fHits[hitsInMultiplet[0]].RMS;
  
     float minVal = 9999;
     float maxVal = 0;
     for(unsigned short ii = 0; ii < hitsInMultiplet.size(); ++ii) {
       unsigned int iht = hitsInMultiplet[ii];
       bool useit = (hitRequest == kAllHits);
       if(hitRequest == kUsedHits && tjs.fHits[iht].InTraj > 0) useit = true;
       if(hitRequest == kUnusedHits && tjs.fHits[iht].InTraj == 0) useit = true;
       if(!useit) continue;
       float cv = tjs.fHits[iht].PeakTime;
       float rms = tjs.fHits[iht].RMS;
       float arg = cv - rms;
       if(arg < minVal) minVal = arg;
       arg = cv + rms;
       if(arg > maxVal) maxVal = arg;
     } // ii
     if(maxVal == 0) return 0;
     return (maxVal - minVal) / 2;
   } // HitsRMSTick

float tca::HitsRMSTime	(	TjStuff &	tjs,
		const std::vector< unsigned int > &	hitsInMultiplet,
		HitStatus_t	hitRequest
	)

Definition at line 3607 of file Utils.cxx.

References HitsRMSTick(), and tca::TjStuff::UnitsPerTick.

Referenced by DotProd(), and tca::TrajClusterAlg::HitsTimeErr2().

   {
     return tjs.UnitsPerTick * HitsRMSTick(tjs, hitsInMultiplet, hitRequest);
   } // HitsRMSTick

double tca::InShowerProb	(	double	showerEnergy,
		double	along,
		double	trans
	)

float tca::InShowerProb	(	const TjStuff &	tjs,
		const ShowerStruct3D &	ss3,
		const PFPStruct &	pfp
	)

Definition at line 2172 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, tca::PFPStruct::ID, tca::ShowerStruct3D::ID, InShowerProb(), ss, and tca::PFPStruct::TjIDs.

   {
     // returns a likelihood (0 - 1) that the pfp particle belongs in shower ss3
     
     if(ss3.ID == 0 || pfp.ID == 0) return 0;
     float sum = 0;
     float cnt = 0;
     for(auto cid : ss3.CotIDs) {
       auto& ss = tjs.cots[cid - 1];
       if(ss.ID == 0) continue;
       for(auto tid : pfp.TjIDs) {
         auto& tj = tjs.allTraj[tid - 1];
         if(tj.CTP != ss.CTP) continue;
 //        std::cout<<"3S"<<ss3.ID<<" P"<<pfp.ID<<" ";
         sum += InShowerProb(tjs, ss, tj);
         ++cnt;
       } // tid
     } //cid
     if(cnt == 0) return 0;
     return sum / cnt;
 
   } // InShowerProb

float tca::InShowerProb	(	const TjStuff &	tjs,
		const ShowerStruct &	ss,
		const Trajectory &	tj
	)

Definition at line 2196 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::Trajectory::CTP, tca::ShowerStruct::CTP, DotProd(), FindAlongTrans(), tca::Trajectory::ID, tca::ShowerStruct::ID, PosSep(), tca::Trajectory::Pts, tca::ShowerStruct::ShowerTjID, and TrajTrajDOCA().

Referenced by InShowerProb(), and Reconcile3D().

   {
     // returns a likelihood (0 - 1) that the tj particle belongs in shower ss
     // Keep it simple: construct a FOM, take the inverse and limit it to the range 0 - 1
     if(ss.ID == 0 || tj.ID == 0) return 0;
     if(ss.CTP != tj.CTP) return 0;
     
     auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
     if(stj.Pts.size() != 3) return 0;
     unsigned short closePt1, closePt2;
     float doca = 1E6;
     TrajTrajDOCA(tjs, stj, tj, closePt1, closePt2, doca);
     if(doca == 1E6) return 0;
     float showerLen = PosSep(stj.Pts[0].Pos, stj.Pts[2].Pos);
     // make a rough separation cut. Return a small but non-zero value
     if(doca > 5 * showerLen) return 0.01;
     auto& stp = stj.Pts[closePt1];
     if(stp.DeltaRMS == 0) return 0;
     auto& ttp = tj.Pts[closePt2];
     Point2_t alongTrans;
     FindAlongTrans(stp.Pos, stp.Dir, ttp.Pos, alongTrans);
 //    std::cout<<"ISP: 2S"<<ss.ID<<" T"<<tj.ID<<" showerLen "<<(int)showerLen<<" closePt "<<closePt1;
 //    std::cout<<" closePt "<<closePt2<<" along "<<std::fixed<<std::setprecision(1)<<alongTrans[0]<<" "<<alongTrans[1];
     float rms = stp.DeltaRMS;
     if(rms < 1) rms = 1;
     float arg = alongTrans[1] / rms;
     float radProb = exp(-0.5 * arg * arg);
 //    std::cout<<" rms "<<rms<<" radProb "<<std::setprecision(3)<<radProb;
     // This is a fake but may be OK if this function is called before the shower is well-defined
     rms = showerLen;
     arg = alongTrans[0] / rms;
     float longProb = exp(-0.5 * arg * arg);
 //    std::cout<<" longProb "<<std::setprecision(3)<<longProb;
     float costh = std::abs(DotProd(stp.Dir, ttp.Dir));
 //    std::cout<<" costh "<<std::setprecision(3)<<costh;
     float prob = radProb * longProb * costh;
 //    std::cout<<" InShowerProb "<<std::setprecision(3)<<prob<<"\n";
     return prob;
 
   } // InShowerProb

double tca::InShowerProbLong	(	double	showerEnergy,
		double	along
	)

Definition at line 2118 of file TCShower.cxx.

References ShowerParams().

Referenced by FindParent(), InShowerProbParam(), MergeSubShowers(), ParentFOM(), and tca::TruthMatcher::StudyShowerParents().

   {
     // Returns the likelihood that the point at position along (cm) is inside an EM shower
     // having showerEnergy (MeV). The variable along is relative to shower max.
     
     if(showerEnergy < 10) return 0;
     
     double shMaxAlong, shE95Along;
     ShowerParams(showerEnergy, shMaxAlong, shE95Along);
     // 50% of the shower energy is deposited between 0 < shMaxAlong < 1, which should be obvious considering
     // that is the definition of the shower max, so the probability should be ~1 at shMaxAlong = 1.
     // The Geant study shows that 95% of the energy is contained within 2.5 * shMax and has a small dependence 
     // on the shower energy, which is modeled in ShowerParams. This function uses a
     // sigmoid likelihood function is constructed with these constraints using the scaling variable tau 
     double tau = (along + shMaxAlong) / shMaxAlong;
     if(tau < -1 || tau > 4) return 0;
     
     double tauHalf, width;
     if(tau > 0) {
       tauHalf = 1.7;
       width = 0.35;
     } else {
       // Allow for some uncertainty in the shower start position
       tau = -tau;
       tauHalf = 0.2;
       width = 0.1;
     }
 
     double prob = 1 / (1 + exp((tau - tauHalf)/width));
     return prob;
     
   } // InShowrProbLong

double tca::InShowerProbParam	(	double	showerEnergy,
		double	along,
		double	trans
	)

Definition at line 2166 of file TCShower.cxx.

References InShowerProbLong(), and InShowerProbTrans().

   {
     return InShowerProbLong(showerEnergy, along) * InShowerProbTrans(showerEnergy, along, trans);
   } // InShowerProbParam

double tca::InShowerProbTrans	(	double	showerEnergy,
		double	along,
		double	trans
	)

Definition at line 2152 of file TCShower.cxx.

References ShowerParamTransRMS().

Referenced by InShowerProbParam(), and MergeSubShowers().

   {
     // Returns the likelihood that the point, (along, trans) (cm), is inside an EM shower having energy showerEnergy (MeV)
     // where along is relative to the shower start position and trans is the radial distance. 
 
     if(showerEnergy < 10) return 0;
     double rms = ShowerParamTransRMS(showerEnergy, along);
     trans = std::abs(trans);
     double prob = exp(-0.5 * trans / rms);
     return prob;
     
   } // InShowerProbTrans

bool tca::InsideTPC	(	const TjStuff &	tjs,
		Point3_t &	pos,
		geo::TPCID &	inTPCID
	)

Definition at line 2725 of file PFPUtils.cxx.

References geo::GeometryCore::DetHalfHeight(), geo::GeometryCore::DetHalfWidth(), geo::GeometryCore::DetLength(), tca::TjStuff::geom, geo::GeometryCore::IterateTPCIDs(), geo::TPCGeo::LocalToWorld(), and geo::GeometryCore::TPC().

Referenced by DotProd(), tca::TruthMatcher::MatchTruth(), and tca::TruthMatcher::StudyShowerParents().

   {
     // determine which TPC this point is in. This function returns false
     // if the point is not inside any TPC
     double abit = -2;
     for (const geo::TPCID& tpcid: tjs.geom->IterateTPCIDs()) {
       const geo::TPCGeo& TPC = tjs.geom->TPC(tpcid);
       double local[3] = {0.,0.,0.};
       double world[3] = {0.,0.,0.};
       TPC.LocalToWorld(local,world);
       unsigned int cstat = tpcid.Cryostat;
       unsigned int tpc = tpcid.TPC;
       // reduce the active area of the TPC by 1 cm to be consistent with FillWireHitRange
       if(pos[0] < world[0]-tjs.geom->DetHalfWidth(tpc,cstat) + abit) continue;
       if(pos[0] > world[0]+tjs.geom->DetHalfWidth(tpc,cstat) - abit) continue;
       if(pos[1] < world[1]-tjs.geom->DetHalfHeight(tpc,cstat) + abit) continue;
       if(pos[1] > world[1]+tjs.geom->DetHalfHeight(tpc,cstat) - abit) continue;
       if(pos[2] < world[2]-tjs.geom->DetLength(tpc,cstat)/2 + abit) continue;
       if(pos[2] > world[2]+tjs.geom->DetLength(tpc,cstat)/2 - abit) continue;
       inTPCID = tpcid;
       return true;
     } // tpcid
     return false;
   } // InsideTPC

bool tca::InTrajOK	(	TjStuff &	tjs,
		std::string	someText
	)

Definition at line 1199 of file Utils.cxx.

References AlgBitNames, tca::TjStuff::allTraj, evd::details::end(), tca::TjStuff::fHits, kKilled, kUsedHits, PrintHit(), PrintTrajectory(), PutTrajHitsInVector(), and tca::TjStuff::vtx.

Referenced by tca::TrajClusterAlg::FindVtxTraj(), tca::TrajClusterAlg::MakeAllTrajClusters(), tca::TrajClusterAlg::MakeJunkTraj(), and tca::TrajClusterAlg::ReconstructAllTraj().

   {
     // Check tjs.allTraj -> InTraj associations
     
     unsigned short tID;
     unsigned int iht;
     unsigned short itj = 0;
     std::vector<unsigned int> tHits;
     std::vector<unsigned int> atHits;
     for(auto& tj : tjs.allTraj) {
       // ignore abandoned trajectories
       if(tj.AlgMod[kKilled]) continue;
       tID = tj.ID;
       if(tj.AlgMod[kKilled]) {
         std::cout<<someText<<" ChkInTraj hit size mis-match in tj ID "<<tj.ID<<" AlgBitNames";
         for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(tj.AlgMod[ib]) std::cout<<" "<<AlgBitNames[ib];
         std::cout<<"\n";
         continue;
       }
       tHits = PutTrajHitsInVector(tj, kUsedHits);
       if(tHits.size() < 2) {
         std::cout<<someText<<" ChkInTraj: Insufficient hits in traj "<<tj.ID<<"\n";
         PrintTrajectory("CIT", tjs, tj, USHRT_MAX);
         continue;
       }
       std::sort(tHits.begin(), tHits.end());
       atHits.clear();
       for(iht = 0; iht < tjs.fHits.size(); ++iht) {
         if(tjs.fHits[iht].InTraj == tID) atHits.push_back(iht);
       } // iht
       if(atHits.size() < 2) {
         std::cout<<someText<<" ChkInTraj: Insufficient hits in atHits in traj "<<tj.ID<<" Killing it\n";
         tj.AlgMod[kKilled] = true;
         continue;
       }
       if(!std::equal(tHits.begin(), tHits.end(), atHits.begin())) {
         mf::LogVerbatim myprt("TC");
         myprt<<someText<<" ChkInTraj failed: inTraj - UseHit mis-match for T"<<tID<<" tj.WorkID "<<tj.WorkID<<" atHits size "<<atHits.size()<<" tHits size "<<tHits.size()<<" in CTP "<<tj.CTP<<"\n";
         myprt<<"AlgMods: ";
         for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(tj.AlgMod[ib]) myprt<<" "<<AlgBitNames[ib];
         myprt<<"\n";
         myprt<<"index     inTraj     UseHit \n";
         for(iht = 0; iht < atHits.size(); ++iht) {
           myprt<<"iht "<<iht<<" "<<PrintHit(tjs.fHits[atHits[iht]]);
           if(iht < tHits.size()) myprt<<" "<<PrintHit(tjs.fHits[tHits[iht]]);
           if(atHits[iht] != tHits[iht]) myprt<<" <<< "<<atHits[iht]<<" != "<<tHits[iht];
           myprt<<"\n";
         } // iht
         if(tHits.size() > atHits.size()) {
           for(iht = atHits.size(); iht < atHits.size(); ++iht) {
             myprt<<"atHits "<<iht<<" "<<PrintHit(tjs.fHits[atHits[iht]])<<"\n";
           } // iht
           PrintTrajectory("CIT", tjs, tj, USHRT_MAX);
         } // tHit.size > atHits.size()
         return false;
       }
       // check the VtxID
       for(unsigned short end = 0; end < 2; ++end) {
         if(tj.VtxID[end] > tjs.vtx.size()) {
           mf::LogVerbatim("TC")<<someText<<" ChkInTraj: Bad VtxID "<<tj.ID;
           std::cout<<someText<<" ChkInTraj: Bad VtxID "<<tj.ID<<" vtx size "<<tjs.vtx.size()<<"\n";
           tj.AlgMod[kKilled] = true;
           PrintTrajectory("CIT", tjs, tj, USHRT_MAX);
           return false;
         }
       } // end
       ++itj;
     } // tj
     return true;
     
   } // InTrajOK

unsigned short tca::IsCloseToVertex	(	TjStuff &	tjs,
		VtxStore &	inVx2
	)

Definition at line 3093 of file TCVertex.cxx.

References tca::TjStuff::Vertex2DCuts, VertexVertexPull(), and tca::TjStuff::vtx.

Referenced by Find2DVertices().

   {
     // Returns the ID of a 2D vertex having the minimum pull < user-specified cut
     
     float minPull = tjs.Vertex2DCuts[3];
     unsigned short imBest = 0;
     for(auto& vx2 : tjs.vtx) {
       float pull = VertexVertexPull(tjs, inVx2, vx2);
       if(pull < minPull) {
         minPull = pull;
         imBest = vx2.ID;
       }
     } // vx2
     return imBest;
   } // IsCloseToVertex

unsigned short tca::IsCloseToVertex	(	TjStuff &	tjs,
		Vtx3Store &	vx3
	)

Definition at line 3110 of file TCVertex.cxx.

References tca::TjStuff::Vertex3DCuts, VertexVertexPull(), tca::TjStuff::vtx3, and tca::Vtx3Store::X.

   {
     // Returns the ID of a 3D vertex having the minimum pull < user-specified cut
     
     float minPull = tjs.Vertex3DCuts[1];
     unsigned short imBest = 0;
     for(auto& oldvx3 : tjs.vtx3) {
       if(oldvx3.ID == 0) continue;
       if(std::abs(oldvx3.X - vx3.X) > tjs.Vertex3DCuts[0]) continue;
       float pull = VertexVertexPull(tjs, vx3, oldvx3);
       if(pull < minPull) {
         minPull = pull;
         imBest = oldvx3.ID;
       }
     } // oldvx3
     return imBest;
     
   } // IsCloseToVertex

bool tca::IsShowerLike	(	const TjStuff &	tjs,
		const std::vector< int >	TjIDs
	)

Definition at line 2071 of file TCShower.cxx.

References tca::TjStuff::allTraj, and kShowerLike.

Referenced by DefineDontCluster(), DefinePFPParents(), and PrintPFP().

   {
     // Vote for the list of Tjs (assumed associated with a PFParticle) being shower-like
     if(TjIDs.empty()) return false;
     unsigned short cnt = 0;
     for(auto tid : TjIDs) {
       if(tid <= 0 || tid > (int)tjs.allTraj.size()) continue;
       if(tjs.allTraj[tid - 1].AlgMod[kShowerLike] > 0) ++cnt;
     } // tjid
     return (cnt > 1);
   } // IsInShower

void tca::KillPoorVertices	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid
	)

Definition at line 2233 of file TCVertex.cxx.

References geo::CryostatID::Cryostat, DecodeCTP(), MakeVertexObsolete(), geo::TPCID::TPC, tca::TjStuff::Vertex2DCuts, tca::TjStuff::vtx, and tca::TjStuff::vtx3.

Referenced by tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // kill 2D vertices that have low score and are not attached to a high-score 3D vertex
     if(tjs.vtx.empty()) return;
     unsigned int cstat = tpcid.Cryostat;
     unsigned int tpc = tpcid.TPC;
     for(auto& vx : tjs.vtx) {
       if(vx.ID == 0) continue;
       geo::PlaneID planeID = DecodeCTP(vx.CTP);
       if(planeID.Cryostat != cstat) continue;
       if(planeID.TPC != tpc) continue;
       if(vx.Score > tjs.Vertex2DCuts[7]) continue;
       if(vx.Vx3ID > 0) {
         auto& vx3 = tjs.vtx3[vx.Vx3ID - 1];
         if(vx3.Primary) continue;
         if(tjs.vtx3[vx.Vx3ID - 1].Score >= tjs.Vertex2DCuts[7]) continue;
       }
       MakeVertexObsolete(tjs, vx, false);
     } // vx
     
   } // KillPoorVertices

void tca::KillVerticesInShower	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 767 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::ShowerStruct::CTP, tca::TjStuff::dontCluster, tca::ShowerStruct::Envelope, GetAssns(), tca::ShowerStruct::ID, kKillInShowerVx, MakeVertexObsolete(), PointInsideEnvelope(), tca::TjStuff::UseAlg, tca::TjStuff::vtx, and tca::TjStuff::vtx3.

Referenced by MergeShowersAndStore().

   {
     // make the vertices inside the shower envelope obsolete and update dontCluster
     if(ss.ID == 0) return;
     if(!tjs.UseAlg[kKillInShowerVx]) return;
     std::string fcnLabel = inFcnLabel + ".KVIS";
     
     for(auto& vx2 : tjs.vtx) {
       if(vx2.ID == 0) continue;
       if(vx2.CTP != ss.CTP) continue;
       // ensure it isn't associated with a neutrino vertex
       if(vx2.Vx3ID > 0 && tjs.vtx3[vx2.Vx3ID - 1].Neutrino) continue;
       if(!PointInsideEnvelope(vx2.Pos, ss.Envelope)) continue;
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Clobber 2V"<<vx2.ID<<" -> 3V"<<vx2.Vx3ID<<" inside 2S"<<ss.ID;
       // update dontCluster
       for(auto& dc : tjs.dontCluster) {
         if(dc.TjIDs[0] == 0) continue;
         if(dc.Vx2ID != vx2.ID) continue;
         if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Remove T"<<dc.TjIDs[0]<<"-T"<<dc.TjIDs[0]<<" in dontCluster";
         dc.TjIDs[0] = 0;
         dc.TjIDs[1] = 0;
       } // dc
       if(vx2.Vx3ID > 0) {
         auto TIn3V = GetAssns(tjs, "3V", vx2.Vx3ID, "T");
         for(auto tid : TIn3V) tjs.allTraj[tid - 1].AlgMod[kKillInShowerVx] = true;
         auto& vx3 = tjs.vtx3[vx2.Vx3ID - 1];
         MakeVertexObsolete(tjs, vx3);
       } else {
         auto TIn2V = GetAssns(tjs, "2V", vx2.ID, "T");
         for(auto tid : TIn2V) tjs.allTraj[tid - 1].AlgMod[kKillInShowerVx] = true;
         MakeVertexObsolete(tjs, vx2, true);
       }
     } // vx2
     
   } // KillVerticesInShower

double tca::KinkAngle	(	const TjStuff &	tjs,
		const std::vector< TrajPoint3 > &	tp3s,
		unsigned short	atPt,
		double	sep
	)

Definition at line 1913 of file PFPUtils.cxx.

References DeltaAngle(), and PosSep2().

Referenced by DotProd(), FindKinks(), PrintTp3s(), and Split3DKink().

   {
     // calculate a kink angle at the TjPt 
     if(tp3s.empty()) return -1;
     if(atPt < 1 || atPt > tp3s.size() - 2) return -1;
     double sep2 = sep * sep;
     unsigned short pt1 = USHRT_MAX;
     for(unsigned short ii = 1; ii < tp3s.size(); ++ii) {
       unsigned short ipt = atPt - ii;
       if(PosSep2(tp3s[atPt].Pos, tp3s[ipt].Pos) > sep2) {
         pt1 = ipt;
         break;
       }
       if(ipt == 0) break;
     } // ii
     if(pt1 == USHRT_MAX) return -1;
     unsigned short pt2 = USHRT_MAX;
     for(unsigned short ii = 1; ii < tp3s.size(); ++ii) {
       unsigned short ipt = atPt + ii;
       if(ipt == tp3s.size()) break;
       if(PosSep2(tp3s[atPt].Pos, tp3s[ipt].Pos) > sep2) {
         pt2 = ipt;
         break;
       }
     } // ii
     if(pt2 == USHRT_MAX) return -1;
     return DeltaAngle(tp3s[pt1].Dir, tp3s[pt2].Dir);
   } // KinkAngle

float tca::LengthInCTP	(	TjStuff &	tjs,
		std::vector< int > &	tjids,
		CTP_t	inCTP
	)

Definition at line 1106 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, and PosSep2().

   {
     // Calculates the maximum length between the end points of Tjs in the list of tjids in inCTP
     if(tjids.empty()) return 0;
     // put the end point positions into a vector
     std::vector<Point2_t> endPos;
     for(auto tjid : tjids) {
       auto& tj = tjs.allTraj[tjid - 1];
       if(tj.CTP != inCTP) continue;
       endPos.push_back(tj.Pts[tj.EndPt[0]].Pos);
       endPos.push_back(tj.Pts[tj.EndPt[1]].Pos);
     } // tjid
     if(endPos.size() < 2) return 0;
     float extent = 0;
     for(unsigned short pt1 = 0; pt1 < endPos.size() - 1; ++pt1) {
       for(unsigned short pt2 = pt1 + 1; pt2 < endPos.size(); ++pt2) {
         float sep = PosSep2(endPos[pt1], endPos[pt2]);
         if(sep > extent) extent = sep;
       } // pt2
     } // pt1
     return sqrt(extent);
   } // LengthInCTP

bool tca::LineLineIntersect	(	Point3_t	p1,
		Point3_t	p2,
		Point3_t	p3,
		Point3_t	p4,
		Point3_t &	intersect,
		float &	doca
	)

Definition at line 2781 of file PFPUtils.cxx.

References min, and PosSep().

Referenced by DotProd(), and PointDirIntersect().

   {
     /*
      Calculate the line segment PaPb that is the shortest route between
      two lines P1P2 and P3P4. Calculate also the values of mua and mub where
      Pa = P1 + mua (P2 - P1)
      Pb = P3 + mub (P4 - P3)
      Return FALSE if no solution exists.
      http://paulbourke.net/geometry/pointlineplane/
      */
 
     Point3_t p13, p43, p21;
     double d1343,d4321,d1321,d4343,d2121;
     double numer,denom;
     constexpr double EPS = std::numeric_limits<double>::min();
     
     p13[0] = p1[0] - p3[0];
     p13[1] = p1[1] - p3[1];
     p13[2] = p1[2] - p3[2];
     p43[0] = p4[0] - p3[0];
     p43[1] = p4[1] - p3[1];
     p43[2] = p4[2] - p3[2];
     if (std::abs(p43[0]) < EPS && std::abs(p43[1]) < EPS && std::abs(p43[2]) < EPS) return(false);
     p21[0] = p2[0] - p1[0];
     p21[1] = p2[1] - p1[1];
     p21[2] = p2[2] - p1[2];
     if (std::abs(p21[0]) < EPS && std::abs(p21[1]) < EPS && std::abs(p21[2]) < EPS) return(false);
     
     d1343 = p13[0] * p43[0] + p13[1] * p43[1] + p13[2] * p43[2];
     d4321 = p43[0] * p21[0] + p43[1] * p21[1] + p43[2] * p21[2];
     d1321 = p13[0] * p21[0] + p13[1] * p21[1] + p13[2] * p21[2];
     d4343 = p43[0] * p43[0] + p43[1] * p43[1] + p43[2] * p43[2];
     d2121 = p21[0] * p21[0] + p21[1] * p21[1] + p21[2] * p21[2];
     
     denom = d2121 * d4343 - d4321 * d4321;
     if (std::abs(denom) < EPS) return(false);
     numer = d1343 * d4321 - d1321 * d4343;
     
     double mua = numer / denom;
     double mub = (d1343 + d4321 * mua) / d4343;
     
     intersect[0] = p1[0] + mua * p21[0];
     intersect[1] = p1[1] + mua * p21[1];
     intersect[2] = p1[2] + mua * p21[2];
     Point3_t pb;
     pb[0] = p3[0] + mub * p43[0];
     pb[1] = p3[1] + mub * p43[1];
     pb[2] = p3[2] + mub * p43[2];
     doca = PosSep(intersect, pb);
     // average the closest points
     for(unsigned short xyz = 0; xyz < 3; ++xyz) intersect[xyz] += pb[xyz];
     for(unsigned short xyz = 0; xyz < 3; ++xyz) intersect[xyz] /= 2;
     return true;
   } // LineLineIntersect

TrajPoint tca::MakeBareTP	(	TjStuff &	tjs,
		Point3_t &	pos,
		Vector3_t &	dir,
		CTP_t	inCTP
	)

Definition at line 3435 of file Utils.cxx.

References tca::TrajPoint::Ang, detinfo::DetectorProperties::ConvertXToTicks(), tca::TrajPoint::CTP, DecodeCTP(), tca::TrajPoint::Delta, tca::TjStuff::detprop, tca::TrajPoint::Dir, tca::TjStuff::geom, tca::TjStuff::MaxPos0, norm, geo::PlaneID::Plane, tca::TrajPoint::Pos, tca::TjStuff::UnitsPerTick, and geo::GeometryCore::WireCoordinate().

Referenced by DotProd(), FindMissedTjsInTp3s(), FindNeutralVertices(), FindParent(), FindPFParticles(), FindShowerStart(), tca::MCParticleListUtils::MakeTruTrajPoint(), tca::TruthMatcher::MatchTruth(), PrintShowers(), SetParent(), and tca::TruthMatcher::StudyShowerParents().

   {
     // Projects the space point defined by pos and dir into the CTP and returns it in the form of a trajectory point.
     // The TP Pos[0] is set to a negative number if the point has an invalid wire position but doesn't return an
     // error if the position is on a dead wire. The projection of the direction vector in CTP is stored in tp.Delta.
     TrajPoint tp;
     tp.Pos = {{0,0}};
     tp.Dir = {{0,1}};
     tp.CTP = inCTP;
     geo::PlaneID planeID = DecodeCTP(inCTP);
     
     tp.Pos[0] = tjs.geom->WireCoordinate(pos[1], pos[2], planeID);
     if(tp.Pos[0] < 0 || (!tjs.MaxPos0.empty() && tp.Pos[0] > tjs.MaxPos0[planeID.Plane])) {
       tp.Pos[0] = -1;
       return tp;
     }
     tp.Pos[1] = tjs.detprop->ConvertXToTicks(pos[0], planeID) * tjs.UnitsPerTick;
     
     // now find the direction if dir is defined
     if(dir[0] == 0 && dir[1] == 0 && dir[2] == 0) return tp;
     // Make a point at the origin and one 100 units away
     // BUG the double brace syntax is required to work around clang bug 21629
     // (https://bugs.llvm.org/show_bug.cgi?id=21629)
     Point3_t ori3 = {{0.0, 0.0, 0.0}};
     Point3_t pos3 = {{100 * dir[0], 100 * dir[1], 100 * dir[2]}};
     // 2D position of ori3 and the pos3 projection
     std::array<double, 2> ori2;
     std::array<double, 2> pos2;
     std::array<double, 2> dir2;
     // the wire coordinates
     ori2[0] = tjs.geom->WireCoordinate(ori3[1], ori3[2], planeID);
     pos2[0] = tjs.geom->WireCoordinate(pos3[1], pos3[2], planeID);
     // the time coordinates
     ori2[1] = tjs.detprop->ConvertXToTicks(ori3[0], planeID) * tjs.UnitsPerTick;
     pos2[1] = tjs.detprop->ConvertXToTicks(pos3[0], planeID) * tjs.UnitsPerTick;
     
     dir2[0] = pos2[0] - ori2[0];
     dir2[1] = pos2[1] - ori2[1];
     
     double norm = sqrt(dir2[0] * dir2[0] + dir2[1] * dir2[1]);
     tp.Dir[0] = dir2[0] / norm;
     tp.Dir[1] = dir2[1] / norm;
     tp.Ang = atan2(dir2[1], dir2[0]);
     tp.Delta = norm / 100;
     
     // The Orth vectors are not unit normalized so we need to correct for this
     double w0 = tjs.geom->WireCoordinate(0, 0, planeID);
     // cosine-like component
     double cs = tjs.geom->WireCoordinate(1, 0, planeID) - w0;
     // sine-like component
     double sn = tjs.geom->WireCoordinate(0, 1, planeID) - w0;
     norm = sqrt(cs * cs + sn * sn);
     tp.Delta /= norm;
     
     return tp;
   } // MakeBareTP

bool tca::MakeBareTrajPoint	(	const TjStuff &	tjs,
		unsigned int	fromHit,
		unsigned int	toHit,
		TrajPoint &	tp
	)

Definition at line 3493 of file Utils.cxx.

References EncodeCTP(), tca::TjStuff::fHits, and MakeBareTrajPoint().

Referenced by DotProd(), tca::TrajClusterAlg::EndMerge(), tca::TrajClusterAlg::FillGaps(), tca::TrajClusterAlg::GottaKink(), MergeShowerChain(), ParentFOM(), and tca::TrajClusterAlg::StartTraj().

   {
     CTP_t tCTP = EncodeCTP(tjs.fHits[fromHit].ArtPtr->WireID());
     return MakeBareTrajPoint(tjs, (float)tjs.fHits[fromHit].ArtPtr->WireID().Wire, tjs.fHits[fromHit].PeakTime,
                                   (float)tjs.fHits[toHit].ArtPtr->WireID().Wire,   tjs.fHits[toHit].PeakTime, tCTP, tp);
     
   } // MakeBareTrajPoint

bool tca::MakeBareTrajPoint	(	const TjStuff &	tjs,
		float	fromWire,
		float	fromTick,
		float	toWire,
		float	toTick,
		CTP_t	tCTP,
		TrajPoint &	tp
	)

Definition at line 3502 of file Utils.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::CTP, tca::TrajPoint::Dir, norm, tca::TrajPoint::Pos, and tca::TjStuff::UnitsPerTick.

   {
     tp.CTP = tCTP;
     tp.Pos[0] = fromWire;
     tp.Pos[1] = tjs.UnitsPerTick * fromTick;
     tp.Dir[0] = toWire - fromWire;
     tp.Dir[1] = tjs.UnitsPerTick * (toTick - fromTick);
     double norm = sqrt(tp.Dir[0] * tp.Dir[0] + tp.Dir[1] * tp.Dir[1]);
     if(norm == 0) return false;
     tp.Dir[0] /= norm;
     tp.Dir[1] /= norm;
     tp.Ang = atan2(tp.Dir[1], tp.Dir[0]);
     return true;
   } // MakeBareTrajPoint

bool tca::MakeBareTrajPoint	(	const Point2_t &	fromPos,
		const Point2_t &	toPos,
		TrajPoint &	tpOut
	)

Definition at line 3518 of file Utils.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::Dir, PointDirection(), and tca::TrajPoint::Pos.

   {
     tpOut.Pos = fromPos;
     tpOut.Dir = PointDirection(fromPos, toPos);
 /*
     tpOut.Dir[0] = toPos[0] - fromPos[0];
     tpOut.Dir[1] = toPos[1] - fromPos[1];
     double norm = sqrt(tpOut.Dir[0] * tpOut.Dir[0] + tpOut.Dir[1] * tpOut.Dir[1]);
     if(norm == 0) return false;
     tpOut.Dir[0] /= norm;
     tpOut.Dir[1] /= norm;
 */
     tpOut.Ang = atan2(tpOut.Dir[1], tpOut.Dir[0]);
     return true;
     
   } // MakeBareTrajPoint

bool tca::MakeBareTrajPoint	(	const TjStuff &	tjs,
		const TrajPoint &	tpIn1,
		const TrajPoint &	tpIn2,
		TrajPoint &	tpOut
	)

Definition at line 3536 of file Utils.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::CTP, tca::TrajPoint::Dir, PointDirection(), and tca::TrajPoint::Pos.

Referenced by FindCloseTjs(), MakeBareTrajPoint(), SignalBetween(), TjDeltaRMS(), and UpdateVxEnvironment().

   {
     tpOut.CTP = tpIn1.CTP;
     tpOut.Pos = tpIn1.Pos;
     tpOut.Dir = PointDirection(tpIn1.Pos, tpIn2.Pos);
 /*
     tpOut.Dir[0] = tpIn2.Pos[0] - tpIn1.Pos[0];
     tpOut.Dir[1] = tpIn2.Pos[1] - tpIn1.Pos[1];
     double norm = sqrt(tpOut.Dir[0] * tpOut.Dir[0] + tpOut.Dir[1] * tpOut.Dir[1]);
     if(norm == 0) return false;
     tpOut.Dir[0] /= norm;
     tpOut.Dir[1] /= norm;
 */
     tpOut.Ang = atan2(tpOut.Dir[1], tpOut.Dir[0]);
     return true;
   } // MakeBareTrajPoint

void tca::MakeJunkTjVertices	(	TjStuff &	tjs,
		const CTP_t &	inCTP
	)

void tca::MakeJunkVertices	(	TjStuff &	tjs,
		const CTP_t &	inCTP
	)

Definition at line 14 of file TCVertex.cxx.

References tca::TjStuff::allTraj, close(), tca::VtxStore::CTP, debug, DecodeCTP(), FindCloseTjs(), tca::VtxStore::ID, kFixed, kJunkTj, kJunkVx, kKilled, kShowerLike, tca::DebugStuff::Plane, geo::PlaneID::Plane, tca::VtxStore::Pos, tca::VtxStore::PosErr, PosSep(), tca::VtxStore::Score, SignalBetween(), tca::VtxStore::Stat, StoreVertex(), tca::DebugStuff::Tick, tca::VtxStore::Topo, TrajLength(), tca::TjStuff::UnitsPerTick, tca::TjStuff::UseAlg, tca::TjStuff::Vertex2DCuts, and tca::TjStuff::vtx.

Referenced by tca::TrajClusterAlg::ReconstructAllTraj().

   {
     // Vertices between poorly reconstructed tjs (especially junk tjs) and normal
     // tjs can fail because the junk tj trajectory parameters are inaccurate. This function
     // uses proximity and not pointing to make junk vertices
     // Don't use this if standard vertex reconstruction is disabled
     if(tjs.Vertex2DCuts[0] <= 0) return;
     if(!tjs.UseAlg[kJunkVx]) return;
     if(tjs.allTraj.size() < 2) return;
     
     // Look for tjs that are within maxSep of the end of a Tj
     constexpr float maxSep = 4;
     
     geo::PlaneID planeID = DecodeCTP(inCTP);
     bool prt = (debug.Plane == (int)planeID.Plane && debug.Tick == 99999);
     if(prt) {
       mf::LogVerbatim("TC")<<"MakeJunkVertices: prt set for plane "<<planeID.Plane<<" maxSep btw tjs "<<maxSep;
 //      PrintAllTraj("MJTi", tjs, debug, USHRT_MAX, tjs.allTraj.size());
     }
     
     // make a template vertex
     VtxStore junkVx;
     junkVx.CTP = inCTP;
     junkVx.Topo = 9;
     junkVx.Stat[kJunkVx] = true;
     junkVx.Stat[kFixed] = true;
     // set an invalid ID
     junkVx.ID = USHRT_MAX;
     // put in generous errors
     // BUG the double brace syntax is required to work around clang bug 21629
     // (https://bugs.llvm.org/show_bug.cgi?id=21629)
     junkVx.PosErr = {{2.0, 2.0}};
     // define a minimal score so it won't get clobbered
     junkVx.Score = tjs.Vertex2DCuts[7] + 0.1;
 
     // look at both ends of long tjs
     for(unsigned short it1 = 0; it1 < tjs.allTraj.size() - 1; ++it1) {
       auto& tj1 = tjs.allTraj[it1];
       if(tj1.AlgMod[kKilled]) continue;
       if(tj1.SSID > 0 || tj1.AlgMod[kShowerLike]) continue;
       if(tj1.CTP != inCTP) continue;
       if(tj1.AlgMod[kJunkTj]) continue;
       if(TrajLength(tj1) < 10) continue;
       if(tj1.MCSMom < 100) continue;
       for(unsigned short end1 = 0; end1 < 2; ++end1) {
         // existing vertex?
         if(tj1.VtxID[end1] > 0) continue;
         auto& tp1 = tj1.Pts[tj1.EndPt[end1]];
         // get a list of tjs in this vicinity
         auto tjlist = FindCloseTjs(tjs, tp1, tp1, maxSep);
         if(tjlist.empty()) continue;
         // set to an invalid ID
         junkVx.ID = USHRT_MAX;
         for(auto tj2id : tjlist) {
           auto& tj2 = tjs.allTraj[tj2id - 1];
           if(tj2.CTP != inCTP) continue;
           if(tj2id == tj1.ID) continue;
           if(tj2.SSID > 0 || tj2.AlgMod[kShowerLike]) continue;
           float close = maxSep;
           unsigned short closeEnd = USHRT_MAX;
           for(unsigned short end2 = 0; end2 < 2; ++end2) {
             auto& tp2 = tj2.Pts[tj2.EndPt[end2]];
             float sep = PosSep(tp1.Pos, tp2.Pos);
             if(sep < close) {
               close = sep;
               closeEnd = end2;
             } // sep
           } // end2
           if(closeEnd > 1) continue;
           auto& tp2 = tj2.Pts[tj2.EndPt[closeEnd]];
           bool signalBetween = SignalBetween(tjs, tp1, tp2, 0.8, prt);
           if(!signalBetween) continue;
           if(junkVx.ID == USHRT_MAX) {
             // define the new vertex
             junkVx.ID = tjs.vtx.size() + 1;
             junkVx.Pos = tp1.Pos;
           } // new vertex
           tj2.VtxID[closeEnd] = junkVx.ID;
           tj1.VtxID[end1] = junkVx.ID;
         } // tjid
         if(junkVx.ID == USHRT_MAX) continue;
         if(!StoreVertex(tjs, junkVx)) {
           mf::LogVerbatim("TC")<<"MJV: StoreVertex failed";
           for(auto& tj : tjs.allTraj) {
             if(tj.AlgMod[kKilled]) continue;
             if(tj.VtxID[0] == junkVx.ID) tj.VtxID[0] = 0;
             if(tj.VtxID[1] == junkVx.ID) tj.VtxID[1] = 0;
           } // tj
           continue;
         } // StoreVertex failed
         if(prt) {
           mf::LogVerbatim("TC")<<" New junk 2V"<<junkVx.ID<<" at "<<std::fixed<<std::setprecision(1)<<junkVx.Pos[0]<<":"<<junkVx.Pos[1]/tjs.UnitsPerTick;
         } // prt
         junkVx.ID = USHRT_MAX;
       } // end1
     } // it1
     
   } // MakeJunkVertices

void tca::MakeShowerObsolete	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 3310 of file TCShower.cxx.

References tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, tca::ShowerStruct3D::ID, tca::ShowerStruct3D::PFPIndex, tca::TjStuff::pfps, and ss.

   {
     // set the ss3 ID = 0 and remove 2D shower -> 3D shower associations. The 2D showers are not
     // declared obsolete
     for(auto cid : ss3.CotIDs) {
       if(cid == 0 || (unsigned short)cid > tjs.cots.size()) continue;
       auto& ss = tjs.cots[cid - 1];
       if(ss.SS3ID > 0 && ss.SS3ID != ss3.ID) {
         std::cout<<"MakeShowerObsolete:  3S"<<ss3.ID<<" -> 2S"<<ss.ID<<" SS3ID 3S"<<ss.SS3ID<<" != "<<ss3.ID<<"\n";
         continue;
       }
       ss.SS3ID = 0;
     } // cid
     if(prt) {
       std::string fcnLabel = inFcnLabel + ".MSO";
       mf::LogVerbatim("TC")<<fcnLabel<<" Killed  3S"<<ss3.ID;
     }
     if(ss3.PFPIndex < tjs.pfps.size()) {
       std::cout<<"MakeShowerObsolete:  3S"<<ss3.ID<<" -> P"<<ss3.PFPIndex+1<<" assn exists but maybe shouldn't...";
     }
     ss3.ID = 0;
   } // MakeShowerObsolete

void tca::MakeShowerObsolete	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3334 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::ShowerStruct::ID, kKilled, kMergeNrShowers, kMergeOverlap, kMergeShChain, kMergeSubShowers, kShwrParent, MakeTrajectoryObsolete(), tca::TjStuff::showers, tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::SS3ID, tca::Trajectory::SSID, and tca::ShowerStruct::TjIDs.

Referenced by CompleteIncompleteShower(), FindShowers3D(), Match2DShowers(), MergeShowers(), Reconcile3D(), and RemoveTj().

   {
     // Gracefully kills the shower and the associated shower Tj
     
     if(ss.ID == 0) return;
     
     std::string fcnLabel = inFcnLabel + ".MSO";
     
     auto& stp1 = tjs.allTraj[ss.ShowerTjID - 1].Pts[1];
     if(!stp1.Hits.empty()) {
       std::cout<<fcnLabel<<" Trying to kill shower "<<ss.ID<<" that has hits associated with it. Don't do this...\n";
     }
     
     // clear a 3S -> 2S assn
     if(ss.SS3ID > 0 && ss.SS3ID <= (int)tjs.showers.size()) {
       auto& ss3 = tjs.showers[ss.SS3ID - 1];
       std::vector<int> newCIDs;
       for(auto cid : ss3.CotIDs) {
         if(cid != ss.ID) newCIDs.push_back(cid);
       } // cid
       ss3.CotIDs = newCIDs;
     } // ss3 assn exists
     
     // Kill the shower Tj if it exists. This also releases the hits
     if(ss.ShowerTjID > 0) MakeTrajectoryObsolete(tjs, ss.ShowerTjID - 1);
     
     // Restore the original InShower Tjs
     // Unset the killed bit
     for(auto& tjID : ss.TjIDs) {
       Trajectory& tj = tjs.allTraj[tjID - 1];
       tj.AlgMod[kKilled] = false;
       // clear all of the shower-related bits
       tj.SSID = 0;
       tj.AlgMod[kShwrParent] = false;
       tj.AlgMod[kMergeOverlap] = false;
       tj.AlgMod[kMergeSubShowers] = false;
       tj.AlgMod[kMergeNrShowers] = false;
       tj.AlgMod[kMergeShChain] = false;
     } // tjID
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Killed 2S"<<ss.ID<<" and ST"<<ss.ShowerTjID;
     ss.ID = 0;
     // No reason to do this
 //    ss.TjIDs.clear();
     
   } // MakeShowerObsolete

bool tca::MakeTp3	(	TjStuff &	tjs,
		const TrajPoint &	itp,
		const TrajPoint &	jtp,
		TrajPoint3 &	tp3,
		bool	findDirection
	)

Definition at line 1526 of file PFPUtils.cxx.

References tca::TrajPoint::Chg, detinfo::DetectorProperties::ConvertTicksToX(), detinfo::DetectorProperties::ConvertXToTicks(), tca::TrajPoint::CTP, DecodeCTP(), tca::TrajPoint3::dEdx, den, tca::TjStuff::detprop, tca::TrajPoint::Dir, tca::TrajPoint3::Dir, tca::TjStuff::geom, tca::TrajPoint::Pos, tca::TrajPoint3::Pos, PosSep(), tca::TjStuff::UnitsPerTick, and geo::GeometryCore::WireCoordinate().

Referenced by FindCompleteness(), FindXMatches(), Match2DShowers(), and UpdateShower().

   {
     // Make a 3D trajectory point using two 2D trajectory points
     tp3.Dir = {{999.0, 999.0, 999.0}};
     tp3.Pos = {{999.0, 999.0, 999.0}};
     geo::PlaneID iPlnID = DecodeCTP(itp.CTP);
     geo::PlaneID jPlnID = DecodeCTP(jtp.CTP);
     double upt = tjs.UnitsPerTick;
     double ix = tjs.detprop->ConvertTicksToX(itp.Pos[1] / upt, iPlnID);
     double jx = tjs.detprop->ConvertTicksToX(jtp.Pos[1] / upt, jPlnID);
     
     // don't continue if the points are wildly far apart in X
     if(std::abs(ix - jx) > 20) return false;
     tp3.Pos[0] = 0.5 * (ix + jx);
     // determine the wire orientation and offsets using WireCoordinate
     // wire = yp * OrthY + zp * OrthZ - Wire0 = cs * yp + sn * zp - wire0
     // wire offset
     double iw0 = tjs.geom->WireCoordinate(0, 0, iPlnID);
     // cosine-like component
     double ics = tjs.geom->WireCoordinate(1, 0, iPlnID) - iw0;
     // sine-like component
     double isn = tjs.geom->WireCoordinate(0, 1, iPlnID) - iw0;
     double jw0 = tjs.geom->WireCoordinate(0, 0, jPlnID);
     double jcs = tjs.geom->WireCoordinate(1, 0, jPlnID) - jw0;
     double jsn = tjs.geom->WireCoordinate(0, 1, jPlnID) - jw0;
     double den = isn * jcs - ics * jsn;
     if(den == 0) return false;
     double iPos0 = itp.Pos[0];
     double jPos0 = jtp.Pos[0];
     // Find the Z position of the intersection
     tp3.Pos[2] = (jcs * (iPos0 - iw0) - ics * (jPos0 - jw0)) / den;
     // and the Y position
     bool useI = std::abs(ics) > std::abs(jcs);
     if(useI) {
       tp3.Pos[1] = (iPos0 - iw0 - isn * tp3.Pos[2]) / ics;
     } else {
       tp3.Pos[1] = (jPos0 - jw0 - jsn * tp3.Pos[2]) / jcs;
     }
     
     // Now find the direction. Protect against large angles first
     if(jtp.Dir[1] == 0) {
       // Going either in the +X direction or -X direction
       if(jtp.Dir[0] > 0) { tp3.Dir[0] = 1; } else { tp3.Dir[0] = -1; }
       tp3.Dir[1] = 0;
       tp3.Dir[2] = 0;
       return true;
     } // jtp.Dir[1] == 0
     
     // stuff the average TP charge into dEdx
     tp3.dEdx = 0.5 * (itp.Chg + jtp.Chg);
     
     if(!findDirection) return true;
 
     // make a copy of itp and shift it by many wires to avoid precision problems
     double itp2_0 = itp.Pos[0] + 100;
     double itp2_1 = itp.Pos[1];
     if(std::abs(itp.Dir[0]) > 0.01) itp2_1 += 100 * itp.Dir[1] / itp.Dir[0];
     // Create a second Point3 for the shifted point
     Point3_t pos2;
     // Find the X position corresponding to the shifted point 
     pos2[0] = tjs.detprop->ConvertTicksToX(itp2_1 / upt, iPlnID);
     // Convert X to Ticks in the j plane and then to WSE units
     double jtp2Pos1 = tjs.detprop->ConvertXToTicks(pos2[0], jPlnID) * upt;
     // Find the wire position (Pos0) in the j plane that this corresponds to
     double jtp2Pos0 = (jtp2Pos1 - jtp.Pos[1]) * (jtp.Dir[0] / jtp.Dir[1]) + jtp.Pos[0];
     // Find the Y,Z position using itp2 and jtp2Pos0
     pos2[2] = (jcs * (itp2_0 - iw0) - ics * (jtp2Pos0 - jw0)) / den;
     if(useI) {
       pos2[1] = (itp2_0 - iw0 - isn * pos2[2]) / ics;
     } else {
       pos2[1] = (jtp2Pos0 - jw0 - jsn * pos2[2]) / jcs;
     }
     double sep = PosSep(tp3.Pos, pos2);
     if(sep == 0) return false;
     for(unsigned short ixyz = 0; ixyz < 3; ++ixyz) tp3.Dir[ixyz] = (pos2[ixyz] - tp3.Pos[ixyz]) /sep;
 
     return true;
     
   } // MakeTP3

void tca::MakeTrajectoryObsolete	(	TjStuff &	tjs,
		unsigned int	itj
	)

Definition at line 1797 of file Utils.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::fHits, and kKilled.

Referenced by MakeShowerObsolete(), MergeAndStore(), MergePFPTjs(), and MergeShowersAndStore().

   {
     // Note that this does not change the state of UseHit to allow
     // resurrecting the trajectory later (RestoreObsoleteTrajectory)
     if(itj > tjs.allTraj.size() - 1) return;
     int killTjID = tjs.allTraj[itj].ID;
     for(auto& hit : tjs.fHits) if(hit.InTraj == killTjID) hit.InTraj = 0;
     tjs.allTraj[itj].AlgMod[kKilled] = true;
   } // MakeTrajectoryObsolete

bool tca::MakeVertexObsolete	(	TjStuff &	tjs,
		VtxStore &	vx2,
		bool	forceKill
	)

Definition at line 2917 of file TCVertex.cxx.

References tca::TjStuff::allTraj, tca::VtxStore::CTP, DecodeCTP(), evd::details::end(), tca::VtxStore::ID, tca::Vtx3Store::ID, kEnvOverlap, kHiVx3Score, kKilled, kPhoton, kTjHiVx3Score, tca::TjStuff::NumPlanes, tca::TjStuff::pfps, geo::PlaneID::Plane, tca::VtxStore::Pos, SetVx3Score(), tca::TjStuff::Vertex2DCuts, tca::TjStuff::vtx, tca::TjStuff::vtx3, tca::Vtx3Store::Vx2ID, tca::VtxStore::Vx3ID, and tca::Vtx3Store::Wire.

Referenced by CheckTrajBeginChg(), ChkVxTjs(), CompleteIncomplete3DVertices(), KillPoorVertices(), KillVerticesInShower(), MakeVertexObsolete(), MergeAndStore(), MergePFPTjs(), SplitTrajCrossingVertices(), and TagShowerLike().

   {
     // Makes a 2D vertex obsolete
     
     // check for a high-score 3D vertex
     bool hasHighScoreVx3 = (vx2.Vx3ID > 0);
     if(hasHighScoreVx3 && !forceKill && tjs.vtx3[vx2.Vx3ID - 1].Score >= tjs.Vertex2DCuts[7]) return false;
     
     // Kill it
     int vx2id = vx2.ID;
     if(vx2.Vx3ID > 0) {
       auto& vx3 = tjs.vtx3[vx2.Vx3ID - 1];
       for(auto& v3v2id : vx3.Vx2ID) if(v3v2id == vx2.ID) v3v2id = 0;
     }
     vx2.ID = 0;
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       for(unsigned short end = 0; end < 2; ++end) {
         if(tj.VtxID[end] != vx2id) continue;
         tj.VtxID[end] = 0;
         tj.AlgMod[kPhoton] = false;
         // clear the kEnvOverlap bits on the TPs
         for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
           if(end == 0) { 
             unsigned short ipt = tj.EndPt[0] + ii;
             auto& tp = tj.Pts[ipt];
             if(!tp.Environment[kEnvOverlap]) break;
             if(ipt == tj.EndPt[1]) break;
           } else {
             unsigned short ipt = tj.EndPt[1] - ii;
             auto& tp = tj.Pts[ipt];
             if(!tp.Environment[kEnvOverlap]) break;
             if(ipt == tj.EndPt[0]) break;
           }
         } // ii
         if(tj.AlgMod[kTjHiVx3Score]) {
           // see if the vertex at the other end is high-score and if so, preserve the state
           unsigned short oend = 1 - end;
           if(tj.VtxID[oend] > 0) {
             auto& ovx2 = tjs.vtx[tj.VtxID[oend] - 1];
             if(!ovx2.Stat[kHiVx3Score]) tj.AlgMod[kTjHiVx3Score] = false;
           } // vertex at the other end
         } // tj.AlgMod[kTjHiVx3Score]
       } // end
     } // tj
     
     if(!hasHighScoreVx3) return true;
     
     // update the affected 3D vertex
     Vtx3Store& vx3 = tjs.vtx3[vx2.Vx3ID - 1];
     // make the 3D vertex incomplete
     geo::PlaneID planeID = DecodeCTP(vx2.CTP);
     unsigned short plane = planeID.Plane;
     if(vx3.Vx2ID[plane] != vx2id) return true;
     vx3.Vx2ID[plane] = 0;
     vx3.Wire = vx2.Pos[0];
     // Ensure that there are at least two 2D vertices left
     unsigned short n2D = 0;
     for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
       if(vx3.Vx2ID[plane] > 0) ++n2D;
     } // plane
     
     if(n2D > 1) {
       // 3D vertex is incomplete
       // correct the score
       SetVx3Score(tjs, vx3, false);
       return true;
     }
     
     // 3D vertex is obsolete
     // Detach the all remaining 2D vertices from the 3D vertex
     for(auto& vx2 : tjs.vtx) {
       if(vx2.ID == 0) continue;
       if(vx2.Vx3ID == vx3.ID) vx2.Vx3ID = 0;
     } // vx2
     for(auto& pfp : tjs.pfps) {
       for(unsigned short end = 0; end < 2; ++end) if(pfp.Vx3ID[end] == vx3.ID) pfp.Vx3ID[end] = 0;
     } // pfp
     vx3.ID = 0;
     return true;
     
   } // MakeVertexObsolete

bool tca::MakeVertexObsolete	(	TjStuff &	tjs,
		Vtx3Store &	vx3
	)

Definition at line 3001 of file TCVertex.cxx.

References tca::Vtx3Store::ID, MakeVertexObsolete(), tca::TjStuff::vtx, tca::TjStuff::vtx3, and tca::Vtx3Store::Vx2ID.

   {
     // Deletes a 3D vertex and 2D vertices in all planes
     // The 2D and 3D vertices are NOT killed if forceKill is false and the 3D vertex
     // has a high score
     if(vx3.ID == 0) return true;
     if(vx3.ID > int(tjs.vtx3.size())) return false;
     
     // set the score to 0
 //    vx3.Score = 0;
     
     for(auto vx2id : vx3.Vx2ID) {
       if(vx2id == 0 || vx2id > (int)tjs.vtx.size()) continue;
       auto& vx2 = tjs.vtx[vx2id - 1];
       MakeVertexObsolete(tjs, vx2, true);
     }
     vx3.ID = 0;
     return true;
   } // MakeVertexObsolete

void tca::Match2DShowers	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		const geo::TPCID &	tpcid,
		bool	prt
	)

Definition at line 947 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::ShowerStruct3D::ChgPos, ChkAssns(), CompleteIncompleteShower(), tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, CreateSS3(), geo::CryostatID::Cryostat, tca::ShowerStruct::CTP, DecodeCTP(), tca::TrajPoint3::Dir, tca::ShowerStruct3D::Dir, tca::ShowerStruct::Energy, tca::ShowerStruct3D::Energy, greaterThan(), tca::ShowerStruct::ID, tca::ShowerStruct3D::ID, tca::SortEntry::index, MakeShowerObsolete(), MakeTp3(), Match3DFOM(), tca::ShowerStruct3D::MatchFOM, tca::TjStuff::NumPlanes, tca::ShowerStruct3D::PFPIndex, geo::PlaneID::Plane, tca::TrajPoint3::Pos, PosSep(), PrintShowers(), tca::Trajectory::Pts, Reconcile3D(), tca::TjStuff::showers, tca::ShowerStruct::ShowerTjID, ss, tca::ShowerStruct::SS3ID, StoreShower(), tca::ShowerStruct::TjIDs, geo::TPCID::TPC, and UpdateShower().

Referenced by FindShowers3D().

   {
     // Match 2D showers using position and direction to create 3D showers
     
     std::string fcnLabel = inFcnLabel + ".M2DS";
     if(prt) mf::LogVerbatim("TC")<<fcnLabel;
     
     float fomCut = 2;
     
     ChkAssns(fcnLabel, tjs);
     
     // sort the showers by decreasing energy and increasing AspectRatio so that the 3D direction is defined
     // by the first matching pair
     std::vector<SortEntry> sortVec;
     for(unsigned short indx = 0; indx < tjs.cots.size(); ++indx) {
       auto& ss = tjs.cots[indx];
       if(ss.ID == 0) continue;
       // already matched?
       if(ss.SS3ID > 0) continue;
       if(ss.TjIDs.empty()) continue;
       geo::PlaneID planeID = DecodeCTP(ss.CTP);
       if(planeID.Cryostat != tpcid.Cryostat) continue;
       if(planeID.TPC != tpcid.TPC) continue;
       SortEntry se;
       se.index = indx;
       se.length = ss.Energy / ss.AspectRatio;
       sortVec.push_back(se);
     } // indx
     if(sortVec.size() < 2) return;
     std::sort(sortVec.begin(), sortVec.end(), greaterThan);
     
     // Look for a 3D match using the 2D shower charge centers
     for(unsigned short ii = 0; ii < sortVec.size() - 1; ++ii) {
       unsigned short iIndx = sortVec[ii].index;
       auto& iss = tjs.cots[iIndx];
       // already matched?
       if(iss.SS3ID > 0) continue;
       Trajectory& istj = tjs.allTraj[iss.ShowerTjID - 1];
       geo::PlaneID iplaneID = DecodeCTP(iss.CTP);
       for(unsigned short jj = 0; jj < sortVec.size(); ++jj) {
         if(iss.SS3ID > 0) break;
         unsigned short jIndx = sortVec[jj].index;
         ShowerStruct& jss = tjs.cots[jIndx];
         // already matched?
         if(iss.SS3ID > 0) break;
         if(jss.SS3ID > 0) continue;
         if(jss.CTP == iss.CTP) continue;
         Trajectory& jstj = tjs.allTraj[jss.ShowerTjID - 1];
         TrajPoint3 tp3;
         if(!MakeTp3(tjs, istj.Pts[1], jstj.Pts[1], tp3, true)) continue;
         float fomij = Match3DFOM(fcnLabel, tjs, iss.ID, jss.ID, prt);
         if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" i2S"<<iss.ID<<" j2S"<<jss.ID<<" fomij "<<fomij<<" fomCut "<<fomCut;
         if(fomij > fomCut) continue;
         geo::PlaneID jplaneID = DecodeCTP(jss.CTP);
         if(tjs.NumPlanes == 2) {
           ShowerStruct3D ss3 = CreateSS3(tjs, tpcid);
           ss3.ChgPos = tp3.Pos;
           ss3.Dir = tp3.Dir;
           ss3.CotIDs.resize(2);
           ss3.CotIDs[0] = iss.ID;
           ss3.CotIDs[1] = jss.ID;
           ss3.Energy.resize(2);
           ss3.Energy[0] = iss.Energy;
           ss3.Energy[1] = jss.Energy;
           ss3.MatchFOM = fomij;
           ss3.PFPIndex = USHRT_MAX;
           if(!StoreShower(fcnLabel, tjs, ss3)) continue;
           if(prt) mf::LogVerbatim("TC")<<" new 2-plane TPC 3S"<<ss3.ID<<" with fomij "<<fomij;
           continue;
         } // 2-plane TPC
         float bestFOM = fomCut;
         unsigned short bestck = USHRT_MAX;
         for(unsigned short ck = 0; ck < tjs.cots.size(); ++ck) {
           ShowerStruct& kss = tjs.cots[ck];
           if(kss.ID == iss.ID || kss.ID == jss.ID) continue;
           if(kss.CTP == iss.CTP || kss.CTP == jss.CTP) continue;
           if(kss.ID == 0) continue;
           if(kss.TjIDs.empty()) continue;
           if(kss.SS3ID > 0) continue;
           geo::PlaneID kplaneID = DecodeCTP(kss.CTP);
           if(kplaneID.Cryostat != tpcid.Cryostat) continue;
           if(kplaneID.TPC != tpcid.TPC) continue;
           Trajectory& kstj = tjs.allTraj[kss.ShowerTjID - 1];
           TrajPoint3 iktp3;
           MakeTp3(tjs, istj.Pts[1], kstj.Pts[1], iktp3, true);
           float fomik = Match3DFOM(fcnLabel, tjs, iss.ID, kss.ID, prt);
           if(fomik > bestFOM) continue;
           float sep = PosSep(tp3.Pos, iktp3.Pos);
           if(sep > 50) {
             if(prt) mf::LogVerbatim("TC")<<" 2S"<<iss.ID<<" 2S"<<jss.ID<<" 2S"<<kss.ID<<" Large stp[1] point separation "<<(int)sep;
             continue;
           }
           bestFOM = fomik;
           bestck = ck;
         } // ck
         // 3-plane TPC below
         ShowerStruct3D ss3 = CreateSS3(tjs, tpcid);
         // Define ss3 using the tp3 found with the first pair
         ss3.ChgPos = tp3.Pos;
         ss3.Dir = tp3.Dir;
         ss3.MatchFOM = bestFOM;
         if(bestck == USHRT_MAX) {
           // showers match in 2 planes
           ss3.CotIDs.resize(2);
           ss3.CotIDs[0] = iss.ID;
           ss3.CotIDs[1] = jss.ID;
           ss3.Energy[iplaneID.Plane] = iss.Energy;
           ss3.Energy[jplaneID.Plane] = jss.Energy;
           if(prt) mf::LogVerbatim("TC")<<" new 2-plane 3S"<<ss3.ID<<" using 2S"<<iss.ID<<" 2S"<<jss.ID<<" with FOM "<<ss3.MatchFOM<<" try to complete it";
           // ignore this 3D match if the shower can't be completed
           if(!CompleteIncompleteShower(fcnLabel, tjs, ss3, prt)) continue;
           iss.SS3ID = ss3.ID;
           jss.SS3ID = ss3.ID;
         } else {
           // showers match in 3 planes
           unsigned short ck = bestck;
           ShowerStruct& kss = tjs.cots[ck];
           ss3.CotIDs.resize(3);
           ss3.CotIDs[0] = iss.ID;
           ss3.CotIDs[1] = jss.ID;
           ss3.CotIDs[2] = kss.ID;
           geo::PlaneID kplaneID = DecodeCTP(kss.CTP);
           ss3.Energy[iplaneID.Plane] = iss.Energy;
           ss3.Energy[jplaneID.Plane] = jss.Energy;
           ss3.Energy[kplaneID.Plane] = kss.Energy;
           tjs.cots[ck].SS3ID = ss3.ID;
           if(prt) mf::LogVerbatim("TC")<<" new 3-plane 3S"<<ss3.ID<<" using 2S"<<iss.ID<<" 2S"<<jss.ID<<" 2S"<<tjs.cots[ck].ID<<" with FOM "<<ss3.MatchFOM;
         }
         ss3.MatchFOM = 0.5 * (fomij + bestFOM);
         // sort the IDs
         std::sort(ss3.CotIDs.begin(), ss3.CotIDs.end());
         // Set the 3S -> 2S assns and store it
         if(!StoreShower(fcnLabel, tjs, ss3)) {
           MakeShowerObsolete(fcnLabel, tjs, ss3, prt);
           continue;
         }
         // make a reference to the stored shower
         auto& nss3 = tjs.showers[tjs.showers.size() - 1];
         if(nss3.NeedsUpdate) UpdateShower(fcnLabel, tjs, nss3, prt);
         // reconcile tj -> 2S -> 3S and tj -> pfps
         if(!Reconcile3D(fcnLabel, tjs, nss3, prt)) {
           MakeShowerObsolete(fcnLabel, tjs, nss3, prt);
           continue;
         }
         if(nss3.NeedsUpdate) UpdateShower(fcnLabel, tjs, nss3, prt);
         if(prt) mf::LogVerbatim("TC")<<" 3S"<<nss3.ID<<" updated";
         break;
       } // cj
     } // ci
     
     ChkAssns(fcnLabel, tjs);
     
     if(prt) PrintShowers("M2DS", tjs);
 
   } // Match2DShowers

float tca::Match3DFOM	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 1417 of file TCShower.cxx.

References tca::ShowerStruct3D::CotIDs, and Match3DFOM().

   {
     float fom = 0;
     float cnt = 0;
     for(unsigned short ii = 0; ii < ss3.CotIDs.size() - 1; ++ii) {
       unsigned short icid = ss3.CotIDs[ii];
       for(unsigned short jj = ii + 1; jj < ss3.CotIDs.size(); ++jj) {
         unsigned short jcid = ss3.CotIDs[jj];
         fom += Match3DFOM(inFcnLabel, tjs, icid, jcid, prt);
         ++cnt;
       } // cj
     } // ci
     if(cnt == 0) return 100;
     return fom / cnt;
   } // Match3DFOM

float tca::Match3DFOM	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		int	icid,
		int	jcid,
		int	kcid,
		bool	prt
	)

Definition at line 1434 of file TCShower.cxx.

References tca::TjStuff::cots, and Match3DFOM().

   {
     if(icid == 0 || icid > (int)tjs.cots.size()) return 100;
     if(jcid == 0 || jcid > (int)tjs.cots.size()) return 100;
     if(kcid == 0 || kcid > (int)tjs.cots.size()) return 100;
     
     float ijfom = Match3DFOM(inFcnLabel, tjs, icid, jcid, prt);
     float jkfom = Match3DFOM(inFcnLabel, tjs, jcid, kcid, prt);
     
     return 0.5 * (ijfom + jkfom);
     
   } // Match3DFOM

float tca::Match3DFOM	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		int	icid,
		int	jcid,
		bool	prt
	)

Definition at line 1449 of file TCShower.cxx.

References tca::TjStuff::allTraj, detinfo::DetectorProperties::ConvertTicksToX(), tca::TjStuff::cots, DecodeCTP(), tca::TjStuff::detprop, and tca::TjStuff::UnitsPerTick.

Referenced by Match2DShowers(), and Match3DFOM().

   {
     // returns a Figure of Merit for a 3D match of two showers
     if(icid == 0 || icid > (int)tjs.cots.size()) return 100;
     if(jcid == 0 || jcid > (int)tjs.cots.size()) return 100;
     
     auto& iss = tjs.cots[icid - 1];
     auto& istj = tjs.allTraj[iss.ShowerTjID - 1];    
     auto& jss = tjs.cots[jcid - 1];
     auto& jstj = tjs.allTraj[jss.ShowerTjID - 1];
     
     if(iss.CTP == jss.CTP) return 100;
     
     std::string fcnLabel = inFcnLabel + ".MFOM";
     
     float energyAsym = std::abs(iss.Energy - jss.Energy) / (iss.Energy + jss.Energy);
     
     // don't apply the asymmetry cut on low energy showers
     if((iss.Energy > 200 || jss.Energy > 200) && energyAsym > 0.5) return 50;
     
     geo::PlaneID iPlnID = DecodeCTP(iss.CTP);
     geo::PlaneID jPlnID = DecodeCTP(jss.CTP);
 
     // compare match at the charge center
     float ix = tjs.detprop->ConvertTicksToX(istj.Pts[1].Pos[1] / tjs.UnitsPerTick, iPlnID);
     float jx = tjs.detprop->ConvertTicksToX(jstj.Pts[1].Pos[1] / tjs.UnitsPerTick, jPlnID);
     float pos1fom = std::abs(ix - jx) / 10;
 
     float mfom = energyAsym * pos1fom;
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<fcnLabel<<" i2S"<<iss.ID<<" j2S"<<jss.ID;
       myprt<<std::fixed<<std::setprecision(2);
 //      myprt<<" pos0fom "<<pos0fom;
       myprt<<" pos1fom "<<pos1fom;
 //      myprt<<" pos2fom "<<pos2fom;
       myprt<<" energyAsym "<<energyAsym;
       myprt<<" mfom "<<mfom;
     }
     
     return mfom;
   } // Madtch3DFOM

void tca::Match3DVtxTjs	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid,
		bool	prt
	)

Definition at line 1506 of file TCVertex.cxx.

References tca::TjStuff::allTraj, AnalyzePFP(), CreatePFP(), DefinePFP(), tca::PFPStruct::Dir, GetVtxTjIDs(), tca::PFPStruct::ID, tca::SortEntry::index, kKilled, kMat3D, tca::TjStuff::matchVec, tca::PFPStruct::MatchVecIndex, tca::TjStuff::NumPlanes, tca::PFPStruct::PDGCode, PDGCodeVote(), PrintPFP(), SetDifference(), SetIntersection(), Split3DKink(), StorePFP(), tca::PFPStruct::TjIDs, tmp, tca::SortEntry::val, valDecreasing(), tca::TjStuff::Vertex2DCuts, tca::TjStuff::vtx3, tca::PFPStruct::Vx3ID, and tca::PFPStruct::XYZ.

Referenced by FindPFParticles().

   {
     // Matches Tjs that are attached to 2D vertices that are matched in 3D. This function does not attempt
     // to determine the appropriate ends of matched Tjs when there is a 3D vertex at both ends. This is done
     // in Find3DEndPoints
     
     if(tjs.vtx3.empty()) return;
     if(tjs.matchVec.empty()) return;
 
     // sort the vertices by decreasing score
     std::vector<SortEntry> sortVec;
     for(unsigned short iv3 = 0; iv3 < tjs.vtx3.size(); ++iv3) {
       auto& vx3 = tjs.vtx3[iv3];
       if(vx3.ID == 0) continue;
       if(vx3.TPCID != tpcid) continue;
       // put the TjIDs into a vector for matching
       float score = 0;
       auto v3TjIDs = GetVtxTjIDs(tjs, vx3, score);
       if(v3TjIDs.empty()) continue;
       if(score < tjs.Vertex2DCuts[7]) continue;
 /*
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<"M3DVTj 3V"<<vx3.ID<<" score "<<score<<" TjIDs";
         for(auto& tjID : v3TjIDs) myprt<<" T"<<std::to_string(tjID);
       }
 */
       SortEntry se;
       se.index = iv3;
       se.val = score;
       sortVec.push_back(se);
     } // vx3
     if(sortVec.empty()) return;
     if(sortVec.size() > 1) std::sort(sortVec.begin(), sortVec.end(), valDecreasing);
     
     for(unsigned short ii = 0; ii < sortVec.size(); ++ii) {
       auto& vx3 = tjs.vtx3[sortVec[ii].index];
       float score = 0;
       std::vector<int> v3TjIDs = GetVtxTjIDs(tjs, vx3, score);
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<"M3DVTj 3V"<<vx3.ID<<" score "<<score<<" Tjs";
         for(auto& tjID : v3TjIDs) myprt<<" T"<<tjID;
       }
       for(unsigned int ims = 0; ims < tjs.matchVec.size(); ++ims) {
         auto& ms = tjs.matchVec[ims];
         if(ms.Count == 0) continue;
         bool skipit = false;
         for(auto tjid : ms.TjIDs) {
           auto& tj = tjs.allTraj[tjid - 1];
           if(tj.AlgMod[kMat3D]) skipit = true;
           if(tj.AlgMod[kKilled]) skipit = true;
         }
         if(skipit) continue;
         std::vector<int> shared = SetIntersection(ms.TjIDs, v3TjIDs);
         if(shared.size() < 2) continue;
         if(prt) mf::LogVerbatim("TC")<<" ims "<<ims<<" shared size "<<shared.size();
         PFPStruct pfp = CreatePFP(tjs, tpcid);
         pfp.TjIDs = ms.TjIDs;
         pfp.Vx3ID[0] = vx3.ID;
         // note that the ms position is the average position of all 3D matched Tp3s at this point.
         // It is not the start position. This will be determined in DefinePFP.
         pfp.XYZ[0] = ms.Pos;
         pfp.Dir[0] = ms.Dir;
         pfp.MatchVecIndex = ims;
         if(prt) mf::LogVerbatim("TC")<<"M3DVTj: pfp P"<<pfp.ID<<" 3V"<<vx3.ID<<" ims "<<ims;
         // Set the PDGCode so DefinePFP can ignore incompatible matches
         pfp.PDGCode = PDGCodeVote(tjs, pfp.TjIDs, prt);
         // make a copy of the TjIDs to test for changes
         auto saveTjIDs = pfp.TjIDs;
         if(!DefinePFP("M3DVTj1", tjs, pfp, prt)) continue;
         // separation distance (cm) for kink detection.
         double sep = 1;
         bool didSplit = Split3DKink(tjs, pfp, sep, prt);
         if(prt) PrintPFP("M3D", tjs, pfp, true);
         if(!didSplit && shared.size() != ms.TjIDs.size()) {
           // Try to repair the PFParticle by merging the Tj that was in the match list but
           // wasn't attached to the vertex. Hopefully there aren't more than one...
           auto tjNotInVx = SetDifference(ms.TjIDs, shared);
         }
         AnalyzePFP(tjs, pfp, prt);
         if(!StorePFP(tjs, pfp)) continue;
         if(pfp.TjIDs != saveTjIDs) {
           // v3TjIDs is wrong if Tjs were merged so re-make it.
           auto tmp = GetVtxTjIDs(tjs, vx3, score);
           v3TjIDs.clear();
           // then re-build it
           for(auto tjid : tmp) {
             auto& tj = tjs.allTraj[tjid - 1];
             if(!tj.AlgMod[kMat3D]) v3TjIDs.push_back(tjid);
           } // tjid
           if(v3TjIDs.size() < 2) break;
         } // pfp.TjIDs != saveTjIDs
         ms.Count = 0;
         // clobber MatchStructs that use the Tjs in this pfp
         for(auto& allms : tjs.matchVec) {
           auto mfpfp = SetIntersection(allms.TjIDs, pfp.TjIDs);
           if(!mfpfp.empty()) allms.Count = 0;
         } // allms
         auto leftover = SetDifference(v3TjIDs, pfp.TjIDs);
         if(prt) {
           mf::LogVerbatim myprt("TC");
           myprt<<" leftover";
           for(auto tjid : leftover) myprt<<" T"<<tjid;
         }
         if(leftover.size() < 2) break;
         // keep looking using the leftovers
         v3TjIDs = leftover;
       } // ims
       if(v3TjIDs.size() > 1 && v3TjIDs.size() <= tjs.NumPlanes) {
         // a last-ditch attempt
         PFPStruct pfp = CreatePFP(tjs, tpcid);
         // put the available leftovers in
         for(auto& tjid : v3TjIDs) {
           auto& tj = tjs.allTraj[tjid - 1];
           if(tj.AlgMod[kMat3D]) continue;
           if(tj.AlgMod[kKilled]) continue;
           pfp.TjIDs.push_back(tjid);
         } // tjid
         if(pfp.TjIDs.size() < 2) continue;
         pfp.Vx3ID[0] = vx3.ID;
         if(!DefinePFP("M3DVTj2", tjs, pfp, prt)) continue;
         Split3DKink(tjs, pfp, 1, prt);
         AnalyzePFP(tjs, pfp, prt);
         if(prt) PrintPFP("left", tjs, pfp, true);
         if(!StorePFP(tjs, pfp)) continue;
       }
     } // ims
   } // Match3DVtxTjs

unsigned short tca::MatchVecIndex	(	const TjStuff &	tjs,
		int	tjID
	)

Definition at line 1058 of file Utils.cxx.

References tca::TjStuff::matchVec.

   {
     // returns the index into the tjs.matchVec vector of the first 3D match that
     // includes tjID
     for(unsigned int ims = 0; ims < tjs.matchVec.size(); ++ims) {
       const auto& ms = tjs.matchVec[ims];
       if(std::find(ms.TjIDs.begin(), ms.TjIDs.end(), tjID) != ms.TjIDs.end()) return ims;
     } // indx
     return USHRT_MAX;
   } // MatchVecIndex

float tca::MaxChargeAsymmetry	(	TjStuff &	tjs,
		std::vector< int > &	tjIDs
	)

Definition at line 235 of file Utils.cxx.

References tca::TjStuff::allTraj, DecodeCTP(), tca::TjStuff::NumPlanes, geo::PlaneID::Plane, and UpdateTjChgProperties().

   {
     // calculates the maximum charge asymmetry in all planes using the supplied list of Tjs
     if(tjIDs.size() < 2) return 1;
     std::vector<float> plnchg(tjs.NumPlanes);
     for(auto tjid : tjIDs) {
       if(tjid <= 0 || tjid > (int)tjs.allTraj.size()) return 1;
       auto& tj = tjs.allTraj[tjid - 1];
       if(tj.TotChg == 0) UpdateTjChgProperties("MCA", tjs, tj, false);
       unsigned short plane = DecodeCTP(tj.CTP).Plane;
       plnchg[plane] += tj.TotChg;
     } // tjid
     float aveChg = 0;
     float cnt = 0;
     for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
       if(plnchg[plane] == 0) continue;
       aveChg += plnchg[plane];
       ++cnt;
     } // plane
     if(cnt < 2) return 1;
     aveChg /= cnt;
     float maxAsym = 0;
     for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
       // ignore zeros
       if(plnchg[plane] == 0) continue;
       float asym = std::abs(plnchg[plane] - aveChg) / (plnchg[plane] + aveChg);
       if(asym > maxAsym) maxAsym = asym;
     } // plane
     return maxAsym;
   } // MaxChargeAsymmetry

float tca::MaxHitDelta	(	TjStuff &	tjs,
		Trajectory &	tj
	)

Definition at line 2649 of file Utils.cxx.

References PointTrajDOCA(), and tca::Trajectory::Pts.

Referenced by tca::TrajClusterAlg::CheckHiMultUnusedHits(), and tca::TrajClusterAlg::FillGaps().

   {
     float delta, md = 0;
     unsigned short ii;
     unsigned int iht;
     for(auto& tp : tj.Pts) {
       for(ii = 0; ii < tp.Hits.size(); ++ii) {
         if(!tp.UseHit[ii]) continue;
         iht = tp.Hits[ii];
         delta = PointTrajDOCA(tjs, iht, tp);
         if(delta > md) md = delta;
       } // ii
     } // pts
     return md;
   } // MaxHitDelta

float tca::MaxTjLen	(	TjStuff const &	tjs,
		std::vector< int > &	tjIDs
	)

Definition at line 2189 of file Utils.cxx.

References tca::TjStuff::allTraj, and PosSep2().

Referenced by DefinePFP(), and FindPFParticles().

   {
     // returns the length of the longest Tj in the supplied list
     if(tjIDs.empty()) return 0;
     float maxLen = 0;
     for(auto tjid : tjIDs) {
       if(tjid < 1 || tjid > (int)tjs.allTraj.size()) continue;
       auto& tj = tjs.allTraj[tjid - 1];
       float sep2 = PosSep2(tj.Pts[tj.EndPt[0]].Pos, tj.Pts[tj.EndPt[1]].Pos);
       if(sep2 > maxLen) maxLen = sep2;
     } // tj
     return sqrt(maxLen);
   } // MaxTjLen

short tca::MCSMom	(	const TjStuff &	tjs,
		const std::vector< int > &	tjIDs
	)

Definition at line 2837 of file Utils.cxx.

References tca::TjStuff::allTraj.

Referenced by tca::TrajClusterAlg::CheckTraj(), DefinePFP(), DotProd(), tca::TrajClusterAlg::FillGaps(), FindCots(), FindHammerVertices2(), FindParent(), FindPFParticles(), tca::TrajClusterAlg::FindSoftKink(), tca::TrajClusterAlg::GottaKink(), tca::TrajClusterAlg::IsGhost(), MergeNearby2DShowers(), MergePFPTjs(), MergeSubShowersTj(), tca::TruthMatcher::StudyElectrons(), tca::TruthMatcher::StudyShowerParents(), and tca::TrajClusterAlg::UpdateTraj().

   {
     // Find the average MCSMom of the trajectories
     if(tjIDs.empty()) return 0;
     float summ = 0;
     float suml = 0;
     for(auto tjid : tjIDs) {
       auto& tj = tjs.allTraj[tjid - 1];
       float npts = tj.EndPt[1] - tj.EndPt[0] + 1;
       summ += npts * tj.MCSMom;
       suml += npts;
     } // tjid
     return (short)(summ / suml);
   } // MCSMom

short tca::MCSMom	(	TjStuff &	tjs,
		Trajectory &	tj
	)

Definition at line 2853 of file Utils.cxx.

References tca::Trajectory::EndPt, and MCSMom().

   {
     return MCSMom(tjs, tj, tj.EndPt[0], tj.EndPt[1]);
   } // MCSMom

short tca::MCSMom	(	TjStuff &	tjs,
		Trajectory &	tj,
		unsigned short	firstPt,
		unsigned short	lastPt
	)

Definition at line 2859 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::EndPt, kJunkTj, MCSThetaRMS(), NearestPtWithChg(), NumPtsWithCharge(), tca::Trajectory::Pts, and TrajPointSeparation().

Referenced by MCSMom(), PrintPFP(), and SetPDGCode().

   {
     // Estimate the trajectory momentum using Multiple Coulomb Scattering ala PDG RPP
     
     if(firstPt == lastPt) return 0;
     if(firstPt > lastPt) std::swap(firstPt, lastPt);
     
     firstPt = NearestPtWithChg(tjs, tj, firstPt);
     lastPt = NearestPtWithChg(tjs, tj, lastPt);
     if(firstPt >= lastPt) return 0;
     
     if(firstPt < tj.EndPt[0]) return 0;
     if(lastPt > tj.EndPt[1]) return 0;
     // Can't do this with only 2 points
     if(NumPtsWithCharge(tjs, tj, false, firstPt, lastPt) < 3) return 0;
     // Ignore junk Tjs
     if(tj.AlgMod[kJunkTj]) return 0;
         
     double tjLen = TrajPointSeparation(tj.Pts[firstPt], tj.Pts[lastPt]);
     if(tjLen < 1) return 0;
     // mom calculated in MeV
     double thetaRMS = MCSThetaRMS(tjs, tj, firstPt, lastPt);
     if(thetaRMS < 0.001) return 999;
     double mom = 13.8 * sqrt(tjLen / 14) / thetaRMS;
     if(mom > 999) mom = 999;
     return (short)mom;
   } // MCSMom

float tca::MCSThetaRMS	(	TjStuff &	tjs,
		Trajectory &	tj
	)

Definition at line 2907 of file Utils.cxx.

References tca::Trajectory::EndPt, MCSThetaRMS(), tca::Trajectory::Pts, and TrajPointSeparation().

Referenced by DotProd(), tca::TrajClusterAlg::EndMerge(), and tca::TrajClusterAlg::GottaKink().

   {
     // This returns the MCS scattering angle expected for one WSE unit of travel along the trajectory.
     // It is used to define kink and vertex cuts. This should probably be named something different to
     // prevent confusion
     
     float tps = TrajPointSeparation(tj.Pts[tj.EndPt[0]], tj.Pts[tj.EndPt[1]]);
     if(tps < 1) return 1;
     
     return MCSThetaRMS(tjs, tj, tj.EndPt[0], tj.EndPt[1]) / sqrt(tps);
     
   } // MCSThetaRMS

double tca::MCSThetaRMS	(	TjStuff &	tjs,
		Trajectory &	tj,
		unsigned short	firstPt,
		unsigned short	lastPt
	)

Definition at line 2921 of file Utils.cxx.

References tca::Trajectory::EndPt, tca::Trajectory::MCSMom, NearestPtWithChg(), tca::Trajectory::Pts, TjDeltaRMS(), and TrajPointSeparation().

Referenced by MCSMom(), and MCSThetaRMS().

   {
     // This returns the MCS scattering angle expected for the length of the trajectory
     // spanned by firstPt to lastPt. It is used primarily to calculate MCSMom
     
     if(firstPt < tj.EndPt[0]) return 1;
     if(lastPt > tj.EndPt[1]) return 1;
     
     firstPt = NearestPtWithChg(tjs, tj, firstPt);
     lastPt = NearestPtWithChg(tjs, tj, lastPt);
     if(firstPt >= lastPt) return 1;
     
     double sigmaS;
     unsigned short cnt;
     TjDeltaRMS(tjs, tj, firstPt, lastPt, sigmaS, cnt);
     if(sigmaS < 0) return 1;
     // require that cnt is a significant fraction of the total number of charged points
     // so that we don't get erroneously high MCSMom when there are large gaps.
     // This is the number of points expected in the count if there are no gaps
     unsigned short numPts = lastPt - firstPt - 1;
     // return the previously calculated value of MCSMom
     if(numPts > 5 && cnt < 0.7 * numPts) return tj.MCSMom;
     double tjLen = TrajPointSeparation(tj.Pts[firstPt], tj.Pts[lastPt]);
     if(tjLen < 1) return 1;
     // Theta_o =  4 * sqrt(3) * sigmaS / path
     return (6.8 * sigmaS / tjLen);
     
   } // MCSThetaRMS

bool tca::MergeAndStore	(	TjStuff &	tjs,
		unsigned int	itj1,
		unsigned int	itj2,
		bool	doPrt
	)

Not allowed

Definition at line 3896 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::Trajectory::EndPt, GetPFPIndex(), HasDuplicateHits(), tca::Trajectory::ID, kBragg, kDeltaRay, kKilled, kMichel, kShowerTj, MakeTrajectoryObsolete(), MakeVertexObsolete(), MergeShowerTjsAndStore(), tca::Trajectory::ParentID, PosSep2(), PrintPos(), PrintTrajectory(), tca::Trajectory::Pts, ReverseTraj(), SetEndPoints(), SetPDGCode(), tca::Trajectory::StepDir, tca::Trajectory::StopFlag, StoreTraj(), TrajPointTrajDOCA(), UpdateMatchStructs(), tca::TjStuff::vtx, tca::Trajectory::VtxID, and tca::Trajectory::WorkID.

Referenced by ChkVxTjs(), DotProd(), tca::TrajClusterAlg::EndMerge(), and MergeTjIntoPFP().

   {
     // Merge the two trajectories in allTraj and store them. Returns true if it was successfull.
     // Merging is done between the end (end = 1) of tj1 and the beginning (end = 0) of tj2. This function preserves the
     // AlgMod state of itj1.
     // The itj1 -> itj2 merge order is reversed if end1 of itj2 is closer to end0 of itj1
     
     if(itj1 > tjs.allTraj.size() - 1) return false;
     if(itj2 > tjs.allTraj.size() - 1) return false;
     if(tjs.allTraj[itj1].AlgMod[kKilled] || tjs.allTraj[itj2].AlgMod[kKilled]) return false;
     
     // Merging shower Tjs requires merging the showers as well.
     if(tjs.allTraj[itj1].AlgMod[kShowerTj] || tjs.allTraj[itj2].AlgMod[kShowerTj]) return MergeShowerTjsAndStore(tjs, itj1, itj2, doPrt);
     
     // Ensure that the order of 3D-matched Tjs is consistent with the convention that 
     unsigned short pfp1 = GetPFPIndex(tjs, tjs.allTraj[itj1].ID);
     unsigned short pfp2 = GetPFPIndex(tjs, tjs.allTraj[itj2].ID);
     if(pfp1 != USHRT_MAX || pfp2 != USHRT_MAX) {
       if(pfp1 != USHRT_MAX && pfp2 != USHRT_MAX) {
 //        std::cout<<"MAS: Both tjs are used in a PFParticle. Need PFParticle merging code to do this. pfps size "<<tjs.pfps.size()<<"\n";
         return false;
       }
       // Swap so that the order of tj1 is preserved. Tj2 may be reversed to be consistent
       if(pfp1 == USHRT_MAX) std::swap(itj1, itj2);
     } // one or both used in a PFParticle
         
     // make copies so they can be trimmed as needed
     Trajectory tj1 = tjs.allTraj[itj1];
     Trajectory tj2 = tjs.allTraj[itj2];
     
     // ensure that these are in the same step order
     if(tj2.StepDir != tj1.StepDir) ReverseTraj(tjs, tj2);
     
     Point2_t tp1e0 = tj1.Pts[tj1.EndPt[0]].Pos;
     Point2_t tp1e1 = tj1.Pts[tj1.EndPt[1]].Pos;
     Point2_t tp2e0 = tj2.Pts[tj2.EndPt[0]].Pos;
     Point2_t tp2e1 = tj2.Pts[tj2.EndPt[1]].Pos;
     
     if(doPrt) {
       mf::LogVerbatim("TC")<<"MergeAndStore: tj1 T"<<tj1.ID<<" tj2 T"<<tj2.ID<<" at merge points "<<PrintPos(tjs, tp1e1)<<" "<<PrintPos(tjs, tp2e0);
     }
     
     // swap the order so that abs(tj1end1 - tj2end0) is less than abs(tj2end1 - tj1end0)
     if(PosSep2(tp1e1, tp2e0) > PosSep2(tp2e1, tp1e0)) {
       std::swap(tj1, tj2);
       std::swap(tp1e0, tp2e0);
       std::swap(tp1e1, tp2e1);
       if(doPrt) mf::LogVerbatim("TC")<<" swapped the order. Merge points "<<PrintPos(tjs, tp1e1)<<" "<<PrintPos(tjs, tp2e0);
     }
     
     // Here is what we are looking for, where - indicates a TP with charge.
     // Note that this graphic is in the stepping direction (+1 = +wire direction)
     // tj1:  0------------1
     // tj2:                  0-----------1
     // Another possibility with overlap
     // tj1:  0-------------1
     // tj2:               0--------------1
     
     if(tj1.StepDir > 1) {
       // Not allowed
       // tj1:  0---------------------------1
       // tj2:                  0------1
       if(tp2e0[0] > tp1e0[0] && tp2e1[0] < tp1e1[0]) return false;
       // tj1:                  0------1
       // tj2:  0---------------------------1
       if(tp1e0[0] > tp2e0[0] && tp1e1[0] < tp2e1[0]) return false;
     } else {
       // same as above but with ends reversed
       if(tp2e1[0] > tp1e1[0] && tp2e0[0] < tp1e0[0]) return false;
       if(tp1e1[0] > tp2e1[0] && tp1e0[0] < tp2e0[0]) return false;
     }
     
     if(tj1.VtxID[1] > 0 && tj2.VtxID[0] == tj1.VtxID[1]) {
       auto& vx = tjs.vtx[tj1.VtxID[1] - 1];
       if(!MakeVertexObsolete(tjs, vx, false)) {
         if(doPrt) mf::LogVerbatim("TC")<<"MergeAndStore: Found a good vertex between Tjs "<<tj1.VtxID[1]<<" No merging";
         return false;
       }
     }
     
     if(tj1.StopFlag[1][kBragg]) {
       if(doPrt) mf::LogVerbatim("TC")<<"MergeAndStore: You are merging the end of trajectory T"<<tj1.ID<<" with a Bragg peak. Not merging\n";
       return false;
     }
     
     // remove any points at the end of tj1 that don't have used hits
     tj1.Pts.resize(tj1.EndPt[1] + 1);
     
     // determine if they overlap by finding the point on tj2 that is closest
     // to the end point of tj1.
     TrajPoint& endtj1TP = tj1.Pts[tj1.EndPt[1]];
     // Set minSep large so that dead wire regions are accounted for
     float minSep = 1000;
     unsigned short tj2ClosePt = 0;
     // Note that TrajPointTrajDOCA only considers TPs that have charge
     TrajPointTrajDOCA(tjs, endtj1TP, tj2, tj2ClosePt, minSep);
     if(doPrt) mf::LogVerbatim("TC")<<" Merge point tj1 "<<PrintPos(tjs, endtj1TP)<<" tj2ClosePt "<<tj2ClosePt<<" Pos "<<PrintPos(tjs, tj2.Pts[tj2ClosePt]);
     // check for full overlap
     if(tj2ClosePt > tj2.EndPt[1]) return false;
     
     // The approach is to append tj2 to tj1, store tj1 as a new trajectory,
     // and re-assign all hits to the new trajectory
     
     // First ensure that any hit will appear only once in the merged trajectory in the overlap region
     // whether it is used or unused. The point on tj2 where the merge will begin, tj2ClosePt, will be
     // increased until this condition is met.
     // Make a temporary vector of tj1 hits in the end points for simpler searching
     std::vector<unsigned int> tj1Hits;
     for(unsigned short ii = 0; ii < tj1.Pts.size(); ++ii) {
       // only go back a few points in tj1
       if(ii > 10) break;
       unsigned short ipt = tj1.Pts.size() - 1 - ii;
       tj1Hits.insert(tj1Hits.end(), tj1.Pts[ipt].Hits.begin(), tj1.Pts[ipt].Hits.end());
       if(ipt == 0) break;
     } // ii
     
     bool bumpedPt = true;
     while(bumpedPt) {
       bumpedPt = false;
       for(unsigned short ii = 0; ii < tj2.Pts[tj2ClosePt].Hits.size(); ++ii) {
         unsigned int iht = tj2.Pts[tj2ClosePt].Hits[ii];
         if(std::find(tj1Hits.begin(), tj1Hits.end(), iht) != tj1Hits.end()) bumpedPt = true;
       } // ii
       if(bumpedPt && tj2ClosePt < tj2.EndPt[1]) {
         ++tj2ClosePt;
       } else {
         break;
       }
     } // bumpedPt
     if(doPrt) mf::LogVerbatim("TC")<<" revised tj2ClosePt "<<tj2ClosePt;
     // append tj2 hits to tj1
     
     tj1.Pts.insert(tj1.Pts.end(), tj2.Pts.begin() + tj2ClosePt, tj2.Pts.end());
     // re-define the end points
     SetEndPoints(tjs, tj1);
     tj1.StopFlag[1] = tj2.StopFlag[1];
     
     // A more exhaustive check that hits only appear once
     if(HasDuplicateHits(tjs, tj1, doPrt)) {
       if(doPrt) {
         mf::LogVerbatim("TC")<<"MergeAndStore found duplicate hits. Coding error";
         PrintTrajectory("MAS", tjs, tj1, USHRT_MAX);
         PrintTrajectory("tj1", tjs, tjs.allTraj[itj1], USHRT_MAX);
         PrintTrajectory("tj2", tjs, tjs.allTraj[itj2], USHRT_MAX);
       }
       return false;
     }
     if(tj2.VtxID[1] > 0) {
       // move the end vertex of tj2 to the end of tj1
       tj1.VtxID[1] = tj2.VtxID[1];
     }   
     // Transfer some of the AlgMod bits
     if(tj2.AlgMod[kMichel]) tj1.AlgMod[kMichel] = true;
     if(tj2.AlgMod[kDeltaRay]) {
       tj1.AlgMod[kDeltaRay] = true;
       tj1.ParentID = tj2.ParentID;
     }
     // keep track of the IDs before they are clobbered
     int tj1ID = tj1.ID;
     int tj2ID = tj2.ID;
     // kill the original trajectories
     MakeTrajectoryObsolete(tjs, itj1);
     MakeTrajectoryObsolete(tjs, itj2);
     // Do this so that StoreTraj keeps the correct WorkID (of itj1)
     tj1.ID = tj1.WorkID;
     SetPDGCode(tjs, tj1);
     if(!StoreTraj(tjs, tj1)) return false;
     int newTjID = tjs.allTraj.size();
     // Use the ParentID to trace which new Tj is superseding the merged ones
     tj1.ParentID = newTjID;
     tj2.ParentID = newTjID;
     // update match structs if they exist
     UpdateMatchStructs(tjs, tj1.ID, newTjID);
     UpdateMatchStructs(tjs, tj2.ID, newTjID);
     if(doPrt) mf::LogVerbatim("TC")<<" MAS success. New Tj T"<<newTjID;
     // Transfer the ParentIDs of any other Tjs that refer to Tj1 and Tj2 to the new Tj
     for(auto& tj : tjs.allTraj) if(tj.ParentID == tj1ID || tj.ParentID == tj2ID) tj.ParentID = newTjID;
 
     return true;
   } // MergeAndStore

void tca::MergeGhostTjs	(	TjStuff &	tjs,
		CTP_t	inCTP
	)

Definition at line 1830 of file Utils.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::fHits, kAllHits, kKilled, kMrgGhost, PutTrajHitsInVector(), and tca::TjStuff::UseAlg.

   {
     // Merges short Tjs that share many hits with a longer Tj
     if(!tjs.UseAlg[kMrgGhost]) return;
     
     for(auto& shortTj : tjs.allTraj) {
       if(shortTj.AlgMod[kKilled]) continue;
       if(shortTj.CTP != inCTP) continue;
       unsigned short spts = shortTj.EndPt[1] - shortTj.EndPt[0];
       if(spts > 20) continue;
       // ignore delta rays
       if(shortTj.PDGCode == 11) continue;
       // ignore InShower Tjs
       if(shortTj.SSID > 0) continue;
       auto tjhits = PutTrajHitsInVector(shortTj, kAllHits);
       if(tjhits.empty()) continue;
       std::vector<int> tids;
       std::vector<unsigned short> tcnt;
       for(auto iht : tjhits) {
         auto& hit = tjs.fHits[iht];
         if(hit.InTraj <= 0) continue;
         if((unsigned int)hit.InTraj > tjs.allTraj.size()) continue;
         if(hit.InTraj == shortTj.ID) continue;
         unsigned short indx = 0;
         for(indx = 0; indx < tids.size(); ++indx) if(hit.InTraj == tids[indx]) break;
         if(indx == tids.size()) {
           tids.push_back(hit.InTraj);
           tcnt.push_back(1);
         } else {
           ++tcnt[indx];
         }
       } // iht
       if(tids.empty()) continue;
       // find the max count for Tjs that are longer than this one
       unsigned short maxcnt = 0;
       for(unsigned short indx = 0; indx < tids.size(); ++indx) {
         if(tcnt[indx] > maxcnt) {
           auto& ltj = tjs.allTraj[tids[indx] - 1];
           unsigned short lpts = ltj.EndPt[1] - ltj.EndPt[0];
           if(lpts < spts) continue;
           maxcnt = tcnt[indx];
         }
       } // indx
       float hitFrac = (float)maxcnt / (float)tjhits.size();
       if(hitFrac < 0.1) continue;
     } // shortTj
   } // MergeGhostTjs

void tca::MergeNearby2DShowers	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		const CTP_t &	inCTP,
		bool	prt
	)

Definition at line 2443 of file TCShower.cxx.

References AddTj(), tca::Trajectory::AlgMod, tca::TjStuff::allTraj, ChkAssns(), tca::TjStuff::cots, tca::ShowerStruct::CTP, DontCluster(), GetAssns(), tca::ShowerStruct::ID, kMat3D, kMergeNrShowers, MCSMom(), MergeShowersAndStore(), tca::ShowerStruct::NearTjIDs, tca::TjStuff::pfps, SetIntersection(), tca::ShowerStruct::ShowerTjID, ss, tca::ShowerStruct::TjIDs, and tca::TjStuff::UseAlg.

Referenced by FindShowers3D().

   {
     if(!tjs.UseAlg[kMergeNrShowers]) return;
     if(tjs.cots.empty()) return;
     
     std::string fcnLabel = inFcnLabel + ".MNS";
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<fcnLabel<<" list";
       for(auto& ss : tjs.cots) {
         if(ss.CTP != inCTP) continue;
         if(ss.ID == 0) continue;
         myprt<<"  ss.ID "<<ss.ID<<" NearTjs";
         for(auto& id : ss.NearTjIDs) myprt<<" "<<id;
         myprt<<"\n";
       }
     } // prt
     
     bool keepMerging = true;
     while(keepMerging) {
       keepMerging = false;
       for(unsigned short ci1 = 0; ci1 < tjs.cots.size() - 1; ++ci1) {
         ShowerStruct& ss1 = tjs.cots[ci1];
         if(ss1.CTP != inCTP) continue;
         if(ss1.ID == 0) continue;
         if(ss1.TjIDs.empty()) continue;
         // put the inshower tjs and the nearby tjs into one list
         std::vector<int> ss1list = ss1.TjIDs;
         ss1list.insert(ss1list.end(), ss1.NearTjIDs.begin(), ss1.NearTjIDs.end());
         for(unsigned short ci2 = ci1 + 1; ci2 < tjs.cots.size(); ++ci2) {
           ShowerStruct& ss2 = tjs.cots[ci2];
           if(ss2.CTP != inCTP) continue;
           if(ss2.ID == 0) continue;
           if(ss2.TjIDs.empty()) continue;
           if(DontCluster(tjs, ss1.TjIDs, ss2.TjIDs)) continue;
           std::vector<int> ss2list = ss2.TjIDs;
           ss2list.insert(ss2list.end(), ss2.NearTjIDs.begin(), ss2.NearTjIDs.end());
           std::vector<int> shared = SetIntersection(ss1list, ss2list);
           if(shared.empty()) continue;
           if(prt) {
             mf::LogVerbatim myprt("TC");
             myprt<<fcnLabel<<" Merge 2S"<<ss2.ID<<" into 2S"<<ss1.ID<<"? shared nearby:";
             for(auto tjid : shared) myprt<<" T"<<tjid;
           } // prt
           // add the shared Tjs to ss1 if they meet the requirements
           bool doMerge = false;
           for(auto& tjID : shared) {
             bool inSS1 = (std::find(ss1.TjIDs.begin(), ss1.TjIDs.end(), tjID) != ss1.TjIDs.end());
             bool inSS2 = (std::find(ss2.TjIDs.begin(), ss2.TjIDs.end(), tjID) != ss2.TjIDs.end());
             if(inSS1 && !inSS2) doMerge = true;
             if(!inSS1 && inSS2) doMerge = true;
             // need to add it?
             if(inSS1 || inSS2) continue;
             auto& tj = tjs.allTraj[tjID - 1];
             // ignore long muons
             if(tj.PDGCode == 13 && tj.Pts.size() > 100 && tj.ChgRMS < 0.5) {
               if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" T"<<tj.ID<<" looks like a muon. Don't add it";
               continue;
             }
             // see if it looks like a muon in 3D
             if(tj.AlgMod[kMat3D]) {
               auto TInP = GetAssns(tjs, "T", tj.ID, "P");
               if(!TInP.empty()) {
                 auto& pfp = tjs.pfps[TInP[0] - 1];
                 if(pfp.PDGCode == 13 && MCSMom(tjs, pfp.TjIDs) > 500) continue;
               } // TInP not empty
             } // 3D matched
             if(AddTj(fcnLabel, tjs, tjID, ss1, false, prt)) doMerge = true;
           } // tjID
           if(!doMerge) continue;
           if(MergeShowersAndStore(fcnLabel, tjs, ss1.ID, ss2.ID, prt)) {
             Trajectory& stj = tjs.allTraj[ss1.ShowerTjID - 1];
             stj.AlgMod[kMergeNrShowers] = true;
             if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" success";
             keepMerging = true;
             break;
           }
         } // ci2
       } // ci1
     } // keepMerging
     
     ChkAssns(fcnLabel, tjs);
     
   } //MergeNearby2DShowers

void tca::MergeOverlap	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		const CTP_t &	inCTP,
		bool	prt
	)

Definition at line 2530 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, ChkAssns(), close(), tca::TjStuff::cots, DontCluster(), DotProd(), kMergeOverlap, MergeShowersAndStore(), PointInsideEnvelope(), PosSep(), PosSep2(), tca::TjStuff::ShowerTag, and tca::TjStuff::UseAlg.

Referenced by cluster::ClusterCrawlerAlg::ClusterLoop(), and FindShowers3D().

   {
     // Merge showers whose envelopes overlap each other
     
     /*
      # 0 Mode (<= 0 OFF, 1 = find showers before 3D match, 2 = find showers after 3D match)
      # 1 Max Tj MCSMom for a shower tag
      # 2 Max separation
      # 3 Min energy (MeV)
      # 4 rms width factor
      # 5 Min shower 1/2 width (WSE units)
      # 6 Min total Tj Pts
      # 7 Min Tjs
      # 8 max parent FOM
      # 9 max direction FOM
      # 10 max aspect ratio
      # 11 Debug in CTP (>10 debug cotID + 10)
      */
     
     if(tjs.ShowerTag[2] <= 0) return;
     if(!tjs.UseAlg[kMergeOverlap]) return;
     if(tjs.cots.empty()) return;
     
     std::string fcnLabel = inFcnLabel + ".MO";
     
     // Require that the maximum separation is about two radiation lengths
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" checking using separation cut "<<tjs.ShowerTag[2];
     
     float sepCut2 = tjs.ShowerTag[2] * tjs.ShowerTag[2];
     
     // Iterate if a merge is done
     bool didMerge = true;
     while(didMerge) {
       didMerge = false;
       // See if the envelopes overlap
       for(unsigned short ict = 0; ict < tjs.cots.size() - 1; ++ict) {
         auto& iss = tjs.cots[ict];
         if(iss.ID == 0) continue;
         if(iss.TjIDs.empty()) continue;
         if(iss.CTP != inCTP) continue;
         for(unsigned short jct = ict + 1; jct < tjs.cots.size(); ++jct) {
           auto& jss = tjs.cots[jct];
           if(jss.ID == 0) continue;
           if(jss.TjIDs.empty()) continue;
           if(jss.CTP != iss.CTP) continue;
           if(DontCluster(tjs, iss.TjIDs, jss.TjIDs)) continue;
           bool doMerge = false;
           for(auto& ivx : iss.Envelope) {
             doMerge = PointInsideEnvelope(ivx, jss.Envelope);
             if(doMerge) break;
           } // ivx
           if(!doMerge) {
             for(auto& jvx : jss.Envelope) {
               doMerge = PointInsideEnvelope(jvx, iss.Envelope);
               if(doMerge) break;
             } // ivx
           }
           if(!doMerge) {
             // check proximity between the envelopes
             for(auto& ivx : iss.Envelope) {
               for(auto& jvx : jss.Envelope) {
                 if(PosSep2(ivx, jvx) < sepCut2) {
                   if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Envelopes 2S"<<iss.ID<<" 2S"<<jss.ID<<" are close "<<PosSep(ivx, jvx)<<" cut "<<tjs.ShowerTag[2];
                   doMerge = true;
                   break;
                 }
               } // jvx
               if(doMerge) break;
             } // ivx
           } // !domerge
           if(!doMerge) continue;
           // check the relative positions and angle differences. Determine which tps are the
           // closest. Don't merge if the closest points are at the shower start and the angle
           // difference is large
           unsigned short iClosePt = 0;
           unsigned short jClosePt = 0;
           float close = 1E6;
           auto& istj = tjs.allTraj[iss.ShowerTjID - 1];
           auto& jstj = tjs.allTraj[jss.ShowerTjID - 1];
           for(unsigned short ipt = 0; ipt < 3; ++ipt) {
             for(unsigned short jpt = 0; jpt < 3; ++jpt) {
               float sep = PosSep2(istj.Pts[ipt].Pos, jstj.Pts[jpt].Pos);
               if(sep < close) {
                 close = sep;
                 iClosePt = ipt;
                 jClosePt = jpt;
               }
             } // jpt
           } // ipt
           float costh = DotProd(istj.Pts[0].Dir, jstj.Pts[0].Dir);
           if(iClosePt == 0 && jClosePt == 0 && costh < 0.955) {
             if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" showers are close at the start points with costh "<<costh<<". Don't merge";
             continue;
           }
           if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Merge "<<iss.ID<<" and "<<jss.ID;
           if(MergeShowersAndStore(fcnLabel, tjs, iss.ID, jss.ID, prt)) {
             Trajectory& stj = tjs.allTraj[iss.ShowerTjID - 1];
             stj.AlgMod[kMergeOverlap] = true;
             didMerge = true;
             break;
           } else {
             if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Merge failed";
           }
         } // jct
       } // ict
     } // didMerge
     
     ChkAssns(fcnLabel, tjs);
 
   } // MergeOverlap

bool tca::MergePFPTjs	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 1174 of file PFPUtils.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, geo::CryostatID::Cryostat, tca::Trajectory::CTP, DecodeCTP(), EncodeCTP(), evd::details::end(), tca::TjStuff::EventsProcessed, tca::TjStuff::geom, tca::Trajectory::ID, tca::PFPStruct::ID, kMat3DMerge, MakeTrajectoryObsolete(), MakeVertexObsolete(), tca::Trajectory::MCSMom, MCSMom(), geo::TPCGeo::Nplanes(), geo::PlaneID::Plane, PrintPFP(), tca::Trajectory::Pts, ReverseTraj(), SetEndPoints(), SetPDGCode(), tca::Trajectory::SSID, tca::Trajectory::StepDir, StoreTraj(), tca::PFPStruct::TjIDs, tca::PFPStruct::Tp3s, geo::TPCID::TPC, geo::GeometryCore::TPC(), tca::PFPStruct::TPCID, UpdateMatchStructs(), UpdateTp3s(), tca::TjStuff::vtx, and tca::Trajectory::VtxID.

Referenced by DefinePFP().

   {
     // Checks the list of Tjs in pfp.TjIDs and merges those that are in 
     // the same plane. This function uses the ordering of Tps which should
     // have been sorted
     if(pfp.TjIDs.empty()) return false;
     if(pfp.Tp3s.empty()) return false;
     
     geo::TPCGeo const& TPC = tjs.geom->TPC(pfp.TPCID);
     unsigned short nplanes = TPC.Nplanes();
     
     // see if anything needs to be done
     std::vector<unsigned short> cntInPln(nplanes);
     bool itsOK = true;
     for(auto tjid : pfp.TjIDs) {
       auto& tj = tjs.allTraj[tjid - 1];
       unsigned short plane = DecodeCTP(tj.CTP).Plane;
       ++cntInPln[plane];
       if(cntInPln[plane] > 1) itsOK = false;
     }
     if(itsOK) return true;
     
     // vector of tj IDs that will replace pfp.TjIDs
     std::vector<int> newTjIDs;
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"MergePFPTjs: P"<<pfp.ID<<" in";
       for(auto tjid : pfp.TjIDs) myprt<<" T"<<tjid;
     }
     
     for(unsigned short plane = 0; plane < nplanes; ++plane) {
       CTP_t inCTP = EncodeCTP(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
       // save the TjIDs as unsigned short to match with Tj2Pts
       std::vector<unsigned short> tjids;
       for(auto tjid : pfp.TjIDs) if(tjs.allTraj[tjid - 1].CTP == inCTP) tjids.push_back((unsigned short)tjid);
       // Only one tj in this plane. No need to merge
       if(tjids.size() == 1) {
         newTjIDs.push_back((int)tjids[0]);
         continue;
       }
       // no tjs in this plane
       if(tjids.size() == 0) continue;
       // find the first ID and ipt of Tjs in this plane as they are
       // encountered while iterating through Tp3s. This scheme assumes that the Tp3s have
       // been sorted by distance from the start and the Tjs are broken end-to-end. This 
       // information will be used to determine if Tjs need to be reversed before inserting
       // the points in to the merged trajectory
       //                     Tj ID   first ipt
       std::vector<std::array<unsigned short, 2>> firstPts;
       for(unsigned short itp3 = 0; itp3 < pfp.Tp3s.size(); ++itp3) {
         auto& tp3 = pfp.Tp3s[itp3];
         for(auto& tj2pt : tp3.Tj2Pts) {
           unsigned short tjIndx = 0;
           for(tjIndx = 0; tjIndx < tjids.size(); ++tjIndx) if(tj2pt.id == tjids[tjIndx]) break;
           if(tjIndx == tjids.size()) continue;
           // look for this tj in firstPts
           unsigned short firstPtsIndx = 0;
           for(firstPtsIndx = 0; firstPtsIndx < firstPts.size(); ++firstPtsIndx) if(tj2pt.id == firstPts[firstPtsIndx][0]) break;
           if(firstPtsIndx == firstPts.size()) {
             // not found so add it
             std::array<unsigned short, 2> firstPt {{tj2pt.id, tj2pt.ipt}};
             firstPts.push_back(firstPt);
           }
         } // tj2pt
       } // itp3
       if(firstPts.empty()) continue;
       // create a new merged trajectory
       Trajectory mtj;
       // give it a bogus ID
       mtj.ID = -6666;
       mtj.CTP = inCTP;
       mtj.StepDir = 1;
       bool first = true;
       for(auto firstPt : firstPts) {
         // make a copy so we can reverse it and drop it if the merge fails
         auto tj = tjs.allTraj[firstPt[0] - 1];
         unsigned short midPt = 0.5 * (tj.EndPt[0] + tj.EndPt[1]);
         if(firstPt[1] > midPt) ReverseTraj(tjs, tj);
         // Transfer vertices to mtj
         if(first) {
           first = false;
           mtj.VtxID[0] = tj.VtxID[0];
         }
         mtj.VtxID[1] = tj.VtxID[1];
         // insert the points at the end
         for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
           auto& tp = tj.Pts[ipt];
           if(tp.Chg <= 0) continue;
           mtj.Pts.push_back(tp);
         }
       } // firstPt
       mtj.AlgMod[kMat3DMerge] = true;
       SetEndPoints(tjs, mtj);
       mtj.MCSMom = MCSMom(tjs, mtj);
       SetPDGCode(tjs, mtj);
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<" P"<<pfp.ID<<" try to merge";
         for(auto tjid : tjids) {
           auto& tj = tjs.allTraj[tjid - 1];
           myprt<<" T"<<tjid<<" MCSMom "<<tj.MCSMom;
         }
         myprt<<" -> T"<<tjs.allTraj.size() + 1;
         myprt<<" MCSMom "<<mtj.MCSMom;
       }
       // kill the broken tjs and update the pfp TP3s
       for(auto tjid : tjids) {
         auto& tj = tjs.allTraj[tjid - 1];
         if(tj.SSID > 0) mtj.SSID = tj.SSID;
         MakeTrajectoryObsolete(tjs, tjid - 1);
       }
       // save the new one
       if(!StoreTraj(tjs, mtj)) {
         std::cout<<"MergePFPTjs: StoreTraj failed P"<<pfp.ID<<" EventsProcessed "<<tjs.EventsProcessed<<"\n";
         return false;
       }
       int newTjID = tjs.allTraj.size();
       newTjIDs.push_back(newTjID);
       // prepare to clobber vertices
       std::vector<unsigned short> vxlist;
       for(auto tjid : tjids) {
         // update the stored match struct and Tp3s
         UpdateMatchStructs(tjs, tjid, newTjID);
         // Update the Tp3s of this pfp
         UpdateTp3s(tjs, pfp, tjid, newTjID);
         auto& tj = tjs.allTraj[tjid - 1];
         for(unsigned short end = 0; end < 2; ++end) {
           if(tj.VtxID[end] == 0) continue;
           if(std::find(vxlist.begin(), vxlist.end(), tj.VtxID[end]) != vxlist.end()) {
             auto& vx2 = tjs.vtx[tj.VtxID[end] - 1];
 //            std::cout<<"P"<<pfp.ID<<" Clobber 2V"<<vx2.ID<<"\n";
             MakeVertexObsolete(tjs, vx2, true);
           } else {
             vxlist.push_back(tj.VtxID[end]);
           }
         } // end
       } // tjid
     } // plane
     
     pfp.TjIDs = newTjIDs;
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"MergePFPTjs: P"<<pfp.ID<<" out";
       for(auto tjid : pfp.TjIDs) myprt<<" T"<<tjid;
       PrintPFP("MPTJ", tjs, pfp, true);
     }
     return true;
   } // MergePFPTjs

void tca::MergeShowerChain	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		const CTP_t &	inCTP,
		bool	prt
	)

Definition at line 2642 of file TCShower.cxx.

References tca::TjStuff::allTraj, ChkAssns(), tca::TjStuff::cots, tca::ShowerStruct::CTP, DontCluster(), tca::ShowerStruct::Energy, tca::ShowerStruct::ID, kMergeShChain, lessThan(), MakeBareTrajPoint(), MergeShowers(), PointTrajDOCA(), PosSep(), PrintPos(), tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::TjIDs, and tca::TjStuff::UseAlg.

Referenced by FindShowers3D().

   {
     // Merge chains of 3 or more showers that lie on a line
     
     if(!tjs.UseAlg[kMergeShChain]) return;
     
     std::string fcnLabel = inFcnLabel + ".MSC";
     
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<": MergeShowerChain inCTP "<<inCTP;
     
     std::vector<int> sids;
     std::vector<TrajPoint> tpList;
     for(unsigned short ict = 0; ict < tjs.cots.size(); ++ict) {
       ShowerStruct& iss = tjs.cots[ict];
       if(iss.ID == 0) continue;
       if(iss.TjIDs.empty()) continue;
       if(iss.CTP != inCTP) continue;
       // ignore wimpy showers
       if(iss.Energy < 50) continue;
       // save the shower ID
       sids.push_back(iss.ID);
       // and the shower center TP
       tpList.push_back(tjs.allTraj[iss.ShowerTjID - 1].Pts[1]);
     } // ict
     if(sids.size() < 3) return;
     
     // sort by wire so the chain order is reasonable
     std::vector<SortEntry> sortVec(sids.size());
     for(unsigned short ii = 0; ii < sortVec.size(); ++ii) {
       sortVec[ii].index = ii;
       sortVec[ii].length = tpList[ii].Pos[0];
     }
     std::sort(sortVec.begin(), sortVec.end(), lessThan);
     auto tsids = sids;
     auto ttpList = tpList;
     for(unsigned short ii = 0; ii < sortVec.size(); ++ii) {
       unsigned short indx = sortVec[ii].index;
       sids[ii] = tsids[indx];
       tpList[ii] = ttpList[indx];
     }
     
     // TODO: These cuts should be generalized somehow
     float minSep = 150;
     float maxDelta = 30;
     for(unsigned short ii = 0; ii < sids.size() - 2; ++ii) {
       auto& iss = tjs.cots[sids[ii] - 1];
       if(iss.ID == 0) continue;
       unsigned short jj = ii + 1;
       auto& jss = tjs.cots[sids[jj] - 1];
       if(jss.ID == 0) continue;
       std::vector<int> chain;
       float sepij = PosSep(tpList[ii].Pos, tpList[jj].Pos);
       if(sepij > minSep) continue;
       bool skipit = DontCluster(tjs, iss.TjIDs, jss.TjIDs);
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" i2S"<<iss.ID<<" "<<PrintPos(tjs, tpList[ii].Pos)<<" j2S"<<jss.ID<<" "<<PrintPos(tjs, tpList[jj].Pos)<<" sepij "<<sepij<<" skipit? "<<skipit;
       if(skipit) continue;
       // draw a line between these points
       TrajPoint tp;
       MakeBareTrajPoint(tjs, tpList[ii], tpList[jj], tp);
 //      PrintTrajPoint("ij", tjs, 0, 1, 0, tp);
       for(unsigned short kk = jj + 1; kk < sids.size(); ++kk) {
         auto& kss = tjs.cots[sids[kk] - 1];
         if(kss.ID == 0) continue;
         if(DontCluster(tjs, iss.TjIDs, kss.TjIDs)) continue;
         if(DontCluster(tjs, jss.TjIDs, kss.TjIDs)) continue;
         float sepjk = PosSep(tpList[jj].Pos, tpList[kk].Pos);
         float delta = PointTrajDOCA(tjs, tpList[kk].Pos[0], tpList[kk].Pos[1], tp);
         if(prt) {
           mf::LogVerbatim myprt("TC");
           myprt<<fcnLabel<<"   k2S"<<kss.ID<<" "<<PrintPos(tjs, tpList[kk].Pos)<<" sepjk "<<sepjk<<" delta "<<delta;
           if(sepjk > minSep || delta > maxDelta) {
             myprt<<" failed separation "<<minSep<<" or delta cut "<<maxDelta;
           } else {
             myprt<<" add to the chain";
           }
         } // prt
         if(sepjk > minSep || delta > maxDelta) {
           // clear a short chain?
           if(chain.size() > 2) {
             // merge this chain
             int newID = MergeShowers(fcnLabel, tjs, chain, prt);
             if(prt) {
               mf::LogVerbatim myprt("TC");
               myprt<<fcnLabel<<" merged chain";
               for(auto ssID : chain) myprt<<" 2S"<<ssID;
               myprt<<" -> 2S"<<newID;
             } // prt
           } // long chain
           chain.clear();
           break;
         }  else {
           // add this shower to the chain
           if(chain.empty()) {
             chain.resize(3);
             chain[0] = sids[ii]; chain[1] = sids[jj]; chain[2] = sids[kk]; 
           } else {
             chain.push_back(sids[kk]);
           }
           // Refine the TP position and direction
           MakeBareTrajPoint(tjs, tpList[ii], tpList[kk], tp);
 //          PrintTrajPoint("ik", tjs, 0, 0, chain.size(), tp);
         } // add to an existing chain
       } // kk
       // push the last one
       if(chain.size() > 2) {
         int newID = MergeShowers(fcnLabel, tjs, chain, prt);
 /*
         if(newID > 0) {
           auto& newss = tjs.cots[newID - 1];
           if(AddTjsInsideEnvelope(fcnLabel, tjs, newss, prt)) UpdateShower(fcnLabel, tjs, newss, prt);
         }
 */
         if(prt) {
           mf::LogVerbatim myprt("TC");
           myprt<<fcnLabel<<" merged chain";
           for(auto ssID : chain) myprt<<" "<<ssID;
           myprt<<" -> new ssID "<<newID;
         } // prt
       } // long chain
     } // ii
     
     ChkAssns(fcnLabel, tjs);
     
   } // MergeShowerChain

int tca::MergeShowers	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		std::vector< int >	ssIDs,
		bool	prt
	)

Definition at line 2985 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::cots, CreateSS(), kKilled, MakeShowerObsolete(), ss, StoreShower(), and UpdateShower().

Referenced by MergeShowerChain().

   {
     // merge a list of showers and return the ID of the merged shower.
     // Returns 0 if there was a failure. 
     
     std::string fcnLabel = inFcnLabel + ".MS";
     if(ssIDs.size() < 2) return 0;
     // check for a valid ID
     for(auto ssID : ssIDs) if(ssID <= 0 || ssID > (int)tjs.cots.size()) return 0;
     // check for the same CTP and consistent assns
     int ss3Assn = 0;
     auto& ss0 = tjs.cots[ssIDs[0] - 1];
     std::vector<int> tjl;
     for(auto ssID : ssIDs) {
       auto& ss = tjs.cots[ssID - 1];
       if(ss.CTP != ss0.CTP) return 0;
       tjl.insert(tjl.end(), ss.TjIDs.begin(), ss.TjIDs.end());
       if(ss.SS3ID > 0 && ss3Assn == 0) ss3Assn = ss.SS3ID;
       if(ss.SS3ID > 0 && ss.SS3ID != ss3Assn) {
         std::cout<<fcnLabel<<" Assn conflict \n";
         return 0;
       }
     } // ssID
     // ensure the InShower Tjs are valid
     for(auto tjID : tjl) {
       auto& tj = tjs.allTraj[tjID - 1];
       if(tj.CTP != ss0.CTP || tj.AlgMod[kKilled]) {
         std::cout<<fcnLabel<<" bad InShower T"<<tjID<<"\n";
         return 0;
       }
     } // tjID
     
     // mark the old showers killed
     for(auto ssID : ssIDs) {
       auto& ss = tjs.cots[ssID - 1];
       ss.ID = 0;
       // kill the shower Tj
       auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
       stj.AlgMod[kKilled] = true;
     } // tjID
 
     // in with the new
     auto newss = CreateSS(tjs, 0, tjl);
     if(newss.ID == 0) return 0;
     
     for(auto tid : tjl) {
       auto& tj = tjs.allTraj[tid - 1];
       tj.SSID = newss.ID;
     } // tid
     newss.SS3ID = ss3Assn;
     
     // define the new shower
     if(!UpdateShower(fcnLabel, tjs, newss, prt)) {
       std::cout<<fcnLabel<<" UpdateShower failed\n";
       MakeShowerObsolete(fcnLabel, tjs, newss, prt);
       return 0;
     }
     // store it
     if(!StoreShower(fcnLabel, tjs, newss)) {
       std::cout<<fcnLabel<<" StoreShower failed\n";
       MakeShowerObsolete(fcnLabel, tjs, newss, prt);
       return 0;
     }
     return newss.ID;
     
   } // MergeShowers

bool tca::MergeShowersAndStore	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		int	icotID,
		int	jcotID,
		bool	prt
	)

Definition at line 3053 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::cots, tca::ShowerStruct::CTP, tca::Trajectory::ID, tca::ShowerStruct::ID, KillVerticesInShower(), MakeTrajectoryObsolete(), tca::ShowerStruct::NearTjIDs, tca::ShowerStruct::NeedsUpdate, tca::Trajectory::Pts, tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::ShPts, tca::ShowerStruct::SS3ID, tca::ShowerStruct::TjIDs, tca::ShowerStruct::TruParentID, and UpdateShower().

Referenced by MergeNearby2DShowers(), MergeOverlap(), MergeShowerTjsAndStore(), MergeSubShowers(), and Reconcile3D().

   {
     // Merge showers using shower indices. The icotID shower is modified in-place.
     // The jcotID shower is declared obsolete. This function also re-defines the shower and
     // preserves the icotID Parent ID.
     
     if(icotID <= 0 || icotID > (int)tjs.cots.size()) return false;
     ShowerStruct& iss = tjs.cots[icotID - 1];
     if(iss.ID == 0) return false;
     if(iss.TjIDs.empty()) return false;
     if(iss.ShowerTjID <= 0) return false;
     
     if(jcotID <= 0 || jcotID > (int)tjs.cots.size()) return false;
     ShowerStruct& jss = tjs.cots[jcotID - 1];
     if(jss.TjIDs.empty()) return false;
     if(jss.ID == 0) return false;
     if(jss.ShowerTjID <= 0) return false;
 
     if(iss.CTP != jss.CTP) return false;
     
     std::string fcnLabel = inFcnLabel + ".MSAS";
     
     if(iss.SS3ID > 0 && jss.SS3ID > 0 && iss.SS3ID != jss.SS3ID) {
       std::cout<<fcnLabel<<" Error: 2S"<<iss.ID<<" and S"<<jss.ID<<" have different 2S -> 3S assns\n";
       return false;
     }
     
     Trajectory& itj = tjs.allTraj[iss.ShowerTjID - 1];
     Trajectory& jtj = tjs.allTraj[jss.ShowerTjID - 1];
     if(!itj.Pts[1].Hits.empty() || !jtj.Pts[1].Hits.empty()) {
       std::cout<<fcnLabel<<" Error: These shower Tjs have hits! T"<<itj.ID<<" T"<<jtj.ID<<"\n";
       return false;
     }
     
     iss.TjIDs.insert(iss.TjIDs.end(), jss.TjIDs.begin(), jss.TjIDs.end());
     // make a new trajectory using itj as a template
     Trajectory ktj = itj;
     ktj.ID = tjs.allTraj.size() + 1;
 
     tjs.allTraj.push_back(ktj);
     // kill jtj
     MakeTrajectoryObsolete(tjs, iss.ShowerTjID - 1);
     MakeTrajectoryObsolete(tjs, jss.ShowerTjID - 1);
     tjs.allTraj[iss.ShowerTjID - 1].ParentID = ktj.ID;
     tjs.allTraj[jss.ShowerTjID - 1].ParentID = ktj.ID;
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" killed stj T"<<iss.ShowerTjID<<" and T"<<jss.ShowerTjID<<" new T"<<ktj.ID;
     // revise the shower
     iss.ShowerTjID = ktj.ID;
     // transfer the list of Tj IDs
     iss.TjIDs.insert(iss.TjIDs.end(), jss.TjIDs.begin(), jss.TjIDs.begin());
     std::sort(iss.TjIDs.begin(), iss.TjIDs.end());
     // correct the assn
     for(auto tid : iss.TjIDs) {
       auto& tj = tjs.allTraj[tid - 1];
       tj.SSID = iss.ID;
     } // tid
     // transfer a 2S -> 3S assn
     if(iss.SS3ID == 0 && jss.SS3ID > 0) iss.SS3ID = jss.SS3ID;
     // merge the list of nearby Tjs
     iss.NearTjIDs.insert(iss.NearTjIDs.end(), jss.NearTjIDs.begin(), jss.NearTjIDs.end());
     // transfer the TruParentID if it is in jss
     if(jss.TruParentID > 0) iss.TruParentID = jss.TruParentID;
 //    iss.ParentID = 0;
     iss.NeedsUpdate = true;
     // force a full update
     iss.ShPts.clear();
     jss.ID = 0;
     bool success = UpdateShower(fcnLabel, tjs, iss, prt);
     KillVerticesInShower(fcnLabel, tjs, iss, prt);
  
     return success;
 
   } // MergeShowersAndStore

bool tca::MergeShowerTjsAndStore	(	TjStuff &	tjs,
		unsigned short	istj,
		unsigned short	jstj,
		bool	prt
	)

Definition at line 3128 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::TjStuff::cots, GetCotID(), tca::Trajectory::ID, tca::ShowerStruct::ID, kShowerTj, MergeShowersAndStore(), and tca::ShowerStruct::TjIDs.

Referenced by MergeAndStore().

   {
     // Merge showers using showerTj indices
     // This function is called from MergeAndStore whose function is to merge two line-like
     // trajectories and store them. This function was called because at least one of the
     // trajectories is a shower Tj. Assume that the decision to merge them has been made elsewhere.
     
     if(istj > tjs.allTraj.size() - 1) return false;
     if(jstj > tjs.allTraj.size() - 1) return false;
     
     Trajectory& itj = tjs.allTraj[istj];
     Trajectory& jtj = tjs.allTraj[jstj];
     
     std::string fcnLabel = "MSTJ";
     
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" MergeShowerTjsAndStore Tj IDs "<<itj.ID<<"  "<<jtj.ID;
     
     // First we check to make sure that both are shower Tjs.
     if(!itj.AlgMod[kShowerTj] && !jtj.AlgMod[kShowerTj]) {
       if(prt) mf::LogVerbatim("TC")<<" One of these isn't a shower Tj";
       return false;
     }
     
     // We need to keep the convention used in MergeAndStore to create a new merged trajectory
     // and kill the two fragments. This doesn't require making a new shower however. We can just
     // re-purpose one of the existing showers
     int icotID = GetCotID(tjs, itj.ID);
     if(icotID == 0) return false;
     ShowerStruct& iss = tjs.cots[icotID - 1];
     if(iss.ID == 0) return false;
     if(iss.TjIDs.empty()) return false;
     int jcotID = GetCotID(tjs, jtj.ID);
     if(jcotID == 0) return false;
     ShowerStruct& jss = tjs.cots[jcotID - 1];
     if(jss.ID == 0) return false;
     if(jss.TjIDs.empty()) return false;
     
     return MergeShowersAndStore(fcnLabel, tjs, icotID, jcotID, prt);
     
   } // MergeShowerTjsAndStore

void tca::MergeSubShowers	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		const CTP_t &	inCTP,
		bool	prt
	)

Definition at line 2878 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::ShowerStruct::AspectRatio, ChkAssns(), tca::TjStuff::cots, tca::TrajPoint::Dir, DontCluster(), tca::ShowerStruct::Energy, FindAlongTrans(), greaterThan(), tca::ShowerStruct::ID, tca::SortEntry::index, InShowerProbLong(), InShowerProbTrans(), kMergeSubShowers, MergeShowersAndStore(), PointTrajDOCA(), tca::TrajPoint::Pos, PosSep(), ShowerParams(), tca::TjStuff::ShowerTag, tca::ShowerStruct::ShowerTjID, ss, tca::ShowerStruct::TjIDs, tca::TjStuff::UseAlg, and tca::TjStuff::WirePitch.

Referenced by FindShowers3D().

   {
     // Merge small showers that are downstream of larger showers
     
     if(!tjs.UseAlg[kMergeSubShowers]) return;
     
     std::string fcnLabel = inFcnLabel + ".MSS";
     bool newCuts = (tjs.ShowerTag[0] == 4);
     constexpr float radLen = 14 / 0.3;
     
     if(prt) {
       if(newCuts) {
         mf::LogVerbatim("TC")<<fcnLabel<<" MergeSubShowers checking using ShowerParams";
       } else {
         mf::LogVerbatim("TC")<<fcnLabel<<" MergeSubShowers checking using radiation length cut ";
       }
     } // prt
     
     bool keepMerging = true;
     while(keepMerging) {
       keepMerging = false;
       // sort by decreasing energy
       std::vector<SortEntry> sortVec;
       for(auto& ss : tjs.cots) {
         if(ss.ID == 0) continue;
         if(ss.CTP != inCTP) continue;
         SortEntry se;
         se.index = ss.ID - 1;
         se.length = ss.Energy;
         sortVec.push_back(se);
       } // ss
       if(sortVec.size() < 2) return;
       std::sort(sortVec.begin(), sortVec.end(), greaterThan);
       for(unsigned short ii = 0; ii < sortVec.size() - 1; ++ii) {
         ShowerStruct& iss = tjs.cots[sortVec[ii].index];
         if(iss.ID == 0) continue;
         // this shouldn't be done to showers that are ~round
         if(iss.AspectRatio > 0.5) continue;
         TrajPoint& istp1 = tjs.allTraj[iss.ShowerTjID - 1].Pts[1];
         double shMaxAlong, along95;
         ShowerParams((double)iss.Energy, shMaxAlong, along95);
         // convert along95 to a separation btw shower max and along95
         along95 -= shMaxAlong;
         // convert to WSE
         along95 /= tjs.WirePitch;
         for(unsigned short jj = ii + 1; jj < sortVec.size(); ++jj) {
           ShowerStruct& jss = tjs.cots[sortVec[jj].index];
           if(jss.ID == 0) continue;
           if(DontCluster(tjs, iss.TjIDs, jss.TjIDs)) continue;
           TrajPoint& jstp1 = tjs.allTraj[jss.ShowerTjID - 1].Pts[1];
           if(newCuts) {
             // find the longitudinal and transverse separation using the higher energy
             // shower which probably is better defined.
             Point2_t alongTrans;
             FindAlongTrans(istp1.Pos, istp1.Dir, jstp1.Pos, alongTrans);
             // the lower energy shower is at the wrong end of the higher energy shower if alongTrans[0] < 0
             if(alongTrans[0] < 0) continue;
             // increase the cut if the second shower is < 10% of the first shower
             float alongCut = along95;
             if(jss.Energy < 0.1 * iss.Energy) alongCut *= 1.5;
             float probLong = InShowerProbLong(iss.Energy, alongTrans[0]);
             float probTran = InShowerProbTrans(iss.Energy, alongTrans[0], alongTrans[1]);
             if(prt) {
               mf::LogVerbatim myprt("TC");
               myprt<<fcnLabel<<" Candidate i2S"<<iss.ID<<" E = "<<(int)iss.Energy<<" j2S"<<jss.ID<<" E = "<<(int)jss.Energy;
               myprt<<" along "<<std::fixed<<std::setprecision(1)<<alongTrans[0]<<" trans "<<alongTrans[1];
               myprt<<" alongCut "<<alongCut<<" probLong "<<probLong<<" probTran "<<probTran;
             } // prt
             // TODO: fix ShowerParams so we can use the likelihood cut instead
             if(alongTrans[0] > alongCut) continue;
             if(alongTrans[1] > alongTrans[0]) continue;
           } else {
             // old cuts
             float sep = PosSep(istp1.Pos, jstp1.Pos);
             float trad = sep / radLen;
             // Find the IP between them using the projection of the one with the lowest aspect ratio
             float delta = 9999;
             if(iss.AspectRatio < jss.AspectRatio) {
               delta = PointTrajDOCA(tjs, jstp1.Pos[0], jstp1.Pos[1], istp1);
             } else {
               delta = PointTrajDOCA(tjs, istp1.Pos[0], istp1.Pos[1], jstp1);
             }
             // See if delta is consistent with the cone angle of the i shower
             float dang = delta / sep;
             if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Candidate i2S"<<iss.ID<<" j2S"<<jss.ID<<" separation "<<(int)sep<<" radiation lengths "<<trad<<" delta "<<delta<<" dang "<<dang;
             if(trad > 3) continue;
             // There must be a correlation between dang and the energy of these showers...
             if(dang > 0.3) continue;
           } // old cuts
 
           if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Merge them. Re-find shower center, etc";
           if(MergeShowersAndStore(fcnLabel, tjs, iss.ID, jss.ID, prt)) {
             Trajectory& stj = tjs.allTraj[iss.ShowerTjID - 1];
             stj.AlgMod[kMergeSubShowers] = true;
             keepMerging = true;
             break;
           }
         } // jj
         if(keepMerging) break;
       } // ii
     } // keepMerging
     
     ChkAssns(fcnLabel, tjs);
     
   } // MergeSubShowers

void tca::MergeSubShowersTj	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		const CTP_t &	inCTP,
		bool	prt
	)

Definition at line 2768 of file TCShower.cxx.

References AddTj(), tca::TjStuff::allTraj, ChgToMeV(), ChkAssns(), tca::TjStuff::cots, DontCluster(), FarEnd(), kKilled, kMergeSubShowersTj, mat, MCSMom(), NumPtsWithCharge(), PointTrajDOCA(), PosSep(), tca::TjStuff::ShowerTag, ss, and tca::TjStuff::UseAlg.

Referenced by FindShowers3D().

   {
     // merge small showers that are downstream of shower-like tjs. This algorithm is written 
     // for low-energy showers with are likely to be sparse and poorly defined.
     
     if(!tjs.UseAlg[kMergeSubShowersTj]) return;
     
     std::string fcnLabel = inFcnLabel + ".MSSTj";
     
     struct TjSS {
       int ssID;
       int tjID;
       float dang;
     };
     std::vector<TjSS> tjss;
     
     // temp vector for DontCluster
     std::vector<int> tjid(1);
     for(auto& ss : tjs.cots) {
       if(ss.ID == 0) continue;
       if(ss.CTP != inCTP) continue;
       // TODO: Evaluate this cut
       if(ss.Energy > 300) continue;
       auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
       auto stp0 = stj.Pts[0];
       float bestDang = 0.3;
       int bestTj = 0;
       // look for a Tj that has higher energy than the shower
       for(auto& tj : tjs.allTraj) {
         if(tj.AlgMod[kKilled]) continue;
         if(tj.CTP != ss.CTP) continue;
         // require that it isn't in any shower
         if(tj.SSID > 0) continue;
         // require it to be not short
         if(NumPtsWithCharge(tjs, tj, false) < 10) continue;
         // and satisfy the ShowerLike MCSMom cut. It is unlikely to be tagged shower-like
         if(tj.MCSMom > tjs.ShowerTag[1]) continue;
         // check consistency
         tjid[0] = tj.ID;
         if(DontCluster(tjs, tjid, ss.TjIDs)) continue;
         float tjEnergy = ChgToMeV(tj.TotChg);
         // find the end that is furthest away from the shower center
         unsigned short farEnd = FarEnd(tjs, tj, stj.Pts[1].Pos);
         // compare MCSMom at the far end and the near end
         unsigned short midpt = 0.5 * (tj.EndPt[0] + tj.EndPt[1]);
         float mom1 = MCSMom(tjs, tj, tj.EndPt[farEnd], midpt);
         float mom2 = MCSMom(tjs, tj, tj.EndPt[1 - farEnd], midpt);
         float asym = (mom1 - mom2) / (mom1 + mom2);
         auto& farTP = tj.Pts[tj.EndPt[farEnd]];
         // IP btw the far end TP and the shower center
         float doca = PointTrajDOCA(tjs, stp0.Pos[0], stp0.Pos[1], farTP);
         float sep = PosSep(farTP.Pos, stp0.Pos);
         float dang = doca / sep;
         if(prt) {
           mf::LogVerbatim myprt("TC");
           myprt<<fcnLabel<<" Candidate 2S"<<ss.ID<<" T"<<tj.ID<<"_"<<farEnd;
           myprt<<" ShEnergy "<<(int)ss.Energy<<" tjEnergy "<<(int)tjEnergy;
           myprt<<" doca "<<doca<<" sep "<<sep<<" dang "<<dang<<" asym "<<asym;
         }
         if(tjEnergy < ss.Energy) continue;
         if(asym < 0.5) continue;
         // TODO: This should be done more carefully
         // separation cut 100 WSE ~ 30 cm in uB
         if(sep > 100) continue;
         if(dang > bestDang) continue;
         bestDang = dang;
         bestTj = tj.ID;
       } // tj
       if(bestTj == 0) continue;
       TjSS match;
       match.ssID = ss.ID;
       match.tjID = bestTj;
       match.dang = bestDang;
       tjss.push_back(match);
     } // ss
     
     if(tjss.empty()) return;
     
     // ensure that a tj is only put in one shower
     bool keepGoing = true;
     while(keepGoing) {
       keepGoing = false;
       float bestDang = 0.3;
       int bestMatch = 0;
       for(unsigned short mat = 0; mat < tjss.size(); ++mat) {
         auto& match = tjss[mat];
         // already used
         if(match.dang < 0) continue;
         if(match.dang < bestDang) bestMatch = mat;
       } // mat
       if(bestMatch > 0) {
         auto& match = tjss[bestMatch];
         auto& ss = tjs.cots[match.ssID - 1];
         if(!AddTj(fcnLabel, tjs, match.tjID, ss, true, prt)) {
           if(prt) mf::LogVerbatim("TC")<<" Failed";
           continue;
         }
         match.dang = -1;
         // set the AlgMod bit
         auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
         stj.AlgMod[kMergeSubShowersTj] = true;
         keepGoing = true;
       } // found bestMatch
     } // keepGoing
     
     ChkAssns(fcnLabel, tjs);
     
   } // MergeSubShowersTj

bool tca::MergeTjIntoPFP	(	TjStuff &	tjs,
		int	mtjid,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 428 of file Utils.cxx.

References tca::TjStuff::allTraj, MergeAndStore(), and tca::PFPStruct::TjIDs.

   {
     // Tries to merge Tj with ID tjid into PFParticle pfp
     if(mtjid > (int)tjs.allTraj.size()) return false;
     auto& mtj = tjs.allTraj[mtjid - 1];
     // find the Tj in pfp.TjIDs which it should be merged with
     int otjid = 0;
     for(auto tjid : pfp.TjIDs) {
       auto& otj = tjs.allTraj[tjid - 1];
       if(otj.CTP == mtj.CTP) {
         otjid = tjid;
         break;
       }
     } // tjid
     if(otjid == 0) return false;
     if(MergeAndStore(tjs, otjid - 1, mtjid - 1, prt)) {
       int newtjid = tjs.allTraj.size();
       if(prt) mf::LogVerbatim("TC")<<"MergeTjIntoPFP: merged T"<<otjid<<" with T"<<mtjid<<" -> T"<<newtjid;
       std::replace(pfp.TjIDs.begin(), pfp.TjIDs.begin(), otjid, newtjid);
       return true;
     } else {
       if(prt) mf::LogVerbatim("TC")<<"MergeTjIntoPFP: merge T"<<otjid<<" with T"<<mtjid<<" failed ";
       return false;
     }
   } // MergeTjIntoPFP

void tca::MergeTjList ( std::vector< std::vector< int >> & tjList )

Definition at line 1494 of file TCShower.cxx.

   {
     // Merge the lists of Tjs in the lists if they share a common Tj ID
     
     if(tjList.size() < 2) return;
     
     bool didMerge = true;
     while(didMerge) {
       didMerge = false;
       for(unsigned short itl = 0; itl < tjList.size() - 1; ++itl) {
         if(tjList[itl].empty()) continue;
         for(unsigned short jtl = itl + 1; jtl < tjList.size(); ++jtl) {
           if(tjList[itl].empty()) continue;
           auto& itList = tjList[itl];
           auto& jtList = tjList[jtl];
           // See if the j Tj is in the i tjList
           bool jtjInItjList = false;
           for(auto& jtj : jtList) {
             if(std::find(itList.begin(), itList.end(), jtj) != itList.end()) {
               jtjInItjList = true;
               break;
             }
             if(jtjInItjList) break;
           } // jtj
           if(jtjInItjList) {
             // append the jtList to itList
             itList.insert(itList.end(), jtList.begin(), jtList.end());
             // clear jtList
             jtList.clear();
             didMerge = true;
           }
         } // jtl
       } // itl
     } // didMerge
     
     // erase the deleted elements
     unsigned short imEmpty = 0;
     while(imEmpty < tjList.size()) {
       for(imEmpty = 0; imEmpty < tjList.size(); ++imEmpty) if(tjList[imEmpty].empty()) break;
       if(imEmpty < tjList.size()) tjList.erase(tjList.begin() + imEmpty);
     } // imEmpty < tjList.size()
     
     // sort the lists by increasing ID and remove duplicates
     for(auto& tjl : tjList) {
       std::sort(tjl.begin(), tjl.end());
       auto last = std::unique(tjl.begin(), tjl.end());
       tjl.erase(last, tjl.end());
     } // tjl
     
   } // MergeTjList

void tca::MergeTjList2	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		std::vector< std::vector< int >> &	tjList,
		bool	prt
	)

bool tca::MergeWithVertex	(	TjStuff &	tjs,
		VtxStore &	vx,
		unsigned short	oVxID,
		bool	prt
	)

Definition at line 544 of file TCVertex.cxx.

References tca::TjStuff::allTraj, tca::VtxStore::ChiDOF, CloseEnd(), tca::VtxStore::CTP, evd::details::end(), FitVertex(), GetVtxTjIDs(), tca::VtxStore::ID, tca::SortEntry::index, kFixed, kKilled, kVtxMerged, kVxMerge, NearestPtWithChg(), NumPtsWithCharge(), tca::VtxStore::Pos, tca::VtxStore::PosErr, PrintPos(), SetVx2Score(), tca::VtxStore::Stat, tmp, tca::TjStuff::UseAlg, valDecreasing(), and tca::TjStuff::vtx.

Referenced by Find2DVertices().

   {
     // Attempts to merge the trajectories attached to vx with an existing 2D vertex
     // referenced by existingVxID. This function doesn't use the existing end0/end1 vertex association.
     // It returns true if the merging was successful in which case the calling function should
     // not store vx. The calling function needs to have set VtxID to vx.ID for tjs that are currently attached
     // to vx. It assumed that vx hasn't yet been pushed onto tjs.vtx
     
     if(!tjs.UseAlg[kVxMerge]) return false;
     
     if(oVxID > tjs.vtx.size()) return false;
     auto& oVx = tjs.vtx[oVxID - 1];
     if(vx.CTP != oVx.CTP) return false;
     
     // get a list of tjs attached to both vertices
     std::vector<int> tjlist = GetVtxTjIDs(tjs, vx);
 //    auto tjlist = GetAssns(tjs, "2V", vx.ID, "T");
     if(tjlist.empty()) return false;
     std::vector<int> tmp = GetVtxTjIDs(tjs, oVx);
 //    auto tmp = GetAssns(tjs, "2V", oVx.ID, "T");
     if(tmp.empty()) return false;
     for(auto tjid : tmp) {
       if(std::find(tjlist.begin(), tjlist.end(), tjid) == tjlist.end()) tjlist.push_back(tjid);
     } // tjid
     if(tjlist.size() < 2) return false;
     // handle the simple case
     if(tjlist.size() == 2) {
       // Unset the fixed bit
       vx.Stat[kFixed] = false;
       oVx.Stat[kFixed] = false;
       // assign the vx tjs to oVx
       for(auto tjid : tjlist) {
         auto& tj = tjs.allTraj[tjid - 1];
         for(unsigned short end = 0; end < 2; ++end) {
           if(tj.VtxID[end] == vx.ID) tj.VtxID[end] = oVx.ID;
         } // end
       } // tjid
       if(!FitVertex(tjs, oVx, prt)) {
         if(prt) mf::LogVerbatim("TC")<<"MWV: merge failed "<<vx.ID<<" and existing "<<oVx.ID;
         return false;
       }
       return true;
     } // size = 2
     
     // sort by decreasing length
     std::vector<SortEntry> sortVec(tjlist.size());
     for(unsigned int indx = 0; indx < sortVec.size(); ++indx) {
       sortVec[indx].index = indx;
       auto& tj = tjs.allTraj[tjlist[indx] - 1];
       sortVec[indx].val = tj.Pts.size();
     } // indx
     std::sort(sortVec.begin(), sortVec.end(), valDecreasing);
     // re-order the list of Tjs
     auto ttl = tjlist;
     for(unsigned short ii = 0; ii < sortVec.size(); ++ii) tjlist[ii] = ttl[sortVec[ii].index];
     // Create a local vertex using the two longest tjs, then add the shorter ones
     // until the pull reaches the cut
     VtxStore aVx;
     aVx.CTP = vx.CTP;
     std::vector<TrajPoint> tjpts(tjlist.size());
     // determine which point on each Tj that will be used in the vertex fit and stash it in
     // the traj point Step variable. This requires knowing the real position of the merged vertex
     // which we estimate by averaging
     std::array<float, 2> vpos;
     vpos[0] = 0.5 * (vx.Pos[0] + oVx.Pos[0]);
     vpos[1] = 0.5 * (vx.Pos[1] + oVx.Pos[1]);
     for(unsigned short ii = 0; ii < tjpts.size(); ++ii) {
       auto& tj = tjs.allTraj[tjlist[ii] - 1];
       unsigned short npwc = NumPtsWithCharge(tjs, tj, false);
       unsigned short end = CloseEnd(tjs, tj, vpos);
       // assume that we will use the end point of the tj
       unsigned short endPt = tj.EndPt[end];
       if(npwc > 6 && tj.Pts[endPt].NTPsFit < 4) {
         if(end == 0) {
           endPt += 3;
         } else {
           endPt -= 3;
         }
         endPt = NearestPtWithChg(tjs, tj, endPt);
       } // few points fit at the end
       if(endPt < tj.EndPt[0]) endPt = tj.EndPt[0];
       if(endPt > tj.EndPt[1]) endPt = tj.EndPt[1];
       // define tjpts
       tjpts[ii].CTP = tj.CTP;
       tjpts[ii].Pos = tj.Pts[endPt].Pos;
       tjpts[ii].Dir = tj.Pts[endPt].Dir;
       tjpts[ii].Ang = tj.Pts[endPt].Ang;
       tjpts[ii].AngErr = tj.Pts[endPt].AngErr;
       // stash the point in Step
       tjpts[ii].Step = endPt;
       // and the end in AngleCode
       tjpts[ii].AngleCode = end;
       // stash the ID in Hits
       tjpts[ii].Hits.resize(1, tj.ID);
     } // tjid
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"MWV: "<<oVxID;
       myprt<<" Fit TPs";
       for(unsigned short ii = 0; ii < tjpts.size(); ++ii) {
         auto& tjpt = tjpts[ii];
         myprt<<" "<<tjlist[ii]<<"_"<<tjpt.Step<<"_"<<PrintPos(tjs, tjpt.Pos);
       }
     } // prt
     // create a subset of the first two for the first fit
     auto fitpts = tjpts;
     fitpts.resize(2);
     if(!FitVertex(tjs, aVx, fitpts, prt)) {
       if(prt) mf::LogVerbatim("TC")<<"MWV: first fit failed ";
       return false;
     }
     // Fit and add tjs to the vertex
     bool needsUpdate = false;
     for(unsigned short ii = 2; ii < tjlist.size(); ++ii) {
       fitpts.push_back(tjpts[ii]);
       if(FitVertex(tjs, aVx, fitpts, prt)) {
         needsUpdate = false;
       } else {
         // remove the last Tj point and keep going
         fitpts.pop_back();
         needsUpdate = true;
       }
     } // ii
     
     if(needsUpdate) FitVertex(tjs, aVx, fitpts, prt);
     if(prt) mf::LogVerbatim("TC")<<"MWV: done "<<vx.ID<<" and existing "<<oVx.ID;
     
     // update. Remove old associations
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       if(tj.CTP != vx.CTP) continue;
       for(unsigned short end = 0; end < 2; ++end) {
         if(tj.VtxID[end] == vx.ID) tj.VtxID[end] = 0;
         if(tj.VtxID[end] == oVxID) tj.VtxID[end] = 0;
       }
     } // tj
     // set the new associations
     for(unsigned short ii = 0; ii < fitpts.size(); ++ii) {
       auto& tjpt = fitpts[ii];
       unsigned short end = tjpt.AngleCode;
       auto& tj = tjs.allTraj[tjpt.Hits[0] - 1];
       if(tj.VtxID[end] != 0) {
         std::cout<<"MWV: coding error. tj "<<tj.ID<<" end "<<end<<" VtxID "<<tj.VtxID[end]<<" != 0\n";
         return false;
       }
       tj.VtxID[end] = oVxID;
     } // ii
     
     // Update oVx 
     oVx.Pos = aVx.Pos;
     oVx.PosErr = aVx.PosErr;
     oVx.ChiDOF = aVx.ChiDOF;
     oVx.NTraj = fitpts.size();
     // Update the score and the charge fraction
     SetVx2Score(tjs, oVx, prt);
     oVx.Stat[kVtxMerged] = true;
     oVx.Stat[kFixed] = false;
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"MWV: "<<oVxID;
       myprt<<" Done TPs";
       for(unsigned short ii = 0; ii < fitpts.size(); ++ii) {
         auto& tjpt = fitpts[ii];
         myprt<<" "<<tjpt.Hits[0]<<"_"<<tjpt.AngleCode<<"_"<<PrintPos(tjs, tjpt.Pos);
       }
     } // prt
 
     return true;
   } // MergeWithVertex

void tca::MoveTPToWire	(	TrajPoint &	tp,
		float	wire
	)

Definition at line 2351 of file Utils.cxx.

References tca::TrajPoint::Dir, and tca::TrajPoint::Pos.

Referenced by tca::TrajClusterAlg::AddHits(), Find2DVertices(), FindCloseTjs(), FindHammerVertices2(), tca::TrajClusterAlg::FindVtxTraj(), FitTraj(), tca::TrajClusterAlg::IsGhost(), and tca::TrajClusterAlg::ReversePropagate().

   {
     // Project TP to a "wire position" Pos[0] and update Pos[1]
     if(tp.Dir[0] == 0) return;
     float dw = wire - tp.Pos[0];
     if(std::abs(dw) < 0.01) return;
     tp.Pos[0] = wire;
     tp.Pos[1] += dw * tp.Dir[1] / tp.Dir[0];
   } // MoveTPToWire

unsigned short tca::NearestPtWithChg	(	TjStuff &	tjs,
		Trajectory &	tj,
		unsigned short	thePt
	)

Definition at line 2889 of file Utils.cxx.

References tca::Trajectory::EndPt, and tca::Trajectory::Pts.

Referenced by DotProd(), Find2DVertices(), MCSMom(), MCSThetaRMS(), MergeWithVertex(), and TjDeltaRMS().

   {
     // returns a point near thePt which has charge
     if(thePt > tj.EndPt[1]) return thePt;
     if(tj.Pts[thePt].Chg > 0) return thePt;
     
     short endPt0 = tj.EndPt[0];
     short endPt1 = tj.EndPt[1];
     for(short off = 1; off < 10; ++off) {
       short ipt = thePt + off;
       if(ipt <= endPt1 && tj.Pts[ipt].Chg > 0) return (unsigned short)ipt;
       ipt = thePt - off;
       if(ipt >= endPt0 && tj.Pts[ipt].Chg > 0) return (unsigned short)ipt;
     } // off
     return thePt;
   } // NearestPtWithChg

int tca::NeutrinoPrimaryTjID	(	const TjStuff &	tjs,
		const Trajectory &	tj
	)

Definition at line 363 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, evd::details::end(), kKilled, tca::Trajectory::ParentID, PrimaryID(), tca::TjStuff::vtx, and tca::TjStuff::vtx3.

Referenced by AddTjsInsideEnvelope(), and PrintAllTraj().

   {
     // Returns the ID of the grandparent of this tj that is a primary tj that is attached
     // to the neutrino vertex. 0 is returned if this condition is not met.
     if(tj.AlgMod[kKilled]) return -1;
     if(tj.ParentID <= 0) return -1;
     int primID = PrimaryID(tjs, tj);
     if(primID <= 0 || primID > (int)tjs.allTraj.size()) return -1;
 
     // We have the ID of the primary tj. Now see if it is attached to the neutrino vertex
     auto& ptj = tjs.allTraj[primID - 1];
     for(unsigned short end = 0; end < 2; ++end) {
       if(ptj.VtxID[end] == 0) continue;
       auto& vx2 = tjs.vtx[ptj.VtxID[end] - 1];
       if(vx2.Vx3ID == 0) continue;
       auto& vx3 = tjs.vtx3[vx2.Vx3ID - 1];
       if(vx3.Neutrino) return primID;
     } // end
     return -1;
   } // NeutrinoPrimaryTjID

unsigned short tca::NumDeltaRays	(	const TjStuff &	tjs,
		const Trajectory &	tj
	)

Definition at line 335 of file Utils.cxx.

References tca::TjStuff::allTraj, tca::Trajectory::ID, kDeltaRay, and kKilled.

   {
     // returns the number of delta rays that have this tj as a parent
     unsigned short cnt = 0;
     for(auto& dtj : tjs.allTraj) {
       if(dtj.AlgMod[kKilled]) continue;
       if(!dtj.AlgMod[kDeltaRay]) continue;
       if(dtj.ParentID == tj.ID) ++cnt;
     } // tj
     return cnt;
   } // NumDeltaRays

unsigned short tca::NumDeltaRays	(	const TjStuff &	tjs,
		std::vector< int > &	tjIDs
	)

Definition at line 348 of file Utils.cxx.

References tca::TjStuff::allTraj, kDeltaRay, and kKilled.

Referenced by PDGCodeVote().

   {
     // Count the number of delta-rays that have a Tj in the list of TjIDs as a parent.
     if(tjIDs.empty()) return 0;
     if(tjIDs[0] <= 0 || tjIDs[0] > (int)tjs.allTraj.size()) return 0;
     unsigned short cnt = 0;
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       if(!tj.AlgMod[kDeltaRay]) continue;
       if(std::find(tjIDs.begin(), tjIDs.end(), tj.ParentID) != tjIDs.end()) ++cnt;
     } // tj
     return cnt;
   } // NumDeltaRays

unsigned short tca::NumHitsInTP	(	const TrajPoint &	tp,
		HitStatus_t	hitRequest
	)

Definition at line 3677 of file Utils.cxx.

References tca::TrajPoint::Hits, kAllHits, kUsedHits, and tca::TrajPoint::UseHit.

Referenced by tca::TrajClusterAlg::AddHits(), tca::TrajClusterAlg::CheckHiMultUnusedHits(), DotProd(), and tca::TrajClusterAlg::MergeTPHits().

   {
     // Counts the number of hits of the specified type in tp
     if(tp.Hits.empty()) return 0;
     
     if(hitRequest == kAllHits) return tp.Hits.size();
     
     unsigned short nhits = 0;
     for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
       if(hitRequest == kUsedHits) {
         if(tp.UseHit[ii]) ++nhits;
       } else {
         // looking for unused hits
         if(!tp.UseHit[ii]) ++nhits;
       }
     } // ii
     return nhits;
   } // NumHitsInTP

unsigned short tca::NumPtsWithCharge	(	const TjStuff &	tjs,
		const Trajectory &	tj,
		bool	includeDeadWires
	)

Definition at line 1738 of file Utils.cxx.

References tca::Trajectory::EndPt, and NumPtsWithCharge().

   {
     unsigned short firstPt = tj.EndPt[0];
     unsigned short lastPt = tj.EndPt[1];
     return NumPtsWithCharge(tjs, tj, includeDeadWires, firstPt, lastPt);
   }

unsigned short tca::NumPtsWithCharge	(	const TjStuff &	tjs,
		const Trajectory &	tj,
		bool	includeDeadWires,
		unsigned short	firstPt,
		unsigned short	lastPt
	)

Definition at line 1746 of file Utils.cxx.

References DeadWireCount(), and tca::Trajectory::Pts.

Referenced by FitTraj(), MCSMom(), NumPtsWithCharge(), and TrimEndPts().

   {
     unsigned short ntp = 0;
     for(unsigned short ipt = firstPt; ipt <= lastPt; ++ipt) if(tj.Pts[ipt].Chg > 0) ++ntp;
     // Add the count of deadwires
     if(includeDeadWires) ntp += DeadWireCount(tjs, tj.Pts[firstPt], tj.Pts[lastPt]);
     return ntp;
   } // NumPtsWithCharge

unsigned short tca::NumUsedHitsInTj	(	const TjStuff &	tjs,
		const Trajectory &	tj
	)

Definition at line 3665 of file Utils.cxx.

References tca::Trajectory::AlgMod, kKilled, and tca::Trajectory::Pts.

Referenced by DotProd().

   {
     if(tj.AlgMod[kKilled]) return 0;
     if(tj.Pts.empty()) return 0;
     unsigned short nhits = 0;
     for(auto& tp : tj.Pts) {
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) if(tp.UseHit[ii]) ++nhits;
     } // tp
     return nhits;
   } // NumHitsInTj

float tca::OverlapFraction	(	TjStuff &	tjs,
		const Trajectory &	tj1,
		const Trajectory &	tj2
	)

Definition at line 584 of file Utils.cxx.

References tca::Trajectory::Pts.

Referenced by CompatibleMerge(), and tca::TrajClusterAlg::EndMerge().

   {
     // returns the fraction of wires spanned by two trajectories
     float minWire = 1E6;
     float maxWire = -1E6;
     
     float cnt1 = 0;
     for(auto& tp : tj1.Pts) {
       if(tp.Chg == 0) continue;
       if(tp.Pos[0] < 0) continue;
       if(tp.Pos[0] < minWire) minWire = tp.Pos[0];
       if(tp.Pos[0] > maxWire) maxWire = tp.Pos[0];
       ++cnt1;
     }
     if(cnt1 == 0) return 0;
     float cnt2 = 0;
     for(auto& tp : tj2.Pts) {
       if(tp.Chg == 0) continue;
       if(tp.Pos[0] < 0) continue;
       if(tp.Pos[0] < minWire) minWire = tp.Pos[0];
       if(tp.Pos[0] > maxWire) maxWire = tp.Pos[0];
       ++cnt2;
     }
     if(cnt2 == 0) return 0;
     int span = maxWire - minWire;
     if(span <= 0) return 0;
     std::vector<unsigned short> wcnt(span);
     for(auto& tp : tj1.Pts) {
       if(tp.Chg == 0) continue;
       if(tp.Pos[0] < -0.4) continue;
       int indx = std::nearbyint(tp.Pos[0] - minWire);
       if(indx < 0 || indx > span - 1) continue;
       ++wcnt[indx];
     }
     for(auto& tp : tj2.Pts) {
       if(tp.Chg == 0) continue;
       if(tp.Pos[0] < -0.4) continue;
       int indx = std::nearbyint(tp.Pos[0] - minWire);
       if(indx < 0 || indx > span - 1) continue;
       ++wcnt[indx];
     }
     float cntOverlap = 0;
     for(auto cnt : wcnt) if(cnt > 1) ++cntOverlap;
     if(cnt1 < cnt2) {
       return cntOverlap / cnt1;
     } else {
       return cntOverlap / cnt2;
     }
     
   } // OverlapFraction

float tca::ParentFOM	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		PFPStruct &	pfp,
		unsigned short	pend,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 2238 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, FarEnd(), tca::PFPStruct::ID, tca::ShowerStruct3D::ID, ParentFOM(), PosSep2(), ss, and tca::PFPStruct::TjIDs.

   {
     // Returns an average weighted parent FOM for all trajectories in the pfp being a parent of the 2D showers in ss3
     if(ss3.ID == 0) return 1000;
     float sum = 0;
     float wsum = 0;
     std::string fcnLabel = inFcnLabel + ".P3FOM";
     float dum1, dum2;
     for(auto cid : ss3.CotIDs) {
       auto& ss = tjs.cots[cid - 1];
       if(ss.ID == 0) continue;
       // look for the 3D matched tj in this CTP
       int tjid = 0;
       for(auto tid : pfp.TjIDs) {
         auto& tj = tjs.allTraj[tid - 1];
         if(tj.ID == 0) continue;
         if(tj.CTP == ss.CTP) tjid = tid;
       } // tid
       if(tjid == 0) continue;
       auto& ptj = tjs.allTraj[tjid - 1];
       auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
       // determine which end is farthest away from the shower center
       unsigned short ptjEnd = FarEnd(tjs, ptj, stj.Pts[1].Pos);
       auto& farTP = ptj.Pts[ptj.EndPt[ptjEnd]];
       float chgCtrSep2 = PosSep2(farTP.Pos, stj.Pts[1].Pos);
       if(chgCtrSep2 < PosSep2(farTP.Pos, stj.Pts[0].Pos) && chgCtrSep2 < PosSep2(farTP.Pos, stj.Pts[2].Pos)) continue;
       float fom = ParentFOM(fcnLabel, tjs, ptj, ptjEnd, ss, dum1, dum2, prt);
       // ignore failures
       if(fom > 50) continue;
       // weight by the 1/aspect ratio
       float wt = 1;
       if(ss.AspectRatio > 0) wt = 1 / ss.AspectRatio;
       sum += wt * fom;
       wsum += wt;
     } // cid
     if(wsum == 0) return 100;
     float fom = sum / wsum;
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" P"<<pfp.ID<<" fom "<<std::fixed<<std::setprecision(3)<<fom;
     return fom;
   } // ParentFOM

float tca::ParentFOM	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		Trajectory &	tj,
		unsigned short &	tjEnd,
		ShowerStruct &	ss,
		float &	tp1Sep,
		float &	vx2Score,
		bool	prt
	)

Definition at line 2280 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TrajPoint::Ang, tca::ShowerStruct::AspectRatio, ChgFracBetween(), ChgFracNearPos(), DeltaAngle(), tca::TrajPoint::DeltaRMS, tca::TrajPoint::Dir, tca::ShowerStruct::DirectionFOM, tca::Trajectory::EndPt, tca::ShowerStruct::Energy, FarEnd(), FindAlongTrans(), GetAssns(), tca::VtxStore::ID, tca::Trajectory::ID, tca::ShowerStruct::ID, InShowerProbLong(), MakeBareTrajPoint(), tca::VtxStore::Pos, tca::TrajPoint::Pos, PosSep(), PrintPos(), tca::Trajectory::Pts, tca::VtxStore::Score, ShowerParams(), tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::TjIDs, tca::TjStuff::vtx, tca::Trajectory::VtxID, and tca::TjStuff::WirePitch.

Referenced by ParentFOM(), and SetParent().

   {
     // returns a FOM for the trajectory at the end point being the parent of ss and the end which
     // was matched.
     
     vx2Score = 0;
     tp1Sep = 0;
     
     if(tjEnd > 1) return 1000;
     if(ss.Energy == 0) return 1000;
 
     if(ss.ID == 0) return 1000;
     if(ss.TjIDs.empty()) return 1000;
     if(ss.ShowerTjID == 0) return 1000;
     
     std::string fcnLabel = inFcnLabel + ".PFOM";
     
     if(ss.AspectRatio > 0.5) {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 2S"<<ss.ID<<" poor AspectRatio "<<ss.AspectRatio<<" FOM not calculated";
       return 100;
     }
 
     float fom = 0;
     float cnt = 0;
     auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
     TrajPoint& stp0 = stj.Pts[0];
     // Shower charge center TP
     TrajPoint& stp1 = stj.Pts[1];
     // get the end that is farthest away from the shower center
     tjEnd = FarEnd(tjs, tj, stp1.Pos);
     // prospective parent TP
     TrajPoint& ptp = tj.Pts[tj.EndPt[tjEnd]];
     // find the along and trans components in WSE units relative to the
     // shower center
     Point2_t alongTrans;
     FindAlongTrans(stp1.Pos, stp1.Dir, ptp.Pos, alongTrans);
     // We can return here if the shower direction is well defined and
     // alongTrans[0] is > 0
     if(ss.AspectRatio < 0.2 && ss.DirectionFOM < 0.5 && alongTrans[0] > 0) return 100;
     tp1Sep = std::abs(alongTrans[0]);
     // Find the expected shower start relative to shower max (cm)
     double shMaxAlong, shE95Along;
     ShowerParams(ss.Energy, shMaxAlong, shE95Along);
     double alongcm = tjs.WirePitch * tp1Sep;
     // InShowerProbLong expects the longitudinal distance relative to shower max so it
     // should be < 0
     float prob = InShowerProbLong(ss.Energy, -alongcm);
     if(prob < 0.05) return 100;
     // The transverse position must certainly be less than the longitudinal distance
     // to shower max.
     if(alongTrans[1] > shMaxAlong) return 100;
     // longitudinal contribution to fom with 1 Xo error error (14 cm)
     float longFOM = std::abs(alongcm + shMaxAlong) / 14;
     fom += longFOM;
     ++cnt;
     // transverse contribution
     float transFOM = -1;
     if(stp0.DeltaRMS > 0) {
       transFOM = alongTrans[1] / stp0.DeltaRMS;
       fom += transFOM;
       ++cnt;
     }
     // make a tp between the supposed parent TP and the shower center
     TrajPoint tp;
     if(!MakeBareTrajPoint(tjs, ptp, stp1, tp)) return 100;
     // we have three angles to compare. The ptp angle, the shower angle and
     // the tp angle. 
     float dang1 = DeltaAngle(ptp.Ang, stp1.Ang);
     float dang1FOM = dang1 / 0.1;
     fom += dang1FOM;
     ++cnt;
     float dang2 = DeltaAngle(ptp.Ang, tp.Ang);
     float dang2FOM = dang1 / 0.1;
     fom += dang2FOM;
     ++cnt;
     // the environment near the parent start should be clean.
     std::vector<int> tjlist(1);
     tjlist[0] = tj.ID;
     // check for a vertex at this end and include the vertex tjs if the vertex is close
     // to the expected shower max position
     float vx2Sep = 0;
     // put in a largish FOM value for Tjs that don't have a vertex
     float vxFOM = 10;
     if(tj.VtxID[tjEnd] > 0) {
       VtxStore& vx2 = tjs.vtx[tj.VtxID[tjEnd] - 1];
       vx2Sep = PosSep(vx2.Pos, stp1.Pos);
       vx2Score = vx2.Score;
       tjlist = GetAssns(tjs, "2V", vx2.ID, "T");
 //      tjlist = GetVtxTjIDs(tjs, vx2);
       vxFOM = std::abs(shMaxAlong - vx2Sep) / 20;
     } // 2D vertex exists
     fom += vxFOM;
     ++cnt;
     float chgFrac = ChgFracNearPos(tjs, ptp.Pos, tjlist);
     float chgFracFOM = (1 - chgFrac) / 0.1;
     fom += chgFracFOM;
     ++cnt;
     // Fraction of wires that have a signal between the parent start and the shower center
     float chgFracBtw = ChgFracBetween(tjs, ptp, stp1.Pos[0], false);
     float chgFrcBtwFOM = (1 - chgFrac) / 0.05;
     fom += chgFrcBtwFOM;
     ++cnt;
 
     // take the average
     fom /= cnt;
     // divide by the InShowerProbability
     fom /= prob;
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<fcnLabel;
       myprt<<" 2S"<<ss.ID;
       myprt<<" T"<<tj.ID<<"_"<<tjEnd<<" Pos "<<PrintPos(tjs, ptp);
       myprt<<std::fixed<<std::setprecision(2);
       myprt<<" along "<<std::fixed<<std::setprecision(1)<<alongTrans[0]<<" fom "<<longFOM;
       myprt<<" trans "<<alongTrans[1]<<" fom "<<transFOM;
       myprt<<" prob "<<prob;
       myprt<<" dang1 "<<dang1<<" fom "<<dang1FOM;
       myprt<<" dang2 "<<dang2<<" fom "<<dang2FOM;
       myprt<<" vx2Score "<<vx2Score<<" fom "<<vxFOM;
       myprt<<" chgFrac "<<chgFrac<<" fom "<<chgFracFOM;
       myprt<<" chgFracBtw "<<chgFracBtw<<" fom "<<chgFrcBtwFOM;
       myprt<<" FOM "<<fom;
     }
     return fom;
     
   } // ParentFOM

unsigned short tca::PDGCodeIndex	(	TjStuff &	tjs,
		int	PDGCode
	)

Definition at line 1783 of file Utils.cxx.

Referenced by tca::TruthMatcher::MatchAndSum(), tca::TruthMatcher::MatchTruth(), and tca::TruthMatcher::StudyElectrons().

   {
     unsigned short pdg = abs(PDGCode);
     if(pdg == 11) return 0; // electron
     if(pdg == 13) return 1; // muon
     if(pdg == 211) return 2; // pion
     if(pdg == 321) return 3; // kaon
     if(pdg == 2212) return 4; // proton
     
     return USHRT_MAX;
     
   } // PDGCodeIndex

int tca::PDGCodeVote	(	TjStuff &	tjs,
		std::vector< int > &	tjIDs,
		bool	prt
	)

Definition at line 267 of file Utils.cxx.

References tca::TjStuff::allTraj, evd::details::end(), kBragg, kShowerLike, NumDeltaRays(), and TrajLength().

Referenced by DefinePFPParents(), FindPFParticles(), and Match3DVtxTjs().

   {
     // Returns the most likely PDGCode for the set of Tjs provided
     // The PDG codes are:
     // 0 = your basic track-like trajectory
     // 11 = Tagged delta-ray
     // 13 = Tagged muon
     // 211 = pion-like. There exists a Bragg peak at an end with a vertex
     // 2212 = proton-like. There exists a Bragg peak at an end without a vertex
     // BUG the double brace syntax is required to work around clang bug 21629
     // (https://bugs.llvm.org/show_bug.cgi?id=21629)
     std::array<int, 5> codeList = {{0, 11, 13, 211, 2212}};
     unsigned short codeIndex = 0;
     if(tjIDs.empty()) return codeList[codeIndex];
     
     std::array<unsigned short, 5> cnts;
     cnts.fill(0);
     // Count Bragg peaks. This assumes that the Tjs are in order...
     std::array<unsigned short, 2> stopCnt {{0, 0}};
     float maxLen = 0;
     for(auto tjid : tjIDs) {
       if(tjid <= 0 || tjid > (int)tjs.allTraj.size()) continue;
       auto& tj = tjs.allTraj[tjid - 1];
       for(unsigned short ii = 0; ii < 5; ++ii) if(tj.PDGCode == codeList[ii]) ++cnts[ii];
       // count InShower Tjs with PDGCode not set (yet)
       if(tj.PDGCode != 11 && tj.AlgMod[kShowerLike]) ++cnts[1];
       for(unsigned short end = 0; end < 2; ++end) if(tj.StopFlag[end][kBragg]) ++stopCnt[end];
       float len = TrajLength(tj);
       if(len > maxLen) maxLen = len;
     } // tjid
     unsigned maxCnt = 0;
     // ignore the first PDG code in the list (the default)
     for(unsigned short ii = 1; ii < 5; ++ii) {
       if(cnts[ii] > maxCnt) {
         maxCnt = cnts[ii];
         codeIndex = ii;
       }
     } // ii
     // check for an inconsistent code
     bool confused = false;
     for(unsigned short ii = 1; ii < 5; ++ii) {
       if(ii == codeIndex) continue;
       if(cnts[ii] == 0) continue;
       confused = true;
     } // ii
     if(confused) {
       // Check for a muon called it a proton
       if(cnts[4] > 0 && stopCnt[2] > 0 && NumDeltaRays(tjs, tjIDs) == 0) {
         codeIndex = 4;
         confused = false;
       }
     } // confused
     if(confused) {
       codeIndex = 0;
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<"PDGCodeVote: mixed vote on the PDGCode: Tj_PDGCode";
         for(auto tjid : tjIDs) {
           if(tjid <= 0 || tjid > (int)tjs.allTraj.size()) continue;
           auto& tj = tjs.allTraj[tjid - 1];
           myprt<<" "<<tj.ID<<"_"<<tj.PDGCode<<"_"<<tj.StopFlag[1][kBragg];
         } // tjid
       }
     } // confused
     return codeList[codeIndex];
   } // PDGCodeVote

float tca::PFPDOCA	(	const PFPStruct &	pfp1,
		const PFPStruct &	pfp2,
		unsigned short &	close1,
		unsigned short &	close2
	)

Definition at line 1761 of file PFPUtils.cxx.

References PosSep2(), and tca::PFPStruct::Tp3s.

Referenced by DefineDontCluster(), DotProd(), and FindCots().

   {
     // returns the Distance of Closest Approach between two PFParticles. 
     close1 = USHRT_MAX;
     close2 = USHRT_MAX;
     float minSep2 = 1E8;
     for(unsigned short ipt1 = 0; ipt1 < pfp1.Tp3s.size(); ++ipt1) {
       auto& tp1 = pfp1.Tp3s[ipt1];
       for(unsigned short ipt2 = 0; ipt2 < pfp2.Tp3s.size(); ++ipt2) {
         auto& tp2 = pfp2.Tp3s[ipt2];
         float sep2 = PosSep2(tp1.Pos, tp2.Pos);
         if(sep2 > minSep2) continue;
         minSep2 = sep2;
         close1 = ipt1;
         close2 = ipt2;
       } // tp2
     } // tp1
     return sqrt(minSep2);
  } // PFPDOCA

void tca::PFPVertexCheck ( TjStuff & tjs )

Definition at line 2418 of file PFPUtils.cxx.

References tca::Vtx3Store::ID, tca::TjStuff::pfps, tca::Vtx3Store::Primary, tca::Vtx3Store::TPCID, geo::TPCID::TPCID(), tca::TjStuff::vtx3, tca::Vtx3Store::Wire, tca::Vtx3Store::X, tca::Vtx3Store::Y, and tca::Vtx3Store::Z.

Referenced by DotProd(), and tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // Ensure that all PFParticles have a start vertex. It is possible for
     // PFParticles to be attached to a 3D vertex that is later killed.
     for(auto& pfp : tjs.pfps) {
       if(pfp.ID == 0) continue;
       if(pfp.Vx3ID[0] > 0) continue;
       Vtx3Store vx3;
       vx3.TPCID = pfp.TPCID;
       // Flag it as a PFP vertex that isn't required to have matched 2D vertices
       vx3.Wire = -2;
       vx3.X = pfp.XYZ[0][0];
       vx3.Y = pfp.XYZ[0][1];
       vx3.Z = pfp.XYZ[0][2];
       vx3.ID = tjs.vtx3.size() + 1;
       vx3.Primary = false;
       tjs.vtx3.push_back(vx3);
 //      std::cout<<"PFPVertexCheck: P"<<pfp.ID<<" create 3V"<<vx3.ID<<"\n";
       pfp.Vx3ID[0] = vx3.ID;
     } // pfp
   } // PFPVertexCheck

bool tca::PFPVxTjOK	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 2283 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, GetVtxTjIDs(), tca::PFPStruct::ID, SetIntersection(), tca::PFPStruct::TjIDs, tmp, tca::TjStuff::vtx, tca::TjStuff::vtx3, and tca::PFPStruct::Vx3ID.

Referenced by AddMissedTj(), AnalyzePFP(), DefinePFP(), and DotProd().

   {
     // Checks the PFP Vx3 -> Vx2 -> Tj assignment to see if there is more
     // than one tj in a plane in the pfp.TjIDs list that is attached to the same 2D vertex. 
     // This problem is fixed by removing the shorter tj from the TjIDs list. This function
     // return true if nothing was done to TjIDs
     if(pfp.ID == 0) return true;
     if(pfp.TjIDs.empty()) return true;
     if(pfp.Vx3ID[0] == 0) return true;
     
     auto& vx3 = tjs.vtx3[pfp.Vx3ID[0] - 1];
     std::vector<int> killMe;
     for(auto vx2id : vx3.Vx2ID) {
       if(vx2id == 0) continue;
       if(vx2id == 666) continue;
       auto& vx2 = tjs.vtx[vx2id - 1];
       auto tjlist = GetVtxTjIDs(tjs, vx2);
       auto setInt = SetIntersection(pfp.TjIDs, tjlist);
 /*
       std::cout<<"PVTC: P"<<pfp.ID<<" Tjs";
       for(auto tid : pfp.TjIDs) std::cout<<" T"<<tid;
       std::cout<<" set Intersection";
       for(auto tid : setInt) std::cout<<" T"<<tid;
       std::cout<<"\n";
 */
       if(setInt.size() < 2) continue;
       // find the longest one
       int imLong = 0;
       unsigned short lenth = 0;
       for(auto tid : setInt) {
         auto& tj = tjs.allTraj[tid - 1];
         unsigned short npts = tj.EndPt[1] - tj.EndPt[0] + 1;
         if(npts < lenth) continue;
         lenth = npts;
         imLong = tj.ID;
       } // tid
       if(imLong == 0) continue;
       // add the others to the killMe list
       for(auto tid : setInt) if(tid != imLong) killMe.push_back(tid);
     } // vx2id
     if(killMe.empty()) return true;
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"PVTC: P"<<pfp.ID<<" removing short tjs attached to a vertex:";
       for(auto tid : killMe) myprt<<" T"<<tid;
     }
     // re-create the TjIDs vector
     std::vector<int> tmp;
     for(auto tid : pfp.TjIDs) {
       if(std::find(killMe.begin(), killMe.end(), tid) == killMe.end()) tmp.push_back(tid);
     } // tid
     pfp.TjIDs = tmp;
     return false;
   } // PFPVxTjOK

Vector3_t tca::PointDirection	(	const Point3_t	p1,
		const Point3_t	p2
	)

Definition at line 1614 of file PFPUtils.cxx.

References dir, and SetMag().

Referenced by ChgFracBetween(), CreateFakePFP(), DefineDontCluster(), DotProd(), FindAlongTrans(), FindParent(), FollowTp3s(), tca::TruthMatcher::StudyShowerParents(), and UpdateShower().

   {
     // Finds the direction vector between the two points from p1 to p2
     Vector3_t dir;
     for(unsigned short xyz = 0; xyz < 3; ++xyz) dir[xyz] = p2[xyz] - p1[xyz];
     if(dir[0] == 0 && dir[1] == 0 && dir[2] == 0) return dir;
     if(!SetMag(dir, 1)) { dir[0] = 0; dir[1] = 0; dir[3] = 0; }
     return dir;
   } // PointDirection

Vector2_t tca::PointDirection	(	const Point2_t	p1,
		const Point2_t	p2
	)

Definition at line 3563 of file Utils.cxx.

References dir, and norm.

Referenced by MakeBareTrajPoint().

   {
     // Finds the direction vector between the two points from p1 to p2
     Vector2_t dir;
     for(unsigned short xyz = 0; xyz < 2; ++xyz) dir[xyz] = p2[xyz] - p1[xyz];
     if(dir[0] == 0 && dir[1] == 0) return dir;
     double norm = sqrt(dir[0] * dir[0] + dir[1] * dir[1]);
     dir[0] /= norm;
     dir[1] /= norm;
     return dir;
   } // PointDirection

bool tca::PointDirIntersect	(	Point3_t	p1,
		Vector3_t	p1Dir,
		Point3_t	p2,
		Vector3_t	p2Dir,
		Point3_t &	intersect,
		float &	doca
	)

Definition at line 2769 of file PFPUtils.cxx.

References LineLineIntersect().

Referenced by DotProd(), and FindNeutralVertices().

   {
     // Point - vector version
     Point3_t p1End, p2End;
     for(unsigned short xyz = 0; xyz < 3; ++xyz) {
       p1End[xyz] = p1[xyz] + 10 * p1Dir[xyz];
       p2End[xyz] = p2[xyz] + 10 * p2Dir[xyz];
     }
     return LineLineIntersect(p1, p1End, p2, p2End, intersect, doca);
   } // PointDirIntersect

bool tca::PointInsideEnvelope	(	const Point2_t &	Point,
		const std::vector< Point2_t > &	Envelope
	)

Definition at line 2705 of file Utils.cxx.

References DeltaAngle().

Referenced by AddLooseHits(), AddTjsInsideEnvelope(), FindNearbyTjs(), KillVerticesInShower(), and MergeOverlap().

   {
     // returns true if the Point is within the Envelope polygon. Entries in Envelope are the
     // Pos[0], Pos[1] locations of the polygon vertices. This is based on the algorithm that the
     // sum of the angles of a vector between a point and the vertices will be 2 * pi for an interior
     // point and 0 for an exterior point
     
     Point2_t p1, p2;
     unsigned short nvx = Envelope.size();
     double angleSum = 0;
     for(unsigned short ii = 0; ii < Envelope.size(); ++ii) {
       p1[0] = Envelope[ii][0] - Point[0];
       p1[1] = Envelope[ii][1] - Point[1];
       p2[0] = Envelope[(ii+1)%nvx][0] - Point[0];
       p2[1] = Envelope[(ii+1)%nvx][1] - Point[1];
       angleSum += DeltaAngle(p1, p2);
     }
     if(abs(angleSum) < M_PI) return false;
     return true;
       
   } // InsideEnvelope

float tca::PointTrajDOCA	(	TjStuff const &	tjs,
		unsigned int	iht,
		TrajPoint const &	tp
	)

Definition at line 2139 of file Utils.cxx.

References tca::TjStuff::fHits, PointTrajDOCA2(), and tca::TjStuff::UnitsPerTick.

   {
     float wire = tjs.fHits[iht].ArtPtr->WireID().Wire;
     float time = tjs.fHits[iht].PeakTime * tjs.UnitsPerTick;
     return sqrt(PointTrajDOCA2(tjs, wire, time, tp));
   } // PointTrajDOCA

float tca::PointTrajDOCA	(	TjStuff const &	tjs,
		float	wire,
		float	time,
		TrajPoint const &	tp
	)

Definition at line 2147 of file Utils.cxx.

References PointTrajDOCA2().

Referenced by CompatibleMerge(), FindCloseHits(), MaxHitDelta(), and TagDeltaRays().

   {
     return sqrt(PointTrajDOCA2(tjs, wire, time, tp));
   } // PointTrajDOCA

float tca::PointTrajDOCA2	(	TjStuff const &	tjs,
		float	wire,
		float	time,
		TrajPoint const &	tp
	)

Definition at line 2153 of file Utils.cxx.

References tca::TrajPoint::Dir, and tca::TrajPoint::Pos.

Referenced by PointTrajDOCA(), and TjDeltaRMS().

   {
     // returns the distance of closest approach squared between a (wire, time(WSE)) point
     // and a trajectory point
     
     float t = (wire  - tp.Pos[0]) * tp.Dir[0] + (time - tp.Pos[1]) * tp.Dir[1];
     float dw = tp.Pos[0] + t * tp.Dir[0] - wire;
     float dt = tp.Pos[1] + t * tp.Dir[1] - time;
     return (dw * dw + dt * dt);
     
   } // PointTrajDOCA2

float tca::PointTrajSep2	(	float	wire,
		float	time,
		TrajPoint const &	tp
	)

Definition at line 2131 of file Utils.cxx.

References tca::TrajPoint::Pos.

   {
     float dw = wire - tp.Pos[0];
     float dt = time - tp.Pos[1];
     return dw * dw + dt * dt;
   }

void tca::PosInPlane	(	const TjStuff &	tjs,
		const Vtx3Store &	vx3,
		unsigned short	plane,
		Point2_t &	pos
	)

Definition at line 3083 of file TCVertex.cxx.

References detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, tca::TjStuff::detprop, tca::TjStuff::geom, geo::TPCID::TPC, tca::Vtx3Store::TPCID, tca::TjStuff::UnitsPerTick, geo::GeometryCore::WireCoordinate(), tca::Vtx3Store::X, tca::Vtx3Store::Y, and tca::Vtx3Store::Z.

Referenced by AttachPFPToVertex(), and PrintAllTraj().

   {
     // returns the 2D position of the vertex in the plane
     pos[0] = tjs.geom->WireCoordinate(vx3.Y, vx3.Z, plane, vx3.TPCID.TPC, vx3.TPCID.Cryostat);
     pos[1] = tjs.detprop->ConvertXToTicks(vx3.X, plane, vx3.TPCID.TPC, vx3.TPCID.Cryostat) * tjs.UnitsPerTick;
     
   } // PosInPlane

double tca::PosSep	(	const Point3_t &	pos1,
		const Point3_t &	pos2
	)

Definition at line 1625 of file PFPUtils.cxx.

References PosSep2().

Referenced by ChgFracBetween(), ChkVxTjs(), DefineDontCluster(), DefineEnvelope(), DefinePFP(), DotProd(), tca::TrajClusterAlg::EndMerge(), Find2DVertices(), FindAlongTrans(), FindCots(), FindHammerVertices2(), FindMissedTjsInTp3s(), FindNeutralVertices(), FindParent(), FindShowers3D(), FindShowerStart(), FitTp3(), FollowTp3s(), InShowerProb(), LineLineIntersect(), tca::MCParticleListUtils::MakeCheatShower(), MakeJunkVertices(), MakeTp3(), Match2DShowers(), tca::TruthMatcher::MatchTruth(), MergeOverlap(), MergeShowerChain(), MergeSubShowers(), MergeSubShowersTj(), ParentFOM(), PrintTp3s(), Reconcile3D(), tca::TruthMatcher::StudyElectrons(), tca::TruthMatcher::StudyShowerParents(), TagShowerLike(), and UpdateShower().

   {
     return sqrt(PosSep2(pos1, pos2));
   } // PosSep

float tca::PosSep	(	const Point2_t &	pos1,
		const Point2_t &	pos2
	)

Definition at line 2220 of file Utils.cxx.

References PosSep2().

Referenced by CompatibleMerge(), PrintPFP(), TagDeltaRays(), and TjDirFOM().

   {
     return sqrt(PosSep2(pos1, pos2));
   } // PosSep

double tca::PosSep2	(	const Point3_t &	pos1,
		const Point3_t &	pos2
	)

Definition at line 1631 of file PFPUtils.cxx.

Referenced by AttachTrajToVertex(), DotProd(), tca::TrajClusterAlg::EndMerge(), FarEnd(), Find2DVertices(), FindKinks(), FindParent(), FitTp3(), FollowTp3s(), KinkAngle(), LengthInCTP(), tca::TrajClusterAlg::MakeAllTrajClusters(), MergeOverlap(), ParentFOM(), PFPDOCA(), PosSep(), tca::MCParticleListUtils::PrimaryElectronPFPID(), tca::TrajClusterAlg::StepCrawl(), tca::TruthMatcher::StudyShowerParents(), TrajPointVertexPull(), UpdateShower(), and tca::TrajClusterAlg::UseUnusedHits().

   {
     // returns the separation distance^2 between two positions in 3D
     double d0 = pos1[0] - pos2[0];
     double d1 = pos1[1] - pos2[1];
     double d2 = pos1[2] - pos2[2];
     return d0*d0 + d1*d1 + d2*d2;
   } // PosSep2

float tca::PosSep2	(	const Point2_t &	pos1,
		const Point2_t &	pos2
	)

Definition at line 2226 of file Utils.cxx.

Referenced by CloseEnd(), FarEnd(), MaxTjLen(), MergeAndStore(), and PosSep().

   {
     // returns the separation distance^2 between two positions
     float d0 = pos1[0] - pos2[0];
     float d1 = pos1[1] - pos2[1];
     return d0*d0+d1*d1;
   } // PosSep2

int tca::PrimaryID	(	const TjStuff &	tjs,
		const Trajectory &	tj
	)

Definition at line 385 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::Trajectory::ID, kKilled, and tca::Trajectory::ParentID.

   {
     // Returns the ID of the grandparent trajectory of this trajectory that is a primary
     // trajectory (i.e. whose ParentID = 0). 
     if(tj.AlgMod[kKilled]) return -1;
     if(tj.ParentID < 0 || tj.ParentID > (int)tjs.allTraj.size()) return -1;
     if(tj.ParentID == 0) return tj.ID;
     int parid = tj.ParentID;
     for(unsigned short nit = 0; nit < 10; ++nit) {
       if(parid < 1 || parid > (int)tjs.allTraj.size()) break;
       auto& tj = tjs.allTraj[parid - 1];
       if(tj.ParentID < 0 || tj.ParentID > (int)tjs.allTraj.size()) return -1;
       if(tj.ParentID == 0) return tj.ID;
       parid = tj.ParentID;
     } // nit
     return -1;
   } // PrimaryID

int tca::PrimaryID	(	const TjStuff &	tjs,
		const PFPStruct &	pfp
	)

Definition at line 404 of file Utils.cxx.

References tca::PFPStruct::ID, tca::PFPStruct::ParentID, and tca::TjStuff::pfps.

Referenced by NeutrinoPrimaryTjID(), PrintAllTraj(), and PrintPFP().

   {
     // returns the ID of the most upstream PFParticle (that is not a neutrino)
     
     if(int(pfp.ParentID) == pfp.ID || pfp.ParentID <= 0) return pfp.ID;
     int parid = pfp.ParentID;
     int dtrid = pfp.ID;
     unsigned short nit = 0;
     while(true) {
       auto& parent = tjs.pfps[parid - 1];
       // found a neutrino
       if(parent.PDGCode == 14 || parent.PDGCode == 12) return dtrid;
       // found a primary PFParticle?
       if(parent.ParentID == 0) return parent.ID;
       if(int(parent.ParentID) == parent.ID) return parent.ID;
       dtrid = parent.ID;
       parid = parent.ParentID;
       if(parid < 0) return 0;
       ++nit;
       if(nit == 10) return 0;
     }
   } // PrimaryID

void tca::Print2DShowers	(	std::string	someText,
		const TjStuff &	tjs,
		CTP_t	inCTP,
		bool	printKilledShowers
	)

Definition at line 4713 of file TCShower.cxx.

References tca::TjStuff::cots, tca::TjStuff::dontCluster, DontCluster(), nlines, PrintShower(), tca::TjStuff::ShowerTag, ss, util::flags::to_string(), and tca::TjStuff::UnitsPerTick.

Referenced by FindShowers3D(), Reconcile3D(), and tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // Prints a one-line summary of 2D showers
     if(tjs.cots.empty()) return;
 
     mf::LogVerbatim myprt("TC");
     
     // see how many lines were are going to print
     bool printAllCTP = (inCTP == USHRT_MAX);
     if(!printAllCTP) {
       unsigned short nlines = 0;
       for(const auto& ss : tjs.cots) {
         if(!printAllCTP && ss.CTP != inCTP) continue;
         if(!printKilledShowers && ss.ID == 0) continue;
         ++nlines;
       } // ss
       if(nlines == 0) {
         myprt<<someText<<" Print2DShowers: Nothing to print";
         return;
       }
     } // !printAllCTP
     
     bool printHeader = true;
     bool printExtras = false;
     for(unsigned short ict = 0; ict < tjs.cots.size(); ++ict) {
       const auto& ss = tjs.cots[ict];
       if(!printAllCTP && ss.CTP != inCTP) continue;
       if(!printKilledShowers && ss.ID == 0) continue;
       PrintShower(someText, tjs, ss, printHeader, printExtras);
       printHeader = false;
     } // ss
     if(tjs.ShowerTag[12] > 9) {
       // List of Tjs
       for(unsigned short ict = 0; ict < tjs.cots.size(); ++ict) {
         const auto& ss = tjs.cots[ict];
         if(!printAllCTP && ss.CTP != inCTP) continue;
         if(!printKilledShowers && ss.ID == 0) continue;
         myprt<<someText<<std::fixed;
         std::string sid = "2S" + std::to_string(ss.ID);
         myprt<<std::setw(5)<<sid;
         myprt<<" Tjs";
         for(auto id : ss.TjIDs) myprt<<" T"<<id;
         myprt<<"\n";
       } // ict
       
     }
     // Print the envelopes
     for(unsigned short ict = 0; ict < tjs.cots.size(); ++ict) {
       const auto& ss = tjs.cots[ict];
       if(!printAllCTP && ss.CTP != inCTP) continue;
       if(!printKilledShowers && ss.ID == 0) continue;
       myprt<<someText<<std::fixed;
       std::string sid = "2S" + std::to_string(ss.ID);
       myprt<<std::setw(5)<<sid;
       myprt<<" Envelope";
       for(auto& vtx : ss.Envelope) myprt<<" "<<(int)vtx[0]<<":"<<(int)(vtx[1]/tjs.UnitsPerTick);
       myprt<<"\n";
     } // ict
     // List of nearby Tjs
     for(unsigned short ict = 0; ict < tjs.cots.size(); ++ict) {
       const auto& ss = tjs.cots[ict];
       if(!printAllCTP && ss.CTP != inCTP) continue;
       if(!printKilledShowers && ss.ID == 0) continue;
       myprt<<someText<<std::fixed;
       std::string sid = "2S" + std::to_string(ss.ID);
       myprt<<std::setw(5)<<sid;
       myprt<<" Nearby";
       for(auto id : ss.NearTjIDs) myprt<<" T"<<id;
       myprt<<"\n";
     } // ict
     // don't cluster list
     myprt<<"DontCluster";
     for(auto& dc : tjs.dontCluster) {
       if(dc.TjIDs[0] > 0) myprt<<" T"<<dc.TjIDs[0]<<"-T"<<dc.TjIDs[1];
     } // dc
     myprt<<"\nDontCluster";
     for(unsigned short ict = 0; ict < tjs.cots.size(); ++ict) {
       const auto& iss = tjs.cots[ict];
       if(iss.ID == 0) continue;
       for(unsigned short jct = ict + 1; jct < tjs.cots.size(); ++jct) {
         const auto& jss = tjs.cots[jct];
         if(jss.ID == 0) continue;
         if(DontCluster(tjs, iss.TjIDs, jss.TjIDs)) myprt<<" 2S"<<iss.ID<<"-2S"<<jss.ID;
       } // jct
     } // ict
   } // Print2DShowers

void tca::PrintAllTraj	(	std::string	someText,
		const TjStuff &	tjs,
		const DebugStuff &	debug,
		unsigned short	itj,
		unsigned short	ipt,
		bool	prtVtx
	)

Definition at line 4232 of file Utils.cxx.

References AlgBitNames, tca::TjStuff::allTraj, geo::CryostatID::Cryostat, DecodeCTP(), evd::details::end(), GetAssns(), tca::Vtx3Store::ID, kAtKink, kAtTj, kAtVtx, kBragg, kEnvNearTj, kKilled, kVtxTruMatch, tca::TjStuff::MCPartList, tca::Vtx3Store::Neutrino, NeutrinoPrimaryTjID(), tca::TjStuff::NumPlanes, tca::TjStuff::pfps, tca::DebugStuff::Plane, geo::PlaneID::Plane, PosInPlane(), tca::Vtx3Store::Primary, PrimaryID(), PrintHeader(), PrintPos(), PrintTrajPoint(), art::right(), tca::Vtx3Store::Score, tca::TjStuff::StepDir, tmp, util::flags::to_string(), geo::TPCID::TPC, tca::Vtx3Store::TPCID, tca::TjStuff::UnitsPerTick, tca::TjStuff::vtx, tca::TjStuff::vtx3, VtxBitNames, tca::Vtx3Store::Vx2ID, tca::Vtx3Store::Wire, tca::Vtx3Store::X, tca::Vtx3Store::XErr, tca::Vtx3Store::Y, tca::Vtx3Store::YErr, tca::Vtx3Store::Z, and tca::Vtx3Store::ZErr.

Referenced by DotProd(), Find2DVertices(), Find3DVertices(), FindShowers3D(), and tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     
     mf::LogVerbatim myprt("TC");
     
     if(prtVtx) {
       if(!tjs.vtx3.empty()) {
         // print out 3D vertices
         myprt<<someText<<"****** 3D vertices ******************************************__2DVtx_ID__*******\n";
         myprt<<someText<<"  Vtx  Cstat  TPC     X       Y       Z    XEr  YEr  ZEr pln0 pln1 pln2 Wire score Prim? Nu? nTru";
         myprt<<" ___________2D_Pos____________ _____Tjs________\n";
         for(unsigned short iv = 0; iv < tjs.vtx3.size(); ++iv) {
           if(tjs.vtx3[iv].ID == 0) continue;
           const Vtx3Store& vx3 = tjs.vtx3[iv];
           myprt<<someText;
           std::string vid = "3V" + std::to_string(vx3.ID);
           myprt<<std::right<<std::setw(5)<<std::fixed<<vid;
           myprt<<std::setprecision(1);
           myprt<<std::right<<std::setw(7)<<vx3.TPCID.Cryostat;
           myprt<<std::right<<std::setw(5)<<vx3.TPCID.TPC;
           myprt<<std::right<<std::setw(8)<<vx3.X;
           myprt<<std::right<<std::setw(8)<<vx3.Y;
           myprt<<std::right<<std::setw(8)<<vx3.Z;
           myprt<<std::right<<std::setw(5)<<vx3.XErr;
           myprt<<std::right<<std::setw(5)<<vx3.YErr;
           myprt<<std::right<<std::setw(5)<<vx3.ZErr;
           myprt<<std::right<<std::setw(5)<<vx3.Vx2ID[0];
           myprt<<std::right<<std::setw(5)<<vx3.Vx2ID[1];
           myprt<<std::right<<std::setw(5)<<vx3.Vx2ID[2];
           myprt<<std::right<<std::setw(5)<<vx3.Wire;
           unsigned short nTruMatch = 0;
           for(unsigned short ipl = 0; ipl < tjs.NumPlanes; ++ipl) {
             if(vx3.Vx2ID[ipl] == 0) continue;
             unsigned short iv2 = vx3.Vx2ID[ipl] - 1;
             if(tjs.vtx[iv2].Stat[kVtxTruMatch]) ++nTruMatch;
           } // ipl
           myprt<<std::right<<std::setw(6)<<std::setprecision(1)<<vx3.Score;
           myprt<<std::setw(6)<<vx3.Primary;
           myprt<<std::setw(4)<<vx3.Neutrino;
           myprt<<std::right<<std::setw(5)<<nTruMatch;
           Point2_t pos;
           for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
             PosInPlane(tjs, vx3, plane, pos);
             myprt<<" "<<PrintPos(tjs, pos);
           } // plane
           if(vx3.Wire == -2) {
             // find the Tjs that are attached to it
             for(auto& pfp : tjs.pfps) {
               if(pfp.Vx3ID[0] == tjs.vtx3[iv].ID) {
                 for(auto& tjID : pfp.TjIDs) myprt<<" T"<<tjID;
               }
               if(pfp.Vx3ID[1] == tjs.vtx3[iv].ID) {
                 for(auto& tjID : pfp.TjIDs) myprt<<" T"<<tjID;
               }
             } // ipfp
           } else {
             auto vxtjs = GetAssns(tjs, "3V", vx3.ID, "T");
             for(auto tjid : vxtjs) myprt<<" T"<<tjid;
           }
           myprt<<"\n";
         }
       } // tjs.vtx3.size
       if(!tjs.vtx.empty()) {
         bool foundOne = false;
         for(unsigned short iv = 0; iv < tjs.vtx.size(); ++iv) {
           auto& vx2 = tjs.vtx[iv];
           if(debug.Plane < 3 && debug.Plane != (int)DecodeCTP(vx2.CTP).Plane) continue;
           if(vx2.NTraj == 0) continue;
           foundOne = true;
         } // iv
         if(foundOne) {
           // print out 2D vertices
           myprt<<someText<<"************ 2D vertices ************\n";
           myprt<<someText<<"  Vtx   CTP    wire  err   tick   err  ChiDOF  NTj Pass  Topo ChgFrac Score  v3D TjIDs\n";
           for(auto& vx2 : tjs.vtx) {
             if(vx2.ID == 0) continue;
             if(debug.Plane < 3 && debug.Plane != (int)DecodeCTP(vx2.CTP).Plane) continue;
             myprt<<someText;
             std::string vid = "2V" + std::to_string(vx2.ID);
             myprt<<std::right<<std::setw(5)<<std::fixed<<vid;
             myprt<<std::right<<std::setw(6)<<vx2.CTP;
             myprt<<std::right<<std::setw(8)<<std::setprecision(0)<<std::nearbyint(vx2.Pos[0]);
             myprt<<std::right<<std::setw(5)<<std::setprecision(1)<<vx2.PosErr[0];
             myprt<<std::right<<std::setw(8)<<std::setprecision(0)<<std::nearbyint(vx2.Pos[1]/tjs.UnitsPerTick);
             myprt<<std::right<<std::setw(5)<<std::setprecision(1)<<vx2.PosErr[1]/tjs.UnitsPerTick;
             myprt<<std::right<<std::setw(7)<<vx2.ChiDOF;
             myprt<<std::right<<std::setw(5)<<vx2.NTraj;
             myprt<<std::right<<std::setw(5)<<vx2.Pass;
             myprt<<std::right<<std::setw(6)<<vx2.Topo;
             myprt<<std::right<<std::setw(9)<<std::setprecision(2)<<vx2.TjChgFrac;
             myprt<<std::right<<std::setw(6)<<std::setprecision(1)<<vx2.Score;
             myprt<<std::right<<std::setw(5)<<vx2.Vx3ID;
             myprt<<"    ";
             // display the traj IDs
             for(unsigned short ii = 0; ii < tjs.allTraj.size(); ++ii) {
               auto const& aTj = tjs.allTraj[ii];
               if(debug.Plane < 3 && debug.Plane != (int)DecodeCTP(aTj.CTP).Plane) continue;
               if(aTj.AlgMod[kKilled]) continue;
               for(unsigned short end = 0; end < 2; ++end) {
                 if(aTj.VtxID[end] != (short)vx2.ID) continue;
                 std::string tid = " T" + std::to_string(aTj.ID) + "_" + std::to_string(end);
                 myprt<<std::right<<std::setw(6)<<tid;
               } // end
             } // ii
             // Special flags. Ignore the first flag bit (0 = kVtxTrjTried) which is done for every vertex
             for(unsigned short ib = 1; ib < VtxBitNames.size(); ++ib) if(vx2.Stat[ib]) myprt<<" "<<VtxBitNames[ib];
             myprt<<"\n";
           } // iv
         }
       } // tjs.vtx.size
     }
      
     if(tjs.allTraj.empty()) {
       mf::LogVerbatim("TC")<<someText<<" No allTraj trajectories to print";
       return;
     }
     
     // Print all trajectories in tjs.allTraj if itj == USHRT_MAX
     // Print a single traj (itj) and a single TP (ipt) or all TPs (USHRT_MAX)
     if(itj == USHRT_MAX) {
       // Print summary trajectory information
       std::vector<unsigned int> tmp;
 //      myprt<<someText<<" TRJ  ID   CTP Pass  Pts     W:T      Ang CS AveQ dEdx     W:T      Ang CS AveQ dEdx Chg(k) chgRMS  Mom SDr __Vtx__  PDG  Par Pri NuPar TRuPDG  E*P TruKE  WorkID \n";
       myprt<<someText<<"    ID   CTP Pass  Pts     W:T      Ang CS AveQ fnTj     W:T      Ang CS AveQ fnTj Chg(k) chgRMS  Mom SDr __Vtx__  PDG DirFOM  Par Pri NuPar TRuPDG  E*P TruKE  WorkID \n";
       for(unsigned short ii = 0; ii < tjs.allTraj.size(); ++ii) {
         auto& aTj = tjs.allTraj[ii];
         if(debug.Plane >=0 && debug.Plane < 3 && debug.Plane != (int)DecodeCTP(aTj.CTP).Plane) continue;
         myprt<<someText<<" ";
         std::string tid;
         if(aTj.AlgMod[kKilled]) { tid = "k" + std::to_string(aTj.ID); } else { tid = "T" + std::to_string(aTj.ID); }
         myprt<<std::fixed<<std::setw(5)<<tid;
         myprt<<std::setw(6)<<aTj.CTP;
         myprt<<std::setw(5)<<aTj.Pass;
 //        myprt<<std::setw(5)<<aTj.Pts.size();
         myprt<<std::setw(5)<<aTj.EndPt[1] - aTj.EndPt[0] + 1;
         unsigned short endPt0 = aTj.EndPt[0];
         auto& tp0 = aTj.Pts[endPt0];
         int itick = tp0.Pos[1]/tjs.UnitsPerTick;
         if(itick < 0) itick = 0;
         myprt<<std::setw(6)<<(int)(tp0.Pos[0]+0.5)<<":"<<itick; // W:T
         if(itick < 10) { myprt<<" "; }
         if(itick < 100) { myprt<<" "; }
         if(itick < 1000) { myprt<<" "; }
         myprt<<std::setw(6)<<std::setprecision(2)<<tp0.Ang;
         myprt<<std::setw(2)<<tp0.AngleCode;
         if(aTj.StopFlag[0][kBragg]) {
           myprt<<"B";
         } else if(aTj.StopFlag[0][kAtVtx]) {
           myprt<<"V";
         } else if(aTj.StopFlag[0][kAtKink]) {
           myprt<<"K";
         } else if(aTj.StopFlag[0][kAtTj]) {
           myprt<<"T";
         } else {
           myprt<<" ";
         }
         myprt<<std::setw(5)<<(int)tp0.AveChg;
         // Print the fraction of points in the first half that are in a shower
         float frac = 0;
         float cnt = 0;
         unsigned short midPt = 0.5 * (aTj.EndPt[0] + aTj.EndPt[1]);
         for(unsigned short ipt = aTj.EndPt[0]; ipt < midPt; ++ipt) {
           auto& tp = aTj.Pts[ipt];
 //          if(tp.Environment[kEnvNearShower]) ++frac;
           if(tp.Environment[kEnvNearTj]) ++frac;
           ++cnt;
         } // ipt
         if(cnt > 0) frac /= cnt;
         myprt<<std::setw(5)<<std::setprecision(1)<<frac;
 /* print NearInShower fraction instead
         unsigned short prec = 1;
         if(aTj.dEdx[0] > 99) prec = 0;
         myprt<<std::setw(5)<<std::setprecision(prec)<<aTj.dEdx[0];
 */
         unsigned short endPt1 = aTj.EndPt[1];
         auto& tp1 = aTj.Pts[endPt1];
         itick = tp1.Pos[1]/tjs.UnitsPerTick;
         myprt<<std::setw(6)<<(int)(tp1.Pos[0]+0.5)<<":"<<itick; // W:T
         if(itick < 10) { myprt<<" "; }
         if(itick < 100) { myprt<<" "; }
         if(itick < 1000) { myprt<<" "; }
         myprt<<std::setw(6)<<std::setprecision(2)<<tp1.Ang;
         myprt<<std::setw(2)<<tp1.AngleCode;
         if(aTj.StopFlag[1][kBragg]) {
           myprt<<"B";
         } else if(aTj.StopFlag[1][kAtVtx]) {
           myprt<<"V";
         } else {
           myprt<<" ";
         }
         myprt<<std::setw(5)<<(int)tp1.AveChg;
         // Print the fraction of points in the second half that are NearInShower
         frac = 0;
         cnt = 0;
         for(unsigned short ipt = midPt; ipt <= aTj.EndPt[1]; ++ipt) {
           auto& tp = aTj.Pts[ipt];
 //          if(tp.Environment[kEnvNearShower]) ++frac;
           if(tp.Environment[kEnvNearTj]) ++frac;
           ++cnt;
         } // ipt
         if(cnt > 0) frac /= cnt;
         myprt<<std::setw(5)<<std::setprecision(1)<<frac;
 /*
         prec = 1;
         if(aTj.dEdx[1] > 99) prec = 0;
         myprt<<std::setw(5)<<std::setprecision(prec)<<aTj.dEdx[1];
 */
         myprt<<std::setw(7)<<std::setprecision(1)<<aTj.TotChg/1000;
         myprt<<std::setw(7)<<std::setprecision(2)<<aTj.ChgRMS;
         myprt<<std::setw(5)<<aTj.MCSMom;
         myprt<<std::setw(4)<<aTj.StepDir;
         myprt<<std::setw(4)<<aTj.VtxID[0];
         myprt<<std::setw(4)<<aTj.VtxID[1];
         myprt<<std::setw(5)<<aTj.PDGCode;
         myprt<<std::setw(7)<<std::setprecision(1)<<aTj.DirFOM;
         myprt<<std::setw(5)<<aTj.ParentID;
         myprt<<std::setw(5)<<PrimaryID(tjs, aTj);
         myprt<<std::setw(6)<<NeutrinoPrimaryTjID(tjs, aTj);
         int truKE = 0;
         int pdg = 0;
         if(aTj.MCPartListIndex < tjs.MCPartList.size()) {
           auto& mcp = tjs.MCPartList[aTj.MCPartListIndex];
           truKE = 1000 * (mcp->E() - mcp->Mass());
           pdg = mcp->PdgCode();
         }
         myprt<<std::setw(6)<<pdg;
         myprt<<std::setw(6)<<std::setprecision(2)<<aTj.EffPur;
         myprt<<std::setw(5)<<truKE;
         myprt<<std::setw(7)<<aTj.WorkID;
         for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(aTj.AlgMod[ib]) myprt<<" "<<AlgBitNames[ib];
         myprt<<"\n";
       } // ii
       return;
     } // itj > tjs.allTraj.size()-1
     
     if(itj > tjs.allTraj.size()-1) return;
     
     auto const& aTj = tjs.allTraj[itj];
     
     mf::LogVerbatim("TC")<<"Print tjs.allTraj["<<itj<<"]: ClusterIndex "<<aTj.ClusterIndex<<" Vtx[0] "<<aTj.VtxID[0]<<" Vtx[1] "<<aTj.VtxID[1];
     myprt<<"AlgBits";
     for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(aTj.AlgMod[ib]) myprt<<" "<<AlgBitNames[ib];
     myprt<<"\n";
     
     PrintHeader(someText);
     if(ipt == USHRT_MAX) {
       // print all points
       for(unsigned short ii = 0; ii < aTj.Pts.size(); ++ii) PrintTrajPoint(someText, tjs, ii, aTj.StepDir, aTj.Pass, aTj.Pts[ii]);
     } else {
       // print just one
       PrintTrajPoint(someText, tjs, ipt, aTj.StepDir, aTj.Pass, aTj.Pts[ipt]);
     }
   } // PrintAllTraj

void tca::PrintClusters ( )

Referenced by cluster::ClusterCrawlerAlg::ClusterLoop(), DotProd(), cluster::ClusterCrawlerAlg::FindStarVertices(), cluster::ClusterCrawlerAlg::FindVertices(), trkf::CCTrackMaker::MakeClusterChains(), trkf::CCTrackMaker::produce(), and cluster::ClusterCrawlerAlg::RunCrawler().

void tca::PrintHeader ( std::string someText )

Definition at line 4568 of file Utils.cxx.

Referenced by DotProd(), tca::TrajClusterAlg::FindVtxTraj(), FitVertex(), PrintAllTraj(), lar_content::LArFormattingHelper::PrintRule(), and PrintTrajectory().

   {
     mf::LogVerbatim("TC")<<someText<<" TRP     CTP  Ind  Stp      W:Tick    Delta  RMS    Ang C   Err  Dir0  Dir1      Q    AveQ  Pull FitChi  NTPF  Hits ";
   } // PrintHeader

std::string tca::PrintHit ( const TCHit & hit )

Definition at line 4732 of file Utils.cxx.

References tca::TCHit::ArtPtr, tca::TCHit::InTraj, tca::TCHit::PeakTime, geo::PlaneID::Plane, util::flags::to_string(), geo::WireID::Wire, and recob::Hit::WireID().

   {
     return std::to_string(hit.ArtPtr->WireID().Plane) + ":" + std::to_string(hit.ArtPtr->WireID().Wire) + ":" + std::to_string((int)hit.PeakTime) + "_" + std::to_string(hit.InTraj);
   } // PrintHit

std::string tca::PrintHitShort ( const TCHit & hit )

Definition at line 4726 of file Utils.cxx.

References tca::TCHit::ArtPtr, tca::TCHit::PeakTime, geo::PlaneID::Plane, util::flags::to_string(), geo::WireID::Wire, and recob::Hit::WireID().

Referenced by DotProd(), tca::TruthMatcher::MatchTruth(), and WatchHit().

   {
     return std::to_string(hit.ArtPtr->WireID().Plane) + ":" + std::to_string(hit.ArtPtr->WireID().Wire) + ":" + std::to_string((int)hit.PeakTime);
   } // PrintHit

void tca::PrintPFP	(	std::string	someText,
		const TjStuff &	tjs,
		const PFPStruct &	pfp,
		bool	printHeader
	)

Definition at line 4619 of file Utils.cxx.

References tca::PFPStruct::dEdx, tca::PFPStruct::Dir, tca::PFPStruct::DtrIDs, tca::PFPStruct::EffPur, tca::PFPStruct::ID, IsShowerLike(), kOutFV, SortEntry::length, tca::TjStuff::MCPartList, tca::PFPStruct::MCPartListIndex, MCSMom(), tca::PFPStruct::ParentID, tca::PFPStruct::PDGCode, PosSep(), PrimaryID(), art::right(), tca::PFPStruct::StopFlag, tca::PFPStruct::TjIDs, util::flags::to_string(), tca::PFPStruct::Tp3s, tca::PFPStruct::Vx3ID, and tca::PFPStruct::XYZ.

Referenced by DotProd(), Match3DVtxTjs(), MergePFPTjs(), and PrintPFPs().

   {
 //    if(pfp.ID == 0) return;
     mf::LogVerbatim myprt("TC");
     if(printHeader) {
       myprt<<someText;
       myprt<<"  PFP sVx  ________sPos_______ CS _______sDir______ ____sdEdx_____ eVx  ________ePos_______ CS _______eDir______ ____edEdx____   Len nTp3 MCSMom ShLike? PDG mcpIndx Par Prim E*P\n";
     }
     myprt<<someText;
     std::string pid = "P" + std::to_string(pfp.ID);
     myprt<<std::setw(5)<<pid;
     // start and end stuff
     for(unsigned short startend = 0; startend < 2; ++startend) {
       myprt<<std::setw(4)<<pfp.Vx3ID[startend];
       myprt<<std::fixed<<std::right<<std::setprecision(1);
       myprt<<std::setw(7)<<pfp.XYZ[startend][0];
       myprt<<std::setw(7)<<pfp.XYZ[startend][1];
       myprt<<std::setw(7)<<pfp.XYZ[startend][2];
       // print character for Outside or Inside the FV
       if(pfp.StopFlag[startend][kOutFV]) {
         myprt<<"  O";
       } else {
         myprt<<"  I";
       }
       myprt<<std::fixed<<std::right<<std::setprecision(2);
       myprt<<std::setw(6)<<pfp.Dir[startend][0];
       myprt<<std::setw(6)<<pfp.Dir[startend][1];
       myprt<<std::setw(6)<<pfp.Dir[startend][2];
       for(auto& dedx : pfp.dEdx[startend]) {
         if(dedx < 50) {
           myprt<<std::setw(5)<<std::setprecision(1)<<dedx;
         } else {
           myprt<<std::setw(5)<<std::setprecision(0)<<dedx;
         }
       } // dedx
       if (pfp.dEdx[startend].size()<3){
         for(size_t i = 0; i<3-pfp.dEdx[startend].size(); ++i){
           myprt<<std::setw(6)<<' ';
         }
       }
     } // startend
     // global stuff
 //    myprt<<std::setw(5)<<pfp.BestPlane;
     float length = PosSep(pfp.XYZ[0], pfp.XYZ[1]);
     if(length < 100) {
       myprt<<std::setw(5)<<std::setprecision(1)<<length;
     } else {
       myprt<<std::setw(5)<<std::setprecision(0)<<length;
     }
     myprt<<std::setw(5)<<std::setprecision(2)<<pfp.Tp3s.size();
     myprt<<std::setw(7)<<MCSMom(tjs, pfp.TjIDs);
     myprt<<std::setw(5)<<IsShowerLike(tjs, pfp.TjIDs);
     myprt<<std::setw(5)<<pfp.PDGCode;
     if(pfp.MCPartListIndex < tjs.MCPartList.size()) {
       myprt<<std::setw(8)<<pfp.MCPartListIndex;
     } else {
       myprt<<"      NA";
     }
     myprt<<std::setw(4)<<pfp.ParentID;
     myprt<<std::setw(5)<<PrimaryID(tjs, pfp);
     myprt<<std::setw(5)<<std::setprecision(2)<<pfp.EffPur;
     if(!pfp.TjIDs.empty()) {
       for(auto& tjID : pfp.TjIDs) myprt<<" T"<<tjID;
     }
     if(!pfp.DtrIDs.empty()) {
       myprt<<" dtrs";
       for(auto& dtrID : pfp.DtrIDs) myprt<<" P"<<dtrID;
     }
   } // PrintPFP

void tca::PrintPFPs	(	std::string	someText,
		const TjStuff &	tjs
	)

Definition at line 4690 of file Utils.cxx.

References tca::TjStuff::pfps, and PrintPFP().

Referenced by DotProd(), FindShowers3D(), and tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     if(tjs.pfps.empty()) return;
     
     mf::LogVerbatim myprt("TC");
     myprt<<someText;
     myprt<<"  PFP sVx  ________sPos_______  ______sDir______  ______sdEdx_____ eVx  ________ePos_______  ______eDir______  ______edEdx_____ BstPln PDG TruPDG Par Prim E*P\n";
     bool printHeader = true;
     for(auto& pfp : tjs.pfps) {
 //      if(pfp.ID == 0) continue;
       PrintPFP(someText, tjs, pfp, printHeader);
       printHeader = false;
     } // im
     
   } // PrintPFPs

std::string tca::PrintPos	(	const TjStuff &	tjs,
		const TrajPoint &	tp
	)

Definition at line 4738 of file Utils.cxx.

References tca::TrajPoint::CTP, tca::TrajPoint::Pos, PrintPos(), and util::flags::to_string().

   {
     return std::to_string(tp.CTP) + ":" + PrintPos(tjs, tp.Pos);
   } // PrintPos

std::string tca::PrintPos	(	const TjStuff &	tjs,
		const Point2_t &	pos
	)

Definition at line 4744 of file Utils.cxx.

References util::flags::to_string(), and tca::TjStuff::UnitsPerTick.

Referenced by CheckTrajBeginChg(), MergeAndStore(), PrintAllTraj(), PrintPos(), TagDeltaRays(), TagMuonDirections(), TjDirFOM(), and UpdateVxEnvironment().

   {
     unsigned int wire = 0;
     if(pos[0] > -0.4) wire = std::nearbyint(pos[0]);
     int time = std::nearbyint(pos[1]/tjs.UnitsPerTick);
     return std::to_string(wire) + ":" + std::to_string(time);
   } // PrintPos

void tca::PrintShower	(	std::string	someText,
		const TjStuff &	tjs,
		const ShowerStruct &	ss,
		bool	printHeader,
		bool	printExtras
	)

Definition at line 4801 of file TCShower.cxx.

Referenced by Print2DShowers().

   {
     // print a single shower and a header (optional) and the extra variables like TjIDs, envelope, etc
     mf::LogVerbatim myprt("TC");
     
     if(printHeader) {
       myprt<<someText<<"   ID   CTP  ParID ParFOM TruParID Energy nTjs  dFOM AspRat  stj  vx0 __Pos0___ Chg(k) dRMS __Pos1___ Chg(k) dRMS __Pos2___ Chg(k) dRMS Angle SS3ID PFPID\n";
     } // printHeader
 
     myprt<<someText<<std::fixed;
     std::string sid = "2S" + std::to_string(ss.ID);
     myprt<<std::setw(5)<<sid;
     myprt<<std::setw(6)<<ss.CTP;
     sid = "NA";
     if(ss.ParentID > 0) sid = "T" + std::to_string(ss.ParentID);
     myprt<<std::setw(7)<<sid;
     myprt<<std::setw(7)<<std::setprecision(2)<<ss.ParentFOM;
     myprt<<std::setw(9)<<ss.TruParentID;
     myprt<<std::setw(7)<<(int)ss.Energy;
     myprt<<std::setw(5)<<ss.TjIDs.size();
     myprt<<std::setw(6)<<std::setprecision(2)<<ss.DirectionFOM;
     myprt<<std::setw(7)<<std::setprecision(2)<<ss.AspectRatio;
     const auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
     std::string tid = "T" + std::to_string(stj.ID);
     myprt<<std::setw(5)<<tid;
     std::string vid = "NA";
     if(stj.VtxID[0] > 0) vid = "2V" + std::to_string(stj.VtxID[0]);
     myprt<<std::setw(5)<<vid;
     for(auto& spt : stj.Pts) {
       myprt<<std::setw(10)<<PrintPos(tjs, spt.Pos);
       myprt<<std::setw(7)<<std::fixed<<std::setprecision(1)<<spt.Chg/1000;
       //        myprt<<std::setw(5)<<spt.NTPsFit;
       myprt<<std::setw(5)<<std::setprecision(1)<<spt.DeltaRMS;
     } // spt
     myprt<<std::setw(6)<<std::setprecision(2)<<stj.Pts[1].Ang;
     std::string sss = "NA";
     if(ss.SS3ID > 0) sss = "3S" + std::to_string(ss.SS3ID);
     myprt<<std::setw(6)<<sss;
     if(ss.SS3ID > 0 && ss.SS3ID < (int)tjs.showers.size()) {
       auto& ss3 = tjs.showers[ss.SS3ID - 1];
       if(ss3.PFPIndex >= 0 && ss3.PFPIndex < tjs.pfps.size()) {
         std::string pid = "P" + std::to_string(ss3.PFPIndex + 1);
         myprt<<std::setw(6)<<pid;
       } else {
         myprt<<std::setw(6)<<"NA";
       }
     } else {
       myprt<<std::setw(6)<<"NA";
     }
     if(ss.NeedsUpdate) myprt<<" *** Needs update";
     
     if(!printExtras) return;
     myprt<<"\n";
     
     myprt<<someText<<std::fixed;
     sid = "2S" + std::to_string(ss.ID);
     myprt<<std::setw(5)<<sid;
     myprt<<" Tjs";
     for(auto id : ss.TjIDs) myprt<<" T"<<id;
     myprt<<"\n";
     myprt<<someText<<std::fixed;
     sid = "2S" + std::to_string(ss.ID);
     myprt<<std::setw(5)<<sid;
     myprt<<" Envelope";
     for(auto& vtx : ss.Envelope) myprt<<" "<<(int)vtx[0]<<":"<<(int)(vtx[1]/tjs.UnitsPerTick);
     myprt<<"\n";
     myprt<<someText<<std::fixed;
     sid = "2S" + std::to_string(ss.ID);
     myprt<<std::setw(5)<<sid;
     myprt<<" Nearby";
     for(auto id : ss.NearTjIDs) myprt<<" T"<<id;
 
   } // PrintShower

void tca::PrintShowers	(	std::string	fcnLabel,
		TjStuff &	tjs
	)

Definition at line 4676 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::cots, EncodeCTP(), MakeBareTP(), tca::TjStuff::NumPlanes, PrintPos(), tca::TjStuff::showers, and ss.

Referenced by Match2DShowers(), and tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     if(tjs.showers.empty()) return;
     mf::LogVerbatim myprt("TC");
     myprt<<fcnLabel<<" 3D showers \n";
     for(auto& ss3 : tjs.showers) {
       myprt<<fcnLabel<<" 3S"<<ss3.ID<<" 3V"<<ss3.Vx3ID;
       myprt<<" parentID "<<ss3.ParentID;
       myprt<<" ChgPos"<<std::fixed;
       for(unsigned short xyz = 0; xyz < 3; ++xyz) myprt<<" "<<std::setprecision(0)<<ss3.ChgPos[xyz];
       myprt<<" Dir";
       for(unsigned short xyz = 0; xyz < 3; ++xyz) myprt<<" "<<std::setprecision(2)<<ss3.Dir[xyz];
       myprt<<" posInPlane";
       std::vector<float> projInPlane(tjs.NumPlanes);
       for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
         CTP_t inCTP = EncodeCTP(ss3.TPCID.Cryostat, ss3.TPCID.TPC, plane);
         auto tp = MakeBareTP(tjs, ss3.ChgPos, ss3.Dir, inCTP);
         myprt<<" "<<PrintPos(tjs, tp.Pos);
         projInPlane[plane] = tp.Delta;
       } // plane
       myprt<<" projInPlane";
       for(unsigned short plane = 0; plane < tjs.NumPlanes; ++plane) {
         myprt<<" "<<std::fixed<<std::setprecision(2)<<projInPlane[plane];
       } // plane
       for(auto cid : ss3.CotIDs) {
         auto& ss = tjs.cots[cid - 1];
         myprt<<"\n  2S"<<ss.ID;
         auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
         myprt<<" ST"<<stj.ID;
         myprt<<" "<<PrintPos(tjs, stj.Pts[stj.EndPt[0]].Pos)<<" - "<<PrintPos(tjs, stj.Pts[stj.EndPt[1]].Pos);
       } // ci
       if(ss3.NeedsUpdate) myprt<<" *** Needs update";
       myprt<<"\n";
     } // sss3
   } // PrintShowers

std::string tca::PrintStopFlag	(	const Trajectory &	tj,
		unsigned short	end
	)

Definition at line 4707 of file Utils.cxx.

References tca::Trajectory::StopFlag, StopFlagNames, tmp, and util::flags::to_string().

Referenced by DotProd(), tca::TrajClusterAlg::FixTrajBegin(), and PrintTrajectory().

   {
     if(end > 1) return "Invalid end";
     std::string tmp;
     bool first = true;
     for(unsigned short ib = 0; ib < StopFlagNames.size(); ++ib) {
       if(tj.StopFlag[end][ib]) {
         if(first) {
           tmp = std::to_string(end) + ":" + StopFlagNames[ib];
           first = false;
         } else {
           tmp += "," + StopFlagNames[ib];
         }
       }
     } // ib
     return tmp;
   } // PrintStopFlag

void tca::PrintTp3	(	std::string	someText,
		const TjStuff &	tjs,
		const TrajPoint3 &	tp3
	)

Definition at line 2945 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, tca::TrajPoint3::Dir, tca::TrajPoint3::Pos, PrintPos(), and tca::TrajPoint3::Tj2Pts.

Referenced by DotProd(), and SetStart().

   {
     mf::LogVerbatim myprt("TC");
     myprt<<someText<<" Pos"<<std::fixed<<std::setprecision(1);
     myprt<<std::setw(6)<<tp3.Pos[0]<<std::setw(6)<<tp3.Pos[1]<<std::setw(6)<<tp3.Pos[2];
     myprt<<" Dir"<<std::fixed<<std::setprecision(3);
     myprt<<std::setw(7)<<tp3.Dir[0]<<std::setw(7)<<tp3.Dir[1]<<std::setw(7)<<tp3.Dir[2];
     myprt<<" tj_ipt";
     for(auto tj2pt : tp3.Tj2Pts) {
       auto& tj = tjs.allTraj[tj2pt.id - 1];
       auto& tp = tj.Pts[tj2pt.ipt];
       myprt<<" "<<tj.ID<<"_"<<PrintPos(tjs, tp);
     } // tj2pt
   } // PrintTp3

void tca::PrintTp3s	(	std::string	someText,
		const TjStuff &	tjs,
		const PFPStruct &	pfp,
		short	printPts
	)

Definition at line 2961 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, DeltaAngle(), tca::PFPStruct::Dir, tca::PFPStruct::ID, KinkAngle(), PosSep(), PrintPos(), tca::PFPStruct::Tp3s, and tca::PFPStruct::XYZ.

Referenced by DotProd().

   {
     if(pfp.Tp3s.empty()) return;
     mf::LogVerbatim myprt("TC");
     if(printPts < 0) {
       // print the head if we are print all points
       myprt<<someText<<" pfp P"<<pfp.ID<<"\n";
       myprt<<someText<<"  ipt ________Pos________ Path   ________Dir_______ along trans  dang  Kink  Tj_ipt \n";
     }
     // print the start
     myprt<<someText<<"    ";
     myprt<<std::fixed<<std::setprecision(1);
     myprt<<std::setw(7)<<pfp.XYZ[0][0]<<std::setw(7)<<pfp.XYZ[0][1]<<std::setw(7)<<pfp.XYZ[0][2];
     myprt<<"     ";
     myprt<<std::fixed<<std::setprecision(2);
     myprt<<std::setw(7)<<pfp.Dir[0][0]<<std::setw(7)<<pfp.Dir[0][1]<<std::setw(7)<<pfp.Dir[0][2];
     myprt<<" <--- pfp.XYZ[0] \n";
     
     unsigned short fromPt = 0;
     unsigned short toPt = pfp.Tp3s.size() - 1;
     if(printPts >= 0) fromPt = toPt;
     Vector3_t prevDir = pfp.Dir[0];
     for(unsigned short ipt = fromPt; ipt <= toPt; ++ipt) {
       auto tp3 = pfp.Tp3s[ipt];
       myprt<<someText<<std::setw(4)<<ipt;
       myprt<<std::fixed<<std::setprecision(1);
       myprt<<std::setw(7)<<tp3.Pos[0]<<std::setw(7)<<tp3.Pos[1]<<std::setw(7)<<tp3.Pos[2];
       myprt<<std::setprecision(1)<<std::setw(5)<<PosSep(tp3.Pos, pfp.XYZ[0]);
       myprt<<std::setprecision(2)<<std::setw(7)<<tp3.Dir[0]<<std::setw(7)<<tp3.Dir[1]<<std::setw(7)<<tp3.Dir[2];
       myprt<<std::setprecision(1)<<std::setw(6)<<tp3.AlongTrans[0];
       myprt<<std::setprecision(1)<<std::setw(6)<<tp3.AlongTrans[1];
       myprt<<std::setprecision(2)<<std::setw(7)<<DeltaAngle(prevDir, tp3.Dir);
       prevDir = tp3.Dir;
       // Calculate the kink angle at point ipt, using the two points that are
       // +/- 1 cm on either side of that point
       double sep = 1;
       myprt<<std::setprecision(2)<<std::setw(7)<<KinkAngle(tjs, pfp.Tp3s, ipt, sep);
       for(auto tj2pt : tp3.Tj2Pts) {
         auto& tj = tjs.allTraj[tj2pt.id - 1];
         auto& tp = tj.Pts[tj2pt.ipt];
         myprt<<" "<<tj.ID<<"_"<<tj2pt.ipt<<"_"<<PrintPos(tjs, tp);
       } // tj2pt
       myprt<<"\n";
     } // ipt
     // print the end
     myprt<<someText<<"    ";
     myprt<<std::fixed<<std::setprecision(1);
     myprt<<std::setw(7)<<pfp.XYZ[1][0]<<std::setw(7)<<pfp.XYZ[1][1]<<std::setw(7)<<pfp.XYZ[1][2];
     myprt<<"     ";
     myprt<<std::fixed<<std::setprecision(2);
     myprt<<std::setw(7)<<pfp.Dir[1][0]<<std::setw(7)<<pfp.Dir[1][1]<<std::setw(7)<<pfp.Dir[1][2];
     myprt<<" <--- pfp.XYZ[1]. Length "<<PosSep(pfp.XYZ[0], pfp.XYZ[1])<<"\n";
   } // PrintTp3s

void tca::PrintTrajectory	(	std::string	someText,
		const TjStuff &	tjs,
		const Trajectory &	tj,
		unsigned short	tPoint
	)

Definition at line 4488 of file Utils.cxx.

   {
     // prints one or all trajectory points on tj
     
     int trupdg = 0;
     if(tj.MCPartListIndex < tjs.MCPartList.size()) trupdg = tjs.MCPartList[tj.MCPartListIndex]->PdgCode();
     
     if(tPoint == USHRT_MAX) {
       if(tj.ID < 0) {
         mf::LogVerbatim myprt("TC");
         myprt<<someText<<" ";
         myprt<<"Work:    ID "<<tj.ID<<"    CTP "<<tj.CTP<<" StepDir "<<tj.StepDir<<" PDG "<<tj.PDGCode<<" TruPDG "<<trupdg<<" tjs.vtx "<<tj.VtxID[0]<<" "<<tj.VtxID[1]<<" nPts "<<tj.Pts.size()<<" EndPts "<<tj.EndPt[0]<<" "<<tj.EndPt[1];
         myprt<<" MCSMom "<<tj.MCSMom;
         myprt<<" StopFlags "<<PrintStopFlag(tj, 0)<<" "<<PrintStopFlag(tj, 1);
         myprt<<" AlgMod names:";
         for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(tj.AlgMod[ib]) myprt<<" "<<AlgBitNames[ib];
       } else {
         mf::LogVerbatim myprt("TC");
         myprt<<someText<<" ";
         myprt<<"tjs.allTraj: ID "<<tj.ID<<" WorkID "<<tj.WorkID<<" StepDir "<<tj.StepDir<<" PDG "<<tj.PDGCode<<" TruPDG "<<trupdg<<" tjs.vtx "<<tj.VtxID[0]<<" "<<tj.VtxID[1]<<" nPts "<<tj.Pts.size()<<" EndPts "<<tj.EndPt[0]<<" "<<tj.EndPt[1];
         myprt<<" MCSMom "<<tj.MCSMom;
         myprt<<" StopFlags "<<PrintStopFlag(tj, 0)<<" "<<PrintStopFlag(tj, 1);
         myprt<<" AlgMod names:";
         for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(tj.AlgMod[ib]) myprt<<" "<<AlgBitNames[ib];
       }
       PrintHeader(someText);
       for(unsigned short ipt = 0; ipt < tj.Pts.size(); ++ipt) PrintTrajPoint(someText, tjs, ipt, tj.StepDir, tj.Pass, tj.Pts[ipt]);
       // See if this trajectory is a shower Tj
       if(tj.AlgMod[kShowerTj]) {
         for(unsigned short ic = 0; ic < tjs.cots.size(); ++ic) {
           if(tjs.cots[ic].TjIDs.empty()) continue;
           // only print out the info for the correct Tj
           if(tjs.cots[ic].ShowerTjID != tj.ID) continue;
           const ShowerStruct& ss = tjs.cots[ic];
           mf::LogVerbatim myprt("TC");
           myprt<<"cots index "<<ic<<" ";
           myprt<<someText<<" Envelope";
           if(ss.Envelope.empty()) {
             myprt<<" NA";
           } else {
             for(auto& vtx : ss.Envelope) myprt<<" "<<(int)vtx[0]<<":"<<(int)(vtx[1]/tjs.UnitsPerTick);
           }
           myprt<<" Energy "<<(int)ss.Energy;
           myprt<<" Area "<<std::fixed<<std::setprecision(1)<<(int)ss.EnvelopeArea<<" ChgDensity "<<ss.ChgDensity;
           myprt<<"\nInShower TjIDs";
           for(auto& tjID : ss.TjIDs) {
             myprt<<" "<<tjID;
           } // tjIDA_Klystron_4U
           
           myprt<<"\n";
           myprt<<"NearTjIDs";
           for(auto& tjID : ss.NearTjIDs) {
             myprt<<" "<<tjID;
           } // tjID
           myprt<<"\n";
           myprt<<"\n";
           myprt<<"Angle "<<std::fixed<<std::setprecision(2)<<ss.Angle<<" +/- "<<ss.AngleErr;
           myprt<<" AspectRatio "<<std::fixed<<std::setprecision(2)<<ss.AspectRatio;
           myprt<<" DirectionFOM "<<std::fixed<<std::setprecision(2)<<ss.DirectionFOM;
           if(ss.ParentID > 0) {
             myprt<<" Parent Tj "<<ss.ParentID<<" FOM "<<ss.ParentFOM;
           } else {
             myprt<<" No parent";
           }
           myprt<<" TruParentID "<<ss.TruParentID<<" SS3ID "<<ss.SS3ID<<"\n";
           if(ss.NeedsUpdate) myprt<<"*********** This shower needs to be updated ***********";
           myprt<<"................................................";
         } // ic
       } // Shower Tj
     } else {
       // just print one traj point
       if(tPoint > tj.Pts.size() -1) {
         mf::LogVerbatim("TC")<<"Can't print non-existent traj point "<<tPoint;
         return;
       }
       PrintTrajPoint(someText, tjs, tPoint, tj.StepDir, tj.Pass, tj.Pts[tPoint]);
     }
   } // PrintTrajectory

void tca::PrintTrajPoint	(	std::string	someText,
		const TjStuff &	tjs,
		unsigned short	ipt,
		short	dir,
		unsigned short	pass,
		TrajPoint const &	tp
	)

Definition at line 4574 of file Utils.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::AngErr, tca::TrajPoint::AngleCode, tca::TrajPoint::AveChg, tca::TrajPoint::Chg, tca::TrajPoint::ChgPull, tca::TrajPoint::CTP, tca::TrajPoint::Delta, tca::TrajPoint::DeltaRMS, tca::TrajPoint::Dir, tca::TjStuff::fHits, tca::TrajPoint::FitChi, tca::TrajPoint::Hits, tca::TrajPoint::NTPsFit, tca::TrajPoint::Pos, tca::TrajPoint::Step, tca::TjStuff::UnitsPerTick, and tca::TrajPoint::UseHit.

Referenced by DotProd(), tca::TrajClusterAlg::FillGaps(), tca::TrajClusterAlg::FindVtxTraj(), FitVertex(), tca::TrajClusterAlg::FixTrajBegin(), tca::TrajClusterAlg::HiEndDelta(), PrintAllTraj(), PrintTrajectory(), SplitTrajCrossingVertices(), and tca::TrajClusterAlg::StepCrawl().

   {
     mf::LogVerbatim myprt("TC");
     myprt<<someText<<" TRP"<<std::fixed;
     myprt<<pass;
     if(dir > 0) { myprt<<"+"; } else { myprt<<"-"; }
     myprt<<std::setw(6)<<tp.CTP;
     myprt<<std::setw(5)<<ipt;
     myprt<<std::setw(5)<<tp.Step;
     myprt<<std::setw(7)<<std::setprecision(1)<<tp.Pos[0]<<":"<<tp.Pos[1]/tjs.UnitsPerTick; // W:T
     if(tp.Pos[1] < 10) { myprt<<"  "; }
     if(tp.Pos[1] < 100) { myprt<<" "; }
     if(tp.Pos[1] < 1000) { myprt<<" "; }
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.Delta;
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.DeltaRMS;
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.Ang;
     myprt<<std::setw(2)<<tp.AngleCode;
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.AngErr;
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.Dir[0];
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.Dir[1];
     myprt<<std::setw(7)<<(int)tp.Chg;
     myprt<<std::setw(8)<<(int)tp.AveChg;
     myprt<<std::setw(6)<<std::setprecision(1)<<tp.ChgPull;
     myprt<<std::setw(7)<<tp.FitChi;
     myprt<<std::setw(6)<<tp.NTPsFit;
     // print the hits associated with this traj point
     if(tp.Hits.size() > 16) {
       // don't print too many hits (e.g. from a shower Tj)
       myprt<<" "<<tp.Hits.size()<<" shower hits";
     } else {
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         unsigned int iht = tp.Hits[ii];
         myprt<<" "<<tjs.fHits[iht].ArtPtr->WireID().Wire<<":"<<(int)tjs.fHits[iht].PeakTime;
         if(tp.UseHit[ii]) {
           // Distinguish used hits from nearby hits
           myprt<<"_";
         } else {
           myprt<<"x";
         }
         myprt<<tjs.fHits[iht].InTraj;
       } // iht
     }
   } // PrintTrajPoint

std::vector< unsigned int > tca::PutTrajHitsInVector	(	Trajectory const &	tj,
		HitStatus_t	hitRequest
	)

Definition at line 2283 of file Utils.cxx.

References tca::Trajectory::AlgMod, kAllHits, kShowerTj, kUnusedHits, kUsedHits, and tca::Trajectory::Pts.

Referenced by tca::TrajClusterAlg::AddLAHits(), tca::TrajClusterAlg::CheckHiMultUnusedHits(), tca::TrajClusterAlg::ChkInTraj(), Finish3DShowers(), HasDuplicateHits(), InTrajOK(), tca::TrajClusterAlg::MakeAllTrajClusters(), tca::TruthMatcher::MatchAndSum(), tca::TruthMatcher::MatchTruth(), MergeGhostTjs(), tca::MCParticleListUtils::PrimaryElectronPFPID(), and TransferTjHits().

   {
     // Put hits in each trajectory point into a flat vector
     std::vector<unsigned int> hitVec;
     
     // special handling for shower trajectories. UseHit isn't valid
     if(tj.AlgMod[kShowerTj]) {
       for(auto& tp : tj.Pts) hitVec.insert(hitVec.end(), tp.Hits.begin(), tp.Hits.end());
       return hitVec;
     } // shower Tj
     
     // reserve under the assumption that there will be one hit per point
     hitVec.reserve(tj.Pts.size());
     for(unsigned short ipt = 0; ipt < tj.Pts.size(); ++ipt) {
       for(unsigned short ii = 0; ii < tj.Pts[ipt].Hits.size(); ++ii) {
         unsigned int iht = tj.Pts[ipt].Hits[ii];
         bool useit = (hitRequest == kAllHits);
         if(tj.Pts[ipt].UseHit[ii] && hitRequest == kUsedHits) useit = true;
         if(!tj.Pts[ipt].UseHit[ii] && hitRequest == kUnusedHits) useit = true;
         if(useit) hitVec.push_back(iht);
       } // iht
     } // ipt
     return hitVec;
   } // PutTrajHitsInVector

bool tca::Reconcile3D	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		const geo::TPCID &	tpcid,
		bool	parentSearchDone,
		bool	prt
	)

Definition at line 491 of file TCShower.cxx.

References AddPFP(), tca::TjStuff::allTraj, ChkAssns(), tca::TjStuff::cots, geo::CryostatID::Cryostat, DecodeCTP(), evd::details::end(), GetAssns(), InShowerProb(), kMat3D, MakeShowerObsolete(), MergeShowersAndStore(), tca::TjStuff::pfps, Print2DShowers(), RemovePFP(), SetIntersection(), ShowerEnergy(), tca::TjStuff::showers, ss, geo::TPCID::TPC, and UpdateShower().

   {
     // Reconcile pfp and shower assns
     
     std::string fcnLabel = inFcnLabel + ".R3D2";
     
     if(prt) Print2DShowers("R3D2i", tjs, USHRT_MAX, false);
     
     // consider them pair-wise
     if(tjs.showers.size() > 1) {
       for(unsigned short ii = 0; ii < tjs.showers.size() - 1; ++ii) {
         auto iss3 = tjs.showers[ii];
         if(iss3.ID == 0) continue;
         if(iss3.TPCID != tpcid) continue;
         auto iPInSS3 = GetAssns(tjs, "3S", iss3.ID, "P");
         if(prt) {
           mf::LogVerbatim myprt("TC");
           myprt<<fcnLabel<<" 3S"<<iss3.ID<<" ->";
           for(auto pid : iPInSS3) myprt<<" P"<<pid;
         } // prt
         for(unsigned short jj = ii + 1; jj < tjs.showers.size(); ++jj) {
           auto jss3 = tjs.showers[jj];
           if(jss3.ID == 0) continue;
           auto jPInSS3 = GetAssns(tjs, "3S", jss3.ID, "P");
           auto shared = SetIntersection(iPInSS3, jPInSS3);
           if(shared.empty()) continue;
           if(prt) {
             mf::LogVerbatim myprt("TC");
             myprt<<fcnLabel<<" Conflict i3S"<<iss3.ID<<" and j3S"<<jss3.ID<<" share";
             for(auto pid : shared) myprt<<" P"<<pid;
           } // prt
           // Compare the InShower likelihoods
           for(auto pid : shared) {
             auto& pfp = tjs.pfps[pid - 1];
             float iProb = InShowerProb(tjs, iss3, pfp);
             float jProb = InShowerProb(tjs, jss3, pfp);
             if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" i3S"<<iss3.ID<<" prob "<<std::setprecision(3)<<iProb<<"  j3S"<<jss3.ID<<" prob "<<jProb;
             if(iProb > jProb) {
               // remove the remnants of pfp from jss3
               RemovePFP(fcnLabel, tjs, pfp, jss3, true, prt);
               // and add them to iss3
               AddPFP(fcnLabel, tjs, pfp.ID, iss3, true, prt);
             } else {
               RemovePFP(fcnLabel, tjs, pfp, iss3, true, prt);
               AddPFP(fcnLabel, tjs, pfp.ID, jss3, true, prt);
             }
           } // pid
         } // jj
       } // ii
     } // > 1 shower
         
     // Look for an in-shower pfp that is not the shower parent that is attached to a vertex. 
     // Remove the attachment and any parent - daughter assn
     if(parentSearchDone) {
       for(auto& ss3 : tjs.showers) {
         if(ss3.ID == 0) continue;
         if(ss3.TPCID != tpcid) continue;
         auto PIn3S = GetAssns(tjs, "3S", ss3.ID, "P");
         for(auto pid : PIn3S) {
           if(pid == ss3.ParentID) continue;
           auto& pfp = tjs.pfps[pid - 1];
           for(unsigned short end = 0; end < 2; ++end) {
             if(pfp.Vx3ID[end] <= 0) continue;
             if(prt) {
               mf::LogVerbatim myprt("TC");
               myprt<<fcnLabel<<" Detach 3S"<<ss3.ID<<" -> P"<<pfp.ID<<"_"<<end<<" -> 3V"<<pfp.Vx3ID[end];
               if(pfp.ParentID > 0) myprt<<" ->Parent P"<<pfp.ParentID;
             }
             // remove P -> P parent-daughter assn
             pfp.Vx3ID[end] = 0;
             if(pfp.ParentID > 0) {
               auto& parentPFP = tjs.pfps[pfp.ParentID - 1];
               std::vector<int> newDtrIDs;
               for(auto did : parentPFP.DtrIDs) if(did != pfp.ID) newDtrIDs.push_back(did);
               parentPFP.DtrIDs = newDtrIDs;
             } // pfp Parent exists
           } // end
         } // pid
       } // ss3
     } // parentSearchDone
     
     unsigned int cstat = tpcid.Cryostat;
     unsigned int tpc = tpcid.TPC;
     // now look for 2D showers that not matched in 3D and have tjs
     // that are 3D-matched
     for(auto& ss : tjs.cots) {
       if(ss.ID == 0) continue;
       if(ss.SS3ID > 0) continue;
       if(DecodeCTP(ss.CTP).TPC != tpc) continue;
       if(DecodeCTP(ss.CTP).Cryostat != cstat) continue;
       std::vector<int> matchedTjs;
       for(auto tid : ss.TjIDs) if(tjs.allTraj[tid - 1].AlgMod[kMat3D]) matchedTjs.push_back(tid);
       if(matchedTjs.empty()) continue;
       // try to merge it with an existing 3D-matched shower
       int mergeWith3S = 0;
       // The merge is compatible if it only matches to one shower
       bool isCompatible = true;
       for(auto tid : matchedTjs) {
         auto TInP = GetAssns(tjs, "T", tid, "P");
         if(TInP.empty()) continue;
         // do some more checking. See what other showers the Tjs in the pfp
         // may belong to in other planes
         auto PIn3S = GetAssns(tjs, "P", TInP[0], "3S");
         for(auto sid : PIn3S) {
           // require that the energy be lower
           auto& ss3 = tjs.showers[sid - 1];
           if(ss.Energy > ShowerEnergy(ss3)) continue;
           if(mergeWith3S == 0) mergeWith3S = sid;
           if(mergeWith3S > 0 && mergeWith3S != sid) isCompatible = false;
         } // sid
       } // tid
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<fcnLabel<<" 2S"<<ss.ID<<" is not 3D-matched but has 3D-matched Tjs:";
         for(auto tid : matchedTjs) {
           myprt<<" T"<<tid;
           auto TInP = GetAssns(tjs, "T", tid, "P");
           if(!TInP.empty()) {
             myprt<<"->P"<<TInP[0];
           } // TInP not empty
         } // tid
       } // prt
       if(mergeWith3S == 0 && ss.Energy < 50) {
         // kill it
         MakeShowerObsolete(fcnLabel, tjs, ss, prt);
       } else if(mergeWith3S > 0 && isCompatible) {
         auto& ss3 = tjs.showers[mergeWith3S - 1];
         for(auto cid : ss3.CotIDs) {
           auto& oss = tjs.cots[cid - 1];
           if(oss.CTP != ss.CTP) continue;
           if(!MergeShowersAndStore(fcnLabel, tjs, oss.ID, ss.ID, prt)) {
             std::cout<<fcnLabel<<" Merge failed\n";
           }
           if(!UpdateShower(fcnLabel, tjs, oss, prt)) {
             std::cout<<fcnLabel<<" UpdateShower failed\n";
           }
           ss3.NeedsUpdate = true;
           if(!UpdateShower(fcnLabel, tjs, ss3, prt)) {
             std::cout<<fcnLabel<<" UpdateShower failed\n";
           }
           break;
         } // cid
       } // mergeWith3S > 0
     } // ss
     
     
     if(prt) Print2DShowers("R3D2o", tjs, USHRT_MAX, false);
     
     ChkAssns(fcnLabel, tjs);
     
     return true;
   } // Reconcile3D

bool tca::Reconcile3D	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 645 of file TCShower.cxx.

References AddPFP(), evd::details::begin(), tca::ShowerStruct3D::ChgPos, ChkAssns(), tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, evd::details::end(), FarEnd(), GetAssns(), tca::ShowerStruct3D::ID, InShowerProb(), tca::TjStuff::pfps, PosSep(), Print2DShowers(), RemovePFP(), SetDifference(), ss, and UpdateShower().

Referenced by FindShowers3D(), and Match2DShowers().

   {
     // checks consistency between pfparticles, showers and tjs associated with ss3
     if(ss3.ID == 0) return false;
     // it isn't a failure if there is a 3D shower in two planes
     if(ss3.CotIDs.size() < 3) return true;
     std::string fcnLabel = inFcnLabel + ".R3D";
 
     if(prt) Print2DShowers("R3Di", tjs, USHRT_MAX, false);
 
     // make local copies so we can recover from a failure
     auto oldSS3 = ss3;
     std::vector<ShowerStruct> oldSS(ss3.CotIDs.size());
     for(unsigned short ii = 0; ii < ss3.CotIDs.size(); ++ii) {
       oldSS[ii] = tjs.cots[ss3.CotIDs[ii] - 1];
     }
     
     std::vector<std::vector<int>> plist(ss3.CotIDs.size());
     for(unsigned short ci = 0; ci < ss3.CotIDs.size(); ++ci) {
       auto& ss = tjs.cots[ss3.CotIDs[ci] - 1];
       for(auto tid : ss.TjIDs) {
         auto tToP = GetAssns(tjs, "T", tid, "P");
         if(tToP.empty()) continue;
         // there should only be one pfp for a tj
         int pid = tToP[0];
         if(std::find(plist[ci].begin(), plist[ci].end(), pid) == plist[ci].end()) plist[ci].push_back(pid);
       } // tid
     } // ci
     // count the occurrence of each pfp
     std::vector<std::array<int, 2>> p_cnt;
     for(auto& pl : plist) {
       for(auto pid : pl) {
         unsigned short indx = 0;
         for(indx = 0; indx < p_cnt.size(); ++indx) if(p_cnt[indx][0] == pid) break;
         if(indx == p_cnt.size()) {
           // not found so add it
           p_cnt.push_back(std::array<int,2> {{pid, 1}});
         } else {
           ++p_cnt[indx][1];
         }
       } // pid
     } // pl
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<fcnLabel<<" 3S"<<ss3.ID<<"\n";
       for(unsigned short ci = 0; ci < ss3.CotIDs.size(); ++ci) {
         myprt<<" -> 2S"<<ss3.CotIDs[ci]<<" ->";
         for(auto pid : plist[ci]) myprt<<" P"<<pid;
         myprt<<"\n";
       } // ci
       myprt<<" P<ID>_count:";
       for(auto& pc : p_cnt) myprt<<" P"<<pc[0]<<"_"<<pc[1];
     } // prt
     
     for(auto& pc : p_cnt) {
       // matched in all planes?
       if(pc[1] == (int)ss3.CotIDs.size()) continue;
       if(pc[1] == 2) {
         // missing a tj in a plane or is this a two-plane pfp?
         auto& pfp = tjs.pfps[pc[0] - 1];
         if(pfp.TjIDs.size() > 2) {
           // ensure that none of the tjs in this pfp are included in a different shower
           auto PIn2S = GetAssns(tjs, "P", pfp.ID, "2S");
           auto sDiff = SetDifference(PIn2S, ss3.CotIDs);
           // Not sure if this can happen
 //          if(sDiff.size() > 1) {std::cout<<fcnLabel<<" sDiff size > 2. Is this possible?\n";}
           if(!sDiff.empty() && std::find(ss3.CotIDs.begin(), ss3.CotIDs.end(), sDiff[0]) == ss3.CotIDs.end()) continue;
           if(prt) {
             mf::LogVerbatim myprt("TC");
             myprt<<fcnLabel<<" 3S"<<ss3.ID<<" P"<<pfp.ID<<" ->";
             for(auto sid : PIn2S) myprt<<" 2S"<<sid;
             myprt<<" sDiff";
             for(auto sid : sDiff) myprt<<" 2S"<<sid;
           } // prt
           // missed a tj in a 2D shower so "add the PFP to the shower" and update it
           if(AddPFP(fcnLabel, tjs, pfp.ID, ss3, true, prt)) {
             // Update the local copies
             oldSS3 = ss3;
             if(ss3.CotIDs.size() != oldSS.size()) {
               std::cout<<fcnLabel<<" Major failure...";
               return false;
             }
             for(unsigned short ii = 0; ii < ss3.CotIDs.size(); ++ii) oldSS[ii] = tjs.cots[ss3.CotIDs[ii] - 1];
           } else {
             // restore the previous state
             ss3 = oldSS3;
             for(unsigned short ii = 0; ii < oldSS.size(); ++ii) {
               auto& ss = oldSS[ii];
               tjs.cots[ss.ID - 1] = ss;
             } // ii
           } // AddPFP failed
         } // pfp.TjIDs.size() > 2
       } else {
         // only one occurrence. check proximity to ss3
         auto& pfp = tjs.pfps[pc[0] - 1];
         unsigned short nearEnd = 1 - FarEnd(tjs, pfp, ss3.ChgPos);
         float prob = InShowerProb(tjs, ss3, pfp);
         float sep = PosSep(pfp.XYZ[nearEnd], ss3.ChgPos);
         if(prt) {
           mf::LogVerbatim myprt("TC");
           myprt<<fcnLabel<<" one occurrence: P"<<pfp.ID<<"_"<<nearEnd<<" closest to ChgPos";
           myprt<<" ChgPos "<<std::fixed<<std::setprecision(1)<<ss3.ChgPos[0]<<" "<<ss3.ChgPos[1]<<" "<<ss3.ChgPos[2];
           myprt<<" sep "<<sep;
           myprt<<" InShowerProb "<<prob;
         } // prt 
         if(sep < 30 && prob > 0.3 && AddPFP(fcnLabel, tjs, pfp.ID, ss3, true, prt)) {
           if(prt) mf::LogVerbatim("TC")<<" AddPFP success";
         } else if(!RemovePFP(fcnLabel, tjs, pfp, ss3, true, prt)) {
           std::cout<<"RemovePFP failed \n";
         }
       } // only one occurrence.
     } // pc
     
     if(!UpdateShower(fcnLabel, tjs, ss3, prt)) return false;
     ChkAssns(fcnLabel, tjs);
     if(prt) Print2DShowers("R3Do", tjs, USHRT_MAX, false);
     
     return true;
     
   } // Reconcile3D

bool tca::RefineVtxPosition	(	TjStuff &	tjs,
		const Trajectory &	tj,
		unsigned short &	nearPt,
		short	nPtsToChk,
		bool	prt
	)

Definition at line 2735 of file TCVertex.cxx.

References tca::Trajectory::EndPt, PrintPos(), and tca::Trajectory::Pts.

Referenced by CompleteIncomplete3DVertices().

   {
     // The tj has been slated to be split somewhere near point nearPt. This function will move
     // the near point a bit to the most likely point of a vertex
     
     float maxChg = tj.Pts[nearPt].Chg;
     short maxChgPt = nearPt;
     
     for(short ipt = nearPt - nPtsToChk; ipt < nearPt + nPtsToChk; ++ipt) {
       if(ipt < tj.EndPt[0] || ipt > tj.EndPt[1]) continue;
       auto& tp = tj.Pts[ipt];
       if(tp.Chg > maxChg) {
         maxChg = tp.Chg;
         maxChgPt = ipt;
       }
       if(prt) mf::LogVerbatim("TC")<<"RVP: ipt "<<ipt<<" Pos "<<tp.CTP<<":"<<PrintPos(tjs, tp.Pos)<<" chg "<<(int)tp.Chg<<" nhits "<<tp.Hits.size();
     } // ipt
     if(nearPt == maxChgPt) return false;
     nearPt = maxChgPt;
     return true;
   } //RefineVtxPosition

void tca::ReleaseHits	(	TjStuff &	tjs,
		Trajectory &	tj
	)

Definition at line 1070 of file Utils.cxx.

References tca::TjStuff::fHits, tca::Trajectory::ID, and tca::Trajectory::Pts.

Referenced by tca::TrajClusterAlg::FindVtxTraj(), tca::TrajClusterAlg::MakeJunkTraj(), tca::TrajClusterAlg::ReconstructAllTraj(), and StoreTraj().

   {
     // Sets InTraj[] = 0 for all TPs in work. Called when abandoning work
     for(auto& tp : tj.Pts) {
       for(auto iht : tp.Hits) {
         if(tjs.fHits[iht].InTraj == tj.ID) tjs.fHits[iht].InTraj = 0;
       }
     } // tp
     
   } // ReleaseWorkHits

bool tca::RemovePFP	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		int	pID,
		ShowerStruct3D &	ss3,
		bool	doUpdate,
		bool	prt
	)

bool tca::RemovePFP	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		PFPStruct &	pfp,
		ShowerStruct3D &	ss3,
		bool	doUpdate,
		bool	prt
	)

Definition at line 1547 of file TCShower.cxx.

References tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, tca::PFPStruct::ID, tca::ShowerStruct3D::ID, tca::ShowerStruct3D::NeedsUpdate, RemoveTj(), ss, tca::PFPStruct::TjIDs, and UpdateShower().

Referenced by Reconcile3D().

   {
     // removes the tjs in the pfp from the ss3 2D showers and optionally update. This function only returns
     // false if there was a failure. The absence of any pfp Tjs in ss3 is not considered a failure
 
     if(pfp.ID == 0 || ss3.ID == 0) return false;
 
     std::string fcnLabel = inFcnLabel + ".RemP";
     for(auto tid : pfp.TjIDs) {
       for(auto cid : ss3.CotIDs) {
         auto& ss = tjs.cots[cid - 1];
         if(std::find(ss.TjIDs.begin(), ss.TjIDs.end(), tid) == ss.TjIDs.end()) continue;
         if(!RemoveTj(fcnLabel, tjs, tid, ss, doUpdate, prt)) return false;
         ss3.NeedsUpdate = true;
       } // cid
     } // ptid
     
     if(doUpdate && ss3.NeedsUpdate) UpdateShower(fcnLabel, tjs, ss3, prt);
     return true;
     
   } // Remove PFP

bool tca::RemoveTj	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		int	TjID,
		ShowerStruct &	ss,
		bool	doUpdate,
		bool	prt
	)

Definition at line 1691 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::ShowerStruct::ID, kShwrParent, MakeShowerObsolete(), tca::ShowerStruct::NeedsUpdate, tca::ShowerStruct::ParentID, tca::ShowerStruct::ShPts, tca::Trajectory::SSID, tca::ShowerStruct::TjIDs, and UpdateShower().

Referenced by RemovePFP().

   {
     // Removes the Tj from a shower
     
     if(TjID > (int)tjs.allTraj.size()) return false;
     
     std::string fcnLabel = inFcnLabel + ".RTj";
     
     // make sure it isn't already in a shower
     Trajectory& tj = tjs.allTraj[TjID - 1];
 
     if(tj.SSID != ss.ID) {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Can't Remove T"<<TjID<<" from 2S"<<ss.ID<<" because it's not in this shower";
       // This isn't a failure
       return true;
     }
     tj.AlgMod[kShwrParent] = false;
     
     bool gotit = false;
     for(unsigned short ii = 0; ii < ss.TjIDs.size(); ++ii) {
       if(TjID == ss.TjIDs[ii]) {
         ss.TjIDs.erase(ss.TjIDs.begin() + ii);
         gotit = true;
         break;
       }
     } // ii
     if(!gotit) return false;
     tj.SSID = 0;
     // Removing a parent Tj?
     if(TjID == ss.ParentID) ss.ParentID = 0;
     // re-build everything?
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Remove T"<<TjID<<" from 2S"<<ss.ID;
     // removed the only tj
     if(ss.TjIDs.empty()) {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Removed the last Tj. Killing 2S"<<ss.ID;
       MakeShowerObsolete(fcnLabel, tjs, ss, prt);
       return true;
     }
     // clear out the shower points to force a complete update when UpdateShower is next called
     ss.ShPts.clear();
     if(doUpdate) {
       ss.NeedsUpdate = true;
       return UpdateShower(fcnLabel, tjs, ss, prt);
     }
     return true;
   } // RemoveTj

void tca::RestoreObsoleteTrajectory	(	TjStuff &	tjs,
		unsigned int	itj
	)

Definition at line 1808 of file Utils.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::fHits, and kKilled.

   {
     if(itj > tjs.allTraj.size() - 1) return;
     if(!tjs.allTraj[itj].AlgMod[kKilled]) {
       mf::LogWarning("TC")<<"RestoreObsoleteTrajectory: Trying to restore not-obsolete trajectory "<<tjs.allTraj[itj].ID;
       return;
     }
     unsigned int iht;
     for(auto& tp : tjs.allTraj[itj].Pts) {
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         if(tp.UseHit[ii]) {
           iht = tp.Hits[ii];
           if(tjs.fHits[iht].InTraj == 0) {
             tjs.fHits[iht].InTraj = tjs.allTraj[itj].ID;
           }
         }
       } // ii
     } // tp
     tjs.allTraj[itj].AlgMod[kKilled] = false;
   } // RestoreObsoleteTrajectory

void tca::Reverse3DMatchTjs	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 996 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::PFPStruct::dEdx, tca::PFPStruct::dEdxErr, tca::PFPStruct::Dir, tca::PFPStruct::DirErr, kBragg, kMat3D, tca::PFPStruct::PDGCode, ReverseTraj(), tca::PFPStruct::TjIDs, tca::PFPStruct::Vx3ID, and tca::PFPStruct::XYZ.

   {
     // Return true if the 3D matched hits in the trajectories in tjs.pfps are in the wrong order in terms of the
     // physics standpoint, e.g. dQ/dx, muon delta-ray tag, cosmic rays entering the detector, etc. 
     
     // Don't reverse showers
     if(pfp.PDGCode == 1111) return;
     
     bool reverseMe = false;
 
     // look for stopping Tjs for contained PFParticles
     if(!reverseMe) {
       unsigned short braggCnt0 = 0;
       unsigned short braggCnt1 = 0;
       for(auto& tjID : pfp.TjIDs) {
         auto& tj = tjs.allTraj[tjID - 1];
         if(tj.StopFlag[0][kBragg]) ++braggCnt0;
         if(tj.StopFlag[1][kBragg]) ++braggCnt1;
       }
       if(braggCnt0 > 0 || braggCnt1 > 0) {
         pfp.PDGCode = 2212;
         // Vote for a Bragg peak at the beginning. It should be at the end
         if(braggCnt0 > braggCnt1) reverseMe = true;
       } // found a Bragg Peak 
     } // look for stopping Tjs 
     
     if(!reverseMe) return;
     
     // All of the trajectories should be reversed
     for(auto& tjID : pfp.TjIDs) {
       unsigned short itj = tjID - 1;
       Trajectory& tj = tjs.allTraj[itj];
       tj.AlgMod[kMat3D] = false;
       ReverseTraj(tjs, tj);
       tj.AlgMod[kMat3D] = true;
     } // tjID
     // swap the matchVec end info also
     std::swap(pfp.XYZ[0], pfp.XYZ[1]);
     std::swap(pfp.Dir[0], pfp.Dir[1]);
     std::swap(pfp.DirErr[0], pfp.DirErr[1]);
     std::swap(pfp.dEdx[0], pfp.dEdx[1]);
     std::swap(pfp.dEdxErr[0], pfp.dEdxErr[1]);
     std::swap(pfp.Vx3ID[0], pfp.Vx3ID[1]);
     
     return;
     
   } // Reverse3DMatchTjs

void tca::ReversePFP	(	TjStuff &	tjs,
		PFPStruct &	pfp
	)

Definition at line 2837 of file PFPUtils.cxx.

References tca::PFPStruct::dEdx, tca::PFPStruct::dEdxErr, tca::PFPStruct::Dir, tca::PFPStruct::DirErr, tca::PFPStruct::StopFlag, tca::PFPStruct::Tp3s, tca::PFPStruct::Vx3ID, and tca::PFPStruct::XYZ.

Referenced by DotProd().

   {
     std::swap(pfp.XYZ[0], pfp.XYZ[1]);
     std::swap(pfp.Dir[0], pfp.Dir[1]);
     for(unsigned short xyz = 0; xyz < 3; ++xyz) {
       pfp.Dir[0][xyz] *= -1;
       pfp.Dir[1][xyz] *= -1;
     }
     std::swap(pfp.DirErr[0], pfp.DirErr[1]);
     std::swap(pfp.dEdx[0], pfp.dEdx[1]);
     std::swap(pfp.dEdxErr[0], pfp.dEdxErr[1]);
     std::swap(pfp.Vx3ID[0], pfp.Vx3ID[1]);
     std::swap(pfp.StopFlag[0], pfp.StopFlag[1]);
     std::reverse(pfp.Tp3s.begin(), pfp.Tp3s.end());
     for(auto& tp3 : pfp.Tp3s) {
       for(unsigned short xyz = 0; xyz < 3; ++xyz) {
         tp3.Dir[xyz] *= -1;
         tp3.Dir[xyz] *= -1;
       } // xyz
     } // tp3
   } // ReversePFP

void tca::ReverseShower	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3269 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::ShowerStruct::Angle, DefineEnvelope(), tca::ShowerStruct::DirectionFOM, tca::ShowerStruct::ID, ReverseTraj(), tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::ShPts, and tca::ShowerStruct::TjIDs.

   {
     // Reverses the shower and the shower tj
     
     if(ss.ID == 0) return;
     if(ss.TjIDs.empty()) return;
     
     std::string fcnLabel = inFcnLabel + ".RevSh";
     
     std::reverse(ss.ShPts.begin(), ss.ShPts.end());
     // change the sign of RotPos
     for(auto& sspt : ss.ShPts) {
       sspt.RotPos[0] = -sspt.RotPos[0];
       sspt.RotPos[1] = -sspt.RotPos[1];
     }
     // flip the shower angle
     if(ss.Angle > 0) {
       ss.Angle -= M_PI;
     } else {
       ss.Angle += M_PI;
     }
     if(ss.DirectionFOM != 0) ss.DirectionFOM = 1 / ss.DirectionFOM;
     auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
     ReverseTraj(tjs, stj);
     DefineEnvelope(fcnLabel, tjs, ss, prt);
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Reversed shower. Shower angle = "<<ss.Angle;
   } // ReverseShower

void tca::ReverseShower	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		int	cotID,
		bool	prt
	)

Definition at line 3298 of file TCShower.cxx.

References tca::TjStuff::cots, tca::ShowerStruct::ID, and ss.

Referenced by FindShowerStart(), and UpdateShower().

   {
     // Reverses the shower and the shower tj
     
     if(cotID > (int)tjs.cots.size()) return;
     ShowerStruct& ss = tjs.cots[cotID - 1];
     if(ss.ID == 0) return;
     ReverseShower(inFcnLabel, tjs, ss, prt);
 
   }

void tca::ReverseTraj	(	TjStuff &	tjs,
		Trajectory &	tj
	)

Definition at line 2666 of file Utils.cxx.

References tca::Trajectory::dEdx, tca::Trajectory::DirFOM, tca::Trajectory::ID, tca::Trajectory::Pts, SetEndPoints(), tca::Trajectory::StepDir, tca::Trajectory::StopFlag, UpdateMatchStructs(), and tca::Trajectory::VtxID.

Referenced by DefineTjParents(), tca::TrajClusterAlg::EndMerge(), MergeAndStore(), MergePFPTjs(), tca::TrajClusterAlg::ReconstructAllTraj(), Reverse3DMatchTjs(), tca::TrajClusterAlg::ReversePropagate(), ReverseShower(), StorePFP(), TagDeltaRays(), and TagMuonDirections().

   {
     // reverse the trajectory
     if(tj.Pts.empty()) return;
 /*
     if(tj.AlgMod[kMat3D]) {
       std::cout<<"Trying to reverse 3D matched Tj "<<tj.ID<<". Need to modify other Tjs and the MatchStruct\n";
       return;
     }
     if(tj.AlgMod[kSetDir]) {
       std::cout<<"Trying to reverse Tj "<<tj.ID<<" whose direction has been set. Not doing it.\n";
       return;
     }
 */
     // reverse the crawling direction flag
     tj.StepDir = -tj.StepDir;
     tj.DirFOM = 1 - tj.DirFOM;
     // Vertices
     std::swap(tj.VtxID[0], tj.VtxID[1]);
     // trajectory points
     std::reverse(tj.Pts.begin(), tj.Pts.end());
     // reverse the stop flag
     std::reverse(tj.StopFlag.begin(), tj.StopFlag.end());
     std::swap(tj.dEdx[0], tj.dEdx[1]);
     // reverse the direction vector on all points
     for(unsigned short ipt = 0; ipt < tj.Pts.size(); ++ipt) {
       if(tj.Pts[ipt].Dir[0] != 0) tj.Pts[ipt].Dir[0] = -tj.Pts[ipt].Dir[0];
       if(tj.Pts[ipt].Dir[1] != 0) tj.Pts[ipt].Dir[1] = -tj.Pts[ipt].Dir[1];
       if(tj.Pts[ipt].Ang > 0) {
         tj.Pts[ipt].Ang -= M_PI;
       } else {
         tj.Pts[ipt].Ang += M_PI;
       }
     } // ipt
     SetEndPoints(tjs, tj);
     UpdateMatchStructs(tjs, tj.ID, tj.ID);
   } // ReverseTraj

void tca::SaveAllCots	(	TjStuff &	tjs,
		const CTP_t &	inCTP,
		std::string	someText
	)

Definition at line 165 of file TCShTree.cxx.

References tca::TjStuff::cots, tca::TjStuff::SaveShowerTree, SaveTjInfo(), and ss.

Referenced by FindShowers3D().

                                                                          {
     if(!tjs.SaveShowerTree) return;
     for(unsigned short cotIndex = 0; cotIndex < tjs.cots.size(); ++cotIndex) {
       auto& ss = tjs.cots[cotIndex];
       if (ss.CTP != inCTP) continue;
       if(ss.ID == 0) continue;
       SaveTjInfo(tjs, ss, someText);
     } // cotIndex
   } // SaveAllCots

void tca::SaveAllCots	(	TjStuff &	tjs,
		std::string	someText
	)

Definition at line 176 of file TCShTree.cxx.

References tca::TjStuff::cots, tca::TjStuff::SaveShowerTree, SaveTjInfo(), and ss.

                                                      {
     if(!tjs.SaveShowerTree) return;
     for(unsigned short cotIndex = 0; cotIndex < tjs.cots.size(); ++cotIndex) {
       auto& ss = tjs.cots[cotIndex];
       if(ss.ID == 0) continue;
       SaveTjInfo(tjs, ss, someText);
     } // cotIndex
   }

void tca::SaveCRInfo	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		bool	prt,
		bool	fIsRealData
	)

Definition at line 8 of file TCCR.cxx.

References tca::PFPStruct::CosmicScore, tca::CRTreeVars::cr_origin, tca::CRTreeVars::cr_pfpxmax, tca::CRTreeVars::cr_pfpxmin, tca::CRTreeVars::cr_pfpyzmindis, tca::TjStuff::crt, tca::TjStuff::geom, GetOrigin(), max, geo::BoxBoundedGeo::MaxY(), geo::BoxBoundedGeo::MaxZ(), min, geo::BoxBoundedGeo::MinY(), geo::BoxBoundedGeo::MinZ(), tca::TjStuff::SaveCRTree, geo::GeometryCore::TPC(), and tca::PFPStruct::XYZ.

Referenced by tca::TrajClusterAlg::RunTrajClusterAlg().

                                                                            {
 
     //Check the origin of pfp
     if (tjs.SaveCRTree){
       if (fIsRealData){
         tjs.crt.cr_origin.push_back(-1);
       }
       else{
         tjs.crt.cr_origin.push_back(GetOrigin(tjs, pfp));
       }
     }
 
     // save the xmin and xmax of each pfp
     tjs.crt.cr_pfpxmin.push_back(std::min(pfp.XYZ[0][0], pfp.XYZ[1][0]));
     tjs.crt.cr_pfpxmax.push_back(std::max(pfp.XYZ[0][0], pfp.XYZ[1][0]));
 
     //find max 
     const geo::TPCGeo &tpc = tjs.geom->TPC(0);
     float mindis0 = FLT_MAX;
     float mindis1 = FLT_MAX;
     if (std::abs(pfp.XYZ[0][1] - tpc.MinY())<mindis0) mindis0 = std::abs(pfp.XYZ[0][1] - tpc.MinY());
     if (std::abs(pfp.XYZ[0][1] - tpc.MaxY())<mindis0) mindis0 = std::abs(pfp.XYZ[0][1] - tpc.MaxY());
     if (std::abs(pfp.XYZ[0][2] - tpc.MinZ())<mindis0) mindis0 = std::abs(pfp.XYZ[0][2] - tpc.MinZ());
     if (std::abs(pfp.XYZ[0][2] - tpc.MaxZ())<mindis0) mindis0 = std::abs(pfp.XYZ[0][2] - tpc.MaxZ());
     if (std::abs(pfp.XYZ[1][1] - tpc.MinY())<mindis1) mindis1 = std::abs(pfp.XYZ[1][1] - tpc.MinY());
     if (std::abs(pfp.XYZ[1][1] - tpc.MaxY())<mindis1) mindis1 = std::abs(pfp.XYZ[1][1] - tpc.MaxY());
     if (std::abs(pfp.XYZ[1][2] - tpc.MinZ())<mindis1) mindis1 = std::abs(pfp.XYZ[1][2] - tpc.MinZ());
     if (std::abs(pfp.XYZ[1][2] - tpc.MaxZ())<mindis1) mindis1 = std::abs(pfp.XYZ[1][2] - tpc.MaxZ());
     //std::cout<<pfp.XYZ[0][1]<<" "<<pfp.XYZ[0][2]<<" "<<pfp.XYZ[1][1]<<" "<<pfp.XYZ[1][2]<<" "<<tpc.MinY()<<" "<<tpc.MaxY()<<" "<<tpc.MinZ()<<" "<<tpc.MaxZ()<<" "<<mindis0<<" "<<mindis1<<" "<<mindis0+mindis1<<std::endl;
     tjs.crt.cr_pfpyzmindis.push_back(mindis0+mindis1);
 
     if (tjs.crt.cr_pfpxmin.back()<-2||
         tjs.crt.cr_pfpxmax.back()>260||
         tjs.crt.cr_pfpyzmindis.back()<30){
       pfp.CosmicScore = 1.;
     }
     else pfp.CosmicScore = 0;
 
     /*
     float minx = FLT_MAX;
     float maxx = FLT_MIN;
 
     for(auto& tjID : pfp.TjIDs) {
       Trajectory& tj = tjs.allTraj[tjID - 1];
       TrajPoint& beginPoint = tj.Pts[tj.EndPt[0]];
       TrajPoint& endPoint = tj.Pts[tj.EndPt[1]];
       if (beginPoint.Pos[1]/tjs.UnitsPerTick<minx){
         minx = beginPoint.Pos[1]/tjs.UnitsPerTick;
       }
       if (beginPoint.Pos[1]/tjs.UnitsPerTick>maxx){
         maxx = beginPoint.Pos[1]/tjs.UnitsPerTick;
       }
       if (endPoint.Pos[1]/tjs.UnitsPerTick<minx){
         minx = endPoint.Pos[1]/tjs.UnitsPerTick;
       }
       if (endPoint.Pos[1]/tjs.UnitsPerTick>maxx){
         maxx = endPoint.Pos[1]/tjs.UnitsPerTick;
       }
     } // tjID
 
     tjs.crt.cr_pfpmintick.push_back(minx);
     tjs.crt.cr_pfpmaxtick.push_back(maxx);
     */
 //    std::cout<<pfp.MCPartListIndex<<std::endl;
 //    std::cout<<pfp.XYZ[0][0]<<" "<<pfp.XYZ[1][0]<<std::endl;
 
   }

void tca::SaveTjInfo	(	TjStuff &	tjs,
		std::vector< std::vector< int >> &	tjList,
		std::string	stageName
	)

Definition at line 5 of file TCShTree.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::Trajectory::CTP, tca::ShowerTreeVars::Envelope, tca::ShowerTreeVars::EnvPlane, tca::ShowerTreeVars::EnvShowerID, tca::ShowerTreeVars::EnvStage, GetStageNum(), tca::Trajectory::ID, kKilled, tca::TjStuff::SaveShowerTree, SaveTjInfoStuff(), tca::ShowerTreeVars::ShowerID, and tca::TjStuff::stv.

Referenced by FindShowers3D(), and SaveAllCots().

                                        {
     if(!tjs.SaveShowerTree) return;
     if(tjList.empty()) return;
     int stageNum = GetStageNum(tjs.stv, stageName);
 
     // get the CTP from the first tj
     CTP_t inCTP = tjs.allTraj[tjList[0][0] - 1].CTP;
     for(unsigned short it1 = 0; it1 < tjs.allTraj.size(); ++it1) {
       Trajectory& tj1 = tjs.allTraj[it1];
       if(tj1.CTP != inCTP) continue;
       if(tj1.AlgMod[kKilled]) continue;
 
       SaveTjInfoStuff(tjs, tj1,  stageNum, stageName);
 
       int trajID = tj1.ID;
       bool inShower = false;
 
       for (size_t l1 = 0; l1 < tjList.size(); ++l1) {
         if (inShower) break;
         for (size_t l2 = 0; l2 < tjList[l1].size(); ++l2) {
 
           if (trajID == tjList[l1][l2]) {
             tjs.stv.ShowerID.back() = l1;
             inShower = true;
             break;
           }
         } // end list loop 2 
       } // end list loop 1
     } // end tjs loop
     // add meaningless envelope to list for counting purposes
     // envelopes are defined once DefineShower is called
     // fill four times, one for each side of polygon
     for (int i = 0; i < 8; i++) {
       tjs.stv.Envelope.push_back(-999);
       tjs.stv.EnvStage.push_back(stageNum);
       tjs.stv.EnvPlane.push_back(-1);
       tjs.stv.EnvShowerID.push_back(-1);
     }
 
   } // SaveTjInfo (tjlist) 

void tca::SaveTjInfo	(	TjStuff &	tjs,
		const ShowerStruct &	ss,
		std::string	stageName
	)

Definition at line 47 of file TCShTree.cxx.

                                                                              {
     if(!tjs.SaveShowerTree) return;
     int stageNum = GetStageNum(tjs.stv, stageName);
 
     // killed shower?
     if(ss.ID == 0) return;
 
     bool noMatch = true;
 
     for(unsigned short it1 = 0; it1 < tjs.allTraj.size(); ++it1) {
 
       Trajectory& tj1 = tjs.allTraj[it1];
 
       if(tj1.AlgMod[kKilled]) continue;
 
       int trajID = tj1.ID;
 
       // check if this tj has already been added to the list
       // for this particular stage and plane
       int tjIndex = -1;
       bool isShowerTj = false;
       for (size_t i = 0; i < tjs.stv.TjID.size(); ++i) {
         if (tjs.stv.StageNum.at(i) != (int)stageNum) continue;
         if (tjs.stv.PlaneNum.at(i) != (short)DecodeCTP(ss.CTP).Plane) continue;
         
         if (tjs.stv.TjID.at(i) == trajID) {
           tjIndex = i;
           if (tjs.stv.IsShowerTj.at(tjIndex) == 1) isShowerTj = true;
           //beenDoneBefore = true;
           break;
         }
       }
 
       if (isShowerTj) continue;
       if (tjIndex == -1) SaveTjInfoStuff(tjs, tj1, stageNum, stageName);
 
       for (size_t i = 0; i < ss.TjIDs.size(); ++i) {
         if (trajID == ss.TjIDs[i]) {
           noMatch = false;
           if (tjIndex == -1) tjs.stv.ShowerID.back() = ss.ID;
           else tjs.stv.ShowerID.at(tjIndex) = ss.ID;
         }
         
         if (it1 == (ss.ShowerTjID - 1)) tjs.stv.IsShowerTj.back() = 1;
         else if (tj1.AlgMod[kShowerTj]) tjs.stv.IsShowerTj.back() = 1; // this is a better check
         // check if tj is shower parent. if so, add to ttree
         // and mark parent flag 
         if (trajID == ss.ParentID) {
           if (tjIndex == -1) {
             tjs.stv.ShowerID.back() = ss.ID;
             tjs.stv.IsShowerParent.back() = 1;
           }
           else {
             tjs.stv.ShowerID.at(tjIndex) = ss.ID;
             tjs.stv.IsShowerParent.at(tjIndex) = 1;
           }
           break;
           
         }
       } // ss TjID loop
     } // end tjs loop
     
     if (noMatch) return;
 
     // add envelope information to showertreevars 
     geo::PlaneID iPlnID = DecodeCTP(ss.CTP);
 
     for (int i = 0; i < 8; i++) {
       tjs.stv.EnvStage.push_back(stageNum);
       tjs.stv.EnvPlane.push_back(iPlnID.Plane);
       tjs.stv.EnvShowerID.push_back(ss.ID);
     }
 
     tjs.stv.Envelope.push_back(ss.Envelope[0][0]);
     tjs.stv.Envelope.push_back(ss.Envelope[0][1]/tjs.UnitsPerTick);
     tjs.stv.Envelope.push_back(ss.Envelope[1][0]);
     tjs.stv.Envelope.push_back(ss.Envelope[1][1]/tjs.UnitsPerTick);
     tjs.stv.Envelope.push_back(ss.Envelope[2][0]);
     tjs.stv.Envelope.push_back(ss.Envelope[2][1]/tjs.UnitsPerTick);
     tjs.stv.Envelope.push_back(ss.Envelope[3][0]);
     tjs.stv.Envelope.push_back(ss.Envelope[3][1]/tjs.UnitsPerTick);
 
   } // SaveTjInfo (cots)

void tca::SaveTjInfoStuff	(	TjStuff &	tjs,
		Trajectory &	tj,
		int	stageNum,
		std::string	stageName
	)

Definition at line 131 of file TCShTree.cxx.

Referenced by SaveTjInfo().

                                                                                         {
     if(!tjs.SaveShowerTree) return;
 
     TrajPoint& beginPoint = tj.Pts[tj.EndPt[0]];
     TrajPoint& endPoint = tj.Pts[tj.EndPt[1]];
 
     tjs.stv.BeginWir.push_back(std::nearbyint(beginPoint.Pos[0]));
     tjs.stv.BeginTim.push_back(std::nearbyint(beginPoint.Pos[1]/tjs.UnitsPerTick));
     tjs.stv.BeginAng.push_back(beginPoint.Ang);
     tjs.stv.BeginChg.push_back(beginPoint.Chg);
     tjs.stv.BeginVtx.push_back(tj.VtxID[0]);
 
     tjs.stv.EndWir.push_back(std::nearbyint(endPoint.Pos[0]));
     tjs.stv.EndTim.push_back(std::nearbyint(endPoint.Pos[1]/tjs.UnitsPerTick));
     tjs.stv.EndAng.push_back(endPoint.Ang);
     tjs.stv.EndChg.push_back(endPoint.Chg);
     tjs.stv.EndVtx.push_back(tj.VtxID[1]);
 
     tjs.stv.MCSMom.push_back(tj.MCSMom);
     tjs.stv.TjID.push_back(tj.ID);
     tjs.stv.IsShowerTj.push_back(-1);
 
     tjs.stv.ShowerID.push_back(-1);
     tjs.stv.IsShowerParent.push_back(-1);
     tjs.stv.StageNum.push_back(stageNum);
     tjs.stv.nStages = stageNum;
     geo::PlaneID iPlnID = DecodeCTP(tj.CTP);
     tjs.stv.PlaneNum.push_back(iPlnID.Plane);
 
     tjs.stv.nPlanes = tjs.NumPlanes;
 
   } // SaveTjInfoStuff  

void tca::ScoreVertices	(	TjStuff &	tjs,
		const geo::TPCID &	tpcid,
		bool	prt
	)

Definition at line 2193 of file TCVertex.cxx.

References tca::TjStuff::allTraj, geo::CryostatID::Cryostat, DecodeCTP(), kHiVx3Score, kKilled, kTjHiVx3Score, SetVx2Score(), SetVx3Score(), geo::TPCID::TPC, tca::TjStuff::vtx, and tca::TjStuff::vtx3.

Referenced by tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // reset all 3D vertex, 2D vertex and Tj high-score vertex bits in tpcid 
     
     unsigned int cstat = tpcid.Cryostat;
     unsigned int tpc = tpcid.TPC;
     
     // reset the 2D vertex status bits
     for(auto& vx : tjs.vtx) {
       if(vx.ID == 0) continue;
       geo::PlaneID planeID = DecodeCTP(vx.CTP);
       if(planeID.Cryostat != cstat) continue;
       if(planeID.TPC != tpc) continue;
       vx.Stat[kHiVx3Score] = false;
     } // vx
     // and the tj bits
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       geo::PlaneID planeID = DecodeCTP(tj.CTP);
       if(planeID.Cryostat != cstat) continue;
       if(planeID.TPC != tpc) continue;
       tj.AlgMod[kTjHiVx3Score] = false;
     } // tj
     // Score the 2D vertices
     for(auto& vx : tjs.vtx) {
       if(vx.ID == 0) continue;
       geo::PlaneID planeID = DecodeCTP(vx.CTP);
       if(planeID.Cryostat != cstat) continue;
       if(planeID.TPC != tpc) continue;
       SetVx2Score(tjs, vx, prt);
     } // vx
     // Score the 3D vertices
     for(auto& vx3 : tjs.vtx3) {
       if(vx3.ID == 0) continue;
       if(vx3.TPCID != tpcid) continue;
        SetVx3Score(tjs, vx3, prt);
     } // vx3
   } // ScoreVertices

void tca::SetAngleCode	(	TjStuff &	tjs,
		TrajPoint &	tp
	)

Definition at line 642 of file Utils.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::AngleCode, AngleRange(), and tca::TjStuff::AngleRanges.

Referenced by FitTraj(), tca::TrajClusterAlg::MakeJunkTraj(), tca::TrajClusterAlg::StartTraj(), and tca::TrajClusterAlg::UpdateTraj().

   {
     unsigned short ar = AngleRange(tjs, tp.Ang);
     if(ar == tjs.AngleRanges.size() - 1) {
       // Very large angle
       tp.AngleCode = 2;
     } else if(tjs.AngleRanges.size() > 2 && ar == tjs.AngleRanges.size() - 2) {
       // Large angle
       tp.AngleCode = 1;
     } else {
       // Small angle
       tp.AngleCode = 0;
     }
     
   } // SetAngleCode

template<typename T >

std::vector< T > tca::SetDifference	(	const std::vector< T > &	set1,
		const std::vector< T > &	set2
	)

Definition at line 236 of file Utils.h.

Referenced by DefinePFPParentsTestBeam(), DotProd(), Match3DVtxTjs(), and Reconcile3D().

   {
     // returns the elements of set1 and set2 that are different
     std::vector<T> different;
     if(set1.empty() && set2.empty()) return different;
     if(!set1.empty() && set2.empty()) return set1;
     if(set1.empty() && !set2.empty()) return set2;
     for(auto element1 : set1) {
       // check for a common element
       if(std::find(set2.begin(), set2.end(), element1) != set2.end()) continue;
       // check for a duplicate
       if(std::find(different.begin(), different.end(), element1) != different.end()) continue;
       different.push_back(element1);
     } // element1
     for(auto element2 : set2) {
       // check for a common element
       if(std::find(set1.begin(), set1.end(), element2) != set1.end()) continue;
       // check for a duplicate
       if(std::find(different.begin(), different.end(), element2) != different.end()) continue;
       different.push_back(element2);
     } // element1
     return different;
   } // SetDifference

void tca::SetEndPoints	(	TjStuff &	tjs,
		Trajectory &	tj
	)

Definition at line 2788 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::EndPt, kShowerTj, and tca::Trajectory::Pts.

   {
     // Find the first (last) TPs, EndPt[0] (EndPt[1], that have charge
     
     // don't mess with showerTjs
     if(tj.AlgMod[kShowerTj]) return;
     tj.EndPt[0] = 0; tj.EndPt[1] = 0;
     if(tj.Pts.size() == 0) return;
     
     // check the end point pointers
     for(unsigned short ipt = 0; ipt < tj.Pts.size(); ++ipt) {
       if(tj.Pts[ipt].Chg != 0) {
         tj.EndPt[0] = ipt;
         break;
       }
     }
     for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
       unsigned short ipt = tj.Pts.size() - 1 - ii;
       if(tj.Pts[ipt].Chg != 0) {
         tj.EndPt[1] = ipt;
         break;
       }
     }
   } // SetEndPoints

void tca::SetHighScoreBits	(	TjStuff &	tjs,
		Vtx3Store &	vx3
	)

Definition at line 2256 of file TCVertex.cxx.

References tca::TjStuff::allTraj, evd::details::end(), GetVtxTjIDs(), tca::VtxStore::ID, tca::Vtx3Store::ID, kHiVx3Score, kTjHiVx3Score, tca::TjStuff::NumPlanes, tca::VtxStore::Stat, tmp, tca::TjStuff::vtx, and tca::Vtx3Store::Vx2ID.

Referenced by SetVx3Score().

   {
     // Sets the tj and 2D vertex score bits to true 
     
     if(vx3.ID == 0) return;
     
     for(unsigned short ipl = 0; ipl < tjs.NumPlanes; ++ipl) {
       if(vx3.Vx2ID[ipl] <= 0) continue;
       VtxStore& vx2 = tjs.vtx[vx3.Vx2ID[ipl] - 1];
       vx2.Stat[kHiVx3Score] = false;
       // transfer this to all attached tjs and vertices attached to those tjs
       std::vector<int> tjlist = GetVtxTjIDs(tjs, vx2);
       std::vector<int> vxlist;
       while(true) {
         // tag Tjs and make a list of attached vertices whose high-score
         // bit needs to be set
         vxlist.clear();
         for(auto tjid : tjlist) {
           auto& tj = tjs.allTraj[tjid - 1];
           tj.AlgMod[kTjHiVx3Score] = true;
           for(unsigned short end = 0; end < 2; ++end) {
             if(tj.VtxID[end] == 0) continue;
             auto& vx2 = tjs.vtx[tj.VtxID[end] - 1];
             if(vx2.Stat[kHiVx3Score]) continue;
             vx2.Stat[kHiVx3Score] = true;
             vxlist.push_back(vx2.ID);
           } // end
         } // tjid
 
         if(vxlist.empty()) break;
         // re-build tjlist using vxlist
         std::vector<int> newtjlist;
         for(auto vxid : vxlist) {
           auto& vx2 = tjs.vtx[vxid - 1];
           auto tmp = GetVtxTjIDs(tjs, vx2);
           for(auto tjid : tmp) {
             if(std::find(tjlist.begin(), tjlist.end(), tjid) == tjlist.end()) newtjlist.push_back(tjid);
           } // tjid
         } // vxid
         if(newtjlist.empty()) break;
         tjlist = newtjlist;
       } // true
     } // ipl
 
   } // SetHighScoreBits

template<typename T >

std::vector< T > tca::SetIntersection	(	const std::vector< T > &	set1,
		const std::vector< T > &	set2
	)

Definition at line 214 of file Utils.h.

Referenced by AddMissedTj(), CompleteIncompleteShower(), DefinePFP(), DotProd(), FindCots(), FindPFParticles(), GetAssns(), Match3DVtxTjs(), tca::TruthMatcher::MatchAndSum(), MergeNearby2DShowers(), PFPVxTjOK(), tca::MCParticleListUtils::PrimaryElectronPFPID(), Reconcile3D(), and SharesHighScoreVx().

   {
     // returns a vector containing the elements of set1 and set2 that are common. This function
     // is a replacement for std::set_intersection which fails in the following situation:
     // set1 = {11 12 17 18} and set2 = {6 12 18}
     // There is no requirement that the elements be sorted, unlike std::set_intersection
     std::vector<T> shared;
     
     if(set1.empty()) return shared;
     if(set2.empty()) return shared;
     for(auto element1 : set1) {
       // check for a common element
       if(std::find(set2.begin(), set2.end(), element1) == set2.end()) continue;
       // check for a duplicate
       if(std::find(shared.begin(), shared.end(), element1) != shared.end()) continue;
       shared.push_back(element1);
     } // element1
     return shared;
   } // SetIntersection

bool tca::SetMag	(	Vector3_t &	v1,
		double	mag
	)

Definition at line 1641 of file PFPUtils.cxx.

References den.

Referenced by DotProd(), FindAlongTrans(), Fit3D(), FollowTp3s(), tca::MCParticleListUtils::MakeTruTrajPoint(), tca::TruthMatcher::MatchTrueHits(), tca::TruthMatcher::MatchTruth(), PointDirection(), tca::MCParticleListUtils::PrimaryElectronStart(), tca::TruthMatcher::StudyPiZeros(), and UpdateShower().

   {
     double den = v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2];
     if(den == 0) return false;
     den = sqrt(den);
     
     v1[0] *= mag / den;
     v1[1] *= mag / den;
     v1[2] *= mag / den;
     return true;
   } // SetMag

bool tca::SetMag	(	Vector2_t &	v1,
		double	mag
	)

Definition at line 2729 of file Utils.cxx.

References den.

Referenced by FindAlongTrans().

   {
     double den = v1[0] * v1[0] + v1[1] * v1[1];
     if(den == 0) return false;
     den = sqrt(den);
     
     v1[0] *= mag / den;
     v1[1] *= mag / den;
     return true;
   } // SetMag

bool tca::SetParent	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		PFPStruct &	pfp,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 1988 of file TCShower.cxx.

References AddTj(), tca::TjStuff::allTraj, tca::ShowerStruct3D::ChgPos, tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, tca::PFPStruct::Dir, evd::details::end(), FarEnd(), GetAssns(), tca::PFPStruct::ID, tca::ShowerStruct3D::ID, kShwrParent, MakeBareTP(), ParentFOM(), tca::ShowerStruct3D::ParentID, ss, tca::PFPStruct::TjIDs, UpdateShower(), tca::TjStuff::vtx3, tca::PFPStruct::Vx3ID, tca::ShowerStruct3D::Vx3ID, and tca::PFPStruct::XYZ.

Referenced by FindParent().

   {
     // set the pfp as the parent of ss3. The calling function should do the error recovery
     if(pfp.ID == 0 || ss3.ID == 0) return false;
     if(ss3.CotIDs.empty()) return false;
     
     std::string fcnLabel = inFcnLabel + ".SP";
     
     for(auto cid : ss3.CotIDs) {
       auto& ss = tjs.cots[cid - 1];
       auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
       stj.VtxID[0] = 0;
       if(ss.ParentID > 0) {
         auto& oldParent = tjs.allTraj[ss.ParentID - 1];
         oldParent.AlgMod[kShwrParent] = false;
         ss.ParentID = 0;
         ss.ParentFOM = 10;
       } // remove old parents
       // add new parents
       for(auto tjid : pfp.TjIDs) {
         auto& tj = tjs.allTraj[tjid - 1];
         if(tj.CTP != ss.CTP) continue;
         if(std::find(ss.TjIDs.begin(), ss.TjIDs.end(), tjid) == ss.TjIDs.end()) {
           // Add the tj but don't update yet
           if(!AddTj(fcnLabel, tjs, tjid, ss, false, prt)) return false;
         } // parent not in ss
         // Don't define it to be the parent if it is short and the pfp projection in this plane is low 
         unsigned short pEnd = FarEnd(tjs, pfp, ss3.ChgPos);
         auto tp = MakeBareTP(tjs, pfp.XYZ[0], pfp.Dir[pEnd], tj.CTP);
         unsigned short npts = tj.EndPt[1] - tj.EndPt[0] + 1;
         if(tp.Delta > 0.5 || npts > 20) {
           if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" parent P"<<pfp.ID<<" -> T"<<tjid<<" -> 2S"<<ss.ID<<" parent";
         } else {
           if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" parent P"<<pfp.ID<<" -> T"<<tjid<<" low projection in plane "<<tp.Delta<<". Not a parent";
           continue;
         }
         ss.ParentID = tjid;
         ss.NeedsUpdate = true;
         // set the ss start vertex
         if(ss3.Vx3ID > 0) {
           auto& vx3 = tjs.vtx3[ss3.Vx3ID - 1];
           auto v2list = GetAssns(tjs, "3V", vx3.ID, "2V");
           for(unsigned short end = 0; end < 2; ++end) {
             if(tj.VtxID[end] <= 0) continue;
             if(std::find(v2list.begin(), v2list.end(), tj.VtxID[end]) != v2list.end()) stj.VtxID[0] = tj.VtxID[end];
           } // end
         } // ss3.Vx3ID > 0
         // and update
         if(!UpdateShower(fcnLabel, tjs, ss, prt)) return false;
       } // tjid
     } // cid
     ss3.ParentID = pfp.ID;
     
     unsigned short pEnd = FarEnd(tjs, pfp, ss3.ChgPos);
     ss3.Vx3ID = pfp.Vx3ID[pEnd];
     float fom3D = ParentFOM(fcnLabel, tjs, pfp, pEnd, ss3, prt);
     for(auto cid : ss3.CotIDs) tjs.cots[cid - 1].ParentFOM = fom3D;
 
     return true;
   } // SetParent

void tca::SetPDGCode	(	TjStuff &	tjs,
		unsigned short	itj
	)

Definition at line 3697 of file Utils.cxx.

References tca::TjStuff::allTraj, and SetPDGCode().

Referenced by CompleteIncomplete3DVertices(), DotProd(), FindHammerVertices(), FindHammerVertices2(), MergePFPTjs(), and tca::TrajClusterAlg::StepCrawl().

   {
     if(itj > tjs.allTraj.size() - 1) return;
     SetPDGCode(tjs, tjs.allTraj[itj]);
   }

void tca::SetPDGCode	(	TjStuff &	tjs,
		Trajectory &	tj
	)

Definition at line 3704 of file Utils.cxx.

References tca::Trajectory::EndPt, tca::Trajectory::MCSMom, MCSMom(), tca::TjStuff::MuonTag, and tca::Trajectory::PDGCode.

Referenced by MergeAndStore(), SetPDGCode(), and SplitTraj().

   {
     // Sets the PDG code for the supplied trajectory. Note that the existing
     // PDG code is left unchanged if these cuts are not met
     
     tj.MCSMom = MCSMom(tjs, tj);
     if(tjs.MuonTag[0] <= 0) return;
     // Special handling of very long straight trajectories, e.g. uB cosmic rays
     unsigned short npts = tj.EndPt[1] - tj.EndPt[0];
     bool isAMuon = (npts > (unsigned short)tjs.MuonTag[0] && tj.MCSMom > tjs.MuonTag[1]);
     // anything really really long must be a muon
     if(npts > 500) isAMuon = true;
     if(isAMuon) tj.PDGCode = 13;
     
   } // SetPDGCode

bool tca::SetStart	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 207 of file PFPUtils.cxx.

References tca::PFPStruct::Dir, tca::PFPStruct::ID, PrintTp3(), tca::PFPStruct::TjIDs, tca::PFPStruct::Tp3s, valIncreasings(), and tca::PFPStruct::XYZ.

Referenced by DefinePFP().

   {
     // Analyzes the space point collection and the Tjs in the pfp to find a new start
     // position. The Tp3s found in FindCompleteness are ordered by increasing X. The general direction 
     // pfp.Dir[0] and the average position of all points in Tp3s was stored in pfp.XYZ[0]. This function
     // rotates each tp3 into this coordinate system to determine (along, trans) for each point. The min (max)
     // value of along defines the start (end) of the trajectory.
     
     if(pfp.ID <= 0 || pfp.TjIDs.empty()) return false;
     if(pfp.Tp3s.size() < 2) return false;
 
     // The projection along the general direction relative to the average position was found
     // in FillCompleteness. Now 
     float minAlong = 1E6;
     unsigned short minPt = 0;
     float maxAlong = -1E6;
     unsigned short maxPt = 0;
     std::vector<SortEntry> sortVec(pfp.Tp3s.size());
     for(unsigned short ipt = 0; ipt < pfp.Tp3s.size(); ++ipt) {
       auto& tp3 = pfp.Tp3s[ipt];
       sortVec[ipt].index = ipt;
       sortVec[ipt].val = tp3.AlongTrans[0];
       // find the min (max) 
       if(tp3.AlongTrans[0] < minAlong) {
         minAlong = tp3.AlongTrans[0];
         minPt = ipt;
       }
       if(tp3.AlongTrans[0] > maxAlong) {
         maxAlong = tp3.AlongTrans[0];
         maxPt = ipt;
       }
     } // tp3
     
     pfp.XYZ[0] = pfp.Tp3s[minPt].Pos;
     pfp.XYZ[1] = pfp.Tp3s[maxPt].Pos;
 
     if(prt) {
       mf::LogVerbatim("TC")<<"SNS: P"<<pfp.ID<<" minPt "<<minPt<<" maxPt "<<maxPt<<" dir "<<std::fixed<<std::setprecision(2)<<pfp.Dir[0][0]<<" "<<pfp.Dir[0][1]<<" "<<pfp.Dir[0][2];
       PrintTp3("minPt", tjs, pfp.Tp3s[minPt]);
       PrintTp3("maxPt", tjs, pfp.Tp3s[maxPt]);
     }
     
     std::sort(sortVec.begin(), sortVec.end(), valIncreasings);
     // put them into order
     std::vector<TrajPoint3> temp;
     for(unsigned short ii = 0; ii < sortVec.size(); ++ii) temp.push_back(pfp.Tp3s[sortVec[ii].index]);
     pfp.Tp3s = temp;
 //    PrintTp3s("SNS", tjs, pfp, -1);
 
     return true;
     
   } // SetStart

void tca::SetVx2Score	(	TjStuff &	tjs,
		bool	prt
	)

Definition at line 2322 of file TCVertex.cxx.

References tca::TjStuff::vtx.

Referenced by AttachTrajToVertex(), CheckTrajBeginChg(), CompleteIncomplete3DVertices(), CompleteIncomplete3DVerticesInGaps(), tca::TrajClusterAlg::EndMerge(), Find2DVertices(), Find3DVertices(), FindHammerVertices(), FindHammerVertices2(), FindNeutralVertices(), MergeWithVertex(), ScoreVertices(), and tca::TrajClusterAlg::SplitHiChgHits().

   {
     // A version that sets the score of the last added vertex
     if(tjs.vtx.empty()) return;
     auto& vx2 = tjs.vtx[tjs.vtx.size() - 1];
     SetVx2Score(tjs, vx2, prt);
   } // SetVx2Score

void tca::SetVx2Score	(	TjStuff &	tjs,
		VtxStore &	vx2,
		bool	prt
	)

Definition at line 2331 of file TCVertex.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, ChgFracNearPos(), tca::Trajectory::ChgRMS, DeltaAngle(), tca::Trajectory::EndPt, GetVtxTjIDs(), tca::VtxStore::ID, kBragg, kJunkTj, kShowerLike, kShowerTj, tca::Trajectory::MCSMom, tca::Trajectory::PDGCode, tca::VtxStore::Pos, tca::VtxStore::PosErr, tca::Trajectory::Pts, tca::VtxStore::Score, tca::Trajectory::StopFlag, tca::VtxStore::TjChgFrac, tca::VtxStore::Topo, tca::TjStuff::Vertex2DCuts, tca::TjStuff::VertexScoreWeights, tca::TjStuff::vtx3, tca::Trajectory::VtxID, and tca::VtxStore::Vx3ID.

   {
     // Calculate the 2D vertex score
     if(vx2.ID == 0) return;
     
     // Don't score vertices from CheckTrajBeginChg, MakeJunkVertices or Neutral vertices. Set to the minimum
     if(vx2.Topo == 8 || vx2.Topo == 9 || vx2.Topo == 11) {
       vx2.Score = tjs.Vertex2DCuts[7] + 0.1;
       auto vtxTjID = GetVtxTjIDs(tjs, vx2);
       vx2.TjChgFrac = ChgFracNearPos(tjs, vx2.Pos, vtxTjID);
       return;
     }
     
     // Cuts on Tjs attached to vertices
     constexpr float maxChgRMS = 0.25;
     constexpr float momBin = 50;
 
     vx2.Score = -1000;
     vx2.TjChgFrac = 0;
     if(vx2.ID == 0) return;    
     if(tjs.VertexScoreWeights.size() < 4) return;
     
     auto vtxTjIDs = GetVtxTjIDs(tjs, vx2);
     if(vtxTjIDs.empty()) return;
 
     // Vertex position error
     float vpeScore = -tjs.VertexScoreWeights[0] * (vx2.PosErr[0] + vx2.PosErr[1]);
     
     unsigned short m3Dcnt = 0;
     if(vx2.Vx3ID > 0) {
       m3Dcnt = 1;
       // Add another if the 3D vertex is complete
       unsigned short ivx3 = vx2.Vx3ID - 1;
       if(tjs.vtx3[ivx3].Wire < 0) m3Dcnt = 2;
     }
     float m3DScore = tjs.VertexScoreWeights[1] * m3Dcnt;
     
     vx2.TjChgFrac = ChgFracNearPos(tjs, vx2.Pos, vtxTjIDs);
     float cfScore = tjs.VertexScoreWeights[2] * vx2.TjChgFrac;
     
     // Define a weight for each Tj
     std::vector<int> tjids;
     std::vector<float> tjwts;
     for(auto tjid : vtxTjIDs) {
       Trajectory& tj = tjs.allTraj[tjid - 1];
       // Feb 22 Ignore short Tjs and junk tjs
       if(tj.AlgMod[kJunkTj]) continue;
       unsigned short lenth = tj.EndPt[1] - tj.EndPt[0] + 1;
       if(lenth < 3) continue;
       float wght = (float)tj.MCSMom / momBin;
       if(wght > 10) wght = 10;
       // weight by tagged muon
       if(tj.PDGCode == 13) wght *= 2;
       // weight by charge rms
       if(tj.ChgRMS < maxChgRMS) ++wght;
       // Shower Tj
       if(tj.AlgMod[kShowerTj]) ++wght;
       // ShowerLike
       if(tj.AlgMod[kShowerLike]) --wght;
       tjids.push_back(tjid);
       tjwts.push_back(wght);
     } // tjid
     
     if(tjids.empty()) return;
     
     float tjScore = 0;
     float sum = 0;
     float cnt = 0;
     for(unsigned short it1 = 0; it1 < tjids.size() - 1; ++it1) {
       Trajectory& tj1 = tjs.allTraj[tjids[it1] - 1];
       float wght1 = tjwts[it1];
       // the end that has a vertex
       unsigned short end1 = 0;
       if(tj1.VtxID[1] == vx2.ID) end1 = 1;
       unsigned short endPt1 = tj1.EndPt[end1];
       // bump up the weight if there is a Bragg peak at the other end
       unsigned short oend1 = 1 - end1;
       if(tj1.StopFlag[oend1][kBragg]) ++wght1;
       float ang1 = tj1.Pts[endPt1].Ang;
       float ang1Err2 = tj1.Pts[endPt1].AngErr * tj1.Pts[endPt1].AngErr;
       for(unsigned short it2 = it1 + 1; it2 < tjids.size(); ++it2) {
         Trajectory& tj2 = tjs.allTraj[tjids[it2] - 1];
         float wght2 = tjwts[it2];
         unsigned end2 = 0;
         if(tj2.VtxID[1] == vx2.ID) end2 = 1;
         // bump up the weight if there is a Bragg peak at the other end
         unsigned short oend2 = 1 - end2;
         if(tj2.StopFlag[oend2][kBragg]) ++wght2;
         unsigned short endPt2 = tj2.EndPt[end2];
         float ang2 = tj2.Pts[endPt2].Ang;
         float ang2Err2 = tj2.Pts[endPt2].AngErr * tj2.Pts[endPt2].AngErr;
         float dang = DeltaAngle(ang1, ang2);
         float dangErr = 0.5 * sqrt(ang1Err2 + ang2Err2);
         if((dang / dangErr) > 3 && wght1 > 0 && wght2 > 0) {
           sum += wght1 + wght2;
           ++cnt;
         }
       } // it2
     } // it1
     if(cnt > 0) {
       sum /= cnt;
       tjScore = tjs.VertexScoreWeights[3] * sum;
     }
     vx2.Score = vpeScore + m3DScore + cfScore + tjScore;
     if(prt) {
       // last call after vertices have been matched to the truth. Use to optimize VertexScoreWeights using
       // an ntuple
       mf::LogVerbatim myprt("TC");
       myprt<<" SVx2W 2V"<<vx2.ID;
       myprt<<" m3Dcnt "<<m3Dcnt;
       myprt<<" PosErr "<<std::fixed<<std::setprecision(2)<<(vx2.PosErr[0] + vx2.PosErr[1]);
       myprt<<" TjChgFrac "<<std::fixed<<std::setprecision(3)<<vx2.TjChgFrac;
       myprt<<" sum "<<std::fixed<<std::setprecision(1)<<sum;
       myprt<<" cnt "<<(int)cnt;
       myprt<<" Score "<<vx2.Score;
     }
   } // SetVx2Score

void tca::SetVx3Score	(	TjStuff &	tjs,
		Vtx3Store &	vx3,
		bool	prt
	)

Definition at line 2303 of file TCVertex.cxx.

References tca::Vtx3Store::ID, tca::TjStuff::NumPlanes, tca::VtxStore::Score, tca::Vtx3Store::Score, SetHighScoreBits(), tca::TjStuff::Vertex2DCuts, tca::TjStuff::vtx, and tca::Vtx3Store::Vx2ID.

Referenced by Find3DVertices(), FindNeutralVertices(), MakeVertexObsolete(), and ScoreVertices().

   {
     // Calculate the 3D vertex score and flag Tjs that are attached to high score vertices as defined 
     // by Vertex2DCuts 
     
     if(vx3.ID == 0) return;
     
     vx3.Score = 0;
     for(unsigned short ipl = 0; ipl < tjs.NumPlanes; ++ipl) {
       if(vx3.Vx2ID[ipl] <= 0) continue;
       VtxStore& vx2 = tjs.vtx[vx3.Vx2ID[ipl] - 1];
       vx3.Score += vx2.Score;
     } // ipl
     vx3.Score /= (float)tjs.NumPlanes;
     if(vx3.Score > tjs.Vertex2DCuts[7]) SetHighScoreBits(tjs, vx3);
     
   } // SetVx3Score

bool tca::SharesHighScoreVx	(	TjStuff &	tjs,
		const PFPStruct &	pfp,
		const Trajectory &	tj
	)

Definition at line 883 of file PFPUtils.cxx.

References evd::details::end(), GetVtxTjIDs(), kHiVx3Score, SetIntersection(), tca::PFPStruct::TjIDs, tca::TjStuff::vtx, and tca::Trajectory::VtxID.

Referenced by DefinePFP(), and FindMissedTjsInTp3s().

   {
     // returns true if tj with tjID shares a high-score 3D vertex with any
     // tj in pfp.TjIDs
     for(unsigned short end = 0; end < 2; ++end) {
       if(tj.VtxID[end] == 0) continue;
       auto& vx2 = tjs.vtx[tj.VtxID[end] - 1];
       if(!vx2.Stat[kHiVx3Score]) continue;
       std::vector<int> vtjlist = GetVtxTjIDs(tjs, vx2);
       auto shared = SetIntersection(vtjlist, pfp.TjIDs);
       if(!shared.empty()) return true;
     } // end
     return false;
   } // SharesHighScoreVx

double tca::ShowerEnergy ( const ShowerStruct3D & ss3 )

Definition at line 4434 of file TCShower.cxx.

References e, tca::ShowerStruct3D::Energy, and tca::ShowerStruct3D::ID.

Referenced by tca::TruthMatcher::StudyShowerParents(), and showerreco::ShowerCalo::~ShowerCalo().

   {
     if(ss3.ID == 0) return 0;
     if(ss3.Energy.empty()) return 0;
     double ave = 0;
     for(auto e : ss3.Energy) {
       ave += e;
     } // e
     ave /= ss3.Energy.size();
     return ave;
   } // ShowerEnergy

float tca::ShowerEnergy	(	const TjStuff &	tjs,
		const std::vector< int >	tjIDs
	)

Definition at line 4447 of file TCShower.cxx.

References tca::TjStuff::allTraj, and ChgToMeV().

Referenced by CompleteIncompleteShower(), FindCots(), FindParent(), FindShowers3D(), and Reconcile3D().

   {
     // Calculate energy using the total charge of all hits in each tj in the shower
     if(tjIDs.empty()) return 0;
     float sum = 0;
     for(auto tid : tjIDs) {
       auto& tj = tjs.allTraj[tid - 1];
       sum += tj.TotChg;
     } // tid
     return ChgToMeV(sum);
   } // ShowerEnergy

void tca::ShowerParams	(	double	showerEnergy,
		double &	shMaxAlong,
		double &	along95
	)

Definition at line 2084 of file TCShower.cxx.

References scale.

Referenced by FindParent(), InShowerProbLong(), MergeSubShowers(), ParentFOM(), and ShowerParamTransRMS().

   {
     // Returns summary properties of photon showers parameterized in the energy range 50 MeV < E_gamma < 1 GeV:
     // shMaxAlong = the longitudinal distance (cm) between the start of the shower and the center of charge
     // along95 = the longitudinal distance (cm) between the start of the shower and 95% energy containment
     // all units are in cm
     if(showerEnergy < 10) {
       shMaxAlong = 0;
       along95 = 0;
       return;
     }
 //    shMaxAlong = 7.0 * log(showerEnergy / 15);
     shMaxAlong = 16 * log(showerEnergy / 15);
     // The 95% containment is reduced a bit at higher energy
     double scale = 2.75 - 9.29E-4 * showerEnergy;
     if(scale < 2) scale = 2;
     along95 = scale * shMaxAlong;
   } // ShowerParams

double tca::ShowerParamTransRMS	(	double	showerEnergy,
		double	along
	)

Definition at line 2104 of file TCShower.cxx.

References ShowerParams().

Referenced by InShowerProbTrans().

   {
     // returns the pareameterized width rms of a shower at along relative to the shower max
     double shMaxAlong, shE95Along;
     ShowerParams(showerEnergy, shMaxAlong, shE95Along);
     if(shMaxAlong <= 0) return 0;
     double tau = (along + shMaxAlong) / shMaxAlong;
     // The shower width is modeled as a simple cone that scales with tau
     double rms = -0.4 + 2.5 * tau;
     if(rms < 0.5) rms = 0.5;
     return rms;
   } // ShowerParamTransRMS

bool tca::SignalAtTp	(	TjStuff &	tjs,
		TrajPoint const &	tp
	)

bool tca::SignalAtTp	(	TjStuff &	tjs,
		const TrajPoint &	tp
	)

Definition at line 1639 of file Utils.cxx.

References tca::TrajPoint::CTP, DecodeCTP(), tca::TrajPoint::Dir, tca::TjStuff::fHits, tca::TjStuff::MaxPos1, tca::TjStuff::NumWires, tca::TCHit::PeakTime, geo::PlaneID::Plane, tca::TrajPoint::Pos, tca::TCHit::RMS, tca::TjStuff::UnitsPerTick, and tca::TjStuff::WireHitRange.

Referenced by ChgFracBetween(), FindHammerVertices2(), FindXMatches(), SignalBetween(), and tca::TrajClusterAlg::StepCrawl().

   {
     // returns true if there is a hit near tp.Pos
     
     if(tp.Pos[0] < -0.4) return false;
     unsigned int wire = std::nearbyint(tp.Pos[0]);
     geo::PlaneID planeID = DecodeCTP(tp.CTP);
     unsigned int ipl = planeID.Plane;
     if(wire >= tjs.NumWires[ipl]) return false;
     if(tp.Pos[1] > tjs.MaxPos1[ipl]) return false;
     // Assume dead wires have a signal
     if(tjs.WireHitRange[ipl][wire].first == -1) return true;
     float projTick = (float)(tp.Pos[1] / tjs.UnitsPerTick);
     float tickRange = 0;
     if(std::abs(tp.Dir[1]) != 0) {
       tickRange = std::abs(0.5 / tp.Dir[1]) / tjs.UnitsPerTick;
       // don't let it get too large
       if(tickRange > 40) tickRange = 40;
     }
     float loTpTick = projTick - tickRange;
     float hiTpTick = projTick + tickRange;
     unsigned int firstHit = (unsigned int)tjs.WireHitRange[ipl][wire].first;
     unsigned int lastHit = (unsigned int)tjs.WireHitRange[ipl][wire].second;
     
     for(unsigned int iht = firstHit; iht < lastHit; ++iht) {
       TCHit& hit = tjs.fHits[iht];
       if(projTick < hit.PeakTime) {
         float loHitTick = hit.PeakTime - 3 * hit.RMS;
         if(hiTpTick > loHitTick) return true;
       } else {
         float hiHitTick = hit.PeakTime + 3 * hit.RMS;
         if(loTpTick < hiHitTick) return true;
       }
     } // iht
     return false;
     
   } // SignalAtTp

bool tca::SignalBetween	(	TjStuff &	tjs,
		const TrajPoint &	tp1,
		const TrajPoint &	tp2,
		const float &	MinWireSignalFraction,
		bool	prt
	)

Definition at line 1495 of file Utils.cxx.

References MakeBareTrajPoint(), tca::TrajPoint::Pos, SignalAtTp(), and SignalBetween().

Referenced by AttachTrajToVertex(), tca::TrajClusterAlg::EndMerge(), Find2DVertices(), and MakeJunkVertices().

   {
     // Returns true if there is a signal on > MinWireSignalFraction of the wires between tp1 and tp2.
     if(MinWireSignalFraction == 0) return true;
     
     if(tp1.Pos[0] < -0.4 || tp2.Pos[0] < -0.4) return false;
     int fromWire = std::nearbyint(tp1.Pos[0]);
     int toWire = std::nearbyint(tp2.Pos[0]);
     
     if(fromWire == toWire) {
       TrajPoint tp = tp1;
       // check for a signal midway between
       tp.Pos[1] = 0.5 * (tp1.Pos[1] + tp2.Pos[1]);
       if(prt) mf::LogVerbatim("TC")<<" SignalBetween fromWire = toWire = "<<fromWire<<" SignalAtTp? "<<SignalAtTp(tjs, tp);
       return SignalAtTp(tjs, tp);
     }
     // define a trajectory point located at tp1 that has a direction towards tp2
     TrajPoint tp;
     if(!MakeBareTrajPoint(tjs, tp1, tp2, tp)) return true;
     return SignalBetween(tjs, tp, toWire, MinWireSignalFraction, prt);
   } // SignalBetween

bool tca::SignalBetween	(	TjStuff &	tjs,
		TrajPoint	tp,
		float	toPos0,
		const float &	MinWireSignalFraction,
		bool	prt
	)

Definition at line 1520 of file Utils.cxx.

References ChgFracBetween().

Referenced by SignalBetween().

   {
     // Returns true if there is a signal on > MinWireSignalFraction of the wires between tp and toPos0.
     return ChgFracBetween(tjs, tp, toPos0, prt) >= MinWireSignalFraction;
   } // SignalBetween

bool tca::Split3DKink	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		double	sep,
		bool	prt
	)

Definition at line 1782 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, AttachAnyTrajToVertex(), tca::VtxStore::CTP, DecodeCTP(), FindKinks(), tca::VtxStore::ID, tca::Vtx3Store::ID, KinkAngle(), kSplit3DKink, tca::PFPStruct::NeedsUpdate, tca::TjStuff::NumPlanes, geo::PlaneID::Plane, tca::VtxStore::Pos, SplitTraj(), StoreVertex(), tca::PFPStruct::TjIDs, tca::VtxStore::Topo, tca::PFPStruct::Tp3s, tca::Vtx3Store::TPCID, tca::PFPStruct::TPCID, tca::TjStuff::UseAlg, tca::TjStuff::vtx, tca::TjStuff::vtx3, tca::Vtx3Store::Vx2ID, tca::Vtx3Store::X, tca::Vtx3Store::Y, and tca::Vtx3Store::Z.

Referenced by DotProd(), FindPFParticles(), and Match3DVtxTjs().

   {
     // Finds kinks in the PFParticle, splits Tjs, creates 2D vertices and forces a rebuild if any are found
     if(pfp.Tp3s.empty()) return false;
     if(!tjs.UseAlg[kSplit3DKink]) return false;
     
     auto kinkPts = FindKinks(tjs, pfp, sep, prt);
     if(kinkPts.empty()) return false;
     if(prt) mf::LogVerbatim("TC")<<"Split3DKink found a kink at Tp3s point "<<kinkPts[0];
     
     // Only split the biggest angle kink
     double big = 0;
     unsigned short kpt = 0;
     for(auto ipt : kinkPts) {
       double dang = KinkAngle(tjs, pfp.Tp3s, ipt, sep);
       if(dang > big) {
         big = dang;
         kpt = ipt;
       }
     } // ipt
     if(kpt < 1 || kpt > pfp.Tp3s.size() - 1) return false;
     // determine which tjs need to be split
     std::vector<unsigned short> tjids;
     std::vector<unsigned short> vx2ids;
     // inspect a few Tp3s near the kink point to get a list of Tjs
     for(unsigned short ipt = kpt; ipt < kpt + 2; ++ipt) {
       auto& tp3 = pfp.Tp3s[ipt];
       for(auto& tp2 : tp3.Tj2Pts) {
         // see if this Tj id is in the list
         if(std::find(tjids.begin(), tjids.end(), tp2.id) != tjids.end()) continue;
         // ensure that it is pfp.TjIDs
         if(std::find(pfp.TjIDs.begin(), pfp.TjIDs.end(), tp2.id) == pfp.TjIDs.end()) continue;
         tjids.push_back(tp2.id);
         auto& tj = tjs.allTraj[tp2.id - 1];
         auto& tp = tj.Pts[tp2.ipt];
         unsigned short closeEnd = USHRT_MAX;
         if(tp2.ipt < tj.EndPt[0] + 2) closeEnd = 0;
         if(tp2.ipt > tj.EndPt[1] - 2) closeEnd = 1;
         if(closeEnd < 2) {
           // No split is needed and there should be a vertex at this end of the Tj that
           // should be associated with a 3D vertex that we will construct
           if(tj.VtxID[closeEnd] == 0) {
 //            std::cout<<Split3DKink: TODO Tj "<<tj.ID<<" has no vertex attached on end "<<closeEnd<<". Write some code.\n";
             return false;
           }
           vx2ids.push_back(tj.VtxID[closeEnd]);
           if(prt) mf::LogVerbatim("TC")<<" tj "<<tj.ID<<" use existing 2V"<<tj.VtxID[closeEnd];
         } else {
           // make a 2D vertex at this point
           VtxStore vx2;
           vx2.ID = tjs.vtx.size() + 1;
           vx2.CTP = tj.CTP;
           vx2.Topo = 10;
           vx2.Pos = tp.Pos;
           if(!StoreVertex(tjs, vx2)) return false;
           if(!SplitTraj(tjs, tp2.id - 1, tp2.ipt, tjs.vtx.size() - 1, prt)) return false;
           vx2ids.push_back(vx2.ID);
           AttachAnyTrajToVertex(tjs, tjs.vtx.size() - 1, prt);
           if(prt) mf::LogVerbatim("TC")<<" tj "<<tj.ID<<" new 2V"<<vx2.ID;
         }
       } // tp2
     } // ipt
     
     if(vx2ids.size() != tjs.NumPlanes) {
 //      std::cout<<"Split3DKink: TODO pfp "<<pfp.ID<<" only has "<<vx2ids.size()<<" 2D vertices. \n";
       return false;
     }
     Vtx3Store vx3;
     vx3.TPCID = pfp.TPCID;
     vx3.ID = tjs.vtx3.size() + 1;
     vx3.X = pfp.Tp3s[kpt].Pos[0];
     vx3.Y = pfp.Tp3s[kpt].Pos[1];
     vx3.Z = pfp.Tp3s[kpt].Pos[2];
     for(auto vx2id : vx2ids) {
       if(vx2id == 0) continue;
       auto& vx2 = tjs.vtx[vx2id - 1];
       unsigned short plane = DecodeCTP(vx2.CTP).Plane;
       vx3.Vx2ID[plane] = vx2id;
       vx2.Vx3ID = vx3.ID;
     } // vx2id
     std::cout<<"Split3DKink add 3V"<<vx3.ID<<"\n";
     tjs.vtx3.push_back(vx3);
     // mark this as needing an update
     pfp.NeedsUpdate = true;
     return true;
   } // Split3DKink

bool tca::SplitTraj	(	TjStuff &	tjs,
		unsigned short	itj,
		float	XPos,
		bool	makeVx2,
		bool	prt
	)

Definition at line 1879 of file Utils.cxx.

References tca::TjStuff::allTraj, detinfo::DetectorProperties::ConvertXToTicks(), tca::VtxStore::CTP, DecodeCTP(), tca::TjStuff::detprop, tca::VtxStore::NTraj, tca::VtxStore::Pos, SplitTraj(), StoreVertex(), tca::VtxStore::Topo, tca::TjStuff::UnitsPerTick, and tca::TjStuff::vtx.

Referenced by CompleteIncomplete3DVertices(), FindHammerVertices(), FindHammerVertices2(), Split3DKink(), and SplitTrajCrossingVertices().

   {
     // Splits the trajectory at an X position and optionally creates a 2D vertex at the split point
     if(itj > tjs.allTraj.size()-1) return false;
     
     auto& tj = tjs.allTraj[itj];
     geo::PlaneID planeID = DecodeCTP(tj.CTP);
     float atPos1 = tjs.detprop->ConvertXToTicks(XPos, planeID) * tjs.UnitsPerTick;
     unsigned short atPt = USHRT_MAX;
     for(unsigned short ipt = tj.EndPt[0] + 1; ipt <= tj.EndPt[1]; ++ipt) {
       if(tj.Pts[ipt].Pos[1] > tj.Pts[ipt - 1].Pos[1]) {
         // positive slope
         if(tj.Pts[ipt - 1].Pos[1] < atPos1 && tj.Pts[ipt].Pos[1] >= atPos1) {
           atPt = ipt;
           break;
         }
       } else {
         // negative slope
         if(tj.Pts[ipt - 1].Pos[1] >= atPos1 && tj.Pts[ipt].Pos[1] < atPos1) {
           atPt = ipt;
           break;
         }
       } // negative slope
     } // ipt
     if(atPt == USHRT_MAX) return false;
     unsigned short vx2Index = USHRT_MAX;
     if(makeVx2) {
       VtxStore newVx2;
       newVx2.CTP = tj.CTP;
       newVx2.Pos[0] = 0.5 * (tj.Pts[atPt - 1].Pos[0] + tj.Pts[atPt].Pos[0]);
       newVx2.Pos[1] = 0.5 * (tj.Pts[atPt - 1].Pos[1] + tj.Pts[atPt].Pos[1]);
       newVx2.Topo = 10;
       newVx2.NTraj = 2;
       if(StoreVertex(tjs, newVx2)) vx2Index = tjs.vtx.size() - 1;
     } // makeVx2
     return SplitTraj(tjs, itj, atPt, vx2Index, prt);
   } // SplitTraj

bool tca::SplitTraj	(	TjStuff &	tjs,
		unsigned short	itj,
		unsigned short	pos,
		unsigned short	ivx,
		bool	prt
	)

Definition at line 1918 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::Trajectory::EndPt, tca::TjStuff::fHits, tca::Trajectory::ID, kSplit, tca::Trajectory::ParentID, tca::Trajectory::PDGCode, tca::Trajectory::Pts, SetEndPoints(), SetPDGCode(), UpdateMatchStructs(), UpdateTjChgProperties(), tca::TjStuff::vtx, and tca::Trajectory::VtxID.

Referenced by CheckTrajBeginChg(), and SplitTraj().

   {
     // Splits the trajectory itj in the tjs.allTraj vector into two trajectories at position pos. Splits
     // the trajectory and associates the ends to the supplied vertex.
     // Here is an example where itj has 9 points and we will split at pos = 4
     // itj (0 1 2 3 4 5 6 7 8) -> new traj (0 1 2 3) + new traj (4 5 6 7 8)
     
     if(itj > tjs.allTraj.size()-1) return false;
     if(pos < tjs.allTraj[itj].EndPt[0] + 1 || pos > tjs.allTraj[itj].EndPt[1] - 1) return false;
     if(ivx != USHRT_MAX && ivx > tjs.vtx.size() - 1) return false;
     
     Trajectory& tj = tjs.allTraj[itj];
     
     // Reset the PDG Code if we are splitting a tagged muon
     bool splittingMuon = (tj.PDGCode == 13);
     if(splittingMuon) tj.PDGCode = 0;
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"SplitTraj: Split T"<<tj.ID<<" at point "<<pos;
       if(ivx < tjs.vtx.size()) myprt<<" with Vtx 2V"<<tjs.vtx[ivx].ID;
     }
 
     // ensure that there will be at least 3 TPs on each trajectory
     unsigned short ipt, ii, ntp = 0;
     for(ipt = 0; ipt < pos; ++ipt) {
       if(tj.Pts[ipt].Chg > 0) ++ntp;
       if(ntp > 2) break;
     } // ipt
     if(ntp < 3) {
       if(prt) mf::LogVerbatim("TC")<<" Split point to small at begin "<<ntp<<" pos "<<pos<<" ID ";
       return false;
     }
     ntp = 0;
     for(ipt = pos + 1; ipt < tj.Pts.size(); ++ipt) {
       if(tj.Pts[ipt].Chg > 0) ++ntp;
       if(ntp > 2) break;
     } // ipt
     if(ntp < 3) {
       if(prt) mf::LogVerbatim("TC")<<" Split point too small at end "<<ntp<<" pos "<<pos<<" EndPt "<<tj.EndPt[1];
       return false;
     }
     
     // make a copy that will become the Tj after the split point
     Trajectory newTj = tj;
     newTj.ID = tjs.allTraj.size() + 1;
     // make another copy in case something goes wrong
     Trajectory oldTj = tj;
     
     // Leave the first section of tj in place. Re-assign the hits
     // to the new trajectory
     unsigned int iht;
     for(ipt = pos + 1; ipt < tj.Pts.size(); ++ipt) {
       tj.Pts[ipt].Chg = 0;
       for(ii = 0; ii < tj.Pts[ipt].Hits.size(); ++ii) {
         if(!tj.Pts[ipt].UseHit[ii]) continue;
         iht = tj.Pts[ipt].Hits[ii];
         // This shouldn't happen but check anyway
         if(tjs.fHits[iht].InTraj != tj.ID) continue;
         tjs.fHits[iht].InTraj = newTj.ID;
         tj.Pts[ipt].UseHit[ii] = false;
       } // ii
     } // ipt
     SetEndPoints(tjs, tj);
     UpdateTjChgProperties("ST", tjs, tj, prt);
     if(splittingMuon) SetPDGCode(tjs, tj);
     
     // Append 3 points from the end of tj onto the
     // beginning of newTj so that hits can be swapped between
     // them later
     unsigned short eraseSize = pos - 2;
     if(eraseSize > newTj.Pts.size() - 1) {
       tj = oldTj;
       return false;
     }
     
     if(ivx < tjs.vtx.size()) tj.VtxID[1] = tjs.vtx[ivx].ID;
     tj.AlgMod[kSplit] = true;
     if(prt) {
       mf::LogVerbatim("TC")<<" Splitting T"<<tj.ID<<" new EndPts "<<tj.EndPt[0]<<" to "<<tj.EndPt[1];
     }
     
     // erase the TPs at the beginning of the new trajectory
     newTj.Pts.erase(newTj.Pts.begin(), newTj.Pts.begin() + eraseSize);
     // unset the first 3 TP hits
     for(ipt = 0; ipt < 3; ++ipt) {
       for(ii = 0; ii < newTj.Pts[ipt].Hits.size(); ++ii) newTj.Pts[ipt].UseHit[ii] = false;
       newTj.Pts[ipt].Chg = 0;
     } // ipt
     SetEndPoints(tjs, newTj);
     UpdateTjChgProperties("ST", tjs, newTj, prt);
     if(splittingMuon) SetPDGCode(tjs, newTj);
     if(ivx < tjs.vtx.size()) newTj.VtxID[0] = tjs.vtx[ivx].ID;
     newTj.AlgMod[kSplit] = true;
     newTj.ParentID = 0;
     // save the ID before push_back in case the tj reference gets lost
     int tjid = tj.ID;
     tjs.allTraj.push_back(newTj);
     UpdateMatchStructs(tjs, tjid, newTj.ID);
 
     if(prt) {
       mf::LogVerbatim("TC")<<"  newTj T"<<newTj.ID<<" EndPts "<<newTj.EndPt[0]<<" to "<<newTj.EndPt[1];
     }
     return true;
     
   } // SplitTraj

void tca::SplitTrajCrossingVertices	(	TjStuff &	tjs,
		CTP_t	inCTP
	)

Definition at line 1091 of file TCVertex.cxx.

References tca::TjStuff::allTraj, debug, DecodeCTP(), DeltaAngle(), evd::details::end(), FitVertex(), GetVtxTjIDs(), kDeltaRay, tca::TjStuff::KinkCuts, kKilled, kOnDeadWire, kSplitTjCVx, MakeVertexObsolete(), NumPtsWithCharge(), tca::DebugStuff::Plane, geo::PlaneID::Plane, PointTrajDOCA(), PrintTrajPoint(), SplitTraj(), tca::DebugStuff::Tick, TrajClosestApproach(), tca::TjStuff::UseAlg, tca::TjStuff::Vertex2DCuts, and tca::TjStuff::vtx.

Referenced by tca::TrajClusterAlg::ReconstructAllTraj().

   {
     // This is kind of self-explanatory...
 
     if(!tjs.UseAlg[kSplitTjCVx]) return;
 
     if(tjs.vtx.empty()) return;
     if(tjs.allTraj.empty()) return;
     
     constexpr float docaCut = 4;
 
     bool prt = (debug.Plane >= 0 && debug.Tick == 77777);
     if(prt) mf::LogVerbatim("TC")<<"Inside SplitTrajCrossingVertices inCTP "<<inCTP;
 
     geo::PlaneID planeID = DecodeCTP(inCTP);        
 
     unsigned short nTraj = tjs.allTraj.size();
     for(unsigned short itj = 0; itj < nTraj; ++itj) {
       // NOTE: Don't use a reference variable because it may get lost if the tj is split
 //      auto& tj = tjs.allTraj[itj];
       if(tjs.allTraj[itj].CTP != inCTP) continue;
       // obsolete trajectory
       if(tjs.allTraj[itj].AlgMod[kKilled]) continue;
       if(tjs.allTraj[itj].AlgMod[kSplitTjCVx]) continue;
       // too short
       if(tjs.allTraj[itj].EndPt[1] < 6) continue;
       for(unsigned short iv = 0; iv < tjs.vtx.size(); ++iv) {
         auto& vx2 = tjs.vtx[iv];
         // obsolete vertex
         if(vx2.NTraj == 0) continue;
         // trajectory already associated with vertex
         if(tjs.allTraj[itj].VtxID[0] == vx2.ID ||
            tjs.allTraj[itj].VtxID[1] == vx2.ID) continue;
         // not in the cryostat/tpc/plane
         if(tjs.allTraj[itj].CTP != vx2.CTP) continue;
         // poor quality
         if(vx2.Score < tjs.Vertex2DCuts[7]) continue;
         float doca = docaCut;
         // make the cut significantly larger if the vertex is in a dead
         // wire gap to get the first TP that is just outside the gap.
         if(vx2.Stat[kOnDeadWire]) doca = 100;
         unsigned short closePt = 0;
         if(!TrajClosestApproach(tjs.allTraj[itj], vx2.Pos[0], vx2.Pos[1], closePt, doca)) continue;
         if(vx2.Stat[kOnDeadWire]) {
           // special handling for vertices in dead wire regions. Find the IP between
           // the closest point on the Tj and the vertex
           doca = PointTrajDOCA(tjs, vx2.Pos[0], vx2.Pos[1], tjs.allTraj[itj].Pts[closePt]);
         }
         if(doca > docaCut) continue;
         if(prt)  mf::LogVerbatim("TC")<<" doca "<<doca<<" btw T"<<tjs.allTraj[itj].ID<<" and 2V"<<tjs.vtx[iv].ID<<" closePt "<<closePt<<" in plane "<<planeID.Plane;
         // compare the length of the Tjs used to make the vertex with the length of the
         // Tj that we want to split. Don't allow a vertex using very short Tjs to split a long
         // Tj in the 3rd plane
         auto vxtjs = GetVtxTjIDs(tjs, vx2);
         if(vxtjs.empty()) continue;
         unsigned short maxPts = 0;
         // ensure that there is a large angle between a Tj already attached to the vertex and the
         // tj that we want to split. We might be considering a delta-ray here
         float maxdang = 0;
         float tjAng = tjs.allTraj[itj].Pts[closePt].Ang;
         for(auto tjid : vxtjs) {
           auto& vtj = tjs.allTraj[tjid - 1];
           if(vtj.AlgMod[kDeltaRay]) continue;
           unsigned short npwc = NumPtsWithCharge(tjs, vtj, false);
           if(npwc > maxPts) maxPts = npwc;
           unsigned short end = 0;
           if(vtj.VtxID[1] == tjs.vtx[iv].ID) end = 1;
           auto& vtp = vtj.Pts[vtj.EndPt[end]];
           float dang = DeltaAngle(vtp.Ang, tjAng);
           if(dang > maxdang) maxdang = dang; 
         } // tjid
         // skip this operation if any of the Tjs in the split list are > 3 * maxPts
         maxPts *= 3;
         bool skipit = false;
         if(NumPtsWithCharge(tjs, tjs.allTraj[itj], false) > maxPts && maxPts < 100) skipit = true;
         if(!skipit && maxdang < tjs.KinkCuts[0]) skipit = true;
         if(prt) mf::LogVerbatim("TC")<<"  maxPts "<<maxPts<<" vxtjs[0] "<<vxtjs[0]<<" maxdang "<<maxdang<<" skipit? "<<skipit;
         if(skipit) {
           // kill the vertex?
           if(doca < 1) MakeVertexObsolete(tjs, vx2, true);
           continue;
         }
         
         // make some adjustments to closePt
         if(vx2.Stat[kOnDeadWire]) {
           // ensure that the tj will be split at the gap. The closePt point may be
           // on the wrong side of it
           auto& closeTP = tjs.allTraj[itj].Pts[closePt];
           if(tjs.allTraj[itj].StepDir > 0 && closePt > tjs.allTraj[itj].EndPt[0]) {
             if(closeTP.Pos[0] > vx2.Pos[0]) --closePt;
           } else if(tjs.allTraj[itj].StepDir < 0 && closePt < tjs.allTraj[itj].EndPt[1]) {
             if(closeTP.Pos[0] < vx2.Pos[0]) ++closePt;
           }
         } else {
           // improve closePt based on vertex position
           // check if closePt and EndPt[1] are the two sides of vertex
           // take dot product of closePt-vtx and EndPt[1]-vtx
           if ((tjs.allTraj[itj].Pts[closePt].Pos[0]-vx2.Pos[0])*(tjs.allTraj[itj].Pts[tjs.allTraj[itj].EndPt[1]].Pos[0]-vx2.Pos[0]) + (tjs.allTraj[itj].Pts[closePt].Pos[1]-vx2.Pos[1])*(tjs.allTraj[itj].Pts[tjs.allTraj[itj].EndPt[1]].Pos[1]-vx2.Pos[1]) <0 && closePt < tjs.allTraj[itj].EndPt[1] - 1) ++closePt;
           else if ((tjs.allTraj[itj].Pts[closePt].Pos[0]-vx2.Pos[0])*(tjs.allTraj[itj].Pts[tjs.allTraj[itj].EndPt[0]].Pos[0]-vx2.Pos[0]) + (tjs.allTraj[itj].Pts[closePt].Pos[1]-vx2.Pos[1])*(tjs.allTraj[itj].Pts[tjs.allTraj[itj].EndPt[0]].Pos[1]-tjs.vtx[iv].Pos[1]) <0 && closePt > tjs.allTraj[itj].EndPt[0] + 1) --closePt;
         }
 
         
         if(prt)  {
           mf::LogVerbatim("TC")<<"Good doca "<<doca<<" btw T"<<tjs.allTraj[itj].ID<<" and 2V"<<vx2.ID<<" closePt "<<closePt<<" in plane "<<planeID.Plane<<" CTP "<<tjs.vtx[iv].CTP;
           PrintTrajPoint("STCV", tjs, closePt, 1, tjs.allTraj[itj].Pass, tjs.allTraj[itj].Pts[closePt]);
         }
         // ensure that the closest point is not near an end
         if(closePt < tjs.allTraj[itj].EndPt[0] + 3) continue;
         if(closePt > tjs.allTraj[itj].EndPt[1] - 3) continue;
         if(!SplitTraj(tjs, itj, closePt, iv, prt)) {
           if(prt) mf::LogVerbatim("TC")<<"SplitTrajCrossingVertices: Failed to split trajectory";
           continue;
         }
         tjs.allTraj[itj].AlgMod[kSplitTjCVx] = true;
         unsigned short newTjIndex = tjs.allTraj.size() - 1;
         tjs.allTraj[newTjIndex].AlgMod[kSplitTjCVx] = true;
         // re-fit the vertex position
         FitVertex(tjs, vx2, prt);
       } // iv
     } // itj
     
   } // SplitTrajCrossingVertices

std::vector< float > tca::StartChgVec	(	TjStuff &	tjs,
		int	cotID,
		bool	prt
	)

Definition at line 4254 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::ShowerStruct::Angle, tca::TjStuff::cots, tca::TjStuff::fHits, tca::ShowerStruct::ID, tca::ShowerStruct::ParentID, tca::TrajPoint::Pos, tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::ShPts, ss, tca::ShowerStruct::TjIDs, and tca::TjStuff::UnitsPerTick.

Referenced by FindStartChg().

   {
     // Returns a histogram vector of the charge in bins of 1 WSE unit at the start of the shower
 
     ShowerStruct& ss = tjs.cots[cotID - 1];
     constexpr unsigned short nbins = 20;
     std::vector<float> schg(nbins);
     if(ss.ID == 0) return schg; 
     if(ss.TjIDs.empty()) return schg; 
     TrajPoint& stp1 = tjs.allTraj[ss.ShowerTjID-1].Pts[1];
     
     // move the min along point back by 2 WSE so that most of the charge in the hits in the
     // first point is included in the histogram
     float minAlong = ss.ShPts[0].RotPos[0] - 2;
     
     float maxTrans = 4;
     // Tighten up on the maximum allowed transverse position if there is a parent
     if(ss.ParentID > 0) maxTrans = 1;
     float cs = cos(-ss.Angle);
     float sn = sin(-ss.Angle);
     std::array<float, 2> chgPos;
     float along, arg;
 
     for(auto& sspt : ss.ShPts) {
       unsigned short indx = (unsigned short)((sspt.RotPos[0] - minAlong));
       if(indx > nbins - 1) break;
       // Count the charge if it is within a few WSE transverse from the shower axis
       if(std::abs(sspt.RotPos[1]) > maxTrans) continue;
       unsigned int iht = sspt.HitIndex;
       float& peakTime = tjs.fHits[iht].PeakTime;
       float& amp = tjs.fHits[iht].PeakAmplitude;
       float& rms = tjs.fHits[iht].RMS;
       chgPos[0] = tjs.fHits[iht].ArtPtr->WireID().Wire - stp1.Pos[0];
       for(float time = peakTime - 2.5 * rms; time < peakTime + 2.5 * rms; ++time) {
         chgPos[1] = time * tjs.UnitsPerTick - stp1.Pos[1];
         along = cs * chgPos[0] - sn * chgPos[1];
         if(along < minAlong) continue;
         indx = (unsigned short)(along - minAlong);
         if(indx > nbins - 1) continue;
         arg = (time - peakTime) / rms;
         schg[indx] += amp * exp(-0.5 * arg * arg);
       } // time
     } // sspt
 
     return schg;
   } // StartChgVec

bool tca::StorePFP	(	TjStuff &	tjs,
		PFPStruct &	pfp
	)

Definition at line 2660 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, tca::PFPStruct::BestPlane, FilldEdx(), tca::PFPStruct::ID, kMat3D, kSetDir, tca::PFPStruct::NeedsUpdate, tca::PFPStruct::PDGCode, tca::TjStuff::pfps, ReverseTraj(), tca::PFPStruct::TjIDs, and tca::PFPStruct::Tp3s.

Referenced by DefineTjParents(), DotProd(), FindPFParticles(), and Match3DVtxTjs().

   {
     // stores the PFParticle in TJStuff
     if(pfp.ID < int(tjs.pfps.size())) return false;
     bool neutrinoPFP = pfp.PDGCode == 12 || pfp.PDGCode == 14;
     if(!neutrinoPFP) {
       if(pfp.TjIDs.empty()) return false;
       if(pfp.PDGCode != 1111 && pfp.Tp3s.size() < 2) return false;
     }
     // check the ID and correct it if it is wrong
     if(pfp.ID != (int)tjs.pfps.size() + 1) pfp.ID = tjs.pfps.size() + 1;
     // check the Tjs and set the 3D match flag
     for(auto tjid : pfp.TjIDs) {
       auto& tj = tjs.allTraj[tjid - 1];
       if(tj.AlgMod[kMat3D]) return false;
       tj.AlgMod[kMat3D] = true;
     } // tjid
     
     if(!pfp.Tp3s.empty()) {
       // ensure that the Tj points are in increasing order and reverse them if they aren't. This
       // presumes that the space points have been ordered from pfp start to pfp end
       std::vector<int> tjids;
       // list of tj points to check for increasing (or decreasing) order
       std::vector<short> firstIpt;
       std::vector<short> lastIpt;
       for(auto& Tp3 : pfp.Tp3s) {
         for(auto& tj2pt : Tp3.Tj2Pts) {
           int tjid = tj2pt.id;
           // check for the first occurrence
           unsigned short ii = 0;
           for(ii = 0; ii < tjids.size(); ++ii) if(tjid == tjids[ii]) break;
           if(ii < tjids.size()) {
             // exists in the list. Keep track of the last point
             lastIpt[ii] = tj2pt.ipt;
             continue;
           }
           tjids.push_back(tjid);
           firstIpt.push_back((short)tj2pt.ipt);
           lastIpt.push_back((short)tj2pt.ipt);
         } // tjpt
       } // spt
       // reverse Tjs if necessary so that end0 is at the start of the pfp
       for(unsigned short ii = 0; ii < tjids.size(); ++ii) {
         // ignore Tjs that aren't associated with this pfp
         if(std::find(pfp.TjIDs.begin(), pfp.TjIDs.end(), tjids[ii]) == pfp.TjIDs.end()) continue;
         auto& tj = tjs.allTraj[tjids[ii] - 1];
         if(lastIpt[ii] < firstIpt[ii]) {
           if(tj.AlgMod[kSetDir]) {
 //            std::cout<<"StorePFP "<<pfp.ID<<" Violating the SetDir flag for Tj "<<tj.ID<<"\n";
             tj.AlgMod[kSetDir] = false;
           }
           ReverseTraj(tjs, tj);
         } // lastIpt[ii] > firstIpt[ii]
       } // ii
     } // Tp3s exist    
     
     if(pfp.BestPlane < 0) FilldEdx(tjs, pfp);
     
     if(pfp.NeedsUpdate) std::cout<<"StorePFP: stored P"<<pfp.ID<<" but NeedsUpdate is true...\n";
     
     tjs.pfps.push_back(pfp);
     return true;
   } // StorePFP

bool tca::StoreShower	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct3D &	ss3
	)

Definition at line 4468 of file TCShower.cxx.

References tca::ShowerStruct3D::CotIDs, tca::TjStuff::cots, tca::ShowerStruct3D::ID, tca::TjStuff::showers, and ss.

Referenced by tca::MCParticleListUtils::MakeCheatShower(), and tca::TruthMatcher::StudyShowerParents().

   {
     // Store a 3D shower. This function sets the 3S -> 2S assns using CotIDs and ensures
     // that the 2S -> 3S assns are OK. 
     
     std::string fcnLabel = inFcnLabel + ".S3S";
     if(ss3.ID <= 0) {
       std::cout<<fcnLabel<<" Invalid ID";
       return false;
     }
     if(ss3.CotIDs.size() < 2) {
       std::cout<<fcnLabel<<" not enough CotIDs";
       return false;
     }
     
     // check the 2S -> 3S assns
     for(auto& ss : tjs.cots) {
       if(ss.ID == 0) continue;
       if(ss.SS3ID == ss3.ID && std::find(ss3.CotIDs.begin(), ss3.CotIDs.end(), ss.ID) == ss3.CotIDs.end()) {
         std::cout<<fcnLabel<<" Bad assn: 2S"<<ss.ID<<" -> 3S"<<ss3.ID<<" but it's not inCotIDs.\n";
         return false;
       }
     } // ss
     
     // check the 3S -> 2S assns
     for(auto cid : ss3.CotIDs) {
       if(cid <= 0 || cid > (int)tjs.cots.size()) return false;
       auto& ss = tjs.cots[cid - 1];
       if(ss.SS3ID > 0 && ss.SS3ID != ss3.ID) {
         std::cout<<fcnLabel<<" Bad assn: 3S"<<ss3.ID<<" -> 2S"<<cid<<" but 2S -> 3S"<<ss.SS3ID<<"\n";
         return false;
       }
     } // cid
     
     // set the 2S -> 3S assns
     for(auto cid : ss3.CotIDs) tjs.cots[cid - 1].SS3ID = ss3.ID;
     
     tjs.showers.push_back(ss3);
     return true;
     
   } // StoreShower

bool tca::StoreShower	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct &	ss
	)

Definition at line 4511 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::ShowerStruct::Cheat, tca::TjStuff::cots, tca::Trajectory::ID, tca::ShowerStruct::ID, kShwrParent, tca::ShowerStruct::ParentID, tca::Trajectory::SSID, and tca::ShowerStruct::TjIDs.

Referenced by CompleteIncompleteShower(), FindShowers3D(), Match2DShowers(), and MergeShowers().

   {
     // Store a ShowerStruct
     std::string fcnLabel = inFcnLabel + ".S2S";
     if(ss.ID <= 0) {
       std::cout<<fcnLabel<<" Invalid ID";
       return false;
     }
     if(!ss.Cheat && ss.TjIDs.empty()) {
       std::cout<<fcnLabel<<" Fail: No TjIDs in 2S"<<ss.ID<<"\n";
       return false;
     }
     if(ss.ParentID > 0) {
       if(ss.ParentID > (int)tjs.allTraj.size()) {
         std::cout<<fcnLabel<<" Fail: 2S"<<ss.ID<<" has an invalid ParentID T"<<ss.ParentID<<"\n";
         return false;
       }
       if(std::find(ss.TjIDs.begin(), ss.TjIDs.end(), ss.ParentID) != ss.TjIDs.end()) {
         std::cout<<fcnLabel<<" Fail: 2S"<<ss.ID<<" ParentID is not in TjIDs.\n";
         return false;
       }
     } // ss.ParentID > 0
 
     // check the ID
     if(ss.ID != (int)tjs.cots.size() + 1) {
       std::cout<<fcnLabel<<" Correcting the ID 2S"<<ss.ID<<" -> 2S"<<tjs.cots.size() + 1;
       ss.ID = tjs.cots.size() + 1;
     }
     
     // set the tj shower bits
     for(auto& tjID : ss.TjIDs) {
       Trajectory& tj = tjs.allTraj[tjID - 1];
       tj.SSID = ss.ID;
       tj.AlgMod[kShwrParent] = false;
       if(tj.ID == ss.ParentID) tj.AlgMod[kShwrParent] = true;
     } // tjID
     tjs.cots.push_back(ss);
     return true;
     
   } // StoreShower

bool tca::StoreTraj	(	TjStuff &	tjs,
		Trajectory &	tj
	)

Definition at line 1095 of file Utils.cxx.

References tca::TjStuff::allTraj, debug, tca::Trajectory::DirFOM, tca::Trajectory::EndPt, tca::TjStuff::fHits, tca::DebugStuff::Hit, tca::Trajectory::ID, tca::Trajectory::ParentID, PrintHit(), tca::Trajectory::Pts, ReleaseHits(), SetEndPoints(), tca::Trajectory::StepDir, TjDirFOM(), UpdateTjChgProperties(), and tca::Trajectory::WorkID.

Referenced by tca::TrajClusterAlg::FindVtxTraj(), tca::TrajClusterAlg::MakeJunkTraj(), MergeAndStore(), MergePFPTjs(), and tca::TrajClusterAlg::ReconstructAllTraj().

   {
     
     if(!(tj.StepDir == 1 || tj.StepDir == -1)) {
       mf::LogError("TC")<<"StoreTraj: Invalid StepDir "<<tj.StepDir;
       return false;
     }
     
     if(tjs.allTraj.size() >= USHRT_MAX) {
       mf::LogError("TC")<<"StoreTraj: Too many trajectories "<<tjs.allTraj.size();
       return false;
     }
     
     // This shouldn't be necessary but do it anyway
     SetEndPoints(tjs, tj);
     
     if(tj.EndPt[1] <= tj.EndPt[0]) return false;
     if(tj.EndPt[1] > tj.Pts.size()) return false;
     unsigned short npts = tj.EndPt[1] - tj.EndPt[0] + 1;
     if(npts < 2) return false;
     
     auto& endTp0 = tj.Pts[tj.EndPt[0]];
     auto& endTp1 = tj.Pts[tj.EndPt[1]];
     
     // Calculate the charge near the end and beginning if necessary. This must be a short
     // trajectory. Find the average using 4 points
     if(endTp0.AveChg <= 0) {
       unsigned short cnt = 0;
       float sum = 0;
       for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
         if(tj.Pts[ipt].Chg == 0) continue;
         sum += tj.Pts[ipt].Chg;
         ++cnt;
         if(cnt == 4) break;
       }
       tj.Pts[tj.EndPt[0]].AveChg = sum / (float)cnt;
     }
     if(endTp1.AveChg <= 0 && npts < 5) endTp1.AveChg = endTp0.AveChg;
     if(endTp1.AveChg <= 0) {
       float sum = 0;
       unsigned short cnt = 0;
       for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
         short ipt = tj.EndPt[1] - ii;
         if(ipt < 0) break;
         if(tj.Pts[ipt].Chg == 0) continue;
         sum += tj.Pts[ipt].Chg;
         ++cnt;
         if(cnt == 4) break;
         if(ipt == 0) break;
       } // ii
       tj.Pts[tj.EndPt[1]].AveChg = sum / (float)cnt;
     } // begin charge == end charge
     
     
     tj.DirFOM = TjDirFOM(tjs, tj, false);
     UpdateTjChgProperties("ST",  tjs, tj, false);
     
     int trID = tjs.allTraj.size() + 1;
 
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       for(unsigned short ii = 0; ii < tj.Pts[ipt].Hits.size(); ++ii) {
         if(tj.Pts[ipt].UseHit[ii]) {
           unsigned int iht = tj.Pts[ipt].Hits[ii];
           if(tjs.fHits[iht].InTraj > 0) {
             mf::LogWarning("TC")<<"StoreTraj: Failed trying to store hit "<<PrintHit(tjs.fHits[iht])<<" in T"<<trID<<" but it is used in T"<<tjs.fHits[iht].InTraj<<" with WorkID "<<tjs.allTraj[tjs.fHits[iht].InTraj-1].WorkID<<" Print and quit";
 //            PrintTrajectory("ST", tjs, tj, USHRT_MAX);
             ReleaseHits(tjs, tj);
             return false;
           } // error
           tjs.fHits[iht].InTraj = trID;
         }
       } // ii
     } // ipt
     
     // ensure that inTraj is clean for the ID
     for(unsigned int iht = 0; iht < tjs.fHits.size(); ++iht) {
       if(tjs.fHits[iht].InTraj == tj.ID) {
         mf::LogWarning("TC")<<"StoreTraj: Hit "<<PrintHit(tjs.fHits[iht])<<" thinks it belongs to T"<<tj.ID<<" but it isn't in the Tj\n";
 //        PrintTrajectory("ST", tjs, tj, USHRT_MAX);
         return false;
       }
     } // iht
     
     tj.WorkID = tj.ID;
     tj.ID = trID;
     // Don't clobber the ParentID if it was defined by the calling function
     if(tj.ParentID == 0) tj.ParentID = trID;
     tjs.allTraj.push_back(tj);
 //    if(prt) mf::LogVerbatim("TC")<<"StoreTraj trID "<<trID<<" CTP "<<tj.CTP<<" EndPts "<<tj.EndPt[0]<<" "<<tj.EndPt[1];
     if(debug.Hit != UINT_MAX) {
       // print out some debug info
       for(unsigned short ipt = 0; ipt < tj.Pts.size(); ++ipt) {
         for(unsigned short ii = 0; ii < tj.Pts[ipt].Hits.size(); ++ii) {
           unsigned int iht = tj.Pts[ipt].Hits[ii];
           if(iht == debug.Hit) std::cout<<"Debug hit appears in trajectory w WorkID "<<tj.WorkID<<" UseHit "<<tj.Pts[ipt].UseHit[ii]<<"\n";
         } // ii
       } // ipt
     } // debug.Hit ...
     
     return true;
     
   } // StoreTraj

bool tca::StoreVertex	(	TjStuff &	tjs,
		VtxStore &	vx
	)

Definition at line 1911 of file TCVertex.cxx.

References tca::TjStuff::allTraj, tca::VtxStore::CTP, tca::VtxStore::ID, kKilled, tca::VtxStore::NTraj, tca::VtxStore::Topo, and tca::TjStuff::vtx.

Referenced by CheckTrajBeginChg(), CompleteIncomplete3DVertices(), CompleteIncomplete3DVerticesInGaps(), tca::TrajClusterAlg::EndMerge(), Find2DVertices(), FindHammerVertices(), FindHammerVertices2(), FindNeutralVertices(), MakeJunkVertices(), Split3DKink(), tca::TrajClusterAlg::SplitHiChgHits(), and SplitTraj().

   {
     // jacket around the push to ensure that the Tj and vtx CTP is consistent.
     // The calling function should score the vertex after the trajectories are attached
     
     if(vx.ID != int(tjs.vtx.size() + 1)) {
       mf::LogVerbatim("TC")<<"StoreVertex: Invalid ID "<<vx.ID<<" It should be "<<tjs.vtx.size() + 1;
       return false;
     }
     
     unsigned short nvxtj = 0;
     unsigned short nok = 0;
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       if(vx.ID == tj.VtxID[0] || vx.ID == tj.VtxID[1]) ++nvxtj;
       if(vx.CTP != tj.CTP) continue;
       if(vx.ID == tj.VtxID[0] || vx.ID == tj.VtxID[1]) ++nok;
     } // tj
     
     if(nok != nvxtj) {
       mf::LogVerbatim("TC")<<"StoreVertex: vertex "<<vx.ID<<" Topo "<<vx.Topo<<" has inconsistent CTP code "<<vx.CTP<<" with one or more Tjs\n";
       for(auto& tj : tjs.allTraj) {
         if(tj.AlgMod[kKilled]) continue;
         if(tj.VtxID[0] == vx.ID) tj.VtxID[0] = 0;
         if(tj.VtxID[1] == vx.ID) tj.VtxID[1] = 0;
       }
       return false;
     }
     vx.NTraj = nok;
     tjs.vtx.push_back(vx);
     return true;
     
   } // StoreVertex

void tca::TagDeltaRays	(	TjStuff &	tjs,
		const CTP_t &	inCTP
	)

Definition at line 2985 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::DebugStuff::CTP, tca::Trajectory::CTP, debug, DeltaAngle(), tca::TjStuff::DeltaRayTag, tca::Trajectory::EndPt, tca::Trajectory::ID, kDeltaRay, tca::TjStuff::KinkCuts, kKilled, tca::Trajectory::MCSMom, tca::Trajectory::ParentID, tca::Trajectory::PDGCode, PointTrajDOCA(), PosSep(), PrintPos(), tca::Trajectory::Pts, ReverseTraj(), tca::Trajectory::StepDir, tca::DebugStuff::Tick, TrajTrajDOCA(), tca::TjStuff::UseAlg, and tca::TjStuff::Vertex2DCuts.

Referenced by DotProd(), and tca::TrajClusterAlg::ReconstructAllTraj().

   {
     // DeltaRayTag vector elements
     // [0] = max separation of both endpoints from a muon
     // [1] = minimum MCSMom
     // [2] = maximum MCSMom
     
     if(!tjs.UseAlg[kDeltaRay]) return;
     if(tjs.DeltaRayTag[0] < 0) return;
     if(tjs.DeltaRayTag.size() < 3) return;
     
     bool prt = (debug.CTP == inCTP) && (debug.Tick == 31313);
 
     // double the user-defined separation cut. We will require that at least one of the ends of 
     // a delta ray be within the user-defined cut and allow
     float maxSep = 2 * tjs.DeltaRayTag[0];
     float maxMinSep = tjs.DeltaRayTag[0];
     unsigned short minMom = tjs.DeltaRayTag[1];
     unsigned short maxMom = tjs.DeltaRayTag[2];
     unsigned short minMuonLength = 2 * tjs.Vertex2DCuts[2];
     unsigned short minpts = 4;
     if(prt) mf::LogVerbatim("TC")<<"TagDeltaRays: maxSep "<<maxSep<<" maxMinSep "<<maxMinSep<<" Mom range "<<minMom<<" to "<<maxMom<<" minpts "<<minpts;
     
     for(unsigned short itj = 0; itj < tjs.allTraj.size(); ++itj) {
       Trajectory& muTj = tjs.allTraj[itj];
       if(muTj.CTP != inCTP) continue;
       if(muTj.AlgMod[kKilled]) continue;
       if(muTj.PDGCode != 13) continue;
       if(prt) mf::LogVerbatim("TC")<<"TagDeltaRays: Muon T"<<muTj.ID<<" EndPts "<<PrintPos(tjs, muTj.Pts[muTj.EndPt[0]])<<"-"<<PrintPos(tjs, muTj.Pts[muTj.EndPt[1]]);
       // min length
       if(muTj.EndPt[1] - muTj.EndPt[0] < minMuonLength) continue;
       auto& mtp0 = muTj.Pts[muTj.EndPt[0]];
       auto& mtp1 = muTj.Pts[muTj.EndPt[1]];
       // Found a muon, now look for delta rays
       for(unsigned short jtj = 0; jtj < tjs.allTraj.size(); ++jtj) {
         if(jtj == itj) continue;
         Trajectory& dtj = tjs.allTraj[jtj];
         if(dtj.AlgMod[kKilled]) continue;
         if(dtj.CTP != inCTP) continue;
         if(dtj.PDGCode == 13) continue;
         // MCSMom cut
         if(dtj.MCSMom < minMom) continue;
         if(dtj.MCSMom > maxMom) continue;
         if(dtj.EndPt[1] - dtj.EndPt[0] < minpts) continue;
         // some rough cuts to require that the delta ray is within the
         // ends of the muon
         auto& dtp0 = dtj.Pts[dtj.EndPt[0]];
         auto& dtp1 = dtj.Pts[dtj.EndPt[1]];
         if(muTj.StepDir > 0) {
           if(dtp0.Pos[0] < mtp0.Pos[0]) continue;
           if(dtp1.Pos[0] > mtp1.Pos[0]) continue;
         } else {
           if(dtp0.Pos[0] > mtp0.Pos[0]) continue;
           if(dtp1.Pos[0] < mtp1.Pos[0]) continue;
         }
         // find the minimum separation
         float doca = maxMinSep;
         unsigned short mpt = 0;
         unsigned short dpt = 0;
         TrajTrajDOCA(tjs, muTj, dtj, mpt, dpt, doca, false);
         if(doca == maxMinSep) continue;
         auto& dTp = dtj.Pts[dpt];
         // cut on the distance from the muon ends
         if(PosSep(dTp.Pos, mtp0.Pos) < tjs.Vertex2DCuts[2]) continue;
         if(PosSep(dTp.Pos, mtp1.Pos) < tjs.Vertex2DCuts[2]) continue;
        // make an angle cut at this point. A delta-ray should have a small angle
         float dang = DeltaAngle(muTj.Pts[mpt].Ang, dtj.Pts[dpt].Ang);
         if(prt) mf::LogVerbatim("TC")<<" dRay? T"<<dtj.ID<<" at "<<PrintPos(tjs, dtj.Pts[dpt].Pos)<<" dang "<<dang<<" doca "<<doca;
         // ignore the angle cut if the separation is small and the delta ray MCSMom is low
         bool closeDeltaRay = (doca < 2 && dtj.MCSMom < 20);
         if(!closeDeltaRay && dang > tjs.KinkCuts[0]) continue;
         // Feb 7, 2018
 //        if(dang > tjs.KinkCuts[0]) continue;
         unsigned short oend = 0;
         // check the delta at the end of the delta-ray that is farthest away from the
         // closest point
         if(dpt > 0.5 * (dtj.EndPt[0] + dtj.EndPt[1])) oend = 1;
         auto& farEndTP = dtj.Pts[dtj.EndPt[oend]];
         float farEndDelta = PointTrajDOCA(tjs, farEndTP.Pos[0], farEndTP.Pos[1], muTj.Pts[mpt]);
         if(prt) mf::LogVerbatim("TC")<<"  farEnd "<<PrintPos(tjs, farEndTP.Pos)<<" farEndDelta "<<farEndDelta;
         if(farEndDelta > maxSep) continue;
         if(prt) mf::LogVerbatim("TC")<<"   delta ray "<<dtj.ID<<" parent -> "<<muTj.ID;
         dtj.ParentID = muTj.ID;
         dtj.PDGCode = 11;
         dtj.AlgMod[kDeltaRay] = true;
         // Set the start of the delta-ray to be end 0
         if(oend != 1) ReverseTraj(tjs, dtj);
       } // jtj
     } // itj
     
   } // TagDeltaRays

void tca::TagJunkTj	(	TjStuff const &	tjs,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 2309 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::ID, kJunkTj, and tca::Trajectory::Pts.

Referenced by tca::TrajClusterAlg::CheckTraj().

   {
     // Characterizes the trajectory as a junk tj even though it may not
     // have been reconstructed in FindJunkTraj. The distinguishing feature is
     // that it is short and has many used hits in each trajectory point.
     
     // Don't bother if it is too long
     if(tj.Pts.size() > 10) return;
     // count the number of points that have many used hits
     unsigned short nhm = 0;
     unsigned short npwc = 0;
     for(auto& tp : tj.Pts) {
       if(tp.Chg == 0) continue;
       ++npwc;
       unsigned short nused = 0;
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         if(tp.UseHit[ii]) ++nused;
       } // ii
       if(nused > 3) ++nhm;
     } // tp
     // Set the junkTj bit if most of the hits are used in most of the tps
     if(nhm > 0.5 * npwc) tj.AlgMod[kJunkTj] = true;
     if(prt) mf::LogVerbatim("TC")<<"TGT: T"<<tj.ID<<" npwc "<<npwc<<" nhm "<<nhm<<" junk? "<<tj.AlgMod[kJunkTj];
   } // TagJunkTj

void tca::TagMuonDirections	(	TjStuff &	tjs,
		short	debugWorkID
	)

Definition at line 3078 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::Trajectory::CTP, tca::Trajectory::EndPt, tca::Trajectory::ID, kKilled, tca::TjStuff::MuonTag, tca::Trajectory::PDGCode, PrintPos(), tca::Trajectory::Pts, ReverseTraj(), tca::Trajectory::StepDir, and tca::Trajectory::WorkID.

Referenced by DotProd(), and tca::TrajClusterAlg::RunTrajClusterAlg().

   {
     // Determine muon directions delta-ray proximity to muon trajectories
     
     if(tjs.MuonTag[0] < 0) return;
     
     unsigned short minLen = tjs.MuonTag[3];
     
     for(unsigned short itj = 0; itj < tjs.allTraj.size(); ++itj) {
       Trajectory& muTj = tjs.allTraj[itj];
       if(muTj.AlgMod[kKilled]) continue;
       bool prt = (debugWorkID < 0 && muTj.WorkID == debugWorkID);
       if(prt) {
         mf::LogVerbatim("TC")<<"TagMuonDirection: Muon "<<muTj.CTP<<" "<<PrintPos(tjs, muTj.Pts[muTj.EndPt[0]])<<"-"<<PrintPos(tjs, muTj.Pts[muTj.EndPt[1]]);
       }
       if(muTj.PDGCode != 13) continue;
       // look for delta ray trajectories and count the number of times that
       unsigned short nPos = 0;
       unsigned short nNeg = 0;
       for(auto& dtj : tjs.allTraj) {
         if(dtj.AlgMod[kKilled]) continue;
         if(dtj.ParentID != muTj.ID) continue;
         if(dtj.EndPt[1] - dtj.EndPt[0] > minLen) continue;
         if(dtj.StepDir > 0) {
           ++nPos;
         } else {
           ++nNeg;
         }
       } // dtj
       if(nPos == nNeg) continue;
       if(nPos > nNeg) {
         if(muTj.StepDir < 0) ReverseTraj(tjs, muTj);
       } else {
         if(muTj.StepDir > 0) ReverseTraj(tjs, muTj);
       }
 //      muTj.AlgMod[kSetDir] = true;
     } // itj
   } // TagMuonDirections

void tca::TagShowerLike	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		const CTP_t &	inCTP
	)

Definition at line 3700 of file TCShower.cxx.

References tca::TjStuff::allTraj, evd::details::begin(), tca::TjStuff::ChargeCuts, evd::details::end(), tca::Trajectory::EndPt, FarEnd(), GetAssns(), tca::Trajectory::ID, kBragg, kKilled, kSetDir, kShowerLike, kShowerTj, MakeVertexObsolete(), NumPtsWithCharge(), PosSep(), tca::Trajectory::Pts, tca::TjStuff::ShowerTag, TrajTrajDOCA(), and tca::TjStuff::vtx.

Referenced by tca::TrajClusterAlg::ReconstructAllTraj().

   {
     // Tag Tjs as InShower if they have MCSMom < ShowerTag[0] and there are more than
     // ShowerTag[6] other Tjs with a separation < ShowerTag[1].     
     
     if(tjs.ShowerTag[0] <= 0) return;
     
     if(tjs.allTraj.size() > 20000) return;
     
     // evaluate different cuts
     bool newCuts = (tjs.ShowerTag[0] > 2);
     float typicalChgRMS = 0.5 * (tjs.ChargeCuts[1] + tjs.ChargeCuts[2]);
     
     // clear out old tags and make a list of Tjs to consider
     std::vector<std::vector<int>> tjLists;
     std::vector<int> tjids;
     for(auto& tj : tjs.allTraj) {
       if(tj.CTP != inCTP) continue;
       if(tj.AlgMod[kKilled]) continue;
       tj.AlgMod[kShowerLike] = false;
       if(tj.AlgMod[kShowerTj]) continue;
       // ignore Tjs with Bragg peaks
       bool skipit = false;
       for(unsigned short end = 0; end < 2; ++end) if(tj.StopFlag[end][kBragg]) skipit = true;
       if(skipit) continue;
       short npwc = NumPtsWithCharge(tjs, tj, false);
       if(newCuts) {
         // evaluate different cuts
         // Don't expect any (primary) electron to be reconstructed as a single trajectory for
         // more than ~2 radiation lengths ~ 30 cm for uB ~ 100 wires 
         if(npwc > 100) continue;
         // allow short Tjs.
         if(npwc > 5) {
           // Increase the MCSMom cut if the Tj is long and the charge RMS is high to reduce sensitivity 
           // to the fcl configuration. A primary electron may be reconstructed as one long Tj with large
           // charge rms and possibly high MCSMom or as several nearby shorter Tjs with lower charge rms
           float momCut = tjs.ShowerTag[1];
           if(tj.ChgRMS > typicalChgRMS) momCut *= tj.ChgRMS / typicalChgRMS;
           if(tj.MCSMom > momCut) continue;
         }
       } else {
         if(npwc < 3) continue;
         if(npwc > 4 && tj.MCSMom > tjs.ShowerTag[1]) continue;
       }
       tjids.push_back(tj.ID);
     } // tj
     
     if(tjids.size() < 2) return;
 
     for(unsigned short it1 = 0; it1 < tjids.size() - 1; ++it1) {
       Trajectory& tj1 = tjs.allTraj[tjids[it1] - 1];
       float len1 = PosSep(tj1.Pts[tj1.EndPt[1]].Pos, tj1.Pts[tj1.EndPt[0]].Pos);
       for(unsigned short it2 = it1 + 1; it2 < tjids.size(); ++it2) {
         Trajectory& tj2 = tjs.allTraj[tjids[it2] - 1];
         unsigned short ipt1, ipt2;
         float doca = tjs.ShowerTag[2];
         // Find the separation between Tjs without considering dead wires
         TrajTrajDOCA(tjs, tj1, tj2, ipt1, ipt2, doca, false);
         if(doca == tjs.ShowerTag[2]) continue;
         // make tighter cuts for user-defined short Tjs
         float len2 = PosSep(tj2.Pts[tj2.EndPt[1]].Pos, tj2.Pts[tj2.EndPt[0]].Pos);
         if(!newCuts) {
           if(len1 < len2 && len1 < doca) {
             if(len1 < doca) continue;
           } else {
             if(len2 < doca) continue;
           }
         } // !newCuts
         // found a close pair. See if one of these is in an existing cluster of Tjs
         bool inlist = false;
         for(unsigned short it = 0; it < tjLists.size(); ++it) {
           bool tj1InList = (std::find(tjLists[it].begin(), tjLists[it].end(), tj1.ID) != tjLists[it].end());
           bool tj2InList = (std::find(tjLists[it].begin(), tjLists[it].end(), tj2.ID) != tjLists[it].end());
           if(tj1InList || tj2InList) {
             // add the one that is not in the list
             if(!tj1InList) tjLists[it].push_back(tj1.ID);
             if(!tj2InList) tjLists[it].push_back(tj2.ID);
             inlist = true;
             break;
           }
           if(inlist) break;
         } // it
         // start a new list with this pair?
         if(!inlist) {
           std::vector<int> newlist(2);
           newlist[0] = tj1.ID;
           newlist[1] = tj2.ID;
           tjLists.push_back(newlist);
         }
       } // it2
     } // it1
     if(tjLists.empty()) return;
 
     // mark them all as ShowerLike Tjs
     unsigned short nsh = 0;
     for(auto& tjl : tjLists) {
       nsh += tjl.size();
       for(auto& tjID : tjl) {
         auto& tj = tjs.allTraj[tjID - 1];
         tj.AlgMod[kShowerLike] = true;
         // unset flags
         tj.AlgMod[kSetDir] = false;
       } // tjid
     } // tjl
     
     // kill vertices with more than 1 shower-like tj that is close to the
     // vertex
     unsigned short nkill = 0;
     for(auto& vx2 : tjs.vtx) {
       if(vx2.ID == 0) continue;
       if(vx2.CTP != inCTP) continue;
       auto TInV2 = GetAssns(tjs, "2V", vx2.ID, "T");
       unsigned short nsl = 0;
       for(auto tid : TInV2) {
         auto& tj = tjs.allTraj[tid - 1];
         if(tj.AlgMod[kShowerLike]) {
           unsigned short nearEnd = 1 - FarEnd(tjs, tj, vx2.Pos);
           if(PosSep(tj.Pts[tj.EndPt[nearEnd]].Pos, vx2.Pos) < 6) ++nsl;
         }
       } // tid
       if(nsl < 2) continue;
       MakeVertexObsolete(tjs, vx2, true);
       ++nkill;
     } // vx2
     if(tjs.ShowerTag[12] >= 0) mf::LogVerbatim("TC")<<"TagShowerLike tagged "<<nsh<<" Tjs and killed "<<nkill<<" vertices in CTP "<<inCTP;
 
   } // TagShowerLike

void tca::TjDeltaRMS	(	TjStuff &	tjs,
		Trajectory &	tj,
		unsigned short	firstPt,
		unsigned short	lastPt,
		double &	rms,
		unsigned short &	cnt
	)

Definition at line 2951 of file Utils.cxx.

References tca::Trajectory::EndPt, tca::TrajPoint::HitPos, MakeBareTrajPoint(), NearestPtWithChg(), PointTrajDOCA2(), tca::TrajPoint::Pos, tca::Trajectory::Pts, and tmp.

Referenced by DotProd(), and MCSThetaRMS().

   {
     // returns the rms scatter of points around a line formed by the firstPt and lastPt of the trajectory
     
     rms = -1;
     if(firstPt < tj.EndPt[0]) return;
     if(lastPt > tj.EndPt[1]) return;
     
     firstPt = NearestPtWithChg(tjs, tj, firstPt);
     lastPt = NearestPtWithChg(tjs, tj, lastPt);
     if(firstPt >= lastPt) return;
     
     TrajPoint tmp;
     // make a bare trajectory point to define a line between firstPt and lastPt.
     // Use the position of the hits at these points
     TrajPoint firstTP = tj.Pts[firstPt];
     firstTP.Pos = firstTP.HitPos;
     TrajPoint lastTP = tj.Pts[lastPt];
     lastTP.Pos = lastTP.HitPos;
     if(!MakeBareTrajPoint(tjs, firstTP, lastTP, tmp)) return;
     // sum up the deviations^2
     double dsum = 0;
     cnt = 0;
     for(unsigned short ipt = firstPt + 1; ipt < lastPt; ++ipt) {
       if(tj.Pts[ipt].Chg == 0) continue;
       dsum += PointTrajDOCA2(tjs, tj.Pts[ipt].HitPos[0],  tj.Pts[ipt].HitPos[1], tmp);
       ++cnt;
     } // ipt
     if(cnt < 2) return;
     rms = sqrt(dsum / (double)cnt);
 
   } // TjDeltaRMS

float tca::TjDirFOM	(	const TjStuff &	tjs,
		const Trajectory &	tj,
		bool	prt
	)

Definition at line 906 of file Utils.cxx.

References tca::Trajectory::AlgMod, B, tca::Trajectory::EndPt, tca::Trajectory::ID, kEnvOverlap, kKilled, geo::origin(), PosSep(), PrintPos(), tca::Trajectory::Pts, w, x, and y.

Referenced by StoreTraj().

   {
     // Calculate a FOM for the tj to be going from EndPt[0] -> EndPt[1] (FOM = 1)
     // or EndPt[1] -> EndPt[0] (FOM = -1) by finding the overall charge slope, weighted
     // by the presence of nearby InShower Tjs
     if(tj.AlgMod[kKilled]) return 0;
     if(tj.EndPt[1] - tj.EndPt[0] < 8) return 0;
 
     std::vector<double> x, y;
     Point2_t origin = tj.Pts[tj.EndPt[0]].HitPos;
     std::vector<double> w, q;
     
     unsigned short firstPt = tj.EndPt[0] + 2;
     unsigned short lastPt = tj.EndPt[1] - 2;
     if(lastPt < firstPt + 3) return 0;
     // don't include end points
     for(unsigned short ipt = firstPt; ipt <= lastPt; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if(tp.Chg <= 0) continue;
       // only consider points that don't overlap with other tjs
       if(tp.Environment[kEnvOverlap]) continue;
       double sep = PosSep(tp.Pos, origin);
       x.push_back(sep);
       y.push_back((double)tp.Chg);
       double wght = 0.2 * tp.Chg;
       w.push_back(wght * wght);
     } // tp
     if(w.size() < 3) return 0;
     
     double sum = 0.;
     double sumx = 0.;
     double sumy = 0.;
     double sumxy = 0.;
     double sumx2 = 0.;
     double sumy2 = 0.;
     
     // weight by the charge ratio and accumulate sums
     double wght;
     for(unsigned short ipt = 0; ipt < x.size(); ++ipt) {
       wght = 1 / w[ipt];
       sum   += wght;
       sumx  += wght * x[ipt];
       sumy  += wght * y[ipt];
       sumx2 += wght * x[ipt] * x[ipt];
       sumy2 += wght * y[ipt] * y[ipt];
       sumxy += wght * x[ipt] * y[ipt];
     }
     // calculate coefficients and std dev
     double delta = sum * sumx2 - sumx * sumx;
     if(delta == 0) return 0;
     // A is the intercept
     double A = (sumx2 * sumy - sumx * sumxy) / delta;
     // B is the slope
     double B = (sumxy * sum  - sumx * sumy) / delta;
     
     // Calculate the FOM
     double ndof = x.size() - 2;
     double varnce = (sumy2 + A*A*sum + B*B*sumx2 - 2 * (A*sumy + B*sumxy - A*B*sumx)) / ndof;
     if(varnce <= 0) return 0;
     double BErr = sqrt(varnce * sum / delta);
     // scale the error so that the significance is +/-1 when the slope is 3 * error
     // Note that the error is correct only if the average Chi/DOF = 1 which is probably not the case
     float slopeSig = B / (3 * BErr);
     if(slopeSig > 1) slopeSig = 1;
     if(slopeSig < -1) slopeSig = -1;
     // rescale it to be in the range of 0 - 1
     slopeSig = (1 + slopeSig) / 2;
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"TjDir: T"<<tj.ID<<" slope "<<std::fixed<<std::setprecision(1)<<B<<" error "<<BErr<<" DirFOM "<<slopeSig;
       myprt<<" using points from "<<PrintPos(tjs, tj.Pts[firstPt])<<" "<<PrintPos(tjs, tj.Pts[lastPt]);
     } // prt
     return slopeSig;
 
   } // TjDirFOM

float tca::TPHitsRMSTick	(	TjStuff &	tjs,
		TrajPoint &	tp,
		HitStatus_t	hitRequest
	)

Definition at line 3582 of file Utils.cxx.

References tca::TjStuff::fHits, tca::TrajPoint::Hits, kAllHits, kUnusedHits, kUsedHits, and tca::TrajPoint::UseHit.

Referenced by DotProd(), tca::TrajClusterAlg::FindUseHits(), and TPHitsRMSTime().

   {
     // Estimate the RMS of all hits associated with a trajectory point
     // without a lot of calculation
     if(tp.Hits.empty()) return 0;
     float minVal = 9999;
     float maxVal = 0;
     for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
       bool useit = (hitRequest == kAllHits);
       if(hitRequest == kUsedHits && tp.UseHit[ii]) useit = true;
       if(hitRequest == kUnusedHits && !tp.UseHit[ii]) useit = true;
       if(!useit) continue;
       unsigned int iht = tp.Hits[ii];
       float cv = tjs.fHits[iht].PeakTime;
       float rms = tjs.fHits[iht].RMS;
       float arg = cv - rms;
       if(arg < minVal) minVal = arg;
       arg = cv + rms;
       if(arg > maxVal) maxVal = arg;
     } // ii
     if(maxVal == 0) return 0;
     return (maxVal - minVal) / 2;
   } // TPHitsRMSTick

float tca::TPHitsRMSTime	(	TjStuff &	tjs,
		TrajPoint &	tp,
		HitStatus_t	hitRequest
	)

Definition at line 3576 of file Utils.cxx.

References TPHitsRMSTick(), and tca::TjStuff::UnitsPerTick.

Referenced by DotProd(), and FillmAllTraj().

   {
     return tjs.UnitsPerTick * TPHitsRMSTick(tjs, tp, hitRequest);
   } // TPHitsRMSTime

unsigned short tca::TPNearVertex	(	TjStuff &	tjs,
		const TrajPoint &	tp
	)

Definition at line 1637 of file TCVertex.cxx.

References tca::TrajPoint::CTP, tca::TrajPoint::Pos, and tca::TjStuff::vtx.

Referenced by tca::TrajClusterAlg::StepCrawl().

   {
     // Returns the index of a vertex if tp is nearby
     for(unsigned short ivx = 0; ivx < tjs.vtx.size(); ++ivx) {
       if(tjs.vtx[ivx].ID == 0) continue;
       if(tjs.vtx[ivx].CTP != tp.CTP) continue;
       if(std::abs(tjs.vtx[ivx].Pos[0] - tp.Pos[0]) > 1.2) continue;
       if(std::abs(tjs.vtx[ivx].Pos[1] - tp.Pos[1]) > 1.2) continue;
       return ivx;
     } // ivx
     return USHRT_MAX;
   } // TPNearVertex

float tca::TpSumHitChg	(	TjStuff &	tjs,
		TrajPoint const &	tp
	)

Definition at line 1678 of file Utils.cxx.

References tca::TjStuff::fHits, tca::TrajPoint::Hits, and tca::TrajPoint::UseHit.

Referenced by tca::TrajClusterAlg::SplitHiChgHits(), and VtxHitsSwap().

                                                       {
     float totchg = 0;
     for (size_t i = 0; i<tp.Hits.size(); ++i){
       if (!tp.UseHit[i]) continue;
       totchg += tjs.fHits[tp.Hits[i]].Integral;
     }
     return totchg;
   } // TpSumHitChg

bool tca::TrajClosestApproach	(	Trajectory const &	tj,
		float	x,
		float	y,
		unsigned short &	closePt,
		float &	DOCA
	)

Definition at line 2244 of file Utils.cxx.

References tca::Trajectory::EndPt, tca::Trajectory::Pts, x, and y.

Referenced by AttachTrajToVertex(), CompatibleMerge(), Find2DVertices(), FindHammerVertices2(), and SplitTrajCrossingVertices().

   {
     // find the closest approach between a trajectory tj and a point (x,y). Returns
     // the index of the closest trajectory point and the distance. Returns false if none
     // of the points on the tj are within DOCA
     
     float close2 = DOCA * DOCA;
     closePt = 0;
     bool foundClose = false;
     
     for(unsigned short ipt = tj.EndPt[0]; ipt < tj.EndPt[1] + 1; ++ipt) {
       if(tj.Pts[ipt].Chg == 0) continue;
       float dx = tj.Pts[ipt].Pos[0] - x;
       if(std::abs(dx) > DOCA) continue;
       float dy = tj.Pts[ipt].Pos[1] - y;
       if(std::abs(dy) > DOCA) continue;
       float sep2 = dx * dx + dy * dy;
       if(sep2 < close2) {
         close2 = sep2;
         closePt = ipt;
         foundClose = true;
       }
     } // ipt
     
     DOCA = sqrt(close2);
     return foundClose;
     
   } // TrajClosestApproach

bool tca::TrajHitsOK	(	TjStuff &	tjs,
		const std::vector< unsigned int > &	iHitsInMultiplet,
		const std::vector< unsigned int > &	jHitsInMultiplet
	)

Definition at line 1563 of file Utils.cxx.

References tca::TjStuff::fHits, HitsPosTick(), and kAllHits.

Referenced by tca::TrajClusterAlg::FindJunkTraj(), and tca::TrajClusterAlg::ReconstructAllTraj().

   {
     // Hits (assume to be on adjacent wires have an acceptable signal overlap
     
     if(iHitsInMultiplet.empty() || jHitsInMultiplet.empty()) return false;
     
     float sum;
     float cvI = HitsPosTick(tjs, iHitsInMultiplet, sum, kAllHits);
     float minI = 1E6;
     float maxI = 0;
     for(auto& iht : iHitsInMultiplet) {
       float cv = tjs.fHits[iht].PeakTime;
       float rms = tjs.fHits[iht].RMS;
       float arg = cv - 3 * rms;
       if(arg < minI) minI = arg;
       arg = cv + 3 * rms;
       if(arg > maxI) maxI = arg;
     }
     
     float cvJ = HitsPosTick(tjs, jHitsInMultiplet, sum, kAllHits);
     float minJ = 1E6;
     float maxJ = 0;
     for(auto& jht : jHitsInMultiplet) {
       float cv = tjs.fHits[jht].PeakTime;
       float rms = tjs.fHits[jht].RMS;
       float arg = cv - 3 * rms;
       if(arg < minJ) minJ = arg;
       arg = cv + 3 * rms;
       if(arg > maxJ) maxJ = arg;
     }
     
     if(cvI < cvJ) {
       if(maxI > minJ) return true;
     } else {
       if(minI < maxJ) return true;
     }
     return false;
   } // TrajHitsOK

bool tca::TrajHitsOK	(	TjStuff &	tjs,
		const unsigned int	iht,
		const unsigned int	jht
	)

Definition at line 1603 of file Utils.cxx.

References tca::TCHit::ArtPtr, tca::TjStuff::fHits, tca::TCHit::PeakTime, tca::TCHit::RMS, geo::WireID::Wire, and recob::Hit::WireID().

   {
     // ensure that two adjacent hits have an acceptable overlap
     if(iht > tjs.fHits.size() - 1) return false;
     if(jht > tjs.fHits.size() - 1) return false;
     // require that they be on adjacent wires
     TCHit& ihit = tjs.fHits[iht];
     TCHit& jhit = tjs.fHits[jht];
     int iwire = ihit.ArtPtr->WireID().Wire;
     int jwire = jhit.ArtPtr->WireID().Wire;
     if(std::abs(iwire - jwire) > 1) return false;
     if(ihit.PeakTime > jhit.PeakTime) {
       float minISignal = ihit.PeakTime - 3 * ihit.RMS;
       float maxJSignal = jhit.PeakTime + 3 * ihit.RMS;
       if(maxJSignal > minISignal) return true;
     } else {
       float maxISignal = ihit.PeakTime + 3 * ihit.RMS;
       float minJSignal = jhit.PeakTime - 3 * ihit.RMS;
       if(minJSignal > maxISignal) return true;
     }
     return false;
   } // TrajHitsOK

void tca::TrajIntersection	(	TrajPoint const &	tp1,
		TrajPoint const &	tp2,
		Point2_t &	pos
	)

Definition at line 2166 of file Utils.cxx.

References TrajIntersection().

Referenced by tca::TrajClusterAlg::EndMerge(), Find2DVertices(), FindHammerVertices2(), and FitVertex().

   {
     TrajIntersection(tp1, tp2, pos[0], pos[1]);
   } // TrajIntersection

void tca::TrajIntersection	(	TrajPoint const &	tp1,
		TrajPoint const &	tp2,
		float &	x,
		float &	y
	)

Definition at line 2171 of file Utils.cxx.

References tca::TrajPoint::Dir, tca::TrajPoint::Pos, and s.

Referenced by TrajIntersection().

   {
     // returns the intersection position, (x,y), of two trajectory points
     
     x = -9999; y = -9999;
     
     double arg1 = tp1.Pos[0] * tp1.Dir[1] - tp1.Pos[1] * tp1.Dir[0];
     double arg2 = tp2.Pos[0] * tp1.Dir[1] - tp2.Pos[1] * tp1.Dir[0];
     double arg3 = tp2.Dir[0] * tp1.Dir[1] - tp2.Dir[1] * tp1.Dir[0];
     if(arg3 == 0) return;
     double s = (arg1 - arg2) / arg3;
     
     x = (float)(tp2.Pos[0] + s * tp2.Dir[0]);
     y = (float)(tp2.Pos[1] + s * tp2.Dir[1]);
     
   } // TrajIntersection

bool tca::TrajIsClean	(	TjStuff &	tjs,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 2814 of file Utils.cxx.

References tca::Trajectory::EndPt, tca::TrajPoint::Hits, tca::Trajectory::Pts, and tca::TrajPoint::UseHit.

Referenced by DotProd(), and tca::TrajClusterAlg::UpdateTraj().

   {
     // Returns true if the trajectory has low hit multiplicity and is in a
     // clean environment
     unsigned short nUsed = 0;
     unsigned short nTotHits = 0;
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       TrajPoint& tp = tj.Pts[ipt];
       nTotHits += tp.Hits.size();
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         if(tp.UseHit[ii]) ++nUsed;
       } // ii
     } // ipt
     if(nTotHits == 0) return false;
     float fracUsed = (float)nUsed / (float)nTotHits;
     if(prt) mf::LogVerbatim("TC")<<"TrajIsClean: nTotHits "<<nTotHits<<" nUsed "<<nUsed<<" fracUsed "<<fracUsed;
     
     if(fracUsed > 0.9) return true;
     return false;
     
   } // TrajIsClean

float tca::TrajLength ( Trajectory & tj )

Definition at line 2204 of file Utils.cxx.

References tca::Trajectory::EndPt, and tca::Trajectory::Pts.

Referenced by AttachTrajToVertex(), tca::TrajClusterAlg::EndMerge(), Find2DVertices(), MakeJunkVertices(), and PDGCodeVote().

   {
     float len = 0, dx, dy;
     unsigned short ipt;
     unsigned short prevPt = tj.EndPt[0];
     for(ipt = tj.EndPt[0] + 1; ipt < tj.EndPt[1] + 1; ++ipt) {
       if(tj.Pts[ipt].Chg == 0) continue;
       dx = tj.Pts[ipt].Pos[0] - tj.Pts[prevPt].Pos[0];
       dy = tj.Pts[ipt].Pos[1] - tj.Pts[prevPt].Pos[1];
       len += sqrt(dx * dx + dy * dy);
       prevPt = ipt;
     }
     return len;
   } // TrajLength

float tca::TrajPointSeparation	(	TrajPoint &	tp1,
		TrajPoint &	tp2
	)

Definition at line 2235 of file Utils.cxx.

References tca::TrajPoint::Pos.

Referenced by tca::TrajClusterAlg::EndMerge(), tca::TrajClusterAlg::GottaKink(), tca::TrajClusterAlg::MakeJunkTraj(), tca::TrajClusterAlg::MaskTrajEndPoints(), MCSMom(), MCSThetaRMS(), and tca::TrajClusterAlg::StepCrawl().

   {
     // Returns the separation distance between two trajectory points
     float dx = tp1.Pos[0] - tp2.Pos[0];
     float dy = tp1.Pos[1] - tp2.Pos[1];
     return sqrt(dx * dx + dy * dy);
   } // TrajPointSeparation

void tca::TrajPointTrajDOCA	(	TjStuff &	tjs,
		TrajPoint const &	tp,
		Trajectory const &	tj,
		unsigned short &	closePt,
		float &	minSep
	)

Definition at line 2026 of file Utils.cxx.

References tca::Trajectory::EndPt, tca::TrajPoint::Pos, and tca::Trajectory::Pts.

Referenced by CompleteIncomplete3DVertices(), FindHammerVertices(), FindHammerVertices2(), tca::TrajClusterAlg::FindMissedVxTjs(), and MergeAndStore().

   {
     // Finds the point, ipt, on trajectory tj that is closest to trajpoint tp
     float best = minSep * minSep;
     closePt = USHRT_MAX;
     float dw, dt, dp2;
     unsigned short ipt;
     for(ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       dw = tj.Pts[ipt].Pos[0] - tp.Pos[0];
       dt = tj.Pts[ipt].Pos[1] - tp.Pos[1];
       dp2 = dw * dw + dt * dt;
       if(dp2 < best) {
         best = dp2;
         closePt = ipt;
       }
     } // ipt
     minSep = sqrt(best);
   } // TrajPointTrajDOCA

float tca::TrajPointVertexPull	(	TjStuff &	tjs,
		const TrajPoint &	tp,
		const VtxStore &	vx
	)

Definition at line 1847 of file TCVertex.cxx.

References tca::TrajPoint::AngErr, tca::TrajPoint::Dir, tca::TrajPoint::HitPosErr2, PointTrajDOCA(), tca::VtxStore::Pos, tca::TrajPoint::Pos, tca::VtxStore::PosErr, and PosSep2().

Referenced by AttachTrajToVertex(), and FitVertex().

   {
     // Calculates the position pull between a trajectory point and a vertex
     
     // impact parameter between them
     double ip = PointTrajDOCA(tjs, vx.Pos[0], vx.Pos[1], tp);
     // separation^2
     double sep2 = PosSep2(vx.Pos, tp.Pos);
     
     // Find the projection of the vertex error ellipse in a coordinate system
     // along the TP direction
     double vxErrW = vx.PosErr[0] * tp.Dir[1];
     double vxErrT = vx.PosErr[1] * tp.Dir[0];
     double vxErr2 = vxErrW * vxErrW + vxErrT * vxErrT;
     // add the TP position error^2
     vxErr2 += tp.HitPosErr2;
     
     // close together so ignore the TP projection error and return
     // the pull using the vertex error and TP position error
     if(sep2 < 1) return (float)(ip/sqrt(vxErr2));
     
     double dang = ip / sqrt(sep2);
     
     // calculate the angle error.
     // Start with the vertex error^2
     double angErr = vxErr2 / sep2;
     // Add the TP angle error^2
     angErr += tp.AngErr * tp.AngErr;
     if(angErr == 0) return 999;
     angErr = sqrt(angErr);
     return (float)(dang / angErr);
     
   } // TrajPointVertexPull

bool tca::TrajTrajDOCA	(	const TjStuff &	tjs,
		const Trajectory &	tj1,
		const Trajectory &	tj2,
		unsigned short &	ipt1,
		unsigned short &	ipt2,
		float &	minSep
	)

Definition at line 2046 of file Utils.cxx.

References TrajTrajDOCA().

Referenced by tca::TrajClusterAlg::EndMerge(), Find2DVertices(), FindCots(), FindNearbyTjs(), InShowerProb(), and TagShowerLike().

   {
     return TrajTrajDOCA(tjs, tj1, tj2, ipt1, ipt2, minSep, false);
   } // TrajTrajDOCA

bool tca::TrajTrajDOCA	(	const TjStuff &	tjs,
		const Trajectory &	tj1,
		const Trajectory &	tj2,
		unsigned short &	ipt1,
		unsigned short &	ipt2,
		float &	minSep,
		bool	considerDeadWires
	)

Definition at line 2052 of file Utils.cxx.

References DeadWireCount(), tca::Trajectory::EndPt, and tca::Trajectory::Pts.

Referenced by DefineTjParents(), TagDeltaRays(), and TrajTrajDOCA().

   {
     // Find the Distance Of Closest Approach between two trajectories less than minSep
     // start with some rough cuts to minimize the use of the more expensive checking. This
     // function returns true if the DOCA is less than minSep
     for(unsigned short iwt = 0; iwt < 2; ++iwt) {
       // Apply box cuts on the ends of the trajectories
       // The Lo/Hi wire(time) at each end of tj1
       float wt0 = tj1.Pts[tj1.EndPt[0]].Pos[iwt];
       float wt1 = tj1.Pts[tj1.EndPt[1]].Pos[iwt];
       float lowt1 = wt0;
       float hiwt1 = wt1;
       if(wt1 < lowt1) {
         lowt1 = wt1;
         hiwt1 = wt0;
       }
       // The Lo/Hi wire(time) at each end of tj2
       wt0 = tj2.Pts[tj2.EndPt[0]].Pos[iwt];
       wt1 = tj2.Pts[tj2.EndPt[1]].Pos[iwt];
       float lowt2 = wt0;
       float hiwt2 = wt1;
       if(wt1 < lowt2) {
         lowt2 = wt1;
         hiwt2 = wt0;
       }
       // Check for this configuration
       //  loWire1.......hiWire1   minSep  loWire2....hiWire2
       //  loTime1.......hiTime1   minSep  loTime2....hiTime2
       if(lowt2 > hiwt1 + minSep) return false;
       // and the other
       if(lowt1 > hiwt2 + minSep) return false;
     } // iwt
 
     float best = minSep * minSep;
     ipt1 = 0; ipt2 = 0;
     float dwc = 0;
     bool isClose = false;
     for(unsigned short i1 = tj1.EndPt[0]; i1 < tj1.EndPt[1] + 1; ++i1) {
       for(unsigned short i2 = tj2.EndPt[0]; i2 < tj2.EndPt[1] + 1; ++i2) {
         if(considerDeadWires) dwc = DeadWireCount(tjs, tj1.Pts[i1], tj2.Pts[i2]);
         float dw = tj1.Pts[i1].Pos[0] - tj2.Pts[i2].Pos[0] - dwc;
         if(std::abs(dw) > minSep) continue;
         float dt = tj1.Pts[i1].Pos[1] - tj2.Pts[i2].Pos[1];
         if(std::abs(dt) > minSep) continue;
         float dp2 = dw * dw + dt * dt;
         if(dp2 < best) {
           best = dp2;
           ipt1 = i1;
           ipt2 = i2;
           isClose = true;
         }
       } // i2
     } // i1
     minSep = sqrt(best);
     return isClose;
   } // TrajTrajDOCA

bool tca::TransferTjHits	(	TjStuff &	tjs,
		bool	prt
	)

Definition at line 4383 of file TCShower.cxx.

References tca::TjStuff::allTraj, tca::TjStuff::cots, tca::TjStuff::fHits, tca::Trajectory::ID, kKilled, kShowerTj, kUsedHits, tca::Trajectory::Pts, PutTrajHitsInVector(), and ss.

Referenced by Finish3DShowers().

   {
     // Transfer InShower hits in all TPCs and planes to the shower Tjs
     
     bool newShowers = false;
     for(auto& ss : tjs.cots) {
       if(ss.ID == 0) continue;
       if(ss.ShowerTjID == 0) continue;
       // Tp 1 of stj will get all of the shower hits
       Trajectory& stj = tjs.allTraj[ss.ShowerTjID - 1];
       if(!stj.Pts[1].Hits.empty()) {
         std::cout<<"TTjH: ShowerTj T"<<stj.ID<<" already has "<<stj.Pts[1].Hits.size()<<" hits\n";
         continue;
       }
       // Note that UseHit is not used since the size is limited to 16
       for(auto& tjID : ss.TjIDs) {
         unsigned short itj = tjID - 1;
         if(tjs.allTraj[itj].AlgMod[kShowerTj]) {
           std::cout<<"TTjH: Coding error. T"<<tjID<<" is a ShowerTj but is in TjIDs\n";
           continue;
         }
         if(tjs.allTraj[itj].SSID <= 0) {
           std::cout<<"TTjH: Coding error. Trying to transfer T"<<tjID<<" hits but it isn't an InShower Tj\n";
           continue;
         }
         auto thits = PutTrajHitsInVector(tjs.allTraj[itj], kUsedHits);
         // associate all hits with the charge center TP
         stj.Pts[1].Hits.insert(stj.Pts[1].Hits.end(), thits.begin(), thits.end());
         // kill Tjs that are in showers
         tjs.allTraj[itj].AlgMod[kKilled] = true;
       } //  tjID
       // re-assign the hit -> stj association
       for(auto& iht : stj.Pts[1].Hits) tjs.fHits[iht].InTraj = stj.ID;
       newShowers = true;
      } // ss
 
     if(prt) mf::LogVerbatim("TC")<<"TTJH: success? "<<newShowers;
     return newShowers;
   } // TransferTjHits

void tca::TrimEndPts	(	std::string	fcnLabel,
		TjStuff &	tjs,
		Trajectory &	tj,
		const std::vector< float > &	fQualityCuts,
		bool	prt
	)

Definition at line 1342 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::CTP, DecodeCTP(), tca::Trajectory::EndPt, tca::Trajectory::ID, kTEP, NumPtsWithCharge(), tca::TjStuff::NumWires, geo::PlaneID::Plane, PrintTrajectory(), tca::Trajectory::Pts, SetEndPoints(), tca::Trajectory::StepDir, UnsetUsedHits(), tca::TjStuff::UseAlg, and tca::TjStuff::WireHitRange.

Referenced by tca::TrajClusterAlg::CheckTraj(), tca::TrajClusterAlg::FixTrajBegin(), and tca::TrajClusterAlg::IsGhost().

   {
     // Trim the hits off the end until there are at least MinPts consecutive hits at the end
     // and the fraction of hits on the trajectory exceeds fQualityCuts[0]
     // Minimum length requirement accounting for dead wires where - denotes a wire with a point
     // and D is a dead wire. Here is an example with minPts = 3
     //  ---DDDDD--- is OK
     //  ----DD-DD-- is OK
     //  ----DDD-D-- is OK
     //  ----DDDDD-- is not OK
     
     if(!tjs.UseAlg[kTEP]) return;
     
     unsigned short npwc = NumPtsWithCharge(tjs, tj, false);
     short minPts = fQualityCuts[1];
     if(minPts < 1) return;
     if(npwc < minPts) return;
     
     // handle short tjs
     if(npwc == minPts + 1) {
       unsigned short endPt1 = tj.EndPt[1];
       auto& tp = tj.Pts[endPt1];
       auto& ptp = tj.Pts[endPt1 - 1];
       // remove the last point if the previous point has no charge or if
       // it isn't on the next wire
       float dwire = std::abs(ptp.Pos[0] - tp.Pos[0]);
       if(ptp.Chg == 0 || dwire > 1.1) {
         UnsetUsedHits(tjs, tp);
         SetEndPoints(tjs, tj);
         tj.AlgMod[kTEP] = true;
       }
       return;
     } // short tj
     
     // find the separation between adjacent points, starting at the end
     short lastPt = 0;
     for(lastPt = tj.EndPt[1]; lastPt >= minPts; --lastPt) {
       // check for an error
       if(lastPt == 1) break;
       if(tj.Pts[lastPt].Chg == 0) continue;
       // number of adjacent points on adjacent wires
       unsigned short nadj = 0;
       unsigned short npwc = 0;
       for(short ipt = lastPt - minPts; ipt < lastPt; ++ipt) {
         if(ipt < 2) break;
         // the current point
         auto& tp = tj.Pts[ipt];
         // the previous point
         auto& ptp = tj.Pts[ipt - 1];
         if(tp.Chg > 0 && ptp.Chg > 0) {
           ++npwc;
           if(std::abs(tp.Pos[0] - ptp.Pos[0]) < 1.5) ++nadj;
         }
       } // ipt
       float ntpwc = NumPtsWithCharge(tjs, tj, true, tj.EndPt[0], lastPt);
       float nwires = std::abs(tj.Pts[tj.EndPt[0]].Pos[0] - tj.Pts[lastPt].Pos[0]) + 1;
       float hitFrac = ntpwc / nwires;
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<"-TEP: T"<<tj.ID<<" lastPt "<<lastPt<<" npwc "<<npwc<<" nadj "<<nadj<<" hitFrac "<<hitFrac;
       if(hitFrac > fQualityCuts[0] && npwc == minPts && nadj == minPts) break;
     } // lastPt
     
     // trim the last point if it just after a dead wire.
     if(tj.Pts[lastPt].Pos[0] > -0.4) {
       unsigned int prevWire = std::nearbyint(tj.Pts[lastPt].Pos[0]);
       if(tj.StepDir > 0) {
         --prevWire;
       } else {
         ++prevWire;
       }
       if(prt) {
         mf::LogVerbatim("TC")<<fcnLabel<<"-TEP: is prevWire "<<prevWire<<" dead? ";
       }
       unsigned short plane = DecodeCTP(tj.CTP).Plane;
       if(prevWire < tjs.NumWires[plane] && tjs.WireHitRange[plane][prevWire].first == -1) --lastPt;
     } // valid Pos[0]
     
     // Nothing needs to be done
     if(lastPt == tj.EndPt[1]) {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<"-TEPo: Tj is OK";
       return;
     }
     
     // clear the points after lastPt
     for(unsigned short ipt = lastPt + 1; ipt <= tj.EndPt[1]; ++ipt) UnsetUsedHits(tjs, tj.Pts[ipt]);
     SetEndPoints(tjs, tj);
     tj.AlgMod[kTEP] = true;
     if(prt) {
       fcnLabel += "-TEPo";
       PrintTrajectory(fcnLabel, tjs, tj, USHRT_MAX);
     }
     
   } // TrimEndPts

float tca::TwoTPAngle	(	TrajPoint &	tp1,
		TrajPoint &	tp2
	)

Definition at line 2274 of file Utils.cxx.

References tca::TrajPoint::Pos.

   {
     // Calculates the angle of a line between two TPs
     float dw = tp2.Pos[0] - tp1.Pos[0];
     float dt = tp2.Pos[1] - tp1.Pos[1];
     return atan2(dw, dt);
   } // TwoTPAngle

void tca::UnsetUsedHits	(	TjStuff &	tjs,
		TrajPoint &	tp
	)

Definition at line 1082 of file Utils.cxx.

References tca::TrajPoint::Chg, tca::TjStuff::fHits, tca::TrajPoint::Hits, and tca::TrajPoint::UseHit.

   {
     // Sets InTraj = 0 and UseHit false for all used hits in tp
     for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
       if(tp.UseHit[ii]) {
         tjs.fHits[tp.Hits[ii]].InTraj = 0;
         tp.UseHit[ii] = false;
       } // UseHit
     } // ii
     tp.Chg = 0;
   } // UnsetUsedHits

void tca::UpdateMatchStructs	(	TjStuff &	tjs,
		int	oldTj,
		int	newTj
	)

Definition at line 16 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, detinfo::DetectorProperties::ConvertTicksToX(), DecodeCTP(), tca::TjStuff::detprop, tca::TjStuff::mallTraj, tca::TjStuff::pfps, and tca::TjStuff::UnitsPerTick.

Referenced by MergeAndStore(), MergePFPTjs(), ReverseTraj(), and SplitTraj().

   {
     // Replaces tjid and ipt references in tjs.matchVec and tjs.pfps from
     // oldTj to newTj. This function is called when Tjs are split or merged
     // or if a Tj is reversed (in which case oldTj = newTj).
     // The method used is to match the trajectory point positions
     if(oldTj <= 0 || oldTj > (int)tjs.allTraj.size()) return;
     if(newTj <= 0 || newTj > (int)tjs.allTraj.size()) return;
     if(tjs.mallTraj.empty() && tjs.pfps.empty()) return;
     
     // convert from int to unsigned short
     int oldtjid = oldTj;
     int newtjid = newTj;
     auto& ntj = tjs.allTraj[newTj - 1];
     unsigned short npts = ntj.EndPt[1] - ntj.EndPt[0] + 1;
     // put the X positions of the new Tj into a vector for matching
     std::vector<float> xpos(ntj.Pts.size());
     geo::PlaneID planeID = DecodeCTP(ntj.CTP);
     for(unsigned short npt = ntj.EndPt[0]; npt <= ntj.EndPt[1]; ++npt) {
       auto& ntp = ntj.Pts[npt];
       if(ntp.Chg <= 0) continue;
       xpos[npt] = tjs.detprop->ConvertTicksToX(ntp.Pos[1]/tjs.UnitsPerTick, planeID);
     } // npt
     
     if(!tjs.mallTraj.empty()) {
       for(unsigned int ipt = 0; ipt < tjs.mallTraj.size(); ++ipt) {
         auto& tj2pt = tjs.mallTraj[ipt];
         if(tj2pt.id > tjs.allTraj.size()) continue;
         if(tj2pt.id != oldtjid) continue;
         // Found the old Tj. Now find the point
         for(unsigned short npt = ntj.EndPt[0]; npt <= ntj.EndPt[1]; ++npt) {
           auto& ntp = ntj.Pts[npt];
           if(ntp.Chg <= 0) continue;
           if(std::nearbyint(ntp.Pos[0]) == tj2pt.wire && xpos[npt] > tj2pt.xlo && xpos[npt] < tj2pt.xhi) {
             tj2pt.id = newtjid;
             tj2pt.ipt = npt;
             tj2pt.npts = npts;
             break;
           } // points match
         } // npt
       } // ipt
     } // !tjs.mallTraj.empty()
     
     // Update pfp space points
     if(!tjs.pfps.empty()) {
       for(auto& pfp : tjs.pfps) {
         for(auto& tp3 : pfp.Tp3s) {
           // check each of the Tj2Pts associated with this space point
           for(auto& tj2pt : tp3.Tj2Pts) {
             if(tj2pt.id > tjs.allTraj.size()) continue;
             if(tj2pt.id != oldtjid) continue;
             // look for the corresponding point (wire) on the new Tj
             for(unsigned short npt = ntj.EndPt[0]; npt <= ntj.EndPt[1]; ++npt) {
               auto& ntp = ntj.Pts[npt];
               if(std::nearbyint(ntp.Pos[0]) == tj2pt.wire && xpos[npt] > tj2pt.xlo && xpos[npt] < tj2pt.xhi) {
                 tj2pt.id = newtjid;
                 tj2pt.ipt = npt;
                 tj2pt.npts = npts;
                 break;
               }
             } // npt
           } // tj2pt
         } // tp3
       } // pfp
     } // pfps exists
 
   } // UpdateMatchStructs

bool tca::UpdateShower	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 1104 of file TCShower.cxx.

Referenced by tca::MCParticleListUtils::MakeCheatShower().

   {
     // This is intended to be a single function replacement for FCC, FA, USWP, etc. The calling
     // function should have set NeedsUpdate true. A complete re-build is done if the ShPts vector
     // is empty. This is only required if a tj is removed from the shower. When adding a tj
     // to the shower the AddTj function appends the tj points to ShPts but doesn't fill
     // the ShPts RotPos values.
     // This function doesn't alter or check associations btw showers and tjs.
     
     if(ss.ID == 0) return false;
     if(!ss.Cheat && ss.TjIDs.empty()) return false;
     if(ss.ShowerTjID <= 0 || ss.ShowerTjID > (int)tjs.allTraj.size()) return false;
     if(ss.ParentID > 0 && ss.ParentID > (int)tjs.allTraj.size()) return false;
     auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
     if(stj.Pts.size() != 3) return false;
 
     std::string fcnLabel = inFcnLabel + ".U2S";
 
     if(!ss.NeedsUpdate && !ss.ShPts.empty()) {
 //      std::cout<<fcnLabel<<" 2S"<<ss.ID<<" doesn't need an update\n";
       return true;
     }
 
     // initialize the variables that will be defined in this function
     ss.Energy = 0; // This is just ShowerEnergy(stj.TotChg) and could be deleted
     ss.AspectRatio = 10;
     // Direction FOM (0 = good). This is a property of the shower shape and is not
     // defined by the presence or absence of a parent tj start point
     ss.DirectionFOM = 10;
     // Total charge of all hits in the shower
     stj.TotChg = 0;
     for(auto& stp : stj.Pts) {
       // Shower start, charge center, and shower end
       stp.Pos = {{0.0, 0.0}};
       // Charge weighted average of hits this section (TP) along the shower
       stp.HitPos = {{0.0, 0.0}};
       // Direction from the start to the charge center - same for all TPs
       stp.Dir = {{0.0, 0.0}};
       // Hit charge in each section
       stp.Chg = 0;
       // transverse rms of hit positions relative to HitPos in this section
       stp.DeltaRMS = 0;
       // number of hits in this section
       stp.NTPsFit = 0;
     } // stp
     
     if(!ss.Cheat) {
       ss.ShPts.clear();
       for(auto tjid : ss.TjIDs) {
         if(tjid <= 0 || tjid > (int)tjs.allTraj.size()) return false;
         auto& tj = tjs.allTraj[tjid - 1];
         if(tj.CTP != ss.CTP) return false;
         if(tj.AlgMod[kShowerTj]) return false;
         for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
           TrajPoint& tp = tj.Pts[ipt];
           for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
             if(!tp.UseHit[ii]) continue;
             unsigned int iht = tp.Hits[ii];
             if(tjs.fHits[iht].Integral <= 0) continue;
             ShowerPoint shpt;
             shpt.HitIndex = iht;
             shpt.TID = tj.ID;
             shpt.Chg = tjs.fHits[iht].Integral;
             shpt.Pos[0] = tjs.fHits[iht].ArtPtr->WireID().Wire;
             shpt.Pos[1] = tjs.fHits[iht].PeakTime * tjs.UnitsPerTick;
             ss.ShPts.push_back(shpt);
           } // ii
         } // ipt
       } // tjid
     }
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 2S"<<ss.ID<<" nShPts "<<ss.ShPts.size();
     
     if(ss.ShPts.size() < 3) return false;
     
     // find the charge center and total charge
     auto& stp1 = stj.Pts[1];
     for(auto& shpt : ss.ShPts) {
       stp1.Pos[0] += shpt.Chg * shpt.Pos[0];
       stp1.Pos[1] += shpt.Chg * shpt.Pos[1];
       stj.TotChg += shpt.Chg;
     } // shpt
     if(stj.TotChg <= 0) return false;
     stp1.Pos[0] /= stj.TotChg;
     stp1.Pos[1] /= stj.TotChg;
     ss.Energy = ChgToMeV(stj.TotChg);
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 2S"<<ss.ID<<" Chg ctr "<<PrintPos(tjs, stp1.Pos)<<" Energy "<<(int)ss.Energy<<" MeV";
     
     // find the direction using the shower parent if one exists
     if(ss.ParentID > 0) {
       // Set the direction to be the start of the parent to the shower center
       auto& ptj = tjs.allTraj[ss.ParentID - 1];
       // find the parent end farthest away from the charge center
       unsigned short pend = FarEnd(tjs, ptj, stp1.Pos);
       auto& ptp = ptj.Pts[ptj.EndPt[pend]];
       stp1.Dir = PointDirection(ptp.Pos, stp1.Pos);
       stp1.Ang = atan2(stp1.Dir[1], stp1.Dir[0]);
     } else {
       // find the shower direction using the points
       double sum = 0.;
       double sumx = 0.;
       double sumy = 0.;
       double sumxy = 0.;
       double sumx2 = 0.;
       double sumy2 = 0.;
       for(auto& shpt : ss.ShPts) {
         sum += shpt.Chg;
         double xx = shpt.Pos[0] - stp1.Pos[0];
         double yy = shpt.Pos[1] - stp1.Pos[1];
         sumx += shpt.Chg * xx;
         sumy += shpt.Chg * yy;
         sumxy += shpt.Chg * xx * yy;
         sumx2 += shpt.Chg * xx * xx;
         sumy2 += shpt.Chg * yy * yy;
       } // shpt
       double delta = sum * sumx2 - sumx * sumx;
       if(delta == 0) return false;
       // A is the intercept (This should be ~0 )
 //      double A = (sumx2 * sumy - sumx * sumxy) / delta;
       // B is the slope
       double B = (sumxy * sum  - sumx * sumy) / delta;
       stp1.Ang = atan(B);
       stp1.Dir[0] = cos(stp1.Ang);
       stp1.Dir[1] = sin(stp1.Ang);
     } // no shower parent
     
     // TODO: ss.Angle should be eliminated. The shower tj Ang should be used instead
     ss.Angle = stp1.Ang;
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 2S"<<ss.ID<<" dir "<<std::fixed<<std::setprecision(2)<<stp1.Dir[0]<<" "<<stp1.Dir[1]<<" Angle "<<stp1.Ang;
     for(unsigned short ipt = 0; ipt < 3; ++ipt) {
       if(ipt == 1) continue;
       stj.Pts[ipt].Dir = stp1.Dir;
       stj.Pts[ipt].Ang = stp1.Ang;
     } // ipt
     
     // fill the RotPos vector and sort
     std::vector<SortEntry> sortVec(ss.ShPts.size());
     unsigned short indx = 0;
     double cs = cos(-stp1.Ang);
     double sn = sin(-stp1.Ang);
     for(auto& shpt : ss.ShPts) {
       double xx = shpt.Pos[0] - stp1.Pos[0];
       double yy = shpt.Pos[1] - stp1.Pos[1];
       shpt.RotPos[0] = cs * xx - sn * yy;
       shpt.RotPos[1] = sn * xx + cs * yy;
       sortVec[indx].index = indx;
       sortVec[indx].length = shpt.RotPos[0];
       ++indx;
     } // shpt
     std::sort(sortVec.begin(), sortVec.end(), lessThan);
     // put the points vector into the sorted order
     auto tPts = ss.ShPts;
     for(unsigned short ii = 0; ii < ss.ShPts.size(); ++ii) ss.ShPts[ii] = tPts[sortVec[ii].index];
     
     // Calculate the aspect ratio
     Point2_t alongTrans {{0.0, 0.0}};
     for(auto& shpt : ss.ShPts) {
       alongTrans[0] += shpt.Chg * std::abs(shpt.RotPos[0]);
       alongTrans[1] += shpt.Chg * std::abs(shpt.RotPos[1]);
     } // shpt
     alongTrans[0] /= stj.TotChg;
     alongTrans[1] /= stj.TotChg;
     if(alongTrans[1] == 0) return false;
     ss.AspectRatio = alongTrans[1] / alongTrans[0];
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 2S"<<ss.ID<<" AspectRatio "<<ss.AspectRatio;
     
     // analyze the charge in three sections. Fill the stj HitPos and find DeltaRMS
     if(!AnalyzeRotPos(fcnLabel, tjs, ss, prt)) return false;
     
     // Reverse the shower direction if needed and define the start point
     if(ss.ParentID > 0) {
       // The direction was defined by the start of a parent to the charge center. Check the consistency
       // with ShPts and reverse if needed
       auto& ptj = tjs.allTraj[ss.ParentID - 1];
       // find the parent end farthest away from the charge center
       unsigned short pend = FarEnd(tjs, ptj, stp1.Pos);
       auto& ptp = ptj.Pts[ptj.EndPt[pend]];
       auto& firstShPt = ss.ShPts[0];
       auto& lastShPt = ss.ShPts[ss.ShPts.size() - 1];
       if(PosSep2(ptp.Pos, lastShPt.Pos) < PosSep2(ptp.Pos, firstShPt.Pos)) ReverseShower(fcnLabel, tjs, ss, prt);
       stj.Pts[0].Pos = ptp.Pos;
     } else {
       // no parent exists. Compare the DeltaRMS at the ends
       if(stj.Pts[2].DeltaRMS < stj.Pts[0].DeltaRMS) ReverseShower(fcnLabel, tjs, ss, prt);
       stj.Pts[0].Pos = ss.ShPts[0].Pos;
     } // no parent
     
     if(stj.Pts[2].DeltaRMS > 0) ss.DirectionFOM = stj.Pts[0].DeltaRMS / stj.Pts[2].DeltaRMS;
     // define the end point
     stj.Pts[2].Pos = ss.ShPts[ss.ShPts.size() - 1].Pos;
     
     DefineEnvelope(fcnLabel, tjs, ss, prt);
     ss.NeedsUpdate = false;
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 2S"<<ss.ID<<" updated";
     return true;
     
   } // UpdateShower

bool tca::UpdateShower	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 1302 of file TCShower.cxx.

Referenced by AddPFP(), AddTj(), AddTjsInsideEnvelope(), CompleteIncompleteShower(), FindParent(), FindShowers3D(), Match2DShowers(), MergeShowers(), MergeShowersAndStore(), Reconcile3D(), RemovePFP(), RemoveTj(), and SetParent().

   {
     // Updates the 3D shower presumably because the 2D showers were changed or need to be updated. 
     // This function returns false if there was a failure.
     
     if(ss3.ID == 0) return false;
     if(ss3.CotIDs.size() < 2) return false;
     
     std::string fcnLabel = inFcnLabel + ".U3S";
     
     // see if any of the 2D showers need an update
     for(auto cid : ss3.CotIDs) {
       auto& ss = tjs.cots[cid - 1];
       if(ss.NeedsUpdate && prt) std::cout<<fcnLabel<<" ********* 3S"<<ss3.ID<<" 2S"<<ss.ID<<" needs an update...\n";
       UpdateShower(fcnLabel, tjs, ss, prt);
     } // ci
     
     // check consistency 
     if(ss3.ParentID > 0) {
       auto& pfp = tjs.pfps[ss3.ParentID - 1];
       unsigned short pend = FarEnd(tjs, pfp, ss3.ChgPos);
       if(pfp.Vx3ID[pend] != ss3.Vx3ID) {
         if(prt) std::cout<<fcnLabel<<" ********* 3S"<<ss3.ID<<" has parent P"<<ss3.ParentID<<" with a vertex that is not attached the shower\n";
       }
     } // ss3.ParentID > 0
     
     // Find the average position and direction using pairs of 2D shower Tjs
     std::array<Point3_t, 3> pos;
     // the direction of all points in 2D showers is the same
     Vector3_t dir;
     std::array<double, 3> chg;
     for(unsigned short ipt = 0; ipt < 3; ++ipt) {
       chg[ipt] = 0;
       for(unsigned short xyz = 0; xyz < 3; ++xyz) {
         pos[ipt][xyz] = 0;
         dir[xyz] = 0;
       }
     } // ipt
     
     for(unsigned short ii = 0; ii < ss3.CotIDs.size() - 1; ++ii) {
       unsigned short ciid = ss3.CotIDs[ii];
       auto& iss = tjs.cots[ciid - 1];
       // make a local copy of the trajectory so we can replace Pos with HitPos = charge center
       auto istj = tjs.allTraj[iss.ShowerTjID - 1];
       for(auto& tp : istj.Pts) tp.Pos = tp.HitPos;
       for(unsigned short jj = ii + 1; jj < ss3.CotIDs.size(); ++jj) {
         unsigned short cjid = ss3.CotIDs[jj];
         auto& jss = tjs.cots[cjid - 1];
         auto jstj = tjs.allTraj[jss.ShowerTjID - 1];
         for(auto& tp : jstj.Pts) tp.Pos = tp.HitPos;
         TrajPoint3 tp3;
         for(unsigned short ipt = 0; ipt < 3; ++ipt) {
           if(!MakeTp3(tjs, istj.Pts[ipt], jstj.Pts[ipt], tp3, true)) continue;
           double ptchg = 0.5 * (istj.Pts[ipt].Chg + jstj.Pts[ipt].Chg);
           chg[ipt] += ptchg;
           for(unsigned short xyz = 0; xyz < 3; ++xyz) {
             pos[ipt][xyz] += ptchg * tp3.Pos[xyz];
             dir[xyz] += ptchg * tp3.Dir[xyz];
           } // xyz
         } // ipt
       } // jj
     } // ii
     
     unsigned short nok = 0;
     for(unsigned short ipt = 0; ipt < 3; ++ipt) {
       if(chg[ipt] == 0) continue;
       for(unsigned short xyz = 0; xyz < 3; ++xyz) pos[ipt][xyz] /= chg[ipt];
       SetMag(dir, 1);
       ++nok;
     } // ipt
     
     if(nok != 3) {
 //      if(prt) std::cout<<fcnLabel<<" ********* 3S"<<ss3.ID<<" Can't find 3 points that match in 3D. \n";
       return false;
     }
     ss3.ChgPos = pos[1];
     
     if(ss3.ParentID > 0) {
       // There is a 3D-matched pfp at the shower start. The end that is farthest away from the
       // shower center should be shower start
       auto& pfp = tjs.pfps[ss3.ParentID - 1];
       unsigned short pend = FarEnd(tjs, pfp, ss3.ChgPos);
       ss3.Start = pfp.XYZ[pend];
       // TODO: use charge weighted average of shower direction and pfp direction?
       ss3.Dir = dir;
     } else {
       ss3.Dir = dir;
       ss3.Start = pos[0];
     }
     // define the end
     ss3.End = pos[2];
     ss3.Len = PosSep(ss3.Start, ss3.End);
     
     // dE/dx, energy, etc
     for(auto cid : ss3.CotIDs) {
       auto& ss = tjs.cots[cid - 1];
       auto& stj = tjs.allTraj[ss.ShowerTjID - 1];
       unsigned short plane = DecodeCTP(ss.CTP).Plane;
       ss3.Energy[plane] = ss.Energy;
       // TODO: calculate the errors in some better way
       ss3.EnergyErr[plane] = 0.3 * ss.Energy;
       // TODO: what does MIPEnergy mean anyway?
       ss3.MIPEnergy[plane] = ss3.EnergyErr[plane];
       ss3.MIPEnergyErr[plane] = ss.Energy;
       ss3.dEdx[plane] = stj.dEdx[0];
       ss3.dEdxErr[plane] = 0.3 * stj.dEdx[0];
     } // ci
              
     ss3.NeedsUpdate = false;
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" updated";
     return true;
 
   } // UpdateShower

void tca::UpdateTjChgProperties	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 3118 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::AveChg, tca::Trajectory::ChgRMS, evd::details::end(), tca::Trajectory::EndPt, tca::TjStuff::fHits, kEnvNearTj, kEnvOverlap, kEnvUnusedHits, kKilled, kPhoton, tca::Trajectory::NeedsUpdate, tca::TjStuff::NPtsAve, tca::Trajectory::Pts, tca::Trajectory::TotChg, tca::TjStuff::vtx, and tca::Trajectory::VtxID.

Referenced by tca::TrajClusterAlg::AddLAHits(), tca::TrajClusterAlg::ChkStopEndPts(), DotProd(), tca::TrajClusterAlg::MaskedHitsOK(), MaxChargeAsymmetry(), SplitTraj(), StoreTraj(), tca::TrajClusterAlg::UpdateTraj(), and UpdateVxEnvironment().

   {
     // Updates properties of the tj that are affected when the TP environment
     // is changed. The most likely reason for a change is when the tj is attached to a
     // vertex in which case the Environment kEnvOverlap bit may be set by the UpdateVxEnvironment
     // function in which case this function is called.
     // The kEnvNearShower bit may be set by TagShowerTjs but this doesn't affect the
     // calculation of the properties of this Tj. This function simply sets the kEnvUnusedHits bit
     // for all TPs. 
     if(tj.AlgMod[kKilled]) return;
 
     std::string fcnLabel = inFcnLabel + ".UpTjProp";
 
     // first (un)set some bits
     for(auto& tp : tj.Pts) {
       if(tp.Chg <= 0) continue;
       tp.Environment[kEnvUnusedHits] = false;
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         if(tp.UseHit[ii]) continue;
         unsigned int iht = tp.Hits[ii];
         if(tjs.fHits[iht].InTraj == 0) {
           tp.Environment[kEnvUnusedHits] = true;
         } else {
           tp.Environment[kEnvNearTj] = true;
         }
       } // ii
     } // tp
     
     // Update the tj charge variables. The concept is explained by this graphic where
     // each column is a wire, Q = a TP with charge, q = a TP with charge that is an
     // EnvOverlap region, x = a wire that has a TP with Chg = 0 or a wire that has no TP 
     // because the wire is dead, o = an EnvOverlap region, V = vertex attached to end. You should
     // imagine that all 3 tjs come from the same vertex
     //   01234567890123456789   npwc  cnt range
     //   VooooQQQQxxxQQQ          7    7   0 - 14
     //   VqqqqQQQQxxxQQQQQQQQ    16   12   0 - 19
     //   VooQQQ                   3    3   0 - 5
     // The average is first calculated using Ave = sum(Q) / npwc
     // TotChg is calculated using 
     tj.TotChg = 0;
     tj.AveChg = 0;
     tj.ChgRMS = 0.5;
     
     // These variables are used to calculate the average and rms using valid points with charge
     double vcnt = 0;
     double vsum = 0;
     double vsum2 = 0;
     //  variables for calculating the backup quanties. These are only used if npwc < 3
     double bcnt = 0;
     double bsum = 0;
     double bsum2 = 0;
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if(tp.Chg <= 0) continue;
       // accumulate a backup sum in case most of the points are overlapped. Note that
       // tp.Chg has an angle correction, which is why the hit integral is summed
       // below. We don't care about this detail for the backup sum
       bsum  += tp.Chg;
       bsum2 += tp.Chg * tp.Chg;
       ++bcnt;
       // Skip TPs that overlap with TPs on other Tjs. A correction will be made below
       if(tj.Pts[ipt].Environment[kEnvOverlap]) continue;
       ++vcnt;
       double tpchg = 0;
       for(unsigned short ii = 0; ii < tj.Pts[ipt].Hits.size(); ++ii) {
         if(!tp.UseHit[ii]) continue;
         unsigned int iht = tp.Hits[ii];
         tpchg += tjs.fHits[iht].Integral;
       } // ii
       vsum  += tpchg;
       vsum2 += tpchg * tpchg;
     } // ipt
     
     if(bcnt == 0) return;
     
     if(vcnt < 3) {
       // use the backup sum
       tj.TotChg = bsum;
       tj.AveChg = bsum / bcnt;
       if(vcnt > 2) {
         double arg = bsum2 - bcnt * tj.AveChg * tj.AveChg;
         if(arg > 0) tj.ChgRMS = sqrt(arg / (bcnt - 1));
       }
       for(auto& tp : tj.Pts) tp.AveChg = tj.AveChg;
       return;
     } // low npwc
     
     double nWires = tj.EndPt[1] - tj.EndPt[0] + 1;
     if(nWires < 2) return;
     // correct for wires missing near vertices.
     // Count the number of wires between vertices at the ends and the first wire
     // that has charge. This code assumes that there should be one TP on each wire
     if(!tj.AlgMod[kPhoton]) {
       for(unsigned short end = 0; end < 2; ++end) {
         if(tj.VtxID[end] == 0) continue;
         auto& tp = tj.Pts[tj.EndPt[end]];
         auto& vx2 = tjs.vtx[tj.VtxID[end] - 1];
         int dw = std::abs(tp.Pos[0] - vx2.Pos[0]);
         // This assumes that the vertex is not inside the wire boundaries of the tj
         nWires += dw;
       } // end
     } // not a photon Tj
     
     tj.AveChg = vsum / vcnt;
     // calculate the total charge using the tj wire range
     tj.TotChg = nWires * tj.AveChg;
     // calculate the rms
     double arg = vsum2 - vcnt * tj.AveChg * tj.AveChg;
     double rms = 0.5;
     if(arg > 0) rms = sqrt(arg / (vcnt - 1));
     rms /= tj.AveChg;
     // don't let it be an unrealistically low value. It could be crazy large however.
     if(rms < 0.1) rms = 0.1;
     // Don't let the calculated charge RMS dominate until it is well known; after there are 5 - 10 valid TPs.
     // Set the starting charge rms = 0.5 
     if(vcnt < 10) {
       double defFrac = 1 / vcnt;
       rms = defFrac * 0.5 + (1 - defFrac) * rms;
     }
     tj.ChgRMS = rms;
     
     // Update the TP charge pulls.
     // Don't let the calculated charge RMS dominate the default
     // RMS until it is well known. Start with 50% error on the
     // charge RMS
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if(tp.Chg <= 0) continue;
       tp.ChgPull = (tp.Chg / tj.AveChg - 1) / tj.ChgRMS;
     } // ipt
     
     // update the local charge average using NPtsAve of the preceding points.
     // Handle short Tjs first.
     if(vcnt < tjs.NPtsAve) {
       for(auto& tp : tj.Pts) tp.AveChg = tj.AveChg;
       return;
     }
     
     // Set the local average to 0 first
     for(auto& tp : tj.Pts) tp.AveChg = 0;
     // Enter the local average on the points where an average can be calculated
     unsigned short nptsave = tjs.NPtsAve;
     unsigned short minPt = tj.EndPt[0] + nptsave;
     float lastAve = 0;
     for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
       unsigned short ipt = tj.EndPt[1] - ii;
       if(ipt < minPt) break;
       float cnt = 0;
       float sum = 0;
       for(unsigned short iii = 0; iii < nptsave; ++iii) {
         unsigned short iipt = ipt - iii;
         // Don't include the charge of the first point
         if(iipt == tj.EndPt[0]) break;
         auto& tp = tj.Pts[iipt];
         if(tp.Chg <= 0) continue;
         sum += tp.Chg;
         ++cnt;
       } // iii
       if(cnt > 2) {
         tj.Pts[ipt].AveChg = sum / cnt;
         lastAve = tj.Pts[ipt].AveChg;
       }
     } // ii
     // Fill in the points where no average was calculated
     for(unsigned short ii = tj.EndPt[0]; ii <= tj.EndPt[1]; ++ii) {
       unsigned short ipt = tj.EndPt[1] - ii;
       auto& tp = tj.Pts[ipt];
       if(tp.AveChg == 0) {
         tp.AveChg = lastAve;
       } else {
         lastAve = tp.AveChg;
       }
     } // ii
     
     tj.NeedsUpdate = false;
     
   } // UpdateTjChgProperties

void tca::UpdateTp3s	(	TjStuff &	tjs,
		PFPStruct &	pfp,
		int	oldTj,
		int	newTj
	)

Definition at line 85 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, detinfo::DetectorProperties::ConvertTicksToX(), DecodeCTP(), tca::TjStuff::detprop, tca::TjStuff::mallTraj, tca::PFPStruct::Tp3s, and tca::TjStuff::UnitsPerTick.

Referenced by MergePFPTjs().

   {
     // Replaces occurrences of oldTj with newTj in the pfp vector of Tp3s
     if(oldTj <= 0 || oldTj > (int)tjs.allTraj.size()) return;
     if(newTj <= 0 || newTj > (int)tjs.allTraj.size()) return;
     if(tjs.mallTraj.empty() && pfp.Tp3s.empty()) return;
     
     // convert from int to unsigned short
     unsigned short oldtjid = oldTj;
     unsigned short newtjid = newTj;
     auto& ntj = tjs.allTraj[newTj - 1];
     unsigned short npts = ntj.EndPt[1] - ntj.EndPt[0] + 1;
     // put the X positions of the new Tj into a vector for matching
     std::vector<float> xpos(ntj.Pts.size());
     geo::PlaneID planeID = DecodeCTP(ntj.CTP);
     for(unsigned short npt = ntj.EndPt[0]; npt <= ntj.EndPt[1]; ++npt) {
       auto& ntp = ntj.Pts[npt];
       if(ntp.Chg <= 0) continue;
       xpos[npt] = tjs.detprop->ConvertTicksToX(ntp.Pos[1]/tjs.UnitsPerTick, planeID);
     } // npt
 
     for(auto& tp3 : pfp.Tp3s) {
       // check each of the Tj2Pts associated with this space point
       for(auto& tj2pt : tp3.Tj2Pts) {
         if(tj2pt.id > tjs.allTraj.size()) continue;
         if(tj2pt.id != oldtjid) continue;
         // look for the corresponding point (wire) on the new Tj
         for(unsigned short npt = ntj.EndPt[0]; npt <= ntj.EndPt[1]; ++npt) {
           auto& ntp = ntj.Pts[npt];
           if(std::nearbyint(ntp.Pos[0]) == tj2pt.wire && xpos[npt] > tj2pt.xlo && xpos[npt] < tj2pt.xhi) {
             tj2pt.id = newtjid;
             tj2pt.ipt = npt;
             tj2pt.npts = npts;
             break;
           }
         } // npt
       } // tj2pt
     } // tp3
     
   } // UpdateTp3s

void tca::UpdateVxEnvironment	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		VtxStore &	vx2,
		bool	prt
	)

Definition at line 3297 of file Utils.cxx.

References tca::TjStuff::allTraj, tca::TrajPoint::Chg, tca::VtxStore::CTP, tca::TrajPoint::Dir, evd::details::end(), tca::VtxStore::ID, kEnvOverlap, kKilled, kOnDeadWire, kPhoton, MakeBareTrajPoint(), tca::VtxStore::Pos, tca::TrajPoint::Pos, PrintPos(), tca::VtxStore::Stat, and UpdateTjChgProperties().

Referenced by DotProd(), and tca::TrajClusterAlg::ReconstructAllTraj().

   {
     // Update the Environment each TP on trajectories near the vertex. This is called when
     // the Tj has been added to a vertex to identify nearby trajectories that contribute to
     // the charge on TPs near the vertex. 
     if(vx2.ID == 0) return;
     if(vx2.Stat[kOnDeadWire]) return;
 
     std::string fcnLabel = inFcnLabel + ".UpVxProp";
 
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" UpdateTjEnvironment check Tjs attached to vx2 "<<vx2.ID;
     
     std::vector<int> tjlist;
     std::vector<unsigned short> tjends;
     if(vx2.Pos[0] < -0.4) return;
     unsigned int vxWire = std::nearbyint(vx2.Pos[0]);
     unsigned int loWire = vxWire;
     unsigned int hiWire = vxWire;
     for(auto& tj : tjs.allTraj) {
       if(tj.AlgMod[kKilled]) continue;
       if(tj.CTP != vx2.CTP) continue;
       // ignore photon Tjs
       if(tj.AlgMod[kPhoton]) continue;
       for(unsigned short end = 0; end < 2; ++end) {
         if(tj.VtxID[end] != vx2.ID) continue;
         tjlist.push_back(tj.ID);
         tjends.push_back(end);
         if(tj.Pts[tj.EndPt[end]].Pos[0] < -0.4) return;
         unsigned int endWire = std::nearbyint(tj.Pts[tj.EndPt[end]].Pos[0]);
         if(endWire < loWire) loWire = endWire;
         if(endWire > hiWire) hiWire = endWire;
       } // end
     } // tj
     if(tjlist.size() < 2) return;
     if(hiWire < loWire + 1) return;
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" check Tjs on wires in the range "<<loWire<<" to "<<hiWire;
     
     // create a vector of TPs between loWire and hiWire for every tj in the list
     //   wire       TP
     std::vector<std::vector<TrajPoint>> wire_tjpt;
     // companion vector of IDs
     std::vector<int> tjids;
     // populate this vector with TPs on Tjs that are in this range
     unsigned short nwires = hiWire - loWire + 1;
     for(unsigned short itj = 0; itj < tjlist.size(); ++itj) {
       auto& tj = tjs.allTraj[tjlist[itj] - 1];
       unsigned short end = tjends[itj];
       std::vector<TrajPoint> tjpt(nwires);
       // first enter valid TPs in the range
       for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
         unsigned short ipt;
         if(end == 0) { ipt = tj.EndPt[0] + ii; } else { ipt = tj.EndPt[1] - ii; }
         if(ipt > tj.Pts.size() - 1) break;
         // Make a copy of the TP so we can alter it
         auto tp = tj.Pts[ipt];
         if(tp.Chg <= 0) continue;
         tp.Chg = 1;
         tp.Hits.clear();
         if(tp.Pos[0] < -0.4) continue;
         unsigned int wire = std::nearbyint(tp.Pos[0]);
         unsigned short indx = wire - loWire;
         if(indx > nwires - 1) break;
         tp.Step = ipt;
         // We will use NTPsFit to count the number of neighboring TPs
         tp.NTPsFit = 0;
         tjpt[indx] = tp;
       } // ii
       // next make TPs on the wires that don't have real TPs
       TrajPoint ltp;
       // put ltp at the vertex position with direction towards the end point
       MakeBareTrajPoint(vx2.Pos, tj.Pts[tj.EndPt[end]].Pos, ltp);
       if(ltp.Dir[0] == 0) continue;
       if(ltp.Pos[0] < -0.4) continue;
       unsigned int wire = std::nearbyint(ltp.Pos[0]);
       ltp.Chg = 0;
       unsigned short indx = wire - loWire;
       // Break if we found a real TP
       if(tjpt[indx].Chg == 0) tjpt[indx] = ltp;
       double stepSize = std::abs(1/ltp.Dir[0]);
       for(unsigned short ii = 0; ii < nwires; ++ii) {
         // move the local TP position by one step in the right direction
         for(unsigned short iwt = 0; iwt < 2; ++iwt) ltp.Pos[iwt] += ltp.Dir[iwt] * stepSize;
         if(ltp.Pos[0] < -0.4) break;
         wire = std::nearbyint(ltp.Pos[0]);
         if(wire < loWire || wire > hiWire) break;
         indx = wire - loWire;
         if(tjpt[indx].Chg > 0) continue;
         tjpt[indx]= ltp;
       } // ii
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<fcnLabel<<" T"<<tj.ID;
         for(auto& tp : tjpt) myprt<<" "<<PrintPos(tjs, tp.Pos)<<"_"<<tp.Step<<"_"<<(int)tp.Chg;
       }
       wire_tjpt.push_back(tjpt);
       tjids.push_back(tj.ID);
     } // itj
     
     // iterate over the wires in the range
     for(unsigned short indx = 0; indx < nwires; ++indx) {
       // count the number of valid points on this wire
       unsigned short npts = 0;
       // count the number of points on this wire that have charge
       unsigned short npwc = 0;
       for(unsigned short itj = 0; itj < wire_tjpt.size(); ++itj) {
         if(wire_tjpt[itj][indx].Pos[0] == 0) continue;
         // found a valid point
         ++npts;
         if(wire_tjpt[itj][indx].Chg > 0) ++npwc;
       } // itj
       // no valid points
 //      if(prt) mf::LogVerbatim("TC")<<" wire "<<loWire + indx<<" npts "<<npts<<" npwc "<<npwc;
       if(npts == 0) continue;
       // all valid points have charge
       if(npwc == npts) continue;
       // re-find the valid points with charge and set the kEnvOverlap bit
       for(unsigned short itj = 0; itj < wire_tjpt.size(); ++itj) {
         if(wire_tjpt[itj][indx].Pos[0] == 0) continue;
         if(wire_tjpt[itj][indx].Chg == 0) continue;
         auto& tj = tjs.allTraj[tjids[itj] - 1];
         unsigned short ipt = wire_tjpt[itj][indx].Step;
         tj.Pts[ipt].Environment[kEnvOverlap] = true;
         tj.NeedsUpdate = true;
         if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Set kEnvOverlap bit on T"<<tj.ID<<" ipt "<<ipt;
       } // itj
     } // indx
     
     // update the charge rms for those tjs whose environment was changed above (or elsewhere)
     for(auto tjid : tjids) {
       auto& tj = tjs.allTraj[tjid - 1];
       if(!tj.NeedsUpdate) continue;
       if(tj.CTP != vx2.CTP) continue;
       UpdateTjChgProperties(fcnLabel, tjs, tj, prt);
     } // tjid
     
   } // UpdateVxEnvironment

bool tca::valDecreasing	(	SortEntry	c1,
		SortEntry	c2
	)

Definition at line 10 of file TCVertex.cxx.

References tca::SortEntry::val.

Referenced by tca::TrajClusterAlg::FindVtxTraj(), tca::TrajClusterAlg::MakeAllTrajClusters(), tca::TrajClusterAlg::MakeJunkTraj(), Match3DVtxTjs(), and MergeWithVertex().

10 { return (c1.val > c2.val);}

SortEntry::val

float val

Definition: Utils.cxx:8

bool tca::valDecreasings	(	SortEntry	c1,
		SortEntry	c2
	)

Definition at line 12 of file PFPUtils.cxx.

References tca::SortEntry::val.

Referenced by FindPFParticles(), and FindXMatches().

12 { return (c1.val > c2.val);}

SortEntry::val

float val

Definition: Utils.cxx:8

bool tca::valIncreasing	(	SortEntry	c1,
		SortEntry	c2
	)

Definition at line 11 of file TCVertex.cxx.

References tca::SortEntry::val.

Referenced by Find3DVertices().

11 { return (c1.val < c2.val);}

SortEntry::val

float val

Definition: Utils.cxx:8

bool tca::valIncreasings	(	SortEntry	c1,
		SortEntry	c2
	)

Definition at line 13 of file PFPUtils.cxx.

References tca::SortEntry::val.

Referenced by FillmAllTraj(), and SetStart().

13 { return (c1.val < c2.val);}

SortEntry::val

float val

Definition: Utils.cxx:8

float tca::VertexVertexPull	(	TjStuff &	tjs,
		const Vtx3Store &	vx1,
		const Vtx3Store &	vx2
	)

Definition at line 1882 of file TCVertex.cxx.

References tca::Vtx3Store::X, tca::Vtx3Store::XErr, tca::Vtx3Store::Y, tca::Vtx3Store::YErr, tca::Vtx3Store::Z, and tca::Vtx3Store::ZErr.

Referenced by IsCloseToVertex().

   {
     // Calculates the position pull between two vertices
     double dx = vx1.X - vx2.X;
     double dy = vx1.Y - vx2.Y;
     double dz = vx1.Z - vx2.Z;
     double dxErr2 = (vx1.XErr * vx1.XErr + vx2.XErr * vx2.XErr) / 2;
     double dyErr2 = (vx1.YErr * vx1.YErr + vx2.YErr * vx2.YErr) / 2;
     double dzErr2 = (vx1.ZErr * vx1.ZErr + vx2.ZErr * vx2.ZErr) / 2;
     dx = dx * dx / dxErr2;
     dy = dy * dy / dyErr2;
     dz = dz * dz / dzErr2;
     return (float)(sqrt(dx + dy + dz)/3);
   }

float tca::VertexVertexPull	(	TjStuff &	tjs,
		const VtxStore &	vx1,
		const VtxStore &	vx2
	)

Definition at line 1898 of file TCVertex.cxx.

References tca::VtxStore::Pos, and tca::VtxStore::PosErr.

   {
     // Calculates the position pull between two vertices
     double dw = vx1.Pos[0] - vx2.Pos[0];
     double dt = vx1.Pos[1] - vx2.Pos[1];
     double dwErr2 = (vx1.PosErr[0] * vx1.PosErr[0] + vx2.PosErr[0] * vx2.PosErr[0]) / 2;
     double dtErr2 = (vx1.PosErr[1] * vx1.PosErr[1] + vx2.PosErr[1] * vx2.PosErr[1]) / 2;
     dw = dw * dw / dwErr2;
     dt = dt * dt / dtErr2;
     return (float)sqrt(dw + dt);
   }

void tca::VtxHitsSwap	(	TjStuff &	tjs,
		const CTP_t	inCTP
	)

Definition at line 2758 of file TCVertex.cxx.

References tca::Trajectory::AlgMod, tca::TjStuff::allTraj, tca::VtxStore::CTP, debug, DecodeCTP(), evd::details::end(), tca::Trajectory::EndPt, tca::TjStuff::fHits, tca::TrajPoint::Hits, tca::VtxStore::ID, tca::Trajectory::ID, kKilled, kVtxHitsSwap, tca::VtxStore::NTraj, tca::DebugStuff::Plane, geo::PlaneID::Plane, PointTrajDOCA(), tca::VtxStore::Pos, PrintPos(), tca::Trajectory::Pts, SetEndPoints(), tca::DebugStuff::Tick, TpSumHitChg(), tca::TjStuff::UseAlg, tca::TrajPoint::UseHit, tca::TjStuff::vtx, and tca::Trajectory::VtxID.

Referenced by tca::TrajClusterAlg::ReconstructAllTraj().

                                                    {
     
     if(!tjs.UseAlg[kVtxHitsSwap]) return;
     
     geo::PlaneID planeID = DecodeCTP(inCTP);
     
     bool vtxPrt = ((debug.Plane == (int)planeID.Plane || debug.Plane == 3) && debug.Tick < 0);
     if(vtxPrt) mf::LogVerbatim("TC")<<"inside VtxHitsSwap on plane "<<planeID.Plane;
     for (unsigned short iv = 0; iv < tjs.vtx.size(); ++iv){
       VtxStore& rvx = tjs.vtx[iv];
       if(rvx.CTP != inCTP) continue;
       // Only consider vertex with two trajectories
       if(rvx.NTraj != 2) continue;
       if (vtxPrt) mf::LogVerbatim("TC")<<"Vertex "<<iv<<" Pos[0]: "<<rvx.Pos[0]<<" "<<rvx.Pos[1];
       std::array<unsigned short, 2> tjlist{{0,0}};
       for(unsigned short itj = 0; itj < tjs.allTraj.size(); ++itj) {
         if(tjs.allTraj[itj].AlgMod[kKilled]) continue;
         if(tjs.allTraj[itj].CTP != rvx.CTP) continue;
         Trajectory& tj = tjs.allTraj[itj];
         // ensure that the ID is OK so the code below doesn't choke
         for(unsigned short end = 0; end < 2; ++end) {
           if(tj.VtxID[end] == rvx.ID) {
             tjlist[end] = itj;
           }
         }
       }//all trajectories
       
       //Ignore short trajectories
       if (tjs.allTraj[tjlist[0]].EndPt[1]<5||
           tjs.allTraj[tjlist[1]].EndPt[1]<5) continue;
       
       for (unsigned short i = 0; i<2; ++i){
         
         //First check if first hit should be swapped
         Trajectory& tj0 = tjs.allTraj[tjlist[i]];
         Trajectory& tj1 = tjs.allTraj[tjlist[1-i]];
         unsigned short endPt0 = tjs.allTraj[tjlist[i]].EndPt[i];
         unsigned short endPt1 = tjs.allTraj[tjlist[1-i]].EndPt[1-i];
         //first TP on first trajectory
         float chg0 = TpSumHitChg(tjs, tj0.Pts[endPt0]);
         float w0 = tj0.Pts[endPt0].Pos[0];
         //if (vtxPrt) mf::LogVerbatim("TC")<<PrintPos(tjs, tj0.Pts[endPt0]);
         //second TP on first trajectory
         float chg1 = 0;
         float w1 = 0;
         unsigned short j = endPt0;
         while (j!=tj0.EndPt[1-i]){
           if (i==0) ++j;
           else --j;
           if (tj0.Pts[j].Chg){
             chg1 = TpSumHitChg(tjs, tj0.Pts[j]);
             w1 = tj0.Pts[j].Pos[0];
             //if (vtxPrt) mf::LogVerbatim("TC")<<PrintPos(tjs, tj0.Pts[j]);
             break;
           }
         }
         //first TP on second trajectory
         float chg2 = TpSumHitChg(tjs,tj1.Pts[endPt1]);
         float w2 = tj1.Pts[endPt1].Pos[0];
         //DOCA between first TP on first TJ and first TP on second TJ
         float delta = 1000;
         for (size_t k = 0; k<tj0.Pts[endPt0].Hits.size(); ++k){
           if (!tj0.Pts[endPt0].UseHit[k]) continue;
           float this_delta = PointTrajDOCA(tjs, tj0.Pts[endPt0].Hits[k], tj1.Pts[endPt1]);
           if (this_delta<delta) delta = this_delta;
         }
         //        if (vtxPrt) mf::LogVerbatim("TC")<<PrintPos(tjs, tj1.Pts[endPt1]);
         //if (vtxPrt) mf::LogVerbatim("TC")<<chg0<<" "<<chg1<<" "<<chg2<<" "<<delta;
         if (chg0>0&&std::abs((chg0-chg1)/chg0)-std::abs((chg0-chg2)/chg0)>0.2&&delta<1.5&&std::abs(w2-w1)<1.5){
           if (vtxPrt) {
             mf::LogVerbatim("TC")<<"chg0 = "<<chg0<<" chg1 = "<<chg1<<" chg2 = "<<chg2<<" delta = "<<delta<<" w0 = "<<w0<<" w1 = "<<w1<<" w2 = "<<w2;
             mf::LogVerbatim("TC")<<"VHS Moving TP "<<PrintPos(tjs, tj0.Pts[endPt0])<<" from TJ "<<tj0.ID<<" to TJ "<<tj1.ID;
           }
           //Add first TP of first trajectory to the second trajectory
           TrajPoint tp = tj0.Pts[endPt0];
           for (size_t j = 0; j<tp.Hits.size(); ++j){
             if (!tp.UseHit[j]) continue;
             tjs.fHits[tp.Hits[j]].InTraj = tj1.ID;
           }
           if (i==0){
             //append to the end
             tj1.Pts.push_back(tp);
           }
           else{
             //insert at the beginning
             tj1.Pts.insert(tj1.Pts.begin(), tp);
           }
           SetEndPoints(tjs, tj1); 
           
           //Remove first TP from first trajectory
           tj0.Pts[endPt0].Chg = 0;
           for (size_t j = 0; j<tj0.Pts[endPt0].Hits.size(); ++j){
             tj0.Pts[endPt0].UseHit[j] = false;
           }
           SetEndPoints(tjs, tj0);
           tj0.AlgMod[kVtxHitsSwap] = true;
           tj1.AlgMod[kVtxHitsSwap] = true;
           break;
         }
         
         //Now Check if the beginning of the first trajectory should be moved to the second trajectory.
         j = endPt0;
         std::vector<unsigned short> tplist;
         while (j!=tj0.EndPt[1-i]){
           if (tj0.Pts[j].Chg){
             float delta = 1000;
             for (size_t k = 0; k<tj0.Pts[j].Hits.size(); ++k){
               if (!tj0.Pts[j].UseHit[k]) continue;
               float this_delta = PointTrajDOCA(tjs, tj0.Pts[j].Hits[k], tj1.Pts[endPt1]);
               if (this_delta<delta) delta = this_delta;
               //if (vtxPrt) mf::LogVerbatim("TC")<<j<<" "<<k<<" "<<PrintPos(tjs, tj0.Pts[j])<<" "<<PointTrajDOCA(tjs, tj0.Pts[j].Hits[k], tj1.Pts[endPt1]);
             }
             if (delta < 0.3 && tj0.Pts[j].Delta > 1.0 && (j==endPt0 || !tplist.empty())){
               tplist.push_back(j);
             }
             else break;
           }
           if (i==0) ++j;
           else --j;
         }
         //if (vtxPrt) mf::LogVerbatim("TC")<<tplist.size();
         //Need at least two TPs to make this change
         if (tplist.size()>1){
           if (vtxPrt) mf::LogVerbatim("TC")<<"VHS Moving "<<tplist.size()<<" TPs from TJ "<<tj0.ID<<" to TJ "<<tj1.ID;
           //Append TPs to the second TJ
           for (unsigned short j = 0; j<tplist.size(); ++j){
             TrajPoint tp = tj0.Pts[tplist[j]];
             for (size_t k = 0; k<tp.Hits.size(); ++k){
               if (!tp.UseHit[k]) continue;
               tjs.fHits[tp.Hits[k]].InTraj = tj1.ID;
             }
             if (i==0){
               //append to the end
               tj1.Pts.push_back(tp);
             }
             else{
               //insert at the beginning
               tj1.Pts.insert(tj1.Pts.begin(), tp);
             }
           }
           SetEndPoints(tjs, tj1); 
           
           //Remove TPs from first trajectory
           for (unsigned short j = 0; j<tplist.size(); ++j){
             tj0.Pts[tplist[j]].Chg = 0;
             for (size_t k = 0; k<tj0.Pts[tplist[j]].Hits.size(); ++k){
               tj0.Pts[tplist[j]].UseHit[k] = false;
             }
           }
           SetEndPoints(tjs, tj0);
           tj0.AlgMod[kVtxHitsSwap] = true;
           tj1.AlgMod[kVtxHitsSwap] = true;
           break;
         }
       }//loop over two trajectories
     }//loop over vertices
   }

unsigned short tca::Vx3Topo	(	TjStuff &	tjs,
		Vtx3Store &	vx3
	)

Definition at line 2450 of file TCVertex.cxx.

References tca::Vtx3Store::ID, tca::TjStuff::vtx, and tca::Vtx3Store::Vx2ID.

   {
     // Returns the most common value of Topo for the 2D vertices that are matched
     // to this 3D vertex. This **might** be a useful measure to identify neutrino interaction
     // vertices
     
     if(vx3.ID == 0) return USHRT_MAX;
     // Consider Topo values between 0 and 9
     std::array<short, 10> cnts;
     cnts.fill(0);
     for(auto vx2id : vx3.Vx2ID) {
       if(vx2id == 0) continue;
       auto& vx2 = tjs.vtx[vx2id - 1];
       if(vx2.Topo < 0 || vx2.Topo > 9) continue;
       ++cnts[vx2.Topo];
     } // vx2id
     short most = 0;
     unsigned short theMost = USHRT_MAX;
     for(unsigned short itp = 0; itp < 10; ++itp) {
       if(cnts[itp] > most) {
         most = cnts[itp];
         theMost = itp;
       }
     } // itp
     return theMost;
   } // Vx3Topo

void tca::WatchHit	(	std::string	someText,
		TjStuff &	tjs,
		const unsigned int &	wHit,
		short &	wInTraj,
		const unsigned short &	tjID
	)

Definition at line 984 of file Utils.cxx.

References tca::TjStuff::fHits, and PrintHitShort().

   {
     // a temp routine to watch when inTraj changes for the supplied hit index, watchHit
     if(wHit > tjs.fHits.size() - 1) return;
     
     if(tjs.fHits[wHit].InTraj != wInTraj) {
       std::cout<<someText<<" Hit "<<PrintHitShort(tjs.fHits[wHit])<<" was InTraj "<<wInTraj<<" now InTraj "<<tjs.fHits[wHit].InTraj<<" T"<<tjID<<"\n";
       wInTraj = tjs.fHits[wHit].InTraj;
     }
   } // WatchHit

bool tca::WireHitRangeOK	(	const TjStuff &	tjs,
		const CTP_t &	inCTP
	)

Definition at line 3886 of file Utils.cxx.

References geo::CryostatID::Cryostat, DecodeCTP(), geo::TPCID::TPC, and tca::TjStuff::TPCID.

Referenced by DotProd(), and FindCloseHits().

   {
     // returns true if the passed CTP code is consistent with the CT code of the WireHitRangeVector
     geo::PlaneID planeID = DecodeCTP(inCTP);
     if(planeID.Cryostat != tjs.TPCID.Cryostat) return false;
     if(planeID.TPC != tjs.TPCID.TPC) return false;
     return true;
   }

unsigned short tca::WiresSkippedInCTP	(	TjStuff &	tjs,
		std::vector< int > &	tjids,
		CTP_t	inCTP
	)

Definition at line 1060 of file PFPUtils.cxx.

References tca::TjStuff::allTraj, and evd::details::end().

   {
     // counts the number of wires between the end points of all Tjs in the list of tjids
     // in inCTP where there is no TP with charge
     if(tjids.empty()) return 0;
     
     // find the min and max Pos[0] positions
     float fLoWire = 1E6;
     float fHiWire = -1E6;
     for(auto tjid : tjids) {
       auto& tj = tjs.allTraj[tjid - 1];
       if(tj.CTP != inCTP) continue;
       for(unsigned short end = 0; end < 2; ++end) {
         float endWire = tj.Pts[tj.EndPt[end]].Pos[0];
         if(endWire < -0.4) continue;
         if(endWire < fLoWire) fLoWire = endWire;
         if(endWire > fHiWire) fHiWire = endWire;
       } // end
     } // tjid
     if(fLoWire >= fHiWire) return 0;
     unsigned int loWire = std::nearbyint(fLoWire);
     unsigned short nWires = std::nearbyint(fHiWire) - loWire + 1;
     std::vector<bool> ptOnWire(nWires, false);
     
     // count the number of points with charge on all Tjs
     float npwc = 0;
     for(auto tjid : tjids) {
       auto& tj = tjs.allTraj[tjid - 1];
       if(tj.CTP != inCTP) continue;
       for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
         auto& tp = tj.Pts[ipt];
         if(tp.Chg <= 0) continue;
         if(tp.Pos[0] < -0.4) continue;
         ++npwc;
         unsigned short indx = std::nearbyint(tp.Pos[0]) - loWire;
         if(indx < nWires) ptOnWire[indx] = true;
       } // ipt
     } // tjid
     if(npwc == 0) return 0;
     float nskip = 0;
     for(unsigned short indx = 0; indx < nWires; ++indx) if(!ptOnWire[indx]) ++nskip;
     return (nskip / npwc);
     
   } // WiresSkippedInCTP

bool tca::WrongSplitTj	(	std::string	inFcnLabel,
		TjStuff &	tjs,
		Trajectory &	tj,
		unsigned short	tjEnd,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 2409 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::ID, kComp3DVx, tca::TjStuff::vtx, and tca::Trajectory::VtxID.

   {
     // Returns true if the trajectory was split by a 3D vertex match and the end of this trajectory is further
     // away from the shower than the partner trajectory
     // Here is a cartoon showing what we are trying to prevent. The shower is represented by a box. The trajectory
     // that is shown as (---*---) was originally reconstructed as a single trajectory. It was later split at the * position
     // by matching in 3D into two trajectories with ID = 1 and 2. We don't want to consider Tj 1 using end 0 as a parent for
     // the shower. Tj is more likely to be the real parent
     //
     //  1111111111 2222222  TjID
     //  0        1 0     1  Tj end
     //               --------------
     //               |            |
     //  ----------*-------        |
     //               |            |
     //               --------------
     if(!tj.AlgMod[kComp3DVx]) return false;
     if(tjEnd > 1) return false;
     
     std::string fcnLabel = inFcnLabel + ".WSTj";
     
     // See if the other end is the end that was split. It should have a vertex with Topo = 8 or 11
     unsigned short otherEnd = 1 - tjEnd;
 //    if(prt) mf::LogVerbatim("TC")<<"WSTj: otherEnd "<<otherEnd<<" vtxID "<<tj.VtxID[otherEnd];
     if(tj.VtxID[otherEnd] == 0) return false;
     unsigned short ivx = tj.VtxID[otherEnd] - 1;
     // A vertex exists but not a 3D split vertex
     if(tjs.vtx[ivx].Topo != 8 && tjs.vtx[ivx].Topo != 10) return false;
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Primary candidate "<<tj.ID<<" was split by a 3D vertex";
     return true;
     
   } // WrongSplitTj

Variable Documentation

const std::vector< std::string > tca::AlgBitNames

Definition at line 4 of file DataStructs.cxx.

Referenced by tca::TrajClusterAlg::ChkInTraj(), tca::TrajClusterAlg::GetAlgBitNames(), InTrajOK(), tca::TrajClusterAlg::MakeAllTrajClusters(), tca::TruthMatcher::MatchAndSum(), PrintAllTraj(), PrintTrajectory(), and tca::TrajClusterAlg::reconfigure().

constexpr unsigned int tca::Cpad = 10000

Definition at line 43 of file DataStructs.h.

Referenced by DecodeCTP().

DebugStuff tca::debug

Definition at line 4 of file DebugStruct.cxx.

Referenced by CompleteIncomplete3DVertices(), CompleteIncomplete3DVerticesInGaps(), detinfo::DetectorPropertiesStandard::DetectorPropertiesStandard(), tca::TrajClusterAlg::EndMerge(), FillWireHitRange(), Find2DVertices(), Find3DVertices(), FindHammerVertices(), FindHammerVertices2(), tca::TrajClusterAlg::FindJunkTraj(), tca::TrajClusterAlg::FindMissedVxTjs(), FindNeutralVertices(), FindShowers3D(), main(), MakeJunkVertices(), trkf::SpacePointAlg::makeSpacePoints(), tca::TrajClusterAlg::reconfigure(), tca::TrajClusterAlg::ReconstructAllTraj(), tca::TrajClusterAlg::RunTrajClusterAlg(), cmtool::CBAlgoPolyOverlap::SetDebug(), cmtool::CBAlgoStartInPoly::SetDebug(), cmtool::CFAlgoTimeOverlap::SetDebug(), cmtool::CFAlgo3DAngle::SetDebug(), cmtool::CBAlgoStartInCone::SetDebug(), SplitTrajCrossingVertices(), tca::TrajClusterAlg::StartTraj(), StoreTraj(), TagDeltaRays(), and VtxHitsSwap().

const std::vector< std::string > tca::StopFlagNames

Initial value:

{
    "Signal",
    "AtKink",
    "AtVtx",
    "Bragg",
    "AtTj",
    "OutFV"
  }

Definition at line 71 of file DataStructs.cxx.

Referenced by PrintStopFlag(), and tca::TrajClusterAlg::reconfigure().

constexpr unsigned int tca::Tpad = 10

Definition at line 42 of file DataStructs.h.

Referenced by DecodeCTP().

const std::vector< std::string > tca::VtxBitNames

Initial value:

{
    "VtxTrjTried",
    "Fixed",
    "OnDeadWire",
    "HiVx3Score",
    "VtxTruMatch",
    "VtxMerged"
  }

Definition at line 80 of file DataStructs.cxx.

Referenced by PrintAllTraj().

Classes

Typedefs

Enumerations

Functions

Variables

Data structures for the reconstruction results

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation