Belle II Software release-09-00-04
RootParameterTracker.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 <tracking/trackFindingVXD/analyzingTools/RootParameterTracker.h>
9
10using namespace Belle2;
11
12
14void RootParameterTracker::collectData4DoubleAlgorithms(std::string tcTypeName, const AnalizerTCInfo& aTC)
15{
16 auto* foundTCTypeData = m_algoDataDouble.find(tcTypeName); // a KeyValBox with all algorithms and data collected to given tcTypeName
17
18 // skip if there is nothing stored for this tcType:
19 if (foundTCTypeData == nullptr) { return; }
20
21 // looping over algorithms:
22 for (auto& entry : *foundTCTypeData) {
23 // increase readability:
24 auto* anAlgorithm = entry.second.first;
25 auto* dataVector = entry.second.second;
26 // sanity check: key has to be compatible with stored algorithm:
27 std::string algoName = anAlgorithm->getIDName();
28 if (entry.first != algoName) {
29 B2ERROR("RootParameterTracker::collectData4DoubleAlgorithms() key (" << entry.first <<
30 ") of container does not match to its content (" << algoName <<
31 ") - skipping entry! ");
32 continue;
33 }
34 B2DEBUG(21, "RootParameterTracker::collectData4DoubleAlgorithms(), executing algorithm of type: " << algoName <<
35 " with collected data-entries of " << dataVector->size());
36
37 try {
38 double calcVal = anAlgorithm->calcData(aTC);
39 dataVector->push_back(calcVal);
40 B2DEBUG(20, "RootParameterTracker::collectData4DoubleAlgorithms(), tc with type " << tcTypeName <<
41 " and applied algorithm " << algoName <<
42 " and got " << calcVal << " as a result!");
43 } catch (AnalyzingAlgorithm<double>::No_refTC_Attached& anException) {
44 B2WARNING("RootParameterTracker::collectData4DoubleAlgorithms(), Exception caught for tc with type " << tcTypeName <<
45 " and applied algorithm " << algoName <<
46 ". Failed with exception: " << anException.what() <<
47 " -> skipping tc!");
48 }
49 }// looping over algorithms
50}
51
52
53
54
55
57void RootParameterTracker::collectData4IntAlgorithms(std::string tcTypeName, const AnalizerTCInfo& aTC)
58{
59 auto* foundTCTypeData = m_algoDataInt.find(tcTypeName); // a KeyValBox with all algorithms and data collected to given tcTypeName
60
61 // skip if there is nothing stored for this tcType:
62 if (foundTCTypeData == nullptr) { return; }
63
64 // looping over algorithms:
65 for (auto& entry : *foundTCTypeData) {
66 // increase readability:
67 auto* anAlgorithm = entry.second.first;
68 auto* dataVector = entry.second.second;
69 // sanity check: key has to be compatible with stored algorithm:
70 std::string algoName = anAlgorithm->getIDName();
71 if (entry.first != algoName) {
72 B2ERROR("RootParameterTracker::collectData4DoubleAlgorithms() key (" << entry.first <<
73 ") of container does not match to its content (" << algoName <<
74 ") - skipping entry! ");
75 continue;
76 }
77 B2DEBUG(50, "RootParameterTracker::collectData4DoubleAlgorithms(), executing algorithm of type: " << algoName <<
78 " with collected data-entries of " << dataVector->size());
79
80 try {
81 int calcVal = anAlgorithm->calcData(aTC);
82 dataVector->push_back(calcVal);
83 B2DEBUG(20, "RootParameterTracker::collectData4DoubleAlgorithms(), tc with type " << tcTypeName <<
84 " and applied algorithm " << algoName <<
85 " and got " << calcVal << " as a result!");
86 } catch (AnalyzingAlgorithm<int>::No_refTC_Attached& anException) {
87 B2WARNING("RootParameterTracker::collectData4DoubleAlgorithms(), Exception caught for tc with type " << tcTypeName <<
88 " and applied algorithm " << algoName <<
89 ". Failed with exception: " << anException.what() <<
90 " -> skipping tc!");
91 }
92 }// looping over algorithms
93}
94
95
96
97
98
100void RootParameterTracker::collectData4VecDoubleAlgorithms(std::string tcTypeName, const AnalizerTCInfo& aTC)
101{
102 auto* foundTCTypeData = m_algoDataVecDouble.find(
103 tcTypeName); // a KeyValBox with all algorithms and data collected to given tcTypeName
104
105 // skip if there is nothing stored for this tcType:
106 if (foundTCTypeData == nullptr) { return; }
107
108 // looping over algorithms:
109 for (auto& entry : *foundTCTypeData) {
110 // increase readability:
111 auto* anAlgorithm = entry.second.first;
112 auto* dataVector = entry.second.second; // std::vector< vector < double>>
113 // sanity check: key has to be compatible with stored algorithm:
114 std::string algoName = anAlgorithm->getIDName();
115 if (entry.first != algoName) {
116 B2ERROR("RootParameterTracker::collectData4VecDoubleAlgorithms() key (" << entry.first <<
117 ") of container does not match to its content (" << algoName <<
118 ") - skipping entry! ");
119 continue;
120 }
121 B2DEBUG(50, "RootParameterTracker::collectData4VecDoubleAlgorithms(), executing algorithm of type: " << algoName <<
122 " with collected data-entries of " << dataVector->size());
123
124 try {
125 std::vector<double> calcVal = anAlgorithm->calcData(aTC);
126 dataVector->push_back(calcVal);
127 auto printVec = [&]() -> std::string {
128 std::string out;
129 for (double val : calcVal)
130 {
131 out += (" " + std::to_string(val));
132 }
133 return (out += "\n");
134 };
135 B2DEBUG(20, "RootParameterTracker::collectData4VecDoubleAlgorithms(), tc with type " << tcTypeName <<
136 " and applied algorithm " << algoName <<
137 " and got: " << printVec() <<
138 " as a result!");
139 } catch (AnalyzingAlgorithm<std::vector<double>>::No_refTC_Attached& anException) {
140 B2WARNING("RootParameterTracker::collectData4VecDoubleAlgorithms(), Exception caught for tc with type " << tcTypeName <<
141 " and applied algorithm " << algoName <<
142 ". Failed with exception: " << anException.what() <<
143 " -> skipping tc!");
144 }
145 }// looping over algorithms
146}
147
148
149
150
151
155void RootParameterTracker::addParameters4DoubleAlgorithms(std::string tcTypeName, std::string algorithmName)
156{
178 B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), given parameters are tcTypeName/algorithmName: " << tcTypeName
179 << "/" <<
180 algorithmName);
181
182 TTree* tree4tcType = prepareTTree(tcTypeName);
183
185 auto* algorithms4tcType = m_algoDataDouble.find(tcTypeName);
186 if (algorithms4tcType == nullptr) {
187 B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), tcType " << tcTypeName <<
188 " not yet added to m_algoDataDouble, doing it now...");
189 m_algoDataDouble.push_back({
190 tcTypeName,
191 StringKeyBox<std::pair<AnalyzingAlgorithm<double>*, std::vector<double>*> >()
192 });
193 algorithms4tcType = m_algoDataDouble.find(tcTypeName);
194 }
195 B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), m_algoDataDouble has " << m_algoDataDouble.size() <<
196 " tcTypes stored");
197
199 auto* data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
200 if (data4AlgorithmOftcType == nullptr) {
201 B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), algorithm " << algorithmName <<
202 " not yet added to m_algoDataDouble[tcType], doing it now...");
203 AnalyzingAlgorithm<double>* newAlgorithm = AnalyzingAlgorithmFactoryDouble<double, AnalizerTCInfo, ROOT::Math::XYZVector>
204 (AlgoritmType::getTypeEnum(algorithmName));
205 algorithms4tcType->push_back({
206 algorithmName,
207 {
208 newAlgorithm,
209 new std::vector<double>()
210 }
211 });
212 data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
213
215 auto* newBranch = tree4tcType->Branch(algorithmName.c_str(), data4AlgorithmOftcType->second);
216 if (newBranch == nullptr) B2ERROR("Could not create Branch " << algorithmName); // mainly to suppress compiler warning
217 // newBranch->Print();
218 } else {
219 B2WARNING("RootParameterTracker::addParameters4DoubleAlgorithms() given tcTypeName/algorithmName: " << tcTypeName <<
220 "/" << algorithmName <<
221 " was already added and will not be added again. This is a sign for unintended behavior - nothing will be added!");
222 }
223 B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), m_algoDataDouble[tcType] has " << algorithms4tcType->size() <<
224 " algorithms stored");
225}
226
227
228
229
230
234void RootParameterTracker::addParameters4IntAlgorithms(std::string tcTypeName, std::string algorithmName)
235{
236 B2DEBUG(5, "RootParameterTracker::addParameters4IntAlgorithms(), given parameters are tcTypeName/algorithmName: " << tcTypeName <<
237 "/" <<
238 algorithmName);
239
240 TTree* tree4tcType = prepareTTree(tcTypeName);
241
243 auto* algorithms4tcType = m_algoDataInt.find(tcTypeName);
244 if (algorithms4tcType == nullptr) {
245 B2DEBUG(5, "RootParameterTracker::addParameters4IntAlgorithms(), tcType " << tcTypeName <<
246 " not yet added to m_algoDataInt, doing it now...");
247 m_algoDataInt.push_back({
248 tcTypeName,
249 StringKeyBox<std::pair<AnalyzingAlgorithm<int>*, std::vector<int>*> >()
250 });
251 algorithms4tcType = m_algoDataInt.find(tcTypeName);
252 }
253 B2DEBUG(5, "RootParameterTracker::addParameters4IntAlgorithms(), m_algoDataInt has " << m_algoDataInt.size() << " tcTypes stored");
254
256 auto* data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
257 if (data4AlgorithmOftcType == nullptr) {
258 B2DEBUG(5, "RootParameterTracker::addParameters4IntAlgorithms(), algorithm " << algorithmName <<
259 " not yet added to m_algoDataInt[tcType], doing it now...");
260 AnalyzingAlgorithm<int>* newAlgorithm =
261 AnalyzingAlgorithmFactoryInt<int, AnalizerTCInfo, ROOT::Math::XYZVector>(AlgoritmType::getTypeEnum(algorithmName));
262
263 algorithms4tcType->push_back({
264 algorithmName,
265 {
266 newAlgorithm,
267 new std::vector<int>()
268 }
269 });
270 data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
271
273 auto* newBranch = tree4tcType->Branch(algorithmName.c_str(), data4AlgorithmOftcType->second);
274 if (newBranch == nullptr) B2ERROR("Could not create Branch " << algorithmName); // mainly to suppress compiler warning
275 // newBranch->Print();
276 } else {
277 B2WARNING("RootParameterTracker::addParameters4DoubleAlgorithms() given tcTypeName/algorithmName: " << tcTypeName <<
278 "/" << algorithmName <<
279 " was already added and will not be added again. This is a sign for unintended behavior - nothing will be added!");
280 }
281 B2DEBUG(5, "RootParameterTracker::addParameters4DoubleAlgorithms(), m_algoDataInt[tcType] has " << algorithms4tcType->size() <<
282 " algorithms stored");
283}
284
285
286
287
288
292void RootParameterTracker::addParameters4VecDoubleAlgorithms(std::string tcTypeName, std::string algorithmName)
293{
294 B2DEBUG(5, "RootParameterTracker::addParameters4VecDoubleAlgorithms(), given parameters are tcTypeName/algorithmName: " <<
295 tcTypeName << "/" <<
296 algorithmName);
297
298 TTree* tree4tcType = prepareTTree(tcTypeName);
299
301 auto* algorithms4tcType = m_algoDataVecDouble.find(tcTypeName);
302 if (algorithms4tcType == nullptr) {
303 B2DEBUG(5, "RootParameterTracker::addParameters4VecDoubleAlgorithms(), tcType " << tcTypeName <<
304 " not yet added to m_algoDataVecDouble, doing it now...");
305 m_algoDataVecDouble.push_back({
306 tcTypeName,
307 StringKeyBox<std::pair<AnalyzingAlgorithm<std::vector<double>>*, std::vector<std::vector<double>>*> >()
308 });
309 algorithms4tcType = m_algoDataVecDouble.find(tcTypeName);
310 }
311 B2DEBUG(5, "RootParameterTracker::addParameters4VecDoubleAlgorithms(), m_algoDataVecDouble has " << m_algoDataVecDouble.size() <<
312 " tcTypes stored");
313
315 auto* data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
316 if (data4AlgorithmOftcType == nullptr) {
317 B2DEBUG(5, "RootParameterTracker::addParameters4VecDoubleAlgorithms(), algorithm " << algorithmName <<
318 " not yet added to m_algoDataVecDouble[tcType], doing it now...");
319 AnalyzingAlgorithm<std::vector<double>>* newAlgorithm =
320 AnalyzingAlgorithmFactoryVecDouble<std::vector<double>, AnalizerTCInfo, ROOT::Math::XYZVector>
321 (AlgoritmType::getTypeEnum(algorithmName));
322 algorithms4tcType->push_back({
323 algorithmName,
324 {
325 newAlgorithm,
326 new std::vector<std::vector<double>>()
327 }
328 });
329 data4AlgorithmOftcType = algorithms4tcType->find(algorithmName);
330
332 auto* newBranch = tree4tcType->Branch(algorithmName.c_str(), data4AlgorithmOftcType->second);
333 if (newBranch == nullptr) B2ERROR("Could not create Branch " << algorithmName); // mainly to suppress compiler warning
334 // newBranch->Print();
335 } else {
336 B2WARNING("RootParameterTracker::addParameters4VecDoubleAlgorithms() given tcTypeName/algorithmName: " << tcTypeName <<
337 "/" << algorithmName <<
338 " was already added and will not be added again. This is a sign for unintended behavior - nothing will be added!");
339 }
340 B2DEBUG(5, "RootParameterTracker::addParameters4VecDoubleAlgorithms(), m_algoDataVecDouble[tcType] has " <<
341 algorithms4tcType->size() << " algorithms stored");
342}
Belle2::AlgoritmType::getTypeEnum
static AlgoritmType::Type getTypeEnum(std::string type)
for given string name of a AlgoritmType the corresponding AlgoritmType will be returned.
Definition: AlgoritmType.h:98
Belle2::AnalizerTCInfo
simple class storing infos relevant for a TC for analizing it.
Definition: AnalizerTCInfo.h:28
Belle2::AnalyzingAlgorithmBase
Base class for storing an algorithm determining the data one wants to have.
Definition: AnalyzingAlgorithmBase.h:31
Belle2::KeyValBox
Minimal container storing a pair of < KeyType, ValueType>
Definition: KeyValBox.h:24
Belle2::RootParameterTracker::m_algoDataInt
AlgoDataBox< int > m_algoDataInt
contains all algorithms and its data storing one int per TC
Definition: RootParameterTracker.h:85
Belle2::RootParameterTracker::addParameters4DoubleAlgorithms
void addParameters4DoubleAlgorithms(std::string tcTypeName, std::string algorithmName)
relevant for all algorithms storing one double per TC:
Definition: RootParameterTracker.cc:155
Belle2::RootParameterTracker::addParameters4VecDoubleAlgorithms
void addParameters4VecDoubleAlgorithms(std::string tcTypeName, std::string algorithmName)
relevant for all algorithms storing one vector of double per TC:
Definition: RootParameterTracker.cc:292
Belle2::RootParameterTracker::collectData4DoubleAlgorithms
void collectData4DoubleAlgorithms(std::string tcTypeName, const AnalizerTCInfo &aTC)
takes aTC with tcTypeName and applies the algorithms for it
Definition: RootParameterTracker.cc:14
Belle2::RootParameterTracker::collectData4IntAlgorithms
void collectData4IntAlgorithms(std::string tcTypeName, const AnalizerTCInfo &aTC)
takes aTC with tcTypeName and applies the algorithms for it
Definition: RootParameterTracker.cc:57
Belle2::RootParameterTracker::addParameters4IntAlgorithms
void addParameters4IntAlgorithms(std::string tcTypeName, std::string algorithmName)
relevant for all algorithms storing one int per TC:
Definition: RootParameterTracker.cc:234
Belle2::RootParameterTracker::prepareTTree
TTree * prepareTTree(std::string tcTypeName)
checks if ttree for given tcTypeName exists and creates it if not.
Definition: RootParameterTracker.h:97
Belle2::RootParameterTracker::collectData4VecDoubleAlgorithms
void collectData4VecDoubleAlgorithms(std::string tcTypeName, const AnalizerTCInfo &aTC)
takes aTC with tcTypeName and applies the algorithms for it
Definition: RootParameterTracker.cc:100
Belle2::RootParameterTracker::m_algoDataVecDouble
AlgoDataBox< std::vector< double > > m_algoDataVecDouble
contains all algorithms and its data storing one vector of double per TC
Definition: RootParameterTracker.h:89
Belle2::RootParameterTracker::m_algoDataDouble
AlgoDataBox< double > m_algoDataDouble
contains all algorithms and its data storing one double per TC
Definition: RootParameterTracker.h:81
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17