12 #define SSTR( x ) dynamic_cast< std::ostringstream & >(( std::ostringstream() << std::dec << x ) ).str()
15 #include <analysis/modules/ParticleKinematicFitter/ParticleKinematicFitterModule.h>
16 #include <analysis/OrcaKinFit/BaseFitter.h>
17 #include <analysis/OrcaKinFit/BaseFitObject.h>
18 #include <analysis/OrcaKinFit/OPALFitterGSL.h>
19 #include <analysis/OrcaKinFit/JetFitObject.h>
20 #include <analysis/OrcaKinFit/NewtonFitterGSL.h>
21 #include <analysis/OrcaKinFit/NewFitterGSL.h>
22 #include <analysis/OrcaKinFit/PxPyPzMFitObject.h>
23 #include <analysis/OrcaKinFit/TextTracer.h>
25 #include <mdst/dataobjects/ECLCluster.h>
28 #include <framework/logging/Logger.h>
31 #include <analysis/dataobjects/Particle.h>
32 #include <analysis/dataobjects/ParticleList.h>
35 #include <analysis/utility/PCmsLabTransform.h>
36 #include <analysis/utility/ParticleCopy.h>
39 #include <CLHEP/Matrix/SymMatrix.h>
40 #include <CLHEP/Vector/LorentzVector.h>
42 using namespace CLHEP;
51 namespace OrcaKinFit {
68 setDescription(
"Kinematic fitter for modular analysis");
69 setPropertyFlags(c_ParallelProcessingCertified);
72 addParam(
"listName", m_listName,
"Name of particle list.",
string(
""));
73 addParam(
"kinematicFitter", m_kinematicFitter,
"Available: OrcaKinFit.",
string(
"OrcaKinFit"));
74 addParam(
"orcaFitterEngine", m_orcaFitterEngine,
"OrcaKinFit engine: NewFitterGSL, NewtonFitterGSL, OPALFitterGSL.",
75 string(
"OPALFitterGSL"));
76 addParam(
"orcaTracer", m_orcaTracer,
"OrcaKinFit tracer: None, Text.",
string(
"None"));
77 addParam(
"orcaConstraint", m_orcaConstraint,
"OrcaKinFit constraint: HardBeam, RecoilMass.",
string(
"HardBeam"));
78 addParam(
"debugFitter", m_debugFitter,
"Switch on/off internal debugging output if available.",
false);
79 addParam(
"debugFitterLevel", m_debugFitterLevel,
"Internal debugging output level if available.", 10);
80 addParam(
"addUnmeasuredPhoton", m_addUnmeasuredPhoton,
"Add one unmeasured photon (-3C).",
false);
81 addParam(
"add3CPhoton", m_add3CPhoton,
"Add one photon with unmeasured energy (-1C).",
false);
82 addParam(
"decayString", m_decayString,
"Specifies which daughter particles are included in the kinematic fit.",
string(
""));
83 addParam(
"updateMother", m_updateMother,
"Update the mother kinematics.",
true);
84 addParam(
"updateDaughters", m_updateDaughters,
"Update the daughter kinematics.",
false);
85 addParam(
"recoilMass", m_recoilMass,
"Recoil mass in GeV. RecoilMass constraint only.", 0.0);
86 addParam(
"invMass", m_invMass,
"Invariant mass in GeV. Mass constraint only.", 0.0);
91 void ParticleKinematicFitterModule::initialize()
93 m_eventextrainfo.registerInDataStore();
95 if (m_decayString !=
"") {
96 m_decaydescriptor.init(m_decayString);
97 B2INFO(
"ParticleKinematicFitter: Using specified decay string: " << m_decayString);
102 void ParticleKinematicFitterModule::beginRun()
104 B2INFO(
"ParticleKinematicFitterModule::beginRun");
107 void ParticleKinematicFitterModule::endRun()
109 B2INFO(
"ParticleKinematicFitterModule::endRun");
112 void ParticleKinematicFitterModule::terminate()
114 B2INFO(
"ParticleKinematicFitterModule::terminate");
118 void ParticleKinematicFitterModule::event()
120 B2DEBUG(17,
"ParticleKinematicFitterModule::event");
124 B2ERROR(
"ParticleList " << m_listName <<
" not found");
128 unsigned int n = plist->getListSize();
130 for (
unsigned i = 0; i < n; i++) {
132 Particle* particle = plist->getParticle(i);
134 if (m_updateDaughters ==
true) {
135 if (m_decayString.empty()) ParticleCopy::copyDaughters(particle);
136 else B2ERROR(
"Daughters update works only when all daughters are selected. Daughters will not be updated");
139 bool ok = doKinematicFit(particle);
141 if (!ok) particle->setPValue(-1.);
147 bool ParticleKinematicFitterModule::doKinematicFit(
Particle* mother)
150 B2DEBUG(17,
"ParticleKinematicFitterModule::doKinematicFit");
155 if (m_kinematicFitter ==
"OrcaKinFit") {
158 if (m_decayString !=
"") {
159 B2FATAL(
"ParticleKinematicFitterModule: OrcaKinFit does not support yet selection of daughters via decay string!") ;
163 if (!(m_orcaFitterEngine ==
"OPALFitterGSL" or
164 m_orcaFitterEngine ==
"NewtonFitterGSL" or
165 m_orcaFitterEngine ==
"NewFitterGSL")) {
166 B2FATAL(
"ParticleKinematicFitterModule: " << m_orcaFitterEngine <<
" is an invalid OrcaKinFit fitter engine!");
170 if (!(m_orcaConstraint ==
"HardBeam" or
171 m_orcaConstraint ==
"RecoilMass" or
172 m_orcaConstraint ==
"Mass")) {
173 B2FATAL(
"ParticleKinematicFitterModule: " << m_orcaConstraint <<
" is an invalid OrcaKinFit constraint!");
177 ok = doOrcaKinFitFit(mother);
182 B2FATAL(
"ParticleKinematicFitter: " << m_kinematicFitter <<
" is an invalid kinematic fitter!");
185 if (!ok)
return false;
192 bool ParticleKinematicFitterModule::doOrcaKinFitFit(
Particle* mother)
194 if (mother->getNDaughters() <= 1) {
195 B2WARNING(
"ParticleKinematicFitterModule: Cannot fit with " << mother->getNDaughters() <<
" daughters.");
200 std::vector<Particle*> particleChildren;
201 bool validChildren = fillFitParticles(mother, particleChildren);
203 if (!validChildren) {
204 B2WARNING(
"ParticleKinematicFitterModule: Cannot find valid children for the fit.");
213 if (m_debugFitter) debugfitter = m_debugFitterLevel;
216 if (m_orcaFitterEngine ==
"OPALFitterGSL") {
218 }
else if (m_orcaFitterEngine ==
"NewtonFitterGSL") {
221 }
else if (m_orcaFitterEngine ==
"NewFitterGSL") {
223 (
dynamic_cast<NewFitterGSL*
>(pfitter))->setDebug(debugfitter);
225 B2FATAL(
"ParticleKinematicFitterModule: " << m_orcaFitterEngine <<
" is an invalid OrcaKinFit fitter engine!");
229 if (!pfitter)
return false;
239 for (
unsigned iChild = 0; iChild < particleChildren.size(); iChild++) {
240 addParticleToOrcaKinFit(fitter, particleChildren[iChild], iChild);
244 if (m_addUnmeasuredPhoton) addUnmeasuredGammaToOrcaKinFit(fitter);
247 addConstraintsToFitter(fitter);
250 addTracerToFitter(fitter);
253 storeOrcaKinFitParticles(
"Measured", fitter, particleChildren, mother);
255 double prob = fitter.fit();
256 double chi2 = fitter.getChi2();
257 int niter = fitter.getIterations();
258 int ndof = fitter.getDoF();
259 int errorcode = fitter.getError();
262 B2DEBUG(17,
"ParticleKinematicFitterModule: -------------------------------------------");
263 B2DEBUG(17,
"ParticleKinematicFitterModule: Fit result of OrcaKinFit using " << m_orcaFitterEngine);
264 B2DEBUG(17,
"ParticleKinematicFitterModule: prob " << prob);
265 B2DEBUG(17,
"ParticleKinematicFitterModule: chi2 " << chi2);
266 B2DEBUG(17,
"ParticleKinematicFitterModule: iterations " << niter);
267 B2DEBUG(17,
"ParticleKinematicFitterModule: ndf " << ndof);
268 B2DEBUG(17,
"ParticleKinematicFitterModule: errorcode " << errorcode);
269 B2DEBUG(17,
"ParticleKinematicFitterModule: -------------------------------------------");
272 if (m_updateMother) updateOrcaKinFitMother(fitter, particleChildren, mother);
275 if (m_updateDaughters) updateOrcaKinFitDaughters(fitter, mother);
278 storeOrcaKinFitParticles(
"Fitted", fitter, particleChildren, mother);
281 mother->addExtraInfo(
"OrcaKinFitProb", prob);
282 mother->addExtraInfo(
"OrcaKinFitChi2", chi2);
283 mother->addExtraInfo(
"OrcaKinFitErrorCode", errorcode);
286 if (m_addUnmeasuredPhoton) {
287 std::vector <BaseFitObject*>* fitObjectContainer = fitter.getFitObjects();
288 for (
auto fo : *fitObjectContainer) {
289 const std::string name = fo->getName();
290 if (name ==
"unmeasured") {
292 TLorentzVector tlv = getTLorentzVector(fitobject);
293 mother->addExtraInfo(
"OrcaKinFitUnmeasuredTheta", tlv.Theta());
294 mother->addExtraInfo(
"OrcaKinFitUnmeasuredPhi", tlv.Phi());
295 mother->addExtraInfo(
"OrcaKinFitUnmeasuredE", tlv.E());
299 mother->addExtraInfo(
"OrcaKinFitUnmeasuredErrorTheta", getFitObjectError(fitobject, 1));
300 mother->addExtraInfo(
"OrcaKinFitUnmeasuredErrorPhi", getFitObjectError(fitobject, 2));
301 mother->addExtraInfo(
"OrcaKinFitUnmeasuredErrorE", getFitObjectError(fitobject, 0));
311 bool ParticleKinematicFitterModule::fillFitParticles(
Particle* mother, std::vector<Particle*>& particleChildren)
313 for (
unsigned ichild = 0; ichild < mother->getNDaughters(); ichild++) {
314 auto* child =
const_cast<Particle*
>(mother->getDaughter(ichild));
316 if (child->getNDaughters() > 0) {
317 bool err = fillFitParticles(child, particleChildren);
319 B2WARNING(
"ParticleKinematicFitterModule: Cannot find valid children for the fit.");
322 }
else if (child->getPValue() > 0) {
323 particleChildren.push_back(child);
325 B2ERROR(
"Daughter with PDG code " << child->getPDGCode() <<
" does not have a valid p-value: p=" << child->getPValue() <<
", E=" <<
326 child->getEnergy() <<
" GeV");
333 bool ParticleKinematicFitterModule::AddFour(
Particle* mother)
335 TMatrixFSym MomentumVertexErrorMatrix(7);
336 for (
unsigned ichild = 0; ichild < mother->getNDaughters(); ichild++) {
337 auto* child =
const_cast<Particle*
>(mother->getDaughter(ichild));
339 if (child->getPValue() > 0) {
340 MomentumVertexErrorMatrix += child->getMomentumVertexErrorMatrix();
341 }
else if (child->getNDaughters() > 0) {
343 MomentumVertexErrorMatrix += child->getMomentumVertexErrorMatrix();
345 B2ERROR(
"Daughter with PDG code " << child->getPDGCode() <<
" does not have a valid p-value: p=" << child->getPValue() <<
", E=" <<
346 child->getEnergy() <<
" GeV");
350 mother->setMomentumVertexErrorMatrix(MomentumVertexErrorMatrix);
355 void ParticleKinematicFitterModule::addParticleToOrcaKinFit(
BaseFitter& fitter,
Particle* particle,
const int index)
357 B2DEBUG(17,
"ParticleKinematicFitterModule: adding a particle to the fitter!");
359 if (m_add3CPhoton && index == 0) {
360 if (particle -> getPDGCode() != 22) {
361 B2ERROR(
"In 3C Kinematic fit, the first daughter should be the Unmeasured Photon!");
364 double startingE = particle -> getECLCluster() -> getEnergy(particle -> getECLClusterEHypothesisBit());
365 double startingPhi = particle -> getECLCluster() -> getPhi();
366 double startingTheta = particle -> getECLCluster() -> getTheta();
368 double startingeE = particle->getECLCluster() -> getUncertaintyEnergy();
369 double startingePhi = particle->getECLCluster() -> getUncertaintyPhi();
370 double startingeTheta = particle->getECLCluster() -> getUncertaintyTheta();
372 B2DEBUG(17, startingPhi <<
" " << startingTheta <<
" " << startingePhi <<
" " << startingeTheta);
375 pfitobject =
new JetFitObject(startingE, startingTheta, startingPhi, startingeE, startingeTheta, startingePhi, 0.);
376 pfitobject->setParam(0, startingE,
false,
false);
377 pfitobject->setParam(1, startingTheta,
true,
false);
378 pfitobject->setParam(2, startingPhi,
true,
false);
380 std::string fitObjectName =
"unmeasured";
381 pfitobject->setName(fitObjectName.c_str());
385 addFitObjectToConstraints(fitobject);
388 fitter.addFitObject(fitobject);
392 CLHEP::HepLorentzVector clheplorentzvector = getCLHEPLorentzVector(particle);
395 CLHEP::HepSymMatrix clhepmomentumerrormatrix = getCLHEPMomentumErrorMatrix(particle);
399 pfitobject =
new PxPyPzMFitObject(clheplorentzvector, clhepmomentumerrormatrix);
400 std::string fitObjectName =
"particle_" + SSTR(index);
401 pfitobject->setName(fitObjectName.c_str());
405 addFitObjectToConstraints(fitobject);
408 fitter.addFitObject(fitobject);
416 CLHEP::HepSymMatrix ParticleKinematicFitterModule::getCLHEPMomentumErrorMatrix(
Particle* particle)
418 CLHEP::HepSymMatrix covMatrix(4);
419 TMatrixFSym errMatrix = particle->getMomentumErrorMatrix();
421 for (
int i = 0; i < 4; i++) {
422 for (
int j = 0; j < 4; j++) {
423 covMatrix[i][j] = errMatrix[i][j];
431 CLHEP::HepSymMatrix ParticleKinematicFitterModule::getCLHEPMomentumVertexErrorMatrix(
Particle* particle)
433 CLHEP::HepSymMatrix covMatrix(7);
434 TMatrixFSym errMatrix = particle->getMomentumVertexErrorMatrix();
436 for (
int i = 0; i < 7; i++) {
437 for (
int j = 0; j < 7; j++) {
438 covMatrix[i][j] = errMatrix[i][j];
446 CLHEP::HepLorentzVector ParticleKinematicFitterModule::getCLHEPLorentzVector(
Particle* particle)
448 CLHEP::HepLorentzVector mom(particle->getPx(), particle->getPy(), particle->getPz(), particle->getEnergy());
455 TLorentzVector mom(fitobject->
getPx(), fitobject->
getPy(), fitobject->
getPz(), fitobject->
getE());
461 TMatrixFSym ParticleKinematicFitterModule::getTMatrixFSymMomentumErrorMatrix()
463 TMatrixFSym errMatrix(4);
465 for (
int i = 0; i < 4; i++) {
466 for (
int j = i; j < 4; j++) {
467 errMatrix[i][j] = 0.0;
475 TMatrixFSym ParticleKinematicFitterModule::getTMatrixFSymMomentumVertexErrorMatrix()
477 TMatrixFSym errMatrix(7);
479 for (
int i = 0; i < 7; i++) {
480 for (
int j = i; j < 7; j++) {
481 errMatrix[i][j] = 0.0;
488 TLorentzVector ParticleKinematicFitterModule::getTLorentzVectorConstraints()
491 if (m_orcaConstraint ==
"HardBeam") {
492 TLorentzVector constraints4vector(m_hardConstraintPx.getValue(),
493 m_hardConstraintPy.getValue(),
494 m_hardConstraintPz.getValue(),
495 m_hardConstraintE.getValue());
496 return constraints4vector;
498 B2FATAL(
"ParticleKinematicFitterModule: " << m_orcaConstraint <<
" is an invalid OrcaKinFit constraint!");
502 return TLorentzVector(0., 0., 0., 0.);
506 void ParticleKinematicFitterModule::setConstraints()
509 if (m_orcaConstraint ==
"HardBeam") {
518 m_hardConstraintPx.resetFOList();
519 m_hardConstraintPy.resetFOList();
520 m_hardConstraintPz.resetFOList();
521 m_hardConstraintE.resetFOList();
523 m_hardConstraintPx.setName(
"Sum(p_x) [hard]");
524 m_hardConstraintPy.setName(
"Sum(p_y) [hard]");
525 m_hardConstraintPz.setName(
"Sum(p_z) [hard]");
526 m_hardConstraintE.setName(
"Sum(E) [hard]");
528 }
else if (m_orcaConstraint ==
"RecoilMass") {
532 m_hardConstraintRecoilMass =
RecoilMassConstraint(m_recoilMass, boost.Px(), boost.Py(), boost.Pz(), boost.E());
534 m_hardConstraintRecoilMass.resetFOList();
535 m_hardConstraintRecoilMass.setName(
"Recoil Mass [hard]");
537 }
else if (m_orcaConstraint ==
"Mass") {
540 m_hardConstraintMass.resetFOList();
541 m_hardConstraintMass.setName(
"Mass [hard]");
543 B2FATAL(
"ParticleKinematicFitterModule: " << m_orcaConstraint <<
" is an invalid OrcaKinFit constraint!");
548 void ParticleKinematicFitterModule::resetFitter(
BaseFitter& fitter)
550 B2DEBUG(17,
"ParticleKinematicFitterModule: Resetting the fitter");
558 if (m_orcaConstraint ==
"HardBeam") {
559 m_hardConstraintPx.addToFOList(fitobject);
560 m_hardConstraintPy.addToFOList(fitobject);
561 m_hardConstraintPz.addToFOList(fitobject);
562 m_hardConstraintE.addToFOList(fitobject);
563 }
else if (m_orcaConstraint ==
"RecoilMass") {
564 m_hardConstraintRecoilMass.addToFOList(fitobject);
565 }
else if (m_orcaConstraint ==
"Mass") {
566 m_hardConstraintMass.addToFOList(fitobject);
568 B2FATAL(
"ParticleKinematicFitterModule: " << m_orcaConstraint <<
" is an invalid OrcaKinFit constraint!");
574 void ParticleKinematicFitterModule::addConstraintsToFitter(
BaseFitter& fitter)
576 if (m_orcaConstraint ==
"HardBeam") {
577 fitter.addConstraint(m_hardConstraintPx);
578 fitter.addConstraint(m_hardConstraintPy);
579 fitter.addConstraint(m_hardConstraintPz);
580 fitter.addConstraint(m_hardConstraintE);
581 }
else if (m_orcaConstraint ==
"RecoilMass") {
582 fitter.addConstraint(m_hardConstraintRecoilMass);
583 }
else if (m_orcaConstraint ==
"Mass") {
584 fitter.addConstraint(m_hardConstraintMass);
588 B2FATAL(
"ParticleKinematicFitterModule: " << m_orcaConstraint <<
" is an invalid OrcaKinFit constraint!");
593 void ParticleKinematicFitterModule::addTracerToFitter(
BaseFitter& fitter)
595 if (m_orcaTracer ==
"Text") {
597 fitter.setTracer(m_textTracer);
598 }
else if (m_orcaTracer !=
"None") {
599 B2FATAL(
"ParticleKinematicFitterModule: " << m_orcaTracer <<
" is an invalid OrcaKinFit tracer!");
603 void ParticleKinematicFitterModule::addUnmeasuredGammaToOrcaKinFit(
BaseFitter& fitter)
606 TLorentzVector tlv = getTLorentzVectorConstraints();
607 double startingE = tlv.E();
608 double startingPhi = tlv.Phi();
609 double startingTheta = tlv.Theta();
613 pfitobject =
new JetFitObject(startingE, startingTheta, startingPhi, 0.0, 0.0, 0.0, 0.);
614 pfitobject->setParam(0, startingE,
false,
false);
615 pfitobject->setParam(1, startingTheta,
false,
false);
616 pfitobject->setParam(2, startingPhi,
false,
false);
618 std::string fitObjectName =
"unmeasured";
619 pfitobject->setName(fitObjectName.c_str());
623 addFitObjectToConstraints(fitobject);
626 fitter.addFitObject(fitobject);
633 std::vector <Belle2::Particle*> bDau = mother->getDaughters();
634 std::vector <BaseFitObject*>* fitObjectContainer = fitter.getFitObjects();
636 const unsigned nd = bDau.size();
638 std::vector<std::vector<unsigned>> pars;
639 std::vector<Particle*> allparticles;
640 for (
unsigned ichild = 0; ichild < nd; ichild++) {
641 const Particle* daughter = mother->getDaughter(ichild);
642 std::vector<unsigned> pard;
643 if (daughter->getNDaughters() > 0) {
644 updateMapOfTrackAndDaughter(l, pars, pard, allparticles, daughter);
645 pars.push_back(pard);
646 allparticles.push_back(bDau[ichild]);
649 pars.push_back(pard);
650 allparticles.push_back(bDau[ichild]);
655 if (l == fitObjectContainer->size() - m_addUnmeasuredPhoton) {
657 if (fitter.getError() == 0) {
658 for (
unsigned iDaug = 0; iDaug < allparticles.size(); iDaug++) {
660 TMatrixFSym errMatrixU(7);
661 if (pars[iDaug].size() > 0) {
662 for (
unsigned int iChild : pars[iDaug]) {
663 BaseFitObject* fo = fitObjectContainer->at(iChild);
665 TLorentzVector tlv_sub = getTLorentzVector(fitobject);
666 TMatrixFSym errMatrixU_sub = getCovMat7(fitobject);
668 errMatrixU = errMatrixU + errMatrixU_sub;
671 B2FATAL(
"ParticleKinematicFitterModule: no fitObject could be used to update the daughter!");
673 TVector3 pos = allparticles[iDaug]->getVertex();
674 TMatrixFSym errMatrix = allparticles[iDaug]->getMomentumVertexErrorMatrix();
675 TMatrixFSym errMatrixMom = allparticles[iDaug]->getMomentumErrorMatrix();
676 TMatrixFSym errMatrixVer = allparticles[iDaug]->getVertexErrorMatrix();
678 for (
int i = 0; i < 3; i++) {
679 for (
int j = i; j < 3; j++) {
680 errMatrixU[i + 4][j + 4] = errMatrixVer[i][j];
684 allparticles[iDaug]->set4Vector(tlv);
685 allparticles[iDaug]->setVertex(pos);
686 allparticles[iDaug]->setMomentumVertexErrorMatrix(errMatrixU);
692 B2ERROR(
"updateOrcaKinFitDaughters: Cannot update daughters, mismatch betwen number of daughters and number of fitobjects!");
698 void ParticleKinematicFitterModule::updateMapOfTrackAndDaughter(
unsigned& l, std::vector<std::vector<unsigned>>& pars,
699 std::vector<unsigned>& parm, std::vector<Particle*>& allparticles,
const Particle* daughter)
701 std::vector <Belle2::Particle*> dDau = daughter->getDaughters();
702 for (
unsigned ichild = 0; ichild < daughter->getNDaughters(); ichild++) {
703 const Particle* child = daughter->getDaughter(ichild);
704 std::vector<unsigned> pard;
705 if (child->getNDaughters() > 0) {
706 updateMapOfTrackAndDaughter(l, pars, pard, allparticles, child);
707 parm.insert(parm.end(), pard.begin(), pard.end());
708 pars.push_back(pard);
709 allparticles.push_back(dDau[ichild]);
713 pars.push_back(pard);
714 allparticles.push_back(dDau[ichild]);
721 void ParticleKinematicFitterModule::updateOrcaKinFitMother(
BaseFitter& fitter, std::vector<Particle*>& particleChildren,
725 TVector3 pos = mother->getVertex();
726 TMatrixFSym errMatrix = mother->getMomentumVertexErrorMatrix();
727 float pvalue = mother->getPValue();
730 TLorentzVector momnew(0., 0., 0., 0.);
732 std::vector <BaseFitObject*>* fitObjectContainer = fitter.getFitObjects();
733 for (
unsigned iChild = 0; iChild < particleChildren.size(); iChild++) {
734 BaseFitObject* fo = fitObjectContainer->at(iChild);
736 TLorentzVector tlv = getTLorentzVector(fitobject);
743 mother->updateMomentum(momnew, pos, errMatrix, pvalue);
747 bool ParticleKinematicFitterModule::storeOrcaKinFitParticles(
const std::string& prefix,
BaseFitter& fitter,
748 std::vector<Particle*>& particleChildren,
Particle* mother)
750 bool updated =
false;
751 std::vector <BaseFitObject*>* fitObjectContainer = fitter.getFitObjects();
753 for (
unsigned iChild = 0; iChild < particleChildren.size(); iChild++) {
754 BaseFitObject* fo = fitObjectContainer->at(iChild);
756 TLorentzVector tlv = getTLorentzVector(fitobject);
759 std::string extraVariableParticlePx =
"OrcaKinFit" + prefix +
"_" + SSTR(iChild) +
"_Px";
760 std::string extraVariableParticlePy =
"OrcaKinFit" + prefix +
"_" + SSTR(iChild) +
"_Py";
761 std::string extraVariableParticlePz =
"OrcaKinFit" + prefix +
"_" + SSTR(iChild) +
"_Pz";
762 std::string extraVariableParticleE =
"OrcaKinFit" + prefix +
"_" + SSTR(iChild) +
"_E";
763 std::string extraVariableParticlePxErr =
"OrcaKinFit" + prefix +
"_" + SSTR(iChild) +
"_PxErr";
764 std::string extraVariableParticlePyErr =
"OrcaKinFit" + prefix +
"_" + SSTR(iChild) +
"_PyErr";
765 std::string extraVariableParticlePzErr =
"OrcaKinFit" + prefix +
"_" + SSTR(iChild) +
"_PzErr";
766 std::string extraVariableParticleEErr =
"OrcaKinFit" + prefix +
"_" + SSTR(iChild) +
"_EErr";
768 mother->addExtraInfo(extraVariableParticlePx, tlv.Px());
769 mother->addExtraInfo(extraVariableParticlePy, tlv.Py());
770 mother->addExtraInfo(extraVariableParticlePz, tlv.Pz());
771 mother->addExtraInfo(extraVariableParticleE, tlv.E());
772 mother->addExtraInfo(extraVariableParticlePxErr, getFitObjectError(fitobject, 0));
773 mother->addExtraInfo(extraVariableParticlePyErr, getFitObjectError(fitobject, 1));
774 mother->addExtraInfo(extraVariableParticlePzErr, getFitObjectError(fitobject, 2));
775 mother->addExtraInfo(extraVariableParticleEErr, -1.0);
782 float ParticleKinematicFitterModule::getFitObjectError(
ParticleFitObject* fitobject,
int ilocal)
786 if (pxpypzmfitobject) {
787 return fitobject->getError(ilocal);
789 B2FATAL(
"ParticleKinematicFitterModule: not implemented yet");
799 if (pxpypzmfitobject) {
801 TMatrixFSym errMatrix(3);
804 for (
int i = 0; i < 3; i++) {
805 for (
int j = 0; j < 3; j++) {
806 errMatrix[i][j] = pxpypzmfitobject->getCov(i, j);
812 B2FATAL(
"ParticleKinematicFitterModule: not implemented yet");
820 TMatrixFSym fitCovMatrix(3);
822 if (strcmp(fitobject->getParamName(0),
"E") == 0) {
824 auto* jetfitObject =
static_cast<JetFitObject*
>(fitobject);
827 fitCovMatrix = getFitObjectCovMat(fitobject);
828 TLorentzVector tlv = getTLorentzVector(fitobject);
830 const double energy = tlv.E();
831 const double theta = tlv.Theta();
832 const double phi = tlv.Phi();
834 const double st = sin(theta);
835 const double ct = cos(theta);
836 const double sp = sin(phi);
837 const double cp = cos(phi);
842 A(0, 1) = energy * cp * ct ;
843 A(0, 2) = -energy * sp * st ;
845 A(1, 1) = energy * sp * ct ;
846 A(1, 2) = energy * cp * st ;
848 A(2, 1) = -energy * st ;
854 TMatrixFSym D = fitCovMatrix.Similarity(A);
858 B2FATAL(
"ParticleKinematicFitterModule: not implemented yet");
863 if (pxpypzmfitobject) {
865 fitCovMatrix = getFitObjectCovMat(fitobject);
868 TLorentzVector tlv = getTLorentzVector(fitobject);
880 A[3][0] = tlv.Px() / tlv.E();
881 A[3][1] = tlv.Py() / tlv.E();
882 A[3][2] = tlv.Pz() / tlv.E();
885 TMatrixFSym D = fitCovMatrix.Similarity(A);
889 B2FATAL(
"ParticleKinematicFitterModule: not implemented yet");