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

void analyze (const edm::Event &, const edm::EventSetup &) override
 
void beginJob () override
 Read from DB and print survey info. More...
 
void endJob () override
 
 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 ()
 
SerialTaskQueue * globalLuminosityBlocksQueue ()
 
SerialTaskQueue * globalRunsQueue ()
 
ModuleDescription const & moduleDescription () const
 
std::string workerType () const
 
 ~EDAnalyzer () override
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
 EDConsumerBase (EDConsumerBase &&)=default
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
EDConsumerBase & operator= (EDConsumerBase &&)=default
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
ProductResolverIndexAndSkipBit uncheckedIndexFrom (EDGetToken) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
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 &)
 
static bool wantsGlobalLuminosityBlocks ()
 
static bool wantsGlobalRuns ()
 
static bool wantsStreamLuminosityBlocks ()
 
static bool wantsStreamRuns ()
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename 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 49 of file TrackerGeometryCompare.h.

Member Typedef Documentation

typedef AlignTransform TrackerGeometryCompare::SurveyValue

Definition at line 51 of file TrackerGeometryCompare.h.

typedef Alignments TrackerGeometryCompare::SurveyValues

Definition at line 52 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(), triggerObjects_cff::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:256
TrackerGeometryCompare::theSurveyValues
const Alignments * theSurveyValues
Definition: TrackerGeometryCompare.h:102
TrackerGeometryCompare::m_vtkmap
std::vector< TrackerMap > m_vtkmap
Definition: TrackerGeometryCompare.h:161
TrackerGeometryCompare::dummyTracker
AlignableTracker * dummyTracker
Definition: TrackerGeometryCompare.h:98
TrackerGeometryCompare::m_h1
std::map< std::string, TH1D * > m_h1
Definition: TrackerGeometryCompare.h:163
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:28
TrackerGeometryCompare::_detIdFlagVector
std::vector< uint32_t > _detIdFlagVector
Definition: TrackerGeometryCompare.h:121
TFileDirectory::make
T * make(const Args &...args) const
make new ROOT object
Definition: TFileDirectory.h:59
TrackerGeometryCompare::_commonTrackerLevel
align::StructureType _commonTrackerLevel
Definition: TrackerGeometryCompare.h:122
cuy.ii
ii
Definition: cuy.py:590
TrackerGeometryCompare::currentTracker
AlignableTracker * currentTracker
Definition: TrackerGeometryCompare.h:99
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:106
TrackerGeometryCompare::referenceTracker
AlignableTracker * referenceTracker
Definition: TrackerGeometryCompare.h:97
TrackerGeometryCompare::theSurveyErrors
const SurveyErrors * theSurveyErrors
Definition: TrackerGeometryCompare.h:103
TrackerGeometryCompare::_weightByIdVector
std::vector< unsigned int > _weightByIdVector
Definition: TrackerGeometryCompare.h:119
TrackerGeometryCompare::_moduleList
std::vector< int > _moduleList
Definition: TrackerGeometryCompare.h:128

Member Function Documentation

void TrackerGeometryCompare::addSurveyInfo ( Alignable *  ali)
private

Definition at line 965 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().

965  {
966 
967  const auto& comp = ali->components();
968 
969  unsigned int nComp = comp.size();
970 
971  for (unsigned int i = 0; i < nComp; ++i) addSurveyInfo(comp[i]);
972 
973  const SurveyError& error = theSurveyErrors->m_surveyErrors[theSurveyIndex];
974 
975  if ( ali->geomDetId().rawId() != error.rawId() ||
976  ali->alignableObjectId() != error.structureType() )
977  {
978  throw cms::Exception("DatabaseError")
979  << "Error reading survey info from DB. Mismatched id!";
980  }
981 
982  const CLHEP::Hep3Vector& pos = theSurveyValues->m_align[theSurveyIndex].translation();
983  const CLHEP::HepRotation& rot = theSurveyValues->m_align[theSurveyIndex].rotation();
984 
985  AlignableSurface surf( align::PositionType( pos.x(), pos.y(), pos.z() ),
986  align::RotationType( rot.xx(), rot.xy(), rot.xz(),
987  rot.yx(), rot.yy(), rot.yz(),
988  rot.zx(), rot.zy(), rot.zz() ) );
989 
990  surf.setWidth( ali->surface().width() );
991  surf.setLength( ali->surface().length() );
992 
993  ali->setSurvey( new SurveyDet( surf, error.matrix() ) );
994 
995  ++theSurveyIndex;
996 
997 }
AlignableSurface::width
align::Scalar width() const
Definition: AlignableSurface.h:36
mps_fire.i
i
Definition: mps_fire.py:277
SurveyError::matrix
ErrorMatrix matrix() const
Definition: SurveyError.h:76
TrackerGeometryCompare::theSurveyValues
const Alignments * theSurveyValues
Definition: TrackerGeometryCompare.h:102
TrackerGeometryCompare::addSurveyInfo
void addSurveyInfo(Alignable *ali)
Definition: TrackerGeometryCompare.cc:965
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:47
Alignable::components
virtual const Alignables & components() const =0
Return vector of all direct components.
SurveyError::structureType
uint8_t structureType() const
Definition: SurveyError.h:66
Alignments::m_align
std::vector< AlignTransform > m_align
Definition: Alignments.h:19
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
SurveyError::rawId
align::ID rawId() const
Definition: SurveyError.h:71
AlCaHLTBitMon_QueryRunRegistry.comp
comp
Definition: AlCaHLTBitMon_QueryRunRegistry.py:249
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:343
TrackerGeometryCompare::theSurveyErrors
const SurveyErrors * theSurveyErrors
Definition: TrackerGeometryCompare.h:103
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 
)
override

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
TrackerGeometryCompare::m_theLevels
std::vector< align::StructureType > m_theLevels
Definition: TrackerGeometryCompare.h:73
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:99
TrackerGeometryCompare::_levelStrings
const std::vector< std::string > _levelStrings
Definition: TrackerGeometryCompare.h:106
TrackerGeometryCompare::referenceTracker
AlignableTracker * referenceTracker
Definition: TrackerGeometryCompare.h:97
AlignableTracker::alignments
Alignments * alignments() const override
Return alignments, sorted by DetId.
Definition: AlignableTracker.cc:52
TrackerGeometryCompare::createROOTGeometry
void createROOTGeometry(const edm::EventSetup &iSetup)
Definition: TrackerGeometryCompare.cc:281
AlignableTracker::alignmentErrors
AlignmentErrorsExtended * alignmentErrors() const override
Return alignment errors, sorted by DetId.
Definition: AlignableTracker.cc:74
edm::EventSetup::get
T get() const
Definition: EventSetup.h:62
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  )
overridevirtual

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(), diffTreeTool::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 tolerance.

