Classes
struct	CRTreeVars

struct	DebugStuff

struct	DontClusterStruct

struct	HistStuff

struct	MatchStruct

class	MCParticleListUtils

struct	PFPStruct

struct	ShowerPoint

struct	ShowerStruct

struct	ShowerStruct3D

struct	ShowerTreeVars

struct	SortEntry

struct	TCConfig

struct	TCEvent

struct	TCHit

struct	TCSlice

struct	Tj2Pt

struct	TjForecast

class	TrajClusterAlg

struct	Trajectory

struct	TrajPoint

struct	TrajPoint3

class	TruthMatcher

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

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

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

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

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

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

typedef unsigned int	CTP_t

Enumerations
enum	HitStatus_t { kAllHits, kUsedHits, kUnusedHits }

Functions
geo::PlaneID	DecodeCTP (CTP_t CTP)

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

CTP_t	EncodeCTP (const geo::PlaneID &planeID)

CTP_t	EncodeCTP (const geo::WireID &wireID)

bool	valDecreasings (SortEntry c1, SortEntry c2)

bool	valIncreasings (SortEntry c1, SortEntry c2)

void	StitchPFPs ()

void	UpdateMatchStructs (TCSlice &slc, int oldTj, int newTj)

void	UpdateTp3s (TCSlice &slc, PFPStruct &pfp, int oldTj, int newTj)

void	FillmAllTraj (TCSlice &slc)

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

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

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

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

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

void	FindCompleteness (TCSlice &slc, PFPStruct &pfp, bool doFit, bool fillTp3s, bool prt)

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

bool	SharesHighScoreVx (TCSlice &slc, const PFPStruct &pfp, const Trajectory &tj)

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

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

float	LengthInCTP (TCSlice &slc, std::vector< int > &tjids, CTP_t inCTP)

bool	AddMissedTj (TCSlice &slc, PFPStruct &pfp, unsigned short itj, bool looseCuts, bool prt)

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

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

bool	MakeTp3 (TCSlice &slc, const TrajPoint &itp, const TrajPoint &jtp, TrajPoint3 &tp3, bool findDirection)

double	DeltaAngle (const Vector3_t v1, const Vector3_t v2)

Vector3_t	PointDirection (const Point3_t p1, const Point3_t p2)

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

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

bool	SetMag (Vector3_t &v1, double mag)

void	FilldEdx (TCSlice &slc, PFPStruct &pfp)

void	FilldEdx (TCSlice &slc, TrajPoint3 &tp3)

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

bool	Split3DKink (TCSlice &slc, PFPStruct &pfp, double sep, bool prt)

std::vector< unsigned short >	FindKinks (TCSlice &slc, PFPStruct &pfp, double sep, bool prt)

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

PFPStruct	CreatePFP (TCSlice &slc)

void	FindPFParticles (TCSlice &slc)

bool	DefinePFP (std::string inFcnLabel, TCSlice &slc, PFPStruct &pfp, bool prt)

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

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

void	PFPVertexCheck (TCSlice &slc)

void	DefinePFPParents (TCSlice &slc, bool prt)

void	DefinePFPParentsTestBeam (TCSlice &slc, bool prt)

bool	StorePFP (TCSlice &slc, PFPStruct &pfp)

bool	InsideFV (TCSlice &slc, 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)

void	ReversePFP (TCSlice &slc, PFPStruct &pfp)

float	ChgFracBetween (TCSlice &slc, Point3_t pos1, Point3_t pos2)

float	ChgFracNearEnd (TCSlice &slc, PFPStruct &pfp, unsigned short end)

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

void	PrintTp3 (std::string someText, TCSlice &slc, const TrajPoint3 &tp3)

void	PrintTp3s (std::string someText, TCSlice &slc, const PFPStruct &pfp, short printPts)

float	AspectRatio (TCSlice &slc, std::vector< int > &tjids, CTP_t inCTP)

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

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

void	StepAway (TCSlice &slc, Trajectory &tj)

void	SetStrategy (TCSlice &slc, Trajectory &tj)

void	Forecast (TCSlice &slc, 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 (TCSlice &slc, unsigned int theHit, std::vector< unsigned int > &hitsInMultiplet)

void	GetHitMultiplet (TCSlice &slc, unsigned int theHit, std::vector< unsigned int > &hitsInMultiplet, unsigned short &localIndex)

float	HitTimeErr (TCSlice &slc, unsigned int iht)

float	HitsTimeErr2 (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	FindSoftKink (TCSlice &slc, Trajectory &tj)

void	FillGaps (TCSlice &slc, Trajectory &tj)

void	CheckHiMultUnusedHits (TCSlice &slc, Trajectory &tj)

void	CheckHiMultEndHits (TCSlice &slc, Trajectory &tj)

void	HiEndDelta (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)

void	GottaKink (TCSlice &slc, Trajectory &tj, unsigned short &killPts)

void	FixTrajBegin (TCSlice &slc, Trajectory &tj)

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

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

bool	IsGhost (TCSlice &slc, Trajectory &tj)

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

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)

void	ChkHiChgHits (TCSlice &slc, CTP_t inCTP)

void	SplitHiChgHits (TCSlice &slc, Trajectory &tj)

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

void	SaveCRInfo (TCSlice &slc, PFPStruct &pfp, bool prt, bool fIsRealData)

int	GetOrigin (TCSlice &slc, PFPStruct &pfp)

void	ClearCRInfo (TCSlice &slc)

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

bool	FindShowerStart (TCSlice &slc, ShowerStruct3D &ss3, bool prt)

void	Finish3DShowers (TCSlice &slc)

bool	FindShowers3D (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)

void	Match2DShowers (std::string inFcnLabel, TCSlice &slc, 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 (std::string inFcnLabel, TCSlice &slc, ShowerStruct3D &ss3, bool prt)

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

float	Match3DFOM (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 (std::string inFcnLabel, TCSlice &slc, ShowerStruct3D &ss3, bool prt)

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

PFPStruct	CreateFakePFP (TCSlice &slc, const ShowerStruct3D &ss3)

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	DefineDontCluster (TCSlice &slc, bool prt)

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

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 (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)

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	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 (TCSlice &slc, const CTP_t &inCTP, unsigned short pass)

void	FindVtxTjs (TCSlice &slc, VtxStore &vx2)

void	FindNeutralVertices (TCSlice &slc)

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

void	ChkVxTjs (TCSlice &slc, const CTP_t &inCTP, bool prt)

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

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

void	SplitTrajCrossingVertices (TCSlice &slc, CTP_t inCTP)

void	Find3DVertices (TCSlice &slc)

void	Match3DVtxTjs (TCSlice &slc, bool prt)

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

bool	AttachPFPToVertex (TCSlice &slc, PFPStruct &pfp, unsigned short end, unsigned short vx3ID, bool prt)

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

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

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

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

float	VertexVertexPull (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 > vxTp, 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)

unsigned short	Vx3Topo (TCSlice &slc, Vtx3Store &vx3)

void	CompleteIncomplete3DVerticesInGaps (TCSlice &slc)

void	CompleteIncomplete3DVertices (TCSlice &slc)

void	VtxHitsSwap (TCSlice &slc, const CTP_t inCTP)

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)

std::vector< unsigned short >	GetPFPVertices (const TCSlice &slc, const PFPStruct &pfp)

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

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

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

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

unsigned short	NumDeltaRays (TCSlice &slc, std::vector< int > &tjIDs)

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

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

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

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

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

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

float	OverlapFraction (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)

float	TjDirFOM (TCSlice &slc, const Trajectory &tj, bool prt)

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

unsigned short	GetPFPIndex (TCSlice &slc, int tjID)

unsigned short	MatchVecIndex (TCSlice &slc, int tjID)

void	ReleaseHits (TCSlice &slc, Trajectory &tj)

void	UnsetUsedHits (TCSlice &slc, TrajPoint &tp)

bool	StoreTraj (TCSlice &slc, Trajectory &tj)

void	ChgSlope (TCSlice &slc, Trajectory &tj, float &slope, float &slopeErr, float &chiDOF)

void	ChgSlope (TCSlice &slc, Trajectory &tj, unsigned short fromPt, unsigned short toPt, float &slope, float &slopeErr, float &chiDOF)

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

void	CheckTrajBeginChg (TCSlice &slc, unsigned short itj)

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

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

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

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

float	ChgFracBetween (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	SignalAtTp (TCSlice &slc, const TrajPoint &tp)

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

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

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

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

float	DeadWireCount (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 (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 (TCSlice &slc, TrajPoint const &tp, Trajectory const &tj, unsigned short &closePt, float &minSep)

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

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

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

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

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

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

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

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

float	TrajLength (Trajectory &tj)

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

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

float	TrajPointSeparation (TrajPoint &tp1, TrajPoint &tp2)

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

float	TwoTPAngle (TrajPoint &tp1, TrajPoint &tp2)

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

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

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

void	MoveTPToWire (TrajPoint &tp, float wire)

std::vector< unsigned int >	FindCloseHits (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)

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

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

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

short	MCSMom (TCSlice &slc, Trajectory &tj)

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

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

float	MCSThetaRMS (TCSlice &slc, Trajectory &tj)

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

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

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

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

void	UpdateVxEnvironment (std::string inFcnLabel, TCSlice &slc, VtxStore &vx2, bool prt)

TrajPoint	MakeBareTP (TCSlice &slc, Point3_t &pos, Vector3_t &dir, CTP_t inCTP)

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

bool	MakeBareTrajPoint (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 (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 (TCSlice &slc, TrajPoint &tp, HitStatus_t hitRequest)

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

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

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

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

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

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

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

void	SetPDGCode (TCSlice &slc, unsigned short itj, bool tjDone)

void	SetPDGCode (TCSlice &slc, Trajectory &tj, bool tjDone)

bool	AnalyzeHits ()

bool	LongPulseHit (const recob::Hit &hit)

bool	FillWireHitRange (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	PrintAll (std::string someText, const std::vector< simb::MCParticle * > &mcpList)

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

void	Print3V (std::string someText, mf::LogVerbatim &myprt, Vtx3Store &vx3)

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

void	Print3S (std::string someText, mf::LogVerbatim &myprt, ShowerStruct3D &ss3)

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

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

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

void	PrintHeader (std::string someText)

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

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

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

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

std::string	PrintHitShort (const TCHit &tch)

std::string	PrintHit (const TCHit &tch)

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

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

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

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

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

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

void	PrintClusters ()

Variables
constexpr unsigned int	Tpad = 10

constexpr unsigned int	Cpad = 10000

DebugStuff	debug

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

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

enum	Strategy_t { kNormal, kStiffEl, kStiffMu, kSlowing }

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

enum	TPEnvironment_t { kEnvDeadWire, kEnvNearTj, kEnvNearShower, kEnvOverlap, kEnvUnusedHits, kEnvClean, 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 >	StopFlagNames

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

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

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 41 of file DataStructs.h.

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

Definition at line 37 of file DataStructs.h.

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

Definition at line 35 of file DataStructs.h.

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

Definition at line 38 of file DataStructs.h.

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

Definition at line 36 of file DataStructs.h.

Enumeration Type Documentation

enum tca::AlgBit_t

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

Definition at line 346 of file DataStructs.h.

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

enum tca::HitStatus_t

Enumerator
kAllHits
kUsedHits
kUnusedHits

Definition at line 36 of file Utils.h.

                {
     kAllHits,
     kUsedHits,
     kUnusedHits,
   } HitStatus_t ;

enum tca::StopFlag_t

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

Definition at line 424 of file DataStructs.h.

                {
     kSignal,
     kAtKink,
     kAtVtx,
     kBragg,
     kAtTj,
     kOutFV,
     kFlagBitSize     
   } StopFlag_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 416 of file DataStructs.h.

                {
     kNormal,
     kStiffEl,       
     kStiffMu,       
     kSlowing        
   } 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 446 of file DataStructs.h.

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

enum tca::TPEnvironment_t

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

Definition at line 435 of file DataStructs.h.

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

enum tca::VtxBit_t

Enumerator
kVtxTrjTried	FindVtxTraj algorithm tried.
kFixed	vertex position fixed manually - no fitting done
kOnDeadWire
kHiVx3Score	matched to a high-score 3D vertex
kVtxTruMatch	tagged as a vertex between Tjs that are matched to MC truth neutrino interaction particles
kVtxMerged
kVtxIndPlnNoChg	vertex quality is suspect - No requirement made on chg btw it and the Tj
kVtxBitSize	don't mess with this line

Definition at line 72 of file DataStructs.h.

                {
     kVtxTrjTried,     
     kFixed,           
     kOnDeadWire,
     kHiVx3Score,      
     kVtxTruMatch,      
     kVtxMerged,
     kVtxIndPlnNoChg,  
     kVtxBitSize     
   } 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 3840 of file TCShower.cxx.

References tca::Trajectory::MCSMom, tca::TCConfig::showerTag, tca::TCSlice::slHits, tcc, and tca::TCSlice::tjs.

   {
     // 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 1091 of file StepUtils.cxx.

References AddLAHits(), tca::Trajectory::AlgMod, tca::TCEvent::allHits, tca::Trajectory::CTP, tca::TCConfig::dbgStp, DeadWireCount(), DecodeCTP(), DefineHitPos(), tca::TrajPoint::Delta, tca::TrajPoint::DeltaRMS, tca::TrajPoint::Dir, tca::Trajectory::EndPt, evt, ExpectedHitsRMS(), FindUseHits(), tca::TCSlice::firstWire, GetHitMultiplet(), tca::TrajPoint::Hits, tca::Trajectory::ID, kAtTj, kNewStpCuts, kRvPrp, kSlowing, kStiffEl, kStopAtTj, kUsedHits, tca::TCSlice::lastWire, LongPulseHit(), MoveTPToWire(), NumHitsInTP(), geo::PlaneID::Plane, PointTrajDOCA(), tca::TrajPoint::Pos, PrintHit(), tca::TCConfig::projectionErrFactor, tca::Trajectory::Pts, SetEndPoints(), tca::TCSlice::slHits, tca::Trajectory::StopFlag, tca::Trajectory::Strategy, tcc, tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, tca::TrajPoint::UseHit, and tca::TCSlice::wireHitRange.

Referenced by cluster::ClusterAndHitMerger::Add(), tca::TrajClusterAlg::ReconstructAllTraj(), and StepAway().

   {
     // 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);
     
     if(tcc.useAlg[kNewStpCuts]) {
       // 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 = 2.5;
     
     // 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(tcc.useAlg[kNewStpCuts] && !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(slc.wireHitRange[ipl][wire].first == -1) sigOK = true;
     if(slc.wireHitRange[ipl][wire].first < 0) return;
     unsigned int firstHit = (unsigned int)slc.wireHitRange[ipl][wire].first;
     unsigned int lastHit = (unsigned int)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(tcc.useAlg[kNewStpCuts] && longPulseHit) {
         if(delta > 3) continue;
       } else {
         if(delta > maxDeltaCut) continue;
       }
       float dt = std::abs(ftime - tp.Pos[1]);
       unsigned short localIndex = 0;
       GetHitMultiplet(slc, iht, hitsInMultiplet, localIndex);
       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()<<" localIndex "<<localIndex<<" 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(tcc.useAlg[kNewStpCuts] && 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;
       }
     }
     if(closeHits.empty() && imBig == UINT_MAX) {
       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.empty()) sigOK = true;
     if(!sigOK) return;
     if(closeHits.size() > 16) closeHits.resize(16);
     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();
     if(tcc.useAlg[kStopAtTj]) {
       // don't continue if we have run into another trajectory and there are no available hits
       unsigned short nAvailable = 0;
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         auto& tcHit = slc.slHits[tp.Hits[ii]];
         if(tcHit.InTraj == 0) ++nAvailable;
       } // ii
       if(nAvailable == 0) {
         tj.StopFlag[1][kAtTj] = true;
         return;
       }
     } // stop at Tj
     // decide which of these hits should be used in the fit. Use a generous maximum delta
     // and require a charge check if we'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 1277 of file StepUtils.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::AngleCode, tca::Trajectory::CTP, tca::TCConfig::dbgStp, DecodeCTP(), DefineHitPos(), DeltaAngle(), tca::TrajPoint::Dir, FindCloseHits(), tca::TrajPoint::Hits, tca::Trajectory::ID, kAllHits, kAtTj, kStopAtTj, tca::TCSlice::lastWire, geo::PlaneID::Plane, tca::TrajPoint::Pos, PrintHit(), PrintPos(), tca::Trajectory::Pts, PutTrajHitsInVector(), SetEndPoints(), tca::TCSlice::slHits, tca::Trajectory::StopFlag, tcc, tca::TCSlice::tjs, tca::TCConfig::unitsPerTick, UpdateTjChgProperties(), tca::TCConfig::useAlg, tca::TrajPoint::UseHit, tca::TCConfig::VLAStepSize, and tca::TCSlice::wireHitRange.

Referenced by AddHits().

   {
     // 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 == -1) sigOK = true;
       if(slc.wireHitRange[plane][wire].first < 0) 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();
     
     if(tcc.useAlg[kStopAtTj]) {
       // don't continue if we have run into another trajectory that has a similar angle
       unsigned short nAvailable = 0;
       unsigned int otherTjHit = INT_MAX;
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         auto& tcHit = slc.slHits[tp.Hits[ii]];
         if(tcHit.InTraj == SHRT_MAX) continue;
         if(tcHit.InTraj > 0) {
           otherTjHit = tp.Hits[ii];
           continue;
         }
         ++nAvailable;
       } // ii
       if(nAvailable == 0 && otherTjHit != UINT_MAX) {
         // get the trajectory index
         unsigned short otherTj = slc.slHits[otherTjHit].InTraj - 1;
         Trajectory& otj = slc.tjs[otherTj];
         // find out what point the hit is in
         unsigned short atPt = USHRT_MAX;
         for(unsigned short ipt = 0; ipt < otj.Pts.size(); ++ipt) {
           for(auto& iht : otj.Pts[ipt].Hits) {
             if(iht == otherTjHit) {
               atPt = ipt;
               break;
             } // iht == otherTjHit
           } // iht
           if(atPt != USHRT_MAX) break;
         } // ipt
         if(atPt != USHRT_MAX && DeltaAngle(tp.Ang, otj.Pts[atPt].Ang) < 0.1) {
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Found a VLA merge candidate trajectory "<<otj.ID<<". Set StopFlag[kAtTj] and stop stepping";
           tj.StopFlag[1][kAtTj] = true;
           return;
         } // atPt is valid
       } // nAvailable == 0 &&
     } // stop at Tj
     
     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 4002 of file TCShower.cxx.

References tca::TCEvent::allHits, tca::TCSlice::cots, tca::ShowerStruct::CTP, DecodeCTP(), tca::ShowerStruct::Envelope, evt, tca::TrajPoint::Hits, tca::Trajectory::ID, tca::ShowerStruct::ID, tca::TCSlice::lastWire, geo::PlaneID::Plane, PointInsideEnvelope(), tca::Trajectory::Pts, tca::ShowerStruct::ShowerTjID, tca::TCSlice::slHits, ss, tcc, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, tca::TCConfig::unitsPerTick, and tca::TCSlice::wireHitRange.

   {
     // Add hits that are inside the envelope to the shower if they are loose, i.e. not
     // used by any trajectory. This function returns true if the set of hits is different than
     // the current set. The calling function should update the shower if this is the case.
     
     ShowerStruct& ss = 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 < 0) continue;
       unsigned int firstHit = (unsigned int)slc.wireHitRange[ipl][wire].first;
       unsigned int lastHit = (unsigned int)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::AddMissedTj	(	TCSlice &	slc,
		PFPStruct &	pfp,
		unsigned short	itj,
		bool	looseCuts,
		bool	prt
	)

Definition at line 1159 of file PFPUtils.cxx.

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

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

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

Definition at line 1498 of file TCShower.cxx.

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

Referenced by Reconcile3D().

   {
     // Add the tjs in the pfp with id = pID to the 2D showers in ss3 and optionally update everything. This
     // function returns true if the addition was successful or if the Tjs in the pfp are already in ss3.
     // This function returns false if there was a failure. There isn't any error recovery.
     
     std::string fcnLabel = inFcnLabel + ".AddP";
 
     if(pID <= 0 || pID > (int)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;
         for(unsigned short ii = 0; ii < pfp.TjIDs.size(); ++ii) {
           if(pfp.TjIDs[ii] == tid) myprt<<" pfp TjCompleteness "<<std::fixed<<std::setprecision(2)<<pfp.TjCompleteness[ii];
         } // itj
         myprt<<" tj.SSID 2S"<<tj.SSID;
       } // prt
       // add it to the shower in the correct CTP
       for(auto& cid : ss3.CotIDs) {
         auto& ss = 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

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

Definition at line 1552 of file TCShower.cxx.

References tca::TCEvent::allHits, tca::TrajPoint::Chg, tca::Trajectory::CTP, tca::ShowerStruct::CTP, tca::Trajectory::EndPt, evt, tca::TrajPoint::Hits, tca::Trajectory::ID, tca::ShowerStruct::ID, tca::ShowerStruct::NearTjIDs, tca::ShowerStruct::NeedsUpdate, tca::Trajectory::Pts, tca::ShowerStruct::ShPts, tca::TCSlice::slHits, tca::Trajectory::SSID, tcc, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, tca::TCConfig::unitsPerTick, UpdateShower(), and tca::TrajPoint::UseHit.

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

   {
     // Adds the Tj to the shower and optionally updates the shower variables
     
     if(tjID <= 0 || tjID > (int)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 3929 of file TCShower.cxx.

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

Referenced by FindShowers3D().

    {
     // This function adds Tjs to the shower. It updates the shower parameters.
     
      if(ss.Envelope.empty()) return false;
      if(ss.ID == 0) return false;
      if(ss.TjIDs.empty()) return false;
      
      std::string fcnLabel = inFcnLabel + ".ATIE";
 
      if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" Checking 2S"<<ss.ID;
 
      std::vector<int> tmp(1);
      unsigned short nadd = 0;
      for(auto& tj : 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 3877 of file Utils.cxx.

References tca::TCEvent::allHits, tca::TCEvent::aveHitRMS, tca::TCEvent::aveHitRMSValid, evt, tca::TCConfig::geom, kDebug, tca::TCConfig::modes, geo::GeometryCore::Nplanes(), and tcc.

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

   {
     // 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 false;
     // 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) {
         std::cout<<"AnalyzeHits found bad plane\n";
         return false;
       } // plane check
       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::AnalyzePFP	(	TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 2421 of file PFPUtils.cxx.

References DefinePFP(), tca::PFPStruct::ID, kMat3D, tca::PFPStruct::NeedsUpdate, NumPtsWithCharge(), tca::PFPStruct::PDGCode, PFPVxTjOK(), tca::PFPStruct::TjCompleteness, tca::PFPStruct::TjIDs, tca::TCSlice::tjs, and tca::PFPStruct::Tp3s.

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

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

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

Definition at line 3102 of file TCShower.cxx.

References tca::ShowerStruct::DirectionFOM, tca::ShowerStruct::ID, tca::Trajectory::Pts, tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::ShPts, and tca::TCSlice::tjs.

Referenced by UpdateShower().

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

unsigned short tca::AngleRange ( TrajPoint const & tp )

Definition at line 716 of file Utils.cxx.

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

Referenced by CheckHiMultUnusedHits().

   {
     return AngleRange(tp.Ang);
   }

unsigned short tca::AngleRange ( float angle )

Definition at line 739 of file Utils.cxx.

References tca::TCConfig::angleRanges, and tcc.

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

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

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

Referenced by evd::RecoBaseDrawer::Slice2D().

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

Definition at line 1868 of file TCVertex.cxx.

References AttachTrajToVertex(), tca::VtxStore::CTP, tca::VtxStore::ID, kHaloTj, kKilled, tcc, tca::TCSlice::tjs, tca::VtxStore::Topo, tca::TCConfig::vtx2DCuts, and tca::TCSlice::vtxs.

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

   {
     
     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 nadd = 0;
     for(auto& tj : slc.tjs) {
       if(tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) continue;
       if(tj.CTP != vx.CTP) continue;
       if(tj.VtxID[0] == vx.ID || tj.VtxID[1] == vx.ID) continue;
       if(AttachTrajToVertex(slc, tj, vx, prt)) ++nadd;
     } // tj
     if(prt) mf::LogVerbatim("TC")<<" AttachAnyTrajToVertex: nadd "<<nadd;
     if(nadd == 0) return false;
     return true;
     
   } // AttachAnyTrajToVertex

bool tca::AttachPFPToVertex	(	TCSlice &	slc,
		PFPStruct &	pfp,
		unsigned short	end,
		unsigned short	vx3ID,
		bool	prt
	)

Definition at line 1830 of file TCVertex.cxx.

References DecodeCTP(), evd::details::end(), tca::PFPStruct::ID, tca::PFPStruct::PDGCode, tca::TCSlice::pfps, geo::PlaneID::Plane, PosInPlane(), tca::PFPStruct::TjIDs, tca::TCSlice::tjs, tca::TCSlice::vtx3s, and tca::PFPStruct::Vx3ID.

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

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

Definition at line 1893 of file TCVertex.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::ChgRMS, tca::VtxStore::CTP, tca::Trajectory::CTP, evd::details::end(), tca::Trajectory::EndPt, FitVertex(), tca::VtxStore::ID, tca::Trajectory::ID, kFixed, kHaloTj, kKilled, kNewVtxCuts, kNoFitToVx, kPhoton, tca::VtxStore::NTraj, tca::VtxStore::Pos, PosSep2(), tca::Trajectory::Pts, SetVx2Score(), SignalBetween(), tca::VtxStore::Stat, tcc, tca::TCSlice::tjs, TrajClosestApproach(), TrajLength(), TrajPointVertexPull(), tca::TCConfig::useAlg, tca::TCConfig::vtx2DCuts, and tca::Trajectory::VtxID.

Referenced by AttachAnyTrajToVertex(), and StepAway().

   {
     // 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(tcc.useAlg[kNewVtxCuts] && !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. Oct 5, 2018 This was too loose.
     if(tcc.useAlg[kNewVtxCuts]) {
       if(tjShort) pullCut *= 2;
     } else {
       if(tjShort) pullCut = 10;
     }
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"ATTV: 2V"<<vx.ID;
       myprt<<" NTraj "<<vx.NTraj;
       myprt<<" oldTJs";
       for(unsigned short itj = 0; itj < 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 > tcc.vtx2DCuts[3]) return false;
     if(tpVxPull > pullCut) return false;
     if(dpt > 2) return true;
     
     // remove the fixed position flag if there are more than 2 tjs
     bool fixedBit = vx.Stat[kFixed];
     if(fixedBit && vx.NTraj < 2) vx.Stat[kFixed] = false;
     
     // don't allow a short Tj with a large pull to bias the fit
     if(tjShort && tpVxPull > tcc.vtx2DCuts[3]) tj.AlgMod[kNoFitToVx] = true;
 
     // Passed all the cuts. Attach it to the vertex and try a fit
     tj.VtxID[end] = vx.ID;
     // flag as a photon Tj so it isn't included in the fit
     tj.AlgMod[kPhoton] = !signalBetween;
     // make a copy of the vertex and fit it
     auto vxTmp = vx;
     if(FitVertex(slc, vxTmp, prt)) {
       SetVx2Score(slc, vxTmp);
       if(prt) mf::LogVerbatim("TC")<<" Success";
       vx = vxTmp;
       return true;
     }
 
     // fit failed so remove the tj -> vx assignment if it is long and
     // set noFitToVtx if it is short
     if(tjShort) {
       tj.AlgMod[kNoFitToVx] = true;
       if(prt) mf::LogVerbatim("TC")<<" Poor fit. Keep short Tj "<<tj.ID<<" with kNoFitToVx";
       return true;
     } else {
       tj.VtxID[end] = 0;
       // restore the fixed flag
       vx.Stat[kFixed] = fixedBit;
       if(prt) mf::LogVerbatim("TC")<<" Poor fit. Removed Tj "<<tj.ID;
       return false;
     }
 
   } // AttachTrajToVertex

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

Definition at line 2526 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TCConfig::dbgStp, tca::Trajectory::EndPt, kBragg, kCHMEH, tca::Trajectory::Pts, SetEndPoints(), tca::Trajectory::StopFlag, tcc, UnsetUsedHits(), and tca::TCConfig::useAlg.

Referenced by CheckTraj().

   {
     // mask off high multiplicity TPs at the end
     if(!tcc.useAlg[kCHMEH]) return;
     if(tj.StopFlag[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 2378 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, AngleRange(), tca::TCConfig::dbgStp, DefineHitPos(), tca::Trajectory::EndPt, GottaKink(), tca::Trajectory::ID, tca::Trajectory::IsGood, kAtKink, kCHMUH, kUsedHits, MaskTrajEndPoints(), MaxHitDelta(), tca::TCConfig::minPtsFit, tca::Trajectory::NeedsUpdate, NumHitsInTP(), NumPtsWithCharge(), tca::Trajectory::Pass, PointTrajDOCA(), PrintHit(), PrintTrajectory(), tca::Trajectory::Pts, PutTrajHitsInVector(), SetEndPoints(), tca::TCSlice::slHits, tca::Trajectory::StopFlag, tcc, UnsetUsedHits(), UpdateTraj(), and tca::TCConfig::useAlg.

   {
     // 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);
     unsigned short killPts;
     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, killPts);
       if(killPts > 0) {
         MaskTrajEndPoints(slc, tj, killPts);
         if(!tj.IsGood) return;
         break;
       }
       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.StopFlag[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 898 of file StepUtils.cxx.

References tca::TCConfig::dbgStp, FillGaps(), FixTrajBegin(), kStiffEl, NumPtsWithCharge(), tca::Trajectory::Strategy, and tcc.

Referenced by CheckTraj().

   {
     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
     FixTrajBegin(slc, tj);
   } // CheckStiffTj

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

Definition at line 911 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, CheckHiMultEndHits(), CheckStiffEl(), ChkChgAsymmetry(), ChkStop(), ChkStopEndPts(), tca::TCConfig::dbgStp, tca::Trajectory::EndPt, FillGaps(), FixTrajBegin(), HasDuplicateHits(), HiEndDelta(), IsGhost(), tca::Trajectory::IsGood, tca::TCSlice::isValid, kAtKink, kBragg, kCTKink, kCTStepChk, kJunkTj, kKilled, kRvPrp, kSignal, kSlowing, kStiffEl, tca::Trajectory::MCSMom, MCSMom(), tca::TCConfig::minMCSMom, tca::TCConfig::minPts, NumPtsWithCharge(), tca::Trajectory::Pass, PrintTrajectory(), tca::Trajectory::Pts, tca::TCConfig::qualityCuts, SetEndPoints(), tca::Trajectory::StopFlag, tca::Trajectory::Strategy, TagJunkTj(), tcc, TrimEndPts(), UnsetUsedHits(), and tca::TCConfig::useAlg.

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

   {
     // 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;
     }
     
     // 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);
     // The last two ranges are Large Angle and Very Large Angle. Determine if the TJ is Small Angle
     bool isSA = (tj.Pts[tj.EndPt[1]].AngleCode == 0);
     
     // First remove any TPs at the end that have no hits after
     // setting the StopFlag. Assume that there are no hits on TPs after the end
     tj.StopFlag[1][kSignal] = false;
     if(tj.EndPt[1] < tj.Pts.size() - 1) {
       // There must be hits at the end so set the kSignal StopFlag
       if(!tj.Pts[tj.EndPt[1]+1].Hits.empty()) tj.StopFlag[1][kSignal] = true;
     }
     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];
     
     // Check for hit width consistency on short trajectories
     if(tj.Pts.size() < 10) {
       float maxWidth = 0;
       float minWidth = 999;
       for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
         if(tj.Pts[ipt].Chg == 0) continue;
         if(tj.Pts[ipt].HitPosErr2 > maxWidth) maxWidth = tj.Pts[ipt].HitPosErr2;
         if(tj.Pts[ipt].HitPosErr2 < minWidth) minWidth = tj.Pts[ipt].HitPosErr2;
       } // ipt
       // Require less than a 3X difference in the hit width or 10X for HitPosErr2
       if(maxWidth > 10 * minWidth) {
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<" TP width variation too large: minWidth "<<minWidth<<" maxWidth "<<maxWidth;
         tj.IsGood = false;
         return;
       }
     } // short trajectory
     
     // 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;
     }
     
     // Check for a Bragg peak at both ends. This may be used by FixTrajBegin.
     ChkStop(slc, tj);
     
     // Update the trajectory parameters at the beginning of the trajectory
     FixTrajBegin(slc, tj);
     
     // ignore short trajectories
     if(tj.EndPt[1] < 4) return;
     
     if(isSA && !tj.StopFlag[1][kBragg]) {
       // Small angle checks
       
       if(tcc.useAlg[kCTKink] && tj.EndPt[1] > 8 && !tj.StopFlag[1][kAtKink] && tj.MCSMom > 50) {
         // look for the signature of a kink near the end of the trajectory.
         // These are: Increasing delta for the last few hits
         unsigned short newSize = USHRT_MAX;
         unsigned short lastPtToChk = tj.EndPt[1] - 4;
         float deltaCut = 2 * tj.Pts[lastPtToChk].DeltaRMS;
         for(unsigned short ipt = tj.EndPt[1]; ipt > lastPtToChk; --ipt) {
           // Stop checking if delta is good
           if(tj.Pts[ipt].Delta < deltaCut) break;
           float drat = tj.Pts[ipt].Delta / tj.Pts[ipt-1].Delta;
           if(drat > 1.2) newSize = ipt;
         } // ipt
         if(newSize != USHRT_MAX) {
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<"CTKink: Masking end points to newSize "<<newSize;
           for(unsigned short ipt = newSize; ipt < tj.Pts.size(); ++ipt) UnsetUsedHits(slc, tj.Pts[ipt]);
           SetEndPoints(tj);
           tj.AlgMod[kCTKink] = true;
         }
       } // tcc.useAlg[kCTKink]
       
       if(tcc.useAlg[kCTStepChk] && !tj.AlgMod[kRvPrp]) {
         // Compare the number of steps taken per TP near the beginning and
         // at the end. This will get confused if RevProp is used
         short nStepBegin = tj.Pts[2].Step - tj.Pts[1].Step;
         short nStepEnd;
         unsigned short lastPt = tj.Pts.size() - 1;
         unsigned short newSize = tj.Pts.size();
         for(unsigned short ipt = lastPt; ipt > lastPt - 2; --ipt) {
           nStepEnd = tj.Pts[ipt].Step - tj.Pts[ipt - 1].Step;
           if(nStepEnd > 3 * nStepBegin) newSize = ipt;
         }
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"CTStepChk: check number of steps. newSize "<<newSize<<" tj.Pts.size() "<<tj.Pts.size();
         if(newSize < tj.Pts.size()) {
           for(unsigned short ipt = newSize; ipt < tj.Pts.size(); ++ipt) UnsetUsedHits(slc, tj.Pts[ipt]);
           SetEndPoints(tj);
           tj.AlgMod[kCTStepChk] = true;
           tj.Pts.resize(newSize);
           return;
         } // newSize < tj.Pts.size()
       } // tcc.useAlg[kCTStepChk]
     } // isSA
     // Oct 30, 2018. FindSoftKink needs work
 //    FindSoftKink(slc, tj);
     
     HiEndDelta(slc, tj);
     
     // 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")<<"CTStepChk: 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 FixTrajBegin.
     ChkStop(slc, tj);
     
     if(tcc.dbgStp && tj.Pts.size() < 100) PrintTrajectory("CTo", slc, tj, USHRT_MAX);
     
   } // CheckTraj

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

Definition at line 1406 of file Utils.cxx.

References tca::VtxStore::ChiDOF, tca::VtxStore::CTP, tca::TCConfig::dbgAlg, tca::TCConfig::dbgSlc, tca::TCConfig::dbgStp, evd::details::end(), tca::VtxStore::ID, kBeginChg, kBragg, kFixed, kFTBRvProp, kHaloTj, kKilled, kNewStpCuts, MakeVertexObsolete(), tca::VtxStore::NTraj, tca::VtxStore::Pass, tca::VtxStore::Pos, PrintPos(), SetVx2Score(), SplitTraj(), tca::VtxStore::Stat, StoreVertex(), tcc, tca::TCSlice::tjs, tca::VtxStore::Topo, tca::TCConfig::useAlg, and tca::TCSlice::vtxs.

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

   {
     // This function is called after the beginning of the tj has been inspected to see if
     // reverse propagation was warranted. Trajectory points at the beginning were removed by
     // this process.
     // A search has been made for a Bragg peak with nothing
     // found. Here we look for a charge pattern like the following, where C means large charge
     // and c means lower charge:
     // CCCCCCccccccc
     // The charge in the two regions should be fairly uniform. 
     
     // This function may split the trajectory so it needs to have been stored
     if(itj > slc.tjs.size() - 1) return;
     auto& tj = slc.tjs[itj];
     
     if(!tcc.useAlg[kBeginChg]) return;
     if(tj.StopFlag[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;
     if(tcc.useAlg[kNewStpCuts]) {
       // 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;
     } // NewStpCuts
     // 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);
     
     if(prt) mf::LogVerbatim("TC")<<"CTBC: Split T"<<tj.ID<<" at "<<PrintPos(slc, tj.Pts[breakPt].Pos)<<"\n";
     
   } // CheckTrajBeginChg

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

Definition at line 1702 of file Utils.cxx.

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

Referenced by SignalBetween().

   {
     // Returns the fraction of wires between tp.Pos[0] and toPos0 that have a hit 
     // on the line defined by tp.Pos and tp.Dir
     
     if(tp.Pos[0] < -0.4 || toPos0 < -0.4) return 0;
     int fromWire = std::nearbyint(tp.Pos[0]);
     int toWire = std::nearbyint(toPos0);
     
     if(fromWire == toWire) {
       return SignalAtTp(slc, 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(slc, 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	(	TCSlice &	slc,
		Point3_t	pos1,
		Point3_t	pos2
	)

Definition at line 2957 of file PFPUtils.cxx.

References detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, tca::TrajPoint::CTP, tca::TCConfig::detprop, dir, EncodeCTP(), tca::TCConfig::geom, tca::TCSlice::nPlanes, PointDirection(), tca::TrajPoint::Pos, PosSep(), SignalAtTp(), tcc, geo::TPCID::TPC, tca::TCSlice::TPCID, tca::TCConfig::unitsPerTick, geo::GeometryCore::WireCoordinate(), and tca::TCConfig::wirePitch.

Referenced by DotProd(), FindParent(), and ParentFOM().

   {
     // 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] = tcc.detprop->ConvertXToTicks(pos1[0], plane, slc.TPCID.TPC, slc.TPCID.Cryostat) * tcc.unitsPerTick;
         ++cnt;
         if(SignalAtTp(slc, tp)) ++sum;
       } // plane
     } // step
     if(cnt == 0) return -1;
     return sum / cnt;
     
   } // ChgFracBetween

float tca::ChgFracNearEnd	(	TCSlice &	slc,
		PFPStruct &	pfp,
		unsigned short	end
	)

Definition at line 2986 of file PFPUtils.cxx.

References ChgFracNearPos(), detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, tca::TCConfig::detprop, EncodeCTP(), tca::TCConfig::geom, tca::PFPStruct::ID, tca::TCSlice::nPlanes, tca::TCSlice::nWires, tcc, tca::PFPStruct::TjIDs, tca::TCSlice::tjs, geo::TPCID::TPC, tca::PFPStruct::TPCID, tca::TCSlice::TPCID, tca::TCConfig::unitsPerTick, geo::GeometryCore::WireCoordinate(), tca::TCSlice::wireHitRange, and tca::PFPStruct::XYZ.

Referenced by DotProd().

   {
     // 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;
 
     float sum = 0;
     float cnt = 0;
     // keep track of the lowest value and maybe reject it
     float lo = 1;
     float hi = 0;
     for(unsigned short plane = 0; plane < 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 pos;
         geo::PlaneID planeID = geo::PlaneID(pfp.TPCID.Cryostat, pfp.TPCID.TPC, plane);
         pos[0] = tcc.geom->WireCoordinate(pfp.XYZ[end][1], pfp.XYZ[end][2], planeID);
         if(pos[0] < -0.4) continue;
         // check for dead wires
         unsigned int wire = std::nearbyint(pos[0]);
         if(wire > slc.nWires[plane]) continue;
         if(slc.wireHitRange[plane][wire].first == -1) continue;
         pos[1] = tcc.detprop->ConvertXToTicks(pfp.XYZ[end][0], planeID) * tcc.unitsPerTick;
         float cf = ChgFracNearPos(slc, pos, tjids);
         if(cf < lo) lo = cf;
         if(cf > hi) hi = cf;
         sum += cf;
         ++cnt;
       } // tjid
     } // plane
     if(cnt == 0) return 0;
     if(cnt > 1 && lo < 0.3 && hi > 0.8) {
       sum -= lo;
       --cnt;
     }
     return sum / cnt;
   } // ChgFracNearEnd

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

Definition at line 2698 of file Utils.cxx.

References tca::TCEvent::allHits, DecodeCTP(), evt, FindCloseHits(), kAllHits, geo::PlaneID::Plane, tca::TCSlice::slHits, and tca::TCSlice::tjs.

Referenced by ChgFracNearEnd(), CompleteIncomplete3DVertices(), CompleteIncomplete3DVerticesInGaps(), EndMerge(), FindHammerVertices(), ParentFOM(), and SetVx2Score().

   {
     // returns the fraction of the charge in the region around pos that is associated with
     // the list of Tj IDs
     if(tjIDs.empty()) return 0;
     std::array<int, 2> wireWindow;
     Point2_t timeWindow;
     // 1/2 size of the region
     constexpr float NNDelta = 5; 
     wireWindow[0] = pos[0] - NNDelta;
     wireWindow[1] = pos[0] + NNDelta;
     timeWindow[0] = pos[1] - NNDelta;
     timeWindow[1] = pos[1] + NNDelta;
     // do some checking
     for(auto& tjID : tjIDs) if(tjID <= 0 || tjID > (int)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

void tca::ChgSlope	(	TCSlice &	slc,
		Trajectory &	tj,
		float &	slope,
		float &	slopeErr,
		float &	chiDOF
	)

Definition at line 1288 of file Utils.cxx.

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

Referenced by Forecast(), and SetStrategy().

   {
     // Fits the points with charge on the Tj and returns the charge slope, slope error and 
     // Chi/DOF
     ChgSlope(slc, tj, tj.EndPt[0], tj.EndPt[1], slope, slopeErr, chiDOF);
   } // ChgSlope

void tca::ChgSlope	(	TCSlice &	slc,
		Trajectory &	tj,
		unsigned short	fromPt,
		unsigned short	toPt,
		float &	slope,
		float &	slopeErr,
		float &	chiDOF
	)

Definition at line 1296 of file Utils.cxx.

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

Referenced by ChgSlope().

   {
     // Fits the points with charge on the Tj and returns the charge slope, slope error and 
     // Chi/DOF
     
     slope = -1000;
     slopeErr = 1000;
     chiDOF = 1000;
     
     // prepare to do the fit
     Point2_t inPt;
     Vector2_t outVec, outVecErr;
     float chgErr;
     // Initialize
     Fit2D(0, inPt, chgErr, outVec, outVecErr, chiDOF);
     float wire0 = -1;
     unsigned short cnt = 0;
     for(unsigned short ipt = fromPt; ipt <= toPt; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if(tp.Chg <= 0) continue;
       ++cnt;
       if(wire0 < 0) wire0 = tp.Pos[0];
       // Accumulate and save points
       inPt[0] = std::abs(tp.Pos[0] - wire0);
       inPt[1] = tp.Chg;
       // Assume 10% point-to-point charge fluctuations
       chgErr = 0.1 * tp.Chg;
       if(!Fit2D(2, inPt, chgErr, outVec, outVecErr, chiDOF)) break;
     } // tp
     if(cnt < 3) return;
     // do the fit and get the results
     if(!Fit2D(-1, inPt, chgErr, outVec, outVecErr, chiDOF)) return;
     slope = outVec[1];
     slopeErr = outVecErr[1];
   } // ChgSlope

float tca::ChgToMeV ( float chg )

Definition at line 4395 of file TCShower.cxx.

Referenced by FindParent(), MergeSubShowersTj(), ShowerEnergy(), and UpdateShower().

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

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

Definition at line 4560 of file TCShower.cxx.

References tca::TCSlice::cots, kKilled, tca::TCSlice::showers, ss, and tca::TCSlice::tjs.

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

   {
     // check tj - ss assns
     
     std::string fcnLabel = inFcnLabel + ".ChkAssns";
     for(auto& ss : 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::ChkChgAsymmetry	(	TCSlice &	slc,
		Trajectory &	tj,
		bool	prt
	)

Definition at line 1611 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::EndPt, tca::Trajectory::ID, kChkChgAsym, kNewStpCuts, tca::Trajectory::PDGCode, PrintTrajectory(), tca::Trajectory::Pts, SetEndPoints(), tcc, UnsetUsedHits(), and tca::TCConfig::useAlg.

Referenced by CheckTraj().

   {
     // looks for a high-charge point in the trajectory which may be due to the
     // trajectory crossing an interaction vertex. The properties of points on the opposite
     // sides of the high-charge point are analyzed. If significant differences are found, all points
     // near the high-charge point are removed as well as those from that point to the end
     if(!tcc.useAlg[kChkChgAsym]) return;
     if(tcc.useAlg[kNewStpCuts] && 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::ChkHiChgHits	(	TCSlice &	slc,
		CTP_t	inCTP
	)

Definition at line 4105 of file StepUtils.cxx.

References kKilled, kSplitHiChgHits, SplitHiChgHits(), tcc, tca::TCSlice::tjs, and tca::TCConfig::useAlg.

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

   {
     // Check allTraj trajectories in the current CTP to see if they are stopping
     if(!tcc.useAlg[kSplitHiChgHits]) return;
     
     for(size_t i = 0; i< slc.tjs.size(); ++i) {
       auto & tj = slc.tjs[i];
       if(tj.CTP != inCTP) continue;
       if(tj.AlgMod[kKilled]) continue;
       SplitHiChgHits(slc, tj);
     } // tj
     
   } // ChkHiChgHits

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

Definition at line 4049 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TCConfig::dbgAlg, tca::TCConfig::dbgStp, tca::Trajectory::EndPt, kMichel, tca::Trajectory::Pts, tcc, and tca::TCConfig::useAlg.

Referenced by MaskTrajEndPoints().

                                                                           {
     
     if(!tcc.useAlg[kMichel]) 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::ChkStop	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 3952 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TrajPoint::Chg, tca::TCConfig::chkStopCuts, tca::TCConfig::dbgAlg, tca::TCConfig::dbgStp, dir, evd::details::end(), tca::Trajectory::EndPt, Fit2D(), tca::Trajectory::ID, kBragg, kChkStop, kStiffEl, tca::Trajectory::MCSMom, tca::TrajPoint::Pos, tca::Trajectory::Pts, tca::Trajectory::StopFlag, tca::Trajectory::Strategy, tcc, and tca::TCConfig::useAlg.

Referenced by CheckTraj(), ChkStopEndPts(), Forecast(), and ReversePropagate().

   {
     // Sets the StopFlag[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.StopFlag[0][kBragg] = false;
     tj.StopFlag[1][kBragg] = false;
     if(!tcc.useAlg[kChkStop]) return;
     if(tcc.chkStopCuts[0] < 0) return;
     
     // don't attempt with low momentum trajectories
     if(tj.MCSMom < 30) 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) {
       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
       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;
 //        if(tcc.dbgStp) mf::LogVerbatim("TC")<<ipt<<"  "<<PrintPos(slc, tp.Pos)<<" "<<inPt[0]<<" Chg "<<(int)tp.Chg;
         ++cnt;
         if(cnt == nPtsToCheck) break;
       } // ii
       if(cnt < 4) 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];
       if(outVec[1] > tcc.chkStopCuts[0] && chiDOF < tcc.chkStopCuts[2] && outVec[1] > 2 * outVecErr[1]) {
         tj.StopFlag[end][kBragg] = true;
         tj.AlgMod[kChkStop] = true;
         // 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 1711 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, ChkStop(), tca::TrajPoint::CTP, tca::Trajectory::CTP, tca::TCConfig::dbgStp, DecodeCTP(), DefineHitPos(), tca::TrajPoint::Dir, tca::Trajectory::EndPt, FindCloseHits(), tca::Trajectory::ID, kAllHits, kBragg, kChkStopEP, kJunkTj, kNewStpCuts, kStiffEl, geo::PlaneID::Plane, tca::TrajPoint::Pos, PrintHit(), PrintPos(), tca::Trajectory::Pts, SetEndPoints(), tca::TCSlice::slHits, tca::Trajectory::StopFlag, tca::Trajectory::Strategy, tcc, tmp, UnsetUsedHits(), UpdateTjChgProperties(), and tca::TCConfig::useAlg.

Referenced by CheckTraj(), FixTrajBegin(), and ReversePropagate().

   {
     // Analyze the end of the Tj after crawling has stopped to see if any of the points
     // should be used
     // TODO: This function results in a small loss of efficiency and needs work. Perhaps by requir
     
     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);
     }
     
     // Check the charge and delta of the last point if there were many points fit
     // BB 11/26/ 2018 This is a bad idea for stopping tracks
     if(!tcc.useAlg[kNewStpCuts]) {
       if(lastTP.NTPsFit > 10 && lastTP.DeltaRMS > 0 && (lastTP.Delta / lastTP.DeltaRMS) > 3 && lastTP.ChgPull > 3) {
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Removing last TP with large Delta "<<lastTP.Delta<<" and large ChgPull "<<lastTP.ChgPull;
         UnsetUsedHits(slc, lastTP);
         tj.AlgMod[kChkStopEP] = true;
         SetEndPoints(tj);
         // check again
         auto& tp = tj.Pts[tj.EndPt[1]];
         if(tp.DeltaRMS > 0 && (tp.Delta / tp.DeltaRMS) > 3 && tp.ChgPull > 3) {
           UnsetUsedHits(slc, tp);
           SetEndPoints(tj);
         }
         return;
       }
     }
     
     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.StopFlag[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 2326 of file TCVertex.cxx.

References DecodeCTP(), evd::details::end(), kHaloTj, kKilled, geo::PlaneID::Plane, tca::TCSlice::tjs, tca::TCSlice::vtx3s, and tca::TCSlice::vtxs.

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

   {
     // Check the associations
 
     // check the 2D -> 3D associations
     geo::PlaneID planeID = DecodeCTP(inCTP);
     unsigned short plane = planeID.Plane;
     for(auto& vx2 : 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::ChkVxTjs	(	TCSlice &	slc,
		const CTP_t &	inCTP,
		bool	prt
	)

Definition at line 874 of file TCVertex.cxx.

References close(), CompatibleMerge(), DeltaAngle(), FarEnd(), GetAssns(), tca::TCSlice::ID, kChkVxTj, kDeltaRay, kFixed, kHaloTj, kKilled, kNewVtxCuts, kOnDeadWire, MakeVertexObsolete(), MergeAndStore(), PointTrajDOCA(), PosSep(), PrintPos(), tcc, tca::TCSlice::tjs, tca::TCConfig::useAlg, and tca::TCSlice::vtxs.

Referenced by EndMerge(), and Find2DVertices().

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

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

void tca::ClearCRInfo ( TCSlice & slc )

Definition at line 118 of file TCCR.cxx.

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

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

Definition at line 2251 of file Utils.cxx.

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

Referenced by MergeWithVertex().

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

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

Definition at line 534 of file Utils.cxx.

References evd::details::end(), tca::TCSlice::tjs, and TrajClosestApproach().

Referenced by ChkVxTjs(), DefinePFP(), and EndMerge().

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

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

Definition at line 605 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::CTP, DeltaAngle(), tca::Trajectory::EndPt, tca::Trajectory::ID, kHaloTj, tca::TCConfig::kinkCuts, kKilled, OverlapFraction(), PointTrajDOCA(), PosSep(), tca::Trajectory::Pts, and tcc.

   {
     // 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]];
 /* This causes problems with hit collections that have cosmics removed
     if(!SignalBetween(slc, tp1, tp2, 0.8, false)) {
       if(prt) mf::LogVerbatim("TC")<<"CM: "<<tj1.ID<<" "<<tj2.ID<<" no signal between these points "<<PrintPos(slc, tp1.Pos)<<" "<<PrintPos(slc, tp2.Pos);
       return false;
     }
 */
     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 ( TCSlice & slc )

Definition at line 2759 of file TCVertex.cxx.

References AttachAnyTrajToVertex(), ChgFracNearPos(), detinfo::DetectorProperties::ConvertXToTicks(), tca::VtxStore::CTP, tca::TCConfig::dbgAlg, tca::TCConfig::dbgSlc, tca::TCConfig::detprop, EncodeCTP(), evd::details::end(), GetAssns(), tca::VtxStore::ID, tca::TCSlice::ID, kComp3DVx, kDebug, kFixed, kHaloTj, kKilled, kVtxIndPlnNoChg, MakeVertexObsolete(), tca::TCConfig::modes, tca::TCSlice::nPlanes, tca::VtxStore::NTraj, NumPtsWithCharge(), tca::VtxStore::Pass, tca::VtxStore::Pos, tca::TrajPoint::Pos, PrintPos(), SetPDGCode(), SetVx2Score(), SplitTraj(), tca::VtxStore::Stat, StoreVertex(), tcc, tca::VtxStore::TjChgFrac, tca::TCSlice::tjs, util::flags::to_string(), tca::VtxStore::Topo, TrajPointTrajDOCA(), tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, tca::TCSlice::vtx3s, tca::TCSlice::vtxs, and tca::VtxStore::Vx3ID.

Referenced by Find3DVertices().

   {
     // Look for trajectories in a plane that lack a 2D vertex as listed in
     // 2DVtxID that are near the projected wire. This may trigger splitting trajectories,
     // assigning them to a new 2D vertex and completing 3D vertices
     
     if(!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[kVtxIndPlnNoChg]) 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] = tcc.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 itj ID "<<tj.ID<<" vtx pos "<<PrintPos(slc, vtp.Pos)<<" doca "<<doca;
         tjIDs.push_back(tj.ID);
         tjPts.push_back(closePt);
       } // itj
       if(tjIDs.empty()) continue;
       // compare the length of the Tjs used to make the vertex with the length of the
       // Tj that we want to split. Don't allow a vertex using very short Tjs to split a long
       // Tj in the 3rd plane
 //      float score;
 //      auto vxtjs = GetVtxTjIDs(slc, vx3, score);
       auto vxtjs = GetAssns(slc, "3V", vx3.ID, "T");
       unsigned short maxPts = 0;
       for(auto tjid : vxtjs) {
         auto& tj = slc.tjs[tjid - 1];
         unsigned short npwc = NumPtsWithCharge(slc, tj, false);
         if(npwc > maxPts) maxPts = npwc;
       } // tjid
       // skip this operation if any of the Tjs in the split list are > 3 * maxPts
       maxPts *= 3;
       bool skipit = false;
       for(auto tjid : tjIDs) {
         auto& tj = slc.tjs[tjid - 1];
         if(NumPtsWithCharge(slc, tj, false) > maxPts) skipit = true;
       } // tjid
       if(prt) mf::LogVerbatim("TC")<<"  maxPts "<<maxPts<<" skipit? "<<skipit;
       if(skipit) continue;
       // 2D vertex
       VtxStore aVtx;
       unsigned short newVtxIndx = 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;
       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 2D vertex "<<newVtx.ID;
       // make a temporary copy so we can nudge it a bit if there is only one Tj
       std::array<float, 2> vpos = aVtx.Pos;
       for(unsigned short ii = 0; ii < tjIDs.size(); ++ii) {
         unsigned short itj = tjIDs[ii] - 1;
         // Don't use a reference variable since it may get scrambled after SplitTraj
 //        auto& tj = slc.tjs[itj];
         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(dpt < 3) {
           // 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, true);
           // and for the new trajectory
           SetPDGCode(slc, slc.tjs.size()-1, true);
         } // 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 ( TCSlice & slc )

Definition at line 2669 of file TCVertex.cxx.

References ChgFracNearPos(), detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, tca::VtxStore::CTP, tca::TrajPoint::CTP, tca::TCConfig::dbgAlg, tca::TCConfig::dbgSlc, DeadWireCount(), tca::TCConfig::detprop, EncodeCTP(), evd::details::end(), tca::VtxStore::ID, tca::Vtx3Store::ID, kComp3DVxIG, kDebug, kHaloTj, kKilled, tca::TCConfig::modes, tca::TCSlice::nPlanes, tca::VtxStore::NTraj, tca::VtxStore::Pass, PointTrajDOCA(), tca::VtxStore::Pos, tca::TrajPoint::Pos, SetVx2Score(), StoreVertex(), tcc, tca::VtxStore::TjChgFrac, tca::TCSlice::tjs, tca::VtxStore::Topo, geo::TPCID::TPC, tca::Vtx3Store::TPCID, tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, tca::TCSlice::vtx3s, tca::TCSlice::vtxs, tca::Vtx3Store::Vx2ID, tca::VtxStore::Vx3ID, tca::Vtx3Store::Wire, and tca::Vtx3Store::X.

Referenced by Find3DVertices().

   {
     
     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.CStat, vx3.TPC, mPlane);
       CTP_t mCTP = EncodeCTP(vx3.TPCID.Cryostat, vx3.TPCID.TPC, mPlane);
       // require that the missing vertex be in a large block of dead wires
       float dwc = DeadWireCount(slc, vx3.Wire - 4, vx3.Wire + 4, mCTP);
       if(dwc < 5) continue;
       // X position of the purported missing vertex
       // A TP for the missing 2D vertex
       VtxStore aVtx;
       aVtx.ID = slc.vtxs.size() + 1;
       aVtx.Pos[0] = vx3.Wire;
       aVtx.Pos[1] = tcc.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 739 of file TCShower.cxx.

References ChkAssns(), tca::ShowerStruct3D::CotIDs, tca::TCSlice::cots, CreateSS(), DecodeCTP(), evd::details::end(), GetAssns(), tca::ShowerStruct3D::ID, tca::TCSlice::ID, kCompleteShower, MakeShowerObsolete(), tca::ShowerStruct3D::NeedsUpdate, tca::TCSlice::nPlanes, tca::TCSlice::pfps, geo::PlaneID::Plane, SetIntersection(), ShowerEnergy(), ss, StoreShower(), tcc, tca::TCSlice::tjs, UpdateShower(), tca::TCConfig::useAlg, and tca::TCSlice::vtxs.

Referenced by Match2DShowers().

   {
     // Find low-energy two-plane showers and try to complete it by making a 2D shower in the third
     // plane using 3D matched tjs
     
     if(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 15 of file TCShower.cxx.

References tca::TCConfig::showerParentReader, and tca::TCConfig::showerParentVars.

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

   {
     // 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) {
       std::cout<<"its not defined\n";
       return;
     }
     std::string fullFileSpec;
     sp.find_file(fMVAShowerParentWeights, fullFileSpec);
     if(fullFileSpec == "") {
       std::cout<<"ConfigureMVA: weights file "<<fMVAShowerParentWeights<<" not found in path\n";
       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

PFPStruct tca::CreateFakePFP	(	TCSlice &	slc,
		const ShowerStruct3D &	ss3
	)

Definition at line 1981 of file TCShower.cxx.

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

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

PFPStruct tca::CreatePFP ( TCSlice & slc )

Definition at line 1973 of file PFPUtils.cxx.

References tca::PFPStruct::dEdx, tca::PFPStruct::dEdxErr, tca::PFPStruct::Dir, tca::PFPStruct::DirErr, evd::details::end(), tca::PFPStruct::ID, tca::TCSlice::nPlanes, tca::PFPStruct::ParentUID, tca::TCSlice::pfps, tca::PFPStruct::TPCID, tca::TCSlice::TPCID, and tca::PFPStruct::XYZ.

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

   {
     // The calling function should define the size of pfp.TjIDs
     PFPStruct pfp;
     pfp.ID = 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, 0);
       pfp.dEdx[1].resize(slc.nPlanes, 0);
       pfp.dEdxErr[0].resize(slc.nPlanes, 0);
       pfp.dEdxErr[1].resize(slc.nPlanes, 0);
     }
     for(unsigned short end = 0; end < 2; ++end) {
       // BUG the double brace syntax is required to work around clang bug 21629
       // (https://bugs.llvm.org/show_bug.cgi?id=21629)
       pfp.Dir[end] = {{0.0, 0.0, 0.0}};
       pfp.DirErr[end] = {{0.0, 0.0, 0.0}};
       pfp.XYZ[end] = {{0.0, 0.0, 0.0}};
     }
     return pfp;
   } // CreatePFP

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

Definition at line 4514 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::TCSlice::cots, tca::Trajectory::CTP, tca::ShowerStruct::CTP, tca::Trajectory::EndPt, tca::ShowerStruct::Envelope, tca::Trajectory::ID, tca::ShowerStruct::ID, kShowerTj, tca::Trajectory::PDGCode, tca::Trajectory::Pts, tca::ShowerStruct::ShowerTjID, ss, tca::ShowerStruct::TjIDs, and tca::TCSlice::tjs.

Referenced by CompleteIncompleteShower(), FindShowers3D(), and MergeShowers().

   {
     // Create a shower and shower Tj using Tjs in the list. If tjl is empty a
     // MC cheat shower is created inCTP. Note that inCTP is only used if tjl is empty.
     // A companion shower tj is created and stored but the ShowerStruct is not.
     ShowerStruct ss;
     
     // 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 4495 of file TCShower.cxx.

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

Referenced by Match2DShowers().

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

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

Definition at line 1881 of file Utils.cxx.

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

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

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

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

Definition at line 1887 of file Utils.cxx.

References DecodeCTP(), tca::TCSlice::nWires, geo::PlaneID::Plane, tmp, and tca::TCSlice::wireHitRange.

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

   {
     if(inWirePos1 < -0.4 || inWirePos2 < -0.4) return 0;
     unsigned int inWire1 = std::nearbyint(inWirePos1);
     unsigned int inWire2 = std::nearbyint(inWirePos2);
     geo::PlaneID planeID = DecodeCTP(tCTP);
     unsigned short plane = planeID.Plane;
     if(inWire1 > 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(slc.wireHitRange[plane][wire].first == -1) ++ndead;
     return ndead;
   } // DeadWireCount

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

Definition at line 108 of file DataStructs.cxx.

References Cpad, and Tpad.

Referenced by AddHits(), AddLAHits(), AddLooseHits(), AttachPFPToVertex(), ChgFracNearPos(), ChkStopEndPts(), ChkVtxAssociations(), CompleteIncompleteShower(), DeadWireCount(), DefineDontCluster(), DefinePFP(), EncodeCTP(), ExpectedHitsRMS(), FilldEdx(), FillmAllTraj(), Find2DVertices(), Find3DVertices(), FindCloseHits(), FindCloseTjs(), FindCompleteness(), tca::TrajClusterAlg::FindJunkTraj(), FindMissedTjsInTp3s(), FindVtxTjs(), FindXMatches(), Finish3DShowers(), FitTp3(), FitTp3s(), cluster::ClusterCrawlerAlg::FitVtx(), FixTrajBegin(), FollowTp3s(), Forecast(), cluster::ClusterCrawlerAlg::GetHitRange(), MakeBareTP(), MakeJunkVertices(), MakeTp3(), MakeVertexObsolete(), Match2DShowers(), Match3DFOM(), tca::TruthMatcher::MatchAndSum(), MaxChargeAsymmetry(), MergePFPTjs(), Print2V(), PrintAllTraj(), cluster::TrajCluster::produce(), tca::TrajClusterAlg::ReconstructAllTraj(), ReversePropagate(), SaveTjInfo(), SaveTjInfoStuff(), SetVx2Score(), SignalAtTp(), Split3DKink(), SplitTraj(), SplitTrajCrossingVertices(), StepAway(), TrimEndPts(), UpdateMatchStructs(), UpdateShower(), UpdateTp3s(), VtxHitsSwap(), cluster::ClusterCrawlerAlg::VtxMatch(), and WireHitRangeOK().

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

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

   {
     // 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 <plane>' to debug 2D vertex finding in plane <plane>\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<<" 'DeltaRay' to debug delta ray tagging\n";
       std::cout<<" 'Muon' to debug muon tagging\n";
       std::cout<<" '2S <plane>' to debug a 2D shower in plane <plane>\n";
       std::cout<<" 'Reco <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("PFP")  != std::string::npos) { tcc.dbgPFP = 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("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.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) {
       // 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]);
       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.Plane = std::stoi(words[1]);
       tcc.dbg2V = true;
       tcc.modes[kDebug] = true;
       return true;
     }
     if(words.size() == 2 && words[0] == "2S") {
       debug.Plane = 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;
     }
     if(words.size() == 2 && words[0] == "Reco") {
       tcc.recoSlice = std::stoi(words[1]);
       std::cout<<"Reconstructing Slice "<<tcc.recoSlice<<"\n";
       return true;
     }
     return false;
   } // DecodeDebugString

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

Definition at line 3329 of file TCShower.cxx.

References DecodeCTP(), tca::TCSlice::dontCluster, DotProd(), GetAssns(), tca::TCSlice::ID, IsShowerLike(), kDebug, tca::TCConfig::modes, PFPDOCA(), tca::TCSlice::pfps, geo::PlaneID::Plane, PointDirection(), PosSep(), t1, t2, tcc, tca::DontClusterStruct::TjIDs, tca::TCSlice::tjs, tca::TCSlice::vtx3s, tca::DontClusterStruct::Vx2ID, and tca::DontClusterStruct::Vx3ID.

Referenced by FindShowers3D().

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

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

Definition at line 3869 of file TCShower.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::Chg, tca::ShowerStruct::ChgDensity, tca::TrajPoint::DeltaRMS, tca::ShowerStruct::Envelope, tca::ShowerStruct::EnvelopeArea, tca::ShowerStruct::ID, SortEntry::length, tca::ShowerStruct::NeedsUpdate, tca::TrajPoint::Pos, PosSep(), tca::Trajectory::Pts, tca::TCConfig::showerTag, tca::ShowerStruct::ShowerTjID, tcc, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, and tca::TCConfig::unitsPerTick.

Referenced by ReverseShower(), and UpdateShower().

   {
     
     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 1840 of file StepUtils.cxx.

References tca::TCEvent::allHits, tca::TrajPoint::Chg, tca::TCConfig::dbgStp, tca::TrajPoint::Dir, evt, tca::TrajPoint::HitPos, tca::TrajPoint::HitPosErr2, tca::TrajPoint::Hits, HitsTimeErr2(), HitTimeErr(), kNewStpCuts, LongPulseHit(), tca::TCSlice::slHits, tcc, tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, and tca::TrajPoint::UseHit.

Referenced by AddHits(), AddLAHits(), CheckHiMultUnusedHits(), ChkStopEndPts(), FillGaps(), Forecast(), MakeHaloTj(), MakeJunkTraj(), MaskedHitsOK(), StepAway(), and UpdateTraj().

   {
     // 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(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(tcc.useAlg[kNewStpCuts] && 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

bool tca::DefinePFP	(	std::string	inFcnLabel,
		TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 2233 of file PFPUtils.cxx.

References CompatibleMerge(), DecodeCTP(), evd::details::end(), FindCompleteness(), FollowTp3s(), tca::PFPStruct::ID, kHaloTj, kKilled, kMat3D, kMat3DMerge, tca::TCConfig::match3DCuts, tca::TCSlice::matchVec, tca::PFPStruct::MatchVecIndex, MaxTjLen(), MCSMom(), MergePFPTjs(), tca::PFPStruct::NeedsUpdate, tca::TCSlice::nPlanes, tca::PFPStruct::PDGCode, PFPVxTjOK(), geo::PlaneID::Plane, PosSep(), SetIntersection(), SetStart(), SharesHighScoreVx(), tcc, tca::PFPStruct::TjIDs, tca::TCSlice::tjs, tca::PFPStruct::Tp3s, tca::TCConfig::useAlg, tca::TCSlice::vtxs, and tca::PFPStruct::Vx3ID.

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

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

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

Definition at line 2530 of file PFPUtils.cxx.

References GetAssns(), IsShowerLike(), kDebug, kTestBeam, tca::TCConfig::modes, tca::TCSlice::nPlanes, PDGCodeVote(), tca::TCSlice::pfps, tcc, tca::TCSlice::tjs, and tca::TCSlice::vtxs.

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

   {
     /*
      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;
         if(cnt3 != slc.nPlanes && tcc.modes[kDebug]) {
           std::cout<<"DPFPR: Missed an end vertex for PFP "<<pfp.ID<<" Write some code\n";
         }
       } // cnt3 > 1
     } // pfp
     
     // Assign a PDGCode to each PFParticle and look for a parent
     for(auto& pfp : slc.pfps) {
       if(pfp.ID == 0) continue;
       // skip a neutrino PFParticle
       if(pfp.PDGCode == 12 || pfp.PDGCode == 14 || pfp.PDGCode == 22) continue;
       pfp.PDGCode = PDGCodeVote(slc, pfp.TjIDs, prt);
       // 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
 
 /* TODO: This needs work
     if(tcc.modes[kTestBeam]) {
       DefinePFPParentsTestBeam(slc, prt);
       return;
     }
 */
     // 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;
         pfp.Primary = true;
         neutrinoPFP.DtrUIDs.push_back(pfp.ID);
         if(pfp.PDGCode == 111) neutrinoPFP.PDGCode = 12;
       } // pfp
     } // neutrino PFP exists    
   } // DefinePFPParents

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

Definition at line 2661 of file PFPUtils.cxx.

References GetPFPIndex(), GetVtxTjIDs(), tca::TCSlice::pfps, SetDifference(), tca::TCSlice::vtx3s, and tca::TCSlice::zLo.

Referenced by DotProd().

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

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

Definition at line 129 of file Utils.cxx.

References CreatePFP(), evd::details::end(), GetVtxTjIDs(), SortEntry::index, kDeltaRay, kHaloTj, kKilled, kTestBeam, tca::TCConfig::match3DCuts, tca::TCConfig::modes, ReverseTraj(), StorePFP(), tcc, tca::TCSlice::tjs, TrajTrajDOCA(), valDecreasing(), tca::TCConfig::vtx2DCuts, tca::TCSlice::vtx3s, and tca::TCSlice::vtxs.

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

   {
 /*
     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) {
         // Temp? Check for an existing parentID
         auto& tj = slc.tjs[tjid - 1];
         if(tj.ParentID != 0) {
 //          std::cout<<"**** Tj "<<tj.ID<<" Existing parent "<<tj.ParentID<<" PDGCode "<<tj.PDGCode<<". with a vertex... \n";
           tj.ParentID = 0;
         }
         if(std::find(masterlist.begin(), masterlist.end(), tjid) == masterlist.end()) masterlist.push_back(tjid);
       } // tjid
     } // vxid
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"DTP: masterlist Tjs";
       for(auto tjid : masterlist) myprt<<" "<<tjid;
     }
     
     // Do the sort
     std::vector<SortEntry> sortVec(temp.size());
     for(unsigned short indx = 0; indx < temp.size(); ++indx) {
       auto& vx3 = 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(), valDecreasing);
     // put them into order
     auto vlist = temp;
     for(unsigned short indx = 0; indx < temp.size(); ++indx) vlist[indx] = temp[sortVec[indx].index];
     
     // make a neutrino PFParticle to associate with the highest score vertex if it is high enough
     if(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
         neutrinoPFP.XYZ[1][0] = vx3.X;
         neutrinoPFP.XYZ[1][1] = vx3.Y;
         neutrinoPFP.XYZ[1][2] = vx3.Z;
         neutrinoPFP.XYZ[0] = neutrinoPFP.XYZ[1];
         neutrinoPFP.Dir[1][2] = 1;
         neutrinoPFP.Dir[0][2] = 1;
         // This may be set to 12 later on if a primary shower is reconstructed 
         neutrinoPFP.PDGCode = 14;
         neutrinoPFP.Vx3ID[1] = vx3.ID;
         neutrinoPFP.Vx3ID[0] = vx3.ID;
         neutrinoPFP.NeedsUpdate = false;
         // the rest of this will be defined later
         if(!StorePFP(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) {
 //              std::cout<<"DTP Error: dtr "<<dtrID<<" already has a parent "<<dtj.ParentID<<". Can't make it daughter of "<<primTjID<<"\n";
               continue;
             }
             pardtr.push_back(std::make_pair(primTjID, dtrID));
             if(prt) mf::LogVerbatim("TC")<<"  primTj "<<primTjID<<" dtrID "<<dtrID;
           } // tjid
         } // end
         // Ensure that end 0 of the trajectory is attached to the primary vertex
         for(unsigned short end = 0; end < 2; ++end) {
           if(primTj.VtxID[end] == 0) continue;
           auto& vx2 = 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) {
 //        std::cout<<"Tj "<<tj.ID<<" is in the master list but doesn't have a Parent\n";
         tj.ParentID = tj.ID;
       }
     } // tjid
 
   } // DefineTjParents

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

Definition at line 1636 of file PFPUtils.cxx.

References DotProd().

Referenced by AddLAHits(), ChkVxTjs(), DotProd(), EndMerge(), FindHammerVertices(), FindHammerVertices2(), FindSoftKink(), FindXMatches(), KinkAngle(), ParentFOM(), PrintTp3s(), SetVx2Score(), SplitTrajCrossingVertices(), and StepAway().

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

References DeltaAngle2().

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

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

Definition at line 2858 of file Utils.cxx.

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

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

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

Definition at line 2848 of file Utils.cxx.

Referenced by DeltaAngle(), and DotProd().

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

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

Definition at line 3313 of file TCShower.cxx.

References tca::TCSlice::dontCluster.

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

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

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

Referenced by DefineDontCluster(), DeltaAngle(), FindAlongTrans(), FindParent(), FindShowerStart(), recob::Seed::GetPointingSign(), InShowerProb(), MergeOverlap(), and StitchPFPs().

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

References AnalyzeHits(), DecodeDebugString(), DeltaAngle(), DeltaAngle2(), dir, DumpTj(), evd::details::end(), FarEnd(), FillWireHitRange(), Fit2D(), GetAssns(), GetSliceIndex(), HitsPosTick(), HitsPosTime(), HitsRMSTick(), HitsRMSTime(), LongPulseHit(), MakeBareTP(), MakeBareTrajPoint(), MCSMom(), MCSThetaRMS(), MergeAndStore(), NearestPtWithChg(), NumHitsInTP(), NumUsedHitsInTj(), PointDirection(), Print2V(), Print3S(), Print3V(), PrintAll(), PrintAllTraj(), PrintClusters(), PrintHeader(), PrintHit(), PrintHitShort(), PrintP(), PrintPFP(), PrintPFPs(), PrintPos(), PrintStopFlag(), PrintT(), PrintTrajectory(), PrintTrajPoint(), SetDifference(), SetEndPoints(), SetIntersection(), SetPDGCode(), StartTraj(), TagDeltaRays(), TjDeltaRMS(), TPHitsRMSTick(), TPHitsRMSTime(), TrajIsClean(), UpdateTjChgProperties(), UpdateVxEnvironment(), and WireHitRangeOK().

144 {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 4237 of file TCShower.cxx.

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

   {
     // Print the shower points to the screen. The user should probably pipe the output to a text file
     // then grep this file for the character string PTS which is piped to a text file which can then be
     // imported into Excel, etc
     // Finds the charge at the start of a shower
     if(cotID > (int)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 4728 of file Utils.cxx.

References tca::TCEvent::allHits, debug, evt, kKilled, slices, tcc, util::flags::to_string(), tca::TCConfig::unitsPerTick, and tca::DebugStuff::WorkID.

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

   {
     // 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.AlgMod[kKilled]) continue;
         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, TPErr\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(2)<<tp.Ang;
           outfile<<","<<std::setprecision(2)<<sqrt(tp.HitPosErr2);
           outfile<<"\n";
         } // ipt
         outfile.close();
         std::cout<<"Points on T"<<tj.UID<<" dumped to "<<fname<<"\n";
         return;
       } // tj
     } // slc
 
   } // DumpTj

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

Definition at line 2679 of file Utils.cxx.

References tca::Trajectory::ChgRMS, tca::Trajectory::EndPt, kBragg, NumPtsWithCharge(), tca::Trajectory::StopFlag, and TjDeltaRMS().

Referenced by tca::TruthMatcher::MatchAndSum(), and tca::TruthMatcher::MatchTruth().

   {
     // returns a number between 0 (not electron-like) and 1 (electron-like)
     if(NumPtsWithCharge(slc, tj, false) < 8) return -1;
     if(tj.StopFlag[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);
     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 45 of file DataStructs.h.

Referenced by ChgFracBetween(), ChgFracNearEnd(), CompleteIncomplete3DVertices(), CompleteIncomplete3DVerticesInGaps(), tca::TrajClusterAlg::CreateSlice(), EncodeCTP(), cluster::ClusterCrawlerAlg::FindHammerClusters(), FindMissedTjsInTp3s(), tca::TrajClusterAlg::FindMissedVxTjs(), FindParent(), FindPFParticles(), FindShowers3D(), FindXMatches(), MakeBareTrajPoint(), MergePFPTjs(), Print3S(), PrintShowers(), cluster::TrajCluster::produce(), cluster::ClusterCrawlerAlg::RunCrawler(), tca::TrajClusterAlg::RunTrajClusterAlg(), StartTraj(), cluster::ClusterCrawlerAlg::TmpStore(), cluster::ClusterCrawlerAlg::Vtx3ClusterMatch(), and cluster::ClusterCrawlerAlg::Vtx3ClusterSplit().

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

tca::Tpad

constexpr unsigned int Tpad

Definition: DataStructs.h:42

tca::Cpad

constexpr unsigned int Cpad

Definition: DataStructs.h:43

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

inline

Definition at line 46 of file DataStructs.h.

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

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

geo::CryostatID::Cryostat

CryostatID_t Cryostat

Index of cryostat.

Definition: geo_types.h:130

geo::PlaneID::Plane

PlaneID_t Plane

Index of the plane within its TPC.

Definition: geo_types.h:258

tca::EncodeCTP

CTP_t EncodeCTP(const geo::WireID &wireID)

Definition: DataStructs.h:47

geo::TPCID::TPC

TPCID_t TPC

Index of the TPC within its cryostat.

Definition: geo_types.h:203

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

inline

Definition at line 47 of file DataStructs.h.

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

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

geo::CryostatID::Cryostat

CryostatID_t Cryostat

Index of cryostat.

Definition: geo_types.h:130

geo::PlaneID::Plane

PlaneID_t Plane

Index of the plane within its TPC.

Definition: geo_types.h:258

tca::EncodeCTP

CTP_t EncodeCTP(const geo::WireID &wireID)

Definition: DataStructs.h:47

geo::TPCID::TPC

TPCID_t TPC

Index of the TPC within its cryostat.

Definition: geo_types.h:203

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

Definition at line 3464 of file StepUtils.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::AngleCode, tca::TrajPoint::AveChg, tca::TCConfig::chargeCuts, ChgFracNearPos(), ChkVxTjs(), CompatibleMerge(), tca::DebugStuff::CTP, tca::VtxStore::CTP, tca::TCConfig::dbgMrg, tca::TCConfig::dbgSlc, debug, DeltaAngle(), FitTraj(), FitVertex(), tca::VtxStore::ID, kBragg, kFixed, tca::TCConfig::kinkCuts, kKilled, kMerge, kShowerLike, kStepDir, kStiffEl, MakeBareTrajPoint(), max, MCSThetaRMS(), MergeAndStore(), min, tca::TCConfig::modes, tca::TrajPoint::NTPsFit, tca::VtxStore::NTraj, NumPtsWithCharge(), OverlapFraction(), tca::VtxStore::Pass, PointTrajDOCA(), tca::VtxStore::Pos, tca::TrajPoint::Pos, PosSep(), PosSep2(), PrintPos(), tca::TCConfig::qualityCuts, ReverseTraj(), SetVx2Score(), SignalBetween(), slices, tca::VtxStore::Stat, StoreVertex(), tcc, tca::TCSlice::tjs, tca::VtxStore::Topo, TrajIntersection(), TrajLength(), TrajPointSeparation(), TrajTrajDOCA(), tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, tca::TCConfig::vtx2DCuts, and tca::TCSlice::vtxs.

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

   {
     // 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 = INT_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 == INT_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
           float dang = DeltaAngle(tp1.Ang, tp2.Ang);
           float sep = PosSep(tp1.Pos, tp2.Pos);
           
           float dangCut;
           float docaCut;
           float chgPull = 0;
           if(tp1.AveChg > tp2.AveChg) {
             chgPull = (tp1.AveChg / tp2.AveChg - 1) / minChgRMS;
           } else {
             chgPull = (tp2.AveChg / tp1.AveChg - 1) / minChgRMS;
           }
           if(loMCSMom) {
             // increase dangCut dramatically for low MCSMom tjs
             dangCut = 1.0;
             // and the doca cut
             docaCut = 2;
           } else {
             // do a more careful calculation of the angle cut
             unsigned short e0 = tj1.EndPt[0];
             unsigned short e1 = tj1.EndPt[1];
             float tj1len = TrajPointSeparation(tj1.Pts[e0], tj1.Pts[e1]);
             float thetaRMS1 = MCSThetaRMS(slc, tj1);
             // calculate (thetaRMS / sqrt(length) )^2
             thetaRMS1 *= thetaRMS1 / tj1len;
             // and now tj2
             e0 = tj2.EndPt[0];
             e1 = tj2.EndPt[1];
             float tj2len = TrajPointSeparation(tj2.Pts[e0], tj2.Pts[e1]);
             float thetaRMS2 = MCSThetaRMS(slc, tj2);
             thetaRMS2 *= thetaRMS2 / tj2len;
             float dangErr = 0.5 * sqrt(thetaRMS1 + thetaRMS2);
             dangCut = tcc.kinkCuts[0] + tcc.kinkCuts[1] * dangErr;
             docaCut = 1;
             if(isVLA) docaCut = 15;
           }
           
           // 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;
           
           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]);
               //              if(prt) mf::LogVerbatim("TC")<<" lastPass merged Tj from "<<PrintPos(slc, tp1OtherEnd.Pos)<<" to "<<PrintPos(slc, tp2OtherEnd.Pos)<<" hitfrac "<<hitFrac<<" cut "<<tcc.qualityCuts[0]; 
             } else {
               // don't merge if the gap between them is longer than the length of the shortest Tj
               float len1 = TrajLength(slc.tjs[it1]);
               float len2 = TrajLength(slc.tjs[it2]);
               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<<" 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;
           
           // don't merge if a Bragg peak exists. A vertex should be made instead
           if(doMerge && (tj1.StopFlag[end1][kBragg] || tj2.StopFlag[end2][kBragg])) 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(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<<" ShowerLike? "<<slc.tjs[it1].AlgMod[kShowerLike]<<" "<<slc.tjs[it2].AlgMod[kShowerLike];
             myprt<<" bestFOM "<<std::fixed<<std::setprecision(2)<<bestFOM;
             myprt<<" bestDOCA "<<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<<" lastPass? "<<lastPass;
             myprt<<" doMerge? "<<doMerge;
           }
           
           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 {
             // 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(PosSep(tp1.Pos, tp2.Pos) < 3 || dang < 0.1) {
               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;
             } else {
               // Tps not so close
               // Dec 11, 2017. Require small separation in EndMerge.
               //              float sepCut = tcc.vtx2DCuts[2];
               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
               if(tj1Short) {
                 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) {
                 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;
             // save the position
             // do a fit
             if(!aVtx.Stat[kFixed] && !FitVertex(slc, aVtx, tcc.dbgMrg)) {
               // 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;
             // Set pion-like PDGCodes
             if(!tj1.Strategy[kStiffEl] && !tj2.Strategy[kStiffEl]) {
               if(tj1.StopFlag[end1][kBragg] && !tj2.StopFlag[end2][kBragg]) tj1.PDGCode = 211;
               if(tj2.StopFlag[end2][kBragg] && !tj1.StopFlag[end1][kBragg]) tj2.PDGCode = 211;
             }
             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
             auto& newVx2 = slc.vtxs[slc.vtxs.size() - 1];
             if(newVx2.Score < tcc.vtx2DCuts[7] && CompatibleMerge(slc, tj1, tj2, tcc.dbgMrg)) {
               slc.tjs[it1].VtxID[end1] = 0;
               slc.tjs[it2].VtxID[end2] = 0;
               slc.vtxs.pop_back();
               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 ";
               }
             }
           } // create a vertex
           if(tj1.AlgMod[kKilled]) break;
         } // end1
       } // it1
     } // iterate
     
     ChkVxTjs(slc, inCTP, tcc.dbgMrg);
     /*
      // Do some checking in debug mode
      if(tcc.modes[kDebug] && lastPass) {
      for(unsigned short it1 = 0; it1 < slc.tjs.size() - 1; ++it1) {
      auto& tj1 = slc.tjs[it1];
      if(tj1.CTP != inCTP) continue;
      if(tj1.AlgMod[kKilled]) continue;
      for(unsigned short end1 = 0; end1 < 2; ++end1) {
      unsigned short end2 = 1 - end1;
      auto& tp1 = tj1.Pts[tj1.EndPt[end1]];
      for(unsigned short it2 = it1 + 1; it2 < slc.tjs.size(); ++it2) {
      auto& tj2 = slc.tjs[it2];
      if(tj2.CTP != inCTP) continue;
      if(tj2.AlgMod[kKilled]) continue;
      auto& tp2 = tj2.Pts[tj2.EndPt[end2]];
      float sep = PosSep2(tp1.HitPos, tp2.HitPos);
      if(sep < 2.5) {
      if(tj1.VtxID[end1] == 0 && tj2.VtxID[end2] == 0) {
      std::cout<<"Tjs "<<tj1.ID<<" and "<<tj2.ID<<" are close at Pos "<<tj1.CTP<<":"<<PrintPos(slc, tp1.HitPos)<<" "<<tj2.CTP<<":"<<PrintPos(slc, tp2.HitPos)<<" with no merge or vertex\n";
      } else if(tj1.VtxID[end1] != tj2.VtxID[end2]) {
      std::cout<<"Tjs "<<tj1.ID<<" and "<<tj2.ID<<" are close at Pos "<<tj1.CTP<<":"<<PrintPos(slc, tp1.HitPos);
      std::cout<<" but have different vertex IDs "<<tj1.VtxID[end1]<<" != "<<tj2.VtxID[end2];
      std::cout<<"\n";
      }
      } // close points
      } // it2
      } // end1
      } // it1
      } // debug mode
      */
   } // EndMerge

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

Definition at line 1802 of file Utils.cxx.

References tca::TCEvent::aveHitRMS, tca::TrajPoint::CTP, DecodeCTP(), tca::TrajPoint::Dir, evt, geo::PlaneID::Plane, tcc, and tca::TCConfig::unitsPerTick.

Referenced by AddHits(), FindUseHits(), and StartTraj().

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

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

Definition at line 3032 of file PFPUtils.cxx.

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

Referenced by ChkVxTjs(), DotProd(), FindParent(), MergeSubShowersTj(), ParentFOM(), Reconcile3D(), SetParent(), TagShowerLike(), and UpdateShower().

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

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

Definition at line 3646 of file Utils.cxx.

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

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

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

Definition at line 1683 of file PFPUtils.cxx.

References tca::PFPStruct::BestPlane, tca::TCConfig::caloAlg, tca::Trajectory::ChgRMS, tca::Trajectory::CTP, DecodeCTP(), tca::Trajectory::dEdx, tca::PFPStruct::dEdx, calo::CalorimetryAlg::dEdx_AREA(), tca::PFPStruct::dEdxErr, tca::PFPStruct::Dir, evd::details::end(), tca::Trajectory::EndPt, tca::TCConfig::geom, tca::PFPStruct::ID, tca::TCSlice::nPlanes, tca::PFPStruct::PDGCode, geo::PlaneID::Plane, geo::GeometryCore::Plane(), tca::Trajectory::Pts, tcc, geo::PlaneGeo::ThetaZ(), tca::PFPStruct::TjIDs, tca::TCSlice::tjs, tca::TCConfig::unitsPerTick, and geo::GeometryCore::WirePitch().

Referenced by DotProd(), and StorePFP().

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

void tca::FilldEdx	(	TCSlice &	slc,
		TrajPoint3 &	tp3
	)

Definition at line 1743 of file PFPUtils.cxx.

References tca::TCEvent::allHits, tca::TCConfig::caloAlg, DecodeCTP(), tca::TrajPoint3::dEdx, calo::CalorimetryAlg::dEdx_AREA(), tca::TrajPoint3::Dir, evt, tca::TCConfig::geom, geo::PlaneID::Plane, geo::GeometryCore::Plane(), tca::TCSlice::slHits, tcc, geo::PlaneGeo::ThetaZ(), tca::TrajPoint3::Tj2Pts, tca::TCSlice::tjs, tca::TCConfig::unitsPerTick, and geo::GeometryCore::WirePitch().

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

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

Definition at line 2264 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TCEvent::allHits, tca::TCConfig::chargeCuts, tca::Trajectory::ChgRMS, tca::TCConfig::dbgStp, DefineHitPos(), tca::Trajectory::EndPt, evt, tca::Trajectory::ID, tca::Trajectory::IsGood, tca::TCSlice::isValid, kFillGap, kJunkTj, kNewStpCuts, MakeBareTrajPoint(), MaxHitDelta(), tca::Trajectory::MCSMom, MCSMom(), tca::Trajectory::Pass, PointTrajDOCA(), PrintHit(), PrintPos(), PrintTrajPoint(), tca::Trajectory::Pts, tca::TCSlice::slHits, tca::Trajectory::StepDir, tcc, UnsetUsedHits(), and tca::TCConfig::useAlg.

Referenced by CheckStiffEl(), and CheckTraj().

   {
     // Fill in any gaps in the trajectory with close hits regardless of charge (well maybe not quite that)
     
     if(!tcc.useAlg[kFillGap]) return;
     if(tj.AlgMod[kJunkTj]) return;
     
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"FG: Check Tj "<<tj.ID<<" from "<<PrintPos(slc, tj.Pts[tj.EndPt[0]])<<" to "<<PrintPos(slc, tj.Pts[tj.EndPt[1]]);
     
     // 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 < tj.EndPt[1]) {
       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;
       }
       // 10/1/2018 BB This shouldn't be a requirement
       // Compare the charge before and after
       if(!tcc.useAlg[kNewStpCuts] && tj.Pts[firstPtWithChg].Chg > 0) {
         float chgrat = tj.Pts[nextPtWithChg].Chg / tj.Pts[firstPtWithChg].Chg;
         if(chgrat < 0.7 || chgrat > 1.4) {
           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::LogWarning("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[kFillGap] = true;
           if(tcc.dbgStp) {
             PrintTrajPoint("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[kFillGap]) tj.MCSMom = MCSMom(slc, tj);
     
   } // FillGaps 

void tca::FillmAllTraj ( TCSlice & slc )

Definition at line 271 of file PFPUtils.cxx.

References detinfo::DetectorProperties::ConvertTicksToX(), geo::CryostatID::Cryostat, DecodeCTP(), tca::TCConfig::detprop, tca::TCConfig::geom, geo::GeometryCore::HasWire(), kHaloTj, kKilled, kMat3D, kTjHiVx3Score, kUsedHits, tca::TCSlice::mallTraj, tca::TCConfig::match3DCuts, tca::TCSlice::matchVec, NumPtsWithCharge(), geo::PlaneID::Plane, tcc, tca::TCSlice::tjs, geo::TPCID::TPC, tca::TCSlice::TPCID, TPHitsRMSTime(), tca::TCConfig::unitsPerTick, and valIncreasings().

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

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

bool tca::FillWireHitRange ( TCSlice & slc )

Definition at line 3944 of file Utils.cxx.

References tca::TCEvent::allHits, tca::TCEvent::aveHitRMS, geo::CryostatID::Cryostat, debug, geo::GeometryCore::DetHalfHeight(), geo::GeometryCore::DetHalfWidth(), geo::GeometryCore::DetLength(), tca::TCConfig::detprop, detinfo::DetectorProperties::DriftVelocity(), detinfo::DetectorProperties::Efield(), evt, tca::TCSlice::firstWire, tca::TCConfig::geom, kDebug, tca::TCSlice::lastWire, geo::TPCGeo::LocalToWorld(), tca::TCConfig::maxPos0, tca::TCConfig::maxPos1, tca::TCConfig::modes, tca::TCSlice::nPlanes, geo::GeometryCore::Nplanes(), detinfo::DetectorProperties::NumberTimeSamples(), tca::TCSlice::nWires, geo::GeometryCore::Nwires(), geo::GeometryCore::PlaneWireToChannel(), detinfo::DetectorProperties::SamplingRate(), tca::TCSlice::slHits, tcc, detinfo::DetectorProperties::Temperature(), tca::DebugStuff::TPC, geo::TPCID::TPC, geo::GeometryCore::TPC(), tca::TCSlice::TPCID, tca::TCConfig::unitsPerTick, geo::GeometryCore::View(), tca::TCSlice::wireHitRange, tca::TCConfig::wirePitch, geo::GeometryCore::WirePitch(), tca::TCSlice::xHi, tca::TCSlice::xLo, tca::TCSlice::yHi, tca::TCSlice::yLo, tca::TCSlice::zHi, and tca::TCSlice::zLo.

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

   {
     // 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) {
       std::cout<<"FillWireHitRange: crazy nPlanes "<<nplanes<<"\n";
       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;
     
     lariov::ChannelStatusProvider const& channelStatus = art::ServiceHandle<lariov::ChannelStatusService>()->GetProvider();
     
     // 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<int, int> flag;
     flag.first = -2; flag.second = -2;
     
     // 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 = tcc.detprop->DriftVelocity(tcc.detprop->Efield(),tcc.detprop->Temperature());
     tickToDist *= 1.e-3 * tcc.detprop->SamplingRate(); // 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] = INT_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)tcc.detprop->NumberTimeSamples() * tcc.unitsPerTick;
     }
     
     // overwrite with the "dead wires" condition
     flag.first = -1; flag.second = -1;
     for(unsigned short ipl = 0; ipl < nplanes; ++ipl) {
       for(unsigned int wire = 0; wire < slc.nWires[ipl]; ++wire) {
         raw::ChannelID_t chan = tcc.geom->PlaneWireToChannel((int)ipl, (int)wire, (int)tpc, (int)cstat);
         if(!channelStatus.IsGood(chan)) slc.wireHitRange[ipl][wire] = flag;
       } // wire
     } // ipl
     
     unsigned int lastWire = 0, lastPlane = 0;
     for(unsigned int iht = 0; iht < slc.slHits.size(); ++iht) {
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       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] == INT_MAX) slc.firstWire[plane] = wire;
       if(slc.wireHitRange[plane][wire].first < 0) slc.wireHitRange[plane][wire].first = iht;
       slc.wireHitRange[plane][wire].second = iht + 1;
       slc.lastWire[plane] = wire + 1;
     } // iht
     
 //    if(!CheckWireHitRange(tcs)) return false;
     
     // Find the average multiplicity 1 hit RMS and calculate the expected max RMS for each range
     if(tcc.modes[kDebug] && (int)tpc == debug.TPC) {
       std::cout<<"tpc "<<tpc<<" tcc.unitsPerTick "<<std::setprecision(3)<<tcc.unitsPerTick<<"\n";
       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::Find2DVertices	(	TCSlice &	slc,
		const CTP_t &	inCTP,
		unsigned short	pass
	)

Definition at line 114 of file TCVertex.cxx.

References AttachAnyTrajToVertex(), tca::VtxStore::ChiDOF, ChkVxTjs(), tca::VtxStore::CTP, tca::TrajPoint::CTP, tca::TCConfig::dbg2V, tca::TCConfig::dbgSlc, DeadWireCount(), debug, DecodeCTP(), FindHammerVertices(), FindHammerVertices2(), FitVertex(), tca::VtxStore::ID, IsCloseToVertex(), kFixed, kHaloTj, kKilled, kNewVtxCuts, kOnDeadWire, kShowerLike, kStepDir, kVtxIndPlnNoChg, tca::TCConfig::maxPos0, tca::TCConfig::maxPos1, MergeWithVertex(), tca::TCConfig::modes, MoveTPToWire(), NearestPtWithChg(), tca::TCSlice::nPlanes, tca::VtxStore::NTraj, tca::VtxStore::Pass, tca::DebugStuff::Plane, geo::PlaneID::Plane, tca::VtxStore::Pos, tca::TrajPoint::Pos, PosSep(), PosSep2(), PrintAllTraj(), PrintPos(), SetVx2Score(), SignalBetween(), tca::VtxStore::Stat, StoreVertex(), tcc, tca::TCSlice::tjs, tca::VtxStore::Topo, TrajClosestApproach(), TrajIntersection(), TrajLength(), TrajTrajDOCA(), tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, tca::TCConfig::vtx2DCuts, and tca::TCSlice::vtxs.

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

   {
     // Find 2D vertices between pairs of tjs that have a same-end topology. Using an example
     // where StepDir = 1 (end 0 is at small wire number) vertices will be found with Topo = 0
     // with a vertex US of the ends (<) or Topo = 2 with a vertex DS of the ends (>). This is reversed
     // if StepDir = -1. Vertices with Topo = 1 (/\) and (\/) are found in EndMerge.
     
     // 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 = (tcc.useAlg[kNewVtxCuts] && 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 plane "<<planeID.Plane<<" in Find2DVertices. firstPassCuts? "<<firstPassCuts<<" requireVtxTjChg "<<requireVtxTjChg;
       PrintAllTraj("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;
           // BB April 19, 2018: require vertex to be near the end
           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;
           // BB April 19, 2018: require vertex to be near the end
           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;
           }
           if(prt) mf::LogVerbatim("TC")<<" wint:tint "<<(int)wint<<":"<<(int)(tint/tcc.unitsPerTick);
           bool fixVxPos = false;
           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[kVtxIndPlnNoChg] = !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);
 /*
           if(tcc.useAlg[kNewVtxCuts]) {
             // try stepping away from the vertex
             auto& newVx2 = slc.vtxs[slc.vtxs.size() - 1];
             auto tjlist = GetAssns(slc, "2V", newVx2.ID, "T");
             // count the number of long straight Tjs
             unsigned short nlong = 0;
             for(auto tjid : tjlist) {
               auto& vtj = slc.tjs[tjid - 1];
               unsigned short npts = vtj.EndPt[1] - vtj.EndPt[0] + 1;
               if(npts > 20 && vtj.MCSMom > 100) ++nlong;
             } // tjid
             if(nlong > 1) {
               std::cout<<"Try 2V"<<newVx2.ID<<" nlong "<<nlong<<"\n";
               FindVtxTjs(slc, newVx2);
             }
           } // new cuts
 */
           SetVx2Score(slc);
         } // it2
       } // end1
     } // it1
     
     // check the consistency of the Tjs for the newly added vertices
     ChkVxTjs(slc, inCTP, prt);
     
     // only call these on the last pass
     if(pass == USHRT_MAX) {
       FindHammerVertices(slc, inCTP);
       FindHammerVertices2(slc, inCTP);
     }
     
     if(prt) PrintAllTraj("F2DVo", slc, USHRT_MAX, USHRT_MAX);
     
   } // Find2DVertices

void tca::Find3DVertices ( TCSlice & slc )

Definition at line 1392 of file TCVertex.cxx.

References CompleteIncomplete3DVertices(), CompleteIncomplete3DVerticesInGaps(), detinfo::DetectorProperties::ConvertTicksToX(), detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, tca::TCConfig::dbg3V, tca::TCConfig::dbgSlc, DecodeCTP(), tca::TCConfig::detprop, evt, FindCloseHits(), tca::TCConfig::geom, tca::TCEvent::globalS3ID, geo::GeometryCore::HasWire(), tca::Vtx3Store::ID, tca::SortEntry::index, geo::GeometryCore::IntersectionPoint(), kAllHits, kHaloTj, kKilled, kNewVtxCuts, kTjHiVx3Score, evd::kWire, geo::kX, tca::TCSlice::nPlanes, tca::TCSlice::nWires, geo::PlaneID::Plane, PrintHit(), tca::Vtx3Store::Score, SetVx2Score(), SetVx3Score(), tca::TCSlice::slHits, tcc, tca::TCSlice::tjs, geo::TPCID::TPC, tca::Vtx3Store::TPCID, tca::TCSlice::TPCID, tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, tca::SortEntry::val, valIncreasing(), tca::TCConfig::vtx2DCuts, tca::TCConfig::vtx3DCuts, tca::TCSlice::vtx3s, tca::TCSlice::vtxs, tca::Vtx3Store::Vx2ID, tca::VtxStore::Vx3ID, tca::Vtx3Store::Wire, geo::GeometryCore::WireCoordinate(), tca::TCConfig::wirePitch, tca::Vtx3Store::X, tca::Vtx3Store::XErr, y, tca::Vtx3Store::Y, tca::Vtx3Store::YErr, tca::TCSlice::yHi, tca::Vtx3Store::Z, z, tca::Vtx3Store::ZErr, and tca::TCSlice::zHi.

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

   {
     // Create 3D vertices from 2D vertices. 3D vertices that are matched
     // in all three planes have Vtx2ID > 0 for all planes. This function re-scores all
     // 2D and 3D vertices and flags Tjs that have high-score 3D vertices    
     
     if(tcc.vtx3DCuts[0] < 0) return;
     if(slc.vtxs.size() < 2) return;
     bool newCuts = (tcc.vtx3DCuts.size() > 2);
     
     // 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);
       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;
 //      PrintAllTraj("F3DV", slc, USHRT_MAX, slc.tjs.size());
     }
     
     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, -100);
     
     for(unsigned short ivx = 0; ivx < vsize; ++ivx) {
       if(slc.vtxs[ivx].ID <= 0) continue;
       if(tcc.useAlg[kNewVtxCuts] && slc.vtxs[ivx].Score < tcc.vtx2DCuts[7]) continue;
       geo::PlaneID planeID = DecodeCTP(slc.vtxs[ivx].CTP);
       if(slc.vtxs[ivx].Pos[0] < -0.4) continue;
       unsigned int wire = std::nearbyint(slc.vtxs[ivx].Pos[0]);
       if(!tcc.geom->HasWire(geo::WireID(planeID, wire))) continue;
       // Convert 2D vertex time error to X error
       double ticks = slc.vtxs[ivx].Pos[1] / tcc.unitsPerTick;
       vX[ivx]  = tcc.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;
     float maxScore = 0;
     constexpr float maxSep = 4;
     // i, j, k indicates 3 different wire planes
     // compare vertices in each view
     for(unsigned short ipl = 0; ipl < 2; ++ipl) {
       for(unsigned short ii = 0; ii < vIndex[ipl].size(); ++ii) {
         unsigned short ivx = vIndex[ipl][ii];
         if(vX[ivx] < 0) continue;
         auto& ivx2 = 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] < 0) 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;
             // see if this pair is already in the list
             //bool gotit = false;
             for(auto& v3t : v3temp) {
               unsigned short cnt = 0;
               if(std::find(v3t.Vx2ID.begin(), v3t.Vx2ID.end(), ivx2.ID) != v3t.Vx2ID.end()) ++cnt;
               if(std::find(v3t.Vx2ID.begin(), v3t.Vx2ID.end(), jvx2.ID) != v3t.Vx2ID.end()) ++cnt;
               if(cnt == slc.nPlanes) {
                 //gotit = true;
                 break;
               } // cnt == slc.nPlanes
             } // v3t
             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 = (int)(tcc.geom->WireCoordinate(y, z, kpl, tpc, cstat) + 0.5);
               if(kWire < 0 || (unsigned int)kWire > slc.nWires[kpl]) continue;
               if(!tcc.geom->HasWire(geo::WireID(cstat, tpc, kpl, kWire))) continue;
               std::array<int, 2> wireWindow;
               std::array<float, 2> timeWindow;
               wireWindow[0] = kWire - maxSep;
               wireWindow[1] = kWire + maxSep;
               float time = tcc.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;
             if(newCuts) {
               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<<"F3DV: 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];
               if(vX[kvx] < 0) continue;
               float dX = std::abs(vX[kvx] - v3d.X);
               // Wire difference error
               float dW = tcc.wirePitch * std::abs(slc.vtxs[kvx].Pos[0] - kWire);
               if(prt) mf::LogVerbatim("TC")<<" k2V"<<kvx+1<<" dX "<<dX<<" dW "<<dW;
               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;
               if(newCuts) {
                 SetVx3Score(slc, v3d);
                 vxScoreWght = tcc.vtx3DCuts[2] / v3d.Score;
                 if(posError < 0.5) posError = 0;
               } // newCuts
               v3d.Score = posError + vxScoreWght;
               if(v3d.Score > maxScore) maxScore = v3d.Score;
               v3temp.push_back(v3d);
             } // kk
           } // jj
         } // jpl
       } // ii
     } // ipl
     
     if(v3temp.empty()) return;
     
     // We will sort this list by increasing score. First add the maxScore for 2-plane matches so that
     // they are considered after the 3-plane matches
     maxScore += 1;
     for(auto& v3 : v3temp) if(v3.Wire >= 0) v3.Score += maxScore;
     
     if(prt) {
       mf::LogVerbatim("TC")<<"v3temp list";
       for(auto& v3 : v3temp) {
         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.globalS3ID;
       vx3.UID = evt.globalS3ID;
       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(slc);
       CompleteIncomplete3DVertices(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	(	Point2_t	pos1,
		Vector2_t	dir1,
		Point2_t	pos2,
		Point2_t &	alongTrans
	)

Definition at line 2817 of file Utils.cxx.

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

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

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

Definition at line 2849 of file PFPUtils.cxx.

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

Referenced by DotProd(), FindCompleteness(), FindParent(), FollowTp3s(), InShowerProb(), MergeSubShowers(), and ParentFOM().

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

std::vector< unsigned int > tca::FindCloseHits	(	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 2496 of file Utils.cxx.

References tca::TCEvent::allHits, evt, tca::TCSlice::firstWire, kAllHits, kUnusedHits, kUsedHits, tca::TCSlice::lastWire, tca::TCSlice::slHits, tcc, tca::TCConfig::unitsPerTick, and tca::TCSlice::wireHitRange.

Referenced by AddLAHits(), ChkStopEndPts(), Find3DVertices(), FindVtxTjs(), FixTrajBegin(), Forecast(), and ReversePropagate().

   {
     // returns a vector of hits that are within the Window[Pos0][Pos1] in plane.
     // Note that hits on wire wireWindow[1] are returned as well. The definition of close
     // depends on setting of usePeakTime. If UsePeakTime is true, a hit is considered nearby if
     // the PeakTime is within the window. This is shown schematically here where
     // the time is on the horizontal axis and a "-" denotes a valid entry
     // timeWindow     -----------------
     // hit PeakTime             +         close
     // hit PeakTime  +                    not close
     // If usePeakTime is false, a hit is considered nearby if the hit StartTick and EndTick overlap with the timeWindow
     // Time window                  ---------
     // Hit StartTick-EndTick      --------        close
     // Hit StartTick - EndTick                  --------  not close
     
     hitsNear = false;
     std::vector<unsigned int> closeHits;
     if(plane > 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(slc.wireHitRange[plane][wire].first == -2) hitsNear = true;
       if(slc.wireHitRange[plane][wire].first < 0) continue;
       unsigned int firstHit = (unsigned int)slc.wireHitRange[plane][wire].first;
       unsigned int lastHit = (unsigned int)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 2552 of file Utils.cxx.

References tca::TCEvent::allHits, tca::TrajPoint::CTP, DecodeCTP(), tca::TrajPoint::Environment, evt, tca::TCSlice::firstWire, tca::TrajPoint::Hits, kAllHits, kEnvDeadWire, kUnusedHits, kUsedHits, tca::TCSlice::lastWire, geo::PlaneID::Plane, PointTrajDOCA(), tca::TrajPoint::Pos, tca::TCSlice::slHits, tcc, tca::TCSlice::tjs, tca::TCConfig::unitsPerTick, tca::TrajPoint::UseHit, tca::TCSlice::wireHitRange, and WireHitRangeOK().

Referenced by ChgFracNearPos(), and MakeHaloTj().

   {
     // Fills tp.Hits sets tp.UseHit true for hits that are close to tp.Pos. Returns true if there are
     // close hits OR if the wire at this position is dead
     
     tp.Hits.clear();
     tp.UseHit.reset();
     if(!WireHitRangeOK(slc, tp.CTP)) {
       return false;
     }
     
     geo::PlaneID planeID = DecodeCTP(tp.CTP);
     unsigned short ipl = planeID.Plane;
     if(tp.Pos[0] < -0.4) return false;
     unsigned int wire = std::nearbyint(tp.Pos[0]);
     if(wire < slc.firstWire[ipl]) return false;
     if(wire > slc.lastWire[ipl]-1) return false;
     
     // dead wire
     if(slc.wireHitRange[ipl][wire].first == -1) {
       tp.Environment[kEnvDeadWire] = true;
       return true;
     }
     tp.Environment[kEnvDeadWire] = false;
     // live wire with no hits
     if(slc.wireHitRange[ipl][wire].first == -2) return false;
     
     unsigned int firstHit = (unsigned int)slc.wireHitRange[ipl][wire].first;
     unsigned int lastHit = (unsigned int)slc.wireHitRange[ipl][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	(	TCSlice &	slc,
		const TrajPoint &	fromTp,
		const TrajPoint &	toTp,
		const float &	maxDelta
	)

Definition at line 2604 of file Utils.cxx.

References tca::TCEvent::allHits, tca::TrajPoint::CTP, DecodeCTP(), evt, tca::TCSlice::firstWire, tca::TCSlice::lastWire, MakeBareTrajPoint(), MoveTPToWire(), geo::PlaneID::Plane, tca::TrajPoint::Pos, tca::TCSlice::slHits, tcc, tca::TCSlice::tjs, tmp, tca::TCConfig::unitsPerTick, and tca::TCSlice::wireHitRange.

Referenced by MakeJunkVertices().

   {
     // Returns a list of Tj IDs that have hits within distance maxDelta on a line drawn between the two Tps as shown
     // graphically here, where a "*" is a Tp and "|" and "-" are the boundaries of the region that is checked 
     //
     //    ---------------
     //    |             |
     //    *             *
     //    |             |
     //    ---------------
     // If the wire positions of fromTp and toTp are the same, a different region is checked as shown here
     //
     //     -----------
     //     |         |
     //     |    *    |
     //     |         |
     //     -----------
     
     std::vector<int> tmp;
     if(fromTp.Pos[0] < -0.4 || toTp.Pos[0] < -0.4) return tmp;
     
     TrajPoint tp;
     // Make the tp so that stepping is positive
     unsigned int firstWire, lastWire;
     if(toTp.Pos[0] > fromTp.Pos[0]) {
       if(!MakeBareTrajPoint(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);
     }
     
     geo::PlaneID planeID = DecodeCTP(tp.CTP);
     unsigned short ipl = planeID.Plane;
     
     if(firstWire < slc.firstWire[ipl]) firstWire = slc.firstWire[ipl];
     if(firstWire > slc.lastWire[ipl]-1) return tmp;
     if(lastWire < slc.firstWire[ipl]) return tmp;
     if(lastWire > slc.lastWire[ipl]-1) lastWire = slc.lastWire[ipl]-1;
     
     for(unsigned int wire = firstWire; wire <= lastWire; ++wire) {
       if(slc.wireHitRange[ipl][wire].first == -1) continue;
       if(slc.wireHitRange[ipl][wire].first == -2) 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 = (unsigned int)slc.wireHitRange[ipl][wire].first;
       unsigned int lastHit = (unsigned int)slc.wireHitRange[ipl][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::FindCompleteness	(	TCSlice &	slc,
		PFPStruct &	pfp,
		bool	doFit,
		bool	fillTp3s,
		bool	prt
	)

Definition at line 737 of file PFPUtils.cxx.

References tca::TrajPoint3::AlongTrans, geo::CryostatID::Cryostat, DecodeCTP(), dir, tca::TrajPoint3::Dir, tca::PFPStruct::Dir, tca::PFPStruct::EffPur, trkf::fill(), FindAlongTrans(), Fit3D(), tca::TCConfig::geom, tca::PFPStruct::ID, MakeTp3(), tca::TCSlice::mallTraj, tca::TCConfig::match3DCuts, tca::TCSlice::nPlanes, geo::PlaneID::Plane, tca::TrajPoint3::Pos, tcc, tca::TrajPoint3::Tj2Pts, tca::PFPStruct::TjCompleteness, tca::PFPStruct::TjIDs, tca::TCSlice::tjs, tmp, tca::PFPStruct::Tp3s, geo::TPCID::TPC, geo::GeometryCore::WireCoordinate(), tca::TCSlice::wireHitRange, and tca::PFPStruct::XYZ.

Referenced by DefinePFP(), and FindPFParticles().

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

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

Definition at line 3416 of file TCShower.cxx.

References tca::TCConfig::chargeCuts, DontCluster(), GetAssns(), greaterThan(), tca::Trajectory::ID, tca::TCSlice::ID, kHaloTj, kKilled, kMat3D, kShowerLike, kShowerTj, tca::Trajectory::MCSMom, MCSMom(), NumPtsWithCharge(), PFPDOCA(), tca::TCSlice::pfps, PosSep(), SetIntersection(), ShowerEnergy(), tca::TCConfig::showerTag, t1, t2, tcc, tca::TCSlice::tjs, tmp, TrajTrajDOCA(), and tca::TCConfig::wirePitch.

Referenced by FindShowers3D().

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

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

Definition at line 1154 of file TCVertex.cxx.

References ChgFracNearPos(), tca::VtxStore::ChiDOF, tca::VtxStore::CTP, tca::TCConfig::dbgAlg, tca::TCConfig::dbgSlc, DeltaAngle(), GetAssns(), tca::VtxStore::ID, tca::TCSlice::ID, kDebug, kHaloTj, kHamVx, kJunkTj, kKilled, kNewVtxCuts, kShowerLike, tca::TCConfig::modes, tca::VtxStore::NTraj, tca::VtxStore::Pass, tca::VtxStore::Pos, SetPDGCode(), SetVx2Score(), SplitTraj(), StoreVertex(), tcc, tca::TCSlice::tjs, tca::VtxStore::Topo, TrajPointTrajDOCA(), tca::TCConfig::useAlg, and tca::TCSlice::vtxs.

Referenced by Find2DVertices().

   {
     // Look for a trajectory that intersects another. Split
     // the trajectory and make a vertex. The convention used
     // is shown pictorially here. Trajectory tj1 must be longer
     // than tj2
     // tj2       ------
     // tj1         /
     // tj1        /
     // tj1       /
     
     if(!tcc.useAlg[kHamVx]) return;
     
     bool prt = (tcc.modes[kDebug] && tcc.dbgSlc && tcc.dbgAlg[kHamVx]);
 
     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;
       // 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 if tj1 is a lot shorter than tj2
 //          if(tj1len < 0.5 * tj2len) continue;
           // ignore very long straight trajectories (probably a cosmic muon)
           unsigned short end20 = slc.tjs[it2].EndPt[0];
           unsigned short end21 = slc.tjs[it2].EndPt[1];
           if(tcc.useAlg[kNewVtxCuts]) {
             if(tj2len > 200 && slc.tjs[it2].PDGCode == 13) continue;
           } else {
             if(tj2len > 100 && DeltaAngle(slc.tjs[it2].Pts[end20].Ang, slc.tjs[it2].Pts[end21].Ang) < 0.2) continue;
           }
           // Require no vertex associated with itj2
 //          if(slc.tjs[it2].VtxID[0] > 0 || slc.tjs[it2].VtxID[1] > 0) continue;
           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;
           // 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;
           // create a new vertex
           VtxStore aVtx;
           aVtx.Pos = slc.tjs[it2].Pts[closePt2].Pos;
           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";
             slc.vtxs.pop_back();
             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, true);
           // and for the new trajectory
           SetPDGCode(slc, newTjIndex, true);
           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 979 of file TCVertex.cxx.

References AttachAnyTrajToVertex(), tca::VtxStore::ChiDOF, tca::VtxStore::CTP, tca::TCConfig::dbgAlg, tca::TCConfig::dbgSlc, DeltaAngle(), dir, tca::VtxStore::ID, kDebug, kHaloTj, kHamVx, kHamVx2, kJunkTj, kKilled, kNewVtxCuts, kShowerLike, MCSMom(), tca::TCConfig::modes, MoveTPToWire(), tca::VtxStore::NTraj, NumPtsWithCharge(), tca::VtxStore::Pass, PointTrajDOCA(), tca::VtxStore::Pos, PosSep(), PrintPos(), SetPDGCode(), SetVx2Score(), SignalAtTp(), SplitTraj(), StoreVertex(), tcc, tca::TCSlice::tjs, tmp, tca::VtxStore::Topo, TrajClosestApproach(), TrajIntersection(), TrajPointTrajDOCA(), tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, and tca::TCSlice::vtxs.

Referenced by Find2DVertices().

   {
     // Variant of FindHammerVertices with slightly different requirements:
     // 1) tj1 is a straight trajectory with most of the points fit
     // 2) No angle requirement between tj1 and tj2
     // 3) Large charge near the intersection point X on tj2
     // tj2       ---X---
     // tj1         /
     // tj1        /
     // tj1       /
     // minimum^2 DOCA of tj1 endpoint with tj2
     
     if(!tcc.useAlg[kHamVx2]) 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;
       // 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(tcc.useAlg[kNewVtxCuts] && 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(prt) mf::LogVerbatim("TC")<<" intPt2 "<<intPt2<<" at Pos "<<PrintPos(slc, slc.tjs[it2].Pts[ipt])<<" delta "<<delta<<" chg "<<slc.tjs[it2].Pts[ipt].Chg<<" pull "<<pull;
             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(slc, 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";
             // we can just remove the vertex since no Tj VtxID association has been made yet
             slc.vtxs.pop_back();
             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, true);
           // and for the new trajectory
           SetPDGCode(slc, newTjIndex, true);
           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

std::vector< unsigned short > tca::FindKinks	(	TCSlice &	slc,
		PFPStruct &	pfp,
		double	sep,
		bool	prt
	)

Definition at line 1901 of file PFPUtils.cxx.

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

Referenced by DotProd(), and Split3DKink().

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

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

Definition at line 950 of file PFPUtils.cxx.

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

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

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

Definition at line 3762 of file TCShower.cxx.

References tca::ShowerStruct::CTP, tca::ShowerStruct::Envelope, GetAssns(), tca::ShowerStruct::ID, tca::TCSlice::ID, kKilled, kShowerTj, tca::ShowerStruct::NearTjIDs, PointInsideEnvelope(), PointTrajDOCA(), tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, TrajTrajDOCA(), and tca::TCSlice::vtxs.

Referenced by FindShowers3D().

   {
     // Find Tjs that are near the shower but are not included in it
     ss.NearTjIDs.clear();
     
     // check for a valid envelope
     if(ss.Envelope.empty()) return;
     auto& stj = 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 = GetVtxTjIDs(slc, vx);
       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

void tca::FindNeutralVertices ( TCSlice & slc )

Definition at line 529 of file TCVertex.cxx.

References kVxNeutral, tca::TCConfig::neutralVxCuts, tca::TCSlice::nPlanes, tca::TCSlice::pfps, tcc, and tca::TCConfig::useAlg.

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

   {
     // Look for 2D neutral vertices between Tjs 
     if(!tcc.useAlg[kVxNeutral]) return;
     if(tcc.neutralVxCuts.size() < 4) return;
     if(slc.nPlanes < 3) return;
     if(slc.pfps.size() < 2) return;
     
     /* TODO This algorithm needs work.
     
     bool prt = tcc.dbgVxNeutral && tcc.dbgSlc;
     
     struct CandVx {
       unsigned short ip1;
       unsigned short end1;
       unsigned short ip2;
       unsigned short end2;
       Point3_t intersect;
       float sepSum;
       bool isValid;
     };
     std::vector<CandVx> candVxs;
 
     for(unsigned short ip1 = 0; ip1 < slc.pfps.size() - 1; ++ip1) {
       auto& p1 = slc.pfps[ip1];
       if(p1.ID == 0) continue;
       if(p1.Tp3s.empty()) continue;
       float len1 = PosSep(p1.XYZ[0], p1.XYZ[1]);
       if(len1 < tcc.neutralVxCuts[3]) continue;
       for(unsigned short end1 = 0; end1 < 2; ++end1) {
         float cfne1 = ChgFracNearEnd(slc, p1, end1);
         if(cfne1 < tcc.neutralVxCuts[0]) continue;
         for(unsigned short ip2 = ip1 + 1; ip2 < slc.pfps.size(); ++ip2) {
           auto& p2 = slc.pfps[ip2];
           if(p2.ID == 0) continue;
           if(p2.Tp3s.empty()) continue;
           float len2 = PosSep(p2.XYZ[0], p2.XYZ[1]);
           if(len2 < tcc.neutralVxCuts[3]) continue;
           for(unsigned short end2 = 0; end2 < 2; ++end2) {
             float cfne2 = ChgFracNearEnd(slc, p2, end2);
             if(cfne2 < tcc.neutralVxCuts[0]) continue;
             float vxDOCA = 1E6;
             Point3_t intersect;
             if(!PointDirIntersect(p1.XYZ[end1], p1.Dir[end1], p2.XYZ[end2], p2.Dir[end2], intersect, vxDOCA)) continue;
             if(intersect[0] < slc.xLo || intersect[0] > slc.xHi) continue;
             if(intersect[1] < slc.yLo || intersect[1] > slc.yHi) continue;
             if(intersect[2] < slc.zLo || intersect[2] > slc.zHi) continue;
             // ensure that the pfp end and the vertex are consistent
             float sep1 = PosSep(intersect, p1.XYZ[end1]);
             if(PosSep(intersect, p1.XYZ[1-end1]) < sep1) continue;
             float sep2 = PosSep(intersect, p2.XYZ[end2]);
             if(PosSep(intersect, p2.XYZ[1-end2]) < sep2) continue;
             if(vxDOCA > tcc.neutralVxCuts[1]) continue;
             // ensure that there isn't a lot of charge between the end of each pfp and the intersection point
             float cfb1 = ChgFracBetween(slc, p1.XYZ[end1], intersect);
             float cfb2 = ChgFracBetween(slc, p2.XYZ[end2], intersect);
             if(prt) {
               mf::LogVerbatim myprt("TC");
               myprt<<"FNV: P"<<p1.ID<<"_"<<end1<<" sep1 "<<std::fixed<<std::setprecision(2)<<sep1;
               myprt<<" cfne1 "<<cfne1<<" cfb1 "<<cfb1;
               myprt<<" P"<<p2.ID<<"_"<<end2<<" sep2 "<<sep2<<" cfne2 "<<cfne2<<" cfb2 "<<cfb2;
               myprt<<" intersect "<<intersect[0]<<" "<<intersect[1]<<" "<<intersect[2];
               myprt<<" vxDOCA "<<vxDOCA;
             } // prt
             if(cfb1 > tcc.neutralVxCuts[2]) continue;
             if(cfb2 > tcc.neutralVxCuts[2]) continue;
             // check existing candidates
             float sepSum = sep1 + sep2;
             bool skipit = false;
             for(auto& candVx : candVxs) {
               if(!candVx.isValid) continue;
               if(candVx.ip1 != ip1 && candVx.ip2 != ip2) continue;
               // see if the separation sum is smaller
               if(sepSum < candVx.sepSum) {
                 // flag the saved one as not valid
                 candVx.isValid = false;
               } else {
                 skipit = true;
                 break;
               }
             } // candVx
             if(skipit) continue;
             CandVx candVx;
             candVx.ip1 = ip1;
             candVx.end1 = end1;
             candVx.ip2 = ip2;
             candVx.end2 = end2;
             candVx.intersect = intersect;
             candVx.sepSum = sep1 + sep2;
             candVx.isValid = true;
             candVxs.push_back(candVx);
             if(prt) mf::LogVerbatim("TC")<<" candidate";
           } // end2
         } // ip2
       } // end1
     } // ip1
     
     if(candVxs.empty()) return;
     
     // Make vertices with the valid candidates
     for(auto& candVx : candVxs) {
       if(!candVx.isValid) continue;
       Vtx3Store vx3;
       auto& p1 = slc.pfps[candVx.ip1];
       auto& p2 = slc.pfps[candVx.ip2];
       vx3.TPCID = p1.TPCID;
       vx3.Vx2ID.resize(slc.nPlanes);
       vx3.ID = slc.vtx3s.size() + 1;
       // try to improve the vertex position by fitting the Tjs in 2D
       std::vector<TrajPoint> vxTps;
       Vector3_t dir = {{0, 0, 0}};
       for(unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
         vxTps.clear();
         CTP_t inCTP = EncodeCTP(p1.TPCID.Cryostat, p1.TPCID.TPC, plane);
         // Need the position in this plane to find the closest end
         auto vtp = MakeBareTP(slc, candVx.intersect, dir, inCTP);
         if(vtp.Pos[0] < 0) continue;
         for(auto tid : p1.TjIDs) {
           auto& tj = slc.tjs[tid - 1];
           if(tj.CTP != vtp.CTP) continue;
           unsigned short end = CloseEnd(slc, tj, vtp.Pos);
           auto vxTp = tj.Pts[tj.EndPt[end]];
           vxTp.Step = tid;
           vxTp.AngleCode = end;
           vxTps.push_back(vxTp);
         } // tid
         for(auto tid : p2.TjIDs) {
           auto& tj = slc.tjs[tid - 1];
           if(tj.CTP != vtp.CTP) continue;
           unsigned short end = CloseEnd(slc, tj, vtp.Pos);
           auto vxTp = tj.Pts[tj.EndPt[end]];
           vxTp.Step = tid;
           vxTp.AngleCode = end;
           vxTps.push_back(vxTp);
         } // tid
         if(vxTps.size() < 2) continue;
         VtxStore vx2;
         vx2.CTP = inCTP;
         vx2.Topo = 11;
         if(!FitVertex(slc, vx2, vxTps, prt)) {
           if(prt) mf::LogVerbatim("TC")<<"FNV: vertex fit failed";
           continue;
         } // fit failed
         vx2.ID = slc.vtxs.size() + 1;
         for(auto& vxTp : vxTps) {
           int tid = vxTp.Step;
           auto& tj = slc.tjs[tid - 1];
           tj.VtxID[vxTp.AngleCode] = vx2.ID;
         }
         if(prt) mf::LogVerbatim("TC")<<"FNV: 2V fit inCTP "<<inCTP<<" pos "<<PrintPos(slc, vx2.Pos);
         vx2.Vx3ID = vx3.ID;
         vx3.Vx2ID[plane] = vx2.ID;
         SetVx2Score(slc, vx2);
         if(!StoreVertex(slc, vx2)) {
           if(prt) mf::LogVerbatim("TC")<<"FNV: store vertex failed";
           continue;
         } // StoreVertex failed
       } // plane
       vx3.X = candVx.intersect[0];
       vx3.Y = candVx.intersect[1];
       vx3.Z = candVx.intersect[2];
       vx3.Primary = true;
       SetVx3Score(slc, vx3);
       ++evt.globalS3ID;
       vx3.UID = evt.globalS3ID;
       slc.vtx3s.push_back(vx3);
       if(prt) mf::LogVerbatim("TC")<<"FNV: P"<<p1.ID<<"_"<<candVx.end1<<" P"<<p2.ID<<"_"<<candVx.end2<<" -> 3V"<<vx3.ID;
     } // candVx
 */
   } // FindNeutralVertices

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

Definition at line 1668 of file TCShower.cxx.

Referenced by FindShowers3D().

   {
     // look for a parent pfp for the shower.The 2D showers associated with it 
     // The parent should be at the start of the shower (shend = 0) if it is well-defined
     // (has small AspectRatio and small DirectionFOM). A search is also made for a parent at
     // the "wrong" end of the shower (shend = 1). The best one at the wrong end is used if
     // no parent is found at the shower start and the shower is poorly defined.
     //
     // This function returns false if there was a failure. Not finding a parent is not a failure
     
     if(ss3.ID == 0) return false;
     if(ss3.CotIDs.size() < 2) return false;
     // Use the MVA reader
     if(!tcc.showerParentReader) return false;
     if(tcc.showerParentVars.size() != 9) return false;
     // don't call this function when studying this function. See TCTruth StudyShowerParents
     if(!tcc.useAlg[kShwrParent]) return false;
     
     std::string fcnLabel = inFcnLabel + ".FPar";
 //    MCParticleListUtils mcpu{slc};
 //    int truPFP = mcpu.PrimaryElectronPFPID(slc);
     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 pToS = PointDirection(pfp.XYZ[pEnd], ss3.ChgPos);
       double costh1 = std::abs(DotProd(pToS, ss3.Dir));
       if(costh1 < 0.4) continue;
       float costh2 = DotProd(pToS, pfp.Dir[pEnd]);
       // distance^2 between the pfp end and the shower start, charge center, and shower end
       float distToStart2 = PosSep2(pfp.XYZ[pEnd], ss3.Start);
       float distToChgPos2 = PosSep2(pfp.XYZ[pEnd], ss3.ChgPos);
       float distToEnd2 = PosSep2(pfp.XYZ[pEnd], ss3.End);
       if(dprt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" P"<<pfp.ID<<"_"<<pEnd<<" distToStart "<<sqrt(distToStart2)<<" distToChgPos "<<sqrt(distToChgPos2)<<" distToEnd "<<sqrt(distToEnd2);
       // find the end of the shower closest to the pfp
       unsigned short shEnd = 0;
       if(distToEnd2 < distToStart2) shEnd = 1;
       // This can't be a parent if the pfp end is closer to the shower center than the start or the end
       if(shEnd == 0 && distToChgPos2 < distToStart2) continue;
       if(shEnd == 1 && distToChgPos2 < distToEnd2) continue;
       if(dprt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<"_"<<shEnd<<" P"<<pfp.ID<<"_"<<pEnd<<" costh1 "<<costh1;
       Point2_t alongTrans;
       // find the longitudinal and transverse components of the pfp start point relative to the
       // shower center
       FindAlongTrans(ss3.ChgPos, ss3.Dir, pfp.XYZ[pEnd], alongTrans);
       if(dprt) mf::LogVerbatim("TC")<<fcnLabel<<"   alongTrans "<<alongTrans[0]<<" "<<alongTrans[1];
       // find the probability this point is inside the shower. Offset by the expected
       // shower max distance. distToShowerMax will be > 0 if the pfp end is closer to
       // ChgPos than expected from the parameterization
       float distToShowerMax = shMaxAlong - std::abs(alongTrans[0]);
       float prob = InShowerProbLong(energy, distToShowerMax);
       if(dprt) mf::LogVerbatim("TC")<<fcnLabel<<"        prob "<<prob;
       if(prob < 0.1) continue;
       float chgFrac = 0;
       float totSep = 0;
       // find the charge fraction btw the pfp start and the point that is 
       // half the distance to the charge center in each plane
       for(unsigned short plane = 0; plane < 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(slc, pfp.XYZ[pEnd], 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;
 /*
       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]);
 */
       // load the MVA variables
       tcc.showerParentVars[0] = energy;
       tcc.showerParentVars[1] = pfpEnergy;
       tcc.showerParentVars[2] = MCSMom(slc, pfp.TjIDs);
       tcc.showerParentVars[3] = PosSep(pfp.XYZ[0], pfp.XYZ[1]);
       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");
 /*
       // use the overall pfp direction instead of the starting direction. It may not be so
       // good if the shower develops quickly
       auto pfpDir = PointDirection(pfp.XYZ[pEnd], pfp.XYZ[1 - pEnd]);
       costh = DotProd(pfpDir, ss3.Dir);
       if(dprt) mf::LogVerbatim("TC")<<fcnLabel<<" pfpDir "<<pfpDir[0]<<" "<<pfpDir[1]<<" "<<pfpDir[2]<<" costh "<<costh;
       if(std::abs(costh) < 0.6) continue;
 */
       // find the parentFOM
 //      float candParFOM = ParentFOM(fcnLabel, slc, pfp, pEnd, ss3, prt);
       
       if(prt) {
         mf::LogVerbatim myprt("TC");
         myprt<<fcnLabel;
         myprt<<" 3S"<<ss3.ID<<"_"<<shEnd;
         myprt<<" P"<<pfp.ID<<"_"<<pEnd<<" ParentVars";
         for(auto var : 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(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 ( TCSlice & slc )

Definition at line 1998 of file PFPUtils.cxx.

References AnalyzePFP(), CreatePFP(), geo::CryostatID::Cryostat, tca::TCConfig::dbgPFP, tca::TCConfig::dbgSlc, DefinePFP(), tca::PFPStruct::Dir, EncodeCTP(), FindCompleteness(), FindXMatches(), tca::PFPStruct::ID, tca::SortEntry::index, kEnvFlag, kKilled, kMat3D, kTestBeam, MakeBareTP(), tca::TCConfig::match3DCuts, Match3DVtxTjs(), tca::TCSlice::matchVec, tca::PFPStruct::MatchVecIndex, MaxTjLen(), MCSMom(), tca::TCConfig::modes, tca::TCSlice::nPlanes, tca::PFPStruct::PDGCode, PDGCodeVote(), SetIntersection(), Split3DKink(), StorePFP(), tcc, tca::PFPStruct::TjCompleteness, tca::PFPStruct::TjIDs, tca::TCSlice::tjs, geo::TPCID::TPC, tca::PFPStruct::TPCID, tca::SortEntry::val, valDecreasings(), and tca::PFPStruct::XYZ.

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

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

bool tca::FindShowers3D ( TCSlice & slc )

Definition at line 286 of file TCShower.cxx.

References AddTjsInsideEnvelope(), ChkAssns(), tca::TCSlice::cots, CreateSS(), geo::CryostatID::Cryostat, tca::DebugStuff::CTP, tca::TCConfig::dbg2S, tca::TCConfig::dbg3S, tca::TCConfig::dbgSlc, debug, DefineDontCluster(), EncodeCTP(), FindCots(), FindNearbyTjs(), FindParent(), tca::TCConfig::geom, kSaveShowerTree, MakeShowerObsolete(), Match2DShowers(), MergeNearby2DShowers(), MergeOverlap(), MergeShowerChain(), MergeSubShowers(), MergeSubShowersTj(), tca::TCConfig::modes, geo::TPCGeo::Nplanes(), tca::TCSlice::nPlanes, Print2DShowers(), PrintAllTraj(), PrintPFPs(), Reconcile3D(), SaveAllCots(), SaveTjInfo(), ShowerEnergy(), tca::TCSlice::showers, tca::TCConfig::showerTag, ss, StoreShower(), tcc, geo::TPCID::TPC, geo::GeometryCore::TPC(), tca::TCSlice::TPCID, and UpdateShower().

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

   {
     // Find 2D showers using 3D-matched trajectories. This returns true if showers were found
     // which requires re-doing the 3D trajectory match
     
     bool reconstruct = (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("FSi", slc, USHRT_MAX, 0);
     }
     
     // define a list of tjs that shouldn't be clustered in the same shower because
     // they are matched to pfp particles that are likely parents of 3D showers
     DefineDontCluster(slc, prt2S);
 
     // 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) {
       CTP_t inCTP = EncodeCTP(slc.TPCID.Cryostat, slc.TPCID.TPC, 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)) {
           std::cout<<fcnLabel<<" StoreShower failed 2S"<<ss.ID<<"\n";
           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");
 //    std::cout<<"Add function to check for neutrino vertex inside showers\n";
     for(auto& ss3 : slc.showers) {
       if(ss3.ID == 0) continue;
       FindParent(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	(	TCSlice &	slc,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 45 of file TCShower.cxx.

References tca::ShowerStruct3D::ChgPos, tca::ShowerStruct3D::CotIDs, tca::TCSlice::cots, tca::ShowerStruct3D::Dir, DotProd(), tca::ShowerStruct3D::End, tca::ShowerStruct3D::ID, tca::ShowerStruct3D::Len, MakeBareTP(), tca::ShowerStruct3D::OpenAngle, PosSep(), ReverseShower(), ss, tca::ShowerStruct3D::Start, tcc, tca::TCSlice::tjs, tca::TCSlice::vtx3s, tca::ShowerStruct3D::Vx3ID, and tca::TCConfig::wirePitch.

   {
     // The shower ChgPos and Dir were found by the calling function but Dir 
     // may be inconsistent with the 2D shower directions
     if(ss3.ID == 0) return false;
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"Inside FSS: 3S"<<ss3.ID<<" ->";
       for(auto cid : ss3.CotIDs) myprt<<" 2S"<<cid;
       myprt<<" Vx 3V"<<ss3.Vx3ID;
     } // prt
     
     // find a parent Tj in the list of 2D showers that is the farthest away from the
     // shower center
     unsigned short useParentCID = 0;
     float maxParentSep = 0;
     unsigned short usePtSepCID = 0;
     float maxPtSep = 0;
     // assume that the 2D shower direction is consistent with the 3D shower direction. This
     // variable is only used when no parent exists
     bool dirOK = true;
     for(auto cid : ss3.CotIDs) {
       auto& ss = slc.cots[cid - 1];
       // Find the position, direction and projection in this plane
       auto& stj = slc.tjs[ss.ShowerTjID - 1];
       auto chgCtrTP = MakeBareTP(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(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
 //      std::cout<<"useCI "<<useCID<<" sep "<<PosSep(startTP.Pos, stj.Pts[1].Pos)<<" projInPln "<<chgCtrTP.Delta<<"\n";
       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::FindSoftKink	(	TCSlice &	slc,
		Trajectory &	tj
	)

Definition at line 2211 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TCConfig::dbgStp, DeltaAngle(), tca::Trajectory::EndPt, tca::Trajectory::ID, tca::TCConfig::kinkCuts, kNewStpCuts, kSoftKink, kStiffEl, tca::Trajectory::MCSMom, MCSMom(), PrintPos(), tca::Trajectory::Pts, SetEndPoints(), tca::Trajectory::Strategy, tcc, UnsetUsedHits(), and tca::TCConfig::useAlg.

   {
     // Looks for a soft kink in the trajectory and truncates it if one is found.
     // This is best done after FixTrajBegin has been called.
     
     if(!tcc.useAlg[kSoftKink]) return;
     if(tcc.useAlg[kNewStpCuts] && tj.Strategy[kStiffEl]) return;
     if(tj.Pts.size() < 15) return;
     if(tj.MCSMom < 100) return;
     
     float dang = DeltaAngle(tj.Pts[tj.EndPt[0]].Ang, tj.Pts[tj.EndPt[1]].Ang);
     
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"FindSoftKink: "<<tj.ID<<" dang "<<dang<<" cut "<<0.5 * tcc.kinkCuts[0];
     }
     if(dang < 0.5 * tcc.kinkCuts[0]) return;
     // require at least 5 points fitted at the end of the trajectory
     unsigned short endPt = tj.EndPt[1];
     if(tj.Pts[endPt].NTPsFit < 5) return;
     if(tj.Pts[endPt].NTPsFit > endPt) return;
     // Estimate where where the kink would be
     unsigned short kinkPt = endPt - tj.Pts[endPt].NTPsFit;
     // Require at least 5 points in the trajectory before the kink
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<" kinkPt "<<kinkPt<<" NTPsFit at kinkPt "<<tj.Pts[kinkPt].NTPsFit<<" max "<<0.5 * kinkPt;
     if(kinkPt < 5) return;
     // require fewer points fitted in this region compared the number of points prior to it
     if(tj.Pts[kinkPt].NTPsFit > 0.5 * kinkPt) return;
     // scan back until we find the maximum number of points fitted
     unsigned short maxPtsFit = tj.Pts[kinkPt].NTPsFit;
     unsigned short atPt = kinkPt;
     for(unsigned short ipt = kinkPt; kinkPt > tj.EndPt[0] + 5; --ipt) {
       if(tj.Pts[ipt].NTPsFit > maxPtsFit) {
         maxPtsFit = tj.Pts[ipt].NTPsFit;
         atPt = ipt;
       }
       // stop scanning when the max starts falling
       if(tj.Pts[ipt].NTPsFit < maxPtsFit) break;
       if(ipt == 0) break;
     } // ipt
     if(atPt < 5) return;
     // require the trajectory be straight before the kink - the section we are going to keep
     if(MCSMom(slc, tj, tj.EndPt[0], atPt) < 500) return;
     // release the hits in TPs after this point
     for(unsigned short ipt = atPt; ipt < tj.Pts.size(); ++ipt) UnsetUsedHits(slc, tj.Pts[ipt]);
     // Truncate the trajectory at this point
     tj.Pts.resize(atPt + 1);
     SetEndPoints(tj);
     tj.AlgMod[kSoftKink] = true;
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<" truncated trajectory at "<<PrintPos(slc, tj.Pts[tj.Pts.size()-1]);
     
   } // FindSoftKinks

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

Definition at line 4076 of file TCShower.cxx.

References tca::ShowerStruct::AspectRatio, tca::TCSlice::cots, tca::ShowerStruct::DirectionFOM, tca::ShowerStruct::ID, tca::ShowerStruct::ParentID, tca::TCConfig::showerTag, tca::ShowerStruct::ShowerTjID, ss, StartChgVec(), tcc, tca::ShowerStruct::TjIDs, and tca::TCSlice::tjs.

   {
     // 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;
     
     // Correct for dead wires in this region - maybe later...
 //    unsigned short nDeadWires = DeadWireCount();
     
     unsigned short nBinsAverage = 5;
     double maxChg = 2 * chg;
     for(unsigned short nit = 0; nit < 2; ++nit) {
       double sum = 0;
       double sum2 = 0;
       double cnt = 0;
       for(unsigned short ii = startPt; ii < schg.size() - 1; ++ii) {
         // break if we find 2 consecutive high charge points
         if(schg[ii] > maxChg && schg[ii + 1] > maxChg) break;
         // or two zeros
         if(schg[ii] == 0 && schg[ii + 1] == 0) break;
         if(schg[ii] > maxChg) continue;
         sum += schg[ii];
         sum2 += schg[ii] * schg[ii];
         ++cnt;
         if(cnt == nBinsAverage) break;
       } // ii
       // check for a failure
       if(cnt < 3) {
         if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" nit "<<nit<<" cnt "<<cnt<<" is too low. sum "<<(int)sum<<" maxChg "<<(int)maxChg;
         // try to recover. Pick the next point
         ++startPt;
         chg = schg[startPt];
         maxChg = 2 * chg;
         continue;
       }
       // convert sum to the average charge
       chg = sum / cnt;
       double arg = sum2 - cnt * chg * chg;
       if(arg < 0) break;
       rms = sqrt(arg / (cnt - 1));
       // don't allow the rms to get crazy
       double maxrms = 0.5 * sum;
       if(rms > maxrms) rms = maxrms;
       maxChg = chg + 2 * rms;
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" nit "<<nit<<" cnt "<<cnt<<" chg "<<(int)chg<<" rms "<<(int)rms<<" maxChg "<<(int)maxChg<<" nBinsAverage "<<nBinsAverage;
       nBinsAverage = 20;
     } // nit
     
     stp0.AveChg = chg;
     
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 2S"<<cotID<<" Starting charge "<<(int)stp0.AveChg<<" startPt  "<<startPt;
     
   } // FindStartChg

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

Definition at line 1923 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TCEvent::allHits, tca::TrajPoint::AngleCode, tca::TrajPoint::AveChg, tca::Trajectory::AveChg, tca::TCConfig::chargeCuts, tca::Trajectory::ChgRMS, tca::TCConfig::dbgStp, tca::TrajPoint::Delta, tca::TrajPoint::Dir, tca::Trajectory::EndPt, evt, ExpectedHitsRMS(), GetHitMultiplet(), tca::TrajPoint::Hits, HitsRMSTick(), HitTimeErr(), tca::Trajectory::ID, kNewStpCuts, kRvPrp, kStiffEl, kUnusedHits, LongPulseHit(), tca::Trajectory::MCSMom, tca::Trajectory::PDGCode, PointTrajDOCA(), tca::TrajPoint::Pos, PrintHit(), tca::Trajectory::Pts, tca::TCSlice::slHits, tca::Trajectory::Strategy, tcc, TPHitsRMSTick(), tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, and tca::TrajPoint::UseHit.

Referenced by AddHits().

   {
     // 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;
 /* Nov 6, 2018. This is a bad idea if widely separated hits were associated with the TP
     // Use all available hits on the last pass for the first few points when starting out
     if(ipt < 3 && tj.Pass == tcc.minPts.size() - 1) {
       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;
       }
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"FUH: Using all hits on seed trajectory on the last pass";
       return;
     } // last pass for the first two points
 */
     // 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(tcc.useAlg[kNewStpCuts] && (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];
       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;
       unsigned short localIndex;
       GetHitMultiplet(slc, bestDeltaHit, hitsInMultiplet, localIndex);
       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;
       unsigned short localIndex;
       GetHitMultiplet(slc, bestDeltaHit, tHits, localIndex);
       // 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) {
         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::FindVtxTjs	(	TCSlice &	slc,
		VtxStore &	vx2
	)

Definition at line 409 of file TCVertex.cxx.

References tca::Trajectory::AlgMod, tca::TCEvent::allHits, CheckTraj(), tca::VtxStore::CTP, tca::TCConfig::dbg2V, tca::TCConfig::dbgAlg, DecodeCTP(), tca::Trajectory::EndPt, evt, FindCloseHits(), tca::TrajPoint::Hits, tca::VtxStore::ID, tca::Trajectory::ID, InTrajOK(), tca::Trajectory::IsGood, tca::TCSlice::isValid, kChkInTraj, kUnusedHits, kVtxTj, kVtxTrjTried, tca::TCConfig::minPts, MoveTPToWire(), NumPtsWithCharge(), tca::Trajectory::Pass, geo::PlaneID::Plane, tca::VtxStore::Pos, PrintHeader(), PrintHit(), PrintTrajPoint(), tca::Trajectory::Pts, ReleaseHits(), tca::VtxStore::Score, tca::TCSlice::slHits, StartTraj(), tca::VtxStore::Stat, StepAway(), tca::Trajectory::StepDir, StoreTraj(), tcc, tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, tca::TrajPoint::UseHit, valDecreasing(), tca::TCConfig::vtx2DCuts, and tca::Trajectory::VtxID.

   {
     // Look for available hits in the vicinity of this vertex and try to make
     // a vertex trajectory from them
     
     if(!tcc.useAlg[kVtxTj]) return;
     
     if(vx2.Stat[kVtxTrjTried]) return;
     // ignore low score
     if(vx2.Score < tcc.vtx2DCuts[7]) return;
     
     bool prt = (tcc.dbg2V || tcc.dbgAlg[kVtxTj]);
     
     std::array<int, 2> wireWindow;
     std::array<float, 2> timeWindow;
     
     // on the first try we look for small angle trajectories which will have hits
     // with a large wire window and a small time window
     // Vertex2DCuts fcl input usage
     // 0 User definition of a short Tj => max number of Tj points
     // 1 max separation between a vertex and the start of a trajectory for a user-defined short Tj
     // 2 max separation for a user-defined long Tj
     // 3 max position pull when attaching a Tj to a vertex
     // 4 max position error for creating a Tj or attaching Tjs to an existing vertex
     // 5 Min MCSMom of Tjs that can be used to create a vertex
     // 6 min frac of Points/Wire between a vtx and a Tj. Ideally one if the efficiency is good
     // 7 min Score
     // 8 ID of a vertex for printing special debugging information
     wireWindow[0] = std::nearbyint(vx2.Pos[0] - tcc.vtx2DCuts[1]);
     wireWindow[1] = std::nearbyint(vx2.Pos[0] + tcc.vtx2DCuts[1]);
     timeWindow[0] = vx2.Pos[1] - tcc.vtx2DCuts[1];
     timeWindow[1] = vx2.Pos[1] + tcc.vtx2DCuts[1];
     
     geo::PlaneID planeID = DecodeCTP(vx2.CTP);
     unsigned short ipl = planeID.Plane;
     
     if(prt) mf::LogVerbatim("TC")<<"inside FindVtxTjs 2v"<<vx2.ID<<" Window "<<wireWindow[0]<<" "<<wireWindow[1]<<" "<<timeWindow[0]/tcc.unitsPerTick<<" "<<timeWindow[1]/tcc.unitsPerTick<<" in plane "<<ipl;
     
     // find nearby available hits
     bool hitsNear;
     std::vector<unsigned int> closeHits = FindCloseHits(slc, wireWindow, timeWindow, ipl, kUnusedHits, true, hitsNear);
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"closeHits";
       for(auto& iht : closeHits) myprt<<" "<<PrintHit(slc.slHits[iht]);
     }
     if(closeHits.empty()) return;
     // sort by distance from the vertex
     std::vector<SortEntry> sortVec(closeHits.size());
     SortEntry sortEntry;
     for(unsigned short ii = 0; ii < closeHits.size(); ++ii) {
       unsigned int iht = closeHits[ii];
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       float dw = hit.WireID().Wire - vx2.Pos[0];
       float dt = tcc.unitsPerTick * hit.PeakTime() - vx2.Pos[1];
       float d2 = dw * dw + dt * dt;
       sortEntry.index = ii;
       sortEntry.val = d2;
       sortVec[ii] = sortEntry;
     } // ii
     std::sort(sortVec.begin(), sortVec.end(), valDecreasing);
     unsigned int vWire = std::nearbyint(vx2.Pos[0]);
     int vTick = vx2.Pos[1]/tcc.unitsPerTick;
     if(prt) PrintHeader("FVT");
     for(unsigned short ii = 0; ii < closeHits.size(); ++ii) {
       unsigned int iht = closeHits[sortVec[ii].index];
       if(slc.slHits[iht].InTraj > 0) continue;
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       // the direction will be poorly defined if a hit is very close to the vertex and it is in this list.
       // Ignore these hits
       if(hit.WireID().Wire == vWire) {
         // on the vertex wire. Check for a close time
         if(abs(hit.PeakTime() - vTick) < 10) continue;
       } // hit on vtx wire
       float toWire = hit.WireID().Wire;
       float toTick = hit.PeakTime();
       // assume the last pass and fix it later after the angle is calculated
       unsigned short pass = tcc.minPts.size() - 1;
       Trajectory tj;
       if(!StartTraj(slc, tj, vx2.Pos[0], vx2.Pos[1]/tcc.unitsPerTick, toWire, toTick, vx2.CTP, pass)) continue;
       // ensure that the first TP is good
       if(tj.Pts[0].Pos[0] < 0) continue;
       tj.VtxID[0] = vx2.ID;
       TrajPoint tp = tj.Pts[0];
       // Move the Pt to the hit
       MoveTPToWire(tp, toWire);
       // attach the hit
       tp.Hits.push_back(iht);
       tp.UseHit[tp.Hits.size()-1] = true;
       slc.slHits[iht].InTraj = tj.ID;
       tp.UseHit[tp.Hits.size()-1] = false;
       if(prt) PrintTrajPoint("FVT", slc, 0, tj.StepDir, tj.Pass, tp);
       // Step away and see what happens
       StepAway(slc, tj);
       // check for a major failure
       if(!slc.isValid) return;
       // Check the quality of the trajectory
       CheckTraj(slc, tj);
       if(!tj.IsGood || NumPtsWithCharge(slc, tj, true) < 2) {
         if(prt) mf::LogVerbatim("TC")<<" xxxxxxx Not enough points "<<NumPtsWithCharge(slc, tj, true)<<" minimum "<<tcc.minPts[tj.Pass]<<" or !IsGood";
         ReleaseHits(slc, tj);
         continue;
       }
       tj.AlgMod[kVtxTj] = true;
       slc.isValid = StoreTraj(slc, tj);
       if(tcc.useAlg[kChkInTraj]) {
         slc.isValid = InTrajOK(slc, "FVT");
         if(!slc.isValid) {
           mf::LogVerbatim("TC")<<"InTrajOK failed in FindVtxTjs";
           return;
         }
       }
       if(prt) mf::LogVerbatim("TC")<<"FindVtxTjs: calling StoreTraj with npts "<<tj.EndPt[1];
     } // ii
     
     // Flag this as tried so we don't try again
     vx2.Stat[kVtxTrjTried] = true;
   } // FindVtxTjs

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

Definition at line 1355 of file PFPUtils.cxx.

References detinfo::DetectorProperties::ConvertXToTicks(), tca::MatchStruct::Count, geo::CryostatID::Cryostat, tca::TrajPoint::CTP, DecodeCTP(), DeltaAngle(), tca::TCConfig::detprop, tca::TrajPoint3::Dir, EncodeCTP(), tca::TCConfig::geom, tca::SortEntry::index, MakeTp3(), tca::TCSlice::mallTraj, tca::TCConfig::match3DCuts, tca::TCConfig::maxPos0, tca::TCSlice::nPlanes, geo::PlaneID::Plane, tca::TrajPoint::Pos, tca::TrajPoint3::Pos, SignalAtTp(), tcc, tca::MatchStruct::TjIDs, tca::TCSlice::tjs, geo::TPCID::TPC, tca::TCConfig::unitsPerTick, valDecreasings(), and geo::GeometryCore::WireCoordinate().

Referenced by FindPFParticles().

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

void tca::Finish3DShowers ( TCSlice & slc )

Definition at line 131 of file TCShower.cxx.

References ChkAssns(), tca::TCSlice::cots, CreatePFP(), DecodeCTP(), evd::details::end(), GetAssns(), GetSliceIndex(), tca::TCSlice::ID, kKilled, kUsedHits, tca::TCSlice::pfps, geo::PlaneID::Plane, PutTrajHitsInVector(), tca::TCSlice::showers, slices, ss, tca::TCSlice::tjs, TransferTjHits(), tca::TCSlice::vtx3s, tca::Trajectory::VtxID, and tca::TCSlice::vtxs.

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

   {
     // 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) {
         std::cout<<"Finish3DShowers 3S"<<ss3.ID<<" already has a pfp associated with it...\n";
         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()) {
           std::cout<<"Finish3DShowers 3S"<<ss3.ID<<" has an invalid cots ID"<<cid<<"\n";
           return;
         }
         auto& ss = slc.cots[cid - 1];
         auto& stj = slc.tjs[ss.ShowerTjID - 1];
         showerPFP.TjIDs[ii] = stj.ID;
       } // ci
       showerPFP.PDGCode = 1111;
       showerPFP.XYZ[0] = ss3.Start;
       showerPFP.Dir[0] = ss3.Dir;
       showerPFP.DirErr[0] = ss3.DirErr;
       showerPFP.Vx3ID[0] = ss3.Vx3ID;
       showerPFP.XYZ[1] = ss3.End;
       showerPFP.Dir[1] = ss3.Dir;
       // dEdx is indexed by plane for pfps and by 2D shower index for 3D showers
       for(auto cid : ss3.CotIDs) {
         auto& ss = 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;
         if(ndead != pfp.TjIDs.size()) {
           std::cout<<"Finish3DShowers: Not all Tjs in P"<<pfp.ID<<" are killed";
           for(auto tid : pfp.TjIDs) {
             auto& tj = slc.tjs[tid - 1];
             std::cout<<" T"<<tid<<" dead? "<<tj.AlgMod[kKilled];
           }
           std::cout<<"\n";
         } // ndead
         pfp.ID = 0;
       } // pfp
     } // pfps not empty
     
     // kill orphan 2D vertices
     for(auto& vx2 : 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
     
     // check
     for(auto& pfp : slc.pfps) {
       if(pfp.ID == 0) continue;
       if(pfp.PDGCode != 1111) continue;
       if(pfp.Vx3ID[0] > 0 && slc.vtx3s[pfp.Vx3ID[0] - 1].ID == 0) {
         std::cout<<"Finish3DShowers shower P"<<pfp.ID<<" has Vx3ID[0] = "<<pfp.Vx3ID[0]<<" but the vertex is killed\n";
       } // Vx3 check
     } // pfp
 
   } // Finish3DShowers

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

Definition at line 4536 of file Utils.cxx.

References B.

Referenced by ChgSlope(), ChkStop(), DotProd(), and MakeJunkTraj().

   {
     // 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::Fit3D	(	unsigned short	mode,
		Point3_t	point,
		Vector3_t	dir,
		Point3_t &	fitPos,
		Vector3_t &	fitDir
	)

Definition at line 1042 of file PFPUtils.cxx.

References SetMag().

Referenced by FindCompleteness().

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

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

Definition at line 646 of file PFPUtils.cxx.

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

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

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

Definition at line 556 of file PFPUtils.cxx.

References dir.

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

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

Definition at line 562 of file PFPUtils.cxx.

References detinfo::DetectorProperties::ConvertTicksToX(), geo::CryostatID::Cryostat, DecodeCTP(), tca::TCConfig::detprop, tca::TCConfig::geom, norm, tca::TCSlice::nPlanes, geo::PlaneID::Plane, sw, tcc, tca::TCSlice::tjs, geo::TPCID::TPC, tca::TCConfig::unitsPerTick, w, geo::GeometryCore::WireCoordinate(), and x.

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

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

Definition at line 753 of file Utils.cxx.

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

Referenced by EndMerge(), GottaKink(), HiEndDelta(), MaskBadTPs(), MaskedHitsOK(), UpdateStiffEl(), and UpdateTraj().

   {
     // Jacket around FitTraj to fit the leading edge of the supplied trajectory
     unsigned short originPt = tj.EndPt[1];
     unsigned short npts = tj.Pts[originPt].NTPsFit;
     TrajPoint tpFit;
     unsigned short fitDir = -1;
     FitTraj(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 766 of file Utils.cxx.

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

Referenced by FitTraj().

   {
     // Fit the supplied trajectory using HitPos positions with the origin at originPt.
     // The npts is interpreted as the number of points on each side of the origin
     // The allowed modes are as follows, where i denotes a TP that is included, . denotes
     // a TP with no hits, and x denotes a TP that is not included
     //TP 012345678  fitDir  originPt npts
     //   Oiiixxxxx   1        0       4 << npts in the fit
     //   xi.iiOxxx  -1        5       4
     //   xiiiOiiix   0        4       4 << 2 * npts + 1 points in the fit
     //   xxxiO.ixx   0        4       1
     //   0iiixxxxx   0        0       4
     // This routine puts the results into tp if the fit is successfull. The
     // fit "direction" is in increasing order along the trajectory from 0 to tj.Pts.size() - 1.
     
     //    static const float twoPi = 2 * M_PI;
     
     if(originPt > tj.Pts.size() - 1) {
       mf::LogWarning("TC")<<"FitTraj: Requesting fit of invalid TP "<<originPt;
       return;
     }
     
     // copy the origin TP into the fit TP
     tpFit = tj.Pts[originPt];
     // Assume that the fit will fail
     tpFit.FitChi = 999;
     if(fitDir < -1 || fitDir > 1) return;
     
     std::vector<double> x, y;
     Point2_t origin = tj.Pts[originPt].HitPos;
     // Use TP position if there aren't any hits on it
     if(tj.Pts[originPt].Chg == 0) origin = tj.Pts[originPt].Pos;
     
     // simple two point case
     if(NumPtsWithCharge(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);
     //    if(prt) mf::LogVerbatim("TC")<<"FitTraj "<<originPt<<" originPt Dir "<<tj.Pts[originPt].Dir[0]<<" "<<tj.Pts[originPt].Dir[1]<<" rotAngle "<<rotAngle<<" tpFit.Dir "<<tpFit.Dir[0]<<" "<<tpFit.Dir[1]<<" Ang "<<tpFit.Ang<<" flipDir "<<flipDir<<" fit vector size "<<x.size();
     
     // rotate (0, intcpt) into (W,T) coordinates
     tpFit.Pos[0] = -sn * A + origin[0];
     tpFit.Pos[1] =  cs * A + origin[1];
     // force the origin to be at origin[0]
     if(tpFit.AngleCode < 2) MoveTPToWire(tpFit, origin[0]);
     
     if(x.size() < 3) return;
     
     // Calculate chisq/DOF
     double ndof = x.size() - 2;
     double varnce = (sumy2 + A*A*sum + B*B*sumx2 - 2 * (A*sumy + B*sumxy - A*B*sumx)) / ndof;
     if(varnce > 0.) {
       // Intercept error is not used
       //      InterceptError = sqrt(varnce * sumx2 / delta);
       double slopeError = sqrt(varnce * sum / delta);
       tpFit.AngErr = std::abs(atan(slopeError));
     } else {
       tpFit.AngErr = 0.01;
     }
     sum = 0;
     // calculate chisq
     double arg;
     for(unsigned short ii = 0; ii < y.size(); ++ii) {
       arg = y[ii] - A - B * x[ii];
       sum += arg * arg / w[ii];
     }
     tpFit.FitChi = sum / ndof;
     
   } // FitTraj

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

Definition at line 2131 of file TCVertex.cxx.

References tca::VtxStore::CTP, tca::VtxStore::ID, kFixed, kHaloTj, kKilled, kNewVtxCuts, kNoFitToVx, kPhoton, tca::VtxStore::Stat, tcc, tca::TCSlice::tjs, and tca::TCConfig::useAlg.

Referenced by AttachTrajToVertex(), EndMerge(), Find2DVertices(), MergeWithVertex(), and SplitTrajCrossingVertices().

   {
     // A poor-mans fitting scheme. If the fitted vertex position error is within the supplied
     // value, the position and errors are updated and we return true, otherwise the vertex is
     // left unchanged and we return false
     
     // 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;
       if(tj.AlgMod[kNoFitToVx]) continue;
       bool added = false;
       if(tj.VtxID[0] == vx.ID) {
         vxTp.push_back(tj.Pts[tj.EndPt[0]]);
         added = true;
       }
       if(tj.VtxID[1] == vx.ID) {
         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(tcc.useAlg[kNewVtxCuts] && 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 >	vxTp,
		bool	prt
	)

Definition at line 2184 of file TCVertex.cxx.

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

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

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

Definition at line 2988 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TrajPoint::AngleCode, ChkStopEndPts(), tca::TrajPoint::CTP, tca::TCConfig::dbgStp, DecodeCTP(), tca::TrajPoint::DeltaRMS, tca::TrajPoint::Dir, tca::Trajectory::EndPt, FindCloseHits(), FixTrajBegin(), tca::TrajPoint::Hits, tca::Trajectory::IsGood, kFixBegin, kFTBRvProp, kJunkTj, kKilled, kNewStpCuts, kRvPrp, kUnusedHits, NumPtsWithCharge(), tca::TCSlice::nWires, tca::Trajectory::Pass, geo::PlaneID::Plane, tca::TrajPoint::Pos, PrintPos(), PrintTrajPoint(), tca::Trajectory::Pts, tca::TCConfig::qualityCuts, ReversePropagate(), seeds, SetEndPoints(), tca::Trajectory::StepDir, tcc, TrimEndPts(), UnsetUsedHits(), tca::TCConfig::useAlg, tca::TrajPoint::UseHit, tca::TCConfig::VLAStepSize, and tca::TCSlice::wireHitRange.

   {
     // Update the parameters at the beginning 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;
     for(unsigned short ipt = tj.EndPt[0]; ipt < tj.EndPt[1]; ++ipt) {
       if(tj.Pts[ipt].Chg == 0) continue;
       if(tj.Pts[ipt].NTPsFit > maxPtsFit) {
         maxPtsFit = tj.Pts[ipt].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(tcc.useAlg[kNewStpCuts] && needsRevProp) needsRevProp = (nPtsLeft > 5);
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"FTB: firstPtFit "<<PrintPos(slc, tj.Pts[firstPtFit].Pos)<<" atPt "<<PrintPos(slc, tj.Pts[atPt].Pos)<<" nPts left after trimming "<<nPtsLeft;
     
     if(!needsRevProp) {
       // 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;
       if(tcc.useAlg[kNewStpCuts]) {
         // 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] && slc.wireHitRange[plane][wire].first == -1);
         if(tcc.dbgStp && needsRevProp) mf::LogVerbatim("TC")<<"FTB: Previous wire "<<wire<<" is dead. Call ReversePropagate";
       } // NewStpCuts
       if(!needsRevProp) {
         // check for hits on a not-dead wire
         float maxDelta = 3 * tp.DeltaRMS;
         if(FindCloseHits(slc, tp, maxDelta, kUnusedHits) && !tp.Hits.empty()) {
           needsRevProp = true;
           if(tcc.dbgStp) {
             mf::LogVerbatim("TC")<<"FTB: Close unused hits found near EndPt[0] "<<tp.Hits.size()<<". Call ReversePropagate";
             PrintTrajPoint("FTB", slc, 0, tj.StepDir, tj.Pass, tp);
           }
         }
       } // !needsRevProp
     } // !needsRevProp
     
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"FTB: 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
       if(tcc.useAlg[kNewStpCuts]) 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);
     }
     // Clean up the first points if no reverse propagation was done
     if(!tj.AlgMod[kRvPrp]) FixTrajBegin(slc, tj, atPt);
     
   } // FixTrajBegin

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

Definition at line 3092 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TrajPoint::Ang, tca::TrajPoint::AngErr, tca::TrajPoint::AngleCode, tca::Trajectory::AveChg, tca::Trajectory::ChgRMS, tca::TCConfig::dbgStp, tca::TrajPoint::Dir, tca::Trajectory::EndPt, kBragg, kFixBegin, kJunkTj, kNewStpCuts, tca::Trajectory::MCSMom, NumPtsWithCharge(), tca::Trajectory::PDGCode, PointTrajDOCA(), tca::TrajPoint::Pos, PrintPos(), PrintStopFlag(), tca::Trajectory::Pts, SetEndPoints(), tca::Trajectory::StopFlag, tcc, UnsetUsedHits(), tca::TCConfig::useAlg, and tca::Trajectory::VtxID.

Referenced by CheckStiffEl(), CheckTraj(), and FixTrajBegin().

   {
     // 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 somewhat longer trajectories that are curly
     if(npwc < 10 && tj.MCSMom < 100) return;
     // ignore shower-like trajectories
     if(tj.PDGCode == 11) return;
     // ignore junk trajectories
     if(tj.AlgMod[kJunkTj]) return;
     // ignore stopping trajectories
     if(tj.StopFlag[0][kBragg]) 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;
     if(tcc.useAlg[kNewStpCuts]) {
       // 10/2/2018 BB Change requirement
       // 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;
     } // kNewStpCuts
     
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"FixTrajBegin: atPt "<<atPt<<" firstPt "<<firstPt<<" Stops at end 0? "<<PrintStopFlag(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 maskThisPt = (tj.Pts[ipt].Delta > maxDelta);
       if(maskThisPt) maskedPts = true;
       if(tcc.useAlg[kNewStpCuts]) {
         // 10/1/18 BB only mask off the bad point. Not all of them to the end
         if(maskThisPt) {
           UnsetUsedHits(slc, tp);
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<" mask off "<<PrintPos(slc, tj.Pts[ipt].Pos)<<" "<<tj.Pts[ipt].Delta;
         } // maskThisPt
       } else {
         // old cuts - mask off all points to the beginning
         if(maskedPts) {
           UnsetUsedHits(slc, tp);
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<" mask off "<<PrintPos(slc, tj.Pts[ipt].Pos)<<" "<<tj.Pts[ipt].Delta;
         } // maskedPts
       } // old cuts
       if(ipt == 0) break;
     } // ii
     if(maskedPts) SetEndPoints(tj);
     tj.AlgMod[kFixBegin] = true;
     
   } // FixTrajBegin

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

Definition at line 3173 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TrajPoint::Ang, tca::TrajPoint::AngErr, tca::TrajPoint::AngleCode, tca::Trajectory::AveChg, tca::Trajectory::ChgRMS, tca::TCConfig::dbgStp, tca::TrajPoint::Dir, tca::Trajectory::EndPt, kBragg, kFixEnd, kJunkTj, tca::Trajectory::MCSMom, NumPtsWithCharge(), tca::Trajectory::PDGCode, PointTrajDOCA(), tca::TrajPoint::Pos, PrintTrajectory(), tca::Trajectory::Pts, tca::Trajectory::StopFlag, tcc, and tca::TCConfig::useAlg.

   {
     // Update the parameters at the end of the trajectory starting at point atPt
     
     if(!tcc.useAlg[kFixEnd]) return;
     // ignore short trajectories
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
     if(npwc < 6) return;
     // ignore somewhat longer trajectories that are curly
     if(npwc < 10 && tj.MCSMom < 100) return;
     // ignore shower-like trajectories
     if(tj.PDGCode == 11) return;
     // ignore junk trajectories
     if(tj.AlgMod[kJunkTj]) return;
     // ingore stopping trajectories
     if(tj.StopFlag[1][kBragg]) return;
     
     if(tcc.dbgStp) {
       mf::LogVerbatim("TC")<<"FixTrajEnd: atPt "<<atPt;
     }
     
     if(atPt == tj.EndPt[1]) return;
     
     // update the trajectory for all the intervening points
     for(unsigned short ipt = atPt + 1; ipt <= tj.EndPt[1]; ++ipt) {
       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;
       if(tcc.dbgStp) {
         PrintTrajectory("FTE", slc, tj, ipt);
       }
     } // ipt
     tj.AlgMod[kFixEnd] = true;
     
   } // FixTrajEnd

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

Definition at line 405 of file PFPUtils.cxx.

References detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, DecodeCTP(), tca::TCConfig::detprop, tca::PFPStruct::Dir, FindAlongTrans(), tca::TCConfig::geom, kEnvFlag, tca::TCSlice::nPlanes, geo::PlaneID::Plane, PointDirection(), PosSep(), PosSep2(), SetMag(), tcc, tca::PFPStruct::TjIDs, tca::TCSlice::tjs, tca::PFPStruct::Tp3s, geo::TPCID::TPC, tca::PFPStruct::TPCID, tca::TCConfig::unitsPerTick, tca::TCSlice::vtx3s, tca::PFPStruct::Vx3ID, geo::GeometryCore::WireCoordinate(), tca::TCConfig::wirePitch, and tca::PFPStruct::XYZ.

Referenced by DefinePFP().

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

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

Definition at line 404 of file StepUtils.cxx.

References tca::Trajectory::AveChg, tca::Trajectory::ChgRMS, ChgSlope(), ChkStop(), tca::Trajectory::CTP, tca::TCConfig::dbgStp, DecodeCTP(), DefineHitPos(), tca::Trajectory::EndPt, evt, FindCloseHits(), tca::TCSlice::firstWire, tca::Trajectory::ID, kAllHits, kBragg, kEnvDeadWire, kEnvNearShower, tca::TCSlice::lastWire, tca::Trajectory::MCSMom, MCSMom(), MoveTPToWire(), NumPtsWithCharge(), tca::Trajectory::PDGCode, geo::PlaneID::Plane, PointTrajDOCA(), PrintPos(), tca::Trajectory::Pts, SetEndPoints(), tca::Trajectory::StopFlag, tcc, tjfs, tca::Trajectory::TotChg, UpdateTjChgProperties(), and tca::TCEvent::WorkID.

Referenced by StepAway().

   {
     // 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 minShPts = 3;
 
     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 tp = 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(tp.Pos[1] - tp.HitPos[1]);
     if(forecastWin0 < 1) forecastWin0 = 1;
     tp.Pos = tp.HitPos;
     double stepSize = std::abs(1/tp.Dir[0]);
     float window = 10 * 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(tp.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;
     unsigned short nShLike = 0;
     unsigned short 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) tp.Pos[iwt] += tp.Dir[iwt] * stepSize;
       unsigned int wire = std::nearbyint(tp.Pos[0]);
       if(wire < slc.firstWire[plane]) break;
       if(wire > slc.lastWire[plane]-1) break;
       MoveTPToWire(tp, (float)wire);
       ++tp.Step;
       if(FindCloseHits(slc, tp, 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(!tp.Environment[kEnvDeadWire]) {
           nMissed = 0;
           tp.UseHit.set();
           DefineHitPos(slc, tp);
           fctj.TotChg += tp.Chg;
           tp.Delta = PointTrajDOCA(slc, tp.HitPos[0], tp.HitPos[1], tp);
           tp.DeltaRMS = tp.Delta / window;
           tp.Environment.reset();
           totHits += tp.Hits.size();
           if(tp.Chg > maxChg) {
             maxChg = tp.Chg;
             maxChgPt = fctj.Pts.size();
           }
           // Note that ChgPull uses the average charge and charge RMS of the 
           // trajectory before it entered the forecast envelope
           tp.ChgPull = (tp.Chg / minAveChg - 1) / tj.ChgRMS;
           if((tp.ChgPull > 3 && tp.Hits.size() > 1) || tp.ChgPull > 10) {
             ++nShLike;
             // break if the tj was tracklike before this point
             if(nShLike > minShPts && nTkLike >= minShPts) {
               trimPts = minShPts;
               showerStartNear = npwc + fctj.Pts.size() - minShPts;
               if(doPrt) {
                 mf::LogVerbatim("TC")<<"showerlike was tracklike - break";
               }
               break;
             }
             // not track-like anymore
             if(nShLike >= minShPts) nTkLike = 0;
             // break if it approaches the side of the envelope
             if(tp.DeltaRMS > 0.8) {
               leavesNear = npwc + fctj.Pts.size();
               leavesBeforeEnd = true;
               break;
             }
             tp.Environment[kEnvNearShower] = true;
             // flag a showerlike TP so it isn't used in the MCSMom calculation
             tp.HitPosErr2 = 100;
           } else {
             ++nTkLike;
             // break if the tj was shower-like before this point
             if(nTkLike > minShPts && nShLike >= minShPts) {
               trimPts = minShPts;
               showerEndNear = npwc + fctj.Pts.size() - minShPts;
               if(doPrt) {
                 mf::LogVerbatim("TC")<<"tracklike was showerlike - break";
               }
               break;
             }
             // not shower-like anymore
             if(nTkLike >= minShPts) nShLike = 0;
             // break if it approaches the side of the envelope
             if(tp.DeltaRMS > 0.9) {
               leavesNear = npwc + fctj.Pts.size();
               leavesBeforeEnd = true;
               break;
             }
           }
           fctj.Pts.push_back(tp);
           if(doPrt) {
             mf::LogVerbatim myprt("TC");
             myprt<<std::setw(4)<<npwc + fctj.Pts.size()<<" "<<PrintPos(slc, tp);
             myprt<<std::setw(5)<<tp.Hits.size();
             myprt<<std::setw(5)<<(int)tp.Chg;
             myprt<<std::fixed<<std::setprecision(1);
             myprt<<std::setw(8)<<tp.ChgPull;
             myprt<<std::setw(8)<<tp.Delta;
             myprt<<std::setw(8)<<std::setprecision(2)<<tp.DeltaRMS;
             myprt<<std::setw(8)<<sqrt(tp.HitPosErr2);
             myprt<<std::setw(6)<<nTkLike;
             myprt<<std::setw(6)<<nShLike;
           } // doPrt
         } else {
 //          if(doPrt) std::cout<<istp<<" Pos "<<PrintPos(slc, tp)<<" window "<<window<<" dead wire\n";
         }
       } 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() < 6) 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;
     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
       ChgSlope(slc, fctj, fctj.EndPt[0], maxChgPt, tjf.chgSlope, tjf.chgSlopeErr, tjf.chgFitChiDOF);
     } else {
       ChgSlope(slc, fctj, tjf.chgSlope, tjf.chgSlopeErr, tjf.chgFitChiDOF);
     }
     ChkStop(slc, fctj);
     UpdateTjChgProperties("Fc", slc, fctj, false);
     tjf.chgRMS = fctj.ChgRMS;
     tjf.endBraggPeak = fctj.StopFlag[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, tp);
       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 4279 of file Utils.cxx.

References tca::TCSlice::cots, evd::details::end(), kHaloTj, kKilled, kMat3D, tca::TCSlice::pfps, SetIntersection(), tca::TCSlice::showers, ss, tca::TCSlice::tjs, tmp, tca::TCSlice::vtx3s, and tca::TCSlice::vtxs.

Referenced by ChkVxTjs(), CompleteIncomplete3DVertices(), CompleteIncompleteShower(), DefineDontCluster(), DefinePFPParents(), DotProd(), FindCots(), FindHammerVertices(), FindNearbyTjs(), FindParent(), Finish3DShowers(), KillVerticesInShower(), MergeNearby2DShowers(), ParentFOM(), Print3V(), PrintAllTraj(), Reconcile3D(), SetParent(), and TagShowerLike().

   {
     // 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
     
     std::cout<<"GetAssns doesn't know about "<<type1Name<<" -> "<<type2Name<<" assns, or id "<<id<<" is not valid.\n";
 
     return tmp;
     
   } // GetAssns

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

Definition at line 4359 of file TCShower.cxx.

References tca::TCSlice::cots.

Referenced by MergeShowerTjsAndStore().

   {
     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	(	TCSlice &	slc,
		unsigned int	theHit,
		std::vector< unsigned int > &	hitsInMultiplet
	)

Definition at line 1573 of file StepUtils.cxx.

References GetHitMultiplet().

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

   {
     unsigned short localIndex;
     GetHitMultiplet(slc, theHit, hitsInMultiplet, localIndex);
   } // GetHitMultiplet

void tca::GetHitMultiplet	(	TCSlice &	slc,
		unsigned int	theHit,
		std::vector< unsigned int > &	hitsInMultiplet,
		unsigned short &	localIndex
	)

Definition at line 1580 of file StepUtils.cxx.

References tca::TCEvent::allHits, tca::TCEvent::aveHitRMS, evt, tca::TCConfig::multHitSep, tca::TCSlice::slHits, tcc, and tmp.

Referenced by AddHits(), FindUseHits(), GetHitMultiplet(), and IsGhost().

   {
     hitsInMultiplet.clear();
     localIndex = 0;
     if(theHit > slc.slHits.size() - 1) return;
     if(slc.slHits[theHit].InTraj == SHRT_MAX) return;
     hitsInMultiplet.resize(1);
     hitsInMultiplet[0] = theHit;
     
     auto& hit = (*evt.allHits)[slc.slHits[theHit].allHitsIndex];
     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 short 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
     localIndex = hitsInMultiplet.size() - 1;
     // 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 == SHRT_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;
     
     if(hitsInMultiplet.size() > 16) {
       // Found > 16 hits in a multiplet which would be bad for UseHit. Truncate it
       hitsInMultiplet.resize(16);
       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	(	TCSlice &	slc,
		PFPStruct &	pfp
	)

Definition at line 77 of file TCCR.cxx.

References tca::TCEvent::allHits, tca::TCHit::allHitsIndex, cheat::BackTrackerService::ChannelToTrackIDEs(), evt, tca::TCConfig::geom, simb::MCTruth::Origin(), geo::origin(), geo::GeometryCore::PlaneWireToChannel(), tca::Trajectory::Pts, tca::TCSlice::slHits, tcc, tca::PFPStruct::TjIDs, tca::TCSlice::tjs, and cheat::ParticleInventoryService::TrackIdToMCTruth_P().

Referenced by SaveCRInfo().

                                              {
 
     art::ServiceHandle<cheat::BackTrackerService> bt_serv;    
     art::ServiceHandle<cheat::ParticleInventoryService> pi_serv;    
 
     std::map<int, float> omap; //<origin, energy>
 
     for(auto& tjID : pfp.TjIDs) {
       
       Trajectory& tj = 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(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	(	TCSlice &	slc,
		int	tjID
	)

Definition at line 1127 of file Utils.cxx.

References tca::TCSlice::pfps.

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

   {
     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

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

Definition at line 3267 of file TCVertex.cxx.

References evd::details::end(), tca::PFPStruct::TjIDs, tca::TCSlice::tjs, tmp, and tca::TCSlice::vtxs.

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

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

Definition at line 4496 of file Utils.cxx.

References slices.

Referenced by DotProd(), Finish3DShowers(), MakeHaloTj(), PrimaryUID(), Print2V(), Print3S(), Print3V(), PrintP(), PrintT(), Reconcile3D(), and StitchPFPs().

   {
     // 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 185 of file TCShTree.cxx.

References tca::ShowerTreeVars::StageName.

Referenced by SaveTjInfo().

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

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

Definition at line 3226 of file TCVertex.cxx.

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

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

   {
     // returns a list of trajectory IDs that are attached to vx2
     std::vector<int> tmp;
     if(vx2.ID == 0) return tmp;
     for(auto& tj : 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 3243 of file TCVertex.cxx.

References GetVtxTjIDs(), tca::Vtx3Store::ID, tmp, and tca::TCSlice::vtxs.

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

void tca::GottaKink	(	TCSlice &	slc,
		Trajectory &	tj,
		unsigned short &	killPts
	)

Definition at line 2842 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TrajPoint::Ang, tca::TrajPoint::AngErr, tca::TCConfig::dbgStp, tca::Trajectory::EndPt, FitTraj(), kAtKink, tca::TCConfig::kinkCuts, kNewStpCuts, kNoKinkChk, kRvPrp, kSlowing, kStiffEl, kStiffMu, tca::Trajectory::MCSMom, MCSMom(), MCSThetaRMS(), NumPtsWithCharge(), tca::Trajectory::PDGCode, PrintPos(), tca::Trajectory::Pts, tca::Trajectory::StopFlag, tca::Trajectory::Strategy, tcc, TrajPointSeparation(), and tca::TCConfig::useAlg.

Referenced by CheckHiMultUnusedHits(), and StepAway().

   {
     // Checks the last few points on the trajectory and returns with the number of
     // points (killPts) that should be killed (aka masked) at the end
     // tcc.kinkCuts
     // 0 = kink angle cut (radians)
     // 1 = kink angle significance cut
     // 2 = nPts fit at the end of the tj
     // Kink angle cut = tcc.kinkCuts[0] + tcc.kinkCuts[1] * MCSThetaRMS
     
     killPts = 0;
     
     // don't apply kink cuts if this looks a high energy electron
     if(tj.Strategy[kStiffEl] || tj.Strategy[kStiffMu]) return;
     
     // decide whether to turn kink checking back on
     if(tcc.kinkCuts[0] > 0 && tj.EndPt[1] == 20) {
       if(MCSMom(slc, tj, 10, 19) > 50) tj.AlgMod[kNoKinkChk] = false;
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"GottaKink turn kink checking back on? "<<tj.AlgMod[kNoKinkChk]<<" with MCSMom "<<MCSMom(slc, tj, 10, 19);
     }
     if(tj.AlgMod[kNoKinkChk]) return;
     
     // we 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[2];
     // fit more points if this is a muon
     if(tcc.useAlg[kNewStpCuts] && tj.PDGCode == 13) nPtsFit += 2;
     if(npwc < 2 * nPtsFit) return;
     unsigned short lastPt = tj.EndPt[1];
     if(tj.Pts[lastPt].Chg == 0) return;
     
     // MCSThetaRMS is the scattering angle for the entire length of the trajectory. Convert
     // this to the scattering angle for one WSE unit
     float thetaRMS = MCSThetaRMS(slc, tj, tj.EndPt[0], tj.EndPt[1]) / sqrt(TrajPointSeparation(tj.Pts[tj.EndPt[0]], tj.Pts[lastPt]));
     float kinkAngCut = tcc.kinkCuts[0] + tcc.kinkCuts[1] * thetaRMS;
     // relax this a bit when doing RevProp
     if(tj.AlgMod[kRvPrp]) kinkAngCut *= 1.3;
     
     // modify for stopping tracks
     if(tj.Strategy[kSlowing]) {
       nPtsFit = 3;
       kinkAngCut *= 3;
     }
     
     // find the point where a kink is expected and fit the points after that point
     unsigned short kinkPt = 0;
     unsigned short cnt = 0;
     float endChg = 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;
       endChg += tj.Pts[ipt].Chg;
       if(cnt == nPtsFit) {
         kinkPt = ipt;
         break;
       }
     } // ii
     if(kinkPt == 0 || cnt == 0) return;
     // fit the last nPtsFit points
     unsigned short fitDir = -1;
     TrajPoint tpFit;
     FitTraj(slc, tj, lastPt, nPtsFit, fitDir, tpFit);
     float dang = std::abs(tj.Pts[kinkPt].Ang - tpFit.Ang);
     // Calculate the average charge of the last ~3 points
     endChg /= cnt;
     float err = tj.Pts[kinkPt].AngErr;
     if(tpFit.AngErr > err) err = tpFit.AngErr;
     if(tj.Strategy[kSlowing]) err *= 2;
     float kinkSig = dang / err;
     float endChgAsym = (endChg - tj.Pts[kinkPt].AveChg) / (endChg + tj.Pts[kinkPt].AveChg);
     if(tcc.dbgStp) {
       mf::LogVerbatim myprt("TC");
       myprt<<"GottaKink kinkPt "<<PrintPos(slc, tj.Pts[kinkPt]);
       myprt<<std::setprecision(3);
       myprt<<" Ang before "<<tj.Pts[kinkPt].Ang<<" Err "<<tj.Pts[kinkPt].AngErr;
       myprt<<" AveChg "<<(int)tj.Pts[kinkPt].AveChg;
       myprt<<" Ang after "<<tpFit.Ang<<" Err "<<tpFit.AngErr;
       myprt<<" endChg "<<endChg;
       myprt<<" dang "<<dang;
       myprt<<" kinkAngCut "<<kinkAngCut;
       myprt<<" kinkSig "<<kinkSig;
       myprt<<" endChgAsym "<<endChgAsym;
     } // dbgStp
     
     if(tcc.useAlg[kNewStpCuts] && npwc < 20) {
       // improvements(?) for short tjs where the kink angle is a bit low but the kink
       // angle significance is high
       bool foundKink = (dang > 0.8 * kinkAngCut && kinkSig > 5);
       if(tcc.dbgStp && foundKink) {
       } // debug
       if(foundKink) {
         killPts = nPtsFit;
         tj.StopFlag[1][kAtKink] = true;
         tj.AlgMod[kNewStpCuts] = true;
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Found a short Tj kink";
         return;
       }
     } // kNewStpCuts and short tj
 
     if(tcc.useAlg[kNewStpCuts] && tj.PDGCode == 13 && dang > kinkAngCut) {
       // New muon cuts. There is probably a delta-ray at the end if there is a kink
       // that is not really large and the end charge is high - Not a kink.
       // chgAsym = 0.2 corresponds to an average charge after the kink points that is
       // 50% larger than the charge before the kink point
       if(dang < 2 * kinkAngCut && endChgAsym > 0.2) return;
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<" Found a muon Tj kink. Calling it not-a-kink";
       killPts = nPtsFit;
       tj.StopFlag[1][kAtKink] = true;
       tj.AlgMod[kNewStpCuts] = true;
       return;
     } // kNewStpCuts and muon with a kink
 
     if(dang > kinkAngCut) {
       killPts = nPtsFit;
       tj.StopFlag[1][kAtKink] = true;
     }
     
     if(killPts > 0) {
       // See if we are tracking a low momentum particle in which case we should just
       // turn off kink checking
       if(tcc.useAlg[kNoKinkChk] && tj.EndPt[1] < 20) {
         // Find MCSMom if it hasn't been done
         if(tj.MCSMom < 0) tj.MCSMom = MCSMom(slc, tj);
         if(tj.MCSMom < 50) {
           killPts = 0;
           tj.StopFlag[1][kAtKink] = false;
           tj.AlgMod[kNoKinkChk] = true;
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<"GottaKink turning off kink checking. MCSMom "<<tj.MCSMom;
         }
       } // turn off kink check
       // Don't stop if the last few points had high charge pull and we are tracking a muon, but do mask off the hits
       if(killPts > 0 && tj.PDGCode == 13 && tj.Pts[lastPt].ChgPull > 2  && tj.Pts[lastPt-1].ChgPull > 2) tj.StopFlag[1][kAtKink] = false;
       // Don't keep stepping or mask off any TPs if we hit a kink while doing RevProp
       if(tj.AlgMod[kRvPrp]) killPts = 0;
     }
     
     if(tcc.dbgStp && tj.StopFlag[1][kAtKink]) mf::LogVerbatim("TC")<<"GottaKink killPts "<<killPts;
 //    if(tcc.dbgStp) mf::LogVerbatim("TC")<<"GottaKink "<<kinkPt<<" Pos "<<PrintPos(slc, tj.Pts[kinkPt])<<" dang "<<std::fixed<<std::setprecision(2)<<dang<<" cut "<<kinkAngCut<<" tpFit chi "<<tpFit.FitChi<<" killPts "<<killPts<<" GottaKink? "<<tj.StopFlag[1][kAtKink]<<" MCSMom "<<tj.MCSMom<<" thetaRMS "<<thetaRMS;
     
   } // GottaKink

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

Definition at line 2469 of file Utils.cxx.

References kAllHits, PrintHit(), PutTrajHitsInVector(), and tca::TCSlice::slHits.

Referenced by CheckTraj(), and MergeAndStore().

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

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

Definition at line 2566 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TrajPoint::Ang, tca::TrajPoint::AngErr, tca::TrajPoint::AngleCode, tca::TrajPoint::Chg, tca::TCConfig::dbgStp, tca::TrajPoint::Delta, tca::TrajPoint::DeltaRMS, tca::TrajPoint::Dir, tca::Trajectory::EndPt, tca::TrajPoint::FitChi, FitTraj(), tca::TrajPoint::HitPos, kBragg, kHED, kStiffEl, tca::Trajectory::MCSMom, tca::TrajPoint::NTPsFit, tca::Trajectory::Pass, PointTrajDOCA(), tca::TrajPoint::Pos, PrintTrajPoint(), tca::Trajectory::Pts, tca::Trajectory::StepDir, tca::Trajectory::StopFlag, tca::Trajectory::Strategy, tcc, and tca::TCConfig::useAlg.

Referenced by CheckTraj().

   {
     // Modify the trajectory at the end if there is a consistent increase in delta. It
     // is called from CheckTraj.
     // This needs to be done carefully...
     
     if(!tcc.useAlg[kHED]) return;
     if(tj.StopFlag[1][kBragg]) return;
     if(tj.Strategy[kStiffEl]) return;
     // Only consider long high momentum.
     if(tj.MCSMom < 100) return;
     if(tj.Pts.size() < 50) return;
     
     unsigned short ept = tj.EndPt[1];
     
     TrajPoint& lastTp = tj.Pts[ept];
     
     if(lastTp.AngleCode > 1) return;
     if(lastTp.FitChi < 1) return;
     
     unsigned short npts = USHRT_MAX;
     float lastDelta = lastTp.Delta;
     // check the last 20 points on the trajectory for a systematic increase in Delta and FitChi
     for(unsigned short ii = 1; ii < 20; ++ii) {
       unsigned short ipt = ept - ii;
       TrajPoint& tp = tj.Pts[ipt];
       if(tp.Chg == 0) continue;
       if(tp.FitChi < 1 || tp.Delta > lastDelta) {
         npts = ii;
         break;
       }
       lastDelta = tp.Delta;
     } // ii
     
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"HED: last point FitChi "<<lastTp.FitChi<<" NTPsFit "<<lastTp.NTPsFit<<" new npts "<<npts;
     
     // something bad happened
     if(npts == USHRT_MAX) return;
     // The Tj end has some other problem
     if(npts < 4) return;
     
     // re-fit the end of the trajectory
     lastTp.NTPsFit = npts;
     FitTraj(slc, tj);
     if(tcc.dbgStp) PrintTrajPoint("HED", slc, ept, tj.StepDir, tj.Pass, lastTp);
     // update the last points
     for(unsigned short ii = 1; ii <= npts; ++ii) {
       unsigned short ipt = ept - ii;
       TrajPoint& tp = tj.Pts[ipt];
       if(tp.Chg == 0) continue;
       tp.Dir = tj.Pts[ept].Dir;
       tp.Ang = tj.Pts[ept].Ang;
       tp.AngErr = tj.Pts[ept].AngErr;
       tp.AngleCode = tj.Pts[ept].AngleCode;
       // Correct the projected time to the wire
       float dw = tp.Pos[0] - tj.Pts[ept].Pos[0];
       if(tp.Dir[0] != 0) tp.Pos[1] = tj.Pts[ept].Pos[1] + dw * tp.Dir[1] / tp.Dir[0];
       tp.Delta = PointTrajDOCA(slc, tp.HitPos[0], tp.HitPos[1], tp);
       tp.DeltaRMS = tj.Pts[ept].DeltaRMS;
       tp.NTPsFit = tj.Pts[ept].NTPsFit;
       tp.FitChi = tj.Pts[ept].FitChi;
       if(tcc.dbgStp) PrintTrajPoint("HED", slc, ipt, tj.StepDir, tj.Pass, tp);
     } // ii
     
     tj.AlgMod[kHED] = true;
     
   } // HiEndDelta

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

Definition at line 2239 of file Utils.cxx.

References tca::TCEvent::allHits, evt, tca::TCSlice::slHits, tcc, and tca::TCConfig::unitsPerTick.

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

   {
     // 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	(	TCSlice &	slc,
		const std::vector< unsigned int > &	hitsInMultiplet,
		float &	sum,
		HitStatus_t	hitRequest
	)

Definition at line 3742 of file Utils.cxx.

References tca::TCEvent::allHits, evt, kAllHits, kUnusedHits, kUsedHits, and tca::TCSlice::slHits.

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

   {
     // returns the position and the charge
     float pos = 0;
     sum = 0;
     for(unsigned short ii = 0; ii < hitsInMultiplet.size(); ++ii) {
       unsigned int iht = hitsInMultiplet[ii];
       bool useit = (hitRequest == kAllHits);
       if(hitRequest == kUsedHits && 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 0;
     return pos / sum;
   } // HitsPosTick

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

Definition at line 3736 of file Utils.cxx.

References HitsPosTick(), tcc, and tca::TCConfig::unitsPerTick.

Referenced by DotProd().

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

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

Definition at line 3706 of file Utils.cxx.

References tca::TCEvent::allHits, evt, kAllHits, kUnusedHits, kUsedHits, and tca::TCSlice::slHits.

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

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

Definition at line 3700 of file Utils.cxx.

References HitsRMSTick(), tcc, and tca::TCConfig::unitsPerTick.

Referenced by DotProd(), and HitsTimeErr2().

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

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

Definition at line 1701 of file StepUtils.cxx.

References tca::TCConfig::hitErrFac, HitsRMSTime(), kUnusedHits, and tcc.

Referenced by DefineHitPos().

   {
     // 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	(	TCSlice &	slc,
		unsigned int	iht
	)

Definition at line 1693 of file StepUtils.cxx.

References tca::TCEvent::allHits, evt, tca::TCConfig::hitErrFac, tca::TCSlice::slHits, tcc, and tca::TCConfig::unitsPerTick.

Referenced by DefineHitPos(), and FindUseHits().

   {
     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

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

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

Definition at line 2103 of file TCShower.cxx.

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

   {
     // 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;
 //        std::cout<<"3S"<<ss3.ID<<" P"<<pfp.ID<<" ";
         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 2127 of file TCShower.cxx.

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

Referenced by InShowerProb(), and Reconcile3D().

   {
     // returns a likelihood (0 - 1) that the tj particle belongs in shower ss
     // Keep it simple: construct a FOM, take the inverse and limit it to the range 0 - 1
     if(ss.ID == 0 || tj.ID == 0) return 0;
     if(ss.CTP != tj.CTP) return 0;
     
     auto& stj = 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);
 //    std::cout<<"ISP: 2S"<<ss.ID<<" T"<<tj.ID<<" showerLen "<<(int)showerLen<<" closePt "<<closePt1;
 //    std::cout<<" closePt "<<closePt2<<" along "<<std::fixed<<std::setprecision(1)<<alongTrans[0]<<" "<<alongTrans[1];
     float rms = stp.DeltaRMS;
     if(rms < 1) rms = 1;
     float arg = alongTrans[1] / rms;
     float radProb = exp(-0.5 * arg * arg);
 //    std::cout<<" rms "<<rms<<" radProb "<<std::setprecision(3)<<radProb;
     // This is a fake but may be OK if this function is called before the shower is well-defined
     rms = showerLen;
     arg = alongTrans[0] / rms;
     float longProb = exp(-0.5 * arg * arg);
 //    std::cout<<" longProb "<<std::setprecision(3)<<longProb;
     float costh = std::abs(DotProd(stp.Dir, ttp.Dir));
 //    std::cout<<" costh "<<std::setprecision(3)<<costh;
     float prob = radProb * longProb * costh;
 //    std::cout<<" InShowerProb "<<std::setprecision(3)<<prob<<"\n";
     return prob;
 
   } // InShowerProb

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

Definition at line 2049 of file TCShower.cxx.

References ShowerParams().

Referenced by FindParent(), InShowerProbParam(), MergeSubShowers(), and ParentFOM().

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

References InShowerProbLong(), and InShowerProbTrans().

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

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

Definition at line 2083 of file TCShower.cxx.

References ShowerParamTransRMS().

Referenced by InShowerProbParam(), and MergeSubShowers().

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

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

Definition at line 2810 of file PFPUtils.cxx.

References evd::details::end(), tca::PFPStruct::ID, tca::TCSlice::xHi, tca::TCSlice::xLo, tca::PFPStruct::XYZ, tca::TCSlice::yHi, tca::TCSlice::yLo, tca::TCSlice::zHi, and tca::TCSlice::zLo.

Referenced by DotProd(), PrintP(), and StitchPFPs().

   {
     // 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;
     
     float abit = 5;
     auto& pos1 = pfp.XYZ[end];
     return (pos1[0] > slc.xLo + abit && pos1[0] < slc.xHi - abit && 
             pos1[1] > slc.yLo + abit && pos1[1] < slc.yHi - abit &&
             pos1[2] > slc.zLo + abit && pos1[2] < slc.zHi - abit);
     
   } // InsideFV

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

Definition at line 2825 of file PFPUtils.cxx.

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

Referenced by DotProd(), and PrintPFP().

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

References AlgBitNames, evd::details::end(), kKilled, kUsedHits, PrintHit(), PrintTrajectory(), PutTrajHitsInVector(), tca::TCSlice::slHits, tca::TCSlice::tjs, and tca::TCSlice::vtxs.

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

   {
     // 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;
       if(tj.AlgMod[kKilled]) {
         std::cout<<someText<<" ChkInTraj hit size mis-match in tj ID "<<tj.ID<<" AlgBitNames";
         for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(tj.AlgMod[ib]) std::cout<<" "<<AlgBitNames[ib];
         std::cout<<"\n";
         continue;
       }
       tHits = PutTrajHitsInVector(tj, kUsedHits);
       if(tHits.size() < 2) {
         std::cout<<someText<<" ChkInTraj: Insufficient hits in traj "<<tj.ID<<"\n";
         PrintTrajectory("CIT", slc, tj, USHRT_MAX);
         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) {
         std::cout<<someText<<" ChkInTraj: Insufficient hits in atHits in traj "<<tj.ID<<" Killing it\n";
         tj.AlgMod[kKilled] = true;
         continue;
       }
       if(!std::equal(tHits.begin(), tHits.end(), atHits.begin())) {
         mf::LogVerbatim myprt("TC");
         myprt<<someText<<" ChkInTraj failed: inTraj - UseHit mis-match for T"<<tID<<" tj.WorkID "<<tj.WorkID<<" atHits size "<<atHits.size()<<" tHits size "<<tHits.size()<<" in CTP "<<tj.CTP<<"\n";
         myprt<<"AlgMods: ";
         for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(tj.AlgMod[ib]) myprt<<" "<<AlgBitNames[ib];
         myprt<<"\n";
         myprt<<"index     inTraj     UseHit \n";
         for(iht = 0; iht < atHits.size(); ++iht) {
           myprt<<"iht "<<iht<<" "<<PrintHit(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;
           std::cout<<someText<<" ChkInTraj: Bad VtxID "<<tj.ID<<" vtx size "<<slc.vtxs.size()<<"\n";
           tj.AlgMod[kKilled] = true;
           PrintTrajectory("CIT", slc, tj, USHRT_MAX);
           return false;
         }
       } // end
       ++itj;
     } // tj
     return true;
     
   } // InTrajOK

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

Definition at line 3297 of file TCVertex.cxx.

References tca::VtxStore::CTP, tcc, VertexVertexPull(), tca::TCConfig::vtx2DCuts, and tca::TCSlice::vtxs.

Referenced by Find2DVertices().

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

Definition at line 3316 of file TCVertex.cxx.

References tcc, VertexVertexPull(), tca::TCConfig::vtx3DCuts, tca::TCSlice::vtx3s, and tca::Vtx3Store::X.

   {
     // 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 3221 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TCConfig::dbgStp, tca::Trajectory::EndPt, tca::Trajectory::ID, tca::Trajectory::IsGood, kKilled, kStiffEl, kUseGhostHits, tca::Trajectory::MCSMom, MCSMom(), tca::TCConfig::minPts, MoveTPToWire(), tca::Trajectory::Pass, tca::Trajectory::PDGCode, tca::TrajPoint::Pos, PrintTrajectory(), tca::Trajectory::Pts, tca::TCConfig::qualityCuts, SetEndPoints(), tca::TCSlice::slHits, tca::Trajectory::Strategy, tcc, tca::TCSlice::tjs, TrimEndPts(), UnsetUsedHits(), and tca::TCConfig::useAlg.

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

   {
     // 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.Pts.size(); ++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 3385 of file StepUtils.cxx.

References tca::TCConfig::dbgAlg, tca::TCConfig::dbgStp, GetHitMultiplet(), kUseGhostHits, tca::TCSlice::slHits, tcc, tca::TCSlice::tjs, and tca::TCConfig::useAlg.

Referenced by CheckTraj().

   {
     // 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);
       // 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 2002 of file TCShower.cxx.

References kShowerLike, and tca::TCSlice::tjs.

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

   {
     // Vote for the list of Tjs (assumed associated with a PFParticle) being shower-like
     if(TjIDs.empty()) return false;
     unsigned short cnt = 0;
     for(auto tid : TjIDs) {
       if(tid <= 0 || tid > (int)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 2418 of file TCVertex.cxx.

References MakeVertexObsolete(), tcc, tca::TCConfig::vtx2DCuts, tca::TCSlice::vtx3s, and tca::TCSlice::vtxs.

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

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

References tca::ShowerStruct::CTP, tca::TCSlice::dontCluster, tca::ShowerStruct::Envelope, GetAssns(), tca::ShowerStruct::ID, tca::TCSlice::ID, kKillInShowerVx, MakeVertexObsolete(), PointInsideEnvelope(), tcc, tca::TCSlice::tjs, tca::TCConfig::useAlg, tca::TCSlice::vtx3s, and tca::TCSlice::vtxs.

Referenced by MergeShowersAndStore().

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

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

Definition at line 1943 of file PFPUtils.cxx.

References DeltaAngle(), and PosSep2().

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

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

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

Definition at line 1135 of file PFPUtils.cxx.

References PosSep2(), and tca::TCSlice::tjs.

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

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

Definition at line 2879 of file PFPUtils.cxx.

References min, and PosSep().

Referenced by DotProd(), and PointDirIntersect().

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

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

Definition at line 3936 of file Utils.cxx.

References recob::Hit::GoodnessOfFit(), and recob::Hit::Multiplicity().

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

   {
     // 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	(	TCSlice &	slc,
		Point3_t &	pos,
		Vector3_t &	dir,
		CTP_t	inCTP
	)

Definition at line 3523 of file Utils.cxx.

References tca::TrajPoint::Ang, detinfo::DetectorProperties::ConvertXToTicks(), tca::TrajPoint::CTP, DecodeCTP(), tca::TrajPoint::Delta, tca::TCConfig::detprop, tca::TrajPoint::Dir, tca::TCConfig::geom, tca::TCConfig::maxPos0, norm, geo::PlaneID::Plane, tca::TrajPoint::Pos, tcc, tca::TCConfig::unitsPerTick, and geo::GeometryCore::WireCoordinate().

Referenced by DotProd(), FindMissedTjsInTp3s(), FindParent(), FindPFParticles(), FindShowerStart(), Print3S(), PrintShowers(), and SetParent().

   {
     // Projects the space point defined by pos and dir into the CTP and returns it in the form of a trajectory point.
     // The TP Pos[0] is set to a negative number if the point has an invalid wire position but doesn't return an
     // error if the position is on a dead wire. The projection of the direction vector in CTP is stored in tp.Delta.
     TrajPoint tp;
     tp.Pos = {{0,0}};
     tp.Dir = {{0,1}};
     tp.CTP = inCTP;
     geo::PlaneID planeID = DecodeCTP(inCTP);
     
     tp.Pos[0] = tcc.geom->WireCoordinate(pos[1], pos[2], planeID);
     if(tp.Pos[0] < 0 || (!tcc.maxPos0.empty() && tp.Pos[0] > tcc.maxPos0[planeID.Plane])) {
       tp.Pos[0] = -1;
       return tp;
     }
     tp.Pos[1] = tcc.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
     // BUG the double brace syntax is required to work around clang bug 21629
     // (https://bugs.llvm.org/show_bug.cgi?id=21629)
     Point3_t ori3 = {{0.0, 0.0, 0.0}};
     Point3_t pos3 = {{100 * dir[0], 100 * dir[1], 100 * dir[2]}};
     // 2D position of ori3 and the pos3 projection
     std::array<double, 2> ori2;
     std::array<double, 2> pos2;
     std::array<double, 2> dir2;
     // the wire coordinates
     ori2[0] = tcc.geom->WireCoordinate(ori3[1], ori3[2], planeID);
     pos2[0] = tcc.geom->WireCoordinate(pos3[1], pos3[2], planeID);
     // the time coordinates
     ori2[1] = tcc.detprop->ConvertXToTicks(ori3[0], planeID) * tcc.unitsPerTick;
     pos2[1] = tcc.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;
     
     return tp;
   } // MakeBareTP

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

Definition at line 3581 of file Utils.cxx.

References tca::TCEvent::allHits, EncodeCTP(), evt, MakeBareTrajPoint(), and tca::TCSlice::slHits.

Referenced by DotProd(), EndMerge(), FillGaps(), MergeShowerChain(), and ParentFOM().

   {
     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	(	TCSlice &	slc,
		float	fromWire,
		float	fromTick,
		float	toWire,
		float	toTick,
		CTP_t	tCTP,
		TrajPoint &	tp
	)

Definition at line 3594 of file Utils.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::CTP, tca::TrajPoint::Dir, norm, tca::TrajPoint::Pos, tcc, and tca::TCConfig::unitsPerTick.

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

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

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

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

Definition at line 3628 of file Utils.cxx.

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

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

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

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

Definition at line 20 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::ChgRMS, tca::Trajectory::CTP, DefineHitPos(), tca::Trajectory::EndPt, evt, FindCloseHits(), GetPFPIndex(), GetSliceIndex(), tca::TCEvent::globalTjID, tca::Trajectory::ID, tca::TCSlice::ID, kAllHits, kDeltaRay, kHaloTj, kKilled, kMat3D, MakeTrajectoryObsolete(), tca::TCConfig::muonTag, tca::Trajectory::ParentID, tca::Trajectory::Pass, tca::Trajectory::PDGCode, tca::TCSlice::pfps, PointTrajDOCA(), PrintTrajectory(), tca::Trajectory::Pts, tca::TCSlice::slHits, slices, tca::Trajectory::StartEnd, tca::Trajectory::StepDir, tcc, tca::TCSlice::tjs, tca::Trajectory::TotChg, tca::Trajectory::UID, tca::TCConfig::useAlg, and tca::Trajectory::WorkID.

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

   {
     // 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) std::cout<<"MakeHaloTj: Killing delta-ray T"<<dtj.ID<<"\n";
       // Kill a delta-ray PFParticle?
       if(dtj.AlgMod[kMat3D]) {
         unsigned short pfpIndex = GetPFPIndex(slc, dtj.ID);
         if(pfpIndex == USHRT_MAX) {
           if(prt) std::cout<<" No PFP found for 3D-matched delta-ray\n";
         } else {
           auto& pfp = slc.pfps[pfpIndex];
           if(prt) std::cout<<" Killing delta-ray PFParticle P"<<pfp.UID<<"\n";
           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.globalTjID;
     tj.UID = evt.globalTjID;
     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) {
       std::cout<<"MHTj: T"<<muTj.ID<<" npts "<<tj.Pts.size()<<" close";
       for(auto tid : closeTjs) std::cout<<" T"<<tid;
       std::cout<<"\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 4223 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TCEvent::allHits, tca::Trajectory::CTP, tca::TCConfig::dbgAlg, tca::TCConfig::dbgStp, DefineHitPos(), evt, Fit2D(), tca::Trajectory::IsGood, kJunkTj, tca::TCConfig::minPts, PrintTrajectory(), tca::Trajectory::Pts, ReleaseHits(), SetAngleCode(), SetEndPoints(), tca::TCSlice::slHits, StartTraj(), StoreTraj(), tcc, tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, and valsDecreasing().

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

   {
     if(!tcc.useAlg[kJunkTj]) return false;
     // Make a crummy trajectory using the provided hits
     
     if(tHits.size() < 2) return false;
     
     bool prt = (tcc.dbgStp || 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());
     // fit all of the hits to a line
     Point2_t inPt;
     Vector2_t outVec, outVecErr;
     float inPtErr = 1, chiDOF;
     // initialize
     Fit2D(0, inPt, inPtErr, outVec, outVecErr, chiDOF);
     std::vector<Point2_t> fitPts(tHits.size());
     for(unsigned short ii = 0; ii < tHits.size(); ++ii) {
       unsigned int iht = tHits[ii];
       if(slc.slHits[iht].InTraj == SHRT_MAX) return false;
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       inPt[0] = hit.WireID().Wire;
       inPt[1] = hit.PeakTime() * tcc.unitsPerTick;
       fitPts[ii] = inPt;
       // accumulate. Don't store the points since we don't care about chisq
       Fit2D(1, inPt, inPtErr, outVec, outVecErr, chiDOF);
     } // ii
     if(!Fit2D(-1, inPt, inPtErr, outVec, outVecErr, chiDOF)) return false;
     
     if(prt) mf::LogVerbatim("TC")<<" tHits line fit Angle "<<atan(outVec[1]);
     // A rough estimate of the trajectory angle
     work.Pts[0].Ang = atan(outVec[1]);
     work.Pts[0].Dir[0] = cos(work.Pts[0].Ang);
     work.Pts[0].Dir[1] = sin(work.Pts[0].Ang);
     SetAngleCode(work.Pts[0]);
     // clone this information for all of the other points
     for(unsigned short ipt = 1; ipt < work.Pts.size(); ++ipt) {
       auto& tp = work.Pts[ipt];
       tp.CTP = work.CTP;
       tp.Ang = work.Pts[0].Ang;
       tp.Dir = work.Pts[0].Dir;
       tp.AngleCode = work.Pts[0].AngleCode;
     } // ipt
     // Rotate the hits into this coordinate system to find the start and end
     // points and general direction
     double cs = cos(-work.Pts[0].Ang);
     double sn = sin(-work.Pts[0].Ang);
     float tAlong, minAlong = 1E6, maxAlong = -1E6;
     // sort the hits by the distance along the general direction
     std::vector<SortEntry> sortVec(tHits.size());
     SortEntry sortEntry;
     for(unsigned short ii = 0; ii < fitPts.size(); ++ii) {
       tAlong = cs * fitPts[ii][0] - sn * fitPts[ii][1];
       if(tAlong < minAlong) minAlong = tAlong;
       if(tAlong > maxAlong) maxAlong = tAlong;
       sortEntry.index = ii;
       sortEntry.val = tAlong;
       sortVec[ii] = sortEntry;
     } // ii
     std::sort(sortVec.begin(), sortVec.end(), valsDecreasing);
     // put a hit into each TP
     for(unsigned short ipt = 0; ipt < work.Pts.size(); ++ipt) {
       auto& tp = work.Pts[ipt];
       tp.Hits.resize(1);
       tp.Hits[0] = tHits[sortVec[ipt].index];
       tp.UseHit[0] = true;
       DefineHitPos(slc, tp);
       // Just use the hit position as the tj position
       tp.Pos = tp.HitPos;
     } // ipt
     SetEndPoints(work);
     work.AlgMod[kJunkTj] = true;
     work.IsGood = true;
     if(prt) {
       PrintTrajectory("MJT", slc, work, USHRT_MAX);
     }
     // Finally push it onto slc.tjs
     if(!StoreTraj(slc, work)) {
       ReleaseHits(slc, work);
       return false;
     }
     return true;
   } // MakeJunkTraj

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

Definition at line 14 of file TCVertex.cxx.

References close(), tca::VtxStore::CTP, tca::TCConfig::dbgSlc, tca::TCConfig::dbgVxJunk, DecodeCTP(), FindCloseTjs(), tca::VtxStore::ID, kFixed, kHaloTj, kJunkTj, kJunkVx, kKilled, kShowerLike, geo::PlaneID::Plane, tca::VtxStore::Pos, tca::VtxStore::PosErr, PosSep(), tca::VtxStore::Score, SignalBetween(), tca::VtxStore::Stat, StoreVertex(), tcc, tca::TCSlice::tjs, tca::VtxStore::Topo, TrajLength(), tca::TCConfig::unitsPerTick, tca::TCConfig::useAlg, tca::TCConfig::vtx2DCuts, and tca::TCSlice::vtxs.

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

   {
     // 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;
 //      PrintAllTraj("MJTi", slc, debug, USHRT_MAX, slc.tjs.size());
     }
     
     // make a template vertex
     VtxStore junkVx;
     junkVx.CTP = inCTP;
     junkVx.Topo = 9;
     junkVx.Stat[kJunkVx] = true;
     junkVx.Stat[kFixed] = true;
     // set an invalid ID
     junkVx.ID = USHRT_MAX;
     // put in generous errors
     // BUG the double brace syntax is required to work around clang bug 21629
     // (https://bugs.llvm.org/show_bug.cgi?id=21629)
     junkVx.PosErr = {{2.0, 2.0}};
     // define a minimal score so it won't get clobbered
     junkVx.Score = 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::MakeShowerObsolete	(	std::string	inFcnLabel,
		TCSlice &	slc,
		ShowerStruct3D &	ss3,
		bool	prt
	)

Definition at line 3242 of file TCShower.cxx.

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

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

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

Definition at line 3266 of file TCShower.cxx.

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

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

   {
     // Gracefully kills the shower and the associated shower Tj
     
     if(ss.ID == 0) return;
     
     std::string fcnLabel = inFcnLabel + ".MSO";
     
     auto& stp1 = slc.tjs[ss.ShowerTjID - 1].Pts[1];
     if(!stp1.Hits.empty()) {
       std::cout<<fcnLabel<<" Trying to kill shower "<<ss.ID<<" that has hits associated with it. Don't do this...\n";
     }
     
     // clear a 3S -> 2S assn
     if(ss.SS3ID > 0 && ss.SS3ID <= (int)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;
     // No reason to do this
 //    ss.TjIDs.clear();
     
   } // MakeShowerObsolete

bool tca::MakeTp3	(	TCSlice &	slc,
		const TrajPoint &	itp,
		const TrajPoint &	jtp,
		TrajPoint3 &	tp3,
		bool	findDirection
	)

Definition at line 1555 of file PFPUtils.cxx.

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

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

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

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

Definition at line 1922 of file Utils.cxx.

References kKilled, tca::TCSlice::slHits, and tca::TCSlice::tjs.

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

   {
     // 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 3120 of file TCVertex.cxx.

References tca::VtxStore::CTP, tca::TCConfig::dbg2V, tca::TCConfig::dbg3V, DecodeCTP(), evd::details::end(), tca::VtxStore::ID, tca::Vtx3Store::ID, kEnvOverlap, kHaloTj, kHiVx3Score, kKilled, kPhoton, kTjHiVx3Score, tca::TCSlice::nPlanes, tca::TCSlice::pfps, geo::PlaneID::Plane, tca::VtxStore::Pos, SetVx3Score(), tcc, tca::TCSlice::tjs, tca::TCConfig::vtx2DCuts, tca::TCSlice::vtx3s, tca::TCSlice::vtxs, tca::Vtx3Store::Vx2ID, tca::VtxStore::Vx3ID, and tca::Vtx3Store::Wire.

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

   {
     // Makes a 2D vertex obsolete
     
     // check for a high-score 3D vertex
     bool hasHighScoreVx3 = (vx2.Vx3ID > 0);
     if(hasHighScoreVx3 && !forceKill && 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;
     } // plane
     
     if(n2D > 1) {
       // 3D vertex is incomplete
       // correct the score
       SetVx3Score(slc, vx3);
       return true;
     }
     
     // 3D vertex is obsolete
     // Detach the 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 3208 of file TCVertex.cxx.

References tca::Vtx3Store::ID, MakeVertexObsolete(), tca::TCSlice::vtx3s, tca::TCSlice::vtxs, and tca::Vtx3Store::Vx2ID.

   {
     // Deletes a 3D vertex and 2D vertices in all planes
     // The 2D and 3D vertices are NOT killed if forceKill is false and the 3D vertex
     // has a high score
     if(vx3.ID == 0) return true;
     if(vx3.ID > int(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 2665 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TrajPoint::Chg, tca::TCConfig::dbgAlg, tca::TCConfig::dbgStp, tca::TrajPoint::Delta, tca::TrajPoint::FitChi, FitTraj(), tca::Trajectory::IsGood, kMaskBadTPs, kRvPrp, tca::TrajPoint::NTPsFit, tca::Trajectory::Pts, tcc, UnsetUsedHits(), and tca::TCConfig::useAlg.

Referenced by UpdateTraj().

   {
     // 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 2710 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TCEvent::allHits, tca::TCConfig::dbgStp, DefineHitPos(), tca::Trajectory::EndPt, evt, FitTraj(), tca::TrajPoint::Hits, tca::Trajectory::ID, kMaskHits, tca::TCConfig::minPtsFit, tca::TrajPoint::NTPsFit, tca::Trajectory::Pass, PrintTrajectory(), tca::Trajectory::Pts, SetEndPoints(), tca::TCSlice::slHits, tcc, UpdateTjChgProperties(), tca::TCConfig::useAlg, and tca::TrajPoint::UseHit.

Referenced by StepAway().

   {
     // 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 3887 of file StepUtils.cxx.

References ChkMichel(), tca::TCConfig::dbgStp, tca::Trajectory::EndPt, tca::Trajectory::ID, tca::Trajectory::IsGood, PointTrajDOCA(), PrintPos(), tca::Trajectory::Pts, SetEndPoints(), tcc, TrajPointSeparation(), and UnsetUsedHits().

Referenced by CheckHiMultUnusedHits(), and StepAway().

   {
     
     // 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.Pts.size() < 3) {
       mf::LogError("TC")<<"MaskTrajEndPoints: Trajectory ID "<<tj.ID<<" too short to mask hits ";
       tj.IsGood = false;
       return;
     }
     if(nPts > tj.Pts.size() - 2) {
       mf::LogError("TC")<<"MaskTrajEndPoints: Trying to mask too many points "<<nPts<<" Pts.size "<<tj.Pts.size();
       tj.IsGood = false;
       return;
     }
     
     // find the last good point (with charge)
     unsigned short lastGoodPt = USHRT_MAX ;
     
     if (!ChkMichel(slc, tj, lastGoodPt)){ //did not find michel electron
       for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
         unsigned short ipt = tj.EndPt[1] - nPts - ii;
         if(tj.Pts[ipt].Chg > 0) {
           lastGoodPt = ipt;
           break;
         }
         if(ipt == 0) break;
       } // ii
     }
     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
	)

Definition at line 882 of file TCShower.cxx.

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

Referenced by FindShowers3D().

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

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

Definition at line 1345 of file TCShower.cxx.

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

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

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

Definition at line 1362 of file TCShower.cxx.

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

   {
     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(inFcnLabel, slc, icid, jcid, prt);
     float jkfom = Match3DFOM(inFcnLabel, slc, jcid, kcid, prt);
     
     return 0.5 * (ijfom + jkfom);
     
   } // Match3DFOM

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

Definition at line 1377 of file TCShower.cxx.

References detinfo::DetectorProperties::ConvertTicksToX(), tca::TCSlice::cots, DecodeCTP(), tca::TCConfig::detprop, tcc, tca::TCSlice::tjs, and tca::TCConfig::unitsPerTick.

Referenced by Match2DShowers(), and Match3DFOM().

   {
     // 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 = tcc.detprop->ConvertTicksToX(istj.Pts[1].Pos[1] / tcc.unitsPerTick, iPlnID);
     float jx = tcc.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<<" pos0fom "<<pos0fom;
       myprt<<" pos1fom "<<pos1fom;
 //      myprt<<" pos2fom "<<pos2fom;
       myprt<<" energyAsym "<<energyAsym;
       myprt<<" mfom "<<mfom;
     }
     
     return mfom;
   } // Madtch3DFOM

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

Definition at line 1693 of file TCVertex.cxx.

References AnalyzePFP(), CreatePFP(), DefinePFP(), tca::PFPStruct::Dir, GetVtxTjIDs(), tca::PFPStruct::ID, tca::SortEntry::index, kHaloTj, kKilled, kM3DVxTj, kMat3D, tca::TCSlice::matchVec, tca::PFPStruct::MatchVecIndex, tca::TCSlice::nPlanes, tca::PFPStruct::PDGCode, PDGCodeVote(), PrintPFP(), SetDifference(), SetIntersection(), Split3DKink(), StorePFP(), tcc, tca::PFPStruct::TjIDs, tca::TCSlice::tjs, tmp, tca::TCConfig::useAlg, tca::SortEntry::val, valDecreasing(), tca::TCConfig::vtx2DCuts, tca::TCSlice::vtx3s, tca::PFPStruct::Vx3ID, and tca::PFPStruct::XYZ.

Referenced by FindPFParticles().

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

unsigned short tca::MatchVecIndex	(	TCSlice &	slc,
		int	tjID
	)

Definition at line 1138 of file Utils.cxx.

References tca::TCSlice::matchVec.

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

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

Definition at line 340 of file Utils.cxx.

References DecodeCTP(), tca::TCSlice::nPlanes, geo::PlaneID::Plane, tca::TCSlice::tjs, and UpdateTjChgProperties().

   {
     // calculates the maximum charge asymmetry in all planes using the supplied list of Tjs
     if(tjIDs.size() < 2) return 1;
     std::vector<float> plnchg(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 2734 of file Utils.cxx.

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

Referenced by CheckHiMultUnusedHits(), and FillGaps().

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

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

Definition at line 2322 of file Utils.cxx.

References PosSep2(), and tca::TCSlice::tjs.

Referenced by DefinePFP(), and FindPFParticles().

   {
     // returns the length of the longest Tj in the supplied list
     if(tjIDs.empty()) return 0;
     float maxLen = 0;
     for(auto tjid : tjIDs) {
       if(tjid < 1 || tjid > (int)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	(	TCSlice &	slc,
		const std::vector< int > &	tjIDs
	)

Definition at line 2914 of file Utils.cxx.

References tca::TCSlice::tjs.

Referenced by CheckTraj(), DefinePFP(), DotProd(), FillGaps(), FindCots(), FindHammerVertices2(), FindParent(), FindPFParticles(), FindSoftKink(), Forecast(), GottaKink(), IsGhost(), MergeNearby2DShowers(), MergePFPTjs(), MergeSubShowersTj(), UpdateStiffEl(), and UpdateTraj().

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

Definition at line 2930 of file Utils.cxx.

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

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

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

Definition at line 2936 of file Utils.cxx.

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

Referenced by MCSMom(), PrintP(), PrintPFP(), and SplitTraj().

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

Definition at line 2984 of file Utils.cxx.

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

Referenced by DotProd(), EndMerge(), and GottaKink().

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

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

Definition at line 2998 of file Utils.cxx.

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

Referenced by MCSMom(), and MCSThetaRMS().

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

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

Not allowed

Definition at line 4095 of file Utils.cxx.

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

Referenced by ChkVxTjs(), DotProd(), EndMerge(), and MergeTjIntoPFP().

   {
     // Merge the two trajectories in allTraj and store them. Returns true if it was successfull.
     // Merging is done between the end (end = 1) of tj1 and the beginning (end = 0) of tj2. This function preserves the
     // AlgMod state of itj1.
     // The itj1 -> itj2 merge order is reversed if end1 of itj2 is closer to end0 of itj1
     
     if(itj1 > 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) {
 //        std::cout<<"MAS: Both tjs are used in a PFParticle. Need PFParticle merging code to do this. pfps size "<<slc.pfps.size()<<"\n";
         return false;
       }
       // Swap so that the order of tj1 is preserved. Tj2 may be reversed to be consistent
       if(pfp1 == USHRT_MAX) std::swap(itj1, itj2);
     } // one or both used in a PFParticle
         
     // make copies so they can be trimmed as needed
     Trajectory tj1 = 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: tj1 T"<<tj1.ID<<" tj2 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;
       // 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.StopFlag[1][kBragg]) {
       if(doPrt) mf::LogVerbatim("TC")<<"MergeAndStore: You are merging the end of trajectory T"<<tj1.ID<<" with a Bragg peak. Not merging\n";
       return false;
     }
     
     // remove any points at the end of tj1 that don't have used hits
     tj1.Pts.resize(tj1.EndPt[1] + 1);
     
     // determine if they overlap by finding the point on tj2 that is closest
     // to the end point of tj1.
     TrajPoint& endtj1TP = tj1.Pts[tj1.EndPt[1]];
     // Set minSep large so that dead wire regions are accounted for
     float minSep = 1000;
     unsigned short tj2ClosePt = 0;
     // Note that TrajPointTrajDOCA only considers TPs that have charge
     TrajPointTrajDOCA(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.StopFlag[1] = tj2.StopFlag[1];
     
     // A more exhaustive check that hits only appear once
     if(HasDuplicateHits(slc, tj1, doPrt)) {
       if(doPrt) {
         mf::LogVerbatim("TC")<<"MergeAndStore found duplicate hits. Coding error";
         PrintTrajectory("MAS", slc, tj1, USHRT_MAX);
         PrintTrajectory("tj1", slc, slc.tjs[itj1], USHRT_MAX);
         PrintTrajectory("tj2", slc, slc.tjs[itj2], USHRT_MAX);
       }
       return false;
     }
     if(tj2.VtxID[1] > 0) {
       // move the end vertex of tj2 to the end of tj1
       tj1.VtxID[1] = tj2.VtxID[1];
     }   
     // Transfer some of the AlgMod bits
     if(tj2.AlgMod[kMichel]) tj1.AlgMod[kMichel] = true;
     if(tj2.AlgMod[kDeltaRay]) {
       tj1.AlgMod[kDeltaRay] = true;
       tj1.ParentID = tj2.ParentID;
     }
     // keep track of the IDs before they are clobbered
     int tj1ID = tj1.ID;
     int tj2ID = tj2.ID;
     // kill the original trajectories
     MakeTrajectoryObsolete(slc, itj1);
     MakeTrajectoryObsolete(slc, itj2);
     // Do this so that StoreTraj keeps the correct WorkID (of itj1)
     tj1.ID = tj1.WorkID;
     SetPDGCode(slc, tj1, 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;
     // update match structs if they exist
     UpdateMatchStructs(slc, tj1.ID, newTjID);
     UpdateMatchStructs(slc, tj2.ID, 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;
 
     return true;
   } // MergeAndStore

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

Definition at line 1955 of file Utils.cxx.

References kAllHits, kHaloTj, kKilled, kMrgGhost, PutTrajHitsInVector(), tca::TCSlice::slHits, tcc, tca::TCSlice::tjs, and tca::TCConfig::useAlg.

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

References AddTj(), tca::Trajectory::AlgMod, ChkAssns(), tca::TCSlice::cots, tca::ShowerStruct::CTP, DontCluster(), GetAssns(), tca::ShowerStruct::ID, tca::TCSlice::ID, kMat3D, kMergeNrShowers, MCSMom(), MergeShowersAndStore(), tca::ShowerStruct::NearTjIDs, tca::TCSlice::pfps, SetIntersection(), tca::ShowerStruct::ShowerTjID, ss, tcc, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, and tca::TCConfig::useAlg.

Referenced by FindShowers3D().

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

References tca::Trajectory::AlgMod, ChkAssns(), close(), tca::TCSlice::cots, DontCluster(), DotProd(), tca::TCSlice::ID, kMergeOverlap, MergeShowersAndStore(), PointInsideEnvelope(), PosSep(), PosSep2(), tca::TCConfig::showerTag, tcc, tca::TCSlice::tjs, and tca::TCConfig::useAlg.

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

   {
     // Merge showers whose envelopes overlap each other
     
     /*
      # 0 Mode (<= 0 OFF, 1 = find showers before 3D match, 2 = find showers after 3D match)
      # 1 Max Tj MCSMom for a shower tag
      # 2 Max separation
      # 3 Min energy (MeV)
      # 4 rms width factor
      # 5 Min shower 1/2 width (WSE units)
      # 6 Min total Tj Pts
      # 7 Min Tjs
      # 8 max parent FOM
      # 9 max direction FOM
      # 10 max aspect ratio
      # 11 Debug in CTP (>10 debug cotID + 10)
      */
     
     if(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

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

Definition at line 1203 of file PFPUtils.cxx.

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

Referenced by DefinePFP().

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

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

Definition at line 2573 of file TCShower.cxx.

References ChkAssns(), tca::TCSlice::cots, tca::ShowerStruct::CTP, DontCluster(), tca::ShowerStruct::Energy, tca::ShowerStruct::ID, kMergeShChain, lessThan(), MakeBareTrajPoint(), MergeShowers(), PointTrajDOCA(), PosSep(), PrintPos(), tca::ShowerStruct::ShowerTjID, tcc, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, and tca::TCConfig::useAlg.

Referenced by FindShowers3D().

   {
     // 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].length = tpList[ii].Pos[0];
     }
     std::sort(sortVec.begin(), sortVec.end(), lessThan);
     auto tsids = sids;
     auto ttpList = tpList;
     for(unsigned short ii = 0; ii < sortVec.size(); ++ii) {
       unsigned short indx = sortVec[ii].index;
       sids[ii] = tsids[indx];
       tpList[ii] = ttpList[indx];
     }
     
     // TODO: These cuts should be generalized somehow
     float minSep = 150;
     float maxDelta = 30;
     for(unsigned short ii = 0; ii < sids.size() - 2; ++ii) {
       auto& iss = 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);
 //      PrintTrajPoint("ij", slc, 0, 1, 0, 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);
 //          PrintTrajPoint("ik", slc, 0, 0, chain.size(), tp);
         } // add to an existing chain
       } // kk
       // push the last one
       if(chain.size() > 2) {
         int newID = MergeShowers(fcnLabel, slc, chain, prt);
 /*
         if(newID > 0) {
           auto& newss = slc.cots[newID - 1];
           if(AddTjsInsideEnvelope(fcnLabel, slc, newss, prt)) UpdateShower(fcnLabel, slc, newss, prt);
         }
 */
         if(prt) {
           mf::LogVerbatim myprt("TC");
           myprt<<fcnLabel<<" merged chain";
           for(auto ssID : chain) myprt<<" "<<ssID;
           myprt<<" -> new ssID "<<newID;
         } // prt
       } // long chain
     } // ii
     
     ChkAssns(fcnLabel, slc);
     
   } // MergeShowerChain

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

Definition at line 2917 of file TCShower.cxx.

References tca::TCSlice::cots, CreateSS(), kKilled, MakeShowerObsolete(), ss, StoreShower(), tca::TCSlice::tjs, and UpdateShower().

Referenced by MergeShowerChain().

   {
     // merge a list of showers and return the ID of the merged shower.
     // Returns 0 if there was a failure. 
     
     std::string fcnLabel = inFcnLabel + ".MS";
     if(ssIDs.size() < 2) return 0;
     // check for a valid ID
     for(auto ssID : ssIDs) if(ssID <= 0 || ssID > (int)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) {
         std::cout<<fcnLabel<<" Assn conflict \n";
         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]) {
         std::cout<<fcnLabel<<" bad InShower T"<<tjID<<"\n";
         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)) {
       std::cout<<fcnLabel<<" UpdateShower failed\n";
       MakeShowerObsolete(fcnLabel, slc, newss, prt);
       return 0;
     }
     // store it
     if(!StoreShower(fcnLabel, slc, newss)) {
       std::cout<<fcnLabel<<" StoreShower failed\n";
       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 2985 of file TCShower.cxx.

References tca::TCSlice::cots, tca::ShowerStruct::CTP, tca::Trajectory::ID, tca::ShowerStruct::ID, KillVerticesInShower(), MakeTrajectoryObsolete(), tca::ShowerStruct::NearTjIDs, tca::ShowerStruct::NeedsUpdate, tca::Trajectory::Pts, tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::ShPts, tca::ShowerStruct::SS3ID, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, tca::ShowerStruct::TruParentID, and UpdateShower().

Referenced by MergeNearby2DShowers(), MergeOverlap(), MergeShowerTjsAndStore(), MergeSubShowers(), and Reconcile3D().

   {
     // Merge showers using shower indices. The icotID shower is modified in-place.
     // The jcotID shower is declared obsolete. This function also re-defines the shower and
     // preserves the icotID Parent ID.
     
     if(icotID <= 0 || icotID > (int)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) {
       std::cout<<fcnLabel<<" Error: 2S"<<iss.ID<<" and S"<<jss.ID<<" have different 2S -> 3S assns\n";
       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()) {
       std::cout<<fcnLabel<<" Error: These shower Tjs have hits! T"<<itj.ID<<" T"<<jtj.ID<<"\n";
       return false;
     }
     
     iss.TjIDs.insert(iss.TjIDs.end(), jss.TjIDs.begin(), jss.TjIDs.end());
     // make a new trajectory using itj as a template
     Trajectory ktj = itj;
     ktj.ID = 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.ParentID = 0;
     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 3060 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::TCSlice::cots, GetCotID(), tca::Trajectory::ID, tca::ShowerStruct::ID, kShowerTj, MergeShowersAndStore(), tca::ShowerStruct::TjIDs, and tca::TCSlice::tjs.

Referenced by MergeAndStore().

   {
     // Merge showers using showerTj indices
     // This function is called from MergeAndStore whose function is to merge two line-like
     // trajectories and store them. This function was called because at least one of the
     // trajectories is a shower Tj. Assume that the decision to merge them has been made elsewhere.
     
     if(istj > 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 2810 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::ShowerStruct::AspectRatio, ChkAssns(), tca::TCSlice::cots, tca::TrajPoint::Dir, DontCluster(), tca::ShowerStruct::Energy, FindAlongTrans(), greaterThan(), tca::ShowerStruct::ID, tca::SortEntry::index, InShowerProbLong(), InShowerProbTrans(), kMergeSubShowers, MergeShowersAndStore(), PointTrajDOCA(), tca::TrajPoint::Pos, PosSep(), ShowerParams(), tca::TCConfig::showerTag, tca::ShowerStruct::ShowerTjID, ss, tcc, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, tca::TCConfig::useAlg, and tca::TCConfig::wirePitch.

Referenced by FindShowers3D().

   {
     // 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.length = ss.Energy;
         sortVec.push_back(se);
       } // ss
       if(sortVec.size() < 2) return;
       std::sort(sortVec.begin(), sortVec.end(), greaterThan);
       for(unsigned short ii = 0; ii < sortVec.size() - 1; ++ii) {
         ShowerStruct& iss = 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
             // TODO: fix ShowerParams so we can use the likelihood cut instead
             if(alongTrans[0] > alongCut) continue;
             if(alongTrans[1] > alongTrans[0]) continue;
           } else {
             // old cuts
             float sep = PosSep(istp1.Pos, jstp1.Pos);
             float trad = sep / radLen;
             // Find the IP between them using the projection of the one with the lowest aspect ratio
             float delta = 9999;
             if(iss.AspectRatio < jss.AspectRatio) {
               delta = PointTrajDOCA(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 2699 of file TCShower.cxx.

References AddTj(), ChgToMeV(), ChkAssns(), tca::TCSlice::cots, DontCluster(), FarEnd(), kHaloTj, kKilled, kMergeSubShowersTj, mat, MCSMom(), NumPtsWithCharge(), PointTrajDOCA(), PosSep(), tca::TCConfig::showerTag, ss, tcc, tca::TCSlice::tjs, and tca::TCConfig::useAlg.

Referenced by FindShowers3D().

   {
     // merge small showers that are downstream of shower-like tjs. This algorithm is written 
     // for low-energy showers with are likely to be sparse and poorly defined.
     
     if(!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 507 of file Utils.cxx.

References MergeAndStore(), tca::PFPStruct::TjIDs, and tca::TCSlice::tjs.

   {
     // 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 1422 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 701 of file TCVertex.cxx.

References tca::VtxStore::ChiDOF, CloseEnd(), tca::VtxStore::CTP, tca::TCConfig::dbgSlc, tca::TCConfig::dbgVxMerge, evd::details::end(), FitVertex(), GetVtxTjIDs(), tca::VtxStore::ID, tca::SortEntry::index, kFixed, kHaloTj, kKilled, kVtxMerged, kVxMerge, NearestPtWithChg(), NumPtsWithCharge(), tca::VtxStore::Pos, tca::VtxStore::PosErr, PrintPos(), SetVx2Score(), tca::VtxStore::Stat, tcc, tca::TCSlice::tjs, tmp, tca::TCConfig::useAlg, valDecreasing(), and tca::TCSlice::vtxs.

Referenced by Find2DVertices().

   {
     // Attempts to merge the trajectories attached to vx with an existing 2D vertex
     // referenced by existingVxID. This function doesn't use the existing end0/end1 vertex association.
     // It returns true if the merging was successful in which case the calling function should
     // not store vx. The calling function needs to have set VtxID to vx.ID for tjs that are currently attached
     // to vx. It assumed that vx hasn't yet been pushed onto 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);
 //    auto tjlist = GetAssns(slc, "2V", vx.ID, "T");
     if(tjlist.empty()) return false;
     std::vector<int> tmp = GetVtxTjIDs(slc, oVx);
 //    auto tmp = GetAssns(slc, "2V", oVx.ID, "T");
     if(tmp.empty()) return false;
     for(auto tjid : tmp) {
       if(std::find(tjlist.begin(), tjlist.end(), tjid) == tjlist.end()) tjlist.push_back(tjid);
     } // tjid
     if(tjlist.size() < 2) return false;
     // handle the simple case
     if(tjlist.size() == 2) {
       // Unset the fixed bit
       vx.Stat[kFixed] = false;
       oVx.Stat[kFixed] = false;
       // assign the vx tjs to oVx
       for(auto tjid : tjlist) {
         auto& tj = 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) {
         std::cout<<"MWV: coding error. tj "<<tj.ID<<" end "<<end<<" VtxID "<<tj.VtxID[end]<<" != 0\n";
         return false;
       }
       tj.VtxID[end] = oVxID;
     } // ii
     
     // Update oVx 
     oVx.Pos = aVx.Pos;
     oVx.PosErr = aVx.PosErr;
     oVx.ChiDOF = aVx.ChiDOF;
     oVx.NTraj = fitpts.size();
     // Update the score and the charge fraction
     SetVx2Score(slc, oVx);
     oVx.Stat[kVtxMerged] = true;
     oVx.Stat[kFixed] = false;
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"MWV: "<<oVxID;
       myprt<<" Done TPs";
       for(unsigned short ii = 0; ii < fitpts.size(); ++ii) {
         auto& tjpt = fitpts[ii];
         myprt<<" "<<tjpt.Hits[0]<<"_"<<tjpt.AngleCode<<"_"<<PrintPos(slc, tjpt.Pos);
       }
     } // prt
 
     return true;
   } // MergeWithVertex

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

Definition at line 2485 of file Utils.cxx.

References tca::TrajPoint::Dir, and tca::TrajPoint::Pos.

Referenced by AddHits(), Find2DVertices(), FindCloseTjs(), FindHammerVertices2(), FindVtxTjs(), FitTraj(), Forecast(), IsGhost(), and ReversePropagate().

   {
     // Project TP to a "wire position" Pos[0] and update Pos[1]
     if(tp.Dir[0] == 0) return;
     float dw = wire - tp.Pos[0];
     if(std::abs(dw) < 0.01) return;
     tp.Pos[0] = wire;
     tp.Pos[1] += dw * tp.Dir[1] / tp.Dir[0];
   } // MoveTPToWire

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

Definition at line 2966 of file Utils.cxx.

References tca::Trajectory::EndPt, and tca::Trajectory::Pts.

Referenced by DotProd(), Find2DVertices(), MCSMom(), MCSThetaRMS(), MergeWithVertex(), and TjDeltaRMS().

   {
     // returns a point near thePt which has charge
     if(thePt > tj.EndPt[1]) return thePt;
     if(tj.Pts[thePt].Chg > 0) return thePt;
     
     short endPt0 = tj.EndPt[0];
     short endPt1 = tj.EndPt[1];
     for(short off = 1; off < 10; ++off) {
       short ipt = thePt + off;
       if(ipt <= endPt1 && tj.Pts[ipt].Chg > 0) return (unsigned short)ipt;
       ipt = thePt - off;
       if(ipt >= endPt0 && tj.Pts[ipt].Chg > 0) return (unsigned short)ipt;
     } // off
     return thePt;
   } // NearestPtWithChg

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

Definition at line 441 of file Utils.cxx.

References tca::Trajectory::AlgMod, evd::details::end(), kHaloTj, kKilled, tca::Trajectory::ParentID, PrimaryID(), tca::TCSlice::tjs, tca::TCSlice::vtx3s, and tca::TCSlice::vtxs.

Referenced by AddTjsInsideEnvelope(), PrintAllTraj(), and PrintT().

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

Definition at line 413 of file Utils.cxx.

References tca::Trajectory::ID, kDeltaRay, kHaloTj, kKilled, and tca::TCSlice::tjs.

   {
     // returns the number of delta rays that have this tj as a parent
     unsigned short cnt = 0;
     for(auto& dtj : slc.tjs) {
       if(dtj.AlgMod[kKilled] || dtj.AlgMod[kHaloTj]) continue;
       if(!dtj.AlgMod[kDeltaRay]) continue;
       if(dtj.ParentID == tj.ID) ++cnt;
     } // tj
     return cnt;
   } // NumDeltaRays

unsigned short tca::NumDeltaRays	(	TCSlice &	slc,
		std::vector< int > &	tjIDs
	)

Definition at line 426 of file Utils.cxx.

References kDeltaRay, kHaloTj, kKilled, and tca::TCSlice::tjs.

   {
     // Count the number of delta-rays that have a Tj in the list of TjIDs as a parent.
     if(tjIDs.empty()) return 0;
     if(tjIDs[0] <= 0 || tjIDs[0] > (int)slc.tjs.size()) return 0;
     unsigned short cnt = 0;
     for(auto& tj : slc.tjs) {
       if(tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) continue;
       if(!tj.AlgMod[kDeltaRay]) continue;
       if(std::find(tjIDs.begin(), tjIDs.end(), tj.ParentID) != tjIDs.end()) ++cnt;
     } // tj
     return cnt;
   } // NumDeltaRays

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

Definition at line 3775 of file Utils.cxx.

References tca::TrajPoint::Hits, kAllHits, kUsedHits, and tca::TrajPoint::UseHit.

Referenced by AddHits(), CheckHiMultUnusedHits(), and DotProd().

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

Definition at line 1863 of file Utils.cxx.

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

Referenced by AnalyzePFP(), CheckHiMultUnusedHits(), CheckStiffEl(), CheckTraj(), CompleteIncomplete3DVertices(), EndMerge(), FillmAllTraj(), FindCots(), FindHammerVertices2(), FindVtxTjs(), FixTrajBegin(), FixTrajEnd(), Forecast(), GottaKink(), MergeSubShowersTj(), MergeWithVertex(), tca::TrajClusterAlg::ReconstructAllTraj(), SetStrategy(), SplitTrajCrossingVertices(), StepAway(), TagShowerLike(), and UpdateTraj().

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

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

Definition at line 1871 of file Utils.cxx.

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

Referenced by ElectronLikelihood(), FitTraj(), MCSMom(), NumPtsWithCharge(), SetPDGCode(), and TrimEndPts().

   {
     unsigned short ntp = 0;
     for(unsigned short ipt = firstPt; ipt <= lastPt; ++ipt) if(tj.Pts[ipt].Chg > 0) ++ntp;
     // Add the count of deadwires
     if(includeDeadWires) ntp += DeadWireCount(slc, tj.Pts[firstPt], tj.Pts[lastPt]);
     return ntp;
   } // NumPtsWithCharge

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

Definition at line 3763 of file Utils.cxx.

References tca::Trajectory::AlgMod, kKilled, and tca::Trajectory::Pts.

Referenced by DotProd().

   {
     if(tj.AlgMod[kKilled]) return 0;
     if(tj.Pts.empty()) return 0;
     unsigned short nhits = 0;
     for(auto& tp : tj.Pts) {
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) if(tp.UseHit[ii]) ++nhits;
     } // tp
     return nhits;
   } // NumHitsInTj

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

Definition at line 664 of file Utils.cxx.

References tca::Trajectory::Pts.

Referenced by CompatibleMerge(), and EndMerge().

   {
     // returns the fraction of wires spanned by two trajectories
     float minWire = 1E6;
     float maxWire = -1E6;
     
     float cnt1 = 0;
     for(auto& tp : tj1.Pts) {
       if(tp.Chg == 0) continue;
       if(tp.Pos[0] < 0) continue;
       if(tp.Pos[0] < minWire) minWire = tp.Pos[0];
       if(tp.Pos[0] > maxWire) maxWire = tp.Pos[0];
       ++cnt1;
     }
     if(cnt1 == 0) return 0;
     float cnt2 = 0;
     for(auto& tp : tj2.Pts) {
       if(tp.Chg == 0) continue;
       if(tp.Pos[0] < 0) continue;
       if(tp.Pos[0] < minWire) minWire = tp.Pos[0];
       if(tp.Pos[0] > maxWire) maxWire = tp.Pos[0];
       ++cnt2;
     }
     if(cnt2 == 0) return 0;
     int span = maxWire - minWire;
     if(span <= 0) return 0;
     std::vector<unsigned short> wcnt(span);
     for(auto& tp : tj1.Pts) {
       if(tp.Chg == 0) continue;
       if(tp.Pos[0] < -0.4) continue;
       int indx = std::nearbyint(tp.Pos[0] - minWire);
       if(indx < 0 || indx > span - 1) continue;
       ++wcnt[indx];
     }
     for(auto& tp : tj2.Pts) {
       if(tp.Chg == 0) continue;
       if(tp.Pos[0] < -0.4) continue;
       int indx = std::nearbyint(tp.Pos[0] - minWire);
       if(indx < 0 || indx > span - 1) continue;
       ++wcnt[indx];
     }
     float cntOverlap = 0;
     for(auto cnt : wcnt) if(cnt > 1) ++cntOverlap;
     if(cnt1 < cnt2) {
       return cntOverlap / cnt1;
     } else {
       return cntOverlap / cnt2;
     }
     
   } // OverlapFraction

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

Definition at line 2169 of file TCShower.cxx.

References tca::ShowerStruct3D::CotIDs, tca::TCSlice::cots, FarEnd(), tca::PFPStruct::ID, tca::ShowerStruct3D::ID, ParentFOM(), PosSep2(), ss, tca::PFPStruct::TjIDs, and tca::TCSlice::tjs.

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

References tca::TrajPoint::Ang, tca::ShowerStruct::AspectRatio, ChgFracBetween(), ChgFracNearPos(), DeltaAngle(), tca::TrajPoint::DeltaRMS, tca::TrajPoint::Dir, tca::ShowerStruct::DirectionFOM, tca::Trajectory::EndPt, tca::ShowerStruct::Energy, FarEnd(), FindAlongTrans(), GetAssns(), tca::VtxStore::ID, tca::Trajectory::ID, tca::ShowerStruct::ID, InShowerProbLong(), MakeBareTrajPoint(), tca::VtxStore::Pos, tca::TrajPoint::Pos, PosSep(), PrintPos(), tca::Trajectory::Pts, tca::VtxStore::Score, ShowerParams(), tca::ShowerStruct::ShowerTjID, tcc, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, tca::Trajectory::VtxID, tca::TCSlice::vtxs, and tca::TCConfig::wirePitch.

Referenced by ParentFOM(), and SetParent().

   {
     // returns a FOM for the trajectory at the end point being the parent of ss and the end which
     // was matched.
     
     vx2Score = 0;
     tp1Sep = 0;
     
     if(tjEnd > 1) return 1000;
     if(ss.Energy == 0) return 1000;
 
     if(ss.ID == 0) return 1000;
     if(ss.TjIDs.empty()) return 1000;
     if(ss.ShowerTjID == 0) return 1000;
     
     std::string fcnLabel = inFcnLabel + ".PFOM";
     
     if(ss.AspectRatio > 0.5) {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 2S"<<ss.ID<<" poor AspectRatio "<<ss.AspectRatio<<" FOM not calculated";
       return 100;
     }
 
     float fom = 0;
     float cnt = 0;
     auto& stj = 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");
 //      tjlist = GetVtxTjIDs(slc, vx2);
       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 1908 of file Utils.cxx.

Referenced by tca::TruthMatcher::MatchAndSum().

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

Definition at line 372 of file Utils.cxx.

References tca::TCSlice::tjs, and TrajLength().

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

   {
     // Returns the most likely PDGCode for the set of Tjs provided
     // The PDG codes are:
     // 0 = your basic track-like trajectory
     // 11 = Tagged delta-ray
     // 13 = Tagged muon
     // 211 = pion-like. There exists a Bragg peak at an end with a vertex
     // 2212 = proton-like. There exists a Bragg peak at an end without a vertex
     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);
     // Count Bragg peaks. This assumes that the Tjs are in order...
 //    std::array<unsigned short, 2> stopCnt {{0, 0}};
     float maxLen = 0;
     for(auto tjid : tjIDs) {
       if(tjid <= 0 || tjid > (int)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];
       // count InShower Tjs with PDGCode not set (yet)
 //      if(tj.PDGCode != 11 && tj.AlgMod[kShowerLike]) ++cnts[1];
 //      for(unsigned short end = 0; end < 2; ++end) if(tj.StopFlag[end][kBragg]) ++stopCnt[end];
       float len = TrajLength(tj);
       if(len > maxLen) maxLen = len;
     } // tjid
     unsigned maxCnt = 0;
     // ignore the first PDG code in the list (the default)
     for(unsigned short ii = 1; ii < 5; ++ii) {
       if(cnts[ii] > maxCnt) {
         maxCnt = cnts[ii];
         codeIndex = ii;
       }
     } // ii
 
     return codeList[codeIndex];
   } // PDGCodeVote

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

Definition at line 1790 of file PFPUtils.cxx.

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

Referenced by DefineDontCluster(), DotProd(), and FindCots().

   {
     // returns the Distance of Closest Approach between two PFParticles. 
     close1 = USHRT_MAX;
     close2 = USHRT_MAX;
     float minSep2 = 1E8;
     for(unsigned short ipt1 = 0; ipt1 < pfp1.Tp3s.size(); ++ipt1) {
       auto& tp1 = pfp1.Tp3s[ipt1];
       for(unsigned short ipt2 = 0; ipt2 < pfp2.Tp3s.size(); ++ipt2) {
         auto& tp2 = pfp2.Tp3s[ipt2];
         float sep2 = PosSep2(tp1.Pos, tp2.Pos);
         if(sep2 > minSep2) continue;
         minSep2 = sep2;
         close1 = ipt1;
         close2 = ipt2;
       } // tp2
     } // tp1
     return sqrt(minSep2);
  } // PFPDOCA

void tca::PFPVertexCheck ( TCSlice & slc )

Definition at line 2502 of file PFPUtils.cxx.

References evt, tca::TCEvent::globalS3ID, tca::Vtx3Store::ID, tca::TCSlice::isValid, tca::TCSlice::nPlanes, tca::TCSlice::pfps, tca::Vtx3Store::Primary, tca::Vtx3Store::TPCID, geo::TPCID::TPCID(), tca::Vtx3Store::UID, tca::TCSlice::vtx3s, tca::Vtx3Store::Vx2ID, tca::Vtx3Store::Wire, tca::Vtx3Store::X, tca::Vtx3Store::Y, and tca::Vtx3Store::Z.

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

   {
     // 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;
     
     for(auto& pfp : slc.pfps) {
       if(pfp.ID == 0) continue;
       if(pfp.Vx3ID[0] > 0) 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;
       vx3.X = pfp.XYZ[0][0];
       vx3.Y = pfp.XYZ[0][1];
       vx3.Z = pfp.XYZ[0][2];
       vx3.ID = slc.vtx3s.size() + 1;
       vx3.Primary = false;
       ++evt.globalS3ID;
       vx3.UID = evt.globalS3ID;
       slc.vtx3s.push_back(vx3);
 //      std::cout<<"PFPVertexCheck: P"<<pfp.ID<<" create 3V"<<vx3.ID<<"\n";
       pfp.Vx3ID[0] = vx3.ID;
     } // pfp
   } // PFPVertexCheck

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

Definition at line 2366 of file PFPUtils.cxx.

References GetVtxTjIDs(), tca::PFPStruct::ID, SetIntersection(), tca::PFPStruct::TjIDs, tca::TCSlice::tjs, tmp, tca::TCSlice::vtx3s, tca::TCSlice::vtxs, and tca::PFPStruct::Vx3ID.

Referenced by AddMissedTj(), AnalyzePFP(), DefinePFP(), and DotProd().

   {
     // Checks the PFP Vx3 -> Vx2 -> Tj assignment to see if there is more
     // than one tj in a plane in the pfp.TjIDs list that is attached to the same 2D vertex. 
     // This problem is fixed by removing the shorter tj from the TjIDs list. This function
     // return true if nothing was done to TjIDs
     if(pfp.ID == 0) return true;
     if(pfp.TjIDs.empty()) return true;
     if(pfp.Vx3ID[0] <= 0 || pfp.Vx3ID[0] > (int)slc.vtx3s.size()) return true;
     
     auto& vx3 = slc.vtx3s[pfp.Vx3ID[0] - 1];
     std::vector<int> killMe;
     for(auto vx2id : vx3.Vx2ID) {
       if(vx2id == 0) continue;
       auto& vx2 = slc.vtxs[vx2id - 1];
       auto tjlist = GetVtxTjIDs(slc, vx2);
       auto setInt = SetIntersection(pfp.TjIDs, tjlist);
 /*
       std::cout<<"PVTC: P"<<pfp.ID<<" Tjs";
       for(auto tid : pfp.TjIDs) std::cout<<" T"<<tid;
       std::cout<<" set Intersection";
       for(auto tid : setInt) std::cout<<" T"<<tid;
       std::cout<<"\n";
 */
       if(setInt.size() < 2) continue;
       // find the longest one
       int imLong = 0;
       unsigned short lenth = 0;
       for(auto tid : setInt) {
         auto& tj = slc.tjs[tid - 1];
         unsigned short npts = tj.EndPt[1] - tj.EndPt[0] + 1;
         if(npts < lenth) continue;
         lenth = npts;
         imLong = tj.ID;
       } // tid
       if(imLong == 0) continue;
       // add the others to the killMe list
       for(auto tid : setInt) if(tid != imLong) killMe.push_back(tid);
     } // vx2id
     if(killMe.empty()) return true;
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"PVTC: P"<<pfp.ID<<" removing short tjs attached to a vertex:";
       for(auto tid : killMe) myprt<<" T"<<tid;
     }
     // re-create the TjIDs vector
     std::vector<int> tmp;
     for(auto tid : pfp.TjIDs) {
       if(std::find(killMe.begin(), killMe.end(), tid) == killMe.end()) tmp.push_back(tid);
     } // tid
     pfp.TjIDs = tmp;
     return false;
   } // PFPVxTjOK

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

Definition at line 1643 of file PFPUtils.cxx.

References dir, and SetMag().

Referenced by ChgFracBetween(), CreateFakePFP(), DefineDontCluster(), DotProd(), FindAlongTrans(), FindParent(), FollowTp3s(), and UpdateShower().

   {
     // Finds the direction vector between the two points from p1 to p2
     Vector3_t dir;
     for(unsigned short xyz = 0; xyz < 3; ++xyz) dir[xyz] = p2[xyz] - p1[xyz];
     if(dir[0] == 0 && dir[1] == 0 && dir[2] == 0) return dir;
     if(!SetMag(dir, 1)) { dir[0] = 0; dir[1] = 0; dir[3] = 0; }
     return dir;
   } // PointDirection

Vector2_t tca::PointDirection	(	const Point2_t	p1,
		const Point2_t	p2
	)

Definition at line 3655 of file Utils.cxx.

References dir, and norm.

Referenced by MakeBareTrajPoint().

   {
     // Finds the direction vector between the two points from p1 to p2
     Vector2_t dir;
     for(unsigned short xyz = 0; xyz < 2; ++xyz) dir[xyz] = p2[xyz] - p1[xyz];
     if(dir[0] == 0 && dir[1] == 0) return dir;
     double norm = sqrt(dir[0] * dir[0] + dir[1] * dir[1]);
     dir[0] /= norm;
     dir[1] /= norm;
     return dir;
   } // PointDirection

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

Definition at line 2867 of file PFPUtils.cxx.

References LineLineIntersect().

Referenced by DotProd().

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

References DeltaAngle().

Referenced by AddLooseHits(), AddTjsInsideEnvelope(), FindNearbyTjs(), KillVerticesInShower(), and MergeOverlap().

   {
     // returns true if the Point is within the Envelope polygon. Entries in Envelope are the
     // Pos[0], Pos[1] locations of the polygon vertices. This is based on the algorithm that the
     // sum of the angles of a vector between a point and the vertices will be 2 * pi for an interior
     // point and 0 for an exterior point
     
     Point2_t p1, p2;
     unsigned short nvx = Envelope.size();
     double angleSum = 0;
     for(unsigned short ii = 0; ii < Envelope.size(); ++ii) {
       p1[0] = Envelope[ii][0] - Point[0];
       p1[1] = Envelope[ii][1] - Point[1];
       p2[0] = Envelope[(ii+1)%nvx][0] - Point[0];
       p2[1] = Envelope[(ii+1)%nvx][1] - Point[1];
       angleSum += DeltaAngle(p1, p2);
     }
     if(abs(angleSum) < M_PI) return false;
     return true;
       
   } // InsideEnvelope

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

Definition at line 2270 of file Utils.cxx.

References tca::TCEvent::allHits, evt, PointTrajDOCA2(), tca::TCSlice::slHits, tcc, and tca::TCConfig::unitsPerTick.

Referenced by AddHits(), CheckHiMultUnusedHits(), ChkVxTjs(), CompleteIncomplete3DVerticesInGaps(), EndMerge(), FillGaps(), FindHammerVertices2(), FindNearbyTjs(), FindUseHits(), FixTrajBegin(), FixTrajEnd(), Forecast(), HiEndDelta(), MaskTrajEndPoints(), MergeShowerChain(), MergeSubShowers(), MergeSubShowersTj(), SplitTrajCrossingVertices(), TrajPointVertexPull(), UpdateDeltaRMS(), UpdateStiffEl(), UpdateTraj(), and VtxHitsSwap().

   {
     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	(	TCSlice &	slc,
		float	wire,
		float	time,
		TrajPoint const &	tp
	)

Definition at line 2280 of file Utils.cxx.

References PointTrajDOCA2().

Referenced by CompatibleMerge(), FindCloseHits(), MakeHaloTj(), MaxHitDelta(), and TagDeltaRays().

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

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

Definition at line 2286 of file Utils.cxx.

References tca::TrajPoint::Dir, and tca::TrajPoint::Pos.

Referenced by PointTrajDOCA(), and TjDeltaRMS().

   {
     // returns the distance of closest approach squared between a (wire, time(WSE)) point
     // and a trajectory point
     
     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 2262 of file Utils.cxx.

References tca::TrajPoint::Pos.

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

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

Definition at line 3287 of file TCVertex.cxx.

References detinfo::DetectorProperties::ConvertXToTicks(), geo::CryostatID::Cryostat, tca::TCConfig::detprop, tca::TCConfig::geom, tcc, geo::TPCID::TPC, tca::Vtx3Store::TPCID, tca::TCConfig::unitsPerTick, geo::GeometryCore::WireCoordinate(), tca::Vtx3Store::X, tca::Vtx3Store::Y, and tca::Vtx3Store::Z.

Referenced by AttachPFPToVertex(), Print3V(), and PrintAllTraj().

   {
     // 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] = tcc.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 1654 of file PFPUtils.cxx.

References PosSep2().

Referenced by ChgFracBetween(), ChkVxTjs(), DefineDontCluster(), DefineEnvelope(), DefinePFP(), DotProd(), EndMerge(), Find2DVertices(), FindAlongTrans(), FindCots(), FindHammerVertices2(), FindMissedTjsInTp3s(), FindParent(), FindShowerStart(), FitTp3(), FollowTp3s(), InShowerProb(), LineLineIntersect(), MakeJunkVertices(), MakeTp3(), Match2DShowers(), MergeOverlap(), MergeShowerChain(), MergeSubShowers(), MergeSubShowersTj(), ParentFOM(), PrintTp3s(), Reconcile3D(), TagShowerLike(), and UpdateShower().

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

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

Definition at line 2353 of file Utils.cxx.

References PosSep2().

Referenced by CompatibleMerge(), PrintP(), PrintPFP(), TagDeltaRays(), and TjDirFOM().

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

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

Definition at line 1660 of file PFPUtils.cxx.

Referenced by AttachTrajToVertex(), DotProd(), EndMerge(), FarEnd(), Find2DVertices(), FindKinks(), FindParent(), FitTp3(), FollowTp3s(), KinkAngle(), LengthInCTP(), MergeOverlap(), ParentFOM(), PFPDOCA(), PosSep(), StepAway(), StitchPFPs(), TrajPointVertexPull(), and UpdateShower().

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

Referenced by CloseEnd(), FarEnd(), MaxTjLen(), MergeAndStore(), and PosSep().

   {
     // returns the separation distance^2 between two positions
     float d0 = pos1[0] - pos2[0];
     float d1 = pos1[1] - pos2[1];
     return d0*d0+d1*d1;
   } // PosSep2

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

Definition at line 463 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::ID, kHaloTj, kKilled, tca::Trajectory::ParentID, and tca::TCSlice::tjs.

Referenced by NeutrinoPrimaryTjID(), PrintAllTraj(), and PrintT().

   {
     // 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	(	TCSlice &	slc,
		const PFPStruct &	pfp
	)

Definition at line 482 of file Utils.cxx.

References GetSliceIndex(), tca::PFPStruct::ID, tca::PFPStruct::ParentUID, slices, and tca::PFPStruct::UID.

Referenced by PrintPFP().

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

References tca::TCSlice::cots, tca::TCSlice::dontCluster, DontCluster(), nlines, PrintShower(), ss, tcc, util::flags::to_string(), and tca::TCConfig::unitsPerTick.

Referenced by FindShowers3D(), and Reconcile3D().

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

Definition at line 5026 of file Utils.cxx.

References tca::VtxStore::ChiDOF, tca::VtxStore::CTP, debug, DecodeCTP(), evd::details::end(), GetSliceIndex(), tca::VtxStore::ID, kKilled, tca::VtxStore::NTraj, tca::VtxStore::Pass, tca::DebugStuff::Plane, geo::PlaneID::Plane, tca::VtxStore::Pos, tca::VtxStore::PosErr, art::right(), tca::VtxStore::Score, slices, tca::VtxStore::Stat, tcc, tca::VtxStore::TjChgFrac, util::flags::to_string(), tca::VtxStore::Topo, tca::VtxStore::UID, tca::TCConfig::unitsPerTick, VtxBitNames, and tca::VtxStore::Vx3ID.

Referenced by DotProd(), and PrintAll().

   {
     // print a 2D vertex on one line
     if(vx2.ID <= 0) return;
     if(debug.Plane >= 0 && debug.Plane != (int)DecodeCTP(vx2.CTP).Plane) return;
     auto sIndx = GetSliceIndex("2V", vx2.UID);
     if(sIndx.first == USHRT_MAX) return;
     auto& slc = slices[sIndx.first];
 //    myprt<<someText;
     std::string str = std::to_string(slc.ID) + ":" + std::to_string(sIndx.first) + ":" + std::to_string(vx2.ID);
     str += "/" + 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 = " T" + std::to_string(tj.UID) + "_" + std::to_string(end);
         myprt<<std::right<<std::setw(6)<<tid;
       } // end
     } // ii
     // Special flags. Ignore the first flag bit (0 = kVtxTrjTried) which is done for every vertex
     for(unsigned short ib = 1; ib < VtxBitNames.size(); ++ib) if(vx2.Stat[ib]) myprt<<" "<<VtxBitNames[ib];
     myprt<<"\n";
   } // Print2V

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

Definition at line 5069 of file Utils.cxx.

References tca::ShowerStruct3D::ChgPos, tca::ShowerStruct3D::CotIDs, geo::CryostatID::Cryostat, tca::ShowerStruct3D::Dir, EncodeCTP(), GetSliceIndex(), tca::ShowerStruct3D::ID, MakeBareTP(), tca::ShowerStruct3D::NeedsUpdate, PrintPos(), slices, ss, util::flags::to_string(), geo::TPCID::TPC, tca::ShowerStruct3D::TPCID, tca::ShowerStruct3D::UID, and tca::ShowerStruct3D::Vx3ID.

Referenced by DotProd(), and PrintAll().

   {
     if(ss3.ID <= 0) return;
     auto sIndx = GetSliceIndex("3S", ss3.UID);
     if(sIndx.first == USHRT_MAX) return;
     auto& slc = slices[sIndx.first];
 //    myprt<<someText;
     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(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 = "2S" + std::to_string(ss.UID);
       myprt<<std::setw(5)<<str;
 /*
       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";
   } // Print3S

void tca::Print3V	(	std::string	someText,
		mf::LogVerbatim &	myprt,
		Vtx3Store &	vx3
	)

Definition at line 4959 of file Utils.cxx.

References geo::CryostatID::Cryostat, evd::details::end(), GetAssns(), GetSliceIndex(), tca::Vtx3Store::ID, kVtxTruMatch, tca::Vtx3Store::Neutrino, PosInPlane(), tca::Vtx3Store::Primary, PrintPos(), art::right(), tca::Vtx3Store::Score, slices, util::flags::to_string(), geo::TPCID::TPC, tca::Vtx3Store::TPCID, tca::Vtx3Store::UID, tca::Vtx3Store::Vx2ID, tca::Vtx3Store::Wire, tca::Vtx3Store::X, tca::Vtx3Store::XErr, tca::Vtx3Store::Y, tca::Vtx3Store::YErr, tca::Vtx3Store::Z, and tca::Vtx3Store::ZErr.

Referenced by DotProd(), and PrintAll().

   {
     // 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];
 //    myprt<<someText;
     std::string str = std::to_string(slc.ID) + ":" + std::to_string(sIndx.first) + ":" + std::to_string(vx3.ID);
     str += "/" + std::to_string(vx3.UID);
     myprt<<std::right<<std::setw(12)<<std::fixed<<str;
     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;
     for(auto vx2id : vx3.Vx2ID) {
       if(vx2id > 0) {
         str = "2V" + std::to_string(slc.vtxs[vx2id - 1].UID);
         myprt<<std::right<<std::setw(5)<<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[kVtxTruMatch]) ++nTruMatch;
     } // ipl
     myprt<<std::right<<std::setw(6)<<std::setprecision(1)<<vx3.Score;
     myprt<<std::setw(6)<<vx3.Primary;
     myprt<<std::setw(4)<<vx3.Neutrino;
     myprt<<std::right<<std::setw(5)<<nTruMatch;
     Point2_t pos;
     for(unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
       PosInPlane(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<<" T"<<tj.UID;
       }
     } // vx3.Wire != -2
     myprt<<"\n";
   } // Print3V

void tca::PrintAll	(	std::string	someText,
		const std::vector< simb::MCParticle * > &	mcpList
	)

Definition at line 4774 of file Utils.cxx.

References debug, sim::ParticleList::EveId(), cheat::ParticleInventoryService::ParticleList(), Print2V(), Print3S(), Print3V(), PrintP(), PrintT(), tca::DebugStuff::Slice, and slices.

Referenced by DotProd(), export_G4VSensitiveDetector(), and cluster::TrajCluster::produce().

   {
     // print everything in all slices
     bool prt3V = false;
     bool prt2V = false;
     bool prtT = false;
     bool prtP = false;
     bool prtS3 = false;
     //bool prtS2 = 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;
       //if(!slc.cots.empty()) prtS2 = true;
     } // slc
     mf::LogVerbatim myprt("TC");
     myprt<<"Debug report from caller "<<someText<<"\n";
     if(!mcpList.empty()) {
       art::ServiceHandle<cheat::ParticleInventoryService> pi_serv;
       myprt<<"************ "<<mcpList.size()<<" MCParticles (> 10 MeV) ************\n";
       myprt<<" mcpindx  PDG    KE eveIndx   Process\n";
       for(unsigned int imcp = 0; imcp < mcpList.size(); ++imcp) {
         auto& mcp = mcpList[imcp];
         int pdg = abs(mcp->PdgCode());
         if(pdg > 3000) continue;
         float TMeV = 1000 * (mcp->E() - mcp->Mass());
         if(TMeV < 10) continue;
         myprt<<std::setw(8)<<imcp;
         myprt<<std::setw(5)<<pdg;
         myprt<<std::setw(6)<<(int)TMeV;
         int eveID = pi_serv->ParticleList().EveId(mcp->TrackId());
         int eveIndx = -1;
         for(unsigned int jmcp = 0; jmcp < mcpList.size(); ++jmcp) {
           if(mcpList[jmcp]->TrackId() == eveID) {
             eveIndx = jmcp;
             break;
           } 
         } // jmcp
         myprt<<std::setw(8)<<eveIndx;
         myprt<<" "<<mcp->Process();
         myprt<<"\n";
       } // imcp
     } // mcpList not empty
     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(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) {
       // print out 3D vertices
       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(someText, myprt, vx3);
       } // slc
     } // prt3V
     if(prt2V) {
       // print out 2D vertices
       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);
       } // 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	(	std::string	someText,
		TCSlice &	slc,
		unsigned short	itj,
		unsigned short	ipt,
		bool	prtVtx
	)

Definition at line 5197 of file Utils.cxx.

References AlgBitNames, geo::CryostatID::Cryostat, debug, DecodeCTP(), evd::details::end(), GetAssns(), tca::Vtx3Store::ID, kAtKink, kAtTj, kAtVtx, kBragg, kEnvNearTj, kKilled, kVtxTruMatch, tca::Vtx3Store::Neutrino, NeutrinoPrimaryTjID(), tca::TCSlice::nPlanes, tca::TCSlice::pfps, tca::DebugStuff::Plane, geo::PlaneID::Plane, PosInPlane(), tca::Vtx3Store::Primary, PrimaryID(), PrintHeader(), PrintPos(), PrintTrajPoint(), art::right(), tca::Vtx3Store::Score, tcc, tca::TCSlice::tjs, tmp, util::flags::to_string(), geo::TPCID::TPC, tca::Vtx3Store::TPCID, tca::TCConfig::unitsPerTick, tca::TCSlice::vtx3s, VtxBitNames, tca::TCSlice::vtxs, tca::Vtx3Store::Vx2ID, tca::Vtx3Store::Wire, tca::Vtx3Store::X, tca::Vtx3Store::XErr, tca::Vtx3Store::Y, tca::Vtx3Store::YErr, tca::Vtx3Store::Z, and tca::Vtx3Store::ZErr.

Referenced by DotProd(), Find2DVertices(), and FindShowers3D().

   {
     
     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[kVtxTruMatch]) ++nTruMatch;
           } // ipl
           myprt<<std::right<<std::setw(6)<<std::setprecision(1)<<vx3.Score;
           myprt<<std::setw(6)<<vx3.Primary;
           myprt<<std::setw(4)<<vx3.Neutrino;
           myprt<<std::right<<std::setw(5)<<nTruMatch;
           Point2_t pos;
           for(unsigned short plane = 0; plane < slc.nPlanes; ++plane) {
             PosInPlane(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 = kVtxTrjTried) which is done for every vertex
             for(unsigned short ib = 1; ib < VtxBitNames.size(); ++ib) if(vx2.Stat[ib]) myprt<<" "<<VtxBitNames[ib];
             myprt<<"\n";
           } // iv
         }
       } // 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
       std::vector<unsigned int> tmp;
 //      myprt<<someText<<" TRJ  ID   CTP Pass  Pts     W:T      Ang CS AveQ dEdx     W:T      Ang CS AveQ dEdx Chg(k) chgRMS  Mom SDr __Vtx__  PDG  Par Pri NuPar TRuPDG  E*P TruKE  WorkID \n";
       myprt<<someText<<"   UID   CTP Pass  Pts     W:T      Ang CS AveQ fnTj     W:T      Ang CS AveQ fnTj Chg(k) chgRMS  Mom SDr __Vtx__  PDG DirFOM  Par Pri NuPar TRuPDG  E*P TruKE  WorkID \n";
       for(unsigned short ii = 0; ii < slc.tjs.size(); ++ii) {
         auto& aTj = slc.tjs[ii];
         if(debug.Plane >=0 && debug.Plane < 3 && debug.Plane != (int)DecodeCTP(aTj.CTP).Plane) continue;
         myprt<<someText<<" ";
         std::string tid;
         if(aTj.AlgMod[kKilled]) { tid = "k" + std::to_string(aTj.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.Pts.size();
         myprt<<std::setw(5)<<aTj.EndPt[1] - aTj.EndPt[0] + 1;
         unsigned short endPt0 = aTj.EndPt[0];
         auto& tp0 = aTj.Pts[endPt0];
         int itick = tp0.Pos[1]/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.StopFlag[0][kBragg]) {
           myprt<<"B";
         } else if(aTj.StopFlag[0][kAtVtx]) {
           myprt<<"V";
         } else if(aTj.StopFlag[0][kAtKink]) {
           myprt<<"K";
         } else if(aTj.StopFlag[0][kAtTj]) {
           myprt<<"T";
         } else {
           myprt<<" ";
         }
         myprt<<std::setw(5)<<(int)tp0.AveChg;
         // Print the fraction of points in the first half that are in a shower
         float frac = 0;
         float cnt = 0;
         unsigned short midPt = 0.5 * (aTj.EndPt[0] + aTj.EndPt[1]);
         for(unsigned short ipt = aTj.EndPt[0]; ipt < midPt; ++ipt) {
           auto& tp = aTj.Pts[ipt];
 //          if(tp.Environment[kEnvNearShower]) ++frac;
           if(tp.Environment[kEnvNearTj]) ++frac;
           ++cnt;
         } // ipt
         if(cnt > 0) frac /= cnt;
         myprt<<std::setw(5)<<std::setprecision(1)<<frac;
 /* print NearInShower fraction instead
         unsigned short prec = 1;
         if(aTj.dEdx[0] > 99) prec = 0;
         myprt<<std::setw(5)<<std::setprecision(prec)<<aTj.dEdx[0];
 */
         unsigned short endPt1 = aTj.EndPt[1];
         auto& tp1 = aTj.Pts[endPt1];
         itick = tp1.Pos[1]/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.StopFlag[1][kBragg]) {
           myprt<<"B";
         } else if(aTj.StopFlag[1][kAtVtx]) {
           myprt<<"V";
         } else {
           myprt<<" ";
         }
         myprt<<std::setw(5)<<(int)tp1.AveChg;
         // Print the fraction of points in the second half that are NearInShower
         frac = 0;
         cnt = 0;
         for(unsigned short ipt = midPt; ipt <= aTj.EndPt[1]; ++ipt) {
           auto& tp = aTj.Pts[ipt];
 //          if(tp.Environment[kEnvNearShower]) ++frac;
           if(tp.Environment[kEnvNearTj]) ++frac;
           ++cnt;
         } // ipt
         if(cnt > 0) frac /= cnt;
         myprt<<std::setw(5)<<std::setprecision(1)<<frac;
 /*
         prec = 1;
         if(aTj.dEdx[1] > 99) prec = 0;
         myprt<<std::setw(5)<<std::setprecision(prec)<<aTj.dEdx[1];
 */
         myprt<<std::setw(7)<<std::setprecision(1)<<aTj.TotChg/1000;
         myprt<<std::setw(7)<<std::setprecision(2)<<aTj.ChgRMS;
         myprt<<std::setw(5)<<aTj.MCSMom;
         myprt<<std::setw(4)<<aTj.StepDir;
         myprt<<std::setw(4)<<aTj.VtxID[0];
         myprt<<std::setw(4)<<aTj.VtxID[1];
         myprt<<std::setw(5)<<aTj.PDGCode;
         myprt<<std::setw(7)<<std::setprecision(1)<<aTj.DirFOM;
         myprt<<std::setw(5)<<aTj.ParentID;
         myprt<<std::setw(5)<<PrimaryID(slc, aTj);
         myprt<<std::setw(6)<<NeutrinoPrimaryTjID(slc, aTj);
         int truKE = 0;
         int pdg = 0;
 /*
         if(aTj.mcpListIndex < evt.mcpList.size()) {
           auto& mcp = evt.mcpList[aTj.mcpListIndex];
           truKE = 1000 * (mcp->E() - mcp->Mass());
           pdg = mcp->PdgCode();
         }
 */
         myprt<<std::setw(6)<<pdg;
         myprt<<std::setw(6)<<std::setprecision(2)<<aTj.EffPur;
         myprt<<std::setw(5)<<truKE;
         myprt<<std::setw(7)<<aTj.WorkID;
         for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(aTj.AlgMod[ib]) myprt<<" "<<AlgBitNames[ib];
         myprt<<"\n";
       } // ii
       return;
     } // itj > 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";
     
     PrintHeader(someText);
     if(ipt == USHRT_MAX) {
       // print all points
       for(unsigned short ii = 0; ii < aTj.Pts.size(); ++ii) PrintTrajPoint(someText, slc, ii, aTj.StepDir, aTj.Pass, aTj.Pts[ii]);
     } else {
       // print just one
       PrintTrajPoint(someText, slc, ipt, aTj.StepDir, aTj.Pass, aTj.Pts[ipt]);
     }
   } // PrintAllTraj

void tca::PrintClusters ( )

Referenced by cluster::ClusterCrawlerAlg::ClusterLoop(), DotProd(), cluster::ClusterCrawlerAlg::FindStarVertices(), cluster::ClusterCrawlerAlg::FindVertices(), trkf::CCTrackMaker::MakeClusterChains(), trkf::CCTrackMaker::produce(), and cluster::ClusterCrawlerAlg::RunCrawler().

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

Definition at line 5535 of file Utils.cxx.

Referenced by DotProd(), FindVtxTjs(), FitVertex(), PrintAllTraj(), lar_content::LArFormattingHelper::PrintRule(), and PrintTrajectory().

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

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

Definition at line 5704 of file Utils.cxx.

References tca::TCEvent::allHits, tca::TCHit::allHitsIndex, evt, tca::TCHit::InTraj, and util::flags::to_string().

Referenced by cluster::ClusterCrawlerAlg::AddHit(), AddHits(), cluster::ClusterCrawlerAlg::AddLAHit(), AddLAHits(), CheckHiMultUnusedHits(), tca::TrajClusterAlg::ChkInTraj(), ChkStopEndPts(), cluster::ClusterCrawlerAlg::ClusterLoop(), DotProd(), FillGaps(), Find3DVertices(), tca::TrajClusterAlg::FindJunkTraj(), FindUseHits(), FindVtxTjs(), HasDuplicateHits(), InTrajOK(), cluster::ClusterCrawlerAlg::MergeOverlap(), tca::TrajClusterAlg::ReconstructAllTraj(), ReversePropagate(), and StoreTraj().

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

References tca::TCEvent::allHits, tca::TCHit::allHitsIndex, evt, and util::flags::to_string().

Referenced by DotProd().

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

References tca::PFPStruct::dEdx, tca::PFPStruct::Dir, tca::PFPStruct::DtrUIDs, tca::PFPStruct::EffPur, GetSliceIndex(), tca::PFPStruct::ID, InsideFV(), IsShowerLike(), SortEntry::length, tca::PFPStruct::mcpListIndex, MCSMom(), tca::PFPStruct::ParentUID, tca::PFPStruct::PDGCode, PosSep(), art::right(), slices, tca::PFPStruct::TjIDs, tca::PFPStruct::TjUIDs, util::flags::to_string(), tca::PFPStruct::Tp3s, tca::PFPStruct::UID, tca::PFPStruct::Vx3ID, and tca::PFPStruct::XYZ.

Referenced by DotProd(), PrintAll(), and StitchPFPs().

   {
     if(pfp.ID <= 0) return;
     if(printHeader) {
       myprt<<"************ PFParticles ************\n";
       myprt<<"     prodID    sVx  _____sPos____ CS _______sDir______ ____sdEdx_____    eVx  _____ePos____ CS _______eDir______ ____edEdx_____   MCS  Len nTp3 SLk? PDG mcpIndx Par E*P\n";
       printHeader = false;
     } // printHeader
     auto sIndx = GetSliceIndex("P", pfp.UID);
     if(sIndx.first == USHRT_MAX) return;
     auto& slc = slices[sIndx.first];
 //    myprt<<someText;
     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 startend = 0; startend < 2; ++startend) {
       str = "--";
       if(pfp.Vx3ID[startend] > 0) str = "3V" + std::to_string(slc.vtx3s[pfp.Vx3ID[startend]-1].UID);
       myprt<<std::setw(6)<<str;
       myprt<<std::fixed<<std::right<<std::setprecision(0);
       myprt<<std::setw(5)<<pfp.XYZ[startend][0];
       myprt<<std::setw(5)<<pfp.XYZ[startend][1];
       myprt<<std::setw(5)<<pfp.XYZ[startend][2];
       // print character for Outside or Inside the FV
       if(InsideFV(slc, pfp, startend)) {
         myprt<<"  I";
       } else {
         myprt<<"  O";
       }
       myprt<<std::fixed<<std::right<<std::setprecision(2);
       myprt<<std::setw(6)<<pfp.Dir[startend][0];
       myprt<<std::setw(6)<<pfp.Dir[startend][1];
       myprt<<std::setw(6)<<pfp.Dir[startend][2];
       for(auto& dedx : pfp.dEdx[startend]) {
         if(dedx < 50) {
           myprt<<std::setw(5)<<std::setprecision(1)<<dedx;
         } else {
           myprt<<std::setw(5)<<std::setprecision(0)<<dedx;
         }
       } // dedx
       if (pfp.dEdx[startend].size()<3){
         for(size_t i = 0; i<3-pfp.dEdx[startend].size(); ++i){
           myprt<<std::setw(6)<<' ';
         }
       }
     } // startend
     // global stuff
     myprt<<std::setw(7)<<MCSMom(slc, pfp.TjIDs);
     float length = PosSep(pfp.XYZ[0], pfp.XYZ[1]);
     if(length < 100) {
       myprt<<std::setw(5)<<std::setprecision(1)<<length;
     } else {
       myprt<<std::setw(5)<<std::setprecision(0)<<length;
     }
     myprt<<std::setw(5)<<std::setprecision(2)<<pfp.Tp3s.size();
     myprt<<std::setw(3)<<IsShowerLike(slc, pfp.TjIDs);
     myprt<<std::setw(5)<<pfp.PDGCode;
     if(pfp.mcpListIndex == UINT_MAX) {
       myprt<<"      --";
     } else {
       myprt<<std::setw(8)<<pfp.mcpListIndex;
     }
     myprt<<std::setw(4)<<pfp.ParentUID;
 //    myprt<<std::setw(5)<<PrimaryUID(slc, pfp);
     myprt<<std::setw(5)<<std::setprecision(2)<<pfp.EffPur;
     if(!pfp.TjIDs.empty()) {
       if(pfp.TjUIDs.empty()) {
         // print Tjs in one TPC
         for(auto tjid : pfp.TjIDs) myprt<<" T"<<slc.tjs[tjid - 1].UID;
       } else {
         // print Tjs in all TPCs (if this is called after FinishEvent)
         for(auto tjuid : pfp.TjUIDs) myprt<<" T"<<tjuid;
       }
     } // TjIDs exist
     if(!pfp.DtrUIDs.empty()) {
       myprt<<" dtrs";
       for(auto dtruid : pfp.DtrUIDs) myprt<<" P"<<dtruid;
     } // dtr ids exist
     myprt<<"\n";
   } // PrintP

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

Definition at line 5587 of file Utils.cxx.

References tca::PFPStruct::dEdx, tca::PFPStruct::Dir, tca::PFPStruct::DtrUIDs, tca::PFPStruct::EffPur, tca::PFPStruct::ID, InsideTPC(), IsShowerLike(), SortEntry::length, MCSMom(), tca::PFPStruct::ParentUID, tca::PFPStruct::PDGCode, PosSep(), PrimaryUID(), art::right(), tca::PFPStruct::TjIDs, util::flags::to_string(), tca::PFPStruct::Tp3s, tca::PFPStruct::Vx3ID, and tca::PFPStruct::XYZ.

Referenced by DotProd(), Match3DVtxTjs(), MergePFPTjs(), and PrintPFPs().

   {
     mf::LogVerbatim myprt("TC");
     if(printHeader) {
       myprt<<someText;
       myprt<<"  PFP sVx  ________sPos_______ CS _______sDir______ ____sdEdx_____ eVx  ________ePos_______ CS _______eDir______ ____edEdx____   Len nTp3 MCSMom ShLike? PDG mcpIndx Par Prim E*P\n";
     }
     myprt<<someText;
     std::string pid = "P" + std::to_string(pfp.ID);
     myprt<<std::setw(5)<<pid;
     // start and end stuff
     for(unsigned short startend = 0; startend < 2; ++startend) {
       myprt<<std::setw(4)<<pfp.Vx3ID[startend];
       myprt<<std::fixed<<std::right<<std::setprecision(1);
       myprt<<std::setw(7)<<pfp.XYZ[startend][0];
       myprt<<std::setw(7)<<pfp.XYZ[startend][1];
       myprt<<std::setw(7)<<pfp.XYZ[startend][2];
       // print character for Outside or Inside the FV
       geo::TPCID tpcid;
       if(InsideTPC(pfp.XYZ[startend], tpcid)) {
         myprt<<"  I";
       } else {
         myprt<<"  O";
       }
       myprt<<std::fixed<<std::right<<std::setprecision(2);
       myprt<<std::setw(6)<<pfp.Dir[startend][0];
       myprt<<std::setw(6)<<pfp.Dir[startend][1];
       myprt<<std::setw(6)<<pfp.Dir[startend][2];
       for(auto& dedx : pfp.dEdx[startend]) {
         if(dedx < 50) {
           myprt<<std::setw(5)<<std::setprecision(1)<<dedx;
         } else {
           myprt<<std::setw(5)<<std::setprecision(0)<<dedx;
         }
       } // dedx
       if (pfp.dEdx[startend].size()<3){
         for(size_t i = 0; i<3-pfp.dEdx[startend].size(); ++i){
           myprt<<std::setw(6)<<' ';
         }
       }
     } // startend
     // global stuff
 //    myprt<<std::setw(5)<<pfp.BestPlane;
     float length = PosSep(pfp.XYZ[0], pfp.XYZ[1]);
     if(length < 100) {
       myprt<<std::setw(5)<<std::setprecision(1)<<length;
     } else {
       myprt<<std::setw(5)<<std::setprecision(0)<<length;
     }
     myprt<<std::setw(5)<<std::setprecision(2)<<pfp.Tp3s.size();
     myprt<<std::setw(7)<<MCSMom(slc, pfp.TjIDs);
     myprt<<std::setw(5)<<IsShowerLike(slc, pfp.TjIDs);
     myprt<<std::setw(5)<<pfp.PDGCode;
 /*
     if(pfp.mcpListIndex < evt.mcpList.size()) {
       myprt<<std::setw(8)<<pfp.mcpListIndex;
     } else {
       myprt<<"      NA";
     }
 */
     myprt<<"      NA";
     myprt<<std::setw(4)<<pfp.ParentUID;
     myprt<<std::setw(5)<<PrimaryUID(slc, pfp);
     myprt<<std::setw(5)<<std::setprecision(2)<<pfp.EffPur;
     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 5661 of file Utils.cxx.

References tca::TCSlice::pfps, and PrintPFP().

Referenced by DotProd(), and FindShowers3D().

   {
     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	(	TCSlice &	slc,
		const TrajPoint &	tp
	)

Definition at line 5712 of file Utils.cxx.

References tca::TrajPoint::CTP, tca::TrajPoint::Pos, PrintPos(), and util::flags::to_string().

Referenced by AddLAHits(), ChkStopEndPts(), ChkVxTjs(), CompleteIncomplete3DVertices(), DotProd(), EndMerge(), FillGaps(), Find2DVertices(), FindHammerVertices2(), FindSoftKink(), FitVertex(), FixTrajBegin(), Forecast(), GottaKink(), MaskTrajEndPoints(), tca::TruthMatcher::MatchAndSum(), MergeShowerChain(), MergeWithVertex(), ParentFOM(), PrintShower(), PrintShowers(), PrintTp3(), PrintTp3s(), tca::TrajClusterAlg::ReconstructAllTraj(), ReversePropagate(), SplitHiChgHits(), StepAway(), UpdateShower(), and VtxHitsSwap().

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

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

Definition at line 5718 of file Utils.cxx.

References tcc, util::flags::to_string(), and tca::TCConfig::unitsPerTick.

Referenced by CheckTrajBeginChg(), MergeAndStore(), Print3S(), Print3V(), PrintAllTraj(), PrintPos(), TagDeltaRays(), TjDirFOM(), and UpdateVxEnvironment().

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

Referenced by Print2DShowers().

   {
     // print a single shower and a header (optional) and the extra variables like TjIDs, envelope, etc
     mf::LogVerbatim myprt("TC");
     
     if(printHeader) {
       myprt<<someText<<"   ID   CTP  ParID ParFOM TruParID Energy nTjs  dFOM AspRat  stj  vx0 __Pos0___ Chg(k) dRMS __Pos1___ Chg(k) dRMS __Pos2___ Chg(k) dRMS Angle SS3ID PFPID\n";
     } // printHeader
 
     myprt<<someText<<std::fixed;
     std::string sid = "2S" + std::to_string(ss.ID);
     myprt<<std::setw(5)<<sid;
     myprt<<std::setw(6)<<ss.CTP;
     sid = "NA";
     if(ss.ParentID > 0) sid = "T" + std::to_string(ss.ParentID);
     myprt<<std::setw(7)<<sid;
     myprt<<std::setw(7)<<std::setprecision(2)<<ss.ParentFOM;
     myprt<<std::setw(9)<<ss.TruParentID;
     myprt<<std::setw(7)<<(int)ss.Energy;
     myprt<<std::setw(5)<<ss.TjIDs.size();
     myprt<<std::setw(6)<<std::setprecision(2)<<ss.DirectionFOM;
     myprt<<std::setw(7)<<std::setprecision(2)<<ss.AspectRatio;
     const auto& stj = 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	(	std::string	fcnLabel,
		TCSlice &	slc
	)

Definition at line 4611 of file TCShower.cxx.

References tca::TCSlice::cots, EncodeCTP(), MakeBareTP(), tca::TCSlice::nPlanes, PrintPos(), tca::TCSlice::showers, ss, and tca::TCSlice::tjs.

Referenced by Match2DShowers().

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

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

Definition at line 5677 of file Utils.cxx.

References tca::Trajectory::StopFlag, StopFlagNames, tmp, and util::flags::to_string().

Referenced by DotProd(), FixTrajBegin(), and PrintTrajectory().

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

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

Definition at line 5109 of file Utils.cxx.

References AlgBitNames, tca::Trajectory::AlgMod, tca::Trajectory::ChgRMS, tca::Trajectory::CTP, tca::Trajectory::DirFOM, tca::Trajectory::EffPur, tca::Trajectory::EndPt, GetSliceIndex(), tca::Trajectory::ID, kAtKink, kAtTj, kAtVtx, kBragg, tca::Trajectory::mcpListIndex, tca::Trajectory::MCSMom, NeutrinoPrimaryTjID(), tca::Trajectory::ParentID, tca::Trajectory::Pass, tca::Trajectory::PDGCode, PrimaryID(), tca::Trajectory::Pts, slices, tca::Trajectory::StepDir, tca::Trajectory::StopFlag, tcc, util::flags::to_string(), tca::Trajectory::TotChg, tca::Trajectory::UID, tca::TCConfig::unitsPerTick, tca::Trajectory::VtxID, and tca::Trajectory::WorkID.

Referenced by DotProd(), and PrintAll().

   {
     // print a 2D vertex on one line
     if(tj.ID <= 0) return;
 //    if(tj.AlgMod[kKilled]) return;
     
     if(printHeader) {
       myprt<<"************ Trajectories ************\n";
       myprt<<"     prodID    CTP Pass  Pts     W:T      Ang CS AveQ     W:T      Ang CS AveQ Chg(k) chgRMS  Mom SDr __Vtx__  PDG DirFOM  Par Pri NuPar  E*P mcpIndex  WorkID \n";
       printHeader = false;
     }
     auto sIndx = GetSliceIndex("T", tj.UID);
     if(sIndx.first == USHRT_MAX) return;
     auto& slc = slices[sIndx.first];
 //    myprt<<someText;
     std::string str = std::to_string(slc.ID) + ":" + std::to_string(sIndx.first) + ":" + std::to_string(tj.ID);
     str += "/" + 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.Pts.size();
     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.StopFlag[0][kBragg]) {
       myprt<<"B";
     } else if(tj.StopFlag[0][kAtVtx]) {
       myprt<<"V";
     } else if(tj.StopFlag[0][kAtKink]) {
       myprt<<"K";
     } else if(tj.StopFlag[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.StopFlag[1][kBragg]) {
       myprt<<"B";
     } else if(tj.StopFlag[1][kAtVtx]) {
       myprt<<"V";
     } 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;
     myprt<<std::setw(4)<<tj.StepDir;
     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(1)<<tj.DirFOM;
     myprt<<std::setw(5)<<tj.ParentID;
     myprt<<std::setw(5)<<PrimaryID(slc, tj);
     myprt<<std::setw(6)<<NeutrinoPrimaryTjID(slc, tj);
     myprt<<std::setw(6)<<std::setprecision(2)<<tj.EffPur;
     if(tj.mcpListIndex == UINT_MAX) {
       myprt<<"    --";
     } else {
       myprt<<std::setw(6)<<tj.mcpListIndex;
     }
     myprt<<std::setw(7)<<tj.WorkID;
     for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(tj.AlgMod[ib]) myprt<<" "<<AlgBitNames[ib];
     myprt<<"\n";
   } // PrintT

void tca::PrintTp3	(	std::string	someText,
		TCSlice &	slc,
		const TrajPoint3 &	tp3
	)

Definition at line 3041 of file PFPUtils.cxx.

References tca::TrajPoint3::Dir, tca::TrajPoint3::Pos, PrintPos(), tca::TrajPoint3::Tj2Pts, and tca::TCSlice::tjs.

Referenced by DotProd(), and SetStart().

   {
     mf::LogVerbatim myprt("TC");
     myprt<<someText<<" Pos"<<std::fixed<<std::setprecision(1);
     myprt<<std::setw(6)<<tp3.Pos[0]<<std::setw(6)<<tp3.Pos[1]<<std::setw(6)<<tp3.Pos[2];
     myprt<<" Dir"<<std::fixed<<std::setprecision(3);
     myprt<<std::setw(7)<<tp3.Dir[0]<<std::setw(7)<<tp3.Dir[1]<<std::setw(7)<<tp3.Dir[2];
     myprt<<" tj_ipt";
     for(auto tj2pt : tp3.Tj2Pts) {
       auto& tj = slc.tjs[tj2pt.id - 1];
       auto& tp = tj.Pts[tj2pt.ipt];
       myprt<<" "<<tj.ID<<"_"<<PrintPos(slc, tp);
     } // tj2pt
   } // PrintTp3

void tca::PrintTp3s	(	std::string	someText,
		TCSlice &	slc,
		const PFPStruct &	pfp,
		short	printPts
	)

Definition at line 3057 of file PFPUtils.cxx.

References DeltaAngle(), tca::PFPStruct::Dir, tca::PFPStruct::ID, KinkAngle(), PosSep(), PrintPos(), tca::TCSlice::tjs, tca::PFPStruct::Tp3s, and tca::PFPStruct::XYZ.

Referenced by DotProd().

   {
     if(pfp.Tp3s.empty()) return;
     mf::LogVerbatim myprt("TC");
     if(printPts < 0) {
       // print the head if we are print all points
       myprt<<someText<<" pfp P"<<pfp.ID<<"\n";
       myprt<<someText<<"  ipt ________Pos________ Path   ________Dir_______ along trans  dang  Kink  Tj_ipt \n";
     }
     // print the start
     myprt<<someText<<"    ";
     myprt<<std::fixed<<std::setprecision(1);
     myprt<<std::setw(7)<<pfp.XYZ[0][0]<<std::setw(7)<<pfp.XYZ[0][1]<<std::setw(7)<<pfp.XYZ[0][2];
     myprt<<"     ";
     myprt<<std::fixed<<std::setprecision(2);
     myprt<<std::setw(7)<<pfp.Dir[0][0]<<std::setw(7)<<pfp.Dir[0][1]<<std::setw(7)<<pfp.Dir[0][2];
     myprt<<" <--- pfp.XYZ[0] \n";
     
     unsigned short fromPt = 0;
     unsigned short toPt = pfp.Tp3s.size() - 1;
     if(printPts >= 0) fromPt = toPt;
     Vector3_t prevDir = pfp.Dir[0];
     for(unsigned short ipt = fromPt; ipt <= toPt; ++ipt) {
       auto tp3 = pfp.Tp3s[ipt];
       myprt<<someText<<std::setw(4)<<ipt;
       myprt<<std::fixed<<std::setprecision(1);
       myprt<<std::setw(7)<<tp3.Pos[0]<<std::setw(7)<<tp3.Pos[1]<<std::setw(7)<<tp3.Pos[2];
       myprt<<std::setprecision(1)<<std::setw(5)<<PosSep(tp3.Pos, pfp.XYZ[0]);
       myprt<<std::setprecision(2)<<std::setw(7)<<tp3.Dir[0]<<std::setw(7)<<tp3.Dir[1]<<std::setw(7)<<tp3.Dir[2];
       myprt<<std::setprecision(1)<<std::setw(6)<<tp3.AlongTrans[0];
       myprt<<std::setprecision(1)<<std::setw(6)<<tp3.AlongTrans[1];
       myprt<<std::setprecision(2)<<std::setw(7)<<DeltaAngle(prevDir, tp3.Dir);
       prevDir = tp3.Dir;
       // Calculate the kink angle at point ipt, using the two points that are
       // +/- 1 cm on either side of that point
       double sep = 1;
       myprt<<std::setprecision(2)<<std::setw(7)<<KinkAngle(slc, pfp.Tp3s, ipt, sep);
       for(auto tj2pt : tp3.Tj2Pts) {
         auto& tj = slc.tjs[tj2pt.id - 1];
         auto& tp = tj.Pts[tj2pt.ipt];
         myprt<<" "<<tj.ID<<"_"<<tj2pt.ipt<<"_"<<PrintPos(slc, tp);
       } // tj2pt
       myprt<<"\n";
     } // ipt
     // print the end
     myprt<<someText<<"    ";
     myprt<<std::fixed<<std::setprecision(1);
     myprt<<std::setw(7)<<pfp.XYZ[1][0]<<std::setw(7)<<pfp.XYZ[1][1]<<std::setw(7)<<pfp.XYZ[1][2];
     myprt<<"     ";
     myprt<<std::fixed<<std::setprecision(2);
     myprt<<std::setw(7)<<pfp.Dir[1][0]<<std::setw(7)<<pfp.Dir[1][1]<<std::setw(7)<<pfp.Dir[1][2];
     myprt<<" <--- pfp.XYZ[1]. Length "<<PosSep(pfp.XYZ[0], pfp.XYZ[1])<<"\n";
   } // PrintTp3s

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

Definition at line 5455 of file Utils.cxx.

Referenced by CheckHiMultUnusedHits(), CheckTraj(), ChkChgAsymmetry(), tca::TrajClusterAlg::ChkInTraj(), DotProd(), FixTrajEnd(), InTrajOK(), IsGhost(), MakeHaloTj(), MakeJunkTraj(), MaskedHitsOK(), MergeAndStore(), tca::TrajClusterAlg::ReconstructAllTraj(), StepAway(), and TrimEndPts().

   {
     // prints one or all trajectory points on tj
     
     int trupdg = 0;
 //    if(tj.mcpListIndex < evt.mcpList.size()) trupdg = evt.mcpList[tj.mcpListIndex]->PdgCode();
     
     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<<" TruPDG "<<trupdg<<" slc.vtxs "<<tj.VtxID[0]<<" "<<tj.VtxID[1]<<" nPts "<<tj.Pts.size()<<" EndPts "<<tj.EndPt[0]<<" "<<tj.EndPt[1];
         myprt<<" MCSMom "<<tj.MCSMom;
         myprt<<" StopFlags "<<PrintStopFlag(tj, 0)<<" "<<PrintStopFlag(tj, 1);
         myprt<<" AlgMod names:";
         for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(tj.AlgMod[ib]) myprt<<" "<<AlgBitNames[ib];
       } else {
         mf::LogVerbatim myprt("TC");
         myprt<<someText<<" ";
         myprt<<"slc.tjs: UID "<<tj.UID<<" WorkID "<<tj.WorkID<<" StepDir "<<tj.StepDir<<" PDG "<<tj.PDGCode<<" TruPDG "<<trupdg<<" slc.vtxs "<<tj.VtxID[0]<<" "<<tj.VtxID[1]<<" nPts "<<tj.Pts.size()<<" EndPts "<<tj.EndPt[0]<<" "<<tj.EndPt[1];
         myprt<<" MCSMom "<<tj.MCSMom;
         myprt<<" StopFlags "<<PrintStopFlag(tj, 0)<<" "<<PrintStopFlag(tj, 1);
         myprt<<" AlgMod names:";
         for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(tj.AlgMod[ib]) myprt<<" "<<AlgBitNames[ib];
       }
       PrintHeader(someText);
       for(unsigned short ipt = 0; ipt < tj.Pts.size(); ++ipt) PrintTrajPoint(someText, 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;
           } // tjIDA_Klystron_4U
           
           myprt<<"\n";
           myprt<<"NearTjIDs";
           for(auto& tjID : ss.NearTjIDs) {
             myprt<<" "<<tjID;
           } // tjID
           myprt<<"\n";
           myprt<<"\n";
           myprt<<"Angle "<<std::fixed<<std::setprecision(2)<<ss.Angle<<" +/- "<<ss.AngleErr;
           myprt<<" AspectRatio "<<std::fixed<<std::setprecision(2)<<ss.AspectRatio;
           myprt<<" DirectionFOM "<<std::fixed<<std::setprecision(2)<<ss.DirectionFOM;
           if(ss.ParentID > 0) {
             myprt<<" Parent Tj "<<ss.ParentID<<" FOM "<<ss.ParentFOM;
           } else {
             myprt<<" No parent";
           }
           myprt<<" TruParentID "<<ss.TruParentID<<" SS3ID "<<ss.SS3ID<<"\n";
           if(ss.NeedsUpdate) myprt<<"*********** This shower needs to be updated ***********";
           myprt<<"................................................";
         } // ic
       } // Shower Tj
     } else {
       // just print one traj point
       if(tPoint > tj.Pts.size() -1) {
         mf::LogVerbatim("TC")<<"Can't print non-existent traj point "<<tPoint;
         return;
       }
       PrintTrajPoint(someText, slc, tPoint, tj.StepDir, tj.Pass, tj.Pts[tPoint]);
     }
   } // PrintTrajectory

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

Definition at line 5541 of file Utils.cxx.

References tca::TCEvent::allHits, tca::TrajPoint::Ang, tca::TrajPoint::AngErr, tca::TrajPoint::AngleCode, tca::TrajPoint::AveChg, tca::TrajPoint::Chg, tca::TrajPoint::ChgPull, tca::TrajPoint::CTP, tca::TrajPoint::Delta, tca::TrajPoint::DeltaRMS, tca::TrajPoint::Dir, evt, tca::TrajPoint::FitChi, tca::TrajPoint::Hits, tca::TrajPoint::NTPsFit, tca::TrajPoint::Pos, tca::TCSlice::slHits, tca::TrajPoint::Step, tcc, tca::TCConfig::unitsPerTick, and tca::TrajPoint::UseHit.

Referenced by DotProd(), FillGaps(), FindVtxTjs(), FitVertex(), FixTrajBegin(), HiEndDelta(), PrintAllTraj(), PrintTrajectory(), SplitTrajCrossingVertices(), and StepAway().

   {
     mf::LogVerbatim myprt("TC");
     myprt<<someText<<" TRP"<<std::fixed;
     myprt<<pass;
     if(dir > 0) { myprt<<"+"; } else { myprt<<"-"; }
     myprt<<std::setw(6)<<tp.CTP;
     myprt<<std::setw(5)<<ipt;
     myprt<<std::setw(5)<<tp.Step;
     myprt<<std::setw(7)<<std::setprecision(1)<<tp.Pos[0]<<":"<<tp.Pos[1]/tcc.unitsPerTick; // W:T
     if(tp.Pos[1] < 10) { myprt<<"  "; }
     if(tp.Pos[1] < 100) { myprt<<" "; }
     if(tp.Pos[1] < 1000) { myprt<<" "; }
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.Delta;
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.DeltaRMS;
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.Ang;
     myprt<<std::setw(2)<<tp.AngleCode;
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.AngErr;
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.Dir[0];
     myprt<<std::setw(6)<<std::setprecision(2)<<tp.Dir[1];
     myprt<<std::setw(7)<<(int)tp.Chg;
     myprt<<std::setw(8)<<(int)tp.AveChg;
     myprt<<std::setw(6)<<std::setprecision(1)<<tp.ChgPull;
     myprt<<std::setw(7)<<tp.FitChi;
     myprt<<std::setw(6)<<tp.NTPsFit;
     // print the hits associated with this traj point
     if(tp.Hits.size() > 16) {
       // don't print too many hits (e.g. from a shower Tj)
       myprt<<" "<<tp.Hits.size()<<" shower hits";
     } else {
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         unsigned int iht = tp.Hits[ii];
         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<<slc.slHits[iht].InTraj;
       } // iht
     }
   } // PrintTrajPoint

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

Definition at line 2416 of file Utils.cxx.

References tca::Trajectory::AlgMod, kAllHits, kShowerTj, kUnusedHits, kUsedHits, and tca::Trajectory::Pts.

Referenced by AddLAHits(), CheckHiMultUnusedHits(), tca::TrajClusterAlg::ChkInTraj(), Finish3DShowers(), HasDuplicateHits(), InTrajOK(), tca::TruthMatcher::MatchAndSum(), MergeGhostTjs(), and TransferTjHits().

   {
     // Put hits in each trajectory point into a flat vector
     std::vector<unsigned int> hitVec;
     
     // special handling for shower trajectories. UseHit isn't valid
     if(tj.AlgMod[kShowerTj]) {
       for(auto& tp : tj.Pts) hitVec.insert(hitVec.end(), tp.Hits.begin(), tp.Hits.end());
       return hitVec;
     } // shower Tj
     
     // reserve under the assumption that there will be one hit per point
     hitVec.reserve(tj.Pts.size());
     for(unsigned short ipt = 0; ipt < tj.Pts.size(); ++ipt) {
       for(unsigned short ii = 0; ii < tj.Pts[ipt].Hits.size(); ++ii) {
         unsigned int iht = tj.Pts[ipt].Hits[ii];
         bool useit = (hitRequest == kAllHits);
         if(tj.Pts[ipt].UseHit[ii] && hitRequest == kUsedHits) useit = true;
         if(!tj.Pts[ipt].UseHit[ii] && hitRequest == kUnusedHits) useit = true;
         if(useit) hitVec.push_back(iht);
       } // iht
     } // ipt
     return hitVec;
   } // PutTrajHitsInVector

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

Definition at line 431 of file TCShower.cxx.

References AddPFP(), ChkAssns(), tca::TCSlice::cots, evd::details::end(), GetAssns(), GetSliceIndex(), tca::TCSlice::ID, InShowerProb(), kMat3D, MakeShowerObsolete(), MergeShowersAndStore(), tca::TCSlice::pfps, Print2DShowers(), RemovePFP(), SetIntersection(), ShowerEnergy(), tca::TCSlice::showers, slices, ss, tca::TCSlice::tjs, and UpdateShower().

   {
     // 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(!MergeShowersAndStore(fcnLabel, slc, oss.ID, ss.ID, prt)) {
             std::cout<<fcnLabel<<" Merge failed\n";
           }
           if(!UpdateShower(fcnLabel, slc, oss, prt)) {
             std::cout<<fcnLabel<<" UpdateShower failed\n";
           }
           ss3.NeedsUpdate = true;
           if(!UpdateShower(fcnLabel, slc, ss3, prt)) {
             std::cout<<fcnLabel<<" UpdateShower failed\n";
           }
           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 580 of file TCShower.cxx.

References AddPFP(), evd::details::begin(), tca::ShowerStruct3D::ChgPos, ChkAssns(), tca::ShowerStruct3D::CotIDs, tca::TCSlice::cots, evd::details::end(), FarEnd(), GetAssns(), tca::ShowerStruct3D::ID, tca::TCSlice::ID, InShowerProb(), tca::TCSlice::pfps, PosSep(), Print2DShowers(), RemovePFP(), SetDifference(), ss, and UpdateShower().

Referenced by FindShowers3D(), and Match2DShowers().

   {
     // checks consistency between pfparticles, showers and tjs associated with ss3
     if(ss3.ID == 0) return false;
     // it isn't a failure if there is a 3D shower in two planes
     if(ss3.CotIDs.size() < 3) return true;
     std::string fcnLabel = inFcnLabel + ".R3D";
 
     if(prt) Print2DShowers("R3Di", 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);
           // Not sure if this can happen
 //          if(sDiff.size() > 1) {std::cout<<fcnLabel<<" sDiff size > 2. Is this possible?\n";}
           if(!sDiff.empty() && std::find(ss3.CotIDs.begin(), ss3.CotIDs.end(), sDiff[0]) == ss3.CotIDs.end()) continue;
           if(prt) {
             mf::LogVerbatim myprt("TC");
             myprt<<fcnLabel<<" 3S"<<ss3.ID<<" P"<<pfp.ID<<" ->";
             for(auto sid : PIn2S) myprt<<" 2S"<<sid;
             myprt<<" sDiff";
             for(auto sid : sDiff) myprt<<" 2S"<<sid;
           } // prt
           // missed a tj in a 2D shower so "add the PFP to the shower" and update it
           if(AddPFP(fcnLabel, slc, pfp.ID, ss3, true, prt)) {
             // Update the local copies
             oldSS3 = ss3;
             if(ss3.CotIDs.size() != oldSS.size()) {
               std::cout<<fcnLabel<<" Major failure...";
               return false;
             }
             for(unsigned short ii = 0; ii < ss3.CotIDs.size(); ++ii) oldSS[ii] = 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);
         float sep = PosSep(pfp.XYZ[nearEnd], ss3.ChgPos);
         if(prt) {
           mf::LogVerbatim myprt("TC");
           myprt<<fcnLabel<<" one occurrence: P"<<pfp.ID<<"_"<<nearEnd<<" closest to ChgPos";
           myprt<<" ChgPos "<<std::fixed<<std::setprecision(1)<<ss3.ChgPos[0]<<" "<<ss3.ChgPos[1]<<" "<<ss3.ChgPos[2];
           myprt<<" sep "<<sep;
           myprt<<" InShowerProb "<<prob;
         } // prt 
         if(sep < 30 && prob > 0.3 && AddPFP(fcnLabel, slc, pfp.ID, ss3, true, prt)) {
           if(prt) mf::LogVerbatim("TC")<<" AddPFP success";
         } else if(!RemovePFP(fcnLabel, slc, pfp, ss3, true, prt)) {
           std::cout<<"RemovePFP failed \n";
         }
       } // 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

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

Definition at line 1150 of file Utils.cxx.

References tca::Trajectory::ID, tca::Trajectory::Pts, and tca::TCSlice::slHits.

Referenced by FindVtxTjs(), MakeJunkTraj(), tca::TrajClusterAlg::ReconstructAllTraj(), and StoreTraj().

   {
     // Sets InTraj[] = 0 for all TPs in work. Called when abandoning work
     for(auto& tp : tj.Pts) {
       for(auto iht : tp.Hits) {
         if(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 1475 of file TCShower.cxx.

References tca::ShowerStruct3D::CotIDs, tca::TCSlice::cots, tca::PFPStruct::ID, tca::ShowerStruct3D::ID, tca::ShowerStruct3D::NeedsUpdate, RemoveTj(), ss, tca::PFPStruct::TjIDs, and UpdateShower().

Referenced by Reconcile3D().

   {
     // removes the tjs in the pfp from the ss3 2D showers and optionally update. This function only returns
     // false if there was a failure. The absence of any pfp Tjs in ss3 is not considered a failure
 
     if(pfp.ID == 0 || ss3.ID == 0) return false;
 
     std::string fcnLabel = inFcnLabel + ".RemP";
     for(auto tid : pfp.TjIDs) {
       for(auto cid : ss3.CotIDs) {
         auto& ss = 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 1620 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::ShowerStruct::ID, kShwrParent, MakeShowerObsolete(), tca::ShowerStruct::NeedsUpdate, tca::ShowerStruct::ParentID, tca::ShowerStruct::ShPts, tca::Trajectory::SSID, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, and UpdateShower().

Referenced by RemovePFP().

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

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

Definition at line 1933 of file Utils.cxx.

References kKilled, tca::TCSlice::slHits, and tca::TCSlice::tjs.

   {
     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::Reverse3DMatchTjs	(	TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt
	)

Definition at line 1078 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::PFPStruct::dEdx, tca::PFPStruct::dEdxErr, tca::PFPStruct::Dir, tca::PFPStruct::DirErr, kBragg, kMat3D, tca::PFPStruct::PDGCode, ReverseTraj(), tca::PFPStruct::TjIDs, tca::TCSlice::tjs, tca::PFPStruct::Vx3ID, and tca::PFPStruct::XYZ.

   {
     // Return true if the 3D matched hits in the trajectories in slc.pfps are in the wrong order in terms of the
     // physics standpoint, e.g. dQ/dx, muon delta-ray tag, cosmic rays entering the detector, etc. 
     
     // Don't reverse showers
     if(pfp.PDGCode == 1111) return;
     
     bool reverseMe = false;
 
     // look for stopping Tjs for contained PFParticles
     if(!reverseMe) {
       unsigned short braggCnt0 = 0;
       unsigned short braggCnt1 = 0;
       for(auto& tjID : pfp.TjIDs) {
         auto& tj = slc.tjs[tjID - 1];
         if(tj.StopFlag[0][kBragg]) ++braggCnt0;
         if(tj.StopFlag[1][kBragg]) ++braggCnt1;
       }
       if(braggCnt0 > 0 || braggCnt1 > 0) {
         pfp.PDGCode = 2212;
         // Vote for a Bragg peak at the beginning. It should be at the end
         if(braggCnt0 > braggCnt1) reverseMe = true;
       } // found a Bragg Peak 
     } // look for stopping Tjs 
     
     if(!reverseMe) return;
     
     // All of the trajectories should be reversed
     for(auto& tjID : pfp.TjIDs) {
       unsigned short itj = tjID - 1;
       Trajectory& tj = slc.tjs[itj];
       tj.AlgMod[kMat3D] = false;
       ReverseTraj(slc, tj);
       tj.AlgMod[kMat3D] = true;
     } // tjID
     // swap the matchVec end info also
     std::swap(pfp.XYZ[0], pfp.XYZ[1]);
     std::swap(pfp.Dir[0], pfp.Dir[1]);
     std::swap(pfp.DirErr[0], pfp.DirErr[1]);
     std::swap(pfp.dEdx[0], pfp.dEdx[1]);
     std::swap(pfp.dEdxErr[0], pfp.dEdxErr[1]);
     std::swap(pfp.Vx3ID[0], pfp.Vx3ID[1]);
     
     return;
     
   } // Reverse3DMatchTjs

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

Definition at line 2935 of file PFPUtils.cxx.

References tca::PFPStruct::dEdx, tca::PFPStruct::dEdxErr, tca::PFPStruct::Dir, tca::PFPStruct::DirErr, tca::PFPStruct::Tp3s, tca::PFPStruct::Vx3ID, and tca::PFPStruct::XYZ.

Referenced by DotProd(), and StitchPFPs().

   {
     std::swap(pfp.XYZ[0], pfp.XYZ[1]);
     std::swap(pfp.Dir[0], pfp.Dir[1]);
     for(unsigned short xyz = 0; xyz < 3; ++xyz) {
       pfp.Dir[0][xyz] *= -1;
       pfp.Dir[1][xyz] *= -1;
     }
     std::swap(pfp.DirErr[0], pfp.DirErr[1]);
     std::swap(pfp.dEdx[0], pfp.dEdx[1]);
     std::swap(pfp.dEdxErr[0], pfp.dEdxErr[1]);
     std::swap(pfp.Vx3ID[0], pfp.Vx3ID[1]);
     std::reverse(pfp.Tp3s.begin(), pfp.Tp3s.end());
     for(auto& tp3 : pfp.Tp3s) {
       for(unsigned short xyz = 0; xyz < 3; ++xyz) {
         tp3.Dir[xyz] *= -1;
         tp3.Dir[xyz] *= -1;
       } // xyz
     } // tp3
   } // ReversePFP

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

Definition at line 1414 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, ChkStop(), ChkStopEndPts(), tca::Trajectory::CTP, tca::TCConfig::dbgAlg, tca::TCConfig::dbgStp, DecodeCTP(), tca::Trajectory::EndPt, FindCloseHits(), tca::TCSlice::firstWire, tca::TrajPoint::Hits, tca::Trajectory::ID, tca::Trajectory::IsGood, kNormal, kRvPrp, kUnusedHits, tca::TCSlice::lastWire, MoveTPToWire(), geo::PlaneID::Plane, PrintHit(), PrintPos(), tca::Trajectory::Pts, ReverseTraj(), SetEndPoints(), tca::TCSlice::slHits, StepAway(), tca::Trajectory::StepDir, tca::Trajectory::Strategy, tcc, tca::TCConfig::useAlg, tca::TrajPoint::UseHit, and tca::TCSlice::wireHitRange.

Referenced by FixTrajBegin().

   {
     // 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]);
     
     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 EndPt 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(slc.wireHitRange[ipl][nextWire].first >= 0) 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
     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 copy, 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);
     if(prt) {
       mf::LogVerbatim("TC")<<" ReversePropagate success. Outgoing StepDir "<<tj.StepDir;
 //      if(tj.Pts.size() < 50) PrintTrajectory("RP", slc, tj, USHRT_MAX);
     }
     
   } // ReversePropagate

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

Definition at line 3201 of file TCShower.cxx.

References tca::ShowerStruct::Angle, DefineEnvelope(), tca::ShowerStruct::DirectionFOM, tca::ShowerStruct::ID, ReverseTraj(), tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::ShPts, tca::ShowerStruct::TjIDs, and tca::TCSlice::tjs.

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

References tca::TCSlice::cots, tca::ShowerStruct::ID, and ss.

Referenced by FindShowerStart(), and UpdateShower().

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

References tca::Trajectory::dEdx, tca::Trajectory::DirFOM, tca::Trajectory::ID, tca::Trajectory::Pts, SetEndPoints(), tca::Trajectory::StartEnd, tca::Trajectory::StepDir, tca::Trajectory::StopFlag, UpdateMatchStructs(), and tca::Trajectory::VtxID.

Referenced by DefineTjParents(), EndMerge(), MergeAndStore(), MergePFPTjs(), Reverse3DMatchTjs(), ReversePropagate(), ReverseShower(), StorePFP(), and TagDeltaRays().

   {
     // reverse the trajectory
     if(tj.Pts.empty()) return;
     // reverse the crawling direction flag
     tj.StepDir = -tj.StepDir;
     tj.DirFOM = 1 - tj.DirFOM;
     // Vertices
     std::swap(tj.VtxID[0], tj.VtxID[1]);
     // trajectory points
     std::reverse(tj.Pts.begin(), tj.Pts.end());
     // reverse the stop flag
     std::reverse(tj.StopFlag.begin(), tj.StopFlag.end());
     std::swap(tj.dEdx[0], tj.dEdx[1]);
     // reverse the direction vector on all points
     for(unsigned short ipt = 0; ipt < tj.Pts.size(); ++ipt) {
       if(tj.Pts[ipt].Dir[0] != 0) tj.Pts[ipt].Dir[0] = -tj.Pts[ipt].Dir[0];
       if(tj.Pts[ipt].Dir[1] != 0) tj.Pts[ipt].Dir[1] = -tj.Pts[ipt].Dir[1];
       if(tj.Pts[ipt].Ang > 0) {
         tj.Pts[ipt].Ang -= M_PI;
       } else {
         tj.Pts[ipt].Ang += M_PI;
       }
     } // ipt
     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 165 of file TCShTree.cxx.

References tca::TCSlice::cots, kSaveShowerTree, tca::TCConfig::modes, SaveTjInfo(), ss, and tcc.

Referenced by FindShowers3D().

                                                                          {
     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 176 of file TCShTree.cxx.

References tca::TCSlice::cots, kSaveShowerTree, tca::TCConfig::modes, SaveTjInfo(), ss, and tcc.

                                                      {
     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	(	TCSlice &	slc,
		PFPStruct &	pfp,
		bool	prt,
		bool	fIsRealData
	)

Definition at line 8 of file TCCR.cxx.

References tca::PFPStruct::CosmicScore, tca::CRTreeVars::cr_origin, tca::CRTreeVars::cr_pfpxmax, tca::CRTreeVars::cr_pfpxmin, tca::CRTreeVars::cr_pfpyzmindis, tca::TCSlice::crt, tca::TCConfig::geom, GetOrigin(), kSaveCRTree, max, geo::BoxBoundedGeo::MaxY(), geo::BoxBoundedGeo::MaxZ(), min, geo::BoxBoundedGeo::MinY(), geo::BoxBoundedGeo::MinZ(), tca::TCConfig::modes, tcc, geo::GeometryCore::TPC(), and tca::PFPStruct::XYZ.

                                                                            {
 
     //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(slc, pfp));
       }
     }
 
     // save the xmin and xmax of each pfp
     slc.crt.cr_pfpxmin.push_back(std::min(pfp.XYZ[0][0], pfp.XYZ[1][0]));
     slc.crt.cr_pfpxmax.push_back(std::max(pfp.XYZ[0][0], pfp.XYZ[1][0]));
 
     //find max 
     const geo::TPCGeo &tpc = tcc.geom->TPC(0);
     float mindis0 = FLT_MAX;
     float mindis1 = FLT_MAX;
     if (std::abs(pfp.XYZ[0][1] - tpc.MinY())<mindis0) mindis0 = std::abs(pfp.XYZ[0][1] - tpc.MinY());
     if (std::abs(pfp.XYZ[0][1] - tpc.MaxY())<mindis0) mindis0 = std::abs(pfp.XYZ[0][1] - tpc.MaxY());
     if (std::abs(pfp.XYZ[0][2] - tpc.MinZ())<mindis0) mindis0 = std::abs(pfp.XYZ[0][2] - tpc.MinZ());
     if (std::abs(pfp.XYZ[0][2] - tpc.MaxZ())<mindis0) mindis0 = std::abs(pfp.XYZ[0][2] - tpc.MaxZ());
     if (std::abs(pfp.XYZ[1][1] - tpc.MinY())<mindis1) mindis1 = std::abs(pfp.XYZ[1][1] - tpc.MinY());
     if (std::abs(pfp.XYZ[1][1] - tpc.MaxY())<mindis1) mindis1 = std::abs(pfp.XYZ[1][1] - tpc.MaxY());
     if (std::abs(pfp.XYZ[1][2] - tpc.MinZ())<mindis1) mindis1 = std::abs(pfp.XYZ[1][2] - tpc.MinZ());
     if (std::abs(pfp.XYZ[1][2] - tpc.MaxZ())<mindis1) mindis1 = std::abs(pfp.XYZ[1][2] - tpc.MaxZ());
     //std::cout<<pfp.XYZ[0][1]<<" "<<pfp.XYZ[0][2]<<" "<<pfp.XYZ[1][1]<<" "<<pfp.XYZ[1][2]<<" "<<tpc.MinY()<<" "<<tpc.MaxY()<<" "<<tpc.MinZ()<<" "<<tpc.MaxZ()<<" "<<mindis0<<" "<<mindis1<<" "<<mindis0+mindis1<<std::endl;
     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;
 
     /*
     float minx = FLT_MAX;
     float maxx = FLT_MIN;
 
     for(auto& tjID : pfp.TjIDs) {
       Trajectory& tj = slc.allTraj[tjID - 1];
       TrajPoint& beginPoint = tj.Pts[tj.EndPt[0]];
       TrajPoint& endPoint = tj.Pts[tj.EndPt[1]];
       if (beginPoint.Pos[1]/slc.unitsPerTick<minx){
         minx = beginPoint.Pos[1]/slc.unitsPerTick;
       }
       if (beginPoint.Pos[1]/slc.unitsPerTick>maxx){
         maxx = beginPoint.Pos[1]/slc.unitsPerTick;
       }
       if (endPoint.Pos[1]/slc.unitsPerTick<minx){
         minx = endPoint.Pos[1]/slc.unitsPerTick;
       }
       if (endPoint.Pos[1]/slc.unitsPerTick>maxx){
         maxx = endPoint.Pos[1]/slc.unitsPerTick;
       }
     } // tjID
 
     slc.crt.cr_pfpmintick.push_back(minx);
     slc.crt.cr_pfpmaxtick.push_back(maxx);
     */
 //    std::cout<<pfp.mcpListIndex<<std::endl;
 //    std::cout<<pfp.XYZ[0][0]<<" "<<pfp.XYZ[1][0]<<std::endl;
 
   }

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

Definition at line 5 of file TCShTree.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::CTP, tca::ShowerTreeVars::Envelope, tca::ShowerTreeVars::EnvPlane, tca::ShowerTreeVars::EnvShowerID, tca::ShowerTreeVars::EnvStage, GetStageNum(), tca::Trajectory::ID, kKilled, kSaveShowerTree, tca::TCConfig::modes, SaveTjInfoStuff(), tca::ShowerTreeVars::ShowerID, stv, tcc, and tca::TCSlice::tjs.

Referenced by FindShowers3D(), and SaveAllCots().

                                        {
     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 47 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 131 of file TCShTree.cxx.

Referenced by SaveTjInfo().

                                                                                         {
     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 2391 of file TCVertex.cxx.

References kHaloTj, kHiVx3Score, kKilled, kTjHiVx3Score, SetVx2Score(), SetVx3Score(), tca::TCSlice::tjs, tca::TCSlice::vtx3s, and tca::TCSlice::vtxs.

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

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

void tca::SetAngleCode ( TrajPoint & tp )

Definition at line 722 of file Utils.cxx.

References tca::TrajPoint::Ang, tca::TrajPoint::AngleCode, AngleRange(), tca::TCConfig::angleRanges, and tcc.

Referenced by FitTraj(), MakeJunkTraj(), StartTraj(), and UpdateTraj().

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

Referenced by DefinePFPParentsTestBeam(), DotProd(), Match3DVtxTjs(), and Reconcile3D().

   {
     // returns the elements of set1 and set2 that are different
     std::vector<T> different;
     if(set1.empty() && set2.empty()) return different;
     if(!set1.empty() && set2.empty()) return set1;
     if(set1.empty() && !set2.empty()) return set2;
     for(auto element1 : set1) {
       // check for a common element
       if(std::find(set2.begin(), set2.end(), element1) != set2.end()) continue;
       // check for a duplicate
       if(std::find(different.begin(), different.end(), element1) != different.end()) continue;
       different.push_back(element1);
     } // element1
     for(auto element2 : set2) {
       // check for a common element
       if(std::find(set1.begin(), set1.end(), element2) != set1.end()) continue;
       // check for a duplicate
       if(std::find(different.begin(), different.end(), element2) != different.end()) continue;
       different.push_back(element2);
     } // element1
     return different;
   } // SetDifference

void tca::SetEndPoints ( Trajectory & tj )

Definition at line 2864 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::EndPt, kHaloTj, kShowerTj, and tca::Trajectory::Pts.

Referenced by AddHits(), AddLAHits(), CheckHiMultEndHits(), CheckHiMultUnusedHits(), CheckTraj(), ChkChgAsymmetry(), ChkStopEndPts(), DotProd(), FindSoftKink(), FixTrajBegin(), Forecast(), IsGhost(), MakeJunkTraj(), MaskedHitsOK(), MaskTrajEndPoints(), MergeAndStore(), MergePFPTjs(), ReversePropagate(), ReverseTraj(), SplitHiChgHits(), SplitTraj(), StepAway(), StoreTraj(), TrimEndPts(), UpdateTraj(), and VtxHitsSwap().

   {
     // 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 2436 of file TCVertex.cxx.

References evd::details::end(), GetVtxTjIDs(), tca::VtxStore::ID, tca::Vtx3Store::ID, kHiVx3Score, kTjHiVx3Score, tca::TCSlice::nPlanes, tca::VtxStore::Stat, tca::TCSlice::tjs, tmp, tca::TCSlice::vtxs, and tca::Vtx3Store::Vx2ID.

Referenced by SetVx3Score().

   {
     // Sets the tj and 2D vertex score bits to true 
     
     if(vx3.ID == 0) return;
     
     for(unsigned short ipl = 0; ipl < 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 231 of file Utils.h.

Referenced by AddMissedTj(), CompleteIncompleteShower(), DefinePFP(), DotProd(), FindCots(), FindPFParticles(), GetAssns(), Match3DVtxTjs(), tca::TruthMatcher::MatchAndSum(), MergeNearby2DShowers(), PFPVxTjOK(), Reconcile3D(), and SharesHighScoreVx().

   {
     // returns a vector containing the elements of set1 and set2 that are common. This function
     // is a replacement for std::set_intersection which fails in the following situation:
     // set1 = {11 12 17 18} and set2 = {6 12 18}
     // There is no requirement that the elements be sorted, unlike std::set_intersection
     std::vector<T> shared;
     
     if(set1.empty()) return shared;
     if(set2.empty()) return shared;
     for(auto element1 : set1) {
       // check for a common element
       if(std::find(set2.begin(), set2.end(), element1) == set2.end()) continue;
       // check for a duplicate
       if(std::find(shared.begin(), shared.end(), element1) != shared.end()) continue;
       shared.push_back(element1);
     } // element1
     return shared;
   } // SetIntersection

bool tca::SetMag	(	Vector3_t &	v1,
		double	mag
	)

Definition at line 1670 of file PFPUtils.cxx.

References den.

Referenced by DotProd(), FindAlongTrans(), Fit3D(), FollowTp3s(), PointDirection(), and UpdateShower().

   {
     double den = v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2];
     if(den == 0) return false;
     den = sqrt(den);
     
     v1[0] *= mag / den;
     v1[1] *= mag / den;
     v1[2] *= mag / den;
     return true;
   } // SetMag

bool tca::SetMag	(	Vector2_t &	v1,
		double	mag
	)

Definition at line 2805 of file Utils.cxx.

References den.

Referenced by FindAlongTrans().

   {
     double den = v1[0] * v1[0] + v1[1] * v1[1];
     if(den == 0) return false;
     den = sqrt(den);
     
     v1[0] *= mag / den;
     v1[1] *= mag / den;
     return true;
   } // SetMag

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

Definition at line 1919 of file TCShower.cxx.

References AddTj(), tca::ShowerStruct3D::ChgPos, tca::ShowerStruct3D::CotIDs, tca::TCSlice::cots, tca::PFPStruct::Dir, evd::details::end(), FarEnd(), GetAssns(), tca::PFPStruct::ID, tca::ShowerStruct3D::ID, tca::TCSlice::ID, kShwrParent, MakeBareTP(), ParentFOM(), tca::ShowerStruct3D::ParentID, ss, tca::PFPStruct::TjIDs, tca::TCSlice::tjs, UpdateShower(), tca::TCSlice::vtx3s, tca::PFPStruct::Vx3ID, tca::ShowerStruct3D::Vx3ID, and tca::PFPStruct::XYZ.

Referenced by FindParent().

   {
     // set the pfp as the parent of ss3. The calling function should do the error recovery
     if(pfp.ID == 0 || ss3.ID == 0) return false;
     if(ss3.CotIDs.empty()) return false;
     
     std::string fcnLabel = inFcnLabel + ".SP";
     
     for(auto cid : ss3.CotIDs) {
       auto& ss = 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 
         unsigned short pEnd = FarEnd(slc, pfp, ss3.ChgPos);
         auto tp = MakeBareTP(slc, pfp.XYZ[0], pfp.Dir[pEnd], tj.CTP);
         unsigned short npts = tj.EndPt[1] - tj.EndPt[0] + 1;
         if(tp.Delta > 0.5 || npts > 20) {
           if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" parent P"<<pfp.ID<<" -> T"<<tjid<<" -> 2S"<<ss.ID<<" parent";
         } else {
           if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 3S"<<ss3.ID<<" parent P"<<pfp.ID<<" -> T"<<tjid<<" low projection in plane "<<tp.Delta<<". Not a parent";
           continue;
         }
         ss.ParentID = tjid;
         ss.NeedsUpdate = true;
         // set the ss start vertex
         if(ss3.Vx3ID > 0) {
           auto& vx3 = 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,
		bool	tjDone
	)

Definition at line 3795 of file Utils.cxx.

References SetPDGCode(), and tca::TCSlice::tjs.

Referenced by CompleteIncomplete3DVertices(), DotProd(), FindHammerVertices(), FindHammerVertices2(), MergePFPTjs(), and StepAway().

   {
     if(itj > slc.tjs.size() - 1) return;
     SetPDGCode(slc, slc.tjs[itj], tjDone);
   }

void tca::SetPDGCode	(	TCSlice &	slc,
		Trajectory &	tj,
		bool	tjDone
	)

Definition at line 3802 of file Utils.cxx.

References tca::Trajectory::ID, kStiffEl, kStiffMu, tca::Trajectory::MCSMom, tca::TCConfig::muonTag, NumPtsWithCharge(), tca::Trajectory::PDGCode, tca::Trajectory::Strategy, and tcc.

Referenced by MergeAndStore(), SetPDGCode(), and SplitTraj().

   {
     // Sets the PDG code for the supplied trajectory. Note that the existing
     // PDG code is left unchanged if these cuts are not met
         
     short npwc = NumPtsWithCharge(slc, tj, false);
     if(npwc < 6) {
       tj.PDGCode = 0;
       return;
     }
     
     if(tj.Strategy[kStiffEl]) {
       tj.PDGCode = 111;
       return;
     }
     if(tj.Strategy[kStiffMu]) {
       tj.PDGCode = 13;
       return;
     }
     
 //    tj.PDGCode = 0;
     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(tj.PDGCode != 0 && tj.PDGCode != 13 && isAMuon) {
       std::cout<<"T"<<tj.ID<<" changing PDGCode from "<<tj.PDGCode<<" to 13. Is this wise?\n";
     }
     if(isAMuon) tj.PDGCode = 13;
     
   } // SetPDGCode

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

Definition at line 351 of file PFPUtils.cxx.

References tca::PFPStruct::Dir, tca::PFPStruct::ID, PrintTp3(), tca::PFPStruct::TjIDs, tca::PFPStruct::Tp3s, valIncreasings(), and tca::PFPStruct::XYZ.

Referenced by DefinePFP().

   {
     // Analyzes the space point collection and the Tjs in the pfp to find a new start
     // position. The Tp3s found in FindCompleteness are ordered by increasing X. The general direction 
     // pfp.Dir[0] and the average position of all points in Tp3s was stored in pfp.XYZ[0]. This function
     // rotates each tp3 into this coordinate system to determine (along, trans) for each point. The min (max)
     // value of along defines the start (end) of the trajectory.
     
     if(pfp.ID <= 0 || pfp.TjIDs.empty()) return false;
     if(pfp.Tp3s.size() < 2) return false;
 
     // The projection along the general direction relative to the average position was found
     // in FillCompleteness. Now 
     float minAlong = 1E6;
     unsigned short minPt = 0;
     float maxAlong = -1E6;
     unsigned short maxPt = 0;
     std::vector<SortEntry> sortVec(pfp.Tp3s.size());
     for(unsigned short ipt = 0; ipt < pfp.Tp3s.size(); ++ipt) {
       auto& tp3 = pfp.Tp3s[ipt];
       sortVec[ipt].index = ipt;
       sortVec[ipt].val = tp3.AlongTrans[0];
       // find the min (max) 
       if(tp3.AlongTrans[0] < minAlong) {
         minAlong = tp3.AlongTrans[0];
         minPt = ipt;
       }
       if(tp3.AlongTrans[0] > maxAlong) {
         maxAlong = tp3.AlongTrans[0];
         maxPt = ipt;
       }
     } // tp3
     
     pfp.XYZ[0] = pfp.Tp3s[minPt].Pos;
     pfp.XYZ[1] = pfp.Tp3s[maxPt].Pos;
 
     if(prt) {
       mf::LogVerbatim("TC")<<"SNS: P"<<pfp.ID<<" minPt "<<minPt<<" maxPt "<<maxPt<<" dir "<<std::fixed<<std::setprecision(2)<<pfp.Dir[0][0]<<" "<<pfp.Dir[0][1]<<" "<<pfp.Dir[0][2];
       PrintTp3("minPt", slc, pfp.Tp3s[minPt]);
       PrintTp3("maxPt", slc, pfp.Tp3s[maxPt]);
     }
     
     std::sort(sortVec.begin(), sortVec.end(), valIncreasings);
     // put them into order
     std::vector<TrajPoint3> temp;
     for(unsigned short ii = 0; ii < sortVec.size(); ++ii) temp.push_back(pfp.Tp3s[sortVec[ii].index]);
     pfp.Tp3s = temp;
 //    PrintTp3s("SNS", slc, pfp, -1);
 
     return true;
     
   } // SetStart

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

Definition at line 303 of file StepUtils.cxx.

References ChgSlope(), tca::TCConfig::dbgStp, tca::Trajectory::EndPt, kSlowing, kStiffEl, kStiffMu, tca::Trajectory::MCSMom, NumPtsWithCharge(), tca::Trajectory::Pts, tca::Trajectory::StartEnd, tca::Trajectory::Strategy, tcc, and tjfs.

Referenced by StepAway().

   {
     // 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);
     bool tkLike = (tjf.outlook < 1.5);
     // A showering-electron-like trajectory
     bool shLike = (tjf.outlook > 2 && tjf.chgSlope > 0);
     // This cut picks up a 240 MeV electron
     if(!shLike) shLike = tjf.showerLikeFraction > 0.4;
     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<<" showerLike? "<<shLike;
       myprt<<" leavesBeforeEnd? "<<tjf.leavesBeforeEnd<<" endBraggPeak? "<<tjf.endBraggPeak; 
     }
     if(tjf.outlook < 0) return;
     // Look for a long clean muon in the forecast
     if(tkLike && tj.MCSMom > 200 && tjf.MCSMom > 800 && tjf.nextForecastUpdate > 50 && tjf.chgFitChiDOF < 10) {
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"SetStrategy: 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) {
       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;
     } // tracklike with > 1 forecast
     if(notStiff && tkLike && tj.MCSMom < 200 && momRat < 0.7) {
       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;
     } // tracklike with > 1 forecast
     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(npwc > 100 && tkLike && tjf.leavesBeforeEnd) {
       // 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;
     }
     // 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) {
       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;
     }
     // A curvy trajectory (not nessecarily track-like) with a consistent increase in charge
     if(tkLike && tjf.MCSMom < 100 && !tjf.leavesBeforeEnd) {
       // find the charge slope of the trajectory
       float chgSlope, chgSlopeErr, chiDOF;
       ChgSlope(slc, tj, chgSlope, chgSlopeErr, chiDOF);
       // a significant increase in the charge in the reconstructed tj, which continues in the
       // forecase polygon. TODO: use chgSlopeErr?
       if(chgSlope > 3 * chgSlopeErr && (tjf.chgSlope > 3 * tjf.chgSlopeErr)) {
         tj.Strategy.reset();
         tj.Strategy[kSlowing] = true;
         lastTP.NTPsFit = 5;
       }
       if(tcc.dbgStp) mf::LogVerbatim("TC")<<"SetStrategy: Curvy? tj chgSlope "<<chgSlope<<" +/ "<<chgSlopeErr<<" forecast chgSlope "<<tjf.chgSlope<<" +/- "<<tjf.chgSlopeErr<<" Slowing? "<<tj.Strategy[kSlowing];
     } // Slowing
   } // SetStrategy

void tca::SetVx2Score ( TCSlice & slc )

Definition at line 2504 of file TCVertex.cxx.

References tca::TCSlice::vtxs.

Referenced by AttachTrajToVertex(), CheckTrajBeginChg(), CompleteIncomplete3DVertices(), CompleteIncomplete3DVerticesInGaps(), EndMerge(), Find2DVertices(), Find3DVertices(), FindHammerVertices(), FindHammerVertices2(), MergeWithVertex(), ScoreVertices(), and SplitHiChgHits().

   {
     // 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 2513 of file TCVertex.cxx.

References tca::Trajectory::AlgMod, ChgFracNearPos(), tca::Trajectory::ChgRMS, tca::VtxStore::CTP, tca::TCConfig::dbg2V, tca::TCConfig::dbgSlc, debug, DecodeCTP(), DeltaAngle(), tca::Trajectory::EndPt, GetVtxTjIDs(), tca::VtxStore::ID, kBragg, kJunkTj, kNewVtxCuts, kShowerLike, kShowerTj, tca::Trajectory::MCSMom, tca::Trajectory::PDGCode, tca::DebugStuff::Plane, geo::PlaneID::Plane, tca::VtxStore::Pos, tca::VtxStore::PosErr, tca::Trajectory::Pts, tca::VtxStore::Score, tca::Trajectory::StopFlag, tcc, tca::VtxStore::TjChgFrac, tca::TCSlice::tjs, tca::VtxStore::Topo, tca::TCConfig::useAlg, tca::TCConfig::vtx2DCuts, tca::TCSlice::vtx3s, tca::Trajectory::VtxID, tca::TCConfig::vtxScoreWeights, and tca::VtxStore::Vx3ID.

   {
     // Calculate the 2D vertex score
     if(vx2.ID == 0) return;
     
     // Don't score vertices from CheckTrajBeginChg, MakeJunkVertices or Neutral vertices. Set to the minimum
     if(vx2.Topo == 8 || vx2.Topo == 9 || vx2.Topo == 11) {
       vx2.Score = 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;
       if(!tcc.useAlg[kNewVtxCuts] && wght > 10) wght = 10;
       // weight by the first tagged muon
       if(tj.PDGCode == 13) {
         ++cnt13;
         if(tcc.useAlg[kNewVtxCuts] && 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.StopFlag[oend1][kBragg]) ++wght1;
       float ang1 = tj1.Pts[endPt1].Ang;
       float ang1Err2 = tj1.Pts[endPt1].AngErr * tj1.Pts[endPt1].AngErr;
       for(unsigned short it2 = it1 + 1; it2 < tjids.size(); ++it2) {
         Trajectory& tj2 = 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.StopFlag[oend2][kBragg]) ++wght2;
         unsigned short endPt2 = tj2.EndPt[end2];
         float ang2 = tj2.Pts[endPt2].Ang;
         float ang2Err2 = tj2.Pts[endPt2].AngErr * tj2.Pts[endPt2].AngErr;
         float dang = DeltaAngle(ang1, ang2);
         float dangErr = 0.5 * sqrt(ang1Err2 + ang2Err2);
         if((dang / dangErr) > 3 && wght1 > 0 && wght2 > 0) {
           sum += wght1 + wght2;
           ++cnt;
         }
       } // it2
     } // it1
     if(cnt > 0) {
       sum /= cnt;
       tjScore = tcc.vtxScoreWeights[3] * sum;
     }
     vx2.Score = vpeScore + m3DScore + cfScore + tjScore;
     if(tcc.dbg2V && tcc.dbgSlc && (int)DecodeCTP(vx2.CTP).Plane == debug.Plane) {
       // last call after vertices have been matched to the truth. Use to optimize vtxScoreWeights using
       // an ntuple
       mf::LogVerbatim myprt("TC");
       myprt<<" SVx2W 2v"<<vx2.ID;
 /*
       myprt<<" m3Dcnt "<<m3Dcnt;
       myprt<<" PosErr "<<std::fixed<<std::setprecision(2)<<(vx2.PosErr[0] + vx2.PosErr[1]);
       myprt<<" TjChgFrac "<<std::fixed<<std::setprecision(3)<<vx2.TjChgFrac;
       myprt<<" sum "<<std::fixed<<std::setprecision(1)<<sum;
       myprt<<" cnt "<<(int)cnt;
 */
       myprt<<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 2483 of file TCVertex.cxx.

References tca::Vtx3Store::ID, tca::TCSlice::nPlanes, tca::VtxStore::Score, tca::Vtx3Store::Score, SetHighScoreBits(), tcc, tca::TCConfig::vtx2DCuts, tca::TCSlice::vtxs, and tca::Vtx3Store::Vx2ID.

Referenced by Find3DVertices(), MakeVertexObsolete(), and ScoreVertices().

   {
     // Calculate the 3D vertex score and flag Tjs that are attached to high score vertices as defined 
     // by Vertex2DCuts 
     
     if(vx3.ID == 0) return;
     
     vx3.Score = 0;
     for(unsigned short ipl = 0; ipl < 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

bool tca::SharesHighScoreVx	(	TCSlice &	slc,
		const PFPStruct &	pfp,
		const Trajectory &	tj
	)

Definition at line 1026 of file PFPUtils.cxx.

References evd::details::end(), GetVtxTjIDs(), kHiVx3Score, SetIntersection(), tca::PFPStruct::TjIDs, tca::Trajectory::VtxID, and tca::TCSlice::vtxs.

Referenced by DefinePFP(), and FindMissedTjsInTp3s().

   {
     // returns true if tj with tjID shares a high-score 3D vertex with any
     // tj in pfp.TjIDs
     for(unsigned short end = 0; end < 2; ++end) {
       if(tj.VtxID[end] == 0) continue;
       auto& vx2 = slc.vtxs[tj.VtxID[end] - 1];
       if(!vx2.Stat[kHiVx3Score]) continue;
       std::vector<int> vtjlist = GetVtxTjIDs(slc, vx2);
       auto shared = SetIntersection(vtjlist, pfp.TjIDs);
       if(!shared.empty()) return true;
     } // end
     return false;
   } // SharesHighScoreVx

double tca::ShowerEnergy ( const ShowerStruct3D & ss3 )

Definition at line 4369 of file TCShower.cxx.

References e, tca::ShowerStruct3D::Energy, and tca::ShowerStruct3D::ID.

Referenced by showerreco::ShowerCalo::~ShowerCalo().

   {
     if(ss3.ID == 0) return 0;
     if(ss3.Energy.empty()) return 0;
     double ave = 0;
     for(auto e : ss3.Energy) {
       ave += e;
     } // e
     ave /= ss3.Energy.size();
     return ave;
   } // ShowerEnergy

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

Definition at line 4382 of file TCShower.cxx.

References ChgToMeV(), and tca::TCSlice::tjs.

Referenced by CompleteIncompleteShower(), FindCots(), FindParent(), FindShowers3D(), and Reconcile3D().

   {
     // Calculate energy using the total charge of all hits in each tj in the shower
     if(tjIDs.empty()) return 0;
     float sum = 0;
     for(auto tid : tjIDs) {
       auto& tj = slc.tjs[tid - 1];
       sum += tj.TotChg;
     } // tid
     return ChgToMeV(sum);
   } // ShowerEnergy

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

Definition at line 2015 of file TCShower.cxx.

References scale.

Referenced by FindParent(), InShowerProbLong(), MergeSubShowers(), ParentFOM(), and ShowerParamTransRMS().

   {
     // Returns summary properties of photon showers parameterized in the energy range 50 MeV < E_gamma < 1 GeV:
     // shMaxAlong = the longitudinal distance (cm) between the start of the shower and the center of charge
     // along95 = the longitudinal distance (cm) between the start of the shower and 95% energy containment
     // all units are in cm
     if(showerEnergy < 10) {
       shMaxAlong = 0;
       along95 = 0;
       return;
     }
 //    shMaxAlong = 7.0 * log(showerEnergy / 15);
     shMaxAlong = 16 * log(showerEnergy / 15);
     // The 95% containment is reduced a bit at higher energy
     double scale = 2.75 - 9.29E-4 * showerEnergy;
     if(scale < 2) scale = 2;
     along95 = scale * shMaxAlong;
   } // ShowerParams

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

Definition at line 2035 of file TCShower.cxx.

References ShowerParams().

Referenced by InShowerProbTrans().

   {
     // returns the pareameterized width rms of a shower at along relative to the shower max
     double shMaxAlong, shE95Along;
     ShowerParams(showerEnergy, shMaxAlong, shE95Along);
     if(shMaxAlong <= 0) return 0;
     double tau = (along + shMaxAlong) / shMaxAlong;
     // The shower width is modeled as a simple cone that scales with tau
     double rms = -0.4 + 2.5 * tau;
     if(rms < 0.5) rms = 0.5;
     return rms;
   } // ShowerParamTransRMS

bool tca::SignalAtTp	(	TCSlice &	slc,
		TrajPoint const &	tp
	)

bool tca::SignalAtTp	(	TCSlice &	slc,
		const TrajPoint &	tp
	)

Definition at line 1814 of file Utils.cxx.

References tca::TCEvent::allHits, tca::TrajPoint::CTP, DecodeCTP(), tca::TrajPoint::Dir, evt, tca::TCConfig::maxPos1, tca::TCSlice::nWires, geo::PlaneID::Plane, tca::TrajPoint::Pos, tca::TCSlice::slHits, tcc, tca::TCConfig::unitsPerTick, and tca::TCSlice::wireHitRange.

Referenced by ChgFracBetween(), FindHammerVertices2(), FindXMatches(), SignalBetween(), and StepAway().

   {
     // returns true if there is a hit near tp.Pos
     
     if(tp.Pos[0] < -0.4) return false;
     unsigned int wire = std::nearbyint(tp.Pos[0]);
     geo::PlaneID planeID = DecodeCTP(tp.CTP);
     unsigned int ipl = planeID.Plane;
     if(wire >= slc.nWires[ipl]) return false;
     if(tp.Pos[1] > tcc.maxPos1[ipl]) return false;
     // Assume dead wires have a signal
     if(slc.wireHitRange[ipl][wire].first == -1) return true;
     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;
     unsigned int firstHit = (unsigned int)slc.wireHitRange[ipl][wire].first;
     unsigned int lastHit = (unsigned int)slc.wireHitRange[ipl][wire].second;
     
     for(unsigned int iht = firstHit; iht < lastHit; ++iht) {
       auto& hit = (*evt.allHits)[slc.slHits[iht].allHitsIndex];
       if(projTick < hit.PeakTime()) {
         float loHitTick = hit.PeakTime() - 3 * hit.RMS();
         if(hiTpTick > loHitTick) return true;
       } else {
         float hiHitTick = hit.PeakTime() + 3 * hit.RMS();
         if(loTpTick < hiHitTick) return true;
       }
     } // iht
     return false;
     
   } // SignalAtTp

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

Definition at line 1671 of file Utils.cxx.

References MakeBareTrajPoint(), tca::TrajPoint::Pos, SignalAtTp(), and SignalBetween().

Referenced by AttachTrajToVertex(), EndMerge(), Find2DVertices(), and MakeJunkVertices().

   {
     // Returns true if there is a signal on > MinWireSignalFraction of the wires between tp1 and tp2.
     if(MinWireSignalFraction == 0) return true;
     
     if(tp1.Pos[0] < -0.4 || tp2.Pos[0] < -0.4) return false;
     int fromWire = std::nearbyint(tp1.Pos[0]);
     int toWire = std::nearbyint(tp2.Pos[0]);
     
     if(fromWire == toWire) {
       TrajPoint tp = tp1;
       // check for a signal midway between
       tp.Pos[1] = 0.5 * (tp1.Pos[1] + tp2.Pos[1]);
       return SignalAtTp(slc, 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	(	TCSlice &	slc,
		TrajPoint	tp,
		float	toPos0,
		const float &	MinWireSignalFraction
	)

Definition at line 1695 of file Utils.cxx.

References ChgFracBetween().

Referenced by SignalBetween().

   {
     // Returns true if there is a signal on > MinWireSignalFraction of the wires between tp and toPos0.
     return ChgFracBetween(slc, tp, toPos0) >= MinWireSignalFraction;
   } // SignalBetween

bool tca::Split3DKink	(	TCSlice &	slc,
		PFPStruct &	pfp,
		double	sep,
		bool	prt
	)

Definition at line 1811 of file PFPUtils.cxx.

References AttachAnyTrajToVertex(), tca::VtxStore::CTP, DecodeCTP(), evt, FindKinks(), tca::TCEvent::globalS3ID, tca::VtxStore::ID, tca::Vtx3Store::ID, KinkAngle(), kSplit3DKink, tca::PFPStruct::NeedsUpdate, tca::TCSlice::nPlanes, geo::PlaneID::Plane, tca::VtxStore::Pos, SplitTraj(), StoreVertex(), tcc, tca::PFPStruct::TjIDs, tca::TCSlice::tjs, tca::VtxStore::Topo, tca::PFPStruct::Tp3s, tca::Vtx3Store::TPCID, tca::PFPStruct::TPCID, tca::Vtx3Store::UID, tca::TCConfig::useAlg, tca::TCSlice::vtx3s, tca::TCSlice::vtxs, tca::Vtx3Store::Vx2ID, tca::Vtx3Store::X, tca::Vtx3Store::Y, and tca::Vtx3Store::Z.

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

   {
     // Finds kinks in the PFParticle, splits slc, creates 2D vertices and forces a rebuild if any are found
     if(pfp.Tp3s.empty()) return false;
     if(!tcc.useAlg[kSplit3DKink]) return false;
     
     auto kinkPts = FindKinks(slc, pfp, sep, prt);
     if(kinkPts.empty()) return false;
     if(prt) mf::LogVerbatim("TC")<<"Split3DKink found a kink at Tp3s point "<<kinkPts[0];
     
     // Only split the biggest angle kink
     double big = 0;
     unsigned short kpt = 0;
     for(auto ipt : kinkPts) {
       double dang = KinkAngle(slc, pfp.Tp3s, ipt, sep);
       if(dang > big) {
         big = dang;
         kpt = ipt;
       }
     } // ipt
     if(kpt < 1 || kpt > pfp.Tp3s.size() - 1) return false;
     // determine which tjs need to be split
     std::vector<unsigned short> tjids;
     std::vector<unsigned short> vx2ids;
     // inspect a few Tp3s near the kink point to get a list of Tjs
     for(unsigned short ipt = kpt; ipt < kpt + 2; ++ipt) {
       auto& tp3 = pfp.Tp3s[ipt];
       for(auto& tp2 : tp3.Tj2Pts) {
         // see if this Tj id is in the list
         if(std::find(tjids.begin(), tjids.end(), tp2.id) != tjids.end()) continue;
         // ensure that it is pfp.TjIDs
         if(std::find(pfp.TjIDs.begin(), pfp.TjIDs.end(), tp2.id) == pfp.TjIDs.end()) continue;
         tjids.push_back(tp2.id);
         auto& tj = slc.tjs[tp2.id - 1];
         auto& tp = tj.Pts[tp2.ipt];
         unsigned short closeEnd = USHRT_MAX;
         if(tp2.ipt < tj.EndPt[0] + 2) closeEnd = 0;
         if(tp2.ipt > tj.EndPt[1] - 2) closeEnd = 1;
         if(closeEnd < 2) {
           // No split is needed and there should be a vertex at this end of the Tj that
           // should be associated with a 3D vertex that we will construct
           if(tj.VtxID[closeEnd] == 0) {
 //            std::cout<<Split3DKink: TODO Tj "<<tj.ID<<" has no vertex attached on end "<<closeEnd<<". Write some code.\n";
             return false;
           }
           vx2ids.push_back(tj.VtxID[closeEnd]);
           if(prt) mf::LogVerbatim("TC")<<" tj "<<tj.ID<<" use existing 2V"<<tj.VtxID[closeEnd];
         } else {
           // make a 2D vertex at this point
           VtxStore vx2;
           vx2.ID = slc.vtxs.size() + 1;
           vx2.CTP = tj.CTP;
           vx2.Topo = 10;
           vx2.Pos = tp.Pos;
           if(!StoreVertex(slc, vx2)) return false;
           if(!SplitTraj(slc, tp2.id - 1, tp2.ipt, slc.vtxs.size() - 1, prt)) return false;
           vx2ids.push_back(vx2.ID);
           AttachAnyTrajToVertex(slc, slc.vtxs.size() - 1, prt);
           if(prt) mf::LogVerbatim("TC")<<" tj "<<tj.ID<<" new 2V"<<vx2.ID;
         }
       } // tp2
     } // ipt
     
     if(vx2ids.size() != slc.nPlanes) {
 //      std::cout<<"Split3DKink: TODO pfp "<<pfp.ID<<" only has "<<vx2ids.size()<<" 2D vertices. \n";
       return false;
     }
     Vtx3Store vx3;
     vx3.TPCID = pfp.TPCID;
     vx3.Vx2ID.resize(slc.nPlanes);
     vx3.ID = slc.vtx3s.size() + 1;
     vx3.X = pfp.Tp3s[kpt].Pos[0];
     vx3.Y = pfp.Tp3s[kpt].Pos[1];
     vx3.Z = pfp.Tp3s[kpt].Pos[2];
     for(auto vx2id : vx2ids) {
       if(vx2id == 0) continue;
       auto& vx2 = slc.vtxs[vx2id - 1];
       unsigned short plane = DecodeCTP(vx2.CTP).Plane;
       vx3.Vx2ID[plane] = vx2id;
       vx2.Vx3ID = vx3.ID;
     } // vx2id
     ++evt.globalS3ID;
     vx3.UID = evt.globalS3ID;
     slc.vtx3s.push_back(vx3);
     // mark this as needing an update
     pfp.NeedsUpdate = true;
     return true;
   } // Split3DKink

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

Definition at line 4120 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::VtxStore::ChiDOF, tca::VtxStore::CTP, tca::Trajectory::CTP, tca::TCConfig::dbgAlg, tca::TCConfig::dbgStp, evd::details::end(), tca::Trajectory::EndPt, tca::VtxStore::ID, tca::Trajectory::ID, kKilled, kSplitHiChgHits, max, min, tca::VtxStore::NTraj, tca::VtxStore::Pass, tca::Trajectory::Pass, tca::VtxStore::Pos, PrintPos(), tca::Trajectory::Pts, SetEndPoints(), SetVx2Score(), tca::TCSlice::slHits, StoreVertex(), tcc, tca::TCSlice::tjs, tca::VtxStore::Topo, TpSumHitChg(), tca::TCConfig::useAlg, tca::Trajectory::VtxID, and tca::TCSlice::vtxs.

Referenced by ChkHiChgHits().

                                                    {
     
     // Check allTraj trajectories in the current CTP and split high charge hits 
     if(!tcc.useAlg[kSplitHiChgHits]) return;
     // Only do it once
     if (tj.AlgMod[kSplitHiChgHits]) return;
     if(tj.AlgMod[kKilled]) return;
     //Ignore short trajectories
     if (tj.EndPt[1]<10) return;
     
     bool prt = (tcc.dbgStp || tcc.dbgAlg[kSplitHiChgHits]);
     
     for(unsigned short end = 0; end < 2; ++end) {
       if(prt) mf::LogVerbatim("TC")<<"SplitHiChghits "<<end<<" "<<tj.VtxID[end];
       float hichg = 0;
       unsigned short tp = tj.EndPt[end];
       unsigned short nlohits = 0;
       unsigned short lastHiTP = USHRT_MAX;
       while (tp != tj.EndPt[1-end]){
         float ptchg = TpSumHitChg(slc, tj.Pts[tp]);
         if (prt) mf::LogVerbatim("TC")<<"SplitHiChgHits "<<tp<<" "<<ptchg<<" "<<PrintPos(slc, tj.Pts[tp]);
         if (ptchg){
           if (tp == tj.EndPt[end]){
             hichg = ptchg;
             lastHiTP = tp;
           }
           else if (ptchg>0.4*hichg){
             if (!nlohits){
               hichg = ptchg;
               lastHiTP = tp;
             }
             else{
               break;
             }
           }
           else ++nlohits;
         }
         if (end==0){
           ++tp;
         }
         else{
           --tp;
         }
       }
       //if (tcc.dbgStp) mf::LogVerbatim("TC")<<"SplitHiChgHits "<<end<<" "<<nlohits;
       if (nlohits>4&&lastHiTP!=USHRT_MAX){
         //Create new vertex
         VtxStore aVtx;
         aVtx.Pos = tj.Pts[lastHiTP].Pos;
         aVtx.NTraj = 2;
         aVtx.Pass = tj.Pass;
         aVtx.Topo = 7;
         aVtx.ChiDOF = 0;
         aVtx.CTP = tj.CTP;
         aVtx.ID = slc.vtxs.size() + 1;
         if(!StoreVertex(slc, aVtx)) {
           if(prt) mf::LogVerbatim("TC")<<" Failed storing vertex "<<tj.VtxID[end];
           return;
         }
         
         // make a copy
         Trajectory newTj = tj;
         newTj.ID = slc.tjs.size() + 1;
         
         // keep high charge hits, reassign other hits to the new trajectory
         unsigned short tp1 = lastHiTP+1;
         if (end==1) tp1 = lastHiTP-1;
         for (unsigned short ipt = std::min(tj.EndPt[1-end], tp1); ipt <= std::max(tj.EndPt[1-end], tp1); ++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;
             unsigned int 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);
         tj.VtxID[1-end] = aVtx.ID;
         tj.AlgMod[kSplitHiChgHits] = true;
         if(prt) {
           mf::LogVerbatim("TC")<<"Splitting trajectory ID "<<tj.ID<<" new EndPts "<<tj.EndPt[0]<<" to "<<tj.EndPt[1];
         }
         
         for (unsigned short ipt = std::min(newTj.EndPt[end], lastHiTP); ipt <= std::max(newTj.EndPt[end], lastHiTP); ++ipt){
           newTj.Pts[ipt].Chg = 0;
           for (unsigned short ii = 0; ii < newTj.Pts[ipt].Hits.size(); ++ii) {
             newTj.Pts[ipt].UseHit[ii] = false;
           }//ii
         }//ipt
         SetEndPoints(newTj);
         newTj.VtxID[end] = aVtx.ID;
         newTj.AlgMod[kSplitHiChgHits] = true;
         slc.tjs.push_back(newTj);
         SetVx2Score(slc);
         
         break;     
       }
     }
   }

bool tca::SplitTraj	(	TCSlice &	slc,
		unsigned short	itj,
		float	XPos,
		bool	makeVx2,
		bool	prt
	)

Definition at line 2004 of file Utils.cxx.

References detinfo::DetectorProperties::ConvertXToTicks(), tca::VtxStore::CTP, DecodeCTP(), tca::TCConfig::detprop, tca::VtxStore::NTraj, tca::VtxStore::Pos, SplitTraj(), StoreVertex(), tcc, tca::TCSlice::tjs, tca::VtxStore::Topo, tca::TCConfig::unitsPerTick, and tca::TCSlice::vtxs.

Referenced by CompleteIncomplete3DVertices(), FindHammerVertices(), FindHammerVertices2(), Split3DKink(), and SplitTrajCrossingVertices().

   {
     // Splits the trajectory at an X position and optionally creates a 2D vertex at the split point
     if(itj > slc.tjs.size()-1) return false;
     
     auto& tj = slc.tjs[itj];
     geo::PlaneID planeID = DecodeCTP(tj.CTP);
     float atPos1 = tcc.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 2043 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::EndPt, evt, tca::TCEvent::globalTjID, tca::Trajectory::ID, kSplit, tca::Trajectory::MCSMom, MCSMom(), tca::Trajectory::ParentID, tca::Trajectory::PDGCode, tca::Trajectory::Pts, SetEndPoints(), SetPDGCode(), tca::TCSlice::slHits, tca::TCSlice::tjs, tca::Trajectory::UID, UpdateMatchStructs(), UpdateTjChgProperties(), tca::Trajectory::VtxID, and tca::TCSlice::vtxs.

Referenced by CheckTrajBeginChg(), and SplitTraj().

   {
     // 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 "<<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 ipt, ii, ntp = 0;
     for(ipt = 0; ipt < pos; ++ipt) {
       if(tj.Pts[ipt].Chg > 0) ++ntp;
       if(ntp > 2) break;
     } // ipt
     if(ntp < 3) {
       if(prt) mf::LogVerbatim("TC")<<" Split point to small at begin "<<ntp<<" pos "<<pos<<" ID ";
       return false;
     }
     ntp = 0;
     for(ipt = pos + 1; ipt < tj.Pts.size(); ++ipt) {
       if(tj.Pts[ipt].Chg > 0) ++ntp;
       if(ntp > 2) break;
     } // ipt
     if(ntp < 3) {
       if(prt) mf::LogVerbatim("TC")<<" Split point too small at end "<<ntp<<" pos "<<pos<<" EndPt "<<tj.EndPt[1];
       return false;
     }
     
     // make a copy that will become the Tj after the split point
     Trajectory newTj = tj;
     newTj.ID = slc.tjs.size() + 1;
     ++evt.globalTjID;
     newTj.UID = evt.globalTjID;
     // make another copy in case something goes wrong
     Trajectory oldTj = tj;
     
     // Leave the first section of tj in place. Re-assign the hits
     // to the new trajectory
     unsigned int iht;
     for(ipt = pos + 1; ipt < tj.Pts.size(); ++ipt) {
       tj.Pts[ipt].Chg = 0;
       for(ii = 0; ii < tj.Pts[ipt].Hits.size(); ++ii) {
         if(!tj.Pts[ipt].UseHit[ii]) continue;
         iht = tj.Pts[ipt].Hits[ii];
         // This shouldn't happen but check anyway
         if(slc.slHits[iht].InTraj != tj.ID) continue;
         slc.slHits[iht].InTraj = newTj.ID;
         tj.Pts[ipt].UseHit[ii] = false;
       } // ii
     } // ipt
     SetEndPoints(tj);
     tj.MCSMom = MCSMom(slc, tj);
     UpdateTjChgProperties("ST", slc, tj, prt);
     if(splittingMuon) SetPDGCode(slc, tj, true);
     
     // 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(ipt = 0; ipt < 3; ++ipt) {
       for(ii = 0; ii < newTj.Pts[ipt].Hits.size(); ++ii) newTj.Pts[ipt].UseHit[ii] = false;
       newTj.Pts[ipt].Chg = 0;
     } // ipt
     SetEndPoints(newTj);
     newTj.MCSMom = MCSMom(slc, newTj);
     UpdateTjChgProperties("ST", slc, newTj, prt);
     if(splittingMuon) SetPDGCode(slc, newTj, true);
     if(ivx < slc.vtxs.size()) newTj.VtxID[0] = slc.vtxs[ivx].ID;
     newTj.AlgMod[kSplit] = true;
     newTj.ParentID = 0;
     // save the ID before push_back in case the tj reference gets lost
     int tjid = tj.ID;
     slc.tjs.push_back(newTj);
     UpdateMatchStructs(slc, tjid, newTj.ID);
 
     if(prt) {
       mf::LogVerbatim("TC")<<"  newTj T"<<newTj.ID<<" EndPts "<<newTj.EndPt[0]<<" to "<<newTj.EndPt[1];
     }
     return true;
     
   } // SplitTraj

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

Definition at line 1268 of file TCVertex.cxx.

References tca::TCConfig::dbgAlg, tca::TCConfig::dbgSlc, DecodeCTP(), DeltaAngle(), evd::details::end(), FitVertex(), GetVtxTjIDs(), kDebug, kDeltaRay, kHaloTj, tca::TCConfig::kinkCuts, kKilled, kOnDeadWire, kSplitTjCVx, MakeVertexObsolete(), tca::TCConfig::modes, NumPtsWithCharge(), geo::PlaneID::Plane, PointTrajDOCA(), PrintTrajPoint(), SplitTraj(), tcc, tca::TCSlice::tjs, TrajClosestApproach(), tca::TCConfig::useAlg, tca::TCConfig::vtx2DCuts, and tca::TCSlice::vtxs.

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

   {
     // 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
 //      auto& tj = slc.tjs[itj];
       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[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;
         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 < tcc.kinkCuts[0]) skipit = true;
         if(prt) mf::LogVerbatim("TC")<<"  maxPts "<<maxPts<<" vxtjs[0] "<<vxtjs[0]<<" maxdang "<<maxdang<<" skipit? "<<skipit;
         if(skipit) {
           // kill the vertex?
           if(doca < 1) MakeVertexObsolete("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;
           PrintTrajPoint("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

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

Definition at line 4188 of file TCShower.cxx.

References tca::TCEvent::allHits, tca::ShowerStruct::Angle, tca::TCSlice::cots, evt, tca::ShowerStruct::ID, tca::ShowerStruct::ParentID, tca::TrajPoint::Pos, tca::ShowerStruct::ShowerTjID, tca::ShowerStruct::ShPts, tca::TCSlice::slHits, ss, tcc, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, and tca::TCConfig::unitsPerTick.

Referenced by FindStartChg().

   {
     // Returns a histogram vector of the charge in bins of 1 WSE unit at the start of the shower
 
     ShowerStruct& ss = 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 4431 of file Utils.cxx.

References tca::TCEvent::allHits, tca::TCConfig::dbgDump, tca::TCConfig::dbgSlc, tca::TCConfig::dbgStp, debug, EncodeCTP(), evt, ExpectedHitsRMS(), tca::Trajectory::ID, kDebug, tca::TCConfig::modes, tca::Trajectory::Pts, tca::TCSlice::slHits, StartTraj(), tca::Trajectory::StepDir, tcc, and tca::DebugStuff::WorkID.

Referenced by DotProd(), FindVtxTjs(), MakeJunkTraj(), and tca::TrajClusterAlg::ReconstructAllTraj().

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

References tca::TrajPoint::Ang, tca::TrajPoint::AngErr, tca::TrajPoint::AngleCode, tca::Trajectory::CTP, tca::TCConfig::dbgDump, tca::TCConfig::dbgSlc, tca::TCConfig::dbgStp, debug, tca::TrajPoint::Dir, evt, ExpectedHitsRMS(), tca::Trajectory::ID, kDebug, kNormal, MakeBareTrajPoint(), tca::TCConfig::modes, tca::Trajectory::ParentID, tca::Trajectory::Pass, tca::Trajectory::Pts, SetAngleCode(), tca::Trajectory::StepDir, tca::Trajectory::Strategy, tcc, tca::DebugStuff::WorkID, and tca::TCEvent::WorkID.

Referenced by StartTraj().

   {
     // 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 15 of file StepUtils.cxx.

References AddHits(), tca::Trajectory::AlgMod, tca::TrajPoint::AngleCode, AttachTrajToVertex(), tca::TrajPoint::Chg, tca::TrajPoint::CTP, tca::Trajectory::CTP, tca::TCConfig::dbg2V, tca::TCConfig::dbgStp, DeadWireCount(), DecodeCTP(), DefineHitPos(), DeltaAngle(), tca::TrajPoint::Dir, tca::TCConfig::doForecast, tca::Trajectory::EndPt, tca::TrajPoint::FitChi, Forecast(), GottaKink(), tca::TrajPoint::Hits, tca::Trajectory::ID, tca::Trajectory::IsGood, kAtKink, kAtTj, kAtVtx, kNewStpCuts, kRvPrp, kSignal, kSlowing, kStopBadFits, MaskedHitsOK(), tca::Trajectory::MaskedLastTP, MaskTrajEndPoints(), tca::TCConfig::maxAngleCode, tca::TCConfig::maxChi, tca::TCConfig::maxPos0, tca::TCConfig::maxPos1, tca::TCConfig::maxWireSkipNoSignal, tca::TCConfig::maxWireSkipWithSignal, tca::Trajectory::MCSMom, tca::TCConfig::minMCSMom, tca::TCConfig::minPtsFit, tca::TCConfig::muonTag, tca::Trajectory::NeedsUpdate, NumPtsWithCharge(), tca::Trajectory::Pass, tca::Trajectory::PDGCode, geo::PlaneID::Plane, tca::TrajPoint::Pos, PosSep2(), PrintPos(), PrintTrajectory(), PrintTrajPoint(), tca::Trajectory::Pts, SetEndPoints(), SetPDGCode(), SetStrategy(), SignalAtTp(), tca::TCSlice::slHits, tca::TrajPoint::Step, tca::Trajectory::StepDir, tca::Trajectory::StopFlag, StopIfBadFits(), tca::Trajectory::Strategy, StrategyBitNames, tcc, tjfs, TPNearVertex(), TrajPointSeparation(), tca::TCConfig::unitsPerTick, UnsetUsedHits(), UpdateTraj(), tca::TCConfig::useAlg, tca::TrajPoint::UseHit, tca::TCConfig::VLAStepSize, and tca::TCSlice::vtxs.

Referenced by FindVtxTjs(), tca::TrajClusterAlg::ReconstructAllTraj(), and ReversePropagate().

   {
     // 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) {
       // Get a forecast of what is ahead. 
 //      unsigned short span = tj.EndPt[1] - tj.EndPt[0] + 1;
       unsigned short span = NumPtsWithCharge(slc, tj, false);
       if(tcc.doForecast && !tj.AlgMod[kRvPrp] && span == tjfs[tjfs.size() - 1].nextForecastUpdate) {
         Forecast(slc, tj);
         SetStrategy(slc, tj);
         SetPDGCode(slc, tj, false);
       }
       // 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;
       
       unsigned short ivx = TPNearVertex(slc, ltp);
       if(ivx != USHRT_MAX) {
         // Trajectory stops near a vertex so make the assignment
         if(AttachTrajToVertex(slc, tj, slc.vtxs[ivx], tcc.dbgStp || tcc.dbg2V)) tj.StopFlag[1][kAtVtx] = true;
         break;
       }
       
       // 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;
       // 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.StopFlag[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()) {
         // 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
         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 && !SignalAtTp(slc, ltp)) {
             tj.StopFlag[1][kSignal] = false;
             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(tj.PDGCode == 13) maxWireSkip = tcc.muonTag[2];
           if(tcc.dbgStp) mf::LogVerbatim("TC")<<" StepAway: no signal 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 ";
                   PrintTrajPoint("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;
         }
         // Don't bother with the rest of the checking below if we
         // set all hits not used on this TP
         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
       // assume that we aren't going to kill the point we just added, or any
       // of the previous points...
       unsigned short killPts = 0;
       // assume that we should keep going after killing points
       bool keepGoing = true;
       // check for a kink. Stop crawling if one is found
       GottaKink(slc, tj, killPts);
       if(tj.StopFlag[1][kAtKink]) {
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"   stop at kink with killPts "<<killPts;
         keepGoing = false;
       }
       // 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(killPts == 0 &&  tj.Pts[lastPt].FitChi > tcc.maxChi && useMaxChiCut) {
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"   bad FitChi "<<tj.Pts[lastPt].FitChi<<" cut "<<tcc.maxChi;
         if(tcc.useAlg[kNewStpCuts]) {
           // remove the last point before quitting
           UnsetUsedHits(slc, tj.Pts[lastPt]);
           SetEndPoints(tj);
         }
         tj.IsGood = (NumPtsWithCharge(slc, tj, true) > tcc.minPtsFit[tj.Pass]);
         return;
       }
       // print the local tp unless we have killing to do
       if(killPts == 0) {
         if(tcc.dbgStp) {
           if(tj.AlgMod[kRvPrp]) {
             PrintTrajectory("RP", slc, tj, lastPt);
           } else {
             PrintTrajectory("SC", slc, tj, lastPt);
           }
         }
       } else {
         MaskTrajEndPoints(slc, tj, killPts);
         if(!tj.IsGood) return;
         unsigned int onWire = (float)(std::nearbyint(tj.Pts[lastPt].Pos[0]));
         float nSteps = (float)(step - tj.Pts[lastPt - killPts].Step);
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"TRP   killing "<<killPts<<" after "<<nSteps<<" steps from prev TP.  Current tp.Pos "<<tp.Pos[0]<<" "<<tp.Pos[1];
         // move the position
         tj.Pts[lastPt].Pos[0] += nSteps * tj.Pts[lastPt].Dir[0];
         tj.Pts[lastPt].Pos[1] += nSteps * tj.Pts[lastPt].Dir[1];
         if(tj.Pts[lastPt].AngleCode == 0) {
           // put the TP at the wire position prior to the move
           float dw = onWire - tj.Pts[lastPt].Pos[0];
           tj.Pts[lastPt].Pos[0] = onWire;
           tj.Pts[lastPt].Pos[1] += dw * tj.Pts[lastPt].Dir[1] / tj.Pts[lastPt].Dir[0];
         }
         // check the MCSMom after we going
         if(tj.Pts.size() > 20 && tj.Pass < tcc.minMCSMom.size() && tj.MCSMom < tcc.minMCSMom[tj.Pass]) break;
         // copy to the local trajectory point
         ltp.Pos = tj.Pts[lastPt].Pos;
         ltp.Dir = tj.Pts[lastPt].Dir;
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"  New ltp.Pos     "<<ltp.Pos[0]<<" "<<ltp.Pos[1]<<" ticks "<<(int)ltp.Pos[1]/tcc.unitsPerTick;
         if(!keepGoing) break;
       }
     } // step
     
     // Do a more carefull treatment
     // This is the wrong place to do this. 
 //    SetPDGCode(slc, tj, true);
     
     if(tcc.dbgStp) mf::LogVerbatim("TC")<<"End StepAway with tj size "<<tj.Pts.size()<<" isGood = "<<tj.IsGood;
     
   } // StepAway

void tca::StitchPFPs ( )

Definition at line 16 of file PFPUtils.cxx.

References tca::TCConfig::dbgStitch, debug, DotProd(), evd::details::end(), tca::TCConfig::geom, GetSliceIndex(), InsideFV(), geo::GeometryCore::NTPC(), tca::TCConfig::pfpStitchCuts, PosSep2(), PrintP(), ReversePFP(), tca::DebugStuff::Slice, slices, tcc, and tmp.

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

   {
     // 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(unsigned short sl1 = 0; sl1 < slices.size() - 1; ++sl1) {
       auto& slc1 = slices[sl1];
       for(unsigned short 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 = p1.XYZ[e1];
               // require the end to be close to a TPC boundary
               if(InsideFV(slc1, p1, e1)) continue;
               auto& dir1 = p1.Dir[e1];
               for(unsigned short e2 = 0; e2 < 2; ++e2) {
                 auto& pos2 = p2.XYZ[e2];
                 // require the end to be close to a TPC boundary
                 if(InsideFV(slc2, p2, e2)) continue;
                 auto& dir2 = p2.Dir[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) {
           if(pfp.XYZ[end][2] < minZ) { minZ = pfp.XYZ[end][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;
       // reverse it if necessary
       if(minZEnd != 0) ReversePFP(slices[minZIndx.first], pfp);
       // 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 2815 of file StepUtils.cxx.

References tca::TCConfig::dbgStp, tca::Trajectory::EndPt, tca::Trajectory::MCSMom, tca::Trajectory::PDGCode, tca::Trajectory::Pts, and tcc.

Referenced by StepAway().

   {
     // 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::StorePFP	(	TCSlice &	slc,
		PFPStruct &	pfp
	)

Definition at line 2749 of file PFPUtils.cxx.

References tca::PFPStruct::BestPlane, evt, FilldEdx(), tca::TCEvent::globalPFPID, tca::PFPStruct::ID, kMat3D, tca::PFPStruct::NeedsUpdate, tca::PFPStruct::PDGCode, tca::TCSlice::pfps, ReverseTraj(), tca::PFPStruct::TjIDs, tca::TCSlice::tjs, tca::PFPStruct::Tp3s, and tca::PFPStruct::UID.

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

   {
     // stores the PFParticle in TJStuff
     if(pfp.ID < int(slc.pfps.size())) return false;
     bool neutrinoPFP = pfp.PDGCode == 12 || pfp.PDGCode == 14;
     if(!neutrinoPFP) {
       if(pfp.TjIDs.empty()) return false;
       if(pfp.PDGCode != 1111 && pfp.Tp3s.size() < 2) return false;
     }
     // check the ID and correct it if it is wrong
     if(pfp.ID != (int)slc.pfps.size() + 1) pfp.ID = slc.pfps.size() + 1;
     ++evt.globalPFPID;
     pfp.UID = evt.globalPFPID;
     // check the Tjs and set the 3D match flag
     for(auto tjid : pfp.TjIDs) {
       auto& tj = slc.tjs[tjid - 1];
       if(tj.AlgMod[kMat3D]) return false;
       tj.AlgMod[kMat3D] = true;
     } // tjid
     
     if(!pfp.Tp3s.empty()) {
       // ensure that the Tj points are in increasing order and reverse them if they aren't. This
       // presumes that the space points have been ordered from pfp start to pfp end
       std::vector<int> tjids;
       // list of tj points to check for increasing (or decreasing) order
       std::vector<short> firstIpt;
       std::vector<short> lastIpt;
       for(auto& Tp3 : pfp.Tp3s) {
         for(auto& tj2pt : Tp3.Tj2Pts) {
           int tjid = tj2pt.id;
           // check for the first occurrence
           unsigned short ii = 0;
           for(ii = 0; ii < tjids.size(); ++ii) if(tjid == tjids[ii]) break;
           if(ii < tjids.size()) {
             // exists in the list. Keep track of the last point
             lastIpt[ii] = tj2pt.ipt;
             continue;
           }
           tjids.push_back(tjid);
           firstIpt.push_back((short)tj2pt.ipt);
           lastIpt.push_back((short)tj2pt.ipt);
         } // tjpt
       } // spt
       // reverse Tjs if necessary so that end0 is at the start of the pfp
       for(unsigned short ii = 0; ii < tjids.size(); ++ii) {
         // ignore Tjs that aren't associated with this pfp
         if(std::find(pfp.TjIDs.begin(), pfp.TjIDs.end(), tjids[ii]) == pfp.TjIDs.end()) continue;
         auto& tj = slc.tjs[tjids[ii] - 1];
         if(lastIpt[ii] < firstIpt[ii]) ReverseTraj(slc, tj);
       } // ii
     } // Tp3s exist    
     
     if(pfp.BestPlane < 0) FilldEdx(slc, pfp);
     
     if(pfp.NeedsUpdate) std::cout<<"StorePFP: stored P"<<pfp.ID<<" but NeedsUpdate is true...\n";
     
     slc.pfps.push_back(pfp);
     return true;
   } // StorePFP

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

Definition at line 4403 of file TCShower.cxx.

References tca::ShowerStruct3D::CotIDs, tca::TCSlice::cots, evt, tca::TCEvent::globalS3ID, tca::ShowerStruct3D::ID, tca::TCSlice::showers, ss, and tca::ShowerStruct3D::UID.

   {
     // 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.globalS3ID;
     ss3.UID = evt.globalS3ID;
     
     slc.showers.push_back(ss3);
     return true;
     
   } // StoreShower

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

Definition at line 4449 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::TCSlice::cots, evt, tca::TCEvent::globalS2ID, tca::Trajectory::ID, tca::ShowerStruct::ID, kShwrParent, tca::ShowerStruct::ParentID, tca::Trajectory::SSID, tca::ShowerStruct::TjIDs, tca::TCSlice::tjs, and tca::ShowerStruct::UID.

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

   {
     // Store a ShowerStruct
     std::string fcnLabel = inFcnLabel + ".S2S";
     if(ss.ID <= 0) {
       std::cout<<fcnLabel<<" Invalid ID";
       return false;
     }
     if(ss.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.globalS2ID;
     ss.UID = evt.globalS2ID;
     
     slc.cots.push_back(ss);
     return true;
     
   } // StoreShower

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

Definition at line 1175 of file Utils.cxx.

References AlgBitNames, tca::Trajectory::AlgMod, tca::TCConfig::dbgSlc, debug, tca::Trajectory::DirFOM, tca::Trajectory::EndPt, evt, tca::TCEvent::globalTjID, tca::DebugStuff::Hit, tca::Trajectory::ID, kDebug, tca::TCConfig::modes, tca::Trajectory::ParentID, PrintHit(), tca::Trajectory::Pts, ReleaseHits(), SetEndPoints(), tca::TCSlice::slHits, tca::Trajectory::StepDir, tcc, TjDirFOM(), tca::TCSlice::tjs, tca::Trajectory::UID, UpdateTjChgProperties(), and tca::Trajectory::WorkID.

Referenced by FindVtxTjs(), MakeJunkTraj(), MergeAndStore(), MergePFPTjs(), and tca::TrajClusterAlg::ReconstructAllTraj().

   {
     
     if(!(tj.StepDir == 1 || tj.StepDir == -1)) {
       mf::LogError("TC")<<"StoreTraj: Invalid StepDir "<<tj.StepDir;
       return false;
     }
     
     if(slc.tjs.size() >= USHRT_MAX) {
       mf::LogError("TC")<<"StoreTraj: Too many trajectories "<<slc.tjs.size();
       return false;
     }
     
     // This shouldn't be necessary but do it anyway
     SetEndPoints(tj);
     
     if(tj.EndPt[1] <= tj.EndPt[0]) return false;
     if(tj.EndPt[1] > tj.Pts.size()) return false;
     unsigned short npts = tj.EndPt[1] - tj.EndPt[0] + 1;
     if(npts < 2) return false;
     
     auto& endTp0 = tj.Pts[tj.EndPt[0]];
     auto& endTp1 = tj.Pts[tj.EndPt[1]];
     
     // Calculate the charge near the end and beginning if necessary. This must be a short
     // trajectory. Find the average using 4 points
     if(endTp0.AveChg <= 0) {
       unsigned short cnt = 0;
       float sum = 0;
       for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
         if(tj.Pts[ipt].Chg == 0) continue;
         sum += tj.Pts[ipt].Chg;
         ++cnt;
         if(cnt == 4) break;
       }
       tj.Pts[tj.EndPt[0]].AveChg = sum / (float)cnt;
     }
     if(endTp1.AveChg <= 0 && npts < 5) endTp1.AveChg = endTp0.AveChg;
     if(endTp1.AveChg <= 0) {
       float sum = 0;
       unsigned short cnt = 0;
       for(unsigned short ii = 0; ii < tj.Pts.size(); ++ii) {
         short ipt = tj.EndPt[1] - ii;
         if(ipt < 0) break;
         if(tj.Pts[ipt].Chg == 0) continue;
         sum += tj.Pts[ipt].Chg;
         ++cnt;
         if(cnt == 4) break;
         if(ipt == 0) break;
       } // ii
       tj.Pts[tj.EndPt[1]].AveChg = sum / (float)cnt;
     } // begin charge == end charge
     
     
     tj.DirFOM = TjDirFOM(slc, tj, false);
     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) {
             std::cout<<"StoreTraj bad iht "<<iht<<" slHits size "<<slc.slHits.size()<<" tj.ID "<<tj.ID<<"\n";
             ReleaseHits(slc, tj);
             return false;
           }
           if(slc.slHits[iht].InTraj > 0) {
             std::cout<<"StoreTraj fail "<<iht<<" "<<slc.slHits[iht].InTraj<<" WorkID "<<tj.WorkID<<" InTraj "<<slc.slHits[iht].InTraj;
             std::cout<<" algs ";
             for(unsigned short ib = 0; ib < AlgBitNames.size(); ++ib) if(tj.AlgMod[ib]) std::cout<<" "<<AlgBitNames[ib];
             std::cout<<"\n";
             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";
 //        PrintTrajectory("ST", tjs, tj, USHRT_MAX);
         return false;
       }
     } // iht
     
     tj.WorkID = tj.ID;
     tj.ID = trID;
     // increment the global ID
     ++evt.globalTjID;
     tj.UID = evt.globalTjID;
     // 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 2093 of file TCVertex.cxx.

References tca::VtxStore::CTP, evt, tca::TCEvent::globalS2ID, tca::VtxStore::ID, kKilled, tca::VtxStore::NTraj, tca::TCSlice::tjs, tca::VtxStore::Topo, tca::VtxStore::UID, and tca::TCSlice::vtxs.

Referenced by CheckTrajBeginChg(), CompleteIncomplete3DVertices(), CompleteIncomplete3DVerticesInGaps(), EndMerge(), Find2DVertices(), FindHammerVertices(), FindHammerVertices2(), MakeJunkVertices(), Split3DKink(), SplitHiChgHits(), and SplitTraj().

   {
     // jacket around the push to ensure that the Tj and vtx CTP is consistent.
     // The calling function should score the vertex after the trajectories are attached
     
     if(vx.ID != int(slc.vtxs.size() + 1)) {
       mf::LogVerbatim("TC")<<"StoreVertex: Invalid ID "<<vx.ID<<" It should be "<<slc.vtxs.size() + 1;
       return false;
     }
     
     ++evt.globalS2ID;
     vx.UID = evt.globalS2ID;
     
     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::TagDeltaRays	(	TCSlice &	slc,
		const CTP_t &	inCTP
	)

Definition at line 3065 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::CTP, tca::TCConfig::dbgDeltaRayTag, tca::TCConfig::dbgSlc, DeltaAngle(), tca::TCConfig::deltaRayTag, tca::Trajectory::EndPt, tca::Trajectory::ID, kDeltaRay, kHaloTj, tca::TCConfig::kinkCuts, kKilled, tca::Trajectory::MCSMom, tca::Trajectory::ParentID, tca::Trajectory::PDGCode, PointTrajDOCA(), PosSep(), PrintPos(), tca::Trajectory::Pts, ReverseTraj(), tca::Trajectory::StepDir, tcc, tca::TCSlice::tjs, TrajTrajDOCA(), tca::TCConfig::useAlg, and tca::TCConfig::vtx2DCuts.

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

   {
     // DeltaRayTag vector elements
     // [0] = max separation of both endpoints from a muon
     // [1] = minimum MCSMom
     // [2] = maximum MCSMom
     
     if(!tcc.useAlg[kDeltaRay]) return;
     if(tcc.deltaRayTag[0] < 0) return;
     if(tcc.deltaRayTag.size() < 3) return;
     
     bool prt = (tcc.dbgDeltaRayTag && tcc.dbgSlc);
 
     // double the user-defined separation cut. We will require that at least one of the ends of 
     // a delta ray be within the user-defined cut and allow
     float maxSep = 2 * tcc.deltaRayTag[0];
     float maxMinSep = tcc.deltaRayTag[0];
     unsigned short minMom = tcc.deltaRayTag[1];
     unsigned short maxMom = tcc.deltaRayTag[2];
     unsigned short minMuonLength = 2 * tcc.vtx2DCuts[2];
     unsigned short minpts = 4;
     if(prt) mf::LogVerbatim("TC")<<"TagDeltaRays: maxSep "<<maxSep<<" maxMinSep "<<maxMinSep<<" Mom range "<<minMom<<" to "<<maxMom<<" minpts "<<minpts;
     
     for(unsigned short itj = 0; itj < slc.tjs.size(); ++itj) {
       Trajectory& muTj = slc.tjs[itj];
       if(muTj.CTP != inCTP) continue;
       if(muTj.AlgMod[kKilled] || muTj.AlgMod[kHaloTj]) continue;
       if(muTj.PDGCode != 13) continue;
       if(prt) mf::LogVerbatim("TC")<<"TagDeltaRays: Muon T"<<muTj.ID<<" EndPts "<<PrintPos(slc, muTj.Pts[muTj.EndPt[0]])<<"-"<<PrintPos(slc, muTj.Pts[muTj.EndPt[1]]);
       // min length
       if(muTj.EndPt[1] - muTj.EndPt[0] < minMuonLength) continue;
       auto& mtp0 = muTj.Pts[muTj.EndPt[0]];
       auto& mtp1 = muTj.Pts[muTj.EndPt[1]];
       // Found a muon, now look for delta rays
       for(unsigned short jtj = 0; jtj < slc.tjs.size(); ++jtj) {
         if(jtj == itj) continue;
         Trajectory& dtj = slc.tjs[jtj];
         if(dtj.AlgMod[kKilled] || dtj.AlgMod[kHaloTj]) continue;
         if(dtj.CTP != inCTP) continue;
         if(dtj.PDGCode == 13) continue;
         // MCSMom cut
         if(dtj.MCSMom < minMom) continue;
         if(dtj.MCSMom > maxMom) continue;
         if(dtj.EndPt[1] - dtj.EndPt[0] < minpts) continue;
         // some rough cuts to require that the delta ray is within the
         // ends of the muon
         auto& dtp0 = dtj.Pts[dtj.EndPt[0]];
         auto& dtp1 = dtj.Pts[dtj.EndPt[1]];
         if(muTj.StepDir > 0) {
           if(dtp0.Pos[0] < mtp0.Pos[0]) continue;
           if(dtp1.Pos[0] > mtp1.Pos[0]) continue;
         } else {
           if(dtp0.Pos[0] > mtp0.Pos[0]) continue;
           if(dtp1.Pos[0] < mtp1.Pos[0]) continue;
         }
         // find the minimum separation
         float doca = maxMinSep;
         unsigned short mpt = 0;
         unsigned short dpt = 0;
         TrajTrajDOCA(slc, muTj, dtj, mpt, dpt, doca, false);
         if(doca == maxMinSep) continue;
         auto& dTp = dtj.Pts[dpt];
         // cut on the distance from the muon ends
         if(PosSep(dTp.Pos, mtp0.Pos) < tcc.vtx2DCuts[2]) continue;
         if(PosSep(dTp.Pos, mtp1.Pos) < tcc.vtx2DCuts[2]) continue;
        // make an angle cut at this point. A delta-ray should have a small angle
         float dang = DeltaAngle(muTj.Pts[mpt].Ang, dtj.Pts[dpt].Ang);
         if(prt) mf::LogVerbatim("TC")<<" dRay? T"<<dtj.ID<<" at "<<PrintPos(slc, dtj.Pts[dpt].Pos)<<" dang "<<dang<<" doca "<<doca;
         // ignore the angle cut if the separation is small and the delta ray MCSMom is low
         bool closeDeltaRay = (doca < 2 && dtj.MCSMom < 20);
         if(!closeDeltaRay && dang > tcc.kinkCuts[0]) continue;
         unsigned short oend = 0;
         // check the delta at the end of the delta-ray that is farthest away from the
         // closest point
         if(dpt > 0.5 * (dtj.EndPt[0] + dtj.EndPt[1])) oend = 1;
         auto& farEndTP = dtj.Pts[dtj.EndPt[oend]];
         float farEndDelta = PointTrajDOCA(slc, farEndTP.Pos[0], farEndTP.Pos[1], muTj.Pts[mpt]);
         if(prt) mf::LogVerbatim("TC")<<"  farEnd "<<PrintPos(slc, farEndTP.Pos)<<" farEndDelta "<<farEndDelta;
         if(farEndDelta > maxSep) continue;
         if(prt) mf::LogVerbatim("TC")<<"   delta ray "<<dtj.ID<<" parent -> "<<muTj.ID;
         dtj.ParentID = muTj.ID;
         dtj.PDGCode = 11;
         dtj.AlgMod[kDeltaRay] = true;
         // Set the start of the delta-ray to be end 0
         if(oend != 1) ReverseTraj(slc, dtj);
       } // jtj
     } // itj
     
   } // TagDeltaRays

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

Definition at line 2442 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::ID, kJunkTj, kNewStpCuts, tca::Trajectory::PDGCode, tca::Trajectory::Pts, tcc, and tca::TCConfig::useAlg.

Referenced by CheckTraj().

   {
     // Characterizes the trajectory as a junk tj even though it may not
     // have been reconstructed in FindJunkTraj. The distinguishing feature is
     // that it is short and has many used hits in each trajectory point.
     
     // Don't bother if it is too long
     if(tj.Pts.size() > 10) return;
     if(tcc.useAlg[kNewStpCuts] && 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 3631 of file TCShower.cxx.

References evd::details::begin(), tca::TCConfig::chargeCuts, tca::DebugStuff::CTP, tca::TCConfig::dbg2S, tca::TCConfig::dbgSlc, debug, evd::details::end(), tca::Trajectory::EndPt, FarEnd(), GetAssns(), tca::Trajectory::ID, tca::TCSlice::ID, kBragg, kHaloTj, kKilled, kShowerLike, kShowerTj, MakeVertexObsolete(), NumPtsWithCharge(), PosSep(), tca::Trajectory::Pts, tca::TCConfig::showerTag, tcc, tca::TCSlice::tjs, TrajTrajDOCA(), and tca::TCSlice::vtxs.

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

   {
     // 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;
     // evaluate different cuts
     bool newCuts = (tcc.showerTag[0] > 2);
     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.StopFlag[end][kBragg]) skipit = true;
       if(skipit) continue;
       short npwc = NumPtsWithCharge(slc, tj, false);
       if(newCuts) {
         // evaluate different cuts
         // Don't expect any (primary) electron to be reconstructed as a single trajectory for
         // more than ~2 radiation lengths ~ 30 cm for uB ~ 100 wires 
         if(npwc > 100) continue;
         // allow short Tjs.
         if(npwc > 5) {
           // Increase the MCSMom cut if the Tj is long and the charge RMS is high to reduce sensitivity 
           // to the fcl configuration. A primary electron may be reconstructed as one long Tj with large
           // charge rms and possibly high MCSMom or as several nearby shorter Tjs with lower charge rms
           float momCut = tcc.showerTag[1];
           if(tj.ChgRMS > typicalChgRMS) momCut *= tj.ChgRMS / typicalChgRMS;
           if(tj.MCSMom > momCut) continue;
         }
       } else {
         if(npwc < 3) continue;
         if(npwc > 4 && tj.MCSMom > tcc.showerTag[1]) continue;
       }
       tjids.push_back(tj.ID);
     } // tj
     
     if(tjids.size() < 2) return;
 
     for(unsigned short it1 = 0; it1 < tjids.size() - 1; ++it1) {
       Trajectory& tj1 = slc.tjs[tjids[it1] - 1];
       float len1 = PosSep(tj1.Pts[tj1.EndPt[1]].Pos, tj1.Pts[tj1.EndPt[0]].Pos);
       for(unsigned short it2 = it1 + 1; it2 < tjids.size(); ++it2) {
         Trajectory& tj2 = 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
         float len2 = PosSep(tj2.Pts[tj2.EndPt[1]].Pos, tj2.Pts[tj2.EndPt[0]].Pos);
         if(!newCuts) {
           if(len1 < len2 && len1 < doca) {
             if(len1 < doca) continue;
           } else {
             if(len2 < doca) continue;
           }
         } // !newCuts
         // found a close pair. See if one of these is in an existing cluster of Tjs
         bool inlist = false;
         for(unsigned short it = 0; it < tjLists.size(); ++it) {
           bool tj1InList = (std::find(tjLists[it].begin(), tjLists[it].end(), tj1.ID) != tjLists[it].end());
           bool tj2InList = (std::find(tjLists[it].begin(), tjLists[it].end(), tj2.ID) != tjLists[it].end());
           if(tj1InList || tj2InList) {
             // add the one that is not in the list
             if(!tj1InList) tjLists[it].push_back(tj1.ID);
             if(!tj2InList) tjLists[it].push_back(tj2.ID);
             inlist = true;
             break;
           }
           if(inlist) break;
         } // it
         // start a new list with this pair?
         if(!inlist) {
           std::vector<int> newlist(2);
           newlist[0] = tj1.ID;
           newlist[1] = tj2.ID;
           tjLists.push_back(newlist);
         }
       } // it2
     } // it1
     if(tjLists.empty()) return;
 
     // mark them all as ShowerLike Tjs
     unsigned short nsh = 0;
     for(auto& tjl : tjLists) {
       nsh += tjl.size();
       for(auto& tjID : tjl) {
         auto& tj = slc.tjs[tjID - 1];
         tj.AlgMod[kShowerLike] = true;
       } // tjid
     } // tjl
     
     // kill vertices with more than 1 shower-like tj that is close to the
     // vertex
     unsigned short nkill = 0;
     for(auto& vx2 : slc.vtxs) {
       if(vx2.ID == 0) continue;
       if(vx2.CTP != inCTP) continue;
       auto TInV2 = GetAssns(slc, "2V", vx2.ID, "T");
       unsigned short nsl = 0;
       bool has111 = false;
       for(auto tid : TInV2) {
         auto& tj = slc.tjs[tid - 1];
         if(tj.PDGCode == 111) has111 = true;
         if(tj.AlgMod[kShowerLike]) {
           unsigned short nearEnd = 1 - FarEnd(slc, tj, vx2.Pos);
           if(PosSep(tj.Pts[tj.EndPt[nearEnd]].Pos, vx2.Pos) < 6) ++nsl;
         }
       } // tid
       if(nsl < 2) continue;
       if(has111) continue;
       MakeVertexObsolete("TSL", slc, vx2, true);
       ++nkill;
     } // vx2
     if(prt) mf::LogVerbatim("TC")<<"TagShowerLike tagged "<<nsh<<" Tjs and killed "<<nkill<<" vertices in CTP "<<inCTP;
 
   } // TagShowerLike

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

Definition at line 3029 of file Utils.cxx.

References tca::Trajectory::EndPt, tca::TrajPoint::HitPos, kNewStpCuts, MakeBareTrajPoint(), NearestPtWithChg(), PointTrajDOCA2(), tca::TrajPoint::Pos, tca::Trajectory::Pts, tcc, tmp, and tca::TCConfig::useAlg.

Referenced by DotProd(), ElectronLikelihood(), and MCSThetaRMS().

   {
     // returns the rms scatter of points around a line formed by the firstPt and lastPt of the trajectory
     
     rms = -1;
     if(firstPt < tj.EndPt[0]) return;
     if(lastPt > tj.EndPt[1]) return;
     
     firstPt = NearestPtWithChg(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(tcc.useAlg[kNewStpCuts] && 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

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

Definition at line 986 of file Utils.cxx.

References tca::Trajectory::AlgMod, B, tca::Trajectory::EndPt, tca::Trajectory::ID, kEnvOverlap, kHaloTj, kKilled, geo::origin(), PosSep(), PrintPos(), tca::Trajectory::Pts, w, x, and y.

Referenced by StoreTraj().

   {
     // Calculate a FOM for the tj to be going from EndPt[0] -> EndPt[1] (FOM = 1)
     // or EndPt[1] -> EndPt[0] (FOM = -1) by finding the overall charge slope, weighted
     // by the presence of nearby InShower Tjs
     if(tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) return 0;
     if(tj.EndPt[1] - tj.EndPt[0] < 8) return 0;
 
     std::vector<double> x, y;
     Point2_t origin = tj.Pts[tj.EndPt[0]].HitPos;
     std::vector<double> w, q;
     
     unsigned short firstPt = tj.EndPt[0] + 2;
     unsigned short lastPt = tj.EndPt[1] - 2;
     if(lastPt < firstPt + 3) return 0;
     // don't include end points
     for(unsigned short ipt = firstPt; ipt <= lastPt; ++ipt) {
       auto& tp = tj.Pts[ipt];
       if(tp.Chg <= 0) continue;
       // only consider points that don't overlap with other tjs
       if(tp.Environment[kEnvOverlap]) continue;
       double sep = PosSep(tp.Pos, origin);
       x.push_back(sep);
       y.push_back((double)tp.Chg);
       double wght = 0.2 * tp.Chg;
       w.push_back(wght * wght);
     } // tp
     if(w.size() < 3) return 0;
     
     double sum = 0.;
     double sumx = 0.;
     double sumy = 0.;
     double sumxy = 0.;
     double sumx2 = 0.;
     double sumy2 = 0.;
     
     // weight by the charge ratio and accumulate sums
     double wght;
     for(unsigned short ipt = 0; ipt < x.size(); ++ipt) {
       wght = 1 / w[ipt];
       sum   += wght;
       sumx  += wght * x[ipt];
       sumy  += wght * y[ipt];
       sumx2 += wght * x[ipt] * x[ipt];
       sumy2 += wght * y[ipt] * y[ipt];
       sumxy += wght * x[ipt] * y[ipt];
     }
     // calculate coefficients and std dev
     double delta = sum * sumx2 - sumx * sumx;
     if(delta == 0) return 0;
     // A is the intercept
     double A = (sumx2 * sumy - sumx * sumxy) / delta;
     // B is the slope
     double B = (sumxy * sum  - sumx * sumy) / delta;
     
     // Calculate the FOM
     double ndof = x.size() - 2;
     double varnce = (sumy2 + A*A*sum + B*B*sumx2 - 2 * (A*sumy + B*sumxy - A*B*sumx)) / ndof;
     if(varnce <= 0) return 0;
     double BErr = sqrt(varnce * sum / delta);
     // scale the error so that the significance is +/-1 when the slope is 3 * error
     // Note that the error is correct only if the average Chi/DOF = 1 which is probably not the case
     float slopeSig = B / (3 * BErr);
     if(slopeSig > 1) slopeSig = 1;
     if(slopeSig < -1) slopeSig = -1;
     // rescale it to be in the range of 0 - 1
     slopeSig = (1 + slopeSig) / 2;
     
     if(prt) {
       mf::LogVerbatim myprt("TC");
       myprt<<"TjDir: T"<<tj.ID<<" slope "<<std::fixed<<std::setprecision(1)<<B<<" error "<<BErr<<" DirFOM "<<slopeSig;
       myprt<<" using points from "<<PrintPos(slc, tj.Pts[firstPt])<<" "<<PrintPos(slc, tj.Pts[lastPt]);
     } // prt
     return slopeSig;
 
   } // TjDirFOM

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

Definition at line 3674 of file Utils.cxx.

References tca::TCEvent::allHits, evt, tca::TrajPoint::Hits, kAllHits, kUnusedHits, kUsedHits, tca::TCSlice::slHits, and tca::TrajPoint::UseHit.

Referenced by DotProd(), FindUseHits(), and TPHitsRMSTime().

   {
     // Estimate the RMS of all hits associated with a trajectory point
     // without a lot of calculation
     if(tp.Hits.empty()) return 0;
     float minVal = 9999;
     float maxVal = 0;
     for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
       bool useit = (hitRequest == kAllHits);
       if(hitRequest == kUsedHits && tp.UseHit[ii]) useit = true;
       if(hitRequest == kUnusedHits && !tp.UseHit[ii]) useit = true;
       if(!useit) continue;
       unsigned int iht = tp.Hits[ii];
       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	(	TCSlice &	slc,
		TrajPoint &	tp,
		HitStatus_t	hitRequest
	)

Definition at line 3668 of file Utils.cxx.

References tcc, TPHitsRMSTick(), and tca::TCConfig::unitsPerTick.

Referenced by DotProd(), and FillmAllTraj().

   {
     return tcc.unitsPerTick * TPHitsRMSTick(slc, tp, hitRequest);
   } // TPHitsRMSTime

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

Definition at line 1816 of file TCVertex.cxx.

References tca::TrajPoint::CTP, tca::TrajPoint::Pos, and tca::TCSlice::vtxs.

Referenced by StepAway().

   {
     // 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	(	TCSlice &	slc,
		TrajPoint const &	tp
	)

Definition at line 1853 of file Utils.cxx.

References tca::TCEvent::allHits, evt, tca::TrajPoint::Hits, tca::TCSlice::slHits, and tca::TrajPoint::UseHit.

Referenced by SplitHiChgHits(), and VtxHitsSwap().

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

References tca::Trajectory::EndPt, tca::Trajectory::Pts, x, and y.

Referenced by AttachTrajToVertex(), CompatibleMerge(), Find2DVertices(), FindHammerVertices2(), and SplitTrajCrossingVertices().

   {
     // find the closest approach between a trajectory tj and a point (x,y). Returns
     // the index of the closest trajectory point and the distance. Returns false if none
     // of the points on the tj are within DOCA
     
     float close2 = DOCA * DOCA;
     closePt = 0;
     bool foundClose = false;
     
     for(unsigned short ipt = tj.EndPt[0]; ipt < tj.EndPt[1] + 1; ++ipt) {
       if(tj.Pts[ipt].Chg == 0) continue;
       float dx = tj.Pts[ipt].Pos[0] - x;
       if(std::abs(dx) > DOCA) continue;
       float dy = tj.Pts[ipt].Pos[1] - y;
       if(std::abs(dy) > DOCA) continue;
       float sep2 = dx * dx + dy * dy;
       if(sep2 < close2) {
         close2 = sep2;
         closePt = ipt;
         foundClose = true;
       }
     } // ipt
     
     DOCA = sqrt(close2);
     return foundClose;
     
   } // TrajClosestApproach

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

Definition at line 1736 of file Utils.cxx.

References tca::TCEvent::allHits, evt, HitsPosTick(), kAllHits, and tca::TCSlice::slHits.

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

   {
     // Hits (assume to be on adjacent wires have an acceptable signal overlap
     
     if(iHitsInMultiplet.empty() || jHitsInMultiplet.empty()) return false;
     
     float sum;
     float cvI = HitsPosTick(slc, iHitsInMultiplet, sum, kAllHits);
     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);
     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 1778 of file Utils.cxx.

References tca::TCEvent::allHits, evt, and tca::TCSlice::slHits.

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

References TrajIntersection().

Referenced by EndMerge(), Find2DVertices(), FindHammerVertices2(), and FitVertex().

   {
     TrajIntersection(tp1, tp2, pos[0], pos[1]);
   } // TrajIntersection

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

Definition at line 2304 of file Utils.cxx.

References tca::TrajPoint::Dir, tca::TrajPoint::Pos, and s.

Referenced by TrajIntersection().

   {
     // returns the intersection position, (x,y), of two trajectory points
     
     x = -9999; y = -9999;
     
     double arg1 = tp1.Pos[0] * tp1.Dir[1] - tp1.Pos[1] * tp1.Dir[0];
     double arg2 = tp2.Pos[0] * tp1.Dir[1] - tp2.Pos[1] * tp1.Dir[0];
     double arg3 = tp2.Dir[0] * tp1.Dir[1] - tp2.Dir[1] * tp1.Dir[0];
     if(arg3 == 0) return;
     double s = (arg1 - arg2) / arg3;
     
     x = (float)(tp2.Pos[0] + s * tp2.Dir[0]);
     y = (float)(tp2.Pos[1] + s * tp2.Dir[1]);
     
   } // TrajIntersection

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

Definition at line 2891 of file Utils.cxx.

References tca::Trajectory::EndPt, tca::TrajPoint::Hits, tca::Trajectory::Pts, and tca::TrajPoint::UseHit.

Referenced by DotProd(), and UpdateTraj().

   {
     // Returns true if the trajectory has low hit multiplicity and is in a
     // clean environment
     unsigned short nUsed = 0;
     unsigned short nTotHits = 0;
     for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       TrajPoint& tp = tj.Pts[ipt];
       nTotHits += tp.Hits.size();
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         if(tp.UseHit[ii]) ++nUsed;
       } // ii
     } // ipt
     if(nTotHits == 0) return false;
     float fracUsed = (float)nUsed / (float)nTotHits;
     if(prt) mf::LogVerbatim("TC")<<"TrajIsClean: nTotHits "<<nTotHits<<" nUsed "<<nUsed<<" fracUsed "<<fracUsed;
     
     if(fracUsed > 0.9) return true;
     return false;
     
   } // TrajIsClean

float tca::TrajLength ( Trajectory & tj )

Definition at line 2337 of file Utils.cxx.

References tca::Trajectory::EndPt, and tca::Trajectory::Pts.

Referenced by AttachTrajToVertex(), EndMerge(), Find2DVertices(), MakeJunkVertices(), and PDGCodeVote().

   {
     float len = 0, dx, dy;
     unsigned short ipt;
     unsigned short prevPt = tj.EndPt[0];
     for(ipt = tj.EndPt[0] + 1; ipt < tj.EndPt[1] + 1; ++ipt) {
       if(tj.Pts[ipt].Chg == 0) continue;
       dx = tj.Pts[ipt].Pos[0] - tj.Pts[prevPt].Pos[0];
       dy = tj.Pts[ipt].Pos[1] - tj.Pts[prevPt].Pos[1];
       len += sqrt(dx * dx + dy * dy);
       prevPt = ipt;
     }
     return len;
   } // TrajLength

float tca::TrajPointSeparation	(	TrajPoint &	tp1,
		TrajPoint &	tp2
	)

Definition at line 2368 of file Utils.cxx.

References tca::TrajPoint::Pos.

Referenced by EndMerge(), GottaKink(), MaskTrajEndPoints(), tca::TruthMatcher::MatchTruth(), MCSMom(), MCSThetaRMS(), and StepAway().

   {
     // 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	(	TCSlice &	slc,
		TrajPoint const &	tp,
		Trajectory const &	tj,
		unsigned short &	closePt,
		float &	minSep
	)

Definition at line 2155 of file Utils.cxx.

References tca::Trajectory::EndPt, tca::TrajPoint::Pos, and tca::Trajectory::Pts.

Referenced by CompleteIncomplete3DVertices(), FindHammerVertices(), FindHammerVertices2(), tca::TrajClusterAlg::FindMissedVxTjs(), and MergeAndStore().

   {
     // Finds the point, ipt, on trajectory tj that is closest to trajpoint tp
     float best = minSep * minSep;
     closePt = USHRT_MAX;
     float dw, dt, dp2;
     unsigned short ipt;
     for(ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
       dw = tj.Pts[ipt].Pos[0] - tp.Pos[0];
       dt = tj.Pts[ipt].Pos[1] - tp.Pos[1];
       dp2 = dw * dw + dt * dt;
       if(dp2 < best) {
         best = dp2;
         closePt = ipt;
       }
     } // ipt
     minSep = sqrt(best);
   } // TrajPointTrajDOCA

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

Definition at line 2029 of file TCVertex.cxx.

References tca::TrajPoint::AngErr, tca::TrajPoint::Dir, tca::TrajPoint::HitPosErr2, PointTrajDOCA(), tca::VtxStore::Pos, tca::TrajPoint::Pos, tca::VtxStore::PosErr, and PosSep2().

Referenced by AttachTrajToVertex(), and FitVertex().

   {
     // Calculates the position pull between a trajectory point and a vertex
     
     // impact parameter between them
     double ip = PointTrajDOCA(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	(	TCSlice &	slc,
		const Trajectory &	tj1,
		const Trajectory &	tj2,
		unsigned short &	ipt1,
		unsigned short &	ipt2,
		float &	minSep
	)

Definition at line 2175 of file Utils.cxx.

References TrajTrajDOCA().

Referenced by EndMerge(), Find2DVertices(), FindCots(), FindNearbyTjs(), InShowerProb(), and TagShowerLike().

   {
     return TrajTrajDOCA(slc, tj1, tj2, ipt1, ipt2, minSep, false);
   } // TrajTrajDOCA

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

Definition at line 2181 of file Utils.cxx.

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

Referenced by DefineTjParents(), TagDeltaRays(), and TrajTrajDOCA().

   {
     // Find the Distance Of Closest Approach between two trajectories less than minSep
     // start with some rough cuts to minimize the use of the more expensive checking. This
     // function returns true if the DOCA is less than minSep
     for(unsigned short iwt = 0; iwt < 2; ++iwt) {
       // Apply box cuts on the ends of the trajectories
       // The Lo/Hi wire(time) at each end of tj1
       float wt0 = tj1.Pts[tj1.EndPt[0]].Pos[iwt];
       float wt1 = tj1.Pts[tj1.EndPt[1]].Pos[iwt];
       float lowt1 = wt0;
       float hiwt1 = wt1;
       if(wt1 < lowt1) {
         lowt1 = wt1;
         hiwt1 = wt0;
       }
       // The Lo/Hi wire(time) at each end of tj2
       wt0 = tj2.Pts[tj2.EndPt[0]].Pos[iwt];
       wt1 = tj2.Pts[tj2.EndPt[1]].Pos[iwt];
       float lowt2 = wt0;
       float hiwt2 = wt1;
       if(wt1 < lowt2) {
         lowt2 = wt1;
         hiwt2 = wt0;
       }
       // Check for this configuration
       //  loWire1.......hiWire1   minSep  loWire2....hiWire2
       //  loTime1.......hiTime1   minSep  loTime2....hiTime2
       if(lowt2 > hiwt1 + minSep) return false;
       // and the other
       if(lowt1 > hiwt2 + minSep) return false;
     } // iwt
 
     float best = minSep * minSep;
     ipt1 = 0; ipt2 = 0;
     float dwc = 0;
     bool isClose = false;
     for(unsigned short i1 = tj1.EndPt[0]; i1 < tj1.EndPt[1] + 1; ++i1) {
       for(unsigned short i2 = tj2.EndPt[0]; i2 < tj2.EndPt[1] + 1; ++i2) {
         if(considerDeadWires) dwc = DeadWireCount(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 4318 of file TCShower.cxx.

References tca::TCSlice::cots, tca::Trajectory::ID, kKilled, kShowerTj, kUsedHits, tca::Trajectory::Pts, PutTrajHitsInVector(), tca::TCSlice::slHits, ss, and tca::TCSlice::tjs.

Referenced by Finish3DShowers().

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

References tca::Trajectory::AlgMod, tca::Trajectory::CTP, DecodeCTP(), tca::Trajectory::EndPt, tca::Trajectory::ID, kNewStpCuts, kTEP, NumPtsWithCharge(), tca::TCSlice::nWires, tca::Trajectory::PDGCode, geo::PlaneID::Plane, PrintTrajectory(), tca::Trajectory::Pts, SetEndPoints(), tca::Trajectory::StepDir, tcc, UnsetUsedHits(), tca::TCConfig::useAlg, and tca::TCSlice::wireHitRange.

Referenced by CheckTraj(), FixTrajBegin(), and IsGhost().

   {
     // Trim the hits off the end until there are at least MinPts consecutive hits at the end
     // and the fraction of hits on the trajectory exceeds fQualityCuts[0]
     // Minimum length requirement accounting for dead wires where - denotes a wire with a point
     // and D is a dead wire. Here is an example with minPts = 3
     //  ---DDDDD--- is OK
     //  ----DD-DD-- is OK
     //  ----DDD-D-- is OK
     //  ----DDDDD-- is not OK
     
     if(!tcc.useAlg[kTEP]) return;
     if(tcc.useAlg[kNewStpCuts] && tj.PDGCode == 111) return;
     
     unsigned short npwc = NumPtsWithCharge(slc, tj, false);
     short minPts = fQualityCuts[1];
     if(minPts < 1) return;
     if(npwc < minPts) return;
     
     // handle short tjs
     if(npwc == minPts + 1) {
       unsigned short endPt1 = tj.EndPt[1];
       auto& tp = tj.Pts[endPt1];
       auto& ptp = tj.Pts[endPt1 - 1];
       // remove the last point if the previous point has no charge or if
       // it isn't on the next wire
       float dwire = std::abs(ptp.Pos[0] - tp.Pos[0]);
       if(ptp.Chg == 0 || dwire > 1.1) {
         UnsetUsedHits(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 adjacent points on adjacent wires
       unsigned short nadj = 0;
       unsigned short npwc = 0;
       for(short ipt = lastPt - minPts; ipt < lastPt; ++ipt) {
         if(ipt < 2) break;
         // the current point
         auto& tp = tj.Pts[ipt];
         // the previous point
         auto& ptp = tj.Pts[ipt - 1];
         if(tp.Chg > 0 && ptp.Chg > 0) {
           ++npwc;
           if(std::abs(tp.Pos[0] - ptp.Pos[0]) < 1.5) ++nadj;
         }
       } // ipt
       float ntpwc = NumPtsWithCharge(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(tcc.useAlg[kNewStpCuts]) {
         // use new cuts
         if(hitFrac > fQualityCuts[0] && ntpwc > minPts) break;
       } else {
         if(hitFrac > fQualityCuts[0] && npwc == minPts && nadj == minPts) break;
       }
     } // lastPt
     
     // trim the last point if it just after a dead wire.
     if(tj.Pts[lastPt].Pos[0] > -0.4) {
       unsigned int prevWire = std::nearbyint(tj.Pts[lastPt].Pos[0]);
       if(tj.StepDir > 0) {
         --prevWire;
       } else {
         ++prevWire;
       }
       if(prt) {
         mf::LogVerbatim("TC")<<fcnLabel<<"-TEP: is prevWire "<<prevWire<<" dead? ";
       }
       unsigned short plane = DecodeCTP(tj.CTP).Plane;
       if(prevWire < slc.nWires[plane] && slc.wireHitRange[plane][prevWire].first == -1) --lastPt;
     } // valid Pos[0]
     
     // Nothing needs to be done
     if(lastPt == tj.EndPt[1]) {
       if(prt) mf::LogVerbatim("TC")<<fcnLabel<<"-TEPo: Tj is OK";
       return;
     }
     
     // clear the points after lastPt
     for(unsigned short ipt = lastPt + 1; ipt <= tj.EndPt[1]; ++ipt) UnsetUsedHits(slc, tj.Pts[ipt]);
     SetEndPoints(tj);
     tj.AlgMod[kTEP] = true;
     if(prt) {
       fcnLabel += "-TEPo";
       PrintTrajectory(fcnLabel, slc, tj, USHRT_MAX);
     }
     
   } // TrimEndPts

float tca::TwoTPAngle	(	TrajPoint &	tp1,
		TrajPoint &	tp2
	)

Definition at line 2407 of file Utils.cxx.

References tca::TrajPoint::Pos.

   {
     // Calculates the angle of a line between two TPs
     float dw = tp2.Pos[0] - tp1.Pos[0];
     float dt = tp2.Pos[1] - tp1.Pos[1];
     return atan2(dw, dt);
   } // TwoTPAngle

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

Definition at line 1162 of file Utils.cxx.

References tca::TrajPoint::Chg, tca::TrajPoint::Hits, tca::TCSlice::slHits, and tca::TrajPoint::UseHit.

Referenced by CheckHiMultEndHits(), CheckHiMultUnusedHits(), CheckTraj(), ChkChgAsymmetry(), ChkStopEndPts(), FillGaps(), FindSoftKink(), FixTrajBegin(), IsGhost(), MaskBadTPs(), MaskTrajEndPoints(), StepAway(), TrimEndPts(), and UpdateTraj().

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

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

Definition at line 2635 of file StepUtils.cxx.

References tca::TrajPoint::Chg, tca::TrajPoint::DeltaRMS, tca::Trajectory::EndPt, tca::TrajPoint::NTPsFit, PointTrajDOCA(), and tca::Trajectory::Pts.

Referenced by UpdateStiffEl(), and UpdateTraj().

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

void tca::UpdateMatchStructs	(	TCSlice &	slc,
		int	oldTj,
		int	newTj
	)

Definition at line 160 of file PFPUtils.cxx.

References detinfo::DetectorProperties::ConvertTicksToX(), DecodeCTP(), tca::TCConfig::detprop, tca::TCSlice::mallTraj, tca::TCSlice::pfps, tcc, tca::TCSlice::tjs, and tca::TCConfig::unitsPerTick.

Referenced by MergeAndStore(), MergePFPTjs(), ReverseTraj(), and SplitTraj().

   {
     // Replaces tjid and ipt references in slc.matchVec and slc.pfps from
     // oldTj to newTj. This function is called when Tjs are split or merged
     // or if a Tj is reversed (in which case oldTj = newTj).
     // The method used is to match the trajectory point positions
     if(oldTj <= 0 || oldTj > (int)slc.tjs.size()) return;
     if(newTj <= 0 || newTj > (int)slc.tjs.size()) return;
     if(slc.mallTraj.empty() && slc.pfps.empty()) return;
     
     // convert from int to unsigned short
     int oldtjid = oldTj;
     int newtjid = newTj;
     auto& ntj = slc.tjs[newTj - 1];
     unsigned short npts = ntj.EndPt[1] - ntj.EndPt[0] + 1;
     // put the X positions of the new Tj into a vector for matching
     std::vector<float> xpos(ntj.Pts.size());
     geo::PlaneID planeID = DecodeCTP(ntj.CTP);
     for(unsigned short npt = ntj.EndPt[0]; npt <= ntj.EndPt[1]; ++npt) {
       auto& ntp = ntj.Pts[npt];
       if(ntp.Chg <= 0) continue;
       xpos[npt] = tcc.detprop->ConvertTicksToX(ntp.Pos[1]/tcc.unitsPerTick, planeID);
     } // npt
     
     if(!slc.mallTraj.empty()) {
       for(unsigned int ipt = 0; ipt < slc.mallTraj.size(); ++ipt) {
         auto& tj2pt = slc.mallTraj[ipt];
         if(tj2pt.id > slc.tjs.size()) continue;
         if(tj2pt.id != oldtjid) continue;
         // Found the old Tj. Now find the point
         for(unsigned short npt = ntj.EndPt[0]; npt <= ntj.EndPt[1]; ++npt) {
           auto& ntp = ntj.Pts[npt];
           if(ntp.Chg <= 0) continue;
           if(std::nearbyint(ntp.Pos[0]) == tj2pt.wire && xpos[npt] > tj2pt.xlo && xpos[npt] < tj2pt.xhi) {
             tj2pt.id = newtjid;
             tj2pt.ipt = npt;
             tj2pt.npts = npts;
             break;
           } // points match
         } // npt
       } // ipt
     } // !slc.mallTraj.empty()
     
     // Update pfp space points
     if(!slc.pfps.empty()) {
       for(auto& pfp : slc.pfps) {
         for(auto& tp3 : pfp.Tp3s) {
           // check each of the Tj2Pts associated with this space point
           for(auto& tj2pt : tp3.Tj2Pts) {
             if(tj2pt.id > slc.tjs.size()) continue;
             if(tj2pt.id != oldtjid) continue;
             // look for the corresponding point (wire) on the new Tj
             for(unsigned short npt = ntj.EndPt[0]; npt <= ntj.EndPt[1]; ++npt) {
               auto& ntp = ntj.Pts[npt];
               if(std::nearbyint(ntp.Pos[0]) == tj2pt.wire && xpos[npt] > tj2pt.xlo && xpos[npt] < tj2pt.xhi) {
                 tj2pt.id = newtjid;
                 tj2pt.ipt = npt;
                 tj2pt.npts = npts;
                 break;
               }
             } // npt
           } // tj2pt
         } // tp3
       } // pfp
     } // pfps exists
 
   } // UpdateMatchStructs

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

Definition at line 1033 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()) {
 //      std::cout<<fcnLabel<<" 2S"<<ss.ID<<" doesn't need an update\n";
       return true;
     }
 
     // initialize the variables that will be defined in this function
     ss.Energy = 0; // This is just ShowerEnergy(stj.TotChg) and could be deleted
     ss.AspectRatio = 10;
     // Direction FOM (0 = good). This is a property of the shower shape and is not
     // defined by the presence or absence of a parent tj start point
     ss.DirectionFOM = 10;
     // Total charge of all hits in the shower
     stj.TotChg = 0;
     for(auto& stp : stj.Pts) {
       // Shower start, charge center, and shower end
       stp.Pos = {{0.0, 0.0}};
       // Charge weighted average of hits this section (TP) along the shower
       stp.HitPos = {{0.0, 0.0}};
       // Direction from the start to the charge center - same for all TPs
       stp.Dir = {{0.0, 0.0}};
       // Hit charge in each section
       stp.Chg = 0;
       // transverse rms of hit positions relative to HitPos in this section
       stp.DeltaRMS = 0;
       // number of hits in this section
       stp.NTPsFit = 0;
     } // stp
     
     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].length = shpt.RotPos[0];
       ++indx;
     } // shpt
     std::sort(sortVec.begin(), sortVec.end(), lessThan);
     // put the points vector into the sorted order
     auto tPts = ss.ShPts;
     for(unsigned short ii = 0; ii < ss.ShPts.size(); ++ii) ss.ShPts[ii] = tPts[sortVec[ii].index];
     
     // Calculate the aspect ratio
     Point2_t alongTrans {{0.0, 0.0}};
     for(auto& shpt : ss.ShPts) {
       alongTrans[0] += shpt.Chg * std::abs(shpt.RotPos[0]);
       alongTrans[1] += shpt.Chg * std::abs(shpt.RotPos[1]);
     } // shpt
     alongTrans[0] /= stj.TotChg;
     alongTrans[1] /= stj.TotChg;
     if(alongTrans[1] == 0) return false;
     ss.AspectRatio = alongTrans[1] / alongTrans[0];
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" 2S"<<ss.ID<<" AspectRatio "<<ss.AspectRatio;
     
     // analyze the charge in three sections. Fill the stj HitPos and find DeltaRMS
     if(!AnalyzeRotPos(fcnLabel, 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 1230 of file TCShower.cxx.

Referenced by AddPFP(), AddTj(), AddTjsInsideEnvelope(), CompleteIncompleteShower(), FindParent(), FindShowers3D(), Match2DShowers(), MergeShowers(), MergeShowersAndStore(), Reconcile3D(), RemovePFP(), RemoveTj(), and SetParent().

   {
     // Updates the 3D shower presumably because the 2D showers were changed or need to be updated. 
     // This function returns false if there was a failure.
     
     if(ss3.ID == 0) return false;
     if(ss3.CotIDs.size() < 2) return false;
     
     std::string fcnLabel = inFcnLabel + ".U3S";
     
     // see if any of the 2D showers need an update
     for(auto cid : ss3.CotIDs) {
       auto& ss = 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
     
     for(unsigned short ii = 0; ii < ss3.CotIDs.size() - 1; ++ii) {
       unsigned short ciid = ss3.CotIDs[ii];
       auto& iss = slc.cots[ciid - 1];
       // make a local copy of the trajectory so we can replace Pos with HitPos = charge center
       auto istj = slc.tjs[iss.ShowerTjID - 1];
       for(auto& tp : istj.Pts) tp.Pos = tp.HitPos;
       for(unsigned short jj = ii + 1; jj < ss3.CotIDs.size(); ++jj) {
         unsigned short cjid = ss3.CotIDs[jj];
         auto& jss = slc.cots[cjid - 1];
         auto jstj = slc.tjs[jss.ShowerTjID - 1];
         for(auto& tp : jstj.Pts) tp.Pos = tp.HitPos;
         TrajPoint3 tp3;
         for(unsigned short ipt = 0; ipt < 3; ++ipt) {
           if(!MakeTp3(slc, istj.Pts[ipt], jstj.Pts[ipt], tp3, true)) continue;
           double ptchg = 0.5 * (istj.Pts[ipt].Chg + jstj.Pts[ipt].Chg);
           chg[ipt] += ptchg;
           for(unsigned short xyz = 0; xyz < 3; ++xyz) {
             pos[ipt][xyz] += ptchg * tp3.Pos[xyz];
             dir[xyz] += ptchg * tp3.Dir[xyz];
           } // xyz
         } // ipt
       } // jj
     } // ii
     
     unsigned short nok = 0;
     for(unsigned short ipt = 0; ipt < 3; ++ipt) {
       if(chg[ipt] == 0) continue;
       for(unsigned short xyz = 0; xyz < 3; ++xyz) pos[ipt][xyz] /= chg[ipt];
       SetMag(dir, 1);
       ++nok;
     } // ipt
     
     if(nok != 3) {
 //      if(prt) std::cout<<fcnLabel<<" ********* 3S"<<ss3.ID<<" Can't find 3 points that match in 3D. \n";
       return false;
     }
     ss3.ChgPos = pos[1];
     
     if(ss3.ParentID > 0) {
       // There is a 3D-matched pfp at the shower start. The end that is farthest away from the
       // shower center should be shower start
       auto& pfp = slc.pfps[ss3.ParentID - 1];
       unsigned short pend = FarEnd(slc, pfp, ss3.ChgPos);
       ss3.Start = pfp.XYZ[pend];
       // TODO: use charge weighted average of shower direction and pfp direction?
       ss3.Dir = dir;
     } else {
       ss3.Dir = dir;
       ss3.Start = pos[0];
     }
     // define the end
     ss3.End = pos[2];
     ss3.Len = PosSep(ss3.Start, ss3.End);
     
     // dE/dx, energy, etc
     for(auto cid : ss3.CotIDs) {
       auto& ss = 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 633 of file StepUtils.cxx.

References tca::TrajPoint::AngleCode, tca::TCConfig::dbgStp, tca::TrajPoint::Delta, tca::Trajectory::EndPt, tca::TrajPoint::FitChi, FitTraj(), tca::TrajPoint::HitPos, kStiffEl, tca::Trajectory::MCSMom, MCSMom(), tca::Trajectory::NeedsUpdate, tca::TrajPoint::NTPsFit, tca::Trajectory::PDGCode, PointTrajDOCA(), tca::Trajectory::Pts, tca::Trajectory::Strategy, tcc, UpdateDeltaRMS(), and UpdateTjChgProperties().

Referenced by UpdateTraj().

   {
     // 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);
 //    SetAngleCode(lastTP);
     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 3196 of file Utils.cxx.

References tca::Trajectory::AlgMod, tca::TCEvent::allHits, tca::Trajectory::AveChg, tca::Trajectory::ChgRMS, evd::details::end(), tca::Trajectory::EndPt, evt, kEnvNearTj, kEnvOverlap, kEnvUnusedHits, kHaloTj, kKilled, kPhoton, tca::Trajectory::NeedsUpdate, tca::TCConfig::nPtsAve, tca::Trajectory::Pts, tca::TCSlice::slHits, tcc, tca::Trajectory::TotChg, tca::Trajectory::VtxID, and tca::TCSlice::vtxs.

Referenced by AddLAHits(), ChkStopEndPts(), DotProd(), Forecast(), MaskedHitsOK(), MaxChargeAsymmetry(), SplitTraj(), StoreTraj(), UpdateStiffEl(), UpdateTraj(), and UpdateVxEnvironment().

   {
     // Updates properties of the tj that are affected when the TP environment
     // is changed. The most likely reason for a change is when the tj is attached to a
     // vertex in which case the Environment kEnvOverlap bit may be set by the UpdateVxEnvironment
     // function in which case this function is called.
     // The kEnvNearShower bit may be set by TagShowerTjs but this doesn't affect the
     // calculation of the properties of this Tj.tcc.maxPos0 This function simply sets the kEnvUnusedHits bit
     // for all TPs. 
     if(tj.AlgMod[kKilled] || tj.AlgMod[kHaloTj]) return;
 
     std::string fcnLabel = inFcnLabel + ".UpTjProp";
 
     // first (un)set some bits
     for(auto& tp : tj.Pts) {
       if(tp.Chg <= 0) continue;
       tp.Environment[kEnvUnusedHits] = false;
       for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
         if(tp.UseHit[ii]) continue;
         unsigned int iht = tp.Hits[ii];
         if(slc.slHits[iht].InTraj == 0) {
           tp.Environment[kEnvUnusedHits] = true;
         } else {
           tp.Environment[kEnvNearTj] = true;
         }
       } // ii
     } // tp
     
     // Update the tj charge variables. The concept is explained by this graphic where
     // each column is a wire, Q = a TP with charge, q = a TP with charge that is an
     // EnvOverlap region, x = a wire that has a TP with Chg = 0 or a wire that has no TP 
     // because the wire is dead, o = an EnvOverlap region, V = vertex attached to end. You should
     // imagine that all 3 tjs come from the same vertex
     //   01234567890123456789   npwc  cnt range
     //   VooooQQQQxxxQQQ          7    7   0 - 14
     //   VqqqqQQQQxxxQQQQQQQQ    16   12   0 - 19
     //   VooQQQ                   3    3   0 - 5
     // The average is first calculated using Ave = sum(Q) / npwc
     // TotChg is calculated using 
     tj.TotChg = 0;
     tj.AveChg = 0;
     tj.ChgRMS = 0.5;
     
     // These variables are used to calculate the average and rms using valid points with charge
     double vcnt = 0;
     double vsum = 0;
     double vsum2 = 0;
     // 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;
       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;
     
     // 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::UpdateTp3s	(	TCSlice &	slc,
		PFPStruct &	pfp,
		int	oldTj,
		int	newTj
	)

Definition at line 229 of file PFPUtils.cxx.

References detinfo::DetectorProperties::ConvertTicksToX(), DecodeCTP(), tca::TCConfig::detprop, tca::TCSlice::mallTraj, tcc, tca::TCSlice::tjs, tca::PFPStruct::Tp3s, and tca::TCConfig::unitsPerTick.

Referenced by MergePFPTjs().

   {
     // Replaces occurrences of oldTj with newTj in the pfp vector of Tp3s
     if(oldTj <= 0 || oldTj > (int)slc.tjs.size()) return;
     if(newTj <= 0 || newTj > (int)slc.tjs.size()) return;
     if(slc.mallTraj.empty() && pfp.Tp3s.empty()) return;
     
     // convert from int to unsigned short
     unsigned short oldtjid = oldTj;
     unsigned short newtjid = newTj;
     auto& ntj = slc.tjs[newTj - 1];
     unsigned short npts = ntj.EndPt[1] - ntj.EndPt[0] + 1;
     // put the X positions of the new Tj into a vector for matching
     std::vector<float> xpos(ntj.Pts.size());
     geo::PlaneID planeID = DecodeCTP(ntj.CTP);
     for(unsigned short npt = ntj.EndPt[0]; npt <= ntj.EndPt[1]; ++npt) {
       auto& ntp = ntj.Pts[npt];
       if(ntp.Chg <= 0) continue;
       xpos[npt] = tcc.detprop->ConvertTicksToX(ntp.Pos[1]/tcc.unitsPerTick, planeID);
     } // npt
 
     for(auto& tp3 : pfp.Tp3s) {
       // check each of the Tj2Pts associated with this space point
       for(auto& tj2pt : tp3.Tj2Pts) {
         if(tj2pt.id > slc.tjs.size()) continue;
         if(tj2pt.id != oldtjid) continue;
         // look for the corresponding point (wire) on the new Tj
         for(unsigned short npt = ntj.EndPt[0]; npt <= ntj.EndPt[1]; ++npt) {
           auto& ntp = ntj.Pts[npt];
           if(std::nearbyint(ntp.Pos[0]) == tj2pt.wire && xpos[npt] > tj2pt.xlo && xpos[npt] < tj2pt.xhi) {
             tj2pt.id = newtjid;
             tj2pt.ipt = npt;
             tj2pt.npts = npts;
             break;
           }
         } // npt
       } // tj2pt
     } // tp3
     
   } // UpdateTp3s

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

Definition at line 655 of file StepUtils.cxx.

References tca::Trajectory::AlgMod, tca::TrajPoint::AngErr, tca::TrajPoint::AngleCode, tca::TrajPoint::Chg, tca::Trajectory::CTP, tca::TCConfig::dbgStp, DeadWireCount(), DefineHitPos(), tca::TrajPoint::Delta, tca::TrajPoint::Dir, tca::Trajectory::EndPt, tca::TrajPoint::FitChi, FitTraj(), tca::TrajPoint::HitPos, kNewStpCuts, kRvPrp, kSlowing, kStiffEl, MaskBadTPs(), tca::Trajectory::MaskedLastTP, tca::TCConfig::maxChi, tca::Trajectory::MCSMom, MCSMom(), tca::TCConfig::minPtsFit, tca::TCConfig::muonTag, tca::Trajectory::NeedsUpdate, tca::TrajPoint::NTPsFit, NumPtsWithCharge(), tca::Trajectory::Pass, tca::Trajectory::PDGCode, PointTrajDOCA(), tca::TrajPoint::Pos, tca::Trajectory::Pts, SetAngleCode(), SetEndPoints(), tca::Trajectory::Strategy, tcc, TrajIsClean(), UnsetUsedHits(), UpdateDeltaRMS(), UpdateStiffEl(), UpdateTjChgProperties(), and tca::TCConfig::useAlg.

Referenced by CheckHiMultUnusedHits(), and StepAway().

   {
     // 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];
     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.6 * tj.MCSMom;
       if(tcc.useAlg[kNewStpCuts]) minMCSMom = 0.5 * tj.MCSMom;
       if(lastPt > 10 && newMCSMom < minMCSMom) {
         if(tcc.dbgStp) mf::LogVerbatim("TC")<<"UpdateTraj: 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")<<"UpdateTraj: 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")<<"UpdateTraj: 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")<<"UpdateTraj: 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(tcc.useAlg[kNewStpCuts] && 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")<<"UpdateTraj: 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;
         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	(	std::string	inFcnLabel,
		TCSlice &	slc,
		VtxStore &	vx2,
		bool	prt
	)

Definition at line 3385 of file Utils.cxx.

References tca::TrajPoint::Chg, tca::VtxStore::CTP, tca::TrajPoint::Dir, evd::details::end(), tca::VtxStore::ID, kEnvOverlap, kHaloTj, kKilled, kOnDeadWire, kPhoton, MakeBareTrajPoint(), tca::VtxStore::Pos, tca::TrajPoint::Pos, PrintPos(), tca::VtxStore::Stat, tca::TCSlice::tjs, and UpdateTjChgProperties().

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

   {
     // Update the Environment each TP on trajectories near the vertex. This is called when
     // the Tj has been added to a vertex to identify nearby trajectories that contribute to
     // the charge on TPs near the vertex. 
     if(vx2.ID == 0) return;
     if(vx2.Stat[kOnDeadWire]) return;
 
     std::string fcnLabel = inFcnLabel + ".UpVxProp";
 
     if(prt) mf::LogVerbatim("TC")<<fcnLabel<<" UpdateTjEnvironment check Tjs attached to vx2 "<<vx2.ID;
     
     std::vector<int> tjlist;
     std::vector<unsigned short> tjends;
     if(vx2.Pos[0] < -0.4) return;
     unsigned int vxWire = std::nearbyint(vx2.Pos[0]);
     unsigned int loWire = vxWire;
     unsigned int hiWire = vxWire;
     for(auto& tj : 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")<<fcnLabel<<" check Tjs on wires in the range "<<loWire<<" to "<<hiWire;
     
     // create a vector of TPs between loWire and hiWire for every tj in the list
     //   wire       TP
     std::vector<std::vector<TrajPoint>> wire_tjpt;
     // companion vector of IDs
     std::vector<int> tjids;
     // populate this vector with TPs on Tjs that are in this range
     unsigned short nwires = hiWire - loWire + 1;
     for(unsigned short itj = 0; itj < tjlist.size(); ++itj) {
       auto& tj = 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<<fcnLabel<<" 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(prt) mf::LogVerbatim("TC")<<" wire "<<loWire + indx<<" npts "<<npts<<" npwc "<<npwc;
       if(npts == 0) continue;
       // all valid points have charge
       if(npwc == npts) continue;
       // re-find the valid points with charge and set the kEnvOverlap bit
       for(unsigned short itj = 0; itj < wire_tjpt.size(); ++itj) {
         if(wire_tjpt[itj][indx].Pos[0] == 0) continue;
         if(wire_tjpt[itj][indx].Chg == 0) continue;
         auto& tj = 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")<<fcnLabel<<" Set kEnvOverlap bit on T"<<tj.ID<<" ipt "<<ipt;
       } // itj
     } // indx
     
     // update the charge rms for those tjs whose environment was changed above (or elsewhere)
     for(auto tjid : tjids) {
       auto& tj = slc.tjs[tjid - 1];
       if(!tj.NeedsUpdate) continue;
       if(tj.CTP != vx2.CTP) continue;
       UpdateTjChgProperties(fcnLabel, slc, tj, prt);
     } // tjid
     
   } // UpdateVxEnvironment

bool tca::valDecreasing	(	SortEntry	c1,
		SortEntry	c2
	)

Definition at line 10 of file TCVertex.cxx.

References tca::SortEntry::val.

Referenced by FindVtxTjs(), Match3DVtxTjs(), and MergeWithVertex().

10 { return (c1.val > c2.val);}

SortEntry::val

float val

Definition: StepUtils.cxx:6

bool tca::valDecreasings	(	SortEntry	c1,
		SortEntry	c2
	)

Definition at line 12 of file PFPUtils.cxx.

References tca::SortEntry::val.

Referenced by FindPFParticles(), and FindXMatches().

12 { return (c1.val > c2.val);}

SortEntry::val

float val

Definition: StepUtils.cxx:6

bool tca::valIncreasing	(	SortEntry	c1,
		SortEntry	c2
	)

Definition at line 11 of file TCVertex.cxx.

References tca::SortEntry::val.

Referenced by Find3DVertices().

11 { return (c1.val < c2.val);}

SortEntry::val

float val

Definition: StepUtils.cxx:6

bool tca::valIncreasings	(	SortEntry	c1,
		SortEntry	c2
	)

Definition at line 13 of file PFPUtils.cxx.

References tca::SortEntry::val.

Referenced by FillmAllTraj(), and SetStart().

13 { return (c1.val < c2.val);}

SortEntry::val

float val

Definition: StepUtils.cxx:6

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

Definition at line 2064 of file TCVertex.cxx.

References tca::Vtx3Store::X, tca::Vtx3Store::XErr, tca::Vtx3Store::Y, tca::Vtx3Store::YErr, tca::Vtx3Store::Z, and tca::Vtx3Store::ZErr.

Referenced by IsCloseToVertex().

   {
     // Calculates the position pull between two vertices
     double dx = vx1.X - vx2.X;
     double dy = vx1.Y - vx2.Y;
     double dz = vx1.Z - vx2.Z;
     double dxErr2 = (vx1.XErr * vx1.XErr + vx2.XErr * vx2.XErr) / 2;
     double dyErr2 = (vx1.YErr * vx1.YErr + vx2.YErr * vx2.YErr) / 2;
     double dzErr2 = (vx1.ZErr * vx1.ZErr + vx2.ZErr * vx2.ZErr) / 2;
     dx = dx * dx / dxErr2;
     dy = dy * dy / dyErr2;
     dz = dz * dz / dzErr2;
     return (float)(sqrt(dx + dy + dz)/3);
   }

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

Definition at line 2080 of file TCVertex.cxx.

References tca::VtxStore::Pos, and tca::VtxStore::PosErr.

   {
     // Calculates the position pull between two vertices
     double dw = vx1.Pos[0] - vx2.Pos[0];
     double dt = vx1.Pos[1] - vx2.Pos[1];
     double dwErr2 = (vx1.PosErr[0] * vx1.PosErr[0] + vx2.PosErr[0] * vx2.PosErr[0]) / 2;
     double dtErr2 = (vx1.PosErr[1] * vx1.PosErr[1] + vx2.PosErr[1] * vx2.PosErr[1]) / 2;
     dw = dw * dw / dwErr2;
     dt = dt * dt / dtErr2;
     return (float)sqrt(dw + dt);
   }

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

Definition at line 2962 of file TCVertex.cxx.

References tca::Trajectory::AlgMod, tca::VtxStore::CTP, tca::TCConfig::dbg2V, tca::TCConfig::dbgAlg, debug, DecodeCTP(), evd::details::end(), tca::Trajectory::EndPt, tca::TrajPoint::Hits, tca::VtxStore::ID, tca::Trajectory::ID, kHaloTj, kKilled, kVtxHitsSwap, tca::VtxStore::NTraj, tca::DebugStuff::Plane, geo::PlaneID::Plane, PointTrajDOCA(), tca::VtxStore::Pos, PrintPos(), tca::Trajectory::Pts, SetEndPoints(), tca::TCSlice::slHits, tcc, tca::TCSlice::tjs, TpSumHitChg(), tca::TCConfig::useAlg, tca::TrajPoint::UseHit, tca::Trajectory::VtxID, and tca::TCSlice::vtxs.

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

                                                    {
     
     if(!tcc.useAlg[kVtxHitsSwap]) return;
     
     geo::PlaneID planeID = DecodeCTP(inCTP);
     
     bool prt = ((tcc.dbg2V &&  debug.Plane == (int)planeID.Plane) || tcc.dbgAlg[kVtxHitsSwap]);
     for (unsigned short iv = 0; iv < slc.vtxs.size(); ++iv){
       VtxStore& rvx = slc.vtxs[iv];
       if(rvx.CTP != inCTP) continue;
       // Only consider vertex with two trajectories
       if(rvx.NTraj != 2) continue;
       if (prt) mf::LogVerbatim("TC")<<"VtxHitsSwap: 2V"<<rvx.ID<<" Pos[0]: "<<rvx.Pos[0]<<" "<<rvx.Pos[1];
       std::array<unsigned short, 2> tjlist{{0,0}};
       for(unsigned short itj = 0; itj < slc.tjs.size(); ++itj) {
         if(slc.tjs[itj].AlgMod[kKilled] || slc.tjs[itj].AlgMod[kHaloTj]) continue;
         if(slc.tjs[itj].CTP != rvx.CTP) continue;
         Trajectory& tj = slc.tjs[itj];
         // ensure that the ID is OK so the code below doesn't choke
         for(unsigned short end = 0; end < 2; ++end) {
           if(tj.VtxID[end] == rvx.ID) {
             tjlist[end] = itj;
           }
         }
       }//all trajectories
       
       //Ignore short trajectories
       if (slc.tjs[tjlist[0]].EndPt[1]<5||
           slc.tjs[tjlist[1]].EndPt[1]<5) continue;
       
       for (unsigned short i = 0; i<2; ++i){
         
         //First check if first hit should be swapped
         Trajectory& tj0 = slc.tjs[tjlist[i]];
         Trajectory& tj1 = slc.tjs[tjlist[1-i]];
         unsigned short endPt0 = slc.tjs[tjlist[i]].EndPt[i];
         unsigned short endPt1 = slc.tjs[tjlist[1-i]].EndPt[1-i];
         //first TP on first trajectory
         float chg0 = TpSumHitChg(slc, tj0.Pts[endPt0]);
         float w0 = tj0.Pts[endPt0].Pos[0];
         //if (vtxPrt) mf::LogVerbatim("TC")<<PrintPos(slc, tj0.Pts[endPt0]);
         //second TP on first trajectory
         float chg1 = 0;
         float w1 = 0;
         unsigned short j = endPt0;
         while (j!=tj0.EndPt[1-i]){
           if (i==0) ++j;
           else --j;
           if (tj0.Pts[j].Chg){
             chg1 = TpSumHitChg(slc, tj0.Pts[j]);
             w1 = tj0.Pts[j].Pos[0];
             //if (vtxPrt) mf::LogVerbatim("TC")<<PrintPos(slc, tj0.Pts[j]);
             break;
           }
         }
         //first TP on second trajectory
         float chg2 = TpSumHitChg(slc,tj1.Pts[endPt1]);
         float w2 = tj1.Pts[endPt1].Pos[0];
         //DOCA between first TP on first TJ and first TP on second TJ
         float delta = 1000;
         for (size_t k = 0; k<tj0.Pts[endPt0].Hits.size(); ++k){
           if (!tj0.Pts[endPt0].UseHit[k]) continue;
           float this_delta = PointTrajDOCA(slc, tj0.Pts[endPt0].Hits[k], tj1.Pts[endPt1]);
           if (this_delta<delta) delta = this_delta;
         }
         //        if (vtxPrt) mf::LogVerbatim("TC")<<PrintPos(slc, tj1.Pts[endPt1]);
         //if (vtxPrt) mf::LogVerbatim("TC")<<chg0<<" "<<chg1<<" "<<chg2<<" "<<delta;
         if (chg0>0&&std::abs((chg0-chg1)/chg0)-std::abs((chg0-chg2)/chg0)>0.2&&delta<1.5&&std::abs(w2-w1)<1.5){
           if (prt) {
             mf::LogVerbatim("TC")<<" chg0 = "<<chg0<<" chg1 = "<<chg1<<" chg2 = "<<chg2<<" delta = "<<delta<<" w0 = "<<w0<<" w1 = "<<w1<<" w2 = "<<w2;
             mf::LogVerbatim("TC")<<"  Moving TP "<<PrintPos(slc, tj0.Pts[endPt0])<<" from TJ "<<tj0.ID<<" to TJ "<<tj1.ID;
           }
           //Add first TP of first trajectory to the second trajectory
           TrajPoint tp = tj0.Pts[endPt0];
           for (size_t j = 0; j<tp.Hits.size(); ++j){
             if (!tp.UseHit[j]) continue;
             slc.slHits[tp.Hits[j]].InTraj = tj1.ID;
           }
           if (i==0){
             //append to the end
             tj1.Pts.push_back(tp);
           }
           else{
             //insert at the beginning
             tj1.Pts.insert(tj1.Pts.begin(), tp);
           }
           SetEndPoints(tj1); 
           
           //Remove first TP from first trajectory
           tj0.Pts[endPt0].Chg = 0;
           for (size_t j = 0; j<tj0.Pts[endPt0].Hits.size(); ++j){
             tj0.Pts[endPt0].UseHit[j] = false;
           }
           SetEndPoints(tj0);
           tj0.AlgMod[kVtxHitsSwap] = true;
           tj1.AlgMod[kVtxHitsSwap] = true;
           break;
         }
         
         //Now Check if the beginning of the first trajectory should be moved to the second trajectory.
         j = endPt0;
         std::vector<unsigned short> tplist;
         while (j!=tj0.EndPt[1-i]){
           if (tj0.Pts[j].Chg){
             float delta = 1000;
             for (size_t k = 0; k<tj0.Pts[j].Hits.size(); ++k){
               if (!tj0.Pts[j].UseHit[k]) continue;
               float this_delta = PointTrajDOCA(slc, tj0.Pts[j].Hits[k], tj1.Pts[endPt1]);
               if (this_delta<delta) delta = this_delta;
               //if (vtxPrt) mf::LogVerbatim("TC")<<j<<" "<<k<<" "<<PrintPos(slc, tj0.Pts[j])<<" "<<PointTrajDOCA(slc, tj0.Pts[j].Hits[k], tj1.Pts[endPt1]);
             }
             if (delta < 0.3 && tj0.Pts[j].Delta > 1.0 && (j==endPt0 || !tplist.empty())){
               tplist.push_back(j);
             }
             else break;
           }
           if (i==0) ++j;
           else --j;
         }
         //if (vtxPrt) mf::LogVerbatim("TC")<<tplist.size();
         //Need at least two TPs to make this change
         if (tplist.size()>1){
           if (prt) mf::LogVerbatim("TC")<<"  Moving "<<tplist.size()<<" TPs from TJ "<<tj0.ID<<" to TJ "<<tj1.ID;
           //Append TPs to the second TJ
           for (unsigned short j = 0; j<tplist.size(); ++j){
             TrajPoint tp = tj0.Pts[tplist[j]];
             for (size_t k = 0; k<tp.Hits.size(); ++k){
               if (!tp.UseHit[k]) continue;
               slc.slHits[tp.Hits[k]].InTraj = tj1.ID;
             }
             if (i==0){
               //append to the end
               tj1.Pts.push_back(tp);
             }
             else{
               //insert at the beginning
               tj1.Pts.insert(tj1.Pts.begin(), tp);
             }
           }
           SetEndPoints(tj1); 
           
           //Remove TPs from first trajectory
           for (unsigned short j = 0; j<tplist.size(); ++j){
             tj0.Pts[tplist[j]].Chg = 0;
             for (size_t k = 0; k<tj0.Pts[tplist[j]].Hits.size(); ++k){
               tj0.Pts[tplist[j]].UseHit[k] = false;
             }
           }
           SetEndPoints(tj0);
           tj0.AlgMod[kVtxHitsSwap] = true;
           tj1.AlgMod[kVtxHitsSwap] = true;
           break;
         }
       }//loop over two trajectories
     }//loop over vertices
   }

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

Definition at line 2641 of file TCVertex.cxx.

References tca::Vtx3Store::ID, tca::TCSlice::vtxs, and tca::Vtx3Store::Vx2ID.

   {
     // Returns the most common value of Topo for the 2D vertices that are matched
     // to this 3D vertex. This **might** be a useful measure to identify neutrino interaction
     // vertices
     
     if(vx3.ID == 0) return USHRT_MAX;
     // Consider Topo values between 0 and 9
     std::array<short, 10> cnts;
     cnts.fill(0);
     for(auto vx2id : vx3.Vx2ID) {
       if(vx2id == 0) continue;
       auto& vx2 = slc.vtxs[vx2id - 1];
       if(vx2.Topo < 0 || vx2.Topo > 9) continue;
       ++cnts[vx2.Topo];
     } // vx2id
     short most = 0;
     unsigned short theMost = USHRT_MAX;
     for(unsigned short itp = 0; itp < 10; ++itp) {
       if(cnts[itp] > most) {
         most = cnts[itp];
         theMost = itp;
       }
     } // itp
     return theMost;
   } // Vx3Topo

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

Definition at line 4085 of file Utils.cxx.

References geo::CryostatID::Cryostat, DecodeCTP(), geo::TPCID::TPC, and tca::TCSlice::TPCID.

Referenced by DotProd(), and FindCloseHits().

   {
     // returns true if the passed CTP code is consistent with the CT code of the WireHitRangeVector
     geo::PlaneID planeID = DecodeCTP(inCTP);
     if(planeID.Cryostat != slc.TPCID.Cryostat) return false;
     if(planeID.TPC != slc.TPCID.TPC) return false;
     return true;
   }

unsigned short tca::WiresSkippedInCTP	(	TCSlice &	slc,
		std::vector< int > &	tjids,
		CTP_t	inCTP
	)

Definition at line 1089 of file PFPUtils.cxx.

References evd::details::end(), and tca::TCSlice::tjs.

   {
     // counts the number of wires between the end points of all Tjs in the list of tjids
     // in inCTP where there is no TP with charge
     if(tjids.empty()) return 0;
     
     // find the min and max Pos[0] positions
     float fLoWire = 1E6;
     float fHiWire = -1E6;
     for(auto tjid : tjids) {
       auto& tj = slc.tjs[tjid - 1];
       if(tj.CTP != inCTP) continue;
       for(unsigned short end = 0; end < 2; ++end) {
         float endWire = tj.Pts[tj.EndPt[end]].Pos[0];
         if(endWire < -0.4) continue;
         if(endWire < fLoWire) fLoWire = endWire;
         if(endWire > fHiWire) fHiWire = endWire;
       } // end
     } // tjid
     if(fLoWire >= fHiWire) return 0;
     unsigned int loWire = std::nearbyint(fLoWire);
     unsigned short nWires = std::nearbyint(fHiWire) - loWire + 1;
     std::vector<bool> ptOnWire(nWires, false);
     
     // count the number of points with charge on all Tjs
     float npwc = 0;
     for(auto tjid : tjids) {
       auto& tj = slc.tjs[tjid - 1];
       if(tj.CTP != inCTP) continue;
       for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
         auto& tp = tj.Pts[ipt];
         if(tp.Chg <= 0) continue;
         if(tp.Pos[0] < -0.4) continue;
         ++npwc;
         unsigned short indx = std::nearbyint(tp.Pos[0]) - loWire;
         if(indx < nWires) ptOnWire[indx] = true;
       } // ipt
     } // tjid
     if(npwc == 0) return 0;
     float nskip = 0;
     for(unsigned short indx = 0; indx < nWires; ++indx) if(!ptOnWire[indx]) ++nskip;
     return (nskip / npwc);
     
   } // WiresSkippedInCTP

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

Definition at line 2340 of file TCShower.cxx.

References tca::Trajectory::AlgMod, tca::Trajectory::ID, kComp3DVx, tca::Trajectory::VtxID, and tca::TCSlice::vtxs.

   {
     // 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 13 of file DataStructs.cxx.

Referenced by tca::TrajClusterAlg::ChkInTraj(), tca::TrajClusterAlg::GetAlgBitNames(), InTrajOK(), tca::TruthMatcher::MatchAndSum(), PrintAllTraj(), PrintT(), PrintTrajectory(), tca::TrajClusterAlg::reconfigure(), tca::TrajClusterAlg::RunTrajClusterAlg(), and StoreTraj().

constexpr unsigned int tca::Cpad = 10000

Definition at line 43 of file DataStructs.h.

Referenced by DecodeCTP().

DebugStuff tca::debug

TCEvent tca::evt

Definition at line 5 of file DataStructs.cxx.

Referenced by AddHits(), AddLooseHits(), AddTj(), AnalyzeHits(), tca::TruthMatcher::CanReconstruct(), cluster::HoughBaseAlg::ChargeInfo_t::ChargeInfo_t(), ChgFracNearPos(), lar_pandora::LArPandoraHelper::CollectSeeds(), anab::FVectorReader< T, N >::create(), art::PtrMaker< T >::create(), util::CreateAssn(), tca::TrajClusterAlg::CreateSlice(), DefineHitPos(), tca::TrajClusterAlg::DefineShTree(), evd::MCBriefPad::Draw(), evd::TQPad::Draw(), evd::CalorPad::Draw(), evd::Display3DPad::Draw(), evd::TWireProjPad::Draw(), evd::Ortho3DPad::Draw(), evd::RecoBaseDrawer::DrawShower3D(), evd::RecoBaseDrawer::DrawShowerOrtho(), evd::RecoBaseDrawer::DrawTrack3D(), evd::RecoBaseDrawer::DrawTrackOrtho(), evd::RecoBaseDrawer::DrawTrackVertexAssns2D(), DumpTj(), evd::details::RawDigitCacheDataClass::empty(), ExpectedHitsRMS(), FilldEdx(), FillGaps(), FillWireHitRange(), Find3DVertices(), FindCloseHits(), FindCloseTjs(), FindUseHits(), FindVtxTjs(), Forecast(), GetHitMultiplet(), cluster::ClusterMergeHelper::GetManager(), GetOrigin(), evdb::ButtonBar::GoTo(), evd::HeaderDrawer::Header(), HitSep2(), HitsPosTick(), HitsRMSTick(), HitTimeErr(), trkf::PMAlgTrackMaker::init(), lar_pandora::LArPandoraEventDump::PandoraData::LoadAssociation(), main(), MakeBareTrajPoint(), MakeHaloTj(), MakeJunkTraj(), MaskedHitsOK(), tca::TruthMatcher::MatchAndSum(), tca::TruthMatcher::MatchTruth(), tca::TrajClusterAlg::MergeTPHits(), tca::TrajClusterAlg::MergeTPHitsOnWire(), evdb::DisplayWindow::OpenWindow(), mvapid::MVAAlg::SumDistance2::operator()(), PFPVertexCheck(), PointTrajDOCA(), PrintHit(), PrintHitShort(), PrintTrajPoint(), cheat::BackTrackerService::priv_PrepEvent(), event::EventMaker::produce(), trkf::TrackStitcher::produce(), trkf::PMAlgTrackMaker::produce(), evd::RecoBaseDrawer::Prong2D(), cheat::BackTrackerService::provider(), cheat::ParticleInventoryService::provider(), cheat::PhotonBackTrackerService::provider(), art::PtrMaker< T >::PtrMaker(), tca::TrajClusterAlg::reconfigure(), tca::TrajClusterAlg::ReconstructAllTraj(), evdb::ScanFrame::Record(), tca::TrajClusterAlg::RunTrajClusterAlg(), evd::TWireProjPad::SaveHitList(), evd::TWireProjPad::SaveSeedList(), rndm::NuRandomService::seedEngine(), evd::TWireProjPad::SelectOneHit(), util::EventChangeTracker_t::set(), anab::FVectorWriter< 4 >::setDataTag(), evdb::EventHolder::SetEvent(), tca::TrajClusterAlg::SetInputHits(), cluster::ClusterMatchAlg::SetMCTruthModName(), SignalAtTp(), util::DetectorPropertiesServiceArgoNeuT::SimpleBoundary(), Split3DKink(), SplitTraj(), StartChgVec(), StartTraj(), StorePFP(), StoreShower(), StoreTraj(), StoreVertex(), TPHitsRMSTick(), TpSumHitChg(), TrajHitsOK(), UpdateShower(), UpdateTjChgProperties(), and detsim::SimDriftElectrons::~SimDriftElectrons().

std::vector< TCSlice > tca::slices

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

Initial value:

{
    "Signal",
    "AtKink",
    "AtVtx",
    "Bragg",
    "AtTj",
    "OutFV"
  }

Definition at line 82 of file DataStructs.cxx.

Referenced by PrintStopFlag(), and tca::TrajClusterAlg::reconfigure().

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

Initial value:

{
    "Normal",
    "StiffEl",
    "StiffMu",
    "Slowing"
  }

Definition at line 101 of file DataStructs.cxx.

Referenced by StepAway().

ShowerTreeVars tca::stv

Definition at line 8 of file DataStructs.cxx.

Referenced by tca::TrajClusterAlg::DefineShTree(), tca::TrajClusterAlg::RunTrajClusterAlg(), SaveTjInfo(), and SaveTjInfoStuff().

TCConfig tca::tcc

Definition at line 6 of file DataStructs.cxx.

std::vector< TjForecast > tca::tjfs

Definition at line 7 of file DataStructs.cxx.

Referenced by Forecast(), SetStrategy(), and StepAway().

constexpr unsigned int tca::Tpad = 10

Definition at line 42 of file DataStructs.h.

Referenced by DecodeCTP().

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

Initial value:

{
    "VtxTrjTried",
    "Fixed",
    "OnDeadWire",
    "HiVx3Score",
    "VtxTruMatch",
    "VtxMerged",
    "VtxIndPlnNoChg"
  }

Definition at line 91 of file DataStructs.cxx.

Referenced by Print2V(), and PrintAllTraj().

Classes

Typedefs

Enumerations

Functions

Variables

Data structures for the reconstruction results

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation