AlignmentProducerBase Class Reference

#include <AlignmentProducerBase.h>

Inheritance diagram for AlignmentProducerBase:

Protected Member Functions
	AlignmentProducerBase (const edm::ParameterSet &)
void	beginLuminosityBlockImpl (const edm::LuminosityBlock &, const edm::EventSetup &)
	begin lumi block More...
void	beginRunImpl (const edm::Run &, const edm::EventSetup &)
	begin run More...
void	endLuminosityBlockImpl (const edm::LuminosityBlock &, const edm::EventSetup &)
	end lumi block More...
void	endRunImpl (const edm::Run &, const edm::EventSetup &)
	end run More...
bool	finish ()
virtual bool	getAliClusterValueMap (const edm::Event &, edm::Handle< AliClusterValueMap > &)=0
virtual bool	getBeamSpot (const edm::Event &, edm::Handle< reco::BeamSpot > &)=0
virtual bool	getTkFittedLasBeamCollection (const edm::Run &, edm::Handle< TkFittedLasBeamCollection > &)=0
virtual bool	getTrajTrackAssociationCollection (const edm::Event &, edm::Handle< TrajTrackAssociationCollection > &)=0
virtual bool	getTsosVectorCollection (const edm::Run &, edm::Handle< TsosVectorCollection > &)=0
void	initAlignmentAlgorithm (const edm::EventSetup &, bool update=false)
int	nEvent () const
bool	processEvent (const edm::Event &, const edm::EventSetup &)
	Process event. More...
void	startProcessing ()
	Start processing of events. More...
void	terminateProcessing (const edm::EventSetup *=nullptr)
	Terminate processing of events. More...
virtual	~AlignmentProducerBase () noexcept(false)

Protected Attributes
const edm::InputTag	beamSpotTag_
	BeamSpot. More...
const edm::InputTag	clusterValueMapTag_
	ValueMap containing associtaion cluster-flag. More...
const bool	doMuon_
const bool	doTracker_
edm::ESHandle< CSCGeometry >	muonCSCGeometry_
edm::ESHandle< DTGeometry >	muonDTGeometry_
edm::ESHandle< GEMGeometry >	muonGEMGeometry_
const edm::InputTag	tjTkAssociationMapTag_
	Map with tracks/trajectories. More...
const edm::InputTag	tkLasBeamTag_
	LAS beams in edm::Run (ignore if empty) More...
std::shared_ptr< TrackerGeometry >	trackerGeometry_
const bool	useExtras_

Private Member Functions
void	addSurveyInfo (Alignable *)
	Adds survey info to an Alignable. More...
void	applyAlignmentsToDB (const edm::EventSetup &)
void	applyAlignmentsToGeometry ()
template<class G , class DeformationRcd >
void	applyDB (const G *, const edm::EventSetup &) const
	Applies DB constants for SurfaceDeformations. More...
template<class G , class Rcd , class ErrRcd >
void	applyDB (const G *, const edm::EventSetup &, const AlignTransform &) const
void	applyMisalignment ()
	Applies misalignment scenario to @alignableTracker_. More...
void	buildParameterStore ()
	Creates the @alignmentParameterStore_, which manages all Alignables. More...
void	createAlignables (const TrackerTopology *, bool update=false)
void	createAlignmentAlgorithm ()
	Creates the choosen alignment algorithm. More...
void	createCalibrations ()
	Creates the calibrations. More...
void	createGeometries (const edm::EventSetup &, const TrackerTopology *)
	Creates ideal geometry @trackerGeometry_ from IdealGeometryRecord. More...
void	createMonitors ()
	Creates the monitors. More...
void	initBeamSpot (const edm::Event &)
	Initializes Beamspot @beamSpot_ of Alignables @alignableExtras_. More...
void	readInSurveyRcds (const edm::EventSetup &)
	Reads in survey records. More...
bool	setupChanged (const edm::EventSetup &)
	Checks if one of the EventSetup-Records has changed. More...
void	simpleMisalignment (const align::Alignables &, const std::string &, float, float, bool)
	Applies misalignment scenario to @alignableTracker_. More...
void	storeAlignmentsToDB ()
	Writes Alignments (i.e. Records) to database-file. More...
void	writeDB (Alignments *, const std::string &, AlignmentErrorsExtended *, const std::string &, const AlignTransform *, cond::Time_t) const
void	writeDB (AlignmentSurfaceDeformations *, const std::string &, cond::Time_t) const
void	writeForRunRange (cond::Time_t)

Private Attributes
std::unique_ptr< AlignableExtras >	alignableExtras_
std::unique_ptr< AlignableMuon >	alignableMuon_
std::unique_ptr< AlignableTracker >	alignableTracker_
std::unique_ptr< AlignmentAlgorithmBase >	alignmentAlgo_
std::unique_ptr< AlignmentParameterStore >	alignmentParameterStore_
const bool	applyDbAlignment_
edm::Handle< reco::BeamSpot >	beamSpot_
CalibrationsOwner	calibrations_
const bool	checkDbAlignmentValidity_
edm::ParameterSet	config_
const bool	doMisalignmentScenario_
const bool	enableAlignableUpdates_
cond::Time_t	firstRun_ {cond::timeTypeSpecs[cond::runnumber].endValue}
std::unique_ptr< const Alignments >	globalPositions_
	GlobalPositions that might be read from DB, nullptr otherwise. More...
std::string	idealGeometryLabel
bool	isAlgoInitialized_ {false}
bool	isDuringLoop_ {false}
AlignmentMonitors	monitors_
int	nevent_ {0}
bool	runAtPCL_ {false}
const bool	saveApeToDB_
const bool	saveDeformationsToDB_
const bool	saveToDB_
const int	stNFixAlignables_
const double	stRandomRotation_
const double	stRandomShift_
const SurveyErrors *	surveyErrors_ {nullptr}
size_t	surveyIndex_ {0}
const Alignments *	surveyValues_ {nullptr}
const align::RunRanges	uniqueRunRanges_
const bool	useSurvey_
edm::ESWatcher< CSCAlignmentErrorExtendedRcd >	watchCSCAlErrExtRcd_
edm::ESWatcher< CSCAlignmentRcd >	watchCSCAlRcd_
edm::ESWatcher< CSCSurveyErrorExtendedRcd >	watchCSCSurveyErrExtRcd_
edm::ESWatcher< CSCSurveyRcd >	watchCSCSurveyRcd_
edm::ESWatcher< DTAlignmentErrorExtendedRcd >	watchDTAlErrExtRcd_
edm::ESWatcher< DTAlignmentRcd >	watchDTAlRcd_
edm::ESWatcher< DTSurveyErrorExtendedRcd >	watchDTSurveyErrExtRcd_
edm::ESWatcher< DTSurveyRcd >	watchDTSurveyRcd_
edm::ESWatcher< GlobalPositionRcd >	watchGlobalPositionRcd_
edm::ESWatcher< IdealGeometryRecord >	watchIdealGeometryRcd_
edm::ESWatcher< TrackerSurveyErrorExtendedRcd >	watchTkSurveyErrExtRcd_
edm::ESWatcher< TrackerSurveyRcd >	watchTkSurveyRcd_
edm::ESWatcher< TrackerAlignmentErrorExtendedRcd >	watchTrackerAlErrorExtRcd_
edm::ESWatcher< TrackerAlignmentRcd >	watchTrackerAlRcd_
edm::ESWatcher< TrackerSurfaceDeformationRcd >	watchTrackerSurDeRcd_

Detailed Description

Definition at line 70 of file AlignmentProducerBase.h.

Constructor & Destructor Documentation

AlignmentProducerBase()

AlignmentProducerBase::AlignmentProducerBase ( const edm::ParameterSet &  config )

protected

Definition at line 30 of file AlignmentProducerBase.cc.

    : doTracker_{config.getUntrackedParameter<bool>("doTracker")},
      doMuon_{config.getUntrackedParameter<bool>("doMuon")},
      useExtras_{config.getUntrackedParameter<bool>("useExtras")},
      tjTkAssociationMapTag_{config.getParameter<edm::InputTag>("tjTkAssociationMapTag")},
      beamSpotTag_{config.getParameter<edm::InputTag>("beamSpotTag")},
      tkLasBeamTag_{config.getParameter<edm::InputTag>("tkLasBeamTag")},
      clusterValueMapTag_{config.getParameter<edm::InputTag>("hitPrescaleMapTag")},
      uniqueRunRanges_{align::makeUniqueRunRanges(config.getParameter<edm::VParameterSet>("RunRangeSelection"),
                                                  cond::timeTypeSpecs[cond::runnumber].beginValue)},
      config_{config},
      stNFixAlignables_{config.getParameter<int>("nFixAlignables")},
      stRandomShift_{config.getParameter<double>("randomShift")},
      stRandomRotation_{config.getParameter<double>("randomRotation")},
      applyDbAlignment_{config.getUntrackedParameter<bool>("applyDbAlignment")},
      checkDbAlignmentValidity_{config.getUntrackedParameter<bool>("checkDbAlignmentValidity")},
      doMisalignmentScenario_{config.getParameter<bool>("doMisalignmentScenario")},
      saveToDB_{config.getParameter<bool>("saveToDB")},
      saveApeToDB_{config.getParameter<bool>("saveApeToDB")},
      saveDeformationsToDB_{config.getParameter<bool>("saveDeformationsToDB")},
      useSurvey_{config.getParameter<bool>("useSurvey")},
      enableAlignableUpdates_{config.getParameter<bool>("enableAlignableUpdates")},
      idealGeometryLabel("idealForAlignmentProducerBase") {
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::AlignmentProducerBase";
 
  const auto& algoConfig = config_.getParameterSet("algoConfig");
  if (config_.existsAs<bool>("runAtPCL")) {
    // configured in main config?
    runAtPCL_ = config_.getParameter<bool>("runAtPCL");
 
    if (algoConfig.existsAs<bool>("runAtPCL") && (runAtPCL_ != algoConfig.getParameter<bool>("runAtPCL"))) {
      throw cms::Exception("BadConfig") << "Inconsistent settings for 'runAtPCL' in configuration of the "
                                        << "alignment producer and the alignment algorithm.";
    }
 
  } else if (algoConfig.existsAs<bool>("runAtPCL")) {
    // configured in algo config?
    runAtPCL_ = algoConfig.getParameter<bool>("runAtPCL");
 
  } else {
    // assume 'false' if it was not configured
    runAtPCL_ = false;
  }
 
  createAlignmentAlgorithm();
  createMonitors();
  createCalibrations();
}

~AlignmentProducerBase()

AlignmentProducerBase::~AlignmentProducerBase ( )

protectedvirtualnoexcept

Definition at line 80 of file AlignmentProducerBase.cc.

{}

Member Function Documentation

addSurveyInfo()

void AlignmentProducerBase::addSurveyInfo ( Alignable *  ali )

private

Adds survey info to an Alignable.

Definition at line 723 of file AlignmentProducerBase.cc.

                                                        {
  const auto& comps = ali->components();
 
  for (const auto& comp : comps)
    addSurveyInfo(comp);
 
  const SurveyError& error = surveyErrors_->m_surveyErrors[surveyIndex_];
 
  if (ali->id() != error.rawId() || ali->alignableObjectId() != error.structureType()) {
    throw cms::Exception("DatabaseError") << "Error reading survey info from DB. Mismatched id!";
  }
 
  const auto& pos = surveyValues_->m_align[surveyIndex_].translation();
  const auto& rot = surveyValues_->m_align[surveyIndex_].rotation();
 
  AlignableSurface surf(
      align::PositionType(pos.x(), pos.y(), pos.z()),
      align::RotationType(rot.xx(), rot.xy(), rot.xz(), rot.yx(), rot.yy(), rot.yz(), rot.zx(), rot.zy(), rot.zz()));
 
  surf.setWidth(ali->surface().width());
  surf.setLength(ali->surface().length());
 
  ali->setSurvey(new SurveyDet(surf, error.matrix()));
 
  ++surveyIndex_;
}

References Alignable::alignableObjectId(), AlCaHLTBitMon_QueryRunRegistry::comp, Alignable::components(), relativeConstraints::error, Exception, Alignable::id(), AlignableSurface::length(), Alignments::m_align, SurveyErrors::m_surveyErrors, makeMuonMisalignmentScenario::rot, AlignableSurface::setLength(), Alignable::setSurvey(), AlignableSurface::setWidth(), Alignable::surface(), surveyErrors_, surveyIndex_, surveyValues_, and AlignableSurface::width().

Referenced by readInSurveyRcds().

applyAlignmentsToDB()

void AlignmentProducerBase::applyAlignmentsToDB ( const edm::EventSetup &  setup )

private

Applies Alignments from Database (GlobalPositionRcd) to Geometry @trackerGeometry_

Definition at line 433 of file AlignmentProducerBase.cc.

                                                                          {
  // Retrieve and apply alignments, if requested (requires z setup)
  if (applyDbAlignment_) {
    // we need GlobalPositionRcd - and have to keep track for later removal
    // before writing again to DB...
 
    edm::ESHandle<Alignments> globalAlignments;
    setup.get<GlobalPositionRcd>().get(globalAlignments);
    globalPositions_ = std::make_unique<Alignments>(*globalAlignments);
 
    if (doTracker_) {
      applyDB<TrackerGeometry, TrackerAlignmentRcd, TrackerAlignmentErrorExtendedRcd>(
          trackerGeometry_.get(), setup, align::DetectorGlobalPosition(*globalPositions_, DetId(DetId::Tracker)));
 
      applyDB<TrackerGeometry, TrackerSurfaceDeformationRcd>(trackerGeometry_.get(), setup);
    }
 
    if (doMuon_) {
      applyDB<DTGeometry, DTAlignmentRcd, DTAlignmentErrorExtendedRcd>(
          &*muonDTGeometry_, setup, align::DetectorGlobalPosition(*globalPositions_, DetId(DetId::Muon)));
 
      applyDB<CSCGeometry, CSCAlignmentRcd, CSCAlignmentErrorExtendedRcd>(
          &*muonCSCGeometry_, setup, align::DetectorGlobalPosition(*globalPositions_, DetId(DetId::Muon)));
 
      applyDB<GEMGeometry, GEMAlignmentRcd, GEMAlignmentErrorExtendedRcd>(
          &*muonGEMGeometry_, setup, align::DetectorGlobalPosition(*globalPositions_, DetId(DetId::Muon)));
    }
  }
}

References applyDbAlignment_, align::DetectorGlobalPosition(), doMuon_, doTracker_, get, globalPositions_, DetId::Muon, muonCSCGeometry_, muonDTGeometry_, muonGEMGeometry_, singleTopDQM_cfi::setup, DetId::Tracker, and trackerGeometry_.

Referenced by initAlignmentAlgorithm().

applyAlignmentsToGeometry()

void AlignmentProducerBase::applyAlignmentsToGeometry ( )

private

Applies Alignments, AlignmentErrors and SurfaceDeformations to @trackerGeometry_

Definition at line 624 of file AlignmentProducerBase.cc.

                                                      {
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::applyAlignmentsToGeometry"
                            << "Now physically apply alignments to  geometry...";
 
  // Propagate changes to reconstruction geometry (from initialisation or iteration)
  GeometryAligner aligner;
 
  if (doTracker_) {
    if (!alignableTracker_) {
      throw cms::Exception("LogicError") << "@SUB=AlignmentProducerBase::applyAlignmentsToGeometry\n"
                                         << "Trying to apply tracker alignment before creating it.";
    }
 
    std::unique_ptr<Alignments> alignments{alignableTracker_->alignments()};
    std::unique_ptr<AlignmentErrorsExtended> alignmentErrExt{alignableTracker_->alignmentErrors()};
    std::unique_ptr<AlignmentSurfaceDeformations> aliDeforms{alignableTracker_->surfaceDeformations()};
 
    aligner.applyAlignments(trackerGeometry_.get(), alignments.get(), alignmentErrExt.get(), AlignTransform());
    aligner.attachSurfaceDeformations(trackerGeometry_.get(), aliDeforms.get());
  }
 
  if (doMuon_) {
    if (!alignableMuon_) {
      throw cms::Exception("LogicError") << "@SUB=AlignmentProducerBase::applyAlignmentsToGeometry\n"
                                         << "Trying to apply muon alignment before creating it.";
    }
 
    std::unique_ptr<Alignments> dtAlignments{alignableMuon_->dtAlignments()};
    std::unique_ptr<Alignments> cscAlignments{alignableMuon_->cscAlignments()};
    std::unique_ptr<Alignments> gemAlignments{alignableMuon_->gemAlignments()};
 
    std::unique_ptr<AlignmentErrorsExtended> dtAlignmentErrExt{alignableMuon_->dtAlignmentErrorsExtended()};
    std::unique_ptr<AlignmentErrorsExtended> cscAlignmentErrExt{alignableMuon_->cscAlignmentErrorsExtended()};
    std::unique_ptr<AlignmentErrorsExtended> gemAlignmentErrExt{alignableMuon_->gemAlignmentErrorsExtended()};
 
    aligner.applyAlignments(&*muonDTGeometry_, dtAlignments.get(), dtAlignmentErrExt.get(), AlignTransform());
    aligner.applyAlignments(&*muonCSCGeometry_, cscAlignments.get(), cscAlignmentErrExt.get(), AlignTransform());
    aligner.applyAlignments(&*muonGEMGeometry_, gemAlignments.get(), gemAlignmentErrExt.get(), AlignTransform());
  }
}

References alignableMuon_, alignableTracker_, GeometryAligner::applyAlignments(), GeometryAligner::attachSurfaceDeformations(), doMuon_, doTracker_, Exception, muonCSCGeometry_, muonDTGeometry_, muonGEMGeometry_, and trackerGeometry_.

Referenced by initAlignmentAlgorithm(), and startProcessing().

applyDB() [1/2]

template<class G , class DeformationRcd >

void AlignmentProducerBase::applyDB ( const G *  geometry, const edm::EventSetup &  iSetup  ) const

private

Applies DB constants for SurfaceDeformations.

Definition at line 311 of file AlignmentProducerBase.h.

                                                                                        {
  // 'G' is the geometry class for that DB should be applied,
  // 'DeformationRcd' is the record class for its surface deformations
 
  const DeformationRcd& record = iSetup.get<DeformationRcd>();
  if (checkDbAlignmentValidity_) {
    const edm::ValidityInterval& validity = record.validityInterval();
    const edm::IOVSyncValue first = validity.first();
    const edm::IOVSyncValue last = validity.last();
    if (first != edm::IOVSyncValue::beginOfTime() || last != edm::IOVSyncValue::endOfTime()) {
      throw cms::Exception("DatabaseError")
          << "@SUB=AlignmentProducerBase::applyDB"
          << "\nTrying to apply " << record.key().name() << " with multiple IOVs in tag.\n"
          << "Validity range is " << first.eventID().run() << " - " << last.eventID().run();
    }
  }
  edm::ESHandle<AlignmentSurfaceDeformations> surfaceDeformations;
  record.get(surfaceDeformations);
 
  GeometryAligner aligner;
  aligner.attachSurfaceDeformations<G>(geometry, &(*surfaceDeformations));
}

References GeometryAligner::attachSurfaceDeformations(), edm::IOVSyncValue::beginOfTime(), checkDbAlignmentValidity_, edm::IOVSyncValue::endOfTime(), Exception, edm::ValidityInterval::first(), first, callgraph::G, relativeConstraints::geometry, edm::EventSetup::get(), edm::ValidityInterval::last(), dqmdumpme::last, and GlobalPosition_Frontier_DevDB_cff::record.

applyDB() [2/2]

template<class G , class Rcd , class ErrRcd >

void AlignmentProducerBase::applyDB ( const G *  geometry, const edm::EventSetup &  iSetup, const AlignTransform &  globalCoordinates  ) const

private

Applies DB constants belonging to (Err)Rcd to Geometry, taking into account 'globalPosition' correction.

Definition at line 279 of file AlignmentProducerBase.h.

                                                                                   {
  // 'G' is the geometry class for that DB should be applied,
  // 'Rcd' is the record class for its Alignments
  // 'ErrRcd' is the record class for its AlignmentErrorsExtended
  // 'globalCoordinates' are global transformation for this geometry
 
  const Rcd& record = iSetup.get<Rcd>();
  if (checkDbAlignmentValidity_) {
    const edm::ValidityInterval& validity = record.validityInterval();
    const edm::IOVSyncValue first = validity.first();
    const edm::IOVSyncValue last = validity.last();
    if (first != edm::IOVSyncValue::beginOfTime() || last != edm::IOVSyncValue::endOfTime()) {
      throw cms::Exception("DatabaseError")
          << "@SUB=AlignmentProducerBase::applyDB"
          << "\nTrying to apply " << record.key().name() << " with multiple IOVs in tag.\n"
          << "Validity range is " << first.eventID().run() << " - " << last.eventID().run();
    }
  }
 
  edm::ESHandle<Alignments> alignments;
  record.get(alignments);
 
  edm::ESHandle<AlignmentErrorsExtended> alignmentErrors;
  iSetup.get<ErrRcd>().get(alignmentErrors);
 
  GeometryAligner aligner;
  aligner.applyAlignments<G>(geometry, &(*alignments), &(*alignmentErrors), globalCoordinates);
}

References GeometryAligner::applyAlignments(), edm::IOVSyncValue::beginOfTime(), checkDbAlignmentValidity_, edm::IOVSyncValue::endOfTime(), Exception, edm::ValidityInterval::first(), first, callgraph::G, relativeConstraints::geometry, edm::EventSetup::get(), get, edm::ValidityInterval::last(), dqmdumpme::last, and GlobalPosition_Frontier_DevDB_cff::record.

applyMisalignment()

void AlignmentProducerBase::applyMisalignment ( )

private

Applies misalignment scenario to @alignableTracker_.

Definition at line 519 of file AlignmentProducerBase.cc.

                                              {
  // Apply misalignment scenario to alignable tracker and muon if requested
  // WARNING: this assumes scenarioConfig can be passed to both muon and tracker
 
  if (doMisalignmentScenario_ && (doTracker_ || doMuon_)) {
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::applyMisalignment"
                              << "Applying misalignment scenario to " << (doTracker_ ? "tracker" : "")
                              << (doMuon_ ? (doTracker_ ? " and muon" : "muon") : ".");
 
    const auto& scenarioConfig = config_.getParameterSet("MisalignmentScenario");
 
    if (doTracker_) {
      TrackerScenarioBuilder scenarioBuilder(alignableTracker_.get());
      scenarioBuilder.applyScenario(scenarioConfig);
    }
    if (doMuon_) {
      MuonScenarioBuilder muonScenarioBuilder(alignableMuon_.get());
      muonScenarioBuilder.applyScenario(scenarioConfig);
    }
 
  } else {
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::applyMisalignment"
                              << "NOT applying misalignment scenario!";
  }
 
  // Apply simple misalignment
  const auto& sParSel = config_.getParameter<std::string>("parameterSelectorSimple");
  simpleMisalignment(alignmentParameterStore_->alignables(), sParSel, stRandomShift_, stRandomRotation_, true);
}

References alignableMuon_, alignableTracker_, alignmentParameterStore_, MuonScenarioBuilder::applyScenario(), TrackerScenarioBuilder::applyScenario(), config_, doMisalignmentScenario_, doMuon_, doTracker_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), simpleMisalignment(), stRandomRotation_, stRandomShift_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by initAlignmentAlgorithm().

beginLuminosityBlockImpl()

void AlignmentProducerBase::beginLuminosityBlockImpl ( const edm::LuminosityBlock &  , const edm::EventSetup &  setup  )

protected

begin lumi block

Definition at line 247 of file AlignmentProducerBase.cc.

                                                                                                          {
  // Do not forward edm::LuminosityBlock
  alignmentAlgo_->beginLuminosityBlock(setup);
}

References alignmentAlgo_, and singleTopDQM_cfi::setup.

Referenced by AlignmentProducer::beginLuminosityBlock(), and AlignmentProducerAsAnalyzer::beginLuminosityBlock().

beginRunImpl()

void AlignmentProducerBase::beginRunImpl ( const edm::Run &  run, const edm::EventSetup &  setup  )

protected

begin run

Definition at line 204 of file AlignmentProducerBase.cc.

                                                                                      {
  const bool changed{setupChanged(setup)};
  if (changed) {
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::beginRunImpl"
                              << "EventSetup-Record changed.";
 
    // updatable alignables are currently not used at PCL, but event setup
    // changes require a complete re-initialization
    if (runAtPCL_) {
      initAlignmentAlgorithm(setup, /* update = */ false);
    } else if (enableAlignableUpdates_) {
      initAlignmentAlgorithm(setup, /* update = */ true);
    }
  }
 
  alignmentAlgo_->beginRun(run, setup, changed && (runAtPCL_ || enableAlignableUpdates_));
 
  for (const auto& iCal : calibrations_)
    iCal->beginRun(run, setup);
 
  //store the first run analyzed to be used for setting the IOV (for PCL)
  if (firstRun_ > static_cast<cond::Time_t>(run.id().run())) {
    firstRun_ = static_cast<cond::Time_t>(run.id().run());
  }
}

References alignmentAlgo_, calibrations_, enableAlignableUpdates_, firstRun_, initAlignmentAlgorithm(), writedatasetfile::run, runAtPCL_, singleTopDQM_cfi::setup, and setupChanged().

Referenced by AlignmentProducer::beginRun(), and AlignmentProducerAsAnalyzer::beginRun().

buildParameterStore()

void AlignmentProducerBase::buildParameterStore ( )

private

Creates the @alignmentParameterStore_, which manages all Alignables.

Definition at line 491 of file AlignmentProducerBase.cc.

                                                {
  // Create alignment parameter builder
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::buildParameterStore"
                            << "Creating AlignmentParameterBuilder";
 
  const auto& alParamBuildCfg = config_.getParameter<edm::ParameterSet>("ParameterBuilder");
  const auto& alParamStoreCfg = config_.getParameter<edm::ParameterSet>("ParameterStore");
 
  AlignmentParameterBuilder alignmentParameterBuilder{
      alignableTracker_.get(), alignableMuon_.get(), alignableExtras_.get(), alParamBuildCfg};
 
  // Fix alignables if requested
  if (stNFixAlignables_ > 0) {
    alignmentParameterBuilder.fixAlignables(stNFixAlignables_);
  }
 
  // Get list of alignables
  const auto& alignables = alignmentParameterBuilder.alignables();
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::buildParameterStore"
                            << "got " << alignables.size() << " alignables";
 
  // Create AlignmentParameterStore
  alignmentParameterStore_ = std::make_unique<AlignmentParameterStore>(alignables, alParamStoreCfg);
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::buildParameterStore"
                            << "AlignmentParameterStore created!";
}

References alignableExtras_, alignableMuon_, alignableTracker_, alignmentParameterStore_, config_, edm::ParameterSet::getParameter(), and stNFixAlignables_.

Referenced by initAlignmentAlgorithm().

createAlignables()

void AlignmentProducerBase::createAlignables ( const TrackerTopology *  tTopo, bool  update = false  )

private

Creates Alignables @alignableTracker_ from the previously loaded Geometry @trackerGeometry_

Definition at line 464 of file AlignmentProducerBase.cc.

                                                                                      {
  if (doTracker_) {
    if (update) {
      alignableTracker_->update(trackerGeometry_.get(), tTopo);
    } else {
      alignableTracker_ = std::make_unique<AlignableTracker>(trackerGeometry_.get(), tTopo);
    }
  }
 
  if (doMuon_) {
    if (update) {
      alignableMuon_->update(&*muonDTGeometry_, &*muonCSCGeometry_, &*muonGEMGeometry_);
    } else {
      alignableMuon_ = std::make_unique<AlignableMuon>(&*muonDTGeometry_, &*muonCSCGeometry_, &*muonGEMGeometry_);
    }
  }
 
  if (useExtras_) {
    if (update) {
      // FIXME: Requires further code changes to track beam spot condition changes
    } else {
      alignableExtras_ = std::make_unique<AlignableExtras>();
    }
  }
}

References alignableExtras_, alignableMuon_, alignableTracker_, doMuon_, doTracker_, muonCSCGeometry_, muonDTGeometry_, muonGEMGeometry_, trackerGeometry_, update, and useExtras_.

Referenced by initAlignmentAlgorithm().

createAlignmentAlgorithm()

void AlignmentProducerBase::createAlignmentAlgorithm ( )

private

Creates the choosen alignment algorithm.

Definition at line 259 of file AlignmentProducerBase.cc.

                                                     {
  auto algoConfig = config_.getParameter<edm::ParameterSet>("algoConfig");
  algoConfig.addUntrackedParameter("RunRangeSelection", config_.getParameter<edm::VParameterSet>("RunRangeSelection"));
  algoConfig.addUntrackedParameter<align::RunNumber>("firstIOV", runAtPCL_ ? 1 : uniqueRunRanges_.front().first);
  algoConfig.addUntrackedParameter("enableAlignableUpdates", enableAlignableUpdates_);
 
  const auto& algoName = algoConfig.getParameter<std::string>("algoName");
  alignmentAlgo_ = AlignmentAlgorithmPluginFactory::get()->create(algoName, algoConfig);
}

References ALCARECOPromptCalibProdSiPixelAli0T_cff::algoConfig, HIPAlignmentAlgorithm_cfi::algoName, alignmentAlgo_, config_, enableAlignableUpdates_, get, edm::ParameterSet::getParameter(), runAtPCL_, AlCaHLTBitMon_QueryRunRegistry::string, and uniqueRunRanges_.

createCalibrations()

void AlignmentProducerBase::createCalibrations ( )

private

Creates the calibrations.

Definition at line 280 of file AlignmentProducerBase.cc.

                                               {
  const auto& calibrations = config_.getParameter<edm::VParameterSet>("calibrations");
  for (const auto& iCalib : calibrations) {
    calibrations_.emplace_back(
        IntegratedCalibrationPluginFactory::get()->create(iCalib.getParameter<std::string>("calibrationName"), iCalib));
  }
}

