#include <TrackerSystematicMisalignments.h>

Inheritance diagram for TrackerSystematicMisalignments:

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override
	Read ideal tracker geometry from DB. More...

	TrackerSystematicMisalignments (const edm::ParameterSet &)

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	applySystematicMisalignment (Alignable *)

align::GlobalVector	findSystematicMis (const align::PositionType &, const bool blindToZ, const bool blindToR)

Private Attributes
double	m_bowingEpsilon

double	m_ellipticalDelta

double	m_ellipticalEpsilon

bool	m_fromDBGeom

double	m_layerRotEpsilon

double	m_radialEpsilon

double	m_sagittaDelta

double	m_sagittaEpsilon

double	m_skewDelta

double	m_skewEpsilon

double	m_telescopeEpsilon

double	m_twistEpsilon

double	m_zExpEpsilon

bool	oldMinusZconvention

bool	suppressBlindMvmts

AlignableTracker *	theAlignableTracker

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Class to misaligned tracker from DB.

Date: 2012/06/13 09:24:50

Revision: 1.5

Author: Chung Khim Lae

Definition at line 26 of file TrackerSystematicMisalignments.h.

Constructor & Destructor Documentation

◆ TrackerSystematicMisalignments()

TrackerSystematicMisalignments::TrackerSystematicMisalignments ( const edm::ParameterSet & cfg )

Definition at line 41 of file TrackerSystematicMisalignments.cc.

     : theAlignableTracker(nullptr) {
   // use existing geometry
   m_fromDBGeom = cfg.getUntrackedParameter<bool>("fromDBGeom");
  
   // constants
   m_radialEpsilon = cfg.getUntrackedParameter<double>("radialEpsilon");
   m_telescopeEpsilon = cfg.getUntrackedParameter<double>("telescopeEpsilon");
   m_layerRotEpsilon = cfg.getUntrackedParameter<double>("layerRotEpsilon");
   m_bowingEpsilon = cfg.getUntrackedParameter<double>("bowingEpsilon");
   m_zExpEpsilon = cfg.getUntrackedParameter<double>("zExpEpsilon");
   m_twistEpsilon = cfg.getUntrackedParameter<double>("twistEpsilon");
   m_ellipticalEpsilon = cfg.getUntrackedParameter<double>("ellipticalEpsilon");
   m_skewEpsilon = cfg.getUntrackedParameter<double>("skewEpsilon");
   m_sagittaEpsilon = cfg.getUntrackedParameter<double>("sagittaEpsilon");
  
   m_ellipticalDelta = cfg.getUntrackedParameter<double>("ellipticalDelta");
   m_skewDelta = cfg.getUntrackedParameter<double>("skewDelta");
   m_sagittaDelta = cfg.getUntrackedParameter<double>("sagittaDelta");
  
   if (m_radialEpsilon > -990.0) {
     edm::LogWarning("MisalignedTracker") << "Applying radial ...";
   }
   if (m_telescopeEpsilon > -990.0) {
     edm::LogWarning("MisalignedTracker") << "Applying telescope ...";
   }
   if (m_layerRotEpsilon > -990.0) {
     edm::LogWarning("MisalignedTracker") << "Applying layer rotation ...";
   }
   if (m_bowingEpsilon > -990.0) {
     edm::LogWarning("MisalignedTracker") << "Applying bowing ...";
   }
   if (m_zExpEpsilon > -990.0) {
     edm::LogWarning("MisalignedTracker") << "Applying z-expansion ...";
   }
   if (m_twistEpsilon > -990.0) {
     edm::LogWarning("MisalignedTracker") << "Applying twist ...";
   }
   if (m_ellipticalEpsilon > -990.0) {
     edm::LogWarning("MisalignedTracker") << "Applying elliptical ...";
   }
   if (m_skewEpsilon > -990.0) {
     edm::LogWarning("MisalignedTracker") << "Applying skew ...";
   }
   if (m_sagittaEpsilon > -990.0) {
     edm::LogWarning("MisalignedTracker") << "Applying sagitta ...";
   }
  
   // get flag for suppression of blind movements
   suppressBlindMvmts = cfg.getUntrackedParameter<bool>("suppressBlindMvmts");
   if (suppressBlindMvmts) {
     edm::LogWarning("MisalignedTracker") << "Blind movements suppressed (TIB/TOB in z, TID/TEC in r)";
   }
  
   // compatibility with old (weird) z convention
   oldMinusZconvention = cfg.getUntrackedParameter<bool>("oldMinusZconvention");
   if (oldMinusZconvention) {
     edm::LogWarning("MisalignedTracker") << "Old z convention: dz --> -dz";
   } else {
     edm::LogWarning("MisalignedTracker") << "New z convention: dz --> dz";
   }
 }

