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)
FWTTreeCache *	fwTreeCache ()
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)
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_name
bool	m_needUpdate

Detailed Description

Definition at line 36 of file FWFileEntry.h.

Constructor & Destructor Documentation

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

Definition at line 30 of file FWFileEntry.cc.

References openFile().

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

FWFileEntry::~FWFileEntry ( )

virtual

Definition at line 37 of file FWFileEntry.cc.

References mps_fire::i, m_filterEntries, and m_globalEventList.

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

   delete m_globalEventList;
}

FWFileEntry::FWFileEntry ( const FWFileEntry &  )

privatedelete

Member Function Documentation

void FWFileEntry::closeFile

(

)

Definition at line 141 of file FWFileEntry.cc.

References m_event, m_eventTree, and m_file.

Referenced by CmsShowNavigator::appendFile(), CmsShowNavigator::openFile(), and Vispa.Main.Application.Application::tabCloseRequest().

{
   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;
}

fwlite::Event* FWFileEntry::event ( )

inline

Definition at line 60 of file FWFileEntry.h.

Referenced by Types.EventID::cppID().

{ return m_event; }

TFile* FWFileEntry::file ( )

inline

Definition at line 59 of file FWFileEntry.h.

{ return m_file; }

bool FWFileEntry::filterEventsWithCustomParser ( Filter *  filter )

private

Definition at line 419 of file FWFileEntry.cc.

References edm::HLTGlobalStatus::accept(), fwlite::Event::atEnd(), FWTEventList::Enter(), ALCARECOTkAlBeamHalo_cff::filter, filters(), RemoveAddSevLevel::flag, fwLog, fwlite::Handle< T >::getByLabel(), mps_fire::i, edm::EventBase::id(), iEvent, 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, edm::TriggerNames::size(), AlCaHLTBitMon_QueryRunRegistry::string, fwlite::Event::to(), fwlite::Event::toBegin(), edm::TriggerNames::triggerIndex(), and fwlite::Event::triggerNames().

Referenced by runFilter().

{
   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;
}

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

inline

Definition at line 65 of file FWFileEntry.h.

Referenced by CmsShowNavigator::appendFile(), filterEventsWithCustomParser(), and CmsShowNavigator::openFile().

{ return m_filterEntries; }

int FWFileEntry::firstSelectedEvent

(

)

Definition at line 167 of file FWFileEntry.cc.

References m_globalEventList.

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

FWTTreeCache * FWFileEntry::fwTreeCache

(

)

Definition at line 519 of file FWFileEntry.cc.

References m_eventTree, m_file, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by NewEventItemCallIn(), and RemovingEventItemCallIn().

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

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

private

Definition at line 527 of file FWFileEntry.cc.

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().

{   
   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());
}

FWTEventList* FWFileEntry::globalSelection ( )

inline

Definition at line 62 of file FWFileEntry.h.

{ return m_globalEventList; }

bool FWFileEntry::hasActiveFilters

(

)

Definition at line 220 of file FWFileEntry.cc.

References m_filterEntries.

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

   return false;
}

bool FWFileEntry::hasSelectedEvents

(

)

Definition at line 162 of file FWFileEntry.cc.

References m_globalEventList.

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

bool FWFileEntry::isEventSelected

(

int

event

)

Definition at line 156 of file FWFileEntry.cc.

References training_settings::idx, and m_globalEventList.

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

int FWFileEntry::lastEvent ( )

inline

Definition at line 79 of file FWFileEntry.h.

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

int FWFileEntry::lastSelectedEvent

(

)

Definition at line 179 of file FWFileEntry.cc.

References m_globalEventList.

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

void FWFileEntry::needUpdate ( )

inline

Definition at line 84 of file FWFileEntry.h.

References ALCARECOTkAlBeamHalo_cff::filter, and AlCaHLTBitMon_QueryRunRegistry::string.

{ m_needUpdate = true; }

void FWFileEntry::NewEventItemCallIn

(

const FWEventItem *

it

)

Definition at line 537 of file FWFileEntry.cc.

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

Referenced by openFile().

{
   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());
}

int FWFileEntry::nextSelectedEvent

(

int

event

)

Definition at line 187 of file FWFileEntry.cc.

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

{
   // 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];
}

void FWFileEntry::openFile

(

bool

checkVersion

)

Definition at line 45 of file FWFileEntry.cc.

References fireworks::acceptDataFormatsVersion(), b, fireworks::Context::eventItemsManager(), fwLog, utils::gErrorIgnoreLevel, FWGUIManager::getContext(), fireworks::getDecomposedVersion(), FWTTreeCache::GetDefaultCacheSize(), FWGUIManager::getGUIManager(), FWTTreeCache::IsLogging(), FWTTreeCache::IsPrefetching(), fwlog::kInfo, m_event, m_eventTree, m_file, m_name, mps_check::msg, NewEventItemCallIn(), FWEventItemsManager::newItem_, edm::ProcessConfiguration::processName(), edm::ProcessConfiguration::releaseVersion(), RemovingEventItemCallIn(), fwlite::Event::size(), fireworks::supportedDataFormatsVersion(), findQualityFiles::v, and x.

Referenced by Vispa.Main.Application.Application::_readCommandLineAttributes(), Vispa.Main.Application.Application::doubleClickOnFile(), FWFileEntry(), Vispa.Main.Application.Application::openFileDialog(), and Vispa.Main.Application.Application::openRecentFileSlot().

{
   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
   if (checkVersion) {
      typedef std::vector<edm::ProcessHistory> provList;
  
      TTree   *metaData = dynamic_cast<TTree*>(m_file->Get("MetaData"));
      TBranch *b = metaData->GetBranch("ProcessHistory");
      provList *x = nullptr;
      b->SetAddress(&x);
      b->GetEntry(0);
      
      const edm::ProcessConfiguration* dd = nullptr;
      int latestVersion =0;
      int currentVersionArr[] = {0, 0, 0};
      for (auto const& processHistory : *x)
      {
         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;
            }
         }
      }

      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");
}

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

privatedelete

int FWFileEntry::previousSelectedEvent

(

int

event

)

Definition at line 202 of file FWFileEntry.cc.

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

{
   // 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;
}

void FWFileEntry::RemovingEventItemCallIn

(

const FWEventItem *

it

)

Definition at line 548 of file FWFileEntry.cc.

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

Referenced by openFile().

{
   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());
}

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

private

Definition at line 277 of file FWFileEntry.cc.

References b, FWEventItemsManager::begin(), edm::TypeWithDict::byName(), end, FWEventItemsManager::end(), filterEventsWithCustomParser(), runEdmFileComparison::found, fwLog, fwlite::Event::getBranchNameFor(), FWEventItem::getPrimaryData(), FWEventItem::hasEvent(), mps_fire::i, FWTTreeCache::IsPrefetching(), fwlog::kDebug, fwlog::kError, fwlog::kInfo, fwlog::kWarning, m_event, FWFileEntry::Filter::m_eventList, m_eventTree, FWEventSelector::m_expression, m_file, FWFileEntry::Filter::m_needsUpdate, FWFileEntry::Filter::m_selector, FWEventSelector::m_triggerProcess, FWEventItem::moduleLabel(), dataset::name, edm::TypeWithDict::name(), FWEventItem::processName(), FWEventItem::productInstanceLabel(), mps_fire::result, FWEventItem::setEvent(), AlCaHLTBitMon_QueryRunRegistry::string, FWEventItem::type(), edm::TypeWithDict::typeInfo(), and edm::wrappedClassName().

Referenced by updateFilters().

{
   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;
}

TTree* FWFileEntry::tree ( )

inline

Definition at line 61 of file FWFileEntry.h.

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().

{ return m_eventTree; }

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

Definition at line 232 of file FWFileEntry.cc.

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

{
   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;
}

Member Data Documentation

fwlite::Event* FWFileEntry::m_event

private

Definition at line 103 of file FWFileEntry.h.

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

TTree* FWFileEntry::m_eventTree

private

Definition at line 102 of file FWFileEntry.h.

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

TFile* FWFileEntry::m_file

private

Definition at line 101 of file FWFileEntry.h.

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

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

private

Definition at line 107 of file FWFileEntry.h.

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

FWTEventList* FWFileEntry::m_globalEventList

private

Definition at line 108 of file FWFileEntry.h.

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

std::string FWFileEntry::m_name

private

Definition at line 100 of file FWFileEntry.h.

Referenced by openFile().

bool FWFileEntry::m_needUpdate

private

Definition at line 105 of file FWFileEntry.h.

Referenced by updateFilters().