50 locSymMatrix->ResizeTo(locNumMatrixRows, locNumMatrixRows);
56 shared_ptr<DKinFitParticle>
DKinFitUtils::Make_BeamParticle(
int locPID,
int locCharge,
double locMass, TLorentzVector locSpacetimeVertex, TVector3 locMomentum,
const shared_ptr<const TMatrixFSym>& locCovarianceMatrix)
58 if((locCovarianceMatrix->GetNrows() != 7) || (locCovarianceMatrix->GetNcols() != 7))
62 locKinFitParticle->Set_PID(locPID);
63 locKinFitParticle->Set_Charge(locCharge);
64 locKinFitParticle->Set_Mass(locMass);
65 locKinFitParticle->Set_SpacetimeVertex(locSpacetimeVertex);
66 locKinFitParticle->Set_CommonSpacetimeVertex(locSpacetimeVertex);
68 locKinFitParticle->Set_Momentum(locMomentum);
69 locKinFitParticle->Set_CovarianceMatrix(locCovarianceMatrix);
75 cout <<
"DKinFitUtils: Beam particle created. Printing:" << endl;
76 locKinFitParticle->Print_ParticleParams();
79 return locKinFitParticle;
85 locKinFitParticle->Set_PID(locPID);
86 locKinFitParticle->Set_Charge(locCharge);
87 locKinFitParticle->Set_Mass(locMass);
89 locKinFitParticle->Set_VertexP4AtProductionVertex(
true);
93 cout <<
"DKinFitUtils: Target particle created. Printing:" << endl;
94 locKinFitParticle->Print_ParticleParams();
97 return locKinFitParticle;
100 shared_ptr<DKinFitParticle>
DKinFitUtils::Make_DetectedParticle(
int locPID,
int locCharge,
double locMass, TLorentzVector locSpacetimeVertex, TVector3 locMomentum,
double locPathLength,
const shared_ptr<const TMatrixFSym>& locCovarianceMatrix)
102 if((locCovarianceMatrix->GetNrows() != 7) || (locCovarianceMatrix->GetNcols() != 7))
106 locKinFitParticle->Set_PID(locPID);
107 locKinFitParticle->Set_Charge(locCharge);
108 locKinFitParticle->Set_Mass(locMass);
109 locKinFitParticle->Set_SpacetimeVertex(locSpacetimeVertex);
110 locKinFitParticle->Set_CommonSpacetimeVertex(locSpacetimeVertex);
111 locKinFitParticle->Set_Momentum(locMomentum);
112 locKinFitParticle->Set_CovarianceMatrix(locCovarianceMatrix);
113 locKinFitParticle->Set_PathLength(locPathLength);
118 cout <<
"DKinFitUtils: Detected particle created. Printing:" << endl;
119 locKinFitParticle->Print_ParticleParams();
122 return locKinFitParticle;
125 shared_ptr<DKinFitParticle>
DKinFitUtils::Make_DetectedShower(
int locPID,
double locMass, TLorentzVector locSpacetimeVertex,
double locShowerEnergy,
const shared_ptr<const TMatrixFSym>& locCovarianceMatrix)
127 if((locCovarianceMatrix->GetNrows() != 5) || (locCovarianceMatrix->GetNcols() != 5))
131 locKinFitParticle->Set_PID(locPID);
132 locKinFitParticle->Set_Charge(0);
133 locKinFitParticle->Set_Mass(locMass);
134 locKinFitParticle->Set_IsNeutralShowerFlag(
true);
135 locKinFitParticle->Set_SpacetimeVertex(locSpacetimeVertex);
136 locKinFitParticle->Set_CommonSpacetimeVertex(locSpacetimeVertex);
137 locKinFitParticle->Set_ShowerEnergy(locShowerEnergy);
138 locKinFitParticle->Set_CovarianceMatrix(locCovarianceMatrix);
144 cout <<
"DKinFitUtils: Detected shower created. Printing:" << endl;
145 locKinFitParticle->Print_ParticleParams();
148 return locKinFitParticle;
154 locKinFitParticle->Set_PID(locPID);
155 locKinFitParticle->Set_Charge(locCharge);
156 locKinFitParticle->Set_Mass(locMass);
158 locKinFitParticle->Set_VertexP4AtProductionVertex(
true);
162 cout <<
"DKinFitUtils: Missing particle created. Printing:" << endl;
163 locKinFitParticle->Print_ParticleParams();
166 return locKinFitParticle;
169 shared_ptr<DKinFitParticle>
DKinFitUtils::Make_DecayingParticle(
int locPID,
int locCharge,
double locMass,
const set<shared_ptr<DKinFitParticle>>& locFromInitialState,
const set<shared_ptr<DKinFitParticle>>& locFromFinalState)
172 locKinFitParticle->Set_PID(locPID);
173 locKinFitParticle->Set_Charge(locCharge);
174 locKinFitParticle->Set_Mass(locMass);
176 locKinFitParticle->Set_FromInitialState(locFromInitialState);
177 locKinFitParticle->Set_FromFinalState(locFromFinalState);
181 cout <<
"DKinFitUtils: Decaying particle created. Printing:" << endl;
182 locKinFitParticle->Print_ParticleParams();
185 return locKinFitParticle;
194 cout <<
"ERROR: Wrong particle type in DKinFitUtils::Make_MassConstraint(). Returning NULL." << endl;
201 return locIterator->second;
204 locConstraint->Set_DecayingParticle(locDecayingParticle);
207 return locConstraint;
210 shared_ptr<DKinFitConstraint_P4>
DKinFitUtils::Make_P4Constraint(
const set<shared_ptr<DKinFitParticle>>& locInitialParticles,
const set<shared_ptr<DKinFitParticle>>& locFinalParticles)
213 auto locInputPair = std::make_pair(locInitialParticles, locFinalParticles);
216 return locIterator->second;
219 locConstraint->Set_InitialParticles(locInitialParticles);
220 locConstraint->Set_FinalParticles(locFinalParticles);
223 return locConstraint;
226 shared_ptr<DKinFitConstraint_Vertex>
DKinFitUtils::Make_VertexConstraint(
const set<shared_ptr<DKinFitParticle>>& locFullConstrainParticles,
const set<shared_ptr<DKinFitParticle>>& locNoConstrainParticles, TVector3 locVertexGuess)
229 auto locInputPair = std::make_pair(locFullConstrainParticles, locNoConstrainParticles);
232 return locIterator->second;
235 locConstraint->Set_FullConstrainParticles(locFullConstrainParticles);
236 locConstraint->Set_NoConstrainParticles(locNoConstrainParticles);
237 locConstraint->Set_InitVertexGuess(locVertexGuess);
240 return locConstraint;
243 shared_ptr<DKinFitConstraint_Spacetime>
DKinFitUtils::Make_SpacetimeConstraint(
const set<shared_ptr<DKinFitParticle>>& locFullConstrainParticles,
const set<shared_ptr<DKinFitParticle>>& locOnlyConstrainTimeParticles,
const set<shared_ptr<DKinFitParticle>>& locNoConstrainParticles, TLorentzVector locSpacetimeGuess)
245 cout <<
"ERROR: SPACETIME CONSTRAINTS ARE NOT SUPPORTED YET. RETURNING NULL FROM DKinFitUtils::Make_SpacetimeConstraint()." << endl;
249 DSpacetimeParticles locSpacetimeParticles(locFullConstrainParticles, locOnlyConstrainTimeParticles, locNoConstrainParticles);
252 return locIterator->second;
255 locConstraint->Set_FullConstrainParticles(locFullConstrainParticles);
256 locConstraint->Set_OnlyConstrainTimeParticles(locOnlyConstrainTimeParticles);
257 locConstraint->Set_NoConstrainParticles(locNoConstrainParticles);
258 locConstraint->Set_InitVertexGuess(locSpacetimeGuess.Vect());
259 locConstraint->Set_InitTimeGuess(locSpacetimeGuess.T());
262 return locConstraint;
269 if(locMatrix == NULL)
271 int locMatrixSize = locMatrix->GetNcols();
273 *locNewMatrix = *locMatrix;
280 *locClonedKinFitParticle = *locKinFitParticle;
284 cout <<
"Cloned Particle: PID, input, output = " << locKinFitParticle->Get_PID() <<
", " << locKinFitParticle <<
", " << locClonedKinFitParticle << endl;
287 auto locCovarianceMatrix = locClonedKinFitParticle->Get_CovarianceMatrix();
289 locClonedKinFitParticle->Set_CovarianceMatrix(
Clone_SymMatrix(locCovarianceMatrix.get()));
291 return locClonedKinFitParticle;
298 *locClonedConstraint = *locConstraint;
299 return locClonedConstraint;
306 *locClonedConstraint = *locConstraint;
307 return locClonedConstraint;
314 *locClonedConstraint = *locConstraint;
315 return locClonedConstraint;
322 *locClonedConstraint = *locConstraint;
323 return locClonedConstraint;
326 set<shared_ptr<DKinFitParticle>>
DKinFitUtils::Build_CloneParticleSet(
const set<shared_ptr<DKinFitParticle>>& locInputParticles,
const map<shared_ptr<DKinFitParticle>, shared_ptr<DKinFitParticle>>& locCloneIOMap)
const
328 set<shared_ptr<DKinFitParticle>> locCloneParticles;
329 for(
auto& locParticle : locInputParticles)
330 locCloneParticles.insert(locCloneIOMap.find(locParticle)->second);
331 return locCloneParticles;
336 set<shared_ptr<DKinFitConstraint>> locClonedConstraints;
340 set<shared_ptr<DKinFitParticle>> locAllParticles;
341 for(
auto& locConstraint : locInputConstraints)
343 auto locConstraintKinFitParticles = locConstraint->Get_AllParticles();
344 locAllParticles.insert(locConstraintKinFitParticles.begin(), locConstraintKinFitParticles.end());
347 for(
auto& locParticle : locConstraintKinFitParticles)
349 auto locFromAllParticles = locParticle->Get_FromAllParticles();
350 locAllParticles.insert(locFromAllParticles.begin(), locFromAllParticles.end());
357 map<shared_ptr<DKinFitParticle>, shared_ptr<DKinFitParticle>> locCloneIOMap;
358 for(
auto& locParticle : locAllParticles)
362 for(
auto& locClonePair : locCloneIOMap)
364 auto locOutputParticle = locClonePair.second;
369 set<shared_ptr<DKinFitParticle>> locNewFromInitialState;
370 auto locFromInitialState = locOutputParticle->Get_FromInitialState();
371 for(
auto& locParticle : locFromInitialState)
372 locNewFromInitialState.insert(locCloneIOMap[locParticle]);
373 locOutputParticle->Set_FromInitialState(locNewFromInitialState);
376 set<shared_ptr<DKinFitParticle>> locNewFromFinalState;
377 auto locFromFinalState = locOutputParticle->Get_FromFinalState();
378 for(
auto& locParticle : locFromFinalState)
379 locNewFromFinalState.insert(locCloneIOMap[locParticle]);
380 locOutputParticle->Set_FromFinalState(locNewFromFinalState);
384 for(
auto& locConstraint : locInputConstraints)
387 if(locP4Constraint != NULL)
390 locClonedConstraint->Set_InitialParticles(
Build_CloneParticleSet(locClonedConstraint->Get_InitialParticles(), locCloneIOMap));
391 locClonedConstraint->Set_FinalParticles(
Build_CloneParticleSet(locClonedConstraint->Get_FinalParticles(), locCloneIOMap));
392 locClonedConstraints.insert(std::dynamic_pointer_cast<DKinFitConstraint>(locClonedConstraint));
397 if(locMassConstraint != NULL)
400 locClonedConstraint->Set_DecayingParticle(locCloneIOMap.find(locClonedConstraint->Get_DecayingParticle())->second);
401 locClonedConstraints.insert(std::dynamic_pointer_cast<DKinFitConstraint>(locClonedConstraint));
407 if((locVertexConstraint != NULL) && (locSpacetimeConstraint == NULL))
410 locClonedConstraint->Set_FullConstrainParticles(
Build_CloneParticleSet(locClonedConstraint->Get_FullConstrainParticles(), locCloneIOMap));
411 locClonedConstraint->Set_NoConstrainParticles(
Build_CloneParticleSet(locClonedConstraint->Get_NoConstrainParticles(), locCloneIOMap));
412 locClonedConstraints.insert(std::dynamic_pointer_cast<DKinFitConstraint>(locClonedConstraint));
416 if(locSpacetimeConstraint != NULL)
419 locClonedConstraint->Set_FullConstrainParticles(
Build_CloneParticleSet(locClonedConstraint->Get_FullConstrainParticles(), locCloneIOMap));
420 locClonedConstraint->Set_NoConstrainParticles(
Build_CloneParticleSet(locClonedConstraint->Get_NoConstrainParticles(), locCloneIOMap));
421 locClonedConstraint->Set_OnlyConstrainTimeParticles(
Build_CloneParticleSet(locClonedConstraint->Get_OnlyConstrainTimeParticles(), locCloneIOMap));
422 locClonedConstraints.insert(std::dynamic_pointer_cast<DKinFitConstraint>(locClonedConstraint));
427 return locClonedConstraints;
434 set<shared_ptr<DKinFitParticle>> locAllParticles;
435 auto locConstraintIterator = locKinFitConstraints.begin();
436 for(; locConstraintIterator != locKinFitConstraints.end(); ++locConstraintIterator)
438 auto locConstraintKinFitParticles = (*locConstraintIterator)->Get_AllParticles();
439 locAllParticles.insert(locConstraintKinFitParticles.begin(), locConstraintKinFitParticles.end());
442 auto locParticleIterator = locConstraintKinFitParticles.begin();
443 for(; locParticleIterator != locConstraintKinFitParticles.end(); ++locParticleIterator)
445 auto locFromAllParticles = (*locParticleIterator)->Get_FromAllParticles();
446 locAllParticles.insert(locFromAllParticles.begin(), locFromAllParticles.end());
451 for(
auto& locParticle : locAllParticles)
454 locKinFitConstraints.clear();
471 if(locFromInitState.empty())
473 if(locFromInitState.size() >= 2)
475 return ((*locFromInitState.begin())->Get_KinFitParticleType() ==
d_TargetParticle);
483 return TLorentzVector();
487 bool locDontPropagateDecayingP3Flag = (locP3DerivedAtPositionFlag == locAtPositionFlag);
488 return Calc_DecayingP4(locKinFitParticle, locDontPropagateDecayingP3Flag, 1.0, locDontPropagateAtAllFlag);
496 return TLorentzVector();
498 bool locDontPropagateDecayingP3Flag = locAtP3DerivedFlag;
499 return Calc_DecayingP4(locKinFitParticle, locDontPropagateDecayingP3Flag, 1.0, locDontPropagateAtAllFlag);
507 return TLorentzVector();
510 bool locDontPropagateDecayingP3Flag = (locP3DerivedAtProductionVertexFlag == locAtProductionVertexFlag);
511 return Calc_DecayingP4(locKinFitParticle, locDontPropagateDecayingP3Flag, 1.0, locDontPropagateAtAllFlag);
519 int locCharge = locKinFitParticle->
Get_Charge();
522 TLorentzVector locP4 = locKinFitParticle->
Get_P4();
523 TVector3 locPosition = locKinFitParticle->
Get_Position();
542 TVector3 locDeltaX = locVertexSignMultiplier*(locCommonVertex - locPosition);
544 TVector3 locH = locBField.Unit();
545 double locA = -0.00299792458*(double(locCharge))*locBField.Mag();
550 TLorentzVector locP4Sum;
552 locP4Sum += locStateSignMultiplier*locP4;
555 cout <<
"PID, sign, pxyzE = " << locKinFitParticle->
Get_PID() <<
", " << locStateSignMultiplier <<
", " << locP4.Px() <<
", " << locP4.Py() <<
", " << locP4.Pz() <<
", " << locP4.E() << endl;
557 if(!locDontPropagateAtAllFlag && (locKinFitParticleType !=
d_MissingParticle) && (locKinFitParticleType !=
d_TargetParticle) && locCommonVertexFitFlag && locChargedBFieldFlag && ((locKinFitParticleType !=
d_DecayingParticle) || !locDontPropagateDecayingP3Flag))
563 TVector3 locDeltaXCrossH = locDeltaX.Cross(locH);
565 cout <<
"propagate pxyz by: " << -1.0*locStateSignMultiplier*locA*locDeltaXCrossH.X() <<
", " << -1.0*locStateSignMultiplier*locA*locDeltaXCrossH.Y() <<
", " << -1.0*locStateSignMultiplier*locA*locDeltaXCrossH.Z() << endl;
567 locP4Sum.SetVect(locP4Sum.Vect() - locStateSignMultiplier*locA*locDeltaXCrossH);
574 cout <<
"DKinFitter: Calc_DecayingP4() Decaying Particle; PID = " << locKinFitParticle->
Get_PID() << endl;
579 for(
auto& locParticle : locFromInitialState)
582 cout <<
"decaying, partially replace with init-state PID = " << locParticle->Get_PID() << endl;
584 locP4Sum +=
Calc_DecayingP4(locParticle.get(),
false, locNextStateSignMultiplier, locDontPropagateAtAllFlag);
589 for(
auto& locParticle : locFromFinalState)
592 cout <<
"decaying, partially replace with final-state PID = " << locParticle->Get_PID() << endl;
596 locP4Sum +=
Calc_DecayingP4(locParticle.get(),
false, locNextStateSignMultiplier, locDontPropagateAtAllFlag);
634 if(locFitCovMatrix != NULL)
635 locCovarianceMatrix->SetSub(0, *locFitCovMatrix);
637 locCovarianceMatrix->Zero();
641 int locCharge = locKinFitParticle->
Get_Charge();
644 TLorentzVector locP4 = locKinFitParticle->
Get_P4();
645 TVector3 locPosition = locKinFitParticle->
Get_Position();
646 TVector3 locDeltaX = locCommonVertex - locPosition;
648 TVector3 locH = locBField.Unit();
649 double locA = -0.00299792458*(double(locCharge))*locBField.Mag();
663 locSpacetimeVertex.SetVect(locCommonVertex);
666 double locCommonTime = 0.0;
671 double locDeltaXDotH = locDeltaX.Dot(locH);
672 double locPDotH = locP4.Vect().Dot(locH);
673 locCommonTime = locKinFitParticle->
Get_Time() + locDeltaXDotH*locP4.E()/(29.9792458*locPDotH);
675 else if(!locNeutralShowerFlag)
677 double locDeltaXDotP = locDeltaX.Dot(locP4.Vect());
678 locCommonTime = locKinFitParticle->
Get_Time() + locDeltaXDotP*locP4.E()/(29.9792458*locP4.Vect().Mag2());
681 locCommonTime = locKinFitParticle->
Get_Time() - locDeltaX.Mag()*locP4.E()/(29.9792458*locP4.P());
682 locSpacetimeVertex.SetT(locCommonTime);
686 locMomentum = locP4.Vect() - locDeltaX.Cross(locA*locH);
688 locMomentum = locP4.Vect();
692 return Calc_PathLength(locKinFitParticle, locVXi,
nullptr, locPathLengthPair, locRestFrameLifetimePair);
695 int locCommonVxParamIndex_TempMatrix = 7, locCommonTParamIndex_TempMatrix = 10;
701 locCommonVxParamIndex_TempMatrix = locCovarianceMatrix->GetNcols();
702 locCovarianceMatrix->ResizeTo(locCommonVxParamIndex_TempMatrix + 3, locCommonVxParamIndex_TempMatrix + 3);
703 for(
size_t loc_i = 0; loc_i < 3; ++loc_i)
705 for(
size_t loc_j = 0; loc_j < 3; ++loc_j)
706 (*locCovarianceMatrix)(loc_i + locCommonVxParamIndex_TempMatrix, loc_j + locCommonVxParamIndex_TempMatrix) = (*locVXi)(locCommonVxParamIndex + loc_i, locCommonVxParamIndex + loc_j);
713 locCommonTParamIndex_TempMatrix = locCovarianceMatrix->GetNcols();
716 locCovarianceMatrix->ResizeTo(locCovarianceMatrix->GetNcols() + 1, locCovarianceMatrix->GetNcols() + 1);
717 (*locCovarianceMatrix)(locCommonTParamIndex_TempMatrix, locCommonTParamIndex_TempMatrix) = (*locVXi)(locCommonTParamIndex, locCommonTParamIndex);
718 for(
size_t loc_i = 0; loc_i < 3; ++loc_i)
720 (*locCovarianceMatrix)(locCommonTParamIndex_TempMatrix, locCommonVxParamIndex_TempMatrix + loc_i) = (*locVXi)(locCommonTParamIndex, locCommonVxParamIndex + loc_i);
721 (*locCovarianceMatrix)(locCommonVxParamIndex_TempMatrix + loc_i, locCommonTParamIndex_TempMatrix) = (*locVXi)(locCommonVxParamIndex + loc_i, locCommonTParamIndex);
726 double locDeltaXDotH = locDeltaX.Dot(locH);
727 double locPDotH = locP4.Vect().Dot(locH);
729 TMatrixD locTransformationMatrix_CommonTime(locCovarianceMatrix->GetNcols() + 1, locCovarianceMatrix->GetNcols());
730 for(
unsigned int loc_i = 0; int(loc_i) < locCovarianceMatrix->GetNcols(); ++loc_i)
731 locTransformationMatrix_CommonTime(loc_i, loc_i) = 1.0;
733 TVector3 locDCommonTimeDP3 = (locDeltaXDotH/(29.9792458*locPDotH)) * ((1.0/locP4.E())*locP4.Vect() - (locP4.E()/locPDotH)*locH);
734 TVector3 locDCommonTimeDCommonVertex = (locP4.E()/(29.9792458*locPDotH))*locH;
735 TVector3 locDCommonTimeDPosition = -1.0*locDCommonTimeDCommonVertex;
737 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixPxParamIndex) = locDCommonTimeDP3.X();
738 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixPxParamIndex + 1) = locDCommonTimeDP3.Y();
739 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixPxParamIndex + 2) = locDCommonTimeDP3.Z();
741 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixVxParamIndex) = locDCommonTimeDPosition.X();
742 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixVxParamIndex + 1) = locDCommonTimeDPosition.Y();
743 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixVxParamIndex + 2) = locDCommonTimeDPosition.Z();
745 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCommonVxParamIndex_TempMatrix) = locDCommonTimeDCommonVertex.X();
746 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCommonVxParamIndex_TempMatrix + 1) = locDCommonTimeDCommonVertex.Y();
747 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCommonVxParamIndex_TempMatrix + 2) = locDCommonTimeDCommonVertex.Z();
749 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixTParamIndex) = 1.0;
751 locCovarianceMatrix->Similarity(locTransformationMatrix_CommonTime);
753 else if(!locNeutralShowerFlag)
755 double locDeltaXDotP = locDeltaX.Dot(locP4.Vect());
757 TMatrixD locTransformationMatrix_CommonTime(locCovarianceMatrix->GetNcols() + 1, locCovarianceMatrix->GetNcols());
758 for(
unsigned int loc_i = 0; int(loc_i) < locCovarianceMatrix->GetNcols(); ++loc_i)
759 locTransformationMatrix_CommonTime(loc_i, loc_i) = 1.0;
761 TVector3 locDCommonTimeDP3 = (1.0/(29.9792458*locP4.Vect().Mag2())) * (locP4.E()*locDeltaX + locDeltaXDotP*(1.0/locP4.E() - 2.0*locP4.E()/locP4.Vect().Mag2())*locP4.Vect());
762 TVector3 locDCommonTimeDCommonVertex = (locP4.E()/(29.9792458*locP4.Vect().Mag2()))*locP4.Vect();
763 TVector3 locDCommonTimeDPosition = -1.0*locDCommonTimeDCommonVertex;
765 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixPxParamIndex) = locDCommonTimeDP3.X();
766 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixPxParamIndex + 1) = locDCommonTimeDP3.Y();
767 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixPxParamIndex + 2) = locDCommonTimeDP3.Z();
769 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixVxParamIndex) = locDCommonTimeDPosition.X();
770 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixVxParamIndex + 1) = locDCommonTimeDPosition.Y();
771 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixVxParamIndex + 2) = locDCommonTimeDPosition.Z();
773 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCommonVxParamIndex_TempMatrix) = locDCommonTimeDCommonVertex.X();
774 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCommonVxParamIndex_TempMatrix + 1) = locDCommonTimeDCommonVertex.Y();
775 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCommonVxParamIndex_TempMatrix + 2) = locDCommonTimeDCommonVertex.Z();
777 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixTParamIndex) = 1.0;
779 locCovarianceMatrix->Similarity(locTransformationMatrix_CommonTime);
783 TMatrixD locTransformationMatrix_CommonTime(locCovarianceMatrix->GetNcols() + 1, locCovarianceMatrix->GetNcols());
784 for(
unsigned int loc_i = 0; int(loc_i) < locCovarianceMatrix->GetNcols(); ++loc_i)
785 locTransformationMatrix_CommonTime(loc_i, loc_i) = 1.0;
787 double locDCommonTimeDEnergy = locDeltaX.Mag()*locP4.M2()/(29.9792458*locP4.P()*locP4.Vect().Mag2());
788 TVector3 locDCommonTimeDPosition = (locP4.E()/(29.9792458*locP4.P()*locDeltaX.Mag()))*locDeltaX;
789 TVector3 locDCommonTimeDCommonVertex = -1.0*locDCommonTimeDPosition;
791 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixEParamIndex) = locDCommonTimeDEnergy;
793 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixVxParamIndex) = locDCommonTimeDPosition.X();
794 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixVxParamIndex + 1) = locDCommonTimeDPosition.Y();
795 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixVxParamIndex + 2) = locDCommonTimeDPosition.Z();
797 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCommonVxParamIndex_TempMatrix) = locDCommonTimeDCommonVertex.X();
798 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCommonVxParamIndex_TempMatrix + 1) = locDCommonTimeDCommonVertex.Y();
799 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCommonVxParamIndex_TempMatrix + 2) = locDCommonTimeDCommonVertex.Z();
801 locTransformationMatrix_CommonTime(locCommonTParamIndex_TempMatrix, locCovMatrixTParamIndex) = 1.0;
803 locCovarianceMatrix->Similarity(locTransformationMatrix_CommonTime);
810 TMatrixD locTransformationMatrix_Propagation(locMatrixSize, locCovarianceMatrix->GetNcols());
815 locTransformationMatrix_Propagation(0, locCovMatrixPxParamIndex) = 1.0;
816 locTransformationMatrix_Propagation(1, locCovMatrixPxParamIndex + 1) = 1.0;
817 locTransformationMatrix_Propagation(2, locCovMatrixPxParamIndex + 2) = 1.0;
819 locTransformationMatrix_Propagation(0, locCovMatrixVxParamIndex + 1) = -1.0*locA*locH.Z();
820 locTransformationMatrix_Propagation(0, locCovMatrixVxParamIndex + 2) = locA*locH.Y();
822 locTransformationMatrix_Propagation(1, locCovMatrixVxParamIndex) = locA*locH.Z();
823 locTransformationMatrix_Propagation(1, locCovMatrixVxParamIndex + 2) = -1.0*locA*locH.X();
825 locTransformationMatrix_Propagation(2, locCovMatrixVxParamIndex) = -1.0*locA*locH.Y();
826 locTransformationMatrix_Propagation(2, locCovMatrixVxParamIndex + 1) = locA*locH.X();
828 locTransformationMatrix_Propagation(0, locCommonVxParamIndex_TempMatrix + 1) = locA*locH.Z();
829 locTransformationMatrix_Propagation(0, locCommonVxParamIndex_TempMatrix + 2) = -1.0*locA*locH.Y();
831 locTransformationMatrix_Propagation(1, locCommonVxParamIndex_TempMatrix) = -1.0*locA*locH.Z();
832 locTransformationMatrix_Propagation(1, locCommonVxParamIndex_TempMatrix + 2) = locA*locH.X();
834 locTransformationMatrix_Propagation(2, locCommonVxParamIndex_TempMatrix) = locA*locH.Y();
835 locTransformationMatrix_Propagation(2, locCommonVxParamIndex_TempMatrix + 1) = -1.0*locA*locH.X();
839 for(
unsigned int loc_i = 0; loc_i < 3; ++loc_i)
840 locTransformationMatrix_Propagation(loc_i, locCovMatrixPxParamIndex + loc_i) = 1.0;
844 for(
unsigned int loc_i = 0; loc_i < 3; ++loc_i)
845 locTransformationMatrix_Propagation(3 + loc_i, locCommonVxParamIndex_TempMatrix + loc_i) = 1.0;
848 locTransformationMatrix_Propagation(6, locCommonTParamIndex_TempMatrix) = 1.0;
853 for(
unsigned int loc_i = 0; loc_i < 3; ++loc_i)
854 locTransformationMatrix_Propagation(7 + loc_i, locCovMatrixVxParamIndex + loc_i) = 1.0;
857 locTransformationMatrix_Propagation(10, locCovMatrixTParamIndex) = 1.0;
861 locCovarianceMatrix->Similarity(locTransformationMatrix_Propagation);
866 return Calc_PathLength(locKinFitParticle, locVXi, locCovarianceMatrix, locPathLengthPair, locRestFrameLifetimePair);
869 bool DKinFitUtils::Calc_PathLength(
const DKinFitParticle* locKinFitParticle,
const TMatrixDSym* locVXi,
const TMatrixFSym* locCovarianceMatrix, pair<double, double>& locPathLengthPair, pair<double, double>& locRestFrameLifetimePair)
const
886 int locCharge = locKinFitParticle->
Get_Charge();
888 TVector3 locMomentum = locKinFitParticle->
Get_Momentum();
889 TVector3 locPosition = locKinFitParticle->
Get_Position();
890 TVector3 locDeltaX = locCommonVertex - locPosition;
892 TVector3 locH = locBField.Unit();
895 double locPMag = locMomentum.Mag();
898 double locDeltaXDotH = locDeltaX.Dot(locH);
899 double locPDotH = locMomentum.Dot(locH);
900 locPathLengthPair.first = locDeltaXDotH*locPMag/locPDotH;
903 locPathLengthPair.first = locDeltaX.Mag();
906 auto locMass = locKinFitParticle->
Get_Mass();
907 if((locKinFitParticleType ==
d_DecayingParticle) && (locVxParamIndex >= 0) && (locCommonVxParamIndex >= 0))
917 locRestFrameLifetimePair.first = locPathLengthPair.first*locMass/(29.9792458*locPMag);
921 locRestFrameLifetimePair.first = 0.0;
922 locRestFrameLifetimePair.second = 0.0;
926 if(locCovarianceMatrix ==
nullptr)
928 locPathLengthPair.second = 0.0;
929 locRestFrameLifetimePair.second = 0.0;
935 TMatrixFSym locTempMatrix(locCovarianceMatrix->GetNcols());
936 locTempMatrix = *locCovarianceMatrix;
937 int locCommonVxParamIndex_TempMatrix = (locKinFitParticleType !=
d_DecayingParticle) ? locTempMatrix.GetNcols() : 7;
940 locTempMatrix.ResizeTo(locCommonVxParamIndex_TempMatrix + 4, locCommonVxParamIndex_TempMatrix + 4);
941 size_t locSizeToCopy = (locCommonTParamIndex >= 0) ? 4 : 3;
942 for(
size_t loc_i = 0; loc_i < locSizeToCopy; ++loc_i)
944 for(
size_t loc_j = 0; loc_j < locSizeToCopy; ++loc_j)
945 locTempMatrix(loc_i + locCommonVxParamIndex_TempMatrix, loc_j + locCommonVxParamIndex_TempMatrix) = (*locVXi)(locCommonVxParamIndex + loc_i, locCommonVxParamIndex + loc_j);
950 TMatrixD locTransformationMatrix(2, locTempMatrix.GetNcols());
953 double locDeltaXDotH = locDeltaX.Dot(locH);
954 double locPDotH = locMomentum.Dot(locH);
955 double locPMag = locMomentum.Mag();
957 TVector3 locDPathDP3 = (locDeltaXDotH/locPDotH)*((1.0/locPMag)*locMomentum - (locPMag/locPDotH)*locH);
958 TVector3 locDPathDCommon = (locPMag/locPDotH)*locH;
959 TVector3 locDPathDPosition = -1.0*locDPathDCommon;
960 double locMOverC = locMass/29.9792458;
961 TVector3 locDLifetimeDP3 = -1.0*locMOverC*(locDeltaXDotH/(locPDotH*locPDotH))*locH;
962 TVector3 locDLifetimeDCommon = (locMOverC/locPDotH)*locH;
963 TVector3 locDLifetimeDPosition = -1.0*locDLifetimeDCommon;
966 locTransformationMatrix(0, locCovMatrixPxParamIndex) = locDPathDP3.X();
967 locTransformationMatrix(0, locCovMatrixPxParamIndex + 1) = locDPathDP3.Y();
968 locTransformationMatrix(0, locCovMatrixPxParamIndex + 2) = locDPathDP3.Z();
970 locTransformationMatrix(0, locCovMatrixVxParamIndex) = locDPathDPosition.X();
971 locTransformationMatrix(0, locCovMatrixVxParamIndex + 1) = locDPathDPosition.Y();
972 locTransformationMatrix(0, locCovMatrixVxParamIndex + 2) = locDPathDPosition.Z();
974 locTransformationMatrix(0, locCommonVxParamIndex_TempMatrix) = locDPathDCommon.X();
975 locTransformationMatrix(0, locCommonVxParamIndex_TempMatrix + 1) = locDPathDCommon.Y();
976 locTransformationMatrix(0, locCommonVxParamIndex_TempMatrix + 2) = locDPathDCommon.Z();
979 locTransformationMatrix(1, locCovMatrixPxParamIndex) = locDLifetimeDP3.X();
980 locTransformationMatrix(1, locCovMatrixPxParamIndex + 1) = locDLifetimeDP3.Y();
981 locTransformationMatrix(1, locCovMatrixPxParamIndex + 2) = locDLifetimeDP3.Z();
983 locTransformationMatrix(1, locCovMatrixVxParamIndex) = locDLifetimeDPosition.X();
984 locTransformationMatrix(1, locCovMatrixVxParamIndex + 1) = locDLifetimeDPosition.Y();
985 locTransformationMatrix(1, locCovMatrixVxParamIndex + 2) = locDLifetimeDPosition.Z();
987 locTransformationMatrix(1, locCommonVxParamIndex_TempMatrix) = locDLifetimeDCommon.X();
988 locTransformationMatrix(1, locCommonVxParamIndex_TempMatrix + 1) = locDLifetimeDCommon.Y();
989 locTransformationMatrix(1, locCommonVxParamIndex_TempMatrix + 2) = locDLifetimeDCommon.Z();
993 TVector3 locDPathDCommon = locDeltaX.Unit();
994 TVector3 locDPathDPosition = -1.0*locDPathDCommon;
995 double locMOverC = locMass/29.9792458;
996 TVector3 locDLifetimeDP3 = -1.0*locMOverC*(locPathLengthPair.first/(locPMag*locPMag*locPMag))*locMomentum;
997 TVector3 locDLifetimeDCommon = (locMOverC/(locPMag*locPathLengthPair.first))*locDeltaX;
998 TVector3 locDLifetimeDPosition = -1.0*locDLifetimeDCommon;
1001 locTransformationMatrix(0, locCovMatrixVxParamIndex) = locDPathDPosition.X();
1002 locTransformationMatrix(0, locCovMatrixVxParamIndex + 1) = locDPathDPosition.Y();
1003 locTransformationMatrix(0, locCovMatrixVxParamIndex + 2) = locDPathDPosition.Z();
1005 locTransformationMatrix(0, locCommonVxParamIndex_TempMatrix) = locDPathDCommon.X();
1006 locTransformationMatrix(0, locCommonVxParamIndex_TempMatrix + 1) = locDPathDCommon.Y();
1007 locTransformationMatrix(0, locCommonVxParamIndex_TempMatrix + 2) = locDPathDCommon.Z();
1010 locTransformationMatrix(1, locCovMatrixPxParamIndex) = locDLifetimeDP3.X();
1011 locTransformationMatrix(1, locCovMatrixPxParamIndex + 1) = locDLifetimeDP3.Y();
1012 locTransformationMatrix(1, locCovMatrixPxParamIndex + 2) = locDLifetimeDP3.Z();
1014 locTransformationMatrix(1, locCovMatrixVxParamIndex) = locDLifetimeDPosition.X();
1015 locTransformationMatrix(1, locCovMatrixVxParamIndex + 1) = locDLifetimeDPosition.Y();
1016 locTransformationMatrix(1, locCovMatrixVxParamIndex + 2) = locDLifetimeDPosition.Z();
1018 locTransformationMatrix(1, locCommonVxParamIndex_TempMatrix) = locDLifetimeDCommon.X();
1019 locTransformationMatrix(1, locCommonVxParamIndex_TempMatrix + 1) = locDLifetimeDCommon.Y();
1020 locTransformationMatrix(1, locCommonVxParamIndex_TempMatrix + 2) = locDLifetimeDCommon.Z();
1025 cout <<
"Calc_PathLength: Combined matrix: " << endl;
1027 cout <<
"Calc_PathLength: Transform matrix: " << endl;
1031 locTempMatrix.Similarity(locTransformationMatrix);
1034 cout <<
"path/life matrix: " << endl;
1038 locPathLengthPair.second =
sqrt(locTempMatrix(0, 0));
1039 locRestFrameLifetimePair.second =
sqrt(locTempMatrix(1, 1));
1042 cout <<
"calced path, sigma = " << locPathLengthPair.first <<
", " << locPathLengthPair.second << endl;
1043 cout <<
"calced lifetime, sigma = " << locRestFrameLifetimePair.first <<
", " << locRestFrameLifetimePair.second << endl;
1058 int locCharge = locKinFitParticle->
Get_Charge();
1059 TLorentzVector locP4 = locKinFitParticle->
Get_P4();
1060 TVector3 locPosition = locKinFitParticle->
Get_Position();
1064 cout <<
"jacobian: decay product: PID = " << locKinFitParticle->
Get_PID() << endl;
1081 TVector3 locDeltaX = locVertexSignMultiplier*(locCommonVertex - locPosition);
1083 TVector3 locH = locBField.Unit();
1084 double locA = -0.00299792458*(double(locCharge))*locBField.Mag();
1093 locPxParamIndex += locNumEta;
1096 locVxParamIndex += locNumEta;
1097 if(locPxParamIndex < 0)
1100 auto locPxParamIterator = locAdditionalPxParamIndices.find(locKinFitParticle);
1101 if(locPxParamIterator != locAdditionalPxParamIndices.end())
1102 locPxParamIndex = locPxParamIterator->second;
1108 else if(locChargedBFieldFlag && locCommonVertexFitFlag && (locKinFitParticleType !=
d_DecayingParticle))
1111 cout <<
"jacobian: partials part 1" << endl;
1113 locJacobian(0, locPxParamIndex) = 1.0;
1114 locJacobian(1, locPxParamIndex + 1) = 1.0;
1115 locJacobian(2, locPxParamIndex + 2) = 1.0;
1117 locJacobian(0, locVxParamIndex + 1) = locA*locH.Z();
1118 locJacobian(0, locVxParamIndex + 2) = -1.0*locA*locH.Y();
1120 locJacobian(1, locVxParamIndex) = -1.0*locA*locH.Z();
1121 locJacobian(1, locVxParamIndex + 2) = locA*locH.X();
1123 locJacobian(2, locVxParamIndex) = locA*locH.Y();
1124 locJacobian(2, locVxParamIndex + 1) = -1.0*locA*locH.X();
1126 locJacobian(0, locCommonVxParamIndex + 1) -= locJacobian(0, locVxParamIndex + 1);
1127 locJacobian(0, locCommonVxParamIndex + 2) -= locJacobian(0, locVxParamIndex + 2);
1129 locJacobian(1, locCommonVxParamIndex) -= locJacobian(1, locVxParamIndex);
1130 locJacobian(1, locCommonVxParamIndex + 2) -= locJacobian(1, locVxParamIndex + 2);
1132 locJacobian(2, locCommonVxParamIndex) -= locJacobian(2, locVxParamIndex);
1133 locJacobian(2, locCommonVxParamIndex + 1) -= locJacobian(2, locVxParamIndex + 1);
1135 else if(locNeutralShowerFlag)
1138 cout <<
"jacobian: partials part 2" << endl;
1140 double locEOverPSq = locP4.E()/locP4.Vect().Mag2();
1141 locJacobian(0, locEParamIndex) = locEOverPSq*locP4.Px();
1142 locJacobian(1, locEParamIndex) = locEOverPSq*locP4.Py();
1143 locJacobian(2, locEParamIndex) = locEOverPSq*locP4.Pz();
1145 TVector3 locDeltaXOverMagDeltaXSq = locDeltaX*(1.0/locDeltaX.Mag2());
1147 locJacobian(0, locVxParamIndex) = locP4.Px()*(locDeltaXOverMagDeltaXSq.X() - 1.0/locDeltaX.X());
1148 locJacobian(1, locVxParamIndex + 1) = locP4.Py()*(locDeltaXOverMagDeltaXSq.Y() - 1.0/locDeltaX.Y());
1149 locJacobian(2, locVxParamIndex + 2) = locP4.Pz()*(locDeltaXOverMagDeltaXSq.Z() - 1.0/locDeltaX.Z());
1151 locJacobian(0, locVxParamIndex + 1) = locP4.Px()*locDeltaXOverMagDeltaXSq.Y();
1152 locJacobian(0, locVxParamIndex + 2) = locP4.Px()*locDeltaXOverMagDeltaXSq.Z();
1154 locJacobian(1, locVxParamIndex) = locP4.Py()*locDeltaXOverMagDeltaXSq.X();
1155 locJacobian(1, locVxParamIndex + 2) = locP4.Py()*locDeltaXOverMagDeltaXSq.Z();
1157 locJacobian(2, locVxParamIndex) = locP4.Pz()*locDeltaXOverMagDeltaXSq.X();
1158 locJacobian(2, locVxParamIndex + 1) = locP4.Pz()*locDeltaXOverMagDeltaXSq.Y();
1160 locJacobian(0, locCommonVxParamIndex) -= locJacobian(0, locVxParamIndex);
1161 locJacobian(1, locCommonVxParamIndex + 1) -= locJacobian(1, locVxParamIndex + 1);
1162 locJacobian(2, locCommonVxParamIndex + 2) -= locJacobian(2, locVxParamIndex + 2);
1164 locJacobian(0, locCommonVxParamIndex + 1) -= locJacobian(0, locVxParamIndex + 1);
1165 locJacobian(0, locCommonVxParamIndex + 2) -= locJacobian(0, locVxParamIndex + 2);
1167 locJacobian(1, locCommonVxParamIndex) -= locJacobian(1, locVxParamIndex);
1168 locJacobian(1, locCommonVxParamIndex + 2) -= locJacobian(1, locVxParamIndex + 2);
1170 locJacobian(2, locCommonVxParamIndex) -= locJacobian(2, locVxParamIndex);
1171 locJacobian(2, locCommonVxParamIndex + 1) -= locJacobian(2, locVxParamIndex + 1);
1176 cout <<
"jacobian: partials part 3" << endl;
1179 locJacobian(0, locPxParamIndex) = 1.0;
1180 locJacobian(1, locPxParamIndex + 1) = 1.0;
1181 locJacobian(2, locPxParamIndex + 2) = 1.0;
1186 cout <<
"jacobian: partials part 4" << endl;
1192 cout <<
"jacobian: partials part 4a" << endl;
1195 locJacobian(0, locVxParamIndex + 1) += locA*locH.Z();
1196 locJacobian(0, locVxParamIndex + 2) += -1.0*locA*locH.Y();
1198 locJacobian(1, locVxParamIndex) += -1.0*locA*locH.Z();
1199 locJacobian(1, locVxParamIndex + 2) += locA*locH.X();
1201 locJacobian(2, locVxParamIndex) += locA*locH.Y();
1202 locJacobian(2, locVxParamIndex + 1) += -1.0*locA*locH.X();
1204 locJacobian(0, locCommonVxParamIndex + 1) -= locJacobian(0, locVxParamIndex + 1);
1205 locJacobian(0, locCommonVxParamIndex + 2) -= locJacobian(0, locVxParamIndex + 2);
1207 locJacobian(1, locCommonVxParamIndex) -= locJacobian(1, locVxParamIndex);
1208 locJacobian(1, locCommonVxParamIndex + 2) -= locJacobian(1, locVxParamIndex + 2);
1210 locJacobian(2, locCommonVxParamIndex) -= locJacobian(2, locVxParamIndex);
1211 locJacobian(2, locCommonVxParamIndex + 1) -= locJacobian(2, locVxParamIndex + 1);
1217 for(
auto& locParticle : locFromInitialState)
1220 cout <<
"decaying, partially replace with init-state PID = " << locParticle->Get_PID() << endl;
1227 for(
auto& locParticle : locFromFinalState)
1230 cout <<
"decaying, partially replace with final-state PID = " << locParticle->Get_PID() << endl;
1240 cout <<
"jacobian: partials part 5" << endl;
1243 locJacobian(0, locPxParamIndex) = 1.0;
1244 locJacobian(1, locPxParamIndex + 1) = 1.0;
1245 locJacobian(2, locPxParamIndex + 2) = 1.0;
1253 cout <<
"DKinFitUtils::Build_OutputKinFitChain(): Printing input chain." << endl;
1254 locInputKinFitChain->Print_InfoToScreen();
1258 map<shared_ptr<DKinFitParticle>, shared_ptr<DKinFitParticle>> locInputToOutputParticleMap;
1259 for(
auto& locParticle : locKinFitOutputParticles)
1263 locOutputKinFitChain->Set_DefinedParticleStepIndex(locInputKinFitChain->Get_DefinedParticleStepIndex());
1264 locOutputKinFitChain->Set_IsInclusiveChannelFlag(locInputKinFitChain->Get_IsInclusiveChannelFlag());
1267 for(
size_t loc_i = 0; loc_i < locInputKinFitChain->Get_NumKinFitChainSteps(); ++loc_i)
1269 auto locInputKinFitChainStep = locInputKinFitChain->Get_KinFitChainStep(loc_i);
1272 locOutputKinFitChainStep->Set_InitialParticleDecayFromStepIndex(locInputKinFitChainStep->Get_InitialParticleDecayFromStepIndex());
1273 locOutputKinFitChainStep->Set_ConstrainDecayingMassFlag(locInputKinFitChainStep->Get_ConstrainDecayingMassFlag());
1275 auto locInitialParticles = locInputKinFitChainStep->Get_InitialParticles();
1276 for(
auto locKinFitParticle : locInitialParticles)
1278 if(locKinFitParticle ==
nullptr)
1280 auto locMapIterator = locInputToOutputParticleMap.find(locKinFitParticle);
1281 if(locMapIterator != locInputToOutputParticleMap.end())
1282 locKinFitParticle = locMapIterator->second;
1283 locOutputKinFitChainStep->Add_InitialParticle(locKinFitParticle);
1285 locOutputKinFitChain->Set_DecayStepIndex(locKinFitParticle, loc_i);
1288 auto locFinalParticles = locInputKinFitChainStep->Get_FinalParticles();
1289 for(
auto locKinFitParticle : locFinalParticles)
1291 if(locKinFitParticle ==
nullptr)
1293 auto locMapIterator = locInputToOutputParticleMap.find(locKinFitParticle);
1294 if(locMapIterator != locInputToOutputParticleMap.end())
1295 locKinFitParticle = locMapIterator->second;
1296 locOutputKinFitChainStep->Add_FinalParticle(locKinFitParticle);
1299 locOutputKinFitChain->Add_KinFitChainStep(locOutputKinFitChainStep);
1304 cout <<
"DKinFitUtils::Build_OutputKinFitChain(): Printing output chain." << endl;
1305 locOutputKinFitChain->Print_InfoToScreen();
1308 return locOutputKinFitChain;
1313 for(
int loc_i = 0; loc_i < locMatrix.GetNrows(); ++loc_i)
1315 for(
int loc_j = 0; loc_j < locMatrix.GetNcols(); ++loc_j)
1316 cout << locMatrix(loc_i, loc_j) <<
", ";
1323 for(
int loc_i = 0; loc_i < locMatrix.GetNrows(); ++loc_i)
1325 for(
int loc_j = 0; loc_j < locMatrix.GetNcols(); ++loc_j)
1326 cout << locMatrix(loc_i, loc_j) <<
", ";
shared_ptr< DKinFitConstraint_Vertex > Clone_KinFitConstraint_Vertex(const DKinFitConstraint_Vertex *locConstraint)
bool Get_FitCommonVertexFlag(void) const
char Get_Charge(void) const
shared_ptr< DKinFitConstraint_Vertex > Make_VertexConstraint(const set< shared_ptr< DKinFitParticle >> &locFullConstrainParticles, const set< shared_ptr< DKinFitParticle >> &locNoConstrainParticles, TVector3 locVertexGuess=TVector3())
int Get_CovMatrixVxParamIndex(void) const
char Get_CommonVxParamIndex(void) const
shared_ptr< DKinFitConstraint_Mass > Clone_KinFitConstraint_Mass(const DKinFitConstraint_Mass *locConstraint)
set< shared_ptr< DKinFitParticle > > Get_FromInitialState(void) const
shared_ptr< DKinFitParticle > Make_BeamParticle(int locPID, int locCharge, double locMass, TLorentzVector locSpacetimeVertex, TVector3 locMomentum, const shared_ptr< const TMatrixFSym > &locCovarianceMatrix)
map< DSpacetimeParticles, shared_ptr< DKinFitConstraint_Spacetime > > dSpacetimeConstraintMap
int Get_CovMatrixEParamIndex(void) const
shared_ptr< DKinFitParticle > Make_DetectedParticle(int locPID, int locCharge, double locMass, TLorentzVector locSpacetimeVertex, TVector3 locMomentum, double locPathLength, const shared_ptr< const TMatrixFSym > &locCovarianceMatrix)
double Get_Mass(void) const
shared_ptr< DResourcePool< DKinFitConstraint_Spacetime > > dResourcePool_SpacetimeConstraint
int Get_CovMatrixTParamIndex(void) const
TLorentzVector Calc_DecayingP4_ByP3Derived(const DKinFitParticle *locKinFitParticle, bool locAtP3DerivedFlag, bool locDontPropagateAtAllFlag=false) const
shared_ptr< DKinFitParticle > Make_DetectedShower(int locPID, double locMass, TLorentzVector locSpacetimeVertex, double locShowerEnergy, const shared_ptr< const TMatrixFSym > &locCovarianceMatrix)
virtual bool Get_IsBFieldNearBeamline(void) const =0
bool dUpdateCovarianceMatricesFlag
shared_ptr< DKinFitConstraint_Spacetime > Clone_KinFitConstraint_Spacetime(const DKinFitConstraint_Spacetime *locConstraint)
shared_ptr< DKinFitConstraint_P4 > Clone_KinFitConstraint_P4(const DKinFitConstraint_P4 *locConstraint)
map< pair< set< shared_ptr< DKinFitParticle > >, set< shared_ptr< DKinFitParticle > > >, shared_ptr< DKinFitConstraint_P4 > > dP4ConstraintMap
shared_ptr< DKinFitParticle > Make_MissingParticle(int locPID, int locCharge, double locMass)
shared_ptr< DResourcePool< DKinFitConstraint_P4 > > dResourcePool_P4Constraint
virtual TVector3 Get_BField(const TVector3 &locPosition) const =0
set< shared_ptr< DKinFitParticle > > Get_FromFinalState(void) const
virtual void Reset_NewEvent(void)
shared_ptr< DResourcePool< DKinFitChain > > dResourcePool_KinFitChain
char Get_PxParamIndex(void) const
map< shared_ptr< DKinFitParticle >, shared_ptr< DKinFitConstraint_Mass > > dMassConstraintMap
shared_ptr< DKinFitParticle > Make_TargetParticle(int locPID, int locCharge, double locMass)
void Calc_DecayingParticleJacobian(const DKinFitParticle *locKinFitParticle, bool locDontPropagateDecayingP3Flag, double locStateSignMultiplier, int locNumEta, const map< const DKinFitParticle *, int > &locAdditionalPxParamIndices, TMatrixD &locJacobian) const
shared_ptr< DKinFitConstraint_Mass > Make_MassConstraint(const shared_ptr< DKinFitParticle > &locDecayingParticle)
shared_ptr< TMatrixFSym > Get_SymMatrixResource(unsigned int locNumMatrixRows)
set< shared_ptr< DKinFitParticle > > Build_CloneParticleSet(const set< shared_ptr< DKinFitParticle >> &locInputParticles, const map< shared_ptr< DKinFitParticle >, shared_ptr< DKinFitParticle >> &locCloneIOMap) const
shared_ptr< const DKinFitChain > Build_OutputKinFitChain(const shared_ptr< const DKinFitChain > &locInputKinFitChain, set< shared_ptr< DKinFitParticle >> &locKinFitOutputParticles)
void Recycle_LastFitMemory(set< shared_ptr< DKinFitConstraint >> &locKinFitConstraints)
bool Get_IsNeutralShowerFlag(void) const
virtual bool Validate_Constraints(const set< shared_ptr< DKinFitConstraint >> &locKinFitConstraints) const
bool Propagate_TrackInfoToCommonVertex(const DKinFitParticle *locKinFitParticle, const TMatrixDSym *locVXi, TVector3 &locMomentum, TLorentzVector &locSpacetimeVertex, pair< double, double > &locPathLengthPair, pair< double, double > &locRestFrameLifetimePair, TMatrixFSym *locCovarianceMatrix) const
set< shared_ptr< DKinFitConstraint > > Clone_ParticlesAndConstraints(const set< shared_ptr< DKinFitConstraint >> &locInputConstraints)
virtual void Reset_NewFit(void)
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())
shared_ptr< DKinFitConstraint_P4 > Make_P4Constraint(const set< shared_ptr< DKinFitParticle >> &locInitialParticles, const set< shared_ptr< DKinFitParticle >> &locFinalParticles)
shared_ptr< DResourcePool< DKinFitParticle > > dResourcePool_KinFitParticle
bool Get_FitCommonTimeFlag(void) const
map< shared_ptr< DKinFitParticle >, shared_ptr< DKinFitParticle > > dParticleMap_OutputToInput
char Get_EParamIndex(void) const
char Get_VxParamIndex(void) const
shared_ptr< const TMatrixFSym > Get_CovarianceMatrix(void) const
bool Calc_PathLength(const DKinFitParticle *locKinFitParticle, const TMatrixDSym *locVXi, const TMatrixFSym *locCovarianceMatrix, pair< double, double > &locPathLengthPair, pair< double, double > &locRestFrameLifetimePair) const
TLorentzVector Calc_DecayingP4(const DKinFitParticle *locKinFitParticle, bool locIsConstrainedParticle, double locStateSignMultiplier, bool locDontPropagateAtAllFlag=false) const
double Get_CommonTime(void) const
char Get_CommonTParamIndex(void) const
bool Get_IsDecayingParticleDefinedByProducts(const DKinFitParticle *locKinFitParticle) const
DKinFitParticleType Get_KinFitParticleType(void) const
map< pair< set< shared_ptr< DKinFitParticle > >, set< shared_ptr< DKinFitParticle > > >, shared_ptr< DKinFitConstraint_Vertex > > dVertexConstraintMap
TLorentzVector Calc_DecayingP4_ByVertex(const DKinFitParticle *locKinFitParticle, bool locAtProductionVertexFlag, bool locDontPropagateAtAllFlag=false) const
TVector3 Get_Position(void) const
shared_ptr< DResourcePool< TMatrixFSym > > dResourcePool_TMatrixFSym
TLorentzVector Calc_DecayingP4_ByPosition(const DKinFitParticle *locKinFitParticle, bool locAtPositionFlag, bool locDontPropagateAtAllFlag=false) const
shared_ptr< DKinFitParticle > Clone_KinFitParticle(const shared_ptr< DKinFitParticle > &locKinFitParticle)
shared_ptr< DResourcePool< DKinFitConstraint_Mass > > dResourcePool_MassConstraint
void Print_Matrix(const TMatrixD &locMatrix) const
double Get_Time(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)
TVector3 Get_CommonVertex(void) const
shared_ptr< DResourcePool< DKinFitConstraint_Vertex > > dResourcePool_VertexConstraint
int Get_CovMatrixPxParamIndex(void) const
TLorentzVector Get_P4(void) const
shared_ptr< DResourcePool< DKinFitChainStep > > dResourcePool_KinFitChainStep
shared_ptr< TMatrixFSym > Clone_SymMatrix(const TMatrixFSym *locMatrix)
TVector3 Get_Momentum(void) const
bool Get_VertexP4AtProductionVertex(void) const