Referenced by analyze().

608  {
609 
610  using namespace align ;
611 
612  const auto& refComp = refAli->components();
613  const auto& 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  bool converged = false;
636 
637  AlgebraicVector diff, check;
638 
639  for (int i = 0; i < 100; i++){
640 
641  // Get differences between alignments for rotations and translations
642  // both local and global
643  diff = align::diffAlignables(refAli, curAli, _weightBy, _weightById, _weightByIdVector);
644 
645  // 'diffAlignables' returns 'refAli - curAli' for translations and 'curAli - refAli' for rotations.
646  // The plan is to unify this at some point, but a simple change of the sign for one of them was postponed
647  // to do some further checks to understand the rotations better
648  //Updated July 2018: as requested the sign in the translations has been changed to match the one in rotations. A test was done to change the diffAlignables function and solve the issue there, but proved quite time consuming. To unify the sign convention in the least amount of time the choice was made to change the sign here.
649  CLHEP::Hep3Vector dR(-diff[0],-diff[1],-diff[2]);
650  CLHEP::Hep3Vector dW(diff[3],diff[4],diff[5]);
651  CLHEP::Hep3Vector dRLocal(-diff[6],-diff[7],-diff[8]);
652  CLHEP::Hep3Vector dWLocal(diff[9],diff[10],diff[11]);
653 
654  // Translations
655  Rtotal+=dR;
656  lRtotal+=dRLocal;
657 
658  //Rotations
659  CLHEP::HepRotation rot(Wtotal.unit(),Wtotal.mag());
660  CLHEP::HepRotation drot(dW.unit(),dW.mag());
661  rot*=drot;
662  Wtotal.set(rot.axis().x()*rot.delta(), rot.axis().y()*rot.delta(), rot.axis().z()*rot.delta());
663 
664  CLHEP::HepRotation rotLocal(lWtotal.unit(),lWtotal.mag());
665  CLHEP::HepRotation drotLocal(dWLocal.unit(),dWLocal.mag());
666  rotLocal*=drotLocal;
667  lWtotal.set(rotLocal.axis().x()*rotLocal.delta(), rotLocal.axis().y()*rotLocal.delta(), rotLocal.axis().z()*rotLocal.delta());
668 
669  // Move current alignable by shift and check if difference
670  // is smaller than tolerance value
671  // if true, break the loop
672  align::moveAlignable(curAli, diff);
673  float tolerance = 1e-7;
674  check = align::diffAlignables(refAli, curAli, _weightBy, _weightById, _weightByIdVector);
675  align::GlobalVector checkR(check[0],check[1],check[2]);
676  align::GlobalVector checkW(check[3],check[4],check[5]);
677  if ((checkR.mag() < tolerance)&&(checkW.mag() < tolerance))
678  {
679  converged = true;
680  break;
681  }
682  }
683 
684  // give an exception if difference has not fallen below tolerance level
685  // i.e. method has not converged
686  if (!converged){
687  edm::LogInfo("TrackerGeometryCompare") << "Tolerance Exceeded!(alObjId: " << refAli->alignableObjectId()
688  << ", rawId: " << refAli->geomDetId().rawId()
689  << ", subdetId: "<< detid.subdetId() << "): " << diff << check;
690  throw cms::Exception("Tolerance in TrackerGeometryCompare exceeded");
691  }
692 
693  AlgebraicVector TRtot(12);
694  // global
695  TRtot(1) = Rtotal.x(); TRtot(2) = Rtotal.y(); TRtot(3) = Rtotal.z();
696  TRtot(4) = Wtotal.x(); TRtot(5) = Wtotal.y(); TRtot(6) = Wtotal.z();
697  // local
698  TRtot(7) = lRtotal.x(); TRtot(8) = lRtotal.y(); TRtot(9) = lRtotal.z();
699  TRtot(10) = lWtotal.x(); TRtot(11) = lWtotal.y(); TRtot(12) = lWtotal.z();
700 
701  fillTree(refAli, TRtot, tTopo, iSetup);
702  }
703 
704  // another added level for difference between det and detunit
705  for (unsigned int i = 0; i < nComp; ++i)
706  compareGeometries(refComp[i],curComp[i],tTopo,iSetup);
707 
708 }
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:277
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:73
tolerance
const double tolerance
Definition: HGCalGeomParameters.cc:26
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:47
align::diffAlignables
AlgebraicVector diffAlignables(Alignable *refAli, Alignable *curAli, const std::string &weightBy, bool weightById, const std::vector< unsigned int > &weightByIdVector)
Definition: AlignTools.cc:10
Alignable::components
virtual const Alignables & components() const =0
Return vector of all direct components.
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
TrackerGeometryCompare::fillTree
void fillTree(Alignable *refAli, const AlgebraicVector &diff, const TrackerTopology *tTopo, const edm::EventSetup &iSetup)
Definition: TrackerGeometryCompare.cc:807
PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.dR
dR
Definition: PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.py:19
DetId
Definition: DetId.h:18
AlgebraicVector
CLHEP::HepVector AlgebraicVector
Definition: AlgebraicObjects.h:12
TrackerGeometryCompare::_weightByIdVector
std::vector< unsigned int > _weightByIdVector
Definition: TrackerGeometryCompare.h:119
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 mathSSE::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:161
mathSSE::return
return((rh^lh)&mask)
TrackerGeometryCompare::m_h1
std::map< std::string, TH1D * > m_h1
Definition: TrackerGeometryCompare.h:163
Abs
T Abs(T a)
Definition: MathUtil.h:49
cuy.ii
ii
Definition: cuy.py:590
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, mps_splice::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 auto& 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 auto& 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:277
GeometryAligner
Class to update a given geometry with a set of alignments.
Definition: GeometryAligner.h:33
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
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
mps_splice.line
line
Definition: mps_splice.py:75
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:99
AlignmentErrorsExtended::m_alignError
std::vector< AlignTransformErrorExtended > m_alignError
Definition: AlignmentErrorsExtended.h:19
TrackerGeometryCompare::referenceTracker
AlignableTracker * referenceTracker
Definition: TrackerGeometryCompare.h:97
edm::EventSetup::get
T get() const
Definition: EventSetup.h:62
TrackerGeometryCompare::_moduleList
std::vector< int > _moduleList
Definition: TrackerGeometryCompare.h:128
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 748 of file TrackerGeometryCompare.cc.

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

Referenced by setCommonTrackerSystem().

748  {
749 
750  const auto& refComp = refAli->components();
751  const auto& curComp = curAli->components();
752 
753  unsigned int nComp = refComp.size();
754  //only perform for designate levels
755  bool useLevel = false;
756  if (refAli->alignableObjectId() == _commonTrackerLevel) useLevel = true;
757 
758  //useLevel = false;
759  if (useLevel){
760  CLHEP::Hep3Vector Rtotal, Wtotal;
761  Rtotal.set(0.,0.,0.); Wtotal.set(0.,0.,0.);
762 
763  AlgebraicVector diff = align::diffAlignables(refAli, curAli, _weightBy, _weightById, _weightByIdVector);
764  CLHEP::Hep3Vector dR(diff[0],diff[1],diff[2]);
765  Rtotal+=dR;
766  CLHEP::Hep3Vector dW(diff[3],diff[4],diff[5]);
767  CLHEP::HepRotation rot(Wtotal.unit(),Wtotal.mag());
768  CLHEP::HepRotation drot(dW.unit(),dW.mag());
769  rot*=drot;
770  Wtotal.set(rot.axis().x()*rot.delta(), rot.axis().y()*rot.delta(), rot.axis().z()*rot.delta());
771  /*
772  //std::cout << "a";
773  //if (refAli->alignableObjectId() == 1) std::cout << "DIFF: " << diff << std::endl;
774  align::moveAlignable(curAli, diff);
775  float tolerance = 1e-7;
776  AlgebraicVector check = align::diffAlignables(refAli,curAli, _weightBy, _weightById, _weightByIdVector);
777  align::GlobalVector checkR(check[0],check[1],check[2]);
778  align::GlobalVector checkW(check[3],check[4],check[5]);
779  DetId detid(refAli->id());
780  if ((checkR.mag() > tolerance)||(checkW.mag() > tolerance)){
781  edm::LogInfo("TrackerGeometryCompare") << "Tolerance Exceeded!(alObjId: " << refAli->alignableObjectId()
782  << ", rawId: " << refAli->geomDetId().rawId()
783  << ", subdetId: "<< detid.subdetId() << "): " << diff;
784  }
785  else{
786  break;
787  }
788  }
789  */
790 
791  //_TrackerCommonT.set(Rtotal.x(), Rtotal.y(), Rtotal.z());
792  _TrackerCommonT = align::GlobalVector(Rtotal.x(), Rtotal.y(), Rtotal.z());
793  _TrackerCommonR = align::GlobalVector(Wtotal.x(), Wtotal.y(), Wtotal.z());
794  _TrackerCommonCM = curAli->globalPosition();
795  //_TrackerCommonTR(1) = Rtotal.x(); _TrackerCommonTR(2) = Rtotal.y(); _TrackerCommonTR(3) = Rtotal.z();
796  //_TrackerCommonTR(4) = Wtotal.x(); _TrackerCommonTR(5) = Wtotal.y(); _TrackerCommonTR(6) = Wtotal.z();
797 
798 
799  }
800  else{
801  for (unsigned int i = 0; i < nComp; ++i) diffCommonTrackerSystem(refComp[i],curComp[i]);
802  }
803 
804 
805 }
TrackerGeometryCompare::_TrackerCommonR
align::GlobalVector _TrackerCommonR
Definition: TrackerGeometryCompare.h:124
mps_fire.i
i
Definition: mps_fire.py:277
align::GlobalVector
Vector3DBase< Scalar, GlobalTag > GlobalVector
Definition: Definitions.h:33
TrackerGeometryCompare::_TrackerCommonT
align::GlobalVector _TrackerCommonT
Definition: TrackerGeometryCompare.h:123
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:748
Alignable::components
virtual const Alignables & components() const =0
Return vector of all direct components.
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
TrackerGeometryCompare::_commonTrackerLevel
align::StructureType _commonTrackerLevel
Definition: TrackerGeometryCompare.h:122
TrackerGeometryCompare::_TrackerCommonCM
align::PositionType _TrackerCommonCM
Definition: TrackerGeometryCompare.h:125
PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.dR
dR
Definition: PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.py:19
AlgebraicVector
CLHEP::HepVector AlgebraicVector
Definition: AlgebraicObjects.h:12
TrackerGeometryCompare::_weightByIdVector
std::vector< unsigned int > _weightByIdVector
Definition: TrackerGeometryCompare.h:119
Alignable::globalPosition
const PositionType & globalPosition() const
Return the global position of the object.
Definition: Alignable.h:138
void TrackerGeometryCompare::endJob ( void  )
overridevirtual

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:256
TrackerGeometryCompare::m_vtkmap
std::vector< TrackerMap > m_vtkmap
Definition: TrackerGeometryCompare.h:161
void TrackerGeometryCompare::fillIdentifiers ( int  subdetlevel,
int  rawid,
const TrackerTopology *  tTopo 
)
private

