ATLAS Offline Software
Loading...
Searching...
No Matches
LArSamples::TreeAccessor Class Reference

#include <TreeAccessor.h>

Inheritance diagram for LArSamples::TreeAccessor:
Collaboration diagram for LArSamples::TreeAccessor:

Public Member Functions

 TreeAccessor (TTree &cellTree, TTree &scTree, TTree &eventTree, TTree *runTree, TFile *file)
 Constructor.
 TreeAccessor (const TString &fileName)
virtual ~TreeAccessor ()
virtual bool writeToFile (const TString &fileName) const override
virtual unsigned int historySize (unsigned int i) const override
virtual unsigned int historySizeSC (unsigned int i) const override
virtual unsigned int nEvents () const override
virtual const EventData * eventData (unsigned int i) const override
virtual unsigned int nRuns () const override
virtual const RunData * runData (unsigned int i) const override
void add (HistoryContainer *cont)
virtual std::unique_ptr< const History > getCellHistory (unsigned int i) const override
virtual std::unique_ptr< const History > getSCHistory (unsigned int i) const override
virtual std::unique_ptr< const CellInfo > getCellInfo (unsigned int i) const override
std::unique_ptr< const CellInfo > getSCInfo (unsigned int i) const
virtual std::unique_ptr< const History > newCellHistory (unsigned int i) const
virtual const History * cellHistory (unsigned int i) const
virtual std::unique_ptr< const CellInfo > cellInfo (unsigned int i) const
virtual unsigned int nChannels () const
virtual unsigned int nChannelsSC () const
virtual void resetCache () const
const CellInfo * cellInfoCache (unsigned int i) const
const History * pass (unsigned int i, const FilterParams &f) const
const History * cellCache () const
unsigned int cachePos () const
bool save () const
const TTree & cellTree () const
const TTree & SCTree () const
const TTree & eventTree () const
const TTree & runTree () const
TFile * file () const
TString fileName () const
const HistoryContainer * historyContainer (unsigned int i) const
const HistoryContainer * historyContainerSC (unsigned int i) const
void addSC (HistoryContainer *cont)
void addEvent (EventData *eventData)
void addRun (RunData *runData)
HistoryContainer * currentContainer () const
HistoryContainer * currentContainerSC () const
int getCellEntry (unsigned int i) const
int getSCEntry (unsigned int i) const

Static Public Member Functions

static std::unique_ptr< TreeAccessor > open (const TString &fileName)
static std::unique_ptr< TreeAccessor > merge (const std::vector< const Accessor * > &accessors, const TString &fileName="")
static std::unique_ptr< TreeAccessor > merge (const std::vector< const Accessor * > &accessors, const TString &fileName, const TString &LBFile)
static std::unique_ptr< TreeAccessor > filter (const Accessor &accessor, const FilterParams &filterParams, const TString &fileName, const DataTweaker &tweaker)
static std::vector< std::unique_ptr< TreeAccessor > > filter (const Accessor &accessor, const FilterList &filterList, const DataTweaker &tweaker)
static std::unique_ptr< TreeAccessor > makeTemplate (const Accessor &accessor, const TString &fileName)
static PersistentAccessor * merge (const std::vector< const PersistentAccessor * > &accessors, const TString &fileName)
static PersistentAccessor * merge (const std::vector< TString > &inputFiles, const TString &fileName)

Private Attributes

unsigned int m_pos
std::unique_ptr< const History > m_cellCache
std::vector< std::unique_ptr< CellInfo > > m_cellInfoCache
TTree * m_cellTree
TTree * m_SCTree
TTree * m_eventTree
TTree * m_runTree
TFile * m_file
HistoryContainer * m_historyCont
HistoryContainer * m_historyContSC
EventData * m_eventData
RunData * m_runData
std::map< unsigned int, const RunData * > m_runCache

Friends

class Interface

Detailed Description

Definition at line 32 of file TreeAccessor.h.

Constructor & Destructor Documentation

◆ TreeAccessor() [1/2]

LArSamples::TreeAccessor::TreeAccessor ( TTree & cellTree,
TTree & scTree,
TTree & eventTree,
TTree * runTree,
TFile * file )
inline

Constructor.

Definition at line 37 of file TreeAccessor.h.

PersistentAccessor(TTree &cellTree, TTree &SCTree, TTree &eventTree, TTree *runTree, TFile *file)
Constructor.

◆ TreeAccessor() [2/2]

LArSamples::TreeAccessor::TreeAccessor ( const TString & fileName)
inline

Definition at line 40 of file TreeAccessor.h.

◆ ~TreeAccessor()

virtual LArSamples::TreeAccessor::~TreeAccessor ( )
inlinevirtual

Definition at line 44 of file TreeAccessor.h.

44{ resetCache(); }
virtual void resetCache() const

Member Function Documentation

◆ add()

void LArSamples::TreeAccessor::add ( HistoryContainer * cont)
inline

Definition at line 72 of file TreeAccessor.h.

void add(HistoryContainer *cont)

◆ addEvent()

void PersistentAccessor::addEvent ( EventData * eventData)
inherited

Definition at line 175 of file PersistentAccessor.cxx.

176{
178 m_eventTree->Fill();
179 m_eventData = nullptr;
180}
const EventData * eventData(unsigned int i) const

◆ addRun()

void PersistentAccessor::addRun ( RunData * runData)
inherited

Definition at line 183 of file PersistentAccessor.cxx.

184{
186 m_runTree->Fill();
187 m_runData = nullptr;
188}
const RunData * runData(unsigned int i) const

◆ addSC()

void PersistentAccessor::addSC ( HistoryContainer * cont)
inherited

Definition at line 167 of file PersistentAccessor.cxx.

168{
169 m_historyContSC = cont;
170 m_SCTree->Fill();
171 m_historyContSC = nullptr;
172}

◆ cachePos()

unsigned int LArSamples::AbsLArCells::cachePos ( ) const
inlineinherited

Definition at line 49 of file AbsLArCells.h.

49{ return m_pos; }

◆ cellCache()

const History * LArSamples::AbsLArCells::cellCache ( ) const
inlineinherited

Definition at line 48 of file AbsLArCells.h.

48{ return m_cellCache.get(); }
std::unique_ptr< const History > m_cellCache
Definition AbsLArCells.h:55

◆ cellHistory()

const History * AbsLArCells::cellHistory ( unsigned int i) const
virtualinherited

Reimplemented in LArSamples::Interface.

Definition at line 54 of file AbsLArCells.cxx.

