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 EventDataeventData (unsigned int i) const override
virtual unsigned int nRuns () const override
virtual const RunDatarunData (unsigned int i) const override
void add (HistoryContainer *cont)
virtual std::unique_ptr< const HistorygetCellHistory (unsigned int i) const override
virtual std::unique_ptr< const HistorygetSCHistory (unsigned int i) const override
virtual std::unique_ptr< const CellInfogetCellInfo (unsigned int i) const override
std::unique_ptr< const CellInfogetSCInfo (unsigned int i) const
virtual std::unique_ptr< const HistorynewCellHistory (unsigned int i) const
virtual const HistorycellHistory (unsigned int i) const
virtual std::unique_ptr< const CellInfocellInfo (unsigned int i) const
virtual unsigned int nChannels () const
virtual unsigned int nChannelsSC () const
virtual void resetCache () const
const CellInfocellInfoCache (unsigned int i) const
const Historypass (unsigned int i, const FilterParams &f) const
const HistorycellCache () 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 HistoryContainerhistoryContainer (unsigned int i) const
const HistoryContainerhistoryContainerSC (unsigned int i) const
void addSC (HistoryContainer *cont)
void addEvent (EventData *eventData)
void addRun (RunData *runData)
HistoryContainercurrentContainer () const
HistoryContainercurrentContainerSC () const
int getCellEntry (unsigned int i) const
int getSCEntry (unsigned int i) const

Static Public Member Functions

static std::unique_ptr< TreeAccessoropen (const TString &fileName)
static std::unique_ptr< TreeAccessormerge (const std::vector< const Accessor * > &accessors, const TString &fileName="")
static std::unique_ptr< TreeAccessormerge (const std::vector< const Accessor * > &accessors, const TString &fileName, const TString &LBFile)
static std::unique_ptr< TreeAccessorfilter (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< TreeAccessormakeTemplate (const Accessor &accessor, const TString &fileName)
static PersistentAccessormerge (const std::vector< const PersistentAccessor * > &accessors, const TString &fileName)
static PersistentAccessormerge (const std::vector< TString > &inputFiles, const TString &fileName)

Private Attributes

unsigned int m_pos
std::unique_ptr< const Historym_cellCache
std::vector< std::unique_ptr< CellInfo > > m_cellInfoCache
TTree * m_cellTree
TTree * m_SCTree
TTree * m_eventTree
TTree * m_runTree
TFile * m_file
HistoryContainerm_historyCont
HistoryContainerm_historyContSC
EventDatam_eventData
RunDatam_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}
std::unique_ptr< Data > tweak(const Data &data, int evtIndex=-1) const
const EventData & eventData() const
Definition Data.h:97
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
thread_local 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:506
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: