CMS 3D CMS Logo
List of all members | Public Types | Public Member Functions | Private Member Functions | Private Attributes
TrackerGeometryCompare Class Reference

#include <TrackerGeometryCompare.h>

Inheritance diagram for TrackerGeometryCompare:
edm::EDAnalyzer edm::EDConsumerBase

Public Types

typedef std::vector< Alignable * > Alignables
 
typedef AlignTransform SurveyValue
 
typedef Alignments SurveyValues
 
- Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer ModuleType
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 

Public Member Functions

virtual void analyze (const edm::Event &, const edm::EventSetup &)
 
virtual void beginJob ()
 Read from DB and print survey info. More...
 
virtual void endJob ()
 
 TrackerGeometryCompare (const edm::ParameterSet &)
 Do nothing. Required by framework. More...
 
- Public Member Functions inherited from edm::EDAnalyzer
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzer ()
 
ModuleDescription const & moduleDescription () const
 
std::string workerType () const
 
virtual ~EDAnalyzer ()
 
- 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
 
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
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
virtual ~EDConsumerBase () noexcept(false)
 

Private Member Functions

void addSurveyInfo (Alignable *ali)
 
void compareGeometries (Alignable *refAli, Alignable *curAli, const TrackerTopology *tTopo, const edm::EventSetup &iSetup)
 
void compareSurfaceDeformations (TTree *_inputTree11, TTree *_inputTree12)
 
void createROOTGeometry (const edm::EventSetup &iSetup)
 
void diffCommonTrackerSystem (Alignable *refAli, Alignable *curAli)
 
void fillIdentifiers (int subdetlevel, int rawid, const TrackerTopology *tTopo)
 
void fillTree (Alignable *refAli, const AlgebraicVector &diff, const TrackerTopology *tTopo, const edm::EventSetup &iSetup)
 
bool passIdCut (uint32_t)
 
void setCommonTrackerSystem ()
 
void surveyToTracker (AlignableTracker *ali, Alignments *alignVals, AlignmentErrorsExtended *alignErrors)
 

Private Attributes

TTree * _alignTree
 
float _alphaVal
 
int _badModuleQuality
 
float _betaVal
 
align::StructureType _commonTrackerLevel
 
float _dalphaVal
 
float _daVal
 
float _dbetaVal
 
float _dbVal
 
int _detDim
 
bool _detIdFlag
 
std::string _detIdFlagFile
 
std::vector< uint32_t > _detIdFlagVector
 
float _dgammaVal
 
float _dgVal
 
float _dphiVal
 
float _drVal
 
float _duVal
 
float _dvVal
 
float _dwVal
 
float _dxVal
 
float _dyVal
 
float _dzVal
 
float _etaVal
 
std::string _filename
 
float _gammaVal
 
int _id
 
uint32_t _identifiers [6]
 
int _inModuleList
 
std::string _inputFilename1
 
std::string _inputFilename2
 
TFile * _inputRootFile1
 
TFile * _inputRootFile2
 
TTree * _inputTree01
 
TTree * _inputTree02
 
TTree * _inputTree11
 
TTree * _inputTree12
 
std::string _inputTreenameAlign
 
std::string _inputTreenameDeform
 
int _level
 
const std::vector< std::string > _levelStrings
 
int _mid
 
int _mlevel
 
int _moduleInList
 
std::vector< int > _moduleList
 
std::ifstream _moduleListFile
 
std::string _moduleListName
 
float _phiVal
 
float _rVal
 
std::string _setCommonTrackerSystem
 
int _sublevel
 
double _surfDeform [13]
 
float _surLength
 
double _surRot [9]
 
float _surWidth
 
TFile * _theFile
 
align::PositionType _TrackerCommonCM
 
align::GlobalVector _TrackerCommonR
 
align::GlobalVector _TrackerCommonT
 
int _type
 
int _useDetId
 
std::string _weightBy
 
bool _weightById
 
std::string _weightByIdFile
 
std::vector< unsigned int > _weightByIdVector
 
bool _writeToDB
 
float _xVal
 
float _yVal
 
float _zVal
 
AlignableTracker * currentTracker
 
AlignableTracker * dummyTracker
 
bool firstEvent_
 
std::map< std::string, TH1D * > m_h1
 
int m_nBins
 
double m_rangeHigh
 
double m_rangeLow
 
std::vector< align::StructureType > m_theLevels
 
std::vector< TrackerMap > m_vtkmap
 
AlignableTracker * referenceTracker
 
const SurveyErrors * theSurveyErrors
 
unsigned int theSurveyIndex
 
const Alignments * theSurveyValues
 

Additional Inherited Members

- 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::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 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

Module that reads survey info from DB and prints them out.

Usage: module comparator = TrackerGeometryCompare {

lots of stuff

} path p = { comparator }

Date
2012/12/02 22:13:12
Revision
1.14
Author
Nhan Tran

******** Including surface deformations in the geometry comparison ********

Definition at line 50 of file TrackerGeometryCompare.h.

Member Typedef Documentation

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

Definition at line 54 of file TrackerGeometryCompare.h.

typedef AlignTransform TrackerGeometryCompare::SurveyValue

Definition at line 52 of file TrackerGeometryCompare.h.

typedef Alignments TrackerGeometryCompare::SurveyValues

Definition at line 53 of file TrackerGeometryCompare.h.

Constructor & Destructor Documentation

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

Do nothing. Required by framework.

Definition at line 61 of file TrackerGeometryCompare.cc.

References _alignTree, _alphaVal, _badModuleQuality, _betaVal, _dalphaVal, _daVal, _dbetaVal, _dbVal, _detDim, _detIdFlag, _detIdFlagFile, _detIdFlagVector, _dgammaVal, _dgVal, _dphiVal, _drVal, _duVal, _dvVal, _dwVal, _dxVal, _dyVal, _dzVal, _etaVal, _filename, _gammaVal, _id, _identifiers, _inModuleList, _inputFilename1, _inputFilename2, _inputTreenameAlign, _inputTreenameDeform, _level, _mid, _mlevel, _moduleListName, _phiVal, _rVal, _setCommonTrackerSystem, _sublevel, _surfDeform, _surLength, _surRot, _surWidth, _theFile, _type, _useDetId, _weightBy, _weightById, _weightByIdFile, _weightByIdVector, _xVal, _yVal, _zVal, groupFilesInBlocks::fin, edm::ParameterSet::getUntrackedParameter(), hcalTTPDigis_cfi::id, cuy::ii, m_h1, m_nBins, m_rangeHigh, m_rangeLow, m_vtkmap, TFileDirectory::make(), TFileService::mkdir(), and AlCaHLTBitMon_QueryRunRegistry::string.

61  :
62  referenceTracker(nullptr),
63  dummyTracker(nullptr),
64  currentTracker(nullptr),
65  theSurveyIndex(0),
66  theSurveyValues(nullptr),
67  theSurveyErrors(nullptr),
68  _levelStrings(cfg.getUntrackedParameter< std::vector<std::string> >("levels")),
69  _writeToDB(cfg.getUntrackedParameter<bool>("writeToDB")),
70  _commonTrackerLevel(align::invalid),
71  _moduleListFile(nullptr),
72  _moduleList(0),
73  _inputRootFile1(nullptr),
74  _inputRootFile2(nullptr),
75  _inputTree01(nullptr),
76  _inputTree02(nullptr),
77  _inputTree11(nullptr),
78  _inputTree12(nullptr),
79  m_nBins(10000),
80  m_rangeLow(-.1),
81  m_rangeHigh(.1),
82  firstEvent_(true),
83  m_vtkmap(13)
84 {
85  _moduleListName = cfg.getUntrackedParameter< std::string > ("moduleList");
86 
87  //input is ROOT
88  _inputFilename1 = cfg.getUntrackedParameter< std::string > ("inputROOTFile1");
89  _inputFilename2 = cfg.getUntrackedParameter< std::string > ("inputROOTFile2");
90  _inputTreenameAlign = cfg.getUntrackedParameter< std::string > ("treeNameAlign");
91  _inputTreenameDeform = cfg.getUntrackedParameter< std::string > ("treeNameDeform");
92 
93  //output file
94  _filename = cfg.getUntrackedParameter< std::string > ("outputFile");
95 
96 
97  _weightBy = cfg.getUntrackedParameter< std::string > ("weightBy");
98  _setCommonTrackerSystem = cfg.getUntrackedParameter< std::string > ("setCommonTrackerSystem");
99  _detIdFlag = cfg.getUntrackedParameter< bool > ("detIdFlag");
100  _detIdFlagFile = cfg.getUntrackedParameter< std::string > ("detIdFlagFile");
101  _weightById = cfg.getUntrackedParameter< bool > ("weightById");
102  _weightByIdFile = cfg.getUntrackedParameter< std::string > ("weightByIdFile");
103 
104 
105  // if want to use, make id cut list
106  if (_detIdFlag){
107  std::ifstream fin;
108  fin.open( _detIdFlagFile.c_str() );
109 
110  while (!fin.eof() && fin.good() ){
111 
112  uint32_t id;
113  fin >> id;
114  _detIdFlagVector.push_back(id);
115  }
116  fin.close();
117  }
118 
119  // turn weightByIdFile into weightByIdVector
120  if (_weightById){
121  std::ifstream inFile;
122  inFile.open( _weightByIdFile.c_str() );
123  int ctr = 0;
124  while ( !inFile.eof() ){
125  ctr++;
126  unsigned int listId;
127  inFile >> listId;
128  inFile.ignore(256, '\n');
129 
130  _weightByIdVector.push_back( listId );
131  }
132  inFile.close();
133  }
134 
135  //root configuration
136  _theFile = new TFile(_filename.c_str(),"RECREATE");
137  _alignTree = new TTree("alignTree","alignTree");//,"id:level:mid:mlevel:sublevel:x:y:z:r:phi:a:b:c:dx:dy:dz:dr:dphi:da:db:dc");
138  _alignTree->Branch("id", &_id, "id/I");
139  _alignTree->Branch("badModuleQuality", &_badModuleQuality, "badModuleQuality/I");
140  _alignTree->Branch("inModuleList", &_inModuleList, "inModuleList/I");
141  _alignTree->Branch("level", &_level, "level/I");
142  _alignTree->Branch("mid", &_mid, "mid/I");
143  _alignTree->Branch("mlevel", &_mlevel, "mlevel/I");
144  _alignTree->Branch("sublevel", &_sublevel, "sublevel/I");
145  _alignTree->Branch("x", &_xVal, "x/F");
146  _alignTree->Branch("y", &_yVal, "y/F");
147  _alignTree->Branch("z", &_zVal, "z/F");
148  _alignTree->Branch("r", &_rVal, "r/F");
149  _alignTree->Branch("phi", &_phiVal, "phi/F");
150  _alignTree->Branch("eta", &_etaVal, "eta/F");
151  _alignTree->Branch("alpha", &_alphaVal, "alpha/F");
152  _alignTree->Branch("beta", &_betaVal, "beta/F");
153  _alignTree->Branch("gamma", &_gammaVal, "gamma/F");
154  _alignTree->Branch("dx", &_dxVal, "dx/F");
155  _alignTree->Branch("dy", &_dyVal, "dy/F");
156  _alignTree->Branch("dz", &_dzVal, "dz/F");
157  _alignTree->Branch("dr", &_drVal, "dr/F");
158  _alignTree->Branch("dphi", &_dphiVal, "dphi/F");
159  _alignTree->Branch("dalpha", &_dalphaVal, "dalpha/F");
160  _alignTree->Branch("dbeta", &_dbetaVal, "dbeta/F");
161  _alignTree->Branch("dgamma", &_dgammaVal, "dgamma/F");
162  _alignTree->Branch("du", &_duVal, "du/F");
163  _alignTree->Branch("dv", &_dvVal, "dv/F");
164  _alignTree->Branch("dw", &_dwVal, "dw/F");
165  _alignTree->Branch("da", &_daVal, "da/F");
166  _alignTree->Branch("db", &_dbVal, "db/F");
167  _alignTree->Branch("dg", &_dgVal, "dg/F");
168  _alignTree->Branch("useDetId", &_useDetId, "useDetId/I");
169  _alignTree->Branch("detDim", &_detDim, "detDim/I");
170  _alignTree->Branch("surW", &_surWidth, "surW/F");
171  _alignTree->Branch("surL", &_surLength, "surL/F");
172  _alignTree->Branch("surRot", &_surRot, "surRot[9]/D");
173  _alignTree->Branch("identifiers", &_identifiers, "identifiers[6]/I");
174  _alignTree->Branch("type", &_type, "type/I");
175  _alignTree->Branch("surfDeform", &_surfDeform, "surfDeform[13]/D");
176 
177  for (std::vector<TrackerMap>::iterator it = m_vtkmap.begin(); it != m_vtkmap.end(); ++it) {
178  it->setPalette(1) ;
179  it->addPixel(true) ;
180  }
181 
182  edm::Service<TFileService> fs;
183  TFileDirectory subDir_All = fs->mkdir( "AllSubdetectors" );
184  TFileDirectory subDir_PXB = fs->mkdir( "PixelBarrel" );
185  TFileDirectory subDir_PXF = fs->mkdir( "PixelEndcap" );
186  for (int ii = 0; ii < 13; ++ii) {
187  std::stringstream histname0 ;
188  histname0 << "SurfDeform_Par_" << ii ;
189  m_h1[histname0.str()] = subDir_All.make<TH1D>((histname0.str()).c_str(),(histname0.str()).c_str(),m_nBins,m_rangeLow,m_rangeHigh);
190 
191  std::stringstream histname1 ;
192  histname1 << "SurfDeform_PixelBarrel_Par_" << ii ;
193  m_h1[histname1.str()] = subDir_PXB.make<TH1D>((histname1.str()).c_str(),(histname1.str()).c_str(),m_nBins,m_rangeLow,m_rangeHigh);
194 
195  std::stringstream histname2 ;
196  histname2 << "SurfDeform_PixelEndcap_Par_" << ii ;
197  m_h1[histname2.str()] = subDir_PXF.make<TH1D>((histname2.str()).c_str(),(histname2.str()).c_str(),m_nBins,m_rangeLow,m_rangeHigh);
198  }
199 
200 }
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackerGeometryCompare::theSurveyValues
const Alignments * theSurveyValues
Definition: TrackerGeometryCompare.h:104
TrackerGeometryCompare::m_vtkmap
std::vector< TrackerMap > m_vtkmap
Definition: TrackerGeometryCompare.h:163
TrackerGeometryCompare::dummyTracker
AlignableTracker * dummyTracker
Definition: TrackerGeometryCompare.h:100
TrackerGeometryCompare::m_h1
std::map< std::string, TH1D * > m_h1
Definition: TrackerGeometryCompare.h:165
TrackerGeometryCompare::_detIdFlagVector
std::vector< uint32_t > _detIdFlagVector
Definition: TrackerGeometryCompare.h:123
TFileDirectory::make
T * make(const Args &...args) const
make new ROOT object
Definition: TFileDirectory.h:59
TrackerGeometryCompare::_commonTrackerLevel
align::StructureType _commonTrackerLevel
Definition: TrackerGeometryCompare.h:124
cuy.ii
ii
Definition: cuy.py:588
TrackerGeometryCompare::currentTracker
AlignableTracker * currentTracker
Definition: TrackerGeometryCompare.h:101
TFileService::mkdir
TFileDirectory mkdir(const std::string &dir, const std::string &descr="")
create a new subdirectory
Definition: TFileService.h:69
TrackerGeometryCompare::_levelStrings
const std::vector< std::string > _levelStrings
Definition: TrackerGeometryCompare.h:108
TrackerGeometryCompare::referenceTracker
AlignableTracker * referenceTracker
Definition: TrackerGeometryCompare.h:99
TrackerGeometryCompare::theSurveyErrors
const SurveyErrors * theSurveyErrors
Definition: TrackerGeometryCompare.h:105
TrackerGeometryCompare::_weightByIdVector
std::vector< unsigned int > _weightByIdVector
Definition: TrackerGeometryCompare.h:121
TrackerGeometryCompare::_moduleList
std::vector< int > _moduleList
Definition: TrackerGeometryCompare.h:130
hcalTTPDigis_cfi.id
id
Definition: hcalTTPDigis_cfi.py:7

Member Function Documentation

void TrackerGeometryCompare::addSurveyInfo ( Alignable *  ali)
private

Definition at line 939 of file TrackerGeometryCompare.cc.

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

939  {
940 
941  const std::vector<Alignable*>& comp = ali->components();
942 
943  unsigned int nComp = comp.size();
944 
945  for (unsigned int i = 0; i < nComp; ++i) addSurveyInfo(comp[i]);
946 
947  const SurveyError& error = theSurveyErrors->m_surveyErrors[theSurveyIndex];
948 
949  if ( ali->geomDetId().rawId() != error.rawId() ||
950  ali->alignableObjectId() != error.structureType() )
951  {
952  throw cms::Exception("DatabaseError")
953  << "Error reading survey info from DB. Mismatched id!";
954  }
955 
956  const CLHEP::Hep3Vector& pos = theSurveyValues->m_align[theSurveyIndex].translation();
957  const CLHEP::HepRotation& rot = theSurveyValues->m_align[theSurveyIndex].rotation();
958 
959  AlignableSurface surf( align::PositionType( pos.x(), pos.y(), pos.z() ),
960  align::RotationType( rot.xx(), rot.xy(), rot.xz(),
961  rot.yx(), rot.yy(), rot.yz(),
962  rot.zx(), rot.zy(), rot.zz() ) );
963 
964  surf.setWidth( ali->surface().width() );
965  surf.setLength( ali->surface().length() );
966 
967  ali->setSurvey( new SurveyDet( surf, error.matrix() ) );
968 
969  ++theSurveyIndex;
970 
971 }
AlignableSurface::width
align::Scalar width() const
Definition: AlignableSurface.h:36
mps_fire.i
i
Definition: mps_fire.py:156
SurveyError::matrix
ErrorMatrix matrix() const
Definition: SurveyError.h:76
TrackerGeometryCompare::theSurveyValues
const Alignments * theSurveyValues
Definition: TrackerGeometryCompare.h:104
TrackerGeometryCompare::addSurveyInfo
void addSurveyInfo(Alignable *ali)
Definition: TrackerGeometryCompare.cc:939
SurveyError::structureType
uint8_t structureType() const
Definition: SurveyError.h:66
Alignments::m_align
std::vector< AlignTransform > m_align
Definition: Alignments.h:19
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
Alignable::components
virtual Alignables components() const =0
Return vector of all direct components.
SurveyError::rawId
align::ID rawId() const
Definition: SurveyError.h:71
AlCaHLTBitMon_QueryRunRegistry.comp
comp
Definition: AlCaHLTBitMon_QueryRunRegistry.py:248
Alignable::surface
const AlignableSurface & surface() const
Return the Surface (global position and orientation) of the object.
Definition: Alignable.h:135
AlignableSurface::length
align::Scalar length() const
Definition: AlignableSurface.h:38
Alignable::setSurvey
void setSurvey(const SurveyDet *)
Set survey info.
Definition: Alignable.cc:356
TrackerGeometryCompare::theSurveyErrors
const SurveyErrors * theSurveyErrors
Definition: TrackerGeometryCompare.h:105
SurveyErrors::m_surveyErrors
std::vector< SurveyError > m_surveyErrors
Definition: SurveyErrors.h:23
Alignable::geomDetId
const DetId & geomDetId() const
Definition: Alignable.h:186
void TrackerGeometryCompare::analyze ( const edm::Event &  ,
const edm::EventSetup &  iSetup 
)
virtual

Definition at line 226 of file TrackerGeometryCompare.cc.

References _inputTree11, _inputTree12, _levelStrings, _setCommonTrackerSystem, _writeToDB, AlignableTracker::alignmentErrors(), AlignableTracker::alignments(), cond::service::PoolDBOutputService::beginOfTime(), compareGeometries(), compareSurfaceDeformations(), createROOTGeometry(), currentTracker, firstEvent_, edm::EventSetup::get(), edm::Service< T >::isAvailable(), hcalDigis_cfi::level, m_theLevels, AlignableTracker::objectIdProvider(), edm::ESHandle< T >::product(), referenceTracker, setCommonTrackerSystem(), AlignableObjectId::stringToId(), and cond::service::PoolDBOutputService::writeOne().

226  {
227 
228  if (firstEvent_) {
229 
230  //Retrieve tracker topology from geometry
231  edm::ESHandle<TrackerTopology> tTopoHandle;
232  iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
233  const TrackerTopology* const tTopo = tTopoHandle.product();
234 
235  //upload the ROOT geometries
236  createROOTGeometry(iSetup);
237 
238  //setting the levels being used in the geometry comparator
239  edm::LogInfo("TrackerGeometryCompare") << "levels: " << _levelStrings.size();
240  for (const auto& level: _levelStrings){
241  m_theLevels.push_back(currentTracker->objectIdProvider().stringToId(level));
242  edm::LogInfo("TrackerGeometryCompare") << "level: " << level;
243  edm::LogInfo("TrackerGeometryCompare")
244  << "structure type: "
245  << currentTracker->objectIdProvider().stringToId(level);
246  }
247 
248 
249  //set common tracker system first
250  // if setting the tracker common system
251  if (_setCommonTrackerSystem != "NONE"){
252  setCommonTrackerSystem();
253  }
254 
255  //compare the goemetries
256  compareGeometries(referenceTracker,currentTracker,tTopo,iSetup);
257  compareSurfaceDeformations(_inputTree11, _inputTree12);
258 
259  //write out ntuple
260  //might be better to do within output module
261 
262  if (_writeToDB){
263  Alignments* myAlignments = currentTracker->alignments();
264  AlignmentErrorsExtended* myAlignmentErrorsExtended = currentTracker->alignmentErrors();
265 
266  // 2. Store alignment[Error]s to DB
267  edm::Service<cond::service::PoolDBOutputService> poolDbService;
268  // Call service
269  if( !poolDbService.isAvailable() ) // Die if not available
270  throw cms::Exception("NotAvailable") << "PoolDBOutputService not available";
271 
272  poolDbService->writeOne<Alignments>(&(*myAlignments), poolDbService->beginOfTime(), "TrackerAlignmentRcd");
273  poolDbService->writeOne<AlignmentErrorsExtended>(&(*myAlignmentErrorsExtended), poolDbService->beginOfTime(), "TrackerAlignmentErrorExtendedRcd");
274 
275  }
276 
277  firstEvent_ = false;
278  }
279 }
AlignableObjectId::stringToId
align::StructureType stringToId(const char *) const
Definition: AlignableObjectId.cc:296
TrackerGeometryCompare::compareGeometries
void compareGeometries(Alignable *refAli, Alignable *curAli, const TrackerTopology *tTopo, const edm::EventSetup &iSetup)
Definition: TrackerGeometryCompare.cc:608
AlignableTracker::alignmentErrors
AlignmentErrorsExtended * alignmentErrors() const
Return alignment errors, sorted by DetId.
Definition: AlignableTracker.cc:74
TrackerGeometryCompare::m_theLevels
std::vector< align::StructureType > m_theLevels
Definition: TrackerGeometryCompare.h:75
hcalDigis_cfi.level
level
Definition: hcalDigis_cfi.py:18
edm::Service::isAvailable
bool isAvailable() const
Definition: Service.h:46
cond::service::PoolDBOutputService::writeOne
void writeOne(T *payload, Time_t time, const std::string &recordName, bool withlogging=false)
Definition: PoolDBOutputService.h:54
AlignableTracker::objectIdProvider
const AlignableObjectId & objectIdProvider() const
Return tracker alignable object ID provider derived from the tracker&#39;s geometry.
Definition: AlignableTracker.h:171
TrackerGeometryCompare::currentTracker
AlignableTracker * currentTracker
Definition: TrackerGeometryCompare.h:101
TrackerGeometryCompare::_levelStrings
const std::vector< std::string > _levelStrings
Definition: TrackerGeometryCompare.h:108
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
TrackerGeometryCompare::referenceTracker
AlignableTracker * referenceTracker
Definition: TrackerGeometryCompare.h:99
TrackerGeometryCompare::createROOTGeometry
void createROOTGeometry(const edm::EventSetup &iSetup)
Definition: TrackerGeometryCompare.cc:281
AlignableTracker::alignments
Alignments * alignments() const
Return alignments, sorted by DetId.
Definition: AlignableTracker.cc:52
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
TrackerGeometryCompare::compareSurfaceDeformations
void compareSurfaceDeformations(TTree *_inputTree11, TTree *_inputTree12)
Definition: TrackerGeometryCompare.cc:465
void TrackerGeometryCompare::beginJob ( void  )
virtual

