File indexing completed on 2025-04-30 22:24:31
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020 #include <iostream>
0021 #include <memory>
0022 #include "TFile.h"
0023 #include <mutex>
0024
0025
0026 #include "FWCore/Framework/interface/ESProductResolverProvider.h"
0027 #include "FWCore/Framework/interface/ESSourceProductResolverNonConcurrentBase.h"
0028 #include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
0029 #include "FWCore/Framework/interface/ESModuleProducesInfo.h"
0030 #include "DataFormats/FWLite/interface/EventSetup.h"
0031 #include "DataFormats/FWLite/interface/Record.h"
0032 #include "FWCore/Framework/interface/HCTypeTag.h"
0033 #include "FWCore/Utilities/interface/TypeIDBase.h"
0034 #include "FWCore/Utilities/interface/Exception.h"
0035 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0036
0037 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0038
0039 #include "FWCore/Framework/interface/SourceFactory.h"
0040
0041 #include "FWCore/Concurrency/interface/SerialTaskQueue.h"
0042 #include "FWCore/Concurrency/interface/WaitingTaskList.h"
0043
0044
0045 namespace edm {
0046 class EventSetupImpl;
0047 }
0048
0049 namespace {
0050 struct TypeID : public edm::TypeIDBase {
0051 explicit TypeID(const std::type_info& iInfo) : edm::TypeIDBase(iInfo) {}
0052 TypeID() {}
0053 using TypeIDBase::typeInfo;
0054 };
0055 struct FWLiteESGenericHandle {
0056 FWLiteESGenericHandle(const TypeID& iType) : m_type(iType), m_data(nullptr), m_exception(nullptr) {}
0057
0058 FWLiteESGenericHandle(const void* iData) : m_type(), m_data(iData), m_exception(nullptr) {}
0059
0060 FWLiteESGenericHandle(cms::Exception* iException) : m_type(), m_data(nullptr), m_exception(iException) {}
0061
0062 const std::type_info& typeInfo() const { return m_type.typeInfo(); }
0063
0064 TypeID m_type;
0065 const void* m_data;
0066 cms::Exception* m_exception;
0067 };
0068
0069 class FWLiteProductResolver : public edm::eventsetup::ESSourceProductResolverNonConcurrentBase {
0070 public:
0071 FWLiteProductResolver(const TypeID& iTypeID,
0072 const fwlite::Record* iRecord,
0073 edm::SerialTaskQueue* iQueue,
0074 std::mutex* iMutex)
0075 : edm::eventsetup::ESSourceProductResolverNonConcurrentBase(iQueue, iMutex),
0076 m_type(iTypeID),
0077 m_record(iRecord),
0078 m_data{nullptr} {}
0079
0080 void prefetch(const edm::eventsetup::DataKey& iKey, edm::EventSetupRecordDetails) final {
0081 assert(iKey.type() == m_type);
0082
0083 FWLiteESGenericHandle h(m_type);
0084 m_record->get(h, iKey.name().value());
0085 m_data = h.m_data;
0086
0087 if (nullptr != h.m_exception) {
0088 throw *(h.m_exception);
0089 }
0090 }
0091
0092 void invalidateCache() override {
0093 edm::eventsetup::ESSourceProductResolverNonConcurrentBase::invalidateCache();
0094 m_data = nullptr;
0095 }
0096
0097 void const* getAfterPrefetchImpl() const final { return m_data; }
0098
0099 private:
0100 TypeID m_type;
0101 const fwlite::Record* m_record;
0102 void const* m_data;
0103 };
0104 }
0105
0106 class FWLiteESSource : public edm::eventsetup::ESProductResolverProvider, public edm::EventSetupRecordIntervalFinder {
0107 public:
0108 FWLiteESSource(edm::ParameterSet const& iPS);
0109 FWLiteESSource(const FWLiteESSource&) = delete;
0110 const FWLiteESSource& operator=(const FWLiteESSource&) = delete;
0111 ~FWLiteESSource() override;
0112
0113 using EventSetupRecordKey = edm::eventsetup::EventSetupRecordKey;
0114
0115 private:
0116 KeyedResolversVector registerResolvers(const EventSetupRecordKey&, unsigned int iovIndex) override;
0117
0118 std::vector<edm::eventsetup::ESModuleProducesInfo> producesInfo() const override;
0119
0120 void setIntervalFor(const EventSetupRecordKey&, const edm::IOVSyncValue&, edm::ValidityInterval&) override;
0121
0122 void delaySettingRecords() override;
0123
0124
0125 std::unique_ptr<TFile> m_file;
0126 fwlite::EventSetup m_es;
0127 std::map<EventSetupRecordKey, fwlite::RecordID> m_keyToID;
0128 edm::SerialTaskQueue m_queue;
0129 std::mutex m_mutex;
0130 };
0131
0132 FWLiteESSource::FWLiteESSource(edm::ParameterSet const& iPS)
0133 : m_file(TFile::Open(iPS.getParameter<std::string>("fileName").c_str())), m_es(m_file.get()) {}
0134
0135 FWLiteESSource::~FWLiteESSource() {}
0136
0137 edm::eventsetup::ESProductResolverProvider::KeyedResolversVector FWLiteESSource::registerResolvers(
0138 const EventSetupRecordKey& iRecordKey, unsigned int iovIndex) {
0139 KeyedResolversVector keyedProxiesVector;
0140 using edm::eventsetup::heterocontainer::HCTypeTag;
0141
0142 fwlite::RecordID recID = m_keyToID[iRecordKey];
0143 const fwlite::Record& rec = m_es.get(recID);
0144 typedef std::vector<std::pair<std::string, std::string> > TypesAndLabels;
0145 TypesAndLabels typesAndLabels = rec.typeAndLabelOfAvailableData();
0146
0147 std::cout << "Looking for data in record " << iRecordKey.name() << std::endl;
0148 for (TypesAndLabels::const_iterator it = typesAndLabels.begin(), itEnd = typesAndLabels.end(); it != itEnd; ++it) {
0149 std::cout << " need type " << it->first << std::endl;
0150 HCTypeTag tt = HCTypeTag::findType(it->first);
0151 if (tt != HCTypeTag()) {
0152 edm::eventsetup::DataKey dk(tt, edm::eventsetup::IdTags(it->second.c_str()));
0153 keyedProxiesVector.emplace_back(
0154 dk, std::make_shared<FWLiteProductResolver>(TypeID(tt.value()), &rec, &m_queue, &m_mutex));
0155 } else {
0156 LogDebug("UnknownESType") << "The type '" << it->first << "' is unknown in this job";
0157 std::cout << " *****FAILED*****" << std::endl;
0158 }
0159 }
0160 return keyedProxiesVector;
0161 }
0162
0163 std::vector<edm::eventsetup::ESModuleProducesInfo> FWLiteESSource::producesInfo() const {
0164 std::vector<edm::eventsetup::ESModuleProducesInfo> returnValue;
0165 using edm::eventsetup::heterocontainer::HCTypeTag;
0166
0167 for (auto const& keyID : m_keyToID) {
0168 auto const& rec = m_es.get(keyID.second);
0169 for (auto const& typeLabel : rec.typeAndLabelOfAvailableData()) {
0170 HCTypeTag tt = HCTypeTag::findType(typeLabel.first);
0171 if (tt != HCTypeTag()) {
0172 unsigned int index = returnValue.size();
0173 returnValue.emplace_back(
0174 keyID.first, edm::eventsetup::DataKey(tt, edm::eventsetup::IdTags(typeLabel.second.c_str())), index);
0175 }
0176 }
0177 }
0178
0179 return returnValue;
0180 }
0181
0182 void FWLiteESSource::setIntervalFor(const EventSetupRecordKey& iKey,
0183 const edm::IOVSyncValue& iSync,
0184 edm::ValidityInterval& oIOV) {
0185 m_es.syncTo(iSync.eventID(), iSync.time());
0186
0187 const fwlite::Record& rec = m_es.get(m_keyToID[iKey]);
0188 edm::IOVSyncValue endSync(rec.endSyncValue().eventID(), rec.endSyncValue().time());
0189 if (rec.endSyncValue().eventID().run() == 0 && rec.endSyncValue().time().value() == 0ULL) {
0190 endSync = edm::IOVSyncValue::endOfTime();
0191 }
0192 oIOV = edm::ValidityInterval(edm::IOVSyncValue(rec.startSyncValue().eventID(), rec.startSyncValue().time()), endSync);
0193 }
0194
0195 void FWLiteESSource::delaySettingRecords() {
0196 using edm::eventsetup::heterocontainer::HCTypeTag;
0197 std::vector<std::string> recordNames = m_es.namesOfAvailableRecords();
0198
0199 for (std::vector<std::string>::const_iterator it = recordNames.begin(), itEnd = recordNames.end(); it != itEnd;
0200 ++it) {
0201 HCTypeTag t = HCTypeTag::findType(*it);
0202 if (t != HCTypeTag()) {
0203 EventSetupRecordKey key(t);
0204 findingRecordWithKey(key);
0205 usingRecordWithKey(key);
0206 m_keyToID[key] = m_es.recordID(it->c_str());
0207 }
0208 }
0209 }
0210
0211 DEFINE_FWK_EVENTSETUP_SOURCE(FWLiteESSource);