6 dMagneticFieldMap(locMagneticFieldMap), dAnalysisUtilities(locAnalysisUtilities)
54 return (dynamic_cast<const DMagneticFieldMapNoField*>(
dMagneticFieldMap) == NULL);
60 return TVector3(0.0, 0.0, 0.0);
62 double locBx, locBy, locBz;
64 return (TVector3(locBx, locBy, locBz));
71 pair<const DBeamPhoton*, const DEventRFBunch*> locSourcePair(locBeamPhoton, NULL);
82 return locKinFitParticle;
87 pair<const DBeamPhoton*, const DEventRFBunch*> locSourcePair(locBeamPhoton, locEventRFBunch);
98 *locCovarianceMatrix = *(locBeamPhoton->
errorMatrix());
99 (*locCovarianceMatrix)(6, 6) = locEventRFBunch->
dTimeVariance;
101 for(
int loc_i = 0; loc_i < 6; ++loc_i)
103 (*locCovarianceMatrix)(6, loc_i) = 0.0;
104 (*locCovarianceMatrix)(loc_i, 6) = 0.0;
110 return locKinFitParticle;
122 double locPathLength = 0.0;
124 if(locChargedHypo !=
nullptr)
129 if(locNeutralHypo !=
nullptr)
136 return locKinFitParticle;
141 pair<const DNeutralShower*, Particle_t> locSourcePair(locNeutralShower, locPID);
151 return locKinFitParticle;
156 auto locTargetPair = std::make_pair(locPID, locInstance);
162 return locKinFitParticle;
172 return locKinFitParticle;
184 return locKinFitParticle;
193 cout <<
"DKinFitUtils_GlueX: Create DKinFitChain." << endl;
196 locKinFitChain->Set_DefinedParticleStepIndex(-1);
203 auto locKinFitChainStep =
Make_KinFitChainStep(locReactionVertexInfo, locReaction, locParticleCombo, locKinFitType, loc_i, locKinFitChain);
204 locKinFitChain->Add_KinFitChainStep(locKinFitChainStep);
212 set<size_t> locMissingMassSteps;
214 for(
int locCurrentStepIndex : locDefinedParticleStepIndices)
216 while(locCurrentStepIndex != -1)
218 if((locCurrentStepIndex == 0) && locKinFitChain->Get_KinFitChainStep(0)->Get_InitialParticles().empty())
220 locMissingMassSteps.insert(locCurrentStepIndex);
221 locCurrentStepIndex = locKinFitChain->Get_KinFitChainStep(locCurrentStepIndex)->Get_InitialParticleDecayFromStepIndex();
225 auto locIsVertexFit = (locKinFitType !=
d_P4Fit);
229 set<size_t> locProcessedSteps;
234 auto locKinFitChainStep = std::const_pointer_cast<
DKinFitChainStep>(locKinFitChain->Get_KinFitChainStep(loc_i));
237 if(locMissingMassSteps.find(loc_i) != locMissingMassSteps.end())
241 if(locKinFitChainStep->Get_InitialParticle(0) !=
nullptr)
245 locProcessedSteps.insert(loc_i);
248 auto locPID = locReactionStep->Get_InitialPID();
257 auto locDecayParticlePair = std::make_pair(loc_i, DReactionStep::Get_ParticleIndex_Initial());
258 auto locDecayingFullConstrainParticles = locStepVertexInfo->Get_DecayingParticles_FullConstrain(
true);
259 if(locDecayingFullConstrainParticles.find(locDecayParticlePair) != locDecayingFullConstrainParticles.end())
264 auto locDecaySourceParticles =
Get_StepParticles_NonNull(locKinFitChain, locReaction, loc_i, DReactionStep::Get_ParticleIndex_Initial());
265 auto locDecayingParticle =
Make_DecayingParticle(locPID, locDecaySourceParticles.first, locDecaySourceParticles.second);
268 locKinFitChainStep->Set_InitialParticle(locDecayingParticle, 0);
270 if((locFromIndices.first < 0) || (locFromIndices.first == loc_i))
273 auto locProductionStep = std::const_pointer_cast<
DKinFitChainStep>(locKinFitChain->Get_KinFitChainStep(locFromIndices.first));
274 locProductionStep->
Set_FinalParticle(locDecayingParticle, locFromIndices.second);
275 locKinFitChain->Set_DecayStepIndex(locDecayingParticle, loc_i);
282 if(locProcessedSteps.find(loc_i) != locProcessedSteps.end())
286 auto locKinFitChainStep = std::const_pointer_cast<
DKinFitChainStep>(locKinFitChain->Get_KinFitChainStep(loc_i));
289 for(
size_t loc_j = 0; loc_j < locParticleComboStep->Get_NumFinalParticles(); ++loc_j)
293 if(locDecayStepIndex < 0)
296 if(locKinFitChain->Get_KinFitChainStep(locDecayStepIndex)->Get_InitialParticle(0) !=
nullptr)
300 auto locPID = locReactionStep->Get_FinalPID(loc_j);
306 auto locDecayingParticle =
Make_DecayingParticle(locPID, locDecaySourceParticles.first, locDecaySourceParticles.second);
307 locKinFitChainStep->Set_FinalParticle(locDecayingParticle, loc_j);
309 auto locDecayStep = std::const_pointer_cast<
DKinFitChainStep>(locKinFitChain->Get_KinFitChainStep(locDecayStepIndex));
311 locKinFitChain->Set_DecayStepIndex(locDecayingParticle, locDecayStepIndex);
317 cout <<
"DKinFitUtils_GlueX: DKinFitChain Created. Printing:" << endl;
318 locKinFitChain->Print_InfoToScreen();
321 return locKinFitChain;
327 auto locKinFitStep = locKinFitChain->Get_KinFitChainStep(locStepIndex);
330 auto locGrabbedInitialParticles = locKinFitStep->Get_InitialParticles();
331 set<shared_ptr<DKinFitParticle>> locInitialParticles(locGrabbedInitialParticles.begin(), locGrabbedInitialParticles.end());
332 locInitialParticles.erase(
nullptr);
335 auto locGrabbedFinalParticles = locKinFitStep->Get_FinalParticles();
336 set<shared_ptr<DKinFitParticle>> locFinalParticles(locGrabbedFinalParticles.begin(), locGrabbedFinalParticles.end());
337 locFinalParticles.erase(
nullptr);
340 for(
size_t loc_i = 0; loc_i < locGrabbedInitialParticles.size(); ++loc_i)
342 if((locGrabbedInitialParticles[loc_i] !=
nullptr) || (locNonFixedMassParticleIndex == DReactionStep::Get_ParticleIndex_Initial()))
347 auto locStepParticles =
Get_StepParticles_NonNull(locKinFitChain, locReaction, locParticlePair.first, locParticlePair.second);
348 locInitialParticles.insert(locStepParticles.first.begin(), locStepParticles.first.end());
349 locFinalParticles.insert(locStepParticles.second.begin(), locStepParticles.second.end());
353 for(
size_t loc_i = 0; loc_i < locGrabbedFinalParticles.size(); ++loc_i)
355 if((locGrabbedFinalParticles[loc_i] !=
nullptr) || (locNonFixedMassParticleIndex == int(loc_i)))
359 auto locStepParticles =
Get_StepParticles_NonNull(locKinFitChain, locReaction, locDecayStepIndex, DReactionStep::Get_ParticleIndex_Initial());
360 locInitialParticles.insert(locStepParticles.first.begin(), locStepParticles.first.end());
361 locFinalParticles.insert(locStepParticles.second.begin(), locStepParticles.second.end());
366 cout <<
"DKinFitUtils_GlueX::Get_StepParticles_NonNull:" << endl;
367 cout <<
"reaction, step-index, non-fixed-mass particle index: " << locReaction->
Get_ReactionName() <<
", " << locStepIndex <<
", " << locNonFixedMassParticleIndex << endl;
368 cout <<
"Chain: " << endl;
369 locKinFitChain->Print_InfoToScreen();
370 cout <<
"Init-particles:" << endl;
371 for(
auto& locParticle : locInitialParticles)
372 cout << locParticle->Get_PID() <<
", " << locParticle << endl;
373 cout <<
"Final-particles:" << endl;
374 for(
auto& locParticle : locFinalParticles)
375 cout << locParticle->Get_PID() <<
", " << locParticle << endl;
377 return std::make_pair(locInitialParticles, locFinalParticles);
384 locKinFitChainStep->Set_ConstrainDecayingMassFlag(
false);
390 int locKinFitStepIndex = locKinFitChain->Get_NumKinFitChainSteps();
397 locKinFitChainStep->Set_InitialParticleDecayFromStepIndex(-1);
398 auto locBeamPhoton =
dynamic_cast<const DBeamPhoton*
>(locParticleComboStep->Get_InitialParticle_Measured());
399 if(locBeamPhoton != NULL)
403 locKinFitChainStep->Add_InitialParticle(
nullptr);
404 if(locStepIndex == 0)
405 locKinFitChain->Set_DefinedParticleStepIndex(locKinFitStepIndex);
409 locKinFitChainStep->Set_InitialParticleDecayFromStepIndex(locDecayFromStepIndex);
410 auto locPID = locReactionStep->Get_InitialPID();
411 auto locConstrainMassFlag =
IsFixedMass(locPID) ? locReactionStep->Get_KinFitConstrainInitMassFlag() :
false;
412 locKinFitChainStep->Set_ConstrainDecayingMassFlag(locConstrainMassFlag);
418 Particle_t locTargetPID = locReactionStep->Get_TargetPID();
421 size_t locTargetInstance = 0;
422 for(
size_t loc_i = 0; loc_i < locStepIndex; ++loc_i)
424 auto locPreviousStep = locKinFitChain->Get_KinFitChainStep(loc_i);
425 auto locInitialParticles = locPreviousStep->Get_InitialParticles();
426 for(
auto& loKinFitParticle : locInitialParticles)
428 if(loKinFitParticle ==
nullptr)
434 locKinFitChainStep->Add_InitialParticle(
Make_TargetParticle(locTargetPID, locTargetInstance));
438 for(
size_t loc_j = 0; loc_j < locParticleComboStep->Get_NumFinalParticles(); ++loc_j)
441 auto locKinematicData = locParticleComboStep->Get_FinalParticle_Measured(loc_j);
442 Particle_t locPID = locReactionStep->Get_FinalPID(loc_j);
444 if(locReactionStep->Get_MissingParticleIndex() == int(loc_j))
446 locKinFitChain->Set_DefinedParticleStepIndex(locKinFitStepIndex);
449 else if(locDecayStepIndex >= 0)
450 locKinFitChainStep->Add_FinalParticle(
nullptr);
456 bool locNeutralShowerFlag = locVertexIsFitFlag && locStepVertexInfo->Get_FittableVertexFlag();
457 if((
ParticleMass(locPID) > 0.0) && !locSpactimeIsFitFlag)
458 locNeutralShowerFlag =
false;
460 if(!locNeutralShowerFlag)
465 locKinFitChainStep->Add_FinalParticle(
Make_DetectedShower(locNeutralShower, locNeutralParticleHypothesis->PID()));
476 if(locReactionStep->Get_MissingParticleIndex() == DReactionStep::Get_ParticleIndex_Inclusive())
477 locKinFitChain->Set_IsInclusiveChannelFlag(
true);
479 return locKinFitChainStep;
487 cout <<
"DKinFitUtils_GlueX: Create constraints." << endl;
490 set<shared_ptr<DKinFitConstraint>> locAllConstraints;
493 set<shared_ptr<DKinFitConstraint_Mass>> locMassConstraints;
494 map<shared_ptr<DKinFitParticle>, shared_ptr<DKinFitConstraint_Mass>> locParticleMassConstraintMap;
495 map<shared_ptr<DKinFitParticle>,
size_t> locParticleDecayStepMap;
496 map<size_t, shared_ptr<DKinFitConstraint_Mass>> locStepMassConstraintMap;
497 int locP4StepIndex = 0;
501 for(
size_t loc_i = 1; loc_i < locKinFitChain->Get_NumKinFitChainSteps(); ++loc_i)
503 auto locKinFitChainStep = locKinFitChain->Get_KinFitChainStep(loc_i);
504 if(!locKinFitChainStep->Get_ConstrainDecayingMassFlag())
507 for(
auto locKinFitParticle : locKinFitChainStep->Get_InitialParticles())
509 if(locKinFitParticle ==
nullptr)
516 locP4StepIndex = loc_i;
519 locMassConstraints.insert(locMassConstraint);
520 locParticleMassConstraintMap[locKinFitParticle] = locMassConstraint;
521 locParticleDecayStepMap[locKinFitParticle] = loc_i;
522 locStepMassConstraintMap[loc_i] = locMassConstraint;
531 shared_ptr<DKinFitConstraint_P4> locP4Constraint =
nullptr;
533 if(!locKinFitChain->Get_IsInclusiveChannelFlag() && (locDefinedParticleStepIndices.size() <= 1) && ((locKinFitType ==
d_P4Fit) || (locKinFitType ==
d_P4AndVertexFit) || (locKinFitType ==
d_P4AndSpacetimeFit)))
535 if(!locDefinedParticleStepIndices.empty())
536 locP4StepIndex = locDefinedParticleStepIndices.front();
538 locP4Constraint =
Make_P4Constraint(locStepParticles.first, locStepParticles.second);
542 bool locNonZeroErrorFlag =
false;
543 auto locAllParticles = locP4Constraint->Get_AllParticles();
544 set<size_t> locP4ConstrainedParticleSteps;
545 for(
auto& locKinFitParticle : locAllParticles)
552 if(locParticleMassConstraintMap.find(locKinFitParticle) == locParticleMassConstraintMap.end())
554 locNonZeroErrorFlag =
true;
557 locP4ConstrainedParticleSteps.insert(locParticleDecayStepMap[locKinFitParticle]);
561 if(locKinFitParticle->Get_CovarianceMatrix() == NULL)
566 locNonZeroErrorFlag =
true;
570 if(!locNonZeroErrorFlag)
576 size_t locEarliestStepIndex = *locP4ConstrainedParticleSteps.begin();
577 locMassConstraints.erase(locStepMassConstraintMap[locEarliestStepIndex]);
581 if(locP4Constraint->Get_DefinedParticle() != NULL)
584 if(locP4Constraint->Get_IsDefinedParticleInFinalState())
588 TVector3 locInitP3Guess(locDefinedP4.Px(), locDefinedP4.Py(), locDefinedP4.Pz());
589 locP4Constraint->Set_InitP3Guess(locInitP3Guess);
592 locP4Constraint->Set_InitP3Guess(TVector3(0.0, 0.0, 0.0));
596 if(locP4Constraint != NULL)
597 locAllConstraints.insert(locP4Constraint);
598 locAllConstraints.insert(locMassConstraints.begin(), locMassConstraints.end());
602 locSortedVertexConstraints.clear();
608 if(!locStepVertexInfo->Get_FittableVertexFlag())
610 auto locDX4 = locParticleCombo->
Get_ParticleComboStep(locStepVertexInfo->Get_StepIndices().front())->Get_SpacetimeVertex();
611 TLorentzVector locX4(locDX4.X(), locDX4.Y(), locDX4.Z(), locDX4.T());
613 auto locFullConstrainParticles =
Build_ParticleSet(locStepVertexInfo->Get_FullConstrainParticles(
true), locKinFitChain);
614 auto locNoConstrainParticles =
Build_ParticleSet(locStepVertexInfo->Get_NoConstrainParticles(
true), locKinFitChain);
615 auto locOnlyConstrainTimeParticles =
Build_ParticleSet(locStepVertexInfo->Get_OnlyConstrainTimeParticles(), locKinFitChain);
616 if(locSpacetimeFitFlag)
617 locSortedVertexConstraints.push_back(
Make_SpacetimeConstraint(locFullConstrainParticles, locOnlyConstrainTimeParticles, locNoConstrainParticles, locX4));
620 locNoConstrainParticles.insert(locOnlyConstrainTimeParticles.begin(), locOnlyConstrainTimeParticles.end());
621 locSortedVertexConstraints.push_back(
Make_VertexConstraint(locFullConstrainParticles, locNoConstrainParticles, locX4.Vect()));
625 locAllConstraints.insert(locSortedVertexConstraints.begin(), locSortedVertexConstraints.end());
628 cout <<
"DKinFitUtils_GlueX: All Constraints Created." << endl;
630 return locAllConstraints;
635 set<shared_ptr<DKinFitParticle>> locParticles;
636 for(
auto& locParticlePair : locParticleIndices)
638 auto locStep = locKinFitChain->Get_KinFitChainStep(locParticlePair.first);
639 if(locParticlePair.second >= 0)
641 if(locStep->Get_FinalParticle(locParticlePair.second) !=
nullptr)
642 locParticles.insert(locStep->Get_FinalParticle(locParticlePair.second));
644 else if(locParticlePair.second == DReactionStep::Get_ParticleIndex_Initial())
646 if(locStep->Get_InitialParticle(0) !=
nullptr)
647 locParticles.insert(locStep->Get_InitialParticle(0));
650 locParticles.insert(locStep->Get_InitialParticle(1));
661 string locAllConstraintsString;
662 locNumConstraints = 0;
667 auto locIsVertexFit = ((locKinFitType !=
d_NoFit) && (locKinFitType !=
d_P4Fit));
672 map<size_t, string> locMassConstraintStrings;
673 int locP4StepIndex = 0;
689 auto locDecayParticlePair = std::make_pair(loc_i, DReactionStep::Get_ParticleIndex_Initial());
690 auto locDecayingFullConstrainParticles = locStepVertexInfo->Get_DecayingParticles_FullConstrain(
true);
694 if(locDecayingFullConstrainParticles.find(locDecayParticlePair) != locDecayingFullConstrainParticles.end())
695 locP4StepIndex = loc_i;
705 if(!locDefinedParticleStepIndices.empty())
706 locP4StepIndex = locDefinedParticleStepIndices.front();
709 bool locNonZeroErrorFlag =
false;
714 set<size_t> locP4ConstrainedParticleSteps;
718 locNonZeroErrorFlag =
true;
719 else if((locP4StepIndex != 0) && (locMassConstraintStrings.find(locP4StepIndex) == locMassConstraintStrings.end()))
720 locNonZeroErrorFlag =
true;
730 if(locDecayStepIndex > 0)
732 if(locMassConstraintStrings.find(locDecayStepIndex) != locMassConstraintStrings.end())
734 locP4ConstrainedParticleSteps.insert(locDecayStepIndex);
739 locNonZeroErrorFlag =
true;
744 if(!locNonZeroErrorFlag)
750 if((locP4StepIndex != 0) && (locMassConstraintStrings.find(locP4StepIndex) != locMassConstraintStrings.end()))
751 locMassConstraintStrings.erase(locP4StepIndex);
754 size_t locEarliestStepIndex = *locP4ConstrainedParticleSteps.begin();
755 locMassConstraintStrings.erase(locEarliestStepIndex);
760 locAllConstraintsString =
"#it{p}^{4}";
761 locNumConstraints += 4;
762 if(!locDefinedParticleStepIndices.empty())
767 locNumConstraints += locMassConstraintStrings.size();
768 map<size_t, string>::iterator locStringIterator = locMassConstraintStrings.begin();
769 for(; locStringIterator != locMassConstraintStrings.end(); ++locStringIterator)
771 if(locAllConstraintsString !=
"")
772 locAllConstraintsString +=
", ";
773 locAllConstraintsString += locStringIterator->second;
783 if(std::get<0>(locConstraintTuple) > 0)
785 locNumConstraints += std::get<0>(locConstraintTuple);
786 locNumUnknowns += std::get<1>(locConstraintTuple);
787 if(locAllConstraintsString !=
"")
788 locAllConstraintsString +=
", ";
789 locAllConstraintsString += std::get<2>(locConstraintTuple);
793 return locAllConstraintsString;
799 size_t locNumConstraints = 0, locNumUnknowns = 0;
800 string locAllConstraintString;
802 for(
auto& locVertexInfo : locStepVertexInfos)
804 if(!locVertexInfo->Get_FittableVertexFlag())
807 auto locFullConstrainParticles = locVertexInfo->Get_FullConstrainParticles(
true);
808 if(locSpacetimeFitFlag)
810 locNumConstraints += 3*locFullConstrainParticles.size();
811 locNumConstraints += locVertexInfo->Get_OnlyConstrainTimeParticles().size();
816 locNumConstraints += 2*locFullConstrainParticles.size();
821 if(locAllConstraintString !=
"")
822 locAllConstraintString +=
", ";
826 return std::make_tuple(locNumConstraints, locNumUnknowns, locAllConstraintString);
832 string locConstraintString = locSpacetimeFitFlag ?
"#it{x}^{4}_{" :
"#it{x}^{3}_{";
838 set<pair<int, int>> locExcludeDecayParticleIndices;
839 for(
size_t loc_i = 1; loc_i < locStepIndices.size(); ++loc_i)
845 for(
auto locIndices : locParticles)
847 auto locStep = locReaction->Get_ReactionStep(locIndices.first);
848 Particle_t locPID = locStep->Get_PID(locIndices.second);
850 if(locIndices.second == locStep->Get_MissingParticleIndex())
851 locConstraintString +=
string(
"(") + locParticleString +
string(
")");
852 else if(std::binary_search(locFullConstrainParticles.begin(), locFullConstrainParticles.end(), locIndices))
853 locConstraintString +=
string(
"#color[4]{") + locParticleString +
string(
"}");
855 locConstraintString += locParticleString;
859 locConstraintString +=
"#rightarrow";
863 for(
auto locIndices : locParticles)
865 if(locExcludeDecayParticleIndices.find(locIndices) != locExcludeDecayParticleIndices.end())
868 auto locStep = locReaction->Get_ReactionStep(locIndices.first);
869 Particle_t locPID = locStep->Get_PID(locIndices.second);
872 if(locIndices.second == locStep->Get_MissingParticleIndex())
873 locConstraintString +=
string(
"(") + locParticleString +
string(
")");
874 else if(std::binary_search(locFullConstrainParticles.begin(), locFullConstrainParticles.end(), locIndices))
875 locConstraintString +=
string(
"#color[4]{") + locParticleString +
string(
"}");
876 else if(locSpacetimeFitFlag && std::binary_search(locOnlyConstrainTimeParticles.begin(), locOnlyConstrainTimeParticles.end(), locIndices))
877 locConstraintString +=
string(
"#color[3]{") + locParticleString +
string(
"}");
879 locConstraintString += locParticleString;
882 locConstraintString +=
string(
"}");
884 return locConstraintString;
895 TVector3 locMomentum;
896 TLorentzVector locSpacetimeVertex;
897 pair<double, double> locPathLengthPair, locRestFrameLifetimePair;
898 TMatrixFSym locTempCovarianceMatrix(11);
904 *locCovarianceMatrix = locTempCovarianceMatrix.GetSub(0, 6, *locCovarianceMatrix);
907 locKinematicData->
setPosition(
DVector3(locSpacetimeVertex.Vect().X(),locSpacetimeVertex.Vect().Y(),locSpacetimeVertex.Vect().Z()));
908 locKinematicData->
setTime(locSpacetimeVertex.T());
vector< pair< int, int > > Get_FullConstrainParticles(bool locFitFlag, DReactionState_t locState=d_EitherState, Charge_t locCharge=d_AllCharges, bool locIncludeDecayingFlag=true) const
void setMomentum(const DVector3 &aMomentum)
TVector3 Get_BField(const TVector3 &locPosition) const
shared_ptr< DKinFitConstraint_Vertex > Make_VertexConstraint(const set< shared_ptr< DKinFitParticle >> &locFullConstrainParticles, const set< shared_ptr< DKinFitParticle >> &locNoConstrainParticles, TVector3 locVertexGuess=TVector3())
void setTime(double locTime)
static char * ParticleName_ROOT(Particle_t p)
void Reset_NewEvent(void)
bool Get_IncludeBeamlineInVertexFitFlag(void) const
pair< int, int > Get_InitialParticleDecayFromIndices(const DReaction *locReaction, int locStepIndex)
const DAnalysisUtilities * dAnalysisUtilities
vector< size_t > Get_DefinedParticleStepIndex(const DReaction *locReaction)
size_t Get_NumParticleComboSteps(void) const
DKinFitType Get_KinFitType(void) const
string Build_VertexConstraintString(const DReactionStepVertexInfo *locVertexInfo, bool locSpacetimeFitFlag) const
shared_ptr< DKinFitParticle > Make_BeamParticle(int locPID, int locCharge, double locMass, TLorentzVector locSpacetimeVertex, TVector3 locMomentum, const shared_ptr< const TMatrixFSym > &locCovarianceMatrix)
bool Get_KinFitConstrainInitMassFlag(void) const
shared_ptr< DKinFitParticle > Make_DetectedShower(const DNeutralShower *locNeutralShower, Particle_t locPID)
set< shared_ptr< DKinFitParticle > > Build_ParticleSet(const vector< pair< int, int >> &locParticleIndices, const shared_ptr< const DKinFitChain > &locKinFitChain)
map< pair< const DBeamPhoton *, const DEventRFBunch * >, shared_ptr< DKinFitParticle > > dParticleMap_SourceToInput_Beam
const DReactionStepVertexInfo * Get_StepVertexInfo(size_t locStepIndex) const
bool dWillBeamHaveErrorsFlag
map< Particle_t, shared_ptr< DKinFitParticle > > dParticleMap_SourceToInput_Missing
DMagneticFieldMap * GetBfield(unsigned int run_number=1)
shared_ptr< DKinFitParticle > Make_DetectedParticle(int locPID, int locCharge, double locMass, TLorentzVector locSpacetimeVertex, TVector3 locMomentum, double locPathLength, const shared_ptr< const TMatrixFSym > &locCovarianceMatrix)
const DVector3 & position(void) const
TLorentzVector Make_TLorentzVector(DLorentzVector locDLorentzVector) const
Particle_t Get_TargetPID(void) const
double Get_PathLength(void) const
shared_ptr< DKinFitParticle > Make_DetectedShower(int locPID, double locMass, TLorentzVector locSpacetimeVertex, double locShowerEnergy, const shared_ptr< const TMatrixFSym > &locCovarianceMatrix)
shared_ptr< DKinFitParticle > Make_DetectedParticle(const DKinematicData *locKinematicData)
bool Propagate_TrackInfoToCommonVertex(DKinematicData *locKinematicData, DKinFitParticle *locKinFitParticle, const TMatrixDSym *locVXi)
TLorentzVector DLorentzVector
double Get_PathLength(void) const
static int ParticleCharge(Particle_t p)
const DNeutralShower * Get_NeutralShower(void) const
static int PDGtype(Particle_t p)
shared_ptr< DKinFitParticle > Make_BeamParticle(const DBeamPhoton *locBeamPhoton)
TVector3 Make_TVector3(DVector3 locDVector3) const
DLorentzVector dSpacetimeVertex
shared_ptr< DKinFitParticle > Make_MissingParticle(int locPID, int locCharge, double locMass)
const DReaction * Get_Reaction(void) const
string Get_ConstraintInfo(const DReactionVertexInfo *locReactionVertexInfo, const DReaction *locReaction, size_t &locNumConstraints, size_t &locNumUnknowns) const
DLorentzVector Calc_FinalStateP4(const DReaction *locReaction, const DParticleCombo *locParticleCombo, size_t locStepIndex, bool locUseKinFitDataFlag) const
void setErrorMatrix(const shared_ptr< const TMatrixFSym > &aMatrix)
void Set_FinalParticle(const shared_ptr< DKinFitParticle > &locFinalParticle, size_t locIndex)
virtual void Reset_NewEvent(void)
shared_ptr< DResourcePool< DKinFitChain > > dResourcePool_KinFitChain
shared_ptr< DKinFitParticle > Make_TargetParticle(int locPID, int locCharge, double locMass)
Particle_t Get_InitialPID(void) const
shared_ptr< DKinFitConstraint_Mass > Make_MassConstraint(const shared_ptr< DKinFitParticle > &locDecayingParticle)
shared_ptr< TMatrixFSym > Get_SymMatrixResource(unsigned int locNumMatrixRows)
DLorentzVector Calc_MissingP4(const DReaction *locReaction, const DParticleCombo *locParticleCombo, bool locUseKinFitDataFlag) const
string Get_ReactionName(void) const
map< DDecayingParticleInfo, shared_ptr< DKinFitParticle > > dParticleMap_SourceToInput_Decaying
DApplication * dApplication
static unsigned short int IsFixedMass(Particle_t p)
shared_ptr< TMatrixFSym > dCovarianceMatrix
map< shared_ptr< DKinFitParticle >, DDecayingParticleInfo > dParticleMap_InputToSource_Decaying
bool Propagate_TrackInfoToCommonVertex(const DKinFitParticle *locKinFitParticle, const TMatrixDSym *locVXi, TVector3 &locMomentum, TLorentzVector &locSpacetimeVertex, pair< double, double > &locPathLengthPair, pair< double, double > &locRestFrameLifetimePair, TMatrixFSym *locCovarianceMatrix) const
shared_ptr< DKinFitParticle > Make_MissingParticle(Particle_t locPID)
shared_ptr< DKinFitParticle > Make_DecayingParticle(Particle_t locPID, const set< shared_ptr< DKinFitParticle >> &locFromInitialState, const set< shared_ptr< DKinFitParticle >> &locFromFinalState)
shared_ptr< DKinFitConstraint_Spacetime > Make_SpacetimeConstraint(const set< shared_ptr< DKinFitParticle >> &locFullConstrainParticles, const set< shared_ptr< DKinFitParticle >> &locOnlyConstrainTimeParticles, const set< shared_ptr< DKinFitParticle >> &locNoConstrainParticles, TLorentzVector locSpacetimeGuess=TLorentzVector())
void Set_InitialParticle(const shared_ptr< DKinFitParticle > &locInitialParticle, size_t locIndex)
map< pair< const DNeutralShower *, Particle_t >, shared_ptr< DKinFitParticle > > dParticleMap_SourceToInput_Shower
shared_ptr< DKinFitConstraint_P4 > Make_P4Constraint(const set< shared_ptr< DKinFitParticle >> &locInitialParticles, const set< shared_ptr< DKinFitParticle >> &locFinalParticles)
bool dIncludeBeamlineInVertexFitFlag
int Get_MissingParticleIndex(void) const
pair< set< shared_ptr< DKinFitParticle > >, set< shared_ptr< DKinFitParticle > > > Get_StepParticles_NonNull(const shared_ptr< const DKinFitChain > &locKinFitChain, const DReaction *locReaction, size_t locStepIndex, int locNonFixedMassParticleIndex=-99) const
shared_ptr< DKinFitParticle > Make_TargetParticle(Particle_t locPID, size_t locInstance=0)
static double ParticleMass(Particle_t p)
vector< const DReactionStepVertexInfo * > Get_StepVertexInfos(void) const
set< shared_ptr< DKinFitConstraint > > Create_Constraints(const DReactionVertexInfo *locReactionVertexInfo, const DReaction *locReaction, const DParticleCombo *locParticleCombo, const shared_ptr< const DKinFitChain > &locKinFitChain, DKinFitType locKinFitType, vector< shared_ptr< DKinFitConstraint_Vertex >> &locSortedVertexConstraints)
tuple< size_t, size_t, string > Predict_VertexConstraints(const DReactionVertexInfo *locReactionVertexInfo, bool locSpacetimeFitFlag) const
bool Get_IsBFieldNearBeamline(void) const
size_t Get_NumFinalPIDs(void) const
const DVector3 & momentum(void) const
vector< pair< int, int > > Get_OnlyConstrainTimeParticles(void) const
map< shared_ptr< DKinFitParticle >, const JObject * > dParticleMap_InputToSource_JObject
map< const DKinematicData *, shared_ptr< DKinFitParticle > > dParticleMap_SourceToInput_DetectedParticle
bool Get_IsDecayingParticleDefinedByProducts(const DKinFitParticle *locKinFitParticle) const
const DReactionStep * Get_ReactionStep(size_t locStepIndex) const
const DMagneticFieldMap * dMagneticFieldMap
int Get_DecayStepIndex(const DReaction *locReaction, size_t locStepIndex, size_t locParticleIndex)
bool Get_IsInclusiveFlag(void) const
shared_ptr< const TMatrixFSym > errorMatrix(void) const
const DParticleComboStep * Get_ParticleComboStep(size_t locStepIndex) const
void setPosition(const DVector3 &aPosition)
virtual void GetField(const DVector3 &pos, DVector3 &Bout) const =0
vector< size_t > Get_StepIndices(void) const
size_t Get_NumReactionSteps(void) const
shared_ptr< DKinFitParticle > Make_DecayingParticle(int locPID, int locCharge, double locMass, const set< shared_ptr< DKinFitParticle >> &locFromInitialState, const set< shared_ptr< DKinFitParticle >> &locFromFinalState)
shared_ptr< DResourcePool< DKinFitChainStep > > dResourcePool_KinFitChainStep
shared_ptr< DKinFitChainStep > Make_KinFitChainStep(const DReactionVertexInfo *locReactionVertexInfo, const DReaction *locReaction, const DParticleCombo *locParticleCombo, DKinFitType locKinFitType, size_t locStepIndex, const shared_ptr< DKinFitChain > &locKinFitChain)
Particle_t PID(void) const
vector< pair< int, int > > Get_Particles(DReactionState_t locState=d_EitherState, Charge_t locCharge=d_AllCharges, bool locIncludeDecayingFlag=true, bool locIncludeMissingFlag=true, bool locIncludeTargetFlag=true) const
map< pair< Particle_t, size_t >, shared_ptr< DKinFitParticle > > dParticleMap_SourceToInput_Target
shared_ptr< const DKinFitChain > Make_KinFitChain(const DReactionVertexInfo *locReactionVertexInfo, const DReaction *locReaction, const DParticleCombo *locParticleCombo, DKinFitType locKinFitType)