55{
56 if (m_pos == i) return m_cellCache.get();
57 resetCache();
58 std::unique_ptr<const History> history = newCellHistory(i);
59 if (!history) return nullptr;
60 m_cellCache = std::move(history);
61 m_pos = i;
62 return m_cellCache.get();
63}
virtual std::unique_ptr< const History > newCellHistory(unsigned int i) const

◆ cellInfo()

std::unique_ptr< const CellInfo > AbsLArCells::cellInfo ( unsigned int i) const
virtualinherited

Definition at line 66 of file AbsLArCells.cxx.

67{
68 const CellInfo* info = cellInfoCache(i);
69 if (info) {
70 if (info->isValid()) {
71 return std::make_unique<CellInfo> (*info);
72 }
73 return nullptr;
74 }
75 std::unique_ptr<const CellInfo> infop = getCellInfo(i);
76 if (infop) m_cellInfoCache[i] = std::make_unique<CellInfo>(*infop, false);
77 return infop;
78}
virtual std::unique_ptr< const CellInfo > getCellInfo(unsigned int i) const
std::vector< std::unique_ptr< CellInfo > > m_cellInfoCache
Definition AbsLArCells.h:56
const CellInfo * cellInfoCache(unsigned int i) const

◆ cellInfoCache()

const CellInfo * AbsLArCells::cellInfoCache ( unsigned int i) const
inherited

Definition at line 81 of file AbsLArCells.cxx.

82{
83 return m_cellInfoCache[i].get();
84}

◆ cellTree()

const TTree & LArSamples::PersistentAccessor::cellTree ( ) const
inlineinherited

Definition at line 44 of file PersistentAccessor.h.

◆ currentContainer()

HistoryContainer * LArSamples::PersistentAccessor::currentContainer ( ) const
inlineinherited

Definition at line 66 of file PersistentAccessor.h.

66{ return m_historyCont; }

◆ currentContainerSC()

HistoryContainer * LArSamples::PersistentAccessor::currentContainerSC ( ) const
inlineinherited

Definition at line 67 of file PersistentAccessor.h.

67{ return m_historyContSC; }

◆ eventData()

virtual const EventData * LArSamples::TreeAccessor::eventData ( unsigned int i) const
inlineoverridevirtual

Implements LArSamples::Accessor.

Definition at line 67 of file TreeAccessor.h.

◆ eventTree()

const TTree & LArSamples::PersistentAccessor::eventTree ( ) const
inlineinherited

Definition at line 46 of file PersistentAccessor.h.

46{ return *m_eventTree; }

◆ file()

TFile * LArSamples::PersistentAccessor::file ( ) const
inlineinherited

Definition at line 49 of file PersistentAccessor.h.

◆ fileName()

TString PersistentAccessor::fileName ( ) const
inherited

Definition at line 154 of file PersistentAccessor.cxx.

155{
156 return (m_file ? m_file->GetName() : "");
157}

◆ filter() [1/2]

std::vector< std::unique_ptr< TreeAccessor > > TreeAccessor::filter ( const Accessor & accessor,
const FilterList & filterList,
const DataTweaker & tweaker )
static

Definition at line 361 of file TreeAccessor.cxx.