References AlignmentProducer_cff::calibrations, calibrations_, config_, beamerCreator::create(), get, edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

createGeometries()

void AlignmentProducerBase::createGeometries ( const edm::EventSetup &  iSetup, const TrackerTopology *  tTopo  )

private

Creates ideal geometry @trackerGeometry_ from IdealGeometryRecord.

Definition at line 412 of file AlignmentProducerBase.cc.

                                                                                                      {
  if (doTracker_) {
    edm::ESHandle<GeometricDet> geometricDet;
    iSetup.get<IdealGeometryRecord>().get(geometricDet);
 
    edm::ESHandle<PTrackerParameters> ptp;
    iSetup.get<PTrackerParametersRcd>().get(ptp);
 
    TrackerGeomBuilderFromGeometricDet trackerBuilder;
 
    trackerGeometry_ = std::shared_ptr<TrackerGeometry>(trackerBuilder.build(&(*geometricDet), *ptp, tTopo));
  }
 
  if (doMuon_) {
    iSetup.get<MuonGeometryRecord>().get(idealGeometryLabel, muonDTGeometry_);
    iSetup.get<MuonGeometryRecord>().get(idealGeometryLabel, muonCSCGeometry_);
    iSetup.get<MuonGeometryRecord>().get(idealGeometryLabel, muonGEMGeometry_);
  }
}

References TrackerGeomBuilderFromGeometricDet::build(), doMuon_, doTracker_, edm::EventSetup::get(), get, idealGeometryLabel, muonCSCGeometry_, muonDTGeometry_, muonGEMGeometry_, and trackerGeometry_.

Referenced by initAlignmentAlgorithm().

createMonitors()

void AlignmentProducerBase::createMonitors ( )

private

Creates the monitors.

Definition at line 270 of file AlignmentProducerBase.cc.

                                           {
  const auto& monitorConfig = config_.getParameter<edm::ParameterSet>("monitorConfig");
  auto monitors = monitorConfig.getUntrackedParameter<std::vector<std::string> >("monitors");
  for (const auto& miter : monitors) {
    monitors_.emplace_back(
        AlignmentMonitorPluginFactory::get()->create(miter, monitorConfig.getUntrackedParameterSet(miter)));
  }
}

References config_, beamerCreator::create(), get, edm::ParameterSet::getParameter(), AlignmentProducer_cff::monitorConfig, gather_cfg::monitors, and monitors_.

endLuminosityBlockImpl()

void AlignmentProducerBase::endLuminosityBlockImpl ( const edm::LuminosityBlock &  , const edm::EventSetup &  setup  )

protected

end lumi block

Definition at line 253 of file AlignmentProducerBase.cc.

                                                                                                        {
  // Do not forward edm::LuminosityBlock
  alignmentAlgo_->endLuminosityBlock(setup);
}

References alignmentAlgo_, and singleTopDQM_cfi::setup.

Referenced by AlignmentProducer::endLuminosityBlock(), and AlignmentProducerAsAnalyzer::endLuminosityBlock().

endRunImpl()

void AlignmentProducerBase::endRunImpl ( const edm::Run &  run, const edm::EventSetup &  setup  )

protected

end run

Definition at line 231 of file AlignmentProducerBase.cc.

                                                                                    {
  if (!tkLasBeamTag_.encode().empty()) {
    edm::Handle<TkFittedLasBeamCollection> lasBeams;
    edm::Handle<TsosVectorCollection> tsoses;
    getTkFittedLasBeamCollection(run, lasBeams);
    getTsosVectorCollection(run, tsoses);
 
    alignmentAlgo_->endRun(EndRunInfo(run.id(), &(*lasBeams), &(*tsoses)), setup);
  } else {
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::endRunImpl"
                              << "No Tk LAS beams to forward to algorithm.";
    alignmentAlgo_->endRun(EndRunInfo(run.id(), nullptr, nullptr), setup);
  }
}

References alignmentAlgo_, edm::InputTag::encode(), getTkFittedLasBeamCollection(), getTsosVectorCollection(), writedatasetfile::run, singleTopDQM_cfi::setup, and tkLasBeamTag_.

Referenced by AlignmentProducer::endRun(), and AlignmentProducerAsAnalyzer::endRun().

finish()

bool AlignmentProducerBase::finish ( )

protected

Steers activities after end of job, terminates the AlignmentAlgorithm @alignmentAlgo_

Definition at line 751 of file AlignmentProducerBase.cc.

                                   {
  for (const auto& monitor : monitors_)
    monitor->endOfJob();
 
  if (alignmentAlgo_->processesEvents() && nevent_ == 0) {
    return false;
  }
 
  if (saveToDB_ || saveApeToDB_ || saveDeformationsToDB_) {
    if (alignmentAlgo_->storeAlignments())
      storeAlignmentsToDB();
  } else {
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::finish"
                              << "No payload to be stored!";
  }
 
  // takes care of storing output of calibrations, but needs to be called only
  // after 'storeAlignmentsToDB()'
  for (const auto& iCal : calibrations_)
    iCal->endOfJob();
 
  return true;
}

References alignmentAlgo_, calibrations_, beam_dqm_sourceclient-live_cfg::monitor, monitors_, nevent_, saveApeToDB_, saveDeformationsToDB_, saveToDB_, and storeAlignmentsToDB().

Referenced by progressbar.ProgressBar::__next__(), AlignmentProducer::endOfJob(), and AlignmentProducerAsAnalyzer::endProcessBlockProduce().

getAliClusterValueMap()

virtual bool AlignmentProducerBase::getAliClusterValueMap ( const edm::Event &  , edm::Handle< AliClusterValueMap > &    )

protectedpure virtual

Implemented in AlignmentProducerAsAnalyzer, and AlignmentProducer.

Referenced by processEvent().

getBeamSpot()

virtual bool AlignmentProducerBase::getBeamSpot ( const edm::Event &  , edm::Handle< reco::BeamSpot > &    )

protectedpure virtual

Implemented in AlignmentProducerAsAnalyzer, and AlignmentProducer.

Referenced by initBeamSpot().

getTkFittedLasBeamCollection()

virtual bool AlignmentProducerBase::getTkFittedLasBeamCollection ( const edm::Run &  , edm::Handle< TkFittedLasBeamCollection > &    )

protectedpure virtual

Implemented in AlignmentProducerAsAnalyzer, and AlignmentProducer.

Referenced by endRunImpl().

getTrajTrackAssociationCollection()

virtual bool AlignmentProducerBase::getTrajTrackAssociationCollection ( const edm::Event &  , edm::Handle< TrajTrackAssociationCollection > &    )

protectedpure virtual

Implemented in AlignmentProducerAsAnalyzer, and AlignmentProducer.

Referenced by processEvent().

getTsosVectorCollection()

virtual bool AlignmentProducerBase::getTsosVectorCollection ( const edm::Run &  , edm::Handle< TsosVectorCollection > &    )

protectedpure virtual

Implemented in AlignmentProducerAsAnalyzer, and AlignmentProducer.

Referenced by endRunImpl().

initAlignmentAlgorithm()

void AlignmentProducerBase::initAlignmentAlgorithm ( const edm::EventSetup &  setup, bool  update = false  )

protected

Creates Geometry and Alignables of the Tracker and initializes the AlignmentAlgorithm @alignmentAlgo_

Definition at line 341 of file AlignmentProducerBase.cc.

                                                                                          {
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::initAlignmentAlgorithm"
                            << "Begin";
 
  auto isTrueUpdate = update && isAlgoInitialized_;
 
  // Retrieve tracker topology from geometry
  edm::ESHandle<TrackerTopology> tTopoHandle;
  setup.get<TrackerTopologyRcd>().get(tTopoHandle);
  const TrackerTopology* const tTopo = tTopoHandle.product();
 
  // Create the geometries from the ideal geometries
  createGeometries(setup, tTopo);
 
  applyAlignmentsToDB(setup);
  createAlignables(tTopo, isTrueUpdate);
  buildParameterStore();
  applyMisalignment();
 
  // Initialize alignment algorithm and integrated calibration and pass the
  // latter to algorithm
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::initAlignmentAlgorithm"
                            << "Initializing alignment algorithm.";
  alignmentAlgo_->initialize(
      setup, alignableTracker_.get(), alignableMuon_.get(), alignableExtras_.get(), alignmentParameterStore_.get());
 
  // Not all algorithms support calibrations - so do not pass empty vector
  // and throw if non-empty and not supported:
  if (!calibrations_.empty()) {
    if (alignmentAlgo_->supportsCalibrations()) {
      alignmentAlgo_->addCalibrations(calibrations_);
    } else {
      throw cms::Exception("BadConfig") << "@SUB=AlignmentProducerBase::createCalibrations\n"
                                        << "Configured " << calibrations_.size() << " calibration(s) "
                                        << "for algorithm not supporting it.";
    }
  }
 
  isAlgoInitialized_ = true;
 
  applyAlignmentsToGeometry();
 
  if (!isTrueUpdate) {  // only needed the first time
    for (const auto& iCal : calibrations_) {
      iCal->beginOfJob(alignableTracker_.get(), alignableMuon_.get(), alignableExtras_.get());
    }
    for (const auto& monitor : monitors_) {
      monitor->beginOfJob(alignableTracker_.get(), alignableMuon_.get(), alignmentParameterStore_.get());
    }
  }
  startProcessing();  // needed if derived class is non-EDLooper-based
                      // has no effect, if called during loop
 
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::initAlignmentAlgorithm"
                            << "End";
}

References alignableExtras_, alignableMuon_, alignableTracker_, alignmentAlgo_, alignmentParameterStore_, applyAlignmentsToDB(), applyAlignmentsToGeometry(), applyMisalignment(), buildParameterStore(), calibrations_, createAlignables(), createGeometries(), Exception, get, isAlgoInitialized_, beam_dqm_sourceclient-live_cfg::monitor, monitors_, edm::ESHandle< T >::product(), singleTopDQM_cfi::setup, startProcessing(), and update.

Referenced by AlignmentProducer::beginOfJob(), beginRunImpl(), and processEvent().

initBeamSpot()

void AlignmentProducerBase::initBeamSpot ( const edm::Event &  event )

private

Initializes Beamspot @beamSpot_ of Alignables @alignableExtras_.

Definition at line 399 of file AlignmentProducerBase.cc.

                                                              {
  getBeamSpot(event, beamSpot_);
 
  if (nevent_ == 0 && alignableExtras_) {
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::initBeamSpot"
                              << "Initializing AlignableBeamSpot";
 
    alignableExtras_->initializeBeamSpot(
        beamSpot_->x0(), beamSpot_->y0(), beamSpot_->z0(), beamSpot_->dxdz(), beamSpot_->dydz());
  }
}

References alignableExtras_, beamSpot_, reco::BeamSpot::dxdz(), reco::BeamSpot::dydz(), getBeamSpot(), nevent_, reco::BeamSpot::x0(), reco::BeamSpot::y0(), and reco::BeamSpot::z0().

Referenced by processEvent().

nEvent()

int AlignmentProducerBase::nEvent ( ) const

inlineprotected

Definition at line 99 of file AlignmentProducerBase.h.

{ return nevent_; }

References nevent_.

Referenced by AlignmentProducer::endOfLoop().

processEvent()

bool AlignmentProducerBase::processEvent ( const edm::Event &  event, const edm::EventSetup &  setup  )

protected

Process event.

Definition at line 133 of file AlignmentProducerBase.cc.

                                                                                          {
  if (setupChanged(setup)) {
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::processEvent"
                              << "EventSetup-Record changed.";
 
    // updatable alignables are currently not used at PCL, but event setup
    // changes require a complete re-initialization
    if (runAtPCL_) {
      initAlignmentAlgorithm(setup, /* update = */ false);
    } else if (enableAlignableUpdates_) {
      initAlignmentAlgorithm(setup, /* update = */ true);
    }
  }
 
  initBeamSpot(event);  // must happen every event and before incrementing 'nevent_'
 
  ++nevent_;  // must happen before the check below;
              // otherwise subsequent checks fail for "EmptySource"
 
  if (!alignmentAlgo_->processesEvents()) {
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::processEvent"
                              << "Skipping event. The current configuration of the alignment algorithm "
                              << "does not need to process any events.";
    return false;
  }
 
  // reading in survey records
  readInSurveyRcds(setup);
 
  // Printout event number
  for (int i = 10; i < 10000000; i *= 10) {
    if (nevent_ < 10 * i && (nevent_ % i) == 0) {
      edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::processEvent"
                                << "Events processed: " << nevent_;
    }
  }
 
  // Retrieve trajectories and tracks from the event
  // -> merely skip if collection is empty
  edm::Handle<TrajTrackAssociationCollection> handleTrajTracksCollection;
 
  if (getTrajTrackAssociationCollection(event, handleTrajTracksCollection)) {
    // Form pairs of trajectories and tracks
    ConstTrajTrackPairs trajTracks;
    for (auto iter = handleTrajTracksCollection->begin(); iter != handleTrajTracksCollection->end(); ++iter) {
      trajTracks.push_back(ConstTrajTrackPair(&(*(*iter).key), &(*(*iter).val)));
    }
 
    // Run the alignment algorithm with its input
    const AliClusterValueMap* clusterValueMapPtr{nullptr};
    if (!clusterValueMapTag_.encode().empty()) {
      edm::Handle<AliClusterValueMap> clusterValueMap;
      getAliClusterValueMap(event, clusterValueMap);
      clusterValueMapPtr = &(*clusterValueMap);
    }
 
    const AlignmentAlgorithmBase::EventInfo eventInfo{event.id(), trajTracks, *beamSpot_, clusterValueMapPtr};
    alignmentAlgo_->run(setup, eventInfo);
 
    for (const auto& monitor : monitors_) {
      monitor->duringLoop(event, setup, trajTracks);  // forward eventInfo?
    }
  } else {
    edm::LogError("Alignment") << "@SUB=AlignmentProducerBase::processEvent"
                               << "No track collection found: skipping event";
  }
 
  return true;
}

References alignmentAlgo_, beamSpot_, edm::AssociationMap< Tag >::begin(), clusterValueMapTag_, enableAlignableUpdates_, edm::InputTag::encode(), edm::AssociationMap< Tag >::end(), dumpTauVariables_cfi::eventInfo, getAliClusterValueMap(), getTrajTrackAssociationCollection(), mps_fire::i, initAlignmentAlgorithm(), initBeamSpot(), beam_dqm_sourceclient-live_cfg::monitor, monitors_, nevent_, readInSurveyRcds(), runAtPCL_, singleTopDQM_cfi::setup, and setupChanged().

Referenced by AlignmentProducerAsAnalyzer::accumulate(), and AlignmentProducer::duringLoop().

readInSurveyRcds()

void AlignmentProducerBase::readInSurveyRcds ( const edm::EventSetup &  iSetup )

private

Reads in survey records.

Definition at line 666 of file AlignmentProducerBase.cc.

                                                                        {
  // Get Survey Rcds and add Survey Info
  if (doTracker_ && useSurvey_) {
    bool tkSurveyBool = watchTkSurveyRcd_.check(iSetup);
    bool tkSurveyErrBool = watchTkSurveyErrExtRcd_.check(iSetup);
    edm::LogInfo("Alignment") << "watcher tksurveyrcd: " << tkSurveyBool;
    edm::LogInfo("Alignment") << "watcher tksurveyerrrcd: " << tkSurveyErrBool;
    if (tkSurveyBool || tkSurveyErrBool) {
      edm::LogInfo("Alignment") << "ADDING THE SURVEY INFORMATION";
      edm::ESHandle<Alignments> surveys;
      edm::ESHandle<SurveyErrors> surveyErrors;
 
      iSetup.get<TrackerSurveyRcd>().get(surveys);
      iSetup.get<TrackerSurveyErrorExtendedRcd>().get(surveyErrors);
 
      surveyIndex_ = 0;
      surveyValues_ = &*surveys;
      surveyErrors_ = &*surveyErrors;
      addSurveyInfo(alignableTracker_.get());
    }
  }
 
  if (doMuon_ && useSurvey_) {
    bool DTSurveyBool = watchTkSurveyRcd_.check(iSetup);
    bool DTSurveyErrBool = watchTkSurveyErrExtRcd_.check(iSetup);
    bool CSCSurveyBool = watchTkSurveyRcd_.check(iSetup);
    bool CSCSurveyErrBool = watchTkSurveyErrExtRcd_.check(iSetup);
 
    if (DTSurveyBool || DTSurveyErrBool || CSCSurveyBool || CSCSurveyErrBool) {
      edm::ESHandle<Alignments> dtSurveys;
      edm::ESHandle<SurveyErrors> dtSurveyErrors;
      edm::ESHandle<Alignments> cscSurveys;
      edm::ESHandle<SurveyErrors> cscSurveyErrors;
 
      iSetup.get<DTSurveyRcd>().get(dtSurveys);
      iSetup.get<DTSurveyErrorExtendedRcd>().get(dtSurveyErrors);
      iSetup.get<CSCSurveyRcd>().get(cscSurveys);
      iSetup.get<CSCSurveyErrorExtendedRcd>().get(cscSurveyErrors);
 
      surveyIndex_ = 0;
      surveyValues_ = &*dtSurveys;
      surveyErrors_ = &*dtSurveyErrors;
      const auto& barrels = alignableMuon_->DTBarrel();
      for (const auto& barrel : barrels)
        addSurveyInfo(barrel);
 
      surveyIndex_ = 0;
      surveyValues_ = &*cscSurveys;
      surveyErrors_ = &*cscSurveyErrors;
      const auto& endcaps = alignableMuon_->CSCEndcaps();
      for (const auto& endcap : endcaps)
        addSurveyInfo(endcap);
    }
  }
}

References addSurveyInfo(), alignableMuon_, alignableTracker_, Reference_intrackfit_cff::barrel, edm::ESWatcher< T >::check(), doMuon_, doTracker_, makeMuonMisalignmentScenario::endcap, edm::EventSetup::get(), get, surveyErrors_, surveyIndex_, surveyValues_, useSurvey_, watchTkSurveyErrExtRcd_, and watchTkSurveyRcd_.

Referenced by processEvent().

setupChanged()

bool AlignmentProducerBase::setupChanged ( const edm::EventSetup &  setup )

private

Checks if one of the EventSetup-Records has changed.

Definition at line 289 of file AlignmentProducerBase.cc.

                                                                   {
  bool changed{false};
 
  if (watchIdealGeometryRcd_.check(setup)) {
    changed = true;
  }
 
  if (watchGlobalPositionRcd_.check(setup)) {
    changed = true;
  }
 
  if (doTracker_) {
    if (watchTrackerAlRcd_.check(setup)) {
      changed = true;
    }
 
    if (watchTrackerAlErrorExtRcd_.check(setup)) {
      changed = true;
    }
 
    if (watchTrackerSurDeRcd_.check(setup)) {
      changed = true;
    }
  }
 
  if (doMuon_) {
    if (watchDTAlRcd_.check(setup)) {
      changed = true;
    }
 
    if (watchDTAlErrExtRcd_.check(setup)) {
      changed = true;
    }
 
    if (watchCSCAlRcd_.check(setup)) {
      changed = true;
    }
 
    if (watchCSCAlErrExtRcd_.check(setup)) {
      changed = true;
    }
  }
 
  /* TODO: ExtraAlignables: Which record(s) to check?
   *
   if (useExtras_) {}
  */
 
  return changed;
}

References edm::ESWatcher< T >::check(), doMuon_, doTracker_, singleTopDQM_cfi::setup, watchCSCAlErrExtRcd_, watchCSCAlRcd_, watchDTAlErrExtRcd_, watchDTAlRcd_, watchGlobalPositionRcd_, watchIdealGeometryRcd_, watchTrackerAlErrorExtRcd_, watchTrackerAlRcd_, and watchTrackerSurDeRcd_.

Referenced by beginRunImpl(), and processEvent().

simpleMisalignment()

void AlignmentProducerBase::simpleMisalignment ( const align::Alignables &  alivec, const std::string &  selection, float  shift, float  rot, bool  local  )

private

Applies misalignment scenario to @alignableTracker_.

Definition at line 550 of file AlignmentProducerBase.cc.

                                                                                                   {
  std::ostringstream output;  // collecting output
 
  if (shift > 0. || rot > 0.) {
    output << "Adding random flat shift of max size " << shift << " and adding random flat rotation of max size " << rot
           << " to ";
 
    std::vector<bool> commSel(0);
    if (selection != "-1") {
      AlignmentParameterSelector aSelector(nullptr, nullptr);  // no alignable needed here...
      const std::vector<char> cSel(aSelector.convertParamSel(selection));
      if (cSel.size() < RigidBodyAlignmentParameters::N_PARAM) {
        throw cms::Exception("BadConfig")
            << "[AlignmentProducerBase::simpleMisalignment_]\n"
            << "Expect selection string '" << selection << "' to be at least of length "
            << RigidBodyAlignmentParameters::N_PARAM << " or to be '-1'.\n"
            << "(Most probably you have to adjust the parameter 'parameterSelectorSimple'.)";
      }
      for (const auto& cIter : cSel) {
        commSel.push_back(cIter == '0' ? false : true);
      }
      output << "parameters defined by (" << selection << "), representing (x,y,z,alpha,beta,gamma),";
    } else {
      output << "the active parameters of each alignable,";
    }
    output << " in " << (local ? "local" : "global") << " frame.";
 
    for (const auto& ali : alivec) {
      std::vector<bool> mysel(commSel.empty() ? ali->alignmentParameters()->selector() : commSel);
 
      if (std::abs(shift) > 0.00001) {
        double s0 = 0., s1 = 0., s2 = 0.;
        if (mysel[RigidBodyAlignmentParameters::dx])
          s0 = shift * double(random() % 1000 - 500) / 500.;
        if (mysel[RigidBodyAlignmentParameters::dy])
          s1 = shift * double(random() % 1000 - 500) / 500.;
        if (mysel[RigidBodyAlignmentParameters::dz])
          s2 = shift * double(random() % 1000 - 500) / 500.;
 
        if (local)
          ali->move(ali->surface().toGlobal(align::LocalVector(s0, s1, s2)));
        else
          ali->move(align::GlobalVector(s0, s1, s2));
 
        //AlignmentPositionError ape(dx,dy,dz);
        //ali->addAlignmentPositionError(ape);
      }
 
      if (std::abs(rot) > 0.00001) {
        align::EulerAngles r(3);
        if (mysel[RigidBodyAlignmentParameters::dalpha])
          r(1) = rot * double(random() % 1000 - 500) / 500.;
        if (mysel[RigidBodyAlignmentParameters::dbeta])
          r(2) = rot * double(random() % 1000 - 500) / 500.;
        if (mysel[RigidBodyAlignmentParameters::dgamma])
          r(3) = rot * double(random() % 1000 - 500) / 500.;
 
        const align::RotationType mrot = align::toMatrix(r);
        if (local)
          ali->rotateInLocalFrame(mrot);
        else
          ali->rotateInGlobalFrame(mrot);
 
        //ali->addAlignmentPositionErrorFromRotation(mrot);
      }
    }  // end loop on alignables
  } else {
    output << "No simple misalignment added!";
  }
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::simpleMisalignment" << output.str();
}

References funct::abs(), AlignmentParameterSelector::convertParamSel(), RigidBodyAlignmentParameters::dalpha, RigidBodyAlignmentParameters::dbeta, RigidBodyAlignmentParameters::dgamma, RigidBodyAlignmentParameters::dx, RigidBodyAlignmentParameters::dy, RigidBodyAlignmentParameters::dz, Exception, DTRecHitClients_cfi::local, RigidBodyAlignmentParameters::N_PARAM, convertSQLitetoXML_cfg::output, alignCSCRings::r, makeMuonMisalignmentScenario::rot, indexGen::s2, corrVsCorr::selection, edm::shift, and align::toMatrix().

Referenced by applyMisalignment().

startProcessing()

void AlignmentProducerBase::startProcessing ( )

protected

Start processing of events.

Definition at line 83 of file AlignmentProducerBase.cc.

                                            {
  if (isDuringLoop_)
    return;
 
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::startProcessing"
                            << "Begin";
 
  if (!isAlgoInitialized_) {
    throw cms::Exception("LogicError") << "@SUB=AlignmentProducerBase::startProcessing\n"
                                       << "Trying to start event processing before initializing the alignment "
                                       << "algorithm.";
  }
 
  nevent_ = 0;
 
  alignmentAlgo_->startNewLoop();
 
  // FIXME: Should this be done in algorithm::startNewLoop()??
  for (const auto& iCal : calibrations_)
    iCal->startNewLoop();
  for (const auto& monitor : monitors_)
    monitor->startingNewLoop();
 
  applyAlignmentsToGeometry();
  isDuringLoop_ = true;
}

References alignmentAlgo_, applyAlignmentsToGeometry(), calibrations_, Exception, isAlgoInitialized_, isDuringLoop_, beam_dqm_sourceclient-live_cfg::monitor, monitors_, and nevent_.

Referenced by initAlignmentAlgorithm(), and AlignmentProducer::startingNewLoop().

storeAlignmentsToDB()

void AlignmentProducerBase::storeAlignmentsToDB ( )

private

Writes Alignments (i.e. Records) to database-file.

Definition at line 776 of file AlignmentProducerBase.cc.

                                                {
  const auto runRangeSelectionVPSet = config_.getParameterSetVector("RunRangeSelection");
 
  // handle PCL use case
  const auto& uniqueRunRanges =
      (runAtPCL_ ? align::makeUniqueRunRanges(runRangeSelectionVPSet, firstRun_) : uniqueRunRanges_);
 
  std::vector<AlgebraicVector> beamSpotParameters;
 
  for (const auto& iRunRange : uniqueRunRanges) {
    alignmentAlgo_->setParametersForRunRange(iRunRange);
 
    // Save alignments to database
    if (saveToDB_ || saveApeToDB_ || saveDeformationsToDB_) {
      writeForRunRange(iRunRange.first);
    }
 
    // Deal with extra alignables, e.g. beam spot
    if (alignableExtras_) {
      auto& alis = alignableExtras_->beamSpot();
      if (!alis.empty()) {
        auto beamSpotAliPars = dynamic_cast<BeamSpotAlignmentParameters*>(alis[0]->alignmentParameters());
        if (!beamSpotAliPars) {
          throw cms::Exception("LogicError") << "@SUB=AlignmentProducerBase::storeAlignmentsToDB\n"
                                             << "First alignable of alignableExtras_ does not have "
                                             << "'BeamSpotAlignmentParameters', while it should have.";
        }
 
        beamSpotParameters.push_back(beamSpotAliPars->parameters());
      }
    }
  }
 
  if (alignableExtras_) {
    std::ostringstream bsOutput;
 
    auto itPar = beamSpotParameters.cbegin();
    for (auto iRunRange = uniqueRunRanges.cbegin(); iRunRange != uniqueRunRanges.cend(); ++iRunRange, ++itPar) {
      bsOutput << "Run range: " << (*iRunRange).first << " - " << (*iRunRange).second << "\n";
      bsOutput << "  Displacement: x=" << (*itPar)[0] << ", y=" << (*itPar)[1] << "\n";
      bsOutput << "  Slope: dx/dz=" << (*itPar)[2] << ", dy/dz=" << (*itPar)[3] << "\n";
    }
 
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::storeAlignmentsToDB"
                              << "Parameters for alignable beamspot:\n"
                              << bsOutput.str();
  }
}

References alignableExtras_, alignmentAlgo_, config_, Exception, firstRun_, edm::ParameterSet::getParameterSetVector(), align::makeUniqueRunRanges(), runAtPCL_, saveApeToDB_, saveDeformationsToDB_, saveToDB_, uniqueRunRanges_, and writeForRunRange().

Referenced by finish().

terminateProcessing()

void AlignmentProducerBase::terminateProcessing ( const edm::EventSetup *  setup = nullptr )

protected

Terminate processing of events.

Definition at line 111 of file AlignmentProducerBase.cc.

                                                                          {
  if (!isDuringLoop_)
    return;
 
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::terminateProcessing"
                            << "Terminating algorithm.";
  if (setup) {
    alignmentAlgo_->terminate(*setup);
  } else {
    alignmentAlgo_->terminate();
  }
 
  // FIXME: Should this be done in algorithm::terminate()??
  for (const auto& iCal : calibrations_)
    iCal->endOfLoop();
  for (const auto& monitor : monitors_)
    monitor->endOfLoop();
 
  isDuringLoop_ = false;
}

References alignmentAlgo_, calibrations_, isDuringLoop_, beam_dqm_sourceclient-live_cfg::monitor, monitors_, and singleTopDQM_cfi::setup.

Referenced by AlignmentProducer::endOfLoop(), and AlignmentProducerAsAnalyzer::endProcessBlockProduce().

writeDB() [1/2]

void AlignmentProducerBase::writeDB ( Alignments *  alignments, const std::string &  alignRcd, AlignmentErrorsExtended *  alignmentErrors, const std::string &  errRcd, const AlignTransform *  globalCoordinates, cond::Time_t  time  ) const

private

Writes Alignments and/or AlignmentErrors to DB for record names (removes *globalCoordinates before writing if non-null...). Takes over ownership of Alignments and AlignmentErrors.

