/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86

Bug Summary

File:	alld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h
Warning:	line 398, column 7 Null pointer passed to 2nd parameter expecting 'nonnull'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -main-file-name DCutActions.cc -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /w/halld-scifs17exp/home/sdobbs/clang/llvm-project/install/lib/clang/12.0.0 -D HAVE_CCDB -D HAVE_RCDB -D HAVE_EVIO -D HAVE_TMVA=1 -D RCDB_MYSQL=1 -D RCDB_SQLITE=1 -D SQLITE_USE_LEGACY_STRUCT=ON -I .Linux_CentOS7.7-x86_64-gcc4.8.5/libraries/ANALYSIS -I libraries/ANALYSIS -I . -I libraries -I libraries/include -I /w/halld-scifs17exp/home/sdobbs/clang/halld_recon/Linux_CentOS7.7-x86_64-gcc4.8.5/include -I external/xstream/include -I /usr/include/tirpc -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/root/root-6.08.06/include -I /w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/ccdb/ccdb_1.06.06/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/rcdb/rcdb_0.06.00/cpp/include -I /usr/include/mysql -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/sqlitecpp/SQLiteCpp-2.2.0^bs130/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/sqlite/sqlite-3.13.0^bs130/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/hdds/hdds-4.9.0/Linux_CentOS7.7-x86_64-gcc4.8.5/src -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/xerces-c/xerces-c-3.1.4/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/evio/evio-4.4.6/Linux-x86_64/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/backward -internal-isystem /usr/local/include -internal-isystem /w/halld-scifs17exp/home/sdobbs/clang/llvm-project/install/lib/clang/12.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /home/sdobbs/work/clang/halld_recon/src -ferror-limit 19 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-01-21-110224-160369-1 -x c++ libraries/ANALYSIS/DCutActions.cc

libraries/ANALYSIS/DCutActions.cc

→

1#ifdef VTRACE
2#include "vt_user.h"
3#endif

5#include "ANALYSIS/DCutActions.h"

7void DCutAction_MinTrackHits::Initialize(JEventLoop* locEventLoop)
8{
Run_Update(locEventLoop);
10}

12void DCutAction_MinTrackHits::Run_Update(JEventLoop* locEventLoop)
13{
locEventLoop->GetSingle(dParticleID);
15}


18string DCutAction_MinTrackHits::Get_ActionName(void) const
19{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinTrackHits;
return locStream.str();
23}

25bool DCutAction_MinTrackHits::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
26{
auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_Charged);
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
auto locTrackTimeBased = locChargedTrackHypothesis->Get_TrackTimeBased();

set<int> locCDCRings, locFDCPlanes;
dParticleID->Get_CDCRings(locTrackTimeBased->dCDCRings, locCDCRings);
dParticleID->Get_FDCPlanes(locTrackTimeBased->dFDCPlanes, locFDCPlanes);
unsigned int locNumTrackHits = locCDCRings.size() + locFDCPlanes.size();
if(locNumTrackHits < dMinTrackHits)
	return false;
}
return true;
41}

43string DCutAction_ThrownTopology::Get_ActionName(void) const
44{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dExclusiveMatchFlag;
return locStream.str();
48}

50void DCutAction_ThrownTopology::Initialize(JEventLoop* locEventLoop)
51{
Run_Update(locEventLoop);
53}

55void DCutAction_ThrownTopology::Run_Update(JEventLoop* locEventLoop)
56{
locEventLoop->GetSingle(dAnalysisUtilities);
58}

60bool DCutAction_ThrownTopology::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
61{
return dAnalysisUtilities->Check_ThrownsMatchReaction(locEventLoop, Get_Reaction(), dExclusiveMatchFlag);
63}

65bool DCutAction_AllTracksHaveDetectorMatch::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
66{
auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_Charged);
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
if(locChargedTrackHypothesis->Get_SCHitMatchParams() != NULL__null)
	continue;
if(locChargedTrackHypothesis->Get_TOFHitMatchParams() != NULL__null)
	continue;
if(locChargedTrackHypothesis->Get_BCALShowerMatchParams() != NULL__null)
	continue;
if(locChargedTrackHypothesis->Get_FCALShowerMatchParams() != NULL__null)
	continue;
return false;
}
return true;
82}

84string DCutAction_PIDFOM::Get_ActionName(void) const
85{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinimumConfidenceLevel;
return locStream.str();
89}

91bool DCutAction_PIDFOM::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
92{
auto locSteps = locParticleCombo->Get_ParticleComboSteps();
for(size_t loc_i = 0; loc_i < locSteps.size(); ++loc_i)
{
if((dStepPID != Unknown) && (Get_Reaction()->Get_ReactionStep(loc_i)->Get_InitialPID() != dStepPID))
	continue;
auto locParticles = locSteps[loc_i]->Get_FinalParticles_Measured(Get_Reaction()->Get_ReactionStep(loc_i), d_AllCharges);
for(size_t loc_j = 0; loc_j < locParticles.size(); ++loc_j)
{
	if((locParticles[loc_j]->PID() != dParticleID) && (dParticleID != Unknown))
		continue;
	if(ParticleCharge(dParticleID) == 0)
	{
		const DNeutralParticleHypothesis* locNeutralParticleHypothesis = static_cast<const DNeutralParticleHypothesis*>(locParticles[loc_i]);
		if((locNeutralParticleHypothesis->Get_FOM() < dMinimumConfidenceLevel) && (locNeutralParticleHypothesis->Get_NDF() > 0))
			return false;
		if(dCutNDFZeroFlag && (locNeutralParticleHypothesis->Get_NDF() == 0))
			return false;
	}
	else
	{
		const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
		if((locChargedTrackHypothesis->Get_FOM() < dMinimumConfidenceLevel) && (locChargedTrackHypothesis->Get_NDF() > 0))
			return false;
		if(dCutNDFZeroFlag && (locChargedTrackHypothesis->Get_NDF() == 0))
			return false;
	}
}
}
return true;
122}

124string DCutAction_EachPIDFOM::Get_ActionName(void) const
125{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinimumConfidenceLevel;
return locStream.str();
129}

131bool DCutAction_EachPIDFOM::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
132{
auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_AllCharges);
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
if(ParticleCharge(locParticles[loc_i]->PID()) == 0)
{
	const DNeutralParticleHypothesis* locNeutralParticleHypothesis = static_cast<const DNeutralParticleHypothesis*>(locParticles[loc_i]);
	if(dCutNDFZeroFlag && (locNeutralParticleHypothesis->Get_NDF() == 0))
		return false;
	if((locNeutralParticleHypothesis->Get_FOM() < dMinimumConfidenceLevel) && (locNeutralParticleHypothesis->Get_NDF() > 0))
		return false;
}
else
{
	const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
	if(dCutNDFZeroFlag && (locChargedTrackHypothesis->Get_NDF() == 0))
		return false;
	if((locChargedTrackHypothesis->Get_FOM() < dMinimumConfidenceLevel) && (locChargedTrackHypothesis->Get_NDF() > 0))
		return false;
}
}
return true;
154}

156string DCutAction_CombinedPIDFOM::Get_ActionName(void) const
157{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinimumConfidenceLevel;
return locStream.str();
161}

163bool DCutAction_CombinedPIDFOM::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
164{
auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_AllCharges);

unsigned int locTotalNDF = 0;
double locTotalChiSq = 0.0;
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
if(ParticleCharge(locParticles[loc_i]->PID()) == 0)
{
	const DNeutralParticleHypothesis* locNeutralParticleHypothesis = static_cast<const DNeutralParticleHypothesis*>(locParticles[loc_i]);
	if(dCutNDFZeroFlag && (locNeutralParticleHypothesis->Get_NDF() == 0))
		return false;
	locTotalNDF += locNeutralParticleHypothesis->Get_NDF();
	locTotalChiSq += locNeutralParticleHypothesis->Get_ChiSq();
}
else
{
	const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
	if(dCutNDFZeroFlag && (locChargedTrackHypothesis->Get_NDF() == 0))
		return false;
	locTotalNDF += locChargedTrackHypothesis->Get_NDF();
	locTotalChiSq += locChargedTrackHypothesis->Get_ChiSq();
}
}
return ((locTotalNDF == 0) ? true : (TMath::Prob(locTotalChiSq, locTotalNDF) >= dMinimumConfidenceLevel));
189}

191string DCutAction_CombinedTrackingFOM::Get_ActionName(void) const
192{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinimumConfidenceLevel;
return locStream.str();
196}

198bool DCutAction_CombinedTrackingFOM::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
199{
unsigned int locTotalNDF = 0;
double locTotalChiSq = 0.0;

auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_Charged);
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
auto locTrackTimeBased = (dynamic_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]))->Get_TrackTimeBased();
locTotalNDF += locTrackTimeBased->Ndof;
locTotalChiSq += locTrackTimeBased->chisq;
}

return ((locTotalNDF == 0) ? true : (TMath::Prob(locTotalChiSq, locTotalNDF) >= dMinimumConfidenceLevel));
212}

214string DCutAction_MissingMass::Get_ActionName(void) const
215{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinimumMissingMass << "_" << dMaximumMissingMass;
return locStream.str();
219}

221void DCutAction_MissingMass::Initialize(JEventLoop* locEventLoop)
222{
Run_Update(locEventLoop);
224}

226void DCutAction_MissingMass::Run_Update(JEventLoop* locEventLoop)
227{
locEventLoop->GetSingle(dAnalysisUtilities);
229}

231bool DCutAction_MissingMass::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
232{
//build all possible combinations of the included pids
set<set<size_t> > locIndexCombos = dAnalysisUtilities->Build_IndexCombos(Get_Reaction()->Get_ReactionStep(dMissingMassOffOfStepIndex), dMissingMassOffOfPIDs);

//loop over them: Must fail ALL to fail. if any succeed, return true
set<set<size_t> >::iterator locComboIterator = locIndexCombos.begin();
for(; locComboIterator != locIndexCombos.end(); ++locComboIterator)
{
DLorentzVector locMissingP4 = dAnalysisUtilities->Calc_MissingP4(Get_Reaction(), locParticleCombo, 0, dMissingMassOffOfStepIndex, *locComboIterator, Get_UseKinFitResultsFlag());
double locMissingMass = locMissingP4.M();
if((locMissingMass >= dMinimumMissingMass) && (locMissingMass <= dMaximumMissingMass))
	return true;
}

return false; //all failed
247}

249string DCutAction_MissingMassSquared::Get_ActionName(void) const
250{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinimumMissingMassSq << "_" << dMaximumMissingMassSq;
return locStream.str();
254}

256void DCutAction_MissingMassSquared::Initialize(JEventLoop* locEventLoop)
257{
locEventLoop->GetSingle(dAnalysisUtilities);
259}

261void DCutAction_MissingMassSquared::Run_Update(JEventLoop* locEventLoop)
262{
locEventLoop->GetSingle(dAnalysisUtilities);
264}


267bool DCutAction_MissingMassSquared::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
268{
//build all possible combinations of the included pids
set<set<size_t> > locIndexCombos = dAnalysisUtilities->Build_IndexCombos(Get_Reaction()->Get_ReactionStep(dMissingMassOffOfStepIndex), dMissingMassOffOfPIDs);

//loop over them: Must fail ALL to fail. if any succeed, return true
set<set<size_t> >::iterator locComboIterator = locIndexCombos.begin();
for(; locComboIterator != locIndexCombos.end(); ++locComboIterator)
{
DLorentzVector locMissingP4 = dAnalysisUtilities->Calc_MissingP4(Get_Reaction(), locParticleCombo, 0, dMissingMassOffOfStepIndex, *locComboIterator, Get_UseKinFitResultsFlag());
double locMissingMassSq = locMissingP4.M2();
if((locMissingMassSq >= dMinimumMissingMassSq) && (locMissingMassSq <= dMaximumMissingMassSq))
	return true;
}

return false; //all failed
283}

285string DCutAction_InvariantMass::Get_ActionName(void) const
286{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dInitialPID << "_" << dMinMass << "_" << dMaxMass;
return locStream.str();
290}

292void DCutAction_InvariantMass::Initialize(JEventLoop* locEventLoop)
293{
Run_Update(locEventLoop);
295}

297void DCutAction_InvariantMass::Run_Update(JEventLoop* locEventLoop)
298{
locEventLoop->GetSingle(dAnalysisUtilities);
300}

302bool DCutAction_InvariantMass::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
303{
for(size_t loc_i = 0; loc_i < locParticleCombo->Get_NumParticleComboSteps(); ++loc_i)
{
const DReactionStep* locReactionStep = Get_Reaction()->Get_ReactionStep(loc_i);
if((dInitialPID != Unknown) && (locReactionStep->Get_InitialPID() != dInitialPID))
	continue;
if((dStepIndex != -1) && (int(loc_i) != dStepIndex))
	continue;

//build all possible combinations of the included pids
set<set<size_t> > locIndexCombos = dAnalysisUtilities->Build_IndexCombos(locReactionStep, dToIncludePIDs);

//loop over them: Must fail ALL to fail. if any succeed, go to the next step
set<set<size_t> >::iterator locComboIterator = locIndexCombos.begin();
bool locAnyOKFlag = false;
for(; locComboIterator != locIndexCombos.end(); ++locComboIterator)
{
	DLorentzVector locFinalStateP4 = dAnalysisUtilities->Calc_FinalStateP4(Get_Reaction(), locParticleCombo, loc_i, *locComboIterator, Get_UseKinFitResultsFlag());
	double locInvariantMass = locFinalStateP4.M();
	if((locInvariantMass > dMaxMass) || (locInvariantMass < dMinMass))
		continue;
	locAnyOKFlag = true;
	break;
}
if(!locAnyOKFlag)
	return false;
}

return true;
332}

334string DCutAction_AllVertexZ::Get_ActionName(void) const
335{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinVertexZ << "_" << dMaxVertexZ;
return locStream.str();
339}

341bool DCutAction_AllVertexZ::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
342{
auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_Charged);
double locVertexZ;
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
locVertexZ = locParticles[loc_i]->position().Z();
if((locVertexZ < dMinVertexZ) || (locVertexZ > dMaxVertexZ))
	return false;
}
return true;
352}

354string DCutAction_ProductionVertexZ::Get_ActionName(void) const
355{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinVertexZ << "_" << dMaxVertexZ;
return locStream.str();
359}

361bool DCutAction_ProductionVertexZ::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
362{
const DParticleComboStep* locStep = locParticleCombo->Get_ParticleComboStep(0);
double locVertexZ = locStep->Get_Position().Z();
return ((locVertexZ >= dMinVertexZ) && (locVertexZ <= dMaxVertexZ));
366}

368string DCutAction_MaxTrackDOCA::Get_ActionName(void) const
369{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMaxTrackDOCA;
return locStream.str();
373}

375void DCutAction_MaxTrackDOCA::Initialize(JEventLoop* locEventLoop)
376{
Run_Update(locEventLoop);
378}

380void DCutAction_MaxTrackDOCA::Run_Update(JEventLoop* locEventLoop)
381{
locEventLoop->GetSingle(dAnalysisUtilities);
383}

385bool DCutAction_MaxTrackDOCA::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
386{
//should be improved...: the particles at a given vertex may span several steps
auto locSteps = locParticleCombo->Get_ParticleComboSteps();
for(size_t loc_i = 0; loc_i < locSteps.size(); ++loc_i)
{
if((dInitialPID != Unknown) && (Get_Reaction()->Get_ReactionStep(loc_i)->Get_InitialPID() != dInitialPID))
	continue;
auto locParticles = locSteps[loc_i]->Get_FinalParticles_Measured(Get_Reaction()->Get_ReactionStep(loc_i), d_Charged);
for(size_t loc_j = 0; loc_j < locParticles.size(); ++loc_j)
{
	for(size_t loc_k = loc_j + 1; loc_k < locParticles.size(); ++loc_k)
	{
		auto locDOCA = dAnalysisUtilities->Calc_DOCA(locParticles[loc_j], locParticles[loc_k]);
		if(locDOCA > dMaxTrackDOCA)
			return false;
	}
}
}
return true;
405}

407string DCutAction_KinFitFOM::Get_ActionName(void) const
408{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinimumConfidenceLevel;
return locStream.str();
412}

414bool DCutAction_KinFitFOM::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
415{
const DKinFitResults* locKinFitResults = locParticleCombo->Get_KinFitResults();
if(locKinFitResults == NULL__null)
return false;
return (locKinFitResults->Get_ConfidenceLevel() > dMinimumConfidenceLevel);
420}

422string DCutAction_KinFitChiSq::Get_ActionName(void) const
423{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMaximumChiSq;
return locStream.str();
427}

429bool DCutAction_KinFitChiSq::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
430{
const DKinFitResults* locKinFitResults = locParticleCombo->Get_KinFitResults();
if(locKinFitResults == NULL__null)
return false;
return (locKinFitResults->Get_ChiSq()/locKinFitResults->Get_NDF() < dMaximumChiSq);
435}

437void DCutAction_BDTSignalCombo::Initialize(JEventLoop* locEventLoop)
438{
if(dCutAction_TrueBeamParticle == nullptr)
dCutAction_TrueBeamParticle = new DCutAction_TrueBeamParticle(Get_Reaction());
dCutAction_TrueBeamParticle->Initialize(locEventLoop);
Run_Update(locEventLoop);
443}

445void DCutAction_BDTSignalCombo::Run_Update(JEventLoop* locEventLoop)
446{
locEventLoop->GetSingle(dAnalysisUtilities);
448}

450bool DCutAction_BDTSignalCombo::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
451{
452#ifdef VTRACE
VT_TRACER("DCutAction_BDTSignalCombo::Perform_Action()");
454#endif

vector<const DMCThrownMatching*> locMCThrownMatchingVector;
locEventLoop->Get(locMCThrownMatchingVector);
if(locMCThrownMatchingVector.empty())
return false; //not a simulated event
const DMCThrownMatching* locMCThrownMatching = locMCThrownMatchingVector[0];

//Check DReaction vs thrown (i.e. not combo contents)
if(!dAnalysisUtilities->Check_IsBDTSignalEvent(locEventLoop, Get_Reaction(), dExclusiveMatchFlag, dIncludeDecayingToReactionFlag))
return false;

//Do we need to pick the beam photon? If so, look for it
Particle_t locPID = Get_Reaction()->Get_ReactionStep(0)->Get_InitialPID();
if(locPID == Gamma)
{
if(!(*dCutAction_TrueBeamParticle)(locEventLoop, locParticleCombo))
	return false; //needed the true beam photon, didn't have it
}

//get & organize throwns
vector<const DMCThrown*> locMCThrowns;
locEventLoop->Get(locMCThrowns);

map<int, const DMCThrown*> locMCThrownMyIDMap; //map of myid -> thrown
for(size_t loc_i = 0; loc_i < locMCThrowns.size(); ++loc_i)
locMCThrownMyIDMap[locMCThrowns[loc_i]->myid] = locMCThrowns[loc_i];

//OK, now need to check and see if the particles have the right PID & the right parent chain
for(size_t loc_i = 0; loc_i < locParticleCombo->Get_NumParticleComboSteps(); ++loc_i)
{
const DParticleComboStep* locParticleComboStep = locParticleCombo->Get_ParticleComboStep(loc_i);
auto locReactionStep = Get_Reaction()->Get_ReactionStep(loc_i);

auto locParticles = locParticleComboStep->Get_FinalParticles_Measured(locReactionStep, d_AllCharges);
for(size_t loc_j = 0; loc_j < locParticles.size(); ++loc_j)
{
	const DMCThrown* locMCThrown = NULL__null;
	double locMatchFOM = 0.0;
	if(ParticleCharge(locParticles[loc_j]->PID()) == 0)
	{
		//check if good neutral & PID
		const DNeutralParticleHypothesis* locNeutralParticleHypothesis = static_cast<const DNeutralParticleHypothesis*>(locParticles[loc_j]);
		locMCThrown = locMCThrownMatching->Get_MatchingMCThrown(locNeutralParticleHypothesis, locMatchFOM);
		if((locMCThrown == NULL__null) || (locMatchFOM < dMinThrownMatchFOM))
			return false; //not matched
		if(((Particle_t)locMCThrown->type) != locParticles[loc_j]->PID())
			return false; //bad PID
	}
	else
	{
		//check if good track & PID
		double locMatchFOM = 0.0;
		const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_j]);
		locMCThrown = locMCThrownMatching->Get_MatchingMCThrown(locChargedTrackHypothesis, locMatchFOM);
		if((locMCThrown == NULL__null) || (locMatchFOM < dMinThrownMatchFOM))
			return false; //not matched
		if(((Particle_t)locMCThrown->type) != locParticles[loc_j]->PID())
			return false; //bad PID
	}

	//check if parent is correct
	auto locParentSearchReactionStep = locReactionStep;
	int locParentID = locMCThrown->parentid;
	int locSearchStepIndex = loc_i;

	do
	{
		if(locParentID == -1)
			return false; //parent particle is not listed: matched to knock-out particle, is wrong. bail

		if(locParentID == 0)
		{
			//parent id of 0 is directly produced
			Particle_t locInitPID = locParentSearchReactionStep->Get_InitialPID();
			if((locInitPID == phiMeson) || (locInitPID == omega))
			{
				//these particles are not constrained: check their parent step instead
				locSearchStepIndex = DAnalysis::Get_InitialParticleDecayFromIndices(Get_Reaction(), locSearchStepIndex).first;
				locReactionStep = Get_Reaction()->Get_ReactionStep(locSearchStepIndex);
				continue;
			}
			if(locInitPID != Gamma)
				return false; //was directly (photo-) produced, but not so in combo: bail
			break; //good: this is the only "good" exit point of the do-loop
		}

		const DMCThrown* locMCThrownParent = locMCThrownMyIDMap[locParentID];
		Particle_t locPID = locMCThrownParent->PID();
		if((locPID == Unknown) || IsResonance(locPID) || (locPID == omega) || (locPID == phiMeson))
		{
			//intermediate (unknown, resonance, phi, or omega) particle: go to its parent
			locParentID = locMCThrownParent->parentid;
			continue;
		}

		if(locPID != locParentSearchReactionStep->Get_InitialPID())
		{
			//the true particle was produced from a different parent
			if(!dIncludeDecayingToReactionFlag)
				return false; //will not consider intermediate decays: bail

			//it could still be BDT signal, if the thrown parent eventually came from the combo parent particle
			//treat as an intermediate decaying particle: go to its parent
			locParentID = locMCThrownParent->parentid;
			continue;
		}

		//OK, we've determined that the particle in question decayed from the correct particle.
		//HOWEVER, we need to determine whether the PARENT decayed from the correct particle (and on(back)wards until the production step)
		locParentID = locMCThrownParent->parentid;
		locSearchStepIndex = DAnalysis::Get_InitialParticleDecayFromIndices(Get_Reaction(), locSearchStepIndex).first;
		locReactionStep = Get_Reaction()->Get_ReactionStep(locSearchStepIndex);
	}
	while(true);
}
}

return true; //we made it!
573}

575DCutAction_BDTSignalCombo::~DCutAction_BDTSignalCombo(void)
576{
if(dCutAction_TrueBeamParticle != NULL__null)
delete dCutAction_TrueBeamParticle;
579}

581void DCutAction_TrueCombo::Initialize(JEventLoop* locEventLoop)
582{
if(dCutAction_TrueBeamParticle == nullptr)
dCutAction_TrueBeamParticle = new DCutAction_TrueBeamParticle(Get_Reaction());
dCutAction_TrueBeamParticle->Initialize(locEventLoop);
if(dCutAction_ThrownTopology == nullptr)
dCutAction_ThrownTopology = new DCutAction_ThrownTopology(Get_Reaction(), dExclusiveMatchFlag);
dCutAction_ThrownTopology->Initialize(locEventLoop);
589}

591void DCutAction_TrueCombo::Run_Update(JEventLoop* locEventLoop)
592{
dCutAction_TrueBeamParticle->Run_Update(locEventLoop);
dCutAction_ThrownTopology->Run_Update(locEventLoop);
595}

597bool DCutAction_TrueCombo::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
598{
599#ifdef VTRACE
VT_TRACER("DCutAction_TrueCombo::Perform_Action()");
601#endif

vector<const DMCThrownMatching*> locMCThrownMatchingVector;
locEventLoop->Get(locMCThrownMatchingVector);
if(locMCThrownMatchingVector.empty())
return false; //not a simulated event
const DMCThrownMatching* locMCThrownMatching = locMCThrownMatchingVector[0];

if(!(*dCutAction_ThrownTopology)(locEventLoop, locParticleCombo))
return false; //not the thrown topology: bail

//Do we need to pick the beam photon? If so, look for it
if(DAnalysis::Get_IsFirstStepBeam(Get_Reaction()))
{
if(!(*dCutAction_TrueBeamParticle)(locEventLoop, locParticleCombo))
	return false; //needed the true beam photon, didn't have it
}

//get & organize throwns
vector<const DMCThrown*> locMCThrowns;
locEventLoop->Get(locMCThrowns);

map<int, const DMCThrown*> locMCThrownMyIDMap; //map of myid -> thrown
for(size_t loc_i = 0; loc_i < locMCThrowns.size(); ++loc_i)
locMCThrownMyIDMap[locMCThrowns[loc_i]->myid] = locMCThrowns[loc_i];

//OK, now need to check and see if the particles have the right PID & the right parent chain
for(size_t loc_i = 0; loc_i < locParticleCombo->Get_NumParticleComboSteps(); ++loc_i)
{
const DParticleComboStep* locParticleComboStep = locParticleCombo->Get_ParticleComboStep(loc_i);
auto locReactionStep = Get_Reaction()->Get_ReactionStep(loc_i);

auto locParticles = locParticleComboStep->Get_FinalParticles_Measured(locReactionStep, d_AllCharges);
for(size_t loc_j = 0; loc_j < locParticles.size(); ++loc_j)
{
	const DMCThrown* locMCThrown = NULL__null;
	double locMatchFOM = 0.0;
	if(ParticleCharge(locParticles[loc_j]->PID()) == 0)
	{
		//check if good neutral & PID
		const DNeutralParticleHypothesis* locNeutralParticleHypothesis = static_cast<const DNeutralParticleHypothesis*>(locParticles[loc_j]);
		locMCThrown = locMCThrownMatching->Get_MatchingMCThrown(locNeutralParticleHypothesis, locMatchFOM);
		if((locMCThrown == NULL__null) || (locMatchFOM < dMinThrownMatchFOM))
			return false; //not matched
		if(((Particle_t)locMCThrown->type) != locParticles[loc_j]->PID())
			return false; //bad PID
	}
	else
	{
		//check if good track & PID
		double locMatchFOM = 0.0;
		const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_j]);
		locMCThrown = locMCThrownMatching->Get_MatchingMCThrown(locChargedTrackHypothesis, locMatchFOM);
		if((locMCThrown == NULL__null) || (locMatchFOM < dMinThrownMatchFOM))
			return false; //not matched
		if(((Particle_t)locMCThrown->type) != locParticles[loc_j]->PID())
			return false; //bad PID
	}

	//check if parent is correct
	auto locParentSearchReactionStep = locReactionStep;
	int locParentID = locMCThrown->parentid;
	int locSearchStepIndex = loc_i;

	do
	{
		if(locParentID == -1)
			return false; //parent particle is not listed: matched to knock-out particle, is wrong. bail
		if(locParentID == 0)
		{
			//parent id of 0 is directly produced
			if(locParentSearchReactionStep->Get_InitialPID() != Gamma)
				return false; //was directly (photo-) produced, but not so in combo: bail
			break; //good: this is the only "good" exit point of the do-loop
		}

		const DMCThrown* locMCThrownParent = locMCThrownMyIDMap[locParentID];
		Particle_t locPID = locMCThrownParent->PID();
		if((locPID == Unknown) || IsResonance(locPID))
		{
			//intermediate (unknown or resonance) particle: go to its parent
			locParentID = locMCThrownParent->parentid;
			continue;
		}
		if(locPID != locParentSearchReactionStep->Get_InitialPID())
			return false; //the true particle was produced from a different parent: bail

		//OK, we've determined that the particle in question decayed from the correct particle.
		//HOWEVER, we need to determine whether the PARENT decayed from the correct particle (and on(back)wards until the production step)
		locParentID = locMCThrownParent->parentid;
		locSearchStepIndex = DAnalysis::Get_InitialParticleDecayFromIndices(Get_Reaction(), locSearchStepIndex).first;
		if(locSearchStepIndex < 0)
		{
			//DReaction is not the full reaction (i.e. doesn't contain beam (e.g. only pi0 decay))
			if(dExclusiveMatchFlag)
				return false;
			break; //good
		}
		locParentSearchReactionStep = Get_Reaction()->Get_ReactionStep(locSearchStepIndex);
	}
	while(true);
}
}

