Belle II Software light-2406-ragdoll
LowEnergyPi0IdentificationExpertModule.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/LowEnergyPi0IdentificationExpert/LowEnergyPi0IdentificationExpertModule.h>
11
12/* Analysis headers. */
13#include <analysis/variables/ECLVariables.h>
14#include <analysis/variables/HelicityVariables.h>
15
16/* Basf2 headers. */
17#include <mva/interface/Interface.h>
18
19/* Boost headers. */
20#include <boost/algorithm/string/predicate.hpp>
21
22using namespace Belle2;
23
24REG_MODULE(LowEnergyPi0IdentificationExpert);
25
27{
28 setDescription("Low-energy pi0 identification.");
29 addParam("Pi0ListName", m_Pi0ListName, "Pi0 particle list name.",
30 std::string("pi0"));
31 addParam("Belle1", m_Belle1, "Belle 1 data analysis.", false);
32 addParam("identifier", m_identifier,
33 "Database identifier or file used to load the weights.",
36}
37
39{
40}
41
43{
44 m_ListPi0.isRequired(m_Pi0ListName);
45 if (not(boost::ends_with(m_identifier, ".root") or boost::ends_with(m_identifier, ".xml"))) {
46 m_weightfile_representation = std::unique_ptr<DBObjPtr<DatabaseRepresentationOfWeightfile>>(new
48 }
50}
51
53{
54 m_expert.reset();
55 m_dataset.reset();
56}
57
59{
61 if (m_weightfile_representation->hasChanged()) {
62 std::stringstream ss((*m_weightfile_representation)->m_data);
63 auto weightfile = MVA::Weightfile::loadFromStream(ss);
64 init_mva(weightfile);
65 }
66 } else {
68 init_mva(weightfile);
69 }
70}
71
73{
74}
75
77{
78 auto supported_interfaces = MVA::AbstractInterface::getSupportedInterfaces();
79 MVA::GeneralOptions general_options;
80 weightfile.getOptions(general_options);
81 weightfile.addSignalFraction(0.5);
82 m_expert = supported_interfaces[general_options.m_method]->getExpert();
83 m_expert->load(weightfile);
84 std::vector<float> dummy;
85 /* The number of input variables depends on the experiment. */
86 int nInputVariables;
87 if (m_Belle1)
88 nInputVariables = 6;
89 else
90 nInputVariables = 10;
91 dummy.resize(nInputVariables, 0);
92 m_dataset = std::unique_ptr<MVA::SingleDataset>(new MVA::SingleDataset(general_options, std::move(dummy), 0));
93}
94
96{
97 int n = m_ListPi0->getListSize();
98 for (int i = 0; i < n; ++i) {
99 Particle* pi0 = m_ListPi0->getParticle(i);
100 const Particle* gamma1 = pi0->getDaughter(0);
101 const Particle* gamma2 = pi0->getDaughter(1);
102 const Particle* gammaLowEnergy, *gammaHighEnergy;
103 if (gamma1->getEnergy() > gamma2->getEnergy()) {
104 gammaLowEnergy = gamma2;
105 gammaHighEnergy = gamma1;
106 } else {
107 gammaLowEnergy = gamma1;
108 gammaHighEnergy = gamma2;
109 }
110 double gammaLowEnergyPi0Veto, gammaHighEnergyPi0Veto;
111 double gammaLowEnergyE9E21, gammaHighEnergyE9E21;
112 double gammaLowEnergyClusterTheta, gammaHighEnergyClusterTheta;
113 double gammaLowEnergyZernikeMVA, gammaHighEnergyZernikeMVA;
114 double gammaLowEnergyIsolation, gammaHighEnergyIsolation;
115 gammaLowEnergyPi0Veto = pi0->getExtraInfo("lowEnergyPi0VetoGammaLowEnergy");
116 gammaHighEnergyPi0Veto =
117 pi0->getExtraInfo("lowEnergyPi0VetoGammaHighEnergy");
118 gammaLowEnergyE9E21 = Variable::eclClusterE9E21(gammaLowEnergy);
119 gammaHighEnergyE9E21 = Variable::eclClusterE9E21(gammaHighEnergy);
120 gammaLowEnergyClusterTheta = Variable::eclClusterTheta(gammaLowEnergy);
121 gammaHighEnergyClusterTheta = Variable::eclClusterTheta(gammaHighEnergy);
122 if (!m_Belle1) {
123 gammaLowEnergyZernikeMVA = Variable::eclClusterZernikeMVA(gammaLowEnergy);
124 gammaHighEnergyZernikeMVA =
125 Variable::eclClusterZernikeMVA(gammaHighEnergy);
126 gammaLowEnergyIsolation = Variable::eclClusterIsolation(gammaLowEnergy);
127 gammaHighEnergyIsolation = Variable::eclClusterIsolation(gammaHighEnergy);
128 }
129 m_dataset->m_input[0] = gammaLowEnergyPi0Veto;
130 m_dataset->m_input[1] = gammaHighEnergyPi0Veto;
131 m_dataset->m_input[2] = gammaLowEnergyE9E21;
132 m_dataset->m_input[3] = gammaHighEnergyE9E21;
133 m_dataset->m_input[4] = gammaLowEnergyClusterTheta;
134 m_dataset->m_input[5] = gammaHighEnergyClusterTheta;
135 if (!m_Belle1) {
136 m_dataset->m_input[6] = gammaLowEnergyZernikeMVA;
137 m_dataset->m_input[7] = gammaHighEnergyZernikeMVA;
138 m_dataset->m_input[8] = gammaLowEnergyIsolation;
139 m_dataset->m_input[9] = gammaHighEnergyIsolation;
140 }
141 float identification = m_expert->apply(*m_dataset)[0];
142 pi0->addExtraInfo("lowEnergyPi0Identification", identification);
143 }
144}
Class for accessing objects in the database.
Definition: DBObjPtr.h:21
std::unique_ptr< MVA::SingleDataset > m_dataset
Pointer to the current dataset.
void event() override
This method is called for each event.
void endRun() override
This method is called if the current run ends.
void terminate() override
This method is called at the end of the event processing.
std::unique_ptr< MVA::Expert > m_expert
Pointer to the current MVA expert.
std::unique_ptr< DBObjPtr< DatabaseRepresentationOfWeightfile > > m_weightfile_representation
Database pointer to the database representation of the weightfile.
void beginRun() override
Called when entering a new run.
void init_mva(MVA::Weightfile &weightfile)
Initialize mva expert, dataset and features Called every time the weightfile in the database changes ...
std::string m_identifier
Database identifier or file used to load the weights.
static void initSupportedInterfaces()
Static function which initliazes all supported interfaces, has to be called once before getSupportedI...
Definition: Interface.cc:45
static std::map< std::string, AbstractInterface * > getSupportedInterfaces()
Returns interfaces supported by the MVA Interface.
Definition: Interface.h:53
General options which are shared by all MVA trainings.
Definition: Options.h:62
Wraps the data of a single event into a Dataset.
Definition: Dataset.h:135
The Weightfile class serializes all information about a training into an xml tree.
Definition: Weightfile.h:38
static Weightfile loadFromStream(std::istream &stream)
Static function which deserializes a Weightfile from a stream.
Definition: Weightfile.cc:251
void getOptions(Options &options) const
Fills an Option object from the xml tree.
Definition: Weightfile.cc:67
static Weightfile loadFromFile(const std::string &filename)
Static function which loads a Weightfile from a file.
Definition: Weightfile.cc:206
void addSignalFraction(float signal_fraction)
Saves the signal fraction in the xml tree.
Definition: Weightfile.cc:95
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
double getEnergy() const
Returns total energy.
Definition: Particle.h:535
void addExtraInfo(const std::string &name, double value)
Sets the user-defined data of given name to the given value.
Definition: Particle.cc:1336
const Particle * getDaughter(unsigned i) const
Returns a pointer to the i-th daughter particle.
Definition: Particle.cc:631
double getExtraInfo(const std::string &name) const
Return given value if set.
Definition: Particle.cc:1289
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