LArSamples::MultiTreeAccessor Class Reference

#include <MultiTreeAccessor.h>

Inheritance diagram for LArSamples::MultiTreeAccessor:

Collaboration diagram for LArSamples::MultiTreeAccessor:

Public Member Functions
	MultiTreeAccessor (std::vector< std::unique_ptr< const TreeAccessor > > &&accessors)
	Constructor.
virtual	~MultiTreeAccessor ()
virtual unsigned int	nEvents () const override
virtual unsigned int	nRuns () const override
virtual const EventData *	eventData (unsigned int i) const override
virtual const RunData *	runData (unsigned int i) const override
virtual unsigned int	historySize (unsigned int i) const override
virtual unsigned int	historySizeSC (unsigned int i) const override
virtual bool	writeToFile (const TString &fileName) const override
const TreeAccessor &	accessor (unsigned int i) const
unsigned int	nAccessors () const
std::vector< std::unique_ptr< MultiTreeAccessor > >	filterComponents (const FilterList &filterList, const DataTweaker &tweaker) 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

Static Public Member Functions
static std::unique_ptr< MultiTreeAccessor >	open (const std::vector< TString > &files)
static std::unique_ptr< MultiTreeAccessor >	openList (const TString &fileList)
static std::unique_ptr< MultiTreeAccessor >	openWild (const TString &wcName)

Protected Member Functions
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

Private Attributes
std::vector< std::unique_ptr< const TreeAccessor > >	m_accessors
unsigned int	m_pos
std::unique_ptr< const History >	m_cellCache
std::vector< std::unique_ptr< CellInfo > >	m_cellInfoCache

Detailed Description

Definition at line 27 of file MultiTreeAccessor.h.

Constructor & Destructor Documentation

MultiTreeAccessor()

MultiTreeAccessor::MultiTreeAccessor

(

std::vector< std::unique_ptr< const TreeAccessor > > &&

accessors

)

Constructor.

Definition at line 26 of file MultiTreeAccessor.cxx.

  : m_accessors(std::move(accessors))
{
}

~MultiTreeAccessor()

MultiTreeAccessor::~MultiTreeAccessor ( )

virtual

Definition at line 101 of file MultiTreeAccessor.cxx.

{
}

Member Function Documentation

accessor()

const TreeAccessor & LArSamples::MultiTreeAccessor::accessor ( unsigned int i ) const

inline

Definition at line 51 of file MultiTreeAccessor.h.

{ return *m_accessors[i]; }

cachePos()

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

inlineinherited

Definition at line 49 of file AbsLArCells.h.

{ return m_pos; }

cellCache()

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

inlineinherited

Definition at line 48 of file AbsLArCells.h.

{ return m_cellCache.get(); }

cellHistory()

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

virtualinherited

Reimplemented in LArSamples::Interface.

Definition at line 54 of file AbsLArCells.cxx.

{ 
  if (m_pos == i) return m_cellCache.get();
  resetCache();
  std::unique_ptr<const History> history = newCellHistory(i);
  if (!history) return nullptr;
  m_cellCache = std::move(history);
  m_pos = i;
  return m_cellCache.get();
}

cellInfo()

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

virtualinherited

Definition at line 66 of file AbsLArCells.cxx.

{
  const CellInfo* info = cellInfoCache(i);
  if (info) {
    if (info->isValid()) {
      return std::make_unique<CellInfo> (*info);
    }
    return nullptr;
  }
  std::unique_ptr<const CellInfo> infop = getCellInfo(i);
  if (infop)  m_cellInfoCache[i] =  std::make_unique<CellInfo>(*infop, false);
  return infop;
}

cellInfoCache()

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

inherited

Definition at line 81 of file AbsLArCells.cxx.

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

eventData()

const EventData * MultiTreeAccessor::eventData ( unsigned int i ) const

overridevirtual

Implements LArSamples::Accessor.

Definition at line 106 of file MultiTreeAccessor.cxx.

{
  unsigned int nEventsSoFar = 0;
  for (const std::unique_ptr<const TreeAccessor>& accessor : m_accessors) {
    unsigned int n = accessor->nEvents();
    if (i < nEventsSoFar + n) return accessor->eventData(i - nEventsSoFar);
    nEventsSoFar += n;
  }
  return nullptr;
}

filterComponents()

std::vector< std::unique_ptr< MultiTreeAccessor > > MultiTreeAccessor::filterComponents	(	const FilterList &	filterList,
		const DataTweaker &	tweaker ) const

Definition at line 272 of file MultiTreeAccessor.cxx.

{
  std::vector< std::vector<std::unique_ptr<const TreeAccessor> > > filteredAccessors(filterList.size());
  
  std::vector<std::unique_ptr<MultiTreeAccessor> > result;
 
  for (unsigned int i = 0; i < nAccessors(); i++) {
    const TreeAccessor* treeAcc = dynamic_cast<const TreeAccessor*>(&accessor(i));
    cout << "Processing data " << i << " of " << nAccessors();
    if (treeAcc) cout << " (fileName = " << treeAcc->fileName() << ")";
    cout << endl;
    FilterList thisFilterList;
    //
    for (unsigned int f = 0; f < filterList.size(); f++) {
      std::string pathname = (string)filterList.fileName(f);
      if( pathname.find("eos/atlas/") < pathname.length() ){
    int nslashes = 0, slpos = 0;
    for( int k1 = 0; k1 < (int)pathname.length(); k1++ ){
      if( nslashes > 2 )break;
      if( pathname[k1] != '/' )continue;
      nslashes++;
      slpos = k1;
    }
    pathname.resize( slpos );
      }
      TString thisFN = Form("%s_filter%d.root", pathname.c_str(), i );//filterList.fileName(f).Data(), i);
      thisFilterList.add(filterList.filterParams(f), thisFN);
    }
    std::vector<std::unique_ptr<TreeAccessor> > filteredTreeAccs = TreeAccessor::filter(accessor(i), thisFilterList, tweaker);
    if (filteredTreeAccs.size() != filterList.size()) {
      cout << "Filtering failed, exiting" << endl;
      return result;
    }
    for (unsigned int f = 0; f < filteredTreeAccs.size(); f++) filteredAccessors[f].push_back(std::move(filteredTreeAccs[f]));
  }
 
  for (unsigned int f = 0; f < filteredAccessors.size(); f++)
    result.push_back(std::make_unique<MultiTreeAccessor>(std::move(filteredAccessors[f])));
  return result;
}

getCellHistory()

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

overrideprotectedvirtual

Implements LArSamples::AbsLArCells.

Definition at line 171 of file MultiTreeAccessor.cxx.

{ 
  std::unique_ptr<CellInfo> cellInfo;
  std::vector<std::unique_ptr<const Data> > allData;
  std::vector<std::unique_ptr<const EventData> > allEventData;
  for (const std::unique_ptr<const TreeAccessor>& accessor : m_accessors) {
    std::unique_ptr<const History> thisHistory = accessor->getCellHistory(i);
    if (!thisHistory) continue;
    if (!cellInfo) {
      cellInfo = std::make_unique<CellInfo>(*thisHistory->cellInfo());
    }
    const std::vector<std::unique_ptr<const EventData> >& thisEventData = thisHistory->eventData();
    std::map<const EventData*, const EventData*> eventMap;
    for (const std::unique_ptr<const EventData>& event : thisEventData) {
      if (eventMap.find(event.get()) != eventMap.end()) continue;
      auto newED = std::make_unique<EventData>(*event);
      eventMap[event.get()] = newED.get();
      allEventData.push_back(std::move(newED));
    }
   
    for (unsigned int j = 0; j < thisHistory->nData(); j++) {
      allData.push_back(std::make_unique<Data>(*thisHistory->data(j), eventMap[&thisHistory->data(j)->eventData()], nullptr, -1));
      if (!cellInfo->shape(thisHistory->data(j)->gain())) {
        const ShapeInfo* thisShape = thisHistory->cellInfo()->shape(thisHistory->data(j)->gain());
        cellInfo->setShape(thisHistory->data(j)->gain(), thisShape ? new ShapeInfo(*thisShape) : nullptr);
      }
    }
  }
  //data are copied from cellInfo into History member variable
  if (cellInfo)
    return std::make_unique<History>(std::move(allData), *cellInfo, std::move(allEventData), i);
  return nullptr;
}

getCellInfo()

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

overrideprotectedvirtual

Reimplemented from LArSamples::AbsLArCells.

Definition at line 249 of file MultiTreeAccessor.cxx.

{
  resetCache();
  for (const std::unique_ptr<const TreeAccessor>& accessor : m_accessors) {
    const HistoryContainer* cont = accessor->historyContainer(i);
    if (cont && cont->cellInfo()) return std::make_unique<CellInfo>(*cont->cellInfo());
  }
  return nullptr;
}

getSCHistory()

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

overrideprotectedvirtual

Implements LArSamples::AbsLArCells.

Definition at line 205 of file MultiTreeAccessor.cxx.

{ 
  std::unique_ptr<CellInfo> cellInfo;
  std::vector<std::unique_ptr<const Data> > allData;
  std::vector<std::unique_ptr<const EventData> > allEventData;
  for (const std::unique_ptr<const TreeAccessor>& accessor : m_accessors) {
    //cout << "---> Getting history for a treeAccessor..." << endl; 
    std::unique_ptr<const History> thisHistory (accessor->getSCHistory(i));
    //cout << "---> done Getting history for a treeAccessor..." << endl; 
    if (!thisHistory) continue;
    if (!cellInfo) {
      cellInfo = std::make_unique<CellInfo>(*thisHistory->cellInfo());
    //cout << "---> done new cell info" << endl; 
    }
    //cout << "---> Creating new event data N = " << thisHistory->eventData().size() << endl; 
    const std::vector<std::unique_ptr<const EventData> >& thisEventData = thisHistory->eventData();
    std::map<const EventData*, const EventData*> eventMap;
    for (const std::unique_ptr<const EventData>& event : thisEventData) {
      if (eventMap.find(event.get()) != eventMap.end()) continue;
      auto newED = std::make_unique<EventData>(*event);
      eventMap[event.get()] = newED.get();
      allEventData.push_back(std::move(newED));
    }
    //cout << "---> Creating new data N = " << thisHistory->nData() << endl; 
   
    for (unsigned int ii = 0; ii < thisHistory->nData(); ii++) {
     //cout << "------> Creating new data " << i << endl; 
      allData.push_back(std::make_unique<Data>(*thisHistory->data(ii), eventMap[&thisHistory->data(ii)->eventData()], nullptr, -1));
     //cout << "------> done Creating new data " << i << endl; 
      if (!cellInfo->shape(thisHistory->data(ii)->gain())) {
        const ShapeInfo* thisShape = thisHistory->cellInfo()->shape(thisHistory->data(ii)->gain());
        cellInfo->setShape(thisHistory->data(ii)->gain(), thisShape ? new ShapeInfo(*thisShape) : nullptr);
      }
     //cout << "------> done shape " << i << endl; 
    }
     //cout << "---> done Creating new data, deleting treeAcc history" << endl; 
  }
  //cout << "--->returning new history..." << endl;
  if (cellInfo)
    return std::make_unique<History>(std::move(allData), *cellInfo, std::move(allEventData), i);
  return nullptr;
}

historySize()

unsigned int MultiTreeAccessor::historySize ( unsigned int i ) const

overridevirtual

Implements LArSamples::Accessor.

Definition at line 148 of file MultiTreeAccessor.cxx.

{
  resetCache();
  unsigned int size = 0;
  for (const std::unique_ptr<const TreeAccessor>& accessor : m_accessors) {
    const HistoryContainer* cont = accessor->historyContainer(i);
    if (cont) size += cont->nDataContainers();
  }
  return size;
}

historySizeSC()

unsigned int MultiTreeAccessor::historySizeSC ( unsigned int i ) const

overridevirtual

Implements LArSamples::Accessor.

Definition at line 159 of file MultiTreeAccessor.cxx.

{
  resetCache();
  unsigned int size = 0;
  for (const std::unique_ptr<const TreeAccessor>& accessor : m_accessors) {
    const HistoryContainer* cont = accessor->historyContainerSC(i);
    if (cont) size += cont->nDataContainers();
  }
  return size;
}

nAccessors()

unsigned int LArSamples::MultiTreeAccessor::nAccessors ( ) const

inline

Definition at line 52 of file MultiTreeAccessor.h.

{ return m_accessors.size(); }

nChannels()

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

inlinevirtualinherited

Reimplemented in LArSamples::MonitorBase.

Definition at line 35 of file AbsLArCells.h.

{ return Definitions::nChannels; }

nChannelsSC()

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

inlinevirtualinherited

Definition at line 36 of file AbsLArCells.h.

{ return Definitions::nChannelsSC; }

nEvents()

unsigned int MultiTreeAccessor::nEvents ( ) const

overridevirtual

Implements LArSamples::Accessor.

Definition at line 130 of file MultiTreeAccessor.cxx.

{
  unsigned int n = 0;
  for (const std::unique_ptr<const TreeAccessor>& accessor : m_accessors)
     n += accessor->nEvents();
  return n;
}

newCellHistory()

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

virtualinherited

Definition at line 39 of file AbsLArCells.cxx.

{ 
  std::unique_ptr<const History> history = getCellHistory(i);
  if (!history) return nullptr;
  if (!m_cellInfoCache[i]) {
    const CellInfo* ci=history->cellInfo();
    if (ci) {
      m_cellInfoCache[i]=std::make_unique<CellInfo>(*ci,false);
    }
  }
  //  m_cellInfoCache[i] = (history->cellInfo() ? new CellInfo(*history->cellInfo(), false) : new CellInfo());
  return history;
}

nRuns()

unsigned int MultiTreeAccessor::nRuns ( ) const

overridevirtual

Implements LArSamples::Accessor.

Definition at line 139 of file MultiTreeAccessor.cxx.

{
  unsigned int n = 0;
  for (const std::unique_ptr<const TreeAccessor>& accessor : m_accessors)
     n += accessor->nRuns();
  return n;
}

open()

std::unique_ptr< MultiTreeAccessor > MultiTreeAccessor::open ( const std::vector< TString > & files )

static

Definition at line 32 of file MultiTreeAccessor.cxx.

{
  std::vector<std::unique_ptr<const TreeAccessor> > accessors;
  for (const TString& fileName : files) {
    std::unique_ptr<const TreeAccessor> accessor = TreeAccessor::open(fileName);
    if (!accessor) {
      cout << "Skipping invalid file " << fileName << endl;
      continue;
    }
    accessors.push_back(std::move(accessor));
  }
  
  if (accessors.empty()) return nullptr;
  return std::make_unique<MultiTreeAccessor>(std::move(accessors));
}

openList()

std::unique_ptr< MultiTreeAccessor > MultiTreeAccessor::openList ( const TString & fileList )

static

Definition at line 49 of file MultiTreeAccessor.cxx.

{
  std::ifstream f(fileList);
  if (!f) {
    cout << "file " << fileList << " not accessible" << endl;
    return nullptr;
  }
 
  std::string fileName;  
  unsigned int i = 0;
 
  std::vector<std::unique_ptr<const TreeAccessor> > accessors;
  
  while (f >> fileName) {
    std::unique_ptr<const TreeAccessor> accessor = TreeAccessor::open(fileName.c_str());
    if (!accessor) {
      cout << "Skipping invalid file " << fileName << endl;
      continue;
    }
    cout << std::setw(2) << ++i << " - " << fileName << endl;
    accessors.push_back(std::move(accessor));
  }
  
  if (accessors.empty()) return nullptr;
  return std::make_unique<MultiTreeAccessor>(std::move(accessors));
}

openWild()

std::unique_ptr< MultiTreeAccessor > MultiTreeAccessor::openWild ( const TString & wcName )

static

Definition at line 77 of file MultiTreeAccessor.cxx.

{
  // Piggyback on TChain wildcarding feature...
  TChain chain("");
  chain.Add(wcName);
  
  std::vector<std::unique_ptr<const TreeAccessor> > accessors;
  
  for (int i = 0; i < chain.GetListOfFiles()->GetEntries(); i++) {
    std::string fileName = chain.GetListOfFiles()->At(i)->GetTitle();
    std::unique_ptr<const TreeAccessor> accessor = TreeAccessor::open(fileName.c_str());
    if (!accessor) {
      cout << "Skipping invalid file " << fileName << endl;
      continue;
    }
    cout << std::setw(2) << i+1 << " - " << fileName <<  " , nEvents = " << accessor->nEvents() << ", nRuns = " << accessor->nRuns() << endl;
    accessors.push_back(std::move(accessor));
  }
  
  if (accessors.empty()) return nullptr;
  return std::make_unique<MultiTreeAccessor>(std::move(accessors));
}

pass()

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

inherited

Definition at line 96 of file AbsLArCells.cxx.

{ 
  //std::cout << "Called AbsLArCells with hash " << i  << std::endl;
  if (!f.passHash(i)) return nullptr;
  std::unique_ptr<const CellInfo> info = cellInfo(i);
  if (!info) {
    return nullptr;
  }
  //std::cout << "Called AbsLArCells::pass on a cell belonging to " << Id::str(info->calo()) << std::endl;
  bool result = f.passCell(*info);
  return result ? cellHistory(i) : nullptr;
}

resetCache()

void AbsLArCells::resetCache ( ) const

virtualinherited

Definition at line 32 of file AbsLArCells.cxx.

{
  m_cellCache.reset();
  m_pos = nChannels() + 1;
}

runData()

const RunData * MultiTreeAccessor::runData ( unsigned int i ) const

overridevirtual

Implements LArSamples::Accessor.

Definition at line 118 of file MultiTreeAccessor.cxx.

{ 
  unsigned int nRunsSoFar = 0;
  for (const std::unique_ptr<const TreeAccessor>& accessor : m_accessors) {
    unsigned int n = accessor->nRuns();
    if (i < nRunsSoFar + n) return accessor->runData(i - nRunsSoFar);
    nRunsSoFar += n;
  }
  return nullptr;
}

writeToFile()

bool MultiTreeAccessor::writeToFile ( const TString & fileName ) const

overridevirtual

Implements LArSamples::Accessor.

Definition at line 260 of file MultiTreeAccessor.cxx.

{
  std::vector<const Accessor*> accessors;
  for (unsigned int i = 0; i < m_accessors.size(); i++)
    accessors.push_back(m_accessors[i].get());
  cout << "Merging data..." << endl;
  std::unique_ptr<TreeAccessor> singleContainer = TreeAccessor::merge(accessors, fileName);
  return !!singleContainer;
}

Member Data Documentation

m_accessors

std::vector<std::unique_ptr<const TreeAccessor> > LArSamples::MultiTreeAccessor::m_accessors

private

Definition at line 64 of file MultiTreeAccessor.h.

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_pos

unsigned int LArSamples::AbsLArCells::m_pos

mutableprivateinherited

Definition at line 54 of file AbsLArCells.h.

---

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

• MultiTreeAccessor.h
• MultiTreeAccessor.cxx