#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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, 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)

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

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

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, 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 ( const edm::ParameterSet & cfg )

Definition at line 41 of file TrackerSystematicMisalignments.cc.

References edm::ParameterSet::getUntrackedParameter(), 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.

   : 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";
     }
 
 }

Member Function Documentation

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

override

Definition at line 116 of file TrackerSystematicMisalignments.cc.

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

                                                                                              {
 
     //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);
 }

void TrackerSystematicMisalignments::applySystematicMisalignment ( Alignable * ali )

private

Definition at line 169 of file TrackerSystematicMisalignments.cc.

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

Referenced by analyze().

 {
 
     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 );
     }
 }

void TrackerSystematicMisalignments::beginJob ( void )

overridevirtual

Read ideal tracker geometry from DB.

Reimplemented from edm::EDAnalyzer.

Definition at line 110 of file TrackerSystematicMisalignments.cc.

 {
 
 }

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

private

Definition at line 212 of file TrackerSystematicMisalignments.cc.

References funct::cos(), DEFINE_FWK_MODULE, m_bowingEpsilon, m_ellipticalDelta, m_ellipticalEpsilon, m_layerRotEpsilon, m_radialEpsilon, m_sagittaDelta, m_sagittaEpsilon, m_skewDelta, m_skewEpsilon, m_telescopeEpsilon, m_twistEpsilon, m_zExpEpsilon, oldMinusZconvention, PV3DBase< T, PVType, FrameType >::phi(), funct::sin(), mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by applySystematicMisalignment().

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