9#define SSTR( x ) dynamic_cast< std::ostringstream && >(( std::ostringstream() << std::dec << x ) ).str()
12#include <analysis/modules/ParticleKinematicFitter/ParticleKinematicFitterModule.h>
13#include <analysis/OrcaKinFit/BaseFitObject.h>
14#include <analysis/OrcaKinFit/BaseFitter.h>
15#include <analysis/OrcaKinFit/OPALFitterGSL.h>
16#include <analysis/OrcaKinFit/JetFitObject.h>
17#include <analysis/OrcaKinFit/NewtonFitterGSL.h>
18#include <analysis/OrcaKinFit/NewFitterGSL.h>
19#include <analysis/OrcaKinFit/ParticleFitObject.h>
20#include <analysis/OrcaKinFit/PxPyPzMFitObject.h>
21#include <analysis/OrcaKinFit/TextTracer.h>
23#include <mdst/dataobjects/ECLCluster.h>
25#include <TDatabasePDG.h>
28#include <framework/gearbox/Const.h>
29#include <framework/logging/Logger.h>
32#include <analysis/dataobjects/Particle.h>
35#include <analysis/utility/PCmsLabTransform.h>
36#include <analysis/utility/ParticleCopy.h>
37#include <analysis/ClusterUtility/ClusterUtils.h>
44using namespace Belle2::OrcaKinFit;
66 string(
"OPALFitterGSL"));
69 addParam(
"debugFitter",
m_debugFitter,
"Switch on/off internal debugging output if available.",
false);
75 addParam(
"liftPhotonTheta",
m_liftPhotonTheta,
"Lift theta constraint of 3CPhoton. Valid when add3CPhoton is true.",
false);
76 addParam(
"decayString",
m_decayString,
"Specifies which daughter particles are included in the kinematic fit.",
string(
""));
80 addParam(
"invMass",
m_invMass,
"Invariant mass in GeV. Mass constraint only.", 0.0);
81 addParam(
"variablePrefix",
m_prefix,
"Prefix attached to extra info variables.",
string(
""));
83 "DecayString specifying the particles to use only direction information in the fit", std::string(
""));
85 "DecayString specifying the particles where an alternate mass hypothesis is used", std::string(
""));
87 "DecayString specifying the charged particle used to tag whether n or nbar. If tag particle has negative charge, PDG sign of n/nbar is flipped from default given in alternateMassHypos",
90 "integer list of pdg values for particles where different mass hypothesis is used in the fit");
100 B2INFO(
"ParticleKinematicFitter: Using specified decay string: " <<
m_decayString);
110 B2FATAL(
"decayStringForAlternateMassParticles specified but alternateMassHypos not provided.");
112 B2FATAL(
"alternateMassHypos specified but decayStringForAlternateMassParticles not provided.");
124 B2INFO(
"ParticleKinematicFitterModule::terminate");
129 B2DEBUG(17,
"ParticleKinematicFitterModule::event");
131 unsigned int n =
m_plist->getListSize();
133 for (
unsigned i = 0; i < n; i++) {
138 else B2ERROR(
"Daughters update works only when all daughters are selected. Daughters will not be updated");
143 if (!ok) particle->setPValue(-1.);
149 B2DEBUG(17,
"ParticleKinematicFitterModule::doKinematicFit");
158 B2FATAL(
"ParticleKinematicFitterModule: OrcaKinFit does not support yet selection of daughters via decay string!") ;
165 B2FATAL(
"ParticleKinematicFitterModule: " <<
m_orcaFitterEngine <<
" is an invalid OrcaKinFit fitter engine!");
172 B2FATAL(
"ParticleKinematicFitterModule: " <<
m_orcaConstraint <<
" is an invalid OrcaKinFit constraint!");
178 B2FATAL(
"ParticleKinematicFitter: " <<
m_kinematicFitter <<
" is an invalid kinematic fitter!");
181 if (!ok)
return false;
190 B2WARNING(
"ParticleKinematicFitterModule: Cannot fit with " << mother->
getNDaughters() <<
" daughters.");
195 std::vector<int> directionOnlyParticlesIdentifiers;
198 for (
unsigned int i = 0; i < selparticles.size(); i++) {
199 directionOnlyParticlesIdentifiers.push_back(selparticles[i]->getMdstSource());
204 std::vector<int> alternateMassHypoIdentifiers;
207 for (
unsigned int i = 0; i < selparticles.size(); i++) {
208 alternateMassHypoIdentifiers.push_back(selparticles[i]->getMdstSource());
211 B2FATAL(
"alternateMassHypoIdentifiers size must match listAlternateMassHypo");
218 bool flipNeutronPDGsign = 0;
221 if (selparticles.size() != 1) {
222 B2FATAL(
"Select only one particle to tag neutron vs. antineutron");
224 if (selparticles[0]->getCharge() < 0) flipNeutronPDGsign = 1;
229 std::vector<Particle*> particleChildren;
232 if (!validChildren) {
233 B2WARNING(
"ParticleKinematicFitterModule: Cannot find valid children for the fit.");
252 (
dynamic_cast<NewFitterGSL*
>(pfitter))->setDebug(debugfitter);
254 B2FATAL(
"ParticleKinematicFitterModule: " <<
m_orcaFitterEngine <<
" is an invalid OrcaKinFit fitter engine!");
258 if (!pfitter)
return false;
269 for (
unsigned iChild = 0; iChild < particleChildren.size(); iChild++) {
271 bool useDirectionOnly =
false;
272 if (directionOnlyParticlesIdentifiers.size() > 0) {
273 if (std::find(directionOnlyParticlesIdentifiers.begin(), directionOnlyParticlesIdentifiers.end(),
274 particleChildren[iChild]->getMdstSource()) != directionOnlyParticlesIdentifiers.end()) useDirectionOnly =
true;
278 if (alternateMassHypoIdentifiers.size() > 0) {
279 for (
unsigned int i = 0; i < alternateMassHypoIdentifiers.size(); i++) {
280 if (alternateMassHypoIdentifiers[i] == particleChildren[iChild]->getMdstSource()) {
287 if (useDirectionOnly ==
false)
288 B2WARNING(
"Neutron mass hypothesis assigned to fit particle but directionOnly flag not specified for same particle. Setting candidate to useDirectionOnly.");
289 useDirectionOnly =
true;
290 if (flipNeutronPDGsign) massHypo = -massHypo;
308 double prob = fitter.fit();
309 double chi2 = fitter.getChi2();
310 int niter = fitter.getIterations();
311 int ndof = fitter.getDoF();
312 int errorcode = fitter.getError();
314 B2DEBUG(17,
"ParticleKinematicFitterModule: -------------------------------------------");
315 B2DEBUG(17,
"ParticleKinematicFitterModule: Fit result of OrcaKinFit using " <<
m_orcaFitterEngine);
316 B2DEBUG(17,
"ParticleKinematicFitterModule: prob " << prob);
317 B2DEBUG(17,
"ParticleKinematicFitterModule: chi2 " << chi2);
318 B2DEBUG(17,
"ParticleKinematicFitterModule: iterations " << niter);
319 B2DEBUG(17,
"ParticleKinematicFitterModule: ndf " << ndof);
320 B2DEBUG(17,
"ParticleKinematicFitterModule: errorcode " << errorcode);
321 B2DEBUG(17,
"ParticleKinematicFitterModule: -------------------------------------------");
339 std::vector <BaseFitObject*>* fitObjectContainer = fitter.getFitObjects();
340 for (
auto fo : *fitObjectContainer) {
342 const std::string name = fo->getName();
343 if (name.find(
"Unmeasured") != std::string::npos) {
367 for (
unsigned ichild = 0; ichild < mother->
getNDaughters(); ichild++) {
370 if (child->getNDaughters() > 0) {
373 B2WARNING(
"ParticleKinematicFitterModule: Cannot find valid children for the fit.");
376 }
else if (child->getPValue() > 0) {
377 particleChildren.push_back(child);
379 B2ERROR(
"Daughter with PDG code " << child->getPDGCode() <<
" does not have a valid p-value: p=" << child->getPValue() <<
", E=" <<
380 child->getEnergy() <<
" GeV");
389 TMatrixFSym MomentumVertexErrorMatrix(7);
390 for (
unsigned ichild = 0; ichild < mother->
getNDaughters(); ichild++) {
393 if (child->getPValue() > 0) {
394 MomentumVertexErrorMatrix += child->getMomentumVertexErrorMatrix();
395 }
else if (child->getNDaughters() > 0) {
397 MomentumVertexErrorMatrix += child->getMomentumVertexErrorMatrix();
399 B2ERROR(
"Daughter with PDG code " << child->getPDGCode() <<
" does not have a valid p-value: p=" << child->getPValue() <<
", E=" <<
400 child->getEnergy() <<
" GeV");
409 bool useOnlyDirection,
int massHypoPDG)
411 B2DEBUG(17,
"ParticleKinematicFitterModule: adding a particle to the fitter!");
414 if (particle -> getPDGCode() !=
Const::photon.getPDGCode()) {
415 B2ERROR(
"In 3C Kinematic fit, the first daughter should be the Unmeasured Photon!");
418 const ECLCluster* cluster = particle->getECLCluster();
419 double startingE = cluster->getEnergy(particle->getECLClusterEHypothesisBit());
420 double startingPhi = cluster->getPhi();
421 double startingTheta = cluster->getTheta();
425 double startingEError =
sqrt(fabs(EPhiThetaCov[0][0]));
426 double startingPhiError =
sqrt(fabs(EPhiThetaCov[1][1]));
427 double startingThetaError =
sqrt(fabs(EPhiThetaCov[2][2]));
429 B2DEBUG(17, startingPhi <<
" " << startingTheta <<
" " << startingPhiError <<
" " << startingThetaError);
433 pfitobject =
new JetFitObject(startingE, startingTheta, startingPhi, startingEError, startingThetaError, startingPhiError, 0.);
434 pfitobject->
setParam(0, startingE,
false,
false);
436 pfitobject->
setParam(1, startingTheta,
false,
false);
438 pfitobject->
setParam(1, startingTheta,
true,
false);
439 pfitobject->
setParam(2, startingPhi,
true,
false);
441 std::string fitObjectName =
"Unmeasured3C";
442 pfitobject->
setName(fitObjectName.c_str());
449 fitter.addFitObject(fitobject);
451 }
else if (useOnlyDirection || massHypoPDG) {
455 const ECLCluster* cluster = particle->getECLCluster();
457 if (particle->getCharge() != 0 or !cluster) {
458 B2FATAL(
"ParticleKinematicFitterModule: Direction only and alternate mass options only implemented for neutral particles with ECL cluster");
461 double mass = particle->getPDGMass();
462 if (massHypoPDG != 0) {
463 if (TDatabasePDG::Instance()->GetParticle(massHypoPDG) ==
nullptr) {
464 B2FATAL(
"ParticleKinematicFitterModule: " << massHypoPDG <<
" is an unknown PDG code!");
466 mass = TDatabasePDG::Instance()->GetParticle(massHypoPDG)->Mass();
468 double clusterE = cluster->getEnergy(particle->getECLClusterEHypothesisBit());
469 double startingE =
sqrt(clusterE * clusterE + mass * mass);
470 double startingPhi = cluster->getPhi();
471 double startingTheta = cluster->getTheta();
475 double startingEError =
sqrt(fabs(EPhiThetaCov[0][0]));
476 double startingPhiError =
sqrt(fabs(EPhiThetaCov[1][1]));
477 double startingThetaError =
sqrt(fabs(EPhiThetaCov[2][2]));
480 pfitobject =
new JetFitObject(startingE, startingTheta, startingPhi, startingEError, startingThetaError, startingPhiError, mass);
481 pfitobject->
setParam(0, startingE,
true,
false);
482 if (useOnlyDirection) pfitobject->
setParam(0, startingE,
false,
false);
483 pfitobject->
setParam(1, startingTheta,
true,
false);
484 pfitobject->
setParam(2, startingPhi,
true,
false);
486 std::string fitObjectName =
"particle_" + SSTR(index);
487 pfitobject->
setName(fitObjectName.c_str());
494 fitter.addFitObject(fitobject);
506 pfitobject =
new PxPyPzMFitObject(clheplorentzvector, clhepmomentumerrormatrix);
507 std::string fitObjectName =
"particle_" + SSTR(index);
508 pfitobject->
setName(fitObjectName.c_str());
515 fitter.addFitObject(fitobject);
523 CLHEP::HepSymMatrix covMatrix(4);
524 TMatrixFSym errMatrix = particle->getMomentumErrorMatrix();
526 for (
int i = 0; i < 4; i++) {
527 for (
int j = 0; j < 4; j++) {
528 covMatrix[i][j] = errMatrix[i][j];
537 CLHEP::HepSymMatrix covMatrix(7);
538 TMatrixFSym errMatrix = particle->getMomentumVertexErrorMatrix();
540 for (
int i = 0; i < 7; i++) {
541 for (
int j = 0; j < 7; j++) {
542 covMatrix[i][j] = errMatrix[i][j];
551 CLHEP::HepLorentzVector mom(particle->getPx(), particle->getPy(), particle->getPz(), particle->get4Vector().E());
557 ROOT::Math::PxPyPzEVector mom(fitobject->
getPx(), fitobject->
getPy(), fitobject->
getPz(), fitobject->
getE());
564 TMatrixFSym errMatrix(4);
566 for (
int i = 0; i < 4; i++) {
567 for (
int j = i; j < 4; j++) {
568 errMatrix[i][j] = 0.0;
578 TMatrixFSym errMatrix(7);
580 for (
int i = 0; i < 7; i++) {
581 for (
int j = i; j < 7; j++) {
582 errMatrix[i][j] = 0.0;
596 return constraints4vector;
598 B2FATAL(
"ParticleKinematicFitterModule: " <<
m_orcaConstraint <<
" is an invalid OrcaKinFit constraint!");
602 return ROOT::Math::PxPyPzEVector(0., 0., 0., 0.);
641 B2FATAL(
"ParticleKinematicFitterModule: " <<
m_orcaConstraint <<
" is an invalid OrcaKinFit constraint!");
647 B2DEBUG(17,
"ParticleKinematicFitterModule: Resetting the fitter");
663 B2FATAL(
"ParticleKinematicFitterModule: " <<
m_orcaConstraint <<
" is an invalid OrcaKinFit constraint!");
681 B2FATAL(
"ParticleKinematicFitterModule: " <<
m_orcaConstraint <<
" is an invalid OrcaKinFit constraint!");
691 B2FATAL(
"ParticleKinematicFitterModule: " <<
m_orcaTracer <<
" is an invalid OrcaKinFit tracer!");
697 B2DEBUG(17,
"ParticleKinematicFitterModule::addUnmeasuredGammaToOrcaKinFit: adding an unmeasured photon to the fitter!");
700 double startingE = tlv.E();
701 double startingPhi = tlv.Phi();
702 double startingTheta = tlv.Theta();
703 bool paramFlag =
false;
708 std::string fitObjectName =
"UnmeasuredAlongBeam";
711 startingTheta = 41.5e-3;
715 startingTheta = TMath::Pi() - 41.5e-3;
719 fitObjectName =
"Unmeasured";
723 pfitobject =
new JetFitObject(startingE, startingTheta, startingPhi, 0.0, 0.0, 0.0, 0.);
724 pfitobject->
setParam(0, startingE,
false,
false);
725 pfitobject->
setParam(1, startingTheta, paramFlag, paramFlag);
726 pfitobject->
setParam(2, startingPhi, paramFlag, paramFlag);
728 pfitobject->
setName(fitObjectName.c_str());
735 fitter.addFitObject(fitobject);
741 std::vector <BaseFitObject*>* fitObjectContainer = fitter.getFitObjects();
743 const unsigned nd = bDau.size();
745 std::vector<std::vector<unsigned>> pars;
746 std::vector<Particle*> allparticles;
747 for (
unsigned ichild = 0; ichild < nd; ichild++) {
749 std::vector<unsigned> pard;
750 if (daughter->getNDaughters() > 0) {
752 pars.push_back(pard);
753 allparticles.push_back(bDau[ichild]);
756 pars.push_back(pard);
757 allparticles.push_back(bDau[ichild]);
764 if (fitter.getError() == 0) {
765 for (
unsigned iDaug = 0; iDaug < allparticles.size(); iDaug++) {
766 ROOT::Math::PxPyPzEVector tlv ;
767 TMatrixFSym errMatrixU(7);
768 if (pars[iDaug].size() > 0) {
769 for (
unsigned int iChild : pars[iDaug]) {
773 TMatrixFSym errMatrixU_sub =
getCovMat7(fitobject);
775 errMatrixU = errMatrixU + errMatrixU_sub;
778 B2FATAL(
"ParticleKinematicFitterModule: no fitObject could be used to update the daughter!");
780 ROOT::Math::XYZVector pos = allparticles[iDaug]->getVertex();
781 TMatrixFSym errMatrix = allparticles[iDaug]->getMomentumVertexErrorMatrix();
782 TMatrixFSym errMatrixMom = allparticles[iDaug]->getMomentumErrorMatrix();
783 TMatrixFSym errMatrixVer = allparticles[iDaug]->getVertexErrorMatrix();
785 for (
int i = 0; i < 3; i++) {
786 for (
int j = i; j < 3; j++) {
787 errMatrixU[i + 4][j + 4] = errMatrixVer[i][j];
791 allparticles[iDaug]->set4Vector(tlv);
792 allparticles[iDaug]->setVertex(pos);
793 allparticles[iDaug]->setMomentumVertexErrorMatrix(errMatrixU);
799 B2ERROR(
"updateOrcaKinFitDaughters: Cannot update daughters, mismatch between number of daughters and number of fitobjects!");
805 std::vector<unsigned>& parm, std::vector<Particle*>& allparticles,
const Particle* daughter)
807 std::vector <Particle*> dDau = daughter->getDaughters();
808 for (
unsigned ichild = 0; ichild < daughter->getNDaughters(); ichild++) {
809 const Particle* child = daughter->getDaughter(ichild);
810 std::vector<unsigned> pard;
811 if (child->getNDaughters() > 0) {
813 parm.insert(parm.end(), pard.begin(), pard.end());
814 pars.push_back(pard);
815 allparticles.push_back(dDau[ichild]);
819 pars.push_back(pard);
820 allparticles.push_back(dDau[ichild]);
830 ROOT::Math::XYZVector pos = mother->
getVertex();
835 ROOT::Math::PxPyPzEVector momnew(0., 0., 0., 0.);
837 std::vector <BaseFitObject*>* fitObjectContainer = fitter.getFitObjects();
838 for (
unsigned iChild = 0; iChild < particleChildren.size(); iChild++) {
852 std::vector<Particle*>& particleChildren,
Particle* mother)
854 bool updated =
false;
855 std::vector <BaseFitObject*>* fitObjectContainer = fitter.getFitObjects();
857 for (
unsigned iChild = 0; iChild < particleChildren.size(); iChild++) {
863 std::string extraVariableParticlePx =
m_prefix +
"OrcaKinFit" + fitSuffix +
"_" + SSTR(iChild) +
"_Px";
864 std::string extraVariableParticlePy =
m_prefix +
"OrcaKinFit" + fitSuffix +
"_" + SSTR(iChild) +
"_Py";
865 std::string extraVariableParticlePz =
m_prefix +
"OrcaKinFit" + fitSuffix +
"_" + SSTR(iChild) +
"_Pz";
866 std::string extraVariableParticleE =
m_prefix +
"OrcaKinFit" + fitSuffix +
"_" + SSTR(iChild) +
"_E";
867 std::string extraVariableParticlePxErr =
m_prefix +
"OrcaKinFit" + fitSuffix +
"_" + SSTR(iChild) +
"_PxErr";
868 std::string extraVariableParticlePyErr =
m_prefix +
"OrcaKinFit" + fitSuffix +
"_" + SSTR(iChild) +
"_PyErr";
869 std::string extraVariableParticlePzErr =
m_prefix +
"OrcaKinFit" + fitSuffix +
"_" + SSTR(iChild) +
"_PzErr";
870 std::string extraVariableParticleEErr =
m_prefix +
"OrcaKinFit" + fitSuffix +
"_" + SSTR(iChild) +
"_EErr";
872 mother->
addExtraInfo(extraVariableParticlePx, tlv.Px());
873 mother->
addExtraInfo(extraVariableParticlePy, tlv.Py());
874 mother->
addExtraInfo(extraVariableParticlePz, tlv.Pz());
890 if (pxpypzmfitobject) {
893 B2FATAL(
"ParticleKinematicFitterModule: not implemented yet");
903 if (pxpypzmfitobject) {
905 TMatrixFSym errMatrix(3);
908 for (
int i = 0; i < 3; i++) {
909 for (
int j = 0; j < 3; j++) {
910 errMatrix[i][j] = pxpypzmfitobject->getCov(i, j);
916 B2FATAL(
"ParticleKinematicFitterModule: not implemented yet");
922 TMatrixFSym fitCovMatrix(3);
926 auto* jetfitObject =
static_cast<JetFitObject*
>(fitobject);
932 const double energy = tlv.E();
933 const double theta = tlv.Theta();
934 const double phi = tlv.Phi();
936 const double st = sin(theta);
937 const double ct = cos(theta);
938 const double sp = sin(phi);
939 const double cp = cos(phi);
944 A(0, 1) = energy * cp * ct ;
945 A(0, 2) = -energy * sp * st ;
947 A(1, 1) = energy * sp * ct ;
948 A(1, 2) = energy * cp * st ;
950 A(2, 1) = -energy * st ;
956 TMatrixFSym D = fitCovMatrix.Similarity(A);
960 B2FATAL(
"ParticleKinematicFitterModule: not implemented yet");
965 if (pxpypzmfitobject) {
982 A[3][0] = tlv.Px() / tlv.E();
983 A[3][1] = tlv.Py() / tlv.E();
984 A[3][2] = tlv.Pz() / tlv.E();
987 TMatrixFSym D = fitCovMatrix.Similarity(A);
991 B2FATAL(
"ParticleKinematicFitterModule: not implemented yet");
Class to provide momentum-related information from ECLClusters.
const TMatrixDSym GetCovarianceMatrix3x3FromCluster(const ECLCluster *cluster, int particleHypo=Const::photon.getPDGCode())
Returns 3x3 covariance matrix (E, theta, phi)
static const ParticleType neutron
neutron particle
static const ParticleType photon
photon particle
In the store you can park objects that have to be accessed by various modules.
void setDescription(const std::string &description)
Sets the description of the module.
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
virtual const char * getParamName(int ilocal) const =0
Get name of parameter ilocal.
virtual double getError(int ilocal) const
Get error of parameter ilocal.
virtual bool setParam(int ilocal, double par_, bool measured_, bool fixed_=false)
Set value and measured flag of parameter i; return: significant change.
void setName(const char *name_)
Set object's name.
Abstract base class for fitting engines of kinematic fits.
Class for jets with (E, eta, phi) in kinematic fits.
Implements constraint 0 = mass1 - mass2 - m.
Implements a constraint of the form efact*sum(E)+pxfact*sum(px)+pyfact*sum(py)+pzfact*sum(pz)=value.
A kinematic fitter using the Newton-Raphson method to solve the equations.
Description of the fit algorithm and interface:
virtual double getPx() const
Return px.
virtual double getPz() const
Return pz.
virtual double getPy() const
Return py.
virtual double getE() const
Return E.
MassConstraint m_hardConstraintMass
hard mass constraint
bool fillFitParticles(Particle *mother, std::vector< Particle * > &particleChildren)
Fills valid particle's children (with valid error matrix) in the vector of Particles that will enter ...
void addFitObjectToConstraints(ParticleFitObject &fitobject)
Adds Orca fit object to the constraints.
void updateMapOfTrackAndDaughter(unsigned &l, std::vector< std::vector< unsigned > > &pars, std::vector< unsigned > &pard, std::vector< Particle * > &allparticles, const Particle *daughter)
update the map of daughter and tracks, find out which tracks belong to each daughter.
bool m_liftPhotonTheta
lift theta constraint of the 3CPhoton.
bool AddFour(Particle *mother)
Added four vectors and calculated a covariance matrix for a combined particles.
std::string m_orcaConstraint
Constraint (softBeam, hardBeam (default))
std::string m_decayStringForNeutronVsAntiNeutron
n or nbar particle tag selection
int m_debugFitterLevel
internal debugging level (for New and Newton fitter only)
virtual void initialize() override
Initialize the Module.
CLHEP::HepSymMatrix getCLHEPMomentumVertexErrorMatrix(Particle *particle)
Returns particle's 7x7 momentum-vertex-error matrix as a HepSymMatrix.
MomentumConstraint m_hardConstraintE
hard beam constraint E
std::string m_prefix
prefix attached to extrainfo names
virtual void event() override
Event processor.
DecayDescriptor m_decaydescriptorForDirectionOnlyParticles
Decay descriptor of direction only particles selection.
bool m_debugFitter
activate internal debugging (for New and Newton fitter only)
bool m_updateDaughters
update daughter kinematics
std::string m_decayString
daughter particles selection
void addParticleToOrcaKinFit(BaseFitter &fitter, Particle *particle, const int index, bool useOnlyDirection, int massHypoPDG)
Adds given particle to the OrcaKinFit.
std::string m_listName
particle list name
void addUnmeasuredGammaToOrcaKinFit(BaseFitter &fitter)
Adds an unmeasured gamma (E, phi, theta) to the fit (-3C) stored as EventExtraInfo TODO.
std::string m_decayStringForAlternateMassParticles
alternate mass particles selection
virtual void terminate() override
termination.
MomentumConstraint m_hardConstraintPz
hard beam constraint pz
float getFitObjectError(ParticleFitObject *fitobject, int ilocal)
Returns fit object error on the parameter ilocal.
ROOT::Math::PxPyPzEVector getLorentzVectorConstraints()
Get constraints (at whatever stage before/after fitting)
std::string m_orcaFitterEngine
Orca Fitter Engine name.
std::vector< int > m_listAlternateMassHypo
index of particles where only direction is used
bool doOrcaKinFitFit(Particle *p)
Kinematic fit using OrcaKinFit.
bool m_add3CPhoton
add one photon with unmeasured energy to the fit (costs 1 constraints)
TMatrixFSym getTMatrixFSymMomentumErrorMatrix()
Returns particle's 7x7 momentum-error matrix as a TMatrixFSym.
DecayDescriptor m_decaydescriptorForAlternateMassParticles
Decay descriptor of alternate particles selection.
void addConstraintsToFitter(BaseFitter &fitter)
Adds Orca fit object to the constraints.
void addTracerToFitter(BaseFitter &fitter)
Adds tracer to the fitter.
RecoilMassConstraint m_hardConstraintRecoilMass
hard recoil mass constraint
TMatrixFSym getTMatrixFSymMomentumVertexErrorMatrix()
Returns particle's 7x7 momentum-vertex-error matrix as a TMatrixFSym.
StoreObjPtr< EventExtraInfo > m_eventextrainfo
StoreObjPtr for the EventExtraInfo in this mode.
MomentumConstraint m_hardConstraintPy
hard beam constraint py
double m_recoilMass
Recoil mass for RecoilMass constraint.
CLHEP::HepLorentzVector getCLHEPLorentzVector(Particle *particle)
Returns particle's 4-momentum as a HepLorentzVector.
TextTracer * m_textTracer
internal text output variable
std::string m_decayStringForDirectionOnlyParticles
direction only particles selection
DecayDescriptor m_decaydescriptor
Decay descriptor of decays to look for.
TMatrixFSym getCovMat7(ParticleFitObject *fitobject)
Returns covariance matrix.
ROOT::Math::PxPyPzEVector getLorentzVector(ParticleFitObject *fitobject)
bool updateOrcaKinFitDaughters(BaseFitter &fitter, Particle *mother)
Update the daughters: momentum is sum of daughters TODO update covariance matrix.
void setConstraints()
Sets constraints, this is not connect to particles or a fitter at this stage.
bool m_addUnmeasuredPhoton
add one unmeasured photon to the fit (costs 3 constraints)
TMatrixFSym getFitObjectCovMat(ParticleFitObject *fitobject)
Returns covariance matrix.
bool storeOrcaKinFitParticles(const std::string &fitSuffix, BaseFitter &fitter, std::vector< Particle * > &particleChildren, Particle *mother)
store fit object information as ExtraInfo
CLHEP::HepSymMatrix getCLHEPMomentumErrorMatrix(Particle *particle)
Returns particle's 4x4 momentum-error matrix as a HepSymMatrix.
double m_invMass
Invariant mass for Mass constraint.
ParticleKinematicFitterModule()
Constructor.
bool m_fixUnmeasuredPhotonToHER
fix the momentum of the unmeasured photon to HER
DecayDescriptor m_decaydescriptorForNeutronVsAntiNeutron
Decay descriptor of n or nbar particle tag selection.
std::string m_orcaTracer
Tracer (None, Text or ROOT)
StoreObjPtr< ParticleList > m_plist
StoreObjPtr for the particle list.
void updateOrcaKinFitMother(BaseFitter &fitter, std::vector< Particle * > &particleChildren, Particle *mother)
Update the mother: momentum is sum of daughters TODO update covariance matrix.
std::string m_kinematicFitter
Kinematic Fitter name.
void resetFitter(BaseFitter &fitter)
Resets all objects associated with the OrcaKinFit fitter.
bool m_fixUnmeasuredPhotonToLER
fix the momentum of the unmeasured photon to LER
bool doKinematicFit(Particle *p)
Main steering routine for any kinematic fitter.
bool m_updateMother
update mother kinematics
MomentumConstraint m_hardConstraintPx
hard beam constraint px
Class to store reconstructed particles.
double getPValue() const
Returns chi^2 probability of fit if done or -1.
ROOT::Math::XYZVector getVertex() const
Returns vertex position (POCA for charged, IP for neutral FS particles)
unsigned getNDaughters(void) const
Returns number of daughter particles.
void addExtraInfo(const std::string &name, double value)
Sets the user-defined data of given name to the given value.
std::vector< Particle * > getDaughters() const
Returns a vector of pointers to daughter particles.
void setMomentumVertexErrorMatrix(const TMatrixFSym &errMatrix)
Sets 7x7 error matrix.
void setPValue(double pValue)
Sets chi^2 probability of fit.
void updateMomentum(const ROOT::Math::PxPyPzEVector &p4, const ROOT::Math::XYZVector &vertex, const TMatrixFSym &errMatrix, double pValue)
Sets Lorentz vector, position, 7x7 error matrix and p-value.
TMatrixFSym getMomentumVertexErrorMatrix() const
Returns 7x7 error matrix.
const Particle * getDaughter(unsigned i) const
Returns a pointer to the i-th daughter particle.
void addParam(const std::string &name, T ¶mVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
double sqrt(double a)
sqrt for double
void copyDaughters(Particle *mother)
Function copies all (grand-)^n-daughter particles of the argument mother Particle.
Abstract base class for different kinds of events.