return true; //we made it!
706}

708DCutAction_TrueCombo::~DCutAction_TrueCombo(void)
709{
if(dCutAction_TrueBeamParticle != NULL__null)
delete dCutAction_TrueBeamParticle;
if(dCutAction_ThrownTopology != NULL__null)
delete dCutAction_ThrownTopology;
714}

716bool DCutAction_TrueBeamParticle::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
717{
vector<const DBeamPhoton*> locBeamPhotons;
locEventLoop->Get(locBeamPhotons, "TAGGEDMCGEN");
if(locBeamPhotons.empty())
return false; //true not tagged

const DKinematicData* locKinematicData = locParticleCombo->Get_ParticleComboStep(0)->Get_InitialParticle_Measured();
if(locKinematicData == NULL__null)
return false; //initial step is not production step

const DBeamPhoton* locBeamPhoton = dynamic_cast<const DBeamPhoton*>(locKinematicData);
if(locBeamPhoton == NULL__null)
return false; //dunno how could be possible ...

double locDeltaT = fabs(locBeamPhoton->time() - locBeamPhotons[0]->time());
return ((locBeamPhoton->dSystem == locBeamPhotons[0]->dSystem) && (locBeamPhoton->dCounter == locBeamPhotons[0]->dCounter) && (locDeltaT < 1.0));
733}

735bool DCutAction_TruePID::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
736{
vector<const DMCThrownMatching*> locMCThrownMatchingVector;
locEventLoop->Get(locMCThrownMatchingVector);
const DMCThrownMatching* locMCThrownMatching = locMCThrownMatchingVector[0];

auto locSteps = locParticleCombo->Get_ParticleComboSteps();
for(size_t loc_i = 0; loc_i < locSteps.size(); ++loc_i)
{
if((dInitialPID != Unknown) && (Get_Reaction()->Get_ReactionStep(loc_i)->Get_InitialPID() != dInitialPID))
	continue;
auto locParticles = locSteps[loc_i]->Get_FinalParticles_Measured(Get_Reaction()->Get_ReactionStep(loc_i), d_AllCharges);
for(size_t loc_j = 0; loc_j < locParticles.size(); ++loc_j)
{
	if((locParticles[loc_j]->PID() != dTruePID) && (dTruePID != Unknown))
		continue;

	for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
	{
		if(ParticleCharge(dTruePID) == 0)
		{
			double locMatchFOM = 0.0;
			const DNeutralParticleHypothesis* locNeutralParticleHypothesis = static_cast<const DNeutralParticleHypothesis*>(locParticles[loc_i]);
			auto locMCThrown = locMCThrownMatching->Get_MatchingMCThrown(locNeutralParticleHypothesis, locMatchFOM);
			if((locMCThrown == NULL__null) || (locMatchFOM < dMinThrownMatchFOM))
				return false;
			if(((Particle_t)locMCThrown->type) != dTruePID)
				return false;
		}
		else
		{
			double locMatchFOM = 0.0;
			const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
			auto locMCThrown = locMCThrownMatching->Get_MatchingMCThrown(locChargedTrackHypothesis, locMatchFOM);
			if((locMCThrown == NULL__null) || (locMatchFOM < dMinThrownMatchFOM))
				return false;
			if(((Particle_t)locMCThrown->type) != dTruePID)
				return false;
		}
	}
}
}
return true;
778}

780bool DCutAction_AllTruePID::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
781{
vector<const DMCThrownMatching*> locMCThrownMatchingVector;
locEventLoop->Get(locMCThrownMatchingVector);
const DMCThrownMatching* locMCThrownMatching = locMCThrownMatchingVector[0];
const DMCThrown* locMCThrown;

auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_AllCharges);
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
if(ParticleCharge(locParticles[loc_i]->PID()) == 0)
{
	double locMatchFOM = 0.0;
	const DNeutralParticleHypothesis* locNeutralParticleHypothesis = static_cast<const DNeutralParticleHypothesis*>(locParticles[loc_i]);
	locMCThrown = locMCThrownMatching->Get_MatchingMCThrown(locNeutralParticleHypothesis, locMatchFOM);
	if((locMCThrown == NULL__null) || (locMatchFOM < dMinThrownMatchFOM))
		return false;
	if(((Particle_t)locMCThrown->type) != locParticles[loc_i]->PID())
		return false;
}
else
{
	double locMatchFOM = 0.0;
	const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
	locMCThrown = locMCThrownMatching->Get_MatchingMCThrown(locChargedTrackHypothesis, locMatchFOM);
	if((locMCThrown == NULL__null) || (locMatchFOM < dMinThrownMatchFOM))
		return false;
	if(((Particle_t)locMCThrown->type) != locParticles[loc_i]->PID())
		return false;
}
}
return true;
812}

814string DCutAction_GoodEventRFBunch::Get_ActionName(void) const
815{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dCutIfBadRFBunchFlag;
return locStream.str();
819}

821bool DCutAction_GoodEventRFBunch::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
822{
const DEventRFBunch* locEventRFBunch = locParticleCombo->Get_EventRFBunch();
return (locEventRFBunch->dTime == locEventRFBunch->dTime);
825}

827string DCutAction_TransverseMomentum::Get_ActionName(void) const
828{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMaxTransverseMomentum;
return locStream.str();
832}

834bool DCutAction_TransverseMomentum::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
835{
auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_AllCharges);

DVector3 locTotalMomentum;
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
locTotalMomentum += locParticles[loc_i]->momentum();

return (dMaxTransverseMomentum >= locTotalMomentum.Perp());
843}

845string DCutAction_TrackHitPattern::Get_ActionName(void) const
846{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinHitRingsPerCDCSuperlayer << "_" << dMinHitPlanesPerFDCPackage;
return locStream.str();
850}

852bool DCutAction_TrackHitPattern::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
853{
auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_AllCharges);

const DParticleID* locParticleID = NULL__null;
locEventLoop->GetSingle(locParticleID);

for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
auto locTrackTimeBased = locChargedTrackHypothesis->Get_TrackTimeBased();
if(!Cut_TrackHitPattern(locParticleID, locTrackTimeBased))
	return false;
}

return true;
868}

870bool DCutAction_TrackHitPattern::Cut_TrackHitPattern(const DParticleID* locParticleID, const DKinematicData* locTrack) const
871{
const DTrackTimeBased* locTrackTimeBased = dynamic_cast<const DTrackTimeBased*>(locTrack);
const DTrackWireBased* locTrackWireBased = dynamic_cast<const DTrackWireBased*>(locTrack);
const DTrackCandidate* locTrackCandidate = dynamic_cast<const DTrackCandidate*>(locTrack);

map<int, int> locNumHitRingsPerSuperlayer, locNumHitPlanesPerPackage;
if(locTrackTimeBased != NULL__null)
{
locParticleID->Get_CDCNumHitRingsPerSuperlayer(locTrackTimeBased->dCDCRings, locNumHitRingsPerSuperlayer);
locParticleID->Get_FDCNumHitPlanesPerPackage(locTrackTimeBased->dFDCPlanes, locNumHitPlanesPerPackage);
}
else if(locTrackWireBased != NULL__null)
{
locParticleID->Get_CDCNumHitRingsPerSuperlayer(locTrackWireBased->dCDCRings, locNumHitRingsPerSuperlayer);
locParticleID->Get_FDCNumHitPlanesPerPackage(locTrackWireBased->dFDCPlanes, locNumHitPlanesPerPackage);
}
else if(locTrackCandidate != NULL__null)
{
locParticleID->Get_CDCNumHitRingsPerSuperlayer(locTrackCandidate->dCDCRings, locNumHitRingsPerSuperlayer);
locParticleID->Get_FDCNumHitPlanesPerPackage(locTrackCandidate->dFDCPlanes, locNumHitPlanesPerPackage);
}
else
return false;

//CDC: find inner-most & outer-most superlayers
int locInnermostCDCSuperlayer = 10, locOutermostCDCSuperlayer = 0;
for(auto& locSuperlayerPair : locNumHitRingsPerSuperlayer)
{
if(locSuperlayerPair.second == 0)
	continue; //0 hits
if(locSuperlayerPair.first < locInnermostCDCSuperlayer)
	locInnermostCDCSuperlayer = locSuperlayerPair.first;
if(locSuperlayerPair.first > locOutermostCDCSuperlayer)
	locOutermostCDCSuperlayer = locSuperlayerPair.first;
}

//CDC: loop again, cutting
for(auto& locSuperlayerPair : locNumHitRingsPerSuperlayer)
{
if(locSuperlayerPair.first == locOutermostCDCSuperlayer)
	break; //don't check the last one: track could be leaving
if(locSuperlayerPair.first < locInnermostCDCSuperlayer)
	continue; //don't check before the first one: could be detached vertex
if(locSuperlayerPair.second < int(dMinHitRingsPerCDCSuperlayer))
	return false;
}

//FDC: find inner-most & outer-most superlayers
int locOutermostFDCPlane = 0;
for(auto& locPackagePair : locNumHitPlanesPerPackage)
{
if(locPackagePair.second == 0)
	continue; //0 hits
if(locPackagePair.first > locOutermostFDCPlane)
	locOutermostFDCPlane = locPackagePair.first;
}

//FDC: loop again, cutting
for(auto& locPackagePair : locNumHitPlanesPerPackage)
{
if(locPackagePair.first == locOutermostFDCPlane)
	break; //don't check the last one: track could be leaving
if(locPackagePair.second == 0)
	continue; //0 hits: is ok: could be curling through beamline
if(locPackagePair.second < int(dMinHitPlanesPerFDCPackage))
	return false;
}

if((locOutermostCDCSuperlayer <= 2) && locNumHitPlanesPerPackage.empty())
return false; //would have at least expected it to hit the first FDC package //is likely spurious

return true;
943}

945void DCutAction_dEdx::Initialize(JEventLoop* locEventLoop)
946{
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!! //I have no idea why this is needed, but without it it crashes.  Sigh. 
{
if(dCutMap.find(Proton) == dCutMap.end())
{
	dCutMap[Proton].first = new TF1("df_dEdxCut_ProtonLow", "exp(-1.0*[0]*x + [1]) + [2]", 0.0, 12.0);
	dCutMap[Proton].first->SetParameters(3.93024, 3.0, 1.0);
	dCutMap[Proton].second = new TF1("df_dEdxCut_ProtonHigh", "[0]", 0.0, 12.0);
	dCutMap[Proton].second->SetParameter(0, 9999999.9);
}

if(dCutMap.find(PiPlus) == dCutMap.end())
{
	dCutMap[PiPlus].first = new TF1("df_dEdxCut_PionLow", "[0]", 0.0, 12.0);
	dCutMap[PiPlus].first->SetParameter(0, -1.0);
	dCutMap[PiPlus].second = new TF1("df_dEdxCut_PionHigh", "exp(-1.0*[0]*x + [1]) + [2]", 0.0, 12.0);
	dCutMap[PiPlus].second->SetParameters(6.0, 2.80149, 2.55);
}
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
966}

968bool DCutAction_dEdx::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
969{
auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_Charged);
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
auto locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
if(!Cut_dEdx(locChargedTrackHypothesis))
	return false;
}

return true;
979}

981bool DCutAction_dEdx::Cut_dEdx(const DChargedTrackHypothesis* locChargedTrackHypothesis)
982{
auto locTrackTimeBased = locChargedTrackHypothesis->Get_TrackTimeBased();

Particle_t locPID = locChargedTrackHypothesis->PID();
if(dCutMap.find(locPID) == dCutMap.end())
return true;
auto locCutPair = dCutMap[locPID];

if(locTrackTimeBased->dNumHitsUsedFordEdx_CDC == 0)
return true;

auto locP = locTrackTimeBased->momentum().Mag();
auto locdEdx = locTrackTimeBased->ddEdx_CDC_amp*1.0E6;

return ((locdEdx >= locCutPair.first->Eval(locP)) && (locdEdx <= locCutPair.second->Eval(locP)));
997}

