Belle II Software light-2406-ragdoll
KlongMomentumCalculatorExpertModule.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9// Own header.
10#include <analysis/modules/KlongDecayReconstructor/KlongMomentumCalculatorExpertModule.h>
11
12// framework aux
13#include <framework/logging/Logger.h>
14
15// dataobjects
16#include <analysis/dataobjects/Particle.h>
17
18// decay descriptor
19#include <analysis/DecayDescriptor/DecayDescriptorParticle.h>
20
21// utilities
22#include <analysis/DecayDescriptor/ParticleListName.h>
23#include <analysis/utility/ParticleCopy.h>
24#include <analysis/utility/KlongCalculatorUtils.h>
25
26#include <Math/Vector4D.h>
27
28#include <memory>
29
30using namespace std;
31using namespace Belle2;
32
33//-----------------------------------------------------------------
34// Register module
35//-----------------------------------------------------------------
36
37REG_MODULE(KlongMomentumCalculatorExpert);
38
39//-----------------------------------------------------------------
40// Implementation
41//-----------------------------------------------------------------
42
44 Module()
45
46{
47 // set module description (e.g. insert text)
48 setDescription(R"DOC(
49This module is used to employ kinematic constraints to determine the momentum of Klongs for two
50body decays containing a K_L0 and something else. The module creates a list of K_L0 candidates whose K_L0 momentum is
51reconstructed by combining the reconstructed direction of the K_L0 (either from the ECL or the KLM cluster) and
52kinematic constraints of the initial state.
53)DOC");
55
56 // Add parameters
57 addParam("decayString", m_decayString,
58 "Input DecayDescriptor string.");
59 addParam("maximumNumberOfCandidates", m_maximumNumberOfCandidates,
60 "Don't reconstruct channel if more candidates than given are produced.", -1);
61 addParam("writeOut", m_writeOut,
62 "If true, the output ParticleList will be saved by RootOutput. If false, it will be ignored when writing the file.", false);
63 addParam("recoList", m_recoList,
64 "Suffix attached to the output K_L list, if not defined it is set to '_reco' \n", std::string("_reco"));
65}
66
68{
70
71 // obtain the input and output particle lists from the decay string
73 if (!valid)
74 B2ERROR("Invalid input DecayString: " << m_decayString);
75
77
78 // Daughters
79 bool k_check = false;
80 int nProducts = m_decaydescriptor.getNDaughters();
81 if (nProducts !=2)
82 B2FATAL("The module currently only works for final states with exactly two particles!");
83
84 for (int i = 0; i < nProducts; ++i) {
85 const DecayDescriptorParticle* daughter =
87 StoreObjPtr<ParticleList>().isRequired(daughter->getFullName());
88 if (daughter->getPDGCode() == Const::Klong.getPDGCode()) {
89 if (k_check)
90 B2FATAL("More than one K_L is detected! This module accepts only one K_L in the final state.");
91
92 m_klistName = daughter->getFullName() + m_klistName;
93 k_check = true;
94 }
95 }
96
97 if (!k_check)
98 B2FATAL("This module is meant to reconstruct decays with a K_L0 in the final state. There is no K_L0 in this decay!");
99
100 m_generator = std::make_unique<ParticleGenerator>(m_decayString);
101
103 m_koutputList.registerInDataStore(m_klistName, flags);
104}
105
107{
108 m_koutputList.create();
109 m_koutputList->initialize(Const::Klong.getPDGCode(), m_klistName);
110
111 m_generator->init();
112
113 int numberOfCandidates = 0;
114 while (m_generator->loadNext()) {
115
116 Particle particle = m_generator->getCurrentParticle();
117 const double motherMass = particle.getPDGMass();
118 const std::vector<Particle*> daughters = particle.getDaughters();
119
120 ROOT::Math::PxPyPzEVector MotherMomentum;
121 ROOT::Math::PxPyPzEVector KMomentum;
122 int idx = 0;
123 bool is_physical = KlongCalculatorUtils::calculateBtoKlongX(MotherMomentum, KMomentum, daughters, motherMass, idx);
124
125 if (!is_physical)
126 continue;
127
128 numberOfCandidates++;
129
130 if (m_maximumNumberOfCandidates > 0 and numberOfCandidates > m_maximumNumberOfCandidates) {
131 m_koutputList->clear();
132 break;
133 }
134
135 for (auto daughter : daughters) {
136 if (daughter->getPDGCode() == Const::Klong.getPDGCode()) {
137 Particle* kparticle = ParticleCopy::copyParticle(daughter);
138 kparticle->set4Vector(KMomentum);
139 m_koutputList->addParticle(kparticle);
140 kparticle->addExtraInfo("permID", idx);
141 break;
142 }
143 }
144 } //while
145} //event
int getPDGCode() const
PDG code.
Definition: Const.h:473
static const ParticleType Klong
K^0_L particle.
Definition: Const.h:678
EStoreFlags
Flags describing behaviours of objects etc.
Definition: DataStore.h:69
@ c_WriteOut
Object/array should be saved by output modules.
Definition: DataStore.h:70
@ c_DontWriteOut
Object/array should be NOT saved by output modules.
Definition: DataStore.h:71
Represents a particle in the DecayDescriptor.
bool init(const std::string &str)
Initialise the DecayDescriptor from given string.
const DecayDescriptor * getDaughter(int i) const
return i-th daughter (0 based index).
int getNDaughters() const
return number of direct daughters.
const DecayDescriptorParticle * getMother() const
return mother.
StoreObjPtr< ParticleList > m_koutputList
Klong output particle list.
int m_maximumNumberOfCandidates
drop all candidates if more candidates than this parameter are produced
virtual void initialize() override
Initialize the Module.
std::string m_decayString
Input DecayString specifying the decay being reconstructed.
std::string m_recoList
Suffix attached to the output K_L list, if not defined it is set to '_reco'
std::unique_ptr< ParticleGenerator > m_generator
Generates the combinations.
DecayDescriptor m_decaydescriptor
Decay descriptor of the decay being reconstructed.
std::string m_klistName
output K_L0 particle list name
Base class for Modules.
Definition: Module.h:72
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:214
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition: Module.cc:208
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
Definition: Module.h:80
Class to store reconstructed particles.
Definition: Particle.h:75
std::vector< Belle2::Particle * > getDaughters() const
Returns a vector of pointers to daughter particles.
Definition: Particle.cc:637
double getPDGMass(void) const
Returns uncertainty on the invariant mass (requires valid momentum error matrix)
Definition: Particle.cc:604
void addExtraInfo(const std::string &name, double value)
Sets the user-defined data of given name to the given value.
Definition: Particle.cc:1336
void set4Vector(const ROOT::Math::PxPyPzEVector &p4)
Sets Lorentz vector.
Definition: Particle.h:271
bool isRequired(const std::string &name="")
Ensure this array/object has been registered previously.
Accessor to arrays stored in the data store.
Definition: StoreArray.h:113
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:96
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition: Module.h:560
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:650
Particle * copyParticle(const Particle *original)
Function takes argument Particle and creates a copy of it and copies of all its (grand-)^n-daughters.
Definition: ParticleCopy.cc:18
Abstract base class for different kinds of events.
Definition: ClusterUtils.h:24
STL namespace.
static bool calculateBtoKlongX(ROOT::Math::PxPyPzEVector &BMomentum, ROOT::Math::PxPyPzEVector &KMomentum, const std::vector< Particle * > daughters, const double m_b, int &idx)
Calculate kinematics of two body B decays containing a K_L0.