Read from DB and print survey info.

Reimplemented from edm::EDAnalyzer.

Definition at line 202 of file TrackerGeometryCompare.cc.

References firstEvent_.

202  {
203  firstEvent_ = true;
204 }
void TrackerGeometryCompare::compareGeometries ( Alignable *  refAli,
Alignable *  curAli,
const TrackerTopology *  tTopo,
const edm::EventSetup &  iSetup 
)
private

Definition at line 608 of file TrackerGeometryCompare.cc.

References _weightBy, _weightById, _weightByIdVector, Alignable::alignableObjectId(), trackerTree::check(), Alignable::components(), mps_update::diff, align::diffAlignables(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, MillePedeFileConverter_cfg::e, Exception, fillTree(), Alignable::geomDetId(), mps_fire::i, Alignable::id(), m_theLevels, PV3DBase< T, PVType, FrameType >::mag(), align::moveAlignable(), DetId::rawId(), makeMuonMisalignmentScenario::rot, and RecoTauCleanerPlugins::tolerance.

Referenced by analyze().

608  {
609 
610  using namespace align ;
611 
612  const std::vector<Alignable*>& refComp = refAli->components();
613  const std::vector<Alignable*>& curComp = curAli->components();
614 
615  unsigned int nComp = refComp.size();
616  //only perform for designate levels
617  bool useLevel = false;
618  for (unsigned int i = 0; i < m_theLevels.size(); ++i){
619  if (refAli->alignableObjectId() == m_theLevels[i]) useLevel = true;
620  }
621 
622  //another added level for difference between det and detunit
623  //if ((refAli->alignableObjectId()==2)&&(nComp == 1)) useLevel = false;
624 
625  //coordinate matching, etc etc
626  if (useLevel){
627  DetId detid(refAli->id());
628 
629  CLHEP::Hep3Vector Rtotal, Wtotal, lRtotal, lWtotal;
630  Rtotal.set(0.,0.,0.);
631  Wtotal.set(0.,0.,0.);
632  lRtotal.set(0.,0.,0.);
633  lWtotal.set(0.,0.,0.);
634 
635  for (int i = 0; i < 100; i++){
636  AlgebraicVector diff = align::diffAlignables(refAli, curAli, _weightBy, _weightById, _weightByIdVector);
637  CLHEP::Hep3Vector dR(diff[0],diff[1],diff[2]);
638  Rtotal+=dR;
639  CLHEP::Hep3Vector dW(diff[3],diff[4],diff[5]);
640  CLHEP::HepRotation rot(Wtotal.unit(),Wtotal.mag());
641  CLHEP::HepRotation drot(dW.unit(),dW.mag());
642  rot*=drot;
643  Wtotal.set(rot.axis().x()*rot.delta(), rot.axis().y()*rot.delta(), rot.axis().z()*rot.delta());
644  // local coordinates
645  lRtotal.set(diff[6],diff[7],diff[8]);
646  lWtotal.set(diff[9],diff[10],diff[11]);
647 
648  align::moveAlignable(curAli, diff);
649  float tolerance = 1e-7;
650  AlgebraicVector check = align::diffAlignables(refAli, curAli, _weightBy, _weightById, _weightByIdVector);
651  align::GlobalVector checkR(check[0],check[1],check[2]);
652  align::GlobalVector checkW(check[3],check[4],check[5]);
653  if ((checkR.mag() > tolerance)||(checkW.mag() > tolerance)){
654  edm::LogInfo("TrackerGeometryCompare") << "Tolerance Exceeded!(alObjId: " << refAli->alignableObjectId()
655  << ", rawId: " << refAli->geomDetId().rawId()
656  << ", subdetId: "<< detid.subdetId() << "): " << diff;
657  throw cms::Exception("Tolerance in TrackerGeometryCompare exceeded");
658  }
659  else{
660  break;
661  }
662  }
663 
664  AlgebraicVector TRtot(12);
665  // global
666  TRtot(1) = Rtotal.x(); TRtot(2) = Rtotal.y(); TRtot(3) = Rtotal.z();
667  TRtot(4) = Wtotal.x(); TRtot(5) = Wtotal.y(); TRtot(6) = Wtotal.z();
668  // local
669  TRtot(7) = lRtotal.x(); TRtot(8) = lRtotal.y(); TRtot(9) = lRtotal.z();
670  TRtot(10) = lWtotal.x(); TRtot(11) = lWtotal.y(); TRtot(12) = lWtotal.z();
671 
672  fillTree(refAli, TRtot, tTopo, iSetup);
673  }
674 
675  // another added level for difference between det and detunit
676  for (unsigned int i = 0; i < nComp; ++i)
677  compareGeometries(refComp[i],curComp[i],tTopo,iSetup);
678 
679 }
Alignable::id
align::ID id() const
Return the ID of Alignable, i.e. DetId of &#39;first&#39; component GeomDet(Unit).
Definition: Alignable.h:189
mps_fire.i
i
Definition: mps_fire.py:156
TrackerGeometryCompare::compareGeometries
void compareGeometries(Alignable *refAli, Alignable *curAli, const TrackerTopology *tTopo, const edm::EventSetup &iSetup)
Definition: TrackerGeometryCompare.cc:608
TrackerGeometryCompare::m_theLevels
std::vector< align::StructureType > m_theLevels
Definition: TrackerGeometryCompare.h:75
align::diffAlignables
AlgebraicVector diffAlignables(Alignable *refAli, Alignable *curAli, const std::string &weightBy, bool weightById, const std::vector< unsigned int > &weightByIdVector)
Definition: AlignTools.cc:10
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
Alignable::components
virtual Alignables components() const =0
Return vector of all direct components.
TrackerGeometryCompare::fillTree
void fillTree(Alignable *refAli, const AlgebraicVector &diff, const TrackerTopology *tTopo, const edm::EventSetup &iSetup)
Definition: TrackerGeometryCompare.cc:778
PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.dR
dR
Definition: PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.py:19
DetId
Definition: DetId.h:18
AlgebraicVector
CLHEP::HepVector AlgebraicVector
Definition: AlgebraicObjects.h:12
mps_update.diff
diff
Definition: mps_update.py:85
TrackerGeometryCompare::_weightByIdVector
std::vector< unsigned int > _weightByIdVector
Definition: TrackerGeometryCompare.h:121
trackerTree.check
def check(config)
Definition: trackerTree.py:14
align::moveAlignable
void moveAlignable(Alignable *ali, AlgebraicVector diff)
Moves the alignable by the AlgebraicVector.
Definition: AlignTools.cc:81
Alignable::geomDetId
const DetId & geomDetId() const
Definition: Alignable.h:186
void TrackerGeometryCompare::compareSurfaceDeformations ( TTree *  _inputTree11,
TTree *  _inputTree12 
)
private

Definition at line 465 of file TrackerGeometryCompare.cc.

References _inputFilename1, _inputFilename2, _inputRootFile1, _inputRootFile2, _inputTreenameDeform, _surfDeform, Abs(), cuy::ii, createfilelist::int, m_h1, m_nBins, m_rangeHigh, m_rangeLow, m_vtkmap, and reco::return().

Referenced by analyze().

465  {
466 
467  if (_inputFilename1 != "IDEAL" && _inputFilename2 != "IDEAL") {
468 
469  int inputRawid1;
470  int inputRawid2;
471  int inputSubdetid1, inputSubdetid2 ;
472  int inputDtype1, inputDtype2 ;
473  std::vector<double> inputDpar1;
474  std::vector<double> inputDpar2 ;
475  std::vector<double>* p_inputDpar1 = &inputDpar1;
476  std::vector<double>* p_inputDpar2 = &inputDpar2;
477 
478  TTree* refTree = (TTree*) _inputRootFile1->Get(_inputTreenameDeform.c_str());
479  refTree->SetBranchAddress("irawid", &inputRawid1);
480  refTree->SetBranchAddress("subdetid", &inputSubdetid1);
481  refTree->SetBranchAddress("dtype", &inputDtype1);
482  refTree->SetBranchAddress("dpar", &p_inputDpar1);
483 
484  TTree* curTree = (TTree*) _inputRootFile2->Get(_inputTreenameDeform.c_str());
485  curTree->SetBranchAddress("irawid", &inputRawid2);
486  curTree->SetBranchAddress("subdetid", &inputSubdetid2);
487  curTree->SetBranchAddress("dtype", &inputDtype2);
488  curTree->SetBranchAddress("dpar", &p_inputDpar2);
489 
490  unsigned int nEntries11 = refTree->GetEntries();
491  unsigned int nEntries12 = curTree->GetEntries();
492 
493  if (nEntries11 != nEntries12) {
494  edm::LogError("TrackerGeometryCompare") << " Surface deformation parameters in two geometries differ!\n" ;
495  return ;
496  }
497 
498  for (unsigned int iEntry = 0; iEntry < nEntries12; ++iEntry) {
499  refTree->GetEntry(iEntry) ;
500  curTree->GetEntry(iEntry) ;
501  for (int ii = 0; ii < 13; ++ii) { _surfDeform[ii] = -1.0 ; }
502  for (int npar = 0; npar < int(inputDpar2.size()); ++npar ) {
503  if (inputRawid1 == inputRawid2) {
504  _surfDeform[npar] = inputDpar2.at(npar) - inputDpar1.at(npar) ;
505  std::stringstream histname0 ;
506  histname0 << "SurfDeform_Par_" << npar ;
507  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname0.str()]->Fill(_surfDeform[npar]) ;
508  if (inputSubdetid1 == 1 && inputSubdetid2 == 1) {
509  std::stringstream histname1 ;
510  histname1 << "SurfDeform_PixelBarrel_Par_" << npar ;
511  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname1.str()]->Fill(_surfDeform[npar]) ;
512  }
513  if (inputSubdetid1 == 2 && inputSubdetid2 == 2) {
514  std::stringstream histname2 ;
515  histname2 << "SurfDeform_PixelEndcap_Par_" << npar ;
516  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname2.str()]->Fill(_surfDeform[npar]) ;
517  }
518  (m_vtkmap.at(npar)).fill_current_val(inputRawid1,_surfDeform[npar]) ;
519  }
520  }
521  }
522 
523  } else if ( _inputFilename1 == "IDEAL" && _inputFilename2 != "IDEAL" ) {
524 
525  int inputRawid2;
526  int inputSubdetid2 ;
527  int inputDtype2 ;
528  std::vector<double> inputDpar2 ;
529  std::vector<double>* p_inputDpar2 = &inputDpar2;
530 
531  TTree* curTree = (TTree*) _inputRootFile2->Get(_inputTreenameDeform.c_str());
532  curTree->SetBranchAddress("irawid", &inputRawid2);
533  curTree->SetBranchAddress("subdetid", &inputSubdetid2);
534  curTree->SetBranchAddress("dtype", &inputDtype2);
535  curTree->SetBranchAddress("dpar", &p_inputDpar2);
536 
537  unsigned int nEntries12 = curTree->GetEntries();
538 
539  for (unsigned int iEntry = 0; iEntry < nEntries12; ++iEntry) {
540  curTree->GetEntry(iEntry) ;
541  for (int ii = 0; ii < 12; ++ii) { _surfDeform[ii] = -1.0 ; }
542  for (int npar = 0; npar < int(inputDpar2.size()); ++npar ) {
543  _surfDeform[npar] = inputDpar2.at(npar) ;
544  std::stringstream histname0 ;
545  histname0 << "SurfDeform_Par_" << npar ;
546  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname0.str()]->Fill(_surfDeform[npar]) ;
547  if (inputSubdetid2 == 1) {
548  std::stringstream histname1 ;
549  histname1 << "SurfDeform_PixelBarrel_Par_" << npar ;
550  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname1.str()]->Fill(_surfDeform[npar]) ;
551  }
552  if (inputSubdetid2 == 2) {
553  std::stringstream histname2 ;
554  histname2 << "SurfDeform_PixelEndcap_Par_" << npar ;
555  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname2.str()]->Fill(_surfDeform[npar]) ;
556  }
557  (m_vtkmap.at(npar)).fill_current_val(inputRawid2,_surfDeform[npar]) ;
558  }
559  }
560 
561  } else if ( _inputFilename1 != "IDEAL" && _inputFilename2 == "IDEAL" ) {
562 
563  int inputRawid1;
564  int inputSubdetid1 ;
565  int inputDtype1 ;
566  std::vector<double> inputDpar1;
567  std::vector<double>* p_inputDpar1 = &inputDpar1;
568 
569  TTree* refTree = (TTree*) _inputRootFile1->Get(_inputTreenameDeform.c_str());
570  refTree->SetBranchAddress("irawid", &inputRawid1);
571  refTree->SetBranchAddress("subdetid", &inputSubdetid1);
572  refTree->SetBranchAddress("dtype", &inputDtype1);
573  refTree->SetBranchAddress("dpar", &p_inputDpar1);
574 
575  unsigned int nEntries11 = refTree->GetEntries();
576 
577  for (unsigned int iEntry = 0; iEntry < nEntries11; ++iEntry) {
578  refTree->GetEntry(iEntry) ;
579  for (int ii = 0; ii < 12; ++ii) { _surfDeform[ii] = -1.0 ; }
580  for (int npar = 0; npar < int(inputDpar1.size()); ++npar ) {
581  _surfDeform[npar] = - inputDpar1.at(npar) ;
582  std::stringstream histname0 ;
583  histname0 << "SurfDeform_Par_" << npar ;
584  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname0.str()]->Fill(_surfDeform[npar]) ;
585  if (inputSubdetid1 == 1) {
586  std::stringstream histname1 ;
587  histname1 << "SurfDeform_PixelBarrel_Par_" << npar ;
588  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname1.str()]->Fill(_surfDeform[npar]) ;
589  }
590  if (inputSubdetid1 == 2) {
591  std::stringstream histname2 ;
592  histname2 << "SurfDeform_PixelEndcap_Par_" << npar ;
593  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname2.str()]->Fill(_surfDeform[npar]) ;
594  }
595  (m_vtkmap.at(npar)).fill_current_val(inputRawid1,_surfDeform[npar]) ;
596  }
597  }
598 
599  } else if ( _inputFilename1 == "IDEAL" && _inputFilename2 == "IDEAL" ) {
600 
601  edm::LogInfo("TrackerGeometryCompare") << ">>>> Comparing IDEAL with IDEAL: nothing to do! <<<<\n" ;
602 
603  }
604 
605  return ;
606 }
TrackerGeometryCompare::m_vtkmap
std::vector< TrackerMap > m_vtkmap
Definition: TrackerGeometryCompare.h:163
TrackerGeometryCompare::m_h1
std::map< std::string, TH1D * > m_h1
Definition: TrackerGeometryCompare.h:165
Abs
T Abs(T a)
Definition: MathUtil.h:49
cuy.ii
ii
Definition: cuy.py:588
reco::return
return(e1-e2)*(e1-e2)+dp *dp
void TrackerGeometryCompare::createROOTGeometry ( const edm::EventSetup &  iSetup)
private