999string DCutAction_BeamEnergy::Get_ActionName(void) const
1000{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dMinBeamEnergy << "_" << dMaxBeamEnergy;
return locStream.str();
1004}

1006bool DCutAction_BeamEnergy::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
1007{
const DKinematicData* locInitParticle = NULL__null;
if(Get_UseKinFitResultsFlag())
locInitParticle = locParticleCombo->Get_ParticleComboStep(0)->Get_InitialParticle();
else
locInitParticle = locParticleCombo->Get_ParticleComboStep(0)->Get_InitialParticle_Measured();
if(locInitParticle == NULL__null)
return false;

double locBeamEnergy = locInitParticle->energy();
return ((locBeamEnergy >= dMinBeamEnergy) && (locBeamEnergy <= dMaxBeamEnergy));
1018}

1020string DCutAction_TrackFCALShowerEOverP::Get_ActionName(void) const
1021{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dShowerEOverPCut;
return locStream.str();
1025}

1027bool DCutAction_TrackFCALShowerEOverP::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
1028{
// For all charged tracks except e+/e-, cuts those with E/p > input value
// For e+/e-, cuts those with E/p < input value
// Does not cut tracks without a matching FCAL shower

auto locParticles = Get_UseKinFitResultsFlag() ? locParticleCombo->Get_FinalParticles(Get_Reaction(), false, false, d_Charged) : locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_Charged);
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
auto locFCALShowerMatchParams = locChargedTrackHypothesis->Get_FCALShowerMatchParams();
if(locFCALShowerMatchParams == NULL__null)
	continue;

Particle_t locPID = locChargedTrackHypothesis->PID();
const DFCALShower* locFCALShower = locFCALShowerMatchParams->dFCALShower;
double locShowerEOverP = locFCALShower->getEnergy()/locChargedTrackHypothesis->momentum().Mag();

if((locPID == Electron) || (locPID == Positron))
{
	if(locShowerEOverP < dShowerEOverPCut)
		return false;
}
else if(locShowerEOverP > dShowerEOverPCut)
	return false;
}

return true;
1055}

1057string DCutAction_TrackShowerEOverP::Get_ActionName(void) const
1058{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dDetector << "_" << dPID << "_" << dShowerEOverPCut;
return locStream.str();
1062}

1064bool DCutAction_TrackShowerEOverP::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
1065{
// For all charged tracks except e+/e-, cuts those with E/p > input value
// For e+/e-, cuts those with E/p < input value
// Does not cut tracks without a matching FCAL shower

auto locParticles = Get_UseKinFitResultsFlag() ? locParticleCombo->Get_FinalParticles(Get_Reaction(), false, false, d_Charged) : locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_Charged);
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
const DChargedTrackHypothesis* locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);

Particle_t locPID = locChargedTrackHypothesis->PID();
if(locPID != dPID)
	continue;

double locP = locChargedTrackHypothesis->momentum().Mag();
double locShowerEOverP = 0.0;
if(dDetector == SYS_FCAL)
{
	auto locFCALShowerMatchParams = locChargedTrackHypothesis->Get_FCALShowerMatchParams();
	if(locFCALShowerMatchParams == NULL__null)
		continue;

	const DFCALShower* locFCALShower = locFCALShowerMatchParams->dFCALShower;
	locShowerEOverP = locFCALShower->getEnergy()/locP;
}
else if(dDetector == SYS_BCAL)
{
	auto locBCALShowerMatchParams = locChargedTrackHypothesis->Get_BCALShowerMatchParams();
	if(locBCALShowerMatchParams == NULL__null)
		continue;

	const DBCALShower* locBCALShower = locBCALShowerMatchParams->dBCALShower;
	locShowerEOverP = locBCALShower->E/locP;
}
else
	continue; //what??

if((locPID == Electron) || (locPID == Positron))
{
	if(locShowerEOverP < dShowerEOverPCut)
		return false;
}
else if(locShowerEOverP > dShowerEOverPCut)
	return false;
}

return true;
1112}

1114string DCutAction_PIDDeltaT::Get_ActionName(void) const
1115{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dPID << "_" << dSystem << "_" << dDeltaTCut;
return locStream.str();
1119}

1121bool DCutAction_PIDDeltaT::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
1122{
//if dPID = Unknown, apply cut to all PIDs
//if dSystem = SYS_NULL, apply cut to all systems

auto locParticles = Get_UseKinFitResultsFlag() ? locParticleCombo->Get_FinalParticles(Get_Reaction(), false, false, d_AllCharges) : locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_AllCharges);
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
if((dPID != Unknown) && (locParticles[loc_i]->PID() != dPID))
	continue;

auto locChargedHypo = dynamic_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
if(locChargedHypo != nullptr)
{
	if((dSystem != SYS_NULL) && (locChargedHypo->t1_detector() != dSystem))
		continue;
1137//			double locDeltaT = locChargedHypo->time() - (locChargedHypo->t0() + (locChargedHypo->position().Z() - locVertex.Z())/SPEED_OF_LIGHT); //COMPARE: to old
	double locDeltaT = locChargedHypo->Get_TimeAtPOCAToVertex() - locChargedHypo->t0(); //UNCOMMENT WHEN DONE COMPARING
	if(fabs(locDeltaT) > dDeltaTCut)
		return false;
	continue;
}
auto locNeutralHypo = dynamic_cast<const DNeutralParticleHypothesis*>(locParticles[loc_i]);
if(locNeutralHypo != nullptr)
{
	if((dSystem != SYS_NULL) && (locNeutralHypo->t1_detector() != dSystem))
		continue;
	double locDeltaT = locParticles[loc_i]->time() - locNeutralHypo->t0();
	if(fabs(locDeltaT) > dDeltaTCut)
		return false;
	continue;
}
}

return true;
1156}

1158string DCutAction_PIDTimingBeta::Get_ActionName(void) const
1159{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dPID << "_" << dSystem << "_" << dMinBeta << "_" << dMaxBeta;
return locStream.str();
1163}

1165bool DCutAction_PIDTimingBeta::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
1166{
//if dPID = Unknown, apply cut to all PIDs
//if dSystem = SYS_NULL, apply cut to all systems

auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_AllCharges);
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
if((dPID != Unknown) && (locParticles[loc_i]->PID() != dPID))
	continue;

auto locChargedHypo = dynamic_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
if(locChargedHypo != nullptr)
{
	if((dSystem != SYS_NULL) && (locChargedHypo->t1_detector() != dSystem))
		continue;
	double locBeta = locChargedHypo->measuredBeta();
	if((locBeta < dMinBeta) || (locBeta > dMaxBeta))
		return false;
	continue;
}
auto locNeutralHypo = dynamic_cast<const DNeutralParticleHypothesis*>(locParticles[loc_i]);
if(locNeutralHypo != nullptr)
{
	if((dSystem != SYS_NULL) && (locNeutralHypo->t1_detector() != dSystem))
		continue;
	double locBeta = locNeutralHypo->measuredBeta();
	if((locBeta < dMinBeta) || (locBeta > dMaxBeta))
		return false;
	continue;
}
}

return true;
1199}

1201string DCutAction_NoPIDHit::Get_ActionName(void) const
1202{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dPID;
return locStream.str();
1206}

1208bool DCutAction_NoPIDHit::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
1209{
//if dPID = Unknown, apply cut to all PIDs

auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_Charged);
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
if((dPID != Unknown) && (locParticles[loc_i]->PID() != dPID))
	continue;
auto locChargedHypo = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
if(locChargedHypo->t1_detector() == SYS_NULL)
	return false;
}

return true;
1223}

1225string DCutAction_FlightDistance::Get_ActionName(void) const
1226{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dPID << "_" << dMinFlightDistance;
return locStream.str();
1230}

1232bool DCutAction_FlightDistance::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
1233{
//if dPID = Unknown, apply cut to all PIDs
DKinFitType locKinFitType = Get_Reaction()->Get_KinFitType();

// for now, require a kinematic fit to make these selections, assuming that the common decay vertex
// is constrained in the fit
if(!Get_UseKinFitResultsFlag())  
return true;

vector<const DReactionVertexInfo*> locVertexInfos;
locEventLoop->Get(locVertexInfos);

// figure out what the right DReactionVertexInfo is
const DReactionVertexInfo *locReactionVertexInfo = nullptr;
for(auto& locVertexInfo : locVertexInfos) {
auto locVertexReactions = locVertexInfo->Get_Reactions();
if(find(locVertexReactions.begin(), locVertexReactions.end(), Get_Reaction()) != locVertexReactions.end()) {
	locReactionVertexInfo = locVertexInfo;
	break;
}
}

// check each individual decaying particle (if they exist)
for(size_t loc_i = 0; loc_i < locParticleCombo->Get_NumParticleComboSteps(); ++loc_i)
{	
const DParticleComboStep* locParticleComboStep = locParticleCombo->Get_ParticleComboStep(loc_i);
//auto locParticles = Get_UseKinFitResultsFlag() ? locParticleComboStep->Get_FinalParticles(Get_Reaction()->Get_ReactionStep(loc_i), false, false, d_AllCharges) : locParticleComboStep->Get_FinalParticles_Measured(Get_Reaction()->Get_ReactionStep(loc_i), d_AllCharges);

if((dPID != Unknown) && (locParticleComboStep->Get_InitialParticle()->PID() != dPID))
	continue;

// fill info on decaying particles, which is on the particle combo step level
if(((locParticleComboStep->Get_InitialParticle()!=nullptr) && !Is_FinalStateParticle(locParticleComboStep->Get_InitialParticle()->PID()))) {  // decaying particles
	// FOR NOW: we only calculate these displaced vertex quantities if a kinematic fit 
	// was performed where the vertex is constrained
	// TODO: Cleverly handle the other cases

	// pull out information related to the kinematic fit
	if( !Get_UseKinFitResultsFlag() ) continue; 
	if( locReactionVertexInfo == nullptr ) continue; 
	
	auto locKinFitParticle = locParticleComboStep->Get_InitialKinFitParticle();

	// extract the info about the vertex, to make sure that the information that we 
	// need to calculate displaced vertices is there
	auto locStepVertexInfo = locReactionVertexInfo->Get_StepVertexInfo(loc_i);
	
	auto locPathLength = locKinFitParticle->Get_PathLength();
	
	if(locPathLength < dMinFlightDistance)
		return false;
}

}

return true;
1289}


1292string DCutAction_FlightSignificance::Get_ActionName(void) const
1293{
ostringstream locStream;
locStream << DAnalysisAction::Get_ActionName() << "_" << dPID << "_" << dMinFlightSignificance;
return locStream.str();
1297}

1299bool DCutAction_FlightSignificance::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
1300{
//if dPID = Unknown, apply cut to all PIDs
DKinFitType locKinFitType = Get_Reaction()->Get_KinFitType();

// for now, require a kinematic fit to make these selections, assuming that the common decay vertex
// is constrained in the fit
if(!Get_UseKinFitResultsFlag())  
return true;

vector<const DReactionVertexInfo*> locVertexInfos;
locEventLoop->Get(locVertexInfos);

// figure out what the right DReactionVertexInfo is
const DReactionVertexInfo *locReactionVertexInfo = nullptr;
for(auto& locVertexInfo : locVertexInfos) {
auto locVertexReactions = locVertexInfo->Get_Reactions();
if(find(locVertexReactions.begin(), locVertexReactions.end(), Get_Reaction()) != locVertexReactions.end()) {
	locReactionVertexInfo = locVertexInfo;
	break;
}
}

// check each individual decaying particle (if they exist)
for(size_t loc_i = 0; loc_i < locParticleCombo->Get_NumParticleComboSteps(); ++loc_i)
{	
const DParticleComboStep* locParticleComboStep = locParticleCombo->Get_ParticleComboStep(loc_i);
//auto locParticles = Get_UseKinFitResultsFlag() ? locParticleComboStep->Get_FinalParticles(Get_Reaction()->Get_ReactionStep(loc_i), false, false, d_AllCharges) : locParticleComboStep->Get_FinalParticles_Measured(Get_Reaction()->Get_ReactionStep(loc_i), d_AllCharges);

if((dPID != Unknown) && (locParticleComboStep->Get_InitialParticle()->PID() != dPID))
	continue;

// fill info on decaying particles, which is on the particle combo step level
if(((locParticleComboStep->Get_InitialParticle()!=nullptr) && !Is_FinalStateParticle(locParticleComboStep->Get_InitialParticle()->PID()))) {  // decaying particles
	// FOR NOW: we only calculate these displaced vertex quantities if a kinematic fit 
	// was performed where the vertex is constrained
	// TODO: Cleverly handle the other cases

	// pull out information related to the kinematic fit
	if( !Get_UseKinFitResultsFlag() ) continue; 
	if( locReactionVertexInfo == nullptr ) continue; 
	
	auto locKinFitParticle = locParticleComboStep->Get_InitialKinFitParticle();

	// extract the info about the vertex, to make sure that the information that we 
	// need to calculate displaced vertices is there
	auto locStepVertexInfo = locReactionVertexInfo->Get_StepVertexInfo(loc_i);

	auto locPathLength = locKinFitParticle->Get_PathLength();
	auto locPathLengthSigma = locKinFitParticle->Get_PathLengthUncertainty();
	double locPathLengthSignificance = locPathLength / locPathLengthSigma;

	if(locPathLengthSignificance < dMinFlightSignificance)
		return false;

}

}

return true;
1359}



