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

Inheritance diagram for BareRootProductGetter:

Classes
struct	Buffer

Public Member Functions
	BareRootProductGetter ()

edm::WrapperBase const *	getIt (edm::ProductID const &) const override

edm::WrapperBase const *	getThinnedProduct (edm::ProductID const &, unsigned int &key) const override

void	getThinnedProducts (edm::ProductID const &, std::vector< edm::WrapperBase const * > &foundContainers, std::vector< unsigned int > &keys) const override

	~BareRootProductGetter () override

Public Member Functions inherited from edm::EDProductGetter
	EDProductGetter ()

	EDProductGetter (EDProductGetter const &)=delete

EDProductGetter const &	operator= (EDProductGetter const &)=delete

unsigned int	transitionIndex () const

virtual	~EDProductGetter ()

Private Types
typedef std::map< edm::BranchID, Buffer >	IdToBuffers

Private Member Functions
	BareRootProductGetter (BareRootProductGetter const &)=delete

Buffer *	createNewBuffer (edm::BranchID const &) const

edm::WrapperBase const *	getIt (edm::BranchID const &, Long_t eventEntry) const

edm::ThinnedAssociation const *	getThinnedAssociation (edm::BranchID const &branchID, Long_t eventEntry) const

BareRootProductGetter const &	operator= (BareRootProductGetter const &)=delete

unsigned int	transitionIndex_ () const override

Private Attributes
fwlite::BranchMapReader	branchMap_

IdToBuffers	idToBuffers_

Additional Inherited Members
Static Public Member Functions inherited from edm::EDProductGetter
static void	assignEDProductGetter (EDProductGetter const *&)

static EDProductGetter const *	switchProductGetter (EDProductGetter const *)
	These can only be used internally by the framework. More...

Detailed Description

Description: <one line="" class="" summary>="">

Usage: <usage>

Definition at line 43 of file BareRootProductGetter.h.

Member Typedef Documentation

typedef std::map<edm::BranchID, Buffer> BareRootProductGetter::IdToBuffers

private

Definition at line 104 of file BareRootProductGetter.h.

Constructor & Destructor Documentation

BareRootProductGetter::BareRootProductGetter ( )

Definition at line 44 of file BareRootProductGetter.cc.

44 {}

BareRootProductGetter::~BareRootProductGetter ( )

override

Definition at line 50 of file BareRootProductGetter.cc.

50 {}

BareRootProductGetter::BareRootProductGetter ( BareRootProductGetter const & )

privatedelete

Member Function Documentation

BareRootProductGetter::Buffer * BareRootProductGetter::createNewBuffer ( edm::BranchID const & branchID ) const

private

Definition at line 278 of file BareRootProductGetter.cc.

References b, MicroEventContent_cff::branch, fwlite::BranchMapReader::branchIDToBranch(), branchMap_, edm::BranchDescription::branchName(), edm::TypeWithDict::byName(), edm::BranchDescription::className(), Exception, fwlite::BranchMapReader::getEventTree(), idToBuffers_, eostools::move(), parseEventContent::prod, AlCaHLTBitMon_QueryRunRegistry::string, and edm::wrappedClassName().

Referenced by getIt().

                                                                                                      {
   //find the branch
   edm::BranchDescription const& bdesc = branchMap_.branchIDToBranch(branchID);
 
   TBranch* branch = branchMap_.getEventTree()->GetBranch(bdesc.branchName().c_str());
   if (nullptr == branch) {
     //we do not thrown on missing branches since 'getIt' should not throw under that condition
     return nullptr;
   }
   //find the class type
   std::string const fullName = edm::wrappedClassName(bdesc.className());
   edm::TypeWithDict classType(edm::TypeWithDict::byName(fullName));
   if (!bool(classType)) {
     throw cms::Exception("MissingDictionary") << "could not find dictionary for type '" << fullName << "'"
                                               << "\n Please make sure all the necessary libraries are available.";
     return nullptr;
   }
 
   TClass* rootClassType = TClass::GetClass(classType.typeInfo());
   if (nullptr == rootClassType) {
     throw cms::Exception("MissingRootDictionary") << "could not find a ROOT dictionary for type '" << fullName << "'"
                                                   << "\n Please make sure all the necessary libraries are available.";
     return nullptr;
   }
   void* address = rootClassType->New();
 
   static TClass const* edproductTClass = TClass::GetClass(typeid(edm::WrapperBase));
   edm::WrapperBase const* prod =
       static_cast<edm::WrapperBase const*>(rootClassType->DynamicCast(edproductTClass, address, true));
   if (nullptr == prod) {
     throw cms::Exception("FailedConversion") << "failed to convert a '" << fullName << "' to a edm::WrapperBase."
                                              << "Please contact developers since something is very wrong.";
   }
 
   //connect the instance to the branch
   //void* address  = wrapperObj.Address();
   Buffer b(prod, branch, address, rootClassType);
   idToBuffers_[branchID] = std::move(b);
 
   //As of 5.13 ROOT expects the memory address held by the pointer passed to
   // SetAddress to be valid forever
   address = &(idToBuffers_[branchID].address_);
   branch->SetAddress(address);
 
   return &(idToBuffers_[branchID]);
 }

edm::WrapperBase const * BareRootProductGetter::getIt ( edm::ProductID const & pid ) const

overridevirtual

Implements edm::EDProductGetter.

Definition at line 70 of file BareRootProductGetter.cc.

References branchMap_, edm::poolNames::eventTreeName(), Exception, fwlite::BranchMapReader::getEventTree(), fwlite::BranchMapReader::getFile(), idToBuffers_, fwlite::BranchMapReader::productToBranchID(), fwlite::BranchMapReader::updateEvent(), and fwlite::BranchMapReader::updateFile().

Referenced by getThinnedAssociation(), getThinnedProduct(), and getThinnedProducts().

                                                                                 {
   // std::cout << "getIt called " << pid << std::endl;
   TFile* currentFile = dynamic_cast<TFile*>(gROOT->GetListOfFiles()->Last());
   if (nullptr == currentFile) {
     throw cms::Exception("FileNotFound") << "unable to find the TFile '" << gROOT->GetListOfFiles()->Last() << "'\n"
                                          << "retrieved by calling 'gROOT->GetListOfFiles()->Last()'\n"
                                          << "Please check the list of files.";
   }
   if (branchMap_.updateFile(currentFile)) {
     idToBuffers_.clear();
   }
   TTree* eventTree = branchMap_.getEventTree();
   // std::cout << "eventTree " << eventTree << std::endl;
   if (nullptr == eventTree) {
     throw cms::Exception("NoEventsTree")
         << "unable to find the TTree '" << edm::poolNames::eventTreeName() << "' in the last open file, \n"
         << "file: '" << branchMap_.getFile()->GetName()
         << "'\n Please check that the file is a standard CMS ROOT format.\n"
         << "If the above is not the file you expect then please open your data file after all other files.";
   }
   Long_t eventEntry = eventTree->GetReadEntry();
   // std::cout << "eventEntry " << eventEntry << std::endl;
   branchMap_.updateEvent(eventEntry);
   if (eventEntry < 0) {
     throw cms::Exception("GetEntryNotCalled")
         << "please call GetEntry for the 'Events' TTree for each event in order to make edm::Ref's work."
         << "\n Also be sure to call 'SetAddress' for all Branches after calling the GetEntry.";
   }
 
   edm::BranchID branchID = branchMap_.productToBranchID(pid);
 
   return getIt(branchID, eventEntry);
 }

edm::WrapperBase const * BareRootProductGetter::getIt	(	edm::BranchID const &	branchID,
		Long_t	eventEntry
	)		const

private

Definition at line 104 of file BareRootProductGetter.cc.

References BareRootProductGetter::Buffer::address_, BareRootProductGetter::Buffer::branch_, edmScanValgrind::buffer, BareRootProductGetter::Buffer::class_, createNewBuffer(), BareRootProductGetter::Buffer::eventEntry_, Exception, idToBuffers_, parseEventContent::prod, and BareRootProductGetter::Buffer::product_.

                                                                                                        {
   Buffer* buffer = nullptr;
   IdToBuffers::iterator itBuffer = idToBuffers_.find(branchID);
 
   // std::cout << "Buffers" << std::endl;
   if (itBuffer == idToBuffers_.end()) {
     buffer = createNewBuffer(branchID);
     // std::cout << "buffer " << buffer << std::endl;
     if (nullptr == buffer) {
       return nullptr;
     }
   } else {
     buffer = &(itBuffer->second);
   }
   if (nullptr == buffer) {
     throw cms::Exception("NullBuffer") << "Found a null buffer which is supposed to hold the data item."
                                        << "\n Please contact developers since this message should not happen.";
   }
   if (nullptr == buffer->branch_) {
     throw cms::Exception("NullBranch") << "The TBranch which should hold the data item is null."
                                        << "\n Please contact the developers since this message should not happen.";
   }
   if (buffer->eventEntry_ != eventEntry) {
     //NOTE: Need to reset address because user could have set the address themselves
     //std::cout << "new event" << std::endl;
 
     //ROOT WORKAROUND: Create new objects so any internal data cache will get cleared
     void* address = buffer->class_->New();
 
     static TClass const* edproductTClass = TClass::GetClass(typeid(edm::WrapperBase));
     edm::WrapperBase const* prod =
         static_cast<edm::WrapperBase const*>(buffer->class_->DynamicCast(edproductTClass, address, true));
 
     if (nullptr == prod) {
       cms::Exception("FailedConversion") << "failed to convert a '" << buffer->class_->GetName()
                                          << "' to a edm::WrapperBase."
                                          << "Please contact developers since something is very wrong.";
     }
     buffer->address_ = address;
     buffer->product_ = std::shared_ptr<edm::WrapperBase const>(prod);
     //END WORKAROUND
 
     address = &(buffer->address_);
     buffer->branch_->SetAddress(address);
 
     buffer->branch_->GetEntry(eventEntry);
     buffer->eventEntry_ = eventEntry;
   }
   if (!buffer->product_) {
     throw cms::Exception("BranchGetEntryFailed")
         << "Calling GetEntry with index " << eventEntry << "for branch " << buffer->branch_->GetName() << " failed.";
   }
 
   return buffer->product_.get();
 }

edm::ThinnedAssociation const * BareRootProductGetter::getThinnedAssociation	(	edm::BranchID const &	branchID,
		Long_t	eventEntry
	)		const

private

Definition at line 325 of file BareRootProductGetter.cc.

References edm::WrapperBase::dynamicTypeInfo(), Exception, getIt(), edm::errors::LogicError, and wrapper.

Referenced by getThinnedProduct(), and getThinnedProducts().

                                                                                                      {
   edm::WrapperBase const* wrapperBase = getIt(branchID, eventEntry);
   if (wrapperBase == nullptr) {
     throw edm::Exception(edm::errors::LogicError)
         << "BareRootProductGetter::getThinnedAssociation, product ThinnedAssociation not found.\n";
   }
   if (!(typeid(edm::ThinnedAssociation) == wrapperBase->dynamicTypeInfo())) {
     throw edm::Exception(edm::errors::LogicError)
         << "BareRootProductGetter::getThinnedAssociation, product has wrong type, not a ThinnedAssociation.\n";
   }
   edm::Wrapper<edm::ThinnedAssociation> const* wrapper =
       static_cast<edm::Wrapper<edm::ThinnedAssociation> const*>(wrapperBase);
 
   edm::ThinnedAssociation const* thinnedAssociation = wrapper->product();
   return thinnedAssociation;
 }

edm::WrapperBase const * BareRootProductGetter::getThinnedProduct	(	edm::ProductID const &	pid,
		unsigned int &	key
	)		const

overridevirtual

Implements edm::EDProductGetter.

Definition at line 160 of file BareRootProductGetter.cc.

References branchMap_, fwlite::BranchMapReader::getEventTree(), getIt(), getThinnedAssociation(), edm::ThinnedAssociation::hasParentIndex(), edm::BranchID::isValid(), class-composition::parent, edm::ThinnedAssociationsHelper::parentBegin(), edm::ThinnedAssociation::parentCollectionID(), edm::ThinnedAssociationsHelper::parentEnd(), fwlite::BranchMapReader::productToBranchID(), fwlite::BranchMapReader::thinnedAssociationsHelper(), and edm::ThinnedAssociation::thinnedCollectionID().

                                                                                                                {
   Long_t eventEntry = branchMap_.getEventTree()->GetReadEntry();
   edm::BranchID parent = branchMap_.productToBranchID(pid);
   if (!parent.isValid())
     return nullptr;
   edm::ThinnedAssociationsHelper const& thinnedAssociationsHelper = branchMap_.thinnedAssociationsHelper();
 
   // Loop over thinned containers which were made by selecting elements from the parent container
   for (auto associatedBranches = thinnedAssociationsHelper.parentBegin(parent),
             iEnd = thinnedAssociationsHelper.parentEnd(parent);
        associatedBranches != iEnd;
        ++associatedBranches) {
     edm::ThinnedAssociation const* thinnedAssociation =
         getThinnedAssociation(associatedBranches->association(), eventEntry);
     if (thinnedAssociation == nullptr)
       continue;
 
     if (associatedBranches->parent() != branchMap_.productToBranchID(thinnedAssociation->parentCollectionID())) {
       continue;
     }
 
     unsigned int thinnedIndex = 0;
     // Does this thinned container have the element referenced by key?
     // If yes, thinnedIndex is set to point to it in the thinned container
     if (!thinnedAssociation->hasParentIndex(key, thinnedIndex)) {
       continue;
     }
     // Get the thinned container and return a pointer if we can find it
     edm::ProductID const& thinnedCollectionPID = thinnedAssociation->thinnedCollectionID();
     edm::WrapperBase const* thinnedCollection = getIt(thinnedCollectionPID);
     if (thinnedCollection == nullptr) {
       // Thinned container is not found, try looking recursively in thinned containers
       // which were made by selecting elements from this thinned container.
       edm::WrapperBase const* thinnedFromRecursiveCall = getThinnedProduct(thinnedCollectionPID, thinnedIndex);
       if (thinnedFromRecursiveCall != nullptr) {
         key = thinnedIndex;
         return thinnedFromRecursiveCall;
       } else {
         continue;
       }
     }
     key = thinnedIndex;
     return thinnedCollection;
   }
   return nullptr;
 }

void BareRootProductGetter::getThinnedProducts	(	edm::ProductID const &	pid,
		std::vector< edm::WrapperBase const * > &	foundContainers,
		std::vector< unsigned int > &	keys
	)		const

overridevirtual

Implements edm::EDProductGetter.

Definition at line 207 of file BareRootProductGetter.cc.

References branchMap_, fwlite::BranchMapReader::getEventTree(), getIt(), getThinnedAssociation(), edm::ThinnedAssociation::hasParentIndex(), edm::BranchID::isValid(), gen::k, SiStripPI::max, class-composition::parent, edm::ThinnedAssociationsHelper::parentBegin(), edm::ThinnedAssociation::parentCollectionID(), edm::ThinnedAssociationsHelper::parentEnd(), fwlite::BranchMapReader::productToBranchID(), fwlite::BranchMapReader::thinnedAssociationsHelper(), and edm::ThinnedAssociation::thinnedCollectionID().

                                                                                     {
   Long_t eventEntry = branchMap_.getEventTree()->GetReadEntry();
   edm::BranchID parent = branchMap_.productToBranchID(pid);
   if (!parent.isValid())
     return;
   edm::ThinnedAssociationsHelper const& thinnedAssociationsHelper = branchMap_.thinnedAssociationsHelper();
 
   // Loop over thinned containers which were made by selecting elements from the parent container
   for (auto associatedBranches = thinnedAssociationsHelper.parentBegin(parent),
             iEnd = thinnedAssociationsHelper.parentEnd(parent);
        associatedBranches != iEnd;
        ++associatedBranches) {
     edm::ThinnedAssociation const* thinnedAssociation =
         getThinnedAssociation(associatedBranches->association(), eventEntry);
     if (thinnedAssociation == nullptr)
       continue;
 
     if (associatedBranches->parent() != branchMap_.productToBranchID(thinnedAssociation->parentCollectionID())) {
       continue;
     }
 
     unsigned int nKeys = keys.size();
     unsigned int doNotLookForThisIndex = std::numeric_limits<unsigned int>::max();
     std::vector<unsigned int> thinnedIndexes(nKeys, doNotLookForThisIndex);
     bool hasAny = false;
     for (unsigned k = 0; k < nKeys; ++k) {
       // Already found this one
       if (foundContainers[k] != nullptr)
         continue;
       // Already know this one is not in this thinned container
       if (keys[k] == doNotLookForThisIndex)
         continue;
       // Does the thinned container hold the entry of interest?
       // Modifies thinnedIndexes[k] only if it returns true and
       // sets it to the index in the thinned collection.
       if (thinnedAssociation->hasParentIndex(keys[k], thinnedIndexes[k])) {
         hasAny = true;
       }
     }
     if (!hasAny) {
       continue;
     }
     // Get the thinned container and set the pointers and indexes into
     // it (if we can find it)
     edm::ProductID thinnedCollectionPID = thinnedAssociation->thinnedCollectionID();
     edm::WrapperBase const* thinnedCollection = getIt(thinnedCollectionPID);
 
     if (thinnedCollection == nullptr) {
       // Thinned container is not found, try looking recursively in thinned containers
       // which were made by selecting elements from this thinned container.
       getThinnedProducts(thinnedCollectionPID, foundContainers, thinnedIndexes);
       for (unsigned k = 0; k < nKeys; ++k) {
         if (foundContainers[k] == nullptr)
           continue;
         if (thinnedIndexes[k] == doNotLookForThisIndex)
           continue;
         keys[k] = thinnedIndexes[k];
       }
     } else {
       for (unsigned k = 0; k < nKeys; ++k) {
         if (thinnedIndexes[k] == doNotLookForThisIndex)
           continue;
         keys[k] = thinnedIndexes[k];
         foundContainers[k] = thinnedCollection;
       }
     }
   }
 }

BareRootProductGetter const& BareRootProductGetter::operator= ( BareRootProductGetter const & )

privatedelete

unsigned int BareRootProductGetter::transitionIndex_ ( ) const

inlineoverrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 79 of file BareRootProductGetter.h.

79 { return 0u; }

Member Data Documentation

fwlite::BranchMapReader BareRootProductGetter::branchMap_

mutableprivate

Definition at line 106 of file BareRootProductGetter.h.

Referenced by createNewBuffer(), getIt(), getThinnedProduct(), and getThinnedProducts().

IdToBuffers BareRootProductGetter::idToBuffers_

mutableprivate

Definition at line 105 of file BareRootProductGetter.h.

Referenced by createNewBuffer(), and getIt().

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation