edm::detail Namespace Reference

Classes
struct	doIsProductEqual
struct	doIsProductEqual< T, false >
struct	doIsProductEqual< T, true >
struct	doMergeProduct
struct	doMergeProduct< T, false >
struct	doMergeProduct< T, true >
struct	doSwapProduct
struct	doSwapProduct< T, false >
struct	doSwapProduct< T, true >
struct	ElementType
struct	ElementType< edmNew::DetSetVector< T > >
struct	getHasIsProductEqual
struct	getHasIsProductEqual< T, false >
struct	getHasIsProductEqual< T, true >
struct	getHasMergeFunction
struct	getHasMergeFunction< T, false >
struct	getHasMergeFunction< T, true >
struct	getHasSwapFunction
struct	getHasSwapFunction< T, false >
struct	getHasSwapFunction< T, true >
struct	getMemberType
struct	getMemberType< std::vector< edm::Ptr< T > >, true >
struct	getMemberType< std::vector< std::unique_ptr< T, Deleter > >, true >
struct	getMemberType< T, false >
struct	getMemberType< T, true >
struct	GetProduct
struct	GetProduct< RefVector< C, T, F > >
struct	GetProduct< std::vector< std::unique_ptr< T, D >, A > >
struct	getValueType
struct	getValueType< T, false >
struct	getValueType< T, true >
struct	has_isProductEqual_function
struct	has_mergeProduct_function
struct	has_postinsert
struct	has_swap_function
struct	has_typedef_member_type
struct	has_typedef_member_type< std::vector< edm::Ptr< T > > >
struct	has_typedef_member_type< std::vector< std::unique_ptr< T, Deleter > > >
struct	has_typedef_value_type
struct	isProductEqual_function
struct	IsStdOptional
struct	IsStdOptional< std::optional< T > >
struct	mergeProduct_function
class	NamedEventSelector
struct	postinsert_function
struct	swap_function
class	ThinnedOrSlimmedProduct
class	ThreadSafeRegistry
class	TriggerResultsBasedEventSelector

Typedefs
using	GetThinnedKeyFromExceptionFactory = std::function< edm::Exception()>
typedef edm::Handle< edm::TriggerResults >	handle_t
using	no_tag = std::false_type
using	yes_tag = std::true_type

Functions
void	_throw_range (det_id_type i)
bool	configureEventSelector (edm::ParameterSet const &iPSet, std::string const &iProcessName, std::vector< std::string > const &iAllTriggerNames, edm::detail::TriggerResultsBasedEventSelector &oSelector, ConsumesCollector &&iC)
void	doTheOffset (int bunchSpace, int bcr, std::vector< PCaloHit > &calohits, unsigned int evtNr, int vertexOffset, bool wrap)
void	doTheOffset (int bunchSpace, int bcr, std::vector< PSimHit > &simhits, unsigned int evtNr, int vertexOffset, bool wrap)
void	doTheOffset (int bunchSpace, int bcr, std::vector< SimTrack > &simtracks, unsigned int evtNr, int vertexOffset, bool wrap)
void	doTheOffset (int bunchSpace, int bcr, std::vector< SimVertex > &simvertices, unsigned int evtNr, int vertexOffset, bool wrap)
void	doTheOffset (int bunchSpace, int bcr, TrackingRecHitCollection &trackingrechits, unsigned int evtNr, int vertexOffset, bool wrap)
template<typename Item , typename Selector , typename Collection >
void	fillCollectionForThinning (Item const &item, Selector &selector, unsigned int iIndex, Collection &output, ThinnedAssociation &association)
template<typename F >
std::variant< unsigned int, GetThinnedKeyFromExceptionFactory, std::monostate >	getThinnedKeyFrom_implementation (ProductID const &parentID, BranchID const &parent, unsigned int key, ProductID const &thinnedID, BranchID thinned, ThinnedAssociationsHelper const &thinnedAssociationsHelper, F &&getThinnedAssociation)
template<typename F1 , typename F2 , typename F3 >
std::optional< std::tuple< WrapperBase const *, unsigned int > >	getThinnedProduct (ProductID const &pid, unsigned int key, ThinnedAssociationsHelper const &thinnedAssociationsHelper, F1 pidToBid, F2 getThinnedAssociation, F3 getByProductID)
template<typename F1 , typename F2 , typename F3 >
ThinnedOrSlimmedProduct	getThinnedProductOnSlimmingDepth (ProductID const &pid, unsigned int key, ThinnedAssociationsHelper const &thinnedAssociationsHelper, F1 pidToBid, F2 getThinnedAssociation, F3 getByProductID)
template<typename F1 , typename F2 , typename F3 >
void	getThinnedProducts (ProductID const &pid, ThinnedAssociationsHelper const &thinnedAssociationsHelper, F1 pidToBid, F2 getThinnedAssociation, F3 getByProductID, std::vector< WrapperBase const * > &foundContainers, std::vector< unsigned int > &keys)
template<typename F1 , typename F2 , typename F3 >
std::optional< std::tuple< ThinnedAssociation const *, std::vector< unsigned int > > >	getThinnedProductsOnSlimmingDepth (ProductID const &pid, ThinnedAssociationsHelper const &thinnedAssociationsHelper, F1 pidToBid, F2 getThinnedAssociation, F3 getByProductID, std::vector< WrapperBase const * > &foundContainers, std::vector< unsigned int > &keys)
template<typename T >
static no_tag	has_isProductEqual (...)
template<typename T >
static yes_tag	has_isProductEqual (isProductEqual_function< T, &T::isProductEqual > *dummy)
template<typename T >
static no_tag	has_member_type (...)
template<typename T >
static yes_tag	has_member_type (typename T::member_type *)
template<typename T >
static no_tag	has_mergeProduct (...)
template<typename T >
static yes_tag	has_mergeProduct (mergeProduct_function< T, &T::mergeProduct > *dummy)
template<typename T >
no_tag	has_postinsert_helper (...)
template<typename T >
yes_tag	has_postinsert_helper (postinsert_function< T, &T::post_insert > *p)
template<typename T >
static no_tag	has_swap (...)
template<typename T >
static yes_tag	has_swap (swap_function< T, &T::swap > *dummy)
template<typename T >
static no_tag	has_value_type (...)
template<typename T >
static yes_tag	has_value_type (typename T::value_type *)
std::string const &	InvalidHash ()
auto	makeThinnedIndexes (std::vector< unsigned int > const &keys, std::vector< WrapperBase const * > const &foundContainers, ThinnedAssociation const *thinnedAssociation)
template<typename KEY , typename T , typename E >
std::ostream &	operator<< (std::ostream &os, ThreadSafeRegistry< KEY, T > const &reg)
template<typename COLLECTION >
void	reallyfillPtrVector (COLLECTION const &coll, std::type_info const &iToType, std::vector< unsigned long > const &iIndicies, std::vector< void const * > &oPtr)
template<class COLLECTION >
void	reallyFillView (COLLECTION const &coll, ProductID const &id, std::vector< void const * > &ptrs, FillViewHelperVector &helpers)
template<typename COLLECTION >
void	reallySetPtr (COLLECTION const &coll, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
ParameterSetID	registerProperSelectionInfo (edm::ParameterSet const &iInitial, std::string const &iLabel, std::map< std::string, std::vector< std::pair< std::string, int > > > const &outputModulePathPositions, bool anyProductProduced)

Variables
constexpr unsigned int	kThinningDoNotLookForThisIndex = std::numeric_limits<unsigned int>::max()

Typedef Documentation

GetThinnedKeyFromExceptionFactory

typedef std::function< edm::Exception()> edm::detail::GetThinnedKeyFromExceptionFactory

Definition at line 37 of file EDProductGetter.h.

handle_t

typedef edm::Handle<edm::TriggerResults> edm::detail::handle_t

Definition at line 28 of file TriggerResultsBasedEventSelector.h.

no_tag

typedef std::false_type edm::detail::no_tag

Definition at line 22 of file WrapperDetail.h.

yes_tag

typedef std::true_type edm::detail::yes_tag

Definition at line 23 of file WrapperDetail.h.

Function Documentation

_throw_range()

void edm::detail::_throw_range ( det_id_type  i )

inline

Definition at line 69 of file DetSetVector.h.

                                            {
      Exception::throwThis(
          errors::InvalidReference, "DetSetVector::operator[] called with index not in collection;\nindex value: ", i);
    }

References mps_fire::i, edm::errors::InvalidReference, and edm::Exception::throwThis().

Referenced by edm::DetSetVector< TotemRPLocalTrack::FittedRecHit >::operator[]().

configureEventSelector()

bool edm::detail::configureEventSelector	(	edm::ParameterSet const &	iPSet,
		std::string const &	iProcessName,
		std::vector< std::string > const &	iAllTriggerNames,
		edm::detail::TriggerResultsBasedEventSelector &	oSelector,
		edm::ConsumesCollector &&	iC
	)

Handles the final initialization of the TriggerResutsBasedEventSelector

Returns

true if all events will be selected

Definition at line 80 of file TriggerResultsBasedEventSelector.cc.

                                                           {
      // If selectevents is an emtpy ParameterSet, then we are to write
      // all events, or one which contains a vstrig 'SelectEvents' that
      // is empty, we are to write all events. We have no need for any
      // EventSelectors.
      if (iPSet.empty()) {
        oSelector.setupDefault();
        return true;
      }
 
      std::vector<std::string> path_specs = iPSet.getParameter<std::vector<std::string> >("SelectEvents");
 
      if (path_specs.empty()) {
        oSelector.setupDefault();
        return true;
      }
 
      // If we get here, we have the possibility of having to deal with
      // path_specs that look at more than one process.
      std::vector<parsed_path_spec_t> parsed_paths(path_specs.size());
      for (size_t i = 0; i < path_specs.size(); ++i) {
        parse_path_spec(path_specs[i], parsed_paths[i]);
      }
      oSelector.setup(parsed_paths, iAllTriggerNames, iProcessName, std::move(iC));
 
      return false;
    }

References edm::ParameterSet::empty(), edm::ParameterSet::getParameter(), mps_fire::i, eostools::move(), edm::detail::TriggerResultsBasedEventSelector::setup(), and edm::detail::TriggerResultsBasedEventSelector::setupDefault().

Referenced by edm::global::OutputModuleBase::doPreallocate(), edm::limited::OutputModuleBase::doPreallocate(), edm::one::OutputModuleBase::doPreallocate(), edm::global::OutputModuleBase::OutputModuleBase(), edm::limited::OutputModuleBase::OutputModuleBase(), edm::one::OutputModuleBase::OutputModuleBase(), and edm::SubProcess::SubProcess().

doTheOffset() [1/5]

void edm::detail::doTheOffset	(	int	bunchSpace,
		int	bcr,
		std::vector< PCaloHit > &	calohits,
		unsigned int	evtNr,
		int	vertexOffset,
		bool	wrap
	)

Definition at line 49 of file Adjuster.cc.

                                                                                                                 {
      int timeOffset = bcr * bunchSpace;
      EncodedEventId id(bcr, evtNr);
      for (auto& item : calohits) {
        item.setEventId(id);
        item.setTime(item.time() + timeOffset);
      }
    }

References triggerObjects_cff::id, B2GTnPMonitor_cfi::item, and CalibratedDigis_cfi::timeOffset.

doTheOffset() [2/5]

void edm::detail::doTheOffset	(	int	bunchSpace,
		int	bcr,
		std::vector< PSimHit > &	simhits,
		unsigned int	evtNr,
		int	vertexOffset,
		bool	wrap
	)

Definition at line 28 of file Adjuster.cc.

                                                                                                               {
      int timeOffset = bcr * bunchSpace;
      EncodedEventId id(bcr, evtNr);
      if (wrap) {  // wrap time for long-lived hits into one beam crossing
        for (auto& item : simhits) {
          item.setEventId(id);
 
          float Tfloor = floor(item.timeOfFlight());
          float digits = item.timeOfFlight() - Tfloor;
          int remainder = int(Tfloor) % bunchSpace;
          item.setTof(float(remainder) + digits + timeOffset);
        }
      } else {
        for (auto& item : simhits) {
          item.setEventId(id);
          item.setTof(item.timeOfFlight() + timeOffset);
        }
      }
    }

References triggerObjects_cff::id, createfilelist::int, B2GTnPMonitor_cfi::item, HLTBitAnalyser_cfi::simhits, CalibratedDigis_cfi::timeOffset, and edm::convertException::wrap().

doTheOffset() [3/5]

void edm::detail::doTheOffset	(	int	bunchSpace,
		int	bcr,
		std::vector< SimTrack > &	simtracks,
		unsigned int	evtNr,
		int	vertexOffset,
		bool	wrap
	)

Definition at line 7 of file Adjuster.cc.

                                                                                                                  {
      EncodedEventId id(bcr, evtNr);
      for (auto& item : simtracks) {
        item.setEventId(id);
        if (!item.noVertex()) {
          item.setVertexIndex(item.vertIndex() + vertexOffset);
        }
      }
    }

References triggerObjects_cff::id, and B2GTnPMonitor_cfi::item.

Referenced by edm::Adjuster< T >::doOffset().

doTheOffset() [4/5]

void edm::detail::doTheOffset	(	int	bunchSpace,
		int	bcr,
		std::vector< SimVertex > &	simvertices,
		unsigned int	evtNr,
		int	vertexOffset,
		bool	wrap
	)

Definition at line 18 of file Adjuster.cc.

                                                                                                                     {
      int timeOffset = bcr * bunchSpace;
      EncodedEventId id(bcr, evtNr);
      for (auto& item : simvertices) {
        item.setEventId(id);
        item.setTof(item.position().t() + timeOffset);
      }
    }

References triggerObjects_cff::id, B2GTnPMonitor_cfi::item, and CalibratedDigis_cfi::timeOffset.

doTheOffset() [5/5]

void edm::detail::doTheOffset	(	int	bunchSpace,
		int	bcr,
		TrackingRecHitCollection &	trackingrechits,
		unsigned int	evtNr,
		int	vertexOffset,
		bool	wrap
	)

Definition at line 59 of file Adjuster.cc.

                                {
      EncodedEventId id(bcr, evtNr);
      for (auto it = trackingrechits.begin(); it != trackingrechits.end(); ++it) {
        if (trackerHitRTTI::isFast(*it)) {
          FastTrackerRecHit* rechit = static_cast<FastTrackerRecHit*>(&(*it));
          rechit->setEventId(id.rawId());
        }
      }
    }

References edm::OwnVector< T, P >::begin(), edm::OwnVector< T, P >::end(), triggerObjects_cff::id, trackerHitRTTI::isFast(), and FastTrackerRecHit::setEventId().

fillCollectionForThinning()

template<typename Item , typename Selector , typename Collection >

void edm::detail::fillCollectionForThinning	(	Item const &	item,
		Selector &	selector,
		unsigned int	iIndex,
		Collection &	output,
		ThinnedAssociation &	association
	)

Definition at line 43 of file ThinningProducer.h.

                                                                    {
      using SelectorChooseReturnType = decltype(selector.choose(0U, std::declval<Item const&>()));
      constexpr bool isSlimming = detail::IsStdOptional<SelectorChooseReturnType>::value;
      if constexpr (isSlimming) {
        std::optional<typename SelectorChooseReturnType::value_type> obj = selector.choose(iIndex, item);
        if (obj.has_value()) {
          // move to support std::unique_ptr<T> with edm::OwnVector<T> or std::vector<unique_ptr<T>>
          output.push_back(std::move(*obj));
          association.push_back(iIndex);
        }
      } else {
        if (selector.choose(iIndex, item)) {
          output.push_back(item);
          association.push_back(iIndex);
        }
      }
    }

References B2GTnPMonitor_cfi::item, eostools::move(), getGTfromDQMFile::obj, convertSQLitetoXML_cfg::output, and mitigatedMETSequence_cff::U.

Referenced by edmNew::fillCollectionForThinning(), and edm::ThinningProducer< Collection, Selector >::produce().

getThinnedKeyFrom_implementation()

template<typename F >

std::variant<unsigned int, GetThinnedKeyFromExceptionFactory, std::monostate> edm::detail::getThinnedKeyFrom_implementation	(	ProductID const &	parentID,
		BranchID const &	parent,
		unsigned int	key,
		ProductID const &	thinnedID,
		BranchID	thinned,
		ThinnedAssociationsHelper const &	thinnedAssociationsHelper,
		F &&	getThinnedAssociation
	)

Definition at line 394 of file getThinned_implementation.h.

                                   {
      // need to explicitly check for equality of parent BranchID,
      // because ThinnedAssociationsHelper::parentBegin() uses
      // std::lower_bound() that returns a valid iterator in case the
      // parent is not found
      if (auto iParent = thinnedAssociationsHelper.parentBegin(parent);
          iParent == thinnedAssociationsHelper.parentEnd(parent) or iParent->parent() != parent) {
        return [parentID]() {
          return Exception(errors::InvalidReference)
                 << "Parent collection with ProductID " << parentID << " has not been thinned";
        };
      }
 
      bool foundParent = false;
      std::vector<ThinnedAssociation const*> thinnedAssociationParentage;
      while (not foundParent) {
        // TODO: be smarter than linear search every time?
        auto branchesToThinned = std::find_if(
            thinnedAssociationsHelper.begin(), thinnedAssociationsHelper.end(), [&thinned](auto& associatedBranches) {
              return associatedBranches.thinned() == thinned;
            });
        if (branchesToThinned == thinnedAssociationsHelper.end()) {
          return [parentID, thinnedID, thinnedIsThinned = not thinnedAssociationParentage.empty()]() {
            Exception ex(errors::InvalidReference);
            ex << "Requested thinned collection with ProductID " << thinnedID
               << " is not thinned from the parent collection with ProductID " << parentID
               << " or from any collection thinned from it.";
            if (not thinnedIsThinned) {
              ex << " In fact, the collection " << thinnedID
                 << " passed in as a 'thinned' collection has not been thinned at all.";
            }
            return ex;
          };
        }
 
        ThinnedAssociation const* thinnedAssociation = getThinnedAssociation(branchesToThinned->association());
        if (thinnedAssociation == nullptr) {
          Exception ex{errors::LogicError};
          if (thinnedAssociationParentage.empty()) {
            ex << "ThinnedAssociation corresponding to thinned collection with ProductID " << thinnedID
               << " not found.";
          } else {
            ex << "Intermediate ThinnedAssociation between the requested thinned ProductID " << thinnedID
               << " and parent " << parentID << " not found.";
          }
          ex << " This should not happen.\nPlease contact the core framework developers.";
          throw ex;
        }
 
        thinnedAssociationParentage.push_back(thinnedAssociation);
        if (branchesToThinned->parent() == parent) {
          foundParent = true;
        } else {
          // next iteration with current parent as the thinned collection
          thinned = branchesToThinned->parent();
        }
      }
 
      // found the parent, now need to rewind the parentage chain to
      // find the index in the requested thinned collection
      unsigned int thinnedIndex = key;
      for (auto iAssociation = thinnedAssociationParentage.rbegin(), iEnd = thinnedAssociationParentage.rend();
           iAssociation != iEnd;
           ++iAssociation) {
        auto optIndex = (*iAssociation)->getThinnedIndex(thinnedIndex);
        if (optIndex) {
          thinnedIndex = *optIndex;
        } else {
          return std::monostate{};
        }
      }
      return thinnedIndex;
    }

References edm::ThinnedAssociationsHelper::begin(), edm::ThinnedAssociationsHelper::end(), Exception, edm::errors::InvalidReference, crabWrapper::key, edm::errors::LogicError, or, class-composition::parent, edm::ThinnedAssociationsHelper::parentBegin(), and edm::ThinnedAssociationsHelper::parentEnd().

Referenced by fwlite::DataGetterHelper::getThinnedKeyFrom(), BareRootProductGetter::getThinnedKeyFrom(), and edm::EventPrincipal::getThinnedKeyFrom().

getThinnedProduct()

template<typename F1 , typename F2 , typename F3 >

std::optional<std::tuple<WrapperBase const*, unsigned int> > edm::detail::getThinnedProduct	(	ProductID const &	pid,
		unsigned int	key,
		ThinnedAssociationsHelper const &	thinnedAssociationsHelper,
		F1	pidToBid,
		F2	getThinnedAssociation,
		F3	getByProductID
	)

Definition at line 287 of file getThinned_implementation.h.

                           {
      auto thinnedOrSlimmed = getThinnedProductOnSlimmingDepth(
          pid, key, thinnedAssociationsHelper, pidToBid, getThinnedAssociation, getByProductID);
 
      if (thinnedOrSlimmed.hasThinned()) {
        return thinnedOrSlimmed.thinnedProduct();
      } else if (thinnedOrSlimmed.hasSlimmed()) {
        auto [slimmedAssociation, slimmedIndex] = thinnedOrSlimmed.slimmedAssociation();
        ProductID const& slimmedCollectionPID = slimmedAssociation->thinnedCollectionID();
        WrapperBase const* slimmedCollection = getByProductID(slimmedCollectionPID);
        if (slimmedCollection == nullptr) {
          // Slimmed container is not found, try looking recursively in thinned containers
          // which were made by selecting elements from this thinned container.
          return getThinnedProduct(slimmedCollectionPID,
                                   slimmedIndex,
                                   thinnedAssociationsHelper,
                                   pidToBid,
                                   getThinnedAssociation,
                                   getByProductID);
        }
        return std::tuple(slimmedCollection, slimmedIndex);
      }
      return std::nullopt;
    }

References getThinnedProductOnSlimmingDepth(), and crabWrapper::key.

Referenced by BareRootProductGetter::getThinnedProduct(), fwlite::DataGetterHelper::getThinnedProduct(), and edm::EventPrincipal::getThinnedProduct().

getThinnedProductOnSlimmingDepth()

template<typename F1 , typename F2 , typename F3 >

ThinnedOrSlimmedProduct edm::detail::getThinnedProductOnSlimmingDepth	(	ProductID const &	pid,
		unsigned int	key,
		ThinnedAssociationsHelper const &	thinnedAssociationsHelper,
		F1	pidToBid,
		F2	getThinnedAssociation,
		F3	getByProductID
	)

Definition at line 67 of file getThinned_implementation.h.

                                                                                {
      BranchID parent = pidToBid(pid);
 
      auto associatedBranches = thinnedAssociationsHelper.parentBegin(parent);
      auto const iEnd = thinnedAssociationsHelper.parentEnd(parent);
 
      if (associatedBranches == iEnd) {
        return ThinnedOrSlimmedProduct();
      }
      bool const slimmedAllowed = (associatedBranches + 1 == iEnd);
      if (slimmedAllowed and associatedBranches->isSlimmed()) {
        // Slimmed container can be considered only if it has no (thinned) siblings
        ThinnedAssociation const* slimmedAssociation = getThinnedAssociation(associatedBranches->association());
        if (slimmedAssociation == nullptr or
            associatedBranches->parent() != pidToBid(slimmedAssociation->parentCollectionID())) {
          return ThinnedOrSlimmedProduct();
        }
 
        // Does this slimmed container have the element referenced by key?
        auto slimmedIndex = slimmedAssociation->getThinnedIndex(key);
        if (slimmedIndex.has_value()) {
          return ThinnedOrSlimmedProduct(slimmedAssociation, *slimmedIndex);
        } else {
          return ThinnedOrSlimmedProduct();
        }
      }
 
      // Loop over thinned containers which were made by selecting elements from the parent container
      for (; associatedBranches != iEnd; ++associatedBranches) {
        if (associatedBranches->isSlimmed()) {
          continue;
        }
 
        ThinnedAssociation const* thinnedAssociation = getThinnedAssociation(associatedBranches->association());
        if (thinnedAssociation == nullptr)
          continue;
 
        if (associatedBranches->parent() != pidToBid(thinnedAssociation->parentCollectionID())) {
          continue;
        }
 
        // Does this thinned container have the element referenced by key?
        auto thinnedIndex = thinnedAssociation->getThinnedIndex(key);
        if (not thinnedIndex.has_value()) {
          continue;
        }
 
        // Return a pointer to thinned container if we can find it
        ProductID const& thinnedCollectionPID = thinnedAssociation->thinnedCollectionID();
        WrapperBase const* thinnedCollection = getByProductID(thinnedCollectionPID);
        if (thinnedCollection != nullptr) {
          return ThinnedOrSlimmedProduct(thinnedCollection, *thinnedIndex);
        }
 
        // Thinned container is not found, try looking recursively in thinned containers
        // which were made by selecting elements from this thinned container.
        auto thinnedOrSlimmed = getThinnedProductOnSlimmingDepth(thinnedCollectionPID,
                                                                 *thinnedIndex,
                                                                 thinnedAssociationsHelper,
                                                                 pidToBid,
                                                                 getThinnedAssociation,
                                                                 getByProductID);
        if (thinnedOrSlimmed.hasThinned() or (slimmedAllowed and thinnedOrSlimmed.hasSlimmed())) {
          return thinnedOrSlimmed;
        }
      }
 
      return ThinnedOrSlimmedProduct();
    }

References edm::ThinnedAssociation::getThinnedIndex(), crabWrapper::key, or, class-composition::parent, edm::ThinnedAssociationsHelper::parentBegin(), edm::ThinnedAssociation::parentCollectionID(), edm::ThinnedAssociationsHelper::parentEnd(), and edm::ThinnedAssociation::thinnedCollectionID().

Referenced by getThinnedProduct().

getThinnedProducts()

template<typename F1 , typename F2 , typename F3 >

void edm::detail::getThinnedProducts	(	ProductID const &	pid,
		ThinnedAssociationsHelper const &	thinnedAssociationsHelper,
		F1	pidToBid,
		F2	getThinnedAssociation,
		F3	getByProductID,
		std::vector< WrapperBase const * > &	foundContainers,
		std::vector< unsigned int > &	keys
	)

Definition at line 334 of file getThinned_implementation.h.

                                                           {
      auto slimmed = getThinnedProductsOnSlimmingDepth(
          pid, thinnedAssociationsHelper, pidToBid, getThinnedAssociation, getByProductID, foundContainers, keys);
      if (slimmed.has_value()) {
        // no thinned procucts found, try out slimmed next if one is available
        auto [slimmedAssociation, slimmedIndexes] = std::move(*slimmed);
        ProductID const& slimmedCollectionPID = slimmedAssociation->thinnedCollectionID();
        WrapperBase const* slimmedCollection = getByProductID(slimmedCollectionPID);
        unsigned const nKeys = keys.size();
        if (slimmedCollection == nullptr) {
          getThinnedProducts(slimmedCollectionPID,
                             thinnedAssociationsHelper,
                             pidToBid,
                             getThinnedAssociation,
                             getByProductID,
                             foundContainers,
                             slimmedIndexes);
          for (unsigned k = 0; k < nKeys; ++k) {
            if (foundContainers[k] == nullptr)
              continue;
            if (slimmedIndexes[k] == kThinningDoNotLookForThisIndex)
              continue;
            keys[k] = slimmedIndexes[k];
          }
        } else {
          for (unsigned k = 0; k < nKeys; ++k) {
            if (slimmedIndexes[k] == kThinningDoNotLookForThisIndex)
              continue;
            keys[k] = slimmedIndexes[k];
            foundContainers[k] = slimmedCollection;
          }
        }
      }
    }

References getThinnedProductsOnSlimmingDepth(), dqmdumpme::k, relativeConstraints::keys, kThinningDoNotLookForThisIndex, and eostools::move().

Referenced by BareRootProductGetter::getThinnedProducts(), fwlite::DataGetterHelper::getThinnedProducts(), and edm::EventPrincipal::getThinnedProducts().

getThinnedProductsOnSlimmingDepth()

template<typename F1 , typename F2 , typename F3 >

std::optional<std::tuple<ThinnedAssociation const*, std::vector<unsigned int> > > edm::detail::getThinnedProductsOnSlimmingDepth	(	ProductID const &	pid,
		ThinnedAssociationsHelper const &	thinnedAssociationsHelper,
		F1	pidToBid,
		F2	getThinnedAssociation,
		F3	getByProductID,
		std::vector< WrapperBase const * > &	foundContainers,
		std::vector< unsigned int > &	keys
	)

Definition at line 187 of file getThinned_implementation.h.

                                       {
      BranchID parent = pidToBid(pid);
 
      auto associatedBranches = thinnedAssociationsHelper.parentBegin(parent);
      auto const iEnd = thinnedAssociationsHelper.parentEnd(parent);
 
      if (associatedBranches == iEnd) {
        return std::nullopt;
      }
      bool const slimmedAllowed = associatedBranches + 1 == iEnd;
      if (slimmedAllowed and associatedBranches->isSlimmed()) {
        // Slimmed container can be considered only if it has no (thinned) siblings
        ThinnedAssociation const* slimmedAssociation = getThinnedAssociation(associatedBranches->association());
        if (slimmedAssociation == nullptr or
            associatedBranches->parent() != pidToBid(slimmedAssociation->parentCollectionID())) {
          return std::nullopt;
        }
 
        auto [slimmedIndexes, hasAny] = makeThinnedIndexes(keys, foundContainers, slimmedAssociation);
        // Does this slimmed container have any of the elements referenced by keys?
        if (hasAny) {
          return std::tuple(slimmedAssociation, std::move(slimmedIndexes));
        } else {
          return std::nullopt;
        }
      }
 
      // Loop over thinned containers which were made by selecting elements from the parent container
      for (; associatedBranches != iEnd; ++associatedBranches) {
        if (associatedBranches->isSlimmed()) {
          continue;
        }
 
        ThinnedAssociation const* thinnedAssociation = getThinnedAssociation(associatedBranches->association());
        if (thinnedAssociation == nullptr)
          continue;
 
        if (associatedBranches->parent() != pidToBid(thinnedAssociation->parentCollectionID())) {
          continue;
        }
 
        auto [thinnedIndexes, hasAny] = makeThinnedIndexes(keys, foundContainers, thinnedAssociation);
        if (!hasAny) {
          continue;
        }
 
        // Set the pointers and indexes into the thinned container (if we can find it)
        ProductID thinnedCollectionPID = thinnedAssociation->thinnedCollectionID();
        WrapperBase const* thinnedCollection = getByProductID(thinnedCollectionPID);
        unsigned const nKeys = keys.size();
        if (thinnedCollection == nullptr) {
          // Thinned container is not found, try looking recursively in thinned containers
          // which were made by selecting elements from this thinned container.
          auto slimmed = getThinnedProductsOnSlimmingDepth(thinnedCollectionPID,
                                                           thinnedAssociationsHelper,
                                                           pidToBid,
                                                           getThinnedAssociation,
                                                           getByProductID,
                                                           foundContainers,
                                                           thinnedIndexes);
          if (slimmedAllowed and slimmed.has_value()) {
            return slimmed;
          }
          for (unsigned k = 0; k < nKeys; ++k) {
            if (foundContainers[k] == nullptr)
              continue;
            if (thinnedIndexes[k] == kThinningDoNotLookForThisIndex)
              continue;
            keys[k] = thinnedIndexes[k];
          }
        } else {
          for (unsigned k = 0; k < nKeys; ++k) {
            if (thinnedIndexes[k] == kThinningDoNotLookForThisIndex)
              continue;
            keys[k] = thinnedIndexes[k];
            foundContainers[k] = thinnedCollection;
          }
        }
      }
      return std::nullopt;
    }

References dqmdumpme::k, relativeConstraints::keys, kThinningDoNotLookForThisIndex, makeThinnedIndexes(), eostools::move(), or, class-composition::parent, edm::ThinnedAssociationsHelper::parentBegin(), edm::ThinnedAssociation::parentCollectionID(), edm::ThinnedAssociationsHelper::parentEnd(), and edm::ThinnedAssociation::thinnedCollectionID().

Referenced by getThinnedProducts().

has_isProductEqual() [1/2]

template<typename T >

static no_tag edm::detail::has_isProductEqual (   ... )

static

has_isProductEqual() [2/2]

template<typename T >

static yes_tag edm::detail::has_isProductEqual ( isProductEqual_function< T, &T::isProductEqual > *  dummy )

static

has_member_type() [1/2]

template<typename T >

static no_tag edm::detail::has_member_type (   ... )

static

has_member_type() [2/2]

template<typename T >

static yes_tag edm::detail::has_member_type ( typename T::member_type *  )

static

has_mergeProduct() [1/2]

template<typename T >

static no_tag edm::detail::has_mergeProduct (   ... )

static

has_mergeProduct() [2/2]

template<typename T >

static yes_tag edm::detail::has_mergeProduct ( mergeProduct_function< T, &T::mergeProduct > *  dummy )

static

has_postinsert_helper() [1/2]

template<typename T >

no_tag edm::detail::has_postinsert_helper

(

...

)

has_postinsert_helper() [2/2]

template<typename T >

yes_tag edm::detail::has_postinsert_helper

(

postinsert_function< T, &T::post_insert > *

p

)

has_swap() [1/2]

template<typename T >

static no_tag edm::detail::has_swap (   ... )

static

has_swap() [2/2]

template<typename T >

static yes_tag edm::detail::has_swap ( swap_function< T, &T::swap > *  dummy )

static

has_value_type() [1/2]

template<typename T >

static no_tag edm::detail::has_value_type (   ... )

static

has_value_type() [2/2]

template<typename T >

static yes_tag edm::detail::has_value_type ( typename T::value_type *  )

static

InvalidHash()

std::string const & edm::detail::InvalidHash

(

)

Definition at line 11 of file Hash.cc.

                                   {
      static std::string const invalid = cms::MD5Result().compactForm();
      return invalid;
    }

References cms::MD5Result::compactForm(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::hash_detail::isValid_(), and edm::Hash< EntryDescriptionType >::reset().

makeThinnedIndexes()

auto edm::detail::makeThinnedIndexes	(	std::vector< unsigned int > const &	keys,
		std::vector< WrapperBase const * > const &	foundContainers,
		ThinnedAssociation const *	thinnedAssociation
	)

Definition at line 142 of file getThinned_implementation.h.

                                                                          {
      unsigned const nKeys = keys.size();
      std::vector<unsigned int> thinnedIndexes(nKeys, kThinningDoNotLookForThisIndex);
      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] == kThinningDoNotLookForThisIndex) {
          continue;
        }
        // Does the thinned container hold the entry of interest?
        if (auto thinnedIndex = thinnedAssociation->getThinnedIndex(keys[k]); thinnedIndex.has_value()) {
          thinnedIndexes[k] = *thinnedIndex;
          hasAny = true;
        }
      }
      return std::tuple(std::move(thinnedIndexes), hasAny);
    }

References edm::ThinnedAssociation::getThinnedIndex(), dqmdumpme::k, relativeConstraints::keys, kThinningDoNotLookForThisIndex, and eostools::move().

Referenced by getThinnedProductsOnSlimmingDepth().

operator<<()

template<typename KEY , typename T , typename E >

std::ostream& edm::detail::operator<< ( std::ostream &  os, ThreadSafeRegistry< KEY, T > const &  reg  )

inline

Definition at line 97 of file ThreadSafeRegistry.h.

                                                                                         {
      reg.print(os);
      return os;
    }

References edm::detail::ThreadSafeRegistry< KEY, T >::print().

reallyfillPtrVector()

template<typename COLLECTION >

void edm::detail::reallyfillPtrVector	(	COLLECTION const &	coll,
		std::type_info const &	iToType,
		std::vector< unsigned long > const &	iIndicies,
		std::vector< void const * > &	oPtr
	)

Definition at line 37 of file fillPtrVector.h.

                                                           {
      typedef COLLECTION product_type;
      typedef typename GetProduct<product_type>::element_type element_type;
      typedef typename product_type::const_iterator iter;
 
      oPtr.reserve(iIndicies.size());
      if (iToType == typeid(element_type)) {
        for (std::vector<unsigned long>::const_iterator itIndex = iIndicies.begin(), itEnd = iIndicies.end();
             itIndex != itEnd;
             ++itIndex) {
          iter it = coll.begin();
          std::advance(it, *itIndex);
          element_type const* address = GetProduct<product_type>::address(it);
          oPtr.push_back(address);
        }
      } else {
        for (std::vector<unsigned long>::const_iterator itIndex = iIndicies.begin(), itEnd = iIndicies.end();
             itIndex != itEnd;
             ++itIndex) {
          iter it = coll.begin();
          std::advance(it, *itIndex);
          element_type const* address = GetProduct<product_type>::address(it);
          void const* ptr = pointerToBase(iToType, address);
          if (nullptr != ptr) {
            oPtr.push_back(ptr);
          } else {
            Exception::throwThis(errors::LogicError,
                                 "TypeConversionError "
                                 "edm::PtrVector<> : unable to convert type ",
                                 typeid(element_type).name(),
                                 " to ",
                                 iToType.name(),
                                 "\n");
          }
        }
      }
    }

References edm::detail::GetProduct< COLLECTION >::address(), edm::errors::LogicError, Skims_PA_cff::name, edm::pointerToBase(), and edm::Exception::throwThis().

Referenced by edm::fillPtrVector(), edm::OwnArray< T, MAX_SIZE, P >::fillPtrVector(), edm::SortedCollection< EcalRecHit >::fillPtrVector(), and edm::OwnVector< TrackingRegion >::fillPtrVector().

reallyFillView()

template<class COLLECTION >

void edm::detail::reallyFillView	(	COLLECTION const &	coll,
		ProductID const &	id,
		std::vector< void const * > &	ptrs,
		FillViewHelperVector &	helpers
	)

Definition at line 25 of file FillView.h.

                                                       {
      typedef COLLECTION product_type;
      typedef typename GetProduct<product_type>::element_type element_type;
      typedef typename product_type::const_iterator iter;
      typedef typename product_type::size_type size_type;
 
      ptrs.reserve(ptrs.size() + coll.size());
      helpers.reserve(ptrs.size() + coll.size());
      size_type key = 0;
      for (iter i = coll.begin(), e = coll.end(); i != e; ++i, ++key) {
        element_type const* address = GetProduct<product_type>::address(i);
        ptrs.push_back(address);
        helpers.emplace_back(id, key);
      }
    }

References edm::detail::GetProduct< COLLECTION >::address(), MillePedeFileConverter_cfg::e, mps_fire::i, and crabWrapper::key.

Referenced by edm::fillView(), edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::fillView(), edm::SortedCollection< EcalRecHit >::fillView(), and edm::DetSetVector< TotemRPLocalTrack::FittedRecHit >::fillView().

reallySetPtr()

template<typename COLLECTION >

void edm::detail::reallySetPtr	(	COLLECTION const &	coll,
		std::type_info const &	iToType,
		unsigned long	iIndex,
		void const *&	oPtr
	)

Definition at line 36 of file setPtr.h.

                                                                                                                    {
      typedef COLLECTION product_type;
      typedef typename GetProduct<product_type>::element_type element_type;
      typedef typename product_type::const_iterator iter;
 
      if (iToType == typeid(element_type)) {
        iter it = coll.begin();
        std::advance(it, iIndex);
        element_type const* address = GetProduct<product_type>::address(it);
        oPtr = address;
      } else {
        iter it = coll.begin();
        std::advance(it, iIndex);
        element_type const* address = GetProduct<product_type>::address(it);
 
        oPtr = pointerToBase(iToType, address);
 
        if (nullptr == oPtr) {
          Exception::throwThis(errors::LogicError,
                               "TypeConversionError"
                               "edm::Ptr<> : unable to convert type ",
                               typeid(element_type).name(),
                               " to ",
                               iToType.name(),
                               "\n");
        }
      }
    }

References edm::detail::GetProduct< COLLECTION >::address(), edm::errors::LogicError, Skims_PA_cff::name, edm::pointerToBase(), and edm::Exception::throwThis().

Referenced by edm::setPtr(), and edm::SortedCollection< EcalRecHit >::setPtr().

registerProperSelectionInfo()

ParameterSetID edm::detail::registerProperSelectionInfo	(	edm::ParameterSet const &	iInitial,
		std::string const &	iLabel,
		std::map< std::string, std::vector< std::pair< std::string, int > > > const &	outputModulePathPositions,
		bool	anyProductProduced
	)

Takes the user specified SelectEvents PSet and creates a new one which conforms to the canonical format required for provenance

Definition at line 163 of file TriggerResultsBasedEventSelector.cc.

                                 {
      ParameterSet selectEventsInfo;
      selectEventsInfo.copyForModify(iInitial);
      selectEventsInfo.addParameter<bool>("InProcessHistory", anyProductProduced);
      std::vector<std::string> endPaths;
      std::vector<int> endPathPositions;
 
      // The label will be empty if and only if this is a SubProcess
      // SubProcess's do not appear on any end path
      if (!iLabel.empty()) {
        std::map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator iter =
            outputModulePathPositions.find(iLabel);
        assert(iter != outputModulePathPositions.end());
        for (auto const& item : iter->second) {
          endPaths.push_back(item.first);
          endPathPositions.push_back(item.second);
        }
      }
      selectEventsInfo.addParameter<std::vector<std::string> >("EndPaths", endPaths);
      selectEventsInfo.addParameter<std::vector<int> >("EndPathPositions", endPathPositions);
      if (!selectEventsInfo.exists("SelectEvents")) {
        selectEventsInfo.addParameter<std::vector<std::string> >("SelectEvents", std::vector<std::string>());
      }
      selectEventsInfo.registerIt();
 
      return selectEventsInfo.id();
    }

References edm::ParameterSet::addParameter(), cms::cuda::assert(), edm::ParameterSet::copyForModify(), edm::ParameterSet::exists(), edm::ParameterSet::id(), B2GTnPMonitor_cfi::item, and edm::ParameterSet::registerIt().

Referenced by edm::one::OutputModuleBase::setEventSelectionInfo(), and edm::SubProcess::SubProcess().

Variable Documentation

kThinningDoNotLookForThisIndex

constexpr unsigned int edm::detail::kThinningDoNotLookForThisIndex = std::numeric_limits<unsigned int>::max()

constexpr

Definition at line 21 of file getThinned_implementation.h.

Referenced by getThinnedProducts(), getThinnedProductsOnSlimmingDepth(), and makeThinnedIndexes().