Definition at line 863 of file AlignmentProducerBase.cc.

                                                           {
  Alignments* tempAlignments = alignments;
  AlignmentErrorsExtended* tempAlignmentErrorsExtended = alignmentErrors;
 
  // Call service
  edm::Service<cond::service::PoolDBOutputService> poolDb;
  if (!poolDb.isAvailable()) {           // Die if not available
    delete tempAlignments;               // promised to take over ownership...
    delete tempAlignmentErrorsExtended;  // dito
    throw cms::Exception("NotAvailable") << "PoolDBOutputService not available";
  }
 
  if (globalCoordinates  // happens only if (applyDbAlignment_ == true)
      && globalCoordinates->transform() != AlignTransform::Transform::Identity) {
    tempAlignments = new Alignments();                            // temporary storage for
    tempAlignmentErrorsExtended = new AlignmentErrorsExtended();  // final alignments and errors
 
    GeometryAligner aligner;
    aligner.removeGlobalTransform(
        alignments, alignmentErrors, *globalCoordinates, tempAlignments, tempAlignmentErrorsExtended);
 
    delete alignments;       // have to delete original alignments
    delete alignmentErrors;  // same thing for the errors
 
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducerBase::writeDB"
                              << "globalCoordinates removed from alignments (" << alignRcd << ") and errors ("
                              << alignRcd << ").";
  }
 
  if (saveToDB_) {
    edm::LogInfo("Alignment") << "Writing Alignments for run " << time << " to " << alignRcd << ".";
    poolDb->writeOne<Alignments>(tempAlignments, time, alignRcd);
  } else {                  // poolDb->writeOne(..) takes over 'alignments' ownership,...
    delete tempAlignments;  // ...otherwise we have to delete, as promised!
  }
 
  if (saveApeToDB_) {
    edm::LogInfo("Alignment") << "Writing AlignmentErrorsExtended for run " << time << " to " << errRcd << ".";
    poolDb->writeOne<AlignmentErrorsExtended>(tempAlignmentErrorsExtended, time, errRcd);
  } else {                               // poolDb->writeOne(..) takes over 'alignmentErrors' ownership,...
    delete tempAlignmentErrorsExtended;  // ...otherwise we have to delete, as promised!
  }
}

References Exception, edm::Service< T >::isAvailable(), GeometryAligner::removeGlobalTransform(), saveApeToDB_, saveToDB_, protons_cff::time, AlignTransform::transform(), and cond::service::PoolDBOutputService::writeOne().

Referenced by writeForRunRange().

writeDB() [2/2]

void AlignmentProducerBase::writeDB ( AlignmentSurfaceDeformations *  alignmentSurfaceDeformations, const std::string &  surfaceDeformationRcd, cond::Time_t  time  ) const

private

Writes SurfaceDeformations (bows & kinks) to DB for given record name Takes over ownership of AlignmentSurfaceDeformations.

Definition at line 913 of file AlignmentProducerBase.cc.

                                                           {
  // Call service
  edm::Service<cond::service::PoolDBOutputService> poolDb;
  if (!poolDb.isAvailable()) {            // Die if not available
    delete alignmentSurfaceDeformations;  // promised to take over ownership...
    throw cms::Exception("NotAvailable") << "PoolDBOutputService not available";
  }
 
  if (saveDeformationsToDB_) {
    edm::LogInfo("Alignment") << "Writing AlignmentSurfaceDeformations for run " << time << " to "
                              << surfaceDeformationRcd << ".";
    poolDb->writeOne<AlignmentSurfaceDeformations>(alignmentSurfaceDeformations, time, surfaceDeformationRcd);
  } else {                                // poolDb->writeOne(..) takes over 'surfaceDeformation' ownership,...
    delete alignmentSurfaceDeformations;  // ...otherwise we have to delete, as promised!
  }
}

References Exception, edm::Service< T >::isAvailable(), saveDeformationsToDB_, protons_cff::time, and cond::service::PoolDBOutputService::writeOne().

writeForRunRange()

void AlignmentProducerBase::writeForRunRange ( cond::Time_t  time )

private

Writes Alignments and AlignmentErrors for all sub detectors and the given run number

Definition at line 826 of file AlignmentProducerBase.cc.

                                                            {
  if (doTracker_) {                                // first tracker
    const AlignTransform* trackerGlobal{nullptr};  // will be 'removed' from constants
    if (globalPositions_) {                        // i.e. applied before in applyDB
      trackerGlobal = &align::DetectorGlobalPosition(*globalPositions_, DetId(DetId::Tracker));
    }
 
    auto alignments = alignableTracker_->alignments();
    auto alignmentErrors = alignableTracker_->alignmentErrors();
    this->writeDB(
        alignments, "TrackerAlignmentRcd", alignmentErrors, "TrackerAlignmentErrorExtendedRcd", trackerGlobal, time);
 
    // Save surface deformations to database
    if (saveDeformationsToDB_) {
      auto alignmentSurfaceDeformations = alignableTracker_->surfaceDeformations();
      this->writeDB(alignmentSurfaceDeformations, "TrackerSurfaceDeformationRcd", time);
    }
  }
 
  if (doMuon_) {                                // now muon
    const AlignTransform* muonGlobal{nullptr};  // will be 'removed' from constants
    if (globalPositions_) {                     // i.e. applied before in applyDB
      muonGlobal = &align::DetectorGlobalPosition(*globalPositions_, DetId(DetId::Muon));
    }
    // Get alignments+errors, first DT - ownership taken over by writeDB(..), so no delete
    auto alignments = alignableMuon_->dtAlignments();
    auto alignmentErrors = alignableMuon_->dtAlignmentErrorsExtended();
    this->writeDB(alignments, "DTAlignmentRcd", alignmentErrors, "DTAlignmentErrorExtendedRcd", muonGlobal, time);
 
    // Get alignments+errors, now CSC - ownership taken over by writeDB(..), so no delete
    alignments = alignableMuon_->cscAlignments();
    alignmentErrors = alignableMuon_->cscAlignmentErrorsExtended();
    this->writeDB(alignments, "CSCAlignmentRcd", alignmentErrors, "CSCAlignmentErrorExtendedRcd", muonGlobal, time);
  }
}

References alignableMuon_, alignableTracker_, align::DetectorGlobalPosition(), doMuon_, doTracker_, globalPositions_, DetId::Muon, saveDeformationsToDB_, protons_cff::time, DetId::Tracker, and writeDB().

Referenced by storeAlignmentsToDB().

Member Data Documentation

alignableExtras_

std::unique_ptr<AlignableExtras> AlignmentProducerBase::alignableExtras_

private

Definition at line 221 of file AlignmentProducerBase.h.

Referenced by buildParameterStore(), createAlignables(), initAlignmentAlgorithm(), initBeamSpot(), and storeAlignmentsToDB().

alignableMuon_

std::unique_ptr<AlignableMuon> AlignmentProducerBase::alignableMuon_

private

Definition at line 220 of file AlignmentProducerBase.h.

Referenced by applyAlignmentsToGeometry(), applyMisalignment(), buildParameterStore(), createAlignables(), initAlignmentAlgorithm(), readInSurveyRcds(), and writeForRunRange().

alignableTracker_

std::unique_ptr<AlignableTracker> AlignmentProducerBase::alignableTracker_

private

Definition at line 219 of file AlignmentProducerBase.h.

Referenced by applyAlignmentsToGeometry(), applyMisalignment(), buildParameterStore(), createAlignables(), initAlignmentAlgorithm(), readInSurveyRcds(), and writeForRunRange().

alignmentAlgo_

std::unique_ptr<AlignmentAlgorithmBase> AlignmentProducerBase::alignmentAlgo_

private

Definition at line 214 of file AlignmentProducerBase.h.

Referenced by beginLuminosityBlockImpl(), beginRunImpl(), createAlignmentAlgorithm(), endLuminosityBlockImpl(), endRunImpl(), finish(), initAlignmentAlgorithm(), processEvent(), startProcessing(), storeAlignmentsToDB(), and terminateProcessing().

alignmentParameterStore_

std::unique_ptr<AlignmentParameterStore> AlignmentProducerBase::alignmentParameterStore_

private

Definition at line 218 of file AlignmentProducerBase.h.

Referenced by applyMisalignment(), buildParameterStore(), and initAlignmentAlgorithm().

applyDbAlignment_

const bool AlignmentProducerBase::applyDbAlignment_

private

Definition at line 237 of file AlignmentProducerBase.h.

Referenced by applyAlignmentsToDB().

beamSpot_

edm::Handle<reco::BeamSpot> AlignmentProducerBase::beamSpot_

private

Definition at line 223 of file AlignmentProducerBase.h.

Referenced by initBeamSpot(), and processEvent().

beamSpotTag_

const edm::InputTag AlignmentProducerBase::beamSpotTag_

protected

BeamSpot.

Definition at line 125 of file AlignmentProducerBase.h.

Referenced by AlignmentProducer::getBeamSpot().

calibrations_

CalibrationsOwner AlignmentProducerBase::calibrations_

private

Definition at line 215 of file AlignmentProducerBase.h.

Referenced by beginRunImpl(), createCalibrations(), finish(), initAlignmentAlgorithm(), startProcessing(), and terminateProcessing().

checkDbAlignmentValidity_

const bool AlignmentProducerBase::checkDbAlignmentValidity_

private

Definition at line 237 of file AlignmentProducerBase.h.

Referenced by applyDB().

clusterValueMapTag_

const edm::InputTag AlignmentProducerBase::clusterValueMapTag_

protected

ValueMap containing associtaion cluster-flag.

Definition at line 131 of file AlignmentProducerBase.h.

Referenced by AlignmentProducer::getAliClusterValueMap(), and processEvent().

config_

edm::ParameterSet AlignmentProducerBase::config_

private

Definition at line 233 of file AlignmentProducerBase.h.

Referenced by applyMisalignment(), buildParameterStore(), createAlignmentAlgorithm(), createCalibrations(), createMonitors(), and storeAlignmentsToDB().

doMisalignmentScenario_

const bool AlignmentProducerBase::doMisalignmentScenario_

private

Definition at line 238 of file AlignmentProducerBase.h.

Referenced by applyMisalignment().

doMuon_

const bool AlignmentProducerBase::doMuon_

protected

Definition at line 119 of file AlignmentProducerBase.h.

Referenced by applyAlignmentsToDB(), applyAlignmentsToGeometry(), applyMisalignment(), createAlignables(), createGeometries(), readInSurveyRcds(), setupChanged(), and writeForRunRange().

doTracker_

const bool AlignmentProducerBase::doTracker_

protected

Definition at line 119 of file AlignmentProducerBase.h.

Referenced by applyAlignmentsToDB(), applyAlignmentsToGeometry(), applyMisalignment(), createAlignables(), createGeometries(), readInSurveyRcds(), setupChanged(), and writeForRunRange().

enableAlignableUpdates_

const bool AlignmentProducerBase::enableAlignableUpdates_

private

