Belle II Software development
KLMExpertModule.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#include <reconstruction/modules/KlId/KLMExpert/KLMExpertModule.h>
9#include <mdst/dataobjects/KlId.h>
10#include <framework/logging/Logger.h>
11
12#include <mdst/dataobjects/ECLCluster.h>
13#include <mdst/dataobjects/KLMCluster.h>
14#include <tracking/dataobjects/TrackClusterSeparation.h>
15
16#include <mva/interface/Interface.h>
17#include <mva/dataobjects/DatabaseRepresentationOfWeightfile.h>
18#include <mva/interface/Weightfile.h>
19#include <mva/interface/Expert.h>
20
21#include <boost/algorithm/string/predicate.hpp>
22
23// here's where the functions are hidden
24#include "reconstruction/modules/KlId/KLMExpert/KlId.h"
25
26using namespace std;
27using namespace Belle2;
28using namespace Belle2::KlongId;
29
30REG_MODULE(KLMExpert);
31
33{
34 setDescription("Use to calculate KlId for each KLM cluster.");
35 addParam("classifierPath", m_identifier,
36 "path to the classifier you want to use. It is recommended to use the default classifiers and not to mess around with this.",
39}
40
41
42
46
47
48// --------------------------------------Module----------------------------------------------
50{
51 // require existence of necessary datastore obj
52
53 m_klmClusters.isRequired();
54
55 m_klids.registerInDataStore();
56 m_klmClusters.registerRelationTo(m_klids);
57
58
59 if (not(boost::ends_with(m_identifier, ".root") or boost::ends_with(m_identifier, ".xml"))) {
60 m_weightfile_representation = std::unique_ptr<DBObjPtr<DatabaseRepresentationOfWeightfile>>(new
62 }
63
65
66}
67
68
70{
72 if (m_weightfile_representation->hasChanged()) {
73 std::stringstream ss((*m_weightfile_representation)->m_data);
74 auto weightfile = MVA::Weightfile::loadFromStream(ss);
75 init_mva(weightfile);
76 }
77 } else {
79 init_mva(weightfile);
80
81 }
82}
83
85{
86
87 auto supported_interfaces = MVA::AbstractInterface::getSupportedInterfaces();
88 MVA::GeneralOptions general_options;
89 weightfile.getOptions(general_options);
90
91 m_expert = supported_interfaces[general_options.m_method]->getExpert();
92 m_expert->load(weightfile);
93
94 std::vector<float> dummy;
95 dummy.resize(m_feature_variables.size(), 0);
96 m_dataset = std::unique_ptr<MVA::SingleDataset>(new MVA::SingleDataset(general_options, std::move(dummy), 0));
97
98}
99
100
102{
103 // Use the neutralHadron hypothesis for the ECL
105
106 //overwritten at the end of the cluster loop
107 KlId* klid = nullptr;
108
109 // loop thru clusters in event and classify
110 for (KLMCluster& cluster : m_klmClusters) {
111
112 const ROOT::Math::XYZVector& clusterPos = cluster.getClusterPosition();
113
114 // get various KLMCluster vars
115 m_KLMglobalZ = clusterPos.Z();
116 m_KLMnCluster = m_klmClusters.getEntries();
117 m_KLMnLayer = cluster.getLayers();
118 m_KLMnInnermostLayer = cluster.getInnermostLayer();
119 m_KLMtime = cluster.getTime();
120 m_KLMenergy = cluster.getEnergy();
121 m_KLMhitDepth = cluster.getClusterPosition().R();
122
123 // find nearest ecl cluster and calculate distance
124 pair<ECLCluster*, double> closestECLAndDist = findClosestECLCluster(clusterPos, eclHypothesis);
125 ECLCluster* closestECLCluster = get<0>(closestECLAndDist);
126 m_KLMECLDist = get<1>(closestECLAndDist);
127
128 // get variables of the closest ECL cluster might be removed in future
129 if (!(closestECLCluster == nullptr)) {
130 m_KLMECLE = closestECLCluster -> getEnergy(eclHypothesis);
131 m_KLMECLE9oE25 = closestECLCluster -> getE9oE21();
132 m_KLMECLTerror = closestECLCluster -> getDeltaTime99();
133 m_KLMECLTiming = closestECLCluster -> getTime();
134 m_KLMECLEerror = closestECLCluster -> getUncertaintyEnergy();
135 m_KLMECLdeltaL = closestECLCluster -> getDeltaL();
136 m_KLMECLminTrackDist = closestECLCluster -> getMinTrkDistance();
137 m_KLMECLZMVA = closestECLCluster -> getZernikeMVA();
138 m_KLMECLZ40 = closestECLCluster -> getAbsZernike40();
139 m_KLMECLZ51 = closestECLCluster -> getAbsZernike51();
140 } else {
141 m_KLMECLdeltaL = -999;
143 m_KLMECLE = -999;
144 m_KLMECLE9oE25 = -999;
145 m_KLMECLTiming = -999;
146 m_KLMECLTerror = -999;
147 m_KLMECLEerror = -999;
148 m_KLMECLZMVA = -999;
149 m_KLMECLZ40 = -999;
150 m_KLMECLZ51 = -999;
151 }
152
153 // calculate distance to next cluster
154 tuple<const KLMCluster*, double, double> closestKLMAndDist = findClosestKLMCluster(clusterPos);
155 m_KLMnextCluster = get<1>(closestKLMAndDist);
156 m_KLMavInterClusterDist = get<2>(closestKLMAndDist);
157
158 m_KLMTrackSepDist = -999;
159 m_KLMTrackSepAngle = -999;
163
164 auto trackSeperations = cluster.getRelationsTo<TrackClusterSeparation>();
165 float best_dist = 1e10;
166 for (auto trackSeperation : trackSeperations) {
167 float dist = trackSeperation.getDistance();
168 if (dist < best_dist) {
169 best_dist = dist;
170 m_KLMTrackSepDist = trackSeperation.getDistance();
171 m_KLMTrackSepAngle = trackSeperation.getTrackClusterAngle();
172 m_KLMInitialTrackSepAngle = trackSeperation.getTrackClusterInitialSeparationAngle();
173 m_KLMTrackRotationAngle = trackSeperation.getTrackRotationAngle();
174 m_KLMTrackClusterSepAngle = trackSeperation.getTrackClusterSeparationAngle();
175 }
176 }
177
178// reduced vars set
197
198
199 for (unsigned int i = 0; i < m_feature_variables.size(); ++i) {
200 if (!std::isfinite(m_feature_variables[i])) { m_feature_variables[i] = -999; }
201 m_dataset->m_input[i] = m_feature_variables[i];
202 }
203
204 double IDMVAOut = m_expert->apply(*m_dataset)[0];
205 B2DEBUG(175, "KLM Expert classification: " << IDMVAOut);
206 klid = m_klids.appendNew();
207 cluster.addRelationTo(klid, IDMVAOut);
208
209 }// for cluster in clusters
210} // event
Class for accessing objects in the database.
Definition DBObjPtr.h:21
ECL cluster data.
Definition ECLCluster.h:27
EHypothesisBit
The hypothesis bits for this ECLCluster (Connected region (CR) is split using this hypothesis.
Definition ECLCluster.h:31
@ c_neutralHadron
CR is reconstructed as a neutral hadron (N2)
Definition ECLCluster.h:43
KLM cluster data.
Definition KLMCluster.h:29
float m_KLMECLE
energy measured in associated ECL cluster
float m_KLMECLdeltaL
distance between track entry pofloat and cluster center, might be removed
StoreArray< KlId > m_klids
storearray
float m_KLMInitialTrackSepAngle
angular distance from track to cluster at track starting point
float m_KLMECLZMVA
output of a BDT fitted on various Z-moments for the closest ECL cluster
float m_KLMTrackRotationAngle
angle between track at poca and trackbeginning
float m_KLMECLTiming
timing of associated ECL cluster
std::unique_ptr< MVA::SingleDataset > m_dataset
Pointer to the current dataset.
StoreArray< KLMCluster > m_klmClusters
storearray
virtual void initialize() override
init
float m_KLMECLTerror
uncertanty on time in associated ECL cluster
virtual void event() override
process event
float m_KLMtime
timing of KLM Cluster
float m_KLMECLDist
distance associated ECL <-> KLM cluster, extrapolated by genfit
float m_KLMnLayer
number of layers hit in KLM cluster
float m_KLMhitDepth
hit depth in KLM, distance to IP
float m_KLMECLminTrackDist
track distance between associated ECL cluster and track extrapolated into ECL
float m_KLMenergy
Energy deposit in KLM (0.2 GeV * nHitCells)
float m_KLMTrackSepAngle
angular distance from track separation object.
std::unique_ptr< MVA::Expert > m_expert
Pointer to the current MVA Expert.
float m_KLMECLZ40
zernike moment 4,0 of closest ECL
std::unique_ptr< DBObjPtr< DatabaseRepresentationOfWeightfile > > m_weightfile_representation
Database pointer to the Database representation of the weightfile.
virtual ~KLMExpertModule()
Destructor.
float m_KLMnInnermostLayer
number of innermost layers hit
float m_KLMECLEerror
uncertanty on E in associated ECL cluster
float m_KLMECLE9oE25
E in surrounding 9 crystals divided by surrounding 25 crydtalls.
std::vector< float > m_feature_variables
vars to be classified
float m_KLMECLZ51
zernike moment 5,1 of closest ECL
float m_KLMavInterClusterDist
average distance between all KLM clusters
virtual void beginRun() override
beginn run
float m_KLMTrackSepDist
distance from track separation object
float m_KLMglobalZ
global Z position in KLM
float m_KLMnCluster
varibales to write out.
float m_KLMnextCluster
distance to next KLM cluster
float m_KLMTrackClusterSepAngle
angle between trach momentum and cluster (measured from ip)
void init_mva(MVA::Weightfile &weightfile)
Initialize mva expert, dataset and features Called everytime the weightfile in the database changes i...
std::string m_identifier
mva identifier.
Klong identification (KlId) datastore object to store results from KlId calculations.
Definition KlId.h:23
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 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
Store one Track-KLMCluster separation as a ROOT object.
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
Helper functions for all klid modules to improve readability of the code.
Definition KlId.h:27
std::tuple< const Belle2::KLMCluster *, double, double > findClosestKLMCluster(const ROOT::Math::XYZVector &klmClusterPosition)
find nearest KLMCluster, tis distance and the av intercluster distance
Definition KlId.h:236
std::pair< Belle2::ECLCluster *, double > findClosestECLCluster(const ROOT::Math::XYZVector &klmClusterPosition, const Belle2::ECLCluster::EHypothesisBit eclhypothesis=Belle2::ECLCluster::EHypothesisBit::c_neutralHadron)
Find the closest ECLCluster with a neutral hadron hypothesis, and return it with its distance.
Definition KlId.h:203
Abstract base class for different kinds of events.
STL namespace.