Definition at line 1012 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().

1012  {
1013 
1014 
1015  switch( subdetlevel ){
1016 
1017  case 1:
1018  {
1019 
1020  _identifiers[0] = tTopo->pxbModule( rawid );
1021  _identifiers[1] = tTopo->pxbLadder( rawid );
1022  _identifiers[2] = tTopo->pxbLayer( rawid );
1023  _identifiers[3] = 999;
1024  _identifiers[4] = 999;
1025  _identifiers[5] = 999;
1026  break;
1027  }
1028  case 2:
1029  {
1030 
1031  _identifiers[0] = tTopo->pxfModule( rawid );
1032  _identifiers[1] = tTopo->pxfPanel( rawid );
1033  _identifiers[2] = tTopo->pxfBlade( rawid );
1034  _identifiers[3] = tTopo->pxfDisk( rawid );
1035  _identifiers[4] = tTopo->pxfSide( rawid );
1036  _identifiers[5] = 999;
1037  break;
1038  }
1039  case 3:
1040  {
1041 
1042  _identifiers[0] = tTopo->tibModule( rawid );
1043  _identifiers[1] = tTopo->tibStringInfo( rawid )[0];
1044  _identifiers[2] = tTopo->tibStringInfo( rawid )[1];
1045  _identifiers[3] = tTopo->tibStringInfo( rawid )[2];
1046  _identifiers[4] = tTopo->tibLayer( rawid );
1047  _identifiers[5] = 999;
1048  break;
1049  }
1050  case 4:
1051  {
1052 
1053  _identifiers[0] = tTopo->tidModuleInfo( rawid )[0];
1054  _identifiers[1] = tTopo->tidModuleInfo( rawid )[1];
1055  _identifiers[2] = tTopo->tidRing( rawid );
1056  _identifiers[3] = tTopo->tidWheel( rawid );
1057  _identifiers[4] = tTopo->tidSide( rawid );
1058  _identifiers[5] = 999;
1059  break;
1060  }
1061  case 5:
1062  {
1063 
1064  _identifiers[0] = tTopo->tobModule( rawid );
1065  _identifiers[1] = tTopo->tobRodInfo( rawid )[0];
1066  _identifiers[2] = tTopo->tobRodInfo( rawid )[1];
1067  _identifiers[3] = tTopo->tobLayer( rawid );
1068  _identifiers[4] = 999;
1069  _identifiers[5] = 999;
1070  break;
1071  }
1072  case 6:
1073  {
1074 
1075  _identifiers[0] = tTopo->tecModule( rawid );
1076  _identifiers[1] = tTopo->tecRing( rawid );
1077  _identifiers[2] = tTopo->tecPetalInfo( rawid )[0];
1078  _identifiers[3] = tTopo->tecPetalInfo( rawid )[1];
1079  _identifiers[4] = tTopo->tecWheel( rawid );
1080  _identifiers[5] = tTopo->tecSide( rawid );
1081  break;
1082  }
1083  default:
1084  {
1085  edm::LogInfo("TrackerGeometryCompare") << "Error: bad subdetid!!";
1086  break;
1087  }
1088 
1089  }
1090 }
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 807 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().

807  {
808 
809  //Get bad modules
810  edm::ESHandle<SiPixelQuality> SiPixelModules;
811  iSetup.get<SiPixelQualityRcd>().get(SiPixelModules);
812  edm::ESHandle<SiStripQuality> SiStripModules;
813  iSetup.get<SiStripQualityRcd>().get(SiStripModules);
814 
815  _id = refAli->id();
816 
817  _badModuleQuality = 0;
818  //check if module has a bad quality tag
819  if (SiPixelModules->IsModuleBad(_id)){
820  _badModuleQuality = 1;
821 
822  }
823  if (SiStripModules->IsModuleBad(_id)){
824  _badModuleQuality = 1;
825  }
826 
827  //check if module is in a given list of bad/untouched etc. modules
828  _inModuleList = 0;
829  for (unsigned int i = 0 ; i< _moduleList.size(); i++){
830  if ( _moduleList[i] == _id)
831  {
832  _inModuleList = 1;
833  break;
834  }
835  }
836 
837  _level = refAli->alignableObjectId();
838  //need if ali has no mother
839  if (refAli->mother()){
840  _mid = refAli->mother()->geomDetId().rawId();
841  _mlevel = refAli->mother()->alignableObjectId();
842  }
843  else{
844  _mid = -1;
845  _mlevel = -1;
846  }
847  DetId detid(_id);
848  _sublevel = detid.subdetId();
849  fillIdentifiers(_sublevel, _id , tTopo);
850  _xVal = refAli->globalPosition().x();
851  _yVal = refAli->globalPosition().y();
852  _zVal = refAli->globalPosition().z();
853  align::GlobalVector vec(_xVal,_yVal,_zVal);
854  _rVal = vec.perp();
855  _phiVal = vec.phi();
856  _etaVal = vec.eta();
857  align::RotationType rot = refAli->globalRotation();
858  align::EulerAngles eulerAngles = align::toAngles(rot);
859  _alphaVal = eulerAngles[0];
860  _betaVal = eulerAngles[1];
861  _gammaVal = eulerAngles[2];
862  // global
863  _dxVal = diff[0];
864  _dyVal = diff[1];
865  _dzVal = diff[2];
866  // local
867  _duVal = diff[6];
868  _dvVal = diff[7];
869  _dwVal = diff[8];
870  //...TODO...
871  align::GlobalVector g(_dxVal, _dyVal, _dzVal);
872  //getting dR and dPhi
873  align::GlobalVector vRef(_xVal,_yVal,_zVal);
874  align::GlobalVector vCur(_xVal + _dxVal, _yVal + _dyVal, _zVal + _dzVal);
875  _drVal = vCur.perp() - vRef.perp();
876  _dphiVal = vCur.phi() - vRef.phi();
877  // global
878  _dalphaVal = diff[3];
879  _dbetaVal = diff[4];
880  _dgammaVal = diff[5];
881  // local
882  _daVal = diff[9];
883  _dbVal = diff[10];
884  _dgVal = diff[11];
885 
886  //detIdFlag
887  if (refAli->alignableObjectId() == align::AlignableDetUnit){
888  if (_detIdFlag){
889  if ((passIdCut(refAli->id()))||(passIdCut(refAli->mother()->id()))){
890  _useDetId = 1;
891  }
892  else{
893  _useDetId = 0;
894  }
895  }
896  }
897  // det module dimension
898  if (refAli->alignableObjectId() == align::AlignableDetUnit){
899  if (refAli->mother()->alignableObjectId() != align::AlignableDet) _detDim = 1;
900  else if (refAli->mother()->alignableObjectId() == align::AlignableDet) _detDim = 2;
901  }
902  else _detDim = 0;
903 
904  _surWidth = refAli->surface().width();
905  _surLength = refAli->surface().length();
906  align::RotationType rt = refAli->globalRotation();
907  _surRot[0] = rt.xx(); _surRot[1] = rt.xy(); _surRot[2] = rt.xz();
908  _surRot[3] = rt.yx(); _surRot[4] = rt.yy(); _surRot[5] = rt.yz();
909  _surRot[6] = rt.zx(); _surRot[7] = rt.zy(); _surRot[8] = rt.zz();
910 
911  //Fill
912  _alignTree->Fill();
913 
914 }
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:277
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:47
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
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
TrackerGeometryCompare::fillIdentifiers
void fillIdentifiers(int subdetlevel, int rawid, const TrackerTopology *tTopo)
Definition: TrackerGeometryCompare.cc:1012
TkRotation::xz
T xz() const
Definition: extTkRotation.h:253
edm::EventSetup::get
T get() const
Definition: EventSetup.h:62
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:128
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 999 of file TrackerGeometryCompare.cc.

