TFWLiteSelectorBasic Class Reference

#include <FWCore/FWLite/interface/TFWLiteSelectorBasic.h>

Inheritance diagram for TFWLiteSelectorBasic:

Public Member Functions
virtual void	begin (TList *&in)=0
virtual void	postProcessing (TList &out)=0
virtual void	preProcessing (const TList *in, TList &out)=0
virtual void	process (const edm::Event &event)=0
virtual void	terminate (TList &out)=0
	TFWLiteSelectorBasic ()
	~TFWLiteSelectorBasic () override

Private Member Functions
void	Begin (TTree *) override
void	Init (TTree *) override
Bool_t	Notify () override
const TFWLiteSelectorBasic &	operator= (const TFWLiteSelectorBasic &)
Bool_t	Process (Long64_t) override
void	setupNewFile (TFile &)
void	SlaveBegin (TTree *) override
void	SlaveTerminate () override
void	Terminate () override
	TFWLiteSelectorBasic (const TFWLiteSelectorBasic &)
Int_t	Version () const override

Private Attributes
bool	everythingOK_
edm::propagate_const< std::shared_ptr< edm::root::TFWLiteSelectorMembers > >	m_

Detailed Description

Description: A ROOT TSelector which accesses data using an edm::Event

Usage: By inheriting from this class one can make a TSelector for ROOT which works with PROOF and which allows you to access data using an edm::Event.

Definition at line 42 of file TFWLiteSelectorBasic.h.

Constructor & Destructor Documentation

TFWLiteSelectorBasic() [1/2]

TFWLiteSelectorBasic::TFWLiteSelectorBasic

(

)

Definition at line 213 of file TFWLiteSelectorBasic.cc.

: m_(new edm::root::TFWLiteSelectorMembers), everythingOK_(false) {}

~TFWLiteSelectorBasic()

TFWLiteSelectorBasic::~TFWLiteSelectorBasic ( )

override

Definition at line 220 of file TFWLiteSelectorBasic.cc.

{}

TFWLiteSelectorBasic() [2/2]

TFWLiteSelectorBasic::TFWLiteSelectorBasic ( const TFWLiteSelectorBasic &  )

private

Member Function Documentation

begin()

virtual void TFWLiteSelectorBasic::begin ( TList *&  in )

pure virtual

Called each time the 'client' begins processing (remote 'slaves' do not see this message)

Parameters

in	an assignable pointer to a list of objects you want passed to 'preProcessing'. This list is used to communicate with remote slaves. NOTE: you are responsible for deleting this TList and its content once you are done with it.

Implemented in __class__< T >, tfwliteselectortest::ThingsTSelector2, and tfwliteselectortest::ThingsTSelector.

Referenced by Begin().

Begin()

void TFWLiteSelectorBasic::Begin ( TTree *  iTree )

overrideprivate

Definition at line 237 of file TFWLiteSelectorBasic.cc.

References begin(), and Init().

                                             {
  Init(iTree);
  begin(fInput);
}

Init()

void TFWLiteSelectorBasic::Init ( TTree *  iTree )

overrideprivate

Definition at line 247 of file TFWLiteSelectorBasic.cc.

References m_.

Referenced by Begin(), and SlaveBegin().

                                            {
  if (iTree == nullptr)
    return;
  m_->setTree(iTree);
}

Notify()

Bool_t TFWLiteSelectorBasic::Notify ( )

overrideprivate

Definition at line 253 of file TFWLiteSelectorBasic.cc.

References gather_cfg::cout, everythingOK_, geometryDiff::file, m_, and setupNewFile().

                                    {
  //std::cout << "Notify start" << std::endl;
  //we have switched to a new file
  //get new file from Tree
  if (nullptr == m_->tree_) {
    std::cout << "No tree" << std::endl;
    return kFALSE;
  }
  TFile* file = m_->tree_->GetCurrentFile();
  if (nullptr == file) {
    //When in Rome, do as the Romans
    TChain* chain = dynamic_cast<TChain*>(m_->tree());
    if (nullptr == chain) {
      std::cout << "No file" << std::endl;
      return kFALSE;
    }
    file = chain->GetFile();
    if (nullptr == file) {
      std::cout << "No file" << std::endl;
      return kFALSE;
    }
  }
  setupNewFile(*file);
  return everythingOK_ ? kTRUE : kFALSE;
}

operator=()

const TFWLiteSelectorBasic& TFWLiteSelectorBasic::operator= ( const TFWLiteSelectorBasic &  )

private

postProcessing()

virtual void TFWLiteSelectorBasic::postProcessing ( TList &  out )

pure virtual

Called each time the 'slave' has seen all the events

Parameters

out	the list of objects that will be sent to 'terminate'. You can Add() additional objects to 'out' at this point as well.

Implemented in TFWLiteSelector< TWorker >, TFWLiteSelector< ThingsWorker >, TFWLiteSelector< __class__Worker >, and tfwliteselectortest::ThingsTSelector.

Referenced by SlaveTerminate().

preProcessing()

virtual void TFWLiteSelectorBasic::preProcessing ( const TList *  in, TList &  out  )

pure virtual

Called each time the 'slave' is about to start processing

Parameters

in	a pointer to the list of objects created in 'begin()'. The pointer can be 0
out	a list of objects that are the result of processing (e.g. histograms). You should call 'Add()' for each object you want sent to the 'terminate' method.

Implemented in TFWLiteSelector< TWorker >, TFWLiteSelector< ThingsWorker >, TFWLiteSelector< __class__Worker >, and tfwliteselectortest::ThingsTSelector.

Referenced by SlaveBegin().

process()

virtual void TFWLiteSelectorBasic::process ( const edm::Event &  event )

pure virtual

Call each time the 'slave' gets a new Event

Parameters

event

a standard edm::Event which works just like it does in cmsRun

Implemented in TFWLiteSelector< TWorker >, TFWLiteSelector< ThingsWorker >, TFWLiteSelector< __class__Worker >, and tfwliteselectortest::ThingsTSelector.

Referenced by Process().

Process()

Bool_t TFWLiteSelectorBasic::Process ( Long64_t  iEntry )

overrideprivate

Definition at line 290 of file TFWLiteSelectorBasic.cc.

References printConversionInfo::aux, MicroEventContent_cff::branch, edm::poolNames::branchListIndexesBranchName(), edm::BranchTypeToAuxiliaryBranchName(), gather_cfg::cout, edmPickEvents::event, edm::poolNames::eventSelectionsBranchName(), everythingOK_, cppFunctionSkipper::exception, Exception, edm::errors::FatalRootError, edm::propagate_const< T >::get(), edm::InEvent, m_, eostools::move(), and process().

                                                    {
  //std::cout << "Process start" << std::endl;
  if (everythingOK_) {
    std::unique_ptr<edm::EventAuxiliary> eaux = std::make_unique<edm::EventAuxiliary>();
    edm::EventAuxiliary& aux = *eaux;
    edm::EventAuxiliary* pAux = eaux.get();
    TBranch* branch = m_->tree_->GetBranch(edm::BranchTypeToAuxiliaryBranchName(edm::InEvent).c_str());

    branch->SetAddress(&pAux);
    branch->GetEntry(iEntry);

    //NEW      m_->processNames_ = aux.processHistory();

    //      std::cout << "ProcessNames\n";
    //      for(auto const& name : m_->processNames_) {
    //         std::cout << "  " << name << std::endl;
    //     }

    edm::EventSelectionIDVector eventSelectionIDs;
    edm::EventSelectionIDVector* pEventSelectionIDVector = &eventSelectionIDs;
    TBranch* eventSelectionsBranch = m_->tree_->GetBranch(edm::poolNames::eventSelectionsBranchName().c_str());
    if (!eventSelectionsBranch) {
      throw edm::Exception(edm::errors::FatalRootError) << "Failed to find event Selections branch in event tree";
    }
    eventSelectionsBranch->SetAddress(&pEventSelectionIDVector);
    eventSelectionsBranch->GetEntry(iEntry);

    edm::BranchListIndexes branchListIndexes;
    edm::BranchListIndexes* pBranchListIndexes = &branchListIndexes;
    TBranch* branchListIndexBranch = m_->tree_->GetBranch(edm::poolNames::branchListIndexesBranchName().c_str());
    if (!branchListIndexBranch) {
      throw edm::Exception(edm::errors::FatalRootError) << "Failed to find branch list index branch in event tree";
    }
    branchListIndexBranch->SetAddress(&pBranchListIndexes);
    branchListIndexBranch->GetEntry(iEntry);
    m_->branchIDListHelper_->fixBranchListIndexes(branchListIndexes);
    edm::EventToProcessBlockIndexes dummyEventToProcessBlockIndexes;

    try {
      m_->reader_->setEntry(iEntry);
      auto rp = std::make_shared<edm::RunPrincipal>(m_->reg(), m_->pc_, nullptr, 0);
      rp->setAux(edm::RunAuxiliary(aux.run(), aux.time(), aux.time()));
      auto lbp = std::make_shared<edm::LuminosityBlockPrincipal>(m_->reg(), m_->pc_, nullptr, 0);
      lbp->setAux(edm::LuminosityBlockAuxiliary(rp->run(), 1, aux.time(), aux.time()));
      auto history = m_->phreg_->getMapped(eaux->processHistoryID());
      m_->ep_->fillEventPrincipal(*eaux,
                                  history,
                                  std::move(eventSelectionIDs),
                                  std::move(branchListIndexes),
                                  dummyEventToProcessBlockIndexes,
                                  *(m_->provRetriever_),
                                  m_->reader_.get());
      lbp->setRunPrincipal(rp);
      m_->ep_->setLuminosityBlockPrincipal(lbp.get());
      m_->processNames_ = m_->ep_->processHistory();

      edm::Event event(*m_->ep_, m_->md_, nullptr);

      //Make the event principal accessible to edm::Ref's
      Operate sentry(m_->ep_->prodGetter());
      process(event);
    } catch (std::exception const& iEx) {
      std::cout << "While processing entry " << iEntry << " the following exception was caught \n"
                << iEx.what() << std::endl;
    } catch (...) {
      std::cout << "While processing entry " << iEntry << " an unknown exception was caught" << std::endl;
    }
  }
  return everythingOK_ ? kTRUE : kFALSE;
}

setupNewFile()

void TFWLiteSelectorBasic::setupNewFile ( TFile &  iFile )

private

Definition at line 365 of file TFWLiteSelectorBasic.cc.

References edm::poolNames::branchIDListBranchName(), gather_cfg::cout, mps_splice::entry, everythingOK_, Exception, edm::poolNames::fileFormatVersionBranchName(), edm::errors::FileReadError, edm::friendlyname::friendlyName(), mps_fire::i, edm::poolNames::idToParameterSetBlobsBranchName(), edm::InEvent, edm::pset::Registry::insertMapped(), edm::pset::Registry::instance(), B2GTnPMonitor_cfi::item, m_, edm::poolNames::metaDataTreeName(), AlCaHLTBitMon_ParallelJobs::p, edm::poolNames::parameterSetMapBranchName(), edm::poolNames::parameterSetsTreeName(), edm::poolNames::processConfigurationBranchName(), edm::poolNames::processHistoryBranchName(), dumpMFGeometry_cfg::prod, edm::poolNames::productDescriptionBranchName(), muonDTDigis_cfi::pset, edm::setIsMergeable(), AlCaHLTBitMon_QueryRunRegistry::string, groupFilesInBlocks::temp, edm::errors::UnimplementedFeature, and edm::BranchDescription::updateFriendlyClassName().

Referenced by Notify().

                                                    {
  //look up meta-data
  //get product registry

  //std::vector<edm::EventProcessHistoryID> eventProcessHistoryIDs_;
  TTree* metaDataTree = dynamic_cast<TTree*>(iFile.Get(edm::poolNames::metaDataTreeName().c_str()));
  if (!metaDataTree) {
    std::cout << "could not find TTree " << edm::poolNames::metaDataTreeName() << std::endl;
    everythingOK_ = false;
    return;
  }
  edm::FileFormatVersion* fftPtr = &(m_->fileFormatVersion_);
  if (metaDataTree->FindBranch(edm::poolNames::fileFormatVersionBranchName().c_str()) != nullptr) {
    metaDataTree->SetBranchAddress(edm::poolNames::fileFormatVersionBranchName().c_str(), &fftPtr);
  }

  edm::ProductRegistry* pReg = &(*m_->reg_);
  metaDataTree->SetBranchAddress(edm::poolNames::productDescriptionBranchName().c_str(), &(pReg));

  typedef std::map<edm::ParameterSetID, edm::ParameterSetBlob> PsetMap;
  PsetMap psetMap;
  PsetMap* psetMapPtr = &psetMap;
  if (metaDataTree->FindBranch(edm::poolNames::parameterSetMapBranchName().c_str()) != nullptr) {
    metaDataTree->SetBranchAddress(edm::poolNames::parameterSetMapBranchName().c_str(), &psetMapPtr);
  } else {
    TTree* psetTree = dynamic_cast<TTree*>(iFile.Get(edm::poolNames::parameterSetsTreeName().c_str()));
    if (nullptr == psetTree) {
      throw edm::Exception(edm::errors::FileReadError)
          << "Could not find tree " << edm::poolNames::parameterSetsTreeName() << " in the input file.\n";
    }
    typedef std::pair<edm::ParameterSetID, edm::ParameterSetBlob> IdToBlobs;
    IdToBlobs idToBlob;
    IdToBlobs* pIdToBlob = &idToBlob;
    psetTree->SetBranchAddress(edm::poolNames::idToParameterSetBlobsBranchName().c_str(), &pIdToBlob);
    for (long long i = 0; i != psetTree->GetEntries(); ++i) {
      psetTree->GetEntry(i);
      psetMap.insert(idToBlob);
    }
  }

  edm::ProcessHistoryRegistry::vector_type pHistVector;
  edm::ProcessHistoryRegistry::vector_type* pHistVectorPtr = &pHistVector;
  if (metaDataTree->FindBranch(edm::poolNames::processHistoryBranchName().c_str()) != nullptr) {
    metaDataTree->SetBranchAddress(edm::poolNames::processHistoryBranchName().c_str(), &pHistVectorPtr);
  }

  edm::ProcessConfigurationVector procConfigVector;
  edm::ProcessConfigurationVector* procConfigVectorPtr = &procConfigVector;
  if (metaDataTree->FindBranch(edm::poolNames::processConfigurationBranchName().c_str()) != nullptr) {
    metaDataTree->SetBranchAddress(edm::poolNames::processConfigurationBranchName().c_str(), &procConfigVectorPtr);
  }

  auto branchIDListsHelper = std::make_shared<edm::BranchIDListHelper>();
  edm::BranchIDLists const* branchIDListsPtr = &branchIDListsHelper->branchIDLists();
  if (metaDataTree->FindBranch(edm::poolNames::branchIDListBranchName().c_str()) != nullptr) {
    metaDataTree->SetBranchAddress(edm::poolNames::branchIDListBranchName().c_str(), &branchIDListsPtr);
  }

  metaDataTree->GetEntry(0);

  for (auto& prod : m_->reg_->productListUpdator()) {
    prod.second.init();
    setIsMergeable(prod.second);
  }

  // Merge into the registries. For now, we do NOT merge the product registry.
  edm::pset::Registry& psetRegistry = *edm::pset::Registry::instance();
  for (auto const& entry : psetMap) {
    edm::ParameterSet pset(entry.second.pset());
    pset.setID(entry.first);
    psetRegistry.insertMapped(pset);
  }

  for (auto const& ph : pHistVector) {
    m_->phreg_->registerProcessHistory(ph);
  }

  m_->pointerToBranchBuffer_.erase(m_->pointerToBranchBuffer_.begin(), m_->pointerToBranchBuffer_.end());

  std::unique_ptr<edm::ProductRegistry> newReg = std::make_unique<edm::ProductRegistry>();

  edm::ProductRegistry::ProductList& prodList = m_->reg_->productListUpdator();
  {
    for (auto& item : prodList) {
      edm::BranchDescription& prod = item.second;
      //std::cout << "productname = " << item.second << " end " << std::endl;
      std::string newFriendlyName = edm::friendlyname::friendlyName(prod.className());
      if (newFriendlyName == prod.friendlyClassName()) {
        newReg->copyProduct(prod);
      } else {
        if (m_->fileFormatVersion_.splitProductIDs()) {
          throw edm::Exception(edm::errors::UnimplementedFeature)
              << "Cannot change friendly class name algorithm without more development work\n"
              << "to update BranchIDLists.  Contact the framework group.\n";
        }
        edm::BranchDescription newBD(prod);
        newBD.updateFriendlyClassName();
        newReg->copyProduct(newBD);
      }
      prod.init();
    }

    m_->reg().reset(newReg.release());
  }

  edm::ProductRegistry::ProductList& prodList2 = m_->reg_->productListUpdator();
  std::vector<edm::EventEntryDescription> temp(prodList2.size(), edm::EventEntryDescription());
  m_->prov_.swap(temp);
  m_->pointerToBranchBuffer_.reserve(prodList2.size());

  for (auto& item : prodList2) {
    edm::BranchDescription& prod = item.second;
    if (prod.branchType() == edm::InEvent) {
      prod.init();
      //NEED to do this and check to see if branch exists
      if (m_->tree_->GetBranch(prod.branchName().c_str()) == nullptr) {
        prod.setDropped(true);
      }
      prod.setOnDemand(true);

      //std::cout << "id " << it->first << " branch " << it->second << std::endl;
      //m_->pointerToBranchBuffer_.push_back(&(*itB));
      //void* tmp = &(m_->pointerToBranchBuffer_.back());
      //edm::EventEntryDescription* tmp = &(*itB);
      //CDJ need to fix provenance and be backwards compatible, for now just don't read the branch
      //m_->metaTree_->SetBranchAddress(prod.branchName().c_str(), tmp);
    }
  }
  m_->branchIDListHelper_->updateFromInput(*branchIDListsPtr);
  m_->reg_->setFrozen();
  m_->bidToDesc_->clear();
  for (auto const& p : m_->reg_->productList()) {
    m_->bidToDesc_->emplace(p.second.branchID().id(), &p.second);
  }
  m_->ep_ = std::make_shared<edm::EventPrincipal>(
      m_->reg(), m_->branchIDListHelper(), m_->thinnedAssociationsHelper(), m_->pc_, nullptr);
  everythingOK_ = true;
}

SlaveBegin()

void TFWLiteSelectorBasic::SlaveBegin ( TTree *  iTree )

overrideprivate

Definition at line 242 of file TFWLiteSelectorBasic.cc.

References Init(), and preProcessing().

                                                  {
  Init(iTree);
  preProcessing(fInput, *fOutput);
}

SlaveTerminate()

void TFWLiteSelectorBasic::SlaveTerminate ( )

overrideprivate

Definition at line 361 of file TFWLiteSelectorBasic.cc.

References postProcessing().

{ postProcessing(*fOutput); }

terminate()

virtual void TFWLiteSelectorBasic::terminate ( TList &  out )

pure virtual

Called each time the 'client' has finished processing.

Parameters

out	contains the accumulated output of all slaves.

Implemented in __class__< T >, tfwliteselectortest::ThingsTSelector2, and tfwliteselectortest::ThingsTSelector.

Referenced by Terminate().

Terminate()

void TFWLiteSelectorBasic::Terminate ( )

overrideprivate

Definition at line 363 of file TFWLiteSelectorBasic.cc.

References terminate().

{ terminate(*fOutput); }

Version()

Int_t TFWLiteSelectorBasic::Version ( ) const

inlineoverrideprivate

Definition at line 94 of file TFWLiteSelectorBasic.h.

{ return 1; }

Member Data Documentation

everythingOK_

bool TFWLiteSelectorBasic::everythingOK_

private

Definition at line 99 of file TFWLiteSelectorBasic.h.

Referenced by Notify(), Process(), and setupNewFile().

m_

edm::propagate_const<std::shared_ptr<edm::root::TFWLiteSelectorMembers> > TFWLiteSelectorBasic::m_

private

Definition at line 98 of file TFWLiteSelectorBasic.h.

Referenced by Init(), Notify(), Process(), and setupNewFile().