Classes
struct	CRTreeVars

struct	DebugStuff

struct	DontClusterStruct

struct	HistStuff

struct	MatchStruct

struct	ParFit

struct	PFPStruct

struct	SectionFit

struct	ShowerPoint

struct	ShowerStruct

struct	ShowerStruct3D

struct	ShowerTreeVars

struct	SortEntry

struct	TCConfig

struct	TCEvent

struct	TCHit

struct	TCSlice

struct	TCWireIntersection

struct	Tj2Pt

struct	TjForecast

struct	TP3D

class	TrajClusterAlg

struct	Trajectory

struct	TrajPoint

struct	TrajPoint3

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)

void	StitchPFPs ()

void	FindPFParticles (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, TCSlice &slc)

void	MakePFParticles (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, TCSlice &slc, std::vector< MatchStruct > matVec, unsigned short matVec_Iter)

bool	ReconcileTPs (TCSlice &slc, PFPStruct &pfp, bool prt)

void	ReconcileTPs (TCSlice &slc)

void	MakePFPTjs (TCSlice &slc)

void	FillWireIntersections (TCSlice &slc)

bool	TCIntersectionPoint (unsigned int wir1, unsigned int wir2, unsigned int pln1, unsigned int pln2, float &y, float &z)

void	Match3PlanesSpt (TCSlice &slc, std::vector< MatchStruct > &matVec)

bool	SptInTPC (const std::array< unsigned int, 3 > &sptHits, unsigned int tpc)

void	Match3Planes (TCSlice &slc, std::vector< MatchStruct > &matVec)

void	Match2Planes (TCSlice &slc, std::vector< MatchStruct > &matVec)

bool	Update (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, PFPStruct &pfp, bool prt)

bool	ReSection (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, PFPStruct &pfp, bool prt)

void	CountBadPoints (const TCSlice &slc, const PFPStruct &pfp, unsigned short fromPt, unsigned short toPt, unsigned short &nBadPts, unsigned short &firstBadPt)

bool	CanSection (const TCSlice &slc, const PFPStruct &pfp)

unsigned short	Find3DRecoRange (const TCSlice &slc, const PFPStruct &pfp, unsigned short fromPt, unsigned short min2DPts, short dir)

void	GetRange (const PFPStruct &pfp, unsigned short sfIndex, unsigned short &fromPt, unsigned short &npts)

bool	FitSection (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, PFPStruct &pfp, unsigned short sfIndex)

SectionFit	FitTP3Ds (detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, const std::vector< TP3D > &tp3ds, unsigned short fromPt, short fitDir, unsigned short nPtsFit)

bool	FitTP3Ds (detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, PFPStruct &pfp, unsigned short fromPt, unsigned short nPtsFit, unsigned short sfIndex, float &chiDOF)

void	ReconcileVertices (TCSlice &slc, PFPStruct &pfp, bool prt)

void	FillGaps3D (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, TCSlice &slc, PFPStruct &pfp, bool prt)

bool	ValidTwoPlaneMatch (detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, const PFPStruct &pfp)

void	AddPointsInRange (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, TCSlice &slc, PFPStruct &pfp, unsigned short fromPt, unsigned short toPt, CTP_t inCTP, float maxPull, unsigned short &nWires, unsigned short &nAdd, bool prt)

unsigned short	InsertTP3D (PFPStruct &pfp, TP3D &tp3d)

bool	SortSection (PFPStruct &pfp, unsigned short sfIndex)

void	Recover (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, TCSlice &slc, PFPStruct &pfp, bool prt)

bool	MakeTP3Ds (detinfo::DetectorPropertiesData const &detProp, TCSlice &slc, PFPStruct &pfp, bool prt)

bool	MakeSmallAnglePFP (detinfo::DetectorPropertiesData const &detProp, TCSlice &slc, PFPStruct &pfp, bool prt)

void	Reverse (TCSlice &slc, PFPStruct &pfp)

void	FillmAllTraj (detinfo::DetectorPropertiesData const &detProp, TCSlice &slc)

TP3D	MakeTP3D (detinfo::DetectorPropertiesData const &detProp, TCSlice &slc, const TrajPoint &itp, const TrajPoint &jtp)

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 (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, PFPStruct &pfp)

void	Average_dEdX (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, PFPStruct &pfp, float &dEdXAve, float &dEdXRms)

float	dEdx (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, TP3D &tp3d)

TP3D	CreateTP3D (detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, int tjID, unsigned short tpIndex)

bool	SetSection (detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, PFPStruct &pfp, TP3D &tp3d)

float	PointPull (const PFPStruct &pfp, const TP3D &tp3d)

PFPStruct	CreatePFP (const TCSlice &slc)

void	PFPVertexCheck (TCSlice &slc)

void	DefinePFPParents (TCSlice &slc, bool prt)

bool	StorePFP (TCSlice &slc, PFPStruct &pfp)

bool	InsideFV (const TCSlice &slc, const PFPStruct &pfp, unsigned short end)

bool	InsideTPC (const 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)

float	ChgFracBetween (detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, Point3_t pos1, Point3_t pos2)

float	ChgFracNearEnd (detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, const PFPStruct &pfp, unsigned short end)

Vector3_t	DirAtEnd (const PFPStruct &pfp, unsigned short end)

Point3_t	PosAtEnd (const PFPStruct &pfp, unsigned short end)

float	Length (const PFPStruct &pfp)

bool	SectionStartEnd (const PFPStruct &pfp, unsigned short sfIndex, unsigned short &startPt, unsigned short &endPt)

unsigned short	FarEnd (const TCSlice &slc, const PFPStruct &pfp, const Point3_t &pos)

int	PDGCodeVote (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, PFPStruct &pfp)

void	PrintTP3Ds (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, std::string someText, const TCSlice &slc, const PFPStruct &pfp, short printPts)

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

void	StepAway (TCSlice &slc, Trajectory &tj)

bool	StopShort (TCSlice &slc, Trajectory &tj, bool prt)

void	SetStrategy (TCSlice &slc, Trajectory &tj)

void	Forecast (TCSlice &slc, const Trajectory &tj)

void	UpdateStiffEl (TCSlice &slc, Trajectory &tj)

void	UpdateTraj (TCSlice &slc, Trajectory &tj)

void	CheckStiffEl (TCSlice &slc, Trajectory &tj)

void	CheckTraj (TCSlice &slc, Trajectory &tj)

void	AddHits (TCSlice &slc, Trajectory &tj, unsigned short ipt, bool &sigOK)

void	AddLAHits (TCSlice &slc, Trajectory &tj, unsigned short ipt, bool &sigOK)

void	ReversePropagate (TCSlice &slc, Trajectory &tj)

void	GetHitMultiplet (const TCSlice &slc, unsigned int theHit, std::vector< unsigned int > &hitsInMultiplet, bool useLongPulseHits)

float	HitTimeErr (const TCSlice &slc, unsigned int iht)

float	HitsTimeErr2 (const TCSlice &slc, const std::vector< unsigned int > &hitVec)

void	ChkStopEndPts (TCSlice &slc, Trajectory &tj, bool prt)

void	DefineHitPos (TCSlice &slc, TrajPoint &tp)

void	FindUseHits (TCSlice &slc, Trajectory &tj, unsigned short ipt, float maxDelta, bool useChg)

void	FillGaps (TCSlice &slc, Trajectory &tj)

void	CheckHiMultUnusedHits (TCSlice &slc, Trajectory &tj)

void	CheckHiMultEndHits (TCSlice &slc, Trajectory &tj)

void	UpdateDeltaRMS (TCSlice &slc, Trajectory &tj)

void	MaskBadTPs (TCSlice &slc, Trajectory &tj, float const &maxChi)

bool	MaskedHitsOK (TCSlice &slc, Trajectory &tj)

bool	StopIfBadFits (TCSlice &slc, Trajectory &tj)

bool	GottaKink (TCSlice &slc, Trajectory &tj, bool doTrim)

void	ChkBegin (TCSlice &slc, Trajectory &tj)

void	FixBegin (TCSlice &slc, Trajectory &tj, unsigned short atPt)

bool	IsGhost (TCSlice &slc, Trajectory &tj)

bool	IsGhost (TCSlice &slc, std::vector< unsigned int > &tHits)

void	LastEndMerge (TCSlice &slc, CTP_t inCTP)

TrajPoint	CreateTPFromTj (TCSlice &slc, const Trajectory &tj)

void	EndMerge (TCSlice &slc, CTP_t inCTP, bool lastPass)

void	MaskTrajEndPoints (TCSlice &slc, Trajectory &tj, unsigned short nPts)

void	ChkStop (TCSlice &slc, Trajectory &tj)

bool	ChkMichel (TCSlice &slc, Trajectory &tj, unsigned short &lastGoodPt)

bool	MakeJunkTraj (TCSlice &slc, std::vector< unsigned int > tHits)

void	SaveCRInfo (detinfo::DetectorClocksData const &clockData, TCSlice &slc, PFPStruct &pfp, bool prt, bool fIsRealData)

int	GetOrigin (detinfo::DetectorClocksData const &clockData, TCSlice &slc, PFPStruct &pfp)

void	ClearCRInfo (TCSlice &slc)

void	ConfigureMVA (TCConfig &tcc, std::string fMVAShowerParentWeights)

bool	FindShowerStart (detinfo::DetectorPropertiesData const &detProp, TCSlice &slc, ShowerStruct3D &ss3, bool prt)

void	Finish3DShowers (TCSlice &slc)

bool	FindShowers3D (detinfo::DetectorPropertiesData const &detProp, TCSlice &slc)

bool	Reconcile3D (std::string inFcnLabel, TCSlice &slc, bool parentSearchDone, bool prt)

bool	Reconcile3D (std::string inFcnLabel, TCSlice &slc, ShowerStruct3D &ss3, bool prt)

void	KillVerticesInShower (std::string inFcnLabel, TCSlice &slc, ShowerStruct &ss, bool prt)

bool	CompleteIncompleteShower (std::string inFcnLabel, TCSlice &slc, ShowerStruct3D &ss3, bool prt)

bool	UpdateShower (std::string inFcnLabel, TCSlice &slc, ShowerStruct &ss, bool prt)

bool	UpdateShower (std::string inFcnLabel, TCSlice &slc, ShowerStruct3D &ss3, bool prt)

float	Match3DFOM (detinfo::DetectorPropertiesData const &detProp, std::string inFcnLabel, TCSlice &slc, ShowerStruct3D &ss3, bool prt)

float	Match3DFOM (detinfo::DetectorPropertiesData const &detProp, std::string inFcnLabel, TCSlice &slc, int icid, int jcid, int kcid, bool prt)

float	Match3DFOM (detinfo::DetectorPropertiesData const &detProp, std::string inFcnLabel, TCSlice &slc, int icid, int jcid, bool prt)

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

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

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

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

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

bool	FindParent (detinfo::DetectorPropertiesData const &detProp, std::string inFcnLabel, TCSlice &slc, ShowerStruct3D &ss3, bool prt)

bool	SetParent (detinfo::DetectorPropertiesData const &detProp, std::string inFcnLabel, TCSlice &slc, PFPStruct &pfp, ShowerStruct3D &ss3, bool prt)

bool	IsShowerLike (TCSlice &slc, 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 (TCSlice &slc, const ShowerStruct3D &ss3, const PFPStruct &pfp)

float	InShowerProb (TCSlice &slc, const ShowerStruct &ss, const Trajectory &tj)

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

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

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

void	MergeNearby2DShowers (std::string inFcnLabel, TCSlice &slc, const CTP_t &inCTP, bool prt)

void	MergeOverlap (std::string inFcnLabel, TCSlice &slc, const CTP_t &inCTP, bool prt)

void	MergeShowerChain (std::string inFcnLabel, TCSlice &slc, const CTP_t &inCTP, bool prt)

void	MergeSubShowersTj (std::string inFcnLabel, TCSlice &slc, const CTP_t &inCTP, bool prt)

void	MergeSubShowers (std::string inFcnLabel, TCSlice &slc, const CTP_t &inCTP, bool prt)

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

bool	MergeShowersAndStore (std::string inFcnLabel, TCSlice &slc, int icotID, int jcotID, bool prt)

bool	MergeShowerTjsAndStore (TCSlice &slc, unsigned short istj, unsigned short jstj, bool prt)

bool	AnalyzeRotPos (std::string inFcnLabel, TCSlice &slc, ShowerStruct &ss, bool prt)

void	ReverseShower (std::string inFcnLabel, TCSlice &slc, ShowerStruct &ss, bool prt)

void	ReverseShower (std::string inFcnLabel, TCSlice &slc, int cotID, bool prt)

void	MakeShowerObsolete (std::string inFcnLabel, TCSlice &slc, ShowerStruct3D &ss3, bool prt)

void	MakeShowerObsolete (std::string inFcnLabel, TCSlice &slc, ShowerStruct &ss, bool prt)

bool	DontCluster (TCSlice &slc, const std::vector< int > &tjlist1, const std::vector< int > &tjlist2)

void	TagShowerLike (std::string inFcnLabel, TCSlice &slc, const CTP_t &inCTP)

void	FindNearbyTjs (std::string inFcnLabel, TCSlice &slc, ShowerStruct &ss, bool prt)

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

void	DefineEnvelope (std::string inFcnLabel, TCSlice &slc, ShowerStruct &ss, bool prt)

bool	AddTjsInsideEnvelope (std::string inFcnLabel, TCSlice &slc, ShowerStruct &ss, bool prt)

bool	AddLooseHits (TCSlice &slc, int cotID, bool prt)

void	FindStartChg (std::string inFcnLabel, TCSlice &slc, int cotID, bool prt)

std::vector< float >	StartChgVec (TCSlice &slc, int cotID, bool prt)

void	DumpShowerPts (TCSlice &slc, int cotID)

bool	TransferTjHits (TCSlice &slc, bool prt)

int	GetCotID (TCSlice &slc, int ShowerTjID)

double	ShowerEnergy (const ShowerStruct3D &ss3)

float	ShowerEnergy (TCSlice &slc, const std::vector< int > tjIDs)

float	ChgToMeV (float chg)

bool	StoreShower (std::string inFcnLabel, TCSlice &slc, ShowerStruct3D &ss3)

bool	StoreShower (std::string inFcnLabel, TCSlice &slc, ShowerStruct &ss)

ShowerStruct3D	CreateSS3 (TCSlice &slc)

ShowerStruct	CreateSS (TCSlice &slc, const std::vector< int > &tjl)

bool	ChkAssns (std::string inFcnLabel, TCSlice &slc)

void	PrintShowers (detinfo::DetectorPropertiesData const &detProp, std::string fcnLabel, TCSlice &slc)

void	Print2DShowers (std::string someText, TCSlice &slc, CTP_t inCTP, bool printKilledShowers)

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

void	Match2DShowers (std::string inFcnLabel, TCSlice &slc, bool prt)

void	DefineDontCluster (TCSlice &slc, bool prt)

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

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

bool	AddLooseHits (std::string inFcnLabel, TCSlice &slc, int cotID, bool prt)

void	DumpShowerPts (std::string inFcnLabel, TCSlice &slc, int cotID)

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

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

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

void	SaveTjInfo (TCSlice &slc, std::vector< std::vector< int >> &tjList, std::string stageName)

void	SaveTjInfo (TCSlice &slc, const ShowerStruct &ss, std::string stageName)

void	SaveTjInfoStuff (TCSlice &slc, Trajectory &tj, int stageNum, std::string stageName)

void	SaveAllCots (TCSlice &slc, const CTP_t &inCTP, std::string someText)

void	SaveAllCots (TCSlice &slc, 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 (TCSlice &slc, const CTP_t &inCTP)

void	Find2DVertices (detinfo::DetectorPropertiesData const &detProp, TCSlice &slc, const CTP_t &inCTP, unsigned short pass)

bool	MergeWithVertex (TCSlice &slc, VtxStore &vx, unsigned short oVxID)

void	FindHammerVertices2 (TCSlice &slc, const CTP_t &inCTP)

void	FindHammerVertices (TCSlice &slc, const CTP_t &inCTP)

void	SplitTrajCrossingVertices (TCSlice &slc, CTP_t inCTP)

void	Reconcile2Vs (TCSlice &slc)

bool	Reconcile2VTs (TCSlice &slc, std::vector< int > &vx2cls, bool prt)

void	Find3DVertices (detinfo::DetectorPropertiesData const &detProp, TCSlice &slc)

unsigned short	TPNearVertex (const TCSlice &slc, const TrajPoint &tp)

bool	AttachToAnyVertex (TCSlice &slc, PFPStruct &pfp, float maxSep, bool prt)

bool	AttachAnyVertexToTraj (TCSlice &slc, int tjID, bool prt)

bool	AttachAnyTrajToVertex (TCSlice &slc, unsigned short ivx, bool prt)

bool	AttachTrajToVertex (TCSlice &slc, Trajectory &tj, VtxStore &vx, bool prt)

float	TrajPointVertexPull (const TCSlice &slc, const TrajPoint &tp, const VtxStore &vx)

float	VertexVertexPull (const TCSlice &slc, const Vtx3Store &vx1, const Vtx3Store &vx2)

float	VertexVertexPull (const TCSlice &slc, const VtxStore &vx1, const VtxStore &vx2)

bool	StoreVertex (TCSlice &slc, VtxStore &vx)

bool	FitVertex (TCSlice &slc, VtxStore &vx, bool prt)

bool	FitVertex (TCSlice &slc, VtxStore &vx, std::vector< TrajPoint > &vxTPs, bool prt)

bool	ChkVtxAssociations (TCSlice &slc, const CTP_t &inCTP)

void	ScoreVertices (TCSlice &slc)

void	KillPoorVertices (TCSlice &slc)

void	SetHighScoreBits (TCSlice &slc, Vtx3Store &vx3)

void	SetVx3Score (TCSlice &slc, Vtx3Store &vx3)

void	SetVx2Score (TCSlice &slc)

void	SetVx2Score (TCSlice &slc, VtxStore &vx2)

void	CompleteIncomplete3DVerticesInGaps (detinfo::DetectorPropertiesData const &detProp, TCSlice &slc)

void	CompleteIncomplete3DVertices (detinfo::DetectorPropertiesData const &detProp, TCSlice &slc)

bool	RefineVtxPosition (TCSlice &slc, const Trajectory &tj, unsigned short &nearPt, short nPtsToChk, bool prt)

bool	MakeVertexObsolete (std::string fcnLabel, TCSlice &slc, VtxStore &vx2, bool forceKill)

bool	MakeVertexObsolete (TCSlice &slc, Vtx3Store &vx3)

std::vector< int >	GetVtxTjIDs (const TCSlice &slc, const VtxStore &vx2)

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

void	PosInPlane (detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, const Vtx3Store &vx3, unsigned short plane, Point2_t &pos)

unsigned short	IsCloseToVertex (const TCSlice &slc, const VtxStore &inVx2)

unsigned short	IsCloseToVertex (const TCSlice &slc, const Vtx3Store &vx3)

void	MakeJunkTjVertices (TCSlice &slc, const CTP_t &inCTP)

void	MakeHaloTj (TCSlice &slc, Trajectory &muTj, bool prt)

void	DefineTjParents (TCSlice &slc, bool prt)

float	MaxChargeAsymmetry (TCSlice &slc, std::vector< int > &tjIDs)

int	PDGCodeVote (const TCSlice &slc, const std::vector< int > &tjIDs)

int	NeutrinoPrimaryTjID (const TCSlice &slc, const Trajectory &tj)

int	PrimaryID (const TCSlice &slc, const Trajectory &tj)

int	PrimaryUID (const TCSlice &slc, const PFPStruct &pfp)

bool	MergeTjIntoPFP (TCSlice &slc, int mtjid, PFPStruct &pfp, bool prt)

float	PointPull (TCSlice &slc, Point2_t pos, float chg, const Trajectory &tj)

bool	CompatibleMerge (const TCSlice &slc, std::vector< int > &tjIDs, bool prt)

bool	CompatibleMerge (const TCSlice &slc, const Trajectory &tj1, const Trajectory &tj2, bool prt)

float	OverlapFraction (const TCSlice &slc, const Trajectory &tj1, const Trajectory &tj2)

unsigned short	AngleRange (TrajPoint const &tp)

void	SetAngleCode (TrajPoint &tp)

unsigned short	AngleRange (float angle)

void	FitTraj (TCSlice &slc, Trajectory &tj)

void	FitTraj (TCSlice &slc, Trajectory &tj, unsigned short originPt, unsigned short npts, short fitDir, TrajPoint &tpFit)

unsigned short	GetPFPIndex (const TCSlice &slc, int tjID)

void	ReleaseHits (TCSlice &slc, Trajectory &tj)

void	UnsetUsedHits (TCSlice &slc, TrajPoint &tp)

bool	StoreTraj (TCSlice &slc, Trajectory &tj)

void	FitPar (const TCSlice &slc, const Trajectory &tj, unsigned short originPt, unsigned short npts, short fitDir, ParFit &pFit, unsigned short usePar)

bool	InTrajOK (TCSlice &slc, std::string someText)

void	CheckTrajBeginChg (TCSlice &slc, unsigned short itj)

bool	BraggSplit (TCSlice &slc, unsigned short itj)

void	TrimHiChgEndPts (TCSlice &slc, Trajectory &tj, bool prt)

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

void	ChkEndKink (TCSlice &slc, Trajectory &tj, bool prt)

void	ChkChgAsymmetry (TCSlice &slc, Trajectory &tj, bool prt)

bool	SignalBetween (const TCSlice &slc, const TrajPoint &tp1, const TrajPoint &tp2, const float &MinWireSignalFraction)

bool	SignalBetween (const TCSlice &slc, TrajPoint tp, float toPos0, const float &MinWireSignalFraction)

float	ChgFracBetween (const TCSlice &slc, TrajPoint tp, float toPos0)

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

bool	TrajHitsOK (TCSlice &slc, const unsigned int iht, const unsigned int jht)

float	ExpectedHitsRMS (TCSlice &slc, const TrajPoint &tp)

bool	SignalAtTpInSlc (const TCSlice &slc, const TrajPoint &tp)

bool	SignalAtTp (TrajPoint &tp)

bool	NearbySrcHit (geo::PlaneID plnID, unsigned int wire, float loTick, float hiTick)

float	TpSumHitChg (const TCSlice &slc, TrajPoint const &tp)

unsigned short	NumPtsWithCharge (const TCSlice &slc, const Trajectory &tj, bool includeDeadWires)

unsigned short	NumPtsWithCharge (const TCSlice &slc, const Trajectory &tj, bool includeDeadWires, unsigned short firstPt, unsigned short lastPt)

float	DeadWireCount (const TCSlice &slc, const TrajPoint &tp1, const TrajPoint &tp2)

float	DeadWireCount (const TCSlice &slc, const float &inWirePos1, const float &inWirePos2, CTP_t tCTP)

unsigned short	PDGCodeIndex (int PDGCode)

void	MakeTrajectoryObsolete (TCSlice &slc, unsigned int itj)

void	RestoreObsoleteTrajectory (TCSlice &slc, unsigned int itj)

void	MergeGhostTjs (TCSlice &slc, CTP_t inCTP)

bool	SplitTraj (detinfo::DetectorPropertiesData const &detProp, TCSlice &slc, unsigned short itj, float XPos, bool makeVx2, bool prt)

bool	SplitTraj (TCSlice &slc, unsigned short itj, unsigned short pos, unsigned short ivx, bool prt)

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

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

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

float	HitSep2 (const TCSlice &slc, unsigned int iht, unsigned int jht)

unsigned short	CloseEnd (const TCSlice &slc, const Trajectory &tj, const Point2_t &pos)

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

float	PointTrajDOCA (const TCSlice &slc, unsigned int iht, TrajPoint const &tp)

float	PointTrajDOCA (const TCSlice &slc, float wire, float time, TrajPoint const &tp)

float	PointTrajDOCA2 (const TCSlice &slc, 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 (const TCSlice &slc, std::vector< int > &tjIDs)

float	TrajLength (const Trajectory &tj)

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

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

float	TrajPointSeparation (const TrajPoint &tp1, const TrajPoint &tp2)

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

float	TwoTPAngle (const TrajPoint &tp1, const TrajPoint &tp2)

std::vector< unsigned int >	PutHitsInVector (const TCSlice &slc, PFPStruct const &pfp, HitStatus_t hitRequest)

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

void	TagJunkTj (TCSlice &slc, Trajectory &tj, bool prt)

bool	HasDuplicateHits (const TCSlice &slc, Trajectory const &tj, bool prt)

void	MoveTPToWire (TrajPoint &tp, float wire)

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

bool	FindCloseHits (TCSlice &slc, TrajPoint &tp, float const &maxDelta, HitStatus_t hitRequest)

unsigned short	NearbyCleanPt (const TCSlice &slc, const Trajectory &tj, unsigned short end)

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

float	KinkSignificance (TCSlice &slc, Trajectory &tj1, unsigned short end1, Trajectory &tj2, unsigned short end2, unsigned short nPtsFit, bool useChg, bool prt)

float	KinkSignificance (TCSlice &slc, Trajectory &tj, unsigned short kinkPt, unsigned short nPtsFit, bool useChg, bool prt)

float	ElectronLikelihood (const TCSlice &slc, const Trajectory &tj)

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

float	MaxHitDelta (TCSlice &slc, Trajectory &tj)

void	ReverseTraj (TCSlice &slc, 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 (Trajectory &tj)

bool	TrajIsClean (TCSlice &slc, Trajectory &tj, bool prt)

short	MCSMom (const TCSlice &slc, const std::vector< int > &tjIDs)

short	MCSMom (const TCSlice &slc, const Trajectory &tj)

short	MCSMom (const TCSlice &slc, const Trajectory &tj, unsigned short firstPt, unsigned short lastPt)

unsigned short	NearestPtWithChg (const TCSlice &slc, const Trajectory &tj, unsigned short thePt)

float	MCSThetaRMS (const TCSlice &slc, const Trajectory &tj)

double	MCSThetaRMS (const TCSlice &slc, const Trajectory &tj, unsigned short firstPt, unsigned short lastPt)

void	TjDeltaRMS (const TCSlice &slc, const Trajectory &tj, unsigned short firstPt, unsigned short lastPt, double &rms, unsigned short &cnt)

void	SetTPEnvironment (TCSlice &slc, CTP_t inCTP)

void	UpdateTjChgProperties (std::string inFcnLabel, TCSlice &slc, Trajectory &tj, bool prt)

void	UpdateVxEnvironment (TCSlice &slc)

void	UpdateVxEnvironment (TCSlice &slc, VtxStore &vx2, bool prt)

TrajPoint	MakeBareTP (detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, const Point3_t &pos, CTP_t inCTP)

TrajPoint	MakeBareTP (detinfo::DetectorPropertiesData const &detProp, const TCSlice &slc, const Point3_t &pos, const Vector3_t &dir, CTP_t inCTP)

bool	MakeBareTrajPoint (const TCSlice &slc, unsigned int fromHit, unsigned int toHit, TrajPoint &tp)

bool	MakeBareTrajPoint (const TCSlice &slc, 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 TCSlice &slc, const TrajPoint &tpIn1, const TrajPoint &tpIn2, TrajPoint &tpOut)

unsigned short	FarEnd (TCSlice &slc, const Trajectory &tj, const Point2_t &pos)

Vector2_t	PointDirection (const Point2_t p1, const Point2_t p2)

float	TPHitsRMSTime (const TCSlice &slc, const TrajPoint &tp, HitStatus_t hitRequest)

float	TPHitsRMSTick (const TCSlice &slc, const TrajPoint &tp, HitStatus_t hitRequest)

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

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

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

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

unsigned short	NumUsedHitsInTj (const TCSlice &slc, const Trajectory &tj)

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

void	SetPDGCode (TCSlice &slc, unsigned short itj)

void	SetPDGCode (TCSlice &slc, Trajectory &tj)

bool	AnalyzeHits ()

bool	LongPulseHit (const recob::Hit &hit)

void	FillWireHitRange (geo::TPCID inTPCID)

bool	FillWireHitRange (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, TCSlice &slc)

bool	WireHitRangeOK (TCSlice &slc, const CTP_t &inCTP)

bool	MergeAndStore (TCSlice &slc, unsigned int itj1, unsigned int itj2, bool doPrt)

std::vector< int >	GetAssns (TCSlice &slc, std::string type1Name, int id, std::string type2Name)

bool	StartTraj (TCSlice &slc, Trajectory &tj, unsigned int fromhit, unsigned int tohit, unsigned short pass)

bool	StartTraj (TCSlice &slc, Trajectory &tj, float fromWire, float fromTick, float toWire, float toTick, CTP_t &tCTP, unsigned short pass)

std::pair< unsigned short, unsigned short >	GetSliceIndex (std::string typeName, int uID)

bool	Fit2D (short mode, Point2_t inPt, float &inPtErr, Vector2_t &outVec, Vector2_t &outVecErr, float &chiDOF)

bool	DecodeDebugString (std::string strng)

void	DumpTj ()

void	PrintDebugMode ()

void	PrintAll (detinfo::DetectorPropertiesData const &detProp, std::string someText)

void	PrintP (std::string someText, mf::LogVerbatim &myprt, PFPStruct &pfp, bool &printHeader)

void	Print3V (detinfo::DetectorPropertiesData const &detProp, std::string someText, mf::LogVerbatim &myprt, Vtx3Store &vx3, bool &printHeader)

void	Print2V (std::string someText, mf::LogVerbatim &myprt, VtxStore &vx2, bool &printHeader)

void	Print3S (detinfo::DetectorPropertiesData const &detProp, std::string someText, mf::LogVerbatim &myprt, ShowerStruct3D &ss3)

void	PrintT (std::string someText, mf::LogVerbatim &myprt, Trajectory &tj, bool &printHeader)

void	PrintAllTraj (detinfo::DetectorPropertiesData const &detProp, std::string someText, TCSlice &slc, unsigned short itj, unsigned short ipt, bool prtVtx)

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

void	PrintTPHeader (std::string someText)

void	PrintTP (std::string someText, const TCSlice &slc, unsigned short ipt, short dir, unsigned short pass, const TrajPoint &tp)

std::string	TPEnvString (const TrajPoint &tp)

void	PrintPFP (std::string someText, TCSlice &slc, const PFPStruct &pfp, bool printHeader)

void	PrintPFPs (std::string someText, TCSlice &slc)

std::string	PrintEndFlag (const PFPStruct &pfp, unsigned short end)

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

std::string	PrintHitShort (const TCHit &tch)

std::string	PrintHit (const TCHit &tch)

std::string	PrintPos (const TCSlice &slc, const TrajPoint &tp)

std::string	PrintPos (const TCSlice &slc, const Point2_t &pos)

void	ChkMissedKink (TCSlice &slc, Trajectory &tj, bool prt)

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, kVxTruMatch, kVxMerged, kVxIndPlnNoChg, kVxEnvOK, kVxBitSize }

enum	TP3DFlags_t { kTP3DGood, kTP3DBad, kTP3DHiDEdx }

enum	PFPFlags_t { kCanSection, kNeedsUpdate, kSmallAngle }

enum	AlgBit_t { kFillGaps3D, kKink3D, kTEP3D, kJunk3D, kRTPs3D, kMat3D, kMaskHits, kMaskBadTPs, kMichel, kDeltaRay, kCTStepChk, kRvPrp, kCHMUH, kSplit, kComp3DVx, kComp3DVxIG, kHamBragg, kHamVx, kHamVx2, kJunkVx, kJunkTj, kKilled, kMerge, kLastEndMerge, kTEP, kTHCEP, kEndKink, kCHMEH, kFillGaps, kUseGhostHits, kMrgGhost, kChkInTraj, kStopBadFits, kFixBegin, kFTBChg, kBeginChg, kFixEnd, kBraggSplit, kUUH, kVtxTj, kChkVxTj, kPhoton, kHaloTj, kNoFitToVx, kVxMerge, kVxNeutral, kNoKinkChk, kChkStop, kChkStopEP, kChkChgAsym, kFTBRvProp, kTjHiVx3Score, kVtxHitsSwap, kSplitHiChgHits, kShowerLike, kKillInShowerVx, kShowerTj, kShwrParent, kMergeOverlap, kMergeSubShowers, kMergeSubShowersTj, kMergeNrShowers, kMergeShChain, kCompleteShower, kSplitTjCVx, kMakePFPTjs, kStopShort, kReconcile2Vs, kFTBMod, kAlgBitSize }

enum	Strategy_t { kNormal, kStiffEl, kStiffMu, kSlowing }

enum	EndFlag_t { kSignal, kAtKink, kAtVtx, kBragg, kAtTj, kOutFV, kNoFitVx, kFlagBitSize }

enum	TPEnvironment_t { kEnvNotGoodWire, kEnvNearMuon, kEnvNearShower, kEnvOverlap, kEnvUnusedHits, kEnvNearSrcHit, kEnvFlag }

enum	TCModes_t { kStepDir, kTestBeam, kDebug, kStudy1, kStudy2, kStudy3, kStudy4, kSaveCRTree, kTagCosmics, kSaveShowerTree }

TCEvent	evt

TCConfig	tcc

std::vector< TjForecast >	tjfs

ShowerTreeVars	stv

std::vector< TCSlice >	slices

std::vector< TrajPoint >	seeds

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

const std::vector< std::string >	EndFlagNames

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

const std::vector< std::string >	StrategyBitNames

constexpr unsigned int	pAlgModSize = 6

Detailed Description

TrajClusterAlg

Bruce Baller, balle.nosp@m.r@fn.nosp@m.al.go.nosp@m.v Citation: Liquid argon TPC signal formation, signal processing and reconstruction techniques B. Baller 2017 JINST 12 P07010

Typedef Documentation

typedef unsigned int tca::CTP_t

Definition at line 49 of file DataStructs.h.

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

Definition at line 45 of file DataStructs.h.

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

Definition at line 43 of file DataStructs.h.

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

Definition at line 46 of file DataStructs.h.

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

Definition at line 44 of file DataStructs.h.

Enumeration Type Documentation

enum tca::AlgBit_t

Enumerator
kFillGaps3D
kKink3D
kTEP3D
kJunk3D
kRTPs3D
kMat3D
kMaskHits
kMaskBadTPs
kMichel
kDeltaRay
kCTStepChk
kRvPrp
kCHMUH
kSplit
kComp3DVx
kComp3DVxIG
kHamBragg
kHamVx
kHamVx2
kJunkVx
kJunkTj
kKilled
kMerge
kLastEndMerge
kTEP
kTHCEP
kEndKink
kCHMEH
kFillGaps
kUseGhostHits
kMrgGhost
kChkInTraj
kStopBadFits
kFixBegin
kFTBChg
kBeginChg
kFixEnd
kBraggSplit
kUUH
kVtxTj
kChkVxTj
kPhoton
kHaloTj
kNoFitToVx
kVxMerge
kVxNeutral
kNoKinkChk
kChkStop
kChkStopEP
kChkChgAsym
kFTBRvProp
kTjHiVx3Score
kVtxHitsSwap
kSplitHiChgHits
kShowerLike
kKillInShowerVx
kShowerTj
kShwrParent
kMergeOverlap
kMergeSubShowers
kMergeSubShowersTj
kMergeNrShowers
kMergeShChain
kCompleteShower
kSplitTjCVx
kMakePFPTjs
kStopShort
kReconcile2Vs
kFTBMod
kAlgBitSize	don't mess with this line

Definition at line 428 of file DataStructs.h.

                {
     kFillGaps3D, // 3D algorithms for PFPs (bitset size limited to 8 bits)
     kKink3D,
     kTEP3D,
     kJunk3D,
     kRTPs3D,
     kMat3D, // 2D algorithms for Tjs here and below
     kMaskHits,
     kMaskBadTPs,
     kMichel,
     kDeltaRay,
     kCTStepChk,
     kRvPrp,
     kCHMUH,
     kSplit,
     kComp3DVx,
     kComp3DVxIG,
     kHamBragg,
     kHamVx,
     kHamVx2,
     kJunkVx,
     kJunkTj,
     kKilled,
     kMerge,
     kLastEndMerge,
     kTEP,
     kTHCEP,
     kEndKink,
     kCHMEH,
     kFillGaps,
     kUseGhostHits,
     kMrgGhost,
     kChkInTraj,
     kStopBadFits,
     kFixBegin,
     kFTBChg,
     kBeginChg,
     kFixEnd,
     kBraggSplit,
     kUUH,
     kVtxTj,
     kChkVxTj,
     kPhoton,
     kHaloTj,
     kNoFitToVx,
     kVxMerge,
     kVxNeutral,
     kNoKinkChk,
     kChkStop,
     kChkStopEP,
     kChkChgAsym,
     kFTBRvProp,
     kTjHiVx3Score,
     kVtxHitsSwap,
     kSplitHiChgHits,
     kShowerLike,
     kKillInShowerVx,
     kShowerTj,
     kShwrParent,
     kMergeOverlap,
     kMergeSubShowers,
     kMergeSubShowersTj,
     kMergeNrShowers,
     kMergeShChain,
     kCompleteShower,
     kSplitTjCVx,
     kMakePFPTjs,
     kStopShort,
     kReconcile2Vs,
     kFTBMod,
     kAlgBitSize ///< don't mess with this line
   } AlgBit_t;

enum tca::EndFlag_t

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

Definition at line 509 of file DataStructs.h.

                {
     kSignal,
     kAtKink,
     kAtVtx,
     kBragg,
     kAtTj,
     kOutFV,
     kNoFitVx,
     kFlagBitSize ///< don't mess with this line
   } EndFlag_t;

enum tca::HitStatus_t

Enumerator
kAllHits
kUsedHits
kUnusedHits

Definition at line 40 of file Utils.h.

                {
     kAllHits,
     kUsedHits,
     kUnusedHits,
   } HitStatus_t;

enum tca::PFPFlags_t

Enumerator
kCanSection
kNeedsUpdate
kSmallAngle

Definition at line 307 of file DataStructs.h.

                {
     kCanSection,
     kNeedsUpdate,
     kSmallAngle
   } PFPFlags_t;

enum tca::Strategy_t

Enumerator
kNormal
kStiffEl	use the stiff electron strategy
kStiffMu	use the stiff muon strategy
kSlowing	use the slowing-down strategy

Definition at line 501 of file DataStructs.h.

                {
     kNormal,
     kStiffEl, ///< use the stiff electron strategy
     kStiffMu, ///< use the stiff muon strategy
     kSlowing  ///< use the slowing-down strategy
   } Strategy_t;

enum tca::TCModes_t

Enumerator
kStepDir	step from US -> DS (true) or DS -> US (false)
kTestBeam	Expect tracks entering from the front face. Don't create neutrino PFParticles.
kDebug	master switch for turning on debug mode
kStudy1	call study functions to develop cuts, etc (see TCTruth.cxx)
kStudy2	call study functions to develop cuts, etc
kStudy3	call study functions to develop cuts, etc
kStudy4	call study functions to develop cuts, etc
kSaveCRTree	save cosmic ray tree
kTagCosmics	tag cosmic rays
kSaveShowerTree	save shower tree

Definition at line 532 of file DataStructs.h.

                {
     kStepDir,    ///< step from US -> DS (true) or DS -> US (false)
     kTestBeam,   ///< Expect tracks entering from the front face. Don't create neutrino PFParticles
     kDebug,      ///< master switch for turning on debug mode
     kStudy1,     ///< call study functions to develop cuts, etc (see TCTruth.cxx)
     kStudy2,     ///< call study functions to develop cuts, etc
     kStudy3,     ///< call study functions to develop cuts, etc
     kStudy4,     ///< call study functions to develop cuts, etc
     kSaveCRTree, ///< save cosmic ray tree
     kTagCosmics, ///< tag cosmic rays
     kSaveShowerTree ///< save shower tree
   } TCModes_t;

enum tca::TP3DFlags_t

Enumerator
kTP3DGood
kTP3DBad
kTP3DHiDEdx

Definition at line 268 of file DataStructs.h.

                {
     kTP3DGood,    // Is good for fitting and calorimetry
     kTP3DBad,      // Should be removed from the trajectory
     kTP3DHiDEdx  // Has high dE/dx
   } TP3DFlags_t;

enum tca::TPEnvironment_t

Enumerator
kEnvNotGoodWire
kEnvNearMuon
kEnvNearShower
kEnvOverlap
kEnvUnusedHits
kEnvNearSrcHit	TP is near a hit in the srcHit collection but no allHit hit exists (DUNE disambiguation error)
kEnvFlag	a general purpose flag bit used in 3D matching

Definition at line 521 of file DataStructs.h.

                {
     kEnvNotGoodWire,
     kEnvNearMuon,
     kEnvNearShower,
     kEnvOverlap,
     kEnvUnusedHits,
     kEnvNearSrcHit, ///< TP is near a hit in the srcHit collection but no allHit hit exists (DUNE disambiguation error)
     kEnvFlag ///< a general purpose flag bit used in 3D matching
   } 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
kVxTruMatch	tagged as a vertex between Tjs that are matched to MC truth neutrino interaction particles
kVxMerged
kVxIndPlnNoChg	vertex quality is suspect - No requirement made on chg btw it and the Tj
kVxEnvOK	the environment near the vertex was checked - See UpdateVxEnvironment
kVxBitSize	don't mess with this line

Definition at line 93 of file DataStructs.h.

                {
     kVtxTrjTried, ///< FindVtxTraj algorithm tried
     kFixed,       ///< vertex position fixed manually - no fitting done
     kOnDeadWire,
     kHiVx3Score, ///< matched to a high-score 3D vertex
     kVxTruMatch, ///< tagged as a vertex between Tjs that are matched to MC truth neutrino interaction particles
     kVxMerged,
     kVxIndPlnNoChg, ///< vertex quality is suspect - No requirement made on chg btw it and the Tj
     kVxEnvOK,       ///<  the environment near the vertex was checked - See UpdateVxEnvironment
     kVxBitSize      ///< don't mess with this line
   } VtxBit_t;

Function Documentation

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

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

Definition at line 3457 of file TCShower.cxx.

   {
     // 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 > slc.tjs.size() - 1) return;
 
     //short maxMom = (short)(2 * tcc.showerTag[1]);
     short maxMom = tcc.showerTag[1];
     //XL: why is maxMom is twice of the shower tag [1]?
     for (auto& tp : slc.tjs[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 (slc.slHits[iht].InTraj <= 0) continue;
         if ((unsigned int)slc.slHits[iht].InTraj > slc.tjs.size()) continue;
         // check the momentum
         Trajectory& tj = slc.tjs[slc.slHits[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(), slc.slHits[iht].InTraj) != list.end()) continue;
         list.push_back(slc.slHits[iht].InTraj);
       } // ii
     }   // tp
   }     // AddCloseTjsToList

void tca::AddHits	(	TCSlice &	slc,
		Trajectory &	tj,
		unsigned short	ipt,
		bool &	sigOK
	)

Definition at line 1037 of file StepUtils.cxx.

   {
     // Try to add hits to the trajectory point ipt on the supplied
     // trajectory
 
     // assume failure
     sigOK = false;
 
     if(tj.Pts.empty()) return;
     if(ipt > tj.Pts.size() - 1) return;
 
     // Call large angle hit finding if the last tp is large angle
     if(tj.Pts[ipt].AngleCode == 2) {
       AddLAHits(slc, tj, ipt, sigOK);
       return;
     }
 
     TrajPoint& tp = tj.Pts[ipt];
     std::vector<unsigned int> closeHits;
     unsigned int lastPtWithUsedHits = tj.EndPt[1];
 
     unsigned short plane = DecodeCTP(tj.CTP).Plane;
     unsigned int wire = std::nearbyint(tp.Pos[0]);
     if(wire < slc.firstWire[plane] || wire > slc.lastWire[plane]-1) return;
     // Move the TP to this wire
     MoveTPToWire(tp, (float)wire);
 
     // find the projection error to this point. Note that if this is the first
     // TP, lastPtWithUsedHits = 0, so the projection error is 0
     float dw = tp.Pos[0] - tj.Pts[lastPtWithUsedHits].Pos[0];
     float dt = tp.Pos[1] - tj.Pts[lastPtWithUsedHits].Pos[1];
     float dpos = sqrt(dw * dw + dt * dt);
     float projErr = dpos * tj.Pts[lastPtWithUsedHits].AngErr;
     // Add this to the Delta RMS factor and construct a cut
     float deltaCut = 3 * (projErr + tp.DeltaRMS);
 
     // The delta cut shouldn't be less than the delta of hits added on the previous step
     float minDeltaCut = 1.1 * tj.Pts[lastPtWithUsedHits].Delta;
     if(deltaCut < minDeltaCut) deltaCut = minDeltaCut;
 
     deltaCut *= tcc.projectionErrFactor;
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<" AddHits: calculated deltaCut "<<deltaCut<<" dw "<<dw<<" dpos "<<dpos;
 
     if(deltaCut < 0.5) deltaCut = 0.5;
     if(deltaCut > 3) deltaCut = 3;
 
     // TY: open it up for RevProp, since we might be following a stopping track
     if(tj.AlgMod[kRvPrp]) deltaCut *= 2;
 
     // loosen up a bit if we just passed a block of dead wires
     bool passedDeadWires = (abs(dw) > 20 && DeadWireCount(slc, tp.Pos[0], tj.Pts[lastPtWithUsedHits].Pos[0], tj.CTP) > 10);
     if(passedDeadWires) deltaCut *= 2;
     // open it up for StiffEl and Slowing strategies
     if(tj.Strategy[kStiffEl] || tj.Strategy[kSlowing]) deltaCut = 3;
 
     // Create a larger cut to use in case there is nothing close
     float bigDelta = 2 * deltaCut;
     unsigned int imBig = UINT_MAX;
     tp.Delta = deltaCut;
     // ignore all hits with delta larger than maxDeltaCut
     float maxDeltaCut = 2 * bigDelta;
     // apply some limits
     if(!passedDeadWires && maxDeltaCut > 3) {
       maxDeltaCut = 3;
       bigDelta = 1.5;
     }
 
     // projected time in ticks for testing the existence of a hit signal
     raw::TDCtick_t rawProjTick = (float)(tp.Pos[1] / tcc.unitsPerTick);
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<" AddHits: wire "<<wire<<" tp.Pos[0] "<<tp.Pos[0]<<" projTick "<<rawProjTick<<" deltaRMS "<<tp.DeltaRMS<<" tp.Dir[0] "<<tp.Dir[0]<<" deltaCut "<<deltaCut<<" dpos "<<dpos<<" projErr "<<projErr<<" ExpectedHitsRMS "<<ExpectedHitsRMS(slc, tp);
     }
 
     std::vector<unsigned int> hitsInMultiplet;
 
     geo::PlaneID planeID = DecodeCTP(tj.CTP);
     unsigned int ipl = planeID.Plane;
     if(wire > slc.lastWire[ipl]) return;
     // Assume a signal exists on a dead wire
     if(!evt.goodWire[ipl][wire]) sigOK = true;
     if(slc.wireHitRange[ipl][wire].first == UINT_MAX) return;
     unsigned int firstHit = slc.wireHitRange[ipl][wire].first;
     unsigned int lastHit = slc.wireHitRange[ipl][wire].second;
     float fwire = wire;
     for(unsigned int iht = firstHit; iht <= lastHit; ++iht) {
       if(slc.slHits[iht].InTraj == tj.ID) continue;
       if(slc.slHits[iht].InTraj == SHRT_MAX) continue;
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       if(rawProjTick > hit.StartTick() && rawProjTick < hit.EndTick()) sigOK = true;
       float ftime = tcc.unitsPerTick * hit.PeakTime();
       float delta = PointTrajDOCA(slc, fwire, ftime, tp);
       // increase the delta cut if this is a long pulse hit
       bool longPulseHit = LongPulseHit(hit);
       if(longPulseHit) {
         if(delta > 3) continue;
       } else {
         if(delta > maxDeltaCut) continue;
       }
       float dt = std::abs(ftime - tp.Pos[1]);
       GetHitMultiplet(slc, iht, hitsInMultiplet, false);
       if(tcc.dbgStp && delta < 100 && dt < 100) {
         mf::LogVerbatim myprt("TC");
         myprt<<"  iht "<<iht;
         myprt<<" "<<PrintHit(slc.slHits[iht]);
         myprt<<" delta "<<std::fixed<<std::setprecision(2)<<delta<<" deltaCut "<<deltaCut<<" dt "<<dt;
         myprt<<" BB Mult "<<hitsInMultiplet.size()<<" RMS "<<std::setprecision(1)<<hit.RMS();
         myprt<<" Chi "<<std::setprecision(1)<<hit.GoodnessOfFit();
         myprt<<" InTraj "<<slc.slHits[iht].InTraj;
         myprt<<" Chg "<<(int)hit.Integral();
         myprt<<" Signal? "<<sigOK;
       }
       if(slc.slHits[iht].InTraj == 0 && delta < bigDelta && hitsInMultiplet.size() < 3 && !tj.AlgMod[kRvPrp]) {
         // An available hit that is just outside the window that is not part of a large multiplet
         bigDelta = delta;
         imBig = iht;
       }
       if(longPulseHit) {
         if(delta > 3) continue;
       } else {
         if(delta > deltaCut) continue;
       }
 
       if(std::find(closeHits.begin(), closeHits.end(), iht) != closeHits.end()) continue;
       closeHits.push_back(iht);
       if(hitsInMultiplet.size() > 1) {
         // include all the hits in a multiplet
         for(auto& jht : hitsInMultiplet) {
           if(slc.slHits[jht].InTraj == tj.ID) continue;
           if(std::find(closeHits.begin(), closeHits.end(), jht) != closeHits.end()) continue;
           closeHits.push_back(jht);
         } // jht
       } // multiplicity > 1
     } // iht
 
     if(tcc.dbgStp) {
       mf::LogVerbatim myprt("TC");
       myprt<<"closeHits ";
       for(auto iht : closeHits) myprt<<" "<<PrintHit(slc.slHits[iht]);
       if(imBig < slc.slHits.size()) {
         myprt<<" imBig "<<PrintHit(slc.slHits[imBig]);
       } else {
         myprt<<" imBig "<<imBig;
       }
     }
     // check the srcHit collection if it is defined. Add the TP to the trajectory if
     // there is NO hit in the allHits collection but there is a hit in srcHit collection. We
     // can't use it for fitting, etc however
     bool nearSrcHit = false;
     if(!sigOK) nearSrcHit = NearbySrcHit(planeID, wire, (float)rawProjTick, (float)rawProjTick);
     sigOK = sigOK || !closeHits.empty() || nearSrcHit;
 
     if(!sigOK) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" no signal on any wire at tp.Pos "<<tp.Pos[0]<<" "<<tp.Pos[1]<<" tick "<<(int)tp.Pos[1]/tcc.unitsPerTick<<" closeHits size "<<closeHits.size();
       return;
     }
     if(imBig < slc.slHits.size() && closeHits.empty()) {
       closeHits.push_back(imBig);
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Added bigDelta hit "<<PrintHit(slc.slHits[imBig])<<" w delta = "<<bigDelta;
     }
     if(closeHits.size() > 16) closeHits.resize(16);
     if(nearSrcHit) tp.Environment[kEnvNearSrcHit] = true;
     tp.Hits.insert(tp.Hits.end(), closeHits.begin(), closeHits.end());
 
     // reset UseHit and assume that none of these hits will be used (yet)
     tp.UseHit.reset();
    // decide which of these hits should be used in the fit. Use a generous maximum delta
     // and require a charge check if we're not just starting out
     bool useChg = true;
     if(tj.Strategy[kStiffEl] || tj.Strategy[kSlowing]) useChg = false;
     FindUseHits(slc, tj, ipt, 10, useChg);
     DefineHitPos(slc, tp);
     SetEndPoints(tj);
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<" number of close hits "<<closeHits.size()<<" used hits "<<NumHitsInTP(tp, kUsedHits);
   } // AddHits

void tca::AddLAHits	(	TCSlice &	slc,
		Trajectory &	tj,
		unsigned short	ipt,
		bool &	sigOK
	)

Definition at line 1214 of file StepUtils.cxx.

   {
     // Very Large Angle version of AddHits to be called for the last angle range
 
     if(ipt > tj.Pts.size() - 1) return;
     TrajPoint& tp = tj.Pts[ipt];
     tp.Hits.clear();
     tp.UseHit.reset();
     sigOK = false;
 
     unsigned short plane = DecodeCTP(tj.CTP).Plane;
 
     // look at adjacent wires for larger angle trajectories
     // We will check the most likely wire first
     std::vector<int> wires(1);
     wires[0] = std::nearbyint(tp.Pos[0]);
     if(wires[0] < 0 || wires[0] > (int)slc.lastWire[plane]-1) return;
 
     if(tp.AngleCode != 2) {
       mf::LogVerbatim("TC")<<"AddLAHits called with a bad angle code. "<<tp.AngleCode<<" Don't do this";
       return;
     }
     // and the adjacent wires next in the most likely order only
     // after the first two points have been defined
     if(ipt > 1) {
       if(tp.Dir[0] > 0) {
         if(wires[0] < (int)slc.lastWire[plane]-1) wires.push_back(wires[0] + 1);
         if(wires[0] > 0) wires.push_back(wires[0] - 1);
       } else {
         if(wires[0] > 0) wires.push_back(wires[0] - 1);
         if(wires[0] < (int)slc.lastWire[plane]-1) wires.push_back(wires[0] + 1);
       }
     } // ipt > 0 ...
 
     if(tcc.dbgStp) {
       mf::LogVerbatim myprt("TC");
       myprt<<" AddLAHits: Pos "<<PrintPos(slc, tp)<<" tp.AngleCode "<<tp.AngleCode<<" Wires under consideration";
       for(auto& wire : wires) myprt<<" "<<wire;
     }
 
     // a temporary tp that we can move around
     TrajPoint ltp = tp;
     // do this while testing
     sigOK = false;
 
     tp.Hits.clear();
     std::array<int, 2> wireWindow;
     std::array<float, 2> timeWindow;
     float pos1Window = tcc.VLAStepSize/2;
     timeWindow[0] = ltp.Pos[1] - pos1Window;
     timeWindow[1] = ltp.Pos[1] + pos1Window;
     // Put the existing hits in to a vector so we can ensure that they aren't added again
     std::vector<unsigned int> oldHits = PutTrajHitsInVector(tj, kAllHits);
 
     for(unsigned short ii = 0; ii < wires.size(); ++ii) {
       int wire = wires[ii];
       if(wire < 0 || wire > (int)slc.lastWire[plane]) continue;
       // Assume a signal exists on a dead wire
       if(slc.wireHitRange[plane][wire].first == UINT_MAX) sigOK = true;
       if(slc.wireHitRange[plane][wire].first == UINT_MAX) continue;
       wireWindow[0] = wire;
       wireWindow[1] = wire;
       bool hitsNear;
       // Look for hits using the requirement that the timeWindow overlaps with the hit StartTick and EndTick
       std::vector<unsigned int> closeHits = FindCloseHits(slc, wireWindow, timeWindow, plane, kAllHits, true, hitsNear);
       if(hitsNear) sigOK = true;
       for(auto& iht : closeHits) {
         // Ensure that none of these hits are already used by this trajectory
         if(slc.slHits[iht].InTraj == tj.ID) continue;
         // or in another trajectory in any previously added point
         if(std::find(oldHits.begin(), oldHits.end(), iht) != oldHits.end()) continue;
         tp.Hits.push_back(iht);
       }
     } // ii
 
     if(tcc.dbgStp) {
       mf::LogVerbatim myprt("TC");
       myprt<<" LAPos "<<PrintPos(slc, ltp)<<" Tick window "<<(int)(timeWindow[0]/tcc.unitsPerTick)<<" to "<<(int)(timeWindow[1]/tcc.unitsPerTick);
       for(auto& iht : tp.Hits) myprt<<" "<<PrintHit(slc.slHits[iht]);
     } // prt
 
     // no hits found
     if(tp.Hits.empty()) return;
 
     if(tp.Hits.size() > 16) tp.Hits.resize(16);
 
     tp.UseHit.reset();
     for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
       unsigned int iht = tp.Hits[ii];
       if(slc.slHits[iht].InTraj != 0) continue;
       tp.UseHit[ii] = true;
       slc.slHits[iht].InTraj = tj.ID;
     } // ii
     DefineHitPos(slc, tp);
     SetEndPoints(tj);
     UpdateTjChgProperties("ALAH", slc, tj, tcc.dbgStp);
 
   } // AddLAHits

bool tca::AddLooseHits	(	std::string	inFcnLabel,
		TCSlice &	slc,
		int	cotID,
		bool	prt
	)

bool tca::AddLooseHits	(	TCSlice &	slc,
		int	cotID,
		bool	prt
	)

Definition at line 3625 of file TCShower.cxx.

   {
     // 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 = slc.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 = slc.tjs[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 /= tcc.unitsPerTick;
     hiTick /= tcc.unitsPerTick;
     unsigned int loWire = std::nearbyint(fLoWire);
     unsigned int hiWire = std::nearbyint(fHiWire) + 1;
     if (hiWire > slc.lastWire[ipl] - 1) hiWire = slc.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 (slc.wireHitRange[ipl][wire].first == UINT_MAX) continue;
       unsigned int firstHit = slc.wireHitRange[ipl][wire].first;
       unsigned int lastHit = slc.wireHitRange[ipl][wire].second;
       for (unsigned int iht = firstHit; iht < lastHit; ++iht) {
         // used in a trajectory?
         if (slc.slHits[iht].InTraj != 0) continue;
         auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
         // inside the tick range?
         if (hit.PeakTime() < loTick) continue;
         // Note that hits are sorted by increasing time so we can break here
         if (hit.PeakTime() > hiTick) break;
         // see if this hit is inside the envelope
         point[0] = hit.WireID().Wire;
         point[1] = hit.PeakTime() * tcc.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)
       slc.slHits[iht].InTraj = stj.ID;
 
     if (prt)
       mf::LogVerbatim("TC") << "ALH: Added " << stp0.Hits.size() << " hits to stj " << stj.ID;
     return true;
 
   } // AddLooseHits

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

Definition at line 1384 of file TCShower.cxx.

   {
     // 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)slc.pfps.size()) return false;
     auto& pfp = slc.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 = slc.tjs[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 = slc.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;
         myprt << " tj.SSID 2S" << tj.SSID;
       } // prt
       // add it to the shower in the correct CTP
       for (auto& cid : ss3.CotIDs) {
         auto& ss = slc.cots[cid - 1];
         if (ss.CTP != tj.CTP) continue;
         // Add it to the shower.
         AddTj(fcnLabel, slc, tid, ss, doUpdate, prt);
         ss3.NeedsUpdate = true;
         break;
       } // cid
     }   // tid
 
     if (doUpdate && ss3.NeedsUpdate) UpdateShower(fcnLabel, slc, ss3, prt);
     return true;
 
   } // AddPFP

void tca::AddPointsInRange	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc,
		PFPStruct &	pfp,
		unsigned short	fromPt,
		unsigned short	toPt,
		CTP_t	inCTP,
		float	maxPull,
		unsigned short &	nWires,
		unsigned short &	nAdd,
		bool	prt
	)

Definition at line 1837 of file PFPUtils.cxx.

   {
     // Try to insert 2D trajectory points into the 3D trajectory point vector pfp.TP3Ds.
     // This function inserts new TP3Ds and sets the NeedsUpdate flags true.
     // The calling function should call Update
     // Note that maxPull is used for the charge pull as well as the position pull
     nWires = 0;
     nAdd = 0;
     if (fromPt > toPt) return;
     if (toPt >= pfp.TP3Ds.size()) toPt = pfp.TP3Ds.size() - 1;
 
     // Find the average dE/dx so we can apply a generous min/max dE/dx cut
     float dEdXAve = 0;
     float dEdXRms = 0;
     Average_dEdX(clockData, detProp, slc, pfp, dEdXAve, dEdXRms);
     float dEdxMin = 0.5, dEdxMax = 50.;
     if (dEdXAve > 0.5) {
       dEdxMin = dEdXAve - maxPull * dEdXRms;
       if (dEdxMin < 0.5) dEdxMin = 0.5;
       dEdxMax = dEdXAve + maxPull * dEdXRms;
       if (dEdxMax > 50.) dEdxMax = 50.;
     } // dEdXAve > 0.5
 
     // Split the range into sub-ranges; one for each SectionFit and make 2D TPs at the
     // start of each sub-range.
     std::vector<TrajPoint> sfTPs;
     // form a list of TPs that are used in this CTP
     std::vector<std::pair<int, unsigned short>> tpUsed;
     for (auto& tp3d : pfp.TP3Ds) {
       if (tp3d.CTP != inCTP) continue;
       tpUsed.push_back(std::make_pair(tp3d.TjID, tp3d.TPIndex));
     } // tp3d
     unsigned int toWire = 0;
     unsigned int fromWire = UINT_MAX;
 
     unsigned short inSF = USHRT_MAX;
     unsigned short pln = DecodeCTP(inCTP).Plane;
     for (unsigned short ipt = 0; ipt < pfp.TP3Ds.size(); ++ipt) {
       auto& tp3d = pfp.TP3Ds[ipt];
       // Skip if not the last point and we already found a point in this SectionFit
       if (ipt < pfp.TP3Ds.size() - 1 && tp3d.SFIndex == inSF) continue;
       unsigned int wire;
       if (tp3d.CTP == inCTP) {
         // Found the first tp3d in a new SectionFit and it is in the right CTP
         auto& tp = slc.tjs[tp3d.TjID - 1].Pts[tp3d.TPIndex];
         sfTPs.push_back(tp);
         wire = std::nearbyint(tp.Pos[0]);
         if (wire >= slc.nWires[pln]) break;
       }
       else {
         // Found the first tp3d in a new SectionFit and it is in a different CTP.
         // Make a TP in the right CTP
         auto tp = MakeBareTP(detProp, slc, tp3d.Pos, tp3d.Dir, inCTP);
         wire = std::nearbyint(tp.Pos[0]);
         if (wire >= slc.nWires[pln]) break;
         sfTPs.push_back(tp);
       }
       if (wire < fromWire) fromWire = wire;
       if (wire > toWire) toWire = wire;
       inSF = tp3d.SFIndex;
     } // tp3d
     if (sfTPs.empty()) return;
     // reverse the vector if necessary so the wires will be in increasing order
     if (sfTPs.size() > 1 && sfTPs[0].Pos[0] > sfTPs.back().Pos[0]) {
       std::reverse(sfTPs.begin(), sfTPs.end());
     }
 
     // set a generous search window in WSE units
     float window = 50;
 
     if (prt)
       mf::LogVerbatim("TC") << "APIR: inCTP " << inCTP << " fromWire " << fromWire << " toWire "
                             << toWire;
 
     // iterate over the sub-ranges
     for (unsigned short subr = 0; subr < sfTPs.size(); ++subr) {
       auto& fromTP = sfTPs[subr];
       unsigned int toWireInSF = toWire;
       if (subr < sfTPs.size() - 1) toWireInSF = std::nearbyint(sfTPs[subr + 1].Pos[0]);
       SetAngleCode(fromTP);
       unsigned int fromWire = std::nearbyint(fromTP.Pos[0]);
       if (fromWire > toWire) continue;
       if (prt)
         mf::LogVerbatim("TC") << " inCTP " << inCTP << " subr " << subr << " fromWire " << fromWire
                               << " toWireInSF " << toWireInSF;
       for (unsigned int wire = fromWire; wire <= toWireInSF; ++wire) {
         MoveTPToWire(fromTP, (float)wire);
         if (!FindCloseHits(slc, fromTP, window, kUsedHits)) continue;
         if (fromTP.Environment[kEnvNotGoodWire]) continue;
         float bestPull = maxPull;
         TP3D bestTP3D;
         for (auto iht : fromTP.Hits) {
           if (slc.slHits[iht].InTraj <= 0) continue;
           // this hit is used in a TP so find the tpIndex
           auto& utj = slc.tjs[slc.slHits[iht].InTraj - 1];
           unsigned short tpIndex = 0;
           for (tpIndex = utj.EndPt[0]; tpIndex <= utj.EndPt[1]; ++tpIndex) {
             auto& utp = utj.Pts[tpIndex];
             if (utp.Chg <= 0) continue;
             // This doesn't check for UseHit true but that is probably ok here
             if (std::find(utp.Hits.begin(), utp.Hits.end(), iht) != utp.Hits.end()) break;
           } // ipt
           if (tpIndex > utj.EndPt[1]) continue;
           // see if it is already used in this pfp
           std::pair<int, unsigned short> tppr = std::make_pair(utj.ID, tpIndex);
           if (std::find(tpUsed.begin(), tpUsed.end(), tppr) != tpUsed.end()) continue;
           tpUsed.push_back(tppr);
           auto& utp = utj.Pts[tpIndex];
           // see if it is used in a different PFP
           if (utp.InPFP > 0) continue;
           // or if it overlaps another trajectory near a 2D vertex
           if (utp.Environment[kEnvOverlap]) continue;
           auto newTP3D = CreateTP3D(detProp, slc, utj.ID, tpIndex);
           if (!SetSection(detProp, slc, pfp, newTP3D)) continue;
           // set the direction to the direction of the SectionFit it is in so we can calculate dE/dx
           newTP3D.Dir = pfp.SectionFits[newTP3D.SFIndex].Dir;
           float pull = PointPull(pfp, newTP3D);
           float dedx = dEdx(clockData, detProp, slc, newTP3D);
           // Require a good pull and a consistent dE/dx (MeV/cm)
           bool useIt = (pull < bestPull && dedx > dEdxMin && dedx < dEdxMax);
           if (!useIt) continue;
           bestTP3D = newTP3D;
           bestPull = pull;
         } // iht
         if (bestPull < maxPull) {
           if (prt && bestPull < 10) {
             mf::LogVerbatim myprt("TC");
             auto& tp = slc.tjs[bestTP3D.TjID - 1].Pts[bestTP3D.TPIndex];
             myprt << "APIR: P" << pfp.ID << " added TP " << PrintPos(slc, tp);
             myprt << " pull " << std::fixed << std::setprecision(2) << bestPull;
             myprt << " dx " << bestTP3D.TPX - bestTP3D.Pos[0] << " in section " << bestTP3D.SFIndex;
           }
           if (InsertTP3D(pfp, bestTP3D) == USHRT_MAX) continue;
           ++nAdd;
         } // bestPull < maxPull
       }   // wire
     }     // subr
   }       // AddPointsInRange

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

Definition at line 1446 of file TCShower.cxx.

   {
     // Adds the Tj to the shower and optionally updates the shower variables
 
     if (tjID <= 0 || tjID > (int)slc.tjs.size()) return false;
 
     std::string fcnLabel = inFcnLabel + ".AddT";
 
     Trajectory& tj = slc.tjs[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;
           auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
           ss.ShPts[cnt].Chg = hit.Integral();
           ss.ShPts[cnt].Pos[0] = hit.WireID().Wire;
           ss.ShPts[cnt].Pos[1] = hit.PeakTime() * tcc.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, slc, ss, prt);
     return true;
 
   } // AddTj

bool tca::AddTjsInsideEnvelope	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3549 of file TCShower.cxx.

   {
     // 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 : slc.tjs) {
       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(slc, 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(slc, 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, slc, 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, slc, 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, slc, 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::AnalyzeHits ( )

Definition at line 4392 of file Utils.cxx.

   {
     // Find the average hit rms by analyzing the full hit collection. This
     // only needs to be done once per job.
 
     if ((*evt.allHits).empty()) return true;
     // no sense re-calculating it if it's been done
     if (evt.aveHitRMSValid) return true;
 
     unsigned short cstat = (*evt.allHits)[0].WireID().Cryostat;
     unsigned short tpc = (*evt.allHits)[0].WireID().TPC;
 
     unsigned short nplanes = tcc.geom->Nplanes(tpc, cstat);
     evt.aveHitRMS.resize(nplanes);
     std::vector<float> cnt(nplanes, 0);
     for (unsigned short iht = 0; iht < (*evt.allHits).size(); ++iht) {
       auto& hit = (*evt.allHits)[iht];
       unsigned short plane = hit.WireID().Plane;
       if (plane > nplanes - 1) return false;
       if (cnt[plane] > 200) continue;
       // require multiplicity one
       if (hit.Multiplicity() != 1) continue;
       // not-crazy Chisq/DOF
       if (hit.GoodnessOfFit() < 0 || hit.GoodnessOfFit() > 500) continue;
       // don't let a lot of runt hits screw up the calculation
       if (hit.PeakAmplitude() < 1) continue;
       evt.aveHitRMS[plane] += hit.RMS();
       ++cnt[plane];
       // quit if enough hits are found
       bool allDone = true;
       for (unsigned short plane = 0; plane < nplanes; ++plane)
         if (cnt[plane] < 200) allDone = false;
       if (allDone) break;
     } // iht
 
     // assume there are enough hits in each plane
     evt.aveHitRMSValid = true;
     for (unsigned short plane = 0; plane < nplanes; ++plane) {
       if (cnt[plane] > 4) { evt.aveHitRMS[plane] /= cnt[plane]; }
       else {
         evt.aveHitRMS[plane] = 10;
         evt.aveHitRMSValid = false;
       } // cnt too low
     }   // plane
 
     if (tcc.modes[kDebug]) {
       std::cout << "Analyze hits aveHitRMS";
       std::cout << std::fixed << std::setprecision(1);
       for (auto rms : evt.aveHitRMS)
         std::cout << " " << rms;
       std::cout << " aveHitRMSValid? " << evt.aveHitRMSValid << "\n";
     }
 
     return true;
   } // Analyze hits

bool tca::AnalyzeRotPos	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3060 of file TCShower.cxx.

   {
     // 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 = slc.tjs[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;
       // 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 ( TrajPoint const & tp )

Definition at line 764 of file Utils.cxx.

   {
     return AngleRange(tp.Ang);
   }

unsigned short tca::AngleRange ( float angle )

Definition at line 791 of file Utils.cxx.

   {
     // 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 < tcc.angleRanges.size(); ++ir) {
       if (angle < tcc.angleRanges[ir]) return ir;
     }
     return tcc.angleRanges.size() - 1;
   } // AngleRange

bool tca::AttachAnyTrajToVertex	(	TCSlice &	slc,
		unsigned short	ivx,
		bool	prt
	)

Definition at line 1697 of file TCVertex.cxx.

   {
 
     if (ivx > slc.vtxs.size() - 1) return false;
     if (slc.vtxs[ivx].ID == 0) return false;
     if (tcc.vtx2DCuts[0] < 0) return false;
 
     VtxStore& vx = slc.vtxs[ivx];
     // Hammer vertices should be isolated and clean
     if (vx.Topo == 5 || vx.Topo == 6) return false;
 
     unsigned short bestTj = USHRT_MAX;
     // Construct a FOM = (TP-Vtx pull) * (TP-Vtx sep + 1).
     // The +1 keeps FOM from being 0
     float bestFOM = 2 * tcc.vtx2DCuts[3] * (tcc.vtx2DCuts[0] + 1);
     for (unsigned int itj = 0; itj < slc.tjs.size(); ++itj) {
       auto& tj = slc.tjs[itj];
       if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) continue;
       if (tj.CTP != vx.CTP) continue;
       // make some rough cuts
       std::array<float, 2> sep;
       sep[0] = PosSep(vx.Pos, tj.Pts[tj.EndPt[0]].Pos);
       sep[1] = PosSep(vx.Pos, tj.Pts[tj.EndPt[1]].Pos);
       unsigned short end = 0;
       if (sep[1] < sep[0]) end = 1;
       if (sep[end] > 100) continue;
       if (tj.VtxID[end] > 0) continue;
       auto& tp = tj.Pts[tj.EndPt[end]];
       // Pad the separation a bit so we don't get zero
       float fom = TrajPointVertexPull(slc, tp, vx) * (sep[end] + 1);
       if (fom > bestFOM) continue;
       if (prt) {
         mf::LogVerbatim("TC") << "AATTV: T" << tj.ID << " 2V" << vx.ID << " Topo " << vx.Topo
                               << " FOM " << fom << " cut " << bestFOM;
       }
       bestTj = itj;
       bestFOM = fom;
     } // tj
     if (bestTj > slc.tjs.size() - 1) return false;
     auto& tj = slc.tjs[bestTj];
     return AttachTrajToVertex(slc, tj, vx, prt);
   } // AttachAnyTrajToVertex

bool tca::AttachAnyVertexToTraj	(	TCSlice &	slc,
		int	tjID,
		bool	prt
	)

Definition at line 1655 of file TCVertex.cxx.

   {
     // Try to attach a tj that is stored in slc.tjs with any vertex
     if (tjID <= 0 || tjID > (int)slc.tjs.size()) return false;
     if (slc.vtxs.empty()) return false;
     auto& tj = slc.tjs[tjID - 1];
     if (tj.AlgMod[kKilled]) return false;
     if (tcc.vtx2DCuts[0] <= 0) return false;
 
     unsigned short bestVx = USHRT_MAX;
     // Construct a FOM = (TP-Vtx pull) * (TP-Vtx sep + 1) * (Vtx Score).
     // The +1 keeps FOM from being 0
     float bestFOM = 2 * tcc.vtx2DCuts[3] * (tcc.vtx2DCuts[0] + 1) * tcc.vtx2DCuts[7];
     for (unsigned short ivx = 0; ivx < slc.vtxs.size(); ++ivx) {
       auto& vx = slc.vtxs[ivx];
       if (vx.ID == 0) continue;
       if (vx.CTP != tj.CTP) continue;
       // make some rough cuts
       std::array<float, 2> sep;
       sep[0] = PosSep(vx.Pos, tj.Pts[tj.EndPt[0]].Pos);
       sep[1] = PosSep(vx.Pos, tj.Pts[tj.EndPt[1]].Pos);
       unsigned short end = 0;
       if (sep[1] < sep[0]) end = 1;
       if (sep[end] > 100) continue;
       if (tj.VtxID[end] > 0) continue;
       auto& tp = tj.Pts[tj.EndPt[end]];
       // Pad the separation a bit so we don't get zero
       float fom = TrajPointVertexPull(slc, tp, vx) * (sep[end] + 1) * vx.Score;
       if (fom > bestFOM) continue;
       if (prt)
         mf::LogVerbatim("TC") << "AAVTT: T" << tjID << " 2V" << vx.ID << " FOM " << fom << " cut "
                               << bestFOM;
       bestVx = ivx;
       bestFOM = fom;
     } // vx
     if (bestVx > slc.vtxs.size() - 1) return false;
     auto& vx = slc.vtxs[bestVx];
     return AttachTrajToVertex(slc, tj, vx, prt);
   } // AttachAnyVertexToTraj

bool tca::AttachToAnyVertex	(	TCSlice &	slc,
		PFPStruct &	pfp,
		float	maxSep,
		bool	prt
	)

Definition at line 1597 of file TCVertex.cxx.

   {
     // Attaches to any 3D vertex but doesn't require consistency with
     // PFP -> Tj -> 2V -> 3V assns
     if (pfp.ID <= 0) return false;
 
     float pLen = Length(pfp);
     if (pLen == 0) return false;
 
     // save the old assignents and clear them
     //    auto oldVx3ID = pfp.Vx3ID;
     for (unsigned short end = 0; end < 2; ++end)
       pfp.Vx3ID[end] = 0;
     std::array<Point3_t, 2> endPos;
     endPos[0] = PosAtEnd(pfp, 0);
     endPos[1] = PosAtEnd(pfp, 1);
 
     std::array<float, 2> foms{{100., 100.}};
     std::array<int, 2> vtxs{{0}};
     for (auto& vx3 : slc.vtx3s) {
       if (vx3.ID <= 0) continue;
       if (vx3.TPCID != pfp.TPCID) continue;
       std::array<float, 2> sep;
       Point3_t vpos = {{vx3.X, vx3.Y, vx3.Z}};
       sep[0] = PosSep(vpos, endPos[0]);
       sep[1] = PosSep(vpos, endPos[1]);
       unsigned short end = 0;
       if (sep[1] < sep[0]) end = 1;
       // ignore if separation is too large
       if (sep[end] > 100) continue;
       // find the direction vector between these points
       auto vpDir = PointDirection(vpos, endPos[end]);
       auto dir = DirAtEnd(pfp, end);
       double dotp = std::abs(DotProd(vpDir, dir));
       float fom = dotp * sep[end];
       if (prt)
         mf::LogVerbatim("TC") << "ATAV: P" << pfp.ID << " end " << end << " 3V" << vx3.ID << " sep "
                               << sep[end] << " fom " << fom << " maxSep " << maxSep;
       // ignore if separation is too large
       if (sep[end] > maxSep) continue;
       if (fom < foms[end]) {
         foms[end] = fom;
         vtxs[end] = vx3.ID;
       }
     } // vx3
     bool bingo = false;
     for (unsigned short end = 0; end < 2; ++end) {
       if (vtxs[end] == 0) continue;
       if (prt)
         mf::LogVerbatim("TC") << "ATAV: set P" << pfp.ID << " end " << end << " -> 3V" << vtxs[end];
       pfp.Vx3ID[end] = vtxs[end];
       bingo = true;
     } // end
     return bingo;
   } // AttachToAnyVertex

bool tca::AttachTrajToVertex	(	TCSlice &	slc,
		Trajectory &	tj,
		VtxStore &	vx,
		bool	prt
	)

Definition at line 1742 of file TCVertex.cxx.

   {
     // Note that this function does not require a signal between the end of the Tj and the vertex
 
     // tcc.vtx2DCuts 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] || tj.AlgMod[kHaloTj]) 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 = tcc.vtx2DCuts[0];
     // square the separation cut to simplify testing in the loop
     float maxSepCutShort2 = tcc.vtx2DCuts[1] * tcc.vtx2DCuts[1];
     float maxSepCutLong2 = tcc.vtx2DCuts[2] * tcc.vtx2DCuts[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);
     // use the short Tj cut if the trajectory looks like an electron
     if (!tjShort && tj.ChgRMS > 0.5) tjShort = true;
     float closestApproach;
     // ignore bad separation between the closest tj end and the vertex
     if (tjShort) {
       if (vtxTjSep2 > maxSepCutShort2) return false;
       closestApproach = tcc.vtx2DCuts[1];
     }
     else {
       closestApproach = tcc.vtx2DCuts[2];
       if (vtxTjSep2 > maxSepCutLong2) return false;
     }
 
     // Calculate the pull on the vertex
     TrajPoint& tp = tj.Pts[tj.EndPt[end]];
     float tpVxPull = TrajPointVertexPull(slc, tp, vx);
     bool signalBetween = SignalBetween(slc, tp, vx.Pos[0], 0.8);
 
     // 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 > 4 && length < closestApproach) return false;
 
     float pullCut = tcc.vtx2DCuts[3];
     // Dec 21, 2017 Loosen up the pull cut for short close slc. These are likely to
     // be poorly reconstructed. It is better to have them associated with the vertex
     // than not.
     if (tjShort) pullCut *= 2;
 
     if (prt) {
       mf::LogVerbatim myprt("TC");
       myprt << "ATTV: 2V" << vx.ID;
       myprt << " NTraj " << vx.NTraj;
       myprt << " oldTJs";
       for (unsigned short itj = 0; itj < slc.tjs.size(); ++itj) {
         Trajectory& tj = slc.tjs[itj];
         if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) continue;
         if (tj.CTP != vx.CTP) continue;
         if (tj.VtxID[0] == vx.ID) myprt << " T" << tj.ID << "_0";
         if (tj.VtxID[1] == vx.ID) myprt << " T" << tj.ID << "_1";
       }
       myprt << " +  T" << tj.ID << "_" << end << " vtxTjSep " << sqrt(vtxTjSep2) << " tpVxPull "
             << tpVxPull << " pullCut " << pullCut << " dpt " << dpt;
     }
     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;
 
     // 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(slc, vxTmp, prt)) {
       SetVx2Score(slc, vxTmp);
       if (prt) mf::LogVerbatim("TC") << " Success";
       vx = vxTmp;
       return true;
     }
     // Keep the Tj -> Vx assn since we got this far, but don't include this end of the Tj in the fit
     tj.EndFlag[end][kNoFitVx] = true;
     if (prt)
       mf::LogVerbatim("TC") << " Poor fit. Keep T" << tj.ID << "-2V" << vx.ID
                             << " assn with kNoFitVx";
     // restore the fixed flag
     vx.Stat[kFixed] = fixedBit;
     return true;
   } // AttachTrajToVertex

void tca::Average_dEdX	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		PFPStruct &	pfp,
		float &	dEdXAve,
		float &	dEdXRms
	)

Definition at line 2649 of file PFPUtils.cxx.

   {
     // Return a simple average of dE/dx and rms using ALL points in all planes, not
     // just those at the ends ala FilldEdx
     dEdXAve = -1.;
     dEdXRms = -1.;
 
     double sum = 0;
     double sum2 = 0;
     double cnt = 0;
     for (auto& tp3d : pfp.TP3Ds) {
       if (!tp3d.Flags[kTP3DGood] || tp3d.Flags[kTP3DBad]) continue;
       double dedx = dEdx(clockData, detProp, slc, tp3d);
       if (dedx < 0.5 || dedx > 80.) continue;
       sum += dedx;
       sum2 += dedx * dedx;
       ++cnt;
     } // tp3d
     if (cnt < 3) return;
     dEdXAve = sum / cnt;
     // Use a default rms of 30% of the average
     dEdXRms = 0.3 * dEdXAve;
     double arg = sum2 - cnt * dEdXAve * dEdXAve;
     if (arg < 0) return;
     dEdXRms = sqrt(arg) / (cnt - 1);
     // don't return a too-small rms
     double minRms = 0.05 * dEdXAve;
     if (dEdXRms < minRms) dEdXRms = minRms;
   } // Average_dEdX

bool tca::BraggSplit	(	TCSlice &	slc,
		unsigned short	itj
	)

Definition at line 1442 of file Utils.cxx.

   {
     // Searches the stored trajectory for a Bragg Peak and kink and splits it
     if (!tcc.useAlg[kBraggSplit]) return false;
     if (itj > slc.tjs.size() - 1) return false;
     if (tcc.chkStopCuts.size() < 4) return false;
     if (tcc.chkStopCuts[3] <= 0) return false;
     unsigned short nPtsToCheck = tcc.chkStopCuts[1];
     auto& tj = slc.tjs[itj];
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
     if (npwc < 4) return false;
     if (npwc < nPtsToCheck) nPtsToCheck = npwc;
     // do a rough ChgPull check first
     float maxPull = 2;
     unsigned short maxPullPt = USHRT_MAX;
     for (unsigned short ipt = tj.EndPt[0]; ipt < tj.EndPt[1]; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if (tp.ChgPull < maxPull) continue;
       maxPull = tp.ChgPull;
       maxPullPt = ipt;
     } // ipt
     if (maxPullPt == USHRT_MAX) return false;
     short dpt;
     if (maxPullPt < 0.5 * (tj.EndPt[0] + tj.EndPt[1])) { dpt = maxPullPt - tj.EndPt[0]; }
     else {
       dpt = tj.EndPt[1] - maxPullPt;
     }
     if (dpt < 3) return false;
     bool prt = (tcc.dbgSlc && (tcc.dbgStp || tcc.dbgAlg[kBraggSplit]));
     if (prt)
       mf::LogVerbatim("TC") << "BS: T" << tj.ID << " maxPull " << maxPull << " at "
                             << PrintPos(slc, tj.Pts[maxPullPt]) << " dpt " << dpt;
     unsigned short breakPt = USHRT_MAX;
     float bestFOM = tcc.chkStopCuts[3];
     unsigned short bestBragg = 0;
     unsigned short nPtsFit = tcc.kinkCuts[0];
     TrajPoint tp1, tp2;
     ParFit chgFit1, chgFit2;
     for (unsigned short ipt = maxPullPt - 2; ipt <= maxPullPt + 2; ++ipt) {
       FitTraj(slc, tj, ipt - 1, nPtsFit, -1, tp1);
       if (tp1.FitChi > 10) continue;
       FitTraj(slc, tj, ipt + 1, nPtsFit, 1, tp2);
       if (tp2.FitChi > 10) continue;
       float dang = std::abs(tp1.Ang - tp2.Ang);
       FitPar(slc, tj, ipt - 1, nPtsToCheck, -1, chgFit1, 1);
       if (chgFit1.ChiDOF > 100) continue;
       chgFit1.ParSlp = -chgFit1.ParSlp;
       FitPar(slc, tj, ipt + 1, nPtsToCheck, 1, chgFit2, 1);
       if (chgFit2.ChiDOF > 100) continue;
       chgFit2.ParSlp = -chgFit2.ParSlp;
       // require a large positive slope on at least one side
       if (chgFit1.ParSlp < tcc.chkStopCuts[0] && chgFit2.ParSlp < tcc.chkStopCuts[0]) continue;
       // assume it is on side 1
       unsigned short bragg = 1;
       float bchi = chgFit1.ChiDOF;
       if (chgFit2.ParSlp > chgFit1.ParSlp) {
         bragg = 2;
         bchi = chgFit2.ChiDOF;
       }
       float chgAsym = std::abs(chgFit1.Par0 - chgFit2.Par0) / (chgFit1.Par0 + chgFit2.Par0);
       float slpAsym = std::abs(chgFit1.ParSlp - chgFit2.ParSlp) / (chgFit1.ParSlp + chgFit2.ParSlp);
       if (bchi < 1) bchi = 1;
       float fom = 10 * dang * chgAsym * slpAsym / bchi;
       if (prt) {
         mf::LogVerbatim myprt("TC");
         myprt << "pt " << PrintPos(slc, tj.Pts[ipt]) << " " << std::setprecision(2) << dang;
         myprt << " chg1 " << (int)chgFit1.Par0 << " slp " << chgFit1.ParSlp << " chi "
               << chgFit1.ChiDOF;
         myprt << " chg2 " << (int)chgFit2.Par0 << " slp " << chgFit2.ParSlp << " chi "
               << chgFit2.ChiDOF;
         myprt << " chgAsym " << chgAsym;
         myprt << " slpAsym " << slpAsym;
         myprt << " fom " << fom;
         myprt << " bragg " << bragg;
       }
       if (fom < bestFOM) continue;
       bestFOM = fom;
       breakPt = ipt;
       bestBragg = bragg;
     } // ipt
     if (breakPt == USHRT_MAX) return false;
     if (prt)
       mf::LogVerbatim("TC") << " breakPt " << PrintPos(slc, tj.Pts[breakPt]) << " bragg "
                             << bestBragg;
     // Create a vertex at the break point
     VtxStore aVtx;
     aVtx.Pos = tj.Pts[breakPt].Pos;
     aVtx.NTraj = 2;
     aVtx.Pass = tj.Pass;
     aVtx.Topo = 12;
     aVtx.ChiDOF = 0;
     aVtx.CTP = tj.CTP;
     aVtx.ID = slc.vtxs.size() + 1;
     aVtx.Stat[kFixed] = true;
     unsigned short ivx = slc.vtxs.size();
     if (!StoreVertex(slc, aVtx)) return false;
     if (!SplitTraj(slc, itj, breakPt, ivx, prt)) {
       if (prt) mf::LogVerbatim("TC") << "BS: Failed to split trajectory";
       MakeVertexObsolete("BS", slc, slc.vtxs[ivx], false);
       return false;
     }
     SetVx2Score(slc);
     slc.tjs[itj].AlgMod[kBraggSplit] = true;
     unsigned short otj = slc.tjs.size() - 1;
     if (bestBragg == 2) std::swap(itj, otj);
     slc.tjs[itj].PDGCode = 211;
     slc.tjs[itj].EndFlag[1][kBragg] = true;
     slc.tjs[otj].PDGCode = 13;
     return true;
   } // BraggSplit

bool tca::CanSection	(	const TCSlice &	slc,
		const PFPStruct &	pfp
	)

Definition at line 1342 of file PFPUtils.cxx.

   {
     // analyze the TP3D vector to determine if it can be reconstructed in 3D in more than one section with
     // the requirement that there are at least 3 points in two planes
     if (pfp.AlgMod[kJunk3D]) return false;
     if (pfp.AlgMod[kSmallAngle]) return false;
     if (pfp.TP3Ds.size() < 12) return false;
     unsigned short toPt = Find3DRecoRange(slc, pfp, 0, 3, 1);
     if (toPt > pfp.TP3Ds.size()) return false;
     unsigned short nextToPt = Find3DRecoRange(slc, pfp, toPt, 3, 1);
     if (nextToPt > pfp.TP3Ds.size()) return false;
     return true;
   } // CanSection

void tca::CheckHiMultEndHits	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 2307 of file StepUtils.cxx.

   {
     // mask off high multiplicity TPs at the end
     if(!tcc.useAlg[kCHMEH]) return;
     if(tj.EndFlag[1][kBragg]) return;
     if(tj.Pts.size() < 10) return;
     if(tj.Pts[tj.EndPt[1]].AngleCode == 0) return;
     // find the average multiplicity in the first half
     unsigned short aveMult= 0;
     unsigned short ipt, nhalf = tj.Pts.size() / 2;
     unsigned short cnt = 0;
     for(auto& tp : tj.Pts) {
       if(tp.Chg == 0) continue;
       aveMult += tp.Hits.size();
       ++cnt;
       if(cnt == nhalf) break;
     } //  pt
     if(cnt == 0) return;
     aveMult /= cnt;
     if(aveMult == 0) aveMult = 1;
     // convert this into a cut
     aveMult *= 3;
     cnt = 0;
     for(ipt = tj.EndPt[1]; ipt > tj.EndPt[0]; --ipt) {
       if(tj.Pts[ipt].Chg == 0) continue;
       if(tj.Pts[ipt].Hits.size() > aveMult) {
         UnsetUsedHits(slc, tj.Pts[ipt]);
         ++cnt;
         continue;
       }
       break;
     } // ipt
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"CHMEH multiplicity cut "<<aveMult<<" number of TPs masked off "<<cnt;
     if(cnt > 0) {
       tj.AlgMod[kCHMEH] = true;
       SetEndPoints(tj);
     }
   } // CheckHiMultEndHits

void tca::CheckHiMultUnusedHits	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 2165 of file StepUtils.cxx.

   {
     // Check for many unused hits in high multiplicity TPs in work and try to use them
 
     if(!tcc.useAlg[kCHMUH]) return;
 
     // This code might do bad things to short trajectories
     if(NumPtsWithCharge(slc, tj, true) < 6) return;
     if(tj.EndPt[0] == tj.EndPt[1]) return;
     // Angle code 0 tjs shouldn't have any high multiplicity hits added to them
     if(tj.Pts[tj.EndPt[1]].AngleCode == 0) return;
 
     // count the number of unused hits multiplicity > 1 hits and decide
     // if the unused hits should be used. This may trigger another
     // call to StepAway
     unsigned short ii, stopPt;
     // Use this to see if the high multiplicity Pts are mostly near
     // the end or further upstream
     unsigned short lastMult1Pt = USHRT_MAX;
     // the number of TPs with > 1 hit (HiMult)
     unsigned short nHiMultPt = 0;
     // the total number of hits associated with HiMult TPs
     unsigned short nHiMultPtHits = 0;
     // the total number of used hits associated with HiMult TPs
     unsigned short nHiMultPtUsedHits = 0;
     unsigned int iht;
     // start counting at the leading edge and break if a hit
     // is found that is used in a trajectory
     bool doBreak = false;
     unsigned short jj;
     for(ii = 1; ii < tj.Pts.size(); ++ii) {
       stopPt = tj.EndPt[1] - ii;
       for(jj = 0; jj < tj.Pts[stopPt].Hits.size(); ++jj) {
         iht = tj.Pts[stopPt].Hits[jj];
         if(slc.slHits[iht].InTraj > 0) {
           doBreak = true;
           break;
         }
       } // jj
       if(doBreak) break;
       // require 2 consecutive multiplicity = 1 points
       if(lastMult1Pt == USHRT_MAX && tj.Pts[stopPt].Hits.size() == 1 && tj.Pts[stopPt-1].Hits.size() == 1) lastMult1Pt = stopPt;
       if(tj.Pts[stopPt].Hits.size() > 1) {
         ++nHiMultPt;
         nHiMultPtHits += tj.Pts[stopPt].Hits.size();
         nHiMultPtUsedHits += NumHitsInTP(tj.Pts[stopPt], kUsedHits);
       } // high multiplicity TP
       // stop looking when two consecutive single multiplicity TPs are found
       if(lastMult1Pt != USHRT_MAX) break;
       if(stopPt == 1) break;
     } // ii
     // Don't do this if there aren't a lot of high multiplicity TPs
     float fracHiMult = (float)nHiMultPt / (float)ii;
     if(lastMult1Pt != USHRT_MAX) {
       float nchk = tj.EndPt[1] - lastMult1Pt + 1;
       fracHiMult = (float)nHiMultPt / nchk;
     } else {
       fracHiMult = (float)nHiMultPt / (float)ii;
     }
     float fracHitsUsed = 0;
     if(nHiMultPt > 0 && nHiMultPtHits > 0) fracHitsUsed = (float)nHiMultPtUsedHits / (float)nHiMultPtHits;
     // Use this to limit the number of points fit for trajectories that
     // are close the LA tracking cut
     ii = tj.EndPt[1];
     bool sortaLargeAngle = (AngleRange(tj.Pts[ii]) == 1);
 
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"CHMUH: First InTraj stopPt "<<stopPt<<" fracHiMult "<<fracHiMult<<" fracHitsUsed "<<fracHitsUsed<<" lastMult1Pt "<<lastMult1Pt<<" sortaLargeAngle "<<sortaLargeAngle;
     if(fracHiMult < 0.3) return;
     if(fracHitsUsed > 0.98) return;
 
     float maxDelta = 2.5 * MaxHitDelta(slc, tj);
 
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<" Pts size "<<tj.Pts.size()<<" nHiMultPt "<<nHiMultPt<<" nHiMultPtHits "<<nHiMultPtHits<<" nHiMultPtUsedHits "<<nHiMultPtUsedHits<<" sortaLargeAngle "<<sortaLargeAngle<<" maxHitDelta "<<maxDelta;
     }
 
     // Use next pass cuts if available
     if(sortaLargeAngle && tj.Pass < tcc.minPtsFit.size()-1) ++tj.Pass;
 
     // Make a copy of tj in case something bad happens
     Trajectory TjCopy = tj;
     // and the list of used hits
     auto inTrajHits = PutTrajHitsInVector(tj, kUsedHits);
     unsigned short ipt;
 
     // unset the used hits from stopPt + 1 to the end
     for(ipt = stopPt + 1; ipt < tj.Pts.size(); ++ipt) UnsetUsedHits(slc, tj.Pts[ipt]);
     SetEndPoints(tj);
     float delta;
     bool added;
     for(ipt = stopPt + 1; ipt < tj.Pts.size(); ++ipt) {
       // add hits that are within maxDelta and re-fit at each point
       added = false;
       for(ii = 0; ii < tj.Pts[ipt].Hits.size(); ++ii) {
         iht = tj.Pts[ipt].Hits[ii];
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<" ipt "<<ipt<<" hit "<<PrintHit(slc.slHits[iht])<<" inTraj "<<slc.slHits[iht].InTraj<<" delta "<<PointTrajDOCA(slc, iht, tj.Pts[ipt]);
         if(slc.slHits[iht].InTraj != 0) continue;
         delta = PointTrajDOCA(slc, iht, tj.Pts[ipt]);
         if(delta > maxDelta) continue;
         if (!NumHitsInTP(TjCopy.Pts[ipt], kUsedHits)||TjCopy.Pts[ipt].UseHit[ii]){
           tj.Pts[ipt].UseHit[ii] = true;
           slc.slHits[iht].InTraj = tj.ID;
           added = true;
         }
       } // ii
       if(added) DefineHitPos(slc, tj.Pts[ipt]);
       if(tj.Pts[ipt].Chg == 0) continue;
       tj.EndPt[1] = ipt;
       // This will be incremented by one in UpdateTraj
       if(sortaLargeAngle) tj.Pts[ipt].NTPsFit = 2;
       UpdateTraj(slc, tj);
       if(tj.NeedsUpdate) {
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"UpdateTraj failed on point "<<ipt;
         // Clobber the used hits from the corrupted points in tj
         for(unsigned short jpt = stopPt + 1; jpt <= ipt; ++jpt) {
           for(unsigned short jj = 0; jj < tj.Pts[jpt].Hits.size(); ++jj) {
             if(tj.Pts[jpt].UseHit[jj]) slc.slHits[tj.Pts[jpt].Hits[jj]].InTraj = 0;
           } // jj
         } // jpt
         // restore the original trajectory
         tj = TjCopy;
         // restore the hits
         for(unsigned short jpt = stopPt + 1; jpt <= ipt; ++jpt) {
           for(unsigned short jj = 0; jj < tj.Pts[jpt].Hits.size(); ++jj) {
             if(tj.Pts[jpt].UseHit[jj]) slc.slHits[tj.Pts[jpt].Hits[jj]].InTraj = tj.ID;
           } // jj
         } // jpt
         return;
       }
       GottaKink(slc, tj, true);
       if(tcc.dbgStp) PrintTrajectory("CHMUH", slc, tj, ipt);
     } // ipt
     // if we made it here it must be OK
     SetEndPoints(tj);
     // Try to extend it, unless there was a kink
     if(tj.EndFlag[1][kAtKink]) return;
     // trim the end points although this shouldn't happen
     if(tj.EndPt[1] != tj.Pts.size() - 1) tj.Pts.resize(tj.EndPt[1] + 1);
     tj.AlgMod[kCHMUH] = true;
   } // CheckHiMultUnusedHits

void tca::CheckStiffEl	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 914 of file StepUtils.cxx.

   {
     if(!tj.Strategy[kStiffEl]) return;
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"inside CheckStiffTj with NumPtsWithCharge = "<<NumPtsWithCharge(slc, tj, false);
     }
     // Fill in any gaps with hits that were skipped, most likely delta rays on muon tracks
     FillGaps(slc, tj);
     // Update the trajectory parameters at the beginning of the trajectory
     ChkBegin(slc, tj);
   } // CheckStiffTj

void tca::CheckTraj	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 927 of file StepUtils.cxx.

   {
     // Check the quality of the trajectory and possibly trim it or flag it for deletion
 
     if(!tj.IsGood) return;
 
     // ensure that the end points are defined
     SetEndPoints(tj);
     if(tj.EndPt[0] == tj.EndPt[1]) return;
 
     if(tj.Strategy[kStiffEl]) {
       CheckStiffEl(slc, tj);
       return;
     }
 
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"inside CheckTraj with NumPtsWithCharge = "<<NumPtsWithCharge(slc, tj, false);
     }
 
     if(NumPtsWithCharge(slc, tj, false) < tcc.minPts[tj.Pass]) {
       tj.IsGood = false;
       return;
     }
 
     // reduce nPtsFit to the minimum and check for a large angle kink near the ends
 //    ChkEndKink(slc, tj, tcc.dbgStp);
 
     // Look for a charge asymmetry between points on both sides of a high-
     // charge point and trim points in the vicinity
     ChkChgAsymmetry(slc, tj, tcc.dbgStp);
 
     // flag this tj as a junk Tj (even though it wasn't created in FindJunkTraj).
     // Drop it and let FindJunkTraj do it's job
     TagJunkTj(slc, tj, tcc.dbgStp);
     if(tj.AlgMod[kJunkTj]) {
       tj.IsGood = false;
       return;
     }
 
     tj.MCSMom = MCSMom(slc, tj);
 
     // See if the points at the stopping end can be included in the Tj
     ChkStopEndPts(slc, tj, tcc.dbgStp);
 
     // remove any points at the end that don't have charge
     tj.Pts.resize(tj.EndPt[1] + 1);
 
     // Ensure that a hit only appears once in the TJ
     if(HasDuplicateHits(slc, tj, tcc.dbgStp)) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" HasDuplicateHits ";
       tj.IsGood = false;
       return;
     }
 
     // See if this is a ghost trajectory
     if(IsGhost(slc, tj)) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" CT: Ghost trajectory - trimmed hits ";
       if(!tj.IsGood) return;
     }
 
     if(tj.AlgMod[kJunkTj]) return;
 
     // checks are different for Very Large Angle trajectories
     bool isVLA = (tj.Pts[tj.EndPt[1]].AngleCode == 2);
 
     tj.Pts.resize(tj.EndPt[1] + 1);
 
     // Fill in any gaps with hits that were skipped, most likely delta rays on muon tracks
     if(!isVLA) FillGaps(slc, tj);
 
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<" CheckTraj MCSMom "<<tj.MCSMom<<" isVLA? "<<isVLA<<" NumPtsWithCharge "<<NumPtsWithCharge(slc, tj, false)<<" Min Req'd "<<tcc.minPts[tj.Pass];
 
     // Trim the end points until the TJ meets the quality cuts
     TrimEndPts("CT", slc, tj, tcc.qualityCuts, tcc.dbgStp);
     if(tj.AlgMod[kKilled]) {
       tj.IsGood = false;
       return;
     }
 
     TrimHiChgEndPts(slc, tj, tcc.dbgStp);
 
     // Check for a Bragg peak at both ends. This may be used by FixBegin.
     ChkStop(slc, tj);
 
     // Update the trajectory parameters at the beginning of the trajectory
     ChkBegin(slc, tj);
 
     // ignore short trajectories
     if(tj.EndPt[1] < 4) return;
 
     // final quality check
     float npwc = NumPtsWithCharge(slc, tj, true);
     float npts = tj.EndPt[1] - tj.EndPt[0] + 1;
     float frac = npwc / npts;
     tj.IsGood = (frac >= tcc.qualityCuts[0]);
     if(tj.IsGood && tj.Pass < tcc.minMCSMom.size() && !tj.Strategy[kSlowing]) tj.IsGood = (tj.MCSMom >= tcc.minMCSMom[tj.Pass]);
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"CheckTraj: fraction of points with charge "<<frac<<" good traj? "<<tj.IsGood;
     }
     if(!tj.IsGood || !slc.isValid) return;
 
     // lop off high multiplicity hits at the end
     CheckHiMultEndHits(slc, tj);
 
     // Check for a Bragg peak at both ends. This may be used by FixBegin.
     ChkStop(slc, tj);
 
   } // CheckTraj

void tca::CheckTrajBeginChg	(	TCSlice &	slc,
		unsigned short	itj
	)

Definition at line 1335 of file Utils.cxx.

   {
     // 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 > slc.tjs.size() - 1) return;
     auto& tj = slc.tjs[itj];
 
     if (!tcc.useAlg[kBeginChg]) return;
     if (tj.EndFlag[0][kBragg]) return;
     if (tj.AlgMod[kFTBRvProp]) return;
     if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) return;
     if (tj.Pts.size() < 20) return;
 
     bool prt = (tcc.dbgSlc && (tcc.dbgStp || tcc.dbgAlg[kBeginChg]));
 
     // 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;
     // check the charge and rms before and after the split
     std::array<double, 2> cnt, sum, sum2;
     for (unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if (tp.Chg <= 0) continue;
       unsigned short end = 0;
       if (ipt > breakPt) end = 1;
       ++cnt[end];
       sum[end] += tp.Chg;
       sum2[end] += tp.Chg * tp.Chg;
     } // ipt
     for (unsigned short end = 0; end < 2; ++end) {
       if (cnt[end] < 3) return;
       double ave = sum[end] / cnt[end];
       double arg = sum2[end] - cnt[end] * ave * ave;
       if (arg <= 0) return;
       sum2[end] = sqrt(arg / (cnt[end] - 1));
       sum2[end] /= ave;
       sum[end] = ave;
     } // region
     bool doSplit = true;
     // don't split if this looks like an electron - no significant improvement
     // in the charge rms before and after
     if (tj.ChgRMS > 0.5 && sum2[0] > 0.3 && sum2[1] > 0.3) doSplit = false;
     if (prt) {
       mf::LogVerbatim myprt("TC");
       myprt << "CTBC: T" << tj.ID << " chgRMS " << tj.ChgRMS;
       myprt << " AveChg before split point " << (int)sum[0] << " rms " << sum2[0];
       myprt << " after " << (int)sum[1] << " rms " << sum2[1] << " doSplit? " << doSplit;
     } // prt
     if (!doSplit) 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 = slc.vtxs.size() + 1;
     aVtx.Stat[kFixed] = true;
     unsigned short ivx = slc.vtxs.size();
     if (!StoreVertex(slc, aVtx)) return;
     if (!SplitTraj(slc, itj, breakPt, ivx, prt)) {
       if (prt) mf::LogVerbatim("TC") << "CTBC: Failed to split trajectory";
       MakeVertexObsolete("CTBC", slc, slc.vtxs[ivx], false);
       return;
     }
     SetVx2Score(slc);
     slc.tjs[itj].AlgMod[kBeginChg] = true;
 
     if (prt)
       mf::LogVerbatim("TC") << "CTBC: Split T" << tj.ID << " at "
                             << PrintPos(slc, tj.Pts[breakPt].Pos) << "\n";
 
   } // CheckTrajBeginChg

float tca::ChgFracBetween	(	const TCSlice &	slc,
		TrajPoint	tp,
		float	toPos0
	)

Definition at line 1839 of file Utils.cxx.

   {
     // 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) return SignalAtTp(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(tp)) ++nsig;
       tp.Pos[0] += tp.Dir[0] * stepSize;
       tp.Pos[1] += tp.Dir[1] * stepSize;
     } // cnt
     float sigFrac = nsig / num;
     return sigFrac;
   } // ChgFracBetween

float tca::ChgFracBetween	(	detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		Point3_t	pos1,
		Point3_t	pos2
	)

Definition at line 3196 of file PFPUtils.cxx.

   {
     // 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
     float sep = PosSep(pos1, pos2);
     if (sep == 0) return -1;
     unsigned short nstep = sep / tcc.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] += tcc.wirePitch * dir[xyz];
       for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
         tp.CTP = EncodeCTP(slc.TPCID.Cryostat, slc.TPCID.TPC, plane);
         tp.Pos[0] =
           tcc.geom->WireCoordinate(pos1[1], pos1[2], plane, slc.TPCID.TPC, slc.TPCID.Cryostat);
         tp.Pos[1] = detProp.ConvertXToTicks(pos1[0], plane, slc.TPCID.TPC, slc.TPCID.Cryostat) *
                     tcc.unitsPerTick;
         ++cnt;
         if (SignalAtTp(tp)) ++sum;
       } // plane
     }   // step
     if (cnt == 0) return -1;
     return sum / cnt;
   } // ChgFracBetween

float tca::ChgFracNearEnd	(	detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		const PFPStruct &	pfp,
		unsigned short	end
	)

Definition at line 3231 of file PFPUtils.cxx.

   {
     // 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 != slc.TPCID) return 0;
     if (pfp.SectionFits.empty()) return 0;
 
     float sum = 0;
     float cnt = 0;
     // keep track of the lowest value and maybe reject it
     float lo = 1;
     float hi = 0;
     auto pos3 = PosAtEnd(pfp, end);
     for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
       CTP_t inCTP = EncodeCTP(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
       std::vector<int> tjids(1);
       for (auto tjid : pfp.TjIDs) {
         auto& tj = slc.tjs[tjid - 1];
         if (tj.CTP != inCTP) continue;
         tjids[0] = tjid;
         Point2_t pos2;
         geo::PlaneID planeID = geo::PlaneID(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
         pos2[0] = tcc.geom->WireCoordinate(pos3[1], pos3[2], planeID);
         if (pos2[0] < -0.4) continue;
         // check for dead wires
         unsigned int wire = std::nearbyint(pos2[0]);
         if (wire > slc.nWires[plane]) continue;
         if (slc.wireHitRange[plane][wire].first == UINT_MAX) continue;
         pos2[1] = detProp.ConvertXToTicks(pos3[0], planeID) * tcc.unitsPerTick;
         float cf = ChgFracNearPos(slc, pos2, 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	(	const TCSlice &	slc,
		const Point2_t &	pos,
		const std::vector< int > &	tjIDs
	)

Definition at line 3234 of file Utils.cxx.

   {
     // 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)slc.tjs.size()) return 0;
     // Determine which plane we are in
     geo::PlaneID planeID = DecodeCTP(slc.tjs[tjIDs[0] - 1].CTP);
     // get a list of all hits in this region
     bool hitsNear;
     std::vector<unsigned int> closeHits =
       FindCloseHits(slc, 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) {
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       chg += hit.Integral();
       if (slc.slHits[iht].InTraj == 0) continue;
       if (std::find(tjIDs.begin(), tjIDs.end(), slc.slHits[iht].InTraj) != tjIDs.end())
         tchg += hit.Integral();
     } // iht
     if (chg == 0) return 0;
     return tchg / chg;
   } // ChgFracNearPos

float tca::ChgToMeV ( float chg )

Definition at line 3980 of file TCShower.cxx.

   {
     // 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,
		TCSlice &	slc
	)

Definition at line 4155 of file TCShower.cxx.

   {
     // check tj - ss assns
 
     std::string fcnLabel = inFcnLabel + ".ChkAssns";
     for (auto& ss : slc.cots) {
       if (ss.ID == 0) continue;
       for (auto tid : ss.TjIDs) {
         auto& tj = slc.tjs[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)slc.showers.size()) {
         auto& ss3 = slc.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 : slc.tjs) {
       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 = slc.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 : slc.showers) {
       if (ss3.ID == 0) continue;
       for (auto cid : ss3.CotIDs) {
         auto& ss = slc.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::ChkBegin	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 2672 of file StepUtils.cxx.

   {
     // Check the parameters at the start of the trajectory. The first
     // points may not belong to this trajectory since they were added when there was
     // little information. This information may be updated later if ReversePropagate is used
 
     if(!tcc.useAlg[kFixBegin]) return;
     if(tj.AlgMod[kJunkTj]) return;
 
     // don't do anything if this tj has been modified by ReversePropagate
     if(tj.AlgMod[kRvPrp]) return;
 
     // don't bother with really short tjs
     if(tj.Pts.size() < 3) return;
 
     unsigned short atPt = tj.EndPt[1];
     unsigned short maxPtsFit = 0;
     unsigned short firstGoodChgPullPt = USHRT_MAX;
     for(unsigned short ipt = tj.EndPt[0]; ipt < tj.EndPt[1]; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if(tp.Chg == 0) continue;
       if(tp.AveChg > 0 && firstGoodChgPullPt == USHRT_MAX) {
         if(std::abs(tp.ChgPull) < tcc.chargeCuts[0]) firstGoodChgPullPt = ipt;
       } // find the first good charge pull point
       if(tp.NTPsFit > maxPtsFit) {
         maxPtsFit = tp.NTPsFit;
         atPt = ipt;
         // no reason to continue if there are a good number of points fitted
         if(maxPtsFit > 20) break;
       }
     } // ipt
     // find the first point that is in this fit
     unsigned short firstPtFit = tj.EndPt[0];
     unsigned short cnt = 0;
     for(unsigned short ii = 1; ii < tj.Pts.size(); ++ii) {
       if(ii > atPt) break;
       unsigned short ipt = atPt - ii;
       if(tj.Pts[ipt].Chg == 0) continue;
       ++cnt;
       if(cnt == maxPtsFit) {
         firstPtFit = ipt;
         break;
       } // full count
     } // ii
 
     bool needsRevProp = firstPtFit > 3;
     unsigned short nPtsLeft = NumPtsWithCharge(slc, tj, false) - firstPtFit;
     if(needsRevProp) {
       needsRevProp = (nPtsLeft > 5);
     }
     if(tcc.dbgStp) {
       mf::LogVerbatim myprt("TC");
       myprt<<"CB: firstPtFit "<<firstPtFit<<" at "<<PrintPos(slc, tj.Pts[firstPtFit].Pos);
       myprt<<" atPt "<<PrintPos(slc, tj.Pts[atPt].Pos);
       myprt<<" nPts with charge "<<nPtsLeft;
       myprt<<" firstGoodChgPullPt "<<firstGoodChgPullPt;
       if(firstGoodChgPullPt != USHRT_MAX) myprt<<" at "<<PrintPos(slc,tj.Pts[firstGoodChgPullPt]);
       myprt<<" needsRevProp? "<<needsRevProp;
     }
 
     if(!needsRevProp && firstGoodChgPullPt == USHRT_MAX) {
       // check one wire on the other side of EndPt[0] to see if there are hits that are available which could
       // be picked up by reverse propagation
       TrajPoint tp = tj.Pts[0];
       tp.Hits.clear();
       tp.UseHit.reset();
       // Move the TP "backwards"
       double stepSize = tcc.VLAStepSize;
       if(tp.AngleCode < 2) stepSize = std::abs(1/tp.Dir[0]);
       tp.Pos[0] -= tp.Dir[0] * stepSize * tj.StepDir;
       tp.Pos[1] -= tp.Dir[1] * stepSize * tj.StepDir;
       // launch RevProp if this wire is dead
       unsigned int wire = std::nearbyint(tp.Pos[0]);
       unsigned short plane = DecodeCTP(tp.CTP).Plane;
       needsRevProp = (wire < slc.nWires[plane] && !evt.goodWire[plane][wire]);
       if(tcc.dbgStp && needsRevProp) mf::LogVerbatim("TC")<<"CB: Previous wire "<<wire<<" is dead. Call ReversePropagate";
       if(!needsRevProp && firstGoodChgPullPt != USHRT_MAX) {
         // check for hits on a not-dead wire
         // BB May 20, 2019 Do this more carefully
         float maxDelta = 2 * tp.DeltaRMS;
         if(FindCloseHits(slc, tp, maxDelta, kAllHits) && !tp.Hits.empty()) {
           // count used and unused hits
           unsigned short nused = 0;
           for(auto iht : tp.Hits) if(slc.slHits[iht].InTraj > 0) ++nused;
           if(nused == 0) {
             needsRevProp = true;
             if(tcc.dbgStp) {
               mf::LogVerbatim("TC")<<"CB: Found "<<tp.Hits.size()-nused<<" close unused hits found near EndPt[0] "<<PrintPos(slc, tp)<<". Call ReversePropagate";
             } // tcc.dbgStp
           } // nused = 0
         } // Close hits exist
       } // !needsRevProp
     } // !needsRevProp
 
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"CB: maxPtsFit "<<maxPtsFit<<" at point "<<atPt<<" firstPtFit "<<firstPtFit<<" Needs ReversePropagate? "<<needsRevProp;
     }
 
     if(tcc.useAlg[kFTBRvProp] && needsRevProp) {
       // lop off the points before firstPtFit and reverse propagate
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"  clobber TPs "<<PrintPos(slc, tj.Pts[0])<<" to "<<PrintPos(slc, tj.Pts[firstPtFit])<<". Call TrimEndPts then ReversePropagate ";
       // first save the first TP on this trajectory. We will try to re-use it if
       // it isn't used during reverse propagation
       seeds.push_back(tj.Pts[0]);
       for(unsigned short ipt = 0; ipt <= firstPtFit; ++ipt) UnsetUsedHits(slc, tj.Pts[ipt]);
       SetEndPoints(tj);
       tj.AlgMod[kFTBRvProp] = true;
       // Check for quality and trim if necessary before reverse propagation
       TrimEndPts("RPi", slc, tj, tcc.qualityCuts, tcc.dbgStp);
       if(tj.AlgMod[kKilled]) {
         tj.IsGood = false;
         return;
       }
       ReversePropagate(slc, tj);
       ChkStopEndPts(slc, tj, tcc.dbgStp);
     }
     if(firstGoodChgPullPt != USHRT_MAX && firstGoodChgPullPt > atPt) atPt = firstGoodChgPullPt;
     // Update the fit parameters of the first points if no reverse propagation was done
     if(!tj.AlgMod[kRvPrp]) FixBegin(slc, tj, atPt);
 
   } // ChkBegin

void tca::ChkChgAsymmetry	(	TCSlice &	slc,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 1739 of file Utils.cxx.

   {
     // 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 (!tcc.useAlg[kChkChgAsym]) return;
     if (tj.PDGCode == 111) 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(slc, tj.Pts[ipt]);
     SetEndPoints(tj);
     tj.AlgMod[kChkChgAsym] = true;
     if (prt) PrintTrajectory("CCA", slc, tj, USHRT_MAX);
   } // ChkChgAsymmetry

void tca::ChkEndKink	(	TCSlice &	slc,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 1705 of file Utils.cxx.

   {
     // look for large-angle kink near the end
     if (!tcc.useAlg[kEndKink]) return;
     if (tj.PDGCode == 111) return;
     if (tj.EndPt[1] - tj.EndPt[0] < 6) return;
 
     if (prt) mf::LogVerbatim("TC") << "CEK: Inside ChkEndKinks T" << tj.ID << " ";
 
     float maxSig = tcc.kinkCuts[1];
     unsigned short withNptsFit = 0;
     unsigned short nPtsFit = tcc.kinkCuts[0];
     bool useChg = (tcc.kinkCuts[2] > 0);
     for (unsigned short nptsf = 3; nptsf < nPtsFit; ++nptsf) {
       unsigned short ipt = tj.EndPt[1] - nptsf;
       float ks = KinkSignificance(slc, tj, ipt, nptsf, useChg, prt);
       if (ks > maxSig) {
         maxSig = ks;
         withNptsFit = nptsf;
       }
     } // nptsf
     if (withNptsFit > 0) {
       unsigned short ipt = tj.EndPt[1] - withNptsFit;
       std::cout << "CEK: T" << tj.ID << " ipt " << ipt;
       float ks = KinkSignificance(slc, tj, ipt, withNptsFit, false, prt);
       auto& tp = tj.Pts[ipt];
       std::cout << " " << PrintPos(slc, tp) << " withNptsFit " << withNptsFit << " ks " << ks
                 << "\n";
     }
 
   } // ChkEndKink

bool tca::ChkMichel	(	TCSlice &	slc,
		Trajectory &	tj,
		unsigned short &	lastGoodPt
	)

Definition at line 3809 of file StepUtils.cxx.

                                                                           {
 
     if(!tcc.useAlg[kMichel]) return false;
     if(tj.PDGCode == 11 || tj.PDGCode == 111) return false;
 
     bool prt = (tcc.dbgStp || tcc.dbgAlg[kMichel]);
 
     //find number of hits that are consistent with Michel electron
     unsigned short nmichelhits = 0;
     //find number of hits that are consistent with Bragg peak
     unsigned short nbragghits = 0;
     float lastChg = 0;
 
     bool isfirsthit = true;
     unsigned short braggpeak = 0;
 
     for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
       if (ii>tj.EndPt[1]) continue;
       unsigned short ipt = tj.EndPt[1] - ii;
       if (tj.Pts[ipt].Chg>0){
         if (isfirsthit){
           isfirsthit = false;
           if (tj.Pts[ipt].ChgPull<0){
             ++nmichelhits;
           }
         }
         else{
           if (tj.Pts[ipt].ChgPull<0&&nmichelhits&&!nbragghits){//still Michel
             ++nmichelhits;
           }
           else{
             if (!nbragghits){
               ++nbragghits; //Last Bragg peak hit
               lastChg  = tj.Pts[ipt].Chg;
               braggpeak = ipt;
             }
             else if (tj.Pts[ipt].Chg<lastChg){ //still Bragg peak
               ++nbragghits;
               lastChg  = tj.Pts[ipt].Chg;
             }
             else break;
           }
         }
       }
     }
     if(prt) mf::LogVerbatim("TC")<<"ChkMichel Michel hits: "<<nmichelhits<<" Bragg peak hits: "<<nbragghits;
     if (nmichelhits>0&&nbragghits>2){//find Michel topology
       lastGoodPt = braggpeak;
       tj.AlgMod[kMichel] = true;
       return true;
     }
     else{
       return false;
     }
   }

void tca::ChkMissedKink	(	TCSlice &	slc,
		Trajectory &	tj,
		bool	prt
	)

void tca::ChkStop	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 3703 of file StepUtils.cxx.

   {
     // Sets the EndFlag[kBragg] bits on the trajectory by identifying the Bragg peak
     // at each end. This function checks both ends, finding the point with the highest charge nearest the
     // end and considering the first (when end = 0) 4 points or last 4 points (when end = 1). The next
     // 5 - 10 points (fChkStop[0]) are fitted to a line, Q(x - x0) = Qo + (x - x0) * slope where x0 is the
     // wire position of the highest charge point. A large negative slope indicates that there is a Bragg
     // peak at the end.
 
     tj.EndFlag[0][kBragg] = false;
     tj.EndFlag[1][kBragg] = false;
     if(!tcc.useAlg[kChkStop]) return;
     if(tcc.chkStopCuts[0] < 0) return;
 
     if(tj.Strategy[kStiffEl]) return;
 
     // ignore trajectories that are very large angle at both ends
     if(tj.Pts[tj.EndPt[0]].AngleCode == 2 || tj.Pts[tj.EndPt[1]].AngleCode == 2) return;
 
     unsigned short nPtsToCheck = tcc.chkStopCuts[1];
     if(tj.Pts.size() < 6) return;
 
     bool prt = (tcc.dbgStp || tcc.dbgAlg[kChkStop]);
 
     if(prt) {
       mf::LogVerbatim("TC")<<"ChkStop: T"<<tj.ID<<" requiring "<<nPtsToCheck<<" points with charge slope > "<<tcc.chkStopCuts[0]<<" Chg/WSEU";
     }
 
     // find the highest charge hit in the first 3 points at each end
     for(unsigned short end = 0; end < 2; ++end) {
       tj.EndFlag[end][kBragg] = false;
       // require that the end point is reasonably clean
       auto& endTP = tj.Pts[tj.EndPt[end]];
       if(endTP.Hits.size() > 2) continue;
       if(endTP.Environment[kEnvUnusedHits]) continue;
       short dir = 1 - 2 * end;
       // find the point with the highest charge considering the first 3 points
       float big = 0;
       unsigned short hiPt = 0;
       float wire0 = 0;
       for(unsigned short ii = 0; ii < 5; ++ii) {
         short ipt = tj.EndPt[end] + ii * dir;
         if(ipt < tj.EndPt[0] || ipt > tj.EndPt[1]) break;
         TrajPoint& tp = tj.Pts[ipt];
         if(tp.Chg > big) {
           big = tp.Chg;
           wire0 = tp.Pos[0];
           hiPt = ipt;
         }
       } // ii
       // ensure that the high point is closer to the end that is being
       // considered than to the other end
       short dpt0 = hiPt - tj.EndPt[0];
       short dpt1 = tj.EndPt[1] - hiPt;
       if(end == 0 && dpt1 <= dpt0) continue;
       if(end == 1 && dpt0 <= dpt1) continue;
       if(prt) mf::LogVerbatim("TC")<<" end "<<end<<" wire0 "<<wire0<<" Chg "<<big<<" hiPt "<<hiPt;
       float prevChg = big;
       // prepare to do the fit
       Point2_t inPt;
       Vector2_t outVec, outVecErr;
       float chgErr, chiDOF;
       // Initialize
       Fit2D(0, inPt, chgErr, outVec, outVecErr, chiDOF);
       unsigned short cnt = 0;
       for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
         short ipt = hiPt + ii * dir;
         if(ipt < tj.EndPt[0] || ipt > tj.EndPt[1]) break;
         TrajPoint& tp = tj.Pts[ipt];
         if(tp.Chg == 0) continue;
         // quit if the charge is much larger than the previous charge
         if(tp.Chg > 1.5 * prevChg) continue;
         prevChg = tp.Chg;
         // Accumulate and save points
         inPt[0] = std::abs(tp.Pos[0] - wire0);
         inPt[1] = tp.Chg;
         // Assume 20% point-to-point charge fluctuations
         chgErr = 0.2 * tp.Chg;
         if(!Fit2D(2, inPt, chgErr, outVec, outVecErr, chiDOF)) break;
         ++cnt;
         if(cnt == nPtsToCheck) break;
       } // ii
       if(cnt < nPtsToCheck) continue;
       // do the fit and get the results
       if(!Fit2D(-1, inPt, chgErr, outVec, outVecErr, chiDOF)) continue;
       // check for really bad chidof indicating a major failure
       if(chiDOF > 500) continue;
       // The charge slope is negative for a stopping track in the way that the fit was constructed.
       // Flip the sign so we can make a cut against tcc.chkStopCuts[0] which is positive.
       outVec[1] = -outVec[1];
       bool itStops = (outVec[1] > tcc.chkStopCuts[0] && chiDOF < tcc.chkStopCuts[2] && outVec[1] > 2.5 * outVecErr[1]);
       if(itStops) {
         tj.EndFlag[end][kBragg] = true;
         tj.AlgMod[kChkStop] = true;
         if(tj.PDGCode == 11) tj.PDGCode = 0;
         // Put the charge at the end into tp.AveChg
         tj.Pts[tj.EndPt[end]].AveChg = outVec[0];
         if(prt) mf::LogVerbatim("TC")<<" end "<<end<<" fit chidof "<<chiDOF<<" slope "<<outVec[1]<<" +/- "<<outVecErr[1]<<" stopping";
       } else {
         if(prt) mf::LogVerbatim("TC")<<" end "<<end<<" fit chidof "<<chiDOF<<" slope "<<outVec[1]<<" +/- "<<outVecErr[1]<<" Not stopping";
       }
     } // end
 
   } // ChkStop

void tca::ChkStopEndPts	(	TCSlice &	slc,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 1560 of file StepUtils.cxx.

   {
     // Analyze the end of the Tj after crawling has stopped to see if any of the points
     // should be used
 
     if(tj.EndFlag[1][kAtKink]) return;
     if(!tcc.useAlg[kChkStopEP]) return;
     if(tj.AlgMod[kJunkTj]) return;
     if(tj.Strategy[kStiffEl]) return;
 
     unsigned short endPt = tj.EndPt[1];
     // ignore VLA Tjs
     if(tj.Pts[endPt].AngleCode > 1) return;
     // don't get too carried away with this
     if(tj.Pts.size() - endPt > 10) return;
 
     // Get a list of hits a few wires beyond the last point on the Tj
     geo::PlaneID planeID = DecodeCTP(tj.CTP);
     unsigned short plane = planeID.Plane;
 
     // find the last point that has hits on it
     unsigned short lastPt = tj.Pts.size() - 1;
     for(lastPt = tj.Pts.size() - 1; lastPt >= tj.EndPt[1]; --lastPt) if(!tj.Pts[lastPt].Hits.empty()) break;
     auto& lastTP = tj.Pts[lastPt];
 
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"CSEP: checking "<<tj.ID<<" endPt "<<endPt<<" Pts size "<<tj.Pts.size()<<" lastPt Pos "<<PrintPos(slc, lastTP.Pos);
     }
     TrajPoint ltp;
     ltp.CTP = tj.CTP;
     ltp.Pos = tj.Pts[endPt].Pos;
     ltp.Dir = tj.Pts[endPt].Dir;
     double stepSize = std::abs(1/ltp.Dir[0]);
     std::array<int, 2> wireWindow;
     std::array<float, 2> timeWindow;
     std::vector<int> closeHits;
     bool isClean = true;
     for(unsigned short step = 0; step < 10; ++step) {
       for(unsigned short iwt = 0; iwt < 2; ++iwt) ltp.Pos[iwt] += ltp.Dir[iwt] * stepSize;
       int wire = std::nearbyint(ltp.Pos[0]);
       wireWindow[0] = wire;
       wireWindow[1] = wire;
       timeWindow[0] = ltp.Pos[1] - 5;
       timeWindow[1] = ltp.Pos[1] + 5;
       bool hitsNear;
       auto tmp = FindCloseHits(slc, wireWindow, timeWindow, plane, kAllHits, true, hitsNear);
       // add close hits that are not associated with this tj
       for(auto iht : tmp) if(slc.slHits[iht].InTraj != tj.ID) closeHits.push_back(iht);
       float nWiresPast = 0;
       // Check beyond the end of the trajectory to see if there are hits there
       if(ltp.Dir[0] > 0) {
         // stepping +
         nWiresPast = ltp.Pos[0] - lastTP.Pos[0];
       }  else {
         // stepping -
         nWiresPast = lastTP.Pos[0] - ltp.Pos[0];
       }
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Found "<<tmp.size()<<" hits near pos "<<PrintPos(slc, ltp.Pos)<<" nWiresPast "<<nWiresPast;
       if(nWiresPast > 0.5) {
         if(!tmp.empty()) isClean = false;
         if(nWiresPast > 1.5) break;
       } // nWiresPast > 0.5
     } // step
 
     // count the number of available hits
     unsigned short nAvailable = 0;
     for(auto iht : closeHits) if(slc.slHits[iht].InTraj == 0) ++nAvailable;
 
     if(tcc.dbgStp) {
       mf::LogVerbatim myprt("TC");
       myprt<<"closeHits";
       for(auto iht : closeHits) myprt<<" "<<PrintHit(slc.slHits[iht]);
       myprt<<" nAvailable "<<nAvailable;
       myprt<<" isClean "<<isClean;
     } // prt
 
     if(!isClean || nAvailable != closeHits.size()) return;
 
     unsigned short originalEndPt = tj.EndPt[1] + 1;
     // looks clean so use all the hits
     for(unsigned short ipt = originalEndPt; ipt <= lastPt; ++ipt) {
       auto& tp = tj.Pts[ipt];
       bool hitsAdded = false;
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         // This shouldn't happen but check anyway
         if(slc.slHits[tp.Hits[ii]].InTraj != 0) continue;
         tp.UseHit[ii] = true;
         slc.slHits[tp.Hits[ii]].InTraj = tj.ID;
         hitsAdded = true;
       } // ii
       if(hitsAdded) DefineHitPos(slc, tp);
     } // ipt
     tj.AlgMod[kChkStopEP] = true;
     SetEndPoints(tj);
     // Re-fitting the end might be a good idea but it's probably not necessary. The
     // values of Delta should have already been filled
 
     // require a Bragg peak
     ChkStop(slc, tj);
     if(!tj.EndFlag[1][kBragg]) {
       // restore the original
       for(unsigned short ipt = originalEndPt; ipt <= lastPt; ++ipt) UnsetUsedHits(slc, tj.Pts[ipt]);
       SetEndPoints(tj);
     } // no Bragg Peak
 
     UpdateTjChgProperties("CSEP", slc, tj, prt);
 
   } // ChkStopEndPts

bool tca::ChkVtxAssociations	(	TCSlice &	slc,
		const CTP_t &	inCTP
	)

Definition at line 2085 of file TCVertex.cxx.

   {
     // Check the associations
 
     // check the 2D -> 3D associations
     geo::PlaneID planeID = DecodeCTP(inCTP);
     unsigned short plane = planeID.Plane;
     for (auto& vx2 : slc.vtxs) {
       if (vx2.CTP != inCTP) continue;
       if (vx2.ID == 0) continue;
       if (vx2.Vx3ID == 0) continue;
       if (vx2.Vx3ID > int(slc.vtx3s.size())) {
         mf::LogVerbatim("TC") << "ChkVtxAssociations: Invalid vx2.Vx3ID " << vx2.Vx3ID
                               << " in 2D vtx " << vx2.ID;
         return false;
       }
       auto& vx3 = slc.vtx3s[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 : slc.vtx3s) {
       if (vx3.ID == 0) continue;
       if (vx3.Vx2ID[plane] == 0) continue;
       if (vx3.Vx2ID[plane] > (int)slc.vtxs.size()) {
         mf::LogVerbatim("TC") << "ChkVtxAssociations: Invalid vx3.Vx2ID " << vx3.Vx2ID[plane]
                               << " in CTP " << inCTP;
         return false;
       }
       auto& vx2 = slc.vtxs[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 : slc.tjs) {
       if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) continue;
       for (unsigned short end = 0; end < 2; ++end) {
         if (tj.VtxID[end] == 0) continue;
         if (tj.VtxID[end] > slc.vtxs.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 = slc.vtxs[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::ClearCRInfo ( TCSlice & slc )

Definition at line 121 of file TCCR.cxx.

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

void tca::ClearShowerTree ( ShowerTreeVars & stv )

Definition at line 212 of file TCShTree.cxx.

                                             {
     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	(	const TCSlice &	slc,
		const Trajectory &	tj,
		const Point2_t &	pos
	)

Definition at line 2549 of file Utils.cxx.

   {
     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	(	const TCSlice &	slc,
		std::vector< int > &	tjIDs,
		bool	prt
	)

Definition at line 578 of file Utils.cxx.

   {
     // 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 = slc.tjs[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 = slc.tjs[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
     // 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 (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	(	const TCSlice &	slc,
		const Trajectory &	tj1,
		const Trajectory &	tj2,
		bool	prt
	)

Definition at line 650 of file Utils.cxx.

   {
     // 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.AlgMod[kHaloTj] || tj2.AlgMod[kHaloTj]) 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(slc, 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]];
     float doca1 = PointTrajDOCA(slc, tp1.Pos[0], tp1.Pos[1], tp2);
     float doca2 = PointTrajDOCA(slc, 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 * tcc.kinkCuts[0]) {
       if (prt)
         mf::LogVerbatim("TC") << "CM: " << tj1.ID << " " << tj2.ID << " dang " << dang << " > "
                               << 2 * tcc.kinkCuts[0];
       return false;
     }
 
     return true;
   } // CompatibleMerge

void tca::CompleteIncomplete3DVertices	(	detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc
	)

Definition at line 2504 of file TCVertex.cxx.

   {
     // 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 (!tcc.useAlg[kComp3DVx]) return;
     if (slc.nPlanes != 3) return;
 
     bool prt = (tcc.modes[kDebug] && tcc.dbgSlc && tcc.dbgAlg[kComp3DVx]);
 
     float maxdoca = 3;
     if (prt) mf::LogVerbatim("TC") << "Inside CI3DV with maxdoca set to " << maxdoca;
     unsigned short ivx3 = 0;
     for (auto& vx3 : slc.vtx3s) {
       // ignore obsolete vertices
       if (vx3.ID == 0) continue;
       // check for a completed 3D vertex
       if (vx3.Wire < 0) continue;
       unsigned short mPlane = USHRT_MAX;
       // look for vertices in the induction plane in which the charge requirement wasn't imposed
       bool indPlnNoChgVtx = false;
       for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
         if (vx3.Vx2ID[plane] > 0) {
           auto& vx2 = slc.vtxs[vx3.Vx2ID[plane] - 1];
           if (vx2.Stat[kVxIndPlnNoChg]) indPlnNoChgVtx = true;
           continue;
         }
         mPlane = plane;
       } // ipl
       if (mPlane == USHRT_MAX) continue;
       if (indPlnNoChgVtx) 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] = detProp.ConvertXToTicks(vx3.X, mPlane, vx3.TPCID.TPC, vx3.TPCID.Cryostat) *
                    tcc.unitsPerTick;
       if (prt)
         mf::LogVerbatim("TC") << "CI3DV 3V" << vx3.ID << " Pos " << mPlane << ":"
                               << PrintPos(slc, vtp.Pos);
       std::vector<int> tjIDs;
       std::vector<unsigned short> tjPts;
       for (auto& tj : slc.tjs) {
         if (tj.CTP != mCTP) continue;
         if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) 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(slc, 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(slc, tj, closePt, 3, false)) vtp.Pos = tj.Pts[closePt].Pos;
         if (prt)
           mf::LogVerbatim("TC") << "CI3DV 3V" << vx3.ID << " candidate  T" << tj.ID << " vtx pos "
                                 << PrintPos(slc, vtp.Pos) << " doca " << doca << " closePt "
                                 << closePt;
         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
       auto vxtjs = GetAssns(slc, "3V", vx3.ID, "T");
       unsigned short maxPts = 0;
       unsigned short minPts = USHRT_MAX;
       for (auto tjid : vxtjs) {
         auto& tj = slc.tjs[tjid - 1];
         unsigned short npwc = NumPtsWithCharge(slc, tj, false);
         if (npwc > maxPts) maxPts = npwc;
         if (npwc < minPts) minPts = 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 = slc.tjs[tjid - 1];
         if (NumPtsWithCharge(slc, tj, false) > maxPts) skipit = true;
       } // tjid
       if (prt)
         mf::LogVerbatim("TC") << "  maxPts " << maxPts << " skipit? " << skipit << "  minPts "
                               << minPts;
       if (skipit) continue;
       // 2D vertex
       VtxStore aVtx;
       unsigned short newVtxIndx = slc.vtxs.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(slc, aVtx.Pos, tjIDs);
       if (prt)
         mf::LogVerbatim("TC") << " charge fraction near position " << aVtx.TjChgFrac
                               << " cut if < 0.6";
       if (aVtx.TjChgFrac < 0.6) continue;
       if (!StoreVertex(slc, aVtx)) continue;
       // make a reference to the new vertex
       VtxStore& newVtx = slc.vtxs[slc.vtxs.size() - 1];
       if (prt) mf::LogVerbatim("TC") << " Stored new 2V" << 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;
         unsigned short closePt = tjPts[ii];
         // determine which end is the closest
         unsigned short end = 1;
         // closest to the beginning?
         if (fabs(closePt - slc.tjs[itj].EndPt[0]) < fabs(closePt - slc.tjs[itj].EndPt[1])) end = 0;
         short dpt = fabs(closePt - slc.tjs[itj].EndPt[end]);
         if (prt) mf::LogVerbatim("TC") << " dpt " << dpt << " to end " << end;
         if (dpt < 2) {
           // close to an end
           if (slc.tjs[itj].VtxID[end] > 0) {
             // find the distance btw the existing vertex and the end of this tj
             auto& oldTj = slc.tjs[itj];
             auto& oldVx = slc.vtxs[oldTj.VtxID[end] - 1];
             short oldSep = fabs(oldVx.Pos[0] - oldTj.Pts[oldTj.EndPt[end]].Pos[0]);
             if (prt)
               mf::LogVerbatim("TC")
                 << " T" << slc.tjs[itj].ID << " has vertex 2V" << slc.tjs[itj].VtxID[end]
                 << " at end " << end << ". oldSep " << oldSep;
             if (dpt < oldSep) { MakeVertexObsolete("CI3DV", slc, oldVx, true); }
             else {
               continue;
             }
           } // slc.tjs[itj].VtxID[end] > 0
           slc.tjs[itj].VtxID[end] = slc.vtxs[newVtxIndx].ID;
           ++newVtx.NTraj;
           if (prt)
             mf::LogVerbatim("TC") << " attach Traj T" << slc.tjs[itj].ID << " at end " << end;
           slc.tjs[itj].AlgMod[kComp3DVx] = true;
           vpos = slc.tjs[itj].Pts[slc.tjs[itj].EndPt[end]].Pos;
         }
         else {
           // closePt is not near an end, so split the trajectory
           if (SplitTraj(slc, itj, closePt, newVtxIndx, prt)) {
             if (prt)
               mf::LogVerbatim("TC")
                 << " SplitTraj success 2V" << slc.vtxs[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(slc, itj);
           // and for the new trajectory
           SetPDGCode(slc, slc.tjs.size() - 1);
         } // closePt is not near an end, so split the trajectory
         slc.tjs[itj].AlgMod[kComp3DVx] = true;
         unsigned short newtj = slc.tjs.size() - 1;
         slc.tjs[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("CI3DV", slc, 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(slc, newVtx.ID - 1, prt);
         SetVx2Score(slc);
         if (prt) {
           mf::LogVerbatim myprt("TC");
           myprt << " Success: new 2V" << newVtx.ID << " at " << (int)newVtx.Pos[0] << ":"
                 << (int)newVtx.Pos[1] / tcc.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	(	detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc
	)

Definition at line 2410 of file TCVertex.cxx.

   {
 
     if (!tcc.useAlg[kComp3DVxIG]) return;
     if (slc.nPlanes != 3) return;
 
     bool prt = (tcc.modes[kDebug] && tcc.dbgSlc && tcc.dbgAlg[kComp3DVxIG]);
     if (prt) mf::LogVerbatim("TC") << "Inside CI3DVIG:";
 
     for (unsigned short iv3 = 0; iv3 < slc.vtx3s.size(); ++iv3) {
       Vtx3Store& vx3 = slc.vtx3s[iv3];
       // ignore obsolete vertices
       if (vx3.ID == 0) continue;
       // check for a completed 3D vertex
       if (vx3.Wire < 0) continue;
       unsigned short mPlane = USHRT_MAX;
       for (unsigned short ipl = 0; ipl < slc.nPlanes; ++ipl) {
         if (vx3.Vx2ID[ipl] > 0) continue;
         mPlane = ipl;
         break;
       } // ipl
       if (mPlane == USHRT_MAX) continue;
       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(slc, vx3.Wire - 4, vx3.Wire + 4, mCTP);
       if (dwc < 5) continue;
       // X position of the purported missing vertex
       VtxStore aVtx;
       aVtx.ID = slc.vtxs.size() + 1;
       aVtx.Pos[0] = vx3.Wire;
       aVtx.Pos[1] = detProp.ConvertXToTicks(vx3.X, mPlane, vx3.TPCID.TPC, vx3.TPCID.Cryostat) *
                     tcc.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 < slc.tjs.size(); ++itj) {
         if (slc.tjs[itj].CTP != mCTP) continue;
         if (slc.tjs[itj].AlgMod[kKilled] || slc.tjs[itj].AlgMod[kHaloTj]) continue;
         for (unsigned short end = 0; end < 2; ++end) {
           unsigned short ept = slc.tjs[itj].EndPt[end];
           TrajPoint& tp = slc.tjs[itj].Pts[ept];
           unsigned short oept = slc.tjs[itj].EndPt[1 - end];
           TrajPoint& otp = slc.tjs[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(slc, aVtx.Pos[0], aVtx.Pos[1], tp);
           if (doca > 2) continue;
           float dwc = DeadWireCount(slc, 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 " << slc.tjs[itj].ID << " doca " << doca
                                   << " ptSep " << ptSep;
           if (ptSep < -2 || ptSep > 2) continue;
           // don't clobber an existing association
           if (slc.tjs[itj].VtxID[end] > 0) continue;
           tjIDs.push_back(slc.tjs[itj].ID);
           tjEnds.push_back(end);
         } // end
       }   // itj
       if (!tjIDs.empty()) {
         // Determine how messy this region is
         aVtx.TjChgFrac = ChgFracNearPos(slc, aVtx.Pos, tjIDs);
         if (aVtx.TjChgFrac < 0.7) continue;
         aVtx.Vx3ID = vx3.ID;
         // Save the 2D vertex
         if (!StoreVertex(slc, aVtx)) continue;
         for (unsigned short ii = 0; ii < tjIDs.size(); ++ii) {
           unsigned short itj = tjIDs[ii] - 1;
           slc.tjs[itj].VtxID[tjEnds[ii]] = aVtx.ID;
           slc.tjs[itj].AlgMod[kComp3DVxIG] = true;
         } // ii
         SetVx2Score(slc);
         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,
		TCSlice &	slc,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 754 of file TCShower.cxx.

   {
     // 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 (slc.nPlanes != 3) return false;
     if (ss3.CotIDs.size() != 2) return false;
 
     if (!tcc.useAlg[kCompleteShower]) return false;
 
     std::string fcnLabel = inFcnLabel + ".CIS";
     if (prt) mf::LogVerbatim("TC") << fcnLabel << " 3S" << ss3.ID;
 
     auto& iss = slc.cots[ss3.CotIDs[0] - 1];
     auto& jss = slc.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(slc, "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(slc, "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 = slc.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 = slc.tjs[tid - 1];
         for (unsigned short end = 0; end < 2; ++end) {
           if (tj.VtxID[end] <= 0) continue;
           auto& vx2 = slc.vtxs[tj.VtxID[end] - 1];
           auto TIn2V = GetAssns(slc, "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 = slc.tjs[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 = slc.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(slc, 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 = slc.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(slc, 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, slc, kss, prt)) {
         if (prt) mf::LogVerbatim("TC") << fcnLabel << " UpdateShower failed 2S" << kss.ID;
         MakeShowerObsolete(fcnLabel, slc, kss, prt);
         return false;
       } // UpdateShower failed
       if (!StoreShower(fcnLabel, slc, kss)) {
         if (prt) mf::LogVerbatim("TC") << fcnLabel << " StoreShower failed";
         MakeShowerObsolete(fcnLabel, slc, kss, prt);
         return false;
       } // StoreShower failed
       ss3.CotIDs.push_back(kss.ID);
       auto& stj = slc.tjs[kss.ShowerTjID - 1];
       stj.AlgMod[kCompleteShower] = true;
       ss3.NeedsUpdate = true;
       return true;
     } // ksslist empty
 
     // associate ksslist[0] with 3S
     auto& ss = slc.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 = slc.tjs[ss.ShowerTjID - 1];
     stj.AlgMod[kCompleteShower] = true;
     ss3.NeedsUpdate = true;
 
     ChkAssns(fcnLabel, slc);
     return true;
 
   } // CompleteIncompleteShower

void tca::ConfigureMVA	(	TCConfig &	tcc,
		std::string	fMVAShowerParentWeights
	)

Definition at line 33 of file TCShower.cxx.

   {
     // Define the reference to the MVA reader used to determine the best
     // shower parent PFParticle
     cet::search_path sp("FW_SEARCH_PATH");
     if (!tcc.showerParentReader) return;
     std::string fullFileSpec;
     sp.find_file(fMVAShowerParentWeights, fullFileSpec);
     if (fullFileSpec == "") {
       tcc.showerParentReader = 0;
       return;
     }
     tcc.showerParentVars.resize(9);
     tcc.showerParentReader->AddVariable("fShEnergy", &tcc.showerParentVars[0]);
     tcc.showerParentReader->AddVariable("fPfpEnergy", &tcc.showerParentVars[1]);
     tcc.showerParentReader->AddVariable("fMCSMom", &tcc.showerParentVars[2]);
     tcc.showerParentReader->AddVariable("fPfpLen", &tcc.showerParentVars[3]);
     tcc.showerParentReader->AddVariable("fSep", &tcc.showerParentVars[4]);
     tcc.showerParentReader->AddVariable("fDang1", &tcc.showerParentVars[5]);
     tcc.showerParentReader->AddVariable("fDang2", &tcc.showerParentVars[6]);
     tcc.showerParentReader->AddVariable("fChgFrac", &tcc.showerParentVars[7]);
     tcc.showerParentReader->AddVariable("fInShwrProb", &tcc.showerParentVars[8]);
     tcc.showerParentReader->BookMVA("BDT", fullFileSpec);
   } // ConfigureTMVA

void tca::CountBadPoints	(	const TCSlice &	slc,
		const PFPStruct &	pfp,
		unsigned short	fromPt,
		unsigned short	toPt,
		unsigned short &	nBadPts,
		unsigned short &	firstBadPt
	)

Definition at line 1308 of file PFPUtils.cxx.

   {
     // Count the number of points whose pull exceeds tcc.match3DCuts[4]
     firstBadPt = USHRT_MAX;
     nBadPts = 0;
     if (fromPt > pfp.TP3Ds.size() - 1) {
       nBadPts = USHRT_MAX;
       return;
     }
     if (toPt > pfp.TP3Ds.size()) toPt = pfp.TP3Ds.size();
     bool first = true;
     for (unsigned short ipt = fromPt; ipt < toPt; ++ipt) {
       auto& tp3d = pfp.TP3Ds[ipt];
       if (!tp3d.Flags[kTP3DGood]) continue;
       // don't clobber a point if it is on a TP that is overlapping another Tj. This will
       // happen for points close to a vertex and when trajectories cross
       auto& tp = slc.tjs[tp3d.TjID - 1].Pts[tp3d.TPIndex];
       if (tp.Environment[kEnvOverlap]) continue;
       if (PointPull(pfp, tp3d) < tcc.match3DCuts[4]) continue;
       ++nBadPts;
       if (first) {
         first = false;
         firstBadPt = ipt;
       }
     } // ipt
   }   // CountBadPoints

PFPStruct tca::CreatePFP ( const TCSlice & slc )

Definition at line 2823 of file PFPUtils.cxx.

   {
     // The calling function should define the size of pfp.TjIDs
     PFPStruct pfp;
     pfp.ID = slc.pfps.size() + 1;
     pfp.ParentUID = 0;
     pfp.TPCID = slc.TPCID;
     // initialize arrays for both ends
     if (slc.nPlanes < 4) {
       pfp.dEdx[0].resize(slc.nPlanes, -1);
       pfp.dEdx[1].resize(slc.nPlanes, -1);
       pfp.dEdxErr[0].resize(slc.nPlanes, -1);
       pfp.dEdxErr[1].resize(slc.nPlanes, -1);
     }
     // create a single section fit to hold the start/end positions and direction
     pfp.SectionFits.resize(1);
     return pfp;
   } // CreatePFP

ShowerStruct tca::CreateSS	(	TCSlice &	slc,
		const std::vector< int > &	tjl
	)

Definition at line 4108 of file TCShower.cxx.

   {
     // 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;
 
     // Create the shower tj
     Trajectory stj;
     stj.CTP = slc.tjs[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 = slc.tjs.size() + 1;
     // Declare that stj is a shower Tj
     stj.AlgMod[kShowerTj] = true;
     stj.PDGCode = 1111;
     slc.tjs.push_back(stj);
     // define the ss
     ss.ID = slc.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 = slc.tjs[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 ( TCSlice & slc )

Definition at line 4088 of file TCShower.cxx.

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

TP3D tca::CreateTP3D	(	detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		int	tjID,
		unsigned short	tpIndex
	)

Definition at line 2722 of file PFPUtils.cxx.

   {
     // create a TP3D with a single TP. Note that the SectionFit in which it
     // should be placed and the 3D position can't be determined until the the TP3D is
     // associated with a pfp. See SetSection()
 
     TP3D tp3d;
     tp3d.Flags[kTP3DBad] = true;
     if (tjID <= 0 || tjID > (int)slc.tjs.size()) return tp3d;
     auto& tj = slc.tjs[tjID - 1];
     if (tpIndex < tj.EndPt[0] || tpIndex > tj.EndPt[1]) return tp3d;
     tp3d.TjID = tjID;
     tp3d.TPIndex = tpIndex;
     auto& tp2 = tj.Pts[tp3d.TPIndex];
     auto plnID = DecodeCTP(tp2.CTP);
     tp3d.CTP = tp2.CTP;
     double tick = tp2.HitPos[1] / tcc.unitsPerTick;
     tp3d.TPX = detProp.ConvertTicksToX(tick, plnID);
     // Get the RMS of the TP in WSE units and convert to cm
     float rms = TPHitsRMSTime(slc, tp2, kAllHits) * tcc.wirePitch;
     // inflate the error for large angle TPs
     if (tp2.AngleCode == 1) rms *= 2;
     // a more careful treatment for long-pulse hits
     if (tp2.AngleCode > 1) {
       std::vector<unsigned int> hitMultiplet;
       for (std::size_t ii = 0; ii < tp2.Hits.size(); ++ii) {
         if (!tp2.UseHit[ii]) continue;
         GetHitMultiplet(slc, tp2.Hits[ii], hitMultiplet, true);
         if (hitMultiplet.size() > 1) break;
       } // ii
       rms = HitsRMSTime(slc, hitMultiplet, kAllHits) * tcc.wirePitch;
       // the returned RMS is closer to the FWHM, so divide by 2
       rms /= 2;
     } // tp2.AngleCode > 1
     tp3d.TPXErr2 = rms * rms;
     tp3d.Wire = tp2.Pos[0];
     // Can't declare it good since Pos and SFIndex aren't defined
     tp3d.Flags[kTP3DGood] = false;
     tp3d.Flags[kTP3DBad] = false;
     return tp3d;
   } // CreateTP3D

TrajPoint tca::CreateTPFromTj	(	TCSlice &	slc,
		const Trajectory &	tj
	)

Definition at line 3215 of file StepUtils.cxx.

   {
     // Create a trajectory point by averaging the position and direction of all
     // TPs in the trajectory. This is used in LastEndMerge
     TrajPoint tjtp;
     // set the charge invalid
     tjtp.Chg = -1;
     if(tj.AlgMod[kKilled]) return tjtp;
     // stash the ID in the Step
     tjtp.Step = tj.ID;
     tjtp.CTP = tj.CTP;
     tjtp.Pos[0] = 0;
     tjtp.Pos[1] = 0;
     tjtp.Dir[0] = 0;
     tjtp.Dir[1] = 0;
     float cnt = 0;
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if(tp.Chg <= 0) continue;
       tjtp.Pos[0] += tp.Pos[0];
       tjtp.Pos[1] += tp.Pos[1];
       tjtp.Dir[1] += tp.Dir[1];
       ++cnt;
     } // ipt
     tjtp.Pos[0] /= cnt;
     tjtp.Pos[1] /= cnt;
     tjtp.Dir[1] /= cnt;
     double arg = 1 - tjtp.Dir[1] * tjtp.Dir[1];
     if(arg < 0) arg = 0;
     tjtp.Dir[0] = sqrt(arg);
     tjtp.Ang = atan2(tjtp.Dir[1], tjtp.Dir[0]);
     tjtp.Chg = 1;
     return tjtp;
   } // CreateTjTP

float tca::DeadWireCount	(	const TCSlice &	slc,
		const TrajPoint &	tp1,
		const TrajPoint &	tp2
	)

Definition at line 2139 of file Utils.cxx.

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

float tca::DeadWireCount	(	const TCSlice &	slc,
		const float &	inWirePos1,
		const float &	inWirePos2,
		CTP_t	tCTP
	)

Definition at line 2146 of file Utils.cxx.

   {
     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 > slc.nWires[plane] || inWire2 > slc.nWires[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 (!evt.goodWire[plane][wire]) ++ndead;
     return ndead;
   } // DeadWireCount

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

Definition at line 115 of file DataStructs.cxx.

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

bool tca::DecodeDebugString ( std::string strng )

Definition at line 5214 of file Utils.cxx.

   {
     // try to unpack the string as Cryostat:TPC:Plane:Wire:Tick or something
     // like Slice:<slice index>
 
     if (strng == "instruct") {
       std::cout << "****** Unrecognized DebugConfig. Here are your options\n";
       std::cout << " 'C:T:P:W:Tick' where C = cryostat, T = TPC, W = wire, Tick (+/-5) to debug "
                    "stepping (DUNE)\n";
       std::cout << " 'P:W:Tick' for single cryostat/TPC detectors (uB, LArIAT, etc)\n";
       std::cout << " 'WorkID <id> <slice index>' where <id> is a tj work ID (< 0) in slice <slice "
                    "index> (default = 0)\n";
       std::cout << " 'Merge <CTP>' to debug trajectory merging\n";
       std::cout << " '2V <CTP>' to debug 2D vertex finding\n";
       std::cout << " '3V' to debug 3D vertex finding\n";
       std::cout << " 'VxMerge' to debug 2D vertex merging\n";
       std::cout << " 'JunkVx' to debug 2D junk vertex finder\n";
       std::cout << " 'PFP' to debug 3D matching and PFParticles\n";
       std::cout << " 'MVI <MVI> <MVI Iteration>' for detailed debugging of one PFP MatchVecIndex\n";
       std::cout << " 'DeltaRay' to debug delta ray tagging\n";
       std::cout << " 'Muon' to debug muon tagging\n";
       std::cout << " '2S <CTP>' to debug a 2D shower in CTP\n";
       std::cout << " 'Reco TPC <TPC>' to only reconstruct hits in the specified TPC\n";
       std::cout << " 'Reco Slice <ID>' to reconstruct all sub-slices in the recob::Slice with the "
                    "specified ID\n";
       std::cout << " 'SubSlice <sub-slice index>' where <slice index> restricts output to the "
                    "specified sub-slice index\n";
       std::cout << " 'Stitch' to debug PFParticle stitching between TPCs\n";
       std::cout << " 'Sum' or 'Summary' to print a debug summary report\n";
       std::cout << " 'Dump <WorkID>' or 'Dump <UID>' to print all TPs in the trajectory to "
                    "tcdump<UID>.csv\n";
       std::cout << " Note: Algs with debug printing include HamVx, HamVx2, SplitTjCVx, Comp3DVx, "
                    "Comp3DVxIG, VtxHitsSwap\n";
       std::cout << " Set SkipAlgs: [\"bogusText\"] to print a list of algorithm names\n";
       return false;
     } // instruct
 
     // handle the simple cases that don't need decoding
     if (strng.find("3V") != std::string::npos) {
       tcc.dbg3V = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if (strng.find("3S") != std::string::npos) {
       tcc.dbg3S = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if (strng.find("VxMerge") != std::string::npos) {
       tcc.dbgVxMerge = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if (strng.find("JunkVx") != std::string::npos) {
       tcc.dbgVxJunk = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if (strng.find("DeltaRay") != std::string::npos) {
       tcc.dbgDeltaRayTag = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if (strng.find("Muon") != std::string::npos) {
       tcc.dbgMuonTag = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if (strng.find("Stitch") != std::string::npos) {
       tcc.dbgStitch = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if (strng.find("HamVx") != std::string::npos) {
       tcc.dbgAlg[kHamVx] = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if (strng.find("HamVx2") != std::string::npos) {
       tcc.dbgAlg[kHamVx2] = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if (strng.find("Sum") != std::string::npos) {
       tcc.dbgSummary = true;
       tcc.modes[kDebug] = true;
       return true;
     }
 
     std::vector<std::string> words;
     boost::split(words, strng, boost::is_any_of(" :"), boost::token_compress_on);
     if (words.size() == 5) {
       // configure for DUNE
       debug.Cryostat = std::stoi(words[0]);
       debug.TPC = std::stoi(words[1]);
       debug.Plane = std::stoi(words[2]);
       debug.Wire = std::stoi(words[3]);
       debug.Tick = std::stoi(words[4]);
       tcc.modes[kDebug] = true;
       tcc.dbgStp = true;
       // also dump this tj
       tcc.dbgDump = true;
       return true;
     } // nums.size() == 5
     if (words[0] == "PFP" || words[0] == "MVI") {
       tcc.dbgPFP = true;
       tcc.modes[kDebug] = true;
       // Use debug.Hit to identify the matchVec index
       if (words.size() > 2) {
         debug.MVI = std::stoi(words[1]);
         if (words.size() == 3) debug.MVI_Iter = std::stoi(words[2]);
       }
       return true;
     } // PFP
     if (words.size() == 2 && words[0] == "Dump") {
       debug.WorkID = std::stoi(words[1]);
       debug.Slice = 0;
       tcc.modes[kDebug] = true;
       tcc.dbgDump = true;
       return true;
     }
     if (words.size() > 1 && words[0] == "WorkID") {
       debug.WorkID = std::stoi(words[1]);
       if (debug.WorkID >= 0) return false;
       // default to sub-slice index 0
       debug.Slice = 0;
       if (words.size() > 2) debug.Slice = std::stoi(words[2]);
       tcc.modes[kDebug] = true;
       // dbgStp is set true after debug.WorkID is found
       tcc.dbgStp = false;
       return true;
     } // words.size() == 3 && words[0] == "WorkID"
     if (words.size() == 3 && words[0] == "Reco" && words[1] == "TPC") {
       tcc.recoTPC = std::stoi(words[2]);
       tcc.modes[kDebug] = true;
       std::cout << "Reconstructing only in TPC " << tcc.recoTPC << "\n";
       return true;
     }
     if (words.size() == 3 && words[0] == "Reco" && words[1] == "Slice") {
       tcc.recoSlice = std::stoi(words[1]);
       std::cout << "Reconstructing Slice " << tcc.recoSlice << "\n";
       return true;
     }
     if (words.size() == 3) {
       // configure for uB, LArIAT, etc
       debug.Cryostat = 0;
       debug.TPC = 0;
       debug.Plane = std::stoi(words[0]);
       debug.Wire = std::stoi(words[1]);
       debug.Tick = std::stoi(words[2]);
       debug.CTP = EncodeCTP(debug.Cryostat, debug.TPC, debug.Plane);
       tcc.modes[kDebug] = true;
       tcc.dbgStp = true;
       return true;
     }
     if (words.size() == 2 && words[0] == "Merge") {
       debug.CTP = std::stoi(words[1]);
       tcc.dbgMrg = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if (words.size() == 2 && words[0] == "2V") {
       debug.CTP = std::stoi(words[1]);
       tcc.dbg2V = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if (words.size() == 2 && words[0] == "2S") {
       debug.CTP = std::stoi(words[1]);
       tcc.dbg2S = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     // Slice could apply to several debug options.
     if (words.size() == 2 && words[0] == "SubSlice") {
       debug.Slice = std::stoi(words[1]);
       return true;
     }
     return false;
   } // DecodeDebugString

float tca::dEdx	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		TP3D &	tp3d
	)

Definition at line 2686 of file PFPUtils.cxx.

   {
     if (!tp3d.Flags[kTP3DGood]) return 0;
     if (tp3d.TjID > (int)slc.slHits.size()) return 0;
     if (tp3d.TjID <= 0) return 0;
 
     auto& tp = slc.tjs[tp3d.TjID - 1].Pts[tp3d.TPIndex];
     if (tp.Environment[kEnvOverlap]) return 0;
 
     double dQ = 0.;
     double time = 0;
     for (unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
       if (!tp.UseHit[ii]) continue;
       auto& hit = (*evt.allHits)[slc.slHits[tp.Hits[ii]].allHitsIndex];
       dQ += hit.Integral();
     } // ii
     time = tp.Pos[1] / tcc.unitsPerTick;
     geo::PlaneID plnID = DecodeCTP(tp.CTP);
     if (dQ == 0) return 0;
     double angleToVert = tcc.geom->Plane(plnID).ThetaZ() - 0.5 * ::util::pi<>();
     double cosgamma =
       std::abs(std::sin(angleToVert) * tp3d.Dir[1] + std::cos(angleToVert) * tp3d.Dir[2]);
     if (cosgamma < 1.E-5) return 0;
     double dx = tcc.geom->WirePitch(plnID) / cosgamma;
     double dQdx = dQ / dx;
     double t0 = 0;
     float dedx = tcc.caloAlg->dEdx_AREA(clockData, detProp, dQdx, time, plnID.Plane, t0);
     if (std::isinf(dedx)) dedx = 0;
     return dedx;
   } // dEdx

void tca::DefineDontCluster	(	TCSlice &	slc,
		bool	prt
	)

void tca::DefineEnvelope	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3487 of file TCShower.cxx.

   {
 
     if (ss.ID == 0) return;
     if (ss.TjIDs.empty()) return;
     Trajectory& stj = slc.tjs[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] = tcc.showerTag[5] + tcc.showerTag[4] * stp0.DeltaRMS;
     // second vertex
     ss.Envelope[1][0] = PosSep(stp1.Pos, stp2.Pos);
     ss.Envelope[1][1] = tcc.showerTag[5] + tcc.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] / tcc.unitsPerTick);
       myprt << " Area " << (int)ss.EnvelopeArea;
       myprt << " ChgDensity " << ss.ChgDensity;
     }
     // This is the last function used to update a shower
     ss.NeedsUpdate = false;
   } // DefineEnvelope

void tca::DefineHitPos	(	TCSlice &	slc,
		TrajPoint &	tp
	)

Definition at line 1670 of file StepUtils.cxx.

   {
     // defines HitPos, HitPosErr2 and Chg for the used hits in the trajectory point
 
     tp.Chg = 0;
     if(tp.Hits.empty()) return;
 
     unsigned short nused = 0;
     unsigned int iht = 0;
     for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
       if(!tp.UseHit[ii]) continue;
       ++nused;
       iht = tp.Hits[ii];
       if(iht >= slc.slHits.size()) return;
       if(slc.slHits[iht].allHitsIndex >= (*evt.allHits).size()) return;
     }
     if(nused == 0) return;
 
     // don't bother with rest of this if there is only one hit since it can
     // only reside on one wire
     if(nused == 1) {
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       tp.Chg = hit.Integral();
       tp.HitPos[0] = hit.WireID().Wire;
       tp.HitPos[1] = hit.PeakTime() * tcc.unitsPerTick;
       if(LongPulseHit(hit)) {
         // give it a huge error^2 since the position is not well defined
         tp.HitPosErr2 = 100;
       } else {
         // Normalize to 1 WSE path length
         float pathInv = std::abs(tp.Dir[0]);
         if(pathInv < 0.05) pathInv = 0.05;
         tp.Chg *= pathInv;
         float wireErr = tp.Dir[1] * 0.289;
         float timeErr = tp.Dir[0] * HitTimeErr(slc, iht);
         tp.HitPosErr2 = wireErr * wireErr + timeErr * timeErr;
       }
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"DefineHitPos: singlet "<<std::fixed<<std::setprecision(1)<<tp.HitPos[0]<<":"<<(int)(tp.HitPos[1]/tcc.unitsPerTick)<<" ticks. HitPosErr "<<sqrt(tp.HitPosErr2);
       return;
     } // nused == 1
 
     // multiple hits possibly on different wires
     std::vector<unsigned int> hitVec;
     tp.Chg = 0;
     std::array<float, 2> newpos;
     float chg;
     newpos[0] = 0;
     newpos[1] = 0;
     // Find the wire range for hits used in the TP
     unsigned int loWire = INT_MAX;
     unsigned int hiWire = 0;
     for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
       if(!tp.UseHit[ii]) continue;
       unsigned int iht = tp.Hits[ii];
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       chg = hit.Integral();
       unsigned int wire = hit.WireID().Wire;
       if(wire < loWire) loWire = wire;
       if(wire > hiWire) hiWire = wire;
       newpos[0] += chg * wire;
       newpos[1] += chg * hit.PeakTime();
       tp.Chg += chg;
       hitVec.push_back(iht);
     } // ii
 
     if(tp.Chg == 0) return;
 
     tp.HitPos[0] = newpos[0] / tp.Chg;
     tp.HitPos[1] = newpos[1] * tcc.unitsPerTick / tp.Chg;
     // Normalize to 1 WSE path length
     float pathInv = std::abs(tp.Dir[0]);
     if(pathInv < 0.05) pathInv = 0.05;
     tp.Chg *= pathInv;
     // Error is the wire error (1/sqrt(12))^2 if all hits are on one wire.
     // Scale it by the wire range
     float dWire = 1 + hiWire - loWire;
     float wireErr = tp.Dir[1] * dWire * 0.289;
     float timeErr2 = tp.Dir[0] * tp.Dir[0] * HitsTimeErr2(slc, hitVec);
     tp.HitPosErr2 = wireErr * wireErr + timeErr2;
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"DefineHitPos: multiplet "<<std::fixed<<std::setprecision(1)<<tp.HitPos[0]<<":"<<(int)(tp.HitPos[1]/tcc.unitsPerTick)<<" ticks. HitPosErr "<<sqrt(tp.HitPosErr2);
 
   } // DefineHitPos

void tca::DefinePFPParents	(	TCSlice &	slc,
		bool	prt
	)

Definition at line 2883 of file PFPUtils.cxx.

   {
     /*
      This function reconciles vertices, PFParticles and slc, 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 (slc.pfps.empty()) return;
     if (tcc.modes[kTestBeam]) return;
 
     int neutrinoPFPID = 0;
     for (auto& pfp : slc.pfps) {
       if (pfp.ID == 0) continue;
       if (!tcc.modes[kTestBeam] && 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 : slc.pfps) {
       if (pfp.ID == 0) continue;
       // already done?
       if (pfp.Vx3ID[end1] > 0) continue;
       // ignore shower-like pfps
       if (IsShowerLike(slc, 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 = slc.tjs[tjid - 1];
         if (tj.VtxID[end1] == 0) continue;
         auto& vx2 = slc.vtxs[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;
       } // cnt3 > 1
     }   // pfp
 
     // Assign a PDGCode to each PFParticle and look for a parent
     for (auto& pfp : slc.pfps) {
       if (pfp.ID == 0) continue;
       // skip a neutrino PFParticle
       if (pfp.PDGCode == 12 || pfp.PDGCode == 14 || pfp.PDGCode == 22) continue;
       // Define a PFP parent if there are two or more Tjs that are daughters of
       // Tjs that are used by the same PFParticle
       int pfpParentID = INT_MAX;
       unsigned short nParent = 0;
       for (auto tjid : pfp.TjIDs) {
         auto& tj = slc.tjs[tjid - 1];
         if (tj.ParentID <= 0) continue;
         auto parPFP = GetAssns(slc, "T", tj.ParentID, "P");
         if (parPFP.empty()) continue;
         if (pfpParentID == INT_MAX) pfpParentID = parPFP[0];
         if (parPFP[0] == pfpParentID) ++nParent;
       } // ii
       if (nParent > 1) {
         auto& ppfp = slc.pfps[pfpParentID - 1];
         // set the parent UID
         pfp.ParentUID = ppfp.UID;
         // add to the parent daughters list
         ppfp.DtrUIDs.push_back(pfp.UID);
       } // nParent > 1
     }   // ipfp
     // associate primary PFParticles with a neutrino PFParticle
     if (neutrinoPFPID > 0) {
       auto& neutrinoPFP = slc.pfps[neutrinoPFPID - 1];
       int vx3id = neutrinoPFP.Vx3ID[1];
       for (auto& pfp : slc.pfps) {
         if (pfp.ID == 0 || pfp.ID == neutrinoPFPID) continue;
         if (pfp.Vx3ID[0] != vx3id) continue;
         pfp.ParentUID = (size_t)neutrinoPFPID;
         neutrinoPFP.DtrUIDs.push_back(pfp.ID);
         if (pfp.PDGCode == 111) neutrinoPFP.PDGCode = 12;
       } // pfp
     }   // neutrino PFP exists
   }     // DefinePFPParents

void tca::DefineTjParents	(	TCSlice &	slc,
		bool	prt
	)

Definition at line 166 of file Utils.cxx.

   {
     /*
     This function sets the ParentUID 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 ParentUID = 0. All other Tjs in the chain have ParentUID
     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   ParentUID   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 (tcc.modes[kTestBeam]) return;
 
     // clear old information
     for (auto& tj : slc.tjs) {
       if (tj.AlgMod[kKilled]) continue;
       // ignore delta rays
       if (tj.AlgMod[kDeltaRay] || tj.AlgMod[kHaloTj]) continue;
       tj.ParentID = 0;
     } // tj
 
     // sort vertice by decreasing score
     std::vector<int> temp;
     for (auto& vx3 : slc.vtx3s) {
       if (vx3.ID == 0) 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 = slc.vtx3s[vx3id - 1];
       float score;
       auto tjlist = GetVtxTjIDs(slc, vx3, score);
       for (auto tjid : tjlist) {
         auto& tj = slc.tjs[tjid - 1];
         if (tj.ParentID != 0) 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 = slc.vtx3s[temp[indx] - 1];
       sortVec[indx].index = indx;
       sortVec[indx].val = vx3.Score;
     } // indx
     if (sortVec.size() > 1) std::sort(sortVec.begin(), sortVec.end(), valsDecreasing);
     // 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 (tcc.match3DCuts[0] > 0) {
       auto& vx3 = slc.vtx3s[vlist[0] - 1];
       if (vx3.Score > tcc.vtx2DCuts[7]) {
         auto neutrinoPFP = CreatePFP(slc);
         // call it the neutrino vertex
         vx3.Neutrino = true;
         // put the vertex at the end of the neutrino
         auto& sf = neutrinoPFP.SectionFits[0];
         sf.Pos[0] = vx3.X;
         sf.Pos[1] = vx3.Y;
         sf.Pos[2] = vx3.Z;
         sf.Dir[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.Flags[kNeedsUpdate] = false;
         // the rest of this will be defined later
         if (!StorePFP(slc, neutrinoPFP)) return;
       }
     } // User wants to make PFParticles
     // a temp vector to ensure that we only consider a vertex once
     std::vector<bool> lookedAt3(slc.vtx3s.size() + 1, false);
     std::vector<bool> lookedAt2(slc.vtxs.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 = slc.vtx3s[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(slc, vx3, score);
       if (primTjList.empty()) continue;
       pardtr.clear();
       for (auto primTjID : primTjList) {
         auto& primTj = slc.tjs[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 = slc.vtxs[primTj.VtxID[end] - 1];
           if (vx2.Vx3ID == vx3.ID) continue;
           // found a 2D vertex. Check for daughters
           auto dtrList = GetVtxTjIDs(slc, vx2);
           for (auto dtrID : dtrList) {
             // ignore the primary tj
             if (dtrID == primTjID) continue;
             auto& dtj = slc.tjs[dtrID - 1];
             if (dtj.ParentID != -1) 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 = slc.vtxs[primTj.VtxID[end] - 1];
           if (vx2.Vx3ID == vx3.ID && end != 0) ReverseTraj(slc, 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 = slc.tjs[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 = slc.tjs[lastPair.first - 1];
         // find the point on the daughter tj that is closest to the parent
         TrajTrajDOCA(slc, dtj, ptj, dpt, ppt, doca);
         // reverse the daughter if the closest point is near end 1 of the daughter
         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 = slc.vtxs[dtj.VtxID[end] - 1];
           if (lookedAt2[vx2.ID]) continue;
           lookedAt2[vx2.ID] = true;
           auto tjlist = GetVtxTjIDs(slc, 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 = slc.tjs[tjid - 1];
       if (tj.ParentID < 0) tj.ParentID = tj.ID;
     } // tjid
 
   } // DefineTjParents

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

Definition at line 2539 of file PFPUtils.cxx.

   {
     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 3381 of file Utils.cxx.

   {
     // 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 3404 of file Utils.cxx.

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

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

Definition at line 3391 of file Utils.cxx.

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

Vector3_t tca::DirAtEnd	(	const PFPStruct &	pfp,
		unsigned short	end
	)

Definition at line 3283 of file PFPUtils.cxx.

   {
     if (end > 1 || pfp.SectionFits.empty()) return {{0., 0., 0.}};
     if (end == 0) return pfp.SectionFits[0].Dir;
     return pfp.SectionFits[pfp.SectionFits.size() - 1].Dir;
   } // PosAtEnd

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

Definition at line 3256 of file TCShower.cxx.

   {
     // returns true if a pair of tjs in the two lists are in the dontCluster vector
     if (tjlist1.empty() || tjlist2.empty()) return false;
     if (slc.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 : slc.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 128 of file PFPUtils.h.

   {
     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 234 of file Utils.h.

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

void tca::DumpShowerPts	(	std::string	inFcnLabel,
		TCSlice &	slc,
		int	cotID
	)

void tca::DumpShowerPts	(	TCSlice &	slc,
		int	cotID
	)

Definition at line 3873 of file TCShower.cxx.

   {
     // 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)slc.cots.size()) return;
 
     ShowerStruct& ss = slc.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

void tca::DumpTj ( )

Definition at line 5398 of file Utils.cxx.

   {
     // Dump all of the points in a trajectory to the output in a form that can
     // be imported by another application, e.g. Excel
     // Search for the trajectory with the specified WorkID or Unique ID
 
     for (auto& slc : slices) {
       for (auto& tj : slc.tjs) {
         if (tj.WorkID != debug.WorkID && tj.UID != debug.WorkID) continue;
         // print a header
         std::ofstream outfile;
         std::string fname = "tcdump" + std::to_string(tj.UID) + ".csv";
         outfile.open(fname, std::ios::out | std::ios::trunc);
         outfile << "Dump trajectory T" << tj.UID << " WorkID " << tj.WorkID;
         outfile << " ChgRMS " << std::setprecision(2) << tj.ChgRMS;
         outfile << "\n";
         outfile << "Wire, Chg T" << tj.UID
                 << ", totChg, Tick, Delta, NTPsFit, Ang, ChiDOF, KinkSig, HitPosErr\n";
         for (unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
           auto& tp = tj.Pts[ipt];
           outfile << std::fixed;
           outfile << std::setprecision(0) << std::nearbyint(tp.Pos[0]);
           outfile << "," << (int)tp.Chg;
           // total charge near the TP
           float totChg = 0;
           for (auto iht : tp.Hits) {
             auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
             totChg += hit.Integral();
           }
           outfile << "," << (int)totChg;
           outfile << "," << std::setprecision(0) << std::nearbyint(tp.Pos[1] / tcc.unitsPerTick);
           outfile << "," << std::setprecision(2) << tp.Delta;
           outfile << "," << tp.NTPsFit;
           outfile << "," << std::setprecision(3) << tp.Ang;
           outfile << "," << std::setprecision(2) << tp.FitChi;
           outfile << "," << std::setprecision(2) << tp.KinkSig;
           outfile << "," << std::setprecision(2) << sqrt(tp.HitPosErr2);
           outfile << "\n";
         } // ipt
         outfile.close();
         std::cout << "Points on T" << tj.UID << " dumped to " << fname << "\n";
         tcc.dbgDump = false;
         return;
       } // tj
     }   // slc
 
   } // DumpTj

float tca::ElectronLikelihood	(	const TCSlice &	slc,
		const Trajectory &	tj
	)

Definition at line 3214 of file Utils.cxx.

   {
     // returns a number between 0 (not electron-like) and 1 (electron-like)
     if (NumPtsWithCharge(slc, tj, false) < 8) return -1;
     if (tj.EndFlag[0][kBragg] || tj.EndFlag[1][kBragg]) return 0;
 
     unsigned short midPt = 0.5 * (tj.EndPt[0] + tj.EndPt[1]);
     double rms0 = 0, rms1 = 0;
     unsigned short cnt;
     TjDeltaRMS(slc, tj, tj.EndPt[0], midPt, rms0, cnt);
     TjDeltaRMS(slc, tj, midPt, tj.EndPt[1], rms1, cnt);
     float asym = std::abs(rms0 - rms1) / (rms0 + rms1);
     float chgFact = (tj.ChgRMS - 0.1) * 5;
     float elh = 5 * asym * chgFact;
     if (elh > 1) elh = 1;
     return elh;
   } // ElectronLikelihood

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

inline

Definition at line 54 of file DataStructs.h.

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

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

inline

Definition at line 59 of file DataStructs.h.

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

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

inline

Definition at line 64 of file DataStructs.h.

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

void tca::EndMerge	(	TCSlice &	slc,
		CTP_t	inCTP,
		bool	lastPass
	)

Definition at line 3251 of file StepUtils.cxx.

   {
     // Merges trajectories end-to-end or makes vertices. Does a more careful check on the last pass
 
     if(slc.tjs.size() < 2) return;
     if(!tcc.useAlg[kMerge]) return;
 
     bool prt = (tcc.dbgMrg && tcc.dbgSlc && inCTP == debug.CTP);
     if(prt) mf::LogVerbatim("TC")<<"inside EndMerge slice "<<slices.size()-1<<" inCTP "<<inCTP<<" nTjs "<<slc.tjs.size()<<" lastPass? "<<lastPass;
 
     // Ensure that all tjs are in the same order
     short tccStepDir = 1;
     if(!tcc.modes[kStepDir]) tccStepDir = -1;
     for(auto& tj : slc.tjs) {
       if(tj.AlgMod[kKilled]) continue;
       if(tj.CTP != inCTP) continue;
       if(tj.StepDir != tccStepDir) ReverseTraj(slc, tj);
     } // tj
 
     unsigned short maxShortTjLen = tcc.vtx2DCuts[0];
 
     // temp vector for checking the fraction of hits near a merge point
     std::vector<int> tjlist(2);
 
     float minChgRMS = 0.5 * (tcc.chargeCuts[1] + tcc.chargeCuts[2]);
 
     // iterate whenever a merge occurs since tjs will change. This is not necessary
     // when a vertex is created however.
     bool iterate = true;
     while(iterate) {
       iterate = false;
       for(unsigned int it1 = 0; it1 < slc.tjs.size(); ++it1) {
         auto& tj1 = slc.tjs[it1];
         if(tj1.AlgMod[kKilled]) continue;
         if(tj1.CTP != inCTP) continue;
         // don't try to merge high energy electrons
         if(tj1.PDGCode == 111) continue;
         for(unsigned short end1 = 0; end1 < 2; ++end1) {
           // no merge if there is a vertex at the end
           if(tj1.VtxID[end1] > 0) continue;
           // make a copy of tp1 so we can mess with it
           TrajPoint tp1 = tj1.Pts[tj1.EndPt[end1]];
           // do a local fit on the lastpass only using the last 3 points
           if(lastPass && tp1.NTPsFit > 3) {
             // make a local copy of the tj
             auto ttj = slc.tjs[it1];
             auto& lastTP = ttj.Pts[ttj.EndPt[end1]];
             // fit the last 3 points
             lastTP.NTPsFit = 3;
             FitTraj(slc, ttj);
             tp1 = ttj.Pts[ttj.EndPt[end1]];
           } // last pass
           bool isVLA = (tp1.AngleCode == 2);
           float bestFOM = 5;
           if(isVLA) bestFOM = 20;
           float bestDOCA;
           unsigned int imbest = UINT_MAX;
           for(unsigned int it2 = 0; it2 < slc.tjs.size(); ++it2) {
             if(it1 == it2) continue;
             auto& tj2 = slc.tjs[it2];
             // check for consistent direction
             if(tj1.StepDir != tj2.StepDir) continue;
             if(tj2.AlgMod[kKilled]) continue;
             if(tj2.CTP != inCTP) continue;
             // don't try to merge high energy electrons
             if(tj2.PDGCode == 111) continue;
             float olf = OverlapFraction(slc, tj1, tj2);
             if(olf > 0.25) continue;
             unsigned short end2 = 1 - end1;
             // check for a vertex at this end
             if(tj2.VtxID[end2] > 0) continue;
             TrajPoint& tp2 = tj2.Pts[tj2.EndPt[end2]];
             TrajPoint& tp2OtherEnd = tj2.Pts[tj2.EndPt[end1]];
             // ensure that the other end isn't closer
             if(std::abs(tp2OtherEnd.Pos[0] - tp1.Pos[0]) < std::abs(tp2.Pos[0] - tp1.Pos[0])) continue;
             // ensure that the order is correct
             if(tj1.StepDir > 0) {
               if(tp2.Pos[0] < tp1.Pos[0] - 2) continue;
             } else {
               if(tp2.Pos[0] > tp1.Pos[0] + 2) continue;
             }
             // ensure that there is a signal on most of the wires between these points
             if(!SignalBetween(slc, tp1, tp2, 0.8)) {
               continue;
             }
             // Find the distance of closest approach for small angle merging
             // Inflate the doca cut if we are bridging a block of dead wires
             float dang = DeltaAngle(tp1.Ang, tp2.Ang);
             float doca = 15;
             if(isVLA) {
               // compare the minimum separation between Large Angle trajectories using a generous cut
               unsigned short ipt1, ipt2;
               TrajTrajDOCA(slc, tj1, tj2, ipt1, ipt2, doca);
               //              if(prt) mf::LogVerbatim("TC")<<" isVLA check ipt1 "<<ipt1<<" ipt2 "<<ipt2<<" doca "<<doca;
             } else {
               // small angle
               doca = PointTrajDOCA(slc, tp1.Pos[0], tp1.Pos[1], tp2);
             }
             float fom = dang * doca;
             if(fom < bestFOM) {
               bestFOM = fom;
               bestDOCA = doca;
               imbest = it2;
             }
           } // it2
           // No merge/vertex candidates
           if(imbest == UINT_MAX) continue;
 
           // Make angle adjustments to tp1.
           unsigned int it2 = imbest;
           auto& tj2 = slc.tjs[imbest];
           unsigned short end2 = 1 - end1;
           bool loMCSMom = (tj1.MCSMom + tj2.MCSMom) < 150;
           // Don't use the angle at the end Pt for high momentum long trajectories in case there is a little kink at the end
           if(tj1.Pts.size() > 50 && tj1.MCSMom > 100) {
             if(end1 == 0) {
               tp1.Ang = tj1.Pts[tj1.EndPt[0] + 2].Ang;
             } else {
               tp1.Ang = tj1.Pts[tj1.EndPt[1] - 2].Ang;
             }
           } else if(loMCSMom) {
             // Low momentum - calculate the angle using the two Pts at the end
             unsigned short pt1, pt2;
             if(end1 == 0) {
               pt1 = tj1.EndPt[0];
               pt2 = pt1 + 1;
             } else {
               pt2 = tj1.EndPt[1];
               pt1 = pt2 - 1;
             }
             TrajPoint tpdir;
             if(MakeBareTrajPoint(slc, tj1.Pts[pt1], tj1.Pts[pt2], tpdir)) tp1.Ang = tpdir.Ang;
           } // low MCSMom
           // Now do the same for tj2
           TrajPoint tp2 = tj2.Pts[tj2.EndPt[end2]];
           if(tj2.Pts.size() > 50 && tj2.MCSMom > 100) {
             if(end1 == 0) {
               tp2.Ang = tj2.Pts[tj2.EndPt[0] + 2].Ang;
             } else {
               tp2.Ang = tj2.Pts[tj2.EndPt[1] - 2].Ang;
             }
           } else if(loMCSMom) {
             // Low momentum - calculate the angle using the two Pts at the end
             unsigned short pt1, pt2;
             if(end2 == 0) {
               pt1 = tj2.EndPt[0];
               pt2 = pt1 + 1;
             } else {
               pt2 = tj2.EndPt[1];
               pt1 = pt2 - 1;
             }
             TrajPoint tpdir;
             if(MakeBareTrajPoint(slc, tj2.Pts[pt1], tj2.Pts[pt2], tpdir)) tp2.Ang = tpdir.Ang;
           } // low MCSMom
 
           if(!isVLA && !SignalBetween(slc, tp1, tp2, 0.99)) continue;
 
           // decide whether to merge or make a vertex
           // protect against angles > pi/2
           float dang = acos(DotProd(tp1.Dir, tp2.Dir));
           float sep = PosSep(tp1.Pos, tp2.Pos);
           // ignore this pair if the gap between them is much longer than the length of the shortest Tj
           float len1 = TrajLength(slc.tjs[it1]);
           float len2 = TrajLength(slc.tjs[it2]);
           if(len1 < len2 && sep > 3 * len1) continue;
           if(len2 < len1 && sep > 3 * len2) continue;
 
           // default cuts for locMCSMom condition
           float dangCut = 1;
           float docaCut = 2;
           float kinkSig = -1;
           if(!loMCSMom) {
             unsigned short nPtsFit = tcc.kinkCuts[0];
             bool useChg = (tcc.kinkCuts[2] > 0);
             kinkSig = KinkSignificance(slc, tj1, end1, tj2, end2, nPtsFit, useChg, prt);
           }
           docaCut = 1.5;
           if(isVLA) docaCut = 15;
           float chgPull = 0;
           if(tp1.AveChg > tp2.AveChg) {
             chgPull = (tp1.AveChg / tp2.AveChg - 1) / minChgRMS;
           } else {
             chgPull = (tp2.AveChg / tp1.AveChg - 1) / minChgRMS;
           }
           // open up the cuts on the last pass
           float chgFracCut = tcc.vtx2DCuts[8];
           float chgPullCut = tcc.chargeCuts[0];
           if(lastPass) {
             docaCut *= 2;
             chgFracCut *= 0.5;
             chgPullCut *= 1.5;
           }
 
           // check the merge cuts. Start with doca and dang requirements
           bool doMerge = bestDOCA < docaCut && dang < dangCut;
           bool showerTjs = tj1.PDGCode == 11 || tj2.PDGCode == 11;
           bool hiMCSMom = tj1.MCSMom > 200 || tj2.MCSMom > 200;
           // add a charge similarity requirement if not shower-like or low momentum or not LA
           if(doMerge && !showerTjs && hiMCSMom && chgPull > tcc.chargeCuts[0] && !isVLA) doMerge = false;
           // ignore the charge pull cut if both are high momentum and dang is really small
           if(!doMerge && tj1.MCSMom > 900 && tj2.MCSMom > 900 && dang < 0.1 && bestDOCA < docaCut) doMerge = true;
 
           // do not merge if chgPull is really high
           if(doMerge && chgPull > 2 * chgPullCut) doMerge = false;
           float dwc = DeadWireCount(slc, tp1, tp2);
 
           if(doMerge) {
             if(lastPass) {
               // last pass cuts are looser but ensure that the tj after merging meets the quality cut
               float npwc = NumPtsWithCharge(slc, tj1, true) + NumPtsWithCharge(slc, tj2, true);
               auto& tp1OtherEnd = tj1.Pts[tj1.EndPt[1 - end1]];
               auto& tp2OtherEnd = tj2.Pts[tj2.EndPt[1 - end2]];
               float nwires = std::abs(tp1OtherEnd.Pos[0] - tp2OtherEnd.Pos[0]);
               if(nwires == 0) nwires = 1;
               float hitFrac = npwc / nwires;
               doMerge = (hitFrac > tcc.qualityCuts[0]);
             } else {
               // don't merge if the gap between them is longer than the length of the shortest Tj
               if(len1 < len2) {
                 if(sep > len1) doMerge = false;
               } else {
                 if(sep > len2) doMerge = false;
               }
               if(prt) mf::LogVerbatim("TC")<<" merge check sep "<<sep<<" len1 "<<len1<<" len2 "<<len2<<" dead wire count "<<dwc<<" Merge? "<<doMerge;
             } // not lastPass
           } // doMerge
 
           // Require a large charge fraction near a merge point
           tjlist[0] = slc.tjs[it1].ID;
           tjlist[1] = slc.tjs[it2].ID;
           float chgFrac = ChgFracNearPos(slc, tp1.Pos, tjlist);
           if(doMerge && bestDOCA > 1 && chgFrac < chgFracCut) doMerge = false;
 
           // Check the MCSMom asymmetry and don't merge if it is higher than the user-specified cut
           float momAsym = std::abs(tj1.MCSMom - tj2.MCSMom) / (float)(tj1.MCSMom + tj2.MCSMom);
           if(doMerge && momAsym > tcc.vtx2DCuts[9]) doMerge = false;
           if(doMerge && (tj1.EndFlag[end1][kAtKink] || tj2.EndFlag[end2][kAtKink])) {
             // don't merge if a kink exists and the tjs are not too long
             if(len1 < 40 && len2 < 40) doMerge = false;
             // Kink on one + Bragg at other end of the other
             if(tj1.EndFlag[end1][kAtKink] && tj2.EndFlag[1-end2][kBragg]) doMerge = false;
             if(tj1.EndFlag[1-end1][kBragg] && tj2.EndFlag[end2][kAtKink]) doMerge = false;
           }
 
           // decide if we should make a vertex instead
           bool doVtx = false;
           if(!doMerge) {
             // check for a significant kink
             doVtx = (kinkSig > tcc.kinkCuts[1]);
             // and a less significant kink but very close separation
             doVtx = (kinkSig > 0.5 * tcc.kinkCuts[1] && sep < 2);
           } // !doMerge
 
           if(prt) {
             mf::LogVerbatim myprt("TC");
             myprt<<"  EM: T"<<slc.tjs[it1].ID<<"_"<<end1<<" - T"<<slc.tjs[it2].ID<<"_"<<end2<<" tp1-tp2 "<<PrintPos(slc, tp1)<<"-"<<PrintPos(slc, tp2);
             myprt<<" FOM "<<std::fixed<<std::setprecision(2)<<bestFOM;
             myprt<<" DOCA "<<std::setprecision(1)<<bestDOCA;
             myprt<<" cut "<<docaCut<<" isVLA? "<<isVLA;
             myprt<<" dang "<<std::setprecision(2)<<dang<<" dangCut "<<dangCut;
             myprt<<" chgPull "<<std::setprecision(1)<<chgPull<<" Cut "<<chgPullCut;
             myprt<<" chgFrac "<<std::setprecision(2)<<chgFrac;
             myprt<<" momAsym "<<momAsym;
             myprt<<" kinkSig "<<std::setprecision(1)<<kinkSig;
             myprt<<" doMerge? "<<doMerge;
             myprt<<" doVtx? "<<doVtx;
           }
 
           if(bestDOCA > docaCut) continue;
 
           if(doMerge) {
             if(prt) mf::LogVerbatim("TC")<<"  Merge ";
             bool didMerge = false;
             if(end1 == 1) {
               didMerge = MergeAndStore(slc, it1, it2, tcc.dbgMrg);
             } else {
               didMerge = MergeAndStore(slc, it2, it1, tcc.dbgMrg);
             }
             if(didMerge) {
               // Set the end merge flag for the killed trajectories to aid tracing merges
               tj1.AlgMod[kMerge] = true;
               tj2.AlgMod[kMerge] = true;
               iterate = true;
             } // Merge and store successfull
             else {
               if(prt) mf::LogVerbatim("TC")<<"  MergeAndStore failed ";
             }
           } else if(doVtx) {
             // create a vertex instead if it passes the vertex cuts
             VtxStore aVtx;
             aVtx.CTP = slc.tjs[it1].CTP;
             aVtx.ID = slc.vtxs.size() + 1;
             // keep it simple if tp1 and tp2 are very close or if the angle between them
             // is small
             if(prt) {
               mf::LogVerbatim("TC")<<"  candidate 2V"<<aVtx.ID<<" dang "<<dang<<" sep "<<PosSep(tp1.Pos, tp2.Pos);
             }
             bool fix2V = (PosSep(tp1.Pos, tp2.Pos) < 3 || dang < 0.1);
             if(fix2V) {
               aVtx.Pos[0] = 0.5 * (tp1.Pos[0] + tp2.Pos[0]);
               aVtx.Pos[1] = 0.5 * (tp1.Pos[1] + tp2.Pos[1]);
               aVtx.Stat[kFixed] = true;
               aVtx.PosErr[0] = std::abs(tp1.Pos[0] - tp2.Pos[0]);
               aVtx.PosErr[1] = std::abs(tp1.Pos[1] - tp2.Pos[1]);
             } else {
               float sepCut = tcc.vtx2DCuts[1];
               bool tj1Short = (slc.tjs[it1].EndPt[1] - slc.tjs[it1].EndPt[0] < maxShortTjLen);
               bool tj2Short = (slc.tjs[it2].EndPt[1] - slc.tjs[it2].EndPt[0] < maxShortTjLen);
               if(tj1Short || tj2Short) sepCut = tcc.vtx2DCuts[1];
               TrajIntersection(tp1, tp2, aVtx.Pos);
               float dw = aVtx.Pos[0] - tp1.Pos[0];
               if(std::abs(dw) > sepCut) continue;
               float dt = aVtx.Pos[1] - tp1.Pos[1];
               if(std::abs(dt) > sepCut) continue;
               dw = aVtx.Pos[0] - tp2.Pos[0];
               if(std::abs(dw) > sepCut) continue;
               dt = aVtx.Pos[1] - tp2.Pos[1];
               if(std::abs(dt) > sepCut) continue;
               // ensure that the vertex is not closer to the other end if the tj is short
               // but not too short
               if(tj1Short && len1 > 4) {
                 TrajPoint otp1 = slc.tjs[it1].Pts[slc.tjs[it1].EndPt[1-end1]];
                 if(PosSep2(otp1.Pos, aVtx.Pos) < PosSep2(tp1.Pos, aVtx.Pos)) continue;
               }
               if(tj2Short && len2 > 4) {
                 TrajPoint otp2 = slc.tjs[it2].Pts[slc.tjs[it2].EndPt[1-end2]];
                 if(PosSep2(otp2.Pos, aVtx.Pos) < PosSep2(tp2.Pos, aVtx.Pos)) continue;
               }
               // we expect the vertex to be between tp1 and tp2
               if(aVtx.Pos[0] < tp1.Pos[0] && aVtx.Pos[0] < tp2.Pos[0]) {
                 aVtx.Pos[0] = std::min(tp1.Pos[0], tp2.Pos[0]);
                 aVtx.Stat[kFixed] = true;
               }
               if(aVtx.Pos[0] > tp1.Pos[0] && aVtx.Pos[0] > tp2.Pos[0]) {
                 aVtx.Pos[0] = std::max(tp1.Pos[0], tp2.Pos[0]);
                 aVtx.Stat[kFixed] = true;
               }
             } // Tps not so close
             // We got this far. Try a vertex fit to ensure that the errors are reasonable
             slc.tjs[it1].VtxID[end1] = aVtx.ID;
             slc.tjs[it2].VtxID[end2] = aVtx.ID;
             if(!aVtx.Stat[kFixed] && !FitVertex(slc, aVtx, prt)) {
               // back out
               slc.tjs[it1].VtxID[end1] = 0;
               slc.tjs[it2].VtxID[end2] = 0;
               if(prt) mf::LogVerbatim("TC")<<" Vertex fit failed ";
               continue;
             }
             aVtx.NTraj = 2;
             aVtx.Pass = slc.tjs[it1].Pass;
             aVtx.Topo = end1 + end2;
             tj1.AlgMod[kMerge] = true;
             tj2.AlgMod[kMerge] = true;
             if(!StoreVertex(slc, aVtx)) continue;
             SetVx2Score(slc);
             if(prt) {
               auto& newVx = slc.vtxs[slc.vtxs.size() - 1];
               mf::LogVerbatim("TC")<<"  New 2V"<<newVx.ID<<" at "<<(int)newVx.Pos[0]<<":"<<(int)(newVx.Pos[1]/tcc.unitsPerTick)<<" Score "<<newVx.Score;
             }
             // check the score and kill it if it is below the cut
             // BB Oct 1, 2019. Don't kill the vertex in this function since it is
             // called before short trajectories are reconstructed
             auto& newVx2 = slc.vtxs[slc.vtxs.size() - 1];
             if(newVx2.Score < tcc.vtx2DCuts[7] && CompatibleMerge(slc, tj1, tj2, prt)) {
               if(prt) {
                 mf::LogVerbatim myprt("TC");
                 myprt<<"  Bad vertex: Bad score? "<<(newVx2.Score < tcc.vtx2DCuts[7]);
                 myprt<<" cut "<<tcc.vtx2DCuts[7];
                 myprt<<" CompatibleMerge? "<<CompatibleMerge(slc, tj1, tj2, prt);
               }
               slc.tjs[it1].VtxID[end1] = 0;
               slc.tjs[it2].VtxID[end2] = 0;
               MakeVertexObsolete("EM", slc, newVx2, true);
               bool didMerge = false;
               if(end1 == 1) {
                 didMerge = MergeAndStore(slc, it1, it2, tcc.dbgMrg);
               } else {
                 didMerge = MergeAndStore(slc, it2, it1, tcc.dbgMrg);
               }
               if(didMerge) {
                 // Set the end merge flag for the killed trajectories to aid tracing merges
                 tj1.AlgMod[kMerge] = true;
                 tj1.AlgMod[kMerge] = true;
                 iterate = true;
               } // Merge and store successfull
               else {
                 if(prt) mf::LogVerbatim("TC")<<"  MergeAndStore failed ";
               }
             } // OK score
           } // create a vertex
           if(tj1.AlgMod[kKilled]) break;
         } // end1
       } // it1
     } // iterate
 
   } // EndMerge

float tca::ExpectedHitsRMS	(	TCSlice &	slc,
		const TrajPoint &	tp
	)

Definition at line 1945 of file Utils.cxx.

   {
     // 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 * evt.aveHitRMS[planeID.Plane] +
              2 * std::abs(tp.Dir[1] / tp.Dir[0]) / tcc.unitsPerTick;
     }
     else {
       return 500;
     }
   } // ExpectedHitsRMS

unsigned short tca::FarEnd	(	const TCSlice &	slc,
		const PFPStruct &	pfp,
		const Point3_t &	pos
	)

Definition at line 3338 of file PFPUtils.cxx.

   {
     // Returns the end (0 or 1) of the pfp that is furthest away from the position pos
     if (pfp.ID == 0) return 0;
     if (pfp.TP3Ds.empty()) return 0;
     auto& pos0 = pfp.TP3Ds[0].Pos;
     auto& pos1 = pfp.TP3Ds[pfp.TP3Ds.size() - 1].Pos;
     if (PosSep2(pos1, pos) > PosSep2(pos0, pos)) return 1;
     return 0;
   } // FarEnd

unsigned short tca::FarEnd	(	TCSlice &	slc,
		const Trajectory &	tj,
		const Point2_t &	pos
	)

Definition at line 4175 of file Utils.cxx.

   {
     // 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	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		PFPStruct &	pfp
	)

Definition at line 2596 of file PFPUtils.cxx.

   {
     // Fills dE/dx variables in the pfp struct
 
     // don't attempt to find dE/dx at the end of a shower
     unsigned short numEnds = 2;
     if (pfp.PDGCode == 1111) numEnds = 1;
 
     // set dE/dx to 0 to indicate that a valid dE/dx is expected
     for (unsigned short end = 0; end < numEnds; ++end) {
       for (unsigned short plane = 0; plane < slc.nPlanes; ++plane)
         pfp.dEdx[end][plane] = 0;
     } // end
 
     // square of the maximum length that is used for finding the average dE/dx
     float maxSep2 = 5 * tcc.wirePitch;
     maxSep2 *= maxSep2;
 
     for (unsigned short end = 0; end < numEnds; ++end) {
       std::vector<float> cnt(slc.nPlanes);
       short dir = 1 - 2 * end;
       auto endPos = PosAtEnd(pfp, end);
       for (std::size_t ii = 0; ii < pfp.TP3Ds.size(); ++ii) {
         unsigned short ipt;
         if (dir > 0) { ipt = ii; }
         else {
           ipt = pfp.TP3Ds.size() - ii - 1;
         }
         if (ipt >= pfp.TP3Ds.size()) break;
         auto& tp3d = pfp.TP3Ds[ipt];
         if (tp3d.Flags[kTP3DBad]) continue;
         if (PosSep2(tp3d.Pos, endPos) > maxSep2) break;
         // require good points
         if (!tp3d.Flags[kTP3DGood]) continue;
         float dedx = dEdx(clockData, detProp, slc, tp3d);
         if (dedx < 0.5) continue;
         unsigned short plane = DecodeCTP(tp3d.CTP).Plane;
         pfp.dEdx[end][plane] += dedx;
         ++cnt[plane];
       } // ii
       for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
         if (cnt[plane] == 0) continue;
         pfp.dEdx[end][plane] /= cnt[plane];
       } // plane
     }   // end
 
   } // FilldEdx

void tca::FillGaps	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 2031 of file StepUtils.cxx.

   {
     // Fill in any gaps in the trajectory with close hits regardless of charge (well maybe not quite that)
 
     if(!tcc.useAlg[kFillGaps]) return;
     if(tj.AlgMod[kJunkTj]) return;
     if(tj.ChgRMS <= 0) return;
 
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
     if(npwc < 8) return;
 
     // don't consider the last few points since they would be trimmed
     unsigned short toPt = tj.EndPt[1] - 2;
     if(!tj.EndFlag[1][kBragg]) {
       // Don't fill gaps (with high-charge hits) near the end. Find the last point near the
       // end that would have normal charge if all the hit were added
       unsigned short cnt = 0;
       for(unsigned short ipt = tj.EndPt[1] - 2; ipt > tj.EndPt[0]; --ipt) {
         auto& tp = tj.Pts[ipt];
         float chg = tp.Chg;
         if(chg == 0) {
           for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
             unsigned int iht = tp.Hits[ii];
             auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
             chg += hit.Integral();
           }
         } // chg == 0
         float chgPull = (chg / tj.AveChg - 1) / tj.ChgRMS;
         if(chgPull < 2) {
           toPt = ipt;
           break;
         }
         ++cnt;
         if(cnt > 20) break;
       } // ipt
     } // !tj.EndFlag[1][kBragg]
 
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"FG: Check Tj "<<tj.ID<<" from "<<PrintPos(slc, tj.Pts[tj.EndPt[0]])<<" to "<<PrintPos(slc, tj.Pts[toPt]);
 
     // start with the first point that has charge
     short firstPtWithChg = tj.EndPt[0];
     bool first = true;
     float maxDelta = 1;
     // don't let MCSMom suffer too much while filling gaps
     short minMCSMom = 0.7 * tj.MCSMom;
     while(firstPtWithChg < toPt) {
       short nextPtWithChg = firstPtWithChg + 1;
       // find the next point with charge
       for(nextPtWithChg = firstPtWithChg + 1; nextPtWithChg < tj.EndPt[1]; ++nextPtWithChg) {
         if(tj.Pts[nextPtWithChg].Chg > 0) break;
       } // nextPtWithChg
       if(nextPtWithChg == firstPtWithChg + 1) {
         // the next point has charge
         ++firstPtWithChg;
         continue;
       }
       // Found a gap. Require at least two consecutive points with charge after the gap
       if(nextPtWithChg < (tj.EndPt[1] - 1) && tj.Pts[nextPtWithChg + 1].Chg == 0) {
         firstPtWithChg = nextPtWithChg;
         continue;
       }
       // Make a bare trajectory point at firstPtWithChg that points to nextPtWithChg
       TrajPoint tp;
       if(!MakeBareTrajPoint(slc, tj.Pts[firstPtWithChg], tj.Pts[nextPtWithChg], tp)) {
         tj.IsGood = false;
         return;
       }
       // Find the maximum delta between hits and the trajectory Pos for all
       // hits on this trajectory
       if(first) {
         maxDelta = 2.5 * MaxHitDelta(slc, tj);
         first = false;
       } // first
       // define a loose charge cut using the average charge at the first point with charge
       float maxChg = tj.Pts[firstPtWithChg].AveChg * (1 + 2 * tcc.chargeCuts[0] * tj.ChgRMS);
       // Eliminate the charge cut altogether if we are close to an end
       if(tj.Pts.size() < 10) {
         maxChg = 1E6;
       } else {
         short chgCutPt = tj.EndPt[0] + 5;
         if(firstPtWithChg < chgCutPt) {
           // gap is near end 0
           maxChg = 1E6;
         } else {
           // check for gap near end 1
           chgCutPt = tj.EndPt[1] - 5;
           if(chgCutPt < tj.EndPt[0]) chgCutPt = tj.EndPt[0];
           if(nextPtWithChg > chgCutPt) maxChg = 1E6;
         }
       }
 
       // fill in the gap
       for(unsigned short mpt = firstPtWithChg + 1; mpt < nextPtWithChg; ++mpt) {
         if(tj.Pts[mpt].Chg > 0) {
           mf::LogVerbatim("TC")<<"FillGaps coding error: firstPtWithChg "<<firstPtWithChg<<" mpt "<<mpt<<" nextPtWithChg "<<nextPtWithChg;
           slc.isValid = false;
           return;
         }
         bool filled = false;
         float chg = 0;
         for(unsigned short ii = 0; ii < tj.Pts[mpt].Hits.size(); ++ii) {
           unsigned int iht = tj.Pts[mpt].Hits[ii];
           if(slc.slHits[iht].InTraj > 0) continue;
           auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
           float delta = PointTrajDOCA(slc, iht, tp);
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<" FG: "<<PrintPos(slc,tj.Pts[mpt])<<" hit "<<PrintHit(slc.slHits[iht])<<" delta "<<delta<<" maxDelta "<<maxDelta<<" Chg "<<hit.Integral()<<" maxChg "<<maxChg;
           if(delta > maxDelta) continue;
           tj.Pts[mpt].UseHit[ii] = true;
           slc.slHits[iht].InTraj = tj.ID;
           chg += hit.Integral();
           filled = true;
         } // ii
         if(chg > maxChg || MCSMom(slc, tj) < minMCSMom) {
           // don't use these hits after all
           UnsetUsedHits(slc, tj.Pts[mpt]);
           filled = false;
         }
         if(filled) {
           DefineHitPos(slc, tj.Pts[mpt]);
           tj.AlgMod[kFillGaps] = true;
           if(tcc.dbgStp) {
             PrintTP("FG", slc, mpt, tj.StepDir, tj.Pass, tj.Pts[mpt]);
             mf::LogVerbatim("TC")<<"Check MCSMom "<<MCSMom(slc, tj);
           }
         } // filled
       } // mpt
       firstPtWithChg = nextPtWithChg;
     } // firstPtWithChg
 
     if(tj.AlgMod[kFillGaps]) tj.MCSMom = MCSMom(slc, tj);
 
   } // FillGaps

void tca::FillGaps3D	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 1744 of file PFPUtils.cxx.

   {
     // Look for gaps in each plane in the TP3Ds vector in planes in which
     // the projection of the pfp angle is large (~> 60 degrees). Hits
     // reconstructed at large angles are poorly reconstructed which results
     // in poorly reconstructed 2D trajectories
 
     if (pfp.ID <= 0) return;
     if (pfp.TP3Ds.empty()) return;
     if (pfp.SectionFits.empty()) return;
     if (!tcc.useAlg[kFillGaps3D]) return;
     if (pfp.Flags[kJunk3D]) return;
     if (pfp.Flags[kSmallAngle]) return;
 
     // Only print APIR details if MVI is set
     bool foundMVI = (tcc.dbgPFP && pfp.MVI == debug.MVI);
 
     // make a copy in case something goes wrong
     auto pWork = pfp;
 
     unsigned short nPtsAdded = 0;
     unsigned short fromPt = 0;
     unsigned short toPt = pWork.TP3Ds.size();
     for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
       CTP_t inCTP = EncodeCTP(pWork.TPCID.Cryostat, pWork.TPCID.TPC, plane);
       unsigned short nWires, nAdd;
       AddPointsInRange(clockData,
                        detProp,
                        slc,
                        pWork,
                        fromPt,
                        toPt,
                        inCTP,
                        tcc.match3DCuts[4],
                        nWires,
                        nAdd,
                        foundMVI);
       if (pWork.Flags[kNeedsUpdate]) Update(clockData, detProp, slc, pWork, prt);
       nPtsAdded += nAdd;
     } // plane
     if (prt) mf::LogVerbatim("TC") << "FG3D P" << pWork.ID << " added " << nPtsAdded << " points";
     if (pWork.Flags[kNeedsUpdate] && !Update(clockData, detProp, slc, pWork, prt)) return;
     pfp = pWork;
     return;
   } // FillGaps3D

void tca::FillmAllTraj	(	detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc
	)

Definition at line 2381 of file PFPUtils.cxx.

   {
     // Fills the mallTraj vector with trajectory points in the tpc and sorts
     // them by increasing X
 
     int cstat = slc.TPCID.Cryostat;
     int tpc = slc.TPCID.TPC;
 
     // define mallTraj
     slc.mallTraj.clear();
     Tj2Pt tj2pt;
     unsigned short cnt = 0;
 
     // try to reduce CPU time by not attempting to match tjs that are near muons
     bool muFuzzCut = (tcc.match3DCuts.size() > 6 && tcc.match3DCuts[6] > 0);
 
     float rms = tcc.match3DCuts[0];
     for (auto& tj : slc.tjs) {
       if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) continue;
       // ignore already matched
       if (tj.AlgMod[kMat3D]) continue;
       geo::PlaneID planeID = DecodeCTP(tj.CTP);
       if ((int)planeID.Cryostat != cstat) continue;
       if ((int)planeID.TPC != tpc) continue;
       int plane = planeID.Plane;
       if (tj.ID <= 0) continue;
       unsigned short tjID = tj.ID;
       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;
         // ignore already matched
         if (tp.InPFP > 0) continue;
         if (muFuzzCut && tp.Environment[kEnvNearMuon]) continue;
         tj2pt.wire = std::nearbyint(tp.Pos[0]);
         ++cnt;
         // don't try matching if the wire doesn't exist
         if (!tcc.geom->HasWire(geo::WireID(cstat, tpc, plane, tj2pt.wire))) continue;
         float xpos = detProp.ConvertTicksToX(tp.Pos[1] / tcc.unitsPerTick, plane, tpc, cstat);
         tj2pt.xlo = xpos - rms;
         tj2pt.xhi = xpos + rms;
         tj2pt.plane = plane;
         tj2pt.id = tjID;
         tj2pt.ipt = ipt;
         tj2pt.npts = tj.EndPt[1] - tj.EndPt[0] + 1;
         slc.mallTraj.push_back(tj2pt);
       } // tp
     }   // tj
 
     // sort by increasing x
     std::vector<SortEntry> sortVec(slc.mallTraj.size());
     for (std::size_t ipt = 0; ipt < slc.mallTraj.size(); ++ipt) {
       // populate the sort vector
       sortVec[ipt].index = ipt;
       sortVec[ipt].val = slc.mallTraj[ipt].xlo;
     } // ipt
     // sort by increasing xlo
     std::sort(sortVec.begin(), sortVec.end(), valsIncreasing);
     // put slc.mallTraj into sorted order
     auto tallTraj = slc.mallTraj;
     for (std::size_t ii = 0; ii < sortVec.size(); ++ii)
       slc.mallTraj[ii] = tallTraj[sortVec[ii].index];
 
   } // FillmAllTraj

void tca::FillWireHitRange ( geo::TPCID inTPCID )

Definition at line 4459 of file Utils.cxx.

   {
     // Defines the local vector of dead wires and the low-high range of hits in each wire in
     // the TPCID in TCEvent. Note that there is no requirement that the allHits collection is sorted. Care should
     // be taken when looping over hits using this range - see SignalAtTp
 
     // see if this function was called in the current TPCID. There is nothing that needs to
     // be done if that is the case
     if (inTPCID == evt.TPCID) return;
 
     evt.TPCID = inTPCID;
     unsigned short nplanes = tcc.geom->Nplanes(inTPCID);
     unsigned int cstat = inTPCID.Cryostat;
     unsigned int tpc = inTPCID.TPC;
     if (tcc.useChannelStatus) {
       lariov::ChannelStatusProvider const& channelStatus =
         art::ServiceHandle<lariov::ChannelStatusService>()->GetProvider();
       evt.goodWire.resize(nplanes);
       for (unsigned short pln = 0; pln < nplanes; ++pln) {
         unsigned int nwires = tcc.geom->Nwires(pln, tpc, cstat);
         // set all wires dead
         evt.goodWire[pln].resize(nwires, false);
         for (unsigned int wire = 0; wire < nwires; ++wire) {
           raw::ChannelID_t chan =
             tcc.geom->PlaneWireToChannel((int)pln, (int)wire, (int)tpc, (int)cstat);
           evt.goodWire[pln][wire] = channelStatus.IsGood(chan);
         } // wire
       }   // pln
     }
     else {
       // resize and set every channel good
       evt.goodWire.resize(nplanes);
       for (unsigned short pln = 0; pln < nplanes; ++pln) {
         unsigned int nwires = tcc.geom->Nwires(pln, tpc, cstat);
         evt.goodWire[pln].resize(nwires, true);
       } // pln
     }   // don't use channelStatus
 
     // there is no need to define evt.wireHitRange if the hit collection is not sliced. The function
     // SignalAtTP will then use the (smaller) slc.WireHitRange instead of evt.wireHitRange
     if (!evt.expectSlicedHits) return;
 
     // define the size of evt.wireHitRange
     evt.wireHitRange.resize(nplanes);
     for (unsigned short pln = 0; pln < nplanes; ++pln) {
       unsigned int nwires = tcc.geom->Nwires(pln, tpc, cstat);
       evt.wireHitRange[pln].resize(nwires);
       for (unsigned int wire = 0; wire < nwires; ++wire)
         evt.wireHitRange[pln][wire] = {UINT_MAX, UINT_MAX};
     } // pln
 
     // next define the wireHitRange values. Make one loop through the allHits collection
     unsigned int nBadWireFix = 0;
     for (unsigned int iht = 0; iht < (*evt.allHits).size(); ++iht) {
       auto& hit = (*evt.allHits)[iht];
       auto wid = hit.WireID();
       if (wid.Cryostat != cstat) continue;
       if (wid.TPC != tpc) continue;
       unsigned short pln = wid.Plane;
       unsigned int wire = wid.Wire;
       // Check the goodWire status and correct it if it's wrong
       if (!evt.goodWire[pln][wire]) {
         evt.goodWire[pln][wire] = true;
         ++nBadWireFix;
       } // not goodWire
       if (evt.wireHitRange[pln][wire].first == UINT_MAX) evt.wireHitRange[pln][wire].first = iht;
       evt.wireHitRange[pln][wire].second = iht;
     } // iht
     if (nBadWireFix > 0 && tcc.modes[kDebug]) {
       std::cout << "FillWireHitRange found hits on " << nBadWireFix
                 << " wires that were declared not-good by the ChannelStatus service. Fixed it...\n";
     }
   } // FillWireHitRange

bool tca::FillWireHitRange	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc
	)

Definition at line 4535 of file Utils.cxx.

   {
     // 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
     unsigned int cstat = slc.TPCID.Cryostat;
     unsigned int tpc = slc.TPCID.TPC;
     unsigned short nplanes = tcc.geom->Nplanes(tpc, cstat);
     slc.nPlanes = nplanes;
     if (nplanes > 3) return false;
 
     // Y,Z limits of the detector
     double local[3] = {0., 0., 0.};
     double world[3] = {0., 0., 0.};
     const geo::TPCGeo& thetpc = tcc.geom->TPC(tpc, cstat);
     thetpc.LocalToWorld(local, world);
     // reduce the active area of the TPC by 1 cm to prevent wire boundary issues
     slc.xLo = world[0] - tcc.geom->DetHalfWidth(tpc, cstat) + 1;
     slc.xHi = world[0] + tcc.geom->DetHalfWidth(tpc, cstat) - 1;
     slc.yLo = world[1] - tcc.geom->DetHalfHeight(tpc, cstat) + 1;
     slc.yHi = world[1] + tcc.geom->DetHalfHeight(tpc, cstat) - 1;
     slc.zLo = world[2] - tcc.geom->DetLength(tpc, cstat) / 2 + 1;
     slc.zHi = world[2] + tcc.geom->DetLength(tpc, cstat) / 2 - 1;
 
     // initialize everything
     slc.wireHitRange.resize(nplanes);
     slc.firstWire.resize(nplanes);
     slc.lastWire.resize(nplanes);
     slc.nWires.resize(nplanes);
     tcc.maxPos0.resize(nplanes);
     tcc.maxPos1.resize(nplanes);
     evt.aveHitRMS.resize(nplanes, nplanes);
 
     std::pair<unsigned int, unsigned int> flag;
     flag.first = UINT_MAX;
     flag.second = UINT_MAX;
 
     // Calculate tcc.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 = tcc.geom->PlaneWireToChannel(0, 0, (int)tpc, (int)cstat);
     tcc.wirePitch = tcc.geom->WirePitch(tcc.geom->View(channel));
     float tickToDist = detProp.DriftVelocity(detProp.Efield(), detProp.Temperature());
     tickToDist *= 1.e-3 * sampling_rate(clockData); // 1e-3 is conversion of 1/us to 1/ns
     tcc.unitsPerTick = tickToDist / tcc.wirePitch;
     for (unsigned short plane = 0; plane < nplanes; ++plane) {
       slc.firstWire[plane] = UINT_MAX;
       slc.lastWire[plane] = 0;
       slc.nWires[plane] = tcc.geom->Nwires(plane, tpc, cstat);
       slc.wireHitRange[plane].resize(slc.nWires[plane], flag);
       tcc.maxPos0[plane] = (float)slc.nWires[plane] - 0.5;
       tcc.maxPos1[plane] = (float)detProp.NumberTimeSamples() * tcc.unitsPerTick;
     }
 
     unsigned int lastWire = 0, lastPlane = 0;
     for (unsigned int iht = 0; iht < slc.slHits.size(); ++iht) {
       unsigned int ahi = slc.slHits[iht].allHitsIndex;
       if (ahi > (*evt.allHits).size() - 1) return false;
       auto& hit = (*evt.allHits)[ahi];
       if (hit.WireID().Cryostat != cstat) continue;
       if (hit.WireID().TPC != tpc) continue;
       unsigned short plane = hit.WireID().Plane;
       unsigned int wire = hit.WireID().Wire;
       if (wire > slc.nWires[plane] - 1) {
         mf::LogWarning("TC") << "FillWireHitRange: Invalid wire number " << wire << " > "
                              << slc.nWires[plane] - 1 << " in plane " << plane << " Quitting";
         return false;
       } // too large wire number
       if (plane == lastPlane && wire < lastWire) {
         mf::LogWarning("TC")
           << "FillWireHitRange: Hits are not in increasing wire order. Quitting ";
         return false;
       } // hits out of order
       lastWire = wire;
       lastPlane = plane;
       if (slc.firstWire[plane] == UINT_MAX) slc.firstWire[plane] = wire;
       if (slc.wireHitRange[plane][wire].first == UINT_MAX)
         slc.wireHitRange[plane][wire].first = iht;
       slc.wireHitRange[plane][wire].second = iht;
       slc.lastWire[plane] = wire + 1;
     } // iht
     // check
     unsigned int slhitsSize = slc.slHits.size();
     for (unsigned short plane = 0; plane < nplanes; ++plane) {
       for (unsigned int wire = slc.firstWire[plane]; wire < slc.lastWire[plane]; ++wire) {
         if (slc.wireHitRange[plane][wire].first == UINT_MAX) continue;
         if (slc.wireHitRange[plane][wire].first > slhitsSize - 1 &&
             slc.wireHitRange[plane][wire].second > slhitsSize)
           return false;
       } // wire
     }   // plane
 
     // Find the average multiplicity 1 hit RMS and calculate the expected max RMS for each range
     if (tcc.modes[kDebug] && (int)tpc == debug.TPC) {
       // Note that this function is called before the slice is pushed into slices so the index
       // isn't decremented by 1
       std::cout << "Slice ID/Index " << slc.ID << "/" << slices.size() << " tpc " << tpc
                 << " tcc.unitsPerTick " << std::setprecision(3) << tcc.unitsPerTick;
       std::cout << " Active volume (";
       std::cout << std::fixed << std::setprecision(1) << slc.xLo << " < X < " << slc.xHi << ") (";
       std::cout << std::fixed << std::setprecision(1) << slc.yLo << " < Y < " << slc.yHi << ") (";
       std::cout << std::fixed << std::setprecision(1) << slc.zLo << " < Z < " << slc.zHi << ")\n";
     }
 
     return true;
 
   } // FillWireHitRange

void tca::FillWireIntersections ( TCSlice & slc )

Definition at line 611 of file PFPUtils.cxx.

   {
     // Find wire intersections and put them in evt.wireIntersections
 
     // see if anything needs to be done
     if (!evt.wireIntersections.empty() && evt.wireIntersections[0].tpc == slc.TPCID.TPC) return;
 
     evt.wireIntersections.clear();
 
     unsigned int cstat = slc.TPCID.Cryostat;
     unsigned int tpc = slc.TPCID.TPC;
     // find the minMax number of wires in each plane of the TPC
     unsigned int maxWire = slc.nWires[0];
     for (auto nw : slc.nWires)
       if (nw < maxWire) maxWire = nw;
     // Start looking for intersections in the middle
     unsigned int firstWire = maxWire / 2;
 
     // find a valid wire intersection in all plane combinations
     std::vector<std::pair<unsigned short, unsigned short>> pln1pln2;
     for (unsigned short pln1 = 0; pln1 < slc.nPlanes - 1; ++pln1) {
       for (unsigned short pln2 = pln1 + 1; pln2 < slc.nPlanes; ++pln2) {
         auto p1p2 = std::make_pair(pln1, pln2);
         if (std::find(pln1pln2.begin(), pln1pln2.end(), p1p2) != pln1pln2.end()) continue;
         // find two wires that have a valid intersection
         for (unsigned int wire = firstWire; wire < maxWire; ++wire) {
           double y00, z00;
           if (!tcc.geom->IntersectionPoint(wire, wire, pln1, pln2, cstat, tpc, y00, z00)) continue;
           // increment by one wire in pln1 and find another valid intersection
           double y10, z10;
           if (!tcc.geom->IntersectionPoint(wire + 10, wire, pln1, pln2, cstat, tpc, y10, z10))
             continue;
           // increment by one wire in pln2 and find another valid intersection
           double y01, z01;
           if (!tcc.geom->IntersectionPoint(wire, wire + 10, pln1, pln2, cstat, tpc, y01, z01))
             continue;
           TCWireIntersection tcwi;
           tcwi.tpc = tpc;
           tcwi.pln1 = pln1;
           tcwi.pln2 = pln2;
           tcwi.wir1 = wire;
           tcwi.wir2 = wire;
           tcwi.y = y00;
           tcwi.z = z00;
           tcwi.dydw1 = (y10 - y00) / 10;
           tcwi.dzdw1 = (z10 - z00) / 10;
           tcwi.dydw2 = (y01 - y00) / 10;
           tcwi.dzdw2 = (z01 - z00) / 10;
           evt.wireIntersections.push_back(tcwi);
           break;
         } // wire
       }   // pln2
     }     // pln1
   }       // FillWireIntersections

void tca::Find2DVertices	(	detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc,
		const CTP_t &	inCTP,
		unsigned short	pass
	)

Definition at line 146 of file TCVertex.cxx.

   {
     // 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.
 
     // tcc.vtx2DCuts 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
     // 10 Require charge on wires between a vtx and the start of the tjs in induction planes? (1 = yes)
 
     if (tcc.vtx2DCuts[0] <= 0) return;
     if (slc.tjs.size() < 2) return;
 
     bool firstPassCuts = (pass == 0);
 
     geo::PlaneID planeID = DecodeCTP(inCTP);
 
     // require charge between the vertex and the tj start points?
     bool requireVtxTjChg = true;
     if (tcc.vtx2DCuts[10] == 0 && int(planeID.Plane) < slc.nPlanes - 1) requireVtxTjChg = false;
 
     bool prt = (tcc.dbg2V && tcc.dbgSlc && debug.Plane == (int)planeID.Plane);
     if (prt) {
       mf::LogVerbatim("TC") << "prt set for CTP " << inCTP << " in Find2DVertices. firstPassCuts? "
                             << firstPassCuts << " requireVtxTjChg " << requireVtxTjChg;
       PrintAllTraj(detProp, "F2DVi", slc, USHRT_MAX, slc.tjs.size());
     }
 
     unsigned short maxShortTjLen = tcc.vtx2DCuts[0];
     for (unsigned short it1 = 0; it1 < slc.tjs.size() - 1; ++it1) {
       auto& tj1 = slc.tjs[it1];
       if (tj1.AlgMod[kKilled] || tj1.AlgMod[kHaloTj]) 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;
         // wrong end of a high energy electron?
         if (tj1.PDGCode == 111 && end1 != tj1.StartEnd) 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(slc, 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 < slc.tjs.size(); ++it2) {
           auto& tj2 = slc.tjs[it2];
           if (tj2.AlgMod[kKilled] || tj2.AlgMod[kHaloTj]) continue;
           if (tj2.SSID > 0 || tj2.AlgMod[kShowerLike]) continue;
           if (tj2.CTP != inCTP) continue;
           if (tj1.VtxID[end1] > 0) continue;
           if (tj1.MCSMom < tcc.vtx2DCuts[5] && tj2.MCSMom < tcc.vtx2DCuts[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;
           // wrong end of a high energy electron?
           if (tj2.PDGCode == 111 && end2 != tj2.StartEnd) 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(slc, 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 > tcc.maxPos0[planeID.Plane] - 3) continue;
           if (tint < 0 || tint > tcc.maxPos1[planeID.Plane]) continue;
           // Next cut on separation between the TPs and the intersection point
           if (tj1Short || tj2Short) { sepCut = tcc.vtx2DCuts[1]; }
           else {
             sepCut = tcc.vtx2DCuts[2];
           }
           // NewVtxCuts: require close separation on the first pass
           if (firstPassCuts) sepCut = tcc.vtx2DCuts[1];
           Point2_t vPos{{wint, tint}};
           float vt1Sep = PosSep(vPos, tp1.Pos);
           float vt2Sep = PosSep(vPos, tp2.Pos);
           float dwc1 = DeadWireCount(slc, wint, tp1.Pos[0], tp1.CTP);
           float dwc2 = DeadWireCount(slc, wint, tp2.Pos[0], tp1.CTP);
           vt1Sep -= dwc1;
           vt2Sep -= dwc2;
           bool vtxOnDeadWire = (DeadWireCount(slc, 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 / tcc.unitsPerTick) << " tp1 "
                   << PrintPos(slc, tp1) << " tp2 " << PrintPos(slc, 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, slc.tjs[it1].Pts[oendPt1].Pos) < vt1Sep) {
             if (prt)
               mf::LogVerbatim("TC") << " tj1 other end " << PrintPos(slc, tj1.Pts[oendPt1])
                                     << " is closer to the vertex";
             continue;
           }
           if (PosSep(vPos, slc.tjs[it2].Pts[oendPt2].Pos) < vt2Sep) {
             if (prt)
               mf::LogVerbatim("TC") << " tj2 other end " << PrintPos(slc, 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 stepDir = -1;
           if (tcc.modes[kStepDir]) stepDir = 1;
           short dpt1 = stepDir * (closePt1 - endPt1);
           if (prt)
             mf::LogVerbatim("TC") << " endPt1 " << endPt1 << " closePt1 " << closePt1 << " dpt1 "
                                   << dpt1 << " doca1 " << doca1;
           if (dpt1 < -1) continue;
           if (slc.tjs[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 = stepDir * (closePt2 - endPt2);
           if (prt)
             mf::LogVerbatim("TC") << " endPt2 " << endPt2 << " closePt2 " << closePt2 << " dpt2 "
                                   << dpt2 << " doca2 " << doca2;
           if (dpt2 < -1) continue;
           if (slc.tjs[it2].EndPt[1] > 4) {
             if (dpt2 > 3) continue;
           }
           else {
             // tighter cut for short trajectories
             if (dpt2 > 2) continue;
           }
           bool fixVxPos = false;
           // fix the vertex position if there is a charge kink here
           if (tj1.EndFlag[end1][kAtKink]) fixVxPos = true;
           if (prt)
             mf::LogVerbatim("TC") << " wint:tint " << (int)wint << ":"
                                   << (int)(tint / tcc.unitsPerTick) << " fixVxPos? " << fixVxPos;
           if (requireVtxTjChg) {
             // ensure that there is a signal between these TPs and the vertex on most of the wires
             bool signalBetween = true;
             short dpt = abs(wint - tp1.Pos[0]);
             if (dpt > 2 && !SignalBetween(slc, tp1, wint, tcc.vtx2DCuts[6])) {
               if (prt) mf::LogVerbatim("TC") << " Fails SignalBetween for tp1 " << dpt;
               signalBetween = false;
             }
             dpt = abs(wint - tp2.Pos[0]);
             if (dpt > 2 && !SignalBetween(slc, tp2, wint, tcc.vtx2DCuts[6])) {
               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(slc, tj1, tj2, ipt1, ipt2, maxSep, false);
               // require that they are close at the correct end
               if (isClose) isClose = (abs(ipt1 - endPt1) < 4 && abs(ipt2 - endPt2) < 4);
               if (isClose) {
                 if (prt)
                   mf::LogVerbatim("TC")
                     << " TrajTrajDOCA are close with minSep " << maxSep << " near "
                     << PrintPos(slc, tj1.Pts[ipt1].Pos) << " " << PrintPos(slc, tj2.Pts[ipt2].Pos);
                 // 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 / tcc.unitsPerTick);
               }
               else {
                 // closest approach > 3
                 continue;
               }
             } // no signal between
           }   // requireVtxTjChg
           // 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;
           aVtx.Stat[kVxIndPlnNoChg] = !requireVtxTjChg;
           // try to fit it. We need to give it an ID to do that. Take the next
           // available ID
           unsigned short newVtxID = slc.vtxs.size() + 1;
           aVtx.ID = newVtxID;
           tj1.VtxID[end1] = newVtxID;
           tj2.VtxID[end2] = newVtxID;
           if (!FitVertex(slc, aVtx, prt)) {
             tj1.VtxID[end1] = 0;
             tj2.VtxID[end2] = 0;
             continue;
           }
           // check proximity to nearby vertices
           unsigned short mergeMeWithVx = IsCloseToVertex(slc, aVtx);
           if (mergeMeWithVx > 0 && MergeWithVertex(slc, aVtx, mergeMeWithVx)) {
             if (prt) mf::LogVerbatim("TC") << " Merged with close vertex " << mergeMeWithVx;
             continue;
           }
           // Save it
           if (!StoreVertex(slc, 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] / tcc.unitsPerTick;
           }
           AttachAnyTrajToVertex(slc, slc.vtxs.size() - 1, prt);
           SetVx2Score(slc);
         } // it2
       }   // end1
     }     // it1
 
     // only call these on the last pass
     if (pass == USHRT_MAX) {
       FindHammerVertices(slc, inCTP);
       FindHammerVertices2(slc, inCTP);
     }
 
     if (prt) PrintAllTraj(detProp, "F2DVo", slc, USHRT_MAX, USHRT_MAX);
 
   } // Find2DVertices

unsigned short tca::Find3DRecoRange	(	const TCSlice &	slc,
		const PFPStruct &	pfp,
		unsigned short	fromPt,
		unsigned short	min2DPts,
		short	dir
	)

Definition at line 1358 of file PFPUtils.cxx.

   {
     // Scans the TP3Ds vector starting at fromPt until it finds min2DPts in two planes. It returns
     // with the index of that point (+1) in the TP3Ds vector. The dir variable defines the scan direction in
     // the TP3Ds vector
     if (fromPt > pfp.TP3Ds.size() - 1) return USHRT_MAX;
     if (pfp.TP3Ds.size() < 2 * min2DPts) return USHRT_MAX;
     if (dir == 0) return USHRT_MAX;
 
     std::vector<unsigned short> cntInPln(slc.nPlanes);
     for (std::size_t ii = 0; ii < pfp.TP3Ds.size(); ++ii) {
       unsigned short ipt = fromPt + ii;
       if (dir < 0) ipt = fromPt - ii;
       if (ipt >= pfp.TP3Ds.size()) break;
       auto& tp3d = pfp.TP3Ds[ipt];
       if (!tp3d.Flags[kTP3DGood]) continue;
       unsigned short plane = DecodeCTP(slc.tjs[tp3d.TjID - 1].CTP).Plane;
       ++cntInPln[plane];
       unsigned short enufInPlane = 0;
       for (unsigned short plane = 0; plane < slc.nPlanes; ++plane)
         if (cntInPln[plane] >= min2DPts) ++enufInPlane;
       if (enufInPlane > 1) return ipt + 1;
       if (dir < 0 && ipt == 0) break;
     } // ipt
     return USHRT_MAX;
   } // Find3DRecoRange

void tca::Find3DVertices	(	detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc
	)

Definition at line 1282 of file TCVertex.cxx.

   {
     // 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 (tcc.vtx3DCuts[0] < 0) return;
     if (slc.vtxs.size() < 2) return;
 
     // 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 < slc.vtxs.size(); ++ivx) {
       // obsolete vertex
       if (slc.vtxs[ivx].ID == 0) continue;
       geo::PlaneID planeID = DecodeCTP(slc.vtxs[ivx].CTP);
       if (planeID.TPC != slc.TPCID.TPC) 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 < slc.nPlanes; ++plane)
       if (vIndex[plane].size() > 0) ++vtxInPln;
     if (vtxInPln < 2) return;
 
     float thirdPlanedXCut = 2 * tcc.vtx3DCuts[0];
     bool prt = (tcc.dbg3V && tcc.dbgSlc);
     if (prt) {
       mf::LogVerbatim("TC") << "Inside Find3DVertices. dX cut " << tcc.vtx3DCuts[0]
                             << " thirdPlanedXCut " << thirdPlanedXCut;
     }
 
     size_t vsize = slc.vtxs.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, FLT_MAX);
 
     for (unsigned short ivx = 0; ivx < vsize; ++ivx) {
       if (slc.vtxs[ivx].ID <= 0) continue;
       if (slc.vtxs[ivx].Score < tcc.vtx2DCuts[7]) continue;
       if (slc.vtxs[ivx].Pos[0] < -0.4) continue;
       geo::PlaneID planeID = DecodeCTP(slc.vtxs[ivx].CTP);
       // Convert 2D vertex time error to X error
       double ticks = slc.vtxs[ivx].Pos[1] / tcc.unitsPerTick;
       vX[ivx] = detProp.ConvertTicksToX(ticks, planeID);
     } // ivx
 
     // temp vector of all 2D vertex matches
     std::vector<Vtx3Store> v3temp;
 
     unsigned int cstat = slc.TPCID.Cryostat;
     unsigned int tpc = slc.TPCID.TPC;
 
     TrajPoint tp;
     constexpr float maxSep = 4;
     float maxScore = 0;
     // 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] == FLT_MAX) continue;
         auto& ivx2 = slc.vtxs[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] == FLT_MAX) continue;
             auto& jvx2 = slc.vtxs[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 > tcc.vtx3DCuts[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;
             tcc.geom->IntersectionPoint(iWire, jWire, ipl, jpl, cstat, tpc, y, z);
             if (y < slc.yLo || y > slc.yHi || z < slc.zLo || z > slc.zHi) continue;
             unsigned short kpl = 3 - ipl - jpl;
             float kX = 0.5 * (vX[ivx] + vX[jvx]);
             int kWire = -1;
             if (slc.nPlanes > 2) {
               kWire = tcc.geom->WireCoordinate(y, z, kpl, tpc, cstat);
               std::array<int, 2> wireWindow;
               std::array<float, 2> timeWindow;
               wireWindow[0] = kWire - maxSep;
               wireWindow[1] = kWire + maxSep;
               float time =
                 detProp.ConvertXToTicks(kX, kpl, (int)tpc, (int)cstat) * tcc.unitsPerTick;
               timeWindow[0] = time - maxSep;
               timeWindow[1] = time + maxSep;
               bool hitsNear;
               std::vector<unsigned int> closeHits =
                 FindCloseHits(slc, wireWindow, timeWindow, kpl, kAllHits, true, hitsNear);
               if (prt) {
                 mf::LogVerbatim myprt("TC");
                 myprt << " Hits near " << kpl << ":" << kWire << ":"
                       << (int)(time / tcc.unitsPerTick) << " = ";
                 for (auto iht : closeHits)
                   myprt << " " << PrintHit(slc.slHits[iht]);
               }
               if (!hitsNear) continue;
             } // 3-plane TPC
             // save this incomplete 3D vertex
             Vtx3Store v3d;
             // give it a non-zero ID so that SetVx3Score returns a valid score
             v3d.ID = 666;
             v3d.Vx2ID.resize(slc.nPlanes);
             v3d.Vx2ID[ipl] = ivx2.ID;
             v3d.Vx2ID[jpl] = jvx2.ID;
             if (slc.nPlanes == 2) v3d.Vx2ID[2] = -1;
             v3d.X = kX;
             // Use XErr to store dX
             v3d.XErr = dX;
             v3d.Y = y;
             v3d.Z = z;
             v3d.Wire = kWire;
             float posError = dX / tcc.vtx3DCuts[0];
             float vxScoreWght = 0;
             SetVx3Score(slc, v3d);
             vxScoreWght = tcc.vtx3DCuts[2] / v3d.Score;
             if (posError < 0.5) posError = 0;
             v3d.Score = posError + vxScoreWght;
             v3d.TPCID = slc.TPCID;
             // push the incomplete vertex onto the list
             v3temp.push_back(v3d);
 
             if (prt) {
               mf::LogVerbatim myprt("TC");
               myprt << "  2 Plane match i2V";
               myprt << slc.vtxs[ivx].ID << " P:W:T " << ipl << ":" << (int)slc.vtxs[ivx].Pos[0]
                     << ":" << (int)slc.vtxs[ivx].Pos[1];
               myprt << " j2V" << slc.vtxs[jvx].ID << " P:W:T " << jpl << ":"
                     << (int)slc.vtxs[jvx].Pos[0] << ":" << (int)slc.vtxs[jvx].Pos[1];
               myprt << std::fixed << std::setprecision(3);
               myprt << " dX " << dX << " posError " << posError << " vxScoreWght " << vxScoreWght
                     << " Score " << v3d.Score;
             }
 
             if (slc.nPlanes == 2) continue;
 
             // look for a 3 plane match
             for (unsigned short kk = 0; kk < vIndex[kpl].size(); ++kk) {
               unsigned short kvx = vIndex[kpl][kk];
               float dX = std::abs(vX[kvx] - v3d.X);
               // Wire difference error
               float dW = tcc.wirePitch * std::abs(slc.vtxs[kvx].Pos[0] - kWire);
               if (dX > thirdPlanedXCut) continue;
               if (dW > tcc.vtx3DCuts[1]) continue;
               // put the Y,Z difference in YErr and ZErr
               double y = -1000, z = -1000;
               tcc.geom->IntersectionPoint(iWire, kWire, ipl, kpl, cstat, tpc, y, z);
               v3d.YErr = y - v3d.Y;
               v3d.ZErr = z - v3d.Z;
               v3d.Vx2ID[kpl] = slc.vtxs[kvx].ID;
               v3d.Wire = -1;
               // hijack the Score variable to hold the separation^2, weighted by the
               // vertex3DCuts
               dX = (vX[kvx] - v3d.X) / tcc.vtx3DCuts[0];
               float dY = v3d.YErr / tcc.vtx3DCuts[1];
               float dZ = v3d.ZErr / tcc.vtx3DCuts[1];
               posError = dX * dX + dY * dY + dZ * dZ;
               vxScoreWght = 0;
               SetVx3Score(slc, v3d);
               vxScoreWght = tcc.vtx3DCuts[2] / v3d.Score;
               if (posError < 0.5) posError = 0;
               v3d.Score = posError + vxScoreWght;
               if (v3d.Score > maxScore) maxScore = v3d.Score;
               if (prt)
                 mf::LogVerbatim("TC") << "    k2V" << kvx + 1 << " dX " << dX << " dW " << dW
                                       << " 3D score " << 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) {
         if (slc.nPlanes == 2) {
           mf::LogVerbatim("TC") << "2V" << v3.Vx2ID[0] << " 2V" << v3.Vx2ID[1] << " wire "
                                 << v3.Wire << " Score " << v3.Score;
         }
         else {
           mf::LogVerbatim("TC") << "2V" << v3.Vx2ID[0] << " 2V" << v3.Vx2ID[1] << " 2V"
                                 << v3.Vx2ID[2] << " wire " << v3.Wire << " Score " << 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 < slc.nPlanes; ++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 myprt("TC");
       myprt << "v3sel list\n";
       for (auto& v3d : v3sel) {
         for (auto vx2id : v3d.Vx2ID)
           if (vx2id > 0) myprt << " 2V" << vx2id;
         myprt << " wire " << v3d.Wire << " Score " << v3d.Score;
         myprt << "\n";
       } // v3d
     }   // prt
 
     // Count the number of incomplete vertices and store
     unsigned short ninc = 0;
     for (auto& vx3 : v3sel) {
       if (slc.nPlanes == 3 && vx3.Wire >= 0) ++ninc;
       vx3.ID = slc.vtx3s.size() + 1;
       ++evt.global3V_UID;
       vx3.UID = evt.global3V_UID;
       if (prt) {
         mf::LogVerbatim myprt("TC");
         myprt << " 3V" << vx3.ID;
         for (auto v2id : vx3.Vx2ID)
           myprt << " 2V" << v2id;
         myprt << " wire " << vx3.Wire;
       } // prt
       slc.vtx3s.push_back(vx3);
       // make the 2D -> 3D associations
       for (unsigned short ipl = 0; ipl < slc.nPlanes; ++ipl) {
         if (vx3.Vx2ID[ipl] == 0) continue;
         VtxStore& vx2 = slc.vtxs[vx3.Vx2ID[ipl] - 1];
         vx2.Vx3ID = vx3.ID;
       } // ipl
     }   // ivx
 
     // Try to complete incomplete vertices
     if (ninc > 0) {
       CompleteIncomplete3DVerticesInGaps(detProp, slc);
       CompleteIncomplete3DVertices(detProp, slc);
     }
 
     // Score and flag Tjs that are attached to high-score vertices
     // First remove Tj vertex flags
     for (auto& tj : slc.tjs) {
       if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) 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 : slc.vtxs) {
       if (vx2.ID == 0) continue;
       geo::PlaneID planeID = DecodeCTP(vx2.CTP);
       if (planeID.TPC != tpc || planeID.Cryostat != cstat) continue;
       SetVx2Score(slc, vx2);
     } // vx2
     // and the 3D vertices
     for (auto& vx3 : slc.vtx3s) {
       if (vx3.ID == 0) continue;
       SetVx3Score(slc, vx3);
     } // vx3
 
   } // Find3DVertices

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

Definition at line 3096 of file PFPUtils.cxx.

   {
     // 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) costh = 1;
     double sep = PosSep(pos1, pos2);
     alongTrans[0] = costh * sep;
     double sinth = sqrt(1 - costh * costh);
     alongTrans[1] = sinth * sep;
   } // FindAlongTrans

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

Definition at line 3358 of file Utils.cxx.

   {
     // 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

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

Definition at line 2841 of file Utils.cxx.

   {
     // 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 > slc.firstWire.size() - 1) return closeHits;
     // window in the wire coordinate
     int loWire = wireWindow[0];
     if (loWire < (int)slc.firstWire[plane]) loWire = slc.firstWire[plane];
     int hiWire = wireWindow[1];
     if (hiWire > (int)slc.lastWire[plane] - 1) hiWire = slc.lastWire[plane] - 1;
     // window in the time coordinate
     float minTick = timeWindow[0] / tcc.unitsPerTick;
     float maxTick = timeWindow[1] / tcc.unitsPerTick;
     for (int wire = loWire; wire <= hiWire; ++wire) {
       // Set hitsNear if the wire is dead
       if (!evt.goodWire[plane][wire]) hitsNear = true;
       if (slc.wireHitRange[plane][wire].first == UINT_MAX) continue;
       unsigned int firstHit = slc.wireHitRange[plane][wire].first;
       unsigned int lastHit = slc.wireHitRange[plane][wire].second;
       for (unsigned int iht = firstHit; iht <= lastHit; ++iht) {
         auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
         if (usePeakTime) {
           if (hit.PeakTime() < minTick) continue;
           if (hit.PeakTime() > maxTick) break;
         }
         else {
           int hiLo = minTick;
           if (hit.StartTick() > hiLo) hiLo = hit.StartTick();
           int loHi = maxTick;
           if (hit.EndTick() < loHi) loHi = hit.EndTick();
           if (loHi < hiLo) continue;
           if (hiLo > loHi) break;
         }
         hitsNear = true;
         bool takeit = (hitRequest == kAllHits);
         if (hitRequest == kUsedHits && slc.slHits[iht].InTraj > 0) takeit = true;
         if (hitRequest == kUnusedHits && slc.slHits[iht].InTraj == 0) takeit = true;
         if (takeit) closeHits.push_back(iht);
       } // iht
     }   // wire
     return closeHits;
   } // FindCloseHits

bool tca::FindCloseHits	(	TCSlice &	slc,
		TrajPoint &	tp,
		float const &	maxDelta,
		HitStatus_t	hitRequest
	)

Definition at line 2905 of file Utils.cxx.

   {
     // 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();
     tp.Environment.reset();
     if (!WireHitRangeOK(slc, tp.CTP)) { return false; }
 
     if (tp.Pos[0] < -0.4) return false;
     unsigned short plane = DecodeCTP(tp.CTP).Plane;
     unsigned int wire = std::nearbyint(tp.Pos[0]);
     if (wire < slc.firstWire[plane]) return false;
     if (wire > slc.lastWire[plane] - 1) return false;
 
     // dead wire
     if (!evt.goodWire[plane][wire]) {
       tp.Environment[kEnvNotGoodWire] = true;
       return true;
     }
     tp.Environment[kEnvNotGoodWire] = false;
     // live wire with no hits
     if (slc.wireHitRange[plane][wire].first == UINT_MAX) return false;
 
     unsigned int firstHit = slc.wireHitRange[plane][wire].first;
     unsigned int lastHit = slc.wireHitRange[plane][wire].second;
 
     float fwire = wire;
     for (unsigned int iht = firstHit; iht <= lastHit; ++iht) {
       if ((unsigned int)slc.slHits[iht].InTraj > slc.tjs.size()) continue;
       bool useit = (hitRequest == kAllHits);
       if (hitRequest == kUsedHits && slc.slHits[iht].InTraj > 0) useit = true;
       if (hitRequest == kUnusedHits && slc.slHits[iht].InTraj == 0) useit = true;
       if (!useit) continue;
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       float ftime = tcc.unitsPerTick * hit.PeakTime();
       float delta = PointTrajDOCA(slc, 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 (!tp.Hits.empty());
 
   } // FindCloseHits

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

Definition at line 2975 of file Utils.cxx.

   {
     // 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(slc, 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(slc, 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);
     }
 
     unsigned short plane = DecodeCTP(tp.CTP).Plane;
 
     if (firstWire < slc.firstWire[plane]) firstWire = slc.firstWire[plane];
     if (firstWire > slc.lastWire[plane] - 1) return tmp;
     if (lastWire < slc.firstWire[plane]) return tmp;
     if (lastWire > slc.lastWire[plane] - 1) lastWire = slc.lastWire[plane] - 1;
 
     for (unsigned int wire = firstWire; wire <= lastWire; ++wire) {
       if (slc.wireHitRange[plane][wire].first == UINT_MAX) continue;
       MoveTPToWire(tp, (float)wire);
       // Find the tick range at this position
       float minTick = (tp.Pos[1] - maxDelta) / tcc.unitsPerTick;
       float maxTick = (tp.Pos[1] + maxDelta) / tcc.unitsPerTick;
       unsigned int firstHit = slc.wireHitRange[plane][wire].first;
       unsigned int lastHit = slc.wireHitRange[plane][wire].second;
       for (unsigned int iht = firstHit; iht <= lastHit; ++iht) {
         if (slc.slHits[iht].InTraj <= 0) continue;
         if ((unsigned int)slc.slHits[iht].InTraj > slc.tjs.size()) continue;
         auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
         if (hit.PeakTime() < minTick) continue;
         // Hits are sorted by increasing time so we can break when maxTick is reached
         if (hit.PeakTime() > maxTick) break;
         if (std::find(tmp.begin(), tmp.end(), slc.slHits[iht].InTraj) != tmp.end()) continue;
         tmp.push_back(slc.slHits[iht].InTraj);
       } // iht
     }   // wire
 
     return tmp;
 
   } // FindCloseTjs

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

void tca::FindHammerVertices	(	TCSlice &	slc,
		const CTP_t &	inCTP
	)

Definition at line 811 of file TCVertex.cxx.

   {
     // 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 (!tcc.useAlg[kHamVx]) return;
 
     bool prt = (tcc.modes[kDebug] && tcc.dbgSlc && tcc.dbgAlg[kHamVx]);
     if (prt) { mf::LogVerbatim("TC") << "Inside HamVx inCTP " << inCTP; }
 
     for (unsigned short it1 = 0; it1 < slc.tjs.size(); ++it1) {
       if (slc.tjs[it1].CTP != inCTP) continue;
       if (slc.tjs[it1].AlgMod[kKilled] || slc.tjs[it1].AlgMod[kHaloTj]) continue;
       if (slc.tjs[it1].AlgMod[kShowerLike]) continue;
       if (slc.tjs[it1].AlgMod[kJunkTj]) continue;
       if (slc.tjs[it1].PDGCode == 111) continue;
       // minimum length requirements
       unsigned short tj1len = slc.tjs[it1].EndPt[1] - slc.tjs[it1].EndPt[0] + 1;
       if (tj1len < 5) continue;
       // require high MCSMom
       if (slc.tjs[it1].MCSMom < 50) continue;
       if (prt) mf::LogVerbatim("TC") << "FHV: intersection T" << slc.tjs[it1].ID << " candidate";
       // Check each end of tj1
       bool didaSplit = false;
       for (unsigned short end1 = 0; end1 < 2; ++end1) {
         // vertex assignment exists?
         if (slc.tjs[it1].VtxID[end1] > 0) continue;
         unsigned short endPt1 = slc.tjs[it1].EndPt[end1];
         for (unsigned short it2 = 0; it2 < slc.tjs.size(); ++it2) {
           if (slc.tjs[it2].CTP != inCTP) continue;
           if (it1 == it2) continue;
           if (slc.tjs[it2].AlgMod[kKilled] || slc.tjs[it2].AlgMod[kHaloTj]) continue;
           if (slc.tjs[it2].AlgMod[kJunkTj]) continue;
           if (slc.tjs[it2].PDGCode == 111) continue;
           // length of tj2 cut
           unsigned short tj2len = slc.tjs[it2].EndPt[1] - slc.tjs[it2].EndPt[0] + 1;
           if (tj2len < 6) continue;
           // ignore very long straight trajectories (probably a cosmic muon)
           if (tj2len > 200 && slc.tjs[it2].PDGCode == 13 && slc.tjs[it2].MCSMom > 600) continue;
           float minDOCA = 5;
           minDOCA /= std::abs(slc.tjs[it1].Pts[endPt1].Dir[0]);
           float doca = minDOCA;
           unsigned short closePt2 = 0;
           TrajPointTrajDOCA(slc, slc.tjs[it1].Pts[endPt1], slc.tjs[it2], closePt2, doca);
           if (doca == minDOCA) continue;
           // ensure that the closest point is not near an end
           if (prt)
             mf::LogVerbatim("TC") << "FHV: Candidate T" << slc.tjs[it1].ID << " T"
                                   << slc.tjs[it2].ID << " doca " << doca << " tj2.EndPt[0] "
                                   << slc.tjs[it2].EndPt[0] << " closePt2 " << closePt2
                                   << " tj2.EndPt[1] " << slc.tjs[it2].EndPt[1];
           if (closePt2 < slc.tjs[it2].EndPt[0] + 3) continue;
           if (closePt2 > slc.tjs[it2].EndPt[1] - 3) continue;
           // make an angle cut
           float dang = DeltaAngle(slc.tjs[it1].Pts[endPt1].Ang, slc.tjs[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;
           // check the cleanliness in this area
           std::vector<int> tjids(2);
           tjids[0] = slc.tjs[it1].ID;
           tjids[1] = slc.tjs[it2].ID;
           float chgFrac = ChgFracNearPos(slc, slc.tjs[it2].Pts[closePt2].Pos, tjids);
           if (prt) mf::LogVerbatim("TC") << " chgFrac " << chgFrac;
           if (chgFrac < 0.9) continue;
           Point2_t vxpos = slc.tjs[it2].Pts[closePt2].Pos;
           // get a better estimate of the vertex position
           TrajIntersection(
             slc.tjs[it1].Pts[endPt1], slc.tjs[it2].Pts[closePt2], vxpos[0], vxpos[1]);
           // and a better estimate of the point on tj2 where the split should be made
           doca = minDOCA;
           TrajClosestApproach(slc.tjs[it2], vxpos[0], vxpos[1], closePt2, doca);
           if (prt)
             mf::LogVerbatim("TC") << " better pos " << PrintPos(slc, vxpos) << " new closePt2 "
                                   << closePt2;
           // create a new vertex
           VtxStore aVtx;
           aVtx.Pos = vxpos;
           aVtx.NTraj = 3;
           aVtx.Pass = slc.tjs[it2].Pass;
           aVtx.Topo = 5;
           aVtx.ChiDOF = 0;
           aVtx.CTP = inCTP;
           aVtx.ID = slc.vtxs.size() + 1;
           if (!StoreVertex(slc, aVtx)) continue;
           unsigned short ivx = slc.vtxs.size() - 1;
           if (!SplitTraj(slc, it2, closePt2, ivx, prt)) {
             if (prt) mf::LogVerbatim("TC") << "FHV: Failed to split trajectory";
             MakeVertexObsolete("HamVx", slc, slc.vtxs[slc.vtxs.size() - 1], true);
             continue;
           }
           slc.tjs[it1].VtxID[end1] = slc.vtxs[ivx].ID;
           slc.tjs[it1].AlgMod[kHamVx] = true;
           slc.tjs[it2].AlgMod[kHamVx] = true;
           unsigned short newTjIndex = slc.tjs.size() - 1;
           slc.tjs[newTjIndex].AlgMod[kHamVx] = true;
           SetVx2Score(slc);
           // Update the PDGCode for the chopped trajectory
           SetPDGCode(slc, it2);
           // and for the new trajectory
           SetPDGCode(slc, newTjIndex);
           if (prt) {
             auto& vx2 = slc.vtxs[ivx];
             mf::LogVerbatim myprt("TC");
             myprt << " new 2V" << vx2.ID << " Score " << vx2.Score << " Tjs";
             auto tjlist = GetAssns(slc, "2V", vx2.ID, "T");
             for (auto tid : tjlist)
               myprt << " t" << tid;
           }
           didaSplit = true;
           break;
         } // tj2
         if (didaSplit) break;
       } // end1
     }   // tj1
 
   } // FindHammerVertices

void tca::FindHammerVertices2	(	TCSlice &	slc,
		const CTP_t &	inCTP
	)

Definition at line 618 of file TCVertex.cxx.

   {
     // 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 (!tcc.useAlg[kHamVx2]) return;
     // This wasn't written for test beam events
     if (tcc.modes[kTestBeam]) return;
 
     bool prt = (tcc.modes[kDebug] && tcc.dbgSlc && tcc.dbgAlg[kHamVx2]);
     if (prt) mf::LogVerbatim("TC") << "Inside HamVx2";
 
     for (unsigned short it1 = 0; it1 < slc.tjs.size(); ++it1) {
       if (slc.tjs[it1].CTP != inCTP) continue;
       if (slc.tjs[it1].AlgMod[kKilled] || slc.tjs[it1].AlgMod[kHaloTj]) continue;
       if (slc.tjs[it1].AlgMod[kHamVx]) continue;
       if (slc.tjs[it1].AlgMod[kHamVx2]) continue;
       if (slc.tjs[it1].AlgMod[kJunkTj]) continue;
       if (slc.tjs[it1].PDGCode == 111) continue;
       unsigned short numPtsWithCharge1 = NumPtsWithCharge(slc, slc.tjs[it1], false);
       if (numPtsWithCharge1 < 6) continue;
       // require high MCSMom
       if (slc.tjs[it1].MCSMom < 200) continue;
       // Check each end of tj1
       bool didaSplit = false;
       for (unsigned short end1 = 0; end1 < 2; ++end1) {
         // vertex assignment exists?
         if (slc.tjs[it1].VtxID[end1] > 0) continue;
         unsigned short endPt1 = slc.tjs[it1].EndPt[end1];
         for (unsigned short it2 = 0; it2 < slc.tjs.size(); ++it2) {
           if (it1 == it2) continue;
           if (slc.tjs[it2].AlgMod[kKilled] || slc.tjs[it2].AlgMod[kHaloTj]) continue;
           if (slc.tjs[it2].AlgMod[kHamVx]) continue;
           if (slc.tjs[it2].AlgMod[kHamVx2]) continue;
           // require that both be in the same CTP
           if (slc.tjs[it2].CTP != inCTP) continue;
           if (slc.tjs[it2].AlgMod[kShowerLike]) continue;
           if (slc.tjs[it2].AlgMod[kJunkTj]) continue;
           if (slc.tjs[it2].PDGCode == 111) continue;
           unsigned short numPtsWithCharge2 = NumPtsWithCharge(slc, slc.tjs[it2], true);
           if (numPtsWithCharge2 < 6) continue;
           // ignore muon-like tjs
           if (numPtsWithCharge2 > 100 && slc.tjs[it2].MCSMom > 500) continue;
           // Find the minimum separation between tj1 and tj2
           float minDOCA = 5;
           float doca = minDOCA;
           unsigned short closePt2 = 0;
           TrajPointTrajDOCA(slc, slc.tjs[it1].Pts[endPt1], slc.tjs[it2], closePt2, doca);
           if (doca == minDOCA) continue;
           if (prt) {
             mf::LogVerbatim myprt("TC");
             auto& tj1 = slc.tjs[it1];
             auto& tj2 = slc.tjs[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 < slc.tjs[it2].EndPt[0] + 3) continue;
           if (closePt2 > slc.tjs[it2].EndPt[1] - 3) continue;
           // Find the intersection point between the tj1 end and tj2 closest Pt
           float wint, tint;
           TrajIntersection(slc.tjs[it1].Pts[endPt1], slc.tjs[it2].Pts[closePt2], wint, tint);
           // make an angle cut
           float dang = DeltaAngle(slc.tjs[it1].Pts[endPt1].Ang, slc.tjs[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(slc, slc.tjs[it2].Pts[closePt2], slc.tjs[it1], closePt1, doca);
           if (closePt1 != endPt1) continue;
           if (prt)
             mf::LogVerbatim("TC") << " intersection W:T " << (int)wint << ":"
                                   << (int)(tint / tcc.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(slc.tjs[it2], wint, tint, intPt2, doca);
           if (prt)
             mf::LogVerbatim("TC") << " intPt2 on tj2 " << intPt2 << " at Pos "
                                   << PrintPos(slc, slc.tjs[it2].Pts[intPt2]) << " doca " << doca;
           if (doca == minDOCA) continue;
           // find the MCSMom for both sections of tj2
           float mcsmom = slc.tjs[it2].MCSMom;
           float mcsmom1 = MCSMom(slc, slc.tjs[it2], slc.tjs[it2].EndPt[0], intPt2);
           float mcsmom2 = MCSMom(slc, slc.tjs[it2], intPt2, slc.tjs[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 = slc.tjs[it2].Pts[ipt].Chg;
           if (prt)
             mf::LogVerbatim("TC") << " ipt " << ipt << " at Pos "
                                   << PrintPos(slc, slc.tjs[it2].Pts[ipt]) << " chg " << mostChg;
           while (nit < 20) {
             ipt += dir;
             if (ipt < 3 || ipt > slc.tjs[it2].Pts.size() - 4) break;
             float delta = PointTrajDOCA(slc,
                                         slc.tjs[it2].Pts[ipt].Pos[0],
                                         slc.tjs[it2].Pts[ipt].Pos[1],
                                         slc.tjs[it1].Pts[endPt1]);
             float sep = PosSep(slc.tjs[it2].Pts[ipt].Pos, slc.tjs[it1].Pts[endPt1].Pos);
             float dang = delta / sep;
             float pull = dang / slc.tjs[it1].Pts[endPt1].DeltaRMS;
             if (pull < 2 && slc.tjs[it2].Pts[ipt].Chg > mostChg) {
               mostChg = slc.tjs[it2].Pts[ipt].Chg;
               intPt2 = ipt;
             }
           }
           // require a lot of charge in tj2 in this vicinity compared with the average.
           float chgPull = (mostChg - slc.tjs[it2].AveChg) / slc.tjs[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 = slc.tjs[it1].Pts[endPt1];
           if (slc.tjs[it1].Pts[endPt1].Pos[0] < -0.4) continue;
           unsigned int fromWire = std::nearbyint(slc.tjs[it1].Pts[endPt1].Pos[0]);
           if (slc.tjs[it2].Pts[intPt2].Pos[0] < -0.4) continue;
           unsigned int toWire = std::nearbyint(slc.tjs[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(ltp)) {
               skipIt = true;
               break;
             }
           } // wire
           if (skipIt) continue;
           // we have a winner
           // create a new vertex
           VtxStore aVtx;
           aVtx.Pos = slc.tjs[it2].Pts[intPt2].Pos;
           aVtx.NTraj = 3;
           aVtx.Pass = slc.tjs[it2].Pass;
           aVtx.Topo = 6;
           aVtx.ChiDOF = 0;
           aVtx.CTP = inCTP;
           aVtx.ID = slc.vtxs.size() + 1;
           unsigned short ivx = slc.vtxs.size();
           if (!StoreVertex(slc, aVtx)) continue;
           if (!SplitTraj(slc, it2, intPt2, ivx, prt)) {
             if (prt) mf::LogVerbatim("TC") << "FHV2: Failed to split trajectory";
             MakeVertexObsolete("HamVx2", slc, slc.vtxs[ivx], true);
             continue;
           }
           slc.tjs[it1].VtxID[end1] = slc.vtxs[ivx].ID;
           slc.tjs[it1].AlgMod[kHamVx2] = true;
           slc.tjs[it2].AlgMod[kHamVx2] = true;
           unsigned short newTjIndex = slc.tjs.size() - 1;
           slc.tjs[newTjIndex].AlgMod[kHamVx2] = true;
           AttachAnyTrajToVertex(slc, ivx, prt);
           SetVx2Score(slc);
           // Update the PDGCode for the chopped trajectory
           SetPDGCode(slc, it2);
           // and for the new trajectory
           SetPDGCode(slc, newTjIndex);
           if (prt)
             mf::LogVerbatim("TC") << " FHV2: New vtx 2V" << slc.vtxs[ivx].ID << " Score "
                                   << slc.vtxs[ivx].Score;
           didaSplit = true;
           break;
         } // it2
         if (didaSplit) break;
       } // end1
     }   // it1
   }     // FindHammerVertices2

void tca::FindNearbyTjs	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3378 of file TCShower.cxx.

   {
     // 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 = slc.tjs[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 : slc.vtxs) {
       if (vx.CTP != ss.CTP) continue;
       if (vx.ID == 0) continue;
       if (!PointInsideEnvelope(vx.Pos, ss.Envelope)) continue;
       auto vxTjIDs = GetAssns(slc, "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 : slc.tjs) {
       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(slc, 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(slc, 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

bool tca::FindParent	(	detinfo::DetectorPropertiesData const &	detProp,
		std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 1575 of file TCShower.cxx.

   {
     // 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 (!tcc.showerParentReader) return false;
     if (tcc.showerParentVars.size() != 9) return false;
     if (!tcc.useAlg[kShwrParent]) return false;
 
     std::string fcnLabel = inFcnLabel + ".FPar";
     int truPFP = 0;
 
     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(slc.pfps.size() + 1, false);
     for (auto& oldSS3 : slc.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(slc, "3S", ss3.ID, "T");
     if (TjsInSS3.empty()) return false;
 
     for (auto& pfp : slc.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(slc, 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 = slc.tjs[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(slc, pfp, ss3.ChgPos);
       auto pos = PosAtEnd(pfp, pEnd);
       auto pToS = PointDirection(pos, ss3.ChgPos);
       double costh1 = std::abs(DotProd(pToS, ss3.Dir));
       if (costh1 < 0.4) continue;
       auto dir = DirAtEnd(pfp, pEnd);
       float costh2 = DotProd(pToS, dir);
       // distance^2 between the pfp end and the shower start, charge center, and shower end
       float distToStart2 = PosSep2(pos, ss3.Start);
       float distToChgPos2 = PosSep2(pos, ss3.ChgPos);
       float distToEnd2 = PosSep2(pos, 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, pos, 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 < slc.nPlanes; ++plane) {
         CTP_t inCTP = EncodeCTP(ss3.TPCID.Cryostat, ss3.TPCID.TPC, plane);
         int ssid = 0;
         for (auto cid : ss3.CotIDs) {
           auto& ss = slc.cots[cid - 1];
           if (ss.CTP != inCTP) continue;
           ssid = ss.ID;
           break;
         } // cid
         if (ssid == 0) continue;
         auto tpFrom = MakeBareTP(detProp, slc, pos, pToS, inCTP);
         auto& ss = slc.cots[ssid - 1];
         auto& stp1 = slc.tjs[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(slc, tpFrom, toPos);
         // weight by the separation in the plane
         totSep += sep;
         chgFrac += sep * cf;
       } // plane
       if (totSep > 0) chgFrac /= totSep;
       // load the MVA variables
       tcc.showerParentVars[0] = energy;
       tcc.showerParentVars[1] = pfpEnergy;
       tcc.showerParentVars[2] = MCSMom(slc, pfp.TjIDs);
       auto startPos = PosAtEnd(pfp, 0);
       auto endPos = PosAtEnd(pfp, 1);
       tcc.showerParentVars[3] = PosSep(startPos, endPos);
       tcc.showerParentVars[4] = sqrt(distToChgPos2);
       tcc.showerParentVars[5] = acos(costh1);
       tcc.showerParentVars[6] = acos(costh2);
       tcc.showerParentVars[7] = chgFrac;
       tcc.showerParentVars[8] = prob;
       float candParFOM = tcc.showerParentReader->EvaluateMVA("BDT");
 
       if (prt) {
         mf::LogVerbatim myprt("TC");
         myprt << fcnLabel;
         myprt << " 3S" << ss3.ID << "_" << shEnd;
         myprt << " P" << pfp.ID << "_" << pEnd << " ParentVars";
         for (auto var : tcc.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 += slc.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] = slc.cots[ss3.CotIDs[ii] - 1];
     }
 
     ss3.ParentID = bestPFP;
     auto& pfp = slc.pfps[bestPFP - 1];
     unsigned short pend = FarEnd(slc, pfp, ss3.ChgPos);
     ss3.Vx3ID = pfp.Vx3ID[pend];
 
     if (SetParent(detProp, fcnLabel, slc, pfp, ss3, prt) && UpdateShower(fcnLabel, slc, 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];
       slc.cots[ss.ID - 1] = ss;
     } // ii
     return false;
 
   } // FindParent

void tca::FindPFParticles	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc
	)

Definition at line 190 of file PFPUtils.cxx.

   {
     // Match Tjs in 3D and create PFParticles
 
     if (tcc.match3DCuts[0] <= 0) return;
 
     FillWireIntersections(slc);
 
     // clear the TP -> P assn Tjs so that all are considered
     for (auto& tj : slc.tjs) {
       for (auto& tp : tj.Pts)
         tp.InPFP = 0;
     } // tj
 
     bool prt = (tcc.dbgPFP && tcc.dbgSlc);
 
     // Match these points in 3D
     std::vector<MatchStruct> matVec;
 
     // iterate twice (at most), looking for 3-plane matches in long tjs in 3-plane TPCs on the
     // first iteration, 3-plane matches in short tjs on the second iteration.
     // and 2-plane matches + dead regions in 3-plane TPCs on the last iteration
     slc.mallTraj.clear();
 
     unsigned short maxNit = 2;
     if (slc.nPlanes == 2) maxNit = 1;
     if (std::nearbyint(tcc.match3DCuts[2]) == 0) maxNit = 1;
     // fill the mAllTraj vector with TPs if we aren't using SpacePoints
     if (evt.sptHits.empty()) FillmAllTraj(detProp, slc);
     for (unsigned short nit = 0; nit < maxNit; ++nit) {
       matVec.clear();
       if (slc.nPlanes == 3 && nit == 0) {
         // look for match triplets
         Match3Planes(slc, matVec);
       }
       else {
         // look for match doublets requiring a dead region in the 3rd plane for 3-plane TPCs
         Match2Planes(slc, matVec);
       }
       if (matVec.empty()) continue;
       if (prt) {
         mf::LogVerbatim myprt("TC");
         myprt << "nit " << nit << " MVI  Count  Tjs\n";
         for (unsigned int indx = 0; indx < matVec.size(); ++indx) {
           auto& ms = matVec[indx];
           myprt << std::setw(5) << indx << std::setw(6) << (int)ms.Count;
           for (auto tid : ms.TjIDs)
             myprt << " T" << tid;
           // count the number of TPs in all Tjs
           float tpCnt = 0;
           for (auto tid : ms.TjIDs) {
             auto& tj = slc.tjs[tid - 1];
             tpCnt += NumPtsWithCharge(slc, tj, false);
           } // tid
           float frac = ms.Count / tpCnt;
           myprt << " matFrac " << std::fixed << std::setprecision(3) << frac;
           myprt << "\n";
         } // indx
       }   // prt
       MakePFParticles(clockData, detProp, slc, matVec, nit);
     } // nit
 
     // a last debug print
     if (tcc.dbgPFP && debug.MVI != UINT_MAX) {
       for (auto& pfp : slc.pfps)
         if (tcc.dbgPFP && pfp.MVI == debug.MVI)
           PrintTP3Ds(clockData, detProp, "FPFP", slc, pfp, -1);
     } // last debug print
 
     slc.mallTraj.resize(0);
 
   } // FindPFParticles

bool tca::FindShowers3D	(	detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc
	)

Definition at line 287 of file TCShower.cxx.

   {
     // Find 2D showers using 3D-matched trajectories. This returns true if showers were found
     // which requires re-doing the 3D trajectory match
 
     bool reconstruct = (tcc.showerTag[0] == 2) || (tcc.showerTag[0] == 4);
     if (!reconstruct) return false;
 
     bool prt2S = (tcc.dbgSlc && tcc.dbg2S);
     bool prt3S = (tcc.dbgSlc && tcc.dbg3S);
 
     std::string fcnLabel = "FS";
 
     geo::TPCGeo const& TPC = tcc.geom->TPC(slc.TPCID);
     // check for already-existing showers
     for (unsigned short plane = 0; plane < TPC.Nplanes(); ++plane) {
       CTP_t inCTP = EncodeCTP(slc.TPCID.Cryostat, slc.TPCID.TPC, plane);
       for (auto& ss : slc.cots)
         if (ss.CTP == inCTP) return false;
     }
 
     if (prt2S) {
       PrintPFPs("FSi", slc);
       PrintAllTraj(detProp, "FSi", slc, USHRT_MAX, 0);
     }
 
     // lists of Tj IDs in plane, (list1, list2, list3, ...)
     std::vector<std::vector<std::vector<int>>> bigList(slc.nPlanes);
     for (unsigned short plane = 0; plane < TPC.Nplanes(); ++plane) {
       std::vector<std::vector<int>> tjList;
       // Make lists of lists of ShowerLike tjs that will become showers
       //      FindCots(fcnLabel, slc, inCTP, tjList, prt2S);
       SaveTjInfo(slc, 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(slc.TPCID.Cryostat, slc.TPCID.TPC, plane);
       // print detailed debug info for one plane
       bool prtCTP = (prt2S && inCTP == debug.CTP);
       // Create a shower for each one
       for (auto& tjl : bigList[plane]) {
         if (tjl.empty()) continue;
         if (prtCTP) {
           mf::LogVerbatim myprt("TC");
           myprt << "Plane " << plane << " tjList";
           for (auto& tjID : tjl)
             myprt << " " << tjID;
         }
         auto ss = CreateSS(slc, tjl);
         if (ss.ID == 0) continue;
         if (!UpdateShower(fcnLabel, slc, ss, prtCTP)) continue;
         SaveTjInfo(slc, ss, "DS");
         FindNearbyTjs(fcnLabel, slc, ss, prtCTP);
         // don't try to do anything else here until all of the showers are defined
         if (!StoreShower(fcnLabel, slc, ss)) MakeShowerObsolete(fcnLabel, slc, ss, prtCTP);
       } // tjl
       ChkAssns(fcnLabel, slc);
       // try to merge showers in this plane using the lists of nearby Tjs
       if (inCTP == UINT_MAX) continue;
       if (slc.cots.empty()) continue;
       if (prtCTP) Print2DShowers("tjl", slc, inCTP, false);
       MergeShowerChain(fcnLabel, slc, inCTP, prtCTP);
       SaveAllCots(slc, inCTP, "MSC");
       if (prtCTP) Print2DShowers("MSCo", slc, inCTP, false);
       MergeOverlap(fcnLabel, slc, inCTP, prtCTP);
       SaveAllCots(slc, inCTP, "MO");
       if (prtCTP) Print2DShowers("MO", slc, inCTP, false);
       MergeNearby2DShowers(fcnLabel, slc, inCTP, prtCTP);
       SaveAllCots(slc, inCTP, "MSS");
       // merge sub-showers with other showers
       MergeSubShowers(fcnLabel, slc, inCTP, prtCTP);
       // merge sub-showers with shower-like tjs
       MergeSubShowersTj(fcnLabel, slc, inCTP, prtCTP);
       SaveAllCots(slc, inCTP, "MNrby");
       if (prtCTP) Print2DShowers("Nrby", slc, inCTP, false);
       bool tryMerge = false;
       for (unsigned short ii = 0; ii < slc.cots.size(); ++ii) {
         auto& ss = slc.cots[ii];
         if (ss.ID == 0) continue;
         if (ss.CTP != inCTP) continue;
         if (AddTjsInsideEnvelope(fcnLabel, slc, ss, prtCTP)) tryMerge = true;
         if (tcc.modes[kSaveShowerTree]) SaveAllCots(slc, inCTP, "Merge");
       }
       if (tryMerge) MergeNearby2DShowers(fcnLabel, slc, inCTP, prtCTP);
       SaveAllCots(slc, inCTP, "ATj2");
       if (prtCTP) Print2DShowers("ATIE", slc, inCTP, false);
     } // plane
     if (slc.cots.empty()) return false;
     if (prt3S) Print2DShowers("B4", slc, USHRT_MAX, false);
     // Match in 3D, make 3D showers and define them
     //    Match2DShowers(fcnLabel, slc, prt3S);
     SaveAllCots(slc, "M2DS");
     // Reconcile pfp and shower assns before the Parent search
     Reconcile3D(fcnLabel, slc, false, prt3S);
     SaveAllCots(slc, "R3D");
     for (auto& ss3 : slc.showers) {
       if (ss3.ID == 0) continue;
       FindParent(detProp, fcnLabel, slc, ss3, prt3S);
     } // ss3
     // Reconcile pfp and shower assns again
     Reconcile3D(fcnLabel, slc, true, prt3S);
     if (prt3S) Print2DShowers("M2DS", slc, USHRT_MAX, false);
     SaveAllCots(slc, "FP");
 
     // kill low energy 3D showers
     for (auto& ss3 : slc.showers) {
       if (ss3.ID == 0) continue;
       bool killMe = (ShowerEnergy(ss3) < tcc.showerTag[3]);
       if (killMe) MakeShowerObsolete(fcnLabel, slc, ss3, prt3S);
     } // ss3
 
     // kill 2D showers that are either below threshold or have only one tj
     for (auto& ss : slc.cots) {
       if (ss.ID == 0) continue;
       if (ss.SS3ID > 0) continue;
       bool killMe = (ss.TjIDs.size() == 1 || ss.Energy < tcc.showerTag[3]);
       // too small aspect ratio -> something track-like with some shower-like fuzz
       if (ss.AspectRatio < tcc.showerTag[10]) killMe = true;
       if (killMe) MakeShowerObsolete(fcnLabel, slc, ss, prt3S);
     } // ss
 
     unsigned short nNewShowers = 0;
     for (auto& ss : slc.cots) {
       if (ss.ID == 0) continue;
       if (ss.TjIDs.empty()) continue;
       SaveTjInfo(slc, ss, "Done");
       ++nNewShowers;
     } // ss
 
     return (nNewShowers > 0);
 
   } // FindShowers3D

bool tca::FindShowerStart	(	detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 60 of file TCShower.cxx.

   {
     // 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 = slc.cots[cid - 1];
       // Find the position, direction and projection in this plane
       auto& stj = slc.tjs[ss.ShowerTjID - 1];
       auto chgCtrTP = MakeBareTP(detProp, slc, 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", slc, useCID, prt);
     }
 
     // now define the start and length
     auto& ss = slc.cots[useCID - 1];
     auto& stj = slc.tjs[ss.ShowerTjID - 1];
 
     auto chgCtrTP = MakeBareTP(detProp, slc, ss3.ChgPos, ss3.Dir, stj.CTP);
     if (ss3.Vx3ID > 0) {
       auto& vx3 = slc.vtx3s[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
       float sep = tcc.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 = tcc.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,
		TCSlice &	slc,
		int	cotID,
		bool	prt
	)

Definition at line 3702 of file TCShower.cxx.

   {
     // 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)slc.cots.size()) return;
 
     ShowerStruct& ss = slc.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 = slc.tjs[ss.ShowerTjID - 1].Pts[0];
 
     std::string fcnLabel = inFcnLabel + ".FSC";
 
     stp0.AveChg = 0;
 
     if (ss.AspectRatio > tcc.showerTag[10] || ss.DirectionFOM > tcc.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(slc, 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;
 
     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::FindUseHits	(	TCSlice &	slc,
		Trajectory &	tj,
		unsigned short	ipt,
		float	maxDelta,
		bool	useChg
	)

Definition at line 1755 of file StepUtils.cxx.

   {
     // Hits have been associated with trajectory point ipt but none are used. Here we will
     // decide which hits to use.
 
     if(ipt > tj.Pts.size() - 1) return;
     TrajPoint& tp = tj.Pts[ipt];
 
     if(tp.Hits.empty()) return;
     // don't check charge when starting out
     if(ipt < 5) useChg = false;
     float chgPullCut = 1000;
     if(useChg) chgPullCut = tcc.chargeCuts[0];
     // open it up for RevProp, since we might be following a stopping track
     if(tj.AlgMod[kRvPrp]) chgPullCut *= 2;
     if(tj.MCSMom < 30) chgPullCut *= 2;
 
     bool ignoreLongPulseHits = false;
     unsigned short npts = tj.EndPt[1] - tj.EndPt[0] + 1;
     if(npts < 10 || tj.AlgMod[kRvPrp]) ignoreLongPulseHits = true;
     float expectedHitsRMS = ExpectedHitsRMS(slc, tp);
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"FUH:  maxDelta "<<maxDelta<<" useChg requested "<<useChg<<" Norm AveChg "<<(int)tp.AveChg<<" tj.ChgRMS "<<std::setprecision(2)<<tj.ChgRMS<<" chgPullCut "<<chgPullCut<<" TPHitsRMS "<<(int)TPHitsRMSTick(slc, tp, kUnusedHits)<<" ExpectedHitsRMS "<<(int)expectedHitsRMS<<" AngCode "<<tp.AngleCode;
     }
 
     // inverse of the path length for normalizing hit charge to 1 WSE unit
     float pathInv = std::abs(tp.Dir[0]);
     if(pathInv < 0.05) pathInv = 0.05;
 
     // Find the hit that has the smallest delta and the number of available hits
     tp.Delta = maxDelta;
     float delta;
     unsigned short imbest = USHRT_MAX;
     std::vector<float> deltas(tp.Hits.size(), 100);
     // keep track of the best delta - even if it is used
     float bestDelta = maxDelta;
     unsigned short nAvailable = 0;
     unsigned short firstAvailable = USHRT_MAX;
     unsigned short lastAvailable = USHRT_MAX;
     unsigned short firstUsed = USHRT_MAX;
     unsigned short imBadRecoHit = USHRT_MAX;
     bool bestHitLongPulse = false;
     for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
       tp.UseHit[ii] = false;
       unsigned int iht = tp.Hits[ii];
       if(iht >= slc.slHits.size()) continue;
       if(slc.slHits[iht].allHitsIndex >= (*evt.allHits).size()) continue;
       delta = PointTrajDOCA(slc, iht, tp);
       if(delta < bestDelta) bestDelta = delta;
       if(slc.slHits[iht].InTraj > 0) {
         if(firstUsed == USHRT_MAX) firstUsed = ii;
         continue;
       }
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       if(ignoreLongPulseHits && LongPulseHit(hit)) continue;
       if(hit.GoodnessOfFit() < 0 || hit.GoodnessOfFit() > 100) imBadRecoHit = ii;
       if(firstAvailable == USHRT_MAX) firstAvailable = ii;
       lastAvailable = ii;
       ++nAvailable;
       if(tcc.dbgStp) {
         if(useChg) {
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<" "<<ii<<"  "<<PrintHit(slc.slHits[iht])<<" delta "<<delta<<" Norm Chg "<<(int)(hit.Integral() * pathInv);
         } else {
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<" "<<ii<<"  "<<PrintHit(slc.slHits[iht])<<" delta "<<delta;
         }
       } // tcc.dbgStp
       deltas[ii] = delta;
       if(delta < tp.Delta) {
         tp.Delta = delta;
         imbest = ii;
         bestHitLongPulse = LongPulseHit(hit);
       }
     } // ii
 
     float chgWght = 0.5;
 
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<" firstAvailable "<<firstAvailable<<" lastAvailable "<<lastAvailable<<" firstUsed "<<firstUsed<<" imbest "<<imbest<<" single hit. tp.Delta "<<std::setprecision(2)<<tp.Delta<<" bestDelta "<<bestDelta<<" path length "<<1 / pathInv<<" imBadRecoHit "<<imBadRecoHit;
     if(imbest == USHRT_MAX || nAvailable == 0) return;
     unsigned int bestDeltaHit = tp.Hits[imbest];
 
     // just use the best hit if we are tracking a high energy electron and the best hit is a long pulse hit
     if(tj.Strategy[kStiffEl] && bestHitLongPulse) {
       tp.UseHit[imbest] = true;
       slc.slHits[bestDeltaHit].InTraj = tj.ID;
       return;
     }
 
     // Don't try to use a multiplet if a hit in the middle is in a different trajectory
     if(tp.Hits.size() > 2 && nAvailable > 1 && firstUsed != USHRT_MAX && firstAvailable < firstUsed && lastAvailable > firstUsed) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" A hit in the middle of the multiplet is used. Use only the best hit";
       tp.UseHit[imbest] = true;
       slc.slHits[bestDeltaHit].InTraj = tj.ID;
       return;
     } // Used hit inside multiplet
 
     if(tp.AngleCode == 1) {
       // Get the hits that are in the same multiplet as bestDeltaHit
       std::vector<unsigned int> hitsInMultiplet;
       GetHitMultiplet(slc, bestDeltaHit, hitsInMultiplet, false);
       if(tcc.dbgStp) {
         mf::LogVerbatim myprt("TC");
         myprt<<" bestDeltaHit "<<PrintHit(slc.slHits[bestDeltaHit]);
         myprt<<" in multiplet:";
         for(auto& iht : hitsInMultiplet) myprt<<" "<<PrintHit(slc.slHits[iht]);
       }
       // Consider the case where a bad reco hit might be better. It is probably wider and
       // has more charge
       if(imBadRecoHit != USHRT_MAX) {
         unsigned int iht = tp.Hits[imBadRecoHit];
         auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
         if(hit.RMS() > HitsRMSTick(slc, hitsInMultiplet, kUnusedHits)) {
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Using imBadRecoHit "<<PrintHit(slc.slHits[iht]);
           tp.UseHit[imBadRecoHit] = true;
           slc.slHits[iht].InTraj = tj.ID;
           return;
         }
       } // bad reco hit
       // Use the hits in the multiplet instead
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         unsigned int iht = tp.Hits[ii];
         if(slc.slHits[iht].InTraj > 0) continue;
         if(std::find(hitsInMultiplet.begin(), hitsInMultiplet.end(), iht) == hitsInMultiplet.end()) continue;
         tp.UseHit[ii] = true;
         slc.slHits[iht].InTraj = tj.ID;
       } // ii
       return;
     } // isLA
 
     // don't use the best UNUSED hit if the best delta is for a USED hit and it is much better
     // TY: ignore for RevProp
     if(bestDelta < 0.5 * tp.Delta && !tj.AlgMod[kRvPrp]) return;
 
     if(!useChg || (useChg && (tj.AveChg <= 0 || tj.ChgRMS <= 0))) {
       // necessary quantities aren't available for more careful checking
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" tj.AveChg "<<tj.AveChg<<" or tj.ChgRMS "<<tj.ChgRMS<<". Use the best hit";
       tp.UseHit[imbest] = true;
       slc.slHits[bestDeltaHit].InTraj = tj.ID;
       return;
     }
 
     // Don't try to get fancy if we are tracking a stiff tj
     if(tj.PDGCode == 13 && bestDelta < 0.5) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Tracking muon. Use the best hit";
       tp.UseHit[imbest] = true;
       slc.slHits[bestDeltaHit].InTraj = tj.ID;
       return;
     }
 
     // The best hit is the only one available or this is a small angle trajectory
     if(nAvailable == 1 || tp.AngleCode == 0) {
       auto& hit = (*evt.allHits)[slc.slHits[bestDeltaHit].allHitsIndex];
       float aveChg = tp.AveChg;
       if(aveChg <= 0) aveChg = tj.AveChg;
       if(aveChg <= 0) aveChg = hit.Integral();
       float chgRMS = tj.ChgRMS;
       if(chgRMS < 0.2) chgRMS = 0.2;
       float bestDeltaHitChgPull = std::abs(hit.Integral() * pathInv / aveChg - 1) / chgRMS;
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" bestDeltaHitChgPull "<<bestDeltaHitChgPull<<" chgPullCut "<<chgPullCut;
       if(bestDeltaHitChgPull < chgPullCut || tp.Delta < 0.1) {
         tp.UseHit[imbest] = true;
         slc.slHits[bestDeltaHit].InTraj = tj.ID;
       } // good charge or very good delta
       return;
     } // bestDeltaHitMultiplicity == 1
 
     // Find the expected width for the angle of this TP (ticks)
     float expectedWidth = ExpectedHitsRMS(slc, tp);
 
     // Handle two available hits
     if(nAvailable == 2) {
       // See if these two are in the same multiplet and both are available
       std::vector<unsigned int> tHits;
       GetHitMultiplet(slc, bestDeltaHit, tHits, false);
       // ombest is the index of the other hit in tp.Hits that is in the same multiplet as bestDeltaHit
       // if we find it
       unsigned short ombest = USHRT_MAX;
       unsigned int otherHit = INT_MAX;
       if(tHits.size() == 2) {
         unsigned short localIndex = 0;
         if(tHits[0] == bestDeltaHit) localIndex = 1;
         otherHit = tHits[1 - localIndex];
         // get the index of this hit in tp.Hits
         for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
           if(slc.slHits[tp.Hits[ii]].InTraj > 0) continue;
           if(tp.Hits[ii] == otherHit) {
             ombest = ii;
             break;
           }
         } // ii
       } // tHits.size() == 2
       if(tcc.dbgStp) {
         mf::LogVerbatim("TC")<<" Doublet: imbest "<<imbest<<" ombest "<<ombest;
       }
       // The other hit exists in the tp and it is available
       if(ombest < tp.Hits.size()) {
         // compare the best delta hit and the other hit separately and the doublet as a merged pair
         float bestHitDeltaErr = std::abs(tp.Dir[1]) * 0.17 + std::abs(tp.Dir[0]) * HitTimeErr(slc, bestDeltaHit);
         // Construct a FOM starting with the delta pull
         float bestDeltaHitFOM = deltas[imbest] /  bestHitDeltaErr;
         if(bestDeltaHitFOM < 0.5) bestDeltaHitFOM = 0.5;
         // multiply by the charge pull if it is significant
         auto& hit = (*evt.allHits)[slc.slHits[bestDeltaHit].allHitsIndex];
         float bestDeltaHitChgPull = std::abs(hit.Integral() * pathInv / tp.AveChg - 1) / tj.ChgRMS;
         if(bestDeltaHitChgPull > 1) bestDeltaHitFOM *= chgWght * bestDeltaHitChgPull;
         // scale by the ratio
         float rmsRat = hit.RMS() / expectedWidth;
         if(rmsRat < 1) rmsRat = 1 / rmsRat;
         bestDeltaHitFOM *= rmsRat;
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<" bestDeltaHit FOM "<<deltas[imbest]/bestHitDeltaErr<<" bestDeltaHitChgPull "<<bestDeltaHitChgPull<<" rmsRat "<<rmsRat<<" bestDeltaHitFOM "<<bestDeltaHitFOM;
         // Now do the same for the other hit
         float otherHitDeltaErr = std::abs(tp.Dir[1]) * 0.17 + std::abs(tp.Dir[0]) * HitTimeErr(slc, otherHit);
         float otherHitFOM = deltas[ombest] /  otherHitDeltaErr;
         if(otherHitFOM < 0.5) otherHitFOM = 0.5;
         auto& ohit = (*evt.allHits)[slc.slHits[otherHit].allHitsIndex];
         float otherHitChgPull = std::abs(ohit.Integral() * pathInv / tp.AveChg - 1) / tj.ChgRMS;
         if(otherHitChgPull > 1) otherHitFOM *= chgWght * otherHitChgPull;
         rmsRat = ohit.RMS() / expectedWidth;
         if(rmsRat < 1) rmsRat = 1 / rmsRat;
         otherHitFOM *= rmsRat;
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<" otherHit FOM "<<deltas[ombest]/otherHitDeltaErr<<" otherHitChgPull "<<otherHitChgPull<<" rmsRat "<<rmsRat<<" otherHitFOM "<<otherHitFOM;
         // And for the doublet
         float doubletChg = hit.Integral() + ohit.Integral();
         float doubletTime = (hit.Integral() * hit.PeakTime() + ohit.Integral() * ohit.PeakTime()) / doubletChg;
         doubletChg *= pathInv;
         doubletTime *= tcc.unitsPerTick;
         float doubletWidthTick = TPHitsRMSTick(slc, tp, kUnusedHits);
         float doubletRMSTimeErr = doubletWidthTick * tcc.unitsPerTick;
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<" doublet Chg "<<doubletChg<<" doubletTime "<<doubletTime<<" doubletRMSTimeErr "<<doubletRMSTimeErr;
         float doubletFOM = PointTrajDOCA(slc, tp.Pos[0], doubletTime, tp) / doubletRMSTimeErr;
         if(doubletFOM < 0.5) doubletFOM = 0.5;
         float doubletChgPull = std::abs(doubletChg * pathInv / tp.AveChg - 1) / tj.ChgRMS;
         if(doubletChgPull > 1) doubletFOM *= chgWght * doubletChgPull;
         rmsRat = doubletWidthTick / expectedWidth;
         if(rmsRat < 1) rmsRat = 1 / rmsRat;
         doubletFOM *= rmsRat;
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<" doublet FOM "<<PointTrajDOCA(slc, tp.Pos[0], doubletTime, tp)/doubletRMSTimeErr<<" doubletChgPull "<<doubletChgPull<<" rmsRat "<<rmsRat<<" doubletFOM "<<doubletFOM;
         if(doubletFOM < bestDeltaHitFOM && doubletFOM < otherHitFOM) {
           tp.UseHit[imbest] = true;
           slc.slHits[bestDeltaHit].InTraj = tj.ID;
           tp.UseHit[ombest] = true;
           slc.slHits[otherHit].InTraj = tj.ID;
         } else {
           // the doublet is not the best
           if(bestDeltaHitFOM < otherHitFOM) {
             tp.UseHit[imbest] = true;
             slc.slHits[bestDeltaHit].InTraj = tj.ID;
           } else {
             tp.UseHit[ombest] = true;
             slc.slHits[otherHit].InTraj = tj.ID;
           } // otherHit is the best
         } // doublet is not the best
       } else {
         // the other hit isn't available. Just use the singlet
         tp.UseHit[imbest] = true;
         slc.slHits[bestDeltaHit].InTraj = tj.ID;
       }
       return;
     } // nAvailable == 2
     float hitsWidth = TPHitsRMSTick(slc, tp, kUnusedHits);
     float maxTick = tp.Pos[1] / tcc.unitsPerTick + 0.6 * expectedWidth;
     float minTick = tp.Pos[1] / tcc.unitsPerTick - 0.6 * expectedWidth;
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Multiplet: hitsWidth "<<hitsWidth<<" expectedWidth "<<expectedWidth<<" tick range "<<(int)minTick<<" "<<(int)maxTick;
     // use all of the hits in the tick window
     for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
       unsigned int iht = tp.Hits[ii];
       if(slc.slHits[iht].InTraj > 0) continue;
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       if(hit.PeakTime() < minTick) continue;
       if(hit.PeakTime() > maxTick) continue;
       tp.UseHit[ii] = true;
       slc.slHits[iht].InTraj = tj.ID;
     }
 
   } // FindUseHits

void tca::Finish3DShowers ( TCSlice & slc )

Definition at line 154 of file TCShower.cxx.

   {
     // 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 : slc.showers) {
       if (ss3.ID == 0) continue;
       noShowers = false;
     }
     if (noShowers) return;
 
     ChkAssns("Fin3D", slc);
 
     // 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 : slc.showers) {
       if (ss3.ID == 0) continue;
       if (ss3.PFPIndex != USHRT_MAX) continue;
       auto showerPFP = CreatePFP(slc);
       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 > slc.cots.size()) return;
         auto& ss = slc.cots[cid - 1];
         auto& stj = slc.tjs[ss.ShowerTjID - 1];
         showerPFP.TjIDs[ii] = stj.ID;
       } // ci
       showerPFP.PDGCode = 1111;
       auto& sf = showerPFP.SectionFits[0];
       sf.Pos = ss3.Start;
       sf.Dir = ss3.Dir;
       sf.DirErr = ss3.DirErr;
       showerPFP.Vx3ID[0] = ss3.Vx3ID;
       sf.Dir = ss3.Dir;
       // dEdx is indexed by plane for pfps and by 2D shower index for 3D showers
       for (auto cid : ss3.CotIDs) {
         auto& ss = slc.cots[cid - 1];
         unsigned short plane = DecodeCTP(ss.CTP).Plane;
         auto& stj = slc.tjs[ss.ShowerTjID - 1];
         showerPFP.dEdx[0][plane] = stj.dEdx[0];
         showerPFP.dEdxErr[0][plane] = 0.3 * stj.dEdx[0];
       } // ci
       ss3.PFPIndex = slc.pfps.size();
       if (ss3.ParentID > 0) {
         // see if this is a daughter
         auto& dtrPFP = slc.pfps[ss3.ParentID - 1];
         if (dtrPFP.ParentUID > 0) {
           // Transfer the daughter <-> parent assn
           auto slcIndx = GetSliceIndex("P", dtrPFP.ParentUID);
           auto& parPFP = slices[slcIndx.first].pfps[slcIndx.second];
           showerPFP.ParentUID = parPFP.UID;
           std::replace(parPFP.DtrUIDs.begin(), parPFP.DtrUIDs.end(), dtrPFP.UID, showerPFP.UID);
           dtrPFP.ParentUID = 0;
         } // dtrPFP.ParentID > 0
       }   // ss3.ParentID > 0
       slc.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(slc, false)) return;
 
     // Associate shower Tj hits with 3D showers
     for (auto& ss3 : slc.showers) {
       if (ss3.ID == 0) continue;
       for (unsigned short ii = 0; ii < ss3.CotIDs.size(); ++ii) {
         unsigned short cid = ss3.CotIDs[ii];
         auto& ss = slc.cots[cid - 1];
         for (auto tjid : ss.TjIDs) {
           Trajectory& tj = slc.tjs[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 = slc.vtxs[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 = slc.vtx3s[vx2.Vx3ID - 1];
             if (vx3.Neutrino) continue;
             vx3.ID = 0;
           } // end
         }   // tjid
       }     // ii
     }       // ss3
 
     // kill PFParticles
     if (!slc.pfps.empty()) {
       for (auto& pfp : slc.pfps) {
         if (pfp.ID == 0) continue;
         if (pfp.TjIDs.empty()) continue;
         unsigned short ndead = 0;
         for (auto tjid : pfp.TjIDs) {
           auto& tj = slc.tjs[tjid - 1];
           if (tj.AlgMod[kKilled]) ++ndead;
         } // tjid
         if (ndead == 0) continue;
         pfp.ID = 0;
       } // pfp
     }   // pfps not empty
 
     // kill orphan 2D vertices
     for (auto& vx2 : slc.vtxs) {
       if (vx2.ID == 0) continue;
       auto vxtjs = GetAssns(slc, "2V", vx2.ID, "T");
       if (vxtjs.empty()) vx2.ID = 0;
     } // vx2
 
     // kill orphan vertices
     for (auto& vx3 : slc.vtx3s) {
       if (vx3.ID == 0) continue;
       auto vxtjs = GetAssns(slc, "3V", vx3.ID, "T");
       if (vxtjs.empty()) {
         vx3.ID = 0;
         continue;
       }
     } // vx3
 
   } // Finish3DShowers

bool tca::Fit2D	(	short	mode,
		Point2_t	inPt,
		float &	inPtErr,
		Vector2_t &	outVec,
		Vector2_t &	outVecErr,
		float &	chiDOF
	)

Definition at line 5127 of file Utils.cxx.

   {
     // Fit points to a 2D line.
     // Mode = 0: Initialize
     // Mode = 1: Accumulate
     // Mode = 2: Accumulate and store to calculate chiDOF
     // Mode = -1: Fit and put results in outVec and chiDOF
 
     static double sum, sumx, sumy, sumx2, sumy2, sumxy;
     static unsigned short cnt;
     static std::vector<Point2_t> fitPts;
     static std::vector<double> fitWghts;
 
     if (mode == 0) {
       // initialize
       cnt = 0;
       sum = 0.;
       sumx = 0.;
       sumy = 0.;
       sumx2 = 0.;
       sumy2 = 0.;
       sumxy = 0;
       fitPts.resize(0);
       fitWghts.resize(0);
       return true;
     } // mode == 0
 
     if (mode > 0) {
       if (inPtErr <= 0.) return false;
       ++cnt;
       double wght = 1 / (inPtErr * inPtErr);
       sum += wght;
       sumx += wght * inPt[0];
       sumx2 += wght * inPt[0] * inPt[0];
       sumy += wght * inPt[1];
       sumy2 += wght * inPt[1] * inPt[1];
       sumxy += wght * inPt[0] * inPt[1];
       if (mode == 1) return true;
       fitPts.push_back(inPt);
       fitWghts.push_back(wght);
       return true;
     } // Accumulate
 
     if (cnt < 2) return false;
     // do the fit
     double delta = sum * sumx2 - sumx * sumx;
     if (delta == 0.) return false;
     double A = (sumx2 * sumy - sumx * sumxy) / delta;
     double B = (sumxy * sum - sumx * sumy) / delta;
     outVec[0] = A;
     outVec[1] = B;
     chiDOF = 0;
     if (cnt == 2 || fitPts.empty()) return true;
 
     // calculate errors and chiDOF
     if (fitPts.size() != cnt) return false;
     double ndof = cnt - 2;
     double varnce =
       (sumy2 + A * A * sum + B * B * sumx2 - 2 * (A * sumy + B * sumxy - A * B * sumx)) / ndof;
     if (varnce > 0.) {
       outVecErr[0] = sqrt(varnce * sumx2 / delta);
       outVecErr[1] = sqrt(varnce * sum / delta);
     }
     else {
       outVecErr[0] = 0.;
       outVecErr[1] = 0.;
     }
     sum = 0.;
     // calculate chisq
     for (unsigned short ii = 0; ii < fitPts.size(); ++ii) {
       double arg = fitPts[ii][1] - A - B * fitPts[ii][0];
       sum += fitWghts[ii] * arg * arg;
     }
     chiDOF = sum / ndof;
     fitPts.resize(0);
     fitWghts.resize(0);
     return true;
 
   } // Fit2D

void tca::FitPar	(	const TCSlice &	slc,
		const Trajectory &	tj,
		unsigned short	originPt,
		unsigned short	npts,
		short	fitDir,
		ParFit &	pFit,
		unsigned short	usePar
	)

Definition at line 1217 of file Utils.cxx.

   {
     // Fit a TP parameter, like Chg or Delta, to a line using the points starting at originPT.
     // Currently supported values of usePar are Chg (1) and Delta (2)
 
     pFit.ChiDOF = 999;
     pFit.AvePar = 0.;
     if (originPt > tj.Pts.size() - 1) return;
     if (fitDir != 1 && fitDir != -1) return;
     Point2_t inPt;
     Vector2_t outVec, outVecErr;
     float pErr, chiDOF;
     Fit2D(0, inPt, pErr, outVec, outVecErr, chiDOF);
     unsigned short cnt = 0;
     for (unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
       unsigned short ipt = originPt + ii * fitDir;
       if (ipt < tj.EndPt[0] || ipt > tj.EndPt[1]) break;
       auto& tp = tj.Pts[ipt];
       if (tp.Chg <= 0) continue;
       // Accumulate and save points
       inPt[0] = std::abs(tp.Pos[0] - tj.Pts[originPt].Pos[0]);
       float parVal = tp.Chg;
       // Assume errors are 10% for a charge fit
       pErr = 0.1 * parVal;
       if (usePar > 1) {
         parVal = tp.Delta;
         // use the TP hit position error for a Delta Fit
         pErr = sqrt(tp.HitPosErr2);
       }
       inPt[1] = parVal;
       pFit.AvePar += parVal;
       if (!Fit2D(2, inPt, pErr, outVec, outVecErr, chiDOF)) break;
       ++cnt;
       if (cnt == npts) break;
     } // ii
     if (cnt < npts) return;
     // do the fit and get the results
     if (!Fit2D(-1, inPt, pErr, outVec, outVecErr, chiDOF)) return;
     pFit.Pos = tj.Pts[originPt].Pos;
     pFit.Par0 = outVec[0];
     pFit.AvePar /= (float)cnt;
     pFit.ParErr = outVecErr[0];
     pFit.Pos = tj.Pts[originPt].Pos;
     pFit.ParSlp = outVec[1];
     pFit.ParSlpErr = outVecErr[1];
     pFit.ChiDOF = chiDOF;
     pFit.nPtsFit = cnt;
   } // FitPar

bool tca::FitSection	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		PFPStruct &	pfp,
		unsigned short	sfIndex
	)

Definition at line 1413 of file PFPUtils.cxx.

   {
     // Fits the TP3D points in the selected section to a 3D line with the origin at the center of
     // the section
     if (pfp.TP3Ds.size() < 4) return false;
     if (sfIndex >= pfp.SectionFits.size()) return false;
     // don't fit a small angle PFP
     if(pfp.Flags[kSmallAngle]) return true;
 
     unsigned short fromPt = USHRT_MAX;
     unsigned short npts = 0;
     GetRange(pfp, sfIndex, fromPt, npts);
     if (fromPt == USHRT_MAX) return false;
     if (npts < 4) return false;
 
     // check for errors
     for (unsigned short ipt = fromPt; ipt < fromPt + npts; ++ipt) {
       auto& tp3d = pfp.TP3Ds[ipt];
       if (tp3d.SFIndex != sfIndex) return false;
     } // ipt
 
     // fit these points and update
     float chiDOF = 999;
     return FitTP3Ds(detProp, slc, pfp, fromPt, npts, sfIndex, chiDOF);
 
   } // FitSection

SectionFit tca::FitTP3Ds	(	detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		const std::vector< TP3D > &	tp3ds,
		unsigned short	fromPt,
		short	fitDir,
		unsigned short	nPtsFit
	)

Definition at line 1446 of file PFPUtils.cxx.

   {
     // fits the points and returns the fit results in a SectionFit struct. This function assumes that the
     // vector of TP3Ds exists in the slc.TPCID
 
     SectionFit sf;
     sf.ChiDOF = 999;
     if (nPtsFit < 5) return sf;
     if (!(fitDir == -1 || fitDir == 1)) return sf;
     if (fitDir == 1 && fromPt + nPtsFit > tp3ds.size()) return sf;
     if (fitDir == -1 && fromPt < 3) return sf;
 
     // put the offset, cosine-like and sine-like components in a vector
     std::vector<std::array<double, 3>> ocs(slc.nPlanes);
     for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
       auto planeID = geo::PlaneID(slc.TPCID.Cryostat, slc.TPCID.TPC, plane);
       // plane offset
       ocs[plane][0] = tcc.geom->WireCoordinate(0, 0, planeID);
       // get the "cosine-like" component
       ocs[plane][1] = tcc.geom->WireCoordinate(1, 0, planeID) - ocs[plane][0];
       // the "sine-like" component
       ocs[plane][2] = tcc.geom->WireCoordinate(0, 1, planeID) - ocs[plane][0];
     } // plane
 
     const unsigned int nvars = 4;
     unsigned int npts = 0;
 
     // count the number of TPs in each plane
     std::vector<unsigned short> cntInPln(slc.nPlanes, 0);
     // and define the X position for the fit origin
     double x0 = 0.;
     for (short ii = 0; ii < nPtsFit; ++ii) {
       short ipt = fromPt + fitDir * ii;
       if (ipt < 0 || ipt >= (short)tp3ds.size()) break;
       auto& tp3d = tp3ds[ipt];
       if (!tp3d.Flags[kTP3DGood]) continue;
       if (tp3d.TPXErr2 < 0.0001) return sf;
       x0 += tp3d.TPX;
       unsigned short plane = DecodeCTP(tp3d.CTP).Plane;
       ++cntInPln[plane];
       ++npts;
     } // ipt
     if (npts < 6) return sf;
     // ensure there are at least three points in at least two planes
     unsigned short enufInPlane = 0;
     for (unsigned short plane = 0; plane < slc.nPlanes; ++plane)
       if (cntInPln[plane] > 2) ++enufInPlane;
     if (enufInPlane < 2) return sf;
 
     x0 /= (double)npts;
 
     TMatrixD A(npts, nvars);
     // vector holding the Wire number
     TVectorD w(npts);
     unsigned short cnt = 0;
     double weight = 1;
     for (short ii = 0; ii < nPtsFit; ++ii) {
       short ipt = fromPt + fitDir * ii;
       auto& tp3d = tp3ds[ipt];
       if (!tp3d.Flags[kTP3DGood]) continue;
       unsigned short plane = DecodeCTP(tp3d.CTP).Plane;
       double x = tp3d.TPX - x0;
       A[cnt][0] = weight * ocs[plane][1];
       A[cnt][1] = weight * ocs[plane][2];
       A[cnt][2] = weight * ocs[plane][1] * x;
       A[cnt][3] = weight * ocs[plane][2] * x;
       w[cnt] = weight * (tp3d.Wire - ocs[plane][0]);
       ++cnt;
     } // ipt
 
     TDecompSVD svd(A);
     bool ok;
     TVectorD tVec = svd.Solve(w, ok);
     if (!ok) return sf;
     double norm = sqrt(1 + tVec[2] * tVec[2] + tVec[3] * tVec[3]);
 
     norm *= -1;
 
     sf.Dir[0] = 1 / norm;
     sf.Dir[1] = tVec[2] / norm;
     sf.Dir[2] = tVec[3] / norm;
     sf.Pos[0] = x0;
     sf.Pos[1] = tVec[0];
     sf.Pos[2] = tVec[1];
     sf.NPts = npts;
 
     // Calculate errors from sigma * (A^T * A)^(-1) where sigma is the
     // error on the wire number (= 1)
     TMatrixD AT(nvars, npts);
     AT.Transpose(A);
     TMatrixD ATA = AT * A;
     double* det = 0;
     try{ ATA.Invert(det); }
     catch(...) { return sf; }
     sf.DirErr[1] = -sqrt(ATA[2][2]) / norm;
     sf.DirErr[2] = -sqrt(ATA[3][3]) / norm;
 
     // calculate ChiDOF
     sf.ChiDOF = 0;
     // project this 3D vector into a TP in every plane
     std::vector<TrajPoint> plnTP(slc.nPlanes);
     for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
       CTP_t inCTP = EncodeCTP(slc.TPCID.Cryostat, slc.TPCID.TPC, plane);
       plnTP[plane] = MakeBareTP(detProp, slc, sf.Pos, sf.Dir, inCTP);
     } // plane
     // a local position
     Point3_t pos;
     sf.DirErr[0] = 0.;
     for (short ii = 0; ii < nPtsFit; ++ii) {
       short ipt = fromPt + fitDir * ii;
       auto& tp3d = tp3ds[ipt];
       if (!tp3d.Flags[kTP3DGood]) continue;
       unsigned short plane = DecodeCTP(tp3d.CTP).Plane;
       double dw = tp3d.Wire - plnTP[plane].Pos[0];
       // dt/dW was stored in DeltaRMS by MakeBareTP
       double t = dw * plnTP[plane].DeltaRMS;
       for (unsigned short xyz = 0; xyz < 3; ++xyz)
         pos[xyz] = sf.Pos[xyz] + t * sf.Dir[xyz];
       // Note that the tp3d position is directly above the wire position and not the
       // point at the distance of closest approach. Delta is the difference in the
       // drift direction in cm
       double delta = pos[0] - tp3d.TPX;
       sf.ChiDOF += delta * delta / tp3d.TPXErr2;
       // estimate the X slope error ~ X direction vector with an overly simple average
       double dangErr = delta / dw;
       sf.DirErr[0] += dangErr * dangErr;
     } // indx
     sf.DirErr[0] = sqrt(sf.DirErr[0]) / (double)nPtsFit;
     sf.ChiDOF /= (float)(npts - 4);
     return sf;
 
   } // FitTP3Ds

bool tca::FitTP3Ds	(	detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		PFPStruct &	pfp,
		unsigned short	fromPt,
		unsigned short	nPtsFit,
		unsigned short	sfIndex,
		float &	chiDOF
	)

Definition at line 1586 of file PFPUtils.cxx.

   {
     // Fit points in the pfp.TP3Ds vector fromPt. This function
     // doesn't update the TP3Ds unless sfIndex refers to a valid SectionFit in the pfp.
     // No check is made to ensure that the TP3D SFIndex variable is compatible with sfIndex
 
     if (nPtsFit < 5) return false;
     if (fromPt + nPtsFit > pfp.TP3Ds.size()) return false;
 
     auto sf = FitTP3Ds(detProp, slc, pfp.TP3Ds, fromPt, 1, nPtsFit);
     if (sf.ChiDOF > 900) return false;
 
     // don't update the pfp?
     if (sfIndex >= pfp.SectionFits.size()) return true;
 
     // update the pfp Sectionfit
     pfp.SectionFits[sfIndex] = sf;
     // update the TP3Ds
     // project this 3D vector into a TP in every plane
     std::vector<TrajPoint> plnTP(slc.nPlanes);
     for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
       CTP_t inCTP = EncodeCTP(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
       plnTP[plane] = MakeBareTP(detProp, slc, sf.Pos, sf.Dir, inCTP);
     } // plane
     Point3_t pos;
     bool needsSort = false;
     double prevAlong = 0;
     for (unsigned short ipt = fromPt; ipt < fromPt + nPtsFit; ++ipt) {
       auto& tp3d = pfp.TP3Ds[ipt];
       unsigned short plane = DecodeCTP(tp3d.CTP).Plane;
       double dw = tp3d.Wire - plnTP[plane].Pos[0];
       // dt/dW was stored in DeltaRMS by MakeBareTP
       double t = dw * plnTP[plane].DeltaRMS;
       if (ipt == fromPt) { prevAlong = t; }
       else {
         if (t < prevAlong) needsSort = true;
         prevAlong = t;
       }
       for (unsigned short xyz = 0; xyz < 3; ++xyz)
         pos[xyz] = sf.Pos[xyz] + t * sf.Dir[xyz];
       // Note that the tp3d position is directly above the wire position and not the
       // distance of closest approach. The Delta variable is the difference in the
       // drift direction in cm
       double delta = pos[0] - tp3d.TPX;
       tp3d.Pos = pos;
       tp3d.Dir = sf.Dir;
       tp3d.along = t;
       if (tp3d.Flags[kTP3DGood]) sf.ChiDOF += delta * delta / tp3d.TPXErr2;
     } // ipt
     if (needsSort) SortSection(pfp, sfIndex);
     pfp.SectionFits[sfIndex].NeedsUpdate = false;
     return true;
 
   } // FitTP3Ds

void tca::FitTraj	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 806 of file Utils.cxx.

   {
     // 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(slc, tj, originPt, npts, fitDir, tpFit);
     tj.Pts[originPt] = tpFit;
 
   } // FitTraj

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

Definition at line 820 of file Utils.cxx.

   {
     // 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(slc, 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(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(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(tpFit);
 
     // 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	(	TCSlice &	slc,
		VtxStore &	vx,
		bool	prt
	)

Definition at line 1968 of file TCVertex.cxx.

   {
     // Fit the vertex using T -> 2V assns
 
     // tcc.vtx2DCuts 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 : slc.tjs) {
       if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) continue;
       if (tj.CTP != vx.CTP) continue;
       if (tj.AlgMod[kPhoton]) continue;
       bool added = false;
       if (tj.VtxID[0] == vx.ID && !tj.EndFlag[0][kNoFitVx]) {
         vxTp.push_back(tj.Pts[tj.EndPt[0]]);
         added = true;
       }
       if (tj.VtxID[1] == vx.ID && !tj.EndFlag[1][kNoFitVx]) {
         vxTp.push_back(tj.Pts[tj.EndPt[1]]);
         added = true;
       }
       // stash the ID in Step to help debugging
       if (added) {
         auto& tp = vxTp[vxTp.size() - 1];
         if (tj.ID > 0) tp.Step = (int)tj.ID;
         // inflate the angle errors for Tjs with few fitted points
         if (tp.NTPsFit < 4) tp.AngErr *= 4;
       }
     } // tj
 
     bool success = FitVertex(slc, vx, vxTp, prt);
 
     if (!success) return false;
     return true;
   } // FitVertex

bool tca::FitVertex	(	TCSlice &	slc,
		VtxStore &	vx,
		std::vector< TrajPoint > &	vxTPs,
		bool	prt
	)

Definition at line 2018 of file TCVertex.cxx.

   {
     // Version with LSQ fit. Each TP position (P0,P1) and slope S are fit to a vertex
     // at position (V0, V1), using the equation P1 = V1 + (P0 - V0) * S. This is put
     // in the form A * V = b. V is found using V = (A^T * A)^-1 * A^T * b. This is
     // usually done using the TDecompSVD Solve method but here we do it step-wise to
     // get access to the covariance matrix (A^T * A)^-1. The pull between the TP position
     // and the vertex position is stored in tp.Delta
 
     if (vxTPs.size() < 2) return false;
     if (vxTPs.size() == 2) {
       vx.ChiDOF = 0.;
       return true;
     }
 
     unsigned short npts = vxTPs.size();
     TMatrixD A(npts, 2);
     TVectorD b(npts);
     for (unsigned short itj = 0; itj < vxTPs.size(); ++itj) {
       auto& tp = vxTPs[itj];
       double dtdw = tp.Dir[1] / tp.Dir[0];
       double wt = 1 / (tp.AngErr * tp.AngErr);
       A(itj, 0) = -dtdw * wt;
       A(itj, 1) = 1. * wt;
       b(itj) = (tp.Pos[1] - tp.Pos[0] * dtdw) * wt;
     } // itj
 
     TMatrixD AT(2, npts);
     AT.Transpose(A);
     TMatrixD ATA = AT * A;
     double* det = 0;
     try {
       ATA.Invert(det);
     }
     catch (...) {
       return false;
     }
     if (det == NULL) return false;
     TVectorD vxPos = ATA * AT * b;
     vx.PosErr[0] = sqrt(ATA[0][0]);
     vx.PosErr[1] = sqrt(ATA[1][1]);
     vx.Pos[0] = vxPos[0];
     vx.Pos[1] = vxPos[1];
 
     // Calculate Chisq
     vx.ChiDOF = 0;
     if (vxTPs.size() > 2) {
       for (auto& tp : vxTPs) {
         // highjack TP Delta for the vertex pull
         tp.Delta = TrajPointVertexPull(slc, tp, vx);
         vx.ChiDOF += tp.Delta;
       } // itj
       vx.ChiDOF /= (float)(vxTPs.size() - 2);
     } // vxTPs.size() > 2
 
     if (prt) {
       mf::LogVerbatim("TC") << "Note: TP - 2V pull is stored in TP.Delta";
       PrintTPHeader("FV");
       for (auto& tp : vxTPs)
         PrintTP("FV", slc, 0, 1, 1, tp);
     }
 
     return true;
   } // FitVertex

void tca::FixBegin	(	TCSlice &	slc,
		Trajectory &	tj,
		unsigned short	atPt
	)

Definition at line 2795 of file StepUtils.cxx.

   {
     // Update the parameters at the beginning of the trajectory starting at point atPt
 
     if(!tcc.useAlg[kFixBegin]) return;
     // ignore short trajectories
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
     if(npwc < 6) return;
     // ignore shower-like trajectories
     if(tj.PDGCode == 11) return;
     // ignore junk trajectories
     if(tj.AlgMod[kJunkTj]) return;
     unsigned short firstPt = tj.EndPt[0];
 
     if(atPt == tj.EndPt[0]) return;
 
     // Default is to use DeltaRMS of the last point on the Tj
     float maxDelta = 4 * tj.Pts[tj.EndPt[1]].DeltaRMS;
 
     // Find the max DeltaRMS of points from atPt to EndPt[1]
     float maxDeltaRMS = 0;
     for(unsigned short ipt = atPt; ipt <= tj.EndPt[1]; ++ipt) {
       if(tj.Pts[ipt].DeltaRMS > maxDeltaRMS) maxDeltaRMS = tj.Pts[ipt].DeltaRMS;
     } // ipt
     maxDelta = 3 * maxDeltaRMS;
 
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"FB: atPt "<<atPt<<" firstPt "<<firstPt<<" Stops at end 0? "<<PrintEndFlag(tj, 0)<<" start vertex "<<tj.VtxID[0]<<" maxDelta "<<maxDelta;
     }
 
     // update the trajectory for all the points up to atPt
     // assume that we will use all of these points
     bool maskedPts = false;
     for(unsigned short ii = 1; ii < tj.Pts.size(); ++ii) {
       if(ii > atPt) break;
       unsigned int ipt = atPt - ii;
       TrajPoint& tp = tj.Pts[ipt];
       tp.Dir = tj.Pts[atPt].Dir;
       tp.Ang = tj.Pts[atPt].Ang;
       tp.AngErr = tj.Pts[atPt].AngErr;
       tp.AngleCode = tj.Pts[atPt].AngleCode;
       // Correct the projected time to the wire
       float dw = tp.Pos[0] - tj.Pts[atPt].Pos[0];
       if(tp.Dir[0] != 0) tp.Pos[1] = tj.Pts[atPt].Pos[1] + dw * tp.Dir[1] / tp.Dir[0];
       tj.Pts[ipt].Delta = PointTrajDOCA(slc, tj.Pts[ipt].HitPos[0], tj.Pts[ipt].HitPos[1], tj.Pts[ipt]);
       tj.Pts[ipt].DeltaRMS = tj.Pts[atPt].DeltaRMS;
       tj.Pts[ipt].NTPsFit = tj.Pts[atPt].NTPsFit;
       tj.Pts[ipt].FitChi = tj.Pts[atPt].FitChi;
       tj.Pts[ipt].AveChg = tj.Pts[atPt].AveChg;
       tj.Pts[ipt].ChgPull = (tj.Pts[ipt].Chg / tj.AveChg - 1) / tj.ChgRMS;
       bool badChg = (std::abs(tj.Pts[ipt].ChgPull) > tcc.chargeCuts[0]);
       bool maskThisPt = (tj.Pts[ipt].Delta > maxDelta || badChg);
       if(maskThisPt) {
         UnsetUsedHits(slc, tp);
         maskedPts = true;
       }
       if(tcc.dbgStp) {
         mf::LogVerbatim myprt("TC");
         myprt<<" Point "<<PrintPos(slc, tj.Pts[ipt].Pos)<<" Delta "<<tj.Pts[ipt].Delta<<" ChgPull "<<tj.Pts[ipt].ChgPull<<" maskThisPt? "<<maskThisPt;
       }
       if(ipt == 0) break;
     } // ii
     if(maskedPts) SetEndPoints(tj);
     tj.AlgMod[kFixBegin] = true;
 
   } // FixBegin

void tca::Forecast	(	TCSlice &	slc,
		const Trajectory &	tj
	)

Definition at line 434 of file StepUtils.cxx.

   {
     // Extrapolate the last TP of tj by many steps and return a forecast of what is ahead
     // -1       error or not sure
     // ~1       track-like with a slight chance of showers
     // >2       shower-like
     // nextForecastUpdate is set to the number of points on the trajectory when this function should
     // be called again
 
     if(tj.Pts[tj.EndPt[1]].AngleCode == 2) return;
 
     // add a new forecast
     tjfs.resize(tjfs.size() + 1);
     // assume there is insufficient info to make a decision
     auto& tjf = tjfs[tjfs.size() - 1];
     tjf.outlook = -1;
     tjf.nextForecastUpdate = USHRT_MAX;
 
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
     unsigned short istp = 0;
     unsigned short nMissed = 0;
 
     bool doPrt = tcc.dbgStp;
     // turn off annoying output from DefineHitPos
     if(doPrt) tcc.dbgStp = false;
     // find the minimum average TP charge. This will be used to calculate the
     // 'effective number of hits' on a wire = total charge on the wire within the
     // window / (minimum average TP charge). This is intended to reduce the sensitivity
     // of this metric to the hit finder configuration
     float minAveChg = 1E6;
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       if(tj.Pts[ipt].AveChg <= 0) continue;
       if(tj.Pts[ipt].AveChg > minAveChg) continue;
       minAveChg = tj.Pts[ipt].AveChg;
     } // ipt
     if(minAveChg <= 0 || minAveChg == 1E6) return;
     // start a forecast Tj comprised of the points in the forecast envelope
     Trajectory fctj;
     fctj.CTP = tj.CTP;
     fctj.ID = evt.WorkID;
     // make a local copy of the last point
     auto ltp = tj.Pts[tj.EndPt[1]];
     // Use the hits position instead of the fitted position so that a bad
     // fit doesn't screw up the forecast.
     float forecastWin0 = std::abs(ltp.Pos[1] - ltp.HitPos[1]);
     if(forecastWin0 < 1) forecastWin0 = 1;
     ltp.Pos = ltp.HitPos;
     double stepSize = std::abs(1/ltp.Dir[0]);
     float window = tcc.showerTag[7] * stepSize;
     if(doPrt) {
       mf::LogVerbatim("TC")<<"Forecast T"<<tj.ID<<" PDGCode "<<tj.PDGCode<<" npwc "<<npwc<<" minAveChg "<<(int)minAveChg<<" stepSize "<<std::setprecision(2)<<stepSize<<" window "<<window;
       mf::LogVerbatim("TC")<<" stp ___Pos____  nTPH  Chg ChgPull  Delta  DRMS  chgWid nTkLk nShLk";
     }
     unsigned short plane = DecodeCTP(ltp.CTP).Plane;
     float totHits = 0;
     fctj.TotChg = 0;
     float maxChg = 0;
     unsigned short maxChgPt = 0;
     unsigned short leavesNear = USHRT_MAX;
     bool leavesBeforeEnd = false;
     unsigned short showerStartNear = USHRT_MAX;
     unsigned short showerEndNear = USHRT_MAX;
     float nShLike = 0;
     float nTkLike = 0;
     unsigned short trimPts = 0;
     for(istp = 0; istp < 1000; ++istp) {
       // 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;
       unsigned int wire = std::nearbyint(ltp.Pos[0]);
       if(wire < slc.firstWire[plane]) break;
       if(wire > slc.lastWire[plane]-1) break;
       MoveTPToWire(ltp, (float)wire);
       ++ltp.Step;
       if(FindCloseHits(slc, ltp, window, kAllHits)) {
         // Found hits or the wire is dead
         // set all hits used so that we can use DefineHitPos. Note that
         // the hit InTraj is not used or tested in DefineHitPos so this doesn't
         // screw up any assns
         if(!ltp.Environment[kEnvNotGoodWire]) {
           nMissed = 0;
           ltp.UseHit.set();
           DefineHitPos(slc, ltp);
           fctj.TotChg += ltp.Chg;
           ltp.Delta = PointTrajDOCA(slc, ltp.HitPos[0], ltp.HitPos[1], ltp);
           ltp.DeltaRMS = ltp.Delta / window;
           ltp.Environment.reset();
           totHits += ltp.Hits.size();
           if(ltp.Chg > maxChg) {
             maxChg = ltp.Chg;
             maxChgPt = fctj.Pts.size();
           }
           // Note that ChgPull uses the average charge and charge RMS of the
           // trajectory before it entered the forecast envelope
           ltp.ChgPull = (ltp.Chg / minAveChg - 1) / tj.ChgRMS;
           if((ltp.ChgPull > 3 && ltp.Hits.size() > 1) || ltp.ChgPull > 10) {
             ++nShLike;
             // break if it approaches the side of the envelope
             ltp.Environment[kEnvNearShower] = true;
             // flag a showerlike TP so it isn't used in the MCSMom calculation
             ltp.HitPosErr2 = 100;
           } else {
             ++nTkLike;
             ltp.Environment[kEnvNearShower] = false;
           }
           if(fctj.Pts.size() > 10) {
             float shFrac = nShLike / (nShLike + nTkLike);
             if(shFrac > 0.5) {
               if(doPrt) mf::LogVerbatim("TC")<<"Getting showerlike - break";
               break;
             }
           } // fctj.Pts.size() > 6
           // break if it approaches the side of the envelope
           if(ltp.DeltaRMS > 0.8) {
             leavesNear = npwc + fctj.Pts.size();
             if(doPrt) mf::LogVerbatim("TC")<<"leaves before end - break";
             leavesBeforeEnd = true;
             break;
           }
           fctj.Pts.push_back(ltp);
           if(doPrt) {
             mf::LogVerbatim myprt("TC");
             myprt<<std::setw(4)<<npwc + fctj.Pts.size()<<" "<<PrintPos(slc, ltp);
             myprt<<std::setw(5)<<ltp.Hits.size();
             myprt<<std::setw(5)<<(int)ltp.Chg;
             myprt<<std::fixed<<std::setprecision(1);
             myprt<<std::setw(8)<<ltp.ChgPull;
             myprt<<std::setw(8)<<ltp.Delta;
             myprt<<std::setw(8)<<std::setprecision(2)<<ltp.DeltaRMS;
             myprt<<std::setw(8)<<sqrt(ltp.HitPosErr2);
             myprt<<std::setw(6)<<(int)nTkLike;
             myprt<<std::setw(6)<<(int)nShLike;
           } // doPrt
         }
       } else {
         // no hits found
         ++nMissed;
         if(nMissed == 10) {
           if(doPrt) mf::LogVerbatim("TC")<<"No hits found after 10 steps - break";
           break;
         }
       } // no hits found
     } // istp
     // not enuf info to make a forecast
     tcc.dbgStp = doPrt;
     if(fctj.Pts.size() < 3) return;
     // truncate and re-calculate totChg?
     if(trimPts > 0) {
       // truncate the forecast trajectory
       fctj.Pts.resize(fctj.Pts.size() - trimPts);
       // recalculate the total charge
       fctj.TotChg = 0;
       for(auto& tp : fctj.Pts) fctj.TotChg += tp.Chg;
     } // showerEndNear != USHRT_MAX
     SetEndPoints(fctj);
     fctj.MCSMom = MCSMom(slc, fctj);
     tjf.MCSMom = fctj.MCSMom;
     ParFit chgFit;
     if(maxChgPt > 0.3 * fctj.Pts.size() && maxChg > 3 * tj.AveChg) {
       // find the charge slope from the beginning to the maxChgPt if it is well away
       // from the start and it is very large
       FitPar(slc, fctj, 0, maxChgPt, 1, chgFit, 1);
     } else {
       FitPar(slc, fctj, 0, fctj.Pts.size(), 1, chgFit, 1);
     }
     tjf.chgSlope = chgFit.ParSlp;
     tjf.chgSlopeErr = chgFit.ParSlpErr;
     tjf.chgFitChiDOF = chgFit.ChiDOF;
     ChkStop(slc, fctj);
     UpdateTjChgProperties("Fc", slc, fctj, false);
     tjf.chgRMS = fctj.ChgRMS;
     tjf.endBraggPeak = fctj.EndFlag[1][kBragg];
     // Set outlook = Estimate of the number of hits per wire
     tjf.outlook = fctj.TotChg / (fctj.Pts.size() * tj.AveChg);
     // assume we got to the end
     tjf.nextForecastUpdate = npwc + fctj.Pts.size();
     tjf.leavesBeforeEnd = leavesBeforeEnd;
     tjf.foundShower = false;
     if(leavesNear < tjf.nextForecastUpdate) {
       // left the side
       tjf.nextForecastUpdate = leavesNear;
     } else if(showerStartNear < tjf.nextForecastUpdate) {
       // found a shower start
       tjf.nextForecastUpdate = showerStartNear;
       tjf.foundShower = true;
     } else if(showerEndNear < tjf.nextForecastUpdate) {
       // found a shower end
       tjf.nextForecastUpdate = showerEndNear;
     }
     nShLike = 0;
     for(auto& tp : fctj.Pts) if(tp.Environment[kEnvNearShower]) ++nShLike;
     tjf.showerLikeFraction = (float)nShLike / (float)fctj.Pts.size();
 
     if(doPrt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"Forecast T"<<tj.ID<<" tj.AveChg "<<(int)tj.AveChg;
       myprt<<" start "<<PrintPos(slc, tj.Pts[tj.EndPt[1]])<<" cnt "<<fctj.Pts.size()<<" totChg "<<(int)fctj.TotChg;
       myprt<<" last pos "<<PrintPos(slc, ltp);
       myprt<<" MCSMom "<<tjf.MCSMom;
       myprt<<" outlook "<<std::fixed<<std::setprecision(2)<<tjf.outlook;
       myprt<<" chgSlope "<<std::setprecision(1)<<tjf.chgSlope<<" +/- "<<tjf.chgSlopeErr;
       myprt<<" chgRMS "<<std::setprecision(1)<<tjf.chgRMS;
       myprt<<" endBraggPeak "<<tjf.endBraggPeak;
       myprt<<" chiDOF "<<tjf.chgFitChiDOF;
       myprt<<" showerLike fraction "<<tjf.showerLikeFraction;
       myprt<<" nextForecastUpdate "<<tjf.nextForecastUpdate;
       myprt<<" leavesBeforeEnd? "<<tjf.leavesBeforeEnd;
       myprt<<" foundShower? "<<tjf.foundShower;
     }
 
   } // Forecast

std::vector< int > tca::GetAssns	(	TCSlice &	slc,
		std::string	type1Name,
		int	id,
		std::string	type2Name
	)

Definition at line 4847 of file Utils.cxx.

   {
     // returns a list of IDs of objects (slc, vertices, pfps, etc) with type1Name that are in slc 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 <= slc.tjs.size() && type2Name == "P") {
       // return a list of PFPs that have the tj in TjIDs, P -> T<ID>
       for (auto& pfp : slc.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 <= slc.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 = slc.pfps[uid - 1];
       // First form a list of 2S -> T -> P<ID>
       std::vector<int> ssid;
       for (auto& ss : slc.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 : slc.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 <= slc.vtxs.size() && type2Name == "T") {
       // 2V -> T
       for (auto& tj : slc.tjs) {
         if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) 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 <= slc.vtx3s.size() && type2Name == "P") {
       for (auto& pfp : slc.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 <= slc.vtx3s.size() && type2Name == "T") {
       // 3V -> T
       for (auto& tj : slc.tjs) {
         if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) continue;
         for (unsigned short end = 0; end < 2; ++end) {
           if (tj.VtxID[end] > 0 && tj.VtxID[end] <= slc.vtxs.size()) {
             auto& vx2 = slc.vtxs[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 <= slc.vtx3s.size() && type2Name == "2V") {
       // 3V -> 2V
       for (auto& vx2 : slc.vtxs) {
         if (vx2.ID == 0) continue;
         if (vx2.Vx3ID == id) tmp.push_back(vx2.ID);
       } // vx2
       return tmp;
     } // 3V -> 2V
 
     if (type1Name == "3S" && uid <= slc.showers.size() && type2Name == "T") {
       // 3S -> T
       auto& ss3 = slc.showers[uid - 1];
       if (ss3.ID == 0) return tmp;
       for (auto cid : ss3.CotIDs) {
         auto& ss = slc.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 <= slc.cots.size() && type2Name == "T") {
       // 2S -> T
       auto& ss = slc.cots[uid - 1];
       return ss.TjIDs;
     } // 2S -> T
 
     if (type1Name == "3S" && uid <= slc.showers.size() && type2Name == "P") {
       // 3S -> P
       auto& ss3 = slc.showers[uid - 1];
       if (ss3.ID == 0) return tmp;
       for (auto cid : ss3.CotIDs) {
         auto& ss = slc.cots[cid - 1];
         if (ss.ID == 0) continue;
         for (auto tid : ss.TjIDs) {
           auto& tj = slc.tjs[tid - 1];
           if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) continue;
           if (!tj.AlgMod[kMat3D]) continue;
           for (auto& pfp : slc.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 <= slc.tjs.size() && type2Name == "2S") {
       // T -> 2S
       for (auto& ss : slc.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 <= slc.tjs.size() && type2Name == "3S") {
       // T -> 3S
       for (auto& ss : slc.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
 
     return tmp;
   } // GetAssns

int tca::GetCotID	(	TCSlice &	slc,
		int	ShowerTjID
	)

Definition at line 3941 of file TCShower.cxx.

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

void tca::GetHitMultiplet	(	const TCSlice &	slc,
		unsigned int	theHit,
		std::vector< unsigned int > &	hitsInMultiplet,
		bool	useLongPulseHits
	)

Definition at line 1413 of file StepUtils.cxx.

   {
     // This function attempts to return a list of hits in the current slice that are close to the
     // hit specified by theHit and that are similar to it. If theHit is a high-pulseheight hit (aka imTall)
     // and has an RMS similar to a hit on a small angle trajectory (aka Narrow) and is embedded in a series of
     // nearby low-pulseheight wide hits, the hit multiplet will consist of the single Tall and Narrow hit. On the
     // other hand, if theHit references a short and not-narrow hit, all of the hits in the series of nearby
     // hits will be returned. The localIndex is the index of theHit in hitsInMultiplet and shouldn't be
     // confused with the recob::Hit LocalIndex
     hitsInMultiplet.clear();
     // check for flagrant errors
     if(theHit >= slc.slHits.size()) return;
     if(slc.slHits[theHit].InTraj == INT_MAX) return;
     if(slc.slHits[theHit].allHitsIndex >= (*evt.allHits).size()) return;
 
     auto& hit = (*evt.allHits)[slc.slHits[theHit].allHitsIndex];
     // handle long-pulse hits
     if(useLongPulseHits && LongPulseHit(hit)) {
       // return everything in the multiplet as defined by the hit finder, but check for errors
       short int hitMult = hit.Multiplicity();
       unsigned int lIndex = hit.LocalIndex();
       unsigned int firstHit = 0;
       if(lIndex < theHit) firstHit = theHit - lIndex;
       for(unsigned int ii = firstHit; ii < firstHit + hitMult; ++ii) {
         if(ii >= slc.slHits.size()) break;
         auto& tmp = (*evt.allHits)[slc.slHits[ii].allHitsIndex];
         if(tmp.Multiplicity() == hitMult) hitsInMultiplet.push_back(ii);
       } // ii
       return;
     } // LongPulseHit
 
     hitsInMultiplet.resize(1);
     hitsInMultiplet[0] = theHit;
     unsigned int theWire = hit.WireID().Wire;
     unsigned short ipl = hit.WireID().Plane;
 
     float theTime = hit.PeakTime();
     float theRMS = hit.RMS();
     float narrowHitCut = 1.5 * evt.aveHitRMS[ipl];
     bool theHitIsNarrow = (theRMS < narrowHitCut);
     float maxPeak = hit.PeakAmplitude();
     unsigned int imTall = theHit;
     unsigned short nNarrow = 0;
     if(theHitIsNarrow) nNarrow = 1;
     // look for hits < theTime but within hitSep
     if(theHit > 0) {
       for(unsigned int iht = theHit - 1; iht != 0; --iht) {
         auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
         if(hit.WireID().Wire != theWire) break;
         if(hit.WireID().Plane != ipl) break;
         float hitSep = tcc.multHitSep * theRMS;
         float rms = hit.RMS();
         if(rms > theRMS) {
           hitSep = tcc.multHitSep * rms;
           theRMS = rms;
         }
         float dTick = std::abs(hit.PeakTime() - theTime);
         if(dTick > hitSep) break;
         hitsInMultiplet.push_back(iht);
         if(rms < narrowHitCut) ++nNarrow;
         float peakAmp = hit.PeakAmplitude();
         if(peakAmp > maxPeak) {
           maxPeak = peakAmp;
           imTall = iht;
         }
         theTime = hit.PeakTime();
         if(iht == 0) break;
       } // iht
     } // iht > 0
     // reverse the order so that hitsInMuliplet will be
     // returned in increasing time order
     if(hitsInMultiplet.size() > 1) std::reverse(hitsInMultiplet.begin(), hitsInMultiplet.end());
     // look for hits > theTime but within hitSep
     theTime = hit.PeakTime();
     theRMS = hit.RMS();
     for(unsigned int iht = theHit + 1; iht < slc.slHits.size(); ++iht) {
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       if(hit.WireID().Wire != theWire) break;
       if(hit.WireID().Plane != ipl) break;
       if(slc.slHits[iht].InTraj == INT_MAX) continue;
       float hitSep = tcc.multHitSep * theRMS;
       float rms = hit.RMS();
       if(rms > theRMS) {
         hitSep = tcc.multHitSep * rms;
         theRMS = rms;
       }
       float dTick = std::abs(hit.PeakTime() - theTime);
       if(dTick > hitSep) break;
       hitsInMultiplet.push_back(iht);
       if(rms < narrowHitCut) ++nNarrow;
       float peakAmp = hit.PeakAmplitude();
       if(peakAmp > maxPeak) {
         maxPeak = peakAmp;
         imTall = iht;
       }
       theTime = hit.PeakTime();
     } // iht
     if(hitsInMultiplet.size() == 1) return;
 
     // Don't make a multiplet that includes a tall narrow hit with short fat hits
     if(nNarrow == hitsInMultiplet.size()) return;
     if(nNarrow == 0) return;
 
     if(theHitIsNarrow && theHit == imTall) {
       // theHit is narrow and it is the highest amplitude hit in the multiplet. Ignore any
       // others that are short and fat
       auto tmp = hitsInMultiplet;
       tmp.resize(1);
       tmp[0] = theHit;
       hitsInMultiplet = tmp;
     } else {
       // theHit is not narrow and it is not the tallest. Ignore a single hit if it is
       // the tallest and narrow
       auto& hit = (*evt.allHits)[slc.slHits[imTall].allHitsIndex];
       if(hit.RMS() < narrowHitCut) {
         unsigned short killMe = 0;
         for(unsigned short ii = 0; ii < hitsInMultiplet.size(); ++ii) {
           if(hitsInMultiplet[ii] == imTall) {
             killMe = ii;
             break;
           }
         } // ii
         hitsInMultiplet.erase(hitsInMultiplet.begin() + killMe);
       } // slc.slHits[imTall].RMS < narrowHitCut
     } // narrow / tall test
 
   } // GetHitMultiplet

int tca::GetOrigin	(	detinfo::DetectorClocksData const &	clockData,
		TCSlice &	slc,
		PFPStruct &	pfp
	)

Definition at line 75 of file TCCR.cxx.

   {
 
     art::ServiceHandle<cheat::BackTrackerService const> bt_serv;
     art::ServiceHandle<cheat::ParticleInventoryService const> pi_serv;
 
     std::map<int, float> omap; //<origin, energy>
 
     for (auto& tjID : pfp.TjIDs) {
 
       Trajectory& tj = slc.tjs[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& slhit = slc.slHits[iht];
           auto& hit = (*evt.allHits)[slhit.allHitsIndex];
           raw::ChannelID_t channel = tcc.geom->PlaneWireToChannel((int)hit.WireID().Plane,
                                                                   (int)hit.WireID().Wire,
                                                                   (int)hit.WireID().TPC,
                                                                   (int)hit.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(clockData, 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 TCSlice &	slc,
		int	tjID
	)

Definition at line 1048 of file Utils.cxx.

   {
     if (slc.pfps.empty()) return USHRT_MAX;
     for (unsigned int ipfp = 0; ipfp < slc.pfps.size(); ++ipfp) {
       const auto& pfp = slc.pfps[ipfp];
       if (std::find(pfp.TjIDs.begin(), pfp.TjIDs.end(), tjID) != pfp.TjIDs.end()) return ipfp;
     } // indx
     return USHRT_MAX;
   } // GetPFPIndex

void tca::GetRange	(	const PFPStruct &	pfp,
		unsigned short	sfIndex,
		unsigned short &	fromPt,
		unsigned short &	npts
	)

Definition at line 1391 of file PFPUtils.cxx.

   {
     fromPt = USHRT_MAX;
     if (sfIndex >= pfp.SectionFits.size()) return;
     if (pfp.TP3Ds.empty()) return;
     fromPt = USHRT_MAX;
     npts = 0;
     // Note that no test is made for not-good TP3Ds here since that would give a wrong npts count
     for (std::size_t ipt = 0; ipt < pfp.TP3Ds.size(); ++ipt) {
       auto& tp3d = pfp.TP3Ds[ipt];
       if (tp3d.SFIndex < sfIndex) continue;
       if (tp3d.SFIndex > sfIndex) break;
       if (fromPt == USHRT_MAX) fromPt = ipt;
       ++npts;
     } // ipt
   }   // GetRange

std::pair< unsigned short, unsigned short > tca::GetSliceIndex	(	std::string	typeName,
		int	uID
	)

Definition at line 5086 of file Utils.cxx.

   {
     // returns the slice index and product index of a data product having typeName and unique ID uID
     for (unsigned short isl = 0; isl < slices.size(); ++isl) {
       auto& slc = slices[isl];
       if (typeName == "T") {
         for (unsigned short indx = 0; indx < slc.tjs.size(); ++indx) {
           if (slc.tjs[indx].UID == uID) { return std::make_pair(isl, indx); }
         }
       } // T
       if (typeName == "P") {
         for (unsigned short indx = 0; indx < slc.pfps.size(); ++indx) {
           if (slc.pfps[indx].UID == uID) { return std::make_pair(isl, indx); }
         }
       } // P
       if (typeName == "2V") {
         for (unsigned short indx = 0; indx < slc.vtxs.size(); ++indx) {
           if (slc.vtxs[indx].UID == uID) { return std::make_pair(isl, indx); }
         }
       } // 2V
       if (typeName == "3V") {
         for (unsigned short indx = 0; indx < slc.vtx3s.size(); ++indx) {
           if (slc.vtx3s[indx].UID == uID) { return std::make_pair(isl, indx); }
         }
       } // 3V
       if (typeName == "2S") {
         for (unsigned short indx = 0; indx < slc.cots.size(); ++indx) {
           if (slc.cots[indx].UID == uID) { return std::make_pair(isl, indx); }
         }
       } // 2S
       if (typeName == "3S") {
         for (unsigned short indx = 0; indx < slc.showers.size(); ++indx) {
           if (slc.showers[indx].UID == uID) { return std::make_pair(isl, indx); }
         }
       } // T
     }   // isl
     return std::make_pair(USHRT_MAX, USHRT_MAX);
   } // GetSliceIndex

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

Definition at line 194 of file TCShTree.cxx.

                                                             {
     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 TCSlice &	slc,
		const VtxStore &	vx2
	)

Definition at line 2851 of file TCVertex.cxx.

   {
     // returns a list of trajectory IDs that are attached to vx2
     std::vector<int> tmp;
     if (vx2.ID == 0) return tmp;
     for (auto& tj : slc.tjs) {
       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 TCSlice &	slc,
		const Vtx3Store &	vx3,
		float &	score
	)

Definition at line 2868 of file TCVertex.cxx.

   {
     // 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 : slc.vtxs) {
       if (vx2.ID == 0) continue;
       if (vx2.Vx3ID != vx3.ID) continue;
       auto vtxTjID2 = GetVtxTjIDs(slc, 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::GottaKink	(	TCSlice &	slc,
		Trajectory &	tj,
		bool	doTrim
	)

Definition at line 2554 of file StepUtils.cxx.

   {
     // This function returns true if it detects a kink in the trajectory
     // This function trims the points after a kink if one is found if doTrim is true.
 
     // tcc.kinkCuts[] fcl configuration
     // 0 = Number of TPs to fit at the end
     // 1 = Min kink significance
     // 2 = Use charge in significance calculation if > 0
     // 3 = 3D kink fit length (cm) - used in PFPUtils/SplitAtKinks
 
     // don't look for kinks if this looks a high energy electron
     // BB Jan 2, 2020: Return true if a kink was found but don't set the
     // stop-at-kink end flag
     if(tj.Strategy[kStiffEl]) return false;
     // Need at least 2 * kinkCuts[2] points with charge to find a kink
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
     unsigned short nPtsFit = tcc.kinkCuts[0];
     // Set nPtsFit for slowing tjs to the last TP NTPsFit
     if(tj.Strategy[kSlowing]) nPtsFit = tj.Pts[tj.EndPt[1]].NTPsFit;
     if(npwc < 2 * nPtsFit) return false;
 
     bool useCharge = (tcc.kinkCuts[2] > 0);
 
     // find the point where a kink is expected and fit the points after that point
     unsigned short fitPt = USHRT_MAX;
     unsigned short cnt = 0;
     for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
       unsigned short ipt = tj.EndPt[1] - ii - 1;
       // stay away from the starting points which may be skewed if this is a
       // stopping track
       if(ipt <= tj.EndPt[0] + 2) break;
       if(tj.Pts[ipt].Chg <= 0) continue;
       ++cnt;
       // Note that the fitPt is not included in the fits in the kink significance so we need
       // one more point
       if(cnt > nPtsFit) {
         fitPt = ipt;
         break;
       }
     } // ii
     if(fitPt == USHRT_MAX) {
       if(tcc.dbgStp) {
         mf::LogVerbatim myprt("TC");
         myprt<<"GKv2 fitPt not valid. Counted "<<cnt<<" points. Need "<<nPtsFit;
       } // tcc.dbgStp
       return false;
     }
 
     tj.Pts[fitPt].KinkSig = KinkSignificance(slc, tj, fitPt, nPtsFit, useCharge, tcc.dbgStp);
 
     bool thisPtHasKink = (tj.Pts[fitPt].KinkSig > tcc.kinkCuts[1]);
     bool prevPtHasKink = (tj.Pts[fitPt - 1].KinkSig > tcc.kinkCuts[1]);
     if(tcc.dbgStp) {
       mf::LogVerbatim myprt("TC");
       myprt<<"GKv2 fitPt "<<fitPt<<" "<<PrintPos(slc, tj.Pts[fitPt]);
       myprt<<std::fixed<<std::setprecision(5);
       myprt<<" KinkSig "<<std::setprecision(5)<<tj.Pts[fitPt].KinkSig;
       myprt<<" prevPt significance "<<tj.Pts[fitPt - 1].KinkSig;
       if(!thisPtHasKink && !prevPtHasKink) myprt<<" no kink";
       if(thisPtHasKink && !prevPtHasKink) myprt<<" -> Start kink region";
       if(thisPtHasKink && prevPtHasKink) myprt<<" -> Inside kink region";
       if(!thisPtHasKink && prevPtHasKink) myprt<<" -> End kink region";
     } // dbgStp
     // See if we just passed a series of points having a high kink significance. If so,
     // then find the point with the maximum value and call that the kink point
     // Don't declare a kink (yet)
     if(thisPtHasKink) return false;
     // neither points are kink-like
     if(!prevPtHasKink) return false;
 
     // We have left a kink region. Find the point with the max likelihood and call
     // that the kink point
     float maxSig = tcc.kinkCuts[1];
     unsigned short kinkRegionLength = 0;
     unsigned short maxKinkPt = USHRT_MAX;
     for(unsigned short ipt = fitPt - 1; ipt > tj.EndPt[0]; --ipt) {
       auto& tp = tj.Pts[ipt];
       if(tp.KinkSig < 0) continue;
       if(tp.KinkSig > maxSig) {
         // track the max significance
         maxSig = tp.KinkSig;
         maxKinkPt = ipt;
       } // tp.KinkSig > maxSig
       // find the start of the kink region
       if(tp.KinkSig < tcc.kinkCuts[1]) break;
       ++kinkRegionLength;
     } // ipt
     if(maxKinkPt == USHRT_MAX) return false;
     // Require that the candidate kink be above the cut threshold for more than one point.
     // Scale the requirement by the number of points in the fit
     unsigned short kinkRegionLengthMin = 1 + nPtsFit / 5;
     if(tj.Strategy[kStiffMu]) kinkRegionLengthMin = 1 + nPtsFit / 3;
     if(kinkRegionLength < kinkRegionLengthMin) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"GKv2: kink region too short "<<kinkRegionLength<<" Min "<<kinkRegionLengthMin;
       return false;
     }
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"GKv2:   kink at "<<PrintPos(slc, tj.Pts[maxKinkPt])<<std::setprecision(3)<<" maxSig "<<maxSig<<" kinkRegionLength "<<kinkRegionLength<<" Min "<<kinkRegionLengthMin;
     // don't alter the tj unless doTrim is true
     if(!doTrim) return true;
     // trim the points
     for(unsigned short ipt = maxKinkPt + 1; ipt <= tj.EndPt[1]; ++ipt) UnsetUsedHits(slc, tj.Pts[ipt]);
     SetEndPoints(tj);
     // trim another point if the charge of the last two points is wildly dissimilar
     float lastChg = tj.Pts[tj.EndPt[1]].Chg;
     float prevChg = tj.Pts[tj.EndPt[1] - 1].Chg;
     float chgAsym = std::abs(lastChg - prevChg) / (lastChg + prevChg);
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"GKv2: last point after trim "<<PrintPos(slc, tj.Pts[tj.EndPt[1]])<<" chgAsym "<<chgAsym;
     if(chgAsym > 0.1) {
       UnsetUsedHits(slc, tj.Pts[tj.EndPt[1]]);
       SetEndPoints(tj);
     }
     tj.EndFlag[1][kAtKink] = true;
     return true;
 
   } // GottaKink

bool tca::HasDuplicateHits	(	const TCSlice &	slc,
		Trajectory const &	tj,
		bool	prt
	)

Definition at line 2810 of file Utils.cxx.

   {
     // 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(slc.slHits[ii]) << " is a duplicate "
                                   << ii << " " << jj;
           return true;
         }
       } // jj
     }   // ii
     return false;
   } // HasDuplicateHits

float tca::HitSep2	(	const TCSlice &	slc,
		unsigned int	iht,
		unsigned int	jht
	)

Definition at line 2536 of file Utils.cxx.

   {
     // returns the separation^2 between two hits in WSE units
     if (iht > slc.slHits.size() - 1 || jht > slc.slHits.size() - 1) return 1E6;
     auto& ihit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
     auto& jhit = (*evt.allHits)[slc.slHits[jht].allHitsIndex];
     float dw = (float)ihit.WireID().Wire - (float)jhit.WireID().Wire;
     float dt = (ihit.PeakTime() - jhit.PeakTime()) * tcc.unitsPerTick;
     return dw * dw + dt * dt;
   } // HitSep2

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

Definition at line 4287 of file Utils.cxx.

   {
     // 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 && slc.slHits[iht].InTraj > 0) useit = true;
       if (hitRequest == kUnusedHits && slc.slHits[iht].InTraj == 0) useit = true;
       if (!useit) continue;
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       float chg = hit.Integral();
       pos += chg * hit.PeakTime();
       sum += chg;
     } // ii
     if (sum <= 0) return -1;
     return pos / sum;
   } // HitsPosTick

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

Definition at line 4277 of file Utils.cxx.

   {
     return tcc.unitsPerTick * HitsPosTick(slc, hitsInMultiplet, sum, hitRequest);
   } // HitsPosTime

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

Definition at line 4244 of file Utils.cxx.

   {
     if (hitsInMultiplet.empty()) return 0;
 
     if (hitsInMultiplet.size() == 1) {
       auto& hit = (*evt.allHits)[slc.slHits[hitsInMultiplet[0]].allHitsIndex];
       return hit.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 && slc.slHits[iht].InTraj > 0) useit = true;
       if (hitRequest == kUnusedHits && slc.slHits[iht].InTraj == 0) useit = true;
       if (!useit) continue;
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       float cv = hit.PeakTime();
       float rms = hit.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	(	const TCSlice &	slc,
		const std::vector< unsigned int > &	hitsInMultiplet,
		HitStatus_t	hitRequest
	)

Definition at line 4235 of file Utils.cxx.

   {
     return tcc.unitsPerTick * HitsRMSTick(slc, hitsInMultiplet, hitRequest);
   } // HitsRMSTick

float tca::HitsTimeErr2	(	const TCSlice &	slc,
		const std::vector< unsigned int > &	hitVec
	)

Definition at line 1550 of file StepUtils.cxx.

   {
     // Estimates the error^2 of the time using all hits in hitVec
     if(hitVec.empty()) return 0;
     float err = tcc.hitErrFac * HitsRMSTime(slc, hitVec, kUnusedHits);
     return err * err;
   } // HitsTimeErr2

float tca::HitTimeErr	(	const TCSlice &	slc,
		unsigned int	iht
	)

Definition at line 1542 of file StepUtils.cxx.

   {
     if(iht > slc.slHits.size() - 1) return 0;
     auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
     return hit.RMS() * tcc.unitsPerTick * tcc.hitErrFac * hit.Multiplicity();
   } // HitTimeErr

unsigned short tca::InsertTP3D	(	PFPStruct &	pfp,
		TP3D &	tp3d
	)

Definition at line 1988 of file PFPUtils.cxx.

   {
     // inserts the tp3d into the section defined by tp3d.SFIndex
     if (tp3d.SFIndex >= pfp.SectionFits.size()) return USHRT_MAX;
     // Find the first occurrence of this SFIndex
     std::size_t ipt = 0;
     for (ipt = 0; ipt < pfp.TP3Ds.size(); ++ipt)
       if (tp3d.SFIndex == pfp.TP3Ds[ipt].SFIndex) break;
     if (ipt == pfp.TP3Ds.size()) return USHRT_MAX;
     // next see if we can insert it so that re-sorting of this section isn't required
     auto lastTP3D = pfp.TP3Ds.back();
     if (ipt == 0 && tp3d.along < pfp.TP3Ds[0].along) {
       // insert at the beginning. No search needs to be done
     }
     else if (tp3d.SFIndex == lastTP3D.SFIndex && tp3d.along > lastTP3D.along) {
       // insert at the end. Use push_back and return
       pfp.TP3Ds.push_back(tp3d);
       pfp.SectionFits[tp3d.SFIndex].NeedsUpdate = true;
       pfp.Flags[kNeedsUpdate] = true;
       return pfp.TP3Ds.size() - 1;
     }
     else {
       for (std::size_t iipt = ipt; iipt < pfp.TP3Ds.size() - 1; ++iipt) {
         // break out if the next point is in a different section
         if (pfp.TP3Ds[iipt + 1].SFIndex != tp3d.SFIndex) break;
         if (tp3d.along > pfp.TP3Ds[iipt].along && tp3d.along < pfp.TP3Ds[iipt + 1].along) {
           ipt = iipt + 1;
           break;
         }
       } // iipt
     }   // insert in the middle
     pfp.TP3Ds.insert(pfp.TP3Ds.begin() + ipt, tp3d);
     pfp.SectionFits[tp3d.SFIndex].NeedsUpdate = true;
     pfp.Flags[kNeedsUpdate] = true;
     return ipt;
   } // InsertTP3D

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

float tca::InShowerProb	(	TCSlice &	slc,
		const ShowerStruct3D &	ss3,
		const PFPStruct &	pfp
	)

Definition at line 2014 of file TCShower.cxx.

   {
     // 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 = slc.cots[cid - 1];
       if (ss.ID == 0) continue;
       for (auto tid : pfp.TjIDs) {
         auto& tj = slc.tjs[tid - 1];
         if (tj.CTP != ss.CTP) continue;
         sum += InShowerProb(slc, ss, tj);
         ++cnt;
       } // tid
     }   //cid
     if (cnt == 0) return 0;
     return sum / cnt;
 
   } // InShowerProb

float tca::InShowerProb	(	TCSlice &	slc,
		const ShowerStruct &	ss,
		const Trajectory &	tj
	)

Definition at line 2038 of file TCShower.cxx.

   {
     // 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 = slc.tjs[ss.ShowerTjID - 1];
     if (stj.Pts.size() != 3) return 0;
     unsigned short closePt1, closePt2;
     float doca = 1E6;
     TrajTrajDOCA(slc, 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);
     float rms = stp.DeltaRMS;
     if (rms < 1) rms = 1;
     float arg = alongTrans[1] / rms;
     float radProb = exp(-0.5 * arg * arg);
     // 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);
     float costh = std::abs(DotProd(stp.Dir, ttp.Dir));
     float prob = radProb * longProb * costh;
     return prob;
 
   } // InShowerProb

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

Definition at line 1956 of file TCShower.cxx.

   {
     // 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 2007 of file TCShower.cxx.

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

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

Definition at line 1992 of file TCShower.cxx.

   {
     // 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::InsideFV	(	const TCSlice &	slc,
		const PFPStruct &	pfp,
		unsigned short	end
	)

Definition at line 3044 of file PFPUtils.cxx.

   {
     // returns true if the end of the pfp is inside the fiducial volume of the TPC
     if (pfp.ID <= 0) return false;
     if (end > 1) return false;
     if (pfp.SectionFits.empty()) return false;
     // require that the points are sorted which ensures that the start and end points
     // are the first and last points in the TP3Ds vector
     if (pfp.Flags[kNeedsUpdate]) return false;
     bool neutrinoPFP = pfp.PDGCode == 12 || pfp.PDGCode == 14;
 
     float abit = 5;
     Point3_t pos;
     if (neutrinoPFP) { pos = pfp.SectionFits[0].Pos; }
     else if (end == 0) {
       pos = pfp.TP3Ds[0].Pos;
     }
     else {
       pos = pfp.TP3Ds[pfp.TP3Ds.size() - 1].Pos;
     }
     return (pos[0] > slc.xLo + abit && pos[0] < slc.xHi - abit && pos[1] > slc.yLo + abit &&
             pos[1] < slc.yHi - abit && pos[2] > slc.zLo + abit && pos[2] < slc.zHi - abit);
 
   } // InsideFV

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

Definition at line 3071 of file PFPUtils.cxx.

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

bool tca::InTrajOK	(	TCSlice &	slc,
		std::string	someText
	)

Definition at line 1274 of file Utils.cxx.

   {
     // Check slc.tjs -> 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 : slc.tjs) {
       // ignore abandoned trajectories
       if (tj.AlgMod[kKilled]) continue;
       tID = tj.ID;
       tHits = PutTrajHitsInVector(tj, kUsedHits);
       if (tHits.size() < 2) continue;
       std::sort(tHits.begin(), tHits.end());
       atHits.clear();
       for (iht = 0; iht < slc.slHits.size(); ++iht) {
         if (slc.slHits[iht].InTraj == tID) atHits.push_back(iht);
       } // iht
       if (atHits.size() < 2) 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(slc.slHits[atHits[iht]]);
           if (iht < tHits.size()) myprt << " " << PrintHit(slc.slHits[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(slc.slHits[atHits[iht]]) << "\n";
           } // iht
           PrintTrajectory("CIT", slc, tj, USHRT_MAX);
         } // tHit.size > atHits.size()
         return false;
       }
       // check the VtxID
       for (unsigned short end = 0; end < 2; ++end) {
         if (tj.VtxID[end] > slc.vtxs.size()) {
           mf::LogVerbatim("TC") << someText << " ChkInTraj: Bad VtxID " << tj.ID;
           tj.AlgMod[kKilled] = true;
           return false;
         }
       } // end
       ++itj;
     } // tj
     return true;
 
   } // InTrajOK

unsigned short tca::IsCloseToVertex	(	const TCSlice &	slc,
		const VtxStore &	inVx2
	)

Definition at line 2908 of file TCVertex.cxx.

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

unsigned short tca::IsCloseToVertex	(	const TCSlice &	slc,
		const Vtx3Store &	vx3
	)

Definition at line 2928 of file TCVertex.cxx.

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

bool tca::IsGhost	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 2863 of file StepUtils.cxx.

   {
     // Sees if trajectory tj shares many hits with another trajectory and if so merges them.
 
     if(!tcc.useAlg[kUseGhostHits]) return false;
     // ensure that tj is not a saved trajectory
     if(tj.ID > 0) return true;
     // or an already killed trajectory
     if(tj.AlgMod[kKilled]) return true;
     if(tj.Pts.size() < 3) return false;
     if(tj.Strategy[kStiffEl]) return false;
 
     // vectors of traj IDs, and the occurrence count
     std::vector<int> tID;
     std::vector<unsigned short> tCnt;
 
     unsigned short hitCnt = 0;
     unsigned short nAvailable = 0;
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       for(unsigned short ii = 0; ii < tj.Pts[ipt].Hits.size(); ++ii) {
         // ignore hits used by this trajectory
         if(tj.Pts[ipt].UseHit[ii]) {
           ++hitCnt;
           continue;
         }
         unsigned int iht = tj.Pts[ipt].Hits[ii];
         if(slc.slHits[iht].InTraj > 0 && (unsigned int)slc.slHits[iht].InTraj <= slc.tjs.size()) {
           int tjid = slc.slHits[iht].InTraj;
           unsigned short indx;
           for(indx = 0; indx < tID.size(); ++indx) if(tID[indx] == tjid) break;
           if(indx == tID.size()) {
             tID.push_back(tjid);
             tCnt.push_back(1);
           } else {
             ++tCnt[indx];
           }
         } else {
           ++nAvailable;
         }
       } // ii
     } // ipt
 
     // Call it a ghost if > 1/3 of the hits are used by another trajectory
     hitCnt /= 3;
     int oldTjID = INT_MAX;
 
     if(tcc.dbgStp) {
       mf::LogVerbatim myprt("TC");
       myprt<<"IsGhost tj hits size cut "<<hitCnt<<" tID_tCnt";
       for(unsigned short ii = 0; ii < tCnt.size(); ++ii) myprt<<" "<<tID[ii]<<"_"<<tCnt[ii];
       myprt<<"\nAvailable hits "<<nAvailable;
     } // prt
 
     for(unsigned short ii = 0; ii < tCnt.size(); ++ii) {
       if(tCnt[ii] > hitCnt) {
         oldTjID = tID[ii];
         hitCnt = tCnt[ii];
       }
     } // ii
     if(oldTjID == INT_MAX) return false;
     int oldTjIndex = oldTjID - 1;
 
     // See if this looks like a short delta-ray on a long muon
     Trajectory& oTj = slc.tjs[oldTjIndex];
     if(oTj.PDGCode == 13 && hitCnt < 0.1 * oTj.Pts.size()) return false;
 
     // See if there are gaps in this trajectory indicating that it is really a ghost and not
     // just a crossing trajectory
     // find the range of wires spanned by oTj
     int wire0 = INT_MAX;
     int wire1 = 0;
     for(auto& otp : oTj.Pts) {
       int wire = std::nearbyint(otp.Pos[0]);
       if(wire < wire0) wire0 = wire;
       if(wire > wire1) wire1 = wire;
     } // tp
 
     int nwires = wire1 - wire0 + 1;
     std::vector<float> oTjPos1(nwires, -1);
     unsigned short nMissedWires = 0;
     for(unsigned short ipt = oTj.EndPt[0]; ipt <= oTj.EndPt[1]; ++ipt) {
       if(oTj.Pts[ipt].Chg == 0) continue;
       int wire = std::nearbyint(oTj.Pts[ipt].Pos[0]);
       int indx = wire - wire0;
       if(indx < 0 || indx > nwires - 1) continue;
       oTjPos1[indx] = oTj.Pts[ipt].Pos[1];
       ++nMissedWires;
     } // ipt
     // count the number of ghost TPs
     unsigned short ngh = 0;
     // and the number with Delta > 0 relative to oTj
     unsigned short nghPlus = 0;
     // keep track of the first point and last point appearance of oTj
     unsigned short firstPtInoTj = USHRT_MAX;
     unsigned short lastPtInoTj = 0;
     TrajPoint tp = tj.Pts[tj.EndPt[0]];
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       if(tj.Pts[ipt].Chg > 0) {
         tp = tj.Pts[ipt];
         continue;
       }
       int wire = std::nearbyint(tj.Pts[ipt].Pos[0]);
       int indx = wire - wire0;
       if(indx < 0 || indx > nwires - 1) continue;
       if(oTjPos1[indx] > 0) {
         // ensure that the hits in this tp are used in oTj
         bool HitInoTj = false;
         for(unsigned short ii = 0; ii < tj.Pts[ipt].Hits.size(); ++ii) {
           unsigned int iht = tj.Pts[ipt].Hits[ii];
           if(slc.slHits[iht].InTraj ==  oldTjID) HitInoTj = true;
         } // ii
         if(HitInoTj) {
           ++ngh;
           MoveTPToWire(tp, tj.Pts[ipt].Pos[0]);
           if(tp.Pos[1] > oTjPos1[indx]) ++nghPlus;
           if(firstPtInoTj == USHRT_MAX) firstPtInoTj = ipt;
           lastPtInoTj = ipt;
         }
       } // oTjHasChg[indx]
     } // ipt
 
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Number of missed wires in oTj gaps "<<nMissedWires<<" Number of ghost hits in these gaps "<<ngh<<" nghPlus "<<nghPlus<<" cut "<<0.2 * nMissedWires;
 
     if(ngh < 0.2 * nMissedWires) return false;
     if(firstPtInoTj > lastPtInoTj) return false;
 
     // require all of the tj TPs to be on either the + or - side of the oTj trajectory
     if(!(nghPlus > 0.8 * ngh || nghPlus < 0.2 * ngh) ) return false;
 
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Trajectory is a ghost of "<<oldTjID<<" first point in oTj "<<firstPtInoTj<<" last point "<<lastPtInoTj;
 
     // unset all of the shared hits
     for(unsigned short ipt = firstPtInoTj; ipt <= lastPtInoTj; ++ipt) {
       if(tj.Pts[ipt].Chg == 0) continue;
       UnsetUsedHits(slc, tj.Pts[ipt]);
       if(tcc.dbgStp) PrintTrajectory("IG", slc, tj, ipt);
     }
     // see how many points are left at the end
     ngh = 0;
     for(unsigned short ipt = lastPtInoTj; ipt <= tj.EndPt[1]; ++ipt) {
       if(tj.Pts[ipt].Chg > 0) ++ngh;
     } // ipt
     // clobber those too?
     if(ngh > 0 && ngh < tcc.minPts[tj.Pass]) {
       for(unsigned short ipt = lastPtInoTj; ipt <= tj.EndPt[1]; ++ipt) {
         if(tj.Pts[ipt].Chg > 0) UnsetUsedHits(slc, tj.Pts[ipt]);
       } // ipt
     }
     SetEndPoints(tj);
     tj.Pts.resize(tj.EndPt[1] + 1);
     slc.tjs[oldTjIndex].AlgMod[kUseGhostHits] = true;
     TrimEndPts("IG", slc, tj, tcc.qualityCuts, tcc.dbgStp);
     if(tj.AlgMod[kKilled]) {
       tj.IsGood = false;
       if(tcc.dbgStp)  mf::LogVerbatim("TC")<<" Failed quality cuts";
       return true;
     }
     tj.MCSMom = MCSMom(slc, tj);
     if(tcc.dbgStp)  mf::LogVerbatim("TC")<<" New tj size "<<tj.Pts.size();
     return true;
 
   } // IsGhost

bool tca::IsGhost	(	TCSlice &	slc,
		std::vector< unsigned int > &	tHits
	)

Definition at line 3027 of file StepUtils.cxx.

   {
     // Called by FindJunkTraj to see if the passed hits are close to an existing
     // trajectory and if so, they will be used in that other trajectory
 
     if(!tcc.useAlg[kUseGhostHits]) return false;
 
     if(tHits.size() < 2) return false;
 
     bool prt = (tcc.dbgStp || tcc.dbgAlg[kUseGhostHits]);
 
     // find all nearby hits
     std::vector<unsigned int> hitsInMuliplet, nearbyHits;
     for(auto iht : tHits) {
       GetHitMultiplet(slc, iht, hitsInMuliplet, false);
       // prevent double counting
       for(auto mht : hitsInMuliplet) {
         if(std::find(nearbyHits.begin(), nearbyHits.end(), mht) == nearbyHits.end()) {
           nearbyHits.push_back(mht);
         }
       } // mht
     } // iht
 
     // vectors of traj IDs, and the occurrence count
     std::vector<unsigned int> tID, tCnt;
     for(auto iht : nearbyHits) {
       if(slc.slHits[iht].InTraj <= 0) continue;
       unsigned int tid = slc.slHits[iht].InTraj;
       unsigned short indx = 0;
       for(indx = 0; indx < tID.size(); ++indx) if(tID[indx] == tid) break;
       if(indx == tID.size()) {
         tID.push_back(tid);
         tCnt.push_back(1);
       }  else {
         ++tCnt[indx];
       }
     } // iht
     if(tCnt.empty()) return false;
 
     // Call it a ghost if > 50% of the hits are used by another trajectory
     unsigned short tCut = 0.5 * tHits.size();
     int tid = INT_MAX;
 
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"IsGhost tHits size "<<tHits.size()<<" cut fraction "<<tCut<<" tID_tCnt";
       for(unsigned short ii = 0; ii < tCnt.size(); ++ii) myprt<<" "<<tID[ii]<<"_"<<tCnt[ii];
     } // prt
 
     for(unsigned short ii = 0; ii < tCnt.size(); ++ii) {
       if(tCnt[ii] > tCut) {
         tid = tID[ii];
         break;
       }
     } // ii
     if(tid > (int)slc.tjs.size()) return false;
 
     if(prt) mf::LogVerbatim("TC")<<" is ghost of trajectory "<<tid;
 
     // Use all hits in tHits that are found in itj
     for(auto& tp : slc.tjs[tid - 1].Pts) {
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         unsigned int iht = tp.Hits[ii];
         if(slc.slHits[iht].InTraj != 0) continue;
         for(unsigned short jj = 0; jj < tHits.size(); ++jj) {
           unsigned int tht = tHits[jj];
           if(tht != iht) continue;
           tp.UseHit[ii] = true;
           slc.slHits[iht].InTraj = tid;
           break;
         } // jj
       } // ii
     } // tp
     slc.tjs[tid - 1].AlgMod[kUseGhostHits] = true;
     return true;
 
   } // IsGhost

bool tca::IsShowerLike	(	TCSlice &	slc,
		const std::vector< int >	TjIDs
	)

Definition at line 1907 of file TCShower.cxx.

   {
     // 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)slc.tjs.size()) continue;
       if (slc.tjs[tid - 1].AlgMod[kShowerLike] > 0) ++cnt;
     } // tjid
     return (cnt > 1);
   } // IsInShower

void tca::KillPoorVertices ( TCSlice & slc )

Definition at line 2188 of file TCVertex.cxx.

   {
     // kill 2D vertices that have low score and are not attached to a high-score 3D vertex
     if (slc.vtxs.empty()) return;
     for (auto& vx : slc.vtxs) {
       if (vx.ID == 0) continue;
       if (vx.Score > tcc.vtx2DCuts[7]) continue;
       if (vx.Vx3ID > 0) {
         auto& vx3 = slc.vtx3s[vx.Vx3ID - 1];
         if (vx3.Primary) continue;
         if (slc.vtx3s[vx.Vx3ID - 1].Score >= tcc.vtx2DCuts[7]) continue;
       }
       MakeVertexObsolete("KPV", slc, vx, false);
     } // vx
 
   } // KillPoorVertices

void tca::KillVerticesInShower	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 709 of file TCShower.cxx.

   {
     // make the vertices inside the shower envelope obsolete and update dontCluster
     if (ss.ID == 0) return;
     if (!tcc.useAlg[kKillInShowerVx]) return;
     std::string fcnLabel = inFcnLabel + ".KVIS";
 
     for (auto& vx2 : slc.vtxs) {
       if (vx2.ID == 0) continue;
       if (vx2.CTP != ss.CTP) continue;
       // ensure it isn't associated with a neutrino vertex
       if (vx2.Vx3ID > 0 && slc.vtx3s[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 : slc.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(slc, "3V", vx2.Vx3ID, "T");
         for (auto tid : TIn3V)
           slc.tjs[tid - 1].AlgMod[kKillInShowerVx] = true;
         auto& vx3 = slc.vtx3s[vx2.Vx3ID - 1];
         MakeVertexObsolete(slc, vx3);
       }
       else {
         auto TIn2V = GetAssns(slc, "2V", vx2.ID, "T");
         for (auto tid : TIn2V)
           slc.tjs[tid - 1].AlgMod[kKillInShowerVx] = true;
         MakeVertexObsolete("KVIS", slc, vx2, true);
       }
     } // vx2
 
   } // KillVerticesInShower

float tca::KinkSignificance	(	TCSlice &	slc,
		Trajectory &	tj1,
		unsigned short	end1,
		Trajectory &	tj2,
		unsigned short	end2,
		unsigned short	nPtsFit,
		bool	useChg,
		bool	prt
	)

Definition at line 3054 of file Utils.cxx.

   {
     // returns the significance of a potential kink between the ends of two trajectories. This
     // is used when deciding to either merge trajectories or make a vertex between them
 
     if (tj1.CTP != tj2.CTP) return -1;
     if (end1 > 1 || end2 > 1) return -1;
 
     // construct a temporary trajectory to allow using the standard KinkSignificance function.
     // The first nPtsFit points are comprised of TPs from tj1 and the last nPtsFits points are from tj2
     Trajectory tj;
     tj.ID = 666;
     tj.CTP = tj1.CTP;
     short dir = 1;
     if (end1 == 1) dir = -1;
     unsigned short cnt = 0;
     // add tj1 points to the trajectory
     for (short ii = 0; ii < (short)tj1.Pts.size(); ++ii) {
       short ipt = tj1.EndPt[end1] + dir * ii;
       if (ipt < 0) break;
       if (ipt >= (short)tj1.Pts.size()) break;
       auto& tp = tj1.Pts[ipt];
       if (tp.Chg <= 0) continue;
       tj.Pts.push_back(tp);
       ++cnt;
       if (cnt == nPtsFit + 1) break;
     } // ipt
     if (cnt < nPtsFit) return -1;
     // add tj2 points to the trajectory
     dir = 1;
     if (end2 == 1) dir = -1;
     cnt = 0;
     for (short ii = 0; ii < (short)tj2.Pts.size(); ++ii) {
       short ipt = tj2.EndPt[end2] + dir * ii;
       if (ipt < 0) break;
       if (ipt >= (short)tj2.Pts.size()) break;
       auto& tp = tj2.Pts[ipt];
       if (tp.Chg <= 0) continue;
       tj.Pts.push_back(tp);
       ++cnt;
       if (cnt == nPtsFit + 1) break;
     } // ipt
     tj.EndPt[0] = 0;
     tj.EndPt[1] = tj.Pts.size() - 1;
     return KinkSignificance(slc, tj, nPtsFit, nPtsFit, useChg, prt);
   } // KinkSignificance

float tca::KinkSignificance	(	TCSlice &	slc,
		Trajectory &	tj,
		unsigned short	kinkPt,
		unsigned short	nPtsFit,
		bool	useChg,
		bool	prt
	)

Definition at line 3110 of file Utils.cxx.

   {
     // returns a kink significance in the trajectory at the presumed kink point kinkPt
     // using angle and (optional) charge asymmetry. The returned value is negative if there is insufficient
     // information.
     //
     // Check the limits
     if (kinkPt < tj.EndPt[0] + 2) return -1;
     if (kinkPt > tj.EndPt[1] - 2) return -1;
 
     // This function requires knowledge of the DOF of the line fit
     if (nPtsFit < 3) return -1;
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
     // need enough points to do a fit on each sideof the presumed kink point
     if (npwc < 2 * nPtsFit + 1) return -1;
 
     // The hit charge uncertainty is 0.12 - 0.15 (neglecting 2ndry interactions) for hadrons.
     // This translates into an error on the charge
     // asymmetry of about 0.07, or about 0.6 * the charge uncertainty
     double chgRMS = 0.07;
     // An additional contribution to the rms is the dependence on the DOF of the fit.
     // Apply a factor to the significance similar to (and simpler than) the Students t-distribution
     // This will increase the angle and charge error rms by 1.3 (1.05) when nPtsFit = 3 (8)
     double tFactor = 1 + 0.3 / double(nPtsFit - 2);
     chgRMS *= tFactor;
 
     // Fit the trajectory direction on the + side
     short fitDir = 1;
     TrajPoint tpPos;
     FitTraj(slc, tj, kinkPt, nPtsFit, fitDir, tpPos);
     if (tpPos.FitChi > 900) return -1;
     // repeat the trajectory fit on the - side
     fitDir = -1;
     TrajPoint tpNeg;
     FitTraj(slc, tj, kinkPt, nPtsFit, fitDir, tpNeg);
     if (tpNeg.FitChi > 900) return -1;
     double angErr = tpNeg.AngErr;
     if (tpPos.AngErr > angErr) angErr = tpPos.AngErr;
     angErr *= tFactor;
     double dang = DeltaAngle(tpPos.Ang, tpNeg.Ang);
     double dangSig = dang / angErr;
 
     double chgAsym = 0;
     double chgSig = 0;
     if (useChg) {
       // Sum the charge Neg and Pos, excluding the kinkPt
       double chgNeg = 0;
       unsigned short cntNeg = 0;
       for (unsigned short ipt = kinkPt - 1; ipt >= tj.EndPt[0]; --ipt) {
         auto& tp = tj.Pts[ipt];
         if (tp.Chg <= 0) continue;
         chgNeg += tp.Chg;
         ++cntNeg;
         if (cntNeg == nPtsFit) break;
         if (ipt == 0) break;
       } // ipt
       if (cntNeg != nPtsFit) {
         if (prt) mf::LogVerbatim("TC") << " KL: Bad cntNeg " << cntNeg << " != " << nPtsFit;
         return -1;
       }
       // now Pos
       double chgPos = 0;
       unsigned short cntPos = 0;
       for (unsigned short ipt = kinkPt + 1; ipt <= tj.EndPt[1]; ++ipt) {
         auto& tp = tj.Pts[ipt];
         if (tp.Chg <= 0) continue;
         chgPos += tp.Chg;
         ++cntPos;
         if (cntPos == nPtsFit) break;
       } // ipt
       if (cntPos != nPtsFit) {
         if (prt) mf::LogVerbatim("TC") << " KL: Bad cntPos " << cntPos << " != " << nPtsFit;
         return -1;
       }
       chgNeg /= (float)nPtsFit;
       chgPos /= (float)nPtsFit;
       // The charge asymmetry varies between 0 and 1;
       chgAsym = std::abs(chgPos - chgNeg) / (chgPos + chgNeg);
       // calculate the charge asymmetry significance
       chgSig = chgAsym / chgRMS;
     } // useChg
     double kinkSig = sqrt(dangSig * dangSig + chgSig * chgSig);
 
     if (prt) {
       mf::LogVerbatim myprt("TC");
       myprt << "KL: T" << tj.ID << " kinkPt " << PrintPos(slc, tj.Pts[kinkPt]);
       myprt << " nPtsFit " << nPtsFit;
       myprt << " dang " << std::fixed << std::setprecision(3) << dang;
       myprt << std::fixed << std::setprecision(3) << " angErr " << angErr;
       myprt << std::setprecision(2) << " sig " << dangSig;
       myprt << " chgAsym " << chgAsym;
       myprt << " chgSig " << chgSig;
       myprt << " kinkSig " << kinkSig;
     }
     return (float)kinkSig;
   } // KinkSignificance

void tca::LastEndMerge	(	TCSlice &	slc,
		CTP_t	inCTP
	)

Definition at line 3106 of file StepUtils.cxx.

   {
     // last ditch attempt to merge long straight broken trajectories by averaging
     // all points in the trajectory and applying tight angle and separation cuts.
     if(slc.tjs.size() < 2) return;
     if(!tcc.useAlg[kLastEndMerge]) return;
 
     bool prt = tcc.dbgAlg[kLastEndMerge];
 
     // create an averaged TP for each long Trajectory
     std::vector<TrajPoint> tjTP;
     for(auto& tj : slc.tjs) {
       if(tj.AlgMod[kKilled]) continue;
       if(tj.CTP != inCTP) continue;
       if(tj.Pts.size() < 10) continue;
       if(tj.MCSMom < 100) continue;
       auto tjtp = CreateTPFromTj(slc, tj);
       if(tjtp.Chg < 0) continue;
       tjTP.push_back(tjtp);
     } // tj
     if(tjTP.size() < 2) return;
 
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"inside LastEndMerge slice "<<slices.size()-1<<" inCTP "<<inCTP<<" tjTPs";
       for(auto& tjtp : tjTP) myprt<<" T"<<tjtp.Step;
     }
 
     for(unsigned short pt1 = 0; pt1 < tjTP.size() - 1; ++pt1) {
       auto& tp1 = tjTP[pt1];
       auto& tj1 = slc.tjs[tp1.Step - 1];
       if(tj1.AlgMod[kKilled]) continue;
       for(unsigned short pt2 = pt1 + 1; pt2 < tjTP.size(); ++pt2) {
         auto& tp2 = tjTP[pt2];
         auto& tj2 = slc.tjs[tp2.Step - 1];
         if(tj2.AlgMod[kKilled]) continue;
         float dang = DeltaAngle(tp1.Ang, tp2.Ang);
         // make an angle cut
         if(prt && dang < 0.5) mf::LogVerbatim("TC")<<" T"<<tj1.ID<<" T"<<tj2.ID<<" dang "<<dang;
         if(dang > 0.2) continue;
         // and an impact parameter cut
         unsigned short ipt1, ipt2;
         float ip12 = PointTrajDOCA(slc, tp1.Pos[0], tp1.Pos[1], tp2);
         float ip21 = PointTrajDOCA(slc, tp2.Pos[0], tp2.Pos[1], tp1);
         if(prt) mf::LogVerbatim("TC")<<" ip12 "<<ip12<<" ip21 "<<ip21;
         if(ip12 > 15 && ip21 > 15) continue;
         float minSep = 100;
         // find the separation considering dead wires
         TrajTrajDOCA(slc, tj1, tj2, ipt1, ipt2, minSep, false);
         if(minSep == 100) continue;
         if(ipt1 >= tj1.Pts.size() || ipt2 >= tj2.Pts.size()) continue;
         float dwc = DeadWireCount(slc, tj1.Pts[ipt1], tj2.Pts[ipt2]);
         if(prt) mf::LogVerbatim("TC")<<" minSep "<<minSep<<" dwc "<<dwc;
         minSep -= dwc;
         if(minSep > 5) continue;
         // finally require that the proximate points are close to the ends
         float sep10 = PosSep(tj1.Pts[ipt1].Pos, tj1.Pts[tj1.EndPt[0]].Pos);
         float sep11 = PosSep(tj1.Pts[ipt1].Pos, tj1.Pts[tj1.EndPt[1]].Pos);
         if(sep10 > 5 && sep11 > 5) continue;
         unsigned short end1 = 0;
         if(sep11 < sep10) end1 = 1;
         float sep20 = PosSep(tj2.Pts[ipt2].Pos, tj2.Pts[tj2.EndPt[0]].Pos);
         float sep21 = PosSep(tj2.Pts[ipt2].Pos, tj2.Pts[tj2.EndPt[1]].Pos);
         if(sep20 > 5 && sep21 > 5) continue;
         unsigned short end2 = 0;
         if(sep21 < sep20) end2 = 1;
         // don't merge if there is a kink
         if(tj1.EndFlag[end1][kAtKink] || tj2.EndFlag[end2][kAtKink]) continue;
         if(prt) {
           mf::LogVerbatim myprt("TC");
           myprt<<"LEM: T"<<tj1.ID<<"_"<<PrintPos(slc, tp1);
           if(tj1.VtxID[end1] > 0) myprt<<"->2V"<<tj1.VtxID[end1];
           myprt<<" T"<<tj2.ID<<"_"<<PrintPos(slc, tp2);
           if(tj2.VtxID[end2] > 0) myprt<<"->2V"<<tj2.VtxID[end2];
           myprt<<" dang "<<std::setprecision(2)<<dang<<" ip12 "<<ip12;
           myprt<<" ip21 "<<ip21;
           myprt<<" minSep "<<minSep;
           myprt<<" end sep1 "<<sep10<<" "<<sep11;
           myprt<<" end sep2 "<<sep20<<" "<<sep21;
         } // prt
         if(tj1.VtxID[end1] > 0) {
           auto& vx2 = slc.vtxs[tj1.VtxID[end1] - 1];
           MakeVertexObsolete("LEM", slc, vx2, true);
         }
         if(tj2.VtxID[end2] > 0 && tj2.VtxID[end2] != tj1.VtxID[end1]) {
           auto& vx2 = slc.vtxs[tj2.VtxID[end2] - 1];
           MakeVertexObsolete("LEM", slc, vx2, true);
         }
         // remove Bragg flags
         tj1.EndFlag[end1][kBragg] = false;
         tj2.EndFlag[end2][kBragg] = false;
         unsigned int it1 = tj1.ID - 1;
         unsigned int it2 = tj2.ID - 1;
         if(!MergeAndStore(slc, it1, it2, tcc.dbgMrg)) continue;
         // set the AlgMod bit
         auto& ntj = slc.tjs[slc.tjs.size() - 1];
         ntj.AlgMod[kLastEndMerge] = true;
         // create a tp for this tj and add it to the list
         auto tjtp = CreateTPFromTj(slc, ntj);
         if(tjtp.Chg < 0) continue;
         if(prt) mf::LogVerbatim("TC")<<" added T"<<ntj.ID<<" to the merge list";
         tjTP.push_back(tjtp);
         break;
       } // pt1
     } // pt1
 
   } // LastEndMerge

float tca::Length ( const PFPStruct & pfp )

Definition at line 3303 of file PFPUtils.cxx.

   {
     if (pfp.TP3Ds.empty()) return 0;
     return PosSep(pfp.TP3Ds[0].Pos, pfp.TP3Ds[pfp.TP3Ds.size() - 1].Pos);
   } // Length

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

Definition at line 3132 of file PFPUtils.cxx.

   {
     /*
      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

bool tca::LongPulseHit ( const recob::Hit & hit )

Definition at line 4450 of file Utils.cxx.

   {
     // return true if the hit is in a long pulse indicating that it's position
     // and charge are not well known
     return ((hit.GoodnessOfFit() < 0 || hit.GoodnessOfFit() > 50) && hit.Multiplicity() > 5);
   }

TrajPoint tca::MakeBareTP	(	detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		const Point3_t &	pos,
		CTP_t	inCTP
	)

Definition at line 4025 of file Utils.cxx.

   {
     // A version to use when the 2D direction isn't required
     TrajPoint tp;
     tp.Pos = {{0, 0}};
     tp.Dir = {{0, 1}};
     tp.CTP = inCTP;
     geo::PlaneID planeID = DecodeCTP(inCTP);
 
     tp.Pos[0] = tcc.geom->WireCoordinate(pos[1], pos[2], planeID);
     tp.Pos[1] = detProp.ConvertXToTicks(pos[0], planeID) * tcc.unitsPerTick;
     return tp;
   } // MakeBareTP

TrajPoint tca::MakeBareTP	(	detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		const Point3_t &	pos,
		const Vector3_t &	dir,
		CTP_t	inCTP
	)

Definition at line 4044 of file Utils.cxx.

   {
     // 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 = {{-1, 0}};
     tp.Dir = {{0, 1}};
     tp.CTP = inCTP;
     geo::PlaneID planeID = DecodeCTP(inCTP);
 
     tp.Pos[0] = tcc.geom->WireCoordinate(pos[1], pos[2], planeID);
     tp.Pos[1] = detProp.ConvertXToTicks(pos[0], planeID) * tcc.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
     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] = tcc.geom->WireCoordinate(ori3[1], ori3[2], planeID);
     pos2[0] = tcc.geom->WireCoordinate(pos3[1], pos3[2], planeID);
     // the time coordinates
     ori2[1] = detProp.ConvertXToTicks(ori3[0], planeID) * tcc.unitsPerTick;
     pos2[1] = detProp.ConvertXToTicks(pos3[0], planeID) * tcc.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 = tcc.geom->WireCoordinate(0, 0, planeID);
     // cosine-like component
     double cs = tcc.geom->WireCoordinate(1, 0, planeID) - w0;
     // sine-like component
     double sn = tcc.geom->WireCoordinate(0, 1, planeID) - w0;
     norm = sqrt(cs * cs + sn * sn);
     tp.Delta /= norm;
 
     // Stasb dt/dWire in DeltaRMS. This is used in PFPUtils/FitSection to find the
     // distance along a 3D line given the wire number in a plane
     tp.DeltaRMS = 100 / (pos2[0] - ori2[0]);
     return tp;
 
   } // MakeBareTP

bool tca::MakeBareTrajPoint	(	const TCSlice &	slc,
		unsigned int	fromHit,
		unsigned int	toHit,
		TrajPoint &	tp
	)

Definition at line 4108 of file Utils.cxx.

   {
     if (fromHit > slc.slHits.size() - 1) return false;
     if (toHit > slc.slHits.size() - 1) return false;
     auto& fhit = (*evt.allHits)[slc.slHits[fromHit].allHitsIndex];
     auto& thit = (*evt.allHits)[slc.slHits[toHit].allHitsIndex];
     CTP_t tCTP = EncodeCTP(fhit.WireID());
     return MakeBareTrajPoint(slc,
                              (float)fhit.WireID().Wire,
                              fhit.PeakTime(),
                              (float)thit.WireID().Wire,
                              thit.PeakTime(),
                              tCTP,
                              tp);
 
   } // MakeBareTrajPoint

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

Definition at line 4127 of file Utils.cxx.

   {
     tp.CTP = tCTP;
     tp.Pos[0] = fromWire;
     tp.Pos[1] = tcc.unitsPerTick * fromTick;
     tp.Dir[0] = toWire - fromWire;
     tp.Dir[1] = tcc.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 4150 of file Utils.cxx.

   {
     tpOut.Pos = fromPos;
     tpOut.Dir = PointDirection(fromPos, toPos);
     tpOut.Ang = atan2(tpOut.Dir[1], tpOut.Dir[0]);
     return true;
 
   } // MakeBareTrajPoint

bool tca::MakeBareTrajPoint	(	const TCSlice &	slc,
		const TrajPoint &	tpIn1,
		const TrajPoint &	tpIn2,
		TrajPoint &	tpOut
	)

Definition at line 4161 of file Utils.cxx.

   {
     tpOut.CTP = tpIn1.CTP;
     tpOut.Pos = tpIn1.Pos;
     tpOut.Dir = PointDirection(tpIn1.Pos, tpIn2.Pos);
     tpOut.Ang = atan2(tpOut.Dir[1], tpOut.Dir[0]);
     return true;
   } // MakeBareTrajPoint

void tca::MakeHaloTj	(	TCSlice &	slc,
		Trajectory &	muTj,
		bool	prt
	)

Definition at line 45 of file Utils.cxx.

   {
     // Creates a "halo trajectory" around a muon tj consisting of hits and trajectories
     // that are within MuonTag[4] distance. The halo tj is a virtual clone of muTj in the
     // sense that it has the same number of points and the same start and end points.
 
     if (tcc.muonTag.size() < 5) return;
     if (tcc.muonTag[4] <= 0) return;
     if (!tcc.useAlg[kHaloTj]) return;
 
     if (muTj.PDGCode != 13) return;
 
     // check for daughter delta-rays
     std::vector<int> dtrs;
     for (auto& dtj : slc.tjs) {
       if (dtj.AlgMod[kKilled]) continue;
       if (dtj.ParentID != muTj.ID) continue;
       dtrs.push_back(dtj.ID);
       if (!dtj.AlgMod[kDeltaRay]) continue;
       if (prt) mf::LogVerbatim("TC") << "MakeHaloTj: Killing delta-ray T" << dtj.ID;
       // Kill a delta-ray PFParticle?
       if (dtj.AlgMod[kMat3D]) {
         unsigned short pfpIndex = GetPFPIndex(slc, dtj.ID);
         if (pfpIndex == USHRT_MAX) {
           if (prt) mf::LogVerbatim("TC") << " No PFP found for 3D-matched delta-ray";
         }
         else {
           auto& pfp = slc.pfps[pfpIndex];
           if (prt) mf::LogVerbatim("TC") << " Killing delta-ray PFParticle P" << pfp.UID;
           pfp.ID = 0;
           // correct the parent -> daughter assn
           if (pfp.ParentUID > 0) {
             auto parentIndx = GetSliceIndex("P", pfp.ParentUID);
             if (parentIndx.first != USHRT_MAX) {
               auto& parent = slices[parentIndx.first].pfps[parentIndx.second];
               std::vector<int> newDtrUIDs;
               for (auto uid : parent.DtrUIDs)
                 if (uid != dtj.UID) newDtrUIDs.push_back(uid);
               parent.DtrUIDs = newDtrUIDs;
             } // parent found
           }   // correct the parent
         }     // kill PFParticle
       }       // kill
       MakeTrajectoryObsolete(slc, (unsigned int)(dtj.ID - 1));
     } // dtj
 
     // make a copy
     Trajectory tj;
     tj.CTP = muTj.CTP;
     // We can't use StoreTraj so variables need to be defined here
     tj.ID = slc.tjs.size() + 1;
     tj.WorkID = muTj.WorkID;
     // increment the global ID
     ++evt.globalT_UID;
     tj.UID = evt.globalT_UID;
     tj.PDGCode = 11;
     tj.Pass = muTj.Pass;
     tj.StepDir = muTj.StepDir;
     tj.StartEnd = muTj.StartEnd;
     tj.TotChg = 0;
     tj.ChgRMS = 0;
     tj.EndPt[0] = 0;
     tj.ParentID = muTj.ID;
     tj.AlgMod.reset();
     tj.AlgMod[kHaloTj] = true;
     // start a list of tjs that have points near the muon
     std::vector<int> closeTjs;
     for (unsigned short ipt = muTj.EndPt[0]; ipt <= muTj.EndPt[1]; ++ipt) {
       auto tp = muTj.Pts[ipt];
       tp.Hits.resize(0);
       tp.UseHit.reset();
       tp.Chg = 0;
       tp.AveChg = 0;
       tp.ChgPull = 0;
       tp.Delta = 0;
       tp.DeltaRMS = 0;
       tp.FitChi = 0;
       tp.NTPsFit = 0;
       float window = tcc.muonTag[4];
       if (tp.Dir[0] != 0) window *= std::abs(1 / tp.Dir[0]);
       if (!FindCloseHits(slc, tp, window, kAllHits)) continue;
       // add unused hits to the point and look for close tjs
       bool hitsAdded = false;
       for (unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         unsigned int iht = tp.Hits[ii];
         auto inTraj = slc.slHits[iht].InTraj;
         if (inTraj < 0) continue;
         if (inTraj == 0) {
           tp.UseHit[ii] = true;
           slc.slHits[iht].InTraj = tj.ID;
           hitsAdded = true;
         }
         else {
           // add to the closeTjs list
           if (inTraj != muTj.ID &&
               std::find(closeTjs.begin(), closeTjs.end(), inTraj) == closeTjs.end())
             closeTjs.push_back(inTraj);
         }
       } // ii
       if (hitsAdded) {
         DefineHitPos(slc, tp);
         tp.Delta = PointTrajDOCA(slc, tp.HitPos[0], tp.HitPos[1], tp);
         tj.TotChg += tp.Chg;
         tj.Pts.push_back(tp);
       } // hitsAdded
     }   // ipt
     if (tj.Pts.empty()) return;
     tj.EndPt[1] = tj.Pts.size() - 1;
     if (prt) {
       mf::LogVerbatim myprt("TC");
       myprt << "MHTj: T" << muTj.ID << " npts " << tj.Pts.size() << " close";
       for (auto tid : closeTjs)
         myprt << " T" << tid;
       myprt << "\n";
       PrintTrajectory("DM", slc, tj, USHRT_MAX);
     }
     slc.tjs.push_back(tj);
   } // MakeHaloTj

void tca::MakeJunkTjVertices	(	TCSlice &	slc,
		const CTP_t &	inCTP
	)

bool tca::MakeJunkTraj	(	TCSlice &	slc,
		std::vector< unsigned int >	tHits
	)

Definition at line 3866 of file StepUtils.cxx.

   {
     if(!tcc.useAlg[kJunkTj]) return false;
     // Make a crummy trajectory using the provided hits
 
     if(tHits.size() < 2) return false;
 
     bool prt = false;
     if(tcc.dbgAlg[kJunkTj]) {
       for(unsigned short ii = 0; ii < tHits.size(); ++ii) {
         if(slc.slHits[tHits[ii]].allHitsIndex == debug.Hit) {
           prt = true;
           break;
         }
       } // ii
       if(prt) std::cout<<"MakeJunkTraj found debug hit\n";
     } // tcc.dbgAlg[kJunkTj]
 
     // Start the trajectory using the first and last hits to
     // define a starting direction. Use the last pass settings
     Trajectory work;
     unsigned short pass = tcc.minPts.size() - 1;
     if(!StartTraj(slc, work, tHits[0], tHits[tHits.size()-1], pass)) return false;
     // make a TP for every hit
     work.Pts.resize(tHits.size());
     // and put a hit into each one
     for(unsigned short ii = 0; ii < tHits.size(); ++ii) {
       auto& tp = work.Pts[ii];
       unsigned int iht = tHits[ii];
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       tp.CTP = EncodeCTP(hit.WireID());
       if(tp.CTP != work.CTP) return false;
       tp.Hits.push_back(iht);
       tp.UseHit[0] = true;
       // don't use DefineHitPos here because the angle isn't really known yet. Just
       // define enough information to do a fit
       tp.HitPos[0] = hit.WireID().Wire;
       tp.HitPos[1] = hit.PeakTime() * tcc.unitsPerTick;
       tp.HitPosErr2 = 100;
       tp.Chg = hit.Integral();
       tp.Step = ii;
       tp.NTPsFit = tHits.size();
       // flag long-pulse hits
       if(LongPulseHit(hit)) tp.Environment[kEnvUnusedHits] = true;
     } // ii
     work.EndPt[0] = 0;
     work.EndPt[1] = tHits.size() - 1;
     // do an initial fit. The fit results are put in the last TP.
     FitTraj(slc, work);
     auto& lastTP = work.Pts.back();
     // Prepare to sort along the general direction. First find the
     // along and transverse position (Delta) of each TP and calculate DeltaRMS
     double sum = 0.;
     double sum2 = 0.;
     for(auto& tp : work.Pts) {
       Point2_t at;
       FindAlongTrans(lastTP.Pos, lastTP.Dir, tp.HitPos, at);
       sum += at[1];
       sum2 += at[1] * at[1];
       // store the along distance in AveChg for now
       tp.AveChg = at[0];
       tp.Delta = at[1];
       if(tp.Step != lastTP.Step) {
         tp.FitChi = lastTP.FitChi;
         tp.Dir = lastTP.Dir;
         tp.Ang = lastTP.Ang;
         tp.Pos[0] = lastTP.Pos[0] + at[0] * lastTP.Dir[0];
         tp.Pos[1] = lastTP.Pos[1] + at[0] * lastTP.Dir[1];
       }
     } // tp
     double npts = tHits.size();
     sum /= npts;
     double arg = sum2 - npts * sum * sum;
     if(arg <= 0) return false;
     float rms = sqrt(arg) / (npts - 1);
     // apply a loose Delta cut
     float transCut = sum + 3 * rms;
     std::vector<SortEntry> sortVec;
     SortEntry se;
     work.TotChg = 0;
     work.NeedsUpdate = false;
     for(auto& tp : work.Pts) {
       if(tp.Delta > transCut && !tp.Environment[kEnvUnusedHits]) {
         work.NeedsUpdate = true;
         continue;
       }
       se.index = tp.Step;
       se.val = tp.AveChg;
       sortVec.push_back(se);
       tp.DeltaRMS = rms;
       work.TotChg += tp.Chg;
     } // tp
     if(sortVec.size() < 3) return false;
     std::sort(sortVec.begin(), sortVec.end(), valsDecreasing);
     std::vector<TrajPoint> ntps(sortVec.size());
     for(unsigned short ipt = 0; ipt < sortVec.size(); ++ipt) ntps[ipt] = work.Pts[sortVec[ipt].index];
     work.Pts = ntps;
     sum = work.TotChg / (double)ntps.size();
     if(work.NeedsUpdate) {
       work.EndPt[1] = work.Pts.size() - 1;
       UpdateTraj(slc, work);
     } // needs update
     work.AlgMod[kJunkTj] = true;
     work.IsGood = true;
     if(prt) {
       PrintTrajectory("MJT", slc, work, USHRT_MAX);
     }
     // Store it
     return StoreTraj(slc, work);
   } // MakeJunkTraj

void tca::MakeJunkVertices	(	TCSlice &	slc,
		const CTP_t &	inCTP
	)

Definition at line 45 of file TCVertex.cxx.

   {
     // Vertices between poorly reconstructed tjs (especially junk slc) 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 (tcc.vtx2DCuts[0] <= 0) return;
     if (!tcc.useAlg[kJunkVx]) return;
     if (slc.tjs.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 = (tcc.dbgVxJunk && tcc.dbgSlc);
     if (prt) {
       mf::LogVerbatim("TC") << "MakeJunkVertices: prt set for plane " << planeID.Plane
                             << " maxSep btw tjs " << maxSep;
     }
 
     // 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
     junkVx.PosErr = {{2.0, 2.0}};
     // define a minimal score so it won't get clobbered
     junkVx.Score = tcc.vtx2DCuts[7] + 0.1;
 
     // look at both ends of long tjs
     for (unsigned short it1 = 0; it1 < slc.tjs.size() - 1; ++it1) {
       auto& tj1 = slc.tjs[it1];
       if (tj1.AlgMod[kKilled] || tj1.AlgMod[kHaloTj]) 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(slc, tp1, tp1, maxSep);
         if (tjlist.empty()) continue;
         // set to an invalid ID
         junkVx.ID = USHRT_MAX;
         for (auto tj2id : tjlist) {
           auto& tj2 = slc.tjs[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(slc, tp1, tp2, 0.8);
           if (!signalBetween) continue;
           if (junkVx.ID == USHRT_MAX) {
             // define the new vertex
             junkVx.ID = slc.vtxs.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(slc, junkVx)) {
           mf::LogVerbatim("TC") << "MJV: StoreVertex failed";
           for (auto& tj : slc.tjs) {
             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] / tcc.unitsPerTick;
         } // prt
         junkVx.ID = USHRT_MAX;
       } // end1
     }   // it1
 
   } // MakeJunkVertices

void tca::MakePFParticles	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc,
		std::vector< MatchStruct >	matVec,
		unsigned short	matVec_Iter
	)

Definition at line 267 of file PFPUtils.cxx.

   {
     // Makes PFParticles using Tjs listed in matVec
     if (matVec.empty()) return;
 
     bool prt = (tcc.dbgPFP && tcc.dbgSlc);
 
     // create a PFParticle for each valid match combination
     for (std::size_t indx = 0; indx < matVec.size(); ++indx) {
       // tone down the level of printing in ReSection
       bool foundMVI = (tcc.dbgPFP && indx == debug.MVI && matVec_Iter == debug.MVI_Iter);
       if (foundMVI) prt = true;
       auto& ms = matVec[indx];
       if (foundMVI) {
         std::cout << "found MVI " << indx << " in MakePFParticles ms.Count = " << ms.Count << "\n";
       }
       // ignore dead matches
       if (ms.Count == 0) continue;
       // count the number of TPs that are available (not already 3D-matched) and used in a pfp
       float npts = 0;
       for (std::size_t itj = 0; itj < ms.TjIDs.size(); ++itj) {
         auto& tj = slc.tjs[ms.TjIDs[itj] - 1];
         for (unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt)
           if (tj.Pts[ipt].InPFP == 0) ++npts;
       } // tjID
       // Create a vector of PFPs for this match so that we can split it later on if a kink is found
       std::vector<PFPStruct> pfpVec(1);
       pfpVec[0] = CreatePFP(slc);
       // Define the starting set of tjs that were matched. TPs from other tjs may be added later
       pfpVec[0].TjIDs = ms.TjIDs;
       pfpVec[0].MVI = indx;
       // fill the TP3D points using the 2D trajectory points for Tjs in TjIDs. All
       // points are put in one section
       if (!MakeTP3Ds(detProp, slc, pfpVec[0], foundMVI)) {
         if (foundMVI) mf::LogVerbatim("TC") << " MakeTP3Ds failed. Too many points already used ";
         continue;
       }
       // fit all the points to get the general direction
       if (!FitSection(clockData, detProp, slc, pfpVec[0], 0)) continue;
       if (pfpVec[0].SectionFits[0].ChiDOF > 500 && !pfpVec[0].Flags[kSmallAngle]) {
         if (foundMVI)
           mf::LogVerbatim("TC") << " crazy high ChiDOF P" << pfpVec[0].ID << " "
                                 << pfpVec[0].SectionFits[0].ChiDOF << "\n";
         Recover(clockData, detProp, slc, pfpVec[0], foundMVI);
         continue;
       }
       // sort the points by the distance along the general direction vector
       if (!SortSection(pfpVec[0], 0)) continue;
       // define a junk pfp to be short with low MCSMom. These are likely to be shower-like
       // pfps. A simple 3D line fit will be done. No attempt will be made to reconstruct it
       // in sections or to look for kinks
       npts = pfpVec[0].TP3Ds.size();
       pfpVec[0].AlgMod[kJunk3D] = (npts < 20 && MCSMom(slc, pfpVec[0].TjIDs) < 50) || (npts < 10);
       if (prt) {
         auto& pfp = pfpVec[0];
         mf::LogVerbatim myprt("TC");
         myprt << " indx " << matVec_Iter << "/" << indx << " Count " << std::setw(5)
               << (int)ms.Count;
         myprt << " P" << pfpVec[0].ID;
         myprt << " ->";
         for (auto& tjid : pfp.TjIDs)
           myprt << " T" << tjid;
         myprt << " projInPlane";
         for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
           CTP_t inCTP = EncodeCTP(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
           auto tp = MakeBareTP(detProp, slc, pfp.SectionFits[0].Pos, pfp.SectionFits[0].Dir, inCTP);
           myprt << " " << std::setprecision(2) << tp.Delta;
         } // plane
         myprt << " maxTjLen " << (int)MaxTjLen(slc, pfp.TjIDs);
         myprt << " MCSMom " << MCSMom(slc, pfp.TjIDs);
         myprt << " PDGCodeVote " << PDGCodeVote(clockData, detProp, slc, pfp);
         myprt << " nTP3Ds " << pfp.TP3Ds.size();
         myprt << " Reco3DRange "
               << Find3DRecoRange(slc, pfp, 0, (unsigned short)tcc.match3DCuts[3], 1);
       } // prt
       if (foundMVI) { PrintTP3Ds(clockData, detProp, "FF", slc, pfpVec[0], -1); }
       for (unsigned short ip = 0; ip < pfpVec.size(); ++ip) {
         auto& pfp = pfpVec[ip];
         // set the end flag bits
         geo::TPCID tpcid;
         for (unsigned short end = 0; end < 2; ++end) {
           // first set them all to 0
           pfp.EndFlag[end].reset();
           auto pos = PosAtEnd(pfp, end);
           if (!InsideTPC(pos, tpcid)) pfp.EndFlag[end][kOutFV] = true;
         } // end
         // Set kink flag and create a vertex between this pfp and the previous one that was stored
         if (ip > 0) {
           pfp.EndFlag[0][kAtKink] = true;
           Vtx3Store vx3;
           vx3.TPCID = pfp.TPCID;
           vx3.X = pfp.TP3Ds[0].Pos[0];
           vx3.Y = pfp.TP3Ds[0].Pos[1];
           vx3.Z = pfp.TP3Ds[0].Pos[2];
           // TODO: Errors, Score?
           vx3.Score = 100;
           vx3.Vx2ID.resize(slc.nPlanes);
           vx3.Wire = -2;
           vx3.ID = slc.vtx3s.size() + 1;
           vx3.Primary = false;
           ++evt.global3V_UID;
           vx3.UID = evt.global3V_UID;
           slc.vtx3s.push_back(vx3);
           pfp.Vx3ID[0] = vx3.ID;
           auto& prevPFP = slc.pfps[slc.pfps.size() - 1];
           prevPFP.Vx3ID[1] = vx3.ID;
         } // ip > 0
         // check for a valid two-plane match with a Tj in the third plane for long pfps.
         // For short pfps, it is possible that a Tj would be too short to be reconstructed
         // in the third plane.
         if (pfp.TjIDs.size() == 2 && slc.nPlanes == 3 && pfp.TP3Ds.size() > 20 &&
             !ValidTwoPlaneMatch(detProp, slc, pfp)) {
           continue;
         }
         // Skip this combination if it isn't reconstructable in 3D
         if (Find3DRecoRange(slc, pfp, 0, (unsigned short)tcc.match3DCuts[3], 1) == USHRT_MAX)
           continue;
         // See if it possible to reconstruct in more than one section
         pfp.Flags[kCanSection] = CanSection(slc, pfp);
         // Do a fit in multiple sections if the initial fit is poor
         if (pfp.SectionFits[0].ChiDOF < tcc.match3DCuts[5]) {
           // Good fit with one section
           pfp.Flags[kNeedsUpdate] = false;
         }
         else if (pfp.Flags[kCanSection]) {
           if (!ReSection(clockData, detProp, slc, pfp, foundMVI)) continue;
         } // CanSection
         if (foundMVI) { PrintTP3Ds(clockData, detProp, "RS", slc, pfp, -1); }
         // FillGaps3D looks for gaps in the TP3Ds vector caused by broken trajectories and
         // inserts new TP3Ds if there are hits in the gaps. This search is only done in a
         // plane if the projection of the pfp results in a large angle where 2D reconstruction
         // is likely to be poor - not true for TCWork2
         FillGaps3D(clockData, detProp, slc, pfp, foundMVI);
         // Check the TP3D -> TP assn, resolve conflicts and set TP -> InPFP
         if (!ReconcileTPs(slc, pfp, foundMVI)) continue;
         // Look for mis-placed 2D and 3D vertices
         ReconcileVertices(slc, pfp, foundMVI);
         // Set isGood
         for (auto& tp3d : pfp.TP3Ds) {
           if (tp3d.Flags[kTP3DBad]) continue;
           auto& tp = slc.tjs[tp3d.TjID - 1].Pts[tp3d.TPIndex];
           if (tp.Environment[kEnvOverlap]) tp3d.Flags[kTP3DGood] = false;
         } // tp3d
         FilldEdx(clockData, detProp, slc, pfp);
         pfp.PDGCode = PDGCodeVote(clockData, detProp, slc, pfp);
         if (tcc.dbgPFP && pfp.MVI == debug.MVI)
           PrintTP3Ds(clockData, detProp, "STORE", slc, pfp, -1);
         if (!StorePFP(slc, pfp)) break;
       } // ip (iterate over split pfps)
     }   // indx (iterate over matchVec entries)
     slc.mallTraj.resize(0);
   } // MakePFParticles

void tca::MakePFPTjs ( TCSlice & slc )

Definition at line 512 of file PFPUtils.cxx.

   {
     // This function clobbers all of the tjs that are used in TP3Ds in the pfp and replaces
     // them with new tjs that have a consistent set of TPs to prepare for putting them
     // into the event. Note that none of the Tjs are attached to 2D vertices.
     if (!tcc.useAlg[kMakePFPTjs]) return;
 
     // kill trajectories
     std::vector<int> killme;
     for (auto& pfp : slc.pfps) {
       if (pfp.ID <= 0) continue;
       for (auto& tp3d : pfp.TP3Ds) {
         if (tp3d.TjID <= 0) continue;
         if (tp3d.Flags[kTP3DBad]) continue;
         if (std::find(killme.begin(), killme.end(), tp3d.TjID) == killme.end())
           killme.push_back(tp3d.TjID);
       } // tp3d
     }   // pfp
 
     bool prt = (tcc.dbgPFP);
 
     for (auto tid : killme)
       MakeTrajectoryObsolete(slc, (unsigned int)(tid - 1));
 
     // Make template trajectories in each plane. These will be re-used by
     // each PFParticle
     std::vector<Trajectory> ptjs(slc.nPlanes);
     // define the basic tj variables
     for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
       ptjs[plane].Pass = 0;
       ptjs[plane].CTP = EncodeCTP(slc.TPCID.Cryostat, slc.TPCID.TPC, plane);
       // This Tj wasn't created by stepping
       ptjs[plane].StepDir = 0;
       // It was created by this function however
       ptjs[plane].AlgMod[kMakePFPTjs] = true;
       // and is 3D matched
       ptjs[plane].AlgMod[kMat3D] = true;
     } // plane
 
     // now make the new Tjs
     for (auto& pfp : slc.pfps) {
       if (pfp.ID <= 0) continue;
       // initialize the tjs
       for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
         ptjs[plane].Pts.clear();
         --evt.WorkID;
         if (evt.WorkID == INT_MIN) evt.WorkID = -1;
         ptjs[plane].ID = evt.WorkID;
       } // plane
       pfp.TjIDs.clear();
       // iterate through all of the TP3Ds, adding TPs to the TJ in the appropriate plane.
       // The assumption here is that TP order reflects the TP3D order
       for (auto& tp3d : pfp.TP3Ds) {
         if (tp3d.TjID <= 0) continue;
         if (tp3d.Flags[kTP3DBad]) continue;
         // make a copy of the 2D TP
         auto tp = slc.tjs[tp3d.TjID - 1].Pts[tp3d.TPIndex];
         if (tp.InPFP > 0 && tp.InPFP != pfp.ID) continue;
         tp.InPFP = pfp.ID;
         // the TP Step isn't useful anymore, so stash the original TJ ID into it
         tp.Step = tp3d.TjID;
         unsigned short plane = DecodeCTP(tp.CTP).Plane;
         // append it to Pts
         ptjs[plane].Pts.push_back(tp);
       } // tp3d
       // finish defining each of the Tjs and store them
       // new tj ID indexed by plane
       std::vector<int> tids(ptjs.size(), 0);
       for (unsigned short plane = 0; plane < ptjs.size(); ++plane) {
         auto& tj = ptjs[plane];
         if (tj.Pts.size() < 2) continue;
         tj.PDGCode = pfp.PDGCode;
         tj.MCSMom = MCSMom(slc, tj);
         if (!StoreTraj(slc, tj)) continue;
         // associate it with the pfp
         auto& newTj = slc.tjs.back();
         pfp.TjIDs.push_back(newTj.ID);
         tids[plane] = newTj.ID;
       } // tj
       // preserve the PFP -> 3V -> 2V -> T assns
       for(unsigned short end = 0; end < 2; ++end) {
         if(pfp.Vx3ID[end] <= 0) continue;
         auto& vx3 = slc.vtx3s[pfp.Vx3ID[end] - 1];
         for(unsigned short plane = 0; plane < ptjs.size(); ++plane) {
           if(tids[plane] == 0) continue;
           if(vx3.Vx2ID[plane] <= 0) continue;
           auto& vx2 = slc.vtxs[vx3.Vx2ID[plane] - 1];
           auto& tj = slc.tjs[tids[plane] - 1];
           auto tend = CloseEnd(slc, tj, vx2.Pos);
           tj.VtxID[tend] = vx2.ID;
           if(prt) mf::LogVerbatim("TC") << "MPFPTjs: 3V" << vx3.ID << " -> 2V" << vx2.ID
                    << " -> T" << tj.ID << "_" << tend << " in plane " << plane;
         } // plane
       } // end
     }   // pfp
   }     // MakePFPTjs

void tca::MakeShowerObsolete	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 3192 of file TCShower.cxx.

   {
     // 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 > slc.cots.size()) continue;
       auto& ss = slc.cots[cid - 1];
       if (ss.SS3ID > 0 && ss.SS3ID != ss3.ID) continue;
       ss.SS3ID = 0;
     } // cid
     if (prt) {
       std::string fcnLabel = inFcnLabel + ".MSO";
       mf::LogVerbatim("TC") << fcnLabel << " Killed  3S" << ss3.ID;
     }
     ss3.ID = 0;
   } // MakeShowerObsolete

void tca::MakeShowerObsolete	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3211 of file TCShower.cxx.

   {
     // Gracefully kills the shower and the associated shower Tj
 
     if (ss.ID == 0) return;
 
     std::string fcnLabel = inFcnLabel + ".MSO";
 
     auto& stp1 = slc.tjs[ss.ShowerTjID - 1].Pts[1];
     if (!stp1.Hits.empty()) return;
 
     // clear a 3S -> 2S assn
     if (ss.SS3ID > 0 && ss.SS3ID <= (int)slc.showers.size()) {
       auto& ss3 = slc.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(slc, ss.ShowerTjID - 1);
 
     // Restore the original InShower Tjs
     // Unset the killed bit
     for (auto& tjID : ss.TjIDs) {
       Trajectory& tj = slc.tjs[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;
 
   } // MakeShowerObsolete

bool tca::MakeSmallAnglePFP	(	detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 2205 of file PFPUtils.cxx.

   {
     // Create and populate the TP3Ds vector for a small-angle track. The standard track fit
     // will fail for these tracks. The kSmallAngle AlgMod bit
     // is set true. Assume that the calling function, MakeTP3Ds, has decided that this is a
     // small-angle track. 
 
     if(!tcc.useAlg[kSmallAngle]) return false;
     if(pfp.TjIDs.size() < 2) return false;
 
     std::vector<SortEntry> sortVec(pfp.TjIDs.size());
     unsigned short sbCnt = 0;
     for (unsigned short itj = 0; itj < pfp.TjIDs.size(); ++itj) {
       sortVec[itj].index = itj;
       auto& tj = slc.tjs[pfp.TjIDs[itj] - 1];
       sortVec[itj].val = NumPtsWithCharge(slc, tj, false);
       if(pfp.TjUIDs[itj] > 0) ++sbCnt;
     } // ipt
     std::sort(sortVec.begin(), sortVec.end(), valsDecreasing);
 
     // Decide whether to use the inflection points to add another section. Inflection
     // points must exist in the two longest Tjs
     unsigned short tlIndex = sortVec[0].index;
     unsigned short nlIndex = sortVec[1].index;
     auto& tlong = slc.tjs[pfp.TjIDs[tlIndex] - 1];
     auto& nlong = slc.tjs[pfp.TjIDs[nlIndex] - 1];
     bool twoSections = (sbCnt > 1 && pfp.TjUIDs[tlIndex] > 0 && pfp.TjUIDs[nlIndex] > 0);
     unsigned short tStartPt = tlong.EndPt[0];
     unsigned short tEndPt = tlong.EndPt[1];
     unsigned short nStartPt = nlong.EndPt[0];
     unsigned short nEndPt = nlong.EndPt[1];
     if(twoSections) {
       pfp.SectionFits.resize(2);
       tEndPt = pfp.TjUIDs[tlIndex];
       nEndPt = pfp.TjUIDs[nlIndex];
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<"MakeSmallAnglePFP: creating two sections using points";
         myprt<<" T"<<tlong.ID<<"_"<<tEndPt;
         myprt<<" T"<<nlong.ID<<"_"<<nEndPt;
       } // prt
     } // two Sections
     std::vector<Point3_t> sfEndPos;
     for(unsigned short isf = 0; isf < pfp.SectionFits.size(); ++isf) {
       // get the start and end TPs in this section
       auto& ltp0 = tlong.Pts[tStartPt];
       auto& ltp1 = tlong.Pts[tEndPt];
       auto& ntp0 = nlong.Pts[nStartPt];
       auto& ntp1 = nlong.Pts[nEndPt];
       // Get the 3D end points
       auto start = MakeTP3D(detProp, slc, ltp0, ntp0);
       auto end = MakeTP3D(detProp, slc, ltp1, ntp1);
       if(!start.Flags[kTP3DGood] || !end.Flags[kTP3DGood]) {
         std::cout<<" Start/end fail in section "<<isf<<". Add recovery code\n";
         return false;
       } // failure
       if(!InsideTPC(start.Pos, pfp.TPCID)) {
         mf::LogVerbatim("TC")<<" Start is outside the TPC "<<start.Pos[0]<<" "<<start.Pos[1]<<" "<<start.Pos[2];
       }
       if(!InsideTPC(end.Pos, pfp.TPCID)) {
         mf::LogVerbatim("TC")<<" End is outside the TPC "<<end.Pos[0]<<" "<<end.Pos[1]<<" "<<end.Pos[2];
       }
       if(isf == 0) sfEndPos.push_back(start.Pos);
       sfEndPos.push_back(end.Pos);
       auto& sf = pfp.SectionFits[isf];
       // Find the start and end positions
       for(unsigned short xyz = 0; xyz < 3; ++xyz) {
         sf.Dir[xyz] = end.Pos[xyz] - start.Pos[xyz];
         sf.Pos[xyz] = (end.Pos[xyz] + start.Pos[xyz]) / 2.;
       }
       SetMag(sf.Dir, 1.);
       sf.ChiDOF = 0.;
       sf.NPts = 0;
       // move the start/end point indices
       tStartPt = tEndPt + 1; tEndPt = tlong.EndPt[1];
       nStartPt = nEndPt + 1; nEndPt = nlong.EndPt[1];
     } // isf
     // Create TP3Ds
     // a temporary vector to hold TP3Ds for the second SectionFit
     std::vector<TP3D> sf2pts;
     for(unsigned short itj = 0; itj < sortVec.size(); ++itj) {
       int tid = pfp.TjIDs[sortVec[itj].index];
       // don't add points for the Tj that doesn't have an inflection point. It is
       // probably broken and would probably be put in the wrong section
       if(twoSections && pfp.TjUIDs[sortVec[itj].index] < 0) continue;
       auto& tj = slc.tjs[tid - 1];
       unsigned short sb = tj.EndPt[1];
       if(twoSections && pfp.TjUIDs[sortVec[itj].index] > 0) sb = pfp.TjUIDs[sortVec[itj].index];
       // count the number of good TPs in each section
       std::vector<double> npwc(pfp.SectionFits.size(), 0);
       for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
         auto& tp = tj.Pts[ipt];
         if(tp.Chg <= 0) continue;
         if(ipt > sb) { ++npwc[1]; } else { ++npwc[0]; }
       } // ipt
       double length = PosSep(sfEndPos[0], sfEndPos[1]);
       double step = length / npwc[0];
       double along = -length / 2;
       unsigned short sfi = 0;
       for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
         auto& tp = tj.Pts[ipt];
         if(tp.Chg <= 0) continue;
         auto tp3d = CreateTP3D(detProp, slc, tid, ipt);
         if(tp3d.Flags[kTP3DBad]) continue;
         if(ipt == sb + 1) {
           sfi = 1;
           length = PosSep(sfEndPos[1], sfEndPos[2]);
           step = length / npwc[1];
           along = -length / 2;
         }
         tp3d.SFIndex = sfi;
         auto& sf = pfp.SectionFits[sfi];
         ++sf.NPts;
         tp3d.along = along;
         for(unsigned short xyz = 0; xyz < 3; ++xyz) tp3d.Pos[xyz] = sf.Pos[xyz] + along * sf.Dir[xyz];
         tp3d.Dir = sf.Dir;
         along += step;
         double delta = tp3d.Pos[0] - tp3d.TPX;
         sf.ChiDOF += delta * delta / tp3d.TPXErr2;
         // Assume that all points are good
         tp3d.Flags[kTP3DGood] = true;
         if(sfi == 0) {
           pfp.TP3Ds.push_back(tp3d);
         } else {
           sf2pts.push_back(tp3d);
         }
       } // ipt
     } // tid
     if(pfp.TP3Ds.size() < 4) return false;
     for(auto& sf : pfp.SectionFits) {
       if(sf.NPts < 5) return false;
       sf.ChiDOF /= (float)(sf.NPts - 4);
     } // sf
     if(!SortSection(pfp, 0)) return false;
     if(!sf2pts.empty()) {
       // append the points and sort
       pfp.TP3Ds.insert(pfp.TP3Ds.end(), sf2pts.begin(), sf2pts.end());
       if(!SortSection(pfp, 1)) return false;
     } // two sections
     pfp.Flags[kCanSection] = false;
     pfp.AlgMod[kSmallAngle] = true;
     if(prt) {
       mf::LogVerbatim("TC")<<"Created SmallAngle P"<<pfp.ID
           <<" with "<<pfp.TP3Ds.size()
           <<" points in "<<pfp.SectionFits.size()<<" sections\n";
     }
     return true;
   } // MakeSmallAnglePFP

TP3D tca::MakeTP3D	(	detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc,
		const TrajPoint &	itp,
		const TrajPoint &	jtp
	)

Definition at line 2447 of file PFPUtils.cxx.

   {
     // Make a 3D trajectory point using two 2D trajectory points. The TP3D Pos and Wire
     // variables are defined using itp. The SectionFit variables are un-defined
     TP3D tp3d;
     tp3d.TPIndex = 0;
     tp3d.TjID = 0;
     tp3d.CTP = itp.CTP;
     // assume failure
     tp3d.Flags[kTP3DGood] = false;
     tp3d.Dir = {{0.0, 0.0, 1.0}};
     tp3d.Pos = {{999.0, 999.0, 999.0}};
     geo::PlaneID iPlnID = DecodeCTP(itp.CTP);
     geo::PlaneID jPlnID = DecodeCTP(jtp.CTP);
     if(iPlnID == jPlnID) return tp3d;
     double upt = tcc.unitsPerTick;
     double ix = detProp.ConvertTicksToX(itp.Pos[1] / upt, iPlnID);
     double jx = detProp.ConvertTicksToX(jtp.Pos[1] / upt, jPlnID);
     
     // don't continue if the points are wildly far apart in X
     double dx = std::abs(ix - jx);
     if(dx > 20) return tp3d;
     tp3d.Pos[0] = (ix + jx) / 2;
     tp3d.TPX = ix;
     // Fake the error
     tp3d.TPXErr2 = dx;
     // determine the wire orientation and offsets using WireCoordinate
     // wire = yp * OrthY + zp * OrthZ - Wire0 = cs * yp + sn * zp - wire0
     // wire offset
     double iw0 = tcc.geom->WireCoordinate(0, 0, iPlnID);
     // cosine-like component
     double ics = tcc.geom->WireCoordinate(1, 0, iPlnID) - iw0;
     // sine-like component
     double isn = tcc.geom->WireCoordinate(0, 1, iPlnID) - iw0;
     double jw0 = tcc.geom->WireCoordinate(0, 0, jPlnID);
     double jcs = tcc.geom->WireCoordinate(1, 0, jPlnID) - jw0;
     double jsn = tcc.geom->WireCoordinate(0, 1, jPlnID) - jw0;
     double den = isn * jcs - ics * jsn;
     if(den == 0) return tp3d;
     double iPos0 = itp.Pos[0];
     double jPos0 = jtp.Pos[0];
     // Find the Z position of the intersection
     tp3d.Pos[2] = (jcs * (iPos0 - iw0) - ics * (jPos0 - jw0)) / den;
     // and the Y position
     bool useI = std::abs(ics) > std::abs(jcs);
     if(useI) {
       tp3d.Pos[1] = (iPos0 - iw0 - isn * tp3d.Pos[2]) / ics;
     } else {
       tp3d.Pos[1] = (jPos0 - jw0 - jsn * tp3d.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) { tp3d.Dir[0] = 1; } else { tp3d.Dir[0] = -1; }
       tp3d.Dir[1] = 0;
       tp3d.Dir[2] = 0;
       return tp3d;
     } // jtp.Dir[1] == 0
     
     tp3d.Wire = iPos0;
     
     // 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] = detProp.ConvertTicksToX(itp2_1 / upt, iPlnID);
     // Convert X to Ticks in the j plane and then to WSE units
     double jtp2Pos1 = 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(tp3d.Pos, pos2);
     if(sep == 0) return tp3d;
     for(unsigned short ixyz = 0; ixyz < 3; ++ixyz) tp3d.Dir[ixyz] = (pos2[ixyz] - tp3d.Pos[ixyz]) /sep;
     tp3d.Flags[kTP3DGood] = true;
     return tp3d;
     
   } // MakeTP3D

bool tca::MakeTP3Ds	(	detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 2124 of file PFPUtils.cxx.

   {
     // Create and populate the TP3Ds vector. This function is called before the first
     // fit is done so the TP3D along variable can't be determined. It returns false
     // if a majority of the tj points in TjIDs are already assigned to a different pfp
     pfp.TP3Ds.clear();
     if (!pfp.TP3Ds.empty() || pfp.SectionFits.size() != 1) return false;
 
     // Look for TPs that are ~parallel to the wire plane and trajectory points
     // where the min/max Pos[1] value is not near an end.
     // number of Small Angle Tjs
     // stash the inflection point index in the TjUIDs vector
     pfp.TjUIDs.resize(pfp.TjIDs.size(), -1);
     // count TPs with charge in all of the Tjs
     float cnt = 0;
     // and the number of TPs available for use
     float avail = 0;
     // and the number of junk Tjs
     unsigned short nJunk = 0;
     unsigned short nSA = 0;
     for(unsigned short itj = 0; itj < pfp.TjIDs.size(); ++itj) {
       auto& tj = slc.tjs[pfp.TjIDs[itj] - 1];
       if(tj.AlgMod[kJunkTj]) ++nJunk;
       float posMin = 1E6;
       unsigned short iptMin = USHRT_MAX;
       float posMax = -1E6;
       unsigned short iptMax = USHRT_MAX;
       float aveAng = 0;
       float npwc = 0;
       for(unsigned short ipt = tj.EndPt[0]; ipt < tj.EndPt[1]; ++ipt) {
         auto& tp = tj.Pts[ipt];
         if(tp.Chg <= 0) continue;
         ++cnt;
         if (tp.InPFP > 0) continue;
         ++avail;
         if(tp.Pos[1] > posMax) { posMax = tp.Pos[1]; iptMax = ipt; }
         if(tp.Pos[1] < posMin) { posMin = tp.Pos[1]; iptMin = ipt; }
         aveAng += tp.Ang;
         ++npwc;
       } // ipt
       if(npwc == 0) continue;
       aveAng /= npwc;
       if(std::abs(aveAng) < 0.05) ++nSA;
       // No problem if the min/max points are near the ends
       if(iptMin > tj.EndPt[0] + 4 && iptMin < tj.EndPt[1] - 4) pfp.TjUIDs[itj] = iptMin;
       if(iptMax > tj.EndPt[0] + 4 && iptMax < tj.EndPt[1] - 4) pfp.TjUIDs[itj] = iptMax;
     } // tid
     if(avail < 0.8 * cnt) return false;
     // small angle trajectory?
     if(nSA > 1) pfp.AlgMod[kSmallAngle] = true;
     if(prt) mf::LogVerbatim("TC")<<" P"<<pfp.ID<<" MVI "<<pfp.MVI<<" nJunkTj "<<nJunk<<" SmallAngle? "<<pfp.AlgMod[kSmallAngle];
 
     if(pfp.AlgMod[kSmallAngle]) return MakeSmallAnglePFP(detProp, slc, pfp, prt);
 
     // Add the points associated with the Tjs that were used to create the PFP
     for (auto tid : pfp.TjIDs) {
       auto& tj = slc.tjs[tid - 1];
       // There is one TP for every hit in a junk Tj so we can skip one, if there is only one
       if(nJunk == 1 && tj.AlgMod[kJunkTj]) continue;
       // All of the Tj's may be junk, especially for those at very high angle, so the
       // X position of the TP's isn't high quality. Inflate the errors below.
       bool isJunk = tj.AlgMod[kJunkTj];
       for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
         auto& tp = tj.Pts[ipt];
         if (tp.Chg <= 0) continue;
         if (tp.InPFP > 0) continue;
         ++avail;
         auto tp3d = CreateTP3D(detProp, slc, tid, ipt);
         if(tp3d.Flags[kTP3DBad]) continue;
         tp3d.SFIndex = 0;
         if(isJunk) tp3d.TPXErr2 *= 4;
         // We need to assume that all points are good or the first fit will fail
         tp3d.Flags[kTP3DGood] = true;
         pfp.TP3Ds.push_back(tp3d);
       } // ipt
     } // tid
     if(prt) mf::LogVerbatim("TC")<<" has "<<pfp.TP3Ds.size()<<" TP3Ds";
     return true;
   } // MakeTP3Ds

void tca::MakeTrajectoryObsolete	(	TCSlice &	slc,
		unsigned int	itj
	)

Definition at line 2182 of file Utils.cxx.

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

bool tca::MakeVertexObsolete	(	std::string	fcnLabel,
		TCSlice &	slc,
		VtxStore &	vx2,
		bool	forceKill
	)

Definition at line 2740 of file TCVertex.cxx.

   {
     // Makes a 2D vertex obsolete
 
     // check for a high-score 3D vertex
     bool hasHighScoreVx3 = (vx2.Vx3ID > 0);
     if (hasHighScoreVx3 && !forceKill && slc.vtx3s[vx2.Vx3ID - 1].Score >= tcc.vtx2DCuts[7])
       return false;
 
     if (tcc.dbg2V || tcc.dbg3V) {
       mf::LogVerbatim("TC") << fcnLabel << " MVO: killing 2V" << vx2.ID;
     }
 
     // Kill it
     int vx2id = vx2.ID;
     if (vx2.Vx3ID > 0) {
       auto& vx3 = slc.vtx3s[vx2.Vx3ID - 1];
       for (auto& v3v2id : vx3.Vx2ID)
         if (v3v2id == vx2.ID) v3v2id = 0;
     }
     vx2.ID = 0;
     for (auto& tj : slc.tjs) {
       if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) 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 = slc.vtxs[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 = slc.vtx3s[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 < slc.nPlanes; ++plane)
       if (vx3.Vx2ID[plane] > 0) ++n2D;
 
     if (n2D > 1) {
       // 3D vertex is incomplete
       // correct the score
       SetVx3Score(slc, vx3);
       return true;
     }
 
     // 3D vertex is obsolete
     // Detach all remaining 2D vertices from the 3D vertex
     for (auto& vx2 : slc.vtxs) {
       if (vx2.ID == 0) continue;
       if (vx2.Vx3ID == vx3.ID) vx2.Vx3ID = 0;
     } // vx2
     for (auto& pfp : slc.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	(	TCSlice &	slc,
		Vtx3Store &	vx3
	)

Definition at line 2832 of file TCVertex.cxx.

   {
     // 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(slc.vtx3s.size())) return false;
 
     for (auto vx2id : vx3.Vx2ID) {
       if (vx2id == 0 || vx2id > (int)slc.vtxs.size()) continue;
       auto& vx2 = slc.vtxs[vx2id - 1];
       MakeVertexObsolete("MVO3", slc, vx2, true);
     }
     vx3.ID = 0;
     return true;
   } // MakeVertexObsolete

void tca::MaskBadTPs	(	TCSlice &	slc,
		Trajectory &	tj,
		float const &	maxChi
	)

Definition at line 2377 of file StepUtils.cxx.

   {
     // Remove TPs that have the worst values of delta until the fit chisq < maxChi
 
     if(!tcc.useAlg[kMaskBadTPs]) return;
     //don't use this function for reverse propagation
     if(!tcc.useAlg[kRvPrp]) return;
 
     bool prt = (tcc.dbgStp || tcc.dbgAlg[kMaskBadTPs]);
 
     if(tj.Pts.size() < 3) {
       //      mf::LogError("TC")<<"MaskBadTPs: Trajectory ID "<<tj.ID<<" too short to mask hits ";
       tj.IsGood = false;
       return;
     }
     unsigned short nit = 0;
     TrajPoint& lastTP = tj.Pts[tj.Pts.size() - 1];
     while(lastTP.FitChi > maxChi && nit < 3) {
       float maxDelta = 0;
       unsigned short imBad = USHRT_MAX;
       unsigned short cnt = 0;
       for(unsigned short ii = 1; ii < tj.Pts.size(); ++ii) {
         unsigned short ipt = tj.Pts.size() - 1 - ii;
         TrajPoint& tp = tj.Pts[ipt];
         if(tp.Chg == 0) continue;
         if(tp.Delta > maxDelta) {
           maxDelta = tp.Delta;
           imBad = ipt;
         }
         ++cnt;
         if(cnt == tp.NTPsFit) break;
       } // ii
       if(imBad == USHRT_MAX) return;
       if(prt) mf::LogVerbatim("TC")<<"MaskBadTPs: lastTP.FitChi "<<lastTP.FitChi<<"  Mask point "<<imBad;
       // mask the point
       UnsetUsedHits(slc, tj.Pts[imBad]);
       FitTraj(slc, tj);
       if(prt) mf::LogVerbatim("TC")<<"  after FitTraj "<<lastTP.FitChi;
       tj.AlgMod[kMaskBadTPs] = true;
       ++nit;
     } // lastTP.FItChi > maxChi && nit < 3
 
   } // MaskBadTPs

bool tca::MaskedHitsOK	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 2422 of file StepUtils.cxx.

   {
     // The hits in the TP at the end of the trajectory were masked off. Decide whether to continue stepping with the
     // current configuration (true) or whether to stop and possibly try with the next pass settings (false)
 
     if(!tcc.useAlg[kMaskHits]) return true;
 
     unsigned short lastPt = tj.Pts.size() - 1;
     if(tj.Pts[lastPt].Chg > 0) return true;
     unsigned short endPt = tj.EndPt[1];
 
     // count the number of points w/o used hits and the number with one unused hit
     unsigned short nMasked = 0;
     unsigned short nOneHit = 0;
     unsigned short nOKChg = 0;
     unsigned short nOKDelta = 0;
     // number of points with Pos > HitPos
     unsigned short nPosDelta = 0;
     // number of points with Delta increasing vs ipt
     unsigned short nDeltaIncreasing = 0;
     // Fake this a bit to simplify comparing the counts
     float prevDelta = tj.Pts[endPt].Delta;
     float maxOKDelta = 10 * tj.Pts[endPt].DeltaRMS;
     float maxOKChg = 0;
     // find the maximum charge point on the trajectory
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) if(tj.Pts[ipt].Chg > maxOKChg) maxOKChg = tj.Pts[ipt].Chg;
     for(unsigned short ii = 1; ii < tj.Pts.size(); ++ii) {
       unsigned short ipt = tj.Pts.size() - ii;
       auto& tp = tj.Pts[ipt];
       if(tp.Chg > 0) break;
       unsigned short nUnusedHits = 0;
       float chg = 0;
       for(unsigned short jj = 0; jj < tp.Hits.size(); ++jj) {
         unsigned int iht = tp.Hits[jj];
         if(slc.slHits[iht].InTraj != 0) continue;
         ++nUnusedHits;
         auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
         chg += hit.Integral();
       } // jj
       if(chg < maxOKChg) ++nOKChg;
       if(nUnusedHits == 1) ++nOneHit;
       if(tp.Delta < maxOKDelta) ++nOKDelta;
       // count the number of points with Pos time > HitPos time
       if(tp.Pos[1] > tp.HitPos[1]) ++nPosDelta;
       // The number of increasing delta points: Note implied absolute value
       if(tp.Delta < prevDelta) ++nDeltaIncreasing;
       prevDelta = tp.Delta;
       ++nMasked;
     } // ii
 
     // determine if the hits are wandering away from the trajectory direction. This will result in
     // nPosDelta either being ~0 or ~equal to the number of masked points. nPosDelta should have something
     // in between these two extremes if we are stepping through a messy region
     bool driftingAway = nMasked > 2 && (nPosDelta == 0 || nPosDelta == nMasked);
     // Note that nDeltaIncreasing is always positive
     if(driftingAway && nDeltaIncreasing < nMasked - 1) driftingAway = false;
 
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"MHOK:  nMasked "<<nMasked<<" nOneHit "<<nOneHit<<" nOKChg "<<nOKChg<<" nOKDelta "<<nOKDelta<<" nPosDelta "<<nPosDelta<<" nDeltaIncreasing "<<nDeltaIncreasing<<" driftingAway? "<<driftingAway;
     }
 
     if(!driftingAway) {
       if(nMasked < 8 || nOneHit < 8) return true;
       if(nOKDelta != nMasked) return true;
       if(nOKChg != nMasked) return true;
     }
 
     // we would like to reduce the number of fitted points to a minimum and include
     // the masked hits, but we can only do that if there are enough points
     if(tj.Pts[endPt].NTPsFit <= tcc.minPtsFit[tj.Pass]) {
       // stop stepping if we have masked off more points than are in the fit
       if(nMasked > tj.Pts[endPt].NTPsFit) return false;
       return true;
     }
     // Reduce the number of points fit and try to include the points
     unsigned short newNTPSFit;
     if(tj.Pts[endPt].NTPsFit > 2 * tcc.minPtsFit[tj.Pass]) {
       newNTPSFit = tj.Pts[endPt].NTPsFit / 2;
     } else {
       newNTPSFit = tcc.minPtsFit[tj.Pass];
     }
     for(unsigned ipt = endPt + 1; ipt < tj.Pts.size(); ++ipt) {
       TrajPoint& tp = tj.Pts[ipt];
       for(unsigned short ii = 0; ii < tj.Pts[ipt].Hits.size(); ++ii) {
         unsigned int iht = tp.Hits[ii];
         if(slc.slHits[iht].InTraj == 0) {
           tp.UseHit[ii] = true;
           slc.slHits[iht].InTraj = tj.ID;
           break;
         }
       } // ii
       DefineHitPos(slc, tp);
       SetEndPoints(tj);
       tp.NTPsFit = newNTPSFit;
       FitTraj(slc, tj);
       if(tcc.dbgStp) PrintTrajectory("MHOK", slc, tj, ipt);
     } // ipt
 
     tj.AlgMod[kMaskHits] = true;
     UpdateTjChgProperties("MHOK", slc, tj, tcc.dbgStp);
     return true;
 
   } // MaskedHitsOK

void tca::MaskTrajEndPoints	(	TCSlice &	slc,
		Trajectory &	tj,
		unsigned short	nPts
	)

Definition at line 3649 of file StepUtils.cxx.

   {
 
     // Masks off (sets all hits not-Used) nPts trajectory points at the leading edge of the
     // trajectory, presumably because the fit including this points is poor. The position, direction
     // and Delta of the last nPts points is updated as well
 
     if(tj.EndFlag[1][kAtKink]) return;
     if(tj.Pts.size() < 3) {
       mf::LogError("TC")<<"MaskTrajEndPoints: Trajectory ID "<<tj.ID<<" too short to mask hits ";
       return;
     }
     if(nPts > tj.Pts.size() - 2) {
       mf::LogError("TC")<<"MaskTrajEndPoints: Trying to mask too many points "<<nPts<<" Pts.size "<<tj.Pts.size();
       return;
     }
 
     // find the last good point (with charge)
     unsigned short lastGoodPt = USHRT_MAX ;
 
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"MTEP: lastGoodPt "<<lastGoodPt<<" Pts size "<<tj.Pts.size()<<" tj.IsGood "<<tj.IsGood;
     }
     if(lastGoodPt == USHRT_MAX) return;
     tj.EndPt[1] = lastGoodPt;
 
     //for(unsigned short ii = 0; ii < nPts; ++ii) {
     for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
       unsigned short ipt = tj.Pts.size() - 1 - ii;
       if (ipt==lastGoodPt) break;
       UnsetUsedHits(slc, tj.Pts[ipt]);
       // Reset the position and direction of the masked off points
       tj.Pts[ipt].Dir = tj.Pts[lastGoodPt].Dir;
       if(tj.Pts[lastGoodPt].AngleCode == 2) {
         // Very large angle: Move by path length
         float path = TrajPointSeparation(tj.Pts[lastGoodPt], tj.Pts[ipt]);
         tj.Pts[ipt].Pos[0] = tj.Pts[lastGoodPt].Pos[0] + path * tj.Pts[ipt].Dir[0];
         tj.Pts[ipt].Pos[1] = tj.Pts[lastGoodPt].Pos[1] + path * tj.Pts[ipt].Dir[1];
       } else {
         // Not large angle: Move by wire
         float dw = tj.Pts[ipt].Pos[0] - tj.Pts[lastGoodPt].Pos[0];
         // Correct the projected time to the wire
         float newpos = tj.Pts[lastGoodPt].Pos[1] + dw * tj.Pts[ipt].Dir[1] / tj.Pts[ipt].Dir[0];
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"MTEP: ipt "<<ipt<<" Pos[0] "<<tj.Pts[ipt].Pos[0]<<". Move Pos[1] from "<<tj.Pts[ipt].Pos[1]<<" to "<<newpos;
         tj.Pts[ipt].Pos[1] = tj.Pts[lastGoodPt].Pos[1] + dw * tj.Pts[ipt].Dir[1] / tj.Pts[ipt].Dir[0];
       }
       tj.Pts[ipt].Delta = PointTrajDOCA(slc, tj.Pts[ipt].HitPos[0], tj.Pts[ipt].HitPos[1], tj.Pts[ipt]);
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" masked ipt "<<ipt<<" Pos "<<PrintPos(slc, tj.Pts[ipt])<<" Chg "<<tj.Pts[ipt].Chg;
     } // ii
     SetEndPoints(tj);
 
   } // MaskTrajEndPoints

void tca::Match2DShowers	(	std::string	inFcnLabel,
		TCSlice &	slc,
		bool	prt
	)

void tca::Match2Planes	(	TCSlice &	slc,
		std::vector< MatchStruct > &	matVec
	)

Definition at line 944 of file PFPUtils.cxx.

   {
     // A simpler faster version of MatchPlanes that only creates two plane matches
 
     matVec.clear();
     if (slc.mallTraj.empty()) return;
 
     int cstat = slc.TPCID.Cryostat;
     int tpc = slc.TPCID.TPC;
 
     float xcut = tcc.match3DCuts[0];
 
     // the TJ IDs for one match
     std::array<unsigned short, 2> tIDs;
     // vector for matched Tjs
     std::vector<std::array<unsigned short, 2>> mtIDs;
     // and a matching vector for the count
     std::vector<unsigned short> mCnt;
     // ignore Tj matches after hitting a user-defined limit
     unsigned short maxCnt = USHRT_MAX;
     if (tcc.match3DCuts[1] < (float)USHRT_MAX) maxCnt = (unsigned short)tcc.match3DCuts[1];
     // a list of those Tjs
     std::vector<unsigned short> tMaxed;
 
     for (std::size_t ipt = 0; ipt < slc.mallTraj.size() - 1; ++ipt) {
       auto& iTjPt = slc.mallTraj[ipt];
       // see if we hit the maxCnt limit
       if (std::find(tMaxed.begin(), tMaxed.end(), iTjPt.id) != tMaxed.end()) continue;
       auto& itp = slc.tjs[iTjPt.id - 1].Pts[iTjPt.ipt];
       unsigned short iPlane = iTjPt.plane;
       unsigned int iWire = itp.Pos[0];
       bool hitMaxCnt = false;
       for (std::size_t jpt = ipt + 1; jpt < slc.mallTraj.size() - 1; ++jpt) {
         auto& jTjPt = slc.mallTraj[jpt];
         // ensure that the planes are different
         if (jTjPt.plane == iTjPt.plane) 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
         if (jTjPt.xlo > iTjPt.xhi + xcut) break;
         // see if we hit the maxCnt limit
         if (std::find(tMaxed.begin(), tMaxed.end(), jTjPt.id) != tMaxed.end()) continue;
         auto& jtp = slc.tjs[jTjPt.id - 1].Pts[jTjPt.ipt];
         unsigned short jPlane = jTjPt.plane;
         unsigned int jWire = jtp.Pos[0];
         Point3_t ijPos;
         ijPos[0] = itp.Pos[0];
         if (!tcc.geom->IntersectionPoint(
               iWire, jWire, iPlane, jPlane, cstat, tpc, ijPos[1], ijPos[2]))
           continue;
         tIDs[0] = iTjPt.id;
         tIDs[1] = jTjPt.id;
         // swap the order so that the == operator works correctly
         if (tIDs[0] > tIDs[1]) std::swap(tIDs[0], tIDs[1]);
         // look for it in the list
         std::size_t indx = 0;
         for (indx = 0; indx < mtIDs.size(); ++indx)
           if (tIDs == mtIDs[indx]) break;
         if (indx == mtIDs.size()) {
           // not found so add it to mtIDs and add another element to mCnt
           mtIDs.push_back(tIDs);
           mCnt.push_back(0);
         }
         ++mCnt[indx];
         if (mCnt[indx] == maxCnt) {
           // add the Tjs to the list
           tMaxed.insert(tMaxed.end(), tIDs[0]);
           tMaxed.insert(tMaxed.end(), tIDs[1]);
           hitMaxCnt = true;
           break;
         } // hit maxCnt
         if (hitMaxCnt) break;
       } // jpt
     }   // ipt
 
     if (mCnt.empty()) return;
 
     std::vector<SortEntry> sortVec;
     for (std::size_t indx = 0; indx < mCnt.size(); ++indx) {
       auto& tIDs = mtIDs[indx];
       // count the number of TPs in all Tjs
       float tpCnt = 0;
       for (auto tid : tIDs) {
         auto& tj = slc.tjs[tid - 1];
         tpCnt += NumPtsWithCharge(slc, tj, false);
       } // tid
       float frac = mCnt[indx] / tpCnt;
       frac /= 2;
       // ignore matches with a very low match fraction
       if (frac < 0.05) continue;
       SortEntry se;
       se.index = indx;
       se.val = mCnt[indx];
       sortVec.push_back(se);
     } // ii
     if (sortVec.size() > 1) std::sort(sortVec.begin(), sortVec.end(), valsDecreasing);
 
     matVec.resize(sortVec.size());
 
     for (std::size_t ii = 0; ii < sortVec.size(); ++ii) {
       unsigned short indx = sortVec[ii].index;
       auto& ms = matVec[ii];
       ms.Count = mCnt[indx];
       ms.TjIDs.resize(2);
       for (unsigned short plane = 0; plane < 2; ++plane)
         ms.TjIDs[plane] = (int)mtIDs[indx][plane];
     } // indx
 
   } // Match2Planes

float tca::Match3DFOM	(	detinfo::DetectorPropertiesData const &	detProp,
		std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 1209 of file TCShower.cxx.

   {
     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(detProp, inFcnLabel, slc, icid, jcid, prt);
         ++cnt;
       } // cj
     }   // ci
     if (cnt == 0) return 100;
     return fom / cnt;
   } // Match3DFOM

float tca::Match3DFOM	(	detinfo::DetectorPropertiesData const &	detProp,
		std::string	inFcnLabel,
		TCSlice &	slc,
		int	icid,
		int	jcid,
		int	kcid,
		bool	prt
	)

Definition at line 1231 of file TCShower.cxx.

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

float tca::Match3DFOM	(	detinfo::DetectorPropertiesData const &	detProp,
		std::string	inFcnLabel,
		TCSlice &	slc,
		int	icid,
		int	jcid,
		bool	prt
	)

Definition at line 1252 of file TCShower.cxx.

   {
     // returns a Figure of Merit for a 3D match of two showers
     if (icid == 0 || icid > (int)slc.cots.size()) return 100;
     if (jcid == 0 || jcid > (int)slc.cots.size()) return 100;
 
     auto& iss = slc.cots[icid - 1];
     auto& istj = slc.tjs[iss.ShowerTjID - 1];
     auto& jss = slc.cots[jcid - 1];
     auto& jstj = slc.tjs[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 = detProp.ConvertTicksToX(istj.Pts[1].Pos[1] / tcc.unitsPerTick, iPlnID);
     float jx = detProp.ConvertTicksToX(jstj.Pts[1].Pos[1] / tcc.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 << " pos1fom " << pos1fom;
       myprt << " energyAsym " << energyAsym;
       myprt << " mfom " << mfom;
     }
 
     return mfom;
   } // Madtch3DFOM

void tca::Match3Planes	(	TCSlice &	slc,
		std::vector< MatchStruct > &	matVec
	)

Definition at line 813 of file PFPUtils.cxx.

   {
     // A simpler and faster version of MatchPlanes that only creates three plane matches
 
     if (slc.nPlanes != 3) return;
 
     // use SpacePoint -> Hit -> TP assns?
     if (!evt.sptHits.empty()) {
       Match3PlanesSpt(slc, matVec);
       return;
     }
 
     if (slc.mallTraj.empty()) return;
     float xcut = tcc.match3DCuts[0];
     double yzcut = 1.5 * tcc.wirePitch;
 
     // the TJ IDs for one match
     std::array<unsigned short, 3> tIDs;
     // vector for matched Tjs
     std::vector<std::array<unsigned short, 3>> mtIDs;
     // and a matching vector for the count
     std::vector<unsigned short> mCnt;
     // ignore Tj matches after hitting a user-defined limit
     unsigned short maxCnt = USHRT_MAX;
     if (tcc.match3DCuts[1] < (float)USHRT_MAX) maxCnt = (unsigned short)tcc.match3DCuts[1];
     // a list of those Tjs
     std::vector<unsigned short> tMaxed;
 
     for (std::size_t ipt = 0; ipt < slc.mallTraj.size() - 1; ++ipt) {
       auto& iTjPt = slc.mallTraj[ipt];
       // see if we hit the maxCnt limit
       if (std::find(tMaxed.begin(), tMaxed.end(), iTjPt.id) != tMaxed.end()) continue;
       auto& itp = slc.tjs[iTjPt.id - 1].Pts[iTjPt.ipt];
       unsigned int iPlane = iTjPt.plane;
       unsigned int iWire = std::nearbyint(itp.Pos[0]);
       tIDs[iPlane] = iTjPt.id;
       bool hitMaxCnt = false;
       for (std::size_t jpt = ipt + 1; jpt < slc.mallTraj.size() - 1; ++jpt) {
         auto& jTjPt = slc.mallTraj[jpt];
         // ensure that the planes are different
         if (jTjPt.plane == iTjPt.plane) 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
         if (jTjPt.xlo > iTjPt.xhi + xcut) break;
         // see if we hit the maxCnt limit
         if (std::find(tMaxed.begin(), tMaxed.end(), jTjPt.id) != tMaxed.end()) continue;
         auto& jtp = slc.tjs[jTjPt.id - 1].Pts[jTjPt.ipt];
         unsigned short jPlane = jTjPt.plane;
         unsigned int jWire = jtp.Pos[0];
         Point2_t ijPos;
         if (!TCIntersectionPoint(iWire, jWire, iPlane, jPlane, ijPos[0], ijPos[1])) continue;
         tIDs[jPlane] = jTjPt.id;
         for (std::size_t kpt = jpt + 1; kpt < slc.mallTraj.size(); ++kpt) {
           auto& kTjPt = slc.mallTraj[kpt];
           // ensure that the planes are different
           if (kTjPt.plane == iTjPt.plane || kTjPt.plane == jTjPt.plane) continue;
           if (kTjPt.xlo > iTjPt.xhi) continue;
           // break out if the x range difference becomes large
           if (kTjPt.xlo > iTjPt.xhi + xcut) break;
           // see if we hit the maxCnt limit
           if (std::find(tMaxed.begin(), tMaxed.end(), kTjPt.id) != tMaxed.end()) continue;
           auto& ktp = slc.tjs[kTjPt.id - 1].Pts[kTjPt.ipt];
           unsigned short kPlane = kTjPt.plane;
           unsigned int kWire = ktp.Pos[0];
           Point2_t ikPos;
           if (!TCIntersectionPoint(iWire, kWire, iPlane, kPlane, ikPos[0], ikPos[1])) continue;
           if (std::abs(ijPos[0] - ikPos[0]) > yzcut) continue;
           if (std::abs(ijPos[1] - ikPos[1]) > yzcut) continue;
           // we have a match
           tIDs[kPlane] = kTjPt.id;
           // look for it in the list
           unsigned int indx = 0;
           for (indx = 0; indx < mtIDs.size(); ++indx)
             if (tIDs == mtIDs[indx]) break;
           if (indx == mtIDs.size()) {
             // not found so add it to mtIDs and add another element to mCnt
             mtIDs.push_back(tIDs);
             mCnt.push_back(0);
           }
           ++mCnt[indx];
           if (mCnt[indx] == maxCnt) {
             // add the Tjs to the list
             tMaxed.insert(tMaxed.end(), tIDs[0]);
             tMaxed.insert(tMaxed.end(), tIDs[1]);
             tMaxed.insert(tMaxed.end(), tIDs[2]);
             hitMaxCnt = true;
             break;
           } // hit maxCnt
         }   // kpt
         if (hitMaxCnt) break;
       } // jpt
     }   // ipt
 
     if (mCnt.empty()) return;
 
     std::vector<SortEntry> sortVec;
     for (std::size_t indx = 0; indx < mCnt.size(); ++indx) {
       auto& tIDs = mtIDs[indx];
       // count the number of TPs in all Tjs
       float tpCnt = 0;
       for (auto tid : tIDs) {
         auto& tj = slc.tjs[tid - 1];
         tpCnt += NumPtsWithCharge(slc, tj, false);
       } // tid
       float frac = mCnt[indx] / tpCnt;
       frac /= 3;
       // ignore matches with a very low match fraction
       if (frac < 0.05) continue;
       SortEntry se;
       se.index = indx;
       se.val = mCnt[indx];
       sortVec.push_back(se);
     } // ii
     if (sortVec.size() > 1) std::sort(sortVec.begin(), sortVec.end(), valsDecreasing);
 
     matVec.resize(sortVec.size());
 
     for (std::size_t ii = 0; ii < sortVec.size(); ++ii) {
       unsigned short indx = sortVec[ii].index;
       auto& ms = matVec[ii];
       ms.Count = mCnt[indx];
       ms.TjIDs.resize(3);
       for (unsigned short plane = 0; plane < 3; ++plane)
         ms.TjIDs[plane] = (int)mtIDs[indx][plane];
     } // indx
 
   } // Match3Planes

void tca::Match3PlanesSpt	(	TCSlice &	slc,
		std::vector< MatchStruct > &	matVec
	)

Definition at line 700 of file PFPUtils.cxx.

   {
     // fill matVec using SpacePoint -> Hit -> TP -> tj assns
     if (evt.sptHits.empty()) return;
 
     // create a local vector of allHit -> Tj assns and populate it
     std::vector<int> inTraj((*evt.allHits).size(), 0);
     for (auto& tch : slc.slHits)
       inTraj[tch.allHitsIndex] = tch.InTraj;
 
     // the TJ IDs for one match
     std::array<int, 3> tIDs;
     // vector for matched Tjs
     std::vector<std::array<int, 3>> mtIDs;
     // and a matching vector for the count
     std::vector<unsigned short> mCnt;
     // ignore Tj matches after hitting a user-defined limit
     unsigned short maxCnt = USHRT_MAX;
     if (tcc.match3DCuts[1] < (float)USHRT_MAX) maxCnt = (unsigned short)tcc.match3DCuts[1];
     // a list of those Tjs
     std::vector<unsigned short> tMaxed;
 
     unsigned int tpc = slc.TPCID.TPC;
 
     for (auto& sptHits : evt.sptHits) {
       if (sptHits.size() != 3) continue;
       // ensure that the SpacePoint is in the requested TPC
       if (!SptInTPC(sptHits, tpc)) continue;
       unsigned short cnt = 0;
       for (unsigned short plane = 0; plane < 3; ++plane) {
         unsigned int iht = sptHits[plane];
         if (iht == UINT_MAX) continue;
         if (inTraj[iht] <= 0) continue;
         tIDs[plane] = inTraj[iht];
         ++cnt;
       } // iht
       if (cnt != 3) continue;
       // look for it in the list of tj combinations
       unsigned short indx = 0;
       for (indx = 0; indx < mtIDs.size(); ++indx)
         if (tIDs == mtIDs[indx]) break;
       if (indx == mtIDs.size()) {
         // not found so add it to mtIDs and add another element to mCnt
         mtIDs.push_back(tIDs);
         mCnt.push_back(0);
       }
       ++mCnt[indx];
       if (mCnt[indx] == maxCnt) {
         // add the Tjs to the list
         tMaxed.insert(tMaxed.end(), tIDs[0]);
         tMaxed.insert(tMaxed.end(), tIDs[1]);
         tMaxed.insert(tMaxed.end(), tIDs[2]);
         break;
       } // hit maxCnt
       ++cnt;
     } // sptHit
 
     std::vector<SortEntry> sortVec;
     for (unsigned short indx = 0; indx < mCnt.size(); ++indx) {
       auto& tIDs = mtIDs[indx];
       // find the fraction of TPs on the shortest tj that are matched
       float minTPCnt = USHRT_MAX;
       for (auto tid : tIDs) {
         auto& tj = slc.tjs[tid - 1];
         float tpcnt = NumPtsWithCharge(slc, tj, false);
         if (tpcnt < minTPCnt) minTPCnt = tpcnt;
       } // tid
       float frac = (float)mCnt[indx] / minTPCnt;
       // ignore matches with a very low match fraction
       if (frac < 0.05) continue;
       SortEntry se;
       se.index = indx;
       se.val = mCnt[indx];
       sortVec.push_back(se);
     } // ii
     if (sortVec.size() > 1) std::sort(sortVec.begin(), sortVec.end(), valsDecreasing);
 
     matVec.resize(sortVec.size());
 
     for (unsigned short ii = 0; ii < sortVec.size(); ++ii) {
       unsigned short indx = sortVec[ii].index;
       auto& ms = matVec[ii];
       ms.Count = mCnt[indx];
       ms.TjIDs.resize(3);
       for (unsigned short plane = 0; plane < 3; ++plane)
         ms.TjIDs[plane] = mtIDs[indx][plane];
     } // indx
 
   } // Match3PlanesSpt

float tca::MaxChargeAsymmetry	(	TCSlice &	slc,
		std::vector< int > &	tjIDs
	)

Definition at line 372 of file Utils.cxx.

   {
     // calculates the maximum charge asymmetry in all planes using the supplied list of Tjs
     if (tjIDs.size() < 2) return 1;
     std::vector<float> plnchg(slc.nPlanes);
     for (auto tjid : tjIDs) {
       if (tjid <= 0 || tjid > (int)slc.tjs.size()) return 1;
       auto& tj = slc.tjs[tjid - 1];
       if (tj.TotChg == 0) UpdateTjChgProperties("MCA", slc, 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 < slc.nPlanes; ++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 < slc.nPlanes; ++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	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 3274 of file Utils.cxx.

   {
     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(slc, iht, tp);
         if (delta > md) md = delta;
       } // ii
     }   // pts
     return md;
   } // MaxHitDelta

float tca::MaxTjLen	(	const TCSlice &	slc,
		std::vector< int > &	tjIDs
	)

Definition at line 2628 of file Utils.cxx.

   {
     // 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)slc.tjs.size()) continue;
       auto& tj = slc.tjs[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 TCSlice &	slc,
		const std::vector< int > &	tjIDs
	)

Definition at line 3466 of file Utils.cxx.

   {
     // Find the average MCSMom of the trajectories
     if (tjIDs.empty()) return 0;
     float summ = 0;
     float suml = 0;
     for (auto tjid : tjIDs) {
       auto& tj = slc.tjs[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	(	const TCSlice &	slc,
		const Trajectory &	tj
	)

Definition at line 3483 of file Utils.cxx.

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

short tca::MCSMom	(	const TCSlice &	slc,
		const Trajectory &	tj,
		unsigned short	firstPt,
		unsigned short	lastPt
	)

Definition at line 3490 of file Utils.cxx.

   {
     // 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(slc, tj, firstPt);
     lastPt = NearestPtWithChg(slc, 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(slc, 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(slc, 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	(	const TCSlice &	slc,
		const Trajectory &	tj
	)

Definition at line 3539 of file Utils.cxx.

   {
     // 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(slc, tj, tj.EndPt[0], tj.EndPt[1]) / sqrt(tps);
 
   } // MCSThetaRMS

double tca::MCSThetaRMS	(	const TCSlice &	slc,
		const Trajectory &	tj,
		unsigned short	firstPt,
		unsigned short	lastPt
	)

Definition at line 3554 of file Utils.cxx.

   {
     // 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(slc, tj, firstPt);
     lastPt = NearestPtWithChg(slc, tj, lastPt);
     if (firstPt >= lastPt) return 1;
 
     double sigmaS;
     unsigned short cnt;
     TjDeltaRMS(slc, tj, firstPt, lastPt, sigmaS, cnt);
     if (sigmaS < 0) return 1;
     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	(	TCSlice &	slc,
		unsigned int	itj1,
		unsigned int	itj2,
		bool	doPrt
	)

Not allowed

Definition at line 4662 of file Utils.cxx.

   {
     // 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 > slc.tjs.size() - 1) return false;
     if (itj2 > slc.tjs.size() - 1) return false;
     if (slc.tjs[itj1].AlgMod[kKilled] || slc.tjs[itj2].AlgMod[kKilled]) return false;
     if (slc.tjs[itj1].AlgMod[kHaloTj] || slc.tjs[itj2].AlgMod[kHaloTj]) return false;
 
     // Merging shower Tjs requires merging the showers as well.
     if (slc.tjs[itj1].AlgMod[kShowerTj] || slc.tjs[itj2].AlgMod[kShowerTj])
       return MergeShowerTjsAndStore(slc, itj1, itj2, doPrt);
 
     // Ensure that the order of 3D-matched Tjs is consistent with the convention that
     unsigned short pfp1 = GetPFPIndex(slc, slc.tjs[itj1].ID);
     unsigned short pfp2 = GetPFPIndex(slc, slc.tjs[itj2].ID);
     if (pfp1 != USHRT_MAX || pfp2 != USHRT_MAX) {
       if (pfp1 != USHRT_MAX && pfp2 != USHRT_MAX) 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 = slc.tjs[itj1];
     Trajectory tj2 = slc.tjs[itj2];
 
     // ensure that these are in the same step order
     if (tj2.StepDir != tj1.StepDir) ReverseTraj(slc, 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: T" << tj1.ID << " and T" << tj2.ID
                             << " at merge points " << PrintPos(slc, tp1e1) << " "
                             << PrintPos(slc, 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(slc, tp1e1) << " "
                               << PrintPos(slc, 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;
       /// Not allowed
       // 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 = slc.vtxs[tj1.VtxID[1] - 1];
       if (!MakeVertexObsolete("MAS", slc, vx, false)) {
         if (doPrt)
           mf::LogVerbatim("TC") << "MergeAndStore: Found a good vertex between Tjs " << tj1.VtxID[1]
                                 << " No merging";
         return false;
       }
     }
 
     if (tj1.EndFlag[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(slc, endtj1TP, tj2, tj2ClosePt, minSep);
     if (doPrt)
       mf::LogVerbatim("TC") << " Merge point tj1 " << PrintPos(slc, endtj1TP) << " tj2ClosePt "
                             << tj2ClosePt << " Pos " << PrintPos(slc, 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(tj1);
     tj1.EndFlag[1] = tj2.EndFlag[1];
 
     // A more exhaustive check that hits only appear once
     if (HasDuplicateHits(slc, tj1, doPrt)) 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(slc, itj1);
     MakeTrajectoryObsolete(slc, itj2);
     // Do this so that StoreTraj keeps the correct WorkID (of itj1)
     tj1.ID = tj1.WorkID;
     SetPDGCode(slc, tj1);
     tj1.NeedsUpdate = true;
     if (!StoreTraj(slc, tj1)) return false;
     int newTjID = slc.tjs.size();
     // Use the ParentID to trace which new Tj is superseding the merged ones
     tj1.ParentID = newTjID;
     tj2.ParentID = newTjID;
     if (doPrt) mf::LogVerbatim("TC") << " MAS success. Created T" << newTjID;
     // Transfer the ParentIDs of any other Tjs that refer to Tj1 and Tj2 to the new Tj
     for (auto& tj : slc.tjs)
       if (tj.ParentID == tj1ID || tj.ParentID == tj2ID) tj.ParentID = newTjID;
     // try to attach it to a vertex
     AttachAnyVertexToTraj(slc, newTjID, doPrt);
     return true;
   } // MergeAndStore

void tca::MergeGhostTjs	(	TCSlice &	slc,
		CTP_t	inCTP
	)

Definition at line 2218 of file Utils.cxx.

   {
     // Merges short Tjs that share many hits with a longer Tj
     if (!tcc.useAlg[kMrgGhost]) return;
 
     for (auto& shortTj : slc.tjs) {
       if (shortTj.AlgMod[kKilled] || shortTj.AlgMod[kHaloTj]) 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 = slc.slHits[iht];
         if (hit.InTraj <= 0) continue;
         if ((unsigned int)hit.InTraj > slc.tjs.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 = slc.tjs[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,
		TCSlice &	slc,
		const CTP_t &	inCTP,
		bool	prt
	)

Definition at line 2308 of file TCShower.cxx.

   {
     if (!tcc.useAlg[kMergeNrShowers]) return;
     if (slc.cots.empty()) return;
 
     std::string fcnLabel = inFcnLabel + ".MNS";
 
     if (prt) {
       mf::LogVerbatim myprt("TC");
       myprt << fcnLabel << " list";
       for (auto& ss : slc.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 < slc.cots.size() - 1; ++ci1) {
         ShowerStruct& ss1 = slc.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 < slc.cots.size(); ++ci2) {
           ShowerStruct& ss2 = slc.cots[ci2];
           if (ss2.CTP != inCTP) continue;
           if (ss2.ID == 0) continue;
           if (ss2.TjIDs.empty()) continue;
           if (DontCluster(slc, 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 = slc.tjs[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(slc, "T", tj.ID, "P");
               if (!TInP.empty()) {
                 auto& pfp = slc.pfps[TInP[0] - 1];
                 if (pfp.PDGCode == 13 && MCSMom(slc, pfp.TjIDs) > 500) continue;
               } // TInP not empty
             }   // 3D matched
             if (AddTj(fcnLabel, slc, tjID, ss1, false, prt)) doMerge = true;
           } // tjID
           if (!doMerge) continue;
           if (MergeShowersAndStore(fcnLabel, slc, ss1.ID, ss2.ID, prt)) {
             Trajectory& stj = slc.tjs[ss1.ShowerTjID - 1];
             stj.AlgMod[kMergeNrShowers] = true;
             if (prt) mf::LogVerbatim("TC") << fcnLabel << " success";
             keepMerging = true;
             break;
           }
         } // ci2
       }   // ci1
     }     // keepMerging
 
     ChkAssns(fcnLabel, slc);
 
   } //MergeNearby2DShowers

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

Definition at line 2401 of file TCShower.cxx.

   {
     // 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 (tcc.showerTag[2] <= 0) return;
     if (!tcc.useAlg[kMergeOverlap]) return;
     if (slc.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 " << tcc.showerTag[2];
 
     float sepCut2 = tcc.showerTag[2] * tcc.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 < slc.cots.size() - 1; ++ict) {
         auto& iss = slc.cots[ict];
         if (iss.ID == 0) continue;
         if (iss.TjIDs.empty()) continue;
         if (iss.CTP != inCTP) continue;
         for (unsigned short jct = ict + 1; jct < slc.cots.size(); ++jct) {
           auto& jss = slc.cots[jct];
           if (jss.ID == 0) continue;
           if (jss.TjIDs.empty()) continue;
           if (jss.CTP != iss.CTP) continue;
           if (DontCluster(slc, 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 " << tcc.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 = slc.tjs[iss.ShowerTjID - 1];
           auto& jstj = slc.tjs[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, slc, iss.ID, jss.ID, prt)) {
             Trajectory& stj = slc.tjs[iss.ShowerTjID - 1];
             stj.AlgMod[kMergeOverlap] = true;
             didMerge = true;
             break;
           }
           else {
             if (prt) mf::LogVerbatim("TC") << fcnLabel << " Merge failed";
           }
         } // jct
       }   // ict
     }     // didMerge
 
     ChkAssns(fcnLabel, slc);
 
   } // MergeOverlap

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

Definition at line 2522 of file TCShower.cxx.

   {
     // Merge chains of 3 or more showers that lie on a line
 
     if (!tcc.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 < slc.cots.size(); ++ict) {
       ShowerStruct& iss = slc.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(slc.tjs[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].val = tpList[ii].Pos[0];
     }
     std::sort(sortVec.begin(), sortVec.end(), valsDecreasing);
     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 = slc.cots[sids[ii] - 1];
       if (iss.ID == 0) continue;
       unsigned short jj = ii + 1;
       auto& jss = slc.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(slc, iss.TjIDs, jss.TjIDs);
       if (prt)
         mf::LogVerbatim("TC") << fcnLabel << " i2S" << iss.ID << " "
                               << PrintPos(slc, tpList[ii].Pos) << " j2S" << jss.ID << " "
                               << PrintPos(slc, tpList[jj].Pos) << " sepij " << sepij << " skipit? "
                               << skipit;
       if (skipit) continue;
       // draw a line between these points
       TrajPoint tp;
       MakeBareTrajPoint(slc, tpList[ii], tpList[jj], tp);
       for (unsigned short kk = jj + 1; kk < sids.size(); ++kk) {
         auto& kss = slc.cots[sids[kk] - 1];
         if (kss.ID == 0) continue;
         if (DontCluster(slc, iss.TjIDs, kss.TjIDs)) continue;
         if (DontCluster(slc, jss.TjIDs, kss.TjIDs)) continue;
         float sepjk = PosSep(tpList[jj].Pos, tpList[kk].Pos);
         float delta = PointTrajDOCA(slc, tpList[kk].Pos[0], tpList[kk].Pos[1], tp);
         if (prt) {
           mf::LogVerbatim myprt("TC");
           myprt << fcnLabel << "   k2S" << kss.ID << " " << PrintPos(slc, 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, slc, 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(slc, tpList[ii], tpList[kk], tp);
         } // add to an existing chain
       }   // kk
       // push the last one
       if (chain.size() > 2) {
         int newID = MergeShowers(fcnLabel, slc, chain, 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, slc);
 
   } // MergeShowerChain

int tca::MergeShowers	(	std::string	inFcnLabel,
		TCSlice &	slc,
		std::vector< int >	ssIDs,
		bool	prt
	)

Definition at line 2882 of file TCShower.cxx.

   {
     // 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)slc.cots.size()) return 0;
     // check for the same CTP and consistent assns
     int ss3Assn = 0;
     auto& ss0 = slc.cots[ssIDs[0] - 1];
     std::vector<int> tjl;
     for (auto ssID : ssIDs) {
       auto& ss = slc.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) return 0;
     } // ssID
     // ensure the InShower Tjs are valid
     for (auto tjID : tjl) {
       auto& tj = slc.tjs[tjID - 1];
       if (tj.CTP != ss0.CTP || tj.AlgMod[kKilled]) return 0;
     } // tjID
 
     // mark the old showers killed
     for (auto ssID : ssIDs) {
       auto& ss = slc.cots[ssID - 1];
       ss.ID = 0;
       // kill the shower Tj
       auto& stj = slc.tjs[ss.ShowerTjID - 1];
       stj.AlgMod[kKilled] = true;
     } // tjID
 
     // in with the new
     auto newss = CreateSS(slc, tjl);
     if (newss.ID == 0) return 0;
 
     for (auto tid : tjl) {
       auto& tj = slc.tjs[tid - 1];
       tj.SSID = newss.ID;
     } // tid
     newss.SS3ID = ss3Assn;
 
     // define the new shower
     if (!UpdateShower(fcnLabel, slc, newss, prt)) {
       MakeShowerObsolete(fcnLabel, slc, newss, prt);
       return 0;
     }
     // store it
     if (!StoreShower(fcnLabel, slc, newss)) {
       MakeShowerObsolete(fcnLabel, slc, newss, prt);
       return 0;
     }
     return newss.ID;
 
   } // MergeShowers

bool tca::MergeShowersAndStore	(	std::string	inFcnLabel,
		TCSlice &	slc,
		int	icotID,
		int	jcotID,
		bool	prt
	)

Definition at line 2944 of file TCShower.cxx.

   {
     // 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)slc.cots.size()) return false;
     ShowerStruct& iss = slc.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)slc.cots.size()) return false;
     ShowerStruct& jss = slc.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) return false;
 
     Trajectory& itj = slc.tjs[iss.ShowerTjID - 1];
     Trajectory& jtj = slc.tjs[jss.ShowerTjID - 1];
     if (!itj.Pts[1].Hits.empty() || !jtj.Pts[1].Hits.empty()) 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 = slc.tjs.size() + 1;
 
     slc.tjs.push_back(ktj);
     // kill jtj
     MakeTrajectoryObsolete(slc, iss.ShowerTjID - 1);
     MakeTrajectoryObsolete(slc, jss.ShowerTjID - 1);
     slc.tjs[iss.ShowerTjID - 1].ParentID = ktj.ID;
     slc.tjs[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 = slc.tjs[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.NeedsUpdate = true;
     // force a full update
     iss.ShPts.clear();
     jss.ID = 0;
     bool success = UpdateShower(fcnLabel, slc, iss, prt);
     KillVerticesInShower(fcnLabel, slc, iss, prt);
 
     return success;
 
   } // MergeShowersAndStore

bool tca::MergeShowerTjsAndStore	(	TCSlice &	slc,
		unsigned short	istj,
		unsigned short	jstj,
		bool	prt
	)

Definition at line 3015 of file TCShower.cxx.

   {
     // 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 > slc.tjs.size() - 1) return false;
     if (jstj > slc.tjs.size() - 1) return false;
 
     Trajectory& itj = slc.tjs[istj];
     Trajectory& jtj = slc.tjs[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(slc, itj.ID);
     if (icotID == 0) return false;
     ShowerStruct& iss = slc.cots[icotID - 1];
     if (iss.ID == 0) return false;
     if (iss.TjIDs.empty()) return false;
     int jcotID = GetCotID(slc, jtj.ID);
     if (jcotID == 0) return false;
     ShowerStruct& jss = slc.cots[jcotID - 1];
     if (jss.ID == 0) return false;
     if (jss.TjIDs.empty()) return false;
 
     return MergeShowersAndStore(fcnLabel, slc, icotID, jcotID, prt);
 
   } // MergeShowerTjsAndStore

void tca::MergeSubShowers	(	std::string	inFcnLabel,
		TCSlice &	slc,
		const CTP_t &	inCTP,
		bool	prt
	)

Definition at line 2765 of file TCShower.cxx.

   {
     // Merge small showers that are downstream of larger showers
 
     if (!tcc.useAlg[kMergeSubShowers]) return;
 
     std::string fcnLabel = inFcnLabel + ".MSS";
     bool newCuts = (tcc.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 : slc.cots) {
         if (ss.ID == 0) continue;
         if (ss.CTP != inCTP) continue;
         SortEntry se;
         se.index = ss.ID - 1;
         se.val = ss.Energy;
         sortVec.push_back(se);
       } // ss
       if (sortVec.size() < 2) return;
       std::sort(sortVec.begin(), sortVec.end(), valsIncreasing);
       for (unsigned short ii = 0; ii < sortVec.size() - 1; ++ii) {
         ShowerStruct& iss = slc.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 = slc.tjs[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 /= tcc.wirePitch;
         for (unsigned short jj = ii + 1; jj < sortVec.size(); ++jj) {
           ShowerStruct& jss = slc.cots[sortVec[jj].index];
           if (jss.ID == 0) continue;
           if (DontCluster(slc, iss.TjIDs, jss.TjIDs)) continue;
           TrajPoint& jstp1 = slc.tjs[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
             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(slc, jstp1.Pos[0], jstp1.Pos[1], istp1);
             }
             else {
               delta = PointTrajDOCA(slc, 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, slc, iss.ID, jss.ID, prt)) {
             Trajectory& stj = slc.tjs[iss.ShowerTjID - 1];
             stj.AlgMod[kMergeSubShowers] = true;
             keepMerging = true;
             break;
           }
         } // jj
         if (keepMerging) break;
       } // ii
     }   // keepMerging
 
     ChkAssns(fcnLabel, slc);
 
   } // MergeSubShowers

void tca::MergeSubShowersTj	(	std::string	inFcnLabel,
		TCSlice &	slc,
		const CTP_t &	inCTP,
		bool	prt
	)

Definition at line 2653 of file TCShower.cxx.

   {
     // 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 (!tcc.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 : slc.cots) {
       if (ss.ID == 0) continue;
       if (ss.CTP != inCTP) continue;
       // TODO: Evaluate this cut
       if (ss.Energy > 300) continue;
       auto& stj = slc.tjs[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 : slc.tjs) {
         if (tj.AlgMod[kKilled]) continue;
         if (tj.AlgMod[kHaloTj]) 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(slc, tj, false) < 10) continue;
         // and satisfy the ShowerLike MCSMom cut. It is unlikely to be tagged shower-like
         if (tj.MCSMom > tcc.showerTag[1]) continue;
         // check consistency
         tjid[0] = tj.ID;
         if (DontCluster(slc, tjid, ss.TjIDs)) continue;
         float tjEnergy = ChgToMeV(tj.TotChg);
         // find the end that is furthest away from the shower center
         unsigned short farEnd = FarEnd(slc, 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(slc, tj, tj.EndPt[farEnd], midpt);
         float mom2 = MCSMom(slc, 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(slc, 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 = slc.cots[match.ssID - 1];
         if (!AddTj(fcnLabel, slc, match.tjID, ss, true, prt)) {
           if (prt) mf::LogVerbatim("TC") << " Failed";
           continue;
         }
         match.dang = -1;
         // set the AlgMod bit
         auto& stj = slc.tjs[ss.ShowerTjID - 1];
         stj.AlgMod[kMergeSubShowersTj] = true;
         keepGoing = true;
       } // found bestMatch
     }   // keepGoing
 
     ChkAssns(fcnLabel, slc);
 
   } // MergeSubShowersTj

bool tca::MergeTjIntoPFP	(	TCSlice &	slc,
		int	mtjid,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 511 of file Utils.cxx.

   {
     // Tries to merge Tj with ID tjid into PFParticle pfp
     if (mtjid > (int)slc.tjs.size()) return false;
     auto& mtj = slc.tjs[mtjid - 1];
     // find the Tj in pfp.TjIDs which it should be merged with
     int otjid = 0;
     for (auto tjid : pfp.TjIDs) {
       auto& otj = slc.tjs[tjid - 1];
       if (otj.CTP == mtj.CTP) {
         otjid = tjid;
         break;
       }
     } // tjid
     if (otjid == 0) return false;
     if (MergeAndStore(slc, otjid - 1, mtjid - 1, prt)) {
       int newtjid = slc.tjs.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 1301 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,
		TCSlice &	slc,
		std::vector< std::vector< int >> &	tjList,
		bool	prt
	)

bool tca::MergeWithVertex	(	TCSlice &	slc,
		VtxStore &	vx,
		unsigned short	oVxID
	)

Definition at line 449 of file TCVertex.cxx.

   {
     // 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 slc.vtxs
 
     if (!tcc.useAlg[kVxMerge]) return false;
 
     bool prt = tcc.dbgVxMerge && tcc.dbgSlc;
 
     if (oVxID > slc.vtxs.size()) return false;
     auto& oVx = slc.vtxs[oVxID - 1];
     if (vx.CTP != oVx.CTP) return false;
 
     // get a list of tjs attached to both vertices
     std::vector<int> tjlist = GetVtxTjIDs(slc, vx);
     if (tjlist.empty()) return false;
     std::vector<int> tmp = GetVtxTjIDs(slc, oVx);
     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 = slc.tjs[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(slc, 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 = slc.tjs[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 slc, 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 = slc.tjs[tjlist[ii] - 1];
       unsigned short npwc = NumPtsWithCharge(slc, tj, false);
       unsigned short end = CloseEnd(slc, 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(slc, 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(slc, tjpt.Pos);
       }
     } // prt
     // create a subset of the first two for the first fit
     auto fitpts = tjpts;
     fitpts.resize(2);
     if (!FitVertex(slc, 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(slc, aVx, fitpts, prt)) { needsUpdate = false; }
       else {
         // remove the last Tj point and keep going
         fitpts.pop_back();
         needsUpdate = true;
       }
     } // ii
 
     if (needsUpdate) FitVertex(slc, aVx, fitpts, prt);
     if (prt) mf::LogVerbatim("TC") << "MWV: done " << vx.ID << " and existing " << oVx.ID;
 
     // update. Remove old associations
     for (auto& tj : slc.tjs) {
       if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) 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 = slc.tjs[tjpt.Hits[0] - 1];
       if (tj.VtxID[end] != 0) 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(slc, oVx);
     oVx.Stat[kVxMerged] = 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(slc, tjpt.Pos);
       }
     } // prt
 
     return true;
   } // MergeWithVertex

void tca::MoveTPToWire	(	TrajPoint &	tp,
		float	wire
	)

Definition at line 2829 of file Utils.cxx.

   {
     // 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::NearbyCleanPt	(	const TCSlice &	slc,
		const Trajectory &	tj,
		unsigned short	end
	)

Definition at line 2954 of file Utils.cxx.

   {
     // Searches for a TP near the end (or beginnin) that doesn't have the kEnvOverlap bit set
     // with the intent that a fit of a vertex position using this tj will be minimally
     // biased if there are no nearby hits from other tjs. A search is done from the
     // supplied nearPt moving in the + direction if nearPt == tj.EndPt[0] and moving in
     // the - direction if nearPt == tj.EndPt[1]
     if (end > 1) return USHRT_MAX;
     short dir = 1;
     if (end == 1) dir = -1;
     for (short ii = 0; ii < (short)tj.Pts.size(); ++ii) {
       short ipt = tj.EndPt[end] + dir * ii;
       if (ipt < 0 || ipt >= (short)tj.Pts.size()) return USHRT_MAX;
       auto& tp = tj.Pts[ipt];
       if (!tp.Environment[kEnvOverlap]) return ipt;
     } // ii
     return tj.EndPt[end];
   } // FindCleanPt

bool tca::NearbySrcHit	(	geo::PlaneID	plnID,
		unsigned int	wire,
		float	loTick,
		float	hiTick
	)

Definition at line 2069 of file Utils.cxx.

   {
     // Look for a hit on wid in the srcHits collection that has a tick in the range. This
     // is a DUNE-specific function in which hit disambiguation is done in the U and V planes
     if (evt.srcHits == NULL) return false;
     unsigned int pln = plnID.Plane;
     if (pln == 2) return false;
 
     unsigned int cstat = plnID.Cryostat;
     unsigned int tpc = plnID.TPC;
     // get a valid range of hits to search
     if (evt.tpcSrcHitRange[tpc].first >= (*evt.srcHits).size()) return false;
     if (evt.tpcSrcHitRange[tpc].second >= (*evt.srcHits).size()) return false;
     raw::ChannelID_t chan = tcc.geom->PlaneWireToChannel((int)pln, (int)wire, (int)tpc, (int)cstat);
     float atTick = 0.5 * (loTick + hiTick);
     for (unsigned int iht = evt.tpcSrcHitRange[tpc].first; iht <= evt.tpcSrcHitRange[tpc].second;
          ++iht) {
       auto& hit = (*evt.srcHits)[iht];
       if (hit.Channel() != chan) continue;
       if (atTick < hit.PeakTime()) {
         float loHitTick = hit.PeakTime() - 3 * hit.RMS();
         if (hiTick > loHitTick) return true;
       }
       else {
         float hiHitTick = hit.PeakTime() + 3 * hit.RMS();
         if (loTick < hiHitTick) return true;
       }
     } // iht
     return false;
   } // NearbySrcHit

unsigned short tca::NearestPtWithChg	(	const TCSlice &	slc,
		const Trajectory &	tj,
		unsigned short	thePt
	)

Definition at line 3520 of file Utils.cxx.

   {
     // 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 TCSlice &	slc,
		const Trajectory &	tj
	)

Definition at line 442 of file Utils.cxx.

   {
     // 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] || tj.AlgMod[kHaloTj]) return -1;
     if (tj.ParentID <= 0) return -1;
     int primID = PrimaryID(slc, tj);
     if (primID <= 0 || primID > (int)slc.tjs.size()) return -1;
 
     // We have the ID of the primary tj. Now see if it is attached to the neutrino vertex
     auto& ptj = slc.tjs[primID - 1];
     for (unsigned short end = 0; end < 2; ++end) {
       if (ptj.VtxID[end] == 0) continue;
       auto& vx2 = slc.vtxs[ptj.VtxID[end] - 1];
       if (vx2.Vx3ID == 0) continue;
       auto& vx3 = slc.vtx3s[vx2.Vx3ID - 1];
       if (vx3.Neutrino) return primID;
     } // end
     return -1;
   } // NeutrinoPrimaryTjUID

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

Definition at line 4326 of file Utils.cxx.

   {
     // 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 TCSlice &	slc,
		const Trajectory &	tj,
		bool	includeDeadWires
	)

Definition at line 2114 of file Utils.cxx.

   {
     unsigned short firstPt = tj.EndPt[0];
     unsigned short lastPt = tj.EndPt[1];
     return NumPtsWithCharge(slc, tj, includeDeadWires, firstPt, lastPt);
   }

unsigned short tca::NumPtsWithCharge	(	const TCSlice &	slc,
		const Trajectory &	tj,
		bool	includeDeadWires,
		unsigned short	firstPt,
		unsigned short	lastPt
	)

Definition at line 2123 of file Utils.cxx.

   {
     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(slc, tj.Pts[firstPt], tj.Pts[lastPt]);
     return ntp;
   } // NumPtsWithCharge

unsigned short tca::NumUsedHitsInTj	(	const TCSlice &	slc,
		const Trajectory &	tj
	)

Definition at line 4312 of file Utils.cxx.

   {
     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	(	const TCSlice &	slc,
		const Trajectory &	tj1,
		const Trajectory &	tj2
	)

Definition at line 711 of file Utils.cxx.

   {
     // 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,
		TCSlice &	slc,
		PFPStruct &	pfp,
		unsigned short	pend,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 2075 of file TCShower.cxx.

   {
     // 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 = slc.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 = slc.tjs[tid - 1];
         if (tj.ID == 0) continue;
         if (tj.CTP == ss.CTP) tjid = tid;
       } // tid
       if (tjid == 0) continue;
       auto& ptj = slc.tjs[tjid - 1];
       auto& stj = slc.tjs[ss.ShowerTjID - 1];
       // determine which end is farthest away from the shower center
       unsigned short ptjEnd = FarEnd(slc, 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, slc, 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,
		TCSlice &	slc,
		Trajectory &	tj,
		unsigned short &	tjEnd,
		ShowerStruct &	ss,
		float &	tp1Sep,
		float &	vx2Score,
		bool	prt
	)

Definition at line 2127 of file TCShower.cxx.

   {
     // 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 = slc.tjs[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(slc, 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 = tcc.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(slc, 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 = slc.vtxs[tj.VtxID[tjEnd] - 1];
       vx2Sep = PosSep(vx2.Pos, stp1.Pos);
       vx2Score = vx2.Score;
       tjlist = GetAssns(slc, "2V", vx2.ID, "T");
       vxFOM = std::abs(shMaxAlong - vx2Sep) / 20;
     } // 2D vertex exists
     fom += vxFOM;
     ++cnt;
     float chgFrac = ChgFracNearPos(slc, 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(slc, ptp, stp1.Pos[0]);
     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(slc, 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 ( int PDGCode )

Definition at line 2169 of file Utils.cxx.

   {
     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	(	const TCSlice &	slc,
		const std::vector< int > &	tjIDs
	)

Definition at line 405 of file Utils.cxx.

   {
     // 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
     std::array<int, 5> codeList = {{0, 11, 13, 111, 211}};
     unsigned short codeIndex = 0;
     if (tjIDs.empty()) return codeList[codeIndex];
 
     std::array<unsigned short, 5> cnts;
     cnts.fill(0);
     float maxLen = 0;
     for (auto tjid : tjIDs) {
       if (tjid <= 0 || tjid > (int)slc.tjs.size()) continue;
       auto& tj = slc.tjs[tjid - 1];
       for (unsigned short ii = 0; ii < 5; ++ii)
         if (tj.PDGCode == codeList[ii]) ++cnts[ii];
       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
     return codeList[codeIndex];
   } // PDGCodeVote

int tca::PDGCodeVote	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		PFPStruct &	pfp
	)

Definition at line 3351 of file PFPUtils.cxx.

   {
     // returns a vote using PDG code assignments from dE/dx. A PDGCode of -1 is
     // returned if there was a failure and returns 0 if no decision can be made
     if (pfp.TP3Ds.empty()) return -1;
 
     // try to do better using dE/dx
     float dEdXAve = 0;
     float dEdXRms = 0;
     Average_dEdX(clockData, detProp, slc, pfp, dEdXAve, dEdXRms);
     if (dEdXAve < 0) return 0;
     // looks like a proton if dE/dx is high and the rms is low
     dEdXRms /= dEdXAve;
     float length = Length(pfp);
     float mcsmom = 0;
     float chgrms = 0;
     float cnt = 0;
     for (auto tjid : pfp.TjIDs) {
       auto& tj = slc.tjs[tjid - 1];
       float el = ElectronLikelihood(slc, tj);
       if (el <= 0) continue;
       mcsmom += MCSMom(slc, tj);
       chgrms += tj.ChgRMS;
       ++cnt;
     } // tjid
     if (cnt < 2) return 0;
     mcsmom /= cnt;
     chgrms /= cnt;
     int vote = 0;
     // call anything longer than 150 cm a muon
     if (length > 150) vote = 13;
     // or shorter with low dE/dx and really straight
     if (vote == 0 && length > 50 && dEdXAve < 2.5 && mcsmom > 500) vote = 13;
     // protons have high dE/dx, high MCSMom and low charge rms
     if (vote == 0 && dEdXAve > 3.0 && mcsmom > 200 && chgrms < 0.4) vote = 2212;
     // electrons have low MCSMom and large charge RMS
     if (vote == 0 && mcsmom < 50 && chgrms > 0.4) vote = 11;
     return vote;
   } // PDGCodeVote

void tca::PFPVertexCheck ( TCSlice & slc )

Definition at line 2844 of file PFPUtils.cxx.

   {
     // Ensure that all PFParticles have a start vertex. It is possible for
     // PFParticles to be attached to a 3D vertex that is later killed.
     if (!slc.isValid) return;
     if (slc.pfps.empty()) return;
 
     for (auto& pfp : slc.pfps) {
       if (pfp.ID == 0) continue;
       if (pfp.Vx3ID[0] > 0) continue;
       if (pfp.SectionFits.empty()) continue;
       Vtx3Store vx3;
       vx3.TPCID = pfp.TPCID;
       vx3.Vx2ID.resize(slc.nPlanes);
       // Flag it as a PFP vertex that isn't required to have matched 2D vertices
       vx3.Wire = -2;
       Point3_t startPos;
       if (pfp.TP3Ds.empty()) {
         // must be a neutrino pfp
         startPos = pfp.SectionFits[0].Pos;
       }
       else if (!pfp.TP3Ds.empty()) {
         // normal pfp
         startPos = pfp.TP3Ds[0].Pos;
       }
       vx3.X = startPos[0];
       vx3.Y = startPos[1];
       vx3.Z = startPos[2];
       vx3.ID = slc.vtx3s.size() + 1;
       vx3.Primary = false;
       ++evt.global3V_UID;
       vx3.UID = evt.global3V_UID;
       slc.vtx3s.push_back(vx3);
       pfp.Vx3ID[0] = vx3.ID;
     } // pfp
   }   // PFPVertexCheck

Vector3_t tca::PointDirection	(	const Point3_t	p1,
		const Point3_t	p2
	)

Definition at line 2547 of file PFPUtils.cxx.

   {
     // 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 4185 of file Utils.cxx.

   {
     // 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 3114 of file PFPUtils.cxx.

   {
     // 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 3321 of file Utils.cxx.

   {
     // 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::PointPull	(	TCSlice &	slc,
		Point2_t	pos,
		float	chg,
		const Trajectory &	tj
	)

Definition at line 544 of file Utils.cxx.

   {
     // returns the combined position and charge pull for the charge at pos
     // relative to the Tj closest to that point using a loose requirement on position separation.
     if (tj.AlgMod[kKilled]) return 100;
     if (tj.AveChg <= 0) return 100;
     // find the closest point on the tj to pos
     unsigned short closePt = USHRT_MAX;
     float close = 1000;
     for (unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       auto& tp = tj.Pts[ipt];
       float sep2 = PosSep2(pos, tp.Pos);
       if (sep2 > close) continue;
       close = sep2;
       closePt = ipt;
     } // ipt
     if (closePt == USHRT_MAX) return 100;
     // find the delta between the projection of the Tj close TP to inTP
     auto& tp = tj.Pts[closePt];
     float delta = PointTrajDOCA(slc, pos[0], pos[1], tp);
     // estimate the proejcted position error (roughly)
     float posErr = tp.DeltaRMS;
     if (tp.AngErr > 0 && close > 10) posErr += sqrt(tp.AngErr * sqrt(close));
     if (posErr < 0.1) posErr = 0.1;
     float posPull = delta / posErr;
     float chgErr = tj.ChgRMS;
     if (chgErr < 0.15) chgErr = 0.15;
     float chgPull = std::abs(chg / tj.AveChg - 1) / chgErr;
     // return a simple average
     return 0.5 * (posPull + chgPull);
   } // PointPull

float tca::PointPull	(	const PFPStruct &	pfp,
		const TP3D &	tp3d
	)

Definition at line 2814 of file PFPUtils.cxx.

   {
     // returns the pull that the tp3d will cause in the pfp section fit. This
     // currently only uses position but eventually will include charge
     return std::abs(tp3d.Pos[0] - tp3d.TPX) / sqrt(tp3d.TPXErr2);
   } // PointPull

float tca::PointTrajDOCA	(	const TCSlice &	slc,
		unsigned int	iht,
		TrajPoint const &	tp
	)

Definition at line 2570 of file Utils.cxx.

   {
     if (iht > slc.slHits.size() - 1) return 1E6;
     auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
     float wire = hit.WireID().Wire;
     float time = hit.PeakTime() * tcc.unitsPerTick;
     return sqrt(PointTrajDOCA2(slc, wire, time, tp));
   } // PointTrajDOCA

float tca::PointTrajDOCA	(	const TCSlice &	slc,
		float	wire,
		float	time,
		TrajPoint const &	tp
	)

Definition at line 2581 of file Utils.cxx.

   {
     return sqrt(PointTrajDOCA2(slc, wire, time, tp));
   } // PointTrajDOCA

float tca::PointTrajDOCA2	(	const TCSlice &	slc,
		float	wire,
		float	time,
		TrajPoint const &	tp
	)

Definition at line 2588 of file Utils.cxx.

   {
     // returns the distance of closest approach squared between a (wire, time(WSE)) point
     // and a trajectory point
 
     double t = (double)(wire - tp.Pos[0]) * tp.Dir[0] + (double)(time - tp.Pos[1]) * tp.Dir[1];
     double dw = tp.Pos[0] + t * tp.Dir[0] - wire;
     double dt = tp.Pos[1] + t * tp.Dir[1] - time;
     return (float)(dw * dw + dt * dt);
 
   } // PointTrajDOCA2

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

Definition at line 2561 of file Utils.cxx.

   {
     float dw = wire - tp.Pos[0];
     float dt = time - tp.Pos[1];
     return dw * dw + dt * dt;
   }

Point3_t tca::PosAtEnd	(	const PFPStruct &	pfp,
		unsigned short	end
	)

Definition at line 3292 of file PFPUtils.cxx.

   {
     if (end > 1 || pfp.SectionFits.empty()) return {{0., 0., 0.}};
     // handle a neutrino pfp that doesn't have any TP3Ds
     if (pfp.TP3Ds.empty()) return pfp.SectionFits[0].Pos;
     if (end == 0) return pfp.TP3Ds[0].Pos;
     return pfp.TP3Ds[pfp.TP3Ds.size() - 1].Pos;
   } // PosAtEnd

void tca::PosInPlane	(	detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		const Vtx3Store &	vx3,
		unsigned short	plane,
		Point2_t &	pos
	)

Definition at line 2893 of file TCVertex.cxx.

   {
     // returns the 2D position of the vertex in the plane
     pos[0] = tcc.geom->WireCoordinate(vx3.Y, vx3.Z, plane, vx3.TPCID.TPC, vx3.TPCID.Cryostat);
     pos[1] =
       detProp.ConvertXToTicks(vx3.X, plane, vx3.TPCID.TPC, vx3.TPCID.Cryostat) * tcc.unitsPerTick;
 
   } // PosInPlane

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

Definition at line 2564 of file PFPUtils.cxx.

   {
     return sqrt(PosSep2(pos1, pos2));
   } // PosSep

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

Definition at line 2661 of file Utils.cxx.

   {
     return sqrt(PosSep2(pos1, pos2));
   } // PosSep

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

Definition at line 2571 of file PFPUtils.cxx.

   {
     // 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 2668 of file Utils.cxx.

   {
     // 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 TCSlice &	slc,
		const Trajectory &	tj
	)

Definition at line 465 of file Utils.cxx.

   {
     // Returns the ID of the grandparent trajectory of this trajectory that is a primary
     // trajectory (i.e. whose ParentID = 0).
     if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) return -1;
     if (tj.ParentID < 0 || tj.ParentID > (int)slc.tjs.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)slc.tjs.size()) break;
       auto& tj = slc.tjs[parid - 1];
       if (tj.ParentID < 0 || tj.ParentID > (int)slc.tjs.size()) return -1;
       if (tj.ParentID == 0) return tj.ID;
       parid = tj.ParentID;
     } // nit
     return -1;
   } // PrimaryID

int tca::PrimaryUID	(	const TCSlice &	slc,
		const PFPStruct &	pfp
	)

Definition at line 485 of file Utils.cxx.

   {
     // returns the UID of the most upstream PFParticle (that is not a neutrino)
 
     if (int(pfp.ParentUID) == pfp.UID || pfp.ParentUID <= 0) return pfp.ID;
     int paruid = pfp.ParentUID;
     int dtruid = pfp.UID;
     unsigned short nit = 0;
     while (true) {
       auto slcIndx = GetSliceIndex("P", paruid);
       auto& parent = slices[slcIndx.first].pfps[slcIndx.second];
       // found a neutrino
       if (parent.PDGCode == 14 || parent.PDGCode == 12) return dtruid;
       // found a primary PFParticle?
       if (parent.ParentUID == 0) return parent.UID;
       if (int(parent.ParentUID) == parent.UID) return parent.UID;
       dtruid = parent.UID;
       paruid = parent.ParentUID;
       if (paruid < 0) return 0;
       ++nit;
       if (nit == 10) return 0;
     }
   } // PrimaryUID

void tca::Print2DShowers	(	std::string	someText,
		TCSlice &	slc,
		CTP_t	inCTP,
		bool	printKilledShowers
	)

Definition at line 4252 of file TCShower.cxx.

   {
     // Prints a one-line summary of 2D showers
     if (slc.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 : slc.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 < slc.cots.size(); ++ict) {
       const auto& ss = slc.cots[ict];
       if (!printAllCTP && ss.CTP != inCTP) continue;
       if (!printKilledShowers && ss.ID == 0) continue;
       PrintShower(someText, slc, ss, printHeader, printExtras);
       printHeader = false;
     } // ss
     // List of Tjs
     for (unsigned short ict = 0; ict < slc.cots.size(); ++ict) {
       const auto& ss = slc.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 < slc.cots.size(); ++ict) {
       const auto& ss = slc.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] / tcc.unitsPerTick);
       myprt << "\n";
     } // ict
     // List of nearby Tjs
     for (unsigned short ict = 0; ict < slc.cots.size(); ++ict) {
       const auto& ss = slc.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 : slc.dontCluster) {
       if (dc.TjIDs[0] > 0) myprt << " T" << dc.TjIDs[0] << "-T" << dc.TjIDs[1];
     } // dc
     myprt << "\nDontCluster";
     for (unsigned short ict = 0; ict < slc.cots.size(); ++ict) {
       const auto& iss = slc.cots[ict];
       if (iss.ID == 0) continue;
       for (unsigned short jct = ict + 1; jct < slc.cots.size(); ++jct) {
         const auto& jss = slc.cots[jct];
         if (jss.ID == 0) continue;
         if (DontCluster(slc, iss.TjIDs, jss.TjIDs)) myprt << " 2S" << iss.ID << "-2S" << jss.ID;
       } // jct
     }   // ict
   }     // Print2DShowers

void tca::Print2V	(	std::string	someText,
		mf::LogVerbatim &	myprt,
		VtxStore &	vx2,
		bool &	printHeader
	)

Definition at line 5766 of file Utils.cxx.

   {
     // print a 2D vertex on one line
     if (vx2.ID <= 0) return;
     if (debug.CTP != UINT_MAX && vx2.CTP != debug.CTP) return;
     auto sIndx = GetSliceIndex("2V", vx2.UID);
     if (sIndx.first == USHRT_MAX) return;
     auto& slc = slices[sIndx.first];
     if (printHeader) {
       myprt << "************ 2D vertices ************\n";
       myprt << "     prodID    CTP    wire  err   tick   err  ChiDOF  NTj Pass  Topo ChgFrac Score "
                " v3D Tj UIDs\n";
       printHeader = false;
     }
     std::string str = "2V" + std::to_string(vx2.ID) + "/2VU" + std::to_string(vx2.UID);
     myprt << std::right << std::setw(12) << std::fixed << str;
     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] / tcc.unitsPerTick);
     myprt << std::right << std::setw(5) << std::setprecision(1) << vx2.PosErr[1] / tcc.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;
     int v3id = 0;
     if (vx2.Vx3ID > 0) v3id = slc.vtx3s[vx2.Vx3ID - 1].UID;
     myprt << std::right << std::setw(5) << v3id;
     myprt << "    ";
     // display the traj IDs
     for (unsigned short ii = 0; ii < slc.tjs.size(); ++ii) {
       auto const& tj = slc.tjs[ii];
       if (tj.AlgMod[kKilled]) continue;
       for (unsigned short end = 0; end < 2; ++end) {
         if (tj.VtxID[end] != (short)vx2.ID) continue;
         std::string tid = " TU" + std::to_string(tj.UID) + "_" + std::to_string(end);
         myprt << std::right << std::setw(6) << tid;
       } // end
     }   // ii
     myprt << " Stat:";
     // Special flags. Ignore the first flag bit (0 = kVxTrjTried) which is done for every vertex
     for (unsigned short ib = 1; ib < VtxBitNames.size(); ++ib)
       if (vx2.Stat[ib]) myprt << " " << VtxBitNames[ib];
     myprt << "\n";
   } // Print2V

void tca::Print3S	(	detinfo::DetectorPropertiesData const &	detProp,
		std::string	someText,
		mf::LogVerbatim &	myprt,
		ShowerStruct3D &	ss3
	)

Definition at line 5817 of file Utils.cxx.

   {
     if (ss3.ID <= 0) return;
     auto sIndx = GetSliceIndex("3S", ss3.UID);
     if (sIndx.first == USHRT_MAX) return;
     auto& slc = slices[sIndx.first];
     std::string str =
       std::to_string(slc.ID) + ":" + std::to_string(sIndx.first) + ":" + std::to_string(ss3.ID);
     str += "/" + std::to_string(ss3.UID);
     myprt << std::fixed << std::setw(12) << str;
     str = "--";
     if (ss3.Vx3ID > 0) str = "3V" + std::to_string(slc.vtx3s[ss3.Vx3ID - 1].UID);
     myprt << std::setw(6) << str;
     for (unsigned short xyz = 0; xyz < 3; ++xyz)
       myprt << std::setprecision(0) << std::setw(5) << ss3.ChgPos[xyz];
     for (unsigned short xyz = 0; xyz < 3; ++xyz)
       myprt << std::setprecision(2) << std::setw(5) << ss3.Dir[xyz];
     std::vector<float> projInPlane(slc.nPlanes);
     for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
       CTP_t inCTP = EncodeCTP(ss3.TPCID.Cryostat, ss3.TPCID.TPC, plane);
       auto tp = MakeBareTP(detProp, slc, ss3.ChgPos, ss3.Dir, inCTP);
       myprt << " " << PrintPos(slc, tp.Pos);
       projInPlane[plane] = tp.Delta;
     } // plane
     for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
       myprt << std::setprecision(2) << std::setw(5) << projInPlane[plane];
     } // plane
     for (auto cid : ss3.CotIDs) {
       auto& ss = slc.cots[cid - 1];
       str = "2SU" + std::to_string(ss.UID);
       myprt << std::setw(5) << str;
     } // ci
     if (ss3.NeedsUpdate) myprt << " *** Needs update";
     myprt << "\n";
   } // Print3S

void tca::Print3V	(	detinfo::DetectorPropertiesData const &	detProp,
		std::string	someText,
		mf::LogVerbatim &	myprt,
		Vtx3Store &	vx3,
		bool &	printHeader
	)

Definition at line 5689 of file Utils.cxx.

   {
     // print a 3D vertex on one line
     if (vx3.ID <= 0) return;
     auto sIndx = GetSliceIndex("3V", vx3.UID);
     if (sIndx.first == USHRT_MAX) return;
     auto& slc = slices[sIndx.first];
     if (printHeader) {
       myprt
         << "****** 3D vertices ******************************************__2DVtx_UID__*******\n";
       myprt << "     prodID    Cstat TPC     X       Y       Z    pln0   pln1   pln2 Wire score "
                "Prim? Nu? nTru";
       myprt << " ___________2D_Pos____________ _____Tj UIDs________\n";
       printHeader = false;
     }
     std::string str = "3V" + std::to_string(vx3.ID) + "/3VU" + std::to_string(vx3.UID);
     myprt << std::right << std::setw(12) << std::fixed << str;
     myprt << std::setprecision(0);
     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;
     for (auto vx2id : vx3.Vx2ID) {
       if (vx2id > 0) {
         str = "2VU" + std::to_string(slc.vtxs[vx2id - 1].UID);
         myprt << std::right << std::setw(7) << str;
       }
       else {
         myprt << "   --";
       }
     } // vx2id
     myprt << std::right << std::setw(5) << vx3.Wire;
     unsigned short nTruMatch = 0;
     for (unsigned short ipl = 0; ipl < slc.nPlanes; ++ipl) {
       if (vx3.Vx2ID[ipl] == 0) continue;
       unsigned short iv2 = vx3.Vx2ID[ipl] - 1;
       if (slc.vtxs[iv2].Stat[kVxTruMatch]) ++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 < slc.nPlanes; ++plane) {
       PosInPlane(detProp, slc, vx3, plane, pos);
       myprt << " " << PrintPos(slc, pos);
     } // plane
     if (vx3.Wire == -2) {
       // find the Tjs that are attached to it
       for (unsigned short end = 0; end < 2; ++end) {
         for (auto& pfp : slc.pfps) {
           if (pfp.Vx3ID[end] == vx3.ID) {
             for (auto tjID : pfp.TjIDs) {
               auto& tj = slc.tjs[tjID - 1];
               myprt << " T" << tj.UID;
             } // tjID
           }   // pfp.Vx3ID[0] == vx3.ID
         }     // pfp
       }       // end
     }
     else {
       auto vxtjs = GetAssns(slc, "3V", vx3.ID, "T");
       for (auto tjid : vxtjs) {
         auto& tj = slc.tjs[tjid - 1];
         myprt << " TU" << tj.UID;
       }
     } // vx3.Wire != -2
     myprt << "\n";
   } // Print3V

void tca::PrintAll	(	detinfo::DetectorPropertiesData const &	detProp,
		std::string	someText
	)

Definition at line 5519 of file Utils.cxx.

   {
     // print everything in all slices
     bool prt3V = false;
     bool prt2V = false;
     bool prtT = false;
     bool prtP = false;
     bool prtS3 = false;
     for (size_t isl = 0; isl < slices.size(); ++isl) {
       if (debug.Slice >= 0 && int(isl) != debug.Slice) continue;
       auto& slc = slices[isl];
       if (!slc.vtx3s.empty()) prt3V = true;
       if (!slc.vtxs.empty()) prt2V = true;
       if (!slc.tjs.empty()) prtT = true;
       if (!slc.pfps.empty()) prtP = true;
       if (!slc.showers.empty()) prtS3 = true;
     } // slc
     mf::LogVerbatim myprt("TC");
     myprt << "Debug report from caller " << someText << "\n";
     myprt << " 'prodID' = <sliceID>:<subSliceIndex>:<productID>/<productUID>\n";
     if (prtS3) {
       myprt << "************ Showers ************\n";
       myprt << "     prodID      Vtx  parUID  ___ChgPos____ ______Dir_____ ____posInPln____ "
                "___projInPln____ 2D shower UIDs\n";
       for (size_t isl = 0; isl < slices.size(); ++isl) {
         if (debug.Slice >= 0 && int(isl) != debug.Slice) continue;
         auto& slc = slices[isl];
         if (slc.showers.empty()) continue;
         for (auto& ss3 : slc.showers)
           Print3S(detProp, someText, myprt, ss3);
       } // slc
     }   // prtS3
     if (prtP) {
       bool printHeader = true;
       for (size_t isl = 0; isl < slices.size(); ++isl) {
         if (debug.Slice >= 0 && int(isl) != debug.Slice) continue;
         auto& slc = slices[isl];
         if (slc.pfps.empty()) continue;
         for (auto& pfp : slc.pfps)
           PrintP(someText, myprt, pfp, printHeader);
       } // slc
     }   // prtS3
     if (prt3V) {
       bool printHeader = true;
       myprt << "****** 3D vertices "
                "******************************************__2DVtx_UID__*******\n";
       myprt << "     prodID    Cstat TPC     X       Y       Z    XEr  YEr  "
                "ZEr pln0 pln1 pln2 Wire score Prim? Nu? nTru";
       myprt << " ___________2D_Pos____________ _____Tj UIDs________\n";
       for (size_t isl = 0; isl < slices.size(); ++isl) {
         if (debug.Slice >= 0 && int(isl) != debug.Slice) continue;
         auto& slc = slices[isl];
         if (slc.vtx3s.empty()) continue;
         for (auto& vx3 : slc.vtx3s)
           Print3V(detProp, someText, myprt, vx3, printHeader);
       } // slc
     }   // prt3V
     if (prt2V) {
       bool printHeader = true;
       myprt << "************ 2D vertices ************\n";
       myprt << "     prodID      CTP  wire  err   tick   err  ChiDOF  NTj Pass "
                " Topo ChgFrac Score  v3D Tj UIDs\n";
       for (size_t isl = 0; isl < slices.size(); ++isl) {
         if (debug.Slice >= 0 && int(isl) != debug.Slice) continue;
         auto& slc = slices[isl];
         if (slc.vtxs.empty()) continue;
         for (auto& vx2 : slc.vtxs)
           Print2V(someText, myprt, vx2, printHeader);
       } // slc
     }   // prt2V
     if (prtT) {
       bool printHeader = true;
       for (size_t isl = 0; isl < slices.size(); ++isl) {
         if (debug.Slice >= 0 && int(isl) != debug.Slice) continue;
         auto& slc = slices[isl];
         if (slc.tjs.empty()) continue;
         for (auto& tj : slc.tjs)
           PrintT(someText, myprt, tj, printHeader);
       } // slc
     }   // prtT
   }     // PrintAll

void tca::PrintAllTraj	(	detinfo::DetectorPropertiesData const &	detProp,
		std::string	someText,
		TCSlice &	slc,
		unsigned short	itj,
		unsigned short	ipt,
		bool	prtVtx
	)

Definition at line 5950 of file Utils.cxx.

   {
 
     mf::LogVerbatim myprt("TC");
 
     if (prtVtx) {
       if (!slc.vtx3s.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 < slc.vtx3s.size(); ++iv) {
           if (slc.vtx3s[iv].ID == 0) continue;
           const Vtx3Store& vx3 = slc.vtx3s[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 < slc.nPlanes; ++ipl) {
             if (vx3.Vx2ID[ipl] == 0) continue;
             unsigned short iv2 = vx3.Vx2ID[ipl] - 1;
             if (slc.vtxs[iv2].Stat[kVxTruMatch]) ++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 < slc.nPlanes; ++plane) {
             PosInPlane(detProp, slc, vx3, plane, pos);
             myprt << " " << PrintPos(slc, pos);
           } // plane
           if (vx3.Wire == -2) {
             // find the Tjs that are attached to it
             for (auto& pfp : slc.pfps) {
               if (pfp.Vx3ID[0] == slc.vtx3s[iv].ID) {
                 for (auto& tjID : pfp.TjIDs)
                   myprt << " t" << tjID;
               }
               if (pfp.Vx3ID[1] == slc.vtx3s[iv].ID) {
                 for (auto& tjID : pfp.TjIDs)
                   myprt << " t" << tjID;
               }
             } // ipfp
           }
           else {
             auto vxtjs = GetAssns(slc, "3V", vx3.ID, "T");
             for (auto tjid : vxtjs)
               myprt << " t" << tjid;
           }
           myprt << "\n";
         }
       } // slc.vtx3s.size
       if (!slc.vtxs.empty()) {
         bool foundOne = false;
         for (unsigned short iv = 0; iv < slc.vtxs.size(); ++iv) {
           auto& vx2 = slc.vtxs[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
                 << " ID   CTP    wire  err   tick   err  ChiDOF  NTj Pass  Topo ChgFrac Score  v3D "
                    "TjIDs\n";
           for (auto& vx2 : slc.vtxs) {
             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] / tcc.unitsPerTick);
             myprt << std::right << std::setw(5) << std::setprecision(1)
                   << vx2.PosErr[1] / tcc.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 < slc.tjs.size(); ++ii) {
               auto const& aTj = slc.tjs[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 = kVxTrjTried) 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
         }
       } // slc.vtxs.size
     }
 
     if (slc.tjs.empty()) {
       mf::LogVerbatim("TC") << someText << " No allTraj trajectories to print";
       return;
     }
 
     // Print all trajectories in slc.tjs 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
       myprt << "Tj AngleCode-EndFlag (EF) decoder: <AngleCode> + <reason for stopping>";
       myprt << " (B=Bragg Peak, V=Vertex, A=AngleKink, C=ChargeKink, T=Trajectory)\n";
       std::vector<unsigned int> tmp;
       myprt << someText
             << "   UID   CTP Pass  Pts     W:T      Ang EF AveQ     W:T      Ang EF AveQ Chg(k) "
                "chgRMS  Mom SDr __Vtx__  PDG  Par Pri NuPar   WorkID \n";
       for (unsigned short ii = 0; ii < slc.tjs.size(); ++ii) {
         auto& aTj = slc.tjs[ii];
         if (debug.CTP != UINT_MAX && aTj.CTP != debug.CTP) continue;
         myprt << someText << " ";
         std::string tid;
         if (aTj.AlgMod[kKilled]) { tid = "k" + std::to_string(aTj.UID); }
         else {
           tid = "t" + std::to_string(aTj.UID);
         }
         myprt << std::fixed << std::setw(5) << tid;
         myprt << std::setw(6) << aTj.CTP;
         myprt << std::setw(5) << aTj.Pass;
         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] / tcc.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.EndFlag[0][kBragg]) { myprt << "B"; }
         else if (aTj.EndFlag[0][kAtVtx]) {
           myprt << "V";
         }
         else if (aTj.EndFlag[0][kAtKink]) {
           myprt << "K";
         }
         else if (aTj.EndFlag[0][kAtTj]) {
           myprt << "T";
         }
         else {
           myprt << " ";
         }
         myprt << std::setw(5) << (int)tp0.AveChg;
         unsigned short endPt1 = aTj.EndPt[1];
         auto& tp1 = aTj.Pts[endPt1];
         itick = tp1.Pos[1] / tcc.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.EndFlag[1][kBragg]) { myprt << "B"; }
         else if (aTj.EndFlag[1][kAtVtx]) {
           myprt << "V";
         }
         else {
           myprt << " ";
         }
         myprt << std::setw(5) << (int)tp1.AveChg;
         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(5) << aTj.ParentID;
         myprt << std::setw(5) << PrimaryID(slc, aTj);
         myprt << std::setw(6) << NeutrinoPrimaryTjID(slc, aTj);
         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 > slc.tjs.size()-1
 
     if (itj > slc.tjs.size() - 1) return;
 
     auto const& aTj = slc.tjs[itj];
 
     mf::LogVerbatim("TC") << "Print slc.tjs[" << itj << "] 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";
 
     PrintTPHeader(someText);
     if (ipt == USHRT_MAX) {
       // print all points
       for (unsigned short ii = 0; ii < aTj.Pts.size(); ++ii)
         PrintTP(someText, slc, ii, aTj.StepDir, aTj.Pass, aTj.Pts[ii]);
     }
     else {
       // print just one
       PrintTP(someText, slc, ipt, aTj.StepDir, aTj.Pass, aTj.Pts[ipt]);
     }
   } // PrintAllTraj

void tca::PrintClusters ( )

void tca::PrintDebugMode ( )

Definition at line 5448 of file Utils.cxx.

   {
     // print the debug mode configuration to the screen
     std::cout << "*** TrajCluster debug mode configuration in";
     std::cout << " CTP=";
     if (debug.CTP == UINT_MAX) { std::cout << "NA"; }
     else {
       std::cout << debug.CTP;
     }
     std::cout << " Cryostat=" << debug.Cryostat;
     std::cout << " TPC=" << debug.TPC;
     std::cout << " Plane=" << debug.Plane;
     std::cout << " Wire=" << debug.Wire;
     std::cout << " Tick=" << debug.Tick;
     std::cout << " Hit=";
     if (debug.Hit == UINT_MAX) { std::cout << "NA"; }
     else {
       std::cout << debug.Hit;
     }
     std::cout << " WorkID=";
     if (debug.WorkID == 0) { std::cout << "NA"; }
     else {
       std::cout << debug.WorkID;
     }
     std::cout << " Slice=";
     if (debug.Slice == -1) { std::cout << "All"; }
     else {
       std::cout << debug.Slice;
     }
     std::cout << "\n";
     std::cout << "*** tcc.dbg modes:";
     if (tcc.dbgSlc) std::cout << " dbgSlc";
     if (tcc.dbgStp) std::cout << " dbgStp";
     if (tcc.dbgMrg) std::cout << " dbgMrg";
     if (tcc.dbg2V) std::cout << " dbg2V";
     if (tcc.dbg2S) std::cout << " dbg2S";
     if (tcc.dbgVxNeutral) std::cout << " dbgVxNeutral";
     if (tcc.dbgVxMerge) std::cout << " dbgVxMerge";
     if (tcc.dbgVxJunk) std::cout << " dbgVxJunk";
     if (tcc.dbg3V) std::cout << " dbg3V";
     if (tcc.dbgPFP) std::cout << " dbgPFP";
     if (tcc.dbgDeltaRayTag) std::cout << " dbgDeltaRayTag";
     if (tcc.dbgMuonTag) std::cout << " dbgMuonTag";
     if (tcc.dbgStitch) std::cout << " dbgStitch";
     if (tcc.dbgSummary) std::cout << " dbgSummary";
     if (tcc.dbgDump) std::cout << " dbgDump";
     std::cout << "\n";
     std::cout << "*** Using algs:";
     unsigned short cnt = 0;
     for (unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) {
       if (tcc.useAlg[ib] && ib != kKilled) {
         ++cnt;
         if (cnt % 10 == 0) std::cout << "\n   ";
         std::cout << " " << AlgBitNames[ib];
       }
     }
     std::cout << "\n";
     std::cout << "*** Skipping algs:";
     cnt = 0;
     for (unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) {
       if (!tcc.useAlg[ib] && ib != kKilled) {
         ++cnt;
         if (cnt % 10 == 0) std::cout << "\n   ";
         std::cout << " " << AlgBitNames[ib];
       }
     }
     std::cout << "\n";
   } // PrintDebugMode

std::string tca::PrintEndFlag	(	const PFPStruct &	pfp,
		unsigned short	end
	)

Definition at line 6461 of file Utils.cxx.

   {
     if (end > 1) return "Invalid end";
     std::string tmp;
     bool first = true;
     for (unsigned short ib = 0; ib < EndFlagNames.size(); ++ib) {
       if (pfp.EndFlag[end][ib]) {
         if (first) {
           tmp = std::to_string(end) + ":" + EndFlagNames[ib];
           first = false;
         }
         else {
           tmp += "," + EndFlagNames[ib];
         }
       }
     } // ib
     if (first) tmp = " none";
     return tmp;
   } // PrintEndFlag

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

Definition at line 6483 of file Utils.cxx.

   {
     if (end > 1) return "Invalid end";
     std::string tmp;
     bool first = true;
     for (unsigned short ib = 0; ib < EndFlagNames.size(); ++ib) {
       if (tj.EndFlag[end][ib]) {
         if (first) {
           tmp = std::to_string(end) + ":" + EndFlagNames[ib];
           first = false;
         }
         else {
           tmp += "," + EndFlagNames[ib];
         }
       }
     } // ib
     return tmp;
   } // PrintEndFlag

std::string tca::PrintHit ( const TCHit & tch )

Definition at line 6514 of file Utils.cxx.

   {
     if (tch.allHitsIndex > (*evt.allHits).size() - 1) return "NA";
     auto& hit = (*evt.allHits)[tch.allHitsIndex];
     return std::to_string(hit.WireID().Plane) + ":" + std::to_string(hit.WireID().Wire) + ":" +
            std::to_string((int)hit.PeakTime()) + "_" + std::to_string(tch.InTraj);
   } // PrintHit

std::string tca::PrintHitShort ( const TCHit & tch )

Definition at line 6504 of file Utils.cxx.

   {
     if (tch.allHitsIndex > (*evt.allHits).size() - 1) return "NA";
     auto& hit = (*evt.allHits)[tch.allHitsIndex];
     return std::to_string(hit.WireID().Plane) + ":" + std::to_string(hit.WireID().Wire) + ":" +
            std::to_string((int)hit.PeakTime());
   } // PrintHit

void tca::PrintP	(	std::string	someText,
		mf::LogVerbatim &	myprt,
		PFPStruct &	pfp,
		bool &	printHeader
	)

Definition at line 5603 of file Utils.cxx.

   {
     if (pfp.ID <= 0) return;
     if (printHeader) {
       myprt << "************ PFParticles ************\n";
       myprt << "     prodID    sVx  _____sPos____ CS _______sDir______ ____sdEdx_____    eVx  "
                "_____ePos____ CS ____edEdx_____  MVI MCSMom  Len nTP3 nSec SLk? PDG  Par \n";
       printHeader = false;
     } // printHeader
     auto sIndx = GetSliceIndex("P", pfp.UID);
     if (sIndx.first == USHRT_MAX) return;
     auto& slc = slices[sIndx.first];
     std::string str =
       std::to_string(slc.ID) + ":" + std::to_string(sIndx.first) + ":" + std::to_string(pfp.ID);
     str += "/" + std::to_string(pfp.UID);
     myprt << std::setw(12) << str;
     // start and end stuff
     for (unsigned short end = 0; end < 2; ++end) {
       str = "--";
       if (pfp.Vx3ID[end] > 0) str = "3V" + std::to_string(slc.vtx3s[pfp.Vx3ID[end] - 1].UID);
       myprt << std::setw(6) << str;
       myprt << std::fixed << std::right << std::setprecision(0);
       auto pos = PosAtEnd(pfp, end);
       myprt << std::setw(5) << pos[0];
       myprt << std::setw(5) << pos[1];
       myprt << std::setw(5) << pos[2];
       // print character for Outside or Inside the FV
       if (InsideFV(slc, pfp, end)) { myprt << "  I"; }
       else {
         myprt << "  O";
       }
       // only print the starting direction
       if (end == 0) {
         myprt << std::fixed << std::right << std::setprecision(2);
         auto dir = DirAtEnd(pfp, end);
         myprt << std::setw(6) << dir[0];
         myprt << std::setw(6) << dir[1];
         myprt << std::setw(6) << dir[2];
       } // end == 0
       for (auto& dedx : pfp.dEdx[end]) {
         if (dedx < 50) { myprt << std::setw(5) << std::setprecision(1) << dedx; }
         else {
           myprt << std::setw(5) << std::setprecision(0) << dedx;
         }
       } // dedx
       if (pfp.dEdx[end].size() < 3) {
         for (size_t i = 0; i < 3 - pfp.dEdx[end].size(); ++i) {
           myprt << std::setw(6) << ' ';
         }
       }
     } // startend
     myprt << std::setw(6) << pfp.MVI;
     // global stuff
     myprt << std::setw(7) << MCSMom(slc, pfp.TjIDs);
     float length = Length(pfp);
     if (length < 100) { myprt << std::setw(5) << std::setprecision(1) << length; }
     else {
       myprt << std::setw(5) << std::setprecision(0) << length;
     }
     myprt << std::setw(5) << pfp.TP3Ds.size();
     myprt << std::setw(5) << pfp.SectionFits.size();
     myprt << std::setw(5) << IsShowerLike(slc, pfp.TjIDs);
     myprt << std::setw(5) << pfp.PDGCode;
     myprt << std::setw(4) << pfp.ParentUID;
     if (!pfp.TjIDs.empty()) {
       if (pfp.TjUIDs.empty()) {
         // print Tjs in one TPC
         for (auto tjid : pfp.TjIDs)
           myprt << " TU" << slc.tjs[tjid - 1].UID;
       }
       else {
         // print Tjs in all TPCs (if this is called after FinishEvent)
         for (auto tjuid : pfp.TjUIDs)
           myprt << " TU" << tjuid;
       }
     } // TjIDs exist
     if (!pfp.DtrUIDs.empty()) {
       myprt << " dtrs";
       for (auto dtruid : pfp.DtrUIDs)
         myprt << " PU" << dtruid;
     } // dtr ids exist
     myprt << "\n";
   } // PrintP

void tca::PrintPFP	(	std::string	someText,
		TCSlice &	slc,
		const PFPStruct &	pfp,
		bool	printHeader
	)

Definition at line 6371 of file Utils.cxx.

   {
     mf::LogVerbatim myprt("TC");
     if (printHeader) {
       myprt << someText;
       myprt << "  PFP sVx  ________sPos_______ EF _______sDir______ ____sdEdx_____ eVx  "
                "________ePos_______ EF _______eDir______ ____edEdx____   Len nTp3 MCSMom ShLike? "
                "PDG Par Prim\n";
     }
     myprt << someText;
     std::string pid = "P" + std::to_string(pfp.ID);
     myprt << std::setw(5) << pid;
     // start and end stuff
     for (unsigned short end = 0; end < 2; ++end) {
       myprt << std::setw(4) << pfp.Vx3ID[end];
       myprt << std::fixed << std::right << std::setprecision(1);
       auto pos = PosAtEnd(pfp, end);
       myprt << std::setw(7) << pos[0];
       myprt << std::setw(7) << pos[1];
       myprt << std::setw(7) << pos[2];
       // print characters that encode the EndFlag
       std::string ef;
       if (pfp.EndFlag[end][kOutFV]) { ef = "O"; }
       else {
         ef = "I";
       }
       if (pfp.EndFlag[end][kBragg]) ef += "B";
       myprt << std::setw(6) << ef;
       myprt << std::fixed << std::right << std::setprecision(2);
       auto dir = DirAtEnd(pfp, end);
       myprt << std::setw(6) << dir[0];
       myprt << std::setw(6) << dir[1];
       myprt << std::setw(6) << dir[2];
       for (auto& dedx : pfp.dEdx[end]) {
         if (dedx < 50) { myprt << std::setw(5) << std::setprecision(1) << dedx; }
         else {
           myprt << std::setw(5) << std::setprecision(0) << dedx;
         }
       } // dedx
       if (pfp.dEdx[end].size() < 3) {
         for (size_t i = 0; i < 3 - pfp.dEdx[end].size(); ++i) {
           myprt << std::setw(6) << ' ';
         }
       }
     } // startend
     // global stuff
     float length = Length(pfp);
     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.TP3Ds.size();
     myprt << std::setw(7) << MCSMom(slc, pfp.TjIDs);
     myprt << std::setw(5) << IsShowerLike(slc, pfp.TjIDs);
     myprt << std::setw(5) << pfp.PDGCode;
     myprt << "      NA";
     myprt << std::setw(4) << pfp.ParentUID;
     myprt << std::setw(5) << PrimaryUID(slc, pfp);
     if (!pfp.TjIDs.empty()) {
       for (auto& tjID : pfp.TjIDs)
         myprt << " T" << tjID;
     }
     if (!pfp.DtrUIDs.empty()) {
       myprt << " dtrs";
       for (auto& dtrUID : pfp.DtrUIDs)
         myprt << " P" << dtrUID;
     }
   } // PrintPFP

void tca::PrintPFPs	(	std::string	someText,
		TCSlice &	slc
	)

Definition at line 6442 of file Utils.cxx.

   {
     if (slc.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 : slc.pfps) {
       PrintPFP(someText, slc, pfp, printHeader);
       printHeader = false;
     } // im
 
   } // PrintPFPs

std::string tca::PrintPos	(	const TCSlice &	slc,
		const TrajPoint &	tp
	)

Definition at line 6524 of file Utils.cxx.

   {
     return std::to_string(DecodeCTP(tp.CTP).Plane) + ":" + PrintPos(slc, tp.Pos);
   } // PrintPos

std::string tca::PrintPos	(	const TCSlice &	slc,
		const Point2_t &	pos
	)

Definition at line 6531 of file Utils.cxx.

   {
     unsigned int wire = 0;
     if (pos[0] > -0.4) wire = std::nearbyint(pos[0]);
     int time = std::nearbyint(pos[1] / tcc.unitsPerTick);
     return std::to_string(wire) + ":" + std::to_string(time);
   } // PrintPos

void tca::PrintShower	(	std::string	someText,
		TCSlice &	slc,
		const ShowerStruct &	ss,
		bool	printHeader,
		bool	printExtras
	)

Definition at line 4341 of file TCShower.cxx.

   {
     // 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 = slc.tjs[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(slc, 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)slc.showers.size()) {
       auto& ss3 = slc.showers[ss.SS3ID - 1];
       if (ss3.PFPIndex >= 0 && ss3.PFPIndex < slc.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] / tcc.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	(	detinfo::DetectorPropertiesData const &	detProp,
		std::string	fcnLabel,
		TCSlice &	slc
	)

Definition at line 4211 of file TCShower.cxx.

   {
     if (slc.showers.empty()) return;
     mf::LogVerbatim myprt("TC");
     myprt << fcnLabel << " 3D showers \n";
     for (auto& ss3 : slc.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(slc.nPlanes);
       for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
         CTP_t inCTP = EncodeCTP(ss3.TPCID.Cryostat, ss3.TPCID.TPC, plane);
         auto tp = MakeBareTP(detProp, slc, ss3.ChgPos, ss3.Dir, inCTP);
         myprt << " " << PrintPos(slc, tp.Pos);
         projInPlane[plane] = tp.Delta;
       } // plane
       myprt << " projInPlane";
       for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
         myprt << " " << std::fixed << std::setprecision(2) << projInPlane[plane];
       } // plane
       for (auto cid : ss3.CotIDs) {
         auto& ss = slc.cots[cid - 1];
         myprt << "\n  2S" << ss.ID;
         auto& stj = slc.tjs[ss.ShowerTjID - 1];
         myprt << " ST" << stj.ID;
         myprt << " " << PrintPos(slc, stj.Pts[stj.EndPt[0]].Pos) << " - "
               << PrintPos(slc, stj.Pts[stj.EndPt[1]].Pos);
       } // ci
       if (ss3.NeedsUpdate) myprt << " *** Needs update";
       myprt << "\n";
     } // sss3
   }   // PrintShowers

void tca::PrintT	(	std::string	someText,
		mf::LogVerbatim &	myprt,
		Trajectory &	tj,
		bool &	printHeader
	)

Definition at line 5858 of file Utils.cxx.

   {
     // print a 2D vertex on one line
     if (tj.ID <= 0) return;
     if (debug.CTP != UINT_MAX && tj.CTP != debug.CTP) return;
     if (printHeader) {
       myprt << "************ Trajectories ************\n";
       myprt << "Tj AngleCode-EndFlag decoder (EF): <AngleCode> + <reason for stopping>";
       myprt << " (B=Bragg Peak, V=Vertex, A=AngleKink, C=ChargeKink, T=Trajectory)\n";
       myprt << "     prodID    CTP Pass  Pts     W:T      Ang EF AveQ     W:T      Ang EF AveQ "
                "Chg(k) chgRMS  Mom __Vtx__  PDG eLike  Par Pri NuPar   WorkID \n";
       printHeader = false;
     }
     auto sIndx = GetSliceIndex("T", tj.UID);
     if (sIndx.first == USHRT_MAX) return;
     auto& slc = slices[sIndx.first];
     std::string str = "T" + std::to_string(tj.ID) + "/TU" + std::to_string(tj.UID);
     myprt << std::fixed << std::setw(12) << str;
     myprt << std::setw(6) << tj.CTP;
     myprt << std::setw(5) << tj.Pass;
     myprt << std::setw(5) << tj.EndPt[1] - tj.EndPt[0] + 1;
     unsigned short endPt0 = tj.EndPt[0];
     auto& tp0 = tj.Pts[endPt0];
     int itick = tp0.Pos[1] / tcc.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 (tj.EndFlag[0][kBragg]) { myprt << "B"; }
     else if (tj.EndFlag[0][kAtVtx]) {
       myprt << "V";
     }
     else if (tj.EndFlag[0][kAtKink]) {
       myprt << "K";
     }
     else if (tj.EndFlag[0][kAtTj]) {
       myprt << "T";
     }
     else {
       myprt << " ";
     }
     myprt << std::setw(5) << (int)tp0.AveChg;
     unsigned short endPt1 = tj.EndPt[1];
     auto& tp1 = tj.Pts[endPt1];
     itick = tp1.Pos[1] / tcc.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 (tj.EndFlag[1][kBragg]) { myprt << "B"; }
     else if (tj.EndFlag[1][kAtVtx]) {
       myprt << "V";
     }
     else if (tj.EndFlag[1][kAtKink]) {
       myprt << "K";
     }
     else if (tj.EndFlag[1][kAtTj]) {
       myprt << "T";
     }
     else {
       myprt << " ";
     }
     myprt << std::setw(5) << (int)tp1.AveChg;
     myprt << std::setw(7) << std::setprecision(1) << tj.TotChg / 1000;
     myprt << std::setw(7) << std::setprecision(2) << tj.ChgRMS;
     myprt << std::setw(5) << tj.MCSMom;
     int vxid = 0;
     if (tj.VtxID[0] > 0) vxid = slc.vtxs[tj.VtxID[0] - 1].UID;
     myprt << std::setw(4) << vxid;
     vxid = 0;
     if (tj.VtxID[1] > 0) vxid = slc.vtxs[tj.VtxID[1] - 1].UID;
     myprt << std::setw(4) << vxid;
     myprt << std::setw(5) << tj.PDGCode;
     myprt << std::setw(7) << std::setprecision(2) << ElectronLikelihood(slc, tj);
     myprt << std::setw(5) << tj.ParentID;
     myprt << std::setw(5) << PrimaryID(slc, tj);
     myprt << std::setw(6) << NeutrinoPrimaryTjID(slc, tj);
     myprt << std::setw(7) << tj.WorkID;
     for (unsigned short ib = 0; ib < AlgBitNames.size(); ++ib)
       if (tj.AlgMod[ib]) myprt << " " << AlgBitNames[ib];
     for (unsigned short ib = 0; ib < StrategyBitNames.size(); ++ib)
       if (tj.Strategy[ib]) myprt << " " << StrategyBitNames[ib];
     myprt << "\n";
   } // PrintT

void tca::PrintTP	(	std::string	someText,
		const TCSlice &	slc,
		unsigned short	ipt,
		short	dir,
		unsigned short	pass,
		const TrajPoint &	tp
	)

Definition at line 6294 of file Utils.cxx.

   {
     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(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;
     myprt << std::setw(7) << std::setprecision(3) << tp.KinkSig;
     // 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];
         auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
         myprt << " " << hit.WireID().Wire << ":" << (int)hit.PeakTime();
         if (tp.UseHit[ii]) {
           // Distinguish used hits from nearby hits
           myprt << "_";
         }
         else {
           myprt << "x";
         }
         myprt << "T" << slc.slHits[iht].InTraj;
       } // iht
       if (tp.InPFP > 0) myprt << " inP" << tp.InPFP;
     }
     // print Environment
     if (tp.Environment.any()) myprt << " Env: " << TPEnvString(tp);
   } // PrintTP

void tca::PrintTP3Ds	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		std::string	someText,
		const TCSlice &	slc,
		const PFPStruct &	pfp,
		short	printPts
	)

Definition at line 3396 of file PFPUtils.cxx.

   {
     if (pfp.TP3Ds.empty()) return;
     mf::LogVerbatim myprt("TC");
     myprt << someText << " pfp P" << pfp.ID << " MVI " << pfp.MVI;
     for (auto tid : pfp.TjIDs)
       myprt << " T" << tid;
     myprt << " Flags: CanSection? " << pfp.Flags[kCanSection];
     myprt << " NeedsUpdate? " << pfp.Flags[kNeedsUpdate];
     myprt << " Algs:";
     for (unsigned short ib = 0; ib < pAlgModSize; ++ib) {
       if (pfp.AlgMod[ib]) myprt << " " << AlgBitNames[ib];
     } // ib
     myprt << "\n";
     if (!pfp.SectionFits.empty()) {
       myprt << someText
             << "  SFI ________Pos________   ________Dir_______ _____EndPos________ ChiDOF  NPts "
                "NeedsUpdate?\n";
       for (std::size_t sfi = 0; sfi < pfp.SectionFits.size(); ++sfi) {
         myprt << someText << std::setw(4) << sfi;
         auto& sf = pfp.SectionFits[sfi];
         myprt << std::fixed << std::setprecision(1);
         unsigned short startPt = 0, endPt = 0;
         if (SectionStartEnd(pfp, sfi, startPt, endPt)) {
           auto& start = pfp.TP3Ds[startPt].Pos;
           myprt << std::setw(7) << start[0] << std::setw(7) << start[1] << std::setw(7) << start[2];
         }
         else {
           myprt << " Invalid";
         }
         myprt << std::fixed << std::setprecision(2);
         myprt << std::setw(7) << sf.Dir[0] << std::setw(7) << sf.Dir[1] << std::setw(7)
               << sf.Dir[2];
         myprt << std::fixed << std::setprecision(1);
         if (endPt < pfp.TP3Ds.size()) {
           auto& end = pfp.TP3Ds[endPt].Pos;
           myprt << std::setw(7) << end[0] << std::setw(7) << end[1] << std::setw(7) << end[2];
         }
         else {
           myprt << " Invalid";
         }
         myprt << std::setprecision(1) << std::setw(6) << sf.ChiDOF;
         myprt << std::setw(6) << sf.NPts;
         myprt << std::setw(6) << sf.NeedsUpdate;
         myprt << "\n";
       } // sec
     }   // SectionFits
     if (printPts < 0) {
       // print the head if we print all points
       myprt<<someText<<" Note: GBH = TP3D Flags. G = Good, B = Bad, H = High dE/dx \n";
       myprt<<someText<<"  ipt SFI ________Pos________  Delta Pull  GBH   Path  along dE/dx S?    T_ipt_P:W:T\n";
     }
     unsigned short fromPt = 0;
     unsigned short toPt = pfp.TP3Ds.size() - 1;
     if (printPts >= 0) fromPt = toPt;
     // temp kink angle for each point
     std::vector<float> dang(pfp.TP3Ds.size(), -1);
     for (unsigned short ipt = fromPt; ipt <= toPt; ++ipt) {
       auto tp3d = pfp.TP3Ds[ipt];
       myprt << someText << std::setw(4) << ipt;
       myprt << std::setw(4) << tp3d.SFIndex;
       myprt << std::fixed << std::setprecision(1);
       myprt << std::setw(7) << tp3d.Pos[0] << std::setw(7) << tp3d.Pos[1] << std::setw(7)
             << tp3d.Pos[2];
       myprt << std::setprecision(1) << std::setw(6) << (tp3d.Pos[0] - tp3d.TPX);
       float pull = PointPull(pfp, tp3d);
       myprt << std::setprecision(1) << std::setw(6) << pull;
       myprt << std::setw(3) << tp3d.Flags[kTP3DGood] << tp3d.Flags[kTP3DBad];
       myprt << std::setw(7) << std::setprecision(1) << PosSep(tp3d.Pos, pfp.TP3Ds[0].Pos);
       myprt << std::setw(7) << std::setprecision(1) << tp3d.along;
       myprt << std::setw(6) << std::setprecision(2) << dEdx(clockData, detProp, slc, tp3d);
       // print SignalAtTP in each plane
       myprt << " ";
       for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
         CTP_t inCTP = EncodeCTP(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
         auto tp = MakeBareTP(detProp, slc, tp3d.Pos, inCTP);
         myprt << " " << SignalAtTp(tp);
       } // plane
       if (tp3d.TjID > 0) {
         auto& tp = slc.tjs[tp3d.TjID - 1].Pts[tp3d.TPIndex];
         myprt << " T" << tp3d.TjID << "_" << tp3d.TPIndex << "_" << PrintPos(slc, tp) << " "
               << TPEnvString(tp);
       }
       else {
         myprt << " UNDEFINED";
       }
       myprt << "\n";
     } // ipt
   }   // PrintTP3Ds

void tca::PrintTPHeader ( std::string someText )

Definition at line 6285 of file Utils.cxx.

   {
     mf::LogVerbatim("TC") << someText
                           << " TRP     CTP  Ind  Stp Delta  RMS    Ang C   Err  Dir0  Dir1      Q  "
                              "  AveQ  Pull FitChi  NTPF KinkSig  Hits ";
   } // PrintTPHeader

void tca::PrintTrajectory	(	std::string	someText,
		const TCSlice &	slc,
		const Trajectory &	tj,
		unsigned short	tPoint
	)

Definition at line 6193 of file Utils.cxx.

   {
     // prints one or all trajectory points on tj
 
     if (tPoint == USHRT_MAX) {
       if (tj.ID < 0) {
         mf::LogVerbatim myprt("TC");
         myprt << someText << " ";
         myprt << "Work:   UID " << tj.UID << "    CTP " << tj.CTP << " StepDir " << tj.StepDir
               << " PDG " << tj.PDGCode << " slc.vtxs " << tj.VtxID[0] << " " << tj.VtxID[1]
               << " nPts " << tj.Pts.size() << " EndPts " << tj.EndPt[0] << " " << tj.EndPt[1];
         myprt << " MCSMom " << tj.MCSMom;
         myprt << " EndFlags " << PrintEndFlag(tj, 0) << " " << PrintEndFlag(tj, 1);
         myprt << " AlgMods:";
         for (unsigned short ib = 0; ib < AlgBitNames.size(); ++ib)
           if (tj.AlgMod[ib]) myprt << " " << AlgBitNames[ib];
       }
       else {
         mf::LogVerbatim myprt("TC");
         myprt << someText << " ";
         myprt << "slcID " << slc.ID << " T" << tj.ID << " uT" << tj.UID << " WorkID " << tj.WorkID
               << " StepDir " << tj.StepDir << " PDG " << tj.PDGCode << " VtxID " << tj.VtxID[0]
               << " " << tj.VtxID[1] << " nPts " << tj.Pts.size() << " EndPts " << tj.EndPt[0] << " "
               << tj.EndPt[1];
         myprt << " MCSMom " << tj.MCSMom;
         myprt << " EndFlags " << PrintEndFlag(tj, 0) << " " << PrintEndFlag(tj, 1);
         myprt << " AlgMods:";
         for (unsigned short ib = 0; ib < AlgBitNames.size(); ++ib)
           if (tj.AlgMod[ib]) myprt << " " << AlgBitNames[ib];
       }
       PrintTPHeader(someText);
       for (unsigned short ipt = 0; ipt < tj.Pts.size(); ++ipt)
         PrintTP(someText, slc, 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 < slc.cots.size(); ++ic) {
           if (slc.cots[ic].TjIDs.empty()) continue;
           // only print out the info for the correct Tj
           if (slc.cots[ic].ShowerTjID != tj.ID) continue;
           const ShowerStruct& ss = slc.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] / tcc.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;
           } // tjID
 
           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;
       }
       PrintTP(someText, slc, tPoint, tj.StepDir, tj.Pass, tj.Pts[tPoint]);
     }
   } // PrintTrajectory

std::vector< unsigned int > tca::PutHitsInVector	(	const TCSlice &	slc,
		PFPStruct const &	pfp,
		HitStatus_t	hitRequest
	)

Definition at line 2729 of file Utils.cxx.

   {
     // Put hits with the assn P -> TP3D -> TP -> Hit into a vector
     std::vector<unsigned int> hitVec;
     if (pfp.TP3Ds.empty()) return hitVec;
 
     for (auto& tp3d : pfp.TP3Ds) {
       if (tp3d.Flags[kTP3DBad]) continue;
       if (tp3d.TjID <= 0) continue;
       auto& tp = slc.tjs[tp3d.TjID - 1].Pts[tp3d.TPIndex];
       for (unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         unsigned int iht = tp.Hits[ii];
         bool useit = (hitRequest == kAllHits);
         if (tp.UseHit[ii] && hitRequest == kUsedHits) useit = true;
         if (!tp.UseHit[ii] && hitRequest == kUnusedHits) useit = true;
         if (useit) hitVec.push_back(iht);
       }
     } // tp3d
     return hitVec;
   } // PutHitsInVector

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

Definition at line 2752 of file Utils.cxx.

   {
     // Put hits (which are indexed into slHits) 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

void tca::Reconcile2Vs ( TCSlice & slc )

Definition at line 1081 of file TCVertex.cxx.

   {
     // This function is called before Find3DVertices to identify (and possibly reconcile)
     // Tj and 2V inconsistencies using 2D and 3D(?) information
     if (!tcc.useAlg[kReconcile2Vs]) return;
     if (slc.vtxs.empty()) return;
 
     bool prt = (tcc.dbg2V && tcc.dbgSlc);
 
     // clusters of 2Vs
     std::vector<std::vector<int>> vx2Cls;
 
     // iterate over planes
     for (unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
       // look for 2D vertices that are close to each other
       vx2Cls.clear();
       for (unsigned short ii = 0; ii < slc.vtxs.size() - 1; ++ii) {
         auto& i2v = slc.vtxs[ii];
         if (i2v.ID <= 0) continue;
         if (DecodeCTP(i2v.CTP).Plane != plane) continue;
         for (unsigned short jj = ii + 1; jj < slc.vtxs.size(); ++jj) {
           auto& j2v = slc.vtxs[jj];
           if (j2v.ID <= 0) continue;
           if (DecodeCTP(j2v.CTP).Plane != plane) continue;
           // make rough separation cuts
           float dp0 = std::abs(i2v.Pos[0] - j2v.Pos[0]);
           if (dp0 > 10) continue;
           float dp1 = std::abs(i2v.Pos[1] - j2v.Pos[1]);
           if (dp1 > 10) continue;
           // do a more careful look
           float err = i2v.PosErr[0];
           if (j2v.PosErr[0] > err) err = j2v.PosErr[0];
           float dp0Sig = dp0 / err;
           if (dp0Sig > 4) continue;
           err = i2v.PosErr[1];
           if (j2v.PosErr[1] > err) err = j2v.PosErr[1];
           float dp1Sig = dp1 / err;
           if (dp1Sig > 4) continue;
           // Look for one of the 2V IDs in a cluster
           bool gotit = false;
           for (auto& vx2cls : vx2Cls) {
             bool goti = (std::find(vx2cls.begin(), vx2cls.end(), i2v.ID) != vx2cls.end());
             bool gotj = (std::find(vx2cls.begin(), vx2cls.end(), j2v.ID) != vx2cls.end());
             if (goti && gotj) {
               gotit = true;
               break;
             }
             else if (goti) {
               vx2cls.push_back(j2v.ID);
               gotit = true;
               break;
             }
             else if (gotj) {
               gotit = true;
               vx2cls.push_back(i2v.ID);
               break;
             }
           } // vx2cls
           if (!gotit) {
             // start a new cluster with this pair
             std::vector<int> cls(2);
             cls[0] = i2v.ID;
             cls[1] = j2v.ID;
             vx2Cls.push_back(cls);
           } // !gotit
         }   // jj
       }     // ii
       if (vx2Cls.empty()) continue;
       if (prt) {
         mf::LogVerbatim myprt("TC");
         myprt << "2V clusters in plane " << plane;
         for (auto& vx2cls : vx2Cls) {
           myprt << "\n";
           for (auto vx2id : vx2cls)
             myprt << " 2V" << vx2id;
         } // vx2cls
       }   // prt
       for (auto& vx2cls : vx2Cls) {
         Reconcile2VTs(slc, vx2cls, prt);
       } // vx2cls
     }   // plane
 
     // See if any of the vertices have been altered. If so the environment near them,
     // specifically tagging overlapping trajectories, should be re-done
     bool VxEnvironmentNeedsUpdate = false;
     for (auto& vx : slc.vtxs) {
       if (vx.ID <= 0) continue;
       if (!vx.Stat[kVxEnvOK]) VxEnvironmentNeedsUpdate = true;
     } // vx
 
     if (VxEnvironmentNeedsUpdate) UpdateVxEnvironment(slc);
 
   } // Reconcile2Vs

bool tca::Reconcile2VTs	(	TCSlice &	slc,
		std::vector< int > &	vx2cls,
		bool	prt
	)

Definition at line 1177 of file TCVertex.cxx.

   {
     // The 2D vertices IDs in vx2cls were clustered by the calling function. This function
     // checks the T -> 2V assns and possibly changes it. It returns true if an assn is changed
     // or if a vertex in vx2cls is made obsolete, necessitating a change to the list of 2V
     // clusters
     if (vx2cls.size() < 2) return false;
 
     // Form a list of all Tjs associated with this 2V cluster
     std::vector<int> t2vList;
 
     CTP_t inCTP;
     for (auto vx2id : vx2cls) {
       auto& vx2 = slc.vtxs[vx2id - 1];
       inCTP = vx2.CTP;
       // vertex clobbered? If so, vertex clustering needs to be re-done
       if (vx2.ID <= 0) return true;
       auto tlist = GetAssns(slc, "2V", vx2.ID, "T");
       for (auto tid : tlist)
         if (std::find(t2vList.begin(), t2vList.end(), tid) == t2vList.end()) t2vList.push_back(tid);
     } // vx2id
     if (t2vList.size() < 3) return false;
 
     // Sum the T -> 2V pulls
     float sumPulls = 0;
     float cnt = 0;
     for (auto tid : t2vList) {
       auto& tj = slc.tjs[tid - 1];
       for (unsigned short end = 0; end < 2; ++end) {
         if (tj.VtxID[end] <= 0) continue;
         if (std::find(vx2cls.begin(), vx2cls.end(), tj.VtxID[end]) == vx2cls.end()) continue;
         auto& vx = slc.vtxs[tj.VtxID[end] - 1];
         unsigned short nearEnd = 1 - FarEnd(slc, tj, vx.Pos);
         unsigned short fitPt = NearbyCleanPt(slc, tj, nearEnd);
         if (fitPt == USHRT_MAX) return false;
         auto& tp = tj.Pts[fitPt];
         sumPulls += TrajPointVertexPull(slc, tp, vx);
         ++cnt;
       } // end
     }   // tid
 
     if (prt) {
       mf::LogVerbatim myprt("TC");
       myprt << "R2VTs: cluster:";
       for (auto vid : vx2cls)
         myprt << " 2V" << vid;
       myprt << " ->";
       for (auto tid : t2vList)
         myprt << " T" << tid;
       myprt << " sumPulls " << std::setprecision(2) << sumPulls << " cnt " << cnt;
     } // prt
 
     // try to fit all Tjs to one vertex. Find the average position of all of the
     // vertices. This will be used to find the end of the Tjs that are closest to the
     // presumed single vertex
     VtxStore oneVx;
     oneVx.CTP = inCTP;
     for (auto vid : vx2cls) {
       auto& vx = slc.vtxs[vid - 1];
       oneVx.Pos[0] += vx.Pos[0];
       oneVx.Pos[1] += vx.Pos[2];
     } // vid
     oneVx.Pos[0] /= vx2cls.size();
     oneVx.Pos[1] /= vx2cls.size();
     std::vector<TrajPoint> oneVxTPs(t2vList.size());
     for (unsigned short itj = 0; itj < t2vList.size(); ++itj) {
       auto& tj = slc.tjs[t2vList[itj] - 1];
       unsigned short nearEnd = 1 - FarEnd(slc, tj, oneVx.Pos);
       unsigned short fitPt = NearbyCleanPt(slc, tj, nearEnd);
       if (fitPt == USHRT_MAX) return false;
       oneVxTPs[itj] = tj.Pts[fitPt];
       // inflate the TP angle angle error if a TP without an overlap wasn't found
       if (oneVxTPs[itj].Environment[kEnvOverlap]) oneVxTPs[itj].AngErr *= 4;
       oneVxTPs[itj].Step = tj.ID;
     } // ii
     if (!FitVertex(slc, oneVx, oneVxTPs, prt)) return false;
 
     if (oneVx.ChiDOF < 3) {
       // Update the position of the first 2V in the list
       auto& vx = slc.vtxs[vx2cls[0] - 1];
       vx.Pos = oneVx.Pos;
       vx.PosErr = oneVx.PosErr;
       vx.NTraj = t2vList.size();
       vx.ChiDOF = oneVx.ChiDOF;
       vx.Topo = 14;
       // Set a flag that the environment near this vertex (and all other vertices in this slice)
       // should be revisited
       vx.Stat[kVxEnvOK] = false;
       for (unsigned short ivx = 1; ivx < vx2cls.size(); ++ivx) {
         auto& vx = slc.vtxs[vx2cls[ivx] - 1];
         MakeVertexObsolete("R2VTPs", slc, vx, true);
       } // ivx
       // now attach the trajectories
       for (auto tid : t2vList) {
         auto& tj = slc.tjs[tid - 1];
         unsigned short nearEnd = 1 - FarEnd(slc, tj, vx.Pos);
         tj.VtxID[nearEnd] = vx.ID;
       } // tid
       return true;
     } // oneVx.ChiDOF < 3
     return false;
   } // Reconcile2VTs

bool tca::Reconcile3D	(	std::string	inFcnLabel,
		TCSlice &	slc,
		bool	parentSearchDone,
		bool	prt
	)

Definition at line 427 of file TCShower.cxx.

   {
     // Reconcile pfp and shower assns
 
     std::string fcnLabel = inFcnLabel + ".R3D2";
 
     if (prt) Print2DShowers("R3D2i", slc, USHRT_MAX, false);
 
     // consider them pair-wise
     if (slc.showers.size() > 1) {
       for (unsigned short ii = 0; ii < slc.showers.size() - 1; ++ii) {
         auto iss3 = slc.showers[ii];
         if (iss3.ID == 0) continue;
         auto iPInSS3 = GetAssns(slc, "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 < slc.showers.size(); ++jj) {
           auto jss3 = slc.showers[jj];
           if (jss3.ID == 0) continue;
           auto jPInSS3 = GetAssns(slc, "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 = slc.pfps[pid - 1];
             float iProb = InShowerProb(slc, iss3, pfp);
             float jProb = InShowerProb(slc, 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, slc, pfp, jss3, true, prt);
               // and add them to iss3
               AddPFP(fcnLabel, slc, pfp.ID, iss3, true, prt);
             }
             else {
               RemovePFP(fcnLabel, slc, pfp, iss3, true, prt);
               AddPFP(fcnLabel, slc, 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 : slc.showers) {
         if (ss3.ID == 0) continue;
         auto PIn3S = GetAssns(slc, "3S", ss3.ID, "P");
         for (auto pid : PIn3S) {
           if (pid == ss3.ParentID) continue;
           auto& pfp = slc.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.ParentUID > 0) myprt << " ->Parent P" << pfp.ParentUID;
             }
             // remove P -> P parent-daughter assn
             pfp.Vx3ID[end] = 0;
             if (pfp.ParentUID > 0) {
               auto slcIndx = GetSliceIndex("P", pfp.ParentUID);
               auto& parentPFP = slices[slcIndx.first].pfps[slcIndx.second];
               std::vector<int> newDtrUIDs;
               for (auto did : parentPFP.DtrUIDs)
                 if (did != pfp.UID) newDtrUIDs.push_back(did);
               parentPFP.DtrUIDs = newDtrUIDs;
             } // pfp Parent exists
           }   // end
         }     // pid
       }       // ss3
     }         // parentSearchDone
 
     // now look for 2D showers that not matched in 3D and have tjs
     // that are 3D-matched
     for (auto& ss : slc.cots) {
       if (ss.ID == 0) continue;
       if (ss.SS3ID > 0) continue;
       std::vector<int> matchedTjs;
       for (auto tid : ss.TjIDs)
         if (slc.tjs[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(slc, "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(slc, "P", TInP[0], "3S");
         for (auto sid : PIn3S) {
           // require that the energy be lower
           auto& ss3 = slc.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(slc, "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, slc, ss, prt);
       }
       else if (mergeWith3S > 0 && isCompatible) {
         auto& ss3 = slc.showers[mergeWith3S - 1];
         for (auto cid : ss3.CotIDs) {
           auto& oss = slc.cots[cid - 1];
           if (oss.CTP != ss.CTP) continue;
           if (!UpdateShower(fcnLabel, slc, ss3, prt)) return false;
           break;
         } // cid
       }   // mergeWith3S > 0
     }     // ss
 
     if (prt) Print2DShowers("R3D2o", slc, USHRT_MAX, false);
 
     ChkAssns(fcnLabel, slc);
 
     return true;
   } // Reconcile3D

bool tca::Reconcile3D	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 575 of file TCShower.cxx.

   {
     // 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", slc, 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] = slc.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 = slc.cots[ss3.CotIDs[ci] - 1];
       for (auto tid : ss.TjIDs) {
         auto tToP = GetAssns(slc, "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 = slc.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(slc, "P", pfp.ID, "2S");
           auto sDiff = SetDifference(PIn2S, ss3.CotIDs);
           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, slc, pfp.ID, ss3, true, prt)) {
             // Update the local copies
             oldSS3 = ss3;
             if (ss3.CotIDs.size() != oldSS.size()) return false;
             for (unsigned short ii = 0; ii < ss3.CotIDs.size(); ++ii)
               oldSS[ii] = slc.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];
               slc.cots[ss.ID - 1] = ss;
             } // ii
           }   // AddPFP failed
         }     // pfp.TjIDs.size() > 2
       }
       else {
         // only one occurrence. check proximity to ss3
         auto& pfp = slc.pfps[pc[0] - 1];
         unsigned short nearEnd = 1 - FarEnd(slc, pfp, ss3.ChgPos);
         float prob = InShowerProb(slc, ss3, pfp);
         auto pos = PosAtEnd(pfp, nearEnd);
         float sep = PosSep(pos, 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, slc, pfp.ID, ss3, true, prt)) {
           if (prt) mf::LogVerbatim("TC") << " AddPFP success";
         }
         else if (!RemovePFP(fcnLabel, slc, pfp, ss3, true, prt)) {
           if (prt) mf::LogVerbatim("TC") << " RemovePFP failed";
         }
       } // only one occurrence.
     }   // pc
 
     if (!UpdateShower(fcnLabel, slc, ss3, prt)) return false;
     ChkAssns(fcnLabel, slc);
     if (prt) Print2DShowers("R3Do", slc, USHRT_MAX, false);
 
     return true;
 
   } // Reconcile3D

bool tca::ReconcileTPs	(	TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 426 of file PFPUtils.cxx.

   {
     // Reconcile TP -> P assns before the pfp is stored. The TP3D -> TP is defined but
     // the TP -> P assn may not have been done. This function overwrites the TjIDs
     // vector to be the list of Tjs that contribute > 80% of their TPs to this pfp.
     // This function returns true if the assns are consistent.
 
     if (!tcc.useAlg[kRTPs3D]) return true;
     if(pfp.Flags[kSmallAngle]) return true;
     if (pfp.TjIDs.empty()) return false;
     if (pfp.TP3Ds.empty()) return false;
     if (pfp.ID <= 0) return false;
 
     //                  Tj ID, TP count
     std::vector<std::pair<int, float>> tjTPCnt;
     for (auto& tp3d : pfp.TP3Ds) {
       if (tp3d.Flags[kTP3DBad]) continue;
       if (tp3d.TjID <= 0) return false;
       // compare the TP3D -> TP -> P assn with the P -> TP assn
       auto& tp = slc.tjs[tp3d.TjID - 1].Pts[tp3d.TPIndex];
       if (tp.InPFP > 0 && tp.InPFP != pfp.ID) return false;
       // find the (Tj ID, TP count) pair in the list
       unsigned short indx = 0;
       for (indx = 0; indx < tjTPCnt.size(); ++indx)
         if (tjTPCnt[indx].first == tp3d.TjID) break;
       if (indx == tjTPCnt.size()) tjTPCnt.push_back(std::make_pair(tp3d.TjID, 0));
       ++tjTPCnt[indx].second;
       // make the TP -> P assn
       tp.InPFP = pfp.ID;
     } // tp3d
 
     std::vector<int> nTjIDs;
     for (auto& tjtpcnt : tjTPCnt) {
       auto& tj = slc.tjs[tjtpcnt.first - 1];
       float npwc = NumPtsWithCharge(slc, tj, false);
       if (tjtpcnt.second > 0.8 * npwc) nTjIDs.push_back(tjtpcnt.first);
     } // tjtpcnt
     if (prt) { mf::LogVerbatim("TC") << "RTPs3D: P" << pfp.ID << " nTjIDs " << nTjIDs.size(); }
     // TODO: is this really a failure?
     if (nTjIDs.size() < 2) { return false; }
     pfp.TjIDs = nTjIDs;
 
     return true;
   } // ReconcileTPs

void tca::ReconcileTPs ( TCSlice & slc )

Definition at line 473 of file PFPUtils.cxx.

   {
     // Reconciles TP ownership conflicts between PFParticles
     // Make a one-to-one TP -> P assn and look for one-to-many assns.
     // Note: Comparing the pulls for a TP to two different PFParticles generally results
     // in selecting the first PFParticle that was made which is not too surprising considering
     // the order in which they were created. This comparison has been commented out in favor
     // of simply keeping the old assn and removing the new one by setting IsBad true.
 
     if (!tcc.useAlg[kRTPs3D]) return;
 
     // make a list of T -> P assns
     std::vector<int> TinP;
     for (auto& pfp : slc.pfps) {
       if (pfp.ID <= 0) continue;
       if(pfp.Flags[kSmallAngle]) continue;
       for (std::size_t ipt = 0; ipt < pfp.TP3Ds.size(); ++ipt) {
         auto& tp3d = pfp.TP3Ds[ipt];
         if (tp3d.TjID <= 0) continue;
         if (std::find(TinP.begin(), TinP.end(), tp3d.TjID) == TinP.end()) TinP.push_back(tp3d.TjID);
         auto& tp = slc.tjs[tp3d.TjID - 1].Pts[tp3d.TPIndex];
         if (tp.InPFP > 0) {
           // an assn exists. Set the overlap bit and check consistency
           tp.Environment[kEnvOverlap] = true;
           // keep the previous assn (since it was created earlier and is more credible) and remove the new one
           tp3d.Flags[kTP3DBad] = true;
           tp3d.Flags[kTP3DGood] = false;
           tp.InPFP = 0;
         }
         else {
           // no assn exists
           tp.InPFP = pfp.ID;
         } // tp.InPFP > 0
       }   // ipt
     }     // pfp
   }       // ReconcileTPs

void tca::ReconcileVertices	(	TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 1649 of file PFPUtils.cxx.

   {
     // Checks for mis-placed 2D and 3D vertices and either attaches them
     // to a vertex or deletes(?) the vertex while attempting to preserve or
     // correct the P -> T -> 2V -> 3V assn. After this is done, the function
     // TCVertex/AttachToAnyVertex is called.
     // This function returns true if something was done to the pfp that requires
     // a re-definition of the pfp, e.g. adding or removing TP3Ds. Note that this
     // never occurs as the function is currently written
 
     if (tcc.vtx3DCuts.size() < 3) return;
     if (pfp.TP3Ds.empty()) return;
     if (pfp.Flags[kJunk3D]) return;
     if(pfp.Flags[kSmallAngle]) return;
 
     // first make a list of all Tjs
     std::vector<int> tjList;
     for (auto& tp3d : pfp.TP3Ds) {
       if (!tp3d.Flags[kTP3DGood]) continue;
       // ignore single hits
       if (tp3d.TjID <= 0) continue;
       if (std::find(tjList.begin(), tjList.end(), tp3d.TjID) == tjList.end())
         tjList.push_back(tp3d.TjID);
     } // tp3d
     // look for 3D vertices associated with these Tjs and list of
     // orphan 2D vertices - those that are not matched to 3D vertices
     std::vector<int> vx2List, vx3List;
     for (auto tid : tjList) {
       auto& tj = slc.tjs[tid - 1];
       for (unsigned short end = 0; end < 2; ++end) {
         if (tj.VtxID[end] <= 0) continue;
         auto& vx2 = slc.vtxs[tj.VtxID[end] - 1];
         if (vx2.Vx3ID > 0) {
           if (std::find(vx3List.begin(), vx3List.end(), vx2.Vx3ID) == vx3List.end())
             vx3List.push_back(vx2.Vx3ID);
           // 3D vertex exists
         }
         else {
           // no 3D vertex
           if (std::find(vx2List.begin(), vx2List.end(), tj.VtxID[end]) == vx2List.end())
             vx2List.push_back(tj.VtxID[end]);
         } // no 3D vertex
       }   // end
     }     // tid
     // no vertex reconciliation is necessary
     if (vx2List.empty() && vx3List.empty()) return;
     if (prt) {
       mf::LogVerbatim myprt("TC");
       myprt << "RV: P" << pfp.ID << " ->";
       for (auto tid : tjList)
         myprt << " T" << tid;
       myprt << " ->";
       for (auto vid : vx3List)
         myprt << " 3V" << vid;
       if (!vx2List.empty()) {
         myprt << " orphan";
         for (auto vid : vx2List)
           myprt << " 2V" << vid;
       }
     } // prt
     // Just kill the orphan 2D vertices regardless of their score.
     // This is an indicator that the vertex was created between two tjs
     // that maybe should have been reconstructed as one or alternatively
     // as two Tjs. This decision presumes the existence of a 3D kink
     // algorithm that doesn't yet exist...
     for (auto vid : vx2List) {
       auto& vx2 = slc.vtxs[vid - 1];
       MakeVertexObsolete("RV", slc, vx2, true);
     } // vx2List
     // ignore the T -> 2V -> 3V assns (if any exist) and try to directly
     // attach to 3D vertices at both ends
     AttachToAnyVertex(slc, pfp, tcc.vtx3DCuts[2], prt);
     // check for differences and while we are here, see if the pfp was attached
     // to a neutrino vertex and the direction is wrong
     int neutrinoVx = 0;
     if (!slc.pfps.empty()) {
       auto& npfp = slc.pfps[0];
       bool neutrinoPFP = (npfp.PDGCode == 12 || npfp.PDGCode == 14);
       if (neutrinoPFP) neutrinoVx = npfp.Vx3ID[0];
     } // pfps exist
     unsigned short neutrinoVxEnd = 2;
     for (unsigned short end = 0; end < 2; ++end) {
       // see if a vertex got attached
       if (pfp.Vx3ID[end] <= 0) continue;
       if (pfp.Vx3ID[end] == neutrinoVx) neutrinoVxEnd = end;
       // see if this is a vertex in the list using the T -> 2V -> 3V assns
       if (std::find(vx3List.begin(), vx3List.end(), pfp.Vx3ID[end]) != vx3List.end()) continue;
     } // end
     if (neutrinoVxEnd < 2 && neutrinoVxEnd != 0) Reverse(slc, pfp);
 
     return;
   } // ReconcileVertices

void tca::Recover	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 2088 of file PFPUtils.cxx.

   {
     // try to recover from a poor initial fit
     if(pfp.AlgMod[kSmallAngle]) return;
     if(pfp.SectionFits.size() != 1) return;
     if(pfp.TP3Ds.size() < 20) return;
     if(!CanSection(slc, pfp)) return;
 
     // make a copy
     auto p2 = pfp;
     // try two sections
     p2.SectionFits.resize(2);
     unsigned short halfPt = p2.TP3Ds.size() / 2;
     for(unsigned short ipt = halfPt; ipt < p2.TP3Ds.size(); ++ipt) p2.TP3Ds[ipt].SFIndex = 1;
     // Confirm that both sections can be reconstructed
     unsigned short toPt = Find3DRecoRange(slc, p2, 0, 3, 1);
     if(toPt > p2.TP3Ds.size()) return;
     toPt = Find3DRecoRange(slc, p2, halfPt, 3, 1);
     if(toPt > p2.TP3Ds.size()) return;
     if(!FitSection(clockData, detProp, slc, p2, 0) || !FitSection(clockData, detProp, slc, p2, 1)) {
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt << "Recover failed MVI " << p2.MVI << " in TPC " << p2.TPCID.TPC;
         for(auto tid : p2.TjIDs) myprt << " T" << tid; 
       } // prt
       return;
     }
     if(prt) mf::LogVerbatim("TC")<<"Recover: P" << pfp.ID << " success";
     pfp = p2;
 
   } // Recover

bool tca::RefineVtxPosition	(	TCSlice &	slc,
		const Trajectory &	tj,
		unsigned short &	nearPt,
		short	nPtsToChk,
		bool	prt
	)

Definition at line 2704 of file TCVertex.cxx.

   {
     // 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;
     unsigned short fromPt = tj.EndPt[0];
     short spt = (short)nearPt - (short)nPtsToChk;
     if (spt > (short)fromPt) fromPt = nearPt - nPtsToChk;
     unsigned short toPt = nearPt + nPtsToChk;
     if (toPt > tj.EndPt[1]) toPt = tj.EndPt[1];
 
     for (short ipt = fromPt; ipt <= toPt; ++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(slc, tp.Pos) << " chg " << (int)tp.Chg << " nhits "
                               << tp.Hits.size();
     } // ipt
     if (nearPt == maxChgPt) return false;
     nearPt = maxChgPt;
     return true;
   } //RefineVtxPosition

void tca::ReleaseHits	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 1060 of file Utils.cxx.

   {
     // Sets InTraj[] = 0 for all TPs in work. Called when abandoning work
     for (auto& tp : tj.Pts) {
       for (auto iht : tp.Hits) {
         if (slc.slHits[iht].InTraj == tj.ID) slc.slHits[iht].InTraj = 0;
       }
     } // tp
 
   } // ReleaseWorkHits

bool tca::RemovePFP	(	std::string	inFcnLabel,
		TCSlice &	slc,
		int	pID,
		ShowerStruct3D &	ss3,
		bool	doUpdate,
		bool	prt
	)

bool tca::RemovePFP	(	std::string	inFcnLabel,
		TCSlice &	slc,
		PFPStruct &	pfp,
		ShowerStruct3D &	ss3,
		bool	doUpdate,
		bool	prt
	)

Definition at line 1355 of file TCShower.cxx.

   {
     // 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 = slc.cots[cid - 1];
         if (std::find(ss.TjIDs.begin(), ss.TjIDs.end(), tid) == ss.TjIDs.end()) continue;
         if (!RemoveTj(fcnLabel, slc, tid, ss, doUpdate, prt)) return false;
         ss3.NeedsUpdate = true;
       } // cid
     }   // ptid
 
     if (doUpdate && ss3.NeedsUpdate) UpdateShower(fcnLabel, slc, ss3, prt);
     return true;
 
   } // Remove PFP

bool tca::RemoveTj	(	std::string	inFcnLabel,
		TCSlice &	slc,
		int	TjID,
		ShowerStruct &	ss,
		bool	doUpdate,
		bool	prt
	)

Definition at line 1519 of file TCShower.cxx.

   {
     // Removes the Tj from a shower
 
     if (TjID > (int)slc.tjs.size()) return false;
 
     std::string fcnLabel = inFcnLabel + ".RTj";
 
     // make sure it isn't already in a shower
     Trajectory& tj = slc.tjs[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, slc, 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, slc, ss, prt);
     }
     return true;
   } // RemoveTj

bool tca::ReSection	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 1111 of file PFPUtils.cxx.

   {
     // Re-fit the TP3Ds in sections and add/remove sections to keep ChiDOF of each section close to 1.
     // This function only fails when there is a serious error, otherwise if reasonable fits cannot be
     // achieved, the CanSection flag is set false.
     if (pfp.SectionFits.empty()) return false;
     // This function shouldn't be called if this is the case but it isn't a major failure if it is
     if (!pfp.Flags[kCanSection]) return true;
     if(pfp.Flags[kSmallAngle]) return true;
     // Likewise this shouldn't be attempted if there aren't at least 3 points in 2 planes in 2 sections
     // but it isn't a failure
     if (pfp.TP3Ds.size() < 12) {
       pfp.Flags[kCanSection] = false;
       return true;
     }
 
     prt = (pfp.MVI == debug.MVI);
 
     // try to keep ChiDOF between chiLo and chiHi
     float chiLo = 0.5 * tcc.match3DCuts[5];
     float chiHi = 1.5 * tcc.match3DCuts[5];
 
     // clobber the old sections if more than one exists
     if (pfp.SectionFits.size() > 1) {
       // make one section
       pfp.SectionFits.resize(1);
       // put all of the points in it and fit
       for (auto& tp3d : pfp.TP3Ds) {
         tp3d.SFIndex = 0;
         tp3d.Flags[kTP3DGood] = true;
       }
       auto& sf = pfp.SectionFits[0];
       if (!FitSection(clockData, detProp, slc, pfp, 0)) { return false; }
       if (sf.ChiDOF < tcc.match3DCuts[5]) return true;
     } // > 1 SectionFit
     // sort by distance from the start
     if (!SortSection(pfp, 0)) return false;
     // require a minimum of 3 points in 2 planes
     unsigned short min2DPts = 3;
     unsigned short fromPt = 0;
     // set the section index to invalid for all points
     for (auto& tp3d : pfp.TP3Ds)
       tp3d.SFIndex = USHRT_MAX;
     // Guess how many points should be added in each iteration
     unsigned short nPtsToAdd = pfp.TP3Ds.size() / 4;
     // the actual number of points that will be fit in the section
     unsigned short nPts = nPtsToAdd;
     // the minimum number of points
     unsigned short nPtsMin = Find3DRecoRange(slc, pfp, fromPt, min2DPts, 1) - fromPt + 1;
     if (nPtsMin >= pfp.TP3Ds.size()) {
       pfp.Flags[kCanSection] = false;
       return true;
     }
     float chiDOF = 0;
     if (nPts < nPtsMin) nPts = nPtsMin;
     // Try to reduce the number of iterations for long pfps
     if (pfp.TP3Ds.size() > 100) {
       unsigned short nhalf = pfp.TP3Ds.size() / 2;
       FitTP3Ds(detProp, slc, pfp, fromPt, nhalf, USHRT_MAX, chiDOF);
       if (chiDOF < tcc.match3DCuts[5]) nPts = nhalf;
     }
     bool lastSection = false;
     for (unsigned short sfIndex = 0; sfIndex < 20; ++sfIndex) {
       // Try to add/remove points in each section no more than 20 times
       float chiDOFPrev = 0;
       short nHiChi = 0;
       for (unsigned short nit = 0; nit < 10; ++nit) {
         // Decide how many points to add or subtract after doing the fit
         unsigned short nPtsNext = nPts;
         if (!FitTP3Ds(detProp, slc, pfp, fromPt, nPts, USHRT_MAX, chiDOF)) {
           nPtsNext += 1.5 * nPtsToAdd;
         }
         else if (chiDOF < chiLo) {
           // low chiDOF
           if (nHiChi > 2) {
             // declare it close enough if several attempts were made
             nPtsNext = 0;
           }
           else {
             nPtsNext += nPtsToAdd;
           } // nHiChi < 2
           nHiChi = 0;
         }
         else if (chiDOF > chiHi) {
           // high chiDOF
           ++nHiChi;
           if (nHiChi == 1 && chiDOFPrev > tcc.match3DCuts[5]) {
             // reduce the number of points by 1/2 on the first attempt
             nPtsNext /= 2;
           }
           else {
             // that didn't work so start subtracting groups of points
             short npnext = (short)nPts - nHiChi * 5;
             // assume this won't work
             nPtsNext = 0;
             if (npnext > nPtsMin) nPtsNext = npnext;
           }
         }
         else {
           // just right
           nPtsNext = 0;
         }
         // check for passing the end
         if (fromPt + nPtsNext >= pfp.TP3Ds.size()) {
           nPtsNext = pfp.TP3Ds.size() - fromPt;
           lastSection = true;
         }
         if (prt) {
           mf::LogVerbatim myprt("TC");
           myprt << " RS: P" << pfp.ID << " sfi/nit/npts " << sfIndex << "/" << nit << "/" << nPts;
           myprt << std::fixed << std::setprecision(1) << " chiDOF " << chiDOF;
           myprt << " fromPt " << fromPt;
           myprt << " nPtsNext " << nPtsNext;
           myprt << " nHiChi " << nHiChi;
           myprt << " lastSection? " << lastSection;
         }
         if (nPtsNext == 0) break;
         // see if this is the last section
         if (lastSection) break;
         if (chiDOF == chiDOFPrev) {
           if (prt) mf::LogVerbatim("TC") << " MVI " << pfp.MVI << " chiDOF not changing\n";
           break;
         }
         nPts = nPtsNext;
         chiDOFPrev = chiDOF;
       } // nit
       // finished this section. Assign the points to it
       unsigned short toPt = fromPt + nPts;
       if (toPt > pfp.TP3Ds.size()) toPt = pfp.TP3Ds.size();
       for (unsigned short ipt = fromPt; ipt < toPt; ++ipt)
         pfp.TP3Ds[ipt].SFIndex = sfIndex;
       // See if there are enough points remaining to reconstruct another section if this isn't known
       // to be the last section
       if (!lastSection) {
         // this will be the first point in the next section
         unsigned short nextFromPt = fromPt + nPts;
         // See if it will have enough points to be reconstructed
         unsigned short nextToPtMin = Find3DRecoRange(slc, pfp, nextFromPt, min2DPts, 1);
         if (nextToPtMin == USHRT_MAX) {
           // not enough points so this is the last section
           lastSection = true;
           // assign the remaining points to the last section
           for (std::size_t ipt = nextFromPt; ipt < pfp.TP3Ds.size(); ++ipt)
             pfp.TP3Ds[ipt].SFIndex = sfIndex;
         }
       } // !lastSection
       // Do a final fit and update the points. Don't worry about a poor ChiDOF
       FitSection(clockData, detProp, slc, pfp, sfIndex);
       if (!SortSection(pfp, 0)) { return false; }
       if (lastSection) break;
       // Prepare for the next section.
       fromPt = fromPt + nPts;
       nPts = nPtsToAdd;
       nPtsMin = Find3DRecoRange(slc, pfp, fromPt, min2DPts, 1) - fromPt + 1;
       if (nPtsMin >= pfp.TP3Ds.size()) break;
       // add a new section
       pfp.SectionFits.resize(pfp.SectionFits.size() + 1);
     } // snit
 
     // see if the last sf is valid
     if (pfp.SectionFits.size() > 1 && pfp.SectionFits.back().ChiDOF < 0) {
       unsigned short badSFI = pfp.SectionFits.size() - 1;
       // remove it
       pfp.SectionFits.pop_back();
       for (std::size_t ipt = pfp.TP3Ds.size() - 1; ipt > 0; --ipt) {
         auto& tp3d = pfp.TP3Ds[ipt];
         if (tp3d.SFIndex < badSFI) break;
         --tp3d.SFIndex;
       }
       pfp.SectionFits.back().NeedsUpdate = true;
     } // bad last SF
 
     // Ensure that the points at the end are in the last section
     for (std::size_t ipt = pfp.TP3Ds.size() - 1; ipt > 0; --ipt) {
       auto& tp3d = pfp.TP3Ds[ipt];
       if (tp3d.SFIndex < pfp.SectionFits.size()) break;
       tp3d.SFIndex = pfp.SectionFits.size() - 1;
       pfp.Flags[kNeedsUpdate] = true;
       pfp.SectionFits[tp3d.SFIndex].NeedsUpdate = true;
     } // tp3d
 
     Update(clockData, detProp, slc, pfp, prt);
 
     // set CanSection false if the chisq is poor in any section
     for (auto& sf : pfp.SectionFits) {
       if (sf.ChiDOF > tcc.match3DCuts[5]) pfp.Flags[kCanSection] = false;
     }
 
     return true;
   } // resection

void tca::RestoreObsoleteTrajectory	(	TCSlice &	slc,
		unsigned int	itj
	)

Definition at line 2195 of file Utils.cxx.

   {
     if (itj > slc.tjs.size() - 1) return;
     if (!slc.tjs[itj].AlgMod[kKilled]) {
       mf::LogWarning("TC")
         << "RestoreObsoleteTrajectory: Trying to restore not-obsolete trajectory "
         << slc.tjs[itj].ID;
       return;
     }
     unsigned int iht;
     for (auto& tp : slc.tjs[itj].Pts) {
       for (unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         if (tp.UseHit[ii]) {
           iht = tp.Hits[ii];
           if (slc.slHits[iht].InTraj == 0) { slc.slHits[iht].InTraj = slc.tjs[itj].ID; }
         }
       } // ii
     }   // tp
     slc.tjs[itj].AlgMod[kKilled] = false;
   } // RestoreObsoleteTrajectory

void tca::Reverse	(	TCSlice &	slc,
		PFPStruct &	pfp
	)

Definition at line 2359 of file PFPUtils.cxx.

   {
     // reverse the PFParticle
     std::reverse(pfp.TP3Ds.begin(), pfp.TP3Ds.end());
     std::reverse(pfp.SectionFits.begin(), pfp.SectionFits.end());
     for (std::size_t sfi = 0; sfi < pfp.SectionFits.size(); ++sfi) {
       auto& sf = pfp.SectionFits[sfi];
       // flip the direction vector
       for (unsigned short xyz = 0; xyz < 3; ++xyz)
         sf.Dir[xyz] *= -1;
     } // sf
     // correct the along variable
     for (auto& tp3d : pfp.TP3Ds)
       tp3d.along *= -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.EndFlag[0], pfp.EndFlag[1]);
   } // Reverse

void tca::ReversePropagate	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 1314 of file StepUtils.cxx.

   {
     // Reverse the trajectory and step in the opposite direction. The
     // updated trajectory is returned if this process is successful
 
     if(!tcc.useAlg[kRvPrp]) return;
 
     if(tj.Pts.size() < 6) return;
     // only do this once
     if(tj.AlgMod[kRvPrp]) return;
 
     // This code can't handle VLA trajectories
     if(tj.Pts[tj.EndPt[0]].AngleCode == 2) return;
 
     bool prt = (tcc.dbgStp || tcc.dbgAlg[kRvPrp]);
 
     // this function requires the first TP be included in the trajectory.
     if(tj.EndPt[0] > 0) {
       tj.Pts.erase(tj.Pts.begin(), tj.Pts.begin() + tj.EndPt[0]);
       SetEndPoints(tj);
     }
 
     if(prt) mf::LogVerbatim("TC")<<"ReversePropagate: Prepping Tj "<<tj.ID<<" incoming StepDir "<<tj.StepDir;
 
     short stepDir = tj.StepDir;
 
     // find the wire on which the first TP resides
     unsigned int wire0 = std::nearbyint(tj.Pts[0].Pos[0]);
     unsigned int nextWire = wire0 - tj.StepDir;
 
     // check for dead wires
     geo::PlaneID planeID = DecodeCTP(tj.CTP);
     unsigned short ipl = planeID.Plane;
     while(nextWire > slc.firstWire[ipl] && nextWire < slc.lastWire[ipl]) {
       if(evt.goodWire[ipl][nextWire]) break;
       nextWire -= tj.StepDir;
     }
     if(nextWire == slc.lastWire[ipl] - 1) return;
     // clone the first point
     TrajPoint tp = tj.Pts[0];
     // strip off the hits
     tp.Hits.clear(); tp.UseHit.reset();
     // move it to the next wire (in the opposite direction of the step direction)
     MoveTPToWire(tp, (float)nextWire);
     // find close unused hits near this position
     float maxDelta = 10 * tj.Pts[tj.EndPt[1]].DeltaRMS;
     if(!FindCloseHits(slc, tp, maxDelta, kUnusedHits)) return;
     if(prt) mf::LogVerbatim("TC")<<" nUnused hits "<<tp.Hits.size()<<" at Pos "<<PrintPos(slc, tp);
     if(tp.Hits.empty()) return;
     // There are hits on the next wire. Make a working copy of the trajectory, reverse it and try
     // to extend it with StepAway
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<" tp.Hits ";
       for(auto& iht : tp.Hits) myprt<<" "<<PrintHit(slc.slHits[iht])<<"_"<<slc.slHits[iht].InTraj;
     } // tcc.dbgStp
     //
     // Make a working copy of tj
     Trajectory tjWork = tj;
     // So the first shall be last and the last shall be first
     ReverseTraj(slc, tjWork);
     // Flag it to use special cuts in StepAway
     tjWork.AlgMod[kRvPrp] = true;
     // save the strategy word and set it to normal
     auto saveStrategy = tjWork.Strategy;
     tjWork.Strategy.reset();
     tjWork.Strategy[kNormal] = true;
     // Reduce the number of fitted points to a small number
     unsigned short lastPt = tjWork.Pts.size() - 1;
     if(lastPt < 4) return;
     // update the charge
     float chg = 0;
     float cnt = 0;
     for(unsigned short ii = 0; ii < 4; ++ii) {
       unsigned short ipt = lastPt - ii;
       if(tjWork.Pts[ipt].Chg == 0) continue;
       chg += tjWork.Pts[ipt].Chg;
       ++cnt;
     } // ii
     if(cnt == 0) return;
     if(cnt > 1) tjWork.Pts[lastPt].AveChg = chg / cnt;
     StepAway(slc, tjWork);
     if(!tj.IsGood) {
       if(prt) mf::LogVerbatim("TC")<<" ReversePropagate StepAway failed";
       return;
     }
     tjWork.Strategy = saveStrategy;
     // check the new stopping point
     ChkStopEndPts(slc, tjWork, tcc.dbgStp);
     // restore the original direction
     if(tjWork.StepDir != stepDir) ReverseTraj(slc, tjWork);
     tj = tjWork;
     // TODO: Maybe UpdateTjChgProperties should be called here
     // re-check the ends
     ChkStop(slc, tj);
 
   } // ReversePropagate

void tca::ReverseShower	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 3151 of file TCShower.cxx.

   {
     // 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 = slc.tjs[ss.ShowerTjID - 1];
     ReverseTraj(slc, stj);
     DefineEnvelope(fcnLabel, slc, ss, prt);
     if (prt) mf::LogVerbatim("TC") << fcnLabel << " Reversed shower. Shower angle = " << ss.Angle;
   } // ReverseShower

void tca::ReverseShower	(	std::string	inFcnLabel,
		TCSlice &	slc,
		int	cotID,
		bool	prt
	)

Definition at line 3180 of file TCShower.cxx.

   {
     // Reverses the shower and the shower tj
 
     if (cotID > (int)slc.cots.size()) return;
     ShowerStruct& ss = slc.cots[cotID - 1];
     if (ss.ID == 0) return;
     ReverseShower(inFcnLabel, slc, ss, prt);
   }

void tca::ReverseTraj	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 3292 of file Utils.cxx.

   {
     // reverse the trajectory
     if (tj.Pts.empty()) return;
     // reverse the crawling direction flag
     tj.StepDir = -tj.StepDir;
     // 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.EndFlag.begin(), tj.EndFlag.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
     if (tj.StartEnd == 0 || tj.StartEnd == 1) tj.StartEnd = 1 - tj.StartEnd;
     SetEndPoints(tj);
     //    UpdateMatchStructs(slc, tj.ID, tj.ID);
   } // ReverseTraj

void tca::SaveAllCots	(	TCSlice &	slc,
		const CTP_t &	inCTP,
		std::string	someText
	)

Definition at line 174 of file TCShTree.cxx.

                                                                          {
     if(!tcc.modes[kSaveShowerTree]) return;
     for(unsigned short cotIndex = 0; cotIndex < slc.cots.size(); ++cotIndex) {
       auto& ss = slc.cots[cotIndex];
       if (ss.CTP != inCTP) continue;
       if(ss.ID == 0) continue;
       SaveTjInfo(slc, ss, someText);
     } // cotIndex
   } // SaveAllCots

void tca::SaveAllCots	(	TCSlice &	slc,
		std::string	someText
	)

Definition at line 185 of file TCShTree.cxx.

                                                      {
     if(!tcc.modes[kSaveShowerTree]) return;
     for(unsigned short cotIndex = 0; cotIndex < slc.cots.size(); ++cotIndex) {
       auto& ss = slc.cots[cotIndex];
       if(ss.ID == 0) continue;
       SaveTjInfo(slc, ss, someText);
     } // cotIndex
   }

void tca::SaveCRInfo	(	detinfo::DetectorClocksData const &	clockData,
		TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt,
		bool	fIsRealData
	)

Definition at line 29 of file TCCR.cxx.

   {
 
     //Check the origin of pfp
     if (tcc.modes[kSaveCRTree]) {
       if (fIsRealData) { slc.crt.cr_origin.push_back(-1); }
       else {
         slc.crt.cr_origin.push_back(GetOrigin(clockData, slc, pfp));
       }
     }
 
     // save the xmin and xmax of each pfp
     auto& startPos = pfp.TP3Ds[0].Pos;
     auto& endPos = pfp.TP3Ds[pfp.TP3Ds.size() - 1].Pos;
     slc.crt.cr_pfpxmin.push_back(std::min(startPos[0], endPos[0]));
     slc.crt.cr_pfpxmax.push_back(std::max(startPos[0], endPos[0]));
 
     //find max
     const geo::TPCGeo& tpc = tcc.geom->TPC(0);
     float mindis0 = FLT_MAX;
     float mindis1 = FLT_MAX;
     if (std::abs(startPos[1] - tpc.MinY()) < mindis0) mindis0 = std::abs(startPos[1] - tpc.MinY());
     if (std::abs(startPos[1] - tpc.MaxY()) < mindis0) mindis0 = std::abs(startPos[1] - tpc.MaxY());
     if (std::abs(startPos[2] - tpc.MinZ()) < mindis0) mindis0 = std::abs(startPos[2] - tpc.MinZ());
     if (std::abs(startPos[2] - tpc.MaxZ()) < mindis0) mindis0 = std::abs(startPos[2] - tpc.MaxZ());
     if (std::abs(endPos[1] - tpc.MinY()) < mindis1) mindis1 = std::abs(endPos[1] - tpc.MinY());
     if (std::abs(endPos[1] - tpc.MaxY()) < mindis1) mindis1 = std::abs(endPos[1] - tpc.MaxY());
     if (std::abs(endPos[2] - tpc.MinZ()) < mindis1) mindis1 = std::abs(endPos[2] - tpc.MinZ());
     if (std::abs(endPos[2] - tpc.MaxZ()) < mindis1) mindis1 = std::abs(endPos[2] - tpc.MaxZ());
     //std::cout<<startPos[1]<<" "<<startPos[2]<<" "<<endPos[1]<<" "<<endPos[2]<<" "<<tpc.MinY()<<" "<<tpc.MaxY()<<" "<<tpc.MinZ()<<" "<<tpc.MaxZ()<<" "<<mindis0<<" "<<mindis1<<" "<<mindis0+mindis1<<std::endl;
     slc.crt.cr_pfpyzmindis.push_back(mindis0 + mindis1);
 
     if (slc.crt.cr_pfpxmin.back() < -2 || slc.crt.cr_pfpxmax.back() > 260 ||
         slc.crt.cr_pfpyzmindis.back() < 30) {
       pfp.CosmicScore = 1.;
     }
     else
       pfp.CosmicScore = 0;
   }

void tca::SaveTjInfo	(	TCSlice &	slc,
		std::vector< std::vector< int >> &	tjList,
		std::string	stageName
	)

Definition at line 14 of file TCShTree.cxx.

                                        {
     if(!tcc.modes[kSaveShowerTree]) return;
     if(tjList.empty()) return;
     int stageNum = GetStageNum(stv, stageName);
 
     // get the CTP from the first tj
     CTP_t inCTP = slc.tjs[tjList[0][0] - 1].CTP;
     for(unsigned short it1 = 0; it1 < slc.tjs.size(); ++it1) {
       Trajectory& tj1 = slc.tjs[it1];
       if(tj1.CTP != inCTP) continue;
       if(tj1.AlgMod[kKilled]) continue;
 
       SaveTjInfoStuff(slc, 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]) {
             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++) {
       stv.Envelope.push_back(-999);
       stv.EnvStage.push_back(stageNum);
       stv.EnvPlane.push_back(-1);
       stv.EnvShowerID.push_back(-1);
     }
 
   } // SaveTjInfo (tjlist)

void tca::SaveTjInfo	(	TCSlice &	slc,
		const ShowerStruct &	ss,
		std::string	stageName
	)

Definition at line 56 of file TCShTree.cxx.

                                                                              {
     if(!tcc.modes[kSaveShowerTree]) return;
     int stageNum = GetStageNum(stv, stageName);
 
     // killed shower?
     if(ss.ID == 0) return;
 
     bool noMatch = true;
 
     for(unsigned short it1 = 0; it1 < slc.tjs.size(); ++it1) {
 
       Trajectory& tj1 = slc.tjs[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 < stv.TjID.size(); ++i) {
         if (stv.StageNum.at(i) != (int)stageNum) continue;
         if (stv.PlaneNum.at(i) != (short)DecodeCTP(ss.CTP).Plane) continue;
 
         if (stv.TjID.at(i) == trajID) {
           tjIndex = i;
           if (stv.IsShowerTj.at(tjIndex) == 1) isShowerTj = true;
           //beenDoneBefore = true;
           break;
         }
       }
 
       if (isShowerTj) continue;
       if (tjIndex == -1) SaveTjInfoStuff(slc, tj1, stageNum, stageName);
 
       for (size_t i = 0; i < ss.TjIDs.size(); ++i) {
         if (trajID == ss.TjIDs[i]) {
           noMatch = false;
           if (tjIndex == -1) stv.ShowerID.back() = ss.ID;
           else stv.ShowerID.at(tjIndex) = ss.ID;
         }
 
         if (it1 == (ss.ShowerTjID - 1)) stv.IsShowerTj.back() = 1;
         else if (tj1.AlgMod[kShowerTj]) 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) {
             stv.ShowerID.back() = ss.ID;
             stv.IsShowerParent.back() = 1;
           }
           else {
             stv.ShowerID.at(tjIndex) = ss.ID;
             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++) {
       stv.EnvStage.push_back(stageNum);
       stv.EnvPlane.push_back(iPlnID.Plane);
       stv.EnvShowerID.push_back(ss.ID);
     }
 
     stv.Envelope.push_back(ss.Envelope[0][0]);
     stv.Envelope.push_back(ss.Envelope[0][1]/tcc.unitsPerTick);
     stv.Envelope.push_back(ss.Envelope[1][0]);
     stv.Envelope.push_back(ss.Envelope[1][1]/tcc.unitsPerTick);
     stv.Envelope.push_back(ss.Envelope[2][0]);
     stv.Envelope.push_back(ss.Envelope[2][1]/tcc.unitsPerTick);
     stv.Envelope.push_back(ss.Envelope[3][0]);
     stv.Envelope.push_back(ss.Envelope[3][1]/tcc.unitsPerTick);
 
   } // SaveTjInfo (cots)

void tca::SaveTjInfoStuff	(	TCSlice &	slc,
		Trajectory &	tj,
		int	stageNum,
		std::string	stageName
	)

Definition at line 140 of file TCShTree.cxx.

                                                                                         {
     if(!tcc.modes[kSaveShowerTree]) return;
 
     TrajPoint& beginPoint = tj.Pts[tj.EndPt[0]];
     TrajPoint& endPoint = tj.Pts[tj.EndPt[1]];
 
     stv.BeginWir.push_back(std::nearbyint(beginPoint.Pos[0]));
     stv.BeginTim.push_back(std::nearbyint(beginPoint.Pos[1]/tcc.unitsPerTick));
     stv.BeginAng.push_back(beginPoint.Ang);
     stv.BeginChg.push_back(beginPoint.Chg);
     stv.BeginVtx.push_back(tj.VtxID[0]);
 
     stv.EndWir.push_back(std::nearbyint(endPoint.Pos[0]));
     stv.EndTim.push_back(std::nearbyint(endPoint.Pos[1]/tcc.unitsPerTick));
     stv.EndAng.push_back(endPoint.Ang);
     stv.EndChg.push_back(endPoint.Chg);
     stv.EndVtx.push_back(tj.VtxID[1]);
 
     stv.MCSMom.push_back(tj.MCSMom);
     stv.TjID.push_back(tj.ID);
     stv.IsShowerTj.push_back(-1);
 
     stv.ShowerID.push_back(-1);
     stv.IsShowerParent.push_back(-1);
     stv.StageNum.push_back(stageNum);
     stv.nStages = stageNum;
     geo::PlaneID iPlnID = DecodeCTP(tj.CTP);
     stv.PlaneNum.push_back(iPlnID.Plane);
 
     stv.nPlanes = slc.nPlanes;
 
   } // SaveTjInfoStuff

void tca::ScoreVertices ( TCSlice & slc )

Definition at line 2160 of file TCVertex.cxx.

   {
     // reset all 3D vertex, 2D vertex and Tj high-score vertex bits in tpcid
 
     // reset the 2D vertex status bits
     for (auto& vx : slc.vtxs) {
       if (vx.ID == 0) continue;
       vx.Stat[kHiVx3Score] = false;
     } // vx
     // and the tj bits
     for (auto& tj : slc.tjs) {
       if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) continue;
       tj.AlgMod[kTjHiVx3Score] = false;
     } // tj
     // Score the 2D vertices
     for (auto& vx : slc.vtxs) {
       if (vx.ID == 0) continue;
       SetVx2Score(slc, vx);
     } // vx
     // Score the 3D vertices
     for (auto& vx3 : slc.vtx3s) {
       if (vx3.ID == 0) continue;
       SetVx3Score(slc, vx3);
     } // vx3
   }   // ScoreVertices

bool tca::SectionStartEnd	(	const PFPStruct &	pfp,
		unsigned short	sfIndex,
		unsigned short &	startPt,
		unsigned short &	endPt
	)

Definition at line 3311 of file PFPUtils.cxx.

   {
     // this assumes that the TP3Ds vector is sorted
     startPt = USHRT_MAX;
     endPt = USHRT_MAX;
     if (sfIndex >= pfp.SectionFits.size()) return false;
 
     bool first = true;
     for (std::size_t ipt = 0; ipt < pfp.TP3Ds.size(); ++ipt) {
       auto& tp3d = pfp.TP3Ds[ipt];
       if (tp3d.SFIndex < sfIndex) continue;
       if (first) {
         first = false;
         startPt = ipt;
       } // first
       if (tp3d.SFIndex > sfIndex) break;
       endPt = ipt;
     } // ipt
     return true;
 
   } // SectionStartEnd

void tca::SetAngleCode ( TrajPoint & tp )

Definition at line 771 of file Utils.cxx.

   {
     unsigned short ar = AngleRange(tp.Ang);
     if (ar == tcc.angleRanges.size() - 1) {
       // Very large angle
       tp.AngleCode = 2;
     }
     else if (tcc.angleRanges.size() > 2 && ar == tcc.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 428 of file Utils.h.

   {
     // 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 ( Trajectory & tj )

Definition at line 3411 of file Utils.cxx.

   {
     // Find the first (last) TPs, EndPt[0] (EndPt[1], that have charge
 
     // don't mess with showerTjs or halo tjs
     if (tj.AlgMod[kShowerTj] || tj.AlgMod[kHaloTj]) 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	(	TCSlice &	slc,
		Vtx3Store &	vx3
	)

Definition at line 2207 of file TCVertex.cxx.

   {
     // Sets the tj and 2D vertex score bits to true
 
     if (vx3.ID == 0) return;
 
     for (unsigned short ipl = 0; ipl < slc.nPlanes; ++ipl) {
       if (vx3.Vx2ID[ipl] <= 0) continue;
       VtxStore& vx2 = slc.vtxs[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(slc, 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 = slc.tjs[tjid - 1];
           tj.AlgMod[kTjHiVx3Score] = true;
           for (unsigned short end = 0; end < 2; ++end) {
             if (tj.VtxID[end] == 0) continue;
             auto& vx2 = slc.vtxs[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 = slc.vtxs[vxid - 1];
           auto tmp = GetVtxTjIDs(slc, 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 405 of file Utils.h.

   {
     // 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 2582 of file PFPUtils.cxx.

   {
     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 3345 of file Utils.cxx.

   {
     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	(	detinfo::DetectorPropertiesData const &	detProp,
		std::string	inFcnLabel,
		TCSlice &	slc,
		PFPStruct &	pfp,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 1830 of file TCShower.cxx.

   {
     // 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 = slc.cots[cid - 1];
       auto& stj = slc.tjs[ss.ShowerTjID - 1];
       stj.VtxID[0] = 0;
       if (ss.ParentID > 0) {
         auto& oldParent = slc.tjs[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 = slc.tjs[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, slc, 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
         auto pos = PosAtEnd(pfp, 0);
         auto dir = DirAtEnd(pfp, 0);
         auto tp = MakeBareTP(detProp, slc, pos, dir, 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 = slc.vtx3s[ss3.Vx3ID - 1];
           auto v2list = GetAssns(slc, "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, slc, ss, prt)) return false;
       } // tjid
     }   // cid
     ss3.ParentID = pfp.ID;
 
     unsigned short pEnd = FarEnd(slc, pfp, ss3.ChgPos);
     ss3.Vx3ID = pfp.Vx3ID[pEnd];
     float fom3D = ParentFOM(fcnLabel, slc, pfp, pEnd, ss3, prt);
     for (auto cid : ss3.CotIDs)
       slc.cots[cid - 1].ParentFOM = fom3D;
 
     return true;
   } // SetParent

void tca::SetPDGCode	(	TCSlice &	slc,
		unsigned short	itj
	)

Definition at line 4348 of file Utils.cxx.

   {
     if (itj > slc.tjs.size() - 1) return;
     SetPDGCode(slc, slc.tjs[itj]);
   }

void tca::SetPDGCode	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 4356 of file Utils.cxx.

   {
     // Sets the PDG code for the supplied trajectory. Note that the existing
     // PDG code is left unchanged if these cuts are not met
 
     short npwc = NumPtsWithCharge(slc, tj, false);
     if (npwc < 6) {
       tj.PDGCode = 0;
       return;
     }
 
     if (tj.Strategy[kStiffEl] && ElectronLikelihood(slc, tj) > tcc.showerTag[6]) {
       tj.PDGCode = 111;
       return;
     }
     if (tj.Strategy[kStiffMu]) {
       tj.PDGCode = 13;
       return;
     }
 
     if (tcc.showerTag[6] > 0 && ElectronLikelihood(slc, tj) > tcc.showerTag[6]) {
       tj.PDGCode = 11;
       return;
     }
 
     if (tcc.muonTag[0] <= 0) return;
     // Special handling of very long straight trajectories, e.g. uB cosmic rays
     bool isAMuon = (npwc > (unsigned short)tcc.muonTag[0] && tj.MCSMom > tcc.muonTag[1]);
     // anything really really long must be a muon
     if (npwc > 500) isAMuon = true;
     if (isAMuon) tj.PDGCode = 13;
 
   } // SetPDGCode

bool tca::SetSection	(	detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		PFPStruct &	pfp,
		TP3D &	tp3d
	)

Definition at line 2769 of file PFPUtils.cxx.

   {
     // Determine which SectionFit this tp3d should reside in, then calculate
     // the 3D position and the distance from the center of the SectionFit
 
     if (tp3d.Wire < 0) return false;
     if (pfp.SectionFits.empty()) return false;
     if (pfp.SectionFits[0].Pos[0] == -10.0) return false;
     if(pfp.Flags[kSmallAngle]) return true;
 
     auto plnID = DecodeCTP(tp3d.CTP);
 
     if (pfp.SectionFits.size() == 1) { tp3d.SFIndex = 0; }
     else {
       // Find the section center that is closest to this point in the wire coordinate
       float best = 1E6;
       for (std::size_t sfi = 0; sfi < pfp.SectionFits.size(); ++sfi) {
         auto& sf = pfp.SectionFits[sfi];
         float sfWire = tcc.geom->WireCoordinate(sf.Pos[1], sf.Pos[2], plnID);
         float sep = std::abs(sfWire - tp3d.Wire);
         if (sep < best) {
           best = sep;
           tp3d.SFIndex = sfi;
         }
       } // sfi
     }   // pfp.SectionFits.size() > 1
     auto& sf = pfp.SectionFits[tp3d.SFIndex];
     auto plnTP = MakeBareTP(detProp, slc, sf.Pos, sf.Dir, tp3d.CTP);
     // the number of wires relative to the SectionFit center
     double dw = tp3d.Wire - plnTP.Pos[0];
     // dt/dW was stored in DeltaRMS
     double t = dw * plnTP.DeltaRMS;
     // define the 3D position
     for (unsigned short xyz = 0; xyz < 3; ++xyz)
       tp3d.Pos[xyz] = sf.Pos[xyz] + t * sf.Dir[xyz];
     tp3d.along = t;
     tp3d.Flags[kTP3DGood] = true;
     return true;
   } // SetSection

void tca::SetStrategy	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 338 of file StepUtils.cxx.

   {
     // Determine if the tracking strategy is appropriate and make some tweaks if it isn't
     if(tjfs.empty()) return;
     // analyze the last forecast
     auto& tjf = tjfs[tjfs.size() - 1];
 
     auto& lastTP = tj.Pts[tj.EndPt[1]];
     // Stay in Slowing strategy if we are in it and reduce the number of points fit further
     if(tj.Strategy[kSlowing]) {
       lastTP.NTPsFit = 5;
       return;
     }
 
     float npwc = NumPtsWithCharge(slc, tj, false);
     // Keep using the StiffMu strategy if the tj is long and MCSMom is high
     if(tj.Strategy[kStiffMu] && tj.MCSMom > 800 && npwc > 200) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"SetStrategy: Keep using the StiffMu strategy";
       return;
     }
     bool tkLike = (tjf.outlook < 1.5);
     // A showering-electron-like trajectory
     bool chgIncreasing = (tjf.chgSlope > 0);
     // A showering-electron-like trajectory
     bool shLike = (tjf.outlook > 2 && chgIncreasing);
     if(!shLike) shLike = tjf.showerLikeFraction > 0.5;
     float momRat = 0;
     if(tj.MCSMom > 0) momRat = (float)tjf.MCSMom / (float)tj.MCSMom;
     if(tcc.dbgStp) {
       mf::LogVerbatim myprt("TC");
       myprt<<"SetStrategy: npwc "<<npwc<<" outlook "<<tjf.outlook;
       myprt<<" tj MCSMom "<<tj.MCSMom<<" forecast MCSMom "<<tjf.MCSMom;
       myprt<<" momRat "<<std::fixed<<std::setprecision(2)<<momRat;
       myprt<<" tkLike? "<<tkLike<<" shLike? "<<shLike;
       myprt<<" chgIncreasing? "<<chgIncreasing;
       myprt<<" leavesBeforeEnd? "<<tjf.leavesBeforeEnd<<" endBraggPeak? "<<tjf.endBraggPeak;
       myprt<<" nextForecastUpdate "<<tjf.nextForecastUpdate;
     }
     if(tjf.outlook < 0) return;
     // Look for a long clean muon in the forecast
     bool stiffMu = (tkLike && tjf.MCSMom > 600 && tjf.nextForecastUpdate > 100);
     if(stiffMu) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"SetStrategy: High MCSMom, long forecast. Use the StiffMu strategy";
       tj.Strategy.reset();
       tj.Strategy[kStiffMu] = true;
       return;
     } // StiffMu
     bool notStiff = (!tj.Strategy[kStiffEl] && !tj.Strategy[kStiffMu]);
     if(notStiff && !shLike && tj.MCSMom < 100 && tjf.MCSMom < 100 && chgIncreasing) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"SetStrategy: Low MCSMom. Use the Slowing Tj strategy";
       tj.Strategy.reset();
       tj.Strategy[kSlowing] = true;
       lastTP.NTPsFit = 5;
       return;
     } // Low MCSMom
     if(notStiff && !shLike && tj.MCSMom < 200 && momRat < 0.7 && chgIncreasing) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"SetStrategy: Low MCSMom & low momRat. Use the Slowing Tj strategy";
       tj.Strategy.reset();
       tj.Strategy[kSlowing] = true;
       lastTP.NTPsFit = 5;
       return;
     } // low MCSMom
     if(!tjf.leavesBeforeEnd && tjf.endBraggPeak) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"SetStrategy: Found a Bragg peak. Use the Slowing Tj strategy";
       tj.Strategy.reset();
       tj.Strategy[kSlowing] = true;
       lastTP.NTPsFit = 5;
       return;
     } // tracklike with Bragg peak
     if(tkLike && tjf.nextForecastUpdate > 100 && tjf.leavesBeforeEnd && tjf.MCSMom < 500) {
       // A long track-like trajectory that has many points fit and the outlook is track-like and
       // it leaves the forecast polygon. Don't change the strategy but decrease the number of points fit
       lastTP.NTPsFit /= 2;
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"SetStrategy: Long track-like wandered out of forecast envelope. Reduce NTPsFit to "<<lastTP.NTPsFit;
       return;
     } // fairly long and leaves the side
     // a track-like trajectory that has high MCSMom in the forecast and hits a shower
     if(tkLike && tjf.MCSMom > 600 && (tjf.foundShower || tjf.chgFitChiDOF > 20)) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"SetStrategy: high MCSMom "<<tjf.MCSMom<<" and a shower ahead. Use the StiffEl strategy";
       tj.Strategy.reset();
       tj.Strategy[kStiffEl] = true;
       // we think we know the direction (towards the shower) so  startEnd is 0
       tj.StartEnd = 0;
       return;
     } // Stiff electron
     if(shLike && !tjf.leavesBeforeEnd) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"SetStrategy: Inside a shower. Use the StiffEl strategy";
       tj.Strategy.reset();
       tj.Strategy[kStiffEl] = true;
       // we think we know the direction (towards the shower) so  startEnd is 0
       tj.StartEnd = 0;
       return;
     }
   } // SetStrategy

void tca::SetTPEnvironment	(	TCSlice &	slc,
		CTP_t	inCTP
	)

Definition at line 3624 of file Utils.cxx.

   {
     // This function is called after tj reconstruction is completed to set TP Environment
     // bits that are dependent on reconstruction, just kEnvNearMuon for now. This bit is
     // set for all TPs that are within 5 wire-equivalents of a muon
 
     std::array<int, 2> wireWindow;
     Point2_t timeWindow;
     unsigned short plane = DecodeCTP(inCTP).Plane;
     //
     float delta = 5;
 
     for (auto& mutj : slc.tjs) {
       if (mutj.AlgMod[kKilled]) continue;
       if (mutj.CTP != inCTP) continue;
       if (mutj.PDGCode != 13) continue;
       unsigned short nnear = 0;
       for (unsigned short ipt = mutj.EndPt[0]; ipt <= mutj.EndPt[1]; ++ipt) {
         auto& tp = mutj.Pts[ipt];
         wireWindow[0] = tp.Pos[0];
         wireWindow[1] = tp.Pos[0];
         timeWindow[0] = tp.Pos[1] - delta;
         timeWindow[1] = tp.Pos[1] + delta;
         // get a list of all hits in this region
         bool hitsNear;
         auto closeHits =
           FindCloseHits(slc, wireWindow, timeWindow, plane, kAllHits, true, hitsNear);
         if (closeHits.empty()) continue;
         for (auto iht : closeHits) {
           auto inTraj = slc.slHits[iht].InTraj;
           if (inTraj <= 0) continue;
           if (inTraj == mutj.ID) continue;
           auto& dtj = slc.tjs[inTraj - 1];
           if (dtj.PDGCode == 13) continue;
           for (unsigned short jpt = dtj.EndPt[0]; jpt <= dtj.EndPt[1]; ++jpt) {
             auto& dtp = dtj.Pts[jpt];
             if (std::find(dtp.Hits.begin(), dtp.Hits.end(), iht) == dtp.Hits.end()) continue;
             dtp.Environment[kEnvNearMuon] = true;
             ++nnear;
           } // jpt
         }   // iht
       }     // ipt
     }       // mutj
   }         // SetTPEnvironment

void tca::SetVx2Score ( TCSlice & slc )

Definition at line 2278 of file TCVertex.cxx.

   {
     // A version that sets the score of the last added vertex
     if (slc.vtxs.empty()) return;
     auto& vx2 = slc.vtxs[slc.vtxs.size() - 1];
     SetVx2Score(slc, vx2);
   } // SetVx2Score

void tca::SetVx2Score	(	TCSlice &	slc,
		VtxStore &	vx2
	)

Definition at line 2288 of file TCVertex.cxx.

   {
     // 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.Topo == 12) {
       vx2.Score = tcc.vtx2DCuts[7] + 0.1;
       auto vtxTjID = GetVtxTjIDs(slc, vx2);
       vx2.TjChgFrac = ChgFracNearPos(slc, 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 (tcc.vtxScoreWeights.size() < 4) return;
 
     auto vtxTjIDs = GetVtxTjIDs(slc, vx2);
     if (vtxTjIDs.empty()) return;
 
     // Vertex position error
     float vpeScore = -tcc.vtxScoreWeights[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 (slc.vtx3s[ivx3].Wire < 0) m3Dcnt = 2;
     }
     float m3DScore = tcc.vtxScoreWeights[1] * m3Dcnt;
 
     vx2.TjChgFrac = ChgFracNearPos(slc, vx2.Pos, vtxTjIDs);
     float cfScore = tcc.vtxScoreWeights[2] * vx2.TjChgFrac;
 
     // Define a weight for each Tj
     std::vector<int> tjids;
     std::vector<float> tjwts;
     unsigned short cnt13 = 0;
     for (auto tjid : vtxTjIDs) {
       Trajectory& tj = slc.tjs[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;
       // weight by the first tagged muon
       if (tj.PDGCode == 13) {
         ++cnt13;
         if (cnt13 == 1) 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 = slc.tjs[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.EndFlag[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 = slc.tjs[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.EndFlag[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 = tcc.vtxScoreWeights[3] * sum;
     }
     vx2.Score = vpeScore + m3DScore + cfScore + tjScore;
     if (tcc.dbg2V && tcc.dbgSlc && vx2.CTP == debug.CTP) {
       // last call after vertices have been matched to the truth. Use to optimize vtxScoreWeights using
       // an ntuple
       mf::LogVerbatim myprt("TC");
       bool printHeader = true;
       Print2V("SVx2S", myprt, vx2, printHeader);
       myprt << std::fixed << std::setprecision(1);
       myprt << " vpeScore " << vpeScore << " m3DScore " << m3DScore;
       myprt << " cfScore " << cfScore << " tjScore " << tjScore;
       myprt << " Score " << vx2.Score;
     }
   } // SetVx2Score

void tca::SetVx3Score	(	TCSlice &	slc,
		Vtx3Store &	vx3
	)

Definition at line 2256 of file TCVertex.cxx.

   {
     // Calculate the 3D vertex score and flag Tjs that are attached to high score vertices as defined
     // by vtx2DCuts
 
     if (vx3.ID == 0) return;
 
     vx3.Score = 0;
     for (unsigned short ipl = 0; ipl < slc.nPlanes; ++ipl) {
       if (vx3.Vx2ID[ipl] <= 0) continue;
       VtxStore& vx2 = slc.vtxs[vx3.Vx2ID[ipl] - 1];
       vx3.Score += vx2.Score;
     } // ipl
     vx3.Score /= (float)slc.nPlanes;
     // don't allow it to get too small or negative
     if (vx3.Score < 0.001) vx3.Score = 0.001;
     if (vx3.Score > tcc.vtx2DCuts[7]) SetHighScoreBits(slc, vx3);
 
   } // SetVx3Score

double tca::ShowerEnergy ( const ShowerStruct3D & ss3 )

Definition at line 3952 of file TCShower.cxx.

   {
     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	(	TCSlice &	slc,
		const std::vector< int >	tjIDs
	)

Definition at line 3966 of file TCShower.cxx.

   {
     // 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 = slc.tjs[tid - 1];
       sum += tj.TotChg;
     } // tid
     return ChgToMeV(sum);
   } // ShowerEnergy

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

Definition at line 1921 of file TCShower.cxx.

   {
     // 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 = 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 1941 of file TCShower.cxx.

   {
     // 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 ( TrajPoint & tp )

Definition at line 2002 of file Utils.cxx.

   {
     // returns true if there is a hit near tp.Pos by searching through the full hit collection (if there
     // are multiple slices) or through the last slice (if there is only one slice)
 
     tp.Environment[kEnvNearSrcHit] = false;
 
     // just check the hits in the last slice
     if (evt.wireHitRange.empty()) {
       const auto& slc = slices[slices.size() - 1];
       return SignalAtTpInSlc(slc, tp);
     }
 
     if (tp.Pos[0] < -0.4) return false;
     geo::PlaneID planeID = DecodeCTP(tp.CTP);
     unsigned short pln = planeID.Plane;
     unsigned int wire = std::nearbyint(tp.Pos[0]);
     if (wire > evt.goodWire[pln].size() - 1) return false;
     // assume there is a signal on a dead wire
     if (!evt.goodWire[pln][wire]) return true;
 
     // check the proximity of all of the hits in the range
     float projTick = (float)(tp.Pos[1] / tcc.unitsPerTick);
     float tickRange = 0;
     if (std::abs(tp.Dir[1]) != 0) {
       tickRange = std::abs(0.5 / tp.Dir[1]) / tcc.unitsPerTick;
       // don't let it get too large
       if (tickRange > 40) tickRange = 40;
     }
     float loTpTick = projTick - tickRange;
     float hiTpTick = projTick + tickRange;
 
     // no signal here if there are no hits on this wire
     if (evt.wireHitRange[pln][wire].first == UINT_MAX) return false;
 
     for (unsigned int iht = evt.wireHitRange[pln][wire].first;
          iht <= evt.wireHitRange[pln][wire].second;
          ++iht) {
       auto& hit = (*evt.allHits)[iht];
       // We wouldn't need to make this check if hits were sorted
       const auto& wid = hit.WireID();
       if (wid.Cryostat != planeID.Cryostat) continue;
       if (wid.TPC != planeID.TPC) continue;
       if (wid.Plane != planeID.Plane) continue;
       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
     // No hit was found near projTick. Search through the source hits collection
     // (if it is defined) for a hit that may have been removed by disambiguation
     // Use the srcHit collection if it is available
     if (evt.srcHits != NULL) {
       if (NearbySrcHit(planeID, wire, loTpTick, hiTpTick)) {
         tp.Environment[kEnvNearSrcHit] = true;
         return true;
       } // NearbySrcHit
     }   // evt.srcHits != NULL
     return false;
   } // SignalAtTp

bool tca::SignalAtTpInSlc	(	const TCSlice &	slc,
		const TrajPoint &	tp
	)

Definition at line 1960 of file Utils.cxx.

   {
     // Version of SignalAtTP that only checks the hit collection in the current slice
 
     if (tp.Pos[0] < -0.4) return false;
     geo::PlaneID planeID = DecodeCTP(tp.CTP);
     unsigned short pln = planeID.Plane;
     unsigned int wire = std::nearbyint(tp.Pos[0]);
     if (wire > evt.goodWire[pln].size() - 1) return false;
     // assume there is a signal on a dead wire
     if (!evt.goodWire[pln][wire]) return true;
     // no signal here if there are no hits on this wire
     if (slc.wireHitRange[pln][wire].first == UINT_MAX) return false;
     // check the proximity of all of the hits in the range
     float projTick = (float)(tp.Pos[1] / tcc.unitsPerTick);
     float tickRange = 0;
     if (std::abs(tp.Dir[1]) != 0) {
       tickRange = std::abs(0.5 / tp.Dir[1]) / tcc.unitsPerTick;
       // don't let it get too large
       if (tickRange > 40) tickRange = 40;
     }
     float loTpTick = projTick - tickRange;
     float hiTpTick = projTick + tickRange;
     for (unsigned int iht = slc.wireHitRange[pln][wire].first;
          iht <= slc.wireHitRange[pln][wire].second;
          ++iht) {
       unsigned int ahi = slc.slHits[iht].allHitsIndex;
       auto& hit = (*evt.allHits)[ahi];
       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;
   } // SignalAtTpInSlc

bool tca::SignalBetween	(	const TCSlice &	slc,
		const TrajPoint &	tp1,
		const TrajPoint &	tp2,
		const float &	MinWireSignalFraction
	)

Definition at line 1805 of file Utils.cxx.

   {
     // 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]);
       return SignalAtTp(tp);
     }
     // define a trajectory point located at tp1 that has a direction towards tp2
     TrajPoint tp;
     if (!MakeBareTrajPoint(slc, tp1, tp2, tp)) return true;
     return SignalBetween(slc, tp, toWire, MinWireSignalFraction);
   } // SignalBetween

bool tca::SignalBetween	(	const TCSlice &	slc,
		TrajPoint	tp,
		float	toPos0,
		const float &	MinWireSignalFraction
	)

Definition at line 1831 of file Utils.cxx.

   {
     // Returns true if there is a signal on > MinWireSignalFraction of the wires between tp and toPos0.
     return ChgFracBetween(slc, tp, toPos0) >= MinWireSignalFraction;
   } // SignalBetween

bool tca::SortSection	(	PFPStruct &	pfp,
		unsigned short	sfIndex
	)

Definition at line 2027 of file PFPUtils.cxx.

   {
     // sorts the TP3Ds by the distance from the start of a fit section
 
     if (sfIndex > pfp.SectionFits.size() - 1) return false;
     auto& sf = pfp.SectionFits[sfIndex];
     if (sf.Pos[0] == 0.0 && sf.Pos[1] == 0.0 && sf.Pos[2] == 0.0) return false;
 
     // a temp vector of points in this section
     std::vector<TP3D> temp;
     // and the index into TP3Ds
     std::vector<unsigned short> indx;
     // See if the along variable is monotonically increasing
     float prevAlong = 0;
     bool first = true;
     bool needsSort = false;
     for (std::size_t ii = 0; ii < pfp.TP3Ds.size(); ++ii) {
       auto& tp3d = pfp.TP3Ds[ii];
       if (tp3d.SFIndex != sfIndex) continue;
       if (first) {
         first = false;
         prevAlong = tp3d.along;
       }
       else {
         if (tp3d.along < prevAlong) needsSort = true;
         prevAlong = tp3d.along;
       }
       temp.push_back(tp3d);
       indx.push_back(ii);
     } // tp3d
     if (temp.empty()) return false;
     // no sort needed?
     if (temp.size() == 1) return true;
     if (!needsSort) {
       sf.NeedsUpdate = false;
       return true;
     }
     // see if the points are not-contiguous
     bool contiguous = true;
     for (std::size_t ipt = 1; ipt < indx.size(); ++ipt) {
       if (indx[ipt] != indx[ipt - 1] + 1) contiguous = false;
     } // ipt
     if (!contiguous) { return false; }
 
     std::vector<SortEntry> sortVec(temp.size());
     for (std::size_t ii = 0; ii < temp.size(); ++ii) {
       sortVec[ii].index = ii;
       sortVec[ii].val = temp[ii].along;
     } // ipt
     std::sort(sortVec.begin(), sortVec.end(), valsIncreasing);
     for (std::size_t ii = 0; ii < temp.size(); ++ii) {
       // overwrite the tp3d
       auto& tp3d = pfp.TP3Ds[indx[ii]];
       tp3d = temp[sortVec[ii].index];
     } // ii
     sf.NeedsUpdate = false;
     return true;
   } // SortSection

bool tca::SplitTraj	(	detinfo::DetectorPropertiesData const &	detProp,
		TCSlice &	slc,
		unsigned short	itj,
		float	XPos,
		bool	makeVx2,
		bool	prt
	)

Definition at line 2270 of file Utils.cxx.

   {
     // Splits the trajectory at an X position and optionally creates a 2D vertex
     // at the split point
     if (itj > slc.tjs.size() - 1) return false;
 
     auto& tj = slc.tjs[itj];
     geo::PlaneID planeID = DecodeCTP(tj.CTP);
     float atPos1 = detProp.ConvertXToTicks(XPos, planeID) * tcc.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(slc, newVx2)) vx2Index = slc.vtxs.size() - 1;
     } // makeVx2
     return SplitTraj(slc, itj, atPt, vx2Index, prt);
   } // SplitTraj

bool tca::SplitTraj	(	TCSlice &	slc,
		unsigned short	itj,
		unsigned short	pos,
		unsigned short	ivx,
		bool	prt
	)

Definition at line 2317 of file Utils.cxx.

   {
     // Splits the trajectory itj in the slc.tjs 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 > slc.tjs.size() - 1) return false;
     if (pos < slc.tjs[itj].EndPt[0] + 1 || pos > slc.tjs[itj].EndPt[1] - 1) return false;
     if (ivx != USHRT_MAX && ivx > slc.vtxs.size() - 1) return false;
 
     Trajectory& tj = slc.tjs[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 " << PrintPos(slc, tj.Pts[pos]);
       if (ivx < slc.vtxs.size()) myprt << " with Vtx 2V" << slc.vtxs[ivx].ID;
     }
 
     // ensure that there will be at least 3 TPs on each trajectory
     unsigned short ntp = 0;
     for (unsigned short 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;
       return false;
     }
     ntp = 0;
     for (unsigned short ipt = pos + 1; ipt <= tj.EndPt[1]; ++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 = slc.tjs.size() + 1;
     ++evt.globalT_UID;
     newTj.UID = evt.globalT_UID;
     // 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 (unsigned short ipt = pos + 1; ipt <= tj.EndPt[1]; ++ipt) {
       tj.Pts[ipt].Chg = 0;
       for (unsigned short 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 (slc.slHits[iht].InTraj != tj.ID) continue;
         slc.slHits[iht].InTraj = newTj.ID;
         tj.Pts[ipt].UseHit[ii] = false;
       } // ii
     }   // ipt
     SetEndPoints(tj);
     // Update MCSMom and charge properties
     tj.MCSMom = MCSMom(slc, tj);
     UpdateTjChgProperties("ST", slc, tj, prt);
     if (splittingMuon) SetPDGCode(slc, 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 < slc.vtxs.size()) tj.VtxID[1] = slc.vtxs[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 (unsigned short ipt = 0; ipt < 3; ++ipt) {
       for (unsigned short ii = 0; ii < newTj.Pts[ipt].Hits.size(); ++ii)
         newTj.Pts[ipt].UseHit[ii] = false;
       newTj.Pts[ipt].Chg = 0;
     } // ipt
     SetEndPoints(newTj);
     newTj.MCSMom = MCSMom(slc, newTj);
     UpdateTjChgProperties("ST", slc, newTj, prt);
     if (splittingMuon) SetPDGCode(slc, newTj);
     if (ivx < slc.vtxs.size()) newTj.VtxID[0] = slc.vtxs[ivx].ID;
     newTj.AlgMod[kSplit] = true;
     newTj.ParentID = 0;
     slc.tjs.push_back(newTj);
 
     if (prt) {
       mf::LogVerbatim("TC") << "  newTj T" << newTj.ID << " EndPts " << newTj.EndPt[0] << " to "
                             << newTj.EndPt[1];
     }
     return true;
 
   } // SplitTraj

void tca::SplitTrajCrossingVertices	(	TCSlice &	slc,
		CTP_t	inCTP
	)

Definition at line 937 of file TCVertex.cxx.

   {
     // This is kind of self-explanatory...
 
     if (!tcc.useAlg[kSplitTjCVx]) return;
 
     if (slc.vtxs.empty()) return;
     if (slc.tjs.empty()) return;
 
     constexpr float docaCut = 4;
 
     bool prt = (tcc.modes[kDebug] && tcc.dbgSlc && tcc.dbgAlg[kSplitTjCVx]);
     if (prt) mf::LogVerbatim("TC") << "Inside SplitTrajCrossingVertices inCTP " << inCTP;
 
     geo::PlaneID planeID = DecodeCTP(inCTP);
 
     unsigned short nTraj = slc.tjs.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
       if (slc.tjs[itj].CTP != inCTP) continue;
       // obsolete trajectory
       if (slc.tjs[itj].AlgMod[kKilled] || slc.tjs[itj].AlgMod[kHaloTj]) continue;
       if (slc.tjs[itj].AlgMod[kJunkTj]) continue;
       if (slc.tjs[itj].AlgMod[kSplitTjCVx]) continue;
       // too short
       if (slc.tjs[itj].EndPt[1] < 6) continue;
       for (unsigned short iv = 0; iv < slc.vtxs.size(); ++iv) {
         auto& vx2 = slc.vtxs[iv];
         // obsolete vertex
         if (vx2.NTraj == 0) continue;
         // trajectory already associated with vertex
         if (slc.tjs[itj].VtxID[0] == vx2.ID || slc.tjs[itj].VtxID[1] == vx2.ID) continue;
         // not in the cryostat/tpc/plane
         if (slc.tjs[itj].CTP != vx2.CTP) continue;
         // poor quality
         if (vx2.Score < tcc.vtx2DCuts[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(slc.tjs[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(slc, vx2.Pos[0], vx2.Pos[1], slc.tjs[itj].Pts[closePt]);
         }
         if (doca > docaCut) continue;
         if (prt)
           mf::LogVerbatim("TC") << " doca " << doca << " btw T" << slc.tjs[itj].ID << " and 2V"
                                 << slc.vtxs[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(slc, 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.3;
         float tjAng = slc.tjs[itj].Pts[closePt].Ang;
         for (auto tjid : vxtjs) {
           auto& vtj = slc.tjs[tjid - 1];
           if (vtj.AlgMod[kDeltaRay]) continue;
           unsigned short npwc = NumPtsWithCharge(slc, vtj, false);
           if (npwc > maxPts) maxPts = npwc;
           unsigned short end = 0;
           if (vtj.VtxID[1] == slc.vtxs[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(slc, slc.tjs[itj], false) > maxPts && maxPts < 100) skipit = true;
         if (!skipit && maxdang < 0.3) 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("STCV", slc, 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 = slc.tjs[itj].Pts[closePt];
           if (slc.tjs[itj].StepDir > 0 && closePt > slc.tjs[itj].EndPt[0]) {
             if (closeTP.Pos[0] > vx2.Pos[0]) --closePt;
           }
           else if (slc.tjs[itj].StepDir < 0 && closePt < slc.tjs[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 ((slc.tjs[itj].Pts[closePt].Pos[0] - vx2.Pos[0]) *
                     (slc.tjs[itj].Pts[slc.tjs[itj].EndPt[1]].Pos[0] - vx2.Pos[0]) +
                   (slc.tjs[itj].Pts[closePt].Pos[1] - vx2.Pos[1]) *
                     (slc.tjs[itj].Pts[slc.tjs[itj].EndPt[1]].Pos[1] - vx2.Pos[1]) <
                 0 &&
               closePt < slc.tjs[itj].EndPt[1] - 1)
             ++closePt;
           else if ((slc.tjs[itj].Pts[closePt].Pos[0] - vx2.Pos[0]) *
                          (slc.tjs[itj].Pts[slc.tjs[itj].EndPt[0]].Pos[0] - vx2.Pos[0]) +
                        (slc.tjs[itj].Pts[closePt].Pos[1] - vx2.Pos[1]) *
                          (slc.tjs[itj].Pts[slc.tjs[itj].EndPt[0]].Pos[1] - slc.vtxs[iv].Pos[1]) <
                      0 &&
                    closePt > slc.tjs[itj].EndPt[0] + 1)
             --closePt;
         }
 
         if (prt) {
           mf::LogVerbatim("TC") << "Good doca " << doca << " btw T" << slc.tjs[itj].ID << " and 2V"
                                 << vx2.ID << " closePt " << closePt << " in plane " << planeID.Plane
                                 << " CTP " << slc.vtxs[iv].CTP;
           PrintTP("STCV", slc, closePt, 1, slc.tjs[itj].Pass, slc.tjs[itj].Pts[closePt]);
         }
         // ensure that the closest point is not near an end
         if (closePt < slc.tjs[itj].EndPt[0] + 3) continue;
         if (closePt > slc.tjs[itj].EndPt[1] - 3) continue;
         if (!SplitTraj(slc, itj, closePt, iv, prt)) {
           if (prt) mf::LogVerbatim("TC") << "SplitTrajCrossingVertices: Failed to split trajectory";
           continue;
         }
         slc.tjs[itj].AlgMod[kSplitTjCVx] = true;
         unsigned short newTjIndex = slc.tjs.size() - 1;
         slc.tjs[newTjIndex].AlgMod[kSplitTjCVx] = true;
         // re-fit the vertex position
         FitVertex(slc, vx2, prt);
       } // iv
     }   // itj
 
   } // SplitTrajCrossingVertices

bool tca::SptInTPC	(	const std::array< unsigned int, 3 > &	sptHits,
		unsigned int	tpc
	)

Definition at line 792 of file PFPUtils.cxx.

   {
     // returns true if a hit referenced in sptHits resides in the requested tpc. We assume
     // that if one does, then all of them do
 
     unsigned int ahi = UINT_MAX;
     for (auto ii : sptHits)
       if (ii != UINT_MAX) {
         ahi = ii;
         break;
       }
     if (ahi >= (*evt.allHits).size()) return false;
     // get a reference to the hit and see if it is in the desired tpc
     auto& hit = (*evt.allHits)[ahi];
     if (hit.WireID().TPC == tpc) return true;
     return false;
 
   } // SptInTPC

std::vector< float > tca::StartChgVec	(	TCSlice &	slc,
		int	cotID,
		bool	prt
	)

Definition at line 3823 of file TCShower.cxx.

   {
     // Returns a histogram vector of the charge in bins of 1 WSE unit at the start of the shower
 
     ShowerStruct& ss = slc.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 = slc.tjs[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;
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       float peakTime = hit.PeakTime();
       float amp = hit.PeakAmplitude();
       float rms = hit.RMS();
       chgPos[0] = hit.WireID().Wire - stp1.Pos[0];
       for (float time = peakTime - 2.5 * rms; time < peakTime + 2.5 * rms; ++time) {
         chgPos[1] = time * tcc.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::StartTraj	(	TCSlice &	slc,
		Trajectory &	tj,
		unsigned int	fromhit,
		unsigned int	tohit,
		unsigned short	pass
	)

Definition at line 4999 of file Utils.cxx.

   {
     // Start a trajectory located at fromHit with direction pointing to toHit
 
     auto& fromHit = (*evt.allHits)[slc.slHits[fromhit].allHitsIndex];
     auto& toHit = (*evt.allHits)[slc.slHits[tohit].allHitsIndex];
     float fromWire = fromHit.WireID().Wire;
     float fromTick = fromHit.PeakTime();
     float toWire = toHit.WireID().Wire;
     float toTick = toHit.PeakTime();
     CTP_t tCTP = EncodeCTP(fromHit.WireID());
     bool success = StartTraj(slc, tj, fromWire, fromTick, toWire, toTick, tCTP, pass);
     if (!success) return false;
     // turn on debugging using the WorkID?
     if (tcc.modes[kDebug] && !tcc.dbgStp && !tcc.dbgDump && tcc.dbgSlc && tj.ID == debug.WorkID)
       tcc.dbgStp = true;
     if (tcc.dbgStp) {
       auto& tp = tj.Pts[0];
       mf::LogVerbatim("TC") << "StartTraj T" << tj.ID << " from " << (int)fromWire << ":"
                             << (int)fromTick << " -> " << (int)toWire << ":" << (int)toTick
                             << " StepDir " << tj.StepDir << " dir " << tp.Dir[0] << " " << tp.Dir[1]
                             << " ang " << tp.Ang << " AngleCode " << tp.AngleCode << " angErr "
                             << tp.AngErr << " ExpectedHitsRMS " << ExpectedHitsRMS(slc, tp);
     } // tcc.dbgStp
     return true;
   } // StartTraj

bool tca::StartTraj	(	TCSlice &	slc,
		Trajectory &	tj,
		float	fromWire,
		float	fromTick,
		float	toWire,
		float	toTick,
		CTP_t &	tCTP,
		unsigned short	pass
	)

Definition at line 5032 of file Utils.cxx.

   {
     // Start a simple (seed) trajectory going from (fromWire, toTick) to (toWire, toTick).
 
     // decrement the work ID so we can use it for debugging problems
     --evt.WorkID;
     if (evt.WorkID == INT_MIN) evt.WorkID = -1;
     tj.ID = evt.WorkID;
     tj.Pass = pass;
     // Assume we are stepping in the positive WSE units direction
     short stepdir = 1;
     int fWire = std::nearbyint(fromWire);
     int tWire = std::nearbyint(toWire);
     if (tWire < fWire) { stepdir = -1; }
     else if (tWire == fWire) {
       // on the same wire
       if (toTick < fromTick) stepdir = -1;
     }
     tj.StepDir = stepdir;
     tj.CTP = tCTP;
     tj.ParentID = -1;
     tj.Strategy.reset();
     tj.Strategy[kNormal] = true;
 
     // create a trajectory point
     TrajPoint tp;
     if (!MakeBareTrajPoint(slc, fromWire, fromTick, toWire, toTick, tCTP, tp)) return false;
     SetAngleCode(tp);
     tp.AngErr = 0.1;
     tj.Pts.push_back(tp);
     // turn on debugging using the WorkID?
     if (tcc.modes[kDebug] && !tcc.dbgStp && !tcc.dbgDump && tcc.dbgSlc && tj.ID == debug.WorkID)
       tcc.dbgStp = true;
     if (tcc.dbgStp) {
       auto& tp = tj.Pts[0];
       mf::LogVerbatim("TC") << "StartTraj T" << tj.ID << " from " << (int)fromWire << ":"
                             << (int)fromTick << " -> " << (int)toWire << ":" << (int)toTick
                             << " StepDir " << tj.StepDir << " dir " << tp.Dir[0] << " " << tp.Dir[1]
                             << " ang " << tp.Ang << " AngleCode " << tp.AngleCode << " angErr "
                             << tp.AngErr << " ExpectedHitsRMS " << ExpectedHitsRMS(slc, tp);
     } // tcc.dbgStp
     return true;
 
   } // StartTraj

void tca::StepAway	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 28 of file StepUtils.cxx.

   {
     // Step along the direction specified in the traj vector in steps of size step
     // (wire spacing equivalents). Find hits between the last trajectory point and
     // the last trajectory point + step. A new trajectory point is added if hits are
     // found. Stepping continues until no signal is found for two consecutive steps
     // or until a wire or time boundary is reached.
 
     tj.IsGood = false;
     if(tj.Pts.empty()) return;
 
     unsigned short plane = DecodeCTP(tj.CTP).Plane;
 
     unsigned short lastPtWithUsedHits = tj.EndPt[1];
 
     unsigned short lastPt = lastPtWithUsedHits;
     // Construct a local TP from the last TP that will be moved on each step.
     // Only the Pos and Dir variables will be used
     TrajPoint ltp;
     ltp.CTP = tj.CTP;
     ltp.Pos = tj.Pts[lastPt].Pos;
     ltp.Dir = tj.Pts[lastPt].Dir;
     // A second TP is cloned from the leading TP of tj, updated with hits, fit
     // parameters,etc and possibly pushed onto tj as the next TP
     TrajPoint tp;
 
     // assume it is good from here on
     tj.IsGood = true;
 
     unsigned short nMissedSteps = 0;
     // Use MaxChi chisq cut for stiff trajectories
     bool useMaxChiCut = (tj.PDGCode == 13 || !tj.Strategy[kSlowing]);
 
     // Get the first forecast when there are 6 points with charge
     tjfs.resize(1);
     tjfs[0].nextForecastUpdate = 6;
 
     for(unsigned short step = 1; step < 10000; ++step) {
       unsigned short npwc = NumPtsWithCharge(slc, tj, false);
       // analyze the Tj when there are 6 points to see if we should stop
       if(npwc == 6 && StopShort(slc, tj, tcc.dbgStp)) break;
       // Get a forecast of what is ahead.
       if(tcc.doForecast && !tj.AlgMod[kRvPrp] && npwc == tjfs[tjfs.size() - 1].nextForecastUpdate) {
         Forecast(slc, tj);
         SetStrategy(slc, tj);
         SetPDGCode(slc, tj);
       }
       // make a copy of the previous TP
       lastPt = tj.Pts.size() - 1;
       tp = tj.Pts[lastPt];
       ++tp.Step;
       double stepSize = tcc.VLAStepSize;
       if(tp.AngleCode < 2) stepSize = std::abs(1/ltp.Dir[0]);
       // 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;
       // copy this position into tp
       tp.Pos = ltp.Pos;
       tp.Dir = ltp.Dir;
       if(tcc.dbgStp) {
         mf::LogVerbatim myprt("TC");
         myprt<<"StepAway "<<step<<" Pos "<<tp.Pos[0]<<" "<<tp.Pos[1]<<" Dir "<<tp.Dir[0]<<" "<<tp.Dir[1]<<" stepSize "<<stepSize<<" AngCode "<<tp.AngleCode<<" Strategy";
         for(unsigned short ibt = 0; ibt < StrategyBitNames.size(); ++ibt) {
           if(tj.Strategy[ibt]) myprt<<" "<<StrategyBitNames[ibt];
         } // ib
       } // tcc.dbgStp
       // hit the boundary of the TPC?
       if(tp.Pos[0] < 0 || tp.Pos[0] > tcc.maxPos0[plane] ||
          tp.Pos[1] < 0 || tp.Pos[1] > tcc.maxPos1[plane]) break;
       // remove the old hits and other stuff
       tp.Hits.clear();
       tp.UseHit.reset();
       tp.FitChi = 0; tp.Chg = 0;
       tp.Environment.reset();
       unsigned int wire = std::nearbyint(tp.Pos[0]);
       if(!evt.goodWire[plane][wire]) tp.Environment[kEnvNotGoodWire] = true;
       // append to the trajectory
       tj.Pts.push_back(tp);
       // update the index of the last TP
       lastPt = tj.Pts.size() - 1;
       // look for hits
       bool sigOK = false;
       AddHits(slc, tj, lastPt, sigOK);
       // Check the stop flag
       if(tj.EndFlag[1][kAtTj]) break;
       // If successfull, AddHits has defined UseHit for this TP,
       // set the trajectory endpoints, and define HitPos.
       if(tj.Pts[lastPt].Hits.empty() && !tj.Pts[lastPt].Environment[kEnvNearSrcHit]) {
         // Require three points with charge on adjacent wires for small angle
         // stepping.
         if(tj.Pts[lastPt].AngleCode == 0 && lastPt == 2) return;
         // No close hits added.
         ++nMissedSteps;
         // First check for no signal in the vicinity. AddHits checks the hit collection for
         // the current slice. This version of SignalAtTp checks the allHits collection.
         sigOK = SignalAtTp(ltp);
         if(lastPt > 0) {
           // break if this is a reverse propagate activity and there was no signal (not on a dead wire)
           if(!sigOK && tj.AlgMod[kRvPrp]) break;
           // Ensure that there is a signal here after missing a number of steps on a LA trajectory
           if(tj.Pts[lastPt].AngleCode > 0 && nMissedSteps > 4 && !sigOK) break;
           // the last point with hits (used or not) is the previous point
           unsigned short lastPtWithHits = lastPt - 1;
           float tps = TrajPointSeparation(tj.Pts[lastPtWithHits], ltp);
           float dwc = DeadWireCount(slc, ltp, tj.Pts[lastPtWithHits]);
           float nMissedWires = tps * std::abs(ltp.Dir[0]) - dwc;
           float maxWireSkip = tcc.maxWireSkipNoSignal;
           if(sigOK) maxWireSkip = tcc.maxWireSkipWithSignal;
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<" StepAway: no hits found at ltp "<<PrintPos(slc, ltp)
               <<" nMissedWires "<<std::fixed<<std::setprecision(1)<<nMissedWires
               <<" dead wire count "<<dwc<<" maxWireSkip "<<maxWireSkip<<" tj.PDGCode "<<tj.PDGCode;
           if(nMissedWires > maxWireSkip) {
             // We passed a number of wires without adding hits and are ready to quit.
             // First see if there is one good unused hit on the end TP and if so use it
             // lastPtWithHits + 1 == lastPt && tj.Pts[lastPtWithHits].Chg == 0 && tj.Pts[lastPtWithHits].Hits.size() == 1
             if(tj.EndPt[1] < tj.Pts.size() - 1 && tj.Pts[tj.EndPt[1]+1].Hits.size() == 1) {
               unsigned short lastLonelyPoint = tj.EndPt[1] + 1;
               unsigned int iht = tj.Pts[lastLonelyPoint].Hits[0];
               if(slc.slHits[iht].InTraj == 0 && tj.Pts[lastLonelyPoint].Delta < 3 * tj.Pts[lastLonelyPoint].DeltaRMS) {
                 slc.slHits[iht].InTraj = tj.ID;
                 tj.Pts[lastLonelyPoint].UseHit[0] = true;
                 DefineHitPos(slc, tj.Pts[lastLonelyPoint]);
                 SetEndPoints(tj);
                 if(tcc.dbgStp) {
                   mf::LogVerbatim("TC")<<" Added a Last Lonely Hit before breaking ";
                   PrintTP("LLH", slc, lastPt, tj.StepDir, tj.Pass, tj.Pts[lastLonelyPoint]);
                 }
               }
             }
             break;
           }
         } // lastPt > 0
         // no sense keeping this TP on tj if no hits were added
         tj.Pts.pop_back();
         continue;
       } // tj.Pts[lastPt].Hits.empty()
       // ensure that we actually moved
       if(lastPt > 0 && PosSep2(tj.Pts[lastPt].Pos, tj.Pts[lastPt-1].Pos) < 0.1) return;
       // Found hits at this location so reset the missed steps counter
       nMissedSteps = 0;
       // Update the last point fit, etc using the just added hit(s)
       UpdateTraj(slc, tj);
       // a failure occurred
       if(tj.NeedsUpdate) return;
       if(tj.Pts[lastPt].Chg == 0) {
         // There are points on the trajectory by none used in the last step. See
         // how long this has been going on
         float tps = TrajPointSeparation(tj.Pts[tj.EndPt[1]], ltp);
         float dwc = DeadWireCount(slc, ltp, tj.Pts[tj.EndPt[1]]);
         float nMissedWires = tps * std::abs(ltp.Dir[0]) - dwc;
         if(tcc.dbgStp)  mf::LogVerbatim("TC")<<" Hits exist on the trajectory but are not used. Missed wires "<<std::nearbyint(nMissedWires)<<" dead wire count "<<(int)dwc;
         // break if this is a reverse propagate activity with no dead wires
         if(tj.AlgMod[kRvPrp] && dwc == 0) break;
         if(nMissedWires > tcc.maxWireSkipWithSignal) break;
         // try this out
         if(!MaskedHitsOK(slc, tj)) {
           return;
         }
         // check for a series of bad fits and stop stepping
         if(tcc.useAlg[kStopBadFits] && nMissedWires > 4 && StopIfBadFits(slc, tj)) break;
         // Keep stepping
         if(tcc.dbgStp) {
           if(tj.AlgMod[kRvPrp]) {
             PrintTrajectory("RP", slc, tj, lastPt);
           } else {
             PrintTrajectory("SC", slc, tj, lastPt);
           }
         }
         continue;
       } // tp.Hits.empty()
       if(tj.Pts.size() == 3) {
         // ensure that the last hit added is in the same direction as the first two.
         // This is a simple way of doing it
         bool badTj = (PosSep2(tj.Pts[0].HitPos, tj.Pts[2].HitPos) < PosSep2(tj.Pts[0].HitPos, tj.Pts[1].HitPos));
         // ensure that this didn't start as a small angle trajectory and immediately turn
         // into a large angle one
         if(!badTj && tj.Pts[lastPt].AngleCode > tcc.maxAngleCode[tj.Pass]) badTj = true;
         // check for a large change in angle
         if(!badTj) {
           float dang = DeltaAngle(tj.Pts[0].Ang, tj.Pts[2].Ang);
           if(dang > 0.5) badTj = false;
         }
         //check for a wacky delta
         if(!badTj && tj.Pts[2].Delta > 2) badTj = true;
         if(badTj) {
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Bad Tj found on the third point. Quit stepping.";
           tj.IsGood = false;
           return;
         }
       } // tj.Pts.size() == 3
       // Update the local TP with the updated position and direction
       ltp.Pos = tj.Pts[lastPt].Pos;
       ltp.Dir = tj.Pts[lastPt].Dir;
       if(tj.MaskedLastTP) {
         // see if TPs have been masked off many times and if the
         // environment is clean. If so, return and try with next pass
         // cuts
         if(!MaskedHitsOK(slc, tj)) {
           if(tcc.dbgStp) {
             if(tj.AlgMod[kRvPrp]) {
               PrintTrajectory("RP", slc, tj, lastPt);
             } else {
               PrintTrajectory("SC", slc, tj, lastPt);
             }
           }
           return;
         }
         if(tcc.dbgStp) {
           if(tj.AlgMod[kRvPrp]) {
             PrintTrajectory("RP", slc, tj, lastPt);
           } else {
             PrintTrajectory("SC", slc, tj, lastPt);
           }
         }
         continue;
       }
       // We have added a TP with hits
       // check for a kink. Stop crawling if one is found
       GottaKink(slc, tj, true);
       if(tj.EndFlag[1][kAtKink]) {
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"   stop at kink";
         break;
       }
       // See if the Chisq/DOF exceeds the maximum.
       // UpdateTraj should have reduced the number of points fit
       // as much as possible for this pass, so this trajectory is in trouble.
       if(tj.Pts[lastPt].FitChi > tcc.maxChi && useMaxChiCut) {
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"   bad FitChi "<<tj.Pts[lastPt].FitChi<<" cut "<<tcc.maxChi;
         // remove the last point before quitting
         UnsetUsedHits(slc, tj.Pts[lastPt]);
         SetEndPoints(tj);
         tj.IsGood = (NumPtsWithCharge(slc, tj, true) > tcc.minPtsFit[tj.Pass]);
         break;
       }
       if(tcc.dbgStp) {
         if(tj.AlgMod[kRvPrp]) {
           PrintTrajectory("RP", slc, tj, lastPt);
         } else {
           PrintTrajectory("SC", slc, tj, lastPt);
         }
       } // tcc.dbgStp
     } // step
 
     SetPDGCode(slc, tj);
 
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"End StepAway with tj size "<<tj.Pts.size();
 
   } // StepAway

void tca::StitchPFPs ( )

Definition at line 41 of file PFPUtils.cxx.

   {
     // Stitch PFParticles in different TPCs. This does serious damage to PFPStruct and should
     // only be called from TrajCluster module just before making PFParticles to put in the event
     if (slices.size() < 2) return;
     if (tcc.geom->NTPC() == 1) return;
     if (tcc.pfpStitchCuts.size() < 2) return;
     if (tcc.pfpStitchCuts[0] <= 0) return;
 
     bool prt = tcc.dbgStitch;
 
     if (prt) {
       mf::LogVerbatim myprt("TC");
       std::string fcnLabel = "SP";
       myprt << fcnLabel << " cuts " << sqrt(tcc.pfpStitchCuts[0]) << " " << tcc.pfpStitchCuts[1]
             << "\n";
       bool printHeader = true;
       for (size_t isl = 0; isl < slices.size(); ++isl) {
         if (debug.Slice >= 0 && int(isl) != debug.Slice) continue;
         auto& slc = slices[isl];
         if (slc.pfps.empty()) continue;
         for (auto& pfp : slc.pfps)
           PrintP(fcnLabel, myprt, pfp, printHeader);
       } // slc
     }   // prt
 
     // lists of pfp UIDs to stitch
     std::vector<std::vector<int>> stLists;
     for (std::size_t sl1 = 0; sl1 < slices.size() - 1; ++sl1) {
       auto& slc1 = slices[sl1];
       for (std::size_t sl2 = sl1 + 1; sl2 < slices.size(); ++sl2) {
         auto& slc2 = slices[sl2];
         // look for PFParticles in the same recob::Slice
         if (slc1.ID != slc2.ID) continue;
         for (auto& p1 : slc1.pfps) {
           if (p1.ID <= 0) continue;
           // Can't stitch shower PFPs
           if (p1.PDGCode == 1111) continue;
           for (auto& p2 : slc2.pfps) {
             if (p2.ID <= 0) continue;
             // Can't stitch shower PFPs
             if (p2.PDGCode == 1111) continue;
             float maxSep2 = tcc.pfpStitchCuts[0];
             float maxCth = tcc.pfpStitchCuts[1];
             bool gotit = false;
             for (unsigned short e1 = 0; e1 < 2; ++e1) {
               auto pos1 = PosAtEnd(p1, e1);
               // require the end to be close to a TPC boundary
               if (InsideFV(slc1, p1, e1)) continue;
               auto dir1 = DirAtEnd(p1, e1);
               for (unsigned short e2 = 0; e2 < 2; ++e2) {
                 auto pos2 = PosAtEnd(p2, e2);
                 // require the end to be close to a TPC boundary
                 if (InsideFV(slc2, p2, e2)) continue;
                 auto dir2 = DirAtEnd(p2, e2);
                 float sep = PosSep2(pos1, pos2);
                 if (sep > maxSep2) continue;
                 float cth = std::abs(DotProd(dir1, dir2));
                 if (cth < maxCth) continue;
                 maxSep2 = sep;
                 maxCth = cth;
                 gotit = true;
               } // e2
             }   // e1
             if (!gotit) continue;
             if (prt) {
               mf::LogVerbatim myprt("TC");
               myprt << "Stitch slice " << slc1.ID << " P" << p1.UID << " TPC " << p1.TPCID.TPC;
               myprt << " and P" << p2.UID << " TPC " << p2.TPCID.TPC;
               myprt << " sep " << sqrt(maxSep2) << " maxCth " << maxCth;
             }
             // see if either of these are in a list
             bool added = false;
             for (auto& pm : stLists) {
               bool p1InList = (std::find(pm.begin(), pm.end(), p1.UID) != pm.end());
               bool p2InList = (std::find(pm.begin(), pm.end(), p2.UID) != pm.end());
               if (p1InList || p2InList) {
                 if (p1InList) pm.push_back(p2.UID);
                 if (p2InList) pm.push_back(p1.UID);
                 added = true;
               }
             } // pm
             if (added) continue;
             // start a new list
             std::vector<int> tmp(2);
             tmp[0] = p1.UID;
             tmp[1] = p2.UID;
             stLists.push_back(tmp);
             break;
           } // p2
         }   // p1
       }     // sl2
     }       // sl1
     if (stLists.empty()) return;
 
     for (auto& stl : stLists) {
       // Find the endpoints of the stitched pfp
       float minZ = 1E6;
       std::pair<unsigned short, unsigned short> minZIndx;
       unsigned short minZEnd = 2;
       for (auto puid : stl) {
         auto slcIndex = GetSliceIndex("P", puid);
         if (slcIndex.first == USHRT_MAX) continue;
         auto& pfp = slices[slcIndex.first].pfps[slcIndex.second];
         for (unsigned short end = 0; end < 2; ++end) {
           auto pos = PosAtEnd(pfp, end);
           if (pos[2] < minZ) {
             minZ = pos[2];
             minZIndx = slcIndex;
             minZEnd = end;
           }
         } // end
       }   // puid
       if (minZEnd > 1) continue;
       // preserve the pfp with the min Z position
       auto& pfp = slices[minZIndx.first].pfps[minZIndx.second];
       if (prt) mf::LogVerbatim("TC") << "SP: P" << pfp.UID;
       // add the Tjs in the other slices to it
       for (auto puid : stl) {
         if (puid == pfp.UID) continue;
         auto sIndx = GetSliceIndex("P", puid);
         if (sIndx.first == USHRT_MAX) continue;
         auto& opfp = slices[sIndx.first].pfps[sIndx.second];
         if (prt) mf::LogVerbatim("TC") << " +P" << opfp.UID;
         pfp.TjUIDs.insert(pfp.TjUIDs.end(), opfp.TjUIDs.begin(), opfp.TjUIDs.end());
         if (prt) mf::LogVerbatim();
         // Check for parents and daughters
         if (opfp.ParentUID > 0) {
           auto pSlcIndx = GetSliceIndex("P", opfp.ParentUID);
           if (pSlcIndx.first < slices.size()) {
             auto& parpfp = slices[pSlcIndx.first].pfps[pSlcIndx.second];
             std::replace(parpfp.DtrUIDs.begin(), parpfp.DtrUIDs.begin(), opfp.UID, pfp.UID);
           } // valid pSlcIndx
         }   // has a parent
         for (auto dtruid : opfp.DtrUIDs) {
           auto dSlcIndx = GetSliceIndex("P", dtruid);
           if (dSlcIndx.first < slices.size()) {
             auto& dtrpfp = slices[dSlcIndx.first].pfps[dSlcIndx.second];
             dtrpfp.ParentUID = pfp.UID;
           } // valid dSlcIndx
         }   // dtruid
         // declare it obsolete
         opfp.ID = 0;
       } // puid
     }   // stl
 
   } // StitchPFPs

bool tca::StopIfBadFits	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 2527 of file StepUtils.cxx.

   {
     // Returns true if there are a number of Tps that were not used in the trajectory because the fit was poor and the
     // charge pull is not really high. This
 
     // don't consider muons
     if(tj.PDGCode == 13) return false;
     // or long straight Tjs
     if(tj.Pts.size() > 40 && tj.MCSMom > 200) return false;
 
     unsigned short nBadFit = 0;
     unsigned short nHiChg = 0;
     unsigned short cnt = 0;
     for(unsigned short ipt = tj.Pts.size() - 1; ipt > tj.EndPt[1]; --ipt ) {
       if(tj.Pts[ipt].FitChi > 2) ++nBadFit;
       if(tj.Pts[ipt].ChgPull > 3) ++nHiChg;
       ++cnt;
       if(cnt == 5) break;
     } // ipt
 
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"StopIfBadFits: nBadFit "<<nBadFit<<" nHiChg "<<nHiChg;
     if(nBadFit > 3 && nHiChg == 0) return true;
     return false;
 
   } // StopIfBadFits

bool tca::StopShort	(	TCSlice &	slc,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 277 of file StepUtils.cxx.

   {
     // Analyze the trajectory when it is short (~6 points) to look for a pattern like
     // this QQQqqq, where Q is a large charge hit and q is a low charge hit. If this
     // pattern is found, this function removes the last 3 points and returns true.
     // The calling function (e.g. StepAway) should decide what to do (e.g. stop stepping)
 
     // don't use this function during reverse propagation
     if(tj.AlgMod[kRvPrp]) return false;
     if(!tcc.useAlg[kStopShort]) return false;
 
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
     if(npwc > 10) return false;
     ParFit chgFit;
     FitPar(slc, tj, tj.EndPt[0], npwc, 1, chgFit, 1);
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"StopShort: chgFit at "<<PrintPos(slc, tj.Pts[tj.EndPt[0]]);
       myprt<<" ChiDOF "<<chgFit.ChiDOF;
       myprt<<" chg0 "<<chgFit.Par0<<" +/- "<<chgFit.ParErr;
       myprt<<" slp "<<chgFit.ParSlp<<" +/- "<<chgFit.ParSlpErr;
     } // prt
     // Look for a poor charge fit ChiDOF and a significant negative slope. These cuts
     // **should** prevent removing a genuine Bragg peak at the start, which should have
     // a good ChiDOF
     if(chgFit.ChiDOF < 2) return false;
     if(chgFit.ParSlp > -20) return false;
     if(prt) PrintTrajectory("SS", slc, tj, USHRT_MAX);
     // Find the average charge using the first 3 points
     float cnt = 0;
     float aveChg = 0;
     unsigned short lastHiPt = 0;
     for(unsigned short ipt = 0; ipt < tj.Pts.size(); ++ipt) {
       auto& tp = tj.Pts[ipt];
       if(tp.Chg <= 0) continue;
       aveChg += tp.Chg;
       ++cnt;
       lastHiPt = ipt;
       if(cnt == 3) break;
     } // tp
     if(cnt < 3) return false;
     aveChg /= cnt;
     if(prt) mf::LogVerbatim("TC")<<"  aveChg "<<(int)aveChg<<" last TP AveChg "<<(int)tj.Pts[tj.EndPt[1]].AveChg;
     // Look for a sudden drop in the charge (< 1/2)
     unsigned short firstLoPt = lastHiPt + 1;
     for(unsigned short ipt = lastHiPt + 1; ipt < tj.Pts.size(); ++ipt) {
       auto& tp = tj.Pts[ipt];
       if(tp.Chg <= 0 || tp.Chg > 0.5 * aveChg) continue;
       firstLoPt = ipt;
       break;
     } // ipt
     if(prt) mf::LogVerbatim("TC")<<"    stop tracking at "<<PrintPos(slc, tj.Pts[firstLoPt]);
     // Remove everything from the firstLoPt to the end of the trajectory
     for(unsigned short ipt = firstLoPt; ipt <= tj.EndPt[1]; ++ipt) UnsetUsedHits(slc, tj.Pts[ipt]);
     SetEndPoints(tj);
     UpdateTjChgProperties("SS", slc, tj, prt);
     tj.AlgMod[kStopShort] = true;
     return true;
   } // StopShort

bool tca::StorePFP	(	TCSlice &	slc,
		PFPStruct &	pfp
	)

Definition at line 3003 of file PFPUtils.cxx.

   {
     // stores the PFParticle in the slice
     bool neutrinoPFP = (pfp.PDGCode == 12 || pfp.PDGCode == 14);
     if (!neutrinoPFP) {
       if (pfp.TjIDs.empty()) return false;
       if (pfp.PDGCode != 1111 && pfp.TP3Ds.size() < 2) return false;
     }
 
     if(pfp.Flags[kSmallAngle]) {
       // Make the PFP -> TP assn
       for(auto& tp3d : pfp.TP3Ds) {
         if(tp3d.TPIndex != USHRT_MAX) slc.tjs[tp3d.TjID - 1].Pts[tp3d.TPIndex].InPFP = pfp.ID;
       }
     }
 
     // ensure that the InPFP flag is set
     unsigned short nNotSet = 0;
     for (auto& tp3d : pfp.TP3Ds) {
       if (tp3d.Flags[kTP3DBad]) continue;
       auto& tp = slc.tjs[tp3d.TjID - 1].Pts[tp3d.TPIndex];
       if (tp.InPFP != pfp.ID) ++nNotSet;
     } // tp3d
     if (nNotSet > 0) return false;
     // check the ID and correct it if it is wrong
     if (pfp.ID != (int)slc.pfps.size() + 1) pfp.ID = slc.pfps.size() + 1;
     ++evt.globalP_UID;
     pfp.UID = evt.globalP_UID;
 
     // set the 3D match flag
     for (auto tjid : pfp.TjIDs) {
       auto& tj = slc.tjs[tjid - 1];
       tj.AlgMod[kMat3D] = true;
     } // tjid
 
     slc.pfps.push_back(pfp);
     return true;
   } // StorePFP

bool tca::StoreShower	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct3D &	ss3
	)

Definition at line 3989 of file TCShower.cxx.

   {
     // 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 : slc.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)slc.cots.size()) return false;
       auto& ss = slc.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)
       slc.cots[cid - 1].SS3ID = ss3.ID;
 
     ++evt.global3S_UID;
     ss3.UID = evt.global3S_UID;
 
     slc.showers.push_back(ss3);
     return true;
 
   } // StoreShower

bool tca::StoreShower	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct &	ss
	)

Definition at line 4040 of file TCShower.cxx.

   {
     // Store a ShowerStruct
     std::string fcnLabel = inFcnLabel + ".S2S";
     if (ss.ID <= 0) {
       std::cout << fcnLabel << " Invalid ID";
       return false;
     }
     if (ss.TjIDs.empty()) {
       std::cout << fcnLabel << " Fail: No TjIDs in 2S" << ss.ID << "\n";
       return false;
     }
     if (ss.ParentID > 0) {
       if (ss.ParentID > (int)slc.tjs.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)slc.cots.size() + 1) {
       std::cout << fcnLabel << " Correcting the ID 2S" << ss.ID << " -> 2S" << slc.cots.size() + 1;
       ss.ID = slc.cots.size() + 1;
     }
 
     // set the tj shower bits
     for (auto& tjID : ss.TjIDs) {
       Trajectory& tj = slc.tjs[tjID - 1];
       tj.SSID = ss.ID;
       tj.AlgMod[kShwrParent] = false;
       if (tj.ID == ss.ParentID) tj.AlgMod[kShwrParent] = true;
     } // tjID
 
     ++evt.global2S_UID;
     ss.UID = evt.global2S_UID;
 
     slc.cots.push_back(ss);
     return true;
 
   } // StoreShower

bool tca::StoreTraj	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 1087 of file Utils.cxx.

   {
 
     // check for errors
     for (auto& tp : tj.Pts) {
       if (tp.Hits.size() > 16) return false;
     } // tp
 
     if (tj.NeedsUpdate) UpdateTjChgProperties("ST", slc, tj, false);
 
     // This shouldn't be necessary but do it anyway
     SetEndPoints(tj);
 
     if (slc.tjs.size() >= USHRT_MAX || tj.EndPt[1] <= tj.EndPt[0] || tj.EndPt[1] > tj.Pts.size()) {
       ReleaseHits(slc, tj);
       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]];
 
     // ensure that angle errors are defined at both ends, ignoring junk Tjs
     if (!tj.AlgMod[kJunkTj]) {
       if (endTp0.AngErr == 0.1 && endTp1.AngErr != 0.1) { endTp0.AngErr = endTp1.AngErr; }
       else if (endTp0.AngErr != 0.1 && endTp1.AngErr == 0.1) {
         endTp1.AngErr = endTp0.AngErr;
       }
     } // not a junk Tj
 
     // 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
 
     // update the kink significance
     if (!tj.AlgMod[kJunkTj]) {
       unsigned short nPtsFit = tcc.kinkCuts[0];
       bool useChg = (tcc.kinkCuts[2] > 0);
       if (npts > 2 * nPtsFit) {
         for (unsigned short ipt = tj.EndPt[0] + nPtsFit; ipt < tj.EndPt[1] - nPtsFit; ++ipt) {
           auto& tp = tj.Pts[ipt];
           if (tp.KinkSig < 0) tp.KinkSig = KinkSignificance(slc, tj, ipt, nPtsFit, useChg, false);
         }
       } // long trajectory
     }   // not JunkTj
 
     UpdateTjChgProperties("ST", slc, tj, false);
 
     int trID = slc.tjs.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 (iht > slc.slHits.size() - 1) {
             ReleaseHits(slc, tj);
             return false;
           }
           if (slc.slHits[iht].InTraj > 0) {
             ReleaseHits(slc, tj);
             return false;
           } // error
           slc.slHits[iht].InTraj = trID;
         }
       } // ii
     }   // ipt
 
     // ensure that inTraj is clean for the ID
     for (unsigned int iht = 0; iht < slc.slHits.size(); ++iht) {
       if (slc.slHits[iht].InTraj == tj.ID) {
         mf::LogWarning("TC") << "StoreTraj: Hit " << PrintHit(slc.slHits[iht])
                              << " thinks it belongs to T" << tj.ID << " but it isn't in the Tj\n";
         return false;
       }
     } // iht
 
     tj.WorkID = tj.ID;
     tj.ID = trID;
     // increment the global ID
     ++evt.globalT_UID;
     tj.UID = evt.globalT_UID;
     // Don't clobber the ParentID if it was defined by the calling function
     if (tj.ParentID == 0) tj.ParentID = trID;
     slc.tjs.push_back(tj);
     if (tcc.modes[kDebug] && tcc.dbgSlc && debug.Hit != UINT_MAX) {
       // print 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 (slc.slHits[iht].allHitsIndex == 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	(	TCSlice &	slc,
		VtxStore &	vx
	)

Definition at line 1932 of file TCVertex.cxx.

   {
     // 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(slc.vtxs.size() + 1)) return false;
 
     ++evt.global2V_UID;
     vx.UID = evt.global2V_UID;
 
     unsigned short nvxtj = 0;
     unsigned short nok = 0;
     for (auto& tj : slc.tjs) {
       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 : slc.tjs) {
         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;
     slc.vtxs.push_back(vx);
     return true;
   } // StoreVertex

void tca::TagJunkTj	(	TCSlice &	slc,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 2780 of file Utils.cxx.

   {
     // 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;
     if (tj.PDGCode == 111) 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::TagShowerLike	(	std::string	inFcnLabel,
		TCSlice &	slc,
		const CTP_t &	inCTP
	)

Definition at line 3274 of file TCShower.cxx.

   {
     // Tag Tjs as InShower if they have MCSMom < ShowerTag[1] and there are more than
     // ShowerTag[6] other Tjs with a separation < ShowerTag[2].
 
     if (tcc.showerTag[0] <= 0) return;
     if (slc.tjs.size() > 20000) return;
     float typicalChgRMS = 0.5 * (tcc.chargeCuts[1] + tcc.chargeCuts[2]);
 
     bool prt = (tcc.dbgSlc && tcc.dbg2S && inCTP == debug.CTP);
 
     // 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 : slc.tjs) {
       if (tj.CTP != inCTP) continue;
       if (tj.AlgMod[kKilled]) continue;
       if (tj.AlgMod[kHaloTj]) 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.EndFlag[end][kBragg]) skipit = true;
       if (skipit) continue;
       short npwc = NumPtsWithCharge(slc, 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;
       // 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 = tcc.showerTag[1];
         if (tj.ChgRMS > typicalChgRMS) momCut *= tj.ChgRMS / typicalChgRMS;
         if (tj.MCSMom > momCut) continue;
       }
       tjids.push_back(tj.ID);
     } // tj
 
     if (tjids.size() < 2) return;
 
     for (unsigned short it1 = 0; it1 < tjids.size() - 1; ++it1) {
       Trajectory& tj1 = slc.tjs[tjids[it1] - 1];
       for (unsigned short it2 = it1 + 1; it2 < tjids.size(); ++it2) {
         Trajectory& tj2 = slc.tjs[tjids[it2] - 1];
         unsigned short ipt1, ipt2;
         float doca = tcc.showerTag[2];
         // Find the separation between Tjs without considering dead wires
         TrajTrajDOCA(slc, tj1, tj2, ipt1, ipt2, doca, false);
         if (doca == tcc.showerTag[2]) continue;
         // make tighter cuts for user-defined short Tjs
         // 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
     for (auto& tjl : tjLists) {
       // ignore small clusters
       if (tjl.size() < 3) continue;
       for (auto& tjID : tjl) {
         auto& tj = slc.tjs[tjID - 1];
         tj.AlgMod[kShowerLike] = true;
       } // tjid
     }   // tjl
 
     if (prt) {
       unsigned short nsh = 0;
       for (auto& tjl : tjLists) {
         for (auto& tjID : tjl) {
           auto& tj = slc.tjs[tjID - 1];
           if (tj.AlgMod[kShowerLike]) ++nsh;
         } // tjid
       }   // tjl
       mf::LogVerbatim("TC") << "TagShowerLike tagged " << nsh << " Tjs vertices in CTP " << inCTP;
     } // prt
   }   // TagShowerLike

bool tca::TCIntersectionPoint	(	unsigned int	wir1,
		unsigned int	wir2,
		unsigned int	pln1,
		unsigned int	pln2,
		float &	y,
		float &	z
	)

Definition at line 668 of file PFPUtils.cxx.

   {
     // A TrajCluster analog of geometry IntersectionPoint that uses local wireIntersections with
     // float precision. The (y,z) position is only used to match TPs between planes - not for 3D fitting
     if (evt.wireIntersections.empty()) return false;
     if (pln1 == pln2) return false;
 
     if (pln1 > pln2) {
       std::swap(pln1, pln2);
       std::swap(wir1, wir2);
     }
 
     for (auto& wi : evt.wireIntersections) {
       if (wi.pln1 != pln1) continue;
       if (wi.pln2 != pln2) continue;
       // estimate the position using the wire differences
       double dw1 = wir1 - wi.wir1;
       double dw2 = wir2 - wi.wir2;
       y = (float)(wi.y + dw1 * wi.dydw1 + dw2 * wi.dydw2);
       z = (float)(wi.z + dw1 * wi.dzdw1 + dw2 * wi.dzdw2);
       return true;
     } // wi
     return false;
   } // TCIntersectionPoint

void tca::TjDeltaRMS	(	const TCSlice &	slc,
		const Trajectory &	tj,
		unsigned short	firstPt,
		unsigned short	lastPt,
		double &	rms,
		unsigned short &	cnt
	)

Definition at line 3582 of file Utils.cxx.

   {
     // 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(slc, tj, firstPt);
     lastPt = NearestPtWithChg(slc, 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(slc, 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;
       // ignore points with large error
       if (tj.Pts[ipt].HitPosErr2 > 4) continue;
       dsum += PointTrajDOCA2(slc, tj.Pts[ipt].HitPos[0], tj.Pts[ipt].HitPos[1], tmp);
       ++cnt;
     } // ipt
     if (cnt < 2) return;
     rms = sqrt(dsum / (double)cnt);
 
   } // TjDeltaRMS

std::string tca::TPEnvString ( const TrajPoint & tp )

Definition at line 6351 of file Utils.cxx.

   {
     // Print environment bits in human-readable format
     std::string str = "";
     for (unsigned short ib = 0; ib < 8; ++ib) {
       // There aren't any bit names for Environment_t
       if (!tp.Environment[ib]) continue;
       if (ib == kEnvNotGoodWire) str += " NoGdwire";
       if (ib == kEnvNearMuon) str += " NearMuon";
       if (ib == kEnvNearShower) str += " NearShower";
       if (ib == kEnvOverlap) str += " Overlap";
       if (ib == kEnvUnusedHits) str += " UnusedHits";
       if (ib == kEnvNearSrcHit) str += " NearSrcHit";
       if (ib == kEnvFlag) str += " Flag";
     } // ib
     return str;
   } // TPEnvironment

float tca::TPHitsRMSTick	(	const TCSlice &	slc,
		const TrajPoint &	tp,
		HitStatus_t	hitRequest
	)

Definition at line 4207 of file Utils.cxx.

   {
     // Estimate the RMS of all hits associated with a trajectory point
     // without a lot of calculation. Note that this returns a value that is
     // closer to a FWHM, not the RMS
     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];
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       float cv = hit.PeakTime();
       float rms = hit.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	(	const TCSlice &	slc,
		const TrajPoint &	tp,
		HitStatus_t	hitRequest
	)

Definition at line 4200 of file Utils.cxx.

   {
     return tcc.unitsPerTick * TPHitsRMSTick(slc, tp, hitRequest);
   } // TPHitsRMSTime

unsigned short tca::TPNearVertex	(	const TCSlice &	slc,
		const TrajPoint &	tp
	)

Definition at line 1582 of file TCVertex.cxx.

   {
     // Returns the index of a vertex if tp is nearby
     for (unsigned short ivx = 0; ivx < slc.vtxs.size(); ++ivx) {
       if (slc.vtxs[ivx].ID == 0) continue;
       if (slc.vtxs[ivx].CTP != tp.CTP) continue;
       if (std::abs(slc.vtxs[ivx].Pos[0] - tp.Pos[0]) > 1.2) continue;
       if (std::abs(slc.vtxs[ivx].Pos[1] - tp.Pos[1]) > 1.2) continue;
       return ivx;
     } // ivx
     return USHRT_MAX;
   } // TPNearVertex

float tca::TpSumHitChg	(	const TCSlice &	slc,
		TrajPoint const &	tp
	)

Definition at line 2102 of file Utils.cxx.

   {
     float totchg = 0;
     for (size_t i = 0; i < tp.Hits.size(); ++i) {
       if (!tp.UseHit[i]) continue;
       totchg += (*evt.allHits)[slc.slHits[tp.Hits[i]].allHitsIndex].Integral();
     }
     return totchg;
   } // TpSumHitChg

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

Definition at line 2688 of file Utils.cxx.

   {
     // 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	(	TCSlice &	slc,
		const std::vector< unsigned int > &	iHitsInMultiplet,
		const std::vector< unsigned int > &	jHitsInMultiplet
	)

Definition at line 1871 of file Utils.cxx.

   {
     // Hits (assume to be on adjacent wires have an acceptable signal overlap
 
     if (iHitsInMultiplet.empty() || jHitsInMultiplet.empty()) return false;
 
     float sum;
     float cvI = HitsPosTick(slc, iHitsInMultiplet, sum, kAllHits);
     if (cvI < 0) return false;
     float minI = 1E6;
     float maxI = 0;
     for (auto& iht : iHitsInMultiplet) {
       auto const& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       float cv = hit.PeakTime();
       float rms = hit.RMS();
       float arg = cv - 3.1 * rms;
       if (arg < minI) minI = arg;
       arg = cv + 3.1 * rms;
       if (arg > maxI) maxI = arg;
     }
 
     float cvJ = HitsPosTick(slc, jHitsInMultiplet, sum, kAllHits);
     if (cvJ < 0) return false;
     float minJ = 1E6;
     float maxJ = 0;
     for (auto& jht : jHitsInMultiplet) {
       auto& hit = (*evt.allHits)[slc.slHits[jht].allHitsIndex];
       float cv = hit.PeakTime();
       float rms = hit.RMS();
       float arg = cv - 3.1 * rms;
       if (arg < minJ) minJ = arg;
       arg = cv + 3.1 * 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	(	TCSlice &	slc,
		const unsigned int	iht,
		const unsigned int	jht
	)

Definition at line 1919 of file Utils.cxx.

   {
     // ensure that two adjacent hits have an acceptable overlap
     if (iht > slc.slHits.size() - 1) return false;
     if (jht > slc.slHits.size() - 1) return false;
     // require that they be on adjacent wires
     auto& ihit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
     auto& jhit = (*evt.allHits)[slc.slHits[jht].allHitsIndex];
     int iwire = ihit.WireID().Wire;
     int jwire = jhit.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 2602 of file Utils.cxx.

   {
     TrajIntersection(tp1, tp2, pos[0], pos[1]);
   } // TrajIntersection

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

Definition at line 2608 of file Utils.cxx.

   {
     // 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	(	TCSlice &	slc,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 3440 of file Utils.cxx.

   {
     // 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 ( const Trajectory & tj )

Definition at line 2644 of file Utils.cxx.

   {
     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	(	const TrajPoint &	tp1,
		const TrajPoint &	tp2
	)

Definition at line 2678 of file Utils.cxx.

   {
     // 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	(	const TCSlice &	slc,
		TrajPoint const &	tp,
		Trajectory const &	tj,
		unsigned short &	closePt,
		float &	minSep
	)

Definition at line 2433 of file Utils.cxx.

   {
     // 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	(	const TCSlice &	slc,
		const TrajPoint &	tp,
		const VtxStore &	vx
	)

Definition at line 1865 of file TCVertex.cxx.

   {
     // Calculates the position pull between a trajectory point and a vertex
 
     // impact parameter between them
     double ip = PointTrajDOCA(slc, 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 TCSlice &	slc,
		const Trajectory &	tj1,
		const Trajectory &	tj2,
		unsigned short &	ipt1,
		unsigned short &	ipt2,
		float &	minSep
	)

Definition at line 2458 of file Utils.cxx.

   {
     return TrajTrajDOCA(slc, tj1, tj2, ipt1, ipt2, minSep, false);
   } // TrajTrajDOCA

bool tca::TrajTrajDOCA	(	const TCSlice &	slc,
		const Trajectory &	tj1,
		const Trajectory &	tj2,
		unsigned short &	ipt1,
		unsigned short &	ipt2,
		float &	minSep,
		bool	considerDeadWires
	)

Definition at line 2470 of file Utils.cxx.

   {
     // 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(slc, 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	(	TCSlice &	slc,
		bool	prt
	)

Definition at line 3896 of file TCShower.cxx.

   {
     // Transfer InShower hits in all TPCs and planes to the shower Tjs
 
     bool newShowers = false;
     for (auto& ss : slc.cots) {
       if (ss.ID == 0) continue;
       if (ss.ShowerTjID == 0) continue;
       // Tp 1 of stj will get all of the shower hits
       Trajectory& stj = slc.tjs[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 (slc.tjs[itj].AlgMod[kShowerTj]) {
           std::cout << "TTjH: Coding error. T" << tjID << " is a ShowerTj but is in TjIDs\n";
           continue;
         }
         if (slc.tjs[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(slc.tjs[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
         slc.tjs[itj].AlgMod[kKilled] = true;
       } //  tjID
       // re-assign the hit -> stj association
       for (auto& iht : stj.Pts[1].Hits)
         slc.slHits[iht].InTraj = stj.ID;
       newShowers = true;
     } // ss
 
     if (prt) mf::LogVerbatim("TC") << "TTJH: success? " << newShowers;
     return newShowers;
   } // TransferTjHits

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

Definition at line 1598 of file Utils.cxx.

   {
     // 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 (!tcc.useAlg[kTEP]) return;
     if (tj.PDGCode == 111) return;
     if (tj.EndFlag[1][kAtKink]) return;
 
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
     short minPts = fQualityCuts[1];
     if (minPts < 1) return;
     if (npwc < minPts) return;
     // don't consider short Tjs
     if (npwc < 8) 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(slc, tp);
         SetEndPoints(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 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(slc, 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 << " ntpwc " << ntpwc << " nadj " << nadj << " hitFrac "
                               << hitFrac;
       if (hitFrac > fQualityCuts[0] && npwc == minPts && nadj >= minPts - 1) break;
     } // lastPt
 
     if (prt) mf::LogVerbatim("TC") << " lastPt " << lastPt << " " << tj.EndPt[1] << "\n";
     // 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 < slc.nWires[plane] && !evt.goodWire[plane][prevWire]) --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(slc, tj.Pts[ipt]);
     SetEndPoints(tj);
     tj.AlgMod[kTEP] = true;
     if (prt) {
       fcnLabel += "-TEPo";
       PrintTrajectory(fcnLabel, slc, tj, USHRT_MAX);
     }
 
   } // TrimEndPts

void tca::TrimHiChgEndPts	(	TCSlice &	slc,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 1555 of file Utils.cxx.

   {
     // Trim points at the end if the charge pull is too high
     if (!tcc.useAlg[kTHCEP]) return;
     // don't consider long electrons
     if (tj.PDGCode == 111) return;
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
     // only consider long tjs
     if (npwc < 50) return;
     // that don't have a Bragg peak
     if (tj.EndFlag[1][kBragg]) return;
 
     // only look at the last points that would have not been considered by GottaKink
     unsigned short nPtsMax = tcc.kinkCuts[0];
     if (nPtsMax > 8) nPtsMax = 8;
 
     // find the first point with a high charge pull starting at nPtsMax points before the end
     // and count the number of high charge pull points
     float cntBad = 0;
     unsigned short firstBad = USHRT_MAX;
     for (unsigned short ii = 0; ii < nPtsMax; ++ii) {
       unsigned short ipt = tj.EndPt[1] - nPtsMax + ii;
       auto& tp = tj.Pts[ipt];
       if (tp.Chg <= 0) continue;
       if (tp.ChgPull < 3) continue;
       ++cntBad;
       if (firstBad == USHRT_MAX) firstBad = ipt;
     } // ii
     if (firstBad == USHRT_MAX) return;
     // total number of points from the first bad point to the end
     float cntTot = tj.EndPt[1] - firstBad;
     // fraction of those poins that are bad
     float fracBad = cntBad / cntTot;
     if (fracBad < 0.5) return;
     if (prt)
       mf::LogVerbatim("TC") << "THCEP: Trim points starting at " << PrintPos(slc, tj.Pts[firstBad]);
     for (unsigned short ipt = firstBad; ipt <= tj.EndPt[1]; ++ipt)
       UnsetUsedHits(slc, tj.Pts[ipt]);
     tj.AlgMod[kTHCEP] = true;
   } // TrimHiChgEndPts

float tca::TwoTPAngle	(	const TrajPoint &	tp1,
		const TrajPoint &	tp2
	)

Definition at line 2719 of file Utils.cxx.

   {
     // 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	(	TCSlice &	slc,
		TrajPoint &	tp
	)

Definition at line 1073 of file Utils.cxx.

   {
     // 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]) {
         slc.slHits[tp.Hits[ii]].InTraj = 0;
         tp.UseHit[ii] = false;
       } // UseHit
     }   // ii
     tp.Chg = 0;
   } // UnsetUsedHits

bool tca::Update	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 1056 of file PFPUtils.cxx.

   {
     // This function only updates SectionFits that need to be re-sorted or re-fit. It returns
     // false if there was a serious error indicating that the pfp should be abandoned
     if (pfp.TP3Ds.empty() || pfp.SectionFits.empty()) return false;
 
     // special handling for small angle tracks
     if(pfp.AlgMod[kSmallAngle]) {
       for(unsigned short sfi = 0; sfi < pfp.SectionFits.size(); ++sfi) {
         auto& sf = pfp.SectionFits[sfi];
         if (!sf.NeedsUpdate) continue;
         if (!SortSection(pfp, sfi)) return false;
         sf.NPts = 0;
         sf.ChiDOF = 0;
         for(unsigned short ipt = 0; ipt < pfp.TP3Ds.size(); ++ipt) {
           auto& tp3d = pfp.TP3Ds[ipt];
           if(tp3d.SFIndex < sfi) continue;
           if(tp3d.SFIndex > sfi) break;
           ++sf.NPts;
           double delta = tp3d.Pos[0] - tp3d.TPX;
           sf.ChiDOF += delta * delta / tp3d.TPXErr2;
         } // ipt
         if(sf.NPts < 5) {
           sf.ChiDOF = 0;
         } else {
           sf.ChiDOF /= (float)(sf.NPts - 4);
         }
         sf.NeedsUpdate = false;
       } // sfi
       pfp.Flags[kNeedsUpdate] = false;
       return true;
     } // kSmallAngle
 
     for (std::size_t sfi = 0; sfi < pfp.SectionFits.size(); ++sfi) {
       auto& sf = pfp.SectionFits[sfi];
       if (!sf.NeedsUpdate) continue;
       if (!FitSection(clockData, detProp, slc, pfp, sfi)) return false;
       if (!SortSection(pfp, sfi)) return false;
       sf.NeedsUpdate = false;
     } // sfi
 
     // ensure that all points (good or not) have a valid SFIndex
     for (auto& tp3d : pfp.TP3Ds) {
       if (tp3d.SFIndex >= pfp.SectionFits.size()) SetSection(detProp, slc, pfp, tp3d);
     } // tp3d
     pfp.Flags[kNeedsUpdate] = false;
     return true;
   } // Update

void tca::UpdateDeltaRMS	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 2347 of file StepUtils.cxx.

   {
     // Estimate the Delta RMS of the TPs on the end of tj.
 
     unsigned int lastPt = tj.EndPt[1];
     TrajPoint& lastTP = tj.Pts[lastPt];
 
     if(lastTP.Chg == 0) return;
     if(lastPt < 6) return;
 
     unsigned short ii, ipt, cnt = 0;
     float sum = 0;
     for(ii = 1; ii < tj.Pts.size(); ++ii) {
       ipt = lastPt - ii;
       if(ipt > tj.Pts.size() - 1) break;
       if(tj.Pts[ipt].Chg == 0) continue;
       sum += PointTrajDOCA(slc, tj.Pts[ipt].Pos[0], tj.Pts[ipt].Pos[1], lastTP);
       ++cnt;
       if(cnt == lastTP.NTPsFit) break;
       if(ipt == 0) break;
     }
     if(cnt < 3) return;
     // RMS of Gaussian distribution is ~1.2 x the average
     // of a one-sided Gaussian distribution (since Delta is > 0)
     lastTP.DeltaRMS = 1.2 * sum / (float)cnt;
     if(lastTP.DeltaRMS < 0.02) lastTP.DeltaRMS = 0.02;
 
   } // UpdateDeltaRMS

bool tca::UpdateShower	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 911 of file TCShower.cxx.

   {
     // 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.TjIDs.empty()) return false;
     if (ss.ShowerTjID <= 0 || ss.ShowerTjID > (int)slc.tjs.size()) return false;
     if (ss.ParentID > 0 && ss.ParentID > (int)slc.tjs.size()) return false;
     auto& stj = slc.tjs[ss.ShowerTjID - 1];
     if (stj.Pts.size() != 3) return false;
 
     std::string fcnLabel = inFcnLabel + ".U2S";
 
     if (!ss.NeedsUpdate && !ss.ShPts.empty()) 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
 
     ss.ShPts.clear();
     for (auto tjid : ss.TjIDs) {
       if (tjid <= 0 || tjid > (int)slc.tjs.size()) return false;
       auto& tj = slc.tjs[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];
           auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
           if (hit.Integral() <= 0) continue;
           ShowerPoint shpt;
           shpt.HitIndex = iht;
           shpt.TID = tj.ID;
           shpt.Chg = hit.Integral();
           shpt.Pos[0] = hit.WireID().Wire;
           shpt.Pos[1] = hit.PeakTime() * tcc.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(slc, 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 = slc.tjs[ss.ParentID - 1];
       // find the parent end farthest away from the charge center
       unsigned short pend = FarEnd(slc, 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].val = shpt.RotPos[0];
       ++indx;
     } // shpt
     std::sort(sortVec.begin(), sortVec.end(), valsDecreasing);
     // 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, slc, 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 = slc.tjs[ss.ParentID - 1];
       // find the parent end farthest away from the charge center
       unsigned short pend = FarEnd(slc, 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, slc, 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, slc, 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, slc, ss, prt);
     ss.NeedsUpdate = false;
     if (prt) mf::LogVerbatim("TC") << fcnLabel << " 2S" << ss.ID << " updated";
     return true;
 
   } // UpdateShower

bool tca::UpdateShower	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 1116 of file TCShower.cxx.

   {
     // 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 = slc.cots[cid - 1];
       if (ss.NeedsUpdate && prt)
         std::cout << fcnLabel << " ********* 3S" << ss3.ID << " 2S" << ss.ID
                   << " needs an update...\n";
       UpdateShower(fcnLabel, slc, ss, prt);
     } // ci
 
     // check consistency
     if (ss3.ParentID > 0) {
       auto& pfp = slc.pfps[ss3.ParentID - 1];
       unsigned short pend = FarEnd(slc, 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
     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) 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 = slc.pfps[ss3.ParentID - 1];
       unsigned short pend = FarEnd(slc, pfp, ss3.ChgPos);
       ss3.Start = PosAtEnd(pfp, pend);
       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 = slc.cots[cid - 1];
       auto& stj = slc.tjs[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::UpdateStiffEl	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 646 of file StepUtils.cxx.

   {
     // A different stategy for updating a high energy electron trajectories
     if(!tj.Strategy[kStiffEl]) return;
     TrajPoint& lastTP = tj.Pts[tj.EndPt[1]];
     // Set the lastPT delta before doing the fit
     lastTP.Delta = PointTrajDOCA(slc, lastTP.HitPos[0], lastTP.HitPos[1], lastTP);
     if(tj.Pts.size() < 30) lastTP.NTPsFit += 1;
     FitTraj(slc, tj);
     UpdateTjChgProperties("UET", slc, tj, tcc.dbgStp);
     UpdateDeltaRMS(slc, tj);
     tj.MCSMom = MCSMom(slc, tj);
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"UpdateStiffEl: lastPt "<<tj.EndPt[1]<<" Delta "<<lastTP.Delta<<" AngleCode "<<lastTP.AngleCode<<" FitChi "<<lastTP.FitChi<<" NTPsFit "<<lastTP.NTPsFit<<" MCSMom "<<tj.MCSMom;
     }
     tj.NeedsUpdate = false;
     tj.PDGCode = 111;
     return;
   } // UpdateStiffTj

void tca::UpdateTjChgProperties	(	std::string	inFcnLabel,
		TCSlice &	slc,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 3671 of file Utils.cxx.

   {
     // 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.
     if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) return;
 
     // 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 (slc.slHits[iht].InTraj == 0) tp.Environment[kEnvUnusedHits] = 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;
     // Reject a single large charge TP
     float bigChg = 0;
     for (unsigned short ipt = tj.EndPt[0] + 1; ipt < tj.EndPt[1]; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if (tp.Chg > bigChg) bigChg = tp.Chg;
     } // ipt
     //  variables for calculating the backup quanties. These are only used if npwc < 3
     double bcnt = 0;
     double bsum = 0;
     double bsum2 = 0;
     // don't include the end points
     for (unsigned short ipt = tj.EndPt[0] + 1; ipt < tj.EndPt[1]; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if (tp.Chg <= 0) continue;
       // ignore the single large charge TP
       if (tp.Chg == bigChg) 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;
       if (tp.Chg > bigChg) bigChg = 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 += (*evt.allHits)[slc.slHits[iht].allHitsIndex].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;
       if (prt)
         mf::LogVerbatim("TC") << inFcnLabel << ".UpdateTjChgProperties: backup sum Set tj.AveChg "
                               << (int)tj.AveChg << " ChgRMS " << tj.ChgRMS;
       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 = slc.vtxs[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;
     if (prt)
       mf::LogVerbatim("TC") << inFcnLabel << ".UpdateTjChgProperties: Set tj.AveChg "
                             << (int)tj.AveChg << " ChgRMS " << tj.ChgRMS;
 
     // 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 < tcc.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 = tcc.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::UpdateTraj	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 667 of file StepUtils.cxx.

   {
     // Updates the last added trajectory point fit, average hit rms, etc.
 
     tj.NeedsUpdate = true;
     tj.MaskedLastTP = false;
 
     if(tj.EndPt[1] < 1) return;
 
     if(tj.Strategy[kStiffEl]) {
       UpdateStiffEl(slc, tj);
       return;
     }
     unsigned int lastPt = tj.EndPt[1];
     TrajPoint& lastTP = tj.Pts[lastPt];
     // nothing needs to be done if the last point has no hits but is near a hit in the
     // srcHit collection
     if(lastTP.Hits.empty() && lastTP.Environment[kEnvNearSrcHit]) {
       tj.NeedsUpdate = false;
       return;
     }
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
 
     // find the previous TP that has hits (and was therefore in the fit)
     unsigned short prevPtWithHits = USHRT_MAX;
     unsigned short firstFitPt = tj.EndPt[0];
     for(unsigned short ii = 1; ii < tj.Pts.size(); ++ii) {
       unsigned short ipt = lastPt - ii;
       if(tj.Pts[ipt].Chg > 0) {
         prevPtWithHits = ipt;
         break;
       }
       if(ipt == 0) break;
     } // ii
     if(prevPtWithHits == USHRT_MAX) return;
 
     // define the FitChi threshold above which something will be done
     float maxChi = 2;
     unsigned short minPtsFit = tcc.minPtsFit[tj.Pass];
     // just starting out?
     if(lastPt < 4) minPtsFit = 2;
     bool cleanMuon = (tj.PDGCode == 13 && TrajIsClean(slc, tj, tcc.dbgStp) && !tj.Strategy[kSlowing]);
     // was !TrajIsClean...
     if(cleanMuon) {
       // Fitting a clean muon
       maxChi = tcc.maxChi;
       minPtsFit = lastPt / 3;
     }
 
     // Set the lastPT delta before doing the fit
     lastTP.Delta = PointTrajDOCA(slc, lastTP.HitPos[0], lastTP.HitPos[1], lastTP);
 
     // update MCSMom. First ensure that nothing bad has happened
     if(npwc > 3 && tj.Pts[lastPt].Chg > 0 && !tj.Strategy[kSlowing]) {
       short newMCSMom = MCSMom(slc, tj);
       short minMCSMom = 0.5 * tj.MCSMom;
       if(lastPt > 10 && newMCSMom < minMCSMom) {
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"UT: MCSMom took a nose-dive "<<newMCSMom;
         UnsetUsedHits(slc, lastTP);
         DefineHitPos(slc, lastTP);
         SetEndPoints(tj);
         tj.NeedsUpdate = false;
         return;
       }
       tj.MCSMom = newMCSMom;
     } // npwc > 3
 
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"UT: lastPt "<<lastPt<<" lastTP.Delta "<<lastTP.Delta<<" previous point with hits "<<prevPtWithHits<<" tj.Pts size "<<tj.Pts.size()<<" AngleCode "<<lastTP.AngleCode<<" PDGCode "<<tj.PDGCode<<" maxChi "<<maxChi<<" minPtsFit "<<minPtsFit<<" MCSMom "<<tj.MCSMom;
     }
 
     UpdateTjChgProperties("UT", slc, tj, tcc.dbgStp);
 
     if(lastPt == 1) {
       // Handle the second trajectory point. No error calculation. Just update
       // the position and direction
       lastTP.NTPsFit = 2;
       FitTraj(slc, tj);
       lastTP.FitChi = 0.01;
       lastTP.AngErr = tj.Pts[0].AngErr;
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"UT: Second traj point pos "<<lastTP.Pos[0]<<" "<<lastTP.Pos[1]<<"  dir "<<lastTP.Dir[0]<<" "<<lastTP.Dir[1];
       tj.NeedsUpdate = false;
       SetAngleCode(lastTP);
       return;
     }
 
     if(lastPt == 2) {
       // Third trajectory point. Keep it simple
       lastTP.NTPsFit = 3;
       FitTraj(slc, tj);
       tj.NeedsUpdate = false;
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"UT: Third traj point fit "<<lastTP.FitChi;
       SetAngleCode(lastTP);
       return;
     }
 
     // Fit with > 2 TPs
     // Keep adding hits until Chi/DOF exceeds 1
     if(tj.Pts[prevPtWithHits].FitChi < 1 && !tj.Strategy[kSlowing]) lastTP.NTPsFit += 1;
     // Reduce the number of points fit if the trajectory is long and chisq is getting a bit larger
     if(lastPt > 20 && tj.Pts[prevPtWithHits].FitChi > 1.5 && lastTP.NTPsFit > minPtsFit) lastTP.NTPsFit -= 2;
     // don't let long muon fits get too long
     if(cleanMuon && lastPt > 200 && tj.Pts[prevPtWithHits].FitChi > 1.0) lastTP.NTPsFit -= 2;
     FitTraj(slc, tj);
 
     // don't get too fancy when we are starting out
     if(lastPt < 6) {
       tj.NeedsUpdate = false;
       UpdateDeltaRMS(slc, tj);
       SetAngleCode(lastTP);
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Return with lastTP.FitChi "<<lastTP.FitChi<<" Chg "<<lastTP.Chg;
       return;
     }
 
     // find the first point that was fit.
     unsigned short cnt = 0;
     for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
       unsigned short ipt = lastPt - ii;
       if(tj.Pts[ipt].Chg > 0) {
         firstFitPt = ipt;
         ++cnt;
       }
       if(cnt == lastTP.NTPsFit) break;
       if(ipt == 0) break;
     }
 
     unsigned short ndead = DeadWireCount(slc, lastTP.HitPos[0], tj.Pts[firstFitPt].HitPos[0], tj.CTP);
     if(lastTP.FitChi > 1.5 && tj.Pts.size() > 6) {
       // A large chisq jump can occur if we just jumped a large block of dead wires. In
       // this case we don't want to mask off the last TP but reduce the number of fitted points
       // This count will be off if there a lot of dead or missing wires...
       // reduce the number of points significantly
       if(ndead > 5 && !cleanMuon) {
         if(lastTP.NTPsFit > 5) lastTP.NTPsFit = 5;
       } else {
         // Have a longish trajectory and chisq was a bit large.
         // Was this a sudden occurrence and the fraction of TPs are included
         // in the fit? If so, we should mask off this
         // TP and keep going. If these conditions aren't met, we
         // should reduce the number of fitted points
         float chirat = 0;
         if(prevPtWithHits != USHRT_MAX && tj.Pts[prevPtWithHits].FitChi > 0) chirat = lastTP.FitChi / tj.Pts[prevPtWithHits].FitChi;
         // Don't mask hits when doing RevProp. Reduce NTPSFit instead
         tj.MaskedLastTP = (chirat > 1.5 && lastTP.NTPsFit > 0.3 * NumPtsWithCharge(slc, tj, false) && !tj.AlgMod[kRvPrp]);
         // BB April 19, 2018: Don't mask TPs on low MCSMom Tjs
         if(tj.MaskedLastTP && tj.MCSMom < 30) tj.MaskedLastTP = false;
         if(tcc.dbgStp) {
           mf::LogVerbatim("TC")<<" First fit chisq too large "<<lastTP.FitChi<<" prevPtWithHits chisq "<<tj.Pts[prevPtWithHits].FitChi<<" chirat "<<chirat<<" NumPtsWithCharge "<<NumPtsWithCharge(slc, tj, false)<<" tj.MaskedLastTP "<<tj.MaskedLastTP;
         }
         // we should also mask off the last TP if there aren't enough hits
         // to satisfy the minPtsFit constraint
         if(!tj.MaskedLastTP && NumPtsWithCharge(slc, tj, true) < minPtsFit) tj.MaskedLastTP = true;
       } // few dead wires
     } // lastTP.FitChi > 2 ...
 
     // Deal with a really long trajectory that is in trouble (uB cosmic).
     if(tj.PDGCode == 13 && lastTP.FitChi > tcc.maxChi) {
       if(lastTP.NTPsFit > 1.3 * tcc.muonTag[0]) {
         lastTP.NTPsFit *= 0.8;
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Muon - Reduce NTPsFit "<<lastPt;
       } else {
         tj.MaskedLastTP = true;
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Muon - mask last point "<<lastPt;
       }
     }
 
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"UT: First fit "<<lastTP.Pos[0]<<" "<<lastTP.Pos[1]<<"  dir "<<lastTP.Dir[0]<<" "<<lastTP.Dir[1]<<" FitChi "<<lastTP.FitChi<<" NTPsFit "<<lastTP.NTPsFit<<" ndead wires "<<ndead<<" tj.MaskedLastTP "<<tj.MaskedLastTP;
       if(tj.MaskedLastTP) {
         UnsetUsedHits(slc, lastTP);
         DefineHitPos(slc, lastTP);
         SetEndPoints(tj);
         lastPt = tj.EndPt[1];
         lastTP.NTPsFit -= 1;
         FitTraj(slc, tj);
         UpdateTjChgProperties("UT", slc, tj, tcc.dbgStp);
         SetAngleCode(lastTP);
         return;
       }  else {
         // a more gradual change in chisq. Maybe reduce the number of points
         unsigned short newNTPSFit = lastTP.NTPsFit;
         // reduce the number of points fit to keep Chisq/DOF < 2 adhering to the pass constraint
         // and also a minimum number of points fit requirement for long muons
         float prevChi = lastTP.FitChi;
         unsigned short ntry = 0;
         float chiCut = 1.5;
         if(tj.Strategy[kStiffMu]) chiCut = 5;
         while(lastTP.FitChi > chiCut && lastTP.NTPsFit > minPtsFit) {
           if(lastTP.NTPsFit > 15) {
             newNTPSFit = 0.7 * newNTPSFit;
           } else if(lastTP.NTPsFit > 4) {
             newNTPSFit -= 2;
           } else {
             newNTPSFit -= 1;
           }
           if(lastTP.NTPsFit < 3) newNTPSFit = 2;
           if(newNTPSFit < minPtsFit) newNTPSFit = minPtsFit;
           lastTP.NTPsFit = newNTPSFit;
           // BB April 19: try to add a last lonely hit on a low MCSMom tj on the last try
           if(newNTPSFit == minPtsFit && tj.MCSMom < 30) chiCut = 2;
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<"  Bad FitChi "<<lastTP.FitChi<<" Reduced NTPsFit to "<<lastTP.NTPsFit<<" Pass "<<tj.Pass<<" chiCut "<<chiCut;
           FitTraj(slc, tj);
           tj.NeedsUpdate = true;
           if(lastTP.FitChi > prevChi) {
             if(tcc.dbgStp) mf::LogVerbatim("TC")<<"  Chisq is increasing "<<lastTP.FitChi<<"  Try to remove an earlier bad hit";
             MaskBadTPs(slc, tj, chiCut);
             ++ntry;
             if(ntry == 2) break;
           }
           prevChi = lastTP.FitChi;
           if(lastTP.NTPsFit == minPtsFit) break;
         } // lastTP.FitChi > 2 && lastTP.NTPsFit > 2
       }
       // last ditch attempt if things look bad. Drop the last hit
       if(tj.Pts.size() > tcc.minPtsFit[tj.Pass] && lastTP.FitChi > maxChi) {
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"  Last try. Drop last TP "<<lastTP.FitChi<<" NTPsFit "<<lastTP.NTPsFit;
         UnsetUsedHits(slc, lastTP);
         DefineHitPos(slc, lastTP);
         SetEndPoints(tj);
         lastPt = tj.EndPt[1];
         FitTraj(slc, tj);
         tj.MaskedLastTP = true;
       }
 
     if(tj.NeedsUpdate) UpdateTjChgProperties("UT", slc, tj, tcc.dbgStp);
 
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"  Fit done. Chi "<<lastTP.FitChi<<" NTPsFit "<<lastTP.NTPsFit;
 
     if(tj.EndPt[0] == tj.EndPt[1]) return;
 
     // Don't let the angle error get too small too soon. Stepping would stop if the first
     // few hits on a low momentum wandering track happen to have a very good fit to a straight line.
     // We will do this by averaging the default starting value of AngErr of the first TP with the current
     // value from FitTraj.
     if(lastPt < 14) {
       float defFrac = 1 / (float)(tj.EndPt[1]);
       lastTP.AngErr = defFrac * tj.Pts[0].AngErr + (1 - defFrac) * lastTP.AngErr;
     }
 
     UpdateDeltaRMS(slc, tj);
     SetAngleCode(lastTP);
 
     tj.NeedsUpdate = false;
     return;
 
   } // UpdateTraj

void tca::UpdateVxEnvironment ( TCSlice & slc )

Definition at line 3860 of file Utils.cxx.

   {
     // Set the kEnvOverlap bit true for all TPs that are close to other
     // trajectories that are close to vertices. The positions of TPs that
     // overlap are biased and shouldn't be used in a vertex fit. Also, these
     // TPs shouldn't be used to calculate dE/dx. The kEnvOverlap bit is first cleared
     // for ALL TPs and then set for ALL 2D vertices
 
     for (auto& tj : slc.tjs) {
       if (tj.AlgMod[kKilled]) continue;
       for (auto& tp : tj.Pts)
         tp.Environment[kEnvOverlap] = false;
     } // tj
 
     for (auto& vx : slc.vtxs) {
       if (vx.ID <= 0) continue;
       UpdateVxEnvironment(slc, vx, false);
     } // vx
 
   } // UpdateVxEnvironment

void tca::UpdateVxEnvironment	(	TCSlice &	slc,
		VtxStore &	vx2,
		bool	prt
	)

Definition at line 3883 of file Utils.cxx.

   {
     // Update the Environment each TP on trajectories near the vertex
 
     if (vx2.ID == 0) return;
     if (vx2.Stat[kOnDeadWire]) return;
 
     if (prt) mf::LogVerbatim("TC") << "UpdateVxEnvironment 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 : slc.tjs) {
       if (tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) 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") << " 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 = slc.tjs[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 << " T" << tj.ID;
         for (auto& tp : tjpt)
           myprt << " " << PrintPos(slc, 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 (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 = slc.tjs[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") << " 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 = slc.tjs[tjid - 1];
       if (!tj.NeedsUpdate) continue;
       if (tj.CTP != vx2.CTP) continue;
       UpdateTjChgProperties("UVxE", slc, tj, prt);
     } // tjid
 
   } // UpdateVxEnvironment

bool tca::valDecreasing	(	SortEntry	c1,
		SortEntry	c2
	)

Definition at line 33 of file TCVertex.cxx.

   {
     return (c1.val > c2.val);
   }

bool tca::ValidTwoPlaneMatch	(	detinfo::DetectorPropertiesData const &	detProp,
		const TCSlice &	slc,
		const PFPStruct &	pfp
	)

Definition at line 1796 of file PFPUtils.cxx.

   {
     // This function checks the third plane in the PFP when only two Tjs are 3D-matched to
     // ensure that the reason for the lack of a 3rd plane match is that it is in a dead region.
     // This function should be used after an initial fit is done and the TP3Ds are sorted
     if (pfp.TjIDs.size() != 2) return false;
     if (slc.nPlanes != 3) return false;
     if (pfp.TP3Ds.empty()) return false;
 
     // find the third plane
     std::vector<unsigned short> planes;
     for (auto tid : pfp.TjIDs)
       planes.push_back(DecodeCTP(slc.tjs[tid - 1].CTP).Plane);
     unsigned short thirdPlane = 3 - planes[0] - planes[1];
     CTP_t inCTP = EncodeCTP(slc.TPCID.Cryostat, slc.TPCID.TPC, thirdPlane);
     // Project the 3D position at the start into the third plane
     auto tp = MakeBareTP(detProp, slc, pfp.TP3Ds[0].Pos, inCTP);
     unsigned int wire0 = 0;
     if (tp.Pos[0] > 0) wire0 = std::nearbyint(tp.Pos[0]);
     if (wire0 > slc.nWires[thirdPlane]) wire0 = slc.nWires[thirdPlane];
     // Do the same for the end
     unsigned short lastPt = pfp.TP3Ds.size() - 1;
     tp = MakeBareTP(detProp, slc, pfp.TP3Ds[lastPt].Pos, inCTP);
     unsigned int wire1 = 0;
     if (tp.Pos[0] > 0) wire1 = std::nearbyint(tp.Pos[0]);
     if (wire1 > slc.nWires[thirdPlane]) wire1 = slc.nWires[thirdPlane];
     if (wire0 == wire1) return !evt.goodWire[thirdPlane][wire0];
     if (wire1 < wire0) std::swap(wire0, wire1);
     // count the number of good wires
     int dead = 0;
     int wires = wire1 - wire0;
     for (unsigned int wire = wire0; wire < wire1; ++wire)
       if (!evt.goodWire[thirdPlane][wire]) ++dead;
     // require that most of the wires are dead
     return (dead > 0.8 * wires);
   } // ValidTwoPlaneMatch

bool tca::valIncreasing	(	SortEntry	c1,
		SortEntry	c2
	)

Definition at line 38 of file TCVertex.cxx.

   {
     return (c1.val < c2.val);
   }

float tca::VertexVertexPull	(	const TCSlice &	slc,
		const Vtx3Store &	vx1,
		const Vtx3Store &	vx2
	)

Definition at line 1901 of file TCVertex.cxx.

   {
     // 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	(	const TCSlice &	slc,
		const VtxStore &	vx1,
		const VtxStore &	vx2
	)

Definition at line 1918 of file TCVertex.cxx.

   {
     // 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);
   }

bool tca::WireHitRangeOK	(	TCSlice &	slc,
		const CTP_t &	inCTP
	)

Definition at line 4651 of file Utils.cxx.

   {
     // returns true if the passed CTP code is consistent with the CT code of the WireHitRangeVector
     geo::PlaneID planeID = DecodeCTP(inCTP);
     if (planeID.Cryostat != slc.TPCID.Cryostat) return false;
     if (planeID.TPC != slc.TPCID.TPC) return false;
     return true;
   }

bool tca::WrongSplitTj	(	std::string	inFcnLabel,
		TCSlice &	slc,
		Trajectory &	tj,
		unsigned short	tjEnd,
		ShowerStruct &	ss,
		bool	prt
	)

Definition at line 2266 of file TCShower.cxx.

   {
     // 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 (slc.vtxs[ivx].Topo != 8 && slc.vtxs[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 15 of file DataStructs.cxx.

constexpr unsigned int tca::Cpad = 10000

Definition at line 51 of file DataStructs.h.

DebugStuff tca::debug

Definition at line 4 of file DebugStruct.cxx.

const std::vector< std::string > tca::EndFlagNames

Initial value:

{
    "Signal",
    "AtKink",
    "AtVtx",
    "Bragg",
    "AtTj",
    "OutFV",
    "NoFitVx"
  }

Definition at line 87 of file DataStructs.cxx.

TCEvent tca::evt

Definition at line 7 of file DataStructs.cxx.

constexpr unsigned int tca::pAlgModSize = 6

Definition at line 282 of file DataStructs.h.

std::vector< TrajPoint > tca::seeds

Definition at line 13 of file DataStructs.cxx.

std::vector< TCSlice > tca::slices

Definition at line 12 of file DataStructs.cxx.

const std::vector< std::string > tca::StrategyBitNames

Initial value:

{
    "Normal",
    "StiffEl",
    "StiffMu",
    "Slowing"
  }

Definition at line 108 of file DataStructs.cxx.

ShowerTreeVars tca::stv

Definition at line 10 of file DataStructs.cxx.

TCConfig tca::tcc

Definition at line 8 of file DataStructs.cxx.

std::vector< TjForecast > tca::tjfs

Definition at line 9 of file DataStructs.cxx.

constexpr unsigned int tca::Tpad = 10

Definition at line 50 of file DataStructs.h.

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

Initial value:

{
    "VxTrjTried",
    "Fixed",
    "OnDeadWire",
    "HiVx3Score",
    "VxTruMatch",
    "VxMerged",
    "VxIndPlnNoChg",
    "VxEnvOK"
  }

Definition at line 97 of file DataStructs.cxx.

Classes

Typedefs

Enumerations

Functions

Variables

Data structures for the reconstruction results

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation