FWFileEntry Class Reference

#include <FWFileEntry.h>

Classes
struct	Filter

Public Member Functions
void	closeFile ()
fwlite::Event *	event ()
TFile *	file ()
std::list< Filter * > &	filters ()
int	firstSelectedEvent ()
	FWFileEntry (const std::string &name, bool checkVersion, bool checkGlobalTag)
FWTTreeCache *	fwTreeCache ()
const std::string &	getGlobalTag () const
FWTEventList *	globalSelection ()
bool	hasActiveFilters ()
bool	hasSelectedEvents ()
bool	isEventSelected (int event)
int	lastEvent ()
int	lastSelectedEvent ()
void	needUpdate ()
void	NewEventItemCallIn (const FWEventItem *it)
int	nextSelectedEvent (int event)
void	openFile (bool, bool)
int	previousSelectedEvent (int event)
void	RemovingEventItemCallIn (const FWEventItem *it)
TTree *	tree ()
void	updateFilters (const FWEventItemsManager *eiMng, bool isOR)
virtual	~FWFileEntry ()

Private Member Functions
bool	filterEventsWithCustomParser (Filter *filter)
	FWFileEntry (const FWFileEntry &)=delete
std::string	getBranchName (const FWEventItem *it) const
const FWFileEntry &	operator= (const FWFileEntry &)=delete
void	runFilter (Filter *fe, const FWEventItemsManager *eiMng)

Private Attributes
fwlite::Event *	m_event
TTree *	m_eventTree
TFile *	m_file
std::list< Filter * >	m_filterEntries
FWTEventList *	m_globalEventList
std::string	m_globalTag
std::string	m_name
bool	m_needUpdate

Detailed Description

Definition at line 36 of file FWFileEntry.h.

Constructor & Destructor Documentation

FWFileEntry() [1/2]

FWFileEntry::FWFileEntry	(	const std::string &	name,
		bool	checkVersion,
		bool	checkGlobalTag
	)

Definition at line 35 of file FWFileEntry.cc.

    : m_name(name),
      m_file(nullptr),
      m_eventTree(nullptr),
      m_event(nullptr),
      m_needUpdate(true),
      m_globalTag("gt_undef"),
      m_globalEventList(nullptr) {
  openFile(checkVersion, checkGT);
}

References openFile().

~FWFileEntry()

FWFileEntry::~FWFileEntry ( )

virtual

Definition at line 46 of file FWFileEntry.cc.

                          {
  for (std::list<Filter*>::iterator i = m_filterEntries.begin(); i != m_filterEntries.end(); ++i)
    delete (*i)->m_eventList;
 
  delete m_globalEventList;
}

References mps_fire::i, m_filterEntries, and m_globalEventList.

FWFileEntry() [2/2]

FWFileEntry::FWFileEntry ( const FWFileEntry &  )

privatedelete

Member Function Documentation

closeFile()

void FWFileEntry::closeFile

(

)

Definition at line 214 of file FWFileEntry.cc.

                            {
  if (m_file) {
    printf("Reading %lld bytes in %d transactions.\n", m_file->GetBytesRead(), m_file->GetReadCalls());
    delete m_file->GetCacheRead(m_eventTree);
 
    m_file->Close();
    delete m_file;
  }
  if (m_event)
    delete m_event;
}

References m_event, m_eventTree, and m_file.

event()

fwlite::Event* FWFileEntry::event ( )

inline

Definition at line 53 of file FWFileEntry.h.

{ return m_event; }

References m_event.

Referenced by Types.EventID::cppID().

file()

TFile* FWFileEntry::file ( )

inline

Definition at line 52 of file FWFileEntry.h.

{ return m_file; }

References m_file.

filterEventsWithCustomParser()

bool FWFileEntry::filterEventsWithCustomParser ( Filter *  filter )

private

Definition at line 456 of file FWFileEntry.cc.

                                                                  {
  std::string selection(filterEntry->m_selector->m_expression);
 
  boost::regex re_spaces("\\s+");
  selection = boost::regex_replace(selection, re_spaces, "");
  if (selection.find("&&") != std::string::npos && selection.find("||") != std::string::npos) {
    // Combination of && and || operators not supported.
    return false;
  }
 
  fwlite::Handle<edm::TriggerResults> hTriggerResults;
  edm::TriggerNames const* triggerNames(nullptr);
  try {
    hTriggerResults.getByLabel(*m_event, "TriggerResults", "", filterEntry->m_selector->m_triggerProcess.c_str());
    triggerNames = &(m_event->triggerNames(*hTriggerResults));
  } catch (...) {
    fwLog(fwlog::kWarning) << " failed to get trigger results with process name "
                           << filterEntry->m_selector->m_triggerProcess << std::endl;
    return false;
  }
 
  // std::cout << "Number of trigger names: " << triggerNames->size() << std::endl;
  // for (unsigned int i=0; i<triggerNames->size(); ++i)
  //  std::cout << " " << triggerNames->triggerName(i);
  //std::cout << std::endl;
 
  bool junction_mode = true;  // AND
  if (selection.find("||") != std::string::npos)
    junction_mode = false;  // OR
 
  boost::regex re("\\&\\&|\\|\\|");
 
  boost::sregex_token_iterator i(selection.begin(), selection.end(), re, -1);
  boost::sregex_token_iterator j;
 
  // filters and how they enter in the logical expression
  std::vector<std::pair<unsigned int, bool>> filters;
 
  while (i != j) {
    std::string filter = *i++;
    bool flag = true;
    if (filter[0] == '!') {
      flag = false;
      filter.erase(filter.begin());
    }
    unsigned int index = triggerNames->triggerIndex(filter);
    if (index == triggerNames->size()) {
      // Trigger name not found.
      return false;
    }
    filters.push_back(std::make_pair(index, flag));
  }
  if (filters.empty())
    return false;
 
  if (filterEntry->m_eventList)
    filterEntry->m_eventList->Reset();
  else
    filterEntry->m_eventList = new FWTEventList();
  FWTEventList* list = filterEntry->m_eventList;
 
  // loop over events
  edm::EventID currentEvent = m_event->id();
  unsigned int iEvent = 0;
 
  for (m_event->toBegin(); !m_event->atEnd(); ++(*m_event)) {
    hTriggerResults.getByLabel(*m_event, "TriggerResults", "", filterEntry->m_selector->m_triggerProcess.c_str());
    std::vector<std::pair<unsigned int, bool>>::const_iterator filter = filters.begin();
    bool passed = hTriggerResults->accept(filter->first) == filter->second;
    while (++filter != filters.end()) {
      if (junction_mode)
        passed &= hTriggerResults->accept(filter->first) == filter->second;
      else
        passed |= hTriggerResults->accept(filter->first) == filter->second;
    }
    if (passed)
      list->Enter(iEvent);
    ++iEvent;
  }
  m_event->to(currentEvent);
 
  filterEntry->m_needsUpdate = false;
 
  fwLog(fwlog::kDebug) << "FWFile::filterEventsWithCustomParser file [" << m_file->GetName() << "], filter ["
                       << filterEntry->m_selector->m_expression << "], selected [" << list->GetN() << "]" << std::endl;
 
  return true;
}

References edm::HLTGlobalStatus::accept(), fwlite::Event::atEnd(), ALCARECOTkAlBeamHalo_cff::filter, filters(), RemoveAddSevLevel::flag, fwLog, fwlite::Handle< T >::getByLabel(), mps_fire::i, edm::EventBase::id(), iEvent, dqmiolumiharvest::j, fwlog::kDebug, fwlog::kWarning, list(), m_event, FWFileEntry::Filter::m_eventList, FWEventSelector::m_expression, m_file, FWFileEntry::Filter::m_needsUpdate, FWFileEntry::Filter::m_selector, FWEventSelector::m_triggerProcess, TriggerAnalyzer::passed, corrVsCorr::selection, AlCaHLTBitMon_QueryRunRegistry::string, fwlite::Event::to(), fwlite::Event::toBegin(), L1TEGammaOffline_cfi::triggerNames, and fwlite::Event::triggerNames().

Referenced by runFilter().

filters()

std::list<Filter*>& FWFileEntry::filters ( )

inline

Definition at line 58 of file FWFileEntry.h.

{ return m_filterEntries; }

References m_filterEntries.

Referenced by filterEventsWithCustomParser().

firstSelectedEvent()

int FWFileEntry::firstSelectedEvent

(

)

Definition at line 235 of file FWFileEntry.cc.

                                    {
  if (m_globalEventList->GetN() > 0) {
    return m_globalEventList->GetEntry(0);
  } else {
    return -1;
  }
}

References m_globalEventList.

fwTreeCache()

FWTTreeCache * FWFileEntry::fwTreeCache

(

)

Definition at line 547 of file FWFileEntry.cc.

                                       {
  FWTTreeCache* tc = dynamic_cast<FWTTreeCache*>(m_file->GetCacheRead(m_eventTree));
  assert(tc != nullptr && "FWFileEntry::treeCache can not access TTreeCache");
  return tc;
}

References cms::cuda::assert(), m_eventTree, and m_file.

Referenced by NewEventItemCallIn(), and RemovingEventItemCallIn().

getBranchName()

std::string FWFileEntry::getBranchName ( const FWEventItem *  it ) const

private

Definition at line 553 of file FWFileEntry.cc.

                                                                {
  const edm::TypeWithDict elementType(const_cast<TClass*>(it->type()));
  const edm::TypeWithDict wrapperType = edm::TypeWithDict::byName(edm::wrappedClassName(elementType.name()));
  return m_event->getBranchNameFor(
      wrapperType.typeInfo(), it->moduleLabel().c_str(), it->productInstanceLabel().c_str(), it->processName().c_str());
}

References edm::TypeWithDict::byName(), fwlite::Event::getBranchNameFor(), m_event, FWEventItem::moduleLabel(), edm::TypeWithDict::name(), FWEventItem::processName(), FWEventItem::productInstanceLabel(), FWEventItem::type(), edm::TypeWithDict::typeInfo(), and edm::wrappedClassName().

Referenced by NewEventItemCallIn(), and RemovingEventItemCallIn().

getGlobalTag()

const std::string& FWFileEntry::getGlobalTag ( ) const

inline

Definition at line 60 of file FWFileEntry.h.

{ return m_globalTag; }

References m_globalTag.

globalSelection()

FWTEventList* FWFileEntry::globalSelection ( )

inline

Definition at line 55 of file FWFileEntry.h.

{ return m_globalEventList; }

References m_globalEventList.

hasActiveFilters()

bool FWFileEntry::hasActiveFilters

(

)

Definition at line 281 of file FWFileEntry.cc.

                                   {
  for (std::list<Filter*>::iterator it = m_filterEntries.begin(); it != m_filterEntries.end(); ++it) {
    if ((*it)->m_selector->m_enabled)
      return true;
  }
 
  return false;
}

References m_filterEntries.

hasSelectedEvents()

bool FWFileEntry::hasSelectedEvents

(

)

Definition at line 233 of file FWFileEntry.cc.

{ return m_globalEventList->GetN() > 0; }

References m_globalEventList.

isEventSelected()

bool FWFileEntry::isEventSelected

(

int

event

)

Definition at line 228 of file FWFileEntry.cc.

                                                {
  int idx = m_globalEventList->GetIndex(tree_entry);
  return idx >= 0;
}

References training_settings::idx, and m_globalEventList.

lastEvent()

int FWFileEntry::lastEvent ( )

inline

Definition at line 74 of file FWFileEntry.h.

{ return m_eventTree->GetEntries() - 1; }

References m_eventTree.

lastSelectedEvent()

int FWFileEntry::lastSelectedEvent

(

)

Definition at line 243 of file FWFileEntry.cc.

                                   {
  if (m_globalEventList->GetN() > 0)
    return m_globalEventList->GetEntry(m_globalEventList->GetN() - 1);
  else
    return -1;
}

References m_globalEventList.

needUpdate()

void FWFileEntry::needUpdate ( )

inline

Definition at line 79 of file FWFileEntry.h.

{ m_needUpdate = true; }

References m_needUpdate.

NewEventItemCallIn()

void FWFileEntry::NewEventItemCallIn

(

const FWEventItem *

it

)

Definition at line 560 of file FWFileEntry.cc.

                                                          {
  auto tc = fwTreeCache();
 
  if (FWTTreeCache::IsLogging())
    printf("FWFileEntry:NewEventItemCallIn FWEventItem %s, learning=%d\n", getBranchName(it).c_str(), tc->IsLearning());
 
  tc->AddBranchTopLevel(getBranchName(it).c_str());
}

References fwTreeCache(), getBranchName(), and FWTTreeCache::IsLogging().

Referenced by openFile().

nextSelectedEvent()

int FWFileEntry::nextSelectedEvent

(

int

event

)

Definition at line 250 of file FWFileEntry.cc.

                                                 {
  // Find next selected event after the current one.
  // This returns the index in the selected event list.
  // If none exists -1 is returned.
 
  const Long64_t* list = m_globalEventList->GetList();
  Long64_t val = tree_entry;
  Long64_t idx = TMath::BinarySearch(m_globalEventList->GetN(), list, val);
  ++idx;
  if (idx >= m_globalEventList->GetN() || idx < 0)
    return -1;
  return list[idx];
}

References training_settings::idx, list(), m_globalEventList, and heppy_batch::val.

openFile()

void FWFileEntry::openFile	(	bool	checkVersion,
		bool	checkGlobalTag
	)

Definition at line 53 of file FWFileEntry.cc.

                                                                 {
  gErrorIgnoreLevel = 3000;  // suppress warnings about missing dictionaries
 
  TFile* newFile = TFile::Open(m_name.c_str());
 
  if (newFile == nullptr || newFile->IsZombie() || !newFile->Get("Events")) {
    //  std::cout << "Invalid file. Ignored." << std::endl;
    // return false;
    throw std::runtime_error("Invalid file. Ignored.");
  }
 
  m_file = newFile;
 
  gErrorIgnoreLevel = -1;
 
  // check CMSSW relese version for compatibility
  typedef std::vector<edm::ProcessHistory> provList;
 
  TTree* metaData = dynamic_cast<TTree*>(m_file->Get("MetaData"));
  TBranch* b = metaData->GetBranch("ProcessHistory");
  edm::ProcessHistoryVector phv_;
  edm::ProcessHistoryVector* pPhv = &phv_;
  metaData->SetBranchAddress("ProcessHistory", &pPhv);
 
  b->GetEntry(0);
 
  typedef std::map<edm::ParameterSetID, edm::ParameterSetBlob> ParameterSetMap;
  ParameterSetMap psm_;
  TTree* psetTree = dynamic_cast<TTree*>(newFile->Get("ParameterSets"));
  typedef std::pair<edm::ParameterSetID, edm::ParameterSetBlob> IdToBlobs;
  IdToBlobs idToBlob;
  IdToBlobs* pIdToBlob = &idToBlob;
  psetTree->SetBranchAddress("IdToParameterSetsBlobs", &pIdToBlob);
  for (long long i = 0; i != psetTree->GetEntries(); ++i) {
    psetTree->GetEntry(i);
    psm_.insert(idToBlob);
  }
 
  edm::pset::Registry& psetRegistry = *edm::pset::Registry::instance();
  for (auto const& item : psm_) {
    edm::ParameterSet pset(item.second.pset());
    pset.setID(item.first);
    psetRegistry.insertMapped(pset);
  }
 
  const edm::ProcessConfiguration* dd = nullptr;
  int latestVersion = 0;
  int currentVersionArr[] = {0, 0, 0};
  for (auto const& processHistory : phv_) {
    for (auto const& processConfiguration : processHistory) {
      // std::cout << processConfiguration.releaseVersion() << "  " << processConfiguration.processName() << std::endl;
      TString dcv = processConfiguration.releaseVersion();
      fireworks::getDecomposedVersion(dcv, currentVersionArr);
      int nvv = currentVersionArr[0] * 100 + currentVersionArr[1] * 10 + currentVersionArr[2];
      if (nvv > latestVersion) {
        latestVersion = nvv;
        dd = &processConfiguration;
      }
    }
  }
 
  // read first global tag for auto detect of geomtery version
  if (checkGlobalTag) {
    std::map<edm::ProcessConfigurationID, unsigned int> simpleIDs;
    m_globalTag = "";
    for (auto const& ph : phv_) {
      for (auto const& pc : ph) {
        unsigned int id = simpleIDs[pc.id()];
        if (0 == id) {
          id = 1;
          simpleIDs[pc.id()] = id;
        }
        ParameterSetMap::const_iterator itFind = psm_.find(pc.parameterSetID());
        if (itFind == psm_.end()) {
          std::cout << "No ParameterSetID for " << pc.parameterSetID() << std::endl;
          fwLog(fwlog::kInfo) << "FWFileEntry::openFile no ParameterSetID for " << pc.parameterSetID() << std::endl;
        } else {
          edm::ParameterSet processConfig(itFind->second.pset());
          std::vector<std::string> sourceStrings, moduleStrings;
          std::vector<std::string> sources = processConfig.getParameter<std::vector<std::string>>("@all_essources");
          for (auto& itM : sources) {
            edm::ParameterSet const& pset = processConfig.getParameterSet(itM);
            std::string name(pset.getParameter<std::string>("@module_label"));
            if (name.empty()) {
              name = pset.getParameter<std::string>("@module_type");
            }
            if (name != "GlobalTag")
              continue;
 
            for (auto const& item : pset.tbl()) {
              if (item.first == "globaltag") {
                m_globalTag = item.second.getString();
                goto gtEnd;
              }
            }
          }
        }
      }
    }
 
  gtEnd:
    fwLog(fwlog::kDebug) << "FWFileEntry::openFile detected global tag " << m_globalTag << "\n";
  }
 
  // test compatibility of data with CMSSW
  if (checkVersion) {
    if (latestVersion) {
      fwLog(fwlog::kInfo) << "Checking process history. " << m_name.c_str() << " latest process \"" << dd->processName()
                          << "\", version " << dd->releaseVersion() << std::endl;
 
      b->SetAddress(nullptr);
      TString v = dd->releaseVersion();
      if (!fireworks::acceptDataFormatsVersion(v)) {
        int* di = (fireworks::supportedDataFormatsVersion());
        TString msg = Form(
            "incompatible data: Process version does not mactch major data formats version. File produced with %s. "
            "Data formats version \"CMSSW_%d_%d_%d\".\n",
            dd->releaseVersion().c_str(),
            di[0],
            di[1],
            di[2]);
        msg += "Use --no-version-check option if you still want to view the file.\n";
        throw std::runtime_error(msg.Data());
      }
    } else {
      TString msg = "No process history available\n";
      msg += "Use --no-version-check option if you still want to view the file.\n";
      throw std::runtime_error(msg.Data());
    }
  }
 
  m_eventTree = dynamic_cast<TTree*>(m_file->Get("Events"));
 
  if (m_eventTree == nullptr) {
    throw std::runtime_error("Cannot find TTree 'Events' in the data file");
  }
 
  // Initialize caching, this helps also in the case of local file.
  if (FWTTreeCache::IsLogging())
    printf("FWFileEntry::openFile enabling FWTTreeCache for file class '%s'.", m_file->ClassName());
 
  auto tc = new FWTTreeCache(m_eventTree, FWTTreeCache::GetDefaultCacheSize());
  m_file->SetCacheRead(tc, m_eventTree);
  tc->SetEnablePrefetching(FWTTreeCache::IsPrefetching());
  tc->SetLearnEntries(20);
  tc->SetLearnPrefill(TTreeCache::kAllBranches);
  tc->StartLearningPhase();
 
  // load event, set DataGetterHelper callback for branch access
  m_event = new fwlite::Event(m_file, false, [tc](TBranch const& b) { tc->BranchAccessCallIn(&b); });
 
  // Connect to collection add/remove signals
  FWEventItemsManager* eiMng = (FWEventItemsManager*)FWGUIManager::getGUIManager()->getContext()->eventItemsManager();
  eiMng->newItem_.connect(boost::bind(&FWFileEntry::NewEventItemCallIn, this, _1));
  eiMng->removingItem_.connect(boost::bind(&FWFileEntry::RemovingEventItemCallIn, this, _1));
  // no need to connect to goingToClearItems_ ... individual removes are emitted.
 
  if (m_event->size() == 0)
    throw std::runtime_error("fwlite::Event size == 0");
}

References fireworks::acceptDataFormatsVersion(), b, gather_cfg::cout, createTree::dd, fireworks::Context::eventItemsManager(), fwLog, utils::gErrorIgnoreLevel, FWGUIManager::getContext(), fireworks::getDecomposedVersion(), FWTTreeCache::GetDefaultCacheSize(), FWGUIManager::getGUIManager(), mps_fire::i, triggerObjects_cff::id, edm::pset::Registry::insertMapped(), edm::pset::Registry::instance(), FWTTreeCache::IsLogging(), FWTTreeCache::IsPrefetching(), B2GTnPMonitor_cfi::item, fwlog::kDebug, fwlog::kInfo, m_event, m_eventTree, m_file, m_globalTag, m_name, mps_check::msg, Skims_PA_cff::name, NewEventItemCallIn(), FWEventItemsManager::newItem_, muonDTDigis_cfi::pset, RemovingEventItemCallIn(), fwlite::Event::size(), CalibrationSummaryClient_cfi::sources, AlCaHLTBitMon_QueryRunRegistry::string, fireworks::supportedDataFormatsVersion(), and findQualityFiles::v.

Referenced by FWFileEntry().

operator=()

const FWFileEntry& FWFileEntry::operator= ( const FWFileEntry &  )

privatedelete

previousSelectedEvent()

int FWFileEntry::previousSelectedEvent

(

int

event

)

Definition at line 264 of file FWFileEntry.cc.

                                                     {
  // Find first selected event before current one.
  // This returns the index in the selected event list.
  // If none exists -1 is returned.
 
  const Long64_t* list = m_globalEventList->GetList();
  Long64_t val = tree_entry;
  Long64_t idx = TMath::BinarySearch(m_globalEventList->GetN(), list, val);
  if (list[idx] == val)
    --idx;
  if (idx >= 0)
    return list[idx];
  else
    return -1;
}

References training_settings::idx, list(), m_globalEventList, and heppy_batch::val.

RemovingEventItemCallIn()

void FWFileEntry::RemovingEventItemCallIn

(

const FWEventItem *

it

)

Definition at line 569 of file FWFileEntry.cc.

                                                               {
  auto tc = fwTreeCache();
 
  if (FWTTreeCache::IsLogging())
    printf("FWFileEntry:RemovingEventItemCallIn FWEventItem %s, learning=%d\n",
           getBranchName(it).c_str(),
           tc->IsLearning());
 
  tc->DropBranchTopLevel(getBranchName(it).c_str());
}

References fwTreeCache(), getBranchName(), and FWTTreeCache::IsLogging().

Referenced by openFile().

runFilter()

void FWFileEntry::runFilter ( Filter *  fe, const FWEventItemsManager *  eiMng  )

private

Definition at line 327 of file FWFileEntry.cc.

                                                                            {
  if (!filter->m_selector->m_triggerProcess.empty()) {
    filterEventsWithCustomParser(filter);
    return;
  }
 
  // parse selection for known Fireworks expressions
  std::string interpretedSelection = filter->m_selector->m_expression;
  // list of branch names to be added to tree-cache
  std::vector<std::string> branch_names;
 
  for (FWEventItemsManager::const_iterator i = eiMng->begin(), end = eiMng->end(); i != end; ++i) {
    FWEventItem* item = *i;
    if (item == nullptr)
      continue;
    // FIXME: hack to get full branch name filled
    if (!item->hasEvent()) {
      item->setEvent(m_event);
      item->getPrimaryData();
      item->setEvent(nullptr);
    }
 
    boost::regex re(std::string("\\$") + (*i)->name());
 
    if (boost::regex_search(interpretedSelection, re)) {
      const edm::TypeWithDict elementType(const_cast<TClass*>(item->type()));
      const edm::TypeWithDict wrapperType = edm::TypeWithDict::byName(edm::wrappedClassName(elementType.name()));
      std::string fullBranchName = m_event->getBranchNameFor(wrapperType.typeInfo(),
                                                             item->moduleLabel().c_str(),
                                                             item->productInstanceLabel().c_str(),
                                                             item->processName().c_str());
 
      interpretedSelection = boost::regex_replace(interpretedSelection, re, fullBranchName + ".obj");
 
      branch_names.push_back(fullBranchName);
 
      // printf("selection after applying s/%s/%s/: %s\n",
      //     (std::string("\\$") + (*i)->name()).c_str(),
      //     ((*i)->m_fullBranchName + ".obj").c_str(),
      //     interpretedSelection.c_str());
    }
  }
 
  std::size_t found = interpretedSelection.find('$');
  if (found != std::string::npos) {
    fwLog(fwlog::kError) << "FWFileEntry::RunFilter invalid expression " << interpretedSelection << std::endl;
    filter->m_needsUpdate = false;
    return;
  }
 
  m_file->cd();
  m_eventTree->SetEventList(nullptr);
 
  auto prevCache = m_file->GetCacheRead(m_eventTree);
 
  auto interCache = new TTreeCache(m_eventTree, 10 * 1024 * 1024);
  // Do not disconnect the cache, it will be reattached after filtering.
  m_file->SetCacheRead(interCache, m_eventTree, TFile::kDoNotDisconnect);
  interCache->SetEnablePrefetching(FWTTreeCache::IsPrefetching());
  for (auto& b : branch_names)
    interCache->AddBranch(b.c_str(), true);
  interCache->StopLearningPhase();
 
  // Since ROOT will leave any TBranches used in the filtering at the last event,
  // we need to be able to reset them to what fwlite::Event expects them to be.
  // We do this by holding onto the old buffers and create temporary new ones.
 
  std::map<TBranch*, void*> prevAddrs;
 
  {
    TObjArray* branches = m_eventTree->GetListOfBranches();
    std::unique_ptr<TIterator> pIt(branches->MakeIterator());
    while (TObject* branchObj = pIt->Next()) {
      TBranch* b = dynamic_cast<TBranch*>(branchObj);
      if (nullptr != b) {
        const char* name = b->GetName();
        unsigned int length = strlen(name);
        if (length > 1 && name[length - 1] != '.') {
          // This is not a data branch so we should ignore it.
          continue;
        }
        if (nullptr != b->GetAddress()) {
          if (prevAddrs.find(b) != prevAddrs.end()) {
            fwLog(fwlog::kWarning) << "FWFileEntry::runFilter branch is already in the map!\n";
          }
          prevAddrs.insert(std::make_pair(b, b->GetAddress()));
 
          // std::cout <<"Zeroing branch: "<< b->GetName() <<" "<< (void*) b->GetAddress() <<std::endl;
          b->SetAddress(nullptr);
        }
      }
    }
  }
 
  if (filter->m_eventList)
    filter->m_eventList->Reset();
  else
    filter->m_eventList = new FWTEventList;
 
  fwLog(fwlog::kInfo) << "FWFileEntry::runFilter Running filter " << interpretedSelection << "' "
                      << "for file '" << m_file->GetName() << "'.\n";
 
  TEveSelectorToEventList stoelist(filter->m_eventList, interpretedSelection.c_str());
  Long64_t result = m_eventTree->Process(&stoelist);
 
  if (result < 0)
    fwLog(fwlog::kWarning) << "FWFileEntry::runFilter in file [" << m_file->GetName() << "] filter ["
                           << filter->m_selector->m_expression << "] is invalid." << std::endl;
  else
    fwLog(fwlog::kDebug) << "FWFileEntry::runFilter is file [" << m_file->GetName() << "], filter ["
                         << filter->m_selector->m_expression << "] has [" << filter->m_eventList->GetN()
                         << "] events selected" << std::endl;
 
  // Set back the old branch buffers.
  {
    for (auto i : prevAddrs) {
      // std::cout <<"Resetting branch: "<< i.first->GetName() <<" "<< i.second <<std::endl;
      i.first->SetAddress(i.second);
    }
  }
 
  m_file->SetCacheRead(prevCache, m_eventTree);
  delete interCache;
 
  filter->m_needsUpdate = false;
}

References b, FWEventItemsManager::begin(), edm::TypeWithDict::byName(), end, FWEventItemsManager::end(), ALCARECOTkAlBeamHalo_cff::filter, filterEventsWithCustomParser(), newFWLiteAna::found, fwLog, fwlite::Event::getBranchNameFor(), mps_fire::i, FWTTreeCache::IsPrefetching(), B2GTnPMonitor_cfi::item, fwlog::kDebug, fwlog::kError, fwlog::kInfo, fwlog::kWarning, m_event, m_eventTree, m_file, Skims_PA_cff::name, edm::TypeWithDict::name(), mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, edm::TypeWithDict::typeInfo(), and edm::wrappedClassName().

Referenced by updateFilters().

tree()

TTree* FWFileEntry::tree ( )

inline

Definition at line 54 of file FWFileEntry.h.

{ return m_eventTree; }

References m_eventTree.

Referenced by ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::beginLoop(), MetTreeProducer.MetTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::fillTree(), ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::process(), MetTreeProducer.MetTreeProducer::process(), and python.cmstools.EventTree::SetAlias().

updateFilters()

void FWFileEntry::updateFilters	(	const FWEventItemsManager *	eiMng,
		bool	isOR
	)

Definition at line 291 of file FWFileEntry.cc.

                                                                               {
  if (!m_needUpdate)
    return;
 
  if (m_globalEventList)
    m_globalEventList->Reset();
  else
    m_globalEventList = new FWTEventList;
 
  for (std::list<Filter*>::iterator it = m_filterEntries.begin(); it != m_filterEntries.end(); ++it) {
    if ((*it)->m_selector->m_enabled && (*it)->m_needsUpdate) {
      runFilter(*it, eiMng);
    }
    // Need to re-check if enabled after filtering as it can be set to false
    // in runFilter().
    if ((*it)->m_selector->m_enabled) {
      if ((*it)->hasSelectedEvents()) {
        if (globalOR || m_globalEventList->GetN() == 0) {
          m_globalEventList->Add((*it)->m_eventList);
        } else {
          m_globalEventList->Intersect((*it)->m_eventList);
        }
      } else if (!globalOR) {
        m_globalEventList->Reset();
        break;
      }
    }
  }
 
  fwLog(fwlog::kDebug) << "FWFileEntry::updateFilters in [" << m_file->GetName() << "]  global selection ["
                       << m_globalEventList->GetN() << "/" << m_eventTree->GetEntries() << "]" << std::endl;
 
  m_needUpdate = false;
}

References FWTEventList::Add(), fwLog, fwlog::kDebug, m_eventTree, m_file, m_filterEntries, m_globalEventList, m_needUpdate, and runFilter().

Member Data Documentation

m_event

fwlite::Event* FWFileEntry::m_event

private

Definition at line 98 of file FWFileEntry.h.

Referenced by closeFile(), event(), filterEventsWithCustomParser(), getBranchName(), openFile(), and runFilter().

m_eventTree

TTree* FWFileEntry::m_eventTree

private

Definition at line 97 of file FWFileEntry.h.

Referenced by closeFile(), fwTreeCache(), lastEvent(), openFile(), runFilter(), tree(), and updateFilters().

m_file

TFile* FWFileEntry::m_file

private

Definition at line 96 of file FWFileEntry.h.

Referenced by closeFile(), file(), filterEventsWithCustomParser(), fwTreeCache(), openFile(), runFilter(), and updateFilters().

m_filterEntries

std::list<Filter*> FWFileEntry::m_filterEntries

private

Definition at line 103 of file FWFileEntry.h.

Referenced by filters(), hasActiveFilters(), updateFilters(), and ~FWFileEntry().

m_globalEventList

FWTEventList* FWFileEntry::m_globalEventList

private

Definition at line 104 of file FWFileEntry.h.

Referenced by firstSelectedEvent(), globalSelection(), hasSelectedEvents(), isEventSelected(), lastSelectedEvent(), nextSelectedEvent(), previousSelectedEvent(), updateFilters(), and ~FWFileEntry().

m_globalTag

std::string FWFileEntry::m_globalTag

private

Definition at line 101 of file FWFileEntry.h.

Referenced by getGlobalTag(), and openFile().

m_name

std::string FWFileEntry::m_name

private

Definition at line 95 of file FWFileEntry.h.

Referenced by openFile().

m_needUpdate

bool FWFileEntry::m_needUpdate

private

Definition at line 100 of file FWFileEntry.h.

Referenced by needUpdate(), and updateFilters().