CondHDF5ESSource Class Reference

Inheritance diagram for CondHDF5ESSource:

Public Types
using	EventSetupRecordKey = edm::eventsetup::EventSetupRecordKey

Public Member Functions
	CondHDF5ESSource (edm::ParameterSet const &)
Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
bool	concurrentFinder () const
const eventsetup::ComponentDescription &	descriptionForFinder () const
	EventSetupRecordIntervalFinder ()
	EventSetupRecordIntervalFinder (const EventSetupRecordIntervalFinder &)=delete
std::set< eventsetup::EventSetupRecordKey >	findingForRecords () const
const ValidityInterval &	findIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)
bool	nonconcurrentAndIOVNeedsUpdate (const eventsetup::EventSetupRecordKey &key, const IOVSyncValue &syncValue) const
const EventSetupRecordIntervalFinder &	operator= (const EventSetupRecordIntervalFinder &)=delete
void	resetInterval (const eventsetup::EventSetupRecordKey &)
void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)
virtual	~EventSetupRecordIntervalFinder () noexcept(false)
Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
void	createKeyedResolvers (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
const ComponentDescription &	description () const
	ESProductResolverProvider ()
	ESProductResolverProvider (const ESProductResolverProvider &)=delete
void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const
virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
bool	isUsingRecord (const EventSetupRecordKey &key) const
KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)
const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete
void	setAppendToDataLabel (const edm::ParameterSet &)
void	setDescription (const ComponentDescription &iDescription)
virtual void	updateLookup (ESRecordsToProductResolverIndices const &)
std::set< EventSetupRecordKey >	usingRecords () const
virtual	~ESProductResolverProvider () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
static void	prevalidate (ConfigurationDescriptions &)

Private Member Functions
bool	isConcurrentFinder () const final
KeyedResolversVector	registerResolvers (EventSetupRecordKey const &, unsigned int iovIndex) final
void	setIntervalFor (EventSetupRecordKey const &, edm::IOVSyncValue const &, edm::ValidityInterval &) final

Private Attributes
Compression	compression_ = Compression::kNone
cms::h5::File	file_
std::string	filename_
std::mutex	mutex_
edm::SerialTaskQueue	queue_
std::vector< Record >	records_

Additional Inherited Members
Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using	KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>
Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void	findingRecord ()
void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)
Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
template<class T >
void	usingRecord ()
void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

Definition at line 44 of file CondHDF5ESSource.cc.

Member Typedef Documentation

EventSetupRecordKey

using CondHDF5ESSource::EventSetupRecordKey = edm::eventsetup::EventSetupRecordKey

Definition at line 46 of file CondHDF5ESSource.cc.

Constructor & Destructor Documentation

CondHDF5ESSource()

CondHDF5ESSource::CondHDF5ESSource ( edm::ParameterSet const &  iPSet )

explicit

Definition at line 89 of file CondHDF5ESSource.cc.

References cms::cuda::assert(), cms::h5::File::derefGroup(), file_, cms::h5::File::findGroup(), edm::EventSetupRecordIntervalFinder::findingRecordWithKey(), edm::eventsetup::heterocontainer::HCTypeTag::findType(), get, edm::ParameterSet::getParameter(), mps_fire::i, crabWrapper::key, MainPageGenerator::l, eostools::move(), Skims_PA_cff::name, alignCSCRings::r, AlCaHarvesting_cff::record, records_, jetUpdater_cfi::sort, AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, triggerMatcherToHLTDebug_cfi::tags, dqmiodumpindices::typeName, and edm::eventsetup::ESProductResolverProvider::usingRecordWithKey().

    : filename_(iPSet.getUntrackedParameter<std::string>("filename")),
      file_(filename_, cms::h5::File::kReadOnly),
      compression_(nameToEnum(file_.findAttribute("default_payload_compressor")->readString())) {
  const auto globalTagsGroup = file_.findGroup("GlobalTags");
  const auto chosenTag = globalTagsGroup->findGroup(iPSet.getParameter<std::string>("globalTag"));
  const auto tagsDataSet = chosenTag->findDataSet("Tags");
  const auto recordsGroup = file_.findGroup("Records");

  std::vector<hobj_ref_t> tags = tagsDataSet->readRefs();

  std::set<std::string> recordsToExclude;
  {
    auto exclude = iPSet.getParameter<std::vector<std::string>>("excludeRecords");
    recordsToExclude = std::set(exclude.begin(), exclude.end());
  }

  for (auto t : tags) {
    auto tagGroup = file_.derefGroup(t);
    Record record;
    record.name_ = tagGroup->findAttribute("record")->readString();
    //std::cout << record.name_ << std::endl;

    if (recordsToExclude.end() != recordsToExclude.find(record.name_)) {
      //std::cout << "excluding " << record.name_ << std::endl;
      continue;
    }

    auto recordGroup = recordsGroup->findGroup(record.name_);
    //std::cout << "found record group" << std::endl;
    auto dataProductsGroup = recordGroup->findGroup("DataProducts");
    //std::cout << "found DataProducts group" << std::endl;

    for (size_t i = 0; i < dataProductsGroup->getNumObjs(); ++i) {
      std::string productGroupName = dataProductsGroup->getObjnameByIdx(i);
      //std::cout << "looking for " << productGroupName << std::endl;
      auto dataProductGroup = dataProductsGroup->findGroup(productGroupName);

      auto const typeAttr = dataProductGroup->findAttribute("type");
      std::string typeName = typeAttr->readString();
      //loading the factory should also trigger registering the Record and DataProduct keys
      cond::serialization::SerializationHelperFactory::get()->create(typeName);
      std::string name = productGroupName.substr(typeName.size() + 1, productGroupName.size());
      if (name.size() == 1 and name[0] == '-') {
        name = std::string();
      }
      record.dataProducts_.emplace_back(std::move(name), std::move(typeName));
    }

    {
      auto const typeAttr = tagGroup->findAttribute("time_type");
      std::string typeName = typeAttr->readString();
      record.iovIsRunLumi_ = (typeName == "run_lumi");
    }

    std::vector<hobj_ref_t> payloadRefForIOVs;
    {
      auto const firstDataSet = tagGroup->findDataSet("first");
      auto const lastDataSet = tagGroup->findDataSet("last");

      record.iovFirsts_ = firstDataSet->readSyncValues();
      record.iovLasts_ = lastDataSet->readSyncValues();

      {
        auto const payloadDataSet = tagGroup->findDataSet("payload");
        payloadRefForIOVs = payloadDataSet->readRefs();
        assert(payloadRefForIOVs.size() == record.iovFirsts_.size() * record.dataProducts_.size());
      }
    }
    size_t dataProductIndex = 0;
    for (auto r : payloadRefForIOVs) {
      record.dataProducts_[dataProductIndex].payloadForIOVs_.push_back(r);
      ++dataProductIndex;
      if (dataProductIndex >= record.dataProducts_.size()) {
        dataProductIndex = 0;
      }
    }

    //now that we've loaded a plugin that is associated to the record, the record should be registered
    auto key =
        edm::eventsetup::EventSetupRecordKey(edm::eventsetup::heterocontainer::HCTypeTag::findType(record.name_));
    assert(key != edm::eventsetup::heterocontainer::HCTypeTag());
    //tell system we retrieve this Record
    findingRecordWithKey(key);
    usingRecordWithKey(key);

    records_.emplace_back(std::move(record));
  }
  std::sort(records_.begin(), records_.end(), [](auto const& l, auto const& r) { return l.name_ < r.name_; });
}

Member Function Documentation

fillDescriptions()

void CondHDF5ESSource::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 180 of file CondHDF5ESSource.cc.

References edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                  {
  edm::ParameterSetDescription desc;
  desc.addUntracked<std::string>("filename")->setComment("HDF5 file containing the conditions");
  desc.add<std::string>("globalTag")->setComment("Which global tag to use from the file");
  desc.add<std::vector<std::string>>("excludeRecords", std::vector<std::string>())
      ->setComment("List of Records that should not be read from the file");

  descriptions.addDefault(desc);
}

isConcurrentFinder()

bool CondHDF5ESSource::isConcurrentFinder ( ) const

inlinefinalprivatevirtual

Reimplemented from edm::EventSetupRecordIntervalFinder.

Definition at line 52 of file CondHDF5ESSource.cc.

{ return true; }

registerResolvers()

CondHDF5ESSource::KeyedResolversVector CondHDF5ESSource::registerResolvers ( EventSetupRecordKey const &  iRecordKey, unsigned int  iovIndex  )

finalprivatevirtual

Implements edm::eventsetup::ESProductResolverProvider.

Definition at line 214 of file CondHDF5ESSource.cc.

References cms::cuda::assert(), compression_, file_, filename_, edm::eventsetup::heterocontainer::HCTypeTag::findType(), get, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, eostools::move(), edm::eventsetup::EventSetupRecordKey::name(), queue_, AlCaHarvesting_cff::record, and records_.

                                                                                                  {
  CondHDF5ESSource::KeyedResolversVector returnValue;

  //std::cout << "Register proxies called " << iRecordKey.name() << std::endl;
  auto const itRecord =
      std::lower_bound(records_.begin(), records_.end(), iRecordKey.name(), [](auto const& iE, auto const& iV) {
        return iE.name_ < iV;
      });
  assert(itRecord != records_.end());
  auto const& record = *itRecord;
  assert(record.name_ == iRecordKey.name());
  for (auto const& dataProduct : record.dataProducts_) {
    //std::cout << "Making DataProduct " << dataProduct.type_ << " '" << dataProduct.name_ << "' for Record "
    //          << record.name_ << std::endl;
    auto helper = cond::serialization::SerializationHelperFactory::get()->create(dataProduct.type_);
    returnValue.emplace_back(
        edm::eventsetup::DataKey(edm::eventsetup::heterocontainer::HCTypeTag::findType(dataProduct.type_),
                                 dataProduct.name_.c_str()),
        std::make_shared<HDF5ProductResolver>(
            &queue_, std::move(helper), &file_, filename_, compression_, &record, &dataProduct));
  }
  return returnValue;
}

setIntervalFor()

void CondHDF5ESSource::setIntervalFor ( EventSetupRecordKey const &  iRecordKey, edm::IOVSyncValue const &  iSync, edm::ValidityInterval &  iIOV  )

finalprivatevirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 190 of file CondHDF5ESSource.cc.

References cms::cuda::assert(), cond::hdf5::convertSyncValue(), cond::hdf5::findMatchingFirst(), edm::ValidityInterval::invalidInterval(), pfDeepBoostedJetPreprocessParams_cfi::lower_bound, edm::eventsetup::EventSetupRecordKey::name(), AlCaHarvesting_cff::record, and records_.

                                                                 {
  using namespace cond::hdf5;

  auto const itRecord =
      std::lower_bound(records_.begin(), records_.end(), iRecordKey.name(), [](auto const& iE, auto const& iV) {
        return iE.name_ < iV;
      });
  assert(itRecord != records_.end());
  auto const& record = *itRecord;
  assert(record.name_ == iRecordKey.name());
  auto sync = convertSyncValue(iSync, record.iovIsRunLumi_);
  auto itFound = findMatchingFirst(record.iovFirsts_, sync);
  if (itFound == record.iovFirsts_.end()) {
    //std::cout << "BAD SYNC for record " << iRecordKey.name() << std::endl;
    iIOV = edm::ValidityInterval::invalidInterval();
    return;
  }
  iIOV = edm::ValidityInterval{
      convertSyncValue(*itFound, record.iovIsRunLumi_),
      convertSyncValue(record.iovLasts_[itFound - record.iovFirsts_.begin()], record.iovIsRunLumi_)};
}

Member Data Documentation

compression_

Compression CondHDF5ESSource::compression_ = Compression::kNone

private

Definition at line 61 of file CondHDF5ESSource.cc.

Referenced by registerResolvers().

file_

cms::h5::File CondHDF5ESSource::file_

private

Definition at line 60 of file CondHDF5ESSource.cc.

Referenced by CondHDF5ESSource(), and registerResolvers().

filename_

std::string CondHDF5ESSource::filename_

private

Definition at line 59 of file CondHDF5ESSource.cc.

Referenced by registerResolvers().

mutex_

std::mutex CondHDF5ESSource::mutex_

private

Definition at line 57 of file CondHDF5ESSource.cc.

queue_

edm::SerialTaskQueue CondHDF5ESSource::queue_

private

Definition at line 56 of file CondHDF5ESSource.cc.

Referenced by registerResolvers().

records_

std::vector<Record> CondHDF5ESSource::records_

private

Definition at line 58 of file CondHDF5ESSource.cc.

Referenced by CondHDF5ESSource(), registerResolvers(), and setIntervalFor().