Belle II Software development
VariablesToNtupleModule.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#include <analysis/modules/VariablesToNtuple/VariablesToNtupleModule.h>
10
11// analysis
12#include <analysis/dataobjects/Particle.h>
13#include <analysis/dataobjects/ParticleList.h>
14#include <analysis/VariableManager/Utility.h>
15#include <analysis/dataobjects/StringWrapper.h>
16
17// framework
18#include <framework/logging/Logger.h>
19#include <framework/pcore/ProcHandler.h>
20#include <framework/core/ModuleParam.templateDetails.h>
21#include <framework/core/Environment.h>
22#include <framework/core/RandomNumbers.h>
23#include <framework/database/Database.h>
24
25// framework - root utilities
26#include <framework/utilities/MakeROOTCompatible.h>
27#include <framework/utilities/RootFileCreationManager.h>
28#include <framework/io/RootIOUtilities.h>
29
30#include <cmath>
31
32using namespace std;
33using namespace Belle2;
34using namespace RootIOUtilities;
35
36// Register module in the framework
37REG_MODULE(VariablesToNtuple);
38
39
41 Module(), m_tree("", DataStore::c_Persistent), m_outputFileMetaData("", DataStore::c_Persistent)
42{
43 //Set module properties
44 setDescription("Calculate variables specified by the user for a given ParticleList and save them into a TNtuple. The TNtuple is candidate-based, meaning that the variables of each candidate are saved into separate rows.");
46
47 vector<string> emptylist;
48 addParam("particleList", m_particleList,
49 "Name of particle list with reconstructed particles. If no list is provided the variables are saved once per event (only possible for event-type variables)",
50 std::string(""));
51 addParam("variables", m_variables,
52 "List of variables (or collections) to save. Variables are taken from Variable::Manager, and are identical to those available to e.g. ParticleSelector.",
53 emptylist);
54
55 addParam("fileName", m_fileName, "Name of ROOT file for output. Can be overridden using the -o argument of basf2.",
56 string("VariablesToNtuple.root"));
57 addParam("treeName", m_treeName, "Name of the NTuple in the saved file.", string("ntuple"));
58 addParam("basketSize", m_basketsize, "Size of baskets in Output NTuple in bytes.", 1600);
59
60 std::tuple<std::string, std::map<int, unsigned int>> default_sampling{"", {}};
61 addParam("sampling", m_sampling,
62 "Tuple of variable name and a map of integer values and inverse sampling rate. E.g. (signal, {1: 0, 0:10}) selects all signal candidates and every 10th background candidate.",
63 default_sampling);
64
65 addParam("signalSideParticleList", m_signalSideParticleList,
66 "Name of signal-side particle list to store the index of the signal-side particle when one calls the module in a for_each loop over the RestOfEvent",
67 std::string(""));
68
69 addParam("fileNameSuffix", m_fileNameSuffix, "The suffix of the output ROOT file to be appended before ``.root``.",
70 string(""));
71
72 addParam("useFloat", m_useFloat,
73 "Use float type for floating-point numbers.", false);
74
75 addParam("storeEventType", m_storeEventType,
76 "If true, the branch __eventType__ is added. The eventType information is available from MC16 on.", true);
77
78 addParam("dataDescription", m_dataDescription,
79 "Additional dictionary of "
80 "name->value pairs to be added to the file metadata to describe the data",
82
83 addParam("ignoreCommandLineOverride", m_ignoreCommandLineOverride,
84 "Ignore override of file name via command line argument -o. Useful if you have multiple output modules in one path.", false);
85
86}
87
89{
90 m_eventMetaData.isRequired();
91 if (not m_particleList.empty())
93
94 // Initializing the output root file
95
96 // override the output file name with what's been provided with the -o option
98 const std::string& outputFileArgument = Environment::Instance().getOutputFileOverride();
99 if (!outputFileArgument.empty())
100 m_fileName = outputFileArgument;
101 }
102
103 if (!m_fileNameSuffix.empty())
104 m_fileName = m_fileName.insert(m_fileName.rfind(".root"), m_fileNameSuffix);
105
106 if (m_fileName.empty()) {
107 B2FATAL("Output root file name is not set. Please set a valid root output file name (\"fileName\" module parameter).");
108 }
109 // See if there is already a file in which case add a new tree to it ...
110 // otherwise create a new file (all handled by framework)
112 if (!m_file) {
113 B2ERROR("Could not create file \"" << m_fileName <<
114 "\". Please set a valid root output file name (\"fileName\" module parameter).");
115 return;
116 }
117
118 TDirectory::TContext directoryGuard(m_file.get());
119
120 // check if TTree with that name already exists
121 if (m_file->Get(m_treeName.c_str()) || m_treeName == "persistent") {
122 B2FATAL("Tree with the name \"" << m_treeName
123 << "\" already exists in the file \"" << m_fileName << "\"\n"
124 << "or is reserved for FileMetaData.\n"
125 << "\nYou probably want to either set the output fileName or the treeName to something else:\n\n"
126 << " from modularAnalysis import variablesToNtuple\n"
127 << " variablesToNtuple('pi+:all', ['p'], treename='pions', filename='variablesToNtuple.root')\n"
128 << " variablesToNtuple('gamma:all', ['p'], treename='photons', filename='variablesToNtuple.root') # two trees, same file\n"
129 << "\n == Or ==\n"
130 << " from modularAnalysis import variablesToNtuple\n"
131 << " variablesToNtuple('pi+:all', ['p'], filename='pions.root')\n"
132 << " variablesToNtuple('gamma:all', ['p'], filename='photons.root') # two files\n"
133 );
134 return;
135 }
136
137 // set up tree and register it in the datastore
139 m_tree.construct(m_treeName.c_str(), "");
140 m_tree->get().SetCacheSize(100000);
141
144 m_outputFileMetaData.create();
145 }
147
148 // declare counter branches - pass through variable list, remove counters added by user
149 m_tree->get().Branch("__experiment__", &m_experiment, "__experiment__/I");
150 m_tree->get().Branch("__run__", &m_run, "__run__/I");
151 m_tree->get().Branch("__event__", &m_event, "__event__/i");
152 m_tree->get().Branch("__production__", &m_production, "__production__/I");
153 if (not m_particleList.empty()) {
154 m_tree->get().Branch("__candidate__", &m_candidate, "__candidate__/I");
155 m_tree->get().Branch("__ncandidates__", &m_ncandidates, "__ncandidates__/I");
156 }
157
158 if (not m_signalSideParticleList.empty()) {
160 m_tree->get().Branch("__signalSideCandidate__", &m_signalSideCandidate, "__signalSideCandidate__/I");
161 m_tree->get().Branch("__nSignalSideCandidates__", &m_nSignalSideCandidates, "__nSignalSideCandidates__/I");
162 if (not m_roe.isOptional("RestOfEvent")) {
163 B2WARNING("The signalSideParticleList is set outside of a for_each loop over the RestOfEvent. "
164 << "__signalSideCandidates__ and __nSignalSideCandidate__ will be always -1 and 0, respectively.");
165 }
166 }
167
168 if (m_stringWrapper.isOptional("MCDecayString"))
169 m_tree->get().Branch("__MCDecayString__", &m_MCDecayString);
170
171 if (m_storeEventType) {
172 m_tree->get().Branch("__eventType__", &m_eventType);
173 if (not m_eventExtraInfo.isOptional())
174 B2INFO("EventExtraInfo is not registered. __eventType__ will be empty. The eventType is available from MC16 on.");
175 }
176
177 for (const auto& variable : m_variables)
178 if (Variable::isCounterVariable(variable)) {
179 B2WARNING("The counter '" << variable
180 << "' is handled automatically by VariablesToNtuple, you don't need to add it.");
181 }
182
183 // declare branches and get the variable strings
185 // remove duplicates from list of variables but keep the previous order
186 unordered_set<string> seen;
187 auto newEnd = remove_if(m_variables.begin(), m_variables.end(), [&seen](const string & varStr) {
188 if (seen.find(varStr) != std::end(seen)) return true;
189 seen.insert(varStr);
190 return false;
191 });
192 m_variables.erase(newEnd, m_variables.end());
193
194 if (m_useFloat)
195 m_branchAddressesFloat.resize(m_variables.size() + 1);
196 else
197 m_branchAddressesDouble.resize(m_variables.size() + 1);
198 m_branchAddressesInt.resize(m_variables.size() + 1);
199 if (m_useFloat) {
200 m_tree->get().Branch("__weight__", &m_branchAddressesFloat[0], "__weight__/F");
201 } else {
202 m_tree->get().Branch("__weight__", &m_branchAddressesDouble[0], "__weight__/D");
203 }
204 size_t enumerate = 1;
205 for (const string& varStr : m_variables) {
206 string branchName = MakeROOTCompatible::makeROOTCompatible(varStr);
207
208 // Check for deprecated variables
210
211 // also collection function pointers
213 if (!var) {
214 B2ERROR("Variable '" << varStr << "' is not available in Variable::Manager!");
215 } else {
216 if (m_particleList.empty() && var->description.find("[Eventbased]") == string::npos) {
217 B2ERROR("Variable '" << varStr << "' is not an event-based variable, "
218 "but you are using VariablesToNtuple without a decay string, i.e. in the event-wise mode.\n"
219 "If you have created an event-based alias you can wrap your alias with `eventCached` to "
220 "declare it as event based, which avoids this error.\n\n"
221 "vm.addAlias('myAliasName', 'eventCached(myAlias)')");
222 continue;
223 }
224 if (var->variabletype == Variable::Manager::VariableDataType::c_double) {
225 if (m_useFloat) {
226 m_tree->get().Branch(branchName.c_str(), &m_branchAddressesFloat[enumerate], (branchName + "/F").c_str());
227 } else {
228 m_tree->get().Branch(branchName.c_str(), &m_branchAddressesDouble[enumerate], (branchName + "/D").c_str());
229 }
230 } else if (var->variabletype == Variable::Manager::VariableDataType::c_int) {
231 m_tree->get().Branch(branchName.c_str(), &m_branchAddressesInt[enumerate], (branchName + "/I").c_str());
232 } else if (var->variabletype == Variable::Manager::VariableDataType::c_bool) {
233 m_tree->get().Branch(branchName.c_str(), &m_branchAddressesInt[enumerate], (branchName + "/O").c_str());
234 }
235 m_functions.push_back(std::make_pair(var->function, var->variabletype));
236 }
237 enumerate++;
238 }
239 m_tree->get().SetBasketSize("*", m_basketsize);
240
241 m_sampling_name = std::get<0>(m_sampling);
242 m_sampling_rates = std::get<1>(m_sampling);
243
244 if (m_sampling_name != "") {
246 if (m_sampling_variable == nullptr) {
247 B2FATAL("Couldn't find sample variable " << m_sampling_name << " via the Variable::Manager. Check the name!");
248 }
249 for (const auto& pair : m_sampling_rates)
250 m_sampling_counts[pair.first] = 0;
251 } else {
252 m_sampling_variable = nullptr;
253 }
254
255}
256
257
259{
260 if (m_sampling_variable == nullptr)
261 return 1.0;
262
263 long target = 0;
264 if (m_sampling_variable->variabletype == Variable::Manager::VariableDataType::c_double) {
265 target = std::lround(std::get<double>(m_sampling_variable->function(particle)));
266 } else if (m_sampling_variable->variabletype == Variable::Manager::VariableDataType::c_int) {
267 target = std::lround(std::get<int>(m_sampling_variable->function(particle)));
268 } else if (m_sampling_variable->variabletype == Variable::Manager::VariableDataType::c_bool) {
269 target = std::lround(std::get<bool>(m_sampling_variable->function(particle)));
270 }
271 if (m_sampling_rates.find(target) != m_sampling_rates.end() and m_sampling_rates[target] > 0) {
272 m_sampling_counts[target]++;
273 if (m_sampling_counts[target] % m_sampling_rates[target] != 0)
274 return 0;
275 else {
276 m_sampling_counts[target] = 0;
277 return m_sampling_rates[target];
278 }
279 }
280 return 1.0;
281}
282
284{
285 m_event = m_eventMetaData->getEvent();
286 m_run = m_eventMetaData->getRun();
287 m_experiment = m_eventMetaData->getExperiment();
288 m_production = m_eventMetaData->getProduction();
289
290 if (m_experimentLow > m_experimentHigh) { //starting condition
294 } else {
296 ((m_experiment == m_experimentLow) && ((m_run < m_runLow) || ((m_run == m_runLow) && (m_event < m_eventLow))))) {
298 m_runLow = m_run;
300 }
306 }
307 }
308
309 if (m_inputFileMetaData.isValid()) {
310 std::string lfn = m_inputFileMetaData->getLfn();
311 if (not lfn.empty() and (m_parentLfns.empty() or (m_parentLfns.back() != lfn))) {
312 m_parentLfns.push_back(lfn);
313 }
314 }
315
316 // check if the event is a full event or not: if yes, increase the counter
317 if (m_eventMetaData->getErrorFlag() == 0) // no error flag -> this is a full event
318 m_eventCount++;
319
320 if (m_stringWrapper.isValid())
321 m_MCDecayString = m_stringWrapper->getString();
322 else
323 m_MCDecayString = "";
324
325 if (m_storeEventType and m_eventExtraInfo.isValid())
326 m_eventType = m_eventExtraInfo->getEventType();
327 else
328 m_eventType = "";
329
330 if (not m_signalSideParticleList.empty()) {
331 if (m_roe.isValid()) {
333 auto signal = m_roe->getRelatedFrom<Particle>();
334 m_signalSideCandidate = signaSideParticleList->getIndex(signal);
335 m_nSignalSideCandidates = signaSideParticleList->getListSize();
336 } else {
339 }
340 }
341
342 if (m_particleList.empty()) {
343 double weight = getInverseSamplingRateWeight(nullptr);
344 if (m_useFloat) {
345 m_branchAddressesFloat[0] = weight;
346 } else {
347 m_branchAddressesDouble[0] = weight;
348 }
349 if (weight > 0) {
350 for (unsigned int iVar = 0; iVar < m_variables.size(); iVar++) {
351 auto var_result = std::get<0>(m_functions[iVar])(nullptr);
352 auto var_type = std::get<1>(m_functions[iVar]);
353 if (std::holds_alternative<double>(var_result)) {
354 if (var_type != Variable::Manager::VariableDataType::c_double)
355 B2WARNING("Wrong registered data type for variable '" + m_variables[iVar] +
356 "'. Expected Variable::Manager::VariableDataType::c_double. Exported data for this variable might be incorrect.");
357 if (m_useFloat) {
358 m_branchAddressesFloat[iVar + 1] = std::get<double>(var_result);
359 } else {
360 m_branchAddressesDouble[iVar + 1] = std::get<double>(var_result);
361 }
362 } else if (std::holds_alternative<int>(var_result)) {
363 if (var_type != Variable::Manager::VariableDataType::c_int)
364 B2WARNING("Wrong registered data type for variable '" + m_variables[iVar] +
365 "'. Expected Variable::Manager::VariableDataType::c_int. Exported data for this variable might be incorrect.");
366 m_branchAddressesInt[iVar + 1] = std::get<int>(var_result);
367 } else if (std::holds_alternative<bool>(var_result)) {
368 if (var_type != Variable::Manager::VariableDataType::c_bool)
369 B2WARNING("Wrong registered data type for variable '" + m_variables[iVar] +
370 "'. Expected Variable::Manager::VariableDataType::c_bool. Exported data for this variable might be incorrect.");
371 m_branchAddressesInt[iVar + 1] = std::get<bool>(var_result);
372 }
373 }
374 m_tree->get().Fill();
375 }
376
377 } else {
379 m_ncandidates = particlelist->getListSize();
380 for (unsigned int iPart = 0; iPart < m_ncandidates; iPart++) {
381 m_candidate = iPart;
382 const Particle* particle = particlelist->getParticle(iPart);
383 double weight = getInverseSamplingRateWeight(particle);
384 if (m_useFloat) {
385 m_branchAddressesFloat[0] = weight;
386 } else {
387 m_branchAddressesDouble[0] = weight;
388 }
389 if (weight > 0) {
390 for (unsigned int iVar = 0; iVar < m_variables.size(); iVar++) {
391 auto var_result = std::get<0>(m_functions[iVar])(particle);
392 auto var_type = std::get<1>(m_functions[iVar]);
393 if (std::holds_alternative<double>(var_result)) {
394 if (var_type != Variable::Manager::VariableDataType::c_double)
395 B2WARNING("Wrong registered data type for variable '" + m_variables[iVar] +
396 "'. Expected Variable::Manager::VariableDataType::c_double. Exported data for this variable might be incorrect.");
397 if (m_useFloat) {
398 m_branchAddressesFloat[iVar + 1] = std::get<double>(var_result);
399 } else {
400 m_branchAddressesDouble[iVar + 1] = std::get<double>(var_result);
401 }
402 } else if (std::holds_alternative<int>(var_result)) {
403 if (var_type != Variable::Manager::VariableDataType::c_int)
404 B2WARNING("Wrong registered data type for variable '" + m_variables[iVar] +
405 "'. Expected Variable::Manager::VariableDataType::c_int. Exported data for this variable might be incorrect.");
406 m_branchAddressesInt[iVar + 1] = std::get<int>(var_result);
407 } else if (std::holds_alternative<bool>(var_result)) {
408 if (var_type != Variable::Manager::VariableDataType::c_bool)
409 B2WARNING("Wrong registered data type for variable '" + m_variables[iVar] +
410 "'. Expected Variable::Manager::VariableDataType::c_bool. Exported data for this variable might be incorrect.");
411 m_branchAddressesInt[iVar + 1] = std::get<bool>(var_result);
412 }
413 }
414 m_tree->get().Fill();
415 }
416 }
417 }
418}
419
421{
422
423 FileMetaData outputFileMetaData;
424 bool isMC = (m_inputFileMetaData) ? m_inputFileMetaData->isMC() : true;
425 if (!isMC) outputFileMetaData.declareRealData();
426
427 outputFileMetaData.setLow(m_experimentLow, m_runLow, m_eventLow);
428 outputFileMetaData.setHigh(m_experimentHigh, m_runHigh, m_eventHigh);
429 outputFileMetaData.setNEvents(m_tree->get().GetEntries());
430 outputFileMetaData.setNFullEvents(m_eventCount);
431
432 //fill more file level metadata
433 RootIOUtilities::setCreationData(outputFileMetaData);
434 outputFileMetaData.setRandomSeed(RandomNumbers::getSeed());
435 outputFileMetaData.setSteering(Environment::Instance().getSteering());
436 auto mcEvents = Environment::Instance().getNumberOfMCEvents();
437 outputFileMetaData.setMcEvents(mcEvents);
438 outputFileMetaData.setDatabaseGlobalTag(Database::Instance().getGlobalTags());
439 for (const auto& item : m_dataDescription) {
440 m_outputFileMetaData->setDataDescription(item.first, item.second);
441 }
442 for (const auto& item : m_outputFileMetaData->getDataDescription()) {
443 outputFileMetaData.setDataDescription(item.first, item.second);
444 }
445 outputFileMetaData.setDataDescription("isNtupleMetaData", "True");
446 std::sort(m_parentLfns.begin(), m_parentLfns.end());
447 m_parentLfns.erase(std::unique(m_parentLfns.begin(), m_parentLfns.end()), m_parentLfns.end());
448 outputFileMetaData.setParents(m_parentLfns);
449 outputFileMetaData.setLfn(m_file->GetName());
450
451 TTree* persistent = new TTree(c_treeNames[DataStore::c_Persistent].c_str(), c_treeNames[DataStore::c_Persistent].c_str());
452 persistent->Branch("FileMetaData", &outputFileMetaData);
453 persistent->Fill();
454 persistent->Write("persistent", TObject::kWriteDelete);
455}
456
458{
460
461 TDirectory::TContext directoryGuard(m_file.get());
463
464 B2INFO("Writing NTuple " << m_treeName);
465 m_tree->write(m_file.get());
466
467 const bool writeError = m_file->TestBit(TFile::kWriteError);
468 m_file.reset();
469 if (writeError) {
470 B2FATAL("A write error occurred while saving '" << m_fileName << "', please check if enough disk space is available.");
471 }
472 }
473}
In the store you can park objects that have to be accessed by various modules.
Definition DataStore.h:51
@ c_DontWriteOut
Object/array should be NOT saved by output modules.
Definition DataStore.h:71
@ c_Persistent
Object is available during entire execution time.
Definition DataStore.h:60
unsigned int getNumberOfMCEvents() const
Number of generated events (from EventInfoSetter).
const std::string & getOutputFileOverride() const
Return overridden output file name, or "" if none was set.
static Environment & Instance()
Static method to get a reference to the Environment instance.
Metadata information about a file.
void setLow(int experiment, int run, unsigned int event)
Lowest experiment, run and event number setter.
void setHigh(int experiment, int run, unsigned int event)
Highest experiment, run and event number setter.
void setRandomSeed(const std::string &seed)
Random seed setter.
void setSteering(const std::string &steering)
Steering file content setter.
void declareRealData()
Declare that this is not generated, but real data.
void setNFullEvents(unsigned int nEvents)
Number of full events setter.
void setDatabaseGlobalTag(const std::string &globalTag)
Set the database global tag used when creating this file.
void setLfn(const std::string &lfn)
Setter for LFN.
void setDataDescription(const std::string &key, const std::string &value)
describe the data, if the key exists contents will be overwritten.
void setNEvents(unsigned int nEvents)
Number of events setter.
void setMcEvents(unsigned int nEvents)
Number of generated events setter.
void setParents(const std::vector< std::string > &parents)
Parents setter.
static std::string makeROOTCompatible(std::string str)
Remove special characters that ROOT dislikes in branch names, e.g.
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
@ c_TerminateInAllProcesses
When using parallel processing, call this module's terminate() function in all processes().
Definition Module.h:83
Class to store reconstructed particles.
Definition Particle.h:76
static bool isOutputProcess()
Return true if the process is an output process.
static bool parallelProcessingUsed()
Returns true if multiple processes have been spawned, false in single-core mode.
static std::string getSeed()
Get the random number generator seed.
bool isRequired(const std::string &name="")
Ensure this array/object has been registered previously.
Type-safe access to single objects in the data store.
Definition StoreObjPtr.h:96
std::vector< std::string > resolveCollections(const std::vector< std::string > &variables)
Resolve Collection Returns variable names corresponding to the given collection or if it is not a col...
Definition Manager.cc:180
const Var * getVariable(std::string name)
Get the variable belonging to the given key.
Definition Manager.cc:58
static Manager & Instance()
get singleton instance.
Definition Manager.cc:26
void checkDeprecatedVariable(const std::string &name)
Check if a variable is deprecated.
Definition Manager.cc:444
StoreObjPtr< RestOfEvent > m_roe
ROE object.
StoreObjPtr< FileMetaData > m_inputFileMetaData
Pointer to the input file meta data.
bool m_useFloat
Use float type for floating-point numbers.
void fillFileMetaData()
Create and fill FileMetaData object.
std::vector< std::string > m_variables
List of variables to save.
std::vector< float > m_branchAddressesFloat
Branch addresses of variables of type float.
virtual void initialize() override
Initialises the module.
std::map< int, unsigned int > m_sampling_rates
Inverse sampling rates.
virtual void event() override
Method called for each event.
unsigned int m_ncandidates
total n candidates
virtual void terminate() override
Write TTree to file, and close file if necessary.
StoreObjPtr< EventMetaData > m_eventMetaData
the event information
std::map< std::string, std::string > m_dataDescription
Additional metadata description.
std::map< int, unsigned long int > m_sampling_counts
Current number of samples with this value.
std::string m_fileName
Name of ROOT file for output.
std::vector< std::pair< Variable::Manager::FunctionPtr, Variable::Manager::VariableDataType > > m_functions
List of pairs of function pointers and respective data type corresponding to given variables.
std::tuple< std::string, std::map< int, unsigned int > > m_sampling
Tuple of variable name and a map of integer values and inverse sampling rate.
std::vector< int > m_branchAddressesInt
Branch addresses of variables of type int (or bool)
int m_basketsize
Size of TBaskets in the output ROOT file in bytes.
int m_production
production ID (to distinguish MC samples)
unsigned int m_nSignalSideCandidates
total n signal-side candidates
unsigned int m_eventCount
event counter
StoreObjPtr< StringWrapper > m_stringWrapper
string wrapper storing the MCDecayString
bool m_storeEventType
If true, the branch eventType is added.
std::string m_particleList
Name of particle list with reconstructed particles.
bool m_ignoreCommandLineOverride
if true, ignore override of filename
std::string m_eventType
EventType to be filled.
StoreObjPtr< FileMetaData > m_outputFileMetaData
File meta data to be stored in the output ntuple file.
StoreObjPtr< RootMergeable< TTree > > m_tree
The ROOT TNtuple for output.
std::shared_ptr< TFile > m_file
ROOT file for output.
std::vector< double > m_branchAddressesDouble
Branch addresses of variables of type double.
std::string m_sampling_name
Variable name of sampling variable.
float getInverseSamplingRateWeight(const Particle *particle)
Calculate inverse sampling rate weight.
int m_experimentLow
lowest experiment number
StoreObjPtr< EventExtraInfo > m_eventExtraInfo
pointer to EventExtraInfo
std::string m_treeName
Name of the TTree.
std::string m_signalSideParticleList
Name of signal-side particle list.
const Variable::Manager::Var * m_sampling_variable
Variable Pointer to target variable.
int m_experimentHigh
highest experiment number
int m_signalSideCandidate
signal-side candidate counter
std::vector< std::string > m_parentLfns
Vector of parent file LFNs.
std::string m_fileNameSuffix
Suffix to be appended to the output file name.
std::string m_MCDecayString
MC decay string to be filled.
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
std::shared_ptr< TFile > getFile(std::string, bool ignoreErrors=false)
Get a file with a specific name, if is does not exist it will be created.
static Database & Instance()
Instance of a singleton Database.
Definition Database.cc:41
static RootFileCreationManager & getInstance()
Interface for the FileManager.
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition Module.h:649
Some constants and helpers common to the RootInput and RootOutput modules.
const std::string c_treeNames[]
Names of trees.
void setCreationData(FileMetaData &metadata)
Fill the creation info of a file meta data: site, user, data.
Abstract base class for different kinds of events.
STL namespace.
A variable returning a floating-point value for a given Particle.
Definition Manager.h:145