References looper::cfg, m_bowingEpsilon, m_ellipticalDelta, m_ellipticalEpsilon, m_fromDBGeom, m_layerRotEpsilon, m_radialEpsilon, m_sagittaDelta, m_sagittaEpsilon, m_skewDelta, m_skewEpsilon, m_telescopeEpsilon, m_twistEpsilon, m_zExpEpsilon, oldMinusZconvention, and suppressBlindMvmts.

Member Function Documentation

◆ analyze()

void TrackerSystematicMisalignments::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

overridevirtual

Implements edm::EDAnalyzer.

Definition at line 106 of file TrackerSystematicMisalignments.cc.

                                                                                               {
   //Retrieve tracker topology from geometry
   edm::ESHandle<TrackerTopology> tTopoHandle;
   setup.get<TrackerTopologyRcd>().get(tTopoHandle);
   const TrackerTopology* const tTopo = tTopoHandle.product();
  
   edm::ESHandle<GeometricDet> geom;
   setup.get<IdealGeometryRecord>().get(geom);
   edm::ESHandle<PTrackerParameters> ptp;
   setup.get<PTrackerParametersRcd>().get(ptp);
   TrackerGeometry* tracker = TrackerGeomBuilderFromGeometricDet().build(&*geom, *ptp, tTopo);
  
   //take geometry from DB or randomly generate geometry
   if (m_fromDBGeom) {
     //build the tracker
     edm::ESHandle<Alignments> alignments;
     edm::ESHandle<AlignmentErrorsExtended> alignmentErrors;
  
     setup.get<TrackerAlignmentRcd>().get(alignments);
     setup.get<TrackerAlignmentErrorExtendedRcd>().get(alignmentErrors);
  
     edm::ESHandle<Alignments> globalPositionRcd;
     setup.get<TrackerDigiGeometryRecord>().getRecord<GlobalPositionRcd>().get(globalPositionRcd);
  
     //apply the latest alignments
     GeometryAligner aligner;
     aligner.applyAlignments<TrackerGeometry>(&(*tracker),
                                              &(*alignments),
                                              &(*alignmentErrors),
                                              align::DetectorGlobalPosition(*globalPositionRcd, DetId(DetId::Tracker)));
   }
  
   theAlignableTracker = new AlignableTracker(&(*tracker), tTopo);
  
   applySystematicMisalignment(&(*theAlignableTracker));
  
   // -------------- writing out to alignment record --------------
   Alignments* myAlignments = theAlignableTracker->alignments();
   AlignmentErrorsExtended* myAlignmentErrorsExtended = theAlignableTracker->alignmentErrors();
  
   // Store alignment[Error]s to DB
   edm::Service<cond::service::PoolDBOutputService> poolDbService;
   std::string theAlignRecordName = "TrackerAlignmentRcd";
   std::string theErrorRecordName = "TrackerAlignmentErrorExtendedRcd";
  
   // Call service
   if (!poolDbService.isAvailable())  // Die if not available
     throw cms::Exception("NotAvailable") << "PoolDBOutputService not available";
  
   poolDbService->writeOne<Alignments>(&(*myAlignments), poolDbService->beginOfTime(), theAlignRecordName);
   poolDbService->writeOne<AlignmentErrorsExtended>(
       &(*myAlignmentErrorsExtended), poolDbService->beginOfTime(), theErrorRecordName);
 }

References AlignableTracker::alignmentErrors(), AlignableTracker::alignments(), GeometryAligner::applyAlignments(), applySystematicMisalignment(), cond::service::PoolDBOutputService::beginOfTime(), TrackerGeomBuilderFromGeometricDet::build(), align::DetectorGlobalPosition(), relativeConstraints::geom, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), get, edm::Service< T >::isAvailable(), m_fromDBGeom, edm::ESHandle< T >::product(), singleTopDQM_cfi::setup, AlCaHLTBitMon_QueryRunRegistry::string, theAlignableTracker, DetId::Tracker, PbPb_ZMuSkimMuonDPG_cff::tracker, and cond::service::PoolDBOutputService::writeOne().

◆ applySystematicMisalignment()

void TrackerSystematicMisalignments::applySystematicMisalignment ( Alignable * ali )

private

Definition at line 160 of file TrackerSystematicMisalignments.cc.

                                                                                {
   const align::Alignables& comp = ali->components();
   unsigned int nComp = comp.size();
   //move then do for lower level object
   //for issue of det vs detunit
   bool usecomps = true;
   if ((ali->alignableObjectId() == 2) && (nComp >= 1))
     usecomps = false;
   for (unsigned int i = 0; i < nComp; ++i) {
     if (usecomps)
       applySystematicMisalignment(comp[i]);
   }
  
   // if suppression of blind mvmts: check if subdet is blind to a certain mode
   bool blindToZ(false), blindToR(false);
   if (suppressBlindMvmts) {
     const int subdetid = ali->geomDetId().subdetId();
     switch (subdetid) {
       // TIB/TON blind to z
       case SiStripDetId::TIB:
       case SiStripDetId::TOB:
         blindToZ = true;
         break;
       // TID/TEC blind to R
       case SiStripDetId::TID:
       case SiStripDetId::TEC:
         blindToR = true;
         break;
       default:
         break;
     }
   }
  
   const int level = ali->alignableObjectId();
   if ((level == 1) || (level == 2)) {
     const align::PositionType gP = ali->globalPosition();
     const align::GlobalVector gVec = findSystematicMis(gP, blindToZ, blindToR);
     ali->move(gVec);
   }
 }

References Alignable::alignableObjectId(), AlCaHLTBitMon_QueryRunRegistry::comp, Alignable::components(), findSystematicMis(), Alignable::geomDetId(), Alignable::globalPosition(), mps_fire::i, personalPlayback::level, Alignable::move(), DetId::subdetId(), suppressBlindMvmts, SiStripDetId::TEC, SiStripDetId::TIB, SiStripDetId::TID, and SiStripDetId::TOB.

Referenced by analyze().

◆ beginJob()

void TrackerSystematicMisalignments::beginJob ( void )

overridevirtual

Read ideal tracker geometry from DB.

Reimplemented from edm::EDAnalyzer.

Definition at line 104 of file TrackerSystematicMisalignments.cc.

104 {}

◆ findSystematicMis()

align::GlobalVector TrackerSystematicMisalignments::findSystematicMis	(	const align::PositionType &	globalPos,
		const bool	blindToZ,
		const bool	blindToR
	)

private

Definition at line 201 of file TrackerSystematicMisalignments.cc.

                                                                                            {
   //align::GlobalVector TrackerSystematicMisalignments::findSystematicMis( align::PositionType globalPos ){
   // calculates shift for the current alignable
   // all corrections are calculated w.r.t. the original geometry
   double deltaX = 0.0;
   double deltaY = 0.0;
   double deltaZ = 0.0;
   const double oldX = globalPos.x();
   const double oldY = globalPos.y();
   const double oldZ = globalPos.z();
   const double oldPhi = globalPos.phi();
   const double oldR = sqrt(globalPos.x() * globalPos.x() + globalPos.y() * globalPos.y());
  
   if (m_radialEpsilon > -990.0 && !blindToR) {
     deltaX += m_radialEpsilon * oldX;
     deltaY += m_radialEpsilon * oldY;
   }
   if (m_telescopeEpsilon > -990.0 && !blindToZ) {
     deltaZ += m_telescopeEpsilon * oldR;
   }
   if (m_layerRotEpsilon > -990.0) {
     // The following number was chosen such that the Layer Rotation systematic
     // misalignment would not cause an overall rotation of the tracker.
     const double Roffset = 57.0;
     const double xP = oldR * cos(oldPhi + m_layerRotEpsilon * (oldR - Roffset));
     const double yP = oldR * sin(oldPhi + m_layerRotEpsilon * (oldR - Roffset));
     deltaX += (xP - oldX);
     deltaY += (yP - oldY);
   }
   if (m_bowingEpsilon > -990.0 && !blindToR) {
     const double trackeredgePlusZ = 271.846;
     const double bowfactor = m_bowingEpsilon * (trackeredgePlusZ * trackeredgePlusZ - oldZ * oldZ);
     deltaX += oldX * bowfactor;
     deltaY += oldY * bowfactor;
   }
   if (m_zExpEpsilon > -990.0 && !blindToZ) {
     deltaZ += oldZ * m_zExpEpsilon;
   }
   if (m_twistEpsilon > -990.0) {
     const double xP = oldR * cos(oldPhi + m_twistEpsilon * oldZ);
     const double yP = oldR * sin(oldPhi + m_twistEpsilon * oldZ);
     deltaX += (xP - oldX);
     deltaY += (yP - oldY);
   }
   if (m_ellipticalEpsilon > -990.0 && !blindToR) {
     deltaX += oldX * m_ellipticalEpsilon * cos(2.0 * oldPhi + m_ellipticalDelta);
     deltaY += oldY * m_ellipticalEpsilon * cos(2.0 * oldPhi + m_ellipticalDelta);
   }
   if (m_skewEpsilon > -990.0 && !blindToZ) {
     deltaZ += m_skewEpsilon * cos(oldPhi + m_skewDelta);
   }
   if (m_sagittaEpsilon > -990.0) {
     // deltaX += oldX/fabs(oldX)*m_sagittaEpsilon; // old one...
     deltaX += oldR * m_sagittaEpsilon * sin(m_sagittaDelta);
     deltaY += oldR * m_sagittaEpsilon * cos(m_sagittaDelta);  //Delta y is cos so that delta=0 reflects the old behavior
   }
  
   // Compatibility with old version <= 1.5
   if (oldMinusZconvention)
     deltaZ = -deltaZ;
  
   align::GlobalVector gV(deltaX, deltaY, deltaZ);
   return gV;
 }