AlignmentProducer Class Reference

#include <AlignmentProducer.h>

Inheritance diagram for AlignmentProducer:

Public Types
typedef std::vector< Alignable * >	Alignables
typedef std::pair< const Trajectory *, const reco::Track * >	ConstTrajTrackPair
typedef std::vector < ConstTrajTrackPair >	ConstTrajTrackPairCollection
typedef AlignmentAlgorithmBase::RunNumber	RunNumber
typedef AlignmentAlgorithmBase::RunRange	RunRange
typedef std::vector< RunRange >	RunRanges
Public Types inherited from edm::eventsetup::DataProxyProvider
typedef std::vector< std::pair < DataKey, boost::shared_ptr < DataProxy > > >	KeyedProxies
typedef std::vector < EventSetupRecordKey >	Keys
typedef std::map < EventSetupRecordKey, KeyedProxies >	RecordProxies
Public Types inherited from edm::EDLooperBase
enum	Status { kContinue, kStop }

Public Member Functions
	AlignmentProducer (const edm::ParameterSet &iConfig)
	Constructor. More...
virtual void	beginLuminosityBlock (const edm::LuminosityBlock &lumiBlock, const edm::EventSetup &setup)
	Called at lumi block start, calling algorithm's beginLuminosityBlock. More...
virtual void	beginOfJob (const edm::EventSetup &)
	Called at beginning of job. More...
virtual void	beginRun (const edm::Run &run, const edm::EventSetup &setup)
	Called at run start and calling algorithms beginRun. More...
virtual Status	duringLoop (const edm::Event &event, const edm::EventSetup &setup)
	Called at each event. More...
virtual void	endLuminosityBlock (const edm::LuminosityBlock &lumiBlock, const edm::EventSetup &setup)
	Called at lumi block end, calling algorithm's endLuminosityBlock. More...
virtual void	endOfJob ()
	Called at end of job. More...
virtual Status	endOfLoop (const edm::EventSetup &, unsigned int iLoop)
	Called at end of loop. More...
virtual void	endRun (const edm::Run &run, const edm::EventSetup &setup)
	Called at run end - currently reading TkFittedLasBeam if an InpuTag is given for that. More...
virtual boost::shared_ptr < CSCGeometry >	produceCSC (const MuonGeometryRecord &iRecord)
	Produce the muon CSC geometry. More...
virtual boost::shared_ptr < DTGeometry >	produceDT (const MuonGeometryRecord &iRecord)
	Produce the muon DT geometry. More...
virtual boost::shared_ptr < TrackerGeometry >	produceTracker (const TrackerDigiGeometryRecord &iRecord)
	Produce the tracker geometry. More...
virtual void	startingNewLoop (unsigned int iLoop)
	Called at beginning of loop. More...
	~AlignmentProducer ()
	Destructor. More...
Public Member Functions inherited from edm::ESProducerLooper
	ESProducerLooper ()
virtual std::set < eventsetup::EventSetupRecordKey >	modifyingRecords () const
Public Member Functions inherited from edm::ESProducer
	ESProducer ()
virtual	~ESProducer ()
Public Member Functions inherited from edm::ESProxyFactoryProducer
	ESProxyFactoryProducer ()
virtual void	newInterval (const eventsetup::EventSetupRecordKey &iRecordType, const ValidityInterval &iInterval)
	overrides DataProxyProvider method More...
virtual	~ESProxyFactoryProducer ()
Public Member Functions inherited from edm::eventsetup::DataProxyProvider
	DataProxyProvider ()
const ComponentDescription &	description () const
bool	isUsingRecord (const EventSetupRecordKey &) const
const KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey) const
void	resetProxies (const EventSetupRecordKey &iRecordType)
void	resetProxiesIfTransient (const EventSetupRecordKey &iRecordType)
void	setAppendToDataLabel (const edm::ParameterSet &)
void	setDescription (const ComponentDescription &iDescription)
std::set< EventSetupRecordKey >	usingRecords () const
virtual	~DataProxyProvider ()
Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
const eventsetup::ComponentDescription &	descriptionForFinder () const
	EventSetupRecordIntervalFinder ()
std::set < eventsetup::EventSetupRecordKey >	findingForRecords () const
const ValidityInterval &	findIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)
void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)
virtual	~EventSetupRecordIntervalFinder ()
Public Member Functions inherited from edm::EDLooper
	EDLooper ()
	EDLooper (EDLooper const &)=delete
EDLooper &	operator= (EDLooper const &)=delete
virtual	~EDLooper ()
Public Member Functions inherited from edm::EDLooperBase
virtual void	attachTo (ActivityRegistry &)
	Override this method if you need to monitor the state of the processing. More...
virtual void	beginOfJob ()
void	copyInfo (ScheduleInfo const &)
void	doBeginLuminosityBlock (LuminosityBlockPrincipal &, EventSetup const &, ProcessContext *)
void	doBeginRun (RunPrincipal &, EventSetup const &, ProcessContext *)
Status	doDuringLoop (EventPrincipal &eventPrincipal, EventSetup const &es, ProcessingController &, StreamContext *)
void	doEndLuminosityBlock (LuminosityBlockPrincipal &, EventSetup const &, ProcessContext *)
Status	doEndOfLoop (EventSetup const &es)
void	doEndRun (RunPrincipal &, EventSetup const &, ProcessContext *)
void	doStartingNewLoop ()
	EDLooperBase ()
	EDLooperBase (EDLooperBase const &)=delete
EDLooperBase &	operator= (EDLooperBase const &)=delete
void	prepareForNextLoop (eventsetup::EventSetupProvider *esp)
void	setActionTable (ExceptionToActionTable const *actionTable)
void	setModuleChanger (ModuleChanger const *)
virtual	~EDLooperBase ()

Private Member Functions
void	addSurveyInfo_ (Alignable *)
	Add survey info to an alignable. More...
template<class G , class Rcd , class ErrRcd >
void	applyDB (G *geometry, const edm::EventSetup &iSetup, const AlignTransform &globalPosition) const
template<class G , class DeformationRcd >
void	applyDB (G *geometry, const edm::EventSetup &iSetup) const
	Apply DB constants for surface deformations. More...
void	createGeometries_ (const edm::EventSetup &)
	Create tracker and muon geometries. More...
RunRanges	makeNonOverlappingRunRanges (const edm::VParameterSet &RunRangeSelectionVPSet)
void	readInSurveyRcds (const edm::EventSetup &)
	read in survey records More...
void	simpleMisalignment_ (const Alignables &alivec, const std::string &selection, float shift, float rot, bool local)
	Apply random shifts and rotations to selected alignables, according to configuration. More...
void	writeDB (Alignments *alignments, const std::string &alignRcd, AlignmentErrorsExtended *alignmentErrors, const std::string &errRcd, const AlignTransform *globalCoordinates, cond::Time_t time) const
void	writeDB (AlignmentSurfaceDeformations *alignmentSurfaceDeformations, const std::string &surfaceDeformationRcd, cond::Time_t time) const
void	writeForRunRange (cond::Time_t time)

Private Attributes
const bool	applyDbAlignment_
const edm::InputTag	beamSpotTag_
const bool	checkDbAlignmentValidity_
const edm::InputTag	clusterValueMapTag_
const bool	doMisalignmentScenario_
const bool	doMuon_
const bool	doTracker_
const Alignments *	globalPositions_
	GlobalPositions that might be read from DB, NULL otherwise. More...
int	nevent_
const bool	saveApeToDB_
const bool	saveDeformationsToDB_
const bool	saveToDB_
const int	stNFixAlignables_
const double	stRandomRotation_
const double	stRandomShift_
AlignableExtras *	theAlignableExtras
AlignableMuon *	theAlignableMuon
AlignableTracker *	theAlignableTracker
AlignmentAlgorithmBase *	theAlignmentAlgo
AlignmentParameterStore *	theAlignmentParameterStore
std::vector < IntegratedCalibrationBase * >	theCalibrations
const unsigned int	theMaxLoops
std::vector < AlignmentMonitorBase * >	theMonitors
boost::shared_ptr< CSCGeometry >	theMuonCSC
boost::shared_ptr< DTGeometry >	theMuonDT
edm::ParameterSet	theParameterSet
const SurveyErrors *	theSurveyErrors
unsigned int	theSurveyIndex
const Alignments *	theSurveyValues
boost::shared_ptr < TrackerGeometry >	theTracker
const edm::InputTag	tjTkAssociationMapTag_
const edm::InputTag	tkLasBeamTag_
const bool	useExtras_
const bool	useSurvey_
edm::ESWatcher < CSCSurveyErrorExtendedRcd >	watchCSCSurveyErrRcd_
edm::ESWatcher< CSCSurveyRcd >	watchCSCSurveyRcd_
edm::ESWatcher < DTSurveyErrorExtendedRcd >	watchDTSurveyErrRcd_
edm::ESWatcher< DTSurveyRcd >	watchDTSurveyRcd_
edm::ESWatcher < TrackerSurveyErrorExtendedRcd >	watchTkSurveyErrRcd_
edm::ESWatcher< TrackerSurveyRcd >	watchTkSurveyRcd_

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)
Protected Member Functions inherited from edm::ESProducerLooper
virtual void	registerFactoryWithKey (const eventsetup::EventSetupRecordKey &iRecord, std::auto_ptr< eventsetup::ProxyFactoryBase > &iFactory, const std::string &iLabel=std::string())
void	setIntervalFor (const eventsetup::EventSetupRecordKey &iKey, const IOVSyncValue &iTime, ValidityInterval &oInterval)
Protected Member Functions inherited from edm::ESProducer
template<typename T >
void	setWhatProduced (T *iThis, const es::Label &iLabel=es::Label())
template<typename T >
void	setWhatProduced (T *iThis, const char *iLabel)
template<typename T >
void	setWhatProduced (T *iThis, const std::string &iLabel)
template<typename T , typename TDecorator >
void	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel=es::Label())
template<typename T , typename TReturn , typename TRecord >
void	setWhatProduced (T *iThis, TReturn(T::*iMethod)(const TRecord &), const es::Label &iLabel=es::Label())
template<typename T , typename TReturn , typename TRecord , typename TArg >
void	setWhatProduced (T *iThis, TReturn(T::*iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel=es::Label())
Protected Member Functions inherited from edm::ESProxyFactoryProducer
template<class TFactory >
void	registerFactory (std::auto_ptr< TFactory > iFactory, const std::string &iLabel=std::string())
virtual void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList)
	override DataProxyProvider method More...
Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
void	eraseAll (const EventSetupRecordKey &iRecordKey)
	deletes all the Proxies in aStream More...
void	invalidateProxies (const EventSetupRecordKey &iRecordKey)
template<class T >
void	usingRecord ()
void	usingRecordWithKey (const EventSetupRecordKey &)
Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void	findingRecord ()
void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)
Protected Member Functions inherited from edm::EDLooperBase
ModuleChanger const *	moduleChanger () const
	This only returns a non-zero value during the call to endOfLoop. More...
ScheduleInfo const *	scheduleInfo () const
	This returns a non-zero value after the constructor has been called. More...

Detailed Description

Package : Alignment/CommonAlignmentProducer Description : calls alignment algorithms

Author

: Frederic Ronga Revision :

Revision:

1.27

last update:

Date:

2012/06/13 16:23:30

by :

Author:

yana

Definition at line 56 of file AlignmentProducer.h.

Member Typedef Documentation

typedef std::vector<Alignable*> AlignmentProducer::Alignables

Definition at line 60 of file AlignmentProducer.h.

typedef std::pair<const Trajectory*, const reco::Track*> AlignmentProducer::ConstTrajTrackPair

Definition at line 61 of file AlignmentProducer.h.

typedef std::vector<ConstTrajTrackPair> AlignmentProducer::ConstTrajTrackPairCollection

Definition at line 62 of file AlignmentProducer.h.

typedef AlignmentAlgorithmBase::RunNumber AlignmentProducer::RunNumber

Definition at line 64 of file AlignmentProducer.h.

typedef AlignmentAlgorithmBase::RunRange AlignmentProducer::RunRange

Definition at line 65 of file AlignmentProducer.h.

typedef std::vector<RunRange> AlignmentProducer::RunRanges

Definition at line 66 of file AlignmentProducer.h.

Constructor & Destructor Documentation

AlignmentProducer::AlignmentProducer

(

const edm::ParameterSet &

iConfig

)

Constructor.

Definition at line 77 of file AlignmentProducer.cc.

References edm::ParameterSet::addUntrackedParameter(), SurfaceDeformationFactory::create(), doMuon_, doTracker_, Exception, reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mergeVDriftHistosByStation::name, produceCSC(), produceDT(), produceTracker(), edm::ESProducer::setWhatProduced(), AlCaHLTBitMon_QueryRunRegistry::string, theAlignmentAlgo, theCalibrations, and theMonitors.

                                                                   :
  theAlignmentAlgo(0), theAlignmentParameterStore(0),
  theAlignableExtras(0), theAlignableTracker(0), theAlignableMuon(0), 
  globalPositions_(0),
  nevent_(0), theParameterSet(iConfig),
  theMaxLoops( iConfig.getUntrackedParameter<unsigned int>("maxLoops") ),
  stNFixAlignables_(iConfig.getParameter<int>("nFixAlignables") ),
  stRandomShift_(iConfig.getParameter<double>("randomShift")),
  stRandomRotation_(iConfig.getParameter<double>("randomRotation")),
  applyDbAlignment_( iConfig.getUntrackedParameter<bool>("applyDbAlignment")),
  checkDbAlignmentValidity_( iConfig.getUntrackedParameter<bool>("checkDbAlignmentValidity")),
  doMisalignmentScenario_(iConfig.getParameter<bool>("doMisalignmentScenario")),
  saveToDB_(iConfig.getParameter<bool>("saveToDB")),
  saveApeToDB_(iConfig.getParameter<bool>("saveApeToDB")),
  saveDeformationsToDB_(iConfig.getParameter<bool>("saveDeformationsToDB")),
  doTracker_( iConfig.getUntrackedParameter<bool>("doTracker") ),
  doMuon_( iConfig.getUntrackedParameter<bool>("doMuon") ),
  useExtras_( iConfig.getUntrackedParameter<bool>("useExtras") ),
  useSurvey_( iConfig.getParameter<bool>("useSurvey") ),
  tjTkAssociationMapTag_(iConfig.getParameter<edm::InputTag>("tjTkAssociationMapTag")),
  beamSpotTag_(iConfig.getParameter<edm::InputTag>("beamSpotTag")),
  tkLasBeamTag_(iConfig.getParameter<edm::InputTag>("tkLasBeamTag")),
  clusterValueMapTag_(iConfig.getParameter<edm::InputTag>("hitPrescaleMapTag"))
{
  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);
  }

  // Create the alignment algorithm
  edm::ParameterSet algoConfig = iConfig.getParameter<edm::ParameterSet>( "algoConfig" );
  edm::VParameterSet iovSelection = iConfig.getParameter<edm::VParameterSet>( "RunRangeSelection" );
  algoConfig.addUntrackedParameter<edm::VParameterSet>( "RunRangeSelection", iovSelection );
  std::string algoName = algoConfig.getParameter<std::string>( "algoName" );
  theAlignmentAlgo = AlignmentAlgorithmPluginFactory::get( )->create( algoName, algoConfig  );

  // Check if found
  if ( !theAlignmentAlgo )
    throw cms::Exception("BadConfig") << "Couldn't find algorithm called " << algoName;

  // Now create monitors:
  edm::ParameterSet monitorConfig = iConfig.getParameter<edm::ParameterSet>( "monitorConfig" );
  std::vector<std::string> monitors = monitorConfig.getUntrackedParameter<std::vector<std::string> >( "monitors" );
  for (std::vector<std::string>::const_iterator miter = monitors.begin();  miter != monitors.end();  ++miter) {
    AlignmentMonitorBase* newMonitor = AlignmentMonitorPluginFactory::get()->create(*miter, monitorConfig.getUntrackedParameter<edm::ParameterSet>(*miter));

    if (!newMonitor) throw cms::Exception("BadConfig") << "Couldn't find monitor named " << *miter;

    theMonitors.push_back(newMonitor);
  }

  // Finally create integrated calibrations:
  edm::VParameterSet calibrations = iConfig.getParameter<edm::VParameterSet>("calibrations");
  for (auto iCalib = calibrations.begin(); iCalib != calibrations.end(); ++iCalib) {
    const std::string name(iCalib->getParameter<std::string>("calibrationName"));
    theCalibrations.push_back(IntegratedCalibrationPluginFactory::get()->create(name, *iCalib));
    // exception comes from line before: if (!theCalibrations.back()) throw cms::Exception(..) << ..;
  }

}

AlignmentProducer::~AlignmentProducer

(

)

Destructor.

Definition at line 147 of file AlignmentProducer.cc.

References globalPositions_, theAlignableExtras, theAlignableMuon, theAlignableTracker, theAlignmentAlgo, theAlignmentParameterStore, and theCalibrations.

{
  delete theAlignmentAlgo;

  // Delete monitors as well??

  for (auto iCal = theCalibrations.begin(); iCal != theCalibrations.end(); ++iCal) {
    delete *iCal; // delete integrated calibration pointed to by (*iCal)
  }

  delete theAlignmentParameterStore;
  delete theAlignableExtras;
  delete theAlignableTracker;
  delete theAlignableMuon;

  delete globalPositions_;
}

Member Function Documentation

void AlignmentProducer::addSurveyInfo_ ( Alignable *  ali )

private

Add survey info to an alignable.

Definition at line 665 of file AlignmentProducer.cc.

References Alignable::alignableObjectId(), AlCaHLTBitMon_QueryRunRegistry::comp, Alignable::components(), relativeConstraints::error, Exception, i, Alignable::id(), AlignableSurface::length(), Alignments::m_align, SurveyErrors::m_surveyErrors, SurveyError::matrix(), SurveyError::rawId(), makeMuonMisalignmentScenario::rot, AlignableSurface::setLength(), Alignable::setSurvey(), AlignableSurface::setWidth(), SurveyError::structureType(), Alignable::surface(), theSurveyErrors, theSurveyIndex, theSurveyValues, and AlignableSurface::width().

Referenced by readInSurveyRcds().

{
  const std::vector<Alignable*>& comp = ali->components();

  unsigned int nComp = comp.size();

  for (unsigned int i = 0; i < nComp; ++i) addSurveyInfo_(comp[i]);

  const SurveyError& error = theSurveyErrors->m_surveyErrors[theSurveyIndex];

  if ( ali->id() != error.rawId() ||
       ali->alignableObjectId() != error.structureType() )
  {
    throw cms::Exception("DatabaseError")
      << "Error reading survey info from DB. Mismatched id!";
  }

  const CLHEP::Hep3Vector&  pos = theSurveyValues->m_align[theSurveyIndex].translation();
  const CLHEP::HepRotation& rot = theSurveyValues->m_align[theSurveyIndex].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() ) );

  ++theSurveyIndex;
}

template<class G , class Rcd , class ErrRcd >

void AlignmentProducer::applyDB ( G *  geometry, const edm::EventSetup &  iSetup, const AlignTransform &  globalPosition  ) const

private

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

Definition at line 764 of file AlignmentProducer.cc.

References GeometryAligner::applyAlignments(), edm::IOVSyncValue::beginOfTime(), checkDbAlignmentValidity_, edm::IOVSyncValue::endOfTime(), edm::IOVSyncValue::eventID(), Exception, edm::ValidityInterval::first(), plotBeamSpotDB::first, callgraph::G, geometry, edm::EventSetup::get(), edm::ValidityInterval::last(), prof2calltree::last, record, and edm::EventID::run().

{
  // '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=AlignmentProducer::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);
}

template<class G , class DeformationRcd >

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

private

Apply DB constants for surface deformations.

Definition at line 805 of file AlignmentProducer.cc.

References GeometryAligner::attachSurfaceDeformations(), edm::IOVSyncValue::beginOfTime(), checkDbAlignmentValidity_, edm::IOVSyncValue::endOfTime(), edm::IOVSyncValue::eventID(), Exception, edm::ValidityInterval::first(), plotBeamSpotDB::first, callgraph::G, geometry, edm::EventSetup::get(), edm::ValidityInterval::last(), prof2calltree::last, record, and edm::EventID::run().

{
  // '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=AlignmentProducer::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));
}

void AlignmentProducer::beginLuminosityBlock ( const edm::LuminosityBlock &  lumiBlock, const edm::EventSetup &  setup  )

virtual

Called at lumi block start, calling algorithm's beginLuminosityBlock.

Reimplemented from edm::EDLooperBase.

Definition at line 557 of file AlignmentProducer.cc.

References AlignmentAlgorithmBase::beginLuminosityBlock(), and theAlignmentAlgo.

{
  theAlignmentAlgo->beginLuminosityBlock(setup); // do not forward edm::LuminosityBlock
}

void AlignmentProducer::beginOfJob ( const edm::EventSetup &  iSetup )

virtual

Called at beginning of job.

Reimplemented from edm::EDLooperBase.

Definition at line 196 of file AlignmentProducer.cc.

References AlignmentAlgorithmBase::addCalibrations(), align::AlignableMuon, AlignmentParameterStore_cfi::AlignmentParameterStore, applyDbAlignment_, MuonScenarioBuilder::applyScenario(), TrackerScenarioBuilder::applyScenario(), createGeometries_(), align::DetectorGlobalPosition(), doMisalignmentScenario_, doMuon_, doTracker_, Exception, edm::EventSetup::get(), edm::ParameterSet::getParameter(), globalPositions_, AlignmentAlgorithmBase::initialize(), DetId::Muon, edm::ESHandle< class >::product(), simpleMisalignment_(), stNFixAlignables_, stRandomRotation_, stRandomShift_, AlCaHLTBitMon_QueryRunRegistry::string, theAlignableExtras, theAlignableMuon, theAlignableTracker, theAlignmentAlgo, theAlignmentParameterStore, theCalibrations, theMonitors, theMuonCSC, theMuonDT, theParameterSet, theTracker, DetId::Tracker, and useExtras_.

{
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::beginOfJob";

  //Retrieve tracker topology from geometry
  edm::ESHandle<TrackerTopology> tTopoHandle;
  iSetup.get<IdealGeometryRecord>().get(tTopoHandle);
  const TrackerTopology* const tTopo = tTopoHandle.product();

  // Create the geometries from the ideal geometries (first time only)
  this->createGeometries_( iSetup );
  
  // Retrieve and apply alignments, if requested (requires DB setup)
  if ( applyDbAlignment_ ) {
    // we need GlobalPositionRcd - and have to keep track for later removal
    // before writing again to DB...
    edm::ESHandle<Alignments> globalPositionRcd;
    iSetup.get<GlobalPositionRcd>().get(globalPositionRcd);
    globalPositions_ = new Alignments(*globalPositionRcd);

    if ( doTracker_ ) {     // apply to tracker
      this->applyDB<TrackerGeometry,TrackerAlignmentRcd,TrackerAlignmentErrorExtendedRcd>
    (&(*theTracker), iSetup,  
     align::DetectorGlobalPosition(*globalPositions_, DetId(DetId::Tracker)));
      this->applyDB<TrackerGeometry,TrackerSurfaceDeformationRcd>(&(*theTracker), iSetup);
    }
    
    if ( doMuon_ ) { // apply to tracker
      this->applyDB<DTGeometry,DTAlignmentRcd,DTAlignmentErrorExtendedRcd>
    (&(*theMuonDT), iSetup,
     align::DetectorGlobalPosition(*globalPositions_, DetId(DetId::Muon)));
      this->applyDB<CSCGeometry,CSCAlignmentRcd,CSCAlignmentErrorExtendedRcd>
    (&(*theMuonCSC), iSetup,
     align::DetectorGlobalPosition(*globalPositions_, DetId(DetId::Muon)));
    }
  }

  // Create alignable tracker and muon 
  if (doTracker_) {
    theAlignableTracker = new AlignableTracker( &(*theTracker), tTopo );
  }

  if (doMuon_) {
     theAlignableMuon = new AlignableMuon( &(*theMuonDT), &(*theMuonCSC) );
  }

  if (useExtras_) {
    theAlignableExtras = new AlignableExtras();
  }

  // Create alignment parameter builder
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::beginOfJob" 
                            << "Creating AlignmentParameterBuilder";
  edm::ParameterSet aliParamBuildCfg = 
    theParameterSet.getParameter<edm::ParameterSet>("ParameterBuilder");
  AlignmentParameterBuilder alignmentParameterBuilder(theAlignableTracker,
                                                      theAlignableMuon,
                                                      theAlignableExtras,
                              aliParamBuildCfg );
  // Fix alignables if requested
  if (stNFixAlignables_>0) alignmentParameterBuilder.fixAlignables(stNFixAlignables_);

  // Get list of alignables
  Alignables theAlignables = alignmentParameterBuilder.alignables();
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::beginOfJob" 
                            << "got " << theAlignables.size() << " alignables";

  // Create AlignmentParameterStore 
  edm::ParameterSet aliParamStoreCfg = 
    theParameterSet.getParameter<edm::ParameterSet>("ParameterStore");
  theAlignmentParameterStore = new AlignmentParameterStore(theAlignables, aliParamStoreCfg);
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::beginOfJob" 
                            << "AlignmentParameterStore created!";

  // 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=AlignmentProducer::beginOfJob" 
                              << "Applying misalignment scenario to "
                              << (doTracker_ ? "tracker" : "")
                              << (doMuon_    ? (doTracker_ ? " and muon" : "muon") : ".");
    edm::ParameterSet scenarioConfig 
      = theParameterSet.getParameter<edm::ParameterSet>( "MisalignmentScenario" );
    if (doTracker_) {
      TrackerScenarioBuilder scenarioBuilder( theAlignableTracker );
      scenarioBuilder.applyScenario( scenarioConfig );
    }
    if (doMuon_) {
      MuonScenarioBuilder muonScenarioBuilder( theAlignableMuon );
      muonScenarioBuilder.applyScenario( scenarioConfig );
    }
  } else {
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::beginOfJob" 
                              << "NOT applying misalignment scenario!";
  }

  // Apply simple misalignment
  const std::string sParSel(theParameterSet.getParameter<std::string>("parameterSelectorSimple"));
  this->simpleMisalignment_(theAlignables, sParSel, stRandomShift_, stRandomRotation_, true);

  // Initialize alignment algorithm and integrated calibration and pass the latter to algorithm
  theAlignmentAlgo->initialize( iSetup, 
                theAlignableTracker, theAlignableMuon, theAlignableExtras,
                theAlignmentParameterStore );
  for (auto iCal = theCalibrations.begin(); iCal != theCalibrations.end(); ++iCal) {
    (*iCal)->beginOfJob(theAlignableTracker, theAlignableMuon, theAlignableExtras);
  }
  // Not all algorithms support calibrations - so do not pass empty vector
  // and throw if non-empty and not supported:
  if (!theCalibrations.empty() && !theAlignmentAlgo->addCalibrations(theCalibrations)) {
    throw cms::Exception("BadConfig") << "[AlignmentProducer::beginOfJob]\n"
                      << "Configured " << theCalibrations.size() << " calibration(s) "
                      << "for algorithm not supporting it.";
  }

  for (std::vector<AlignmentMonitorBase*>::const_iterator monitor = theMonitors.begin();
       monitor != theMonitors.end();  ++monitor) {
     (*monitor)->beginOfJob(theAlignableTracker, theAlignableMuon, theAlignmentParameterStore);
  }
}

void AlignmentProducer::beginRun ( const edm::Run &  run, const edm::EventSetup &  setup  )

virtual

Called at run start and calling algorithms beginRun.

Reimplemented from edm::EDLooperBase.

Definition at line 532 of file AlignmentProducer.cc.

References AlignmentAlgorithmBase::beginRun(), and theAlignmentAlgo.

{
  theAlignmentAlgo->beginRun(setup); // do not forward edm::Run...
}

void AlignmentProducer::createGeometries_ ( const edm::EventSetup &  iSetup )

private

Create tracker and muon geometries.

Definition at line 641 of file AlignmentProducer.cc.

References TrackerGeomBuilderFromGeometricDet::build(), CSCGeometryBuilderFromDDD::build(), DTGeometryBuilderFromDDD::build(), doMuon_, doTracker_, edm::EventSetup::get(), theMuonCSC, theMuonDT, theParameterSet, and theTracker.

Referenced by beginOfJob().

{
   edm::ESTransientHandle<DDCompactView> cpv;
   iSetup.get<IdealGeometryRecord>().get( cpv );

   if (doTracker_) {
     edm::ESHandle<GeometricDet> geometricDet;
     iSetup.get<IdealGeometryRecord>().get( geometricDet );
     TrackerGeomBuilderFromGeometricDet trackerBuilder;
     theTracker = boost::shared_ptr<TrackerGeometry>( trackerBuilder.build(&(*geometricDet), theParameterSet ));
   }

   if (doMuon_) {
     edm::ESHandle<MuonDDDConstants> mdc;
     iSetup.get<MuonNumberingRecord>().get(mdc);
     DTGeometryBuilderFromDDD DTGeometryBuilder;
     CSCGeometryBuilderFromDDD CSCGeometryBuilder;
     theMuonDT = boost::shared_ptr<DTGeometry>(new DTGeometry );
     DTGeometryBuilder.build( theMuonDT, &(*cpv), *mdc);
     theMuonCSC = boost::shared_ptr<CSCGeometry>( new CSCGeometry );
     CSCGeometryBuilder.build( theMuonCSC, &(*cpv), *mdc );
   }
}

edm::EDLooper::Status AlignmentProducer::duringLoop ( const edm::Event &  event, const edm::EventSetup &  setup  )

virtual

Called at each event.

Implements edm::EDLooper.

Definition at line 470 of file AlignmentProducer.cc.

References SiPixelRawToDigiRegional_cfi::beamSpot, beamSpotTag_, clusterValueMapTag_, edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, edm::InputTag::encode(), ZMuMuCategoriesSequences_cff::eventInfo, edm::Event::getByLabel(), i, edm::EventBase::id(), AlignableExtras::initializeBeamSpot(), edm::EDLooperBase::kContinue, nevent_, readInSurveyRcds(), AlignmentAlgorithmBase::run(), theAlignableExtras, theAlignmentAlgo, theMonitors, and tjTkAssociationMapTag_.

{
  ++nevent_;

  // reading in survey records
  this->readInSurveyRcds(setup);
    
  // Printout event number
  for ( int i=10; i<10000000; i*=10 )
    if ( nevent_<10*i && (nevent_%i)==0 )
      edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::duringLoop" 
                                << "Events processed: " << nevent_;
  
  // Retrieve trajectories and tracks from the event
  // -> merely skip if collection is empty
  edm::Handle<TrajTrackAssociationCollection> m_TrajTracksMap;
  if (event.getByLabel(tjTkAssociationMapTag_, m_TrajTracksMap)) {
    
    // Form pairs of trajectories and tracks
    ConstTrajTrackPairCollection trajTracks;
    for ( TrajTrackAssociationCollection::const_iterator iPair = m_TrajTracksMap->begin();
          iPair != m_TrajTracksMap->end(); ++iPair) {
      trajTracks.push_back( ConstTrajTrackPair( &(*(*iPair).key), &(*(*iPair).val) ) );
    }
    edm::Handle<reco::BeamSpot> beamSpot;
    event.getByLabel(beamSpotTag_, beamSpot);

    if (nevent_==1 && theAlignableExtras) {
      edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::duringLoop"
                << "initializing AlignableBeamSpot" << std::endl;
      theAlignableExtras->initializeBeamSpot(beamSpot->x0(), beamSpot->y0(), beamSpot->z0(),
                         beamSpot->dxdz(), beamSpot->dydz());
    }

    // Run the alignment algorithm with its input
    const AliClusterValueMap *clusterValueMapPtr = 0;
    if(clusterValueMapTag_.encode().size()){//check that the input tag is not empty
      edm::Handle<AliClusterValueMap> clusterValueMap;
      event.getByLabel(clusterValueMapTag_, clusterValueMap);
      clusterValueMapPtr = &(*clusterValueMap);
    }

    const AlignmentAlgorithmBase::EventInfo eventInfo(event.id(), trajTracks, *beamSpot,
                              clusterValueMapPtr);
    theAlignmentAlgo->run(setup, eventInfo);


    for (std::vector<AlignmentMonitorBase*>::const_iterator monitor = theMonitors.begin();
     monitor != theMonitors.end();  ++monitor) {
      (*monitor)->duringLoop(event, setup, trajTracks); // forward eventInfo?
    }
  } else {
    edm::LogError("Alignment") << "@SUB=AlignmentProducer::duringLoop" 
                   << "No track collection found: skipping event";
  }
  

  return kContinue;
}

void AlignmentProducer::endLuminosityBlock ( const edm::LuminosityBlock &  lumiBlock, const edm::EventSetup &  setup  )

virtual

Called at lumi block end, calling algorithm's endLuminosityBlock.

Reimplemented from edm::EDLooperBase.

Definition at line 564 of file AlignmentProducer.cc.

References AlignmentAlgorithmBase::endLuminosityBlock(), and theAlignmentAlgo.

{
  theAlignmentAlgo->endLuminosityBlock(setup); // do not forward edm::LuminosityBlock
}

void AlignmentProducer::endOfJob ( )

virtual

Called at end of job.

Reimplemented from edm::EDLooperBase.

Definition at line 319 of file AlignmentProducer.cc.

References AlignableExtras::beamSpot(), edm::ParameterSet::getParameter(), makeNonOverlappingRunRanges(), nevent_, AlignmentParameters::parameters(), cond::runnumber, saveApeToDB_, saveDeformationsToDB_, saveToDB_, AlignmentAlgorithmBase::setParametersForRunRange(), theAlignableExtras, theAlignmentAlgo, theCalibrations, theMonitors, theParameterSet, cond::timeTypeSpecs, and writeForRunRange().

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

  for (std::vector<AlignmentMonitorBase*>::const_iterator monitor = theMonitors.begin();  monitor != theMonitors.end();  ++monitor) {
     (*monitor)->endOfJob();
  }

  if (0 == nevent_) {
    edm::LogError("Alignment") << "@SUB=AlignmentProducer::endOfJob" << "Did not process any "
                               << "events in last loop, do not dare to store to DB.";
  } else {
    
    // Expand run ranges and make them unique
    edm::VParameterSet runRangeSelectionVPSet(theParameterSet.getParameter<edm::VParameterSet>("RunRangeSelection"));
    RunRanges uniqueRunRanges(this->makeNonOverlappingRunRanges(runRangeSelectionVPSet));
    if (uniqueRunRanges.empty()) { // create dummy IOV
      const RunRange runRange(cond::timeTypeSpecs[cond::runnumber].beginValue,
                  cond::timeTypeSpecs[cond::runnumber].endValue);
      uniqueRunRanges.push_back(runRange);
    }

    std::vector<AlgebraicVector> beamSpotParameters;

    for (RunRanges::const_iterator iRunRange = uniqueRunRanges.begin();
     iRunRange != uniqueRunRanges.end();
     ++iRunRange) {

      theAlignmentAlgo->setParametersForRunRange(*iRunRange);

      // Save alignments to database
      if (saveToDB_ || saveApeToDB_ || saveDeformationsToDB_)
        this->writeForRunRange((*iRunRange).first);
      
      // Deal with extra alignables, e.g. beam spot
      if (theAlignableExtras) {
    Alignables &alis = theAlignableExtras->beamSpot();
    if (!alis.empty()) {
      BeamSpotAlignmentParameters *beamSpotAliPars = dynamic_cast<BeamSpotAlignmentParameters*>(alis[0]->alignmentParameters());
      beamSpotParameters.push_back(beamSpotAliPars->parameters());
    }
      }
    }
    
    if (theAlignableExtras) {
      std::ostringstream bsOutput;
      
      std::vector<AlgebraicVector>::const_iterator itPar = beamSpotParameters.begin();
      for (RunRanges::const_iterator iRunRange = uniqueRunRanges.begin();
       iRunRange != uniqueRunRanges.end();
       ++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=AlignmentProducer::endOfJob"
                << "Parameters for alignable beamspot:\n"
                << bsOutput.str();
    }

    for (auto iCal = theCalibrations.begin(); iCal != theCalibrations.end(); ++iCal) {
      (*iCal)->endOfJob();
    }

  }
}

edm::EDLooper::Status AlignmentProducer::endOfLoop ( const edm::EventSetup &  iSetup, unsigned int  iLoop  )

virtual

Called at end of loop.

Implements edm::EDLooperBase.

Definition at line 435 of file AlignmentProducer.cc.

References edm::EDLooperBase::kContinue, edm::EDLooperBase::kStop, nevent_, AlignmentAlgorithmBase::terminate(), theAlignmentAlgo, theCalibrations, theMaxLoops, and theMonitors.

{

  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.";

  theAlignmentAlgo->terminate(iSetup);
  // FIXME: Should this be done in algorithm::terminate(const edm::EventSetup& iSetup)??
  for (auto iCal = theCalibrations.begin(); iCal != theCalibrations.end(); ++iCal) {
    (*iCal)->endOfLoop();
  }

  for (std::vector<AlignmentMonitorBase*>::const_iterator monitor = theMonitors.begin();  monitor != theMonitors.end();  ++monitor) {
     (*monitor)->endOfLoop(iSetup);
  }

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

void AlignmentProducer::endRun ( const edm::Run &  run, const edm::EventSetup &  setup  )

virtual

Called at run end - currently reading TkFittedLasBeam if an InpuTag is given for that.

Reimplemented from edm::EDLooperBase.

Definition at line 538 of file AlignmentProducer.cc.

References edm::InputTag::encode(), AlignmentAlgorithmBase::endRun(), edm::Run::getByLabel(), edm::RunBase::id(), theAlignmentAlgo, and tkLasBeamTag_.

{
  // call with or without las beam info...
  typedef AlignmentAlgorithmBase::EndRunInfo EndRunInfo;
  if (tkLasBeamTag_.encode().size()) { // non-empty InputTag
    edm::Handle<TkFittedLasBeamCollection> lasBeams;
    edm::Handle<TsosVectorCollection> tsoses;
    run.getByLabel(tkLasBeamTag_, lasBeams);
    run.getByLabel(tkLasBeamTag_, tsoses);
    
    theAlignmentAlgo->endRun(EndRunInfo(run.id(), &(*lasBeams), &(*tsoses)), setup);
  } else {
    edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::endRun"
                  << "No Tk LAS beams to forward to algorithm.";
    theAlignmentAlgo->endRun(EndRunInfo(run.id(), 0, 0), setup);
  }
}

AlignmentProducer::RunRanges AlignmentProducer::makeNonOverlappingRunRanges ( const edm::VParameterSet &  RunRangeSelectionVPSet )

private

Definition at line 957 of file AlignmentProducer.cc.

References cond::TimeTypeSpecs::beginValue, cond::TimeTypeSpecs::endValue, plotBeamSpotDB::first, i, cond::runnumber, groupFilesInBlocks::temp, cond::timeTypeSpecs, and edm::tokenize().

Referenced by endOfJob().

{
  static bool oldRunRangeSelectionWarning = false;

  const RunNumber beginValue = cond::timeTypeSpecs[cond::runnumber].beginValue;
  const RunNumber endValue = cond::timeTypeSpecs[cond::runnumber].endValue;
  
  RunRanges uniqueRunRanges;
  if (!RunRangeSelectionVPSet.empty()) {

    std::map<RunNumber,RunNumber> uniqueFirstRunNumbers;
    
    for (std::vector<edm::ParameterSet>::const_iterator ipset = RunRangeSelectionVPSet.begin();
     ipset != RunRangeSelectionVPSet.end();
     ++ipset) {
      const std::vector<std::string> RunRangeStrings = (*ipset).getParameter<std::vector<std::string> >("RunRanges");
      for (std::vector<std::string>::const_iterator irange = RunRangeStrings.begin();
       irange != RunRangeStrings.end();
       ++irange) {
    
    if ((*irange).find(':')==std::string::npos) {
      
      RunNumber first = beginValue;
      long int temp = strtol((*irange).c_str(), 0, 0);
      if (temp!=-1) first = temp;
      uniqueFirstRunNumbers[first] = first;
      
    } else {
      
      if (!oldRunRangeSelectionWarning) {
        edm::LogWarning("BadConfig") << "@SUB=AlignmentProducer::makeNonOverlappingRunRanges"
                     << "Config file contains old format for 'RunRangeSelection'. Only the start run\n"
                     << "number is used internally. The number of the last run is ignored and can be\n"
                     << "safely removed from the config file.\n";
        oldRunRangeSelectionWarning = true;
      }
      
      std::vector<std::string> tokens = edm::tokenize(*irange, ":");
      long int temp;
      RunNumber first = beginValue;
      temp = strtol(tokens[0].c_str(), 0, 0);
      if (temp!=-1) first = temp;
      uniqueFirstRunNumbers[first] = first;
    }
      }
    }

    for (std::map<RunNumber,RunNumber>::iterator iFirst = uniqueFirstRunNumbers.begin();
     iFirst!=uniqueFirstRunNumbers.end();
     ++iFirst) {
      uniqueRunRanges.push_back(std::pair<RunNumber,RunNumber>((*iFirst).first, endValue));
    }
    for (unsigned int i = 0;i<uniqueRunRanges.size()-1;++i) {
      uniqueRunRanges[i].second = uniqueRunRanges[i+1].first - 1;
    }
    
  } else {
        
    uniqueRunRanges.push_back(std::pair<RunNumber,RunNumber>(beginValue, endValue));
    
  }
  
  return uniqueRunRanges;
}

boost::shared_ptr< CSCGeometry > AlignmentProducer::produceCSC ( const MuonGeometryRecord &  iRecord )

virtual

Produce the muon CSC geometry.

Definition at line 187 of file AlignmentProducer.cc.

References theMuonCSC.

Referenced by AlignmentProducer().

{
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::produceCSC";
  return theMuonCSC;  
}

boost::shared_ptr< DTGeometry > AlignmentProducer::produceDT ( const MuonGeometryRecord &  iRecord )

virtual

Produce the muon DT geometry.

Definition at line 178 of file AlignmentProducer.cc.

References theMuonDT.

Referenced by AlignmentProducer().

{
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::produceDT";
  return theMuonDT;
}

boost::shared_ptr< TrackerGeometry > AlignmentProducer::produceTracker ( const TrackerDigiGeometryRecord &  iRecord )

virtual

Produce the tracker geometry.

Definition at line 169 of file AlignmentProducer.cc.

References theTracker.

Referenced by AlignmentProducer().

{
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::produceTracker";
  return theTracker;
}

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

private

read in survey records

Definition at line 698 of file AlignmentProducer.cc.

References addSurveyInfo_(), edm::ESWatcher< T >::check(), AlignableMuon::CSCEndcaps(), doMuon_, doTracker_, AlignableMuon::DTBarrel(), edm::EventSetup::get(), getDQMSummary::iter, theAlignableMuon, theAlignableTracker, theSurveyErrors, theSurveyIndex, theSurveyValues, useSurvey_, watchTkSurveyErrRcd_, and watchTkSurveyRcd_.

Referenced by duringLoop().

                                                                     {
    
  // Get Survey Rcds and add Survey Info
  if ( doTracker_ && useSurvey_ ){
    bool tkSurveyBool = watchTkSurveyRcd_.check(iSetup);
    bool tkSurveyErrBool = watchTkSurveyErrRcd_.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);
      
      theSurveyIndex  = 0;
      theSurveyValues = &*surveys;
      theSurveyErrors = &*surveyErrors;
      addSurveyInfo_(theAlignableTracker);
    }
  }
  
  if ( doMuon_ && useSurvey_) {
    bool DTSurveyBool = watchTkSurveyRcd_.check(iSetup);
    bool DTSurveyErrBool = watchTkSurveyErrRcd_.check(iSetup);
    bool CSCSurveyBool = watchTkSurveyRcd_.check(iSetup);
    bool CSCSurveyErrBool = watchTkSurveyErrRcd_.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);
      
      theSurveyIndex  = 0;
      theSurveyValues = &*dtSurveys;
      theSurveyErrors = &*dtSurveyErrors;
      std::vector<Alignable*> barrels = theAlignableMuon->DTBarrel();
      for (std::vector<Alignable*>::const_iterator iter = barrels.begin();  iter != barrels.end();  ++iter) {
    addSurveyInfo_(*iter);
      }
      
      theSurveyIndex  = 0;
      theSurveyValues = &*cscSurveys;
      theSurveyErrors = &*cscSurveyErrors;
      std::vector<Alignable*> endcaps = theAlignableMuon->CSCEndcaps();
      for (std::vector<Alignable*>::const_iterator iter = endcaps.begin();  iter != endcaps.end();  ++iter) {
    addSurveyInfo_(*iter);
      }
    }
  }

}

