Belle II Software prerelease-10-00-00a
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/interface/Interface.h>
17
18/* Boost headers. */
19#include <boost/algorithm/string/predicate.hpp>
20
21using namespace Belle2;
22
23REG_MODULE(LowEnergyPi0IdentificationExpert);
24
26{
27 setDescription("Low-energy pi0 identification.");
28 addParam("Pi0ListName", m_Pi0ListName, "Pi0 particle list name.",
29 std::string("pi0"));
30 addParam("Belle1", m_Belle1, "Belle 1 data analysis.", false);
31 addParam("identifier", m_identifier,
32 "Database identifier or file used to load the weights.",
35}
36
40
42{
43 m_ListPi0.isRequired(m_Pi0ListName);
44 if (not(boost::ends_with(m_identifier, ".root") or boost::ends_with(m_identifier, ".xml"))) {
45 m_weightfile_representation = std::unique_ptr<DBObjPtr<DatabaseRepresentationOfWeightfile>>(new
47 }
49}
50
56
58{
60 if (m_weightfile_representation->hasChanged()) {
61 std::stringstream ss((*m_weightfile_representation)->m_data);
62 auto weightfile = MVA::Weightfile::loadFromStream(ss);
63 init_mva(weightfile);
64 }
65 } else {
67 init_mva(weightfile);
68 }
69}
70
74
76{
77 auto supported_interfaces = MVA::AbstractInterface::getSupportedInterfaces();
78 MVA::GeneralOptions general_options;
79 weightfile.getOptions(general_options);
80 weightfile.addSignalFraction(0.5);
81 m_expert = supported_interfaces[general_options.m_method]->getExpert();
82 m_expert->load(weightfile);
83 std::vector<float> dummy;
84 /* The number of input variables depends on the experiment. */
85 int nInputVariables;
86 if (m_Belle1)
87 nInputVariables = 6;
88 else
89 nInputVariables = 10;
90 dummy.resize(nInputVariables, 0);
91 m_dataset = std::unique_ptr<MVA::SingleDataset>(new MVA::SingleDataset(general_options, std::move(dummy), 0));
92}
93
95{
96 int n = m_ListPi0->getListSize();
97 for (int i = 0; i < n; ++i) {
98 Particle* pi0 = m_ListPi0->getParticle(i);
99 const Particle* gamma1 = pi0->getDaughter(0);
100 const Particle* gamma2 = pi0->getDaughter(1);
101 const Particle* gammaLowEnergy, *gammaHighEnergy;
102 if (gamma1->getEnergy() > gamma2->getEnergy()) {
103 gammaLowEnergy = gamma2;
104 gammaHighEnergy = gamma1;
105 } else {
106 gammaLowEnergy = gamma1;
107 gammaHighEnergy = gamma2;
108 }
109 double gammaLowEnergyPi0Veto, gammaHighEnergyPi0Veto;
110 double gammaLowEnergyE9E21, gammaHighEnergyE9E21;
111 double gammaLowEnergyClusterTheta, gammaHighEnergyClusterTheta;
112 double gammaLowEnergyZernikeMVA, gammaHighEnergyZernikeMVA;
113 double gammaLowEnergyIsolation, gammaHighEnergyIsolation;
114 gammaLowEnergyPi0Veto = pi0->getExtraInfo("lowEnergyPi0VetoGammaLowEnergy");
115 gammaHighEnergyPi0Veto =
116 pi0->getExtraInfo("lowEnergyPi0VetoGammaHighEnergy");
117 gammaLowEnergyE9E21 = Variable::eclClusterE9E21(gammaLowEnergy);
118 gammaHighEnergyE9E21 = Variable::eclClusterE9E21(gammaHighEnergy);
119 gammaLowEnergyClusterTheta = Variable::eclClusterTheta(gammaLowEnergy);
120 gammaHighEnergyClusterTheta = Variable::eclClusterTheta(gammaHighEnergy);
121 if (!m_Belle1) {
122 gammaLowEnergyZernikeMVA = Variable::eclClusterZernikeMVA(gammaLowEnergy);
123 gammaHighEnergyZernikeMVA =
124 Variable::eclClusterZernikeMVA(gammaHighEnergy);
125 gammaLowEnergyIsolation = Variable::eclClusterIsolation(gammaLowEnergy);
126 gammaHighEnergyIsolation = Variable::eclClusterIsolation(gammaHighEnergy);
127 }
128 m_dataset->m_input[0] = gammaLowEnergyPi0Veto;
129 m_dataset->m_input[1] = gammaHighEnergyPi0Veto;
130 m_dataset->m_input[2] = gammaLowEnergyE9E21;
131 m_dataset->m_input[3] = gammaHighEnergyE9E21;
132 m_dataset->m_input[4] = gammaLowEnergyClusterTheta;
133 m_dataset->m_input[5] = gammaHighEnergyClusterTheta;
134 if (!m_Belle1) {
135 m_dataset->m_input[6] = gammaLowEnergyZernikeMVA;
136 m_dataset->m_input[7] = gammaHighEnergyZernikeMVA;
137 m_dataset->m_input[8] = gammaLowEnergyIsolation;
138 m_dataset->m_input[9] = gammaHighEnergyIsolation;
139 }
140 float identification = m_expert->apply(*m_dataset)[0];
141 pi0->addExtraInfo("lowEnergyPi0Identification", identification);
142 }
143}
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.