364{
365 std::vector<std::unique_ptr<TreeAccessor> > newAccessors;
366
367 if (filterList.size() == 0) {
368 cout << "No filter categories specified, done! (?)" << endl;
369 return newAccessors;
370 }
371
372 for (unsigned int f = 0; f < filterList.size(); f++) {
373 cout << "Skimming to " << filterList.fileName(f) << endl;
374 if (!gSystem->AccessPathName(filterList.fileName(f))) {
375 cout << "File already exists, exiting." << endl;
376 return newAccessors;
377 }
378 }
379
380 for (unsigned int f = 0; f < filterList.size(); f++)
381 newAccessors.push_back(std::make_unique<TreeAccessor>(filterList.fileName(f)));
382 std::map<std::pair<unsigned int, unsigned int>, unsigned int> eventIndices;
383 std::vector< std::map<unsigned int, unsigned int> > eventsToKeep(filterList.size());
384 std::vector< std::map<unsigned int, unsigned int> > runsToKeep(filterList.size());
385
386 double nTot = 0, nPass = 0;
387
388 for (unsigned int i = 0; i < accessor.nEvents(); i++) {
389 const EventData* eventData = accessor.eventData(i);
390 eventIndices[std::pair<unsigned int, unsigned int>(eventData->run(), eventData->event())] = i;
391 }
392
393 for (unsigned int i = 0; i < accessor.nChannels(); i++) {
394 if (i % 25000 == 0) {
395 cout << "Filtering " << i << "/" << accessor.nChannels()
396 << " (passing so far = " << nPass << ", total seen = " << nTot << ")" << endl;
397 //ClassCounts::printCountsTable();
398 }
399 bool first = true;
400
401 const History* history = nullptr;
402 for (unsigned int f = 0; f < filterList.size(); f++) {
403 history = accessor.pass(i, filterList.filterParams(f));
404 if (history) break;
405 }
406 for (unsigned int f = 0; f < filterList.size(); f++) {
407 if (!history || !history->cellInfo() || !filterList.filterParams(f).passCell(*history->cellInfo())) {
408 HistoryContainer newHist;
409 newAccessors[f]->add(&newHist);
410 continue;
411 }
412 if (first) { nTot += history->nData(); first = false; }
413 HistoryContainer newHist(new CellInfo(*history->cellInfo()));
414 for (unsigned int k = 0; k < history->nData(); k++) {
415 if (!filterList.filterParams(f).passEvent(*history->data(k))) continue;
416 const EventData& eventData = history->data(k)->eventData();
417 std::map<std::pair<unsigned int, unsigned int>, unsigned int>::const_iterator findIndex =
418 eventIndices.find(std::pair<unsigned int, unsigned int>(eventData.run(), eventData.event()));
419 if (findIndex == eventIndices.end()) {
420 cout << "Inconsistent event numbering!!!" << endl;
421 return std::vector<std::unique_ptr<TreeAccessor> >();
422 }
423 int oldEvtIndex = findIndex->second;
424 bool isNewEvt = (eventsToKeep[f].find(oldEvtIndex) == eventsToKeep[f].end());
425 unsigned int newEvtIndex = (isNewEvt ? eventsToKeep[f].size() : eventsToKeep[f][oldEvtIndex]);
426 if (isNewEvt) eventsToKeep[f][oldEvtIndex] = newEvtIndex;
427
428 int oldRunIndex = history->data(k)->eventData().runIndex();
429 bool isNewRun = (runsToKeep[f].find(oldRunIndex) == runsToKeep[f].end());
430 unsigned int newRunIndex = (isNewRun ? runsToKeep[f].size() : runsToKeep[f][oldRunIndex]);
431 if (isNewRun) runsToKeep[f][oldRunIndex] = newRunIndex;
432
433 std::unique_ptr<Data> newData = tweaker.tweak(*history->data(k), newEvtIndex);
434 if (!newData) {
435 cout << "Filtering failed on data " << k << " of cell " << i << ", aborting" << endl;
436 return std::vector<std::unique_ptr<TreeAccessor> >();
437 }
438 nPass++;
439 newHist.add(newData.release()->dissolve());
440 }
441 newAccessors[f]->add(&newHist);
442 }
443 }
444
445 for (unsigned int f = 0; f < filterList.size(); f++) {
446 cout << "Adding runs..." << endl;
447 std::vector<unsigned int> runsToKeep_ordered(runsToKeep[f].size());
448 for (const auto& runIndex : runsToKeep[f])
449 runsToKeep_ordered[runIndex.second] = runIndex.first;
450
451 for (unsigned int runIndex : runsToKeep_ordered) {
452 RunData newRun(*accessor.runData(runIndex));
453 newAccessors[f]->addRun(&newRun);
454 }
455 cout << "Adding events..." << endl;
456 std::vector<unsigned int> eventsToKeep_ordered(eventsToKeep[f].size());
457 for (const auto& eventIndex : eventsToKeep[f])
458 eventsToKeep_ordered[eventIndex.second] = eventIndex.first;
459
460 for (unsigned int eventIndex : eventsToKeep_ordered) {
461 std::map<unsigned int, unsigned int>::const_iterator idx = runsToKeep[f].find(accessor.eventData(eventIndex)->runIndex());
462 int newRunIndex = (idx == runsToKeep[f].end() ? 0 : idx->second);
463 std::unique_ptr<EventData> newEvent (tweaker.tweak(*accessor.eventData(eventIndex), newRunIndex));
464 newAccessors[f]->addEvent(newEvent.get());
465 }
466 }
467 cout << "Filtering done! final size = " << nPass << endl;
468 //ClassCounts::printCountsTable();
469 for (unsigned int f = 0; f < filterList.size(); f++) {
470 cout << "Saving " << newAccessors[f]->fileName() << endl;
471 newAccessors[f]->save();
472 }
473 return newAccessors;
474}
size_t size() const
Number of registered mappings.
std::unique_ptr< Data > tweak(const Data &data, int evtIndex=-1) const
const EventData & eventData() const
Definition Data.h:97
int runIndex() const
Definition EventData.h:53
unsigned int size() const
Definition FilterList.h:29
const FilterParams & filterParams(unsigned int i) const
Definition FilterList.h:30
const TString & fileName(unsigned int i) const
Definition FilterList.h:31
bool passCell(const CellInfo &info) const
bool passEvent(const Data &data) const
const CellInfo * cellInfo() const
Definition History.h:59
const Data * data(unsigned int i) const
Definition History.cxx:88
unsigned int nData() const
Definition History.h:54
virtual const EventData * eventData(unsigned int i) const override
bool first
Definition DeMoScan.py:534
event_number_t eventIndex
const AccessorWrapper< T > * accessor(xAOD::JetAttribute::AttributeID id)
Returns an attribute accessor corresponding to an AttributeID.

◆ filter() [2/2]

std::unique_ptr< TreeAccessor > TreeAccessor::filter ( const Accessor & accessor,
const FilterParams & filterParams,
const TString & fileName,
const DataTweaker & tweaker )
static

Definition at line 350 of file TreeAccessor.cxx.

354{
355 FilterList filterList; filterList.add(filterParams, fileName);
356 std::vector<std::unique_ptr<TreeAccessor> > result = filter(accessor, filterList, tweaker);
357 return (!result.empty() ? std::move(result[0]) : nullptr);
358}
void add(const FilterParams &params, const TString &fileName)
Definition FilterList.h:27
static std::unique_ptr< TreeAccessor > filter(const Accessor &accessor, const FilterParams &filterParams, const TString &fileName, const DataTweaker &tweaker)

◆ getCellEntry()

int LArSamples::PersistentAccessor::getCellEntry ( unsigned int i) const
inlineinherited

Definition at line 72 of file PersistentAccessor.h.

72{ return m_cellTree->GetEntry(i); }

◆ getCellHistory()

std::unique_ptr< const History > TreeAccessor::getCellHistory ( unsigned int i) const
overridevirtual

Implements LArSamples::AbsLArCells.

Definition at line 61 of file TreeAccessor.cxx.

62{
63 if (i >= cellTree().GetEntries()) return nullptr;
64 getCellEntry(i);
65
66 std::vector<std::unique_ptr<const EventData> > eventDatas;
67
68 for (unsigned int k = 0; k < currentContainer()->nDataContainers(); k++) {
69 const EventData* evtData = eventData(currentContainer()->dataContainer(k)->eventIndex());
70 std::unique_ptr<const EventData> newEvtData;
71 if (evtData)
72 newEvtData = std::make_unique<EventData> (*evtData);
73 eventDatas.push_back(std::move(newEvtData));
74 }
76 return std::make_unique<History>(*currentContainer(), std::move(eventDatas), i);
77 return nullptr;
78}
TGraphErrors * GetEntries(TH2F *histo)
virtual std::unique_ptr< const CellInfo > cellInfo(unsigned int i) const
unsigned int nDataContainers() const
HistoryContainer * currentContainer() const
int getCellEntry(unsigned int i) const

◆ getCellInfo()

std::unique_ptr< const CellInfo > TreeAccessor::getCellInfo ( unsigned int i) const
overridevirtual

Reimplemented from LArSamples::AbsLArCells.

Definition at line 46 of file TreeAccessor.cxx.

47{
48 const HistoryContainer* cont = historyContainer(i);
49 if (!cont || !cont->cellInfo()) return nullptr;
50 return std::make_unique<CellInfo>(*cont->cellInfo());
51}
const CellInfo * cellInfo() const
const HistoryContainer * historyContainer(unsigned int i) const

◆ getSCEntry()

int LArSamples::PersistentAccessor::getSCEntry ( unsigned int i) const
inlineinherited

Definition at line 73 of file PersistentAccessor.h.

73{ return m_SCTree->GetEntry(i); }

◆ getSCHistory()

std::unique_ptr< const History > TreeAccessor::getSCHistory ( unsigned int i) const
overridevirtual

Implements LArSamples::AbsLArCells.

Definition at line 80 of file TreeAccessor.cxx.

81{
82 if (i >= SCTree().GetEntries()) return nullptr;
83 getSCEntry(i);
84
85 std::vector<std::unique_ptr<const EventData> > eventDatas;
86
87 for (unsigned int k = 0; k < currentContainerSC()->nDataContainers(); k++) {
88 const EventData* evtData = eventData(currentContainerSC()->dataContainer(k)->eventIndex());
89 std::unique_ptr<const EventData> newEvtData;
90 if (evtData)
91 newEvtData = std::make_unique<EventData> (*evtData);
92 eventDatas.push_back(std::move(newEvtData));
93 }
95 return std::make_unique<History>(*currentContainerSC(), std::move(eventDatas), i);
96 return nullptr;
97}
HistoryContainer * currentContainerSC() const
int getSCEntry(unsigned int i) const

◆ getSCInfo()

std::unique_ptr< const CellInfo > TreeAccessor::getSCInfo ( unsigned int i) const

Definition at line 53 of file TreeAccessor.cxx.

54{
55 const HistoryContainer* cont = historyContainerSC(i);
56 if (!cont || !cont->cellInfo()) return nullptr;
57 return std::make_unique<CellInfo>(*cont->cellInfo());
58}
const HistoryContainer * historyContainerSC(unsigned int i) const

◆ historyContainer()

const HistoryContainer * PersistentAccessor::historyContainer ( unsigned int i) const
inherited

Definition at line 106 of file PersistentAccessor.cxx.

107{
108 m_cellTree->GetEntry(i);
109 return m_historyCont;
110}

◆ historyContainerSC()

const HistoryContainer * PersistentAccessor::historyContainerSC ( unsigned int i) const
inherited

Definition at line 112 of file PersistentAccessor.cxx.

113{
114 m_SCTree->GetEntry(i);
115 return m_historyContSC;
116}

◆ historySize()

virtual unsigned int LArSamples::TreeAccessor::historySize ( unsigned int i) const
inlineoverridevirtual

Implements LArSamples::Accessor.

Definition at line 63 of file TreeAccessor.h.

unsigned int historySize(unsigned int i) const

◆ historySizeSC()

virtual unsigned int LArSamples::TreeAccessor::historySizeSC ( unsigned int i) const
inlineoverridevirtual

Implements LArSamples::Accessor.

Definition at line 64 of file TreeAccessor.h.

unsigned int historySizeSC(unsigned int i) const

◆ makeTemplate()

std::unique_ptr< TreeAccessor > TreeAccessor::makeTemplate ( const Accessor & accessor,
const TString & fileName )
static

Definition at line 477 of file TreeAccessor.cxx.

478{
479 auto newAccessor = std::make_unique<TreeAccessor>(fileName);
480
481 std::vector<short> samples(5, 0);
482 std::vector<float> autoCorrs(4, 0);
483
484 RunData dummyRun(0);
485 newAccessor->addRun(&dummyRun);
486
487 EventData dummyEvent(0, 0, 0, 0);
488 newAccessor->addEvent(&dummyEvent);
489
490 for (unsigned int i = 0; i < accessor.nChannels(); i++) {
491 if (i % 25000 == 0)
492 cout << "Templating " << i << "/" << accessor.nChannels() << endl;
493 const History* history = accessor.cellHistory(i);
494 if (!history || !history->cellInfo()) {
495 HistoryContainer newHist;
496 newAccessor->add(&newHist);
497 continue;
498 }
499 HistoryContainer newHist(new CellInfo(*history->cellInfo()));
500 auto dataContainer = std::make_unique<DataContainer>(CaloGain::LARHIGHGAIN, samples, 0, 0, 0, 0, autoCorrs);
501 newHist.add(dataContainer.release());
502 newAccessor->add(&newHist);
503 }
504
505 newAccessor->save();
506 return newAccessor;
507}
@ LARHIGHGAIN
Definition CaloGain.h:18

◆ merge() [1/4]

PersistentAccessor * PersistentAccessor::merge ( const std::vector< const PersistentAccessor * > & accessors,
const TString & fileName )
staticinherited

Definition at line 209 of file PersistentAccessor.cxx.

211{
213 unsigned int size = 0;
214 CellInfo* info = nullptr;
215
216 int evtIndex = 0, runIndex = 0;
217 std::map<std::pair<int, int>, int> evtMap;
218 std::map<int, int> runMap;
219 std::map< std::pair<const PersistentAccessor*, int>, int > evtAccMap;
220
221 cout << "Merging runs" << endl;
222 for (const PersistentAccessor* accessor : accessors) {
223 if (!accessor) {
224 cout << "Cannot merge: one of the inputs is null!" << endl;
225 delete newAcc;
226 return nullptr;
227 }
228 for (unsigned int i = 0; i < accessor->nRuns(); i++) {
229 int run = accessor->runData(i)->run();
230 if (runMap.find(run) != runMap.end()) continue;
231 runMap[run] = runIndex;
232 RunData* newRun = new RunData(*accessor->runData(i));
233 newAcc->addRun(newRun);
234 delete newRun;
235 runIndex++;
236 }
237 }
238
239 cout << "Merging events" << endl;
240 unsigned int nEventsTotal = 0, iEvt = 0;
241 for (const PersistentAccessor* accessor : accessors) {
242 nEventsTotal += accessor->nEvents();
243 }
244 for (const PersistentAccessor* accessor : accessors) {
245 for (unsigned int i = 0; i < accessor->nEvents(); i++) {
246 iEvt++;
247 if (iEvt % 100000 == 0) cout << "Merging event " << iEvt << "/" << nEventsTotal << endl;
248 std::pair<int, int> evtId(accessor->eventData(i)->run(), accessor->eventData(i)->event());
249 std::pair<const PersistentAccessor*, int> evtAccId(accessor, i);
250 if (evtMap.find(evtId) != evtMap.end()) {
251 cout << "ERROR: Skipping duplicate entry for run " << accessor->eventData(i)->run() << ", event " << accessor->eventData(i)->event() << endl;
252 continue;
253 }
254 evtAccMap[evtAccId] = evtIndex;
255 evtMap[evtId] = evtIndex;
256 std::map<int, int>::const_iterator idx = runMap.find(accessor->eventData(i)->run());
257 int newRunIndex = (idx == runMap.end() ? -999 : idx->second);
258 //cout << "Storing eventData for run " << accessor->eventData(i)->run() << " at index " << newRunIndex << " instead of " << accessor->eventData(i)->runIndex() << endl;
259 EventData* newEvent = new EventData(*accessor->eventData(i), newRunIndex);
260 newAcc->addEvent(newEvent);
261 delete newEvent;
262 evtIndex++;
263 }
264 }
265
266 cout << "Merging cells" << endl;
267 for (unsigned int i = 0; i < Definitions::nChannels; i++) {
268 if (i % 10000 == 0) {
269 cout << "Merging channel " << i << "/" << Definitions::nChannels << " (current size = " << size << ")" << endl;
270 //ClassCounts::printCountsTable();
271 }
272 HistoryContainer* newHistory = nullptr;
273 for (const PersistentAccessor* accessor : accessors) {
274 const HistoryContainer* history = accessor->historyContainer(i);
275 if (!history || !history->isValid()) continue;
276 if (!newHistory) {
277 info = new CellInfo(*history->cellInfo());
278 newHistory = new HistoryContainer(info);
279 }
280 for (unsigned int j = 0; j < history->nDataContainers(); j++) {
281 DataContainer* newDC = new DataContainer(*history->dataContainer(j));
282 std::map<std::pair<const PersistentAccessor*, int>, int>::const_iterator newIndex
283 = evtAccMap.find(std::make_pair(accessor, history->dataContainer(j)->eventIndex()));
284 if (newIndex == evtAccMap.end()) cout << "Event not found for cell " << i << ", data " << j << "." << endl;
285 newDC->setEventIndex(newIndex != evtAccMap.end() ? newIndex->second : -1);
286 newHistory->add(newDC);
287 if (!info->shape(history->dataContainer(j)->gain())) {
288 const ShapeInfo* shape = history->cellInfo()->shape(history->dataContainer(j)->gain());
289 //if (!shape)
290 // cout << "Shape not filled for hash = " << i << ", index = " << j << ", gain = " << history->dataContainer(j)->gain() << endl;
291 info->setShape(history->dataContainer(j)->gain(), (shape ? new ShapeInfo(*shape) : nullptr));
292 }
293 }
294 }
295 if (newHistory) size += newHistory->nDataContainers();
296 newAcc->add(newHistory);
297 delete newHistory;
298 }
299
300
301 cout << "Merging SC" << endl;
302 size=0;
303 for (unsigned int i = 0; i < Definitions::nChannelsSC; i++) {
304 if (i % 10000 == 0) {
305 cout << "Merging channel " << i << "/" << Definitions::nChannelsSC << " (current size = " << size << ")" << endl;
306 //ClassCounts::printCountsTable();
307 }
308 HistoryContainer* newHistory = nullptr;
309 for (const PersistentAccessor* accessor : accessors) {
310 const HistoryContainer* history = accessor->historyContainerSC(i);
311 if (!history || !history->isValid()) continue;
312 if (!newHistory) {
313 info = new CellInfo(*history->cellInfo());
314 newHistory = new HistoryContainer(info);
315 }
316 for (unsigned int j = 0; j < history->nDataContainers(); j++) {
317 DataContainer* newDC = new DataContainer(*history->dataContainer(j));
318 std::map<std::pair<const PersistentAccessor*, int>, int>::const_iterator newIndex
319 = evtAccMap.find(std::make_pair(accessor, history->dataContainer(j)->eventIndex()));
320 if (newIndex == evtAccMap.end()) cout << "Event not found for cell " << i << ", data " << j << "." << endl;
321 newDC->setEventIndex(newIndex != evtAccMap.end() ? newIndex->second : -1);
322 newHistory->add(newDC);
323 if (!info->shape(history->dataContainer(j)->gain())) {
324 const ShapeInfo* shape = history->cellInfo()->shape(history->dataContainer(j)->gain());
325 //if (!shape)
326 // cout << "Shape not filled for hash = " << i << ", index = " << j << ", gain = " << history->dataContainer(j)->gain() << endl;
327 info->setShape(history->dataContainer(j)->gain(), (shape ? new ShapeInfo(*shape) : nullptr));
328 }
329 }
330 }
331 if (newHistory) size += newHistory->nDataContainers();
332 newAcc->addSC(newHistory);
333 delete newHistory;
334 }
335
336
337 cout << "Merging done, final size = " << size << endl;
338 newAcc->save();
339 return newAcc;
340}
const ShapeInfo * shape(CaloGain::CaloGain gain) const
Definition CellInfo.cxx:78
CaloGain::CaloGain gain() const
void setEventIndex(int index)
void add(const DataContainer *data)
append data (takes ownership)
const DataContainer * dataContainer(unsigned int i) const
void addEvent(EventData *eventData)
void addSC(HistoryContainer *cont)
float j(const xAOD::IParticle &, const xAOD::TrackMeasurementValidation &hit, const Eigen::Matrix3d &jab_inv)
int run(int argc, char *argv[])

◆ merge() [2/4]

PersistentAccessor * PersistentAccessor::merge ( const std::vector< TString > & inputFiles,
const TString & fileName )
staticinherited

Definition at line 343 of file PersistentAccessor.cxx.

344{
345 std::vector<const PersistentAccessor*> accessors;
346 for (const TString& inputFile : inputFiles) {
347 PersistentAccessor* accessor = open(inputFile);
348 if (!accessor) {
349 cout << "ERROR : could not open file " << inputFile << endl;
350 return nullptr;
351 }
352 accessors.push_back(accessor);
353 }
355 for (const PersistentAccessor* accessor : accessors) {
356 delete accessor;
357 }
358 return result;
359}
static PersistentAccessor * open(const TString &fileName)
static PersistentAccessor * merge(const std::vector< const PersistentAccessor * > &accessors, const TString &fileName)

◆ merge() [3/4]

std::unique_ptr< TreeAccessor > TreeAccessor::merge ( const std::vector< const Accessor * > & accessors,
const TString & fileName,
const TString & LBFile )
static

Definition at line 187 of file TreeAccessor.cxx.