void AlignmentProducer::simpleMisalignment_ ( const Alignables &  alivec, const std::string &  selection, float  shift, float  rot, bool  local  )

private

Apply random shifts and rotations to selected alignables, according to configuration.

Definition at line 572 of file AlignmentProducer.cc.

References funct::abs(), Alignable::alignmentParameters(), AlignmentParameterSelector::convertParamSel(), RigidBodyAlignmentParameters::dalpha, RigidBodyAlignmentParameters::dbeta, RigidBodyAlignmentParameters::dgamma, RigidBodyAlignmentParameters::dx, RigidBodyAlignmentParameters::dy, RigidBodyAlignmentParameters::dz, Exception, Alignable::move(), RigidBodyAlignmentParameters::N_PARAM, convertSQLitetoXML_cfg::output, alignCSCRings::r, random, Alignable::rotateInGlobalFrame(), Alignable::rotateInLocalFrame(), indexGen::s2, AlignmentParameters::selector(), Alignable::surface(), AlignableSurface::toGlobal(), and align::toMatrix().

Referenced by beginOfJob().

{

  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(0,0); // no alignable needed here...
      const std::vector<char> cSel(aSelector.convertParamSel(selection));
      if (cSel.size() < RigidBodyAlignmentParameters::N_PARAM) {
    throw cms::Exception("BadConfig") 
      << "[AlignmentProducer::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 (std::vector<char>::const_iterator cIter = cSel.begin(); cIter != cSel.end(); ++cIter) {
        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 (std::vector<Alignable*>::const_iterator it = alivec.begin(); it != alivec.end(); ++it) {
      Alignable* ali=(*it);
      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=AlignmentProducer::simpleMisalignment_" << output.str();
}

void AlignmentProducer::startingNewLoop ( unsigned int  iLoop )

virtual

Called at beginning of loop.

Implements edm::EDLooperBase.

Definition at line 389 of file AlignmentProducer.cc.

References AlignableTracker::alignmentErrors(), AlignableTracker::alignments(), GeometryAligner::applyAlignments(), GeometryAligner::attachSurfaceDeformations(), AlignableMuon::cscAlignmentErrorsExtended(), AlignableMuon::cscAlignments(), doMuon_, doTracker_, AlignableMuon::dtAlignmentErrorsExtended(), AlignableMuon::dtAlignments(), nevent_, AlignmentAlgorithmBase::startNewLoop(), Alignable::surfaceDeformations(), theAlignableMuon, theAlignableTracker, theAlignmentAlgo, theCalibrations, and theMonitors.

{
  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::startingNewLoop" 
                            << "Starting loop number " << iLoop;

  nevent_ = 0;

  theAlignmentAlgo->startNewLoop();
  // FIXME: Should this be done in algorithm::startNewLoop()??
  for (auto iCal = theCalibrations.begin(); iCal != theCalibrations.end(); ++iCal) {
    (*iCal)->startNewLoop();
  }

  for (std::vector<AlignmentMonitorBase*>::const_iterator monitor = theMonitors.begin();  monitor != theMonitors.end();  ++monitor) {
     (*monitor)->startingNewLoop();
  }

  edm::LogInfo("Alignment") << "@SUB=AlignmentProducer::startingNewLoop" 
                            << "Now physically apply alignments to  geometry...";


  // Propagate changes to reconstruction geometry (from initialisation or iteration)
  GeometryAligner aligner;
  if ( doTracker_ ) {
    std::auto_ptr<Alignments> alignments(theAlignableTracker->alignments());
    std::auto_ptr<AlignmentErrorsExtended> alignmentErrors(theAlignableTracker->alignmentErrors());
    aligner.applyAlignments<TrackerGeometry>( &(*theTracker),&(*alignments),&(*alignmentErrors), AlignTransform() ); // don't apply global a second time!
    std::auto_ptr<AlignmentSurfaceDeformations> aliDeforms(theAlignableTracker->surfaceDeformations());
    aligner.attachSurfaceDeformations<TrackerGeometry>(&(*theTracker), &(*aliDeforms));

  }
  if ( doMuon_ ) {
    std::auto_ptr<Alignments>      dtAlignments(       theAlignableMuon->dtAlignments());
    std::auto_ptr<AlignmentErrorsExtended> dtAlignmentErrorsExtended(  theAlignableMuon->dtAlignmentErrorsExtended());
    std::auto_ptr<Alignments>      cscAlignments(      theAlignableMuon->cscAlignments());
    std::auto_ptr<AlignmentErrorsExtended> cscAlignmentErrorsExtended( theAlignableMuon->cscAlignmentErrorsExtended());

    aligner.applyAlignments<DTGeometry>( &(*theMuonDT), &(*dtAlignments), &(*dtAlignmentErrorsExtended), AlignTransform() ); // don't apply global a second time!
    aligner.applyAlignments<CSCGeometry>( &(*theMuonCSC), &(*cscAlignments), &(*cscAlignmentErrorsExtended), AlignTransform() ); // nope!
  }
}

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

private

Write alignment and/or errors to DB for record names (removes *globalCoordinates before writing if non-null...). Takes over ownership of alignments and alignmentErrrors.

Definition at line 879 of file AlignmentProducer.cc.

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

Referenced by writeForRunRange().

{
  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=AlignmentProducer::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!
  }
}

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

private

Write surface deformations (bows & kinks) to DB for given record name Takes over ownership of alignmentsurfaceDeformations.

Definition at line 935 of file AlignmentProducer.cc.

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

{
  // 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!
  }
}

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

private

Definition at line 834 of file AlignmentProducer.cc.

References AlignableTracker::alignmentErrors(), AlignableTracker::alignments(), AlignableMuon::cscAlignmentErrorsExtended(), AlignableMuon::cscAlignments(), align::DetectorGlobalPosition(), doMuon_, doTracker_, AlignableMuon::dtAlignmentErrorsExtended(), AlignableMuon::dtAlignments(), globalPositions_, DetId::Muon, saveDeformationsToDB_, Alignable::surfaceDeformations(), theAlignableMuon, theAlignableTracker, DetId::Tracker, and writeDB().

Referenced by endOfJob().

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

Member Data Documentation

const bool AlignmentProducer::applyDbAlignment_

private

Definition at line 182 of file AlignmentProducer.h.

Referenced by beginOfJob().

const edm::InputTag AlignmentProducer::beamSpotTag_

private

Definition at line 190 of file AlignmentProducer.h.

Referenced by duringLoop().

const bool AlignmentProducer::checkDbAlignmentValidity_

private

Definition at line 182 of file AlignmentProducer.h.

Referenced by applyDB().

const edm::InputTag AlignmentProducer::clusterValueMapTag_

private

Definition at line 192 of file AlignmentProducer.h.

Referenced by duringLoop().

const bool AlignmentProducer::doMisalignmentScenario_

private

Definition at line 183 of file AlignmentProducer.h.

Referenced by beginOfJob().

const bool AlignmentProducer::doMuon_

private

Definition at line 185 of file AlignmentProducer.h.

Referenced by AlignmentProducer(), beginOfJob(), createGeometries_(), readInSurveyRcds(), startingNewLoop(), and writeForRunRange().

const bool AlignmentProducer::doTracker_

private

Definition at line 185 of file AlignmentProducer.h.

Referenced by AlignmentProducer(), beginOfJob(), createGeometries_(), readInSurveyRcds(), startingNewLoop(), and writeForRunRange().

const Alignments* AlignmentProducer::globalPositions_

private

GlobalPositions that might be read from DB, NULL otherwise.

Definition at line 171 of file AlignmentProducer.h.

Referenced by beginOfJob(), writeForRunRange(), and ~AlignmentProducer().

int AlignmentProducer::nevent_

private

Definition at line 173 of file AlignmentProducer.h.

Referenced by duringLoop(), endOfJob(), endOfLoop(), and startingNewLoop().

const bool AlignmentProducer::saveApeToDB_

private

Definition at line 184 of file AlignmentProducer.h.

Referenced by endOfJob(), and writeDB().

const bool AlignmentProducer::saveDeformationsToDB_

private

Definition at line 184 of file AlignmentProducer.h.

Referenced by endOfJob(), writeDB(), and writeForRunRange().

const bool AlignmentProducer::saveToDB_

private

Definition at line 184 of file AlignmentProducer.h.

Referenced by endOfJob(), and writeDB().

const int AlignmentProducer::stNFixAlignables_

private

Definition at line 180 of file AlignmentProducer.h.

Referenced by beginOfJob().

const double AlignmentProducer::stRandomRotation_

private

Definition at line 181 of file AlignmentProducer.h.

Referenced by beginOfJob().

const double AlignmentProducer::stRandomShift_

private

Definition at line 181 of file AlignmentProducer.h.

Referenced by beginOfJob().

AlignableExtras* AlignmentProducer::theAlignableExtras

private

Definition at line 163 of file AlignmentProducer.h.

Referenced by beginOfJob(), duringLoop(), endOfJob(), and ~AlignmentProducer().

AlignableMuon* AlignmentProducer::theAlignableMuon

private

Definition at line 165 of file AlignmentProducer.h.

Referenced by beginOfJob(), readInSurveyRcds(), startingNewLoop(), writeForRunRange(), and ~AlignmentProducer().

AlignableTracker* AlignmentProducer::theAlignableTracker

private

Definition at line 164 of file AlignmentProducer.h.

Referenced by beginOfJob(), readInSurveyRcds(), startingNewLoop(), writeForRunRange(), and ~AlignmentProducer().

AlignmentAlgorithmBase* AlignmentProducer::theAlignmentAlgo

private

Definition at line 158 of file AlignmentProducer.h.

Referenced by AlignmentProducer(), beginLuminosityBlock(), beginOfJob(), beginRun(), duringLoop(), endLuminosityBlock(), endOfJob(), endOfLoop(), endRun(), startingNewLoop(), and ~AlignmentProducer().

AlignmentParameterStore* AlignmentProducer::theAlignmentParameterStore

private

Definition at line 159 of file AlignmentProducer.h.

Referenced by beginOfJob(), and ~AlignmentProducer().

std::vector<IntegratedCalibrationBase*> AlignmentProducer::theCalibrations

private

Definition at line 161 of file AlignmentProducer.h.

Referenced by AlignmentProducer(), beginOfJob(), endOfJob(), endOfLoop(), startingNewLoop(), and ~AlignmentProducer().

const unsigned int AlignmentProducer::theMaxLoops

private

Definition at line 178 of file AlignmentProducer.h.

Referenced by endOfLoop().

std::vector<AlignmentMonitorBase*> AlignmentProducer::theMonitors

private

Definition at line 160 of file AlignmentProducer.h.

Referenced by AlignmentProducer(), beginOfJob(), duringLoop(), endOfJob(), endOfLoop(), and startingNewLoop().

boost::shared_ptr<CSCGeometry> AlignmentProducer::theMuonCSC

private

Definition at line 169 of file AlignmentProducer.h.

Referenced by beginOfJob(), createGeometries_(), and produceCSC().

boost::shared_ptr<DTGeometry> AlignmentProducer::theMuonDT

private

Definition at line 168 of file AlignmentProducer.h.

Referenced by beginOfJob(), createGeometries_(), and produceDT().

edm::ParameterSet AlignmentProducer::theParameterSet

private

Definition at line 174 of file AlignmentProducer.h.

Referenced by beginOfJob(), createGeometries_(), and endOfJob().

const SurveyErrors* AlignmentProducer::theSurveyErrors

private

Definition at line 156 of file AlignmentProducer.h.

Referenced by addSurveyInfo_(), and readInSurveyRcds().

unsigned int AlignmentProducer::theSurveyIndex

private

Definition at line 154 of file AlignmentProducer.h.

Referenced by addSurveyInfo_(), and readInSurveyRcds().

const Alignments* AlignmentProducer::theSurveyValues

private

Definition at line 155 of file AlignmentProducer.h.

Referenced by addSurveyInfo_(), and readInSurveyRcds().

boost::shared_ptr<TrackerGeometry> AlignmentProducer::theTracker

private

Definition at line 167 of file AlignmentProducer.h.

Referenced by beginOfJob(), createGeometries_(), and produceTracker().

const edm::InputTag AlignmentProducer::tjTkAssociationMapTag_

private

Definition at line 189 of file AlignmentProducer.h.

Referenced by duringLoop().

const edm::InputTag AlignmentProducer::tkLasBeamTag_

private

Definition at line 191 of file AlignmentProducer.h.

Referenced by endRun().

const bool AlignmentProducer::useExtras_

private

Definition at line 185 of file AlignmentProducer.h.

Referenced by beginOfJob().

const bool AlignmentProducer::useSurvey_

private

Definition at line 186 of file AlignmentProducer.h.

Referenced by readInSurveyRcds().

edm::ESWatcher<CSCSurveyErrorExtendedRcd> AlignmentProducer::watchCSCSurveyErrRcd_

private

Definition at line 200 of file AlignmentProducer.h.

edm::ESWatcher<CSCSurveyRcd> AlignmentProducer::watchCSCSurveyRcd_

private

Definition at line 199 of file AlignmentProducer.h.

edm::ESWatcher<DTSurveyErrorExtendedRcd> AlignmentProducer::watchDTSurveyErrRcd_

private

Definition at line 198 of file AlignmentProducer.h.

edm::ESWatcher<DTSurveyRcd> AlignmentProducer::watchDTSurveyRcd_

private

Definition at line 197 of file AlignmentProducer.h.

edm::ESWatcher<TrackerSurveyErrorExtendedRcd> AlignmentProducer::watchTkSurveyErrRcd_

private

Definition at line 196 of file AlignmentProducer.h.

Referenced by readInSurveyRcds().

edm::ESWatcher<TrackerSurveyRcd> AlignmentProducer::watchTkSurveyRcd_

private

Definition at line 195 of file AlignmentProducer.h.

Referenced by readInSurveyRcds().