Belle II Software development
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
15/* Basf2 headers. */
16#include <mva/dataobjects/DatabaseRepresentationOfWeightfile.h>
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
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
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
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 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:46
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.
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.
void addSignalFraction(float signal_fraction)
Saves the signal fraction in the xml tree.
Definition Weightfile.cc:95
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
Module()
Constructor.
Definition Module.cc:30
@ 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:76
double getEnergy() const
Returns total energy.
Definition Particle.h:555
void addExtraInfo(const std::string &name, double value)
Sets the user-defined data of given name to the given value.
Definition Particle.cc:1421
const Particle * getDaughter(unsigned i) const
Returns a pointer to the i-th daughter particle.
Definition Particle.cc:662
double getExtraInfo(const std::string &name) const
Return given value if set.
Definition Particle.cc:1374
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:559
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition Module.h:649
Abstract base class for different kinds of events.