1363void DCutAction_OneVertexKinFit::Initialize(JEventLoop* locEventLoop)
1364{
// Optional: Useful utility functions.
locEventLoop->GetSingle(dAnalysisUtilities);

dKinFitUtils = new DKinFitUtils_GlueX(locEventLoop);
dKinFitter = new DKinFitter(dKinFitUtils);
dKinFitUtils->Set_UpdateCovarianceMatricesFlag(false);

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
//Required: Create a folder in the ROOT output file that will contain all of the output ROOT objects (if any) for this action.
//If another thread has already created the folder, it just changes to it. 
CreateAndChangeTo_ActionDirectory();

dHist_ConfidenceLevel = GetOrCreate_Histogram<TH1I>("ConfidenceLevel", "Vertex Kinematic Fit;Confidence Level", 500, 0.0, 1.0);
dHist_VertexZ = GetOrCreate_Histogram<TH1I>("VertexZ", "Vertex Kinematic Fit;Vertex-Z (cm)", 500, 0.0, 200.0);
dHist_VertexYVsX = GetOrCreate_Histogram<TH2I>("VertexYVsX", "Vertex Kinematic Fit;Vertex-X (cm);Vertex-Y (cm)", 300, -10.0, 10.0, 300, -10.0, 10.0);
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
1385}

1387void DCutAction_OneVertexKinFit::Run_Update(JEventLoop* locEventLoop)
1388{
locEventLoop->GetSingle(dAnalysisUtilities);
1
Calling 'JEventLoop::GetSingle'→
dKinFitUtils->Set_RunDependent_Data(locEventLoop);
dKinFitter->Set_RunDependent_Data(locEventLoop);
1392}

1394bool DCutAction_OneVertexKinFit::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
1395{
//need to call prior to use in each event (cleans up memory allocated from last event)
//this call invalidates memory from previous fits (but that's OK, we aren't saving them anywhere)
dKinFitter->Reset_NewEvent();
dKinFitUtils->Reset_NewEvent();

//Get particles for fit (all detected q+)
auto locParticles = locParticleCombo->Get_FinalParticles_Measured(Get_Reaction(), d_Charged);

//Make DKinFitParticle objects for each one
deque<shared_ptr<DKinFitParticle>> locKinFitParticles;
set<shared_ptr<DKinFitParticle>> locKinFitParticleSet;
for(size_t loc_i = 0; loc_i < locParticles.size(); ++loc_i)
{
auto locChargedTrackHypothesis = static_cast<const DChargedTrackHypothesis*>(locParticles[loc_i]);
auto locKinFitParticle = dKinFitUtils->Make_DetectedParticle(locChargedTrackHypothesis);
locKinFitParticles.push_back(locKinFitParticle);
locKinFitParticleSet.insert(locKinFitParticle);
}

// vertex guess
TVector3 locVertexGuess = dAnalysisUtilities->Calc_CrudeVertex(locParticles);

// make & set vertex constraint
auto locVertexConstraint = dKinFitUtils->Make_VertexConstraint(locKinFitParticleSet, {}, locVertexGuess);
dKinFitter->Add_Constraint(locVertexConstraint);

// PERFORM THE KINEMATIC FIT
if(!dKinFitter->Fit_Reaction())
{
dKinFitter->Recycle_LastFitMemory(); //RESET MEMORY FROM LAST KINFIT!! //results no longer needed
return (dMinKinFitCL < 0.0); //fit failed to converge, return false if converge required
}

// GET THE FIT RESULTS
double locConfidenceLevel = dKinFitter->Get_ConfidenceLevel();
auto locResultVertexConstraint = std::dynamic_pointer_cast<DKinFitConstraint_Vertex>(*dKinFitter->Get_KinFitConstraints().begin());
TVector3 locFitVertex = locResultVertexConstraint->Get_CommonVertex();

//RESET MEMORY FROM LAST KINFIT!!
dKinFitter->Recycle_LastFitMemory(); //results no longer needed

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action(); //ACQUIRE ROOT LOCK!!
{
dHist_ConfidenceLevel->Fill(locConfidenceLevel);
dHist_VertexZ->Fill(locFitVertex.Z());
dHist_VertexYVsX->Fill(locFitVertex.X(), locFitVertex.Y());
}
Unlock_Action(); //RELEASE ROOT LOCK!!

if(locConfidenceLevel < dMinKinFitCL)
return false;
if(dMinVertexZ < dMaxVertexZ) //don't cut otherwise
{
if((locFitVertex.Z() < dMinVertexZ) || (locFitVertex.Z() > dMaxVertexZ))
	return false;
}
return true;
1456}

1458DCutAction_OneVertexKinFit::~DCutAction_OneVertexKinFit(void)
1459{
if(dKinFitter != NULL__null)
delete dKinFitter;
if(dKinFitUtils != NULL__null)
delete dKinFitUtils;
1464}


←

/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h

→