References _detIdFlagVector, and mps_fire::i.

Referenced by fillTree().

999  {
1000 
1001  bool pass = false;
1002  int nEntries = _detIdFlagVector.size();
1003 
1004  for (int i = 0; i < nEntries; i++){
1005  if (_detIdFlagVector[i] == id) pass = true;
1006  }
1007 
1008  return pass;
1009 
1010 }
mps_fire.i
i
Definition: mps_fire.py:277
TrackerGeometryCompare::_detIdFlagVector
std::vector< uint32_t > _detIdFlagVector
Definition: TrackerGeometryCompare.h:121
void TrackerGeometryCompare::setCommonTrackerSystem ( )
private

Definition at line 710 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().

710  {
711 
712  edm::LogInfo("TrackerGeometryCompare") << "Setting Common Tracker System....";
713 
714  // DM_534??AlignableObjectId dummy;
715  // DM_534??_commonTrackerLevel = dummy.nameToType(_setCommonTrackerSystem);
716  _commonTrackerLevel = currentTracker->objectIdProvider().stringToId(_setCommonTrackerSystem);
717 
718  diffCommonTrackerSystem(referenceTracker, currentTracker);
719 
720  align::EulerAngles dOmega(3); dOmega[0] = _TrackerCommonR.x() ; dOmega[1] = _TrackerCommonR.y(); dOmega[2] = _TrackerCommonR.z();
721  align::RotationType rot = align::toMatrix( dOmega );
722  align::GlobalVector theR = _TrackerCommonT;
723 
724  edm::LogInfo("TrackerGeometryCompare") << "what we get from overlaying the pixels..." << theR << ", " << rot;
725 
726  //transform to the Tracker System
727  align::PositionType trackerCM = currentTracker->globalPosition();
728  align::GlobalVector cmDiff( trackerCM.x()-_TrackerCommonCM.x(), trackerCM.y()-_TrackerCommonCM.y(), trackerCM.z()-_TrackerCommonCM.z() );
729 
730  edm::LogInfo("TrackerGeometryCompare") << "Pixel CM: " << _TrackerCommonCM << ", tracker CM: " << trackerCM;
731 
732  //adjust translational difference factoring in different rotational CM
733  //needed because rotateInGlobalFrame is about CM of alignable, not Tracker
734  const align::GlobalVector::BasicVectorType& lpvgf = cmDiff.basicVector();
735  align::GlobalVector moveV( rot.multiplyInverse(lpvgf) - lpvgf);
736  align::GlobalVector theRprime(theR + moveV);
737 
738  AlgebraicVector TrackerCommonTR(6);
739  TrackerCommonTR(1) = theRprime.x(); TrackerCommonTR(2) = theRprime.y(); TrackerCommonTR(3) = theRprime.z();
740  TrackerCommonTR(4) = _TrackerCommonR.x(); TrackerCommonTR(5) = _TrackerCommonR.y(); TrackerCommonTR(6) = _TrackerCommonR.z();
741 
742  edm::LogInfo("TrackerGeometryCompare") << "and after the transformation: " << TrackerCommonTR;
743 
744  align::moveAlignable(currentTracker, TrackerCommonTR );
745 
746 }
AlignableObjectId::stringToId
align::StructureType stringToId(const char *) const
Definition: AlignableObjectId.cc:296
TrackerGeometryCompare::_TrackerCommonR
align::GlobalVector _TrackerCommonR
Definition: TrackerGeometryCompare.h:124
TrackerGeometryCompare::_TrackerCommonT
align::GlobalVector _TrackerCommonT
Definition: TrackerGeometryCompare.h:123
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
TrackerGeometryCompare::diffCommonTrackerSystem
void diffCommonTrackerSystem(Alignable *refAli, Alignable *curAli)
Definition: TrackerGeometryCompare.cc:748
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
TrackerGeometryCompare::_commonTrackerLevel
align::StructureType _commonTrackerLevel
Definition: TrackerGeometryCompare.h:122
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:125
AlgebraicVector
CLHEP::HepVector AlgebraicVector
Definition: AlgebraicObjects.h:12
align::EulerAngles
AlgebraicVector EulerAngles
Definition: Definitions.h:36
TrackerGeometryCompare::currentTracker
AlignableTracker * currentTracker
Definition: TrackerGeometryCompare.h:99
TrackerGeometryCompare::referenceTracker
AlignableTracker * referenceTracker
Definition: TrackerGeometryCompare.h:97
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 916 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.