Definition at line 281 of file TrackerGeometryCompare.cc.

References _inputFilename1, _inputFilename2, _inputRootFile1, _inputRootFile2, _inputTree01, _inputTree02, _inputTree11, _inputTree12, _inputTreenameAlign, _inputTreenameDeform, _moduleList, _moduleListFile, _moduleListName, GeometryAligner::applyAlignments(), TrackerGeomBuilderFromGeometricDet::build(), SurfaceDeformationFactory::create(), currentTracker, edm::EventSetup::get(), mps_fire::i, geometryCSVtoXML::line, Alignments::m_align, AlignmentErrorsExtended::m_alignError, edm::ESHandle< T >::product(), referenceTracker, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by analyze().

281  {
282 
283  int inputRawId1, inputRawId2;
284  double inputX1, inputY1, inputZ1, inputX2, inputY2, inputZ2;
285  double inputAlpha1, inputBeta1, inputGamma1, inputAlpha2, inputBeta2, inputGamma2;
286 
287  //Retrieve tracker topology from geometry
288  edm::ESHandle<TrackerTopology> tTopoHandle;
289  iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
290  const TrackerTopology* const tTopo = tTopoHandle.product();
291 
292  // Fill module IDs from file into a list
293  _moduleListFile.open(_moduleListName);
294  if (_moduleListFile.is_open()){
295  std::string line;
296  while(!_moduleListFile.eof()){
297  std::getline(_moduleListFile,line);
298  _moduleList.push_back(std::atoi(line.c_str()));
299  }
300  }
301  else{
302  edm::LogInfo("TrackerGeometryCompare") << "Error: Module list not found! Please verify that given list exists!";
303  }
304 
305  //declare alignments
306  Alignments* alignments1 = new Alignments();
307  AlignmentErrorsExtended* alignmentErrors1 = new AlignmentErrorsExtended();
308  if (_inputFilename1 != "IDEAL"){
309  _inputRootFile1 = new TFile(_inputFilename1.c_str());
310  TTree* _inputTree01 = (TTree*) _inputRootFile1->Get(_inputTreenameAlign.c_str());
311  _inputTree01->SetBranchAddress("rawid", &inputRawId1);
312  _inputTree01->SetBranchAddress("x", &inputX1);
313  _inputTree01->SetBranchAddress("y", &inputY1);
314  _inputTree01->SetBranchAddress("z", &inputZ1);
315  _inputTree01->SetBranchAddress("alpha", &inputAlpha1);
316  _inputTree01->SetBranchAddress("beta", &inputBeta1);
317  _inputTree01->SetBranchAddress("gamma", &inputGamma1);
318 
319  int nEntries1 = _inputTree01->GetEntries();
320  //fill alignments
321  for (int i = 0; i < nEntries1; ++i){
322 
323  _inputTree01->GetEntry(i);
324  CLHEP::Hep3Vector translation1(inputX1, inputY1, inputZ1);
325  CLHEP::HepEulerAngles eulerangles1(inputAlpha1,inputBeta1,inputGamma1);
326  uint32_t detid1 = inputRawId1;
327  AlignTransform transform1(translation1, eulerangles1, detid1);
328  alignments1->m_align.push_back(transform1);
329 
330  //dummy errors
331  CLHEP::HepSymMatrix clhepSymMatrix(3,0);
332  AlignTransformErrorExtended transformError(clhepSymMatrix, detid1);
333  alignmentErrors1->m_alignError.push_back(transformError);
334  }
335 
336  // to get the right order
337  std::sort( alignments1->m_align.begin(), alignments1->m_align.end(), lessAlignmentDetId<AlignTransform>() );
338  std::sort( alignmentErrors1->m_alignError.begin(), alignmentErrors1->m_alignError.end(), lessAlignmentDetId<AlignTransformErrorExtended>() );
339  }
340  //------------------
341  Alignments* alignments2 = new Alignments();
342  AlignmentErrorsExtended* alignmentErrors2 = new AlignmentErrorsExtended();
343  if (_inputFilename2 != "IDEAL"){
344  _inputRootFile2 = new TFile(_inputFilename2.c_str());
345  TTree* _inputTree02 = (TTree*) _inputRootFile2->Get(_inputTreenameAlign.c_str());
346  _inputTree02->SetBranchAddress("rawid", &inputRawId2);
347  _inputTree02->SetBranchAddress("x", &inputX2);
348  _inputTree02->SetBranchAddress("y", &inputY2);
349  _inputTree02->SetBranchAddress("z", &inputZ2);
350  _inputTree02->SetBranchAddress("alpha", &inputAlpha2);
351  _inputTree02->SetBranchAddress("beta", &inputBeta2);
352  _inputTree02->SetBranchAddress("gamma", &inputGamma2);
353 
354  int nEntries2 = _inputTree02->GetEntries();
355  //fill alignments
356  for (int i = 0; i < nEntries2; ++i){
357 
358  _inputTree02->GetEntry(i);
359  CLHEP::Hep3Vector translation2(inputX2, inputY2, inputZ2);
360  CLHEP::HepEulerAngles eulerangles2(inputAlpha2,inputBeta2,inputGamma2);
361  uint32_t detid2 = inputRawId2;
362  AlignTransform transform2(translation2, eulerangles2, detid2);
363  alignments2->m_align.push_back(transform2);
364 
365  //dummy errors
366  CLHEP::HepSymMatrix clhepSymMatrix(3,0);
367  AlignTransformErrorExtended transformError(clhepSymMatrix, detid2);
368  alignmentErrors2->m_alignError.push_back(transformError);
369  }
370 
371  //to get the right order
372  std::sort( alignments2->m_align.begin(), alignments2->m_align.end(), lessAlignmentDetId<AlignTransform>() );
373  std::sort( alignmentErrors2->m_alignError.begin(), alignmentErrors2->m_alignError.end(), lessAlignmentDetId<AlignTransformErrorExtended>() );
374  }
375 
376  //accessing the initial geometry
377  edm::ESTransientHandle<DDCompactView> cpv;
378  iSetup.get<IdealGeometryRecord>().get(cpv);
379  edm::ESHandle<GeometricDet> theGeometricDet;
380  iSetup.get<IdealGeometryRecord>().get(theGeometricDet);
381  edm::ESHandle<PTrackerParameters> ptp;
382  iSetup.get<PTrackerParametersRcd>().get( ptp );
383  TrackerGeomBuilderFromGeometricDet trackerBuilder;
384 
385  //reference tracker
386  TrackerGeometry* theRefTracker = trackerBuilder.build(&*theGeometricDet, *ptp, tTopo );
387  if (_inputFilename1 != "IDEAL"){
388  GeometryAligner aligner1;
389  aligner1.applyAlignments<TrackerGeometry>( &(*theRefTracker), &(*alignments1), &(*alignmentErrors1),
390  AlignTransform());
391  }
392  referenceTracker = new AlignableTracker(&(*theRefTracker), tTopo);
393  //referenceTracker->setSurfaceDeformation(surfDef1, true) ;
394 
395  int inputRawid1;
396  int inputRawid2;
397  int inputDtype1, inputDtype2 ;
398  std::vector<double> inputDpar1;
399  std::vector<double> inputDpar2 ;
400  std::vector<double>* p_inputDpar1 = &inputDpar1;
401  std::vector<double>* p_inputDpar2 = &inputDpar2;
402 
403  const std::vector<Alignable*> comp1 = referenceTracker->deepComponents();
404 
405  SurfaceDeformation * surfDef1;
406  if (_inputFilename1 != "IDEAL"){
407  TTree* _inputTree11 = (TTree*) _inputRootFile1->Get(_inputTreenameDeform.c_str());
408  _inputTree11->SetBranchAddress("irawid", &inputRawid1);
409  _inputTree11->SetBranchAddress("dtype", &inputDtype1);
410  _inputTree11->SetBranchAddress("dpar", &p_inputDpar1);
411 
412  unsigned int nEntries11 = _inputTree11->GetEntries();
413  edm::LogInfo("TrackerGeometryCompare") << " nentries11 = " << nEntries11;
414  for (unsigned int iEntry = 0; iEntry < nEntries11; ++iEntry) {
415  _inputTree11->GetEntry(iEntry) ;
416 
417  surfDef1 = SurfaceDeformationFactory::create( inputDtype1, inputDpar1);
418 
419  if (int(comp1[iEntry]->id()) == inputRawid1) {
420  comp1[iEntry]->setSurfaceDeformation(surfDef1, true) ;
421  }
422 
423  }
424  }
425 
426  //currernt tracker
427  TrackerGeometry* theCurTracker = trackerBuilder.build(&*theGeometricDet, *ptp, tTopo);
428  if (_inputFilename2 != "IDEAL"){
429  GeometryAligner aligner2;
430  aligner2.applyAlignments<TrackerGeometry>( &(*theCurTracker), &(*alignments2), &(*alignmentErrors2),
431  AlignTransform());
432  }
433  currentTracker = new AlignableTracker(&(*theCurTracker), tTopo);
434 
435  const std::vector<Alignable*> comp2 = currentTracker->deepComponents();
436 
437  SurfaceDeformation * surfDef2 ;
438  if (_inputFilename2 != "IDEAL"){
439  TTree* _inputTree12 = (TTree*) _inputRootFile2->Get(_inputTreenameDeform.c_str());
440  _inputTree12->SetBranchAddress("irawid", &inputRawid2);
441  _inputTree12->SetBranchAddress("dtype", &inputDtype2);
442  _inputTree12->SetBranchAddress("dpar", &p_inputDpar2);
443 
444  unsigned int nEntries12 = _inputTree12->GetEntries();
445  edm::LogInfo("TrackerGeometryCompare") << " nentries12 = " << nEntries12;
446  for (unsigned int iEntry = 0; iEntry < nEntries12; ++iEntry) {
447  _inputTree12->GetEntry(iEntry) ;
448 
449  surfDef2 = SurfaceDeformationFactory::create( inputDtype2, inputDpar2);
450 
451  if (int(comp2[iEntry]->id()) == inputRawid2) {
452  comp2[iEntry]->setSurfaceDeformation(surfDef2, true) ;
453  }
454 
455  }
456  }
457 
458  delete alignments1;
459  delete alignmentErrors1;
460  delete alignments2;
461  delete alignmentErrors2;
462 
463 }
mps_fire.i
i
Definition: mps_fire.py:156
GeometryAligner
Class to update a given geometry with a set of alignments.
Definition: GeometryAligner.h:33
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackerGeomBuilderFromGeometricDet::build
TrackerGeometry * build(const GeometricDet *gd, const PTrackerParameters &ptp, const TrackerTopology *tTopo)
Definition: TrackerGeomBuilderFromGeometricDet.cc:42
Alignments::m_align
std::vector< AlignTransform > m_align
Definition: Alignments.h:19
GeometryAligner::applyAlignments
void applyAlignments(C *geometry, const Alignments *alignments, const AlignmentErrorsExtended *alignmentErrors, const AlignTransform &globalCoordinates)
Definition: GeometryAligner.h:55
TrackerGeometryCompare::currentTracker
AlignableTracker * currentTracker
Definition: TrackerGeometryCompare.h:101
AlignmentErrorsExtended::m_alignError
std::vector< AlignTransformErrorExtended > m_alignError
Definition: AlignmentErrorsExtended.h:19
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
TrackerGeometryCompare::referenceTracker
AlignableTracker * referenceTracker
Definition: TrackerGeometryCompare.h:99
TrackerGeometryCompare::_moduleList
std::vector< int > _moduleList
Definition: TrackerGeometryCompare.h:130
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
SurfaceDeformationFactory::create
SurfaceDeformation * create(int type, const std::vector< double > &params)
Definition: SurfaceDeformationFactory.cc:41
void TrackerGeometryCompare::diffCommonTrackerSystem ( Alignable *  refAli,
Alignable *  curAli 
)
private

Definition at line 719 of file TrackerGeometryCompare.cc.

References _commonTrackerLevel, _TrackerCommonCM, _TrackerCommonR, _TrackerCommonT, _weightBy, _weightById, _weightByIdVector, Alignable::alignableObjectId(), Alignable::components(), mps_update::diff, align::diffAlignables(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, Alignable::globalPosition(), mps_fire::i, and makeMuonMisalignmentScenario::rot.

Referenced by setCommonTrackerSystem().

719  {
720 
721  const std::vector<Alignable*>& refComp = refAli->components();
722  const std::vector<Alignable*>& curComp = curAli->components();
723 
724  unsigned int nComp = refComp.size();
725  //only perform for designate levels
726  bool useLevel = false;
727  if (refAli->alignableObjectId() == _commonTrackerLevel) useLevel = true;
728 
729  //useLevel = false;
730  if (useLevel){
731  CLHEP::Hep3Vector Rtotal, Wtotal;
732  Rtotal.set(0.,0.,0.); Wtotal.set(0.,0.,0.);
733 
734  AlgebraicVector diff = align::diffAlignables(refAli, curAli, _weightBy, _weightById, _weightByIdVector);
735  CLHEP::Hep3Vector dR(diff[0],diff[1],diff[2]);
736  Rtotal+=dR;
737  CLHEP::Hep3Vector dW(diff[3],diff[4],diff[5]);
738  CLHEP::HepRotation rot(Wtotal.unit(),Wtotal.mag());
739  CLHEP::HepRotation drot(dW.unit(),dW.mag());
740  rot*=drot;
741  Wtotal.set(rot.axis().x()*rot.delta(), rot.axis().y()*rot.delta(), rot.axis().z()*rot.delta());
742  /*
743  //std::cout << "a";
744  //if (refAli->alignableObjectId() == 1) std::cout << "DIFF: " << diff << std::endl;
745  align::moveAlignable(curAli, diff);
746  float tolerance = 1e-7;
747  AlgebraicVector check = align::diffAlignables(refAli,curAli, _weightBy, _weightById, _weightByIdVector);
748  align::GlobalVector checkR(check[0],check[1],check[2]);
749  align::GlobalVector checkW(check[3],check[4],check[5]);
750  DetId detid(refAli->id());
751  if ((checkR.mag() > tolerance)||(checkW.mag() > tolerance)){
752  edm::LogInfo("TrackerGeometryCompare") << "Tolerance Exceeded!(alObjId: " << refAli->alignableObjectId()
753  << ", rawId: " << refAli->geomDetId().rawId()
754  << ", subdetId: "<< detid.subdetId() << "): " << diff;
755  }
756  else{
757  break;
758  }
759  }
760  */
761 
762  //_TrackerCommonT.set(Rtotal.x(), Rtotal.y(), Rtotal.z());
763  _TrackerCommonT = align::GlobalVector(Rtotal.x(), Rtotal.y(), Rtotal.z());
764  _TrackerCommonR = align::GlobalVector(Wtotal.x(), Wtotal.y(), Wtotal.z());
765  _TrackerCommonCM = curAli->globalPosition();
766  //_TrackerCommonTR(1) = Rtotal.x(); _TrackerCommonTR(2) = Rtotal.y(); _TrackerCommonTR(3) = Rtotal.z();
767  //_TrackerCommonTR(4) = Wtotal.x(); _TrackerCommonTR(5) = Wtotal.y(); _TrackerCommonTR(6) = Wtotal.z();
768 
769 
770  }
771  else{
772  for (unsigned int i = 0; i < nComp; ++i) diffCommonTrackerSystem(refComp[i],curComp[i]);
773  }
774 
775 
776 }
TrackerGeometryCompare::_TrackerCommonR
align::GlobalVector _TrackerCommonR
Definition: TrackerGeometryCompare.h:126
mps_fire.i
i
Definition: mps_fire.py:156
align::GlobalVector
Vector3DBase< Scalar, GlobalTag > GlobalVector
Definition: Definitions.h:33
TrackerGeometryCompare::_TrackerCommonT
align::GlobalVector _TrackerCommonT
Definition: TrackerGeometryCompare.h:125
align::diffAlignables
AlgebraicVector diffAlignables(Alignable *refAli, Alignable *curAli, const std::string &weightBy, bool weightById, const std::vector< unsigned int > &weightByIdVector)
Definition: AlignTools.cc:10
TrackerGeometryCompare::diffCommonTrackerSystem
void diffCommonTrackerSystem(Alignable *refAli, Alignable *curAli)
Definition: TrackerGeometryCompare.cc:719
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
Alignable::components
virtual Alignables components() const =0
Return vector of all direct components.
TrackerGeometryCompare::_commonTrackerLevel
align::StructureType _commonTrackerLevel
Definition: TrackerGeometryCompare.h:124
TrackerGeometryCompare::_TrackerCommonCM
align::PositionType _TrackerCommonCM
Definition: TrackerGeometryCompare.h:127
PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.dR
dR
Definition: PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.py:19
AlgebraicVector
CLHEP::HepVector AlgebraicVector
Definition: AlgebraicObjects.h:12
mps_update.diff
diff
Definition: mps_update.py:85
TrackerGeometryCompare::_weightByIdVector
std::vector< unsigned int > _weightByIdVector
Definition: TrackerGeometryCompare.h:121
Alignable::globalPosition
const PositionType & globalPosition() const
Return the global position of the object.
Definition: Alignable.h:138
void TrackerGeometryCompare::endJob ( void  )
virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 206 of file TrackerGeometryCompare.cc.

References _alignTree, _theFile, m_vtkmap, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by o2olib.O2ORunMgr::executeJob().

206  {
207 
208  int iname(0) ;
209  for (std::vector<TrackerMap>::iterator it = m_vtkmap.begin(); it != m_vtkmap.end(); ++it) {
210  std::stringstream mapname ;
211  mapname << "TkMap_SurfDeform" << iname << ".png" ;
212  it->save(true,0,0,mapname.str());
213  mapname.str( std::string() );
214  mapname.clear() ;
215  mapname << "TkMap_SurfDeform" << iname << ".pdf" ;
216  it->save(true,0,0,mapname.str());
217  ++iname ;
218  }
219 
220  _theFile->cd();
221  _alignTree->Write();
222  _theFile->Close();
223 
224 }
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackerGeometryCompare::m_vtkmap
std::vector< TrackerMap > m_vtkmap
Definition: TrackerGeometryCompare.h:163
void TrackerGeometryCompare::fillIdentifiers ( int  subdetlevel,
int  rawid,
const TrackerTopology *  tTopo 
)
private

Definition at line 986 of file TrackerGeometryCompare.cc.

References _identifiers, DEFINE_FWK_MODULE, TrackerTopology::pxbLadder(), TrackerTopology::pxbLayer(), TrackerTopology::pxbModule(), TrackerTopology::pxfBlade(), TrackerTopology::pxfDisk(), TrackerTopology::pxfModule(), TrackerTopology::pxfPanel(), TrackerTopology::pxfSide(), TrackerTopology::tecModule(), TrackerTopology::tecPetalInfo(), TrackerTopology::tecRing(), TrackerTopology::tecSide(), TrackerTopology::tecWheel(), TrackerTopology::tibLayer(), TrackerTopology::tibModule(), TrackerTopology::tibStringInfo(), TrackerTopology::tidModuleInfo(), TrackerTopology::tidRing(), TrackerTopology::tidSide(), TrackerTopology::tidWheel(), TrackerTopology::tobLayer(), TrackerTopology::tobModule(), and TrackerTopology::tobRodInfo().

Referenced by fillTree().

986  {
987 
988 
989  switch( subdetlevel ){
990 
991  case 1:
992  {
993 
994  _identifiers[0] = tTopo->pxbModule( rawid );
995  _identifiers[1] = tTopo->pxbLadder( rawid );
996  _identifiers[2] = tTopo->pxbLayer( rawid );
997  _identifiers[3] = 999;
998  _identifiers[4] = 999;
999  _identifiers[5] = 999;
1000  break;
1001  }
1002  case 2:
1003  {
1004 
1005  _identifiers[0] = tTopo->pxfModule( rawid );
1006  _identifiers[1] = tTopo->pxfPanel( rawid );
1007  _identifiers[2] = tTopo->pxfBlade( rawid );
1008  _identifiers[3] = tTopo->pxfDisk( rawid );
1009  _identifiers[4] = tTopo->pxfSide( rawid );
1010  _identifiers[5] = 999;
1011  break;
1012  }
1013  case 3:
1014  {
1015 
1016  _identifiers[0] = tTopo->tibModule( rawid );
1017  _identifiers[1] = tTopo->tibStringInfo( rawid )[0];
1018  _identifiers[2] = tTopo->tibStringInfo( rawid )[1];
1019  _identifiers[3] = tTopo->tibStringInfo( rawid )[2];
1020  _identifiers[4] = tTopo->tibLayer( rawid );
1021  _identifiers[5] = 999;
1022  break;
1023  }
1024  case 4:
1025  {
1026 
1027  _identifiers[0] = tTopo->tidModuleInfo( rawid )[0];
1028  _identifiers[1] = tTopo->tidModuleInfo( rawid )[1];
1029  _identifiers[2] = tTopo->tidRing( rawid );
1030  _identifiers[3] = tTopo->tidWheel( rawid );
1031  _identifiers[4] = tTopo->tidSide( rawid );
1032  _identifiers[5] = 999;
1033  break;
1034  }
1035  case 5:
1036  {
1037 
1038  _identifiers[0] = tTopo->tobModule( rawid );
1039  _identifiers[1] = tTopo->tobRodInfo( rawid )[0];
1040  _identifiers[2] = tTopo->tobRodInfo( rawid )[1];
1041  _identifiers[3] = tTopo->tobLayer( rawid );
1042  _identifiers[4] = 999;
1043  _identifiers[5] = 999;
1044  break;
1045  }
1046  case 6:
1047  {
1048 
1049  _identifiers[0] = tTopo->tecModule( rawid );
1050  _identifiers[1] = tTopo->tecRing( rawid );
1051  _identifiers[2] = tTopo->tecPetalInfo( rawid )[0];
1052  _identifiers[3] = tTopo->tecPetalInfo( rawid )[1];
1053  _identifiers[4] = tTopo->tecWheel( rawid );
1054  _identifiers[5] = tTopo->tecSide( rawid );
1055  break;
1056  }
1057  default:
1058  {
1059  edm::LogInfo("TrackerGeometryCompare") << "Error: bad subdetid!!";
1060  break;
1061  }
1062 
1063  }
1064 }
TrackerTopology::tibLayer
unsigned int tibLayer(const DetId &id) const
Definition: TrackerTopology.h:150
TrackerTopology::tidRing
unsigned int tidRing(const DetId &id) const
Definition: TrackerTopology.h:229
TrackerTopology::tidModuleInfo
std::vector< unsigned int > tidModuleInfo(const DetId &id) const
Definition: TrackerTopology.h:440
TrackerTopology::pxfDisk
unsigned int pxfDisk(const DetId &id) const
Definition: TrackerTopology.h:455
TrackerTopology::tecRing
unsigned int tecRing(const DetId &id) const
ring id
Definition: TrackerTopology.h:226
TrackerTopology::pxbLadder
unsigned int pxbLadder(const DetId &id) const
Definition: TrackerTopology.h:155
TrackerTopology::tidWheel
unsigned int tidWheel(const DetId &id) const
Definition: TrackerTopology.h:209
TrackerTopology::pxbModule
unsigned int pxbModule(const DetId &id) const
Definition: TrackerTopology.h:160
TrackerTopology::tibStringInfo
std::vector< unsigned int > tibStringInfo(const DetId &id) const
Definition: TrackerTopology.h:423
TrackerTopology::tecPetalInfo
std::vector< unsigned int > tecPetalInfo(const DetId &id) const
Definition: TrackerTopology.h:405
TrackerTopology::tidSide
unsigned int tidSide(const DetId &id) const
Definition: TrackerTopology.h:192
TrackerTopology::tobRodInfo
std::vector< unsigned int > tobRodInfo(const DetId &id) const
Definition: TrackerTopology.h:242
TrackerTopology::tibModule
unsigned int tibModule(const DetId &id) const
Definition: TrackerTopology.h:172
TrackerTopology::pxfModule
unsigned int pxfModule(const DetId &id) const
Definition: TrackerTopology.h:163
TrackerTopology::pxbLayer
unsigned int pxbLayer(const DetId &id) const
Definition: TrackerTopology.h:144
TrackerTopology::tecModule
unsigned int tecModule(const DetId &id) const
Definition: TrackerTopology.h:169
TrackerTopology::tobModule
unsigned int tobModule(const DetId &id) const
Definition: TrackerTopology.h:166
TrackerTopology::pxfSide
unsigned int pxfSide(const DetId &id) const
Definition: TrackerTopology.h:196
TrackerTopology::tecWheel
unsigned int tecWheel(const DetId &id) const
Definition: TrackerTopology.h:206
TrackerTopology::pxfPanel
unsigned int pxfPanel(const DetId &id) const
Definition: TrackerTopology.h:461
TrackerTopology::pxfBlade
unsigned int pxfBlade(const DetId &id) const
Definition: TrackerTopology.h:458
TrackerTopology::tobLayer
unsigned int tobLayer(const DetId &id) const
Definition: TrackerTopology.h:147
TrackerTopology::tecSide
unsigned int tecSide(const DetId &id) const
Definition: TrackerTopology.h:184
void TrackerGeometryCompare::fillTree ( Alignable *  refAli,
const AlgebraicVector &  diff,
const TrackerTopology *  tTopo,
const edm::EventSetup &  iSetup 
)
private

Definition at line 778 of file TrackerGeometryCompare.cc.

References _alignTree, _alphaVal, _badModuleQuality, _betaVal, _dalphaVal, _daVal, _dbetaVal, _dbVal, _detDim, _detIdFlag, _dgammaVal, _dgVal, _dphiVal, _drVal, _duVal, _dvVal, _dwVal, _dxVal, _dyVal, _dzVal, _etaVal, _gammaVal, _id, _inModuleList, _level, _mid, _mlevel, _moduleList, _phiVal, _rVal, _sublevel, _surLength, _surRot, _surWidth, _useDetId, _xVal, _yVal, _zVal, align::AlignableDet, align::AlignableDetUnit, Alignable::alignableObjectId(), PV3DBase< T, PVType, FrameType >::eta(), fillIdentifiers(), g, Alignable::geomDetId(), edm::EventSetup::get(), Alignable::globalPosition(), Alignable::globalRotation(), mps_fire::i, Alignable::id(), SiStripQuality::IsModuleBad(), SiPixelQuality::IsModuleBad(), AlignableSurface::length(), Alignable::mother(), passIdCut(), PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), DetId::rawId(), makeMuonMisalignmentScenario::rot, DetId::subdetId(), Alignable::surface(), align::toAngles(), AlignableSurface::width(), PV3DBase< T, PVType, FrameType >::x(), TkRotation< T >::xx(), TkRotation< T >::xy(), TkRotation< T >::xz(), PV3DBase< T, PVType, FrameType >::y(), TkRotation< T >::yx(), TkRotation< T >::yy(), TkRotation< T >::yz(), PV3DBase< T, PVType, FrameType >::z(), TkRotation< T >::zx(), TkRotation< T >::zy(), and TkRotation< T >::zz().

Referenced by compareGeometries(), and core.AutoFillTreeProducer.AutoFillTreeProducer::process().

778  {
779 
780  //Get bad modules
781  edm::ESHandle<SiPixelQuality> SiPixelModules;
782  iSetup.get<SiPixelQualityRcd>().get(SiPixelModules);
783  edm::ESHandle<SiStripQuality> SiStripModules;
784  iSetup.get<SiStripQualityRcd>().get(SiStripModules);
785 
786  _id = refAli->id();
787 
788  _badModuleQuality = 0;
789  //check if module has a bad quality tag
790  if (SiPixelModules->IsModuleBad(_id)){
791  _badModuleQuality = 1;
792 
793  }
794  if (SiStripModules->IsModuleBad(_id)){
795  _badModuleQuality = 1;
796  }
797 
798  //check if module is in a given list of bad/untouched etc. modules
799  _inModuleList = 0;
800  for (unsigned int i = 0 ; i< _moduleList.size(); i++){
801  if ( _moduleList[i] == _id)
802  {
803  _inModuleList = 1;
804  break;
805  }
806  }
807 
808  _level = refAli->alignableObjectId();
809  //need if ali has no mother
810  if (refAli->mother()){
811  _mid = refAli->mother()->geomDetId().rawId();
812  _mlevel = refAli->mother()->alignableObjectId();
813  }
814  else{
815  _mid = -1;
816  _mlevel = -1;
817  }
818  DetId detid(_id);
819  _sublevel = detid.subdetId();
820  fillIdentifiers(_sublevel, _id , tTopo);
821  _xVal = refAli->globalPosition().x();
822  _yVal = refAli->globalPosition().y();
823  _zVal = refAli->globalPosition().z();
824  align::GlobalVector vec(_xVal,_yVal,_zVal);
825  _rVal = vec.perp();
826  _phiVal = vec.phi();
827  _etaVal = vec.eta();
828  align::RotationType rot = refAli->globalRotation();
829  align::EulerAngles eulerAngles = align::toAngles(rot);
830  _alphaVal = eulerAngles[0];
831  _betaVal = eulerAngles[1];
832  _gammaVal = eulerAngles[2];
833  // global
834  _dxVal = diff[0];
835  _dyVal = diff[1];
836  _dzVal = diff[2];
837  // local
838  _duVal = diff[6];
839  _dvVal = diff[7];
840  _dwVal = diff[8];
841  //...TODO...
842  align::GlobalVector g(_dxVal, _dyVal, _dzVal);
843  //getting dR and dPhi
844  align::GlobalVector vRef(_xVal,_yVal,_zVal);
845  align::GlobalVector vCur(_xVal + _dxVal, _yVal + _dyVal, _zVal + _dzVal);
846  _drVal = vCur.perp() - vRef.perp();
847  _dphiVal = vCur.phi() - vRef.phi();
848  // global
849  _dalphaVal = diff[3];
850  _dbetaVal = diff[4];
851  _dgammaVal = diff[5];
852  // local
853  _daVal = diff[9];
854  _dbVal = diff[10];
855  _dgVal = diff[11];
856 
857  //detIdFlag
858  if (refAli->alignableObjectId() == align::AlignableDetUnit){
859  if (_detIdFlag){
860  if ((passIdCut(refAli->id()))||(passIdCut(refAli->mother()->id()))){
861  _useDetId = 1;
862  }
863  else{
864  _useDetId = 0;
865  }
866  }
867  }
868  // det module dimension
869  if (refAli->alignableObjectId() == align::AlignableDetUnit){
870  if (refAli->mother()->alignableObjectId() != align::AlignableDet) _detDim = 1;
871  else if (refAli->mother()->alignableObjectId() == align::AlignableDet) _detDim = 2;
872  }
873  else _detDim = 0;
874 
875  _surWidth = refAli->surface().width();
876  _surLength = refAli->surface().length();
877  align::RotationType rt = refAli->globalRotation();
878  _surRot[0] = rt.xx(); _surRot[1] = rt.xy(); _surRot[2] = rt.xz();
879  _surRot[3] = rt.yx(); _surRot[4] = rt.yy(); _surRot[5] = rt.yz();
880  _surRot[6] = rt.zx(); _surRot[7] = rt.zy(); _surRot[8] = rt.zz();
881 
882  //Fill
883  _alignTree->Fill();
884 
885 }
TkRotation::xx
T xx() const
Definition: extTkRotation.h:251
AlignableSurface::width
align::Scalar width() const
Definition: AlignableSurface.h:36
Alignable::id
align::ID id() const
Return the ID of Alignable, i.e. DetId of &#39;first&#39; component GeomDet(Unit).
Definition: Alignable.h:189
mps_fire.i
i
Definition: mps_fire.py:156
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
TkRotation::yx
T yx() const
Definition: extTkRotation.h:254
Alignable::globalRotation
const RotationType & globalRotation() const
Return the global orientation of the object.
Definition: Alignable.h:141
g
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g
Definition: Activities.doc:4
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
TkRotation::zx
T zx() const
Definition: extTkRotation.h:257
TkRotation::xy
T xy() const
Definition: extTkRotation.h:252
TkRotation::zz
T zz() const
Definition: extTkRotation.h:259
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
TkRotation::zy
T zy() const
Definition: extTkRotation.h:258
SiStripQuality::IsModuleBad
bool IsModuleBad(const uint32_t &detid) const
Definition: SiStripQuality.cc:601
align::toAngles
EulerAngles toAngles(const RotationType &)
Convert rotation matrix to angles about x-, y-, z-axes (frame rotation).
Definition: Utilities.cc:9
TkRotation::yy
T yy() const
Definition: extTkRotation.h:255
SiPixelQuality::IsModuleBad
bool IsModuleBad(const uint32_t &detid) const
Definition: SiPixelQuality.cc:105
Alignable::surface
const AlignableSurface & surface() const
Return the Surface (global position and orientation) of the object.
Definition: Alignable.h:135
DetId
Definition: DetId.h:18
align::EulerAngles
AlgebraicVector EulerAngles
Definition: Definitions.h:36
AlignableSurface::length
align::Scalar length() const
Definition: AlignableSurface.h:38
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
TrackerGeometryCompare::fillIdentifiers
void fillIdentifiers(int subdetlevel, int rawid, const TrackerTopology *tTopo)
Definition: TrackerGeometryCompare.cc:986
mps_update.diff
diff
Definition: mps_update.py:85
TkRotation::xz
T xz() const
Definition: extTkRotation.h:253
Alignable::globalPosition
const PositionType & globalPosition() const
Return the global position of the object.
Definition: Alignable.h:138
TrackerGeometryCompare::_moduleList
std::vector< int > _moduleList
Definition: TrackerGeometryCompare.h:130
PV3DBase::x
T x() const
Definition: PV3DBase.h:62
Alignable::mother
Alignable * mother() const
Return pointer to container alignable (if any)
Definition: Alignable.h:94
TkRotation::yz
T yz() const
Definition: extTkRotation.h:256
Alignable::geomDetId
const DetId & geomDetId() const
Definition: Alignable.h:186
bool TrackerGeometryCompare::passIdCut ( uint32_t  id)
private

Definition at line 973 of file TrackerGeometryCompare.cc.

References _detIdFlagVector, and mps_fire::i.

Referenced by fillTree().

973  {
974 
975  bool pass = false;
976  int nEntries = _detIdFlagVector.size();
977 
978  for (int i = 0; i < nEntries; i++){
979  if (_detIdFlagVector[i] == id) pass = true;
980  }
981 
982  return pass;
983 
984 }
mps_fire.i
i
Definition: mps_fire.py:156
TrackerGeometryCompare::_detIdFlagVector
std::vector< uint32_t > _detIdFlagVector
Definition: TrackerGeometryCompare.h:123
void TrackerGeometryCompare::setCommonTrackerSystem ( )
private

Definition at line 681 of file TrackerGeometryCompare.cc.

References _commonTrackerLevel, _setCommonTrackerSystem, _TrackerCommonCM, _TrackerCommonR, _TrackerCommonT, currentTracker, diffCommonTrackerSystem(), Alignable::globalPosition(), align::moveAlignable(), AlignableTracker::objectIdProvider(), referenceTracker, makeMuonMisalignmentScenario::rot, AlignableObjectId::stringToId(), align::toMatrix(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

681  {
682 
683  edm::LogInfo("TrackerGeometryCompare") << "Setting Common Tracker System....";
684 
685  // DM_534??AlignableObjectId dummy;
686  // DM_534??_commonTrackerLevel = dummy.nameToType(_setCommonTrackerSystem);
687  _commonTrackerLevel = currentTracker->objectIdProvider().stringToId(_setCommonTrackerSystem);
688 
689  diffCommonTrackerSystem(referenceTracker, currentTracker);
690 
691  align::EulerAngles dOmega(3); dOmega[0] = _TrackerCommonR.x() ; dOmega[1] = _TrackerCommonR.y(); dOmega[2] = _TrackerCommonR.z();
692  align::RotationType rot = align::toMatrix( dOmega );
693  align::GlobalVector theR = _TrackerCommonT;
694 
695  edm::LogInfo("TrackerGeometryCompare") << "what we get from overlaying the pixels..." << theR << ", " << rot;
696 
697  //transform to the Tracker System
698  align::PositionType trackerCM = currentTracker->globalPosition();
699  align::GlobalVector cmDiff( trackerCM.x()-_TrackerCommonCM.x(), trackerCM.y()-_TrackerCommonCM.y(), trackerCM.z()-_TrackerCommonCM.z() );
700 
701  edm::LogInfo("TrackerGeometryCompare") << "Pixel CM: " << _TrackerCommonCM << ", tracker CM: " << trackerCM;
702 
703  //adjust translational difference factoring in different rotational CM
704  //needed because rotateInGlobalFrame is about CM of alignable, not Tracker
705  const align::GlobalVector::BasicVectorType& lpvgf = cmDiff.basicVector();
706  align::GlobalVector moveV( rot.multiplyInverse(lpvgf) - lpvgf);
707  align::GlobalVector theRprime(theR + moveV);
708 
709  AlgebraicVector TrackerCommonTR(6);
710  TrackerCommonTR(1) = theRprime.x(); TrackerCommonTR(2) = theRprime.y(); TrackerCommonTR(3) = theRprime.z();
711  TrackerCommonTR(4) = _TrackerCommonR.x(); TrackerCommonTR(5) = _TrackerCommonR.y(); TrackerCommonTR(6) = _TrackerCommonR.z();
712 
713  edm::LogInfo("TrackerGeometryCompare") << "and after the transformation: " << TrackerCommonTR;
714 
715  align::moveAlignable(currentTracker, TrackerCommonTR );
716 
717 }
AlignableObjectId::stringToId
align::StructureType stringToId(const char *) const
Definition: AlignableObjectId.cc:296
TrackerGeometryCompare::_TrackerCommonR
align::GlobalVector _TrackerCommonR
Definition: TrackerGeometryCompare.h:126
TrackerGeometryCompare::_TrackerCommonT
align::GlobalVector _TrackerCommonT
Definition: TrackerGeometryCompare.h:125
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
TrackerGeometryCompare::diffCommonTrackerSystem
void diffCommonTrackerSystem(Alignable *refAli, Alignable *curAli)
Definition: TrackerGeometryCompare.cc:719
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
TrackerGeometryCompare::_commonTrackerLevel
align::StructureType _commonTrackerLevel
Definition: TrackerGeometryCompare.h:124
AlignableTracker::objectIdProvider
const AlignableObjectId & objectIdProvider() const
Return tracker alignable object ID provider derived from the tracker&#39;s geometry.
Definition: AlignableTracker.h:171
TrackerGeometryCompare::_TrackerCommonCM
align::PositionType _TrackerCommonCM
Definition: TrackerGeometryCompare.h:127
AlgebraicVector
CLHEP::HepVector AlgebraicVector
Definition: AlgebraicObjects.h:12
align::EulerAngles
AlgebraicVector EulerAngles
Definition: Definitions.h:36
TrackerGeometryCompare::currentTracker
AlignableTracker * currentTracker
Definition: TrackerGeometryCompare.h:101
TrackerGeometryCompare::referenceTracker
AlignableTracker * referenceTracker
Definition: TrackerGeometryCompare.h:99
align::toMatrix
RotationType toMatrix(const EulerAngles &)
Convert rotation angles about x-, y-, z-axes to matrix.
Definition: Utilities.cc:42
Alignable::globalPosition
const PositionType & globalPosition() const
Return the global position of the object.
Definition: Alignable.h:138
PV3DBase::x
T x() const
Definition: PV3DBase.h:62
align::moveAlignable
void moveAlignable(Alignable *ali, AlgebraicVector diff)
Moves the alignable by the AlgebraicVector.
Definition: AlignTools.cc:81
void TrackerGeometryCompare::surveyToTracker ( AlignableTracker *  ali,
Alignments *  alignVals,
AlignmentErrorsExtended *  alignErrors 
)
private

Definition at line 887 of file TrackerGeometryCompare.cc.

References AlCaHLTBitMon_QueryRunRegistry::comp, popcon2dropbox::copy(), AlignableTracker::endcapGeomDets(), mps_fire::i, AlignableTracker::innerBarrelGeomDets(), gen::k, Alignments::m_align, AlignmentErrorsExtended::m_alignError, AlignableTracker::outerBarrelGeomDets(), AlignableTracker::pixelEndcapGeomDets(), AlignableTracker::pixelHalfBarrelGeomDets(), SurveyDet::position(), makeMuonMisalignmentScenario::rot, SurveyDet::rotation(), AlignableTracker::TIDGeomDets(), and create_public_lumi_plots::transform.

887  {
888 
889  //getting the right alignables for the alignment record
890  std::vector<Alignable*> detPB = ali->pixelHalfBarrelGeomDets();
891  std::vector<Alignable*> detPEC = ali->pixelEndcapGeomDets();
892  std::vector<Alignable*> detTIB = ali->innerBarrelGeomDets();
893  std::vector<Alignable*> detTID = ali->TIDGeomDets();
894  std::vector<Alignable*> detTOB = ali->outerBarrelGeomDets();
895  std::vector<Alignable*> detTEC = ali->endcapGeomDets();
896 
897  std::vector<Alignable*> allGeomDets;
898  std::copy(detPB.begin(), detPB.end(), std::back_inserter(allGeomDets));
899  std::copy(detPEC.begin(), detPEC.end(), std::back_inserter(allGeomDets));
900  std::copy(detTIB.begin(), detTIB.end(), std::back_inserter(allGeomDets));
901  std::copy(detTID.begin(), detTID.end(), std::back_inserter(allGeomDets));
902  std::copy(detTOB.begin(), detTOB.end(), std::back_inserter(allGeomDets));
903  std::copy(detTEC.begin(), detTEC.end(), std::back_inserter(allGeomDets));
904 
905  std::vector<Alignable*> rcdAlis;
906  for (std::vector<Alignable*>::iterator i = allGeomDets.begin(); i!= allGeomDets.end(); i++){
907  if ((*i)->components().size() == 1){
908  rcdAlis.push_back((*i));
909  }
910  else if ((*i)->components().size() > 1){
911  rcdAlis.push_back((*i));
912  std::vector<Alignable*> comp = (*i)->components();
913  for (std::vector<Alignable*>::iterator j = comp.begin(); j != comp.end(); j++){
914  rcdAlis.push_back((*j));
915  }
916  }
917  }
918 
919  //turning them into alignments
920  for(std::vector<Alignable*>::iterator k = rcdAlis.begin(); k != rcdAlis.end(); k++){
921 
922  const SurveyDet* surveyInfo = (*k)->survey();
923  const align::PositionType& pos(surveyInfo->position());
924  align::RotationType rot(surveyInfo->rotation());
925  CLHEP::Hep3Vector clhepVector(pos.x(),pos.y(),pos.z());
926  CLHEP::HepRotation clhepRotation( CLHEP::HepRep3x3(rot.xx(),rot.xy(),rot.xz(),rot.yx(),rot.yy(),rot.yz(),rot.zx(),rot.zy(),rot.zz()));
927  AlignTransform transform(clhepVector, clhepRotation, (*k)->id());
928  AlignTransformErrorExtended transformError(CLHEP::HepSymMatrix(3,1), (*k)->id());
929  alignVals->m_align.push_back(transform);
930  alignErrors->m_alignError.push_back(transformError);
931  }
932 
933  //to get the right order
934  std::sort( alignVals->m_align.begin(), alignVals->m_align.end(), lessAlignmentDetId<AlignTransform>() );
935  std::sort( alignErrors->m_alignError.begin(), alignErrors->m_alignError.end(), lessAlignmentDetId<AlignTransformErrorExtended>() );
936 
937 }
AlignableTracker::pixelHalfBarrelGeomDets
Alignables & pixelHalfBarrelGeomDets()
Return pixel barrel GeomDets.
Definition: AlignableTracker.h:84
mps_fire.i
i
Definition: mps_fire.py:156
Alignments::m_align
std::vector< AlignTransform > m_align
Definition: Alignments.h:19
SurveyDet::rotation
const align::RotationType & rotation() const
Definition: SurveyDet.h:68
SurveyDet::position
const align::PositionType & position() const
Definition: SurveyDet.h:63
AlignableTracker::innerBarrelGeomDets
Alignables & innerBarrelGeomDets()
Return inner barrel GeomDets.
Definition: AlignableTracker.h:76
AlignableTracker::TIDGeomDets
Alignables & TIDGeomDets()
Return TID GeomDets.
Definition: AlignableTracker.h:92
AlCaHLTBitMon_QueryRunRegistry.comp
comp
Definition: AlCaHLTBitMon_QueryRunRegistry.py:248
AlignableTracker::endcapGeomDets
Alignables & endcapGeomDets()
Return endcap GeomDets.
Definition: AlignableTracker.h:88
create_public_lumi_plots.transform
transform
Definition: create_public_lumi_plots.py:1267
AlignableTracker::pixelEndcapGeomDets
Alignables & pixelEndcapGeomDets()
Return pixel endcap GeomDets.
Definition: AlignableTracker.h:96
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:79
AlignableTracker::outerBarrelGeomDets
Alignables & outerBarrelGeomDets()
Return outer barrel GeomDets.
Definition: AlignableTracker.h:80
AlignmentErrorsExtended::m_alignError
std::vector< AlignTransformErrorExtended > m_alignError
Definition: AlignmentErrorsExtended.h:19

Member Data Documentation

TTree* TrackerGeometryCompare::_alignTree
private

Definition at line 136 of file TrackerGeometryCompare.h.

Referenced by endJob(), fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_alphaVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_badModuleQuality
private

Definition at line 145 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_betaVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

align::StructureType TrackerGeometryCompare::_commonTrackerLevel
private

Definition at line 124 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

float TrackerGeometryCompare::_dalphaVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_daVal
private

Definition at line 150 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dbetaVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dbVal
private

Definition at line 150 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_detDim
private

Definition at line 145 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

bool TrackerGeometryCompare::_detIdFlag
private

Definition at line 117 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_detIdFlagFile
private

Definition at line 118 of file TrackerGeometryCompare.h.

Referenced by TrackerGeometryCompare().

std::vector< uint32_t > TrackerGeometryCompare::_detIdFlagVector
private

Definition at line 123 of file TrackerGeometryCompare.h.

Referenced by passIdCut(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dgammaVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dgVal
private

Definition at line 150 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dphiVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_drVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_duVal
private

Definition at line 150 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dvVal
private

Definition at line 150 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dwVal
private

Definition at line 150 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dxVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dyVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dzVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_etaVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_filename
private

Definition at line 134 of file TrackerGeometryCompare.h.

Referenced by Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor::_readHeaderInfo(), Vispa.Main.TabController.TabController::checkModificationTimestamp(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor::configFile(), Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController::dumpPython(), Vispa.Plugins.EdmBrowser.EdmBrowserTabController.EdmBrowserTabController::eventContent(), Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController::exportDot(), Vispa.Main.TabController.TabController::filename(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor::fullFilename(), Vispa.Main.TabController.TabController::getFileBasename(), Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController::importConfig(), Vispa.Plugins.EventBrowser.EventBrowserTabController.EventBrowserTabController::navigate(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor::open(), Vispa.Main.TabController.TabController::open(), Vispa.Plugins.EdmBrowser.EdmDataAccessor.EdmDataAccessor::open(), Vispa.Main.TabController.TabController::refresh(), Vispa.Main.TabController.TabController::save(), Vispa.Main.TabController.TabController::setFilename(), Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController::startEditMode(), TrackerGeometryCompare(), and Vispa.Main.TabController.TabController::updateLabel().

float TrackerGeometryCompare::_gammaVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_id
private

\ Tree variables

Definition at line 145 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

uint32_t TrackerGeometryCompare::_identifiers[6]
private

Definition at line 152 of file TrackerGeometryCompare.h.

Referenced by fillIdentifiers(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_inModuleList
private

Definition at line 145 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_inputFilename1
private

Definition at line 110 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), createROOTGeometry(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_inputFilename2
private

Definition at line 111 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), createROOTGeometry(), and TrackerGeometryCompare().

TFile* TrackerGeometryCompare::_inputRootFile1
private

Definition at line 137 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and createROOTGeometry().

TFile* TrackerGeometryCompare::_inputRootFile2
private

Definition at line 138 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree01
private

Definition at line 139 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree02
private

Definition at line 140 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree11
private

Definition at line 141 of file TrackerGeometryCompare.h.

Referenced by analyze(), and createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree12
private

Definition at line 142 of file TrackerGeometryCompare.h.

Referenced by analyze(), and createROOTGeometry().

std::string TrackerGeometryCompare::_inputTreenameAlign
private

Definition at line 112 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_inputTreenameDeform
private

Definition at line 113 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), createROOTGeometry(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_level
private

Definition at line 145 of file TrackerGeometryCompare.h.

Referenced by argparse.HelpFormatter::_dedent(), python.rootplot.argparse.HelpFormatter::_dedent(), argparse.HelpFormatter::_indent(), python.rootplot.argparse.HelpFormatter::_indent(), fillTree(), and TrackerGeometryCompare().

const std::vector<std::string> TrackerGeometryCompare::_levelStrings
private

Definition at line 108 of file TrackerGeometryCompare.h.

Referenced by analyze().

int TrackerGeometryCompare::_mid
private

Definition at line 145 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_mlevel
private

Definition at line 145 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_moduleInList
private

Definition at line 131 of file TrackerGeometryCompare.h.

std::vector< int > TrackerGeometryCompare::_moduleList
private

Definition at line 130 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry(), and fillTree().

std::ifstream TrackerGeometryCompare::_moduleListFile
private

Definition at line 129 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry().

std::string TrackerGeometryCompare::_moduleListName
private

Definition at line 109 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_phiVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_rVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_setCommonTrackerSystem
private

Definition at line 116 of file TrackerGeometryCompare.h.

Referenced by analyze(), setCommonTrackerSystem(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_sublevel
private

Definition at line 145 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

double TrackerGeometryCompare::_surfDeform[13]
private

Definition at line 155 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_surLength
private

Definition at line 151 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

double TrackerGeometryCompare::_surRot[9]
private

Definition at line 153 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_surWidth
private

Definition at line 151 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

TFile* TrackerGeometryCompare::_theFile
private

Definition at line 135 of file TrackerGeometryCompare.h.

Referenced by endJob(), and TrackerGeometryCompare().

align::PositionType TrackerGeometryCompare::_TrackerCommonCM
private

Definition at line 127 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

align::GlobalVector TrackerGeometryCompare::_TrackerCommonR
private

Definition at line 126 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

align::GlobalVector TrackerGeometryCompare::_TrackerCommonT
private

Definition at line 125 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

int TrackerGeometryCompare::_type
private

Definition at line 154 of file TrackerGeometryCompare.h.

Referenced by python.Handle::__str__(), cfg-viewer.unscheduled::_proceed(), Vispa.Gui.PortConnection.PointToPointConnection::calculateRoute(), SequenceTypes.ExpandVisitor::result(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_useDetId
private

Definition at line 145 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_weightBy
private

Definition at line 115 of file TrackerGeometryCompare.h.

Referenced by compareGeometries(), diffCommonTrackerSystem(), and TrackerGeometryCompare().

bool TrackerGeometryCompare::_weightById
private

Definition at line 119 of file TrackerGeometryCompare.h.

Referenced by compareGeometries(), diffCommonTrackerSystem(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_weightByIdFile
private

Definition at line 120 of file TrackerGeometryCompare.h.

Referenced by TrackerGeometryCompare().

std::vector< unsigned int > TrackerGeometryCompare::_weightByIdVector
private

Definition at line 121 of file TrackerGeometryCompare.h.

Referenced by compareGeometries(), diffCommonTrackerSystem(), and TrackerGeometryCompare().

bool TrackerGeometryCompare::_writeToDB
private

Definition at line 114 of file TrackerGeometryCompare.h.

Referenced by analyze().

float TrackerGeometryCompare::_xVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_yVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_zVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

AlignableTracker* TrackerGeometryCompare::currentTracker
private

Definition at line 101 of file TrackerGeometryCompare.h.

Referenced by analyze(), createROOTGeometry(), and setCommonTrackerSystem().

AlignableTracker* TrackerGeometryCompare::dummyTracker
private

Definition at line 100 of file TrackerGeometryCompare.h.

bool TrackerGeometryCompare::firstEvent_
private

Definition at line 161 of file TrackerGeometryCompare.h.

Referenced by analyze(), and beginJob().

std::map<std::string,TH1D*> TrackerGeometryCompare::m_h1
private

Definition at line 165 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

int TrackerGeometryCompare::m_nBins
private

Definition at line 157 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

double TrackerGeometryCompare::m_rangeHigh
private

Definition at line 159 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

double TrackerGeometryCompare::m_rangeLow
private

Definition at line 158 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

std::vector<align::StructureType> TrackerGeometryCompare::m_theLevels
private

Definition at line 75 of file TrackerGeometryCompare.h.

Referenced by analyze(), and compareGeometries().

std::vector<TrackerMap> TrackerGeometryCompare::m_vtkmap
private

Definition at line 163 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), endJob(), and TrackerGeometryCompare().

AlignableTracker* TrackerGeometryCompare::referenceTracker
private

Definition at line 99 of file TrackerGeometryCompare.h.

Referenced by analyze(), createROOTGeometry(), and setCommonTrackerSystem().

const SurveyErrors* TrackerGeometryCompare::theSurveyErrors
private

Definition at line 105 of file TrackerGeometryCompare.h.

Referenced by addSurveyInfo().

unsigned int TrackerGeometryCompare::theSurveyIndex
private

Definition at line 103 of file TrackerGeometryCompare.h.

Referenced by addSurveyInfo().

const Alignments* TrackerGeometryCompare::theSurveyValues
private

Definition at line 104 of file TrackerGeometryCompare.h.

Referenced by addSurveyInfo().

Generated for CMSSW Reference Manual by doxygen 1.8.11