ConfigurableAPVCyclePhaseProducer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    SiStripTools
// Class:      ConfigurableAPVCyclePhaseProducer
//
//
// Original Author:  Andrea Venturi
//         Created:  Mon Jan 12 09:05:45 CET 2009
//
//
 
// system include files
#include <memory>
 
// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"
 
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/Run.h"
#include "FWCore/Framework/interface/MakerMacros.h"
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/Exception.h"
 
#include <map>
#include <string>
 
#include "DPGAnalysis/SiStripTools/interface/APVCyclePhaseCollection.h"
 
//
// class decleration
//
 
class ConfigurableAPVCyclePhaseProducer : public edm::EDProducer {
public:
  explicit ConfigurableAPVCyclePhaseProducer(const edm::ParameterSet&);
  ~ConfigurableAPVCyclePhaseProducer() override;
 
private:
  void beginJob() override;
  void beginRun(const edm::Run&, const edm::EventSetup&) override;
  void produce(edm::Event&, const edm::EventSetup&) override;
  void endJob() override;
 
  // ----------member data ---------------------------
 
  const std::vector<std::string> _defpartnames;
  const std::vector<int> _defphases;
 
  std::map<int, std::vector<std::string> > _runpartnames;
  std::map<int, std::vector<int> > _runphases;
 
  APVCyclePhaseCollection _currapvphases;
};
 
//
// constants, enums and typedefs
//
 
//
// static data member definitions
//
 
//
// constructors and destructor
//
ConfigurableAPVCyclePhaseProducer::ConfigurableAPVCyclePhaseProducer(const edm::ParameterSet& iConfig)
    : _defpartnames(iConfig.getParameter<std::vector<std::string> >("defaultPartitionNames")),
      _defphases(iConfig.getParameter<std::vector<int> >("defaultPhases")),
      _currapvphases() {
  produces<APVCyclePhaseCollection, edm::InEvent>();
 
  //now do what ever other initialization is needed
 
  if (_defphases.size() < _defpartnames.size()) {
    // throw exception
    throw cms::Exception("InvalidAPVCyclePhases")
        << " Inconsistent default phases/partitions vector sizes: " << _defphases.size() << " " << _defpartnames.size();
  }
 
  std::vector<edm::ParameterSet> vps(iConfig.getParameter<std::vector<edm::ParameterSet> >("runPhases"));
 
  for (std::vector<edm::ParameterSet>::const_iterator ps = vps.begin(); ps != vps.end(); ps++) {
    _runphases[ps->getParameter<int>("runNumber")] = ps->getUntrackedParameter<std::vector<int> >("phases", _defphases);
    _runpartnames[ps->getParameter<int>("runNumber")] =
        ps->getUntrackedParameter<std::vector<std::string> >("partitions", _defpartnames);
 
    if (_runphases[ps->getParameter<int>("runNumber")].size() <
        _runpartnames[ps->getParameter<int>("runNumber")].size()) {
      // throw exception
      throw cms::Exception("InvalidAPVCyclePhases")
          << " Inconsistent run " << ps->getParameter<int>("runNumber")
          << " phases/partitions vector sizes: " << _runphases[ps->getParameter<int>("runNumber")].size() << " "
          << _runpartnames[ps->getParameter<int>("runNumber")].size();
    }
  }
}
 
ConfigurableAPVCyclePhaseProducer::~ConfigurableAPVCyclePhaseProducer() {
  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)
}
 
//
// member functions
//
 
// ------------ method called to produce the data  ------------
void ConfigurableAPVCyclePhaseProducer::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup) {
  using namespace edm;
 
  _currapvphases.get().clear();
 
  // fill phase map
 
  const std::map<int, std::vector<std::string> >& _crunpartnames = _runpartnames;
  const std::map<int, std::vector<int> >& _crunphases = _runphases;
 
  std::map<int, std::vector<int> >::const_iterator trphases = _crunphases.find(iRun.run());
  std::map<int, std::vector<std::string> >::const_iterator trpartnames = _crunpartnames.find(iRun.run());
 
  std::vector<int> phases = _defphases;
  std::vector<std::string> partnames = _defpartnames;
 
  if (trphases != _crunphases.end()) {
    phases = trphases->second;
  }
  if (trpartnames != _crunpartnames.end()) {
    partnames = trpartnames->second;
  }
 
  if (phases.size() < partnames.size()) {
    // throw exception
    throw cms::Exception("InvalidAPVCyclePhases")
        << " Inconsistent phases/partitions vector sizes: " << phases.size() << " " << partnames.size();
  }
 
  for (unsigned int ipart = 0; ipart < partnames.size(); ++ipart) {
    if (phases[ipart] >= 0) {
      _currapvphases.get()[partnames[ipart]] = phases[ipart];
    }
  }
 
  for (std::map<std::string, int>::const_iterator it = _currapvphases.get().begin(); it != _currapvphases.get().end();
       it++) {
    edm::LogInfo("APVCyclePhaseProducerDebug") << "partition " << it->first << " phase " << it->second;
  }
}
 
void ConfigurableAPVCyclePhaseProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  using namespace edm;
 
  std::unique_ptr<APVCyclePhaseCollection> apvphases(new APVCyclePhaseCollection(_currapvphases));
 
  iEvent.put(std::move(apvphases));
}
 
// ------------ method called once each job just before starting event loop  ------------
void ConfigurableAPVCyclePhaseProducer::beginJob() {}
 
// ------------ method called once each job just after ending the event loop  ------------
void ConfigurableAPVCyclePhaseProducer::endJob() {}
 
//define this as a plug-in
DEFINE_FWK_MODULE(ConfigurableAPVCyclePhaseProducer);