916  {
917 
918  //getting the right alignables for the alignment record
919  auto detPB = ali->pixelHalfBarrelGeomDets();
920  auto detPEC = ali->pixelEndcapGeomDets();
921  auto detTIB = ali->innerBarrelGeomDets();
922  auto detTID = ali->TIDGeomDets();
923  auto detTOB = ali->outerBarrelGeomDets();
924  auto detTEC = ali->endcapGeomDets();
925 
926  align::Alignables allGeomDets;
927  std::copy(detPB.begin(), detPB.end(), std::back_inserter(allGeomDets));
928  std::copy(detPEC.begin(), detPEC.end(), std::back_inserter(allGeomDets));
929  std::copy(detTIB.begin(), detTIB.end(), std::back_inserter(allGeomDets));
930  std::copy(detTID.begin(), detTID.end(), std::back_inserter(allGeomDets));
931  std::copy(detTOB.begin(), detTOB.end(), std::back_inserter(allGeomDets));
932  std::copy(detTEC.begin(), detTEC.end(), std::back_inserter(allGeomDets));
933 
934  align::Alignables rcdAlis;
935  for (const auto& i: allGeomDets){
936  if (i->components().size() == 1){
937  rcdAlis.push_back(i);
938  }
939  else if (i->components().size() > 1){
940  rcdAlis.push_back(i);
941  const auto& comp = i->components();
942  for (const auto& j: comp) rcdAlis.push_back(j);
943  }
944  }
945 
946  //turning them into alignments
947  for(const auto& k: rcdAlis) {
948  const SurveyDet* surveyInfo = k->survey();
949  const align::PositionType& pos(surveyInfo->position());
950  align::RotationType rot(surveyInfo->rotation());
951  CLHEP::Hep3Vector clhepVector(pos.x(),pos.y(),pos.z());
952  CLHEP::HepRotation clhepRotation( CLHEP::HepRep3x3(rot.xx(),rot.xy(),rot.xz(),rot.yx(),rot.yy(),rot.yz(),rot.zx(),rot.zy(),rot.zz()));
953  AlignTransform transform(clhepVector, clhepRotation, k->id());
954  AlignTransformErrorExtended transformError(CLHEP::HepSymMatrix(3,1), k->id());
955  alignVals->m_align.push_back(transform);
956  alignErrors->m_alignError.push_back(transformError);
957  }
958 
959  //to get the right order
960  std::sort( alignVals->m_align.begin(), alignVals->m_align.end(), lessAlignmentDetId<AlignTransform>() );
961  std::sort( alignErrors->m_alignError.begin(), alignErrors->m_alignError.end(), lessAlignmentDetId<AlignTransformErrorExtended>() );
962 
963 }
AlignableTracker::pixelHalfBarrelGeomDets
Alignables & pixelHalfBarrelGeomDets()
Return pixel barrel GeomDets.
Definition: AlignableTracker.h:84
mps_fire.i
i
Definition: mps_fire.py:277
popcon2dropbox.copy
def copy(args, dbName)
Definition: popcon2dropbox.py:122
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:249
AlignableTracker::endcapGeomDets
Alignables & endcapGeomDets()
Return endcap GeomDets.
Definition: AlignableTracker.h:88
create_public_lumi_plots.transform
transform
Definition: create_public_lumi_plots.py:1259
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
align::Alignables
std::vector< Alignable * > Alignables
Definition: Utilities.h:32

Member Data Documentation

TTree* TrackerGeometryCompare::_alignTree
private

Definition at line 134 of file TrackerGeometryCompare.h.

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

float TrackerGeometryCompare::_alphaVal
private

Definition at line 144 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_badModuleQuality
private

Definition at line 143 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_betaVal
private

Definition at line 144 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

align::StructureType TrackerGeometryCompare::_commonTrackerLevel
private

Definition at line 122 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

float TrackerGeometryCompare::_dalphaVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_daVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dbetaVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dbVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_detDim
private

Definition at line 143 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

bool TrackerGeometryCompare::_detIdFlag
private

Definition at line 115 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_detIdFlagFile
private

Definition at line 116 of file TrackerGeometryCompare.h.

Referenced by TrackerGeometryCompare().

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

Definition at line 121 of file TrackerGeometryCompare.h.

Referenced by passIdCut(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dgammaVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dgVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dphiVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_drVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_duVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dvVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dwVal
private

Definition at line 148 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dxVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dyVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dzVal
private

Definition at line 146 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_etaVal
private

Definition at line 144 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_filename
private

Definition at line 132 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 144 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_id
private

\ Tree variables

Definition at line 143 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

uint32_t TrackerGeometryCompare::_identifiers[6]
private

Definition at line 150 of file TrackerGeometryCompare.h.

Referenced by fillIdentifiers(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_inModuleList
private

Definition at line 143 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_inputFilename1
private

Definition at line 108 of file TrackerGeometryCompare.h.

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

std::string TrackerGeometryCompare::_inputFilename2
private

Definition at line 109 of file TrackerGeometryCompare.h.

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

TFile* TrackerGeometryCompare::_inputRootFile1
private

Definition at line 135 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and createROOTGeometry().

TFile* TrackerGeometryCompare::_inputRootFile2
private

Definition at line 136 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree01
private

Definition at line 137 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree02
private

Definition at line 138 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree11
private

Definition at line 139 of file TrackerGeometryCompare.h.

Referenced by analyze(), and createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree12
private

Definition at line 140 of file TrackerGeometryCompare.h.

Referenced by analyze(), and createROOTGeometry().

std::string TrackerGeometryCompare::_inputTreenameAlign
private

Definition at line 110 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_inputTreenameDeform
private

Definition at line 111 of file TrackerGeometryCompare.h.

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

int TrackerGeometryCompare::_level
private

Definition at line 143 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

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

Definition at line 106 of file TrackerGeometryCompare.h.

Referenced by analyze().

int TrackerGeometryCompare::_mid
private

Definition at line 143 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_mlevel
private

Definition at line 143 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_moduleInList
private

Definition at line 129 of file TrackerGeometryCompare.h.

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

Definition at line 128 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry(), and fillTree().

std::ifstream TrackerGeometryCompare::_moduleListFile
private

Definition at line 127 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry().

std::string TrackerGeometryCompare::_moduleListName
private

Definition at line 107 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_phiVal
private

Definition at line 144 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_rVal
private

Definition at line 144 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_setCommonTrackerSystem
private

Definition at line 114 of file TrackerGeometryCompare.h.

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

int TrackerGeometryCompare::_sublevel
private

Definition at line 143 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

double TrackerGeometryCompare::_surfDeform[13]
private

Definition at line 153 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_surLength
private

Definition at line 149 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

double TrackerGeometryCompare::_surRot[9]
private

Definition at line 151 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_surWidth
private

Definition at line 149 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

TFile* TrackerGeometryCompare::_theFile
private

Definition at line 133 of file TrackerGeometryCompare.h.

Referenced by endJob(), and TrackerGeometryCompare().

align::PositionType TrackerGeometryCompare::_TrackerCommonCM
private

Definition at line 125 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

align::GlobalVector TrackerGeometryCompare::_TrackerCommonR
private

Definition at line 124 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

align::GlobalVector TrackerGeometryCompare::_TrackerCommonT
private

Definition at line 123 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

int TrackerGeometryCompare::_type
private

Definition at line 152 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 143 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_weightBy
private

Definition at line 113 of file TrackerGeometryCompare.h.

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

bool TrackerGeometryCompare::_weightById
private

Definition at line 117 of file TrackerGeometryCompare.h.

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

std::string TrackerGeometryCompare::_weightByIdFile
private

Definition at line 118 of file TrackerGeometryCompare.h.

Referenced by TrackerGeometryCompare().

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

Definition at line 119 of file TrackerGeometryCompare.h.

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

bool TrackerGeometryCompare::_writeToDB
private

Definition at line 112 of file TrackerGeometryCompare.h.

Referenced by analyze().

float TrackerGeometryCompare::_xVal
private

Definition at line 144 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_yVal
private

Definition at line 144 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_zVal
private

Definition at line 144 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

AlignableTracker* TrackerGeometryCompare::currentTracker
private

Definition at line 99 of file TrackerGeometryCompare.h.

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

AlignableTracker* TrackerGeometryCompare::dummyTracker
private

Definition at line 98 of file TrackerGeometryCompare.h.

bool TrackerGeometryCompare::firstEvent_
private

Definition at line 159 of file TrackerGeometryCompare.h.

Referenced by analyze(), and beginJob().

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

Definition at line 163 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

int TrackerGeometryCompare::m_nBins
private

Definition at line 155 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

double TrackerGeometryCompare::m_rangeHigh
private

Definition at line 157 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

double TrackerGeometryCompare::m_rangeLow
private

Definition at line 156 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

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

Definition at line 73 of file TrackerGeometryCompare.h.

Referenced by analyze(), and compareGeometries().

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

Definition at line 161 of file TrackerGeometryCompare.h.

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

AlignableTracker* TrackerGeometryCompare::referenceTracker
private

Definition at line 97 of file TrackerGeometryCompare.h.

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

const SurveyErrors* TrackerGeometryCompare::theSurveyErrors
private

Definition at line 103 of file TrackerGeometryCompare.h.

Referenced by addSurveyInfo().

unsigned int TrackerGeometryCompare::theSurveyIndex
private

Definition at line 101 of file TrackerGeometryCompare.h.

Referenced by addSurveyInfo().

const Alignments* TrackerGeometryCompare::theSurveyValues
private

Definition at line 102 of file TrackerGeometryCompare.h.

Referenced by addSurveyInfo().

Generated for CMSSW Reference Manual by doxygen 1.8.11