Belle II Software light-2406-ragdoll
TrackingEnergyLossCorrection.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/TrackingSystematics/TrackingEnergyLossCorrection.h>
11
12#include <framework/datastore/StoreObjPtr.h>
13#include <framework/core/ModuleParam.templateDetails.h>
14#include <analysis/VariableManager/Manager.h>
15#include <analysis/dataobjects/ParticleList.h>
16
17#include <map>
18#include <TRandom.h>
19#include <Math/Vector4D.h>
20
21using namespace Belle2;
22
23REG_MODULE(TrackingEnergyLossCorrection);
24
26{
28 R"DOC(Module to modify Energy of tracks from the lists. Include in your code as
29
30.. code:: python
31
32 mypath.add_module("TrackingEnergyLossCorrection", particleLists=['pi+:cut'], correction=0.001)
33
34The module modifies the input particleLists by subtracting the correction value to the track energy and rescaling the momenta
35
36 )DOC");
37 // Parameter definitions
38 addParam("particleLists", m_ParticleLists, "input particle lists");
39 addParam("correction", m_correction, "correction value to be subtracted from the particle energy",
40 nan("")); // Nan
41 addParam("payloadName", m_payloadName, "ID of table used for reweighing", std::string(""));
42 addParam("correctionName", m_correctionName, "Label for the correction in the look up table", std::string(""));
43}
44
46{
47 if (!isnan(m_correction) && !m_payloadName.empty()) {
48 B2FATAL("It's not allowed to provide both a valid value for the scale parameter and a non-empty table name. Please decide for one of the two options!");
49 } else if (isnan(m_correction) && m_payloadName.empty()) {
50 B2FATAL("Neither a valid value for the scale parameter nor a non-empty table name was provided. Please set (exactly) one of the two options!");
51 } else if (!m_payloadName.empty()) {
52 m_ParticleWeightingLookUpTable = std::make_unique<DBObjPtr<ParticleWeightingLookUpTable>>(m_payloadName);
53
54 std::vector<std::string> variables = Variable::Manager::Instance().resolveCollections((
55 *m_ParticleWeightingLookUpTable.get())->getAxesNames());
56 for (const auto& i_variable : variables) {
58 if (!var) {
59 B2FATAL("Variable '" << i_variable << "' is not available in Variable::Manager!");
60 }
61 }
62 }
63}
64
66{
67 for (auto& iList : m_ParticleLists) {
68 StoreObjPtr<ParticleList> particleList(iList);
69
70 //check particle List exists and has particles
71 if (!particleList) {
72 B2ERROR("ParticleList " << iList << " not found");
73 continue;
74 }
75
76 size_t nPart = particleList->getListSize();
77 for (size_t iPart = 0; iPart < nPart; iPart++) {
78 auto particle = particleList->getParticle(iPart);
79 if (particle->getParticleSource() != Particle::EParticleSourceObject::c_Composite and
80 particle->getParticleSource() != Particle::EParticleSourceObject::c_V0 and
81 particle->getParticleSource() != Particle::EParticleSourceObject::c_Track) {
82 B2WARNING("particle source " << particle->getParticleSource() <<
83 " is not within the expected values. please check before continuing");
84 continue;
85 }
87 }
88 }
89}
90
91
92// Getting LookUp info for given particle in given event
94{
95 std::vector<std::string> variables = Variable::Manager::Instance().resolveCollections((
96 *m_ParticleWeightingLookUpTable.get())->getAxesNames());
97
98 std::map<std::string, double> values;
99 for (const auto& i_variable : variables) {
101 double value = std::get<double>(var->function(particle));
102 values.insert(std::make_pair(i_variable, value));
103 }
104 WeightInfo info = (*m_ParticleWeightingLookUpTable.get())->getInfo(values);
105 for (const auto& entry : info) {
106 particle->writeExtraInfo(m_payloadName + "_" + entry.first, entry.second);
107 }
108
109 return particle->getExtraInfo(m_payloadName + "_" + m_correctionName);
110}
111
112
113
115{
116 if (particle->getParticleSource() == Particle::EParticleSourceObject::c_Composite or
117 particle->getParticleSource() == Particle::EParticleSourceObject::c_V0) {
118 for (auto daughter : particle->getDaughters()) {
119 setEnergyLossCorrection(daughter);
120 }
121 double px = 0;
122 double py = 0;
123 double pz = 0;
124 double E = 0;
125 for (auto daughter : particle->getDaughters()) {
126 px += daughter->getPx();
127 py += daughter->getPy();
128 pz += daughter->getPz();
129 E += daughter->getEnergy();
130 }
131 const ROOT::Math::PxPyPzEVector vec(px, py, pz, E);
132 particle->set4Vector(vec);
133 } else if (particle->getParticleSource() == Particle::EParticleSourceObject::c_Track) {
134 if (!isnan(m_correction)) {
136 } else if (!m_correctionName.empty()) {
137 particle->setEnergyLossCorrection(getCorrectionValue(particle));
138 }
139 }
140
141
142}
Base class for Modules.
Definition: Module.h:72
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:214
Class to store reconstructed particles.
Definition: Particle.h:75
void writeExtraInfo(const std::string &name, const double value)
Sets the user defined extraInfo.
Definition: Particle.cc:1308
std::vector< Belle2::Particle * > getDaughters() const
Returns a vector of pointers to daughter particles.
Definition: Particle.cc:637
void set4Vector(const ROOT::Math::PxPyPzEVector &p4)
Sets Lorentz vector.
Definition: Particle.h:271
void setEnergyLossCorrection(double energyLossCorrection)
Sets Energy loss correction.
Definition: Particle.h:306
EParticleSourceObject getParticleSource() const
Returns particle source as defined with enum EParticleSourceObject.
Definition: Particle.h:478
double getExtraInfo(const std::string &name) const
Return given value if set.
Definition: Particle.cc:1289
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:96
std::vector< std::string > m_ParticleLists
input particle lists
virtual void initialize() override
Initializes the modules and checks the validity of the input parameters.
virtual void event() override
Function to be executed at each event.
double getCorrectionValue(Particle *particle)
Returns the needed correction for particle based on payloadName and correctionName.
TrackingEnergyLossCorrectionModule()
Constructor: Sets the description, the properties and the parameters of the module.
void setEnergyLossCorrection(Particle *particle)
function to set the Energy correction value
std::unique_ptr< DBObjPtr< ParticleWeightingLookUpTable > > m_ParticleWeightingLookUpTable
Pointer to the table in DB.
std::string m_correctionName
Name of the correction from table.
std::vector< std::string > resolveCollections(const std::vector< std::string > &variables)
Resolve Collection Returns variable names corresponding to the given collection or if it is not a col...
Definition: Manager.cc:179
const Var * getVariable(std::string name)
Get the variable belonging to the given key.
Definition: Manager.cc:57
static Manager & Instance()
get singleton instance.
Definition: Manager.cc:25
std::map< std::string, double > WeightInfo
Weight information: a line from the weight lookup table.
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
Abstract base class for different kinds of events.
Definition: ClusterUtils.h:24
A variable returning a floating-point value for a given Particle.
Definition: Manager.h:146