188{
189 // O.Simard - 01.07.2011
190 // Alternative version with LB cleaning.
191
192 bool kBadLB=false;
193 std::vector<unsigned int> LBList;
194 std::ifstream infile(LBFile.Data());
195 std::string line;
196 // assume single-line format with coma-separated LBs (from python)
197 std::getline(infile,line,'\n');
198 TString filter(line.c_str());
199 std::unique_ptr<TObjArray> list (filter.Tokenize(", ")); // coma\space delimiters
200 if(list->GetEntries() == 0){
201 printf("No LB filtering specified, or bad format. Exiting.\n");
202 return nullptr;
203 }
204
205 for(int k = 0; k < list->GetEntries(); k++){
206 TObjString* tobs = (TObjString*)(list->At(k));
207 LBList.push_back((unsigned int)(tobs->String()).Atoi());
208 }
209 printf("LB List: %d\n",(int)LBList.size());
210
211
212 // from here it is similar to other functions of this class
213 auto newAcc = std::make_unique<TreeAccessor>(fileName);
214 unsigned int size = 0;
215
216 int evtIndex = 0, runIndex = 0;
217 std::map<std::pair<int, int>, int> evtMap;
218 std::map<int, int> runMap;
219
220 cout << "Merging runs" << endl;
221 for (const Accessor* accessor : accessors) {
222 if (!accessor) {
223 cout << "Cannot merge: one of the inputs is null!" << endl;
224 return nullptr;
225 }
226 for (unsigned int i = 0; i < accessor->nRuns(); i++) {
227 int run = accessor->runData(i)->run();
228 if (runMap.find(run) != runMap.end()) continue;
229 runMap[run] = runIndex;
230 RunData newRun(*accessor->runData(i));
231 newAcc->addRun(&newRun);
232 runIndex++;
233 }
234 }
235
236 cout << "Merging events" << endl;
237 unsigned int nEventsTotal = 0, iEvt = 0;
238 for (const Accessor* accessor : accessors)
239 nEventsTotal += accessor->nEvents();
240 for (const Accessor* accessor : accessors) {
241 for (unsigned int i = 0; i < accessor->nEvents(); i++) {
242 iEvt++;
243 if (iEvt % 100000 == 0) cout << "Merging event " << iEvt << "/" << nEventsTotal << endl;
244
245 // ----
246 // skip LBs which are found in the list
247 kBadLB=false;
248 for(unsigned int ilb = 0 ; ilb < LBList.size() ; ilb++){
249 if(LBList.at(ilb)==accessor->eventData(i)->lumiBlock()){
250 kBadLB=true;
251 //printf(" == Rejecting Event in LB %4d\n",accessor->eventData(i)->lumiBlock());
252 break;
253 }
254 }
255 if(kBadLB) continue;
256 // ----
257
258 std::pair<int, int> evtId(accessor->eventData(i)->run(), accessor->eventData(i)->event());
259 if (evtMap.find(evtId) != evtMap.end()) continue;
260 evtMap[evtId] = evtIndex;
261 std::map<int, int>::const_iterator idx = runMap.find(accessor->eventData(i)->run());
262 int newRunIndex = (idx == runMap.end() ? -999 : idx->second);
263 EventData newEvent(*accessor->eventData(i), newRunIndex);
264 newAcc->addEvent(&newEvent);
265 evtIndex++;
266 }
267 }
268
269 cout << "Merging cells" << endl;
270 for (unsigned int i = 0; i < newAcc->nChannels(); i++) {
271 if (i % 10000 == 0) {
272 cout << "Merging channel " << i << "/" << newAcc->nChannels() << " (current size = " << size << ")" << endl;
273 //ClassCounts::printCountsTable();
274 }
275 std::optional<HistoryContainer> historyContainer;
276 CellInfo* info = nullptr;
277 for (const Accessor* accessor : accessors) {
278 const History* history = accessor->cellHistory(i);
279 if (!history || !history->isValid()) continue;
280 if (!historyContainer) {
281 info = new CellInfo(*history->cellInfo());
282 historyContainer.emplace (info);
283 }
284 for (unsigned int j = 0; j < history->nData(); j++) {
285 auto newDC = std::make_unique<DataContainer>(history->data(j)->container());
286 std::map<std::pair<int, int>, int>::const_iterator newIndex
287 = evtMap.find(std::make_pair(history->data(j)->run(), history->data(j)->event()));
288 //if (newIndex == evtMap.end()) cout << "Event not found for cell " << i << ", data " << j << "." << endl;
289 newDC->setEventIndex(newIndex != evtMap.end() ? newIndex->second : -1);
290 historyContainer->add(newDC.release());
291 if (not info) continue;
292 if (!info->shape(history->data(j)->gain())) {
293 const ShapeInfo* shape = history->cellInfo()->shape(history->data(j)->gain());
294 if (!shape)
295 cout << "Shape not filled for hash = " << i << ", index = " << j << ", gain = " << Data::gainStr(history->data(j)->gain()) << endl;
296 info->setShape(history->data(j)->gain(), (shape ? new ShapeInfo(*shape) : nullptr));
297 }
298 }
299 }
301 size += historyContainer->nDataContainers();
302 }
303 newAcc->add(&historyContainer.value());
304 //}
305 }
306
307 cout << "Merging SC" << endl;
308 for (unsigned int i = 0; i < newAcc->nChannelsSC(); i++) {
309 if (i % 10000 == 0) {
310 cout << "Merging channel " << i << "/" << newAcc->nChannelsSC() << " (current size = " << size << ")" << endl;
311 }
312 std::optional<HistoryContainer> historyContainer;
313 CellInfo* info = nullptr;
314 for (const Accessor* accessor : accessors) {
315 std::unique_ptr<const History> history = accessor->getSCHistory(i);
316 if (!history || !history->isValid()) continue;
317 if (!historyContainer) {
318 info = new CellInfo(*history->cellInfo());
319 historyContainer.emplace (info);
320 }
321 for (unsigned int j = 0; j < history->nData(); j++) {
322 auto newDC = std::make_unique<DataContainer>(history->data(j)->container());
323 std::map<std::pair<int, int>, int>::const_iterator newIndex
324 = evtMap.find(std::make_pair(history->data(j)->run(), history->data(j)->event()));
325 //if (newIndex == evtMap.end()) cout << "Event not found for cell " << i << ", data " << j << "." << endl;
326 newDC->setEventIndex(newIndex != evtMap.end() ? newIndex->second : -1);
327 historyContainer->add(newDC.release());
328 if (not info) continue;
329 if (!info->shape(history->data(j)->gain())) {
330 const ShapeInfo* shape = history->cellInfo()->shape(history->data(j)->gain());
331 if (!shape)
332 cout << "Shape not filled for hash = " << i << ", index = " << j << ", gain = " << Data::gainStr(history->data(j)->gain()) << endl;
333 info->setShape(history->data(j)->gain(), (shape ? new ShapeInfo(*shape) : nullptr));
334 }
335 }
336 }
338 size += historyContainer->nDataContainers();
339 }
340 newAcc->addSC(&historyContainer.value());
341 //}
342 }
343
344 cout << "Merging done, final size = " << size << endl;
345 newAcc->save();
346 return newAcc;
347}
CaloGain::CaloGain gain() const
Definition Data.h:87
static TString gainStr(CaloGain::CaloGain gain)
Definition Data.cxx:514
const DataContainer & container() const
Definition Data.h:158
int event() const
Definition Data.cxx:28
int run() const
Definition Data.cxx:27
bool isValid() const
Definition History.cxx:149
list(name, path='/')
Definition histSizes.py:38