Definition at line 241 of file AlignmentProducerBase.h.

Referenced by beginRunImpl(), createAlignmentAlgorithm(), and processEvent().

firstRun_

cond::Time_t AlignmentProducerBase::firstRun_ {cond::timeTypeSpecs[cond::runnumber].endValue}

private

Definition at line 275 of file AlignmentProducerBase.h.

Referenced by beginRunImpl(), and storeAlignmentsToDB().

globalPositions_

std::unique_ptr<const Alignments> AlignmentProducerBase::globalPositions_

private

GlobalPositions that might be read from DB, nullptr otherwise.

Definition at line 225 of file AlignmentProducerBase.h.

Referenced by applyAlignmentsToDB(), and writeForRunRange().

idealGeometryLabel

std::string AlignmentProducerBase::idealGeometryLabel

private

Definition at line 242 of file AlignmentProducerBase.h.

Referenced by createGeometries().

isAlgoInitialized_

bool AlignmentProducerBase::isAlgoInitialized_ {false}

private

Definition at line 271 of file AlignmentProducerBase.h.

Referenced by initAlignmentAlgorithm(), and startProcessing().

isDuringLoop_

bool AlignmentProducerBase::isDuringLoop_ {false}

private

Definition at line 272 of file AlignmentProducerBase.h.

Referenced by startProcessing(), and terminateProcessing().

monitors_

AlignmentMonitors AlignmentProducerBase::monitors_

private

Definition at line 216 of file AlignmentProducerBase.h.

Referenced by createMonitors(), finish(), initAlignmentAlgorithm(), processEvent(), startProcessing(), and terminateProcessing().

muonCSCGeometry_

edm::ESHandle<CSCGeometry> AlignmentProducerBase::muonCSCGeometry_

protected

Definition at line 117 of file AlignmentProducerBase.h.

Referenced by applyAlignmentsToDB(), applyAlignmentsToGeometry(), createAlignables(), and createGeometries().

muonDTGeometry_

edm::ESHandle<DTGeometry> AlignmentProducerBase::muonDTGeometry_

protected

Definition at line 116 of file AlignmentProducerBase.h.

Referenced by applyAlignmentsToDB(), applyAlignmentsToGeometry(), createAlignables(), and createGeometries().

muonGEMGeometry_

edm::ESHandle<GEMGeometry> AlignmentProducerBase::muonGEMGeometry_

protected

Definition at line 118 of file AlignmentProducerBase.h.

Referenced by applyAlignmentsToDB(), applyAlignmentsToGeometry(), createAlignables(), and createGeometries().

nevent_

int AlignmentProducerBase::nevent_ {0}

private

Definition at line 228 of file AlignmentProducerBase.h.

Referenced by finish(), initBeamSpot(), nEvent(), processEvent(), and startProcessing().

runAtPCL_

bool AlignmentProducerBase::runAtPCL_ {false}

private

Definition at line 229 of file AlignmentProducerBase.h.

Referenced by beginRunImpl(), createAlignmentAlgorithm(), processEvent(), and storeAlignmentsToDB().

saveApeToDB_

const bool AlignmentProducerBase::saveApeToDB_

private

Definition at line 239 of file AlignmentProducerBase.h.

Referenced by finish(), storeAlignmentsToDB(), and writeDB().

saveDeformationsToDB_

const bool AlignmentProducerBase::saveDeformationsToDB_

private

Definition at line 239 of file AlignmentProducerBase.h.

Referenced by finish(), storeAlignmentsToDB(), writeDB(), and writeForRunRange().

saveToDB_

const bool AlignmentProducerBase::saveToDB_

private

Definition at line 239 of file AlignmentProducerBase.h.

Referenced by finish(), storeAlignmentsToDB(), and writeDB().

stNFixAlignables_

const int AlignmentProducerBase::stNFixAlignables_

private

Definition at line 235 of file AlignmentProducerBase.h.

Referenced by buildParameterStore().

stRandomRotation_

const double AlignmentProducerBase::stRandomRotation_

private

Definition at line 236 of file AlignmentProducerBase.h.

Referenced by applyMisalignment().

stRandomShift_

const double AlignmentProducerBase::stRandomShift_

private

Definition at line 236 of file AlignmentProducerBase.h.

Referenced by applyMisalignment().

surveyErrors_

const SurveyErrors* AlignmentProducerBase::surveyErrors_ {nullptr}

private

Definition at line 268 of file AlignmentProducerBase.h.

Referenced by addSurveyInfo(), and readInSurveyRcds().

surveyIndex_

size_t AlignmentProducerBase::surveyIndex_ {0}

private

Definition at line 266 of file AlignmentProducerBase.h.

Referenced by addSurveyInfo(), and readInSurveyRcds().

surveyValues_

const Alignments* AlignmentProducerBase::surveyValues_ {nullptr}

private

Definition at line 267 of file AlignmentProducerBase.h.

Referenced by addSurveyInfo(), and readInSurveyRcds().

tjTkAssociationMapTag_

const edm::InputTag AlignmentProducerBase::tjTkAssociationMapTag_

protected

Map with tracks/trajectories.

Definition at line 122 of file AlignmentProducerBase.h.

Referenced by AlignmentProducer::getTrajTrackAssociationCollection().

tkLasBeamTag_

const edm::InputTag AlignmentProducerBase::tkLasBeamTag_

protected

LAS beams in edm::Run (ignore if empty)

Definition at line 128 of file AlignmentProducerBase.h.

Referenced by endRunImpl(), AlignmentProducer::getTkFittedLasBeamCollection(), and AlignmentProducer::getTsosVectorCollection().

trackerGeometry_

std::shared_ptr<TrackerGeometry> AlignmentProducerBase::trackerGeometry_

protected

Definition at line 115 of file AlignmentProducerBase.h.

Referenced by applyAlignmentsToDB(), applyAlignmentsToGeometry(), createAlignables(), createGeometries(), and AlignmentProducer::produceTracker().

uniqueRunRanges_

const align::RunRanges AlignmentProducerBase::uniqueRunRanges_

private

Definition at line 227 of file AlignmentProducerBase.h.

Referenced by createAlignmentAlgorithm(), and storeAlignmentsToDB().

useExtras_

const bool AlignmentProducerBase::useExtras_

protected

Definition at line 119 of file AlignmentProducerBase.h.

Referenced by createAlignables().

useSurvey_

const bool AlignmentProducerBase::useSurvey_

private

Definition at line 240 of file AlignmentProducerBase.h.

Referenced by readInSurveyRcds().

watchCSCAlErrExtRcd_

edm::ESWatcher<CSCAlignmentErrorExtendedRcd> AlignmentProducerBase::watchCSCAlErrExtRcd_

private

Definition at line 255 of file AlignmentProducerBase.h.

Referenced by setupChanged().

watchCSCAlRcd_

edm::ESWatcher<CSCAlignmentRcd> AlignmentProducerBase::watchCSCAlRcd_

private

Definition at line 254 of file AlignmentProducerBase.h.

Referenced by setupChanged().

watchCSCSurveyErrExtRcd_

edm::ESWatcher<CSCSurveyErrorExtendedRcd> AlignmentProducerBase::watchCSCSurveyErrExtRcd_

private

Definition at line 262 of file AlignmentProducerBase.h.

watchCSCSurveyRcd_

edm::ESWatcher<CSCSurveyRcd> AlignmentProducerBase::watchCSCSurveyRcd_

private

Definition at line 261 of file AlignmentProducerBase.h.

watchDTAlErrExtRcd_

edm::ESWatcher<DTAlignmentErrorExtendedRcd> AlignmentProducerBase::watchDTAlErrExtRcd_

private

Definition at line 253 of file AlignmentProducerBase.h.

Referenced by setupChanged().

watchDTAlRcd_

edm::ESWatcher<DTAlignmentRcd> AlignmentProducerBase::watchDTAlRcd_

private

Definition at line 252 of file AlignmentProducerBase.h.

Referenced by setupChanged().

watchDTSurveyErrExtRcd_

edm::ESWatcher<DTSurveyErrorExtendedRcd> AlignmentProducerBase::watchDTSurveyErrExtRcd_

private

Definition at line 260 of file AlignmentProducerBase.h.

watchDTSurveyRcd_

edm::ESWatcher<DTSurveyRcd> AlignmentProducerBase::watchDTSurveyRcd_

private

Definition at line 259 of file AlignmentProducerBase.h.

watchGlobalPositionRcd_

edm::ESWatcher<GlobalPositionRcd> AlignmentProducerBase::watchGlobalPositionRcd_

private

Definition at line 246 of file AlignmentProducerBase.h.

Referenced by setupChanged().

watchIdealGeometryRcd_

edm::ESWatcher<IdealGeometryRecord> AlignmentProducerBase::watchIdealGeometryRcd_

private

Definition at line 245 of file AlignmentProducerBase.h.

Referenced by setupChanged().

watchTkSurveyErrExtRcd_

edm::ESWatcher<TrackerSurveyErrorExtendedRcd> AlignmentProducerBase::watchTkSurveyErrExtRcd_

private

Definition at line 258 of file AlignmentProducerBase.h.

Referenced by readInSurveyRcds().

watchTkSurveyRcd_

edm::ESWatcher<TrackerSurveyRcd> AlignmentProducerBase::watchTkSurveyRcd_

private

Definition at line 257 of file AlignmentProducerBase.h.

Referenced by readInSurveyRcds().

watchTrackerAlErrorExtRcd_

edm::ESWatcher<TrackerAlignmentErrorExtendedRcd> AlignmentProducerBase::watchTrackerAlErrorExtRcd_

private

Definition at line 249 of file AlignmentProducerBase.h.

Referenced by setupChanged().

watchTrackerAlRcd_

edm::ESWatcher<TrackerAlignmentRcd> AlignmentProducerBase::watchTrackerAlRcd_

private

Definition at line 248 of file AlignmentProducerBase.h.

Referenced by setupChanged().

watchTrackerSurDeRcd_

edm::ESWatcher<TrackerSurfaceDeformationRcd> AlignmentProducerBase::watchTrackerSurDeRcd_

private

Definition at line 250 of file AlignmentProducerBase.h.

Referenced by setupChanged().