#include <TrackerSystematicMisalignments.h>

Inheritance diagram for TrackerSystematicMisalignments:

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

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

	TrackerSystematicMisalignments (const edm::ParameterSet &)

Public Member Functions inherited from edm::EDAnalyzer
	EDAnalyzer ()

std::string	workerType () const

virtual	~EDAnalyzer ()

Private Member Functions
void	applySystematicMisalignment (Alignable *)

align::GlobalVector	findSystematicMis (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

typedef WorkerT< EDAnalyzer >	WorkerType

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from edm::EDAnalyzer
CurrentProcessingContext const *	currentContext () const

Detailed Description

Class to misaligned tracker from DB.

Date:: 2010/06/14 14:45:15

Revision:: 1.4

Author: Chung Khim Lae

Definition at line 22 of file TrackerSystematicMisalignments.h.

Constructor & Destructor Documentation

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

Definition at line 35 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(0)
 {
     // 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
	)

virtual

Implements edm::EDAnalyzer.

Definition at line 110 of file TrackerSystematicMisalignments.cc.

References AlignableTracker::alignmentErrors(), AlignableTracker::alignments(), GeometryAligner::applyAlignments(), applySystematicMisalignment(), cond::service::PoolDBOutputService::beginOfTime(), TrackerGeomBuilderFromGeometricDet::build(), relativeConstraints::geom, edm::EventSetup::get(), edm::Service< T >::isAvailable(), m_fromDBGeom, theAlignableTracker, patCandidatesForDimuonsSequences_cff::tracker, and cond::service::PoolDBOutputService::writeOne().

                                                                                              {
     
     
     edm::ESHandle<GeometricDet>  geom;
     setup.get<IdealGeometryRecord>().get(geom);  
     TrackerGeometry* tracker = TrackerGeomBuilderFromGeometricDet().build(&*geom);
     
     //take geometry from DB or randomly generate geometry
     if (m_fromDBGeom){
         //build the tracker
         edm::ESHandle<Alignments> alignments;
         edm::ESHandle<AlignmentErrors> alignmentErrors;
         
         setup.get<TrackerAlignmentRcd>().get(alignments);
         setup.get<TrackerAlignmentErrorRcd>().get(alignmentErrors);
         
         //apply the latest alignments
         GeometryAligner aligner;
         aligner.applyAlignments<TrackerGeometry>( &(*tracker), &(*alignments), &(*alignmentErrors), AlignTransform() );
         
     }
     
     theAlignableTracker = new AlignableTracker(&(*tracker));
     
     applySystematicMisalignment( &(*theAlignableTracker) );
     
     // -------------- writing out to alignment record --------------
     Alignments* myAlignments = theAlignableTracker->alignments() ;
     AlignmentErrors* myAlignmentErrors = theAlignableTracker->alignmentErrors() ;
     
     // Store alignment[Error]s to DB
     edm::Service<cond::service::PoolDBOutputService> poolDbService;
     std::string theAlignRecordName = "TrackerAlignmentRcd";
     std::string theErrorRecordName = "TrackerAlignmentErrorRcd";
     
     // 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<AlignmentErrors>(&(*myAlignmentErrors), poolDbService->beginOfTime(), theErrorRecordName);
 }

void TrackerSystematicMisalignments::applySystematicMisalignment ( Alignable * ali )

private

Definition at line 153 of file TrackerSystematicMisalignments.cc.

References Alignable::alignableObjectId(), Alignable::components(), findSystematicMis(), Alignable::geomDetId(), Alignable::globalPosition(), i, testEve_cfg::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 )

virtual

Read ideal tracker geometry from DB.

Reimplemented from edm::EDAnalyzer.

Definition at line 104 of file TrackerSystematicMisalignments.cc.

 {
         
 }

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

private

Definition at line 196 of file TrackerSystematicMisalignments.cc.

References funct::cos(), 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;
 }