#include <ProcessBlockHelper.h>

Inheritance diagram for edm::ProcessBlockHelper:

Public Member Functions
std::vector< unsigned int > const &	cacheEntriesPerFile () const final

std::vector< unsigned int > const &	cacheIndexVectorsPerFile () const final

void	clearAfterOutputFilesClose ()

bool	dropProcessesAndReorderStored (StoredProcessBlockHelper &storedProcessBlockHelper, std::set< std::string > const &processesToKeep, std::vector< unsigned int > const &nEntries, std::vector< unsigned int > &finalIndexToStoredIndex, std::vector< std::string > const &firstFileFinalProcesses) const

void	fillFromPrimaryInput (StoredProcessBlockHelper const &storedProcessBlockHelper, std::vector< unsigned int > const &nEntries)

bool	firstFileDropProcessesAndReorderStored (StoredProcessBlockHelper &storedProcessBlockHelper, std::set< std::string > const &processesToKeep, std::vector< unsigned int > const &nEntries, std::vector< unsigned int > &finalIndexToStoredIndex) const

bool	initializedFromInput () const

void	initializeFromPrimaryInput (StoredProcessBlockHelper const &storedProcessBlockHelper)

std::vector< std::vector< unsigned int > > const &	nEntries () const final

unsigned int	nProcessesInFirstFile () const final

unsigned int	outerOffset () const final

std::vector< std::vector< unsigned int > > const &	processBlockCacheIndices () const final

unsigned int	processBlockIndex (std::string const &processName, EventToProcessBlockIndexes const &) const final

ProcessBlockHelperBase const *	topProcessBlockHelper () const final

std::vector< std::string > const &	topProcessesWithProcessBlockProducts () const final

Public Member Functions inherited from edm::ProcessBlockHelperBase
std::vector< std::string > const &	addedProcesses () const

void	emplaceBackAddedProcessName (std::string const &processName)

void	emplaceBackProcessName (std::string const &processName)

std::vector< std::string > const &	processesWithProcessBlockProducts () const

std::string	selectProcess (ProductRegistry const &, ProductLabels const &, TypeID const &) const

void	setAddedProcesses (std::vector< std::string > const &val)

void	setProcessesWithProcessBlockProducts (std::vector< std::string > const &val)

void	updateForNewProcess (ProductRegistry const &, std::string const &processName)

virtual	~ProcessBlockHelperBase ()

Private Member Functions
void	dropProcessesAndReorderStoredImpl (StoredProcessBlockHelper &storedProcessBlockHelper, std::vector< std::string > &finalProcesses, std::vector< unsigned int > const &nEntries, std::vector< unsigned int > const &finalIndexToStoredIndex) const

void	fillEntriesFromPrimaryInput (std::vector< unsigned int > nEntries)

void	fillFromPrimaryInputWhenNotEmpty (std::vector< std::string > const &storedProcesses, std::vector< unsigned int > const &storedCacheIndices, std::vector< unsigned int > const &nEntries)

Private Attributes
std::vector< unsigned int >	cacheEntriesPerFile_

unsigned int	cacheIndexOffset_ = 0

std::vector< unsigned int >	cacheIndexVectorsPerFile_

bool	initializedFromInput_ = false

std::vector< std::vector< unsigned int > >	nEntries_

unsigned int	nProcessesInFirstFile_ = 0

unsigned int	outerOffset_ = 0

std::vector< std::vector< unsigned int > >	processBlockCacheIndices_

Additional Inherited Members
Static Public Member Functions inherited from edm::ProcessBlockHelperBase
static constexpr unsigned int	invalidCacheIndex ()

static constexpr unsigned int	invalidProcessIndex ()

Detailed Description

Author: W. David Dagenhart, created 15 September, 2020

Definition at line 19 of file ProcessBlockHelper.h.

Member Function Documentation

◆ cacheEntriesPerFile()

std::vector< unsigned int > const & edm::ProcessBlockHelper::cacheEntriesPerFile ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 30 of file ProcessBlockHelper.cc.

References cacheEntriesPerFile_.

30 { return cacheEntriesPerFile_; }

edm::ProcessBlockHelper::cacheEntriesPerFile_

std::vector< unsigned int > cacheEntriesPerFile_

Definition: ProcessBlockHelper.h:100

◆ cacheIndexVectorsPerFile()

std::vector< unsigned int > const & edm::ProcessBlockHelper::cacheIndexVectorsPerFile ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 26 of file ProcessBlockHelper.cc.

References cacheIndexVectorsPerFile_.

                                                                                     {
     return cacheIndexVectorsPerFile_;
   }

◆ clearAfterOutputFilesClose()

void edm::ProcessBlockHelper::clearAfterOutputFilesClose ( )

Definition at line 158 of file ProcessBlockHelper.cc.

References cacheEntriesPerFile_, cacheIndexOffset_, cacheIndexVectorsPerFile_, nEntries_, outerOffset_, and processBlockCacheIndices_.

                                                       {
     processBlockCacheIndices_.clear();
     nEntries_.clear();
     cacheIndexVectorsPerFile_.clear();
     cacheEntriesPerFile_.clear();
     outerOffset_ = 0;
     cacheIndexOffset_ = 0;
   }

◆ dropProcessesAndReorderStored()

bool edm::ProcessBlockHelper::dropProcessesAndReorderStored	(	StoredProcessBlockHelper &	storedProcessBlockHelper,
		std::set< std::string > const &	processesToKeep,
		std::vector< unsigned int > const &	nEntries,
		std::vector< unsigned int > &	finalIndexToStoredIndex,
		std::vector< std::string > const &	firstFileFinalProcesses
	)		const

Definition at line 83 of file ProcessBlockHelper.cc.

References dropProcessesAndReorderStoredImpl(), nEntries(), edm::StoredProcessBlockHelper::processesWithProcessBlockProducts(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::RootFile::dropProcessesAndReorder().

                                                                                                                     {
     std::vector<std::string> const& storedProcesses = storedProcessBlockHelper.processesWithProcessBlockProducts();
 
     std::vector<std::string> finalProcesses;
     // Always will allocate enough space (sometimes too much)
     finalProcesses.reserve(storedProcesses.size());
     finalIndexToStoredIndex.reserve(storedProcesses.size());
 
     // The outer loop here establishes the order
     // Only allows processes that got into finalProcesses for the first file
     for (unsigned int iFirst = 0; iFirst < firstFileFinalProcesses.size(); ++iFirst) {
       // Only includes processes also in storedProcesses
       for (unsigned int iStored = 0; iStored < storedProcesses.size(); ++iStored) {
         std::string const& storedProcess = storedProcesses[iStored];
         if (firstFileFinalProcesses[iFirst] == storedProcess) {
           // Also requires processes have kept ProcessBlock products
           if (processesToKeep.find(storedProcess) != processesToKeep.end()) {
             finalProcesses.emplace_back(storedProcess);
             finalIndexToStoredIndex.emplace_back(iStored);
             break;
           }
         }
       }
     }
 
     bool isModified = true;
     if (storedProcesses == finalProcesses) {
       isModified = false;
       return isModified;
     }
 
     dropProcessesAndReorderStoredImpl(storedProcessBlockHelper, finalProcesses, nEntries, finalIndexToStoredIndex);
     return isModified;
   }

◆ dropProcessesAndReorderStoredImpl()

void edm::ProcessBlockHelper::dropProcessesAndReorderStoredImpl	(	StoredProcessBlockHelper &	storedProcessBlockHelper,
		std::vector< std::string > &	finalProcesses,
		std::vector< unsigned int > const &	nEntries,
		std::vector< unsigned int > const &	finalIndexToStoredIndex
	)		const

private

Definition at line 170 of file ProcessBlockHelper.cc.

References cms::cuda::assert(), edm::ProcessBlockHelperBase::invalidCacheIndex(), dqmiolumiharvest::j, dqmdumpme::k, eostools::move(), nEntries(), hltrates_dqm_sourceclient-live_cfg::offset, edm::StoredProcessBlockHelper::processBlockCacheIndices(), edm::StoredProcessBlockHelper::processesWithProcessBlockProducts(), edm::StoredProcessBlockHelper::setProcessBlockCacheIndices(), and edm::StoredProcessBlockHelper::setProcessesWithProcessBlockProducts().

Referenced by dropProcessesAndReorderStored(), and firstFileDropProcessesAndReorderStored().

                                                                     {
     std::vector<std::string> const& storedProcesses = storedProcessBlockHelper.processesWithProcessBlockProducts();
     std::vector<unsigned int> const& storedCacheIndices = storedProcessBlockHelper.processBlockCacheIndices();
 
     assert(!storedProcesses.empty());
     std::vector<unsigned int> newCacheIndices;
     if (!finalProcesses.empty()) {
       // ProcessBlocks are read in the order of storedProcesses and within
       // each process in entry order in the TTree.  This establishes the cache
       // order that the values in storedCacheIndices refer to. The "offset" refers
       // to cache index value of the first ProcessBlock in a TTree.
       std::vector<unsigned int> oldOffsets;
       oldOffsets.reserve(storedProcesses.size());
       unsigned int offset = 0;
       for (auto const& entries : nEntries) {
         oldOffsets.emplace_back(offset);
         offset += entries;
       }
 
       unsigned int nFinalProcesses = finalProcesses.size();
       std::vector<unsigned int> newOffsets;
       newOffsets.reserve(nFinalProcesses);
       offset = 0;
       for (unsigned int iNew = 0; iNew < nFinalProcesses; ++iNew) {
         newOffsets.emplace_back(offset);
         offset += nEntries[finalIndexToStoredIndex[iNew]];
       }
 
       unsigned int nOuterLoop = storedCacheIndices.size() / storedProcesses.size();
       assert(nOuterLoop * storedProcesses.size() == storedCacheIndices.size());
       newCacheIndices.reserve(nOuterLoop * nFinalProcesses);
       unsigned int storedOuterOffset = 0;
 
       for (unsigned int k = 0; k < nOuterLoop; ++k) {
         for (unsigned int j = 0; j < nFinalProcesses; ++j) {
           unsigned int storedIndex = finalIndexToStoredIndex[j];
           unsigned int oldCacheIndex = storedCacheIndices[storedOuterOffset + storedIndex];
           unsigned int newCacheIndex = invalidCacheIndex();
           if (oldCacheIndex != invalidCacheIndex()) {
             newCacheIndex = oldCacheIndex - oldOffsets[storedIndex] + newOffsets[j];
           }
           newCacheIndices.emplace_back(newCacheIndex);
         }
         storedOuterOffset += storedProcesses.size();
       }
     }
     storedProcessBlockHelper.setProcessBlockCacheIndices(std::move(newCacheIndices));
     storedProcessBlockHelper.setProcessesWithProcessBlockProducts(std::move(finalProcesses));
   }

◆ fillEntriesFromPrimaryInput()

void edm::ProcessBlockHelper::fillEntriesFromPrimaryInput ( std::vector< unsigned int > nEntries )

private

Definition at line 271 of file ProcessBlockHelper.cc.

References cacheEntriesPerFile_, cacheIndexOffset_, eostools::move(), nEntries(), and nEntries_.

Referenced by fillFromPrimaryInput(), and fillFromPrimaryInputWhenNotEmpty().

                                                                                        {
     unsigned int entriesThisFile = 0;
     for (auto const& entries : nEntries) {
       entriesThisFile += entries;
     }
     nEntries_.push_back(std::move(nEntries));
     cacheEntriesPerFile_.push_back(entriesThisFile);
     cacheIndexOffset_ += entriesThisFile;
   }

◆ fillFromPrimaryInput()

void edm::ProcessBlockHelper::fillFromPrimaryInput	(	StoredProcessBlockHelper const &	storedProcessBlockHelper,
		std::vector< unsigned int > const &	nEntries
	)

Definition at line 132 of file ProcessBlockHelper.cc.

References cacheIndexVectorsPerFile_, fillEntriesFromPrimaryInput(), fillFromPrimaryInputWhenNotEmpty(), edm::ProcessBlockHelperBase::invalidCacheIndex(), eostools::move(), nEntries(), nProcessesInFirstFile_, outerOffset_, edm::StoredProcessBlockHelper::processBlockCacheIndices(), processBlockCacheIndices_, and edm::StoredProcessBlockHelper::processesWithProcessBlockProducts().

                                                                                          {
     // I've written this so it will continue to work even if we someday relax
     // the strict merging requirement in the ProductRegistry (there
     // is a little extra complexity that may be unnecessary...).
 
     std::vector<std::string> const& storedProcesses = storedProcessBlockHelper.processesWithProcessBlockProducts();
     std::vector<unsigned int> const& storedCacheIndices = storedProcessBlockHelper.processBlockCacheIndices();
 
     outerOffset_ = processBlockCacheIndices_.size();
 
     if (nProcessesInFirstFile_ == 0) {
       // There were no ProcessBlock products in the first file. Nothing to do.
       return;
     } else if (!storedProcesses.empty()) {
       // Subsequent input file with ProcessBlock products
       fillFromPrimaryInputWhenNotEmpty(storedProcesses, storedCacheIndices, nEntries);
     } else if (storedProcesses.empty()) {
       // Subsequent input file without ProcessBlock products
       processBlockCacheIndices_.emplace_back(nProcessesInFirstFile_, invalidCacheIndex());
       cacheIndexVectorsPerFile_.push_back(1);
       std::vector<unsigned int> newNEntries(nProcessesInFirstFile_, 0);
       fillEntriesFromPrimaryInput(std::move(newNEntries));
     }
   }

◆ fillFromPrimaryInputWhenNotEmpty()

void edm::ProcessBlockHelper::fillFromPrimaryInputWhenNotEmpty	(	std::vector< std::string > const &	storedProcesses,
		std::vector< unsigned int > const &	storedCacheIndices,
		std::vector< unsigned int > const &	nEntries
	)

private

Definition at line 224 of file ProcessBlockHelper.cc.

References cms::cuda::assert(), cacheIndexOffset_, cacheIndexVectorsPerFile_, fillEntriesFromPrimaryInput(), edm::ProcessBlockHelperBase::invalidCacheIndex(), edm::ProcessBlockHelperBase::invalidProcessIndex(), dqmiolumiharvest::j, dqmdumpme::k, eostools::move(), nEntries(), nProcessesInFirstFile_, outerOffset_, processBlockCacheIndices_, edm::ProcessBlockHelperBase::processesWithProcessBlockProducts(), and findQualityFiles::size.

Referenced by fillFromPrimaryInput().

                                                                                                      {
     assert(nProcessesInFirstFile_ <= processesWithProcessBlockProducts().size());
 
     // Calculate a translation from an index into the process names from the first file
     // to an index into the process names from the current file. Note the value will
     // be left invalid if the process name is not found in the current file.
     std::vector<unsigned int> firstFileToStored(nProcessesInFirstFile_, invalidProcessIndex());
     std::vector<unsigned int> newNEntries(nProcessesInFirstFile_, 0);
     for (unsigned int j = 0; j < nProcessesInFirstFile_; ++j) {
       for (unsigned int k = 0; k < storedProcesses.size(); ++k) {
         if (processesWithProcessBlockProducts()[j] == storedProcesses[k]) {
           firstFileToStored[j] = k;
           newNEntries[j] = nEntries[k];
           break;
         }
       }
     }
 
     // Append the cache indices from the current input file to the
     // cache indices container from the previous files.
     unsigned int nCacheIndexVectors = storedCacheIndices.size() / storedProcesses.size();
     assert(storedProcesses.size() * nCacheIndexVectors == storedCacheIndices.size());
     processBlockCacheIndices_.resize(processBlockCacheIndices_.size() + nCacheIndexVectors);
     unsigned int storedIndex = 0;
     for (unsigned int k = 0; k < nCacheIndexVectors; ++k) {
       processBlockCacheIndices_[outerOffset_ + k].reserve(nProcessesInFirstFile_);
       for (unsigned int j = 0; j < nProcessesInFirstFile_; ++j) {
         unsigned int iStored = firstFileToStored[j];
         if (iStored == invalidProcessIndex()) {
           processBlockCacheIndices_[outerOffset_ + k].push_back(invalidCacheIndex());
         } else {
           unsigned int oldCacheIndex = storedCacheIndices[storedIndex];
           ++storedIndex;
           unsigned int newCacheIndex = invalidCacheIndex();
           if (oldCacheIndex != invalidCacheIndex()) {
             newCacheIndex = oldCacheIndex + cacheIndexOffset_;
           }
           processBlockCacheIndices_[outerOffset_ + k].push_back(newCacheIndex);
         }
       }
     }
     cacheIndexVectorsPerFile_.push_back(nCacheIndexVectors);
     fillEntriesFromPrimaryInput(std::move(newNEntries));
   }

◆ firstFileDropProcessesAndReorderStored()

bool edm::ProcessBlockHelper::firstFileDropProcessesAndReorderStored	(	StoredProcessBlockHelper &	storedProcessBlockHelper,
		std::set< std::string > const &	processesToKeep,
		std::vector< unsigned int > const &	nEntries,
		std::vector< unsigned int > &	finalIndexToStoredIndex
	)		const

Definition at line 47 of file ProcessBlockHelper.cc.

References dropProcessesAndReorderStoredImpl(), nEntries(), LaserDQM_cfg::process, and edm::StoredProcessBlockHelper::processesWithProcessBlockProducts().

Referenced by edm::RootFile::dropProcessesAndReorder().

                                                               {
     std::vector<std::string> const& storedProcesses = storedProcessBlockHelper.processesWithProcessBlockProducts();
 
     bool isModified = false;
     unsigned int finalSize = 0;
     for (auto const& process : storedProcesses) {
       if (processesToKeep.find(process) == processesToKeep.end()) {
         isModified = true;
       } else {
         ++finalSize;
       }
     }
     if (!isModified) {
       return isModified;
     }
 
     std::vector<std::string> finalProcesses;
     finalProcesses.reserve(finalSize);
     finalIndexToStoredIndex.reserve(finalSize);
     for (unsigned int iStored = 0; iStored < storedProcesses.size(); ++iStored) {
       if (processesToKeep.find(storedProcesses[iStored]) != processesToKeep.end()) {
         finalProcesses.emplace_back(storedProcesses[iStored]);
         finalIndexToStoredIndex.emplace_back(iStored);
       }
     }
     dropProcessesAndReorderStoredImpl(storedProcessBlockHelper, finalProcesses, nEntries, finalIndexToStoredIndex);
     return isModified;
   }

◆ initializedFromInput()

bool edm::ProcessBlockHelper::initializedFromInput ( ) const

inline

Definition at line 31 of file ProcessBlockHelper.h.

References initializedFromInput_.

Referenced by edm::RootFile::dropProcessesAndReorder().

31 { return initializedFromInput_; }

edm::ProcessBlockHelper::initializedFromInput_

bool initializedFromInput_

Definition: ProcessBlockHelper.h:104

◆ initializeFromPrimaryInput()

void edm::ProcessBlockHelper::initializeFromPrimaryInput ( StoredProcessBlockHelper const & storedProcessBlockHelper )

Definition at line 122 of file ProcessBlockHelper.cc.

References cms::cuda::assert(), relativeConstraints::empty, initializedFromInput_, nProcessesInFirstFile_, edm::ProcessBlockHelperBase::processesWithProcessBlockProducts(), edm::StoredProcessBlockHelper::processesWithProcessBlockProducts(), and edm::ProcessBlockHelperBase::setProcessesWithProcessBlockProducts().

Referenced by edm::RootFile::RootFile().

                                                                                                               {
     if (!initializedFromInput_) {
       initializedFromInput_ = true;
 
       assert(processesWithProcessBlockProducts().empty());
       setProcessesWithProcessBlockProducts(storedProcessBlockHelper.processesWithProcessBlockProducts());
       nProcessesInFirstFile_ = processesWithProcessBlockProducts().size();
     }
   }

◆ nEntries()

std::vector< std::vector< unsigned int > > const & edm::ProcessBlockHelper::nEntries ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 24 of file ProcessBlockHelper.cc.

References nEntries_.

Referenced by dropProcessesAndReorderStored(), dropProcessesAndReorderStoredImpl(), fillEntriesFromPrimaryInput(), fillFromPrimaryInput(), fillFromPrimaryInputWhenNotEmpty(), and firstFileDropProcessesAndReorderStored().

24 { return nEntries_; }

edm::ProcessBlockHelper::nEntries_

std::vector< std::vector< unsigned int > > nEntries_

Definition: ProcessBlockHelper.h:94

◆ nProcessesInFirstFile()

unsigned int edm::ProcessBlockHelper::nProcessesInFirstFile ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 18 of file ProcessBlockHelper.cc.

References nProcessesInFirstFile_.

18 { return nProcessesInFirstFile_; }

edm::ProcessBlockHelper::nProcessesInFirstFile_

unsigned int nProcessesInFirstFile_

Definition: ProcessBlockHelper.h:102

◆ outerOffset()

unsigned int edm::ProcessBlockHelper::outerOffset ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 42 of file ProcessBlockHelper.cc.

References outerOffset_.

42 { return outerOffset_; }

edm::ProcessBlockHelper::outerOffset_

unsigned int outerOffset_

Definition: ProcessBlockHelper.h:110

◆ processBlockCacheIndices()

std::vector< std::vector< unsigned int > > const & edm::ProcessBlockHelper::processBlockCacheIndices ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 20 of file ProcessBlockHelper.cc.

References processBlockCacheIndices_.

                                                                                                {
     return processBlockCacheIndices_;
   }

◆ processBlockIndex()

unsigned int edm::ProcessBlockHelper::processBlockIndex	(	std::string const &	processName,
		EventToProcessBlockIndexes const &	eventToProcessBlockIndexes
	)		const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 32 of file ProcessBlockHelper.cc.

References edm::EventToProcessBlockIndexes::index(), edm::ProcessBlockHelperBase::invalidCacheIndex(), nProcessesInFirstFile_, processBlockCacheIndices_, edm::ProcessBlockHelperBase::processesWithProcessBlockProducts(), and SimL1EmulatorRepack_CalouGT_cff::processName.

                                                                                                         {
     for (unsigned int iProcess = 0; iProcess < nProcessesInFirstFile_; ++iProcess) {
       if (processName == processesWithProcessBlockProducts()[iProcess]) {
         return processBlockCacheIndices_[eventToProcessBlockIndexes.index()][iProcess];
       }
     }
     return invalidCacheIndex();
   }

◆ topProcessBlockHelper()

ProcessBlockHelperBase const * edm::ProcessBlockHelper::topProcessBlockHelper ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 12 of file ProcessBlockHelper.cc.

12 { return this; }

◆ topProcessesWithProcessBlockProducts()

std::vector< std::string > const & edm::ProcessBlockHelper::topProcessesWithProcessBlockProducts ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 14 of file ProcessBlockHelper.cc.

References edm::ProcessBlockHelperBase::processesWithProcessBlockProducts().

                                                                                              {
     return processesWithProcessBlockProducts();
   }

Member Data Documentation

◆ cacheEntriesPerFile_

std::vector<unsigned int> edm::ProcessBlockHelper::cacheEntriesPerFile_

private

Definition at line 100 of file ProcessBlockHelper.h.

Referenced by cacheEntriesPerFile(), clearAfterOutputFilesClose(), and fillEntriesFromPrimaryInput().

◆ cacheIndexOffset_

unsigned int edm::ProcessBlockHelper::cacheIndexOffset_ = 0

private

Definition at line 114 of file ProcessBlockHelper.h.

Referenced by clearAfterOutputFilesClose(), fillEntriesFromPrimaryInput(), and fillFromPrimaryInputWhenNotEmpty().

◆ cacheIndexVectorsPerFile_

std::vector<unsigned int> edm::ProcessBlockHelper::cacheIndexVectorsPerFile_

private

Definition at line 99 of file ProcessBlockHelper.h.

Referenced by cacheIndexVectorsPerFile(), clearAfterOutputFilesClose(), fillFromPrimaryInput(), and fillFromPrimaryInputWhenNotEmpty().

◆ initializedFromInput_

bool edm::ProcessBlockHelper::initializedFromInput_ = false

private

Definition at line 104 of file ProcessBlockHelper.h.

Referenced by initializedFromInput(), and initializeFromPrimaryInput().

◆ nEntries_

std::vector<std::vector<unsigned int> > edm::ProcessBlockHelper::nEntries_

private

Definition at line 94 of file ProcessBlockHelper.h.

Referenced by clearAfterOutputFilesClose(), fillEntriesFromPrimaryInput(), and nEntries().

◆ nProcessesInFirstFile_

unsigned int edm::ProcessBlockHelper::nProcessesInFirstFile_ = 0

private

Definition at line 102 of file ProcessBlockHelper.h.

Referenced by fillFromPrimaryInput(), fillFromPrimaryInputWhenNotEmpty(), initializeFromPrimaryInput(), nProcessesInFirstFile(), and processBlockIndex().

◆ outerOffset_

unsigned int edm::ProcessBlockHelper::outerOffset_ = 0

private

Definition at line 110 of file ProcessBlockHelper.h.

Referenced by clearAfterOutputFilesClose(), fillFromPrimaryInput(), fillFromPrimaryInputWhenNotEmpty(), and outerOffset().

◆ processBlockCacheIndices_

std::vector<std::vector<unsigned int> > edm::ProcessBlockHelper::processBlockCacheIndices_

private

Definition at line 87 of file ProcessBlockHelper.h.

Referenced by clearAfterOutputFilesClose(), fillFromPrimaryInput(), fillFromPrimaryInputWhenNotEmpty(), processBlockCacheIndices(), and processBlockIndex().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ cacheEntriesPerFile()

◆ cacheIndexVectorsPerFile()

◆ clearAfterOutputFilesClose()

◆ dropProcessesAndReorderStored()

◆ dropProcessesAndReorderStoredImpl()

◆ fillEntriesFromPrimaryInput()

◆ fillFromPrimaryInput()

◆ fillFromPrimaryInputWhenNotEmpty()

◆ firstFileDropProcessesAndReorderStored()

◆ initializedFromInput()

◆ initializeFromPrimaryInput()

◆ nEntries()

◆ nProcessesInFirstFile()

◆ outerOffset()

◆ processBlockCacheIndices()

◆ processBlockIndex()

◆ topProcessBlockHelper()

◆ topProcessesWithProcessBlockProducts()

Member Data Documentation

◆ cacheEntriesPerFile_

◆ cacheIndexOffset_

◆ cacheIndexVectorsPerFile_

◆ initializedFromInput_

◆ nEntries_

◆ nProcessesInFirstFile_

◆ outerOffset_

◆ processBlockCacheIndices_