◆ merge() [4/4]

std::unique_ptr< TreeAccessor > TreeAccessor::merge ( const std::vector< const Accessor * > & accessors,
const TString & fileName = "" )
static

Definition at line 99 of file TreeAccessor.cxx.

101{
102 cout << "Merging to " << fileName << endl;
103 auto newAcc = std::make_unique<TreeAccessor>(fileName);
104 unsigned int size = 0;
105
106 int evtIndex = 0, runIndex = 0;
107 std::map<std::pair<int, int>, int> evtMap;
108 std::map<int, int> runMap;
109
110 cout << "Merging runs" << endl;
111 for (const Accessor* accessor : accessors) {
112 if (!accessor) {
113 cout << "Cannot merge: one of the inputs is null!" << endl;
114 return nullptr;
115 }
116 for (unsigned int i = 0; i < accessor->nRuns(); i++) {
117 int run = accessor->runData(i)->run();
118 if (runMap.find(run) != runMap.end()) continue;
119 runMap[run] = runIndex;
120 RunData newRun(*accessor->runData(i));
121 newAcc->addRun(&newRun);
122 runIndex++;
123 }
124 }
125
126 cout << "Merging events" << endl;
127 unsigned int nEventsTotal = 0, iEvt = 0;
128 for (const Accessor* accessor : accessors)
129 nEventsTotal += accessor->nEvents();
130 for (const Accessor* accessor : accessors) {
131 for (unsigned int i = 0; i < accessor->nEvents(); i++) {
132 iEvt++;
133 if (iEvt % 100000 == 0) cout << "Merging event " << iEvt << "/" << nEventsTotal << endl;
134 std::pair<int, int> evtId(accessor->eventData(i)->run(), accessor->eventData(i)->event());
135 if (evtMap.find(evtId) != evtMap.end()) continue;
136 evtMap[evtId] = evtIndex;
137 std::map<int, int>::const_iterator idx = runMap.find(accessor->eventData(i)->run());
138 int newRunIndex = (idx == runMap.end() ? -999 : idx->second);
139 //cout << "Storing eventData for run " << accessor->eventData(i)->run() << " at index " << newRunIndex << " instead of " << accessor->eventData(i)->runIndex() << endl;
140 EventData newEvent(*accessor->eventData(i), newRunIndex);
141 newAcc->addEvent(&newEvent);
142 evtIndex++;
143 }
144 }
145
146 for (unsigned int i = 0; i < newAcc->nChannels(); i++) {
147 if (i % 10000 == 0) {
148 cout << "Merging channel " << i << "/" << newAcc->nChannels() << " (current size = " << size << ")" << endl;
149 //ClassCounts::printCountsTable();
150 }
151 std::optional<HistoryContainer> historyContainer;
152 CellInfo* info = nullptr;
153 for (const Accessor* accessor : accessors) {
154 const History* history = accessor->cellHistory(i);
155 if (!history || !history->isValid()) continue;
156 if (!historyContainer) {
157 info = new CellInfo(*history->cellInfo());
158 historyContainer.emplace (info);
159 }
160 for (unsigned int j = 0; j < history->nData(); j++) {
161 auto newDC = std::make_unique<DataContainer>(history->data(j)->container());
162 std::map<std::pair<int, int>, int>::const_iterator newIndex
163 = evtMap.find(std::make_pair(history->data(j)->run(), history->data(j)->event()));
164 if (newIndex == evtMap.end()) std::cout << "Event not found for cell " << i << ", data " << j << ".\n";
165 newDC->setEventIndex(newIndex != evtMap.end() ? newIndex->second : -1);
166 historyContainer->add(newDC.release());
167 if (not info) continue;
168 if (!info->shape(history->data(j)->gain())) {
169 const ShapeInfo* shape = history->cellInfo()->shape(history->data(j)->gain());
170 if (!shape) {
171 cout << "Shape not filled for hash = " << i << ", index = " << j << ", gain = " << Data::gainStr(history->data(j)->gain()) << endl;
172 }
173 info->setShape(history->data(j)->gain(), (shape ? new ShapeInfo(*shape) : nullptr));
174 }
175 }
176 }
177 if (historyContainer) size += historyContainer->nDataContainers();
178 newAcc->add(&historyContainer.value());
179 }
180
181 cout << "Merging done, final size = " << size << endl;
182 newAcc->save();
183 return newAcc;
184}

◆ nChannels()

virtual unsigned int LArSamples::AbsLArCells::nChannels ( ) const
inlinevirtualinherited

Reimplemented in LArSamples::MonitorBase.

Definition at line 35 of file AbsLArCells.h.

35{ return Definitions::nChannels; }

◆ nChannelsSC()

virtual unsigned int LArSamples::AbsLArCells::nChannelsSC ( ) const
inlinevirtualinherited

Definition at line 36 of file AbsLArCells.h.

◆ nEvents()

virtual unsigned int LArSamples::TreeAccessor::nEvents ( ) const
inlineoverridevirtual

Implements LArSamples::Accessor.

Definition at line 66 of file TreeAccessor.h.

◆ newCellHistory()

std::unique_ptr< const History > AbsLArCells::newCellHistory ( unsigned int i) const
virtualinherited

Definition at line 39 of file AbsLArCells.cxx.

40{
41 std::unique_ptr<const History> history = getCellHistory(i);
42 if (!history) return nullptr;
43 if (!m_cellInfoCache[i]) {
44 const CellInfo* ci=history->cellInfo();
45 if (ci) {
46 m_cellInfoCache[i]=std::make_unique<CellInfo>(*ci,false);
47 }
48 }
49 // m_cellInfoCache[i] = (history->cellInfo() ? new CellInfo(*history->cellInfo(), false) : new CellInfo());
50 return history;
51}
virtual std::unique_ptr< const History > getCellHistory(unsigned int i) const =0

◆ nRuns()

virtual unsigned int LArSamples::TreeAccessor::nRuns ( ) const
inlineoverridevirtual

Implements LArSamples::Accessor.

Definition at line 69 of file TreeAccessor.h.

◆ open()

std::unique_ptr< TreeAccessor > TreeAccessor::open ( const TString & fileName)
static

Definition at line 30 of file TreeAccessor.cxx.

31{
32 std::unique_ptr<TFile> file (TFile::Open(fileName));
33 if (!file) return nullptr;
34 if (!file->IsOpen()) { return nullptr; }
35 TTree* cellTree = (TTree*)file->Get("cells");
36 if (!cellTree) return nullptr;
37 TTree* scTree = (TTree*)file->Get("SC");
38 if (!scTree) return nullptr;
39 TTree* eventTree = (TTree*)file->Get("events");
40 if (!eventTree) return nullptr;
41 TTree* runTree = (TTree*)file->Get("runs");
42 return std::make_unique<TreeAccessor>(*cellTree, *scTree, *eventTree, runTree, file.release());
43}

◆ pass()

const History * AbsLArCells::pass ( unsigned int i,
const FilterParams & f ) const
inherited

Definition at line 96 of file AbsLArCells.cxx.

97{
98 //std::cout << "Called AbsLArCells with hash " << i << std::endl;
99 if (!f.passHash(i)) return nullptr;
100 std::unique_ptr<const CellInfo> info = cellInfo(i);
101 if (!info) {
102 return nullptr;
103 }
104 //std::cout << "Called AbsLArCells::pass on a cell belonging to " << Id::str(info->calo()) << std::endl;
105 bool result = f.passCell(*info);
106 return result ? cellHistory(i) : nullptr;
107}
virtual const History * cellHistory(unsigned int i) const

◆ resetCache()

void AbsLArCells::resetCache ( ) const
virtualinherited

Definition at line 32 of file AbsLArCells.cxx.

33{
34 m_cellCache.reset();
35 m_pos = nChannels() + 1;
36}
virtual unsigned int nChannels() const
Definition AbsLArCells.h:35

◆ runData()

virtual const RunData * LArSamples::TreeAccessor::runData ( unsigned int i) const
inlineoverridevirtual

Implements LArSamples::Accessor.

Definition at line 70 of file TreeAccessor.h.

70{ return PersistentAccessor::runData(i); }

◆ runTree()

const TTree & LArSamples::PersistentAccessor::runTree ( ) const
inlineinherited

Definition at line 47 of file PersistentAccessor.h.

47{ return *m_runTree; }

◆ save()

bool PersistentAccessor::save ( ) const
inherited

Definition at line 191 of file PersistentAccessor.cxx.

192{
193 if (!m_file) return 0;
194 m_file->cd();
195 cout << "Writing " << m_runTree->GetEntries() << " run(s)..." << endl;
196 m_runTree->Write();
197 cout << "Writing " << m_eventTree->GetEntries() << " event(s)..." << endl;
198 m_eventTree->Write();
199 cout << "Writing " << m_cellTree->GetEntries() << " cell(s)..." << endl;
200 m_cellTree->Write();
201 cout << "Writing " << m_SCTree->GetEntries() << " SC(s)..." << endl;
202 m_SCTree->Write();
203 m_file->Flush();
204 cout << "Writing done!" << endl;
205 return true;
206}

◆ SCTree()

const TTree & LArSamples::PersistentAccessor::SCTree ( ) const
inlineinherited

Definition at line 45 of file PersistentAccessor.h.

45{ return *m_SCTree; }

◆ writeToFile()

bool TreeAccessor::writeToFile ( const TString & fileName) const
overridevirtual

Implements LArSamples::Accessor.

Definition at line 509 of file TreeAccessor.cxx.

510{
511 TFile newFile(fileName, "RECREATE");
512 if (!newFile.IsOpen()) return false;
513
514 cellTree().Write();
515 eventTree().Write();
516
517 return true;
518}

◆ Interface

friend class Interface
friend

Definition at line 57 of file TreeAccessor.h.

Member Data Documentation

◆ m_cellCache

std::unique_ptr<const History> LArSamples::AbsLArCells::m_cellCache
mutableprivateinherited

Definition at line 55 of file AbsLArCells.h.

◆ m_cellInfoCache

std::vector<std::unique_ptr<CellInfo> > LArSamples::AbsLArCells::m_cellInfoCache
mutableprivateinherited

Definition at line 56 of file AbsLArCells.h.

◆ m_cellTree

TTree* LArSamples::PersistentAccessor::m_cellTree
privateinherited

Definition at line 77 of file PersistentAccessor.h.

◆ m_eventData

EventData* LArSamples::PersistentAccessor::m_eventData
mutableprivateinherited

Definition at line 81 of file PersistentAccessor.h.

◆ m_eventTree

TTree * LArSamples::PersistentAccessor::m_eventTree
privateinherited

Definition at line 77 of file PersistentAccessor.h.

◆ m_file

TFile* LArSamples::PersistentAccessor::m_file
mutableprivateinherited

Definition at line 78 of file PersistentAccessor.h.

◆ m_historyCont

HistoryContainer* LArSamples::PersistentAccessor::m_historyCont
mutableprivateinherited

Definition at line 79 of file PersistentAccessor.h.

◆ m_historyContSC

HistoryContainer* LArSamples::PersistentAccessor::m_historyContSC
mutableprivateinherited

Definition at line 80 of file PersistentAccessor.h.

◆ m_pos

unsigned int LArSamples::AbsLArCells::m_pos
mutableprivateinherited

Definition at line 54 of file AbsLArCells.h.

◆ m_runCache

std::map<unsigned int, const RunData*> LArSamples::PersistentAccessor::m_runCache
mutableprivateinherited

Definition at line 83 of file PersistentAccessor.h.

◆ m_runData

RunData* LArSamples::PersistentAccessor::m_runData
mutableprivateinherited

Definition at line 82 of file PersistentAccessor.h.

◆ m_runTree

TTree * LArSamples::PersistentAccessor::m_runTree
privateinherited

Definition at line 77 of file PersistentAccessor.h.

◆ m_SCTree

TTree * LArSamples::PersistentAccessor::m_SCTree
privateinherited

Definition at line 77 of file PersistentAccessor.h.


The documentation for this class was generated from the following files: