AlignmentProducer.cc

Go to the documentation of this file.

#include "AlignmentProducer.h"

#include "FWCore/Framework/interface/LooperFactory.h"

#include "Geometry/Records/interface/MuonGeometryRecord.h"
#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"

//------------------------------------------------------------------------------
AlignmentProducer::AlignmentProducer(const edm::ParameterSet &config)
    : AlignmentProducerBase{config}, maxLoops_{config.getUntrackedParameter<unsigned int>("maxLoops")} {
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::AlignmentProducer";

  // Tell the framework what data is being produced
  if (doTracker_) {
    setWhatProduced(this, &AlignmentProducer::produceTracker);
  }
  if (doMuon_) {
    setWhatProduced(this, &AlignmentProducer::produceDT);
    setWhatProduced(this, &AlignmentProducer::produceCSC);
  }
}

//------------------------------------------------------------------------------
std::shared_ptr<TrackerGeometry> AlignmentProducer::produceTracker(const TrackerDigiGeometryRecord &) {
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::produceTracker";
  return trackerGeometry_;
}

//------------------------------------------------------------------------------
std::shared_ptr<DTGeometry> AlignmentProducer::produceDT(const MuonGeometryRecord &) {
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::produceDT";
  return muonDTGeometry_;
}

//------------------------------------------------------------------------------
std::shared_ptr<CSCGeometry> AlignmentProducer::produceCSC(const MuonGeometryRecord &) {
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::produceCSC";
  return muonCSCGeometry_;
}

//------------------------------------------------------------------------------
void AlignmentProducer::beginOfJob(const edm::EventSetup &iSetup) {
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::beginOfJob";
  initAlignmentAlgorithm(iSetup);
}

//------------------------------------------------------------------------------
void AlignmentProducer::endOfJob() {
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::endOfJob";

  if (!finish()) {
    edm::LogError("Alignment") << "@SUB=AlignmentProducer::endOfJob"
                               << "Did not process any events in last loop, do not dare to store to DB.";
  }
}

//------------------------------------------------------------------------------
void AlignmentProducer::startingNewLoop(unsigned int iLoop) {
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::startingNewLoop"
                            << "Starting loop number " << iLoop;
  startProcessing();
}

//------------------------------------------------------------------------------
edm::EDLooper::Status AlignmentProducer::endOfLoop(const edm::EventSetup &iSetup, unsigned int iLoop) {
  if (0 == nEvent()) {
    // beginOfJob is usually called by the framework in the first event of the first loop
    // (a hack: beginOfJob needs the EventSetup that is not well defined without an event)
    // and the algorithms rely on the initialisations done in beginOfJob. We cannot call
    // this->beginOfJob(iSetup); here either since that will access the EventSetup to get
    // some geometry information that is not defined either without having seen an event.
    edm::LogError("Alignment") << "@SUB=AlignmentProducer::endOfLoop"
                               << "Did not process any events in loop " << iLoop
                               << ", stop processing without terminating algorithm.";
    return kStop;
  }

  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::endOfLoop"
                            << "Ending loop " << iLoop << ", terminating algorithm.";
  terminateProcessing(&iSetup);

  if (iLoop == maxLoops_ - 1 || iLoop >= maxLoops_)
    return kStop;
  else
    return kContinue;
}

//------------------------------------------------------------------------------
edm::EDLooper::Status AlignmentProducer::duringLoop(const edm::Event &event, const edm::EventSetup &setup) {
  if (processEvent(event, setup))
    return kContinue;
  else
    return kStop;
}

//------------------------------------------------------------------------------
void AlignmentProducer::beginRun(const edm::Run &run, const edm::EventSetup &setup) { beginRunImpl(run, setup); }

//------------------------------------------------------------------------------
void AlignmentProducer::endRun(const edm::Run &run, const edm::EventSetup &setup) { endRunImpl(run, setup); }

//------------------------------------------------------------------------------
void AlignmentProducer::beginLuminosityBlock(const edm::LuminosityBlock &lumiBlock, const edm::EventSetup &setup) {
  beginLuminosityBlockImpl(lumiBlock, setup);
}

//------------------------------------------------------------------------------
void AlignmentProducer::endLuminosityBlock(const edm::LuminosityBlock &lumiBlock, const edm::EventSetup &setup) {
  endLuminosityBlockImpl(lumiBlock, setup);
}

DEFINE_FWK_LOOPER(AlignmentProducer);