1// $Id: JEventLoop.h 1763 2006-05-10 14:29:25Z davidl $
2//
3//    File: JEventLoop.h
4// Created: Wed Jun  8 12:30:51 EDT 2005
5// Creator: davidl (on Darwin wire129.jlab.org 7.8.0 powerpc)
6//
7 
8#ifndef _JEventLoop_
9#define _JEventLoop_
10 
11#include <sys/time.h>
12 
13#include <vector>
14#include <list>
15#include <string>
16#include <utility>
17#include <typeinfo>
18#include <string.h>
19#include <map>
20#include <utility>
21using std::vector;
22using std::list;
23using std::string;
24using std::type_info;
25 
26#include <JANA/jerror.h>
27#include <JANA/JObject.h>
28#include <JANA/JException.h>
29#include <JANA/JEvent.h>
30#include <JANA/JThread.h>
31#include <JANA/JFactory_base.h>
32#include <JANA/JCalibration.h>
33#include <JANA/JGeometry.h>
34#include <JANA/JResourceManager.h>
35#include <JANA/JStreamLog.h>
36 
37// The following is here just so we can use ROOT's THtml class to generate documentation.
38#include "cint.h"
39 
40 
41// Place everything in JANA namespace
42namespace jana{
43 
44 
45template<class T> class JFactory;
46class JApplication;
47class JEventProcessor;
48 
49 
50class JEventLoop{
51	public:
52	
53		friend class JApplication;
54	
55		enum data_source_t{
56			DATA_NOT_AVAILABLE = 1,
57			DATA_FROM_CACHE,
58			DATA_FROM_SOURCE,
59			DATA_FROM_FACTORY
60		};
61		
62		typedef struct{
63			string caller_name;
64			string caller_tag;
65			string callee_name;
66			string callee_tag;
67			double start_time;
68			double end_time;
69			data_source_t data_source;
70		}call_stack_t;
71		
72		typedef struct{
73			const char* factory_name;
74			string tag;
75			const char* filename;
76			int line;
77		}error_call_stack_t;
78 
79	                                   JEventLoop(JApplication *app); ///< Constructor
80							   virtual ~JEventLoop(); ////< Destructor
81				   virtual const char* className(void){return static_className();}
82					static const char* static_className(void){return "JEventLoop";}
83		
84						 JApplication* GetJApplication(void) const {return app;} ///< Get pointer to the JApplication object
85                                  void RefreshProcessorListFromJApplication(void); ///< Re-copy the list of JEventProcessors from JApplication
86                      virtual jerror_t AddFactory(JFactory_base* factory); ///< Add a factory
87							  jerror_t RemoveFactory(JFactory_base* factory); ///< Remove a factory
88                        JFactory_base* GetFactory(const string data_name, const char *tag="", bool allow_deftag=true); ///< Get a specific factory pointer
89                vector<JFactory_base*> GetFactories(void) const {return factories;} ///< Get all factory pointers
90                                  void GetFactoryNames(vector<string> &factorynames); ///< Get names of all factories in name:tag format
91                                  void GetFactoryNames(map<string,string> &factorynames); ///< Get names of all factories in map with key=name, value=tag
92                    map<string,string> GetDefaultTags(void) const {return default_tags;}
93                              jerror_t ClearFactories(void); ///< Reset all factories in preparation for next event.
94							  jerror_t PrintFactories(int sparsify=0); ///< Print a list of all factories.
95                              jerror_t Print(const string data_name, const char *tag=""); ///< Print the data of the given type
96 
97						 JCalibration* GetJCalibration();
98                template<class T> bool GetCalib(string namepath, map<string,T> &vals);
99                template<class T> bool GetCalib(string namepath, vector<T> &vals);
100                template<class T> bool GetCalib(string namepath, T &val);
101 
102                            JGeometry* GetJGeometry();
103                template<class T> bool GetGeom(string namepath, map<string,T> &vals);
104			    template<class T> bool GetGeom(string namepath, T &val);
105 
106                     JResourceManager* GetJResourceManager(void);
107                                string GetResource(string namepath);
108                template<class T> bool GetResource(string namepath, T vals, int event_number=0);
109 
110                                  void Initialize(void); ///< Do initializations just before event processing starts
111                              jerror_t Loop(void); ///< Loop over events
112                              jerror_t OneEvent(uint64_t event_number); ///< Process a specific single event (if source supports it)
113                              jerror_t OneEvent(void); ///< Process a single event
114                           inline void Pause(void){pause = 1;} ///< Pause event processing
115                           inline void Resume(void){pause = 0;} ///< Resume event processing
116                           inline void Quit(void){quit = 1;} ///< Clean up and exit the event loop
117                           inline bool GetQuit(void) const {return quit;}
118                                  void QuitProgram(void);
119 
120		                               // Support for random access of events
121		                          bool HasRandomAccess(void);
122		                          void AddToEventQueue(uint64_t event_number){ next_events_to_process.push_back(event_number); }
123		                          void AddToEventQueue(list<uint64_t> &event_numbers) { next_events_to_process.insert(next_events_to_process.end(), event_numbers.begin(), event_numbers.end()); }
124		                list<uint64_t> GetEventQueue(void){ return next_events_to_process; }
125		                          void ClearEventQueue(void){ next_events_to_process.clear(); }
126 
127        template<class T> JFactory<T>* GetSingle(const T* &t, const char *tag="", bool exception_if_not_one=true); ///< Get pointer to first data object from (source or factory).
128        template<class T> JFactory<T>* Get(vector<const T*> &t, const char *tag="", bool allow_deftag=true); ///< Get data object pointers from (source or factory)
129        template<class T> JFactory<T>* GetFromFactory(vector<const T*> &t, const char *tag="", data_source_t &data_source=null_data_source, bool allow_deftag=true); ///< Get data object pointers from factory
130            template<class T> jerror_t GetFromSource(vector<const T*> &t, JFactory_base *factory=NULL__null); ///< Get data object pointers from source.
131                        inline JEvent& GetJEvent(void){return event;} ///< Get pointer to the current JEvent object.
132                           inline void SetJEvent(JEvent *event){this->event = *event;} ///< Set the JEvent pointer.
133                           inline void SetAutoFree(int auto_free){this->auto_free = auto_free;} ///< Set the Auto-Free flag on/off
134                      inline pthread_t GetPThreadID(void) const {return pthread_id;} ///< Get the pthread of the thread to which this JEventLoop belongs
135                                double GetInstantaneousRate(void) const {return rate_instantaneous;} ///< Get the current event processing rate
136                                double GetIntegratedRate(void) const {return rate_integrated;} ///< Get the current event processing rate
137                                double GetLastEventProcessingTime(void) const {return delta_time_single;}
138                          unsigned int GetNevents(void) const {return Nevents;}
139 
140                           inline bool CheckEventBoundary(uint64_t event_numberA, uint64_t event_numberB);
141 
142                           inline bool GetCallStackRecordingStatus(void){ return record_call_stack; }
143                           inline void DisableCallStackRecording(void){ record_call_stack = false; }
144                           inline void EnableCallStackRecording(void){ record_call_stack = true; }
145		                     inline void CallStackStart(JEventLoop::call_stack_t &cs, const string &caller_name, const string &caller_tag, const string callee_name, const string callee_tag);
146		                     inline void CallStackEnd(JEventLoop::call_stack_t &cs);
147           inline vector<call_stack_t> GetCallStack(void){return call_stack;} ///< Get the current factory call stack
148                           inline void AddToCallStack(call_stack_t &cs){if(record_call_stack) call_stack.push_back(cs);} ///< Add specified item to call stack record but only if record_call_stack is true
149                           inline void AddToErrorCallStack(error_call_stack_t &cs){error_call_stack.push_back(cs);} ///< Add layer to the factory call stack
150     inline vector<error_call_stack_t> GetErrorCallStack(void){return error_call_stack;} ///< Get the current factory error call stack
151                                  void PrintErrorCallStack(void); ///< Print the current factory call stack
152 
153                        const JObject* FindByID(JObject::oid_t id); ///< Find a data object by its identifier.
154            template<class T> const T* FindByID(JObject::oid_t id); ///< Find a data object by its type and identifier
155                        JFactory_base* FindOwner(const JObject *t); ///< Find the factory that owns a data object by pointer
156                        JFactory_base* FindOwner(JObject::oid_t id); ///< Find a factory that owns a data object by identifier
157 
158                                       // User defined references
159                template<class T> void SetRef(T *t);    ///< Add a user reference to this JEventLoop (must be a pointer)
160                  template<class T> T* GetRef(void);   ///< Get a user-defined reference of a specific type
161          template<class T> vector<T*> GetRefsT(void); ///< Get all user-defined refrences of a specicif type
162     vector<pair<const char*, void*> > GetRefs(void){ return user_refs; }  ///< Get copy of full list of user-defined references
163                template<class T> void RemoveRef(T *t); ///< Remove user reference from list
164 
165									   // Convenience methods wrapping JEvent methods of same name
166		                      uint64_t GetStatus(void){return event.GetStatus();}
167		                          bool GetStatusBit(uint32_t bit){return event.GetStatusBit(bit);}
168		                          bool SetStatusBit(uint32_t bit, bool val=true){return event.SetStatusBit(bit, val);}
169		                          bool ClearStatusBit(uint32_t bit){return event.ClearStatusBit(bit);}
170		                          void ClearStatus(void){event.ClearStatus();}
171		                          void SetStatusBitDescription(uint32_t bit, string description){event.SetStatusBitDescription(bit, description);}
172		                        string GetStatusBitDescription(uint32_t bit){return event.GetStatusBitDescription(bit);}
173		                          void GetStatusBitDescriptions(map<uint32_t, string> &status_bit_descriptions){return event.GetStatusBitDescriptions(status_bit_descriptions);}
174                                string StatusWordToString(void);
175 
176	private:
177		JEvent event;
178		vector<JFactory_base*> factories;
179		vector<JEventProcessor*> processors;
180		vector<error_call_stack_t> error_call_stack;
181		vector<call_stack_t> call_stack;
182		JApplication *app;
183		JThread *jthread;
184		bool initialized;
185		bool print_parameters_called;
186		int pause;
187		int quit;
188		int auto_free;
189		pthread_t pthread_id;
190		map<string, string> default_tags;
191		vector<pair<string,string> > auto_activated_factories;
192		bool record_call_stack;
193		string caller_name;
194		string caller_tag;
195		vector<uint64_t> event_boundaries;
196		int32_t event_boundaries_run; ///< Run number boundaries were retrieved from (possbily 0)
197		list<uint64_t> next_events_to_process;
198		
199		uint64_t Nevents;			      ///< Total events processed (this thread)
200		uint64_t Nevents_rate;		   ///< Num. events accumulated for "instantaneous" rate
201		double delta_time_single;		///< Time spent processing last event
202		double delta_time_rate;			///< Integrated time accumulated "instantaneous" rate (partial number of events)
203		double delta_time;				///< Total time spent processing events (this thread)
204		double rate_instantaneous;		///< Latest instantaneous rate
205		double rate_integrated;			///< Rate integrated over all events
206   
207		static data_source_t null_data_source;
208 
209		vector<pair<const char*, void*> > user_refs;
210};
211 
212 
213// The following is here just so we can use ROOT's THtml class to generate documentation.
214#ifdef G__DICTIONARY
215typedef JEventLoop::call_stack_t call_stack_t;
216typedef JEventLoop::error_call_stack_t error_call_stack_t;
217#endif
218 
219#if !defined(__CINT__) && !defined(__CLING__)
220 
221//-------------
222// GetSingle
223//-------------
224template<class T>
225JFactory<T>* JEventLoop::GetSingle(const T* &t, const char *tag, bool exception_if_not_one)
226{
227	/// This is a convenience method that can be used to get a pointer to the single
228	/// object of type T from the specified factory. It simply calls the Get(vector<...>) method
229	/// and copies the first pointer into "t" (or NULL if something other than 1 object is returned).
230	/// 
231	/// This is intended to address the common situation in which there is an interest
232	/// in the event if and only if there is exactly 1 object of type T. If the event
233	/// has no objects of that type or more than 1 object of that type (for the specified
234	/// factory) then an exception of type "unsigned long" is thrown with the value
235	/// being the number of objects of type T. You can supress the exception by setting
236	/// exception_if_not_one to false. In that case, you will have to check if t==NULL to
237	/// know if the call succeeded.
238	vector<const T*> v;
239	JFactory<T> *fac = Get(v, tag);
2
←
Calling 'JEventLoop::Get'→
240 
241	if(v.size()!=1){
242		t = NULL__null;
243		if(exception_if_not_one) throw v.size();
244	}
245	
246	t = v[0];
247	
248	return fac;
249}
250 
251//-------------
252// Get
253//-------------
254template<class T> 
255JFactory<T>* JEventLoop::Get(vector<const T*> &t, const char *tag, bool allow_deftag)
256{
257	/// Retrieve or generate the array of objects of
258	/// type T for the curent event being processed
259	/// by this thread.
260	///
261	/// By default, preference is given to reading the
262	/// objects from the data source(e.g. file) before generating
263	/// them in the factory. A flag exists in the factory
264	/// however to change this so that the factory is
265	/// given preference.
266	///
267	/// Note that regardless of the setting of this flag,
268	/// the data are only either read in or generated once.
269	/// Ownership of the objects will always be with the
270	/// factory so subsequent calls will always return pointers to
271	/// the same data.
272	///
273	/// If the factory is called on to generate the data,
274	/// it is done by calling the factory's Get() method
275	/// which, in turn, calls the evnt() method. 
276	/// 
277	/// First, we just call the GetFromFactory() method.
278	/// It will make the initial decision as to whether
279	/// it should look in the source first or not. If
280	/// it returns NULL, then the factory couldn't be
281	/// found so we automatically try the file.
282	///
283	/// Note that if no factory exists to hold the objects
284	/// from the file, one can be created automatically
285	/// providing the <i>JANA:AUTOFACTORYCREATE</i>
286	/// configuration parameter is set.
287 
288	// Check if a tag was specified for this data type to use for the
289	// default.
290	const char *mytag = tag2.1
'tag' is not equal to NULL
2.1
'tag' is not equal to NULL
2.1
'tag' is not equal to NULL
==NULL__null ? "":tag; // protection against NULL tags
3
←
'?' condition is false→
291	if(strlen(mytag)==0 && allow_deftag3.1
'allow_deftag' is true
3.1
'allow_deftag' is true
3.1
'allow_deftag' is true
){
4
←
Taking true branch→
292		map<string, string>::const_iterator iter = default_tags.find(T::static_className());
293		if(iter!=default_tags.end())tag = iter->second.c_str();
5
←
Assuming the condition is true→
6
←
Taking true branch→
7
←
Value assigned to 'tag'→
294	}
295	
296	
297	// If we are trying to keep track of the call stack then we
298	// need to add a new call_stack_t object to the the list
299	// and initialize it with the start time and caller/callee
300	// info.
301	call_stack_t cs;
302 
303	// Optionally record starting info of call stack entry
304	if(record_call_stack) CallStackStart(cs, caller_name, caller_tag, T::static_className(), tag);
8
←
Assuming field 'record_call_stack' is false→
9
←
Taking false branch→
305 
306	// Get the data (or at least try to)
307	JFactory<T>* factory=NULL__null;
308	try{
309		factory = GetFromFactory(t, tag, cs.data_source, allow_deftag);
10
←
Passing value via 2nd parameter 'tag'→
11
←
Calling 'JEventLoop::GetFromFactory'→
310		if(!factory){
311			// No factory exists for this type and tag. It's possible
312			// that the source may be able to provide the objects
313			// but it will need a place to put them. We can create a
314			// dumb JFactory just to hold the data in case the source
315			// can provide the objects. Before we do though, make sure
316			// the user condones this via the presence of the
317			// "JANA:AUTOFACTORYCREATE" config parameter.
318			string p;
319			try{
320				gPARMS->GetParameter("JANA:AUTOFACTORYCREATE", p);
321			}catch(...){}
322			if(p.size()==0){
323				jout<<std::endl;
324				_DBG__std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<324<<std::endl;
325				jout<<"No factory of type \""<<T::static_className()<<"\" with tag \""<<tag<<"\" exists."<<std::endl;
326				jout<<"If you are reading objects from a file, I can auto-create a factory"<<std::endl;
327				jout<<"of the appropriate type to hold the objects, but this feature is turned"<<std::endl;
328				jout<<"off by default. To turn it on, set the \"JANA:AUTOFACTORYCREATE\""<<std::endl;
329				jout<<"configuration parameter. This can usually be done by passing the"<<std::endl;
330				jout<<"following argument to the program from the command line:"<<std::endl;
331				jout<<std::endl;
332				jout<<"   -PJANA:AUTOFACTORYCREATE=1"<<std::endl;
333				jout<<std::endl;
334				jout<<"Note that since the most commonly expected occurance of this situation."<<std::endl;
335				jout<<"is an error, the program will now throw an exception so that the factory."<<std::endl;
336				jout<<"call stack can be printed."<<std::endl;
337				jout<<std::endl;
338				throw exception();
339			}else{
340				AddFactory(new JFactory<T>(tag));
341				jout<<__FILE__"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"<<":"<<__LINE__341<<" Auto-created "<<T::static_className()<<":"<<tag<<" factory"<<std::endl;
342			
343				// Now try once more. The GetFromFactory method will call
344				// GetFromSource since it's empty.
345				factory = GetFromFactory(t, tag, cs.data_source, allow_deftag);
346			}
347		}
348	}catch(exception &e){
349		// Uh-oh, an exception was thrown. Add us to the call stack
350		// and re-throw the exception
351		error_call_stack_t ecs;
352		ecs.factory_name = T::static_className();
353		ecs.tag = tag;
354		ecs.filename = NULL__null;
355		error_call_stack.push_back(ecs);
356		throw e;
357	}
358	
359	// If recording the call stack, update the end_time field and add to stack
360	if(record_call_stack) CallStackEnd(cs);
361	
362	return factory;
363}
364 
365//-------------
366// GetFromFactory
367//-------------
368template<class T> 
369JFactory<T>* JEventLoop::GetFromFactory(vector<const T*> &t, const char *tag, data_source_t &data_source, bool allow_deftag)
370{
371	// We need to find the factory providing data type T with
372	// tag given by "tag". 
373	vector<JFactory_base*>::iterator iter=factories.begin();
374	JFactory<T> *factory = NULL__null;
375	string className(T::static_className());
376	
377	// Check if a tag was specified for this data type to use for the
378	// default.
379	const char *mytag = tag==NULL__null ? "":tag; // protection against NULL tags
12
←
Assuming 'tag' is equal to NULL→
13
←
Assuming pointer value is null→
14
←
'?' condition is true→
380	if(strlen(mytag)==0 && allow_deftag14.1
'allow_deftag' is true
14.1
'allow_deftag' is true
14.1
'allow_deftag' is true
){
15
←
Taking true branch→
381		map<string, string>::const_iterator iter = default_tags.find(className);
382		if(iter!=default_tags.end())tag = iter->second.c_str();
16
←
Assuming the condition is false→
17
←
Taking false branch→
383	}
384	
385	for(; iter!=factories.end(); iter++){
18
←
Calling 'operator!=<jana::JFactory_base **, std::vector<jana::JFactory_base *>>'→
21
←
Returning from 'operator!=<jana::JFactory_base **, std::vector<jana::JFactory_base *>>'→
22
←
Loop condition is true.  Entering loop body→
386		// It turns out a long standing bug in g++ makes dynamic_cast return
387		// zero improperly when used on objects created on one side of
388		// a dynamically shared object (DSO) and the cast occurs on the 
389		// other side. I saw bug reports ranging from 2001 to 2004. I saw
390		// saw it first-hand on LinuxEL4 using g++ 3.4.5. This is too bad
391		// since it is much more elegant (and safe) to use dynamic_cast.
392		// To avoid this problem which can occur with plugins, we check
393		// the name of the data classes are the same. (sigh)
394		//factory = dynamic_cast<JFactory<T> *>(*iter);
395		if(className == (*iter)->GetDataClassName())factory = (JFactory<T>*)(*iter);
23
←
Taking true branch→
396		if(factory == NULL__null)continue;
24
←
Assuming 'factory' is not equal to NULL→
25
←
Taking false branch→
397		const char *factag = factory->Tag()==NULL__null ? "":factory->Tag();
26
←
Assuming the condition is true→
27
←
'?' condition is true→
398		if(!strcmp(factag, tag)){
28
←
Null pointer passed to 2nd parameter expecting 'nonnull'
399			break;
400		}else{
401			factory=NULL__null;
402		}
403	}
404	
405	// If factory not found, just return now
406	if(!factory){
407		data_source = DATA_NOT_AVAILABLE;
408		return NULL__null;
409	}
410	
411	// OK, we found the factory. If the evnt() routine has already
412	// been called, then just call the factory's Get() routine
413	// to return a copy of the existing data
414	if(factory->evnt_was_called()){
415		factory->CopyFrom(t);
416		data_source = DATA_FROM_CACHE;
417		return factory;
418	}
419	
420	// Next option is to get the objects from the data source
421	if(factory->GetCheckSourceFirst()){
422		// If the object type/tag is found in the source, it
423		// will return NOERROR, even if there are zero instances
424		// of it. If it is not available in the source then it
425		// will return OBJECT_NOT_AVAILABLE.
426		
427		jerror_t err = GetFromSource(t, factory);
428		if(err == NOERROR){
429			// A return value of NOERROR means the source had the objects
430			// even if there were zero of them.(If the source had no
431			// information about the objects OBJECT_NOT_AVAILABLE would 
432			// have been returned.)
433			// The GetFromSource() call will eventually lead to a call to
434			// the GetObjects() method of the concrete class derived
435			// from JEventSource. That routine should copy the object
436			// pointers into the factory using the factory's CopyTo()
437			// method which also sets the evnt_called flag for the factory.
438			// Note also that the "t" vector is then filled with a call
439			// to the factory's CopyFrom() method in JEvent::GetObjects().
440			// All we need to do now is just set the factory pointers in
441			// the newly generated JObjects and return the factory pointer.
442 
443			factory->SetFactoryPointers();
444			data_source = DATA_FROM_SOURCE;
445 
446			return factory;
447		}
448	}
449		
450	// OK. It looks like we have to have the factory make this.
451	// Get pointers to data from the factory.
452	factory->Get(t);
453	factory->SetFactoryPointers();
454	data_source = DATA_FROM_FACTORY;
455	
456	return factory;
457}
458 
459//-------------
460// GetFromSource
461//-------------
462template<class T> 
463jerror_t JEventLoop::GetFromSource(vector<const T*> &t, JFactory_base *factory)
464{
465	/// This tries to get objects from the event source.
466	/// "factory" must be a valid pointer to a JFactory
467	/// object since that will take ownership of the objects
468	/// created by the source.
469	/// This should usually be called from JEventLoop::GetFromFactory
470	/// which is called from JEventLoop::Get. The latter will
471	/// create a dummy JFactory of the proper flavor and tag if
472	/// one does not already exist so if objects exist in the
473	/// file without a corresponding factory to create them, they
474	/// can still be used.
475	if(!factory)throw OBJECT_NOT_AVAILABLE;
476	
477	return event.GetObjects(t, factory);
478}
479 
480//-------------
481// CallStackStart
482//-------------
483inline void JEventLoop::CallStackStart(JEventLoop::call_stack_t &cs, const string &caller_name, const string &caller_tag, const string callee_name, const string callee_tag)
484{
485	/// This is used to fill initial info into a call_stack_t stucture
486	/// for recording the call stack. It should be matched with a call
487	/// to CallStackEnd. It is normally called from the Get() method
488	/// above, but may also be used by external actors to manipulate
489	/// the call stack (presumably for good and not evil).
490 
491	struct itimerval tmr;
492	getitimer(ITIMER_PROFITIMER_PROF, &tmr);
493 
494	cs.caller_name    = this->caller_name;
495	cs.caller_tag     = this->caller_tag;
496	this->caller_name = cs.callee_name = callee_name;
497	this->caller_tag  = cs.callee_tag  = callee_tag;
498	cs.start_time = tmr.it_value.tv_sec + tmr.it_value.tv_usec/1.0E6;
499}
500 
501//-------------
502// CallStackEnd
503//-------------
504inline void JEventLoop::CallStackEnd(JEventLoop::call_stack_t &cs)
505{
506	/// Complete a call stack entry. This should be matched
507	/// with a previous call to CallStackStart which was
508	/// used to fill the cs structure.
509 
510	struct itimerval tmr;
511	getitimer(ITIMER_PROFITIMER_PROF, &tmr);
512	cs.end_time = tmr.it_value.tv_sec + tmr.it_value.tv_usec/1.0E6;
513	caller_name = cs.caller_name;
514	caller_tag  = cs.caller_tag;
515	call_stack.push_back(cs);
516}
517 
518//-------------
519// CheckEventBoundary
520//-------------
521inline bool JEventLoop::CheckEventBoundary(uint64_t event_numberA, uint64_t event_numberB)
522{
523	/// Check whether the two event numbers span one or more boundaries
524	/// in the calibration/conditions database for the current run number.
525	/// Return true if they do and false if they don't. The first parameter
526	/// "event_numberA" is also checked if it lands on a boundary in which
527	/// case true is also returned. If event_numberB lands on a boundary,
528	/// but event_numberA does not, then false is returned.
529	///
530	/// This method is not expected to be called by a user. It is, however called,
531	/// everytime a JFactory's Get() method is called.
532 
533	// Make sure our copy of the boundaries is up to date
534	if(event.GetRunNumber()!=event_boundaries_run){
535		event_boundaries.clear(); // in case we can't get the JCalibration pointer
536		JCalibration *jcalib = GetJCalibration();
537		if(jcalib)jcalib->GetEventBoundaries(event_boundaries);
538		event_boundaries_run = event.GetRunNumber();
539	}
540	
541	// Loop over boundaries
542	for(unsigned int i=0; i<event_boundaries.size(); i++){
543		uint64_t eb = event_boundaries[i];
544		if((eb - event_numberA)*(eb - event_numberB) < 0.0 || eb==event_numberA){ // think about it ....
545			// events span a boundary or is on a boundary. Return true
546			return true;
547		}
548	}
549 
550	return false;
551}
552 
553//-------------
554// FindByID
555//-------------
556template<class T> 
557const T* JEventLoop::FindByID(JObject::oid_t id)
558{
559	/// This is a templated method that can be used in place
560	/// of the non-templated FindByID(oid_t) method if one knows
561	/// the class of the object with the specified id.
562	/// This method is faster than calling the non-templated
563	/// FindByID and dynamic_cast-ing the JObject since
564	/// this will only search the objects of factories that
565	/// produce the desired data type.
566	/// This method will cast the JObject pointer to one
567	/// of the specified type. To use this method,
568	/// a type is specified in the call as follows:
569	///
570	/// const DMyType *t = loop->FindByID<DMyType>(id);
571	
572	// Loop over factories looking for ones that provide
573	// specified data type.
574	for(unsigned int i=0; i<factories.size(); i++){
575		if(factories[i]->GetDataClassName() != T::static_className())continue;
576 
577		// This factory provides data of type T. Search it for
578		// the object with the specified id.
579		const JObject *my_obj = factories[i]->GetByID(id);
580		if(my_obj)return dynamic_cast<const T*>(my_obj);
581	}
582 
583	return NULL__null;
584}
585 
586//-------------
587// GetCalib (map)
588//-------------
589template<class T>
590bool JEventLoop::GetCalib(string namepath, map<string,T> &vals)
591{
592	/// Get the JCalibration object from JApplication for the run number of
593	/// the current event and call its Get() method to get the constants.
594 
595	// Note that we could do this by making "vals" a generic type T thus, combining
596	// this with the vector version below. However, doing this explicitly will make
597	// it easier for the user to understand how to call us.
598 
599	vals.clear();
600 
601	JCalibration *calib = GetJCalibration();
602	if(!calib){
603		_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<603<<" "<<"Unable to get JCalibration object for run "<<event.GetRunNumber()<<std::endl;
604		return true;
605	}
606	
607	return calib->Get(namepath, vals, event.GetEventNumber());
608}
609 
610//-------------
611// GetCalib (vector)
612//-------------
613template<class T> bool JEventLoop::GetCalib(string namepath, vector<T> &vals)
614{
615	/// Get the JCalibration object from JApplication for the run number of
616	/// the current event and call its Get() method to get the constants.
617 
618	vals.clear();
619 
620	JCalibration *calib = GetJCalibration();
621	if(!calib){
622		_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<622<<" "<<"Unable to get JCalibration object for run "<<event.GetRunNumber()<<std::endl;
623		return true;
624	}
625	
626	return calib->Get(namepath, vals, event.GetEventNumber());
627}
628 
629//-------------
630// GetCalib (single)
631//-------------
632template<class T> bool JEventLoop::GetCalib(string namepath, T &val)
633{
634	/// This is a convenience method for getting a single entry. It
635	/// simply calls the vector version and returns the first entry.
636	/// It returns true if the vector version returns true AND there
637	/// is at least one entry in the vector. No check is made for there
638	/// there being more than one entry in the vector.
639 
640	vector<T> vals;
641	bool ret = GetCalib(namepath, vals);
642	if(vals.empty()) return true;
643	val = vals[0];
644	
645	return ret;
646}
647 
648//-------------
649// GetGeom (map)
650//-------------
651template<class T>
652bool JEventLoop::GetGeom(string namepath, map<string,T> &vals)
653{
654	/// Get the JGeometry object from JApplication for the run number of
655	/// the current event and call its Get() method to get the constants.
656 
657	// Note that we could do this by making "vals" a generic type T thus, combining
658	// this with the vector version below. However, doing this explicitly will make
659	// it easier for the user to understand how to call us.
660 
661	vals.clear();
662 
663	JGeometry *geom = GetJGeometry();
664	if(!geom){
665		_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<665<<" "<<"Unable to get JGeometry object for run "<<event.GetRunNumber()<<std::endl;
666		return true;
667	}
668	
669	return geom->Get(namepath, vals);
670}
671 
672//-------------
673// GetGeom (atomic)
674//-------------
675template<class T> bool JEventLoop::GetGeom(string namepath, T &val)
676{
677	/// Get the JCalibration object from JApplication for the run number of
678	/// the current event and call its Get() method to get the constants.
679 
680	JGeometry *geom = GetJGeometry();
681	if(!geom){
682		_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<682<<" "<<"Unable to get JGeometry object for run "<<event.GetRunNumber()<<std::endl;
683		return true;
684	}
685	
686	return geom->Get(namepath, val);
687}
688 
689//-------------
690// SetRef
691//-------------
692template<class T>
693void JEventLoop::SetRef(T *t)
694{
695	pair<const char*, void*> p(typeid(T).name(), (void*)t);
696	user_refs.push_back(p);
697}
698 
699//-------------
700// GetResource
701//-------------
702template<class T> bool JEventLoop::GetResource(string namepath, T vals, int event_number)
703{
704	JResourceManager *resource_manager = GetJResourceManager();
705	if(!resource_manager){
706		string mess = string("Unable to get the JResourceManager object (namepath=\"")+namepath+"\")";
707		throw JException(mess);
708	}
709 
710	return resource_manager->Get(namepath, vals, event_number);
711}
712 
713//-------------
714// GetRef
715//-------------
716template<class T>
717T* JEventLoop::GetRef(void)
718{
719	/// Get a user-defined reference (a pointer)
720	for(unsigned int i=0; i<user_refs.size(); i++){
721		if(user_refs[i].first == typeid(T).name()) return (T*)user_refs[i].second;
722	}
723 
724	return NULL__null;
725}
726 
727//-------------
728// GetRefsT
729//-------------
730template<class T>
731vector<T*> JEventLoop::GetRefsT(void)
732{
733	vector<T*> refs;
734	for(unsigned int i=0; i<user_refs.size(); i++){
735		if(user_refs[i].first == typeid(T).name()){
736			refs.push_back((T*)user_refs[i].second);
737		}
738	}
739 
740	return refs;
741}
742 
743//-------------
744// RemoveRef
745//-------------
746template<class T>
747void JEventLoop::RemoveRef(T *t)
748{
749	vector<pair<const char*, void*> >::iterator iter;
750	for(iter=user_refs.begin(); iter!= user_refs.end(); iter++){
751		if(iter->second == (void*)t){
752			user_refs.erase(iter);
753			return;
754		}
755	}
756	_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<756<<" "<<" Attempt to remove user reference not in event loop!" << std::endl;
757}
758 
759 
760#endif //__CINT__  __CLING__
761 
762} // Close JANA namespace
763 
764 
765 
766#endif // _JEventLoop_
767 

←

/usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/bits/stl_iterator.h

1// Iterators -*- C++ -*-

3// Copyright (C) 2001-2013 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*/

51/** @file bits/stl_iterator.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{iterator}
*
*  This file implements reverse_iterator, back_insert_iterator,
*  front_insert_iterator, insert_iterator, __normal_iterator, and their
*  supporting functions and overloaded operators.
*/

60#ifndef _STL_ITERATOR_H1
61#define _STL_ITERATOR_H1 1

63#include <bits/cpp_type_traits.h>
64#include <ext/type_traits.h>
65#include <bits/move.h>

67namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
68{
69_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup iterators
 * @{
 */

// 24.4.1 Reverse iterators
/**
 *  Bidirectional and random access iterators have corresponding reverse
 *  %iterator adaptors that iterate through the data structure in the
 *  opposite direction.  They have the same signatures as the corresponding
 *  iterators.  The fundamental relation between a reverse %iterator and its
 *  corresponding %iterator @c i is established by the identity:
 *  @code
 *      &*(reverse_iterator(i)) == &*(i - 1)
 *  @endcode
 *
 *  <em>This mapping is dictated by the fact that while there is always a
 *  pointer past the end of an array, there might not be a valid pointer
 *  before the beginning of an array.</em> [24.4.1]/1,2
 *
 *  Reverse iterators can be tricky and surprising at first.  Their
 *  semantics make sense, however, and the trickiness is a side effect of
 *  the requirement that the iterators must be safe.
*/
template<typename _Iterator>
  class reverse_iterator
  : public iterator<typename iterator_traits<_Iterator>::iterator_category,
      typename iterator_traits<_Iterator>::value_type,
      typename iterator_traits<_Iterator>::difference_type,
      typename iterator_traits<_Iterator>::pointer,
                    typename iterator_traits<_Iterator>::reference>
  {
  protected:
    _Iterator current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::difference_type	difference_type;
    typedef typename __traits_type::pointer		pointer;
    typedef typename __traits_type::reference		reference;

    /**
     *  The default constructor value-initializes member @p current.
     *  If it is a pointer, that means it is zero-initialized.
    */
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 235 No specification of default ctor for reverse_iterator
    reverse_iterator() : current() { }

    /**
     *  This %iterator will move in the opposite direction that @p x does.
    */
    explicit
    reverse_iterator(iterator_type __x) : current(__x) { }

    /**
     *  The copy constructor is normal.
    */
    reverse_iterator(const reverse_iterator& __x)
    : current(__x.current) { }

    /**
     *  A %reverse_iterator across other types can be copied if the
     *  underlying %iterator can be converted to the type of @c current.
    */
    template<typename _Iter>
      reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) { }

    /**
     *  @return  @c current, the %iterator used for underlying work.
    */
    iterator_type
    base() const
    { return current; }

    /**
     *  @return  A reference to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
     *
     *  @warning This implementation requires that for an iterator of the
     *           underlying iterator type, @c x, a reference obtained by
     *           @c *x remains valid after @c x has been modified or
     *           destroyed. This is a bug: http://gcc.gnu.org/PR51823
    */
    reference
    operator*() const
    {
_Iterator __tmp = current;
return *--__tmp;
    }

    /**
     *  @return  A pointer to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
    */
    pointer
    operator->() const
    { return &(operator*()); }

    /**
     *  @return  @c *this
     *
     *  Decrements the underlying iterator.
    */
    reverse_iterator&
    operator++()
    {
--current;
return *this;
    }

    /**
     *  @return  The original value of @c *this
     *
     *  Decrements the underlying iterator.
    */
    reverse_iterator
    operator++(int)
    {
reverse_iterator __tmp = *this;
--current;
return __tmp;
    }

    /**
     *  @return  @c *this
     *
     *  Increments the underlying iterator.
    */
    reverse_iterator&
    operator--()
    {
++current;
return *this;
    }

    /**
     *  @return  A reverse_iterator with the previous value of @c *this
     *
     *  Increments the underlying iterator.
    */
    reverse_iterator
    operator--(int)
    {
reverse_iterator __tmp = *this;
++current;
return __tmp;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator
    operator+(difference_type __n) const
    { return reverse_iterator(current - __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator backwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator&
    operator+=(difference_type __n)
    {
current -= __n;
return *this;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator
    operator-(difference_type __n) const
    { return reverse_iterator(current + __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator forwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator&
    operator-=(difference_type __n)
    {
current += __n;
return *this;
    }

    /**
     *  @return  The value at @c current - @a __n - 1
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reference
    operator[](difference_type __n) const
    { return *(*this + __n); }
  };

//@{
/**
 *  @param  __x  A %reverse_iterator.
 *  @param  __y  A %reverse_iterator.
 *  @return  A simple bool.
 *
 *  Reverse iterators forward many operations to their underlying base()
 *  iterators.  Others are implemented in terms of one another.
 *
*/
template<typename _Iterator>
  inline bool
  operator==(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline bool
  operator<(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y.base() < __x.base(); }

template<typename _Iterator>
  inline bool
  operator!=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline bool
  operator>(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline bool
  operator<=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline bool
  operator>=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x < __y); }

template<typename _Iterator>
  inline typename reverse_iterator<_Iterator>::difference_type
  operator-(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y.base() - __x.base(); }

template<typename _Iterator>
  inline reverse_iterator<_Iterator>
  operator+(typename reverse_iterator<_Iterator>::difference_type __n,
     const reverse_iterator<_Iterator>& __x)
  { return reverse_iterator<_Iterator>(__x.base() - __n); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 280. Comparison of reverse_iterator to const reverse_iterator.
template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator==(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y.base() < __x.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator!=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x < __y); }

template<typename _IteratorL, typename _IteratorR>
376#if __cplusplus201103L >= 201103L
  // DR 685.
  inline auto
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  -> decltype(__y.base() - __x.base())
382#else
  inline typename reverse_iterator<_IteratorL>::difference_type
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
386#endif
  { return __y.base() - __x.base(); }
//@}

// 24.4.2.2.1 back_insert_iterator
/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator appends it to the container using
 *  push_back.
 *
 *  Tip:  Using the back_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class back_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /// The only way to create this %iterator is with a container.
    explicit
    back_insert_iterator(_Container& __x) : container(&__x) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the end, if you like).  Assigning a value to the %iterator will
     *  always append the value to the end of the container.
    */
427#if __cplusplus201103L < 201103L
    back_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_back(__value);
return *this;
    }
434#else
    back_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_back(__value);
return *this;
    }

    back_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_back(std::move(__value));
return *this;
    }
448#endif

    /// Simply returns *this.
    back_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    back_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    back_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of back_insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating back_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  inline back_insert_iterator<_Container>
  back_inserter(_Container& __x)
  { return back_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator prepends it to the container using
 *  push_front.
 *
 *  Tip:  Using the front_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class front_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /// The only way to create this %iterator is with a container.
    explicit front_insert_iterator(_Container& __x) : container(&__x) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the front, if you like).  Assigning a value to the %iterator will
     *  always prepend the value to the front of the container.
    */
517#if __cplusplus201103L < 201103L
    front_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_front(__value);
return *this;
    }
524#else
    front_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_front(__value);
return *this;
    }

    front_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_front(std::move(__value));
return *this;
    }
538#endif

    /// Simply returns *this.
    front_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    front_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    front_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of front_insert_iterator working on @p x.
 *
 *  This wrapper function helps in creating front_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  inline front_insert_iterator<_Container>
  front_inserter(_Container& __x)
  { return front_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator inserts it in the container at the
 *  %iterator's position, rather than overwriting the value at that
 *  position.
 *
 *  (Sequences will actually insert a @e copy of the value before the
 *  %iterator's position.)
 *
 *  Tip:  Using the inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;
    typename _Container::iterator iter;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /**
     *  The only way to create this %iterator is with a container and an
     *  initial position (a normal %iterator into the container).
    */
    insert_iterator(_Container& __x, typename _Container::iterator __i)
    : container(&__x), iter(__i) {}

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator maintains its own position in the
     *  container.  Assigning a value to the %iterator will insert the
     *  value into the container at the place before the %iterator.
     *
     *  The position is maintained such that subsequent assignments will
     *  insert values immediately after one another.  For example,
     *  @code
     *     // vector v contains A and Z
     *
     *     insert_iterator i (v, ++v.begin());
     *     i = 1;
     *     i = 2;
     *     i = 3;
     *
     *     // vector v contains A, 1, 2, 3, and Z
     *  @endcode
    */
628#if __cplusplus201103L < 201103L
    insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }
636#else
    insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }

    insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
iter = container->insert(iter, std::move(__value));
++iter;
return *this;
    }
652#endif

    /// Simply returns *this.
    insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    insert_iterator&
    operator++(int)
    { return *this; }
  };

/**
 *  @param __x  A container of arbitrary type.
 *  @return  An instance of insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container, typename _Iterator>
  inline insert_iterator<_Container>
  inserter(_Container& __x, _Iterator __i)
  {
    return insert_iterator<_Container>(__x,
			 typename _Container::iterator(__i));
  }

// @} group iterators

691_GLIBCXX_END_NAMESPACE_VERSION
692} // namespace

694namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
695{
696_GLIBCXX_BEGIN_NAMESPACE_VERSION

// This iterator adapter is @a normal in the sense that it does not
// change the semantics of any of the operators of its iterator
// parameter.  Its primary purpose is to convert an iterator that is
// not a class, e.g. a pointer, into an iterator that is a class.
// The _Container parameter exists solely so that different containers
// using this template can instantiate different types, even if the
// _Iterator parameter is the same.
using std::iterator_traits;
using std::iterator;
template<typename _Iterator, typename _Container>
  class __normal_iterator
  {
  protected:
    _Iterator _M_current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type 	difference_type;
    typedef typename __traits_type::reference 	reference;
    typedef typename __traits_type::pointer   	pointer;

    _GLIBCXX_CONSTEXPRconstexpr __normal_iterator() : _M_current(_Iterator()) { }

    explicit
    __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

    // Allow iterator to const_iterator conversion
    template<typename _Iter>
      __normal_iterator(const __normal_iterator<_Iter,
	  typename __enable_if<
    	       (std::__are_same<_Iter, typename _Container::pointer>::__value),
      _Container>::__type>& __i)
      : _M_current(__i.base()) { }

    // Forward iterator requirements
    reference
    operator*() const
    { return *_M_current; }

    pointer
    operator->() const
    { return _M_current; }

    __normal_iterator&
    operator++()
    {
++_M_current;
return *this;
    }

    __normal_iterator
    operator++(int)
    { return __normal_iterator(_M_current++); }

    // Bidirectional iterator requirements
    __normal_iterator&
    operator--()
    {
--_M_current;
return *this;
    }

    __normal_iterator
    operator--(int)
    { return __normal_iterator(_M_current--); }

    // Random access iterator requirements
    reference
    operator[](const difference_type& __n) const
    { return _M_current[__n]; }

    __normal_iterator&
    operator+=(const difference_type& __n)
    { _M_current += __n; return *this; }

    __normal_iterator
    operator+(const difference_type& __n) const
    { return __normal_iterator(_M_current + __n); }

    __normal_iterator&
    operator-=(const difference_type& __n)
    { _M_current -= __n; return *this; }

    __normal_iterator
    operator-(const difference_type& __n) const
    { return __normal_iterator(_M_current - __n); }

    const _Iterator&
    base() const
    { return _M_current; }
  };

// Note: In what follows, the left- and right-hand-side iterators are
// allowed to vary in types (conceptually in cv-qualification) so that
// comparison between cv-qualified and non-cv-qualified iterators be
// valid.  However, the greedy and unfriendly operators in std::rel_ops
// will make overload resolution ambiguous (when in scope) if we don't
// provide overloads whose operands are of the same type.  Can someone
// remind me what generic programming is about? -- Gaby

// Forward iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }
19
←
Assuming the condition is true→
20
←
Returning the value 1, which participates in a condition later→

// Random access iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// According to the resolution of DR179 not only the various comparison
// operators but also operator- must accept mixed iterator/const_iterator
// parameters.
template<typename _IteratorL, typename _IteratorR, typename _Container>
881#if __cplusplus201103L >= 201103L
  // DR 685.
  inline auto
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  -> decltype(__lhs.base() - __rhs.base())
887#else
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
891#endif
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline typename __normal_iterator<_Iterator, _Container>::difference_type
  operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
     __n, const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }

906_GLIBCXX_END_NAMESPACE_VERSION
907} // namespace

909#if __cplusplus201103L >= 201103L

911namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
912{
913_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup iterators
 * @{
 */

// 24.4.3  Move iterators
/**
 *  Class template move_iterator is an iterator adapter with the same
 *  behavior as the underlying iterator except that its dereference
 *  operator implicitly converts the value returned by the underlying
 *  iterator's dereference operator to an rvalue reference.  Some
 *  generic algorithms can be called with move iterators to replace
 *  copying with moving.
 */
template<typename _Iterator>
  class move_iterator
  {
  protected:
    _Iterator _M_current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type	difference_type;
    // NB: DR 680.
    typedef _Iterator					pointer;
    typedef value_type&&				reference;

    move_iterator()
    : _M_current() { }

    explicit
    move_iterator(iterator_type __i)
    : _M_current(__i) { }

    template<typename _Iter>
move_iterator(const move_iterator<_Iter>& __i)
: _M_current(__i.base()) { }

    iterator_type
    base() const
    { return _M_current; }

    reference
    operator*() const
    { return std::move(*_M_current); }

    pointer
    operator->() const
    { return _M_current; }

    move_iterator&
    operator++()
    {
++_M_current;
return *this;
    }

    move_iterator
    operator++(int)
    {
move_iterator __tmp = *this;
++_M_current;
return __tmp;
    }

    move_iterator&
    operator--()
    {
--_M_current;
return *this;
    }

    move_iterator
    operator--(int)
    {
move_iterator __tmp = *this;
--_M_current;
return __tmp;
    }

    move_iterator
    operator+(difference_type __n) const
    { return move_iterator(_M_current + __n); }

    move_iterator&
    operator+=(difference_type __n)
    {
_M_current += __n;
return *this;
    }

    move_iterator
    operator-(difference_type __n) const
    { return move_iterator(_M_current - __n); }
  
    move_iterator&
    operator-=(difference_type __n)
    { 
_M_current -= __n;
return *this;
    }

    reference
    operator[](difference_type __n) const
    { return std::move(_M_current[__n]); }
  };

// Note: See __normal_iterator operators note from Gaby to understand
// why there are always 2 versions for most of the move_iterator
// operators.
template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator==(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline bool
  operator==(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator!=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline bool
  operator!=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  { return __x.base() < __y.base(); }

template<typename _Iterator>
  inline bool
  operator<(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __x.base() < __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline bool
  operator<=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline bool
  operator>(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__x < __y); }

template<typename _Iterator>
  inline bool
  operator>=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x < __y); }

// DR 685.
template<typename _IteratorL, typename _IteratorR>
  inline auto
  operator-(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  -> decltype(__x.base() - __y.base())
  { return __x.base() - __y.base(); }

template<typename _Iterator>
  inline auto
  operator-(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  -> decltype(__x.base() - __y.base())
  { return __x.base() - __y.base(); }

template<typename _Iterator>
  inline move_iterator<_Iterator>
  operator+(typename move_iterator<_Iterator>::difference_type __n,
     const move_iterator<_Iterator>& __x)
  { return __x + __n; }

template<typename _Iterator>
  inline move_iterator<_Iterator>
  make_move_iterator(_Iterator __i)
  { return move_iterator<_Iterator>(__i); }

template<typename _Iterator, typename _ReturnType
  = typename conditional<__move_if_noexcept_cond
    <typename iterator_traits<_Iterator>::value_type>::value,
              _Iterator, move_iterator<_Iterator>>::type>
  inline _ReturnType
  __make_move_if_noexcept_iterator(_Iterator __i)
  { return _ReturnType(__i); }

// @} group iterators

1137_GLIBCXX_END_NAMESPACE_VERSION
1138} // namespace

1140#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) std::make_move_iterator(_Iter)
1141#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) \
std::__make_move_if_noexcept_iterator(_Iter)
1143#else
1144#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) (_Iter)
1145#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) (_Iter)
1146#endif // C++11

1148#endif