CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
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

Public Types

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

Public Member Functions

virtual void analyze (const edm::Event &, const edm::EventSetup &)
 
virtual void beginJob ()
 Read from DB and print survey info. More...
 
virtual void endJob ()
 
 TrackerGeometryCompare (const edm::ParameterSet &)
 Do nothing. Required by framework. More...
 
- Public Member Functions inherited from edm::EDAnalyzer
 EDAnalyzer ()
 
std::string workerType () const
 
virtual ~EDAnalyzer ()
 

Private Member Functions

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

Private Attributes

TTree * _alignTree
 
float _alphaVal
 
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]
 
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
 
int _mid
 
int _mlevel
 
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
 
edm::ParameterSet m_params
 
double m_rangeHigh
 
double m_rangeLow
 
std::vector< align::StructureType > m_theLevels
 
std::vector< TrackerMap > m_vtkmap
 
AlignableTracker * referenceTracker
 
const SurveyErrors * theSurveyErrors
 
unsigned int theSurveyIndex
 
const Alignments * theSurveyValues
 

Additional Inherited Members

- Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &)
 
- Protected Member Functions inherited from edm::EDAnalyzer
CurrentProcessingContext const * currentContext () const
 

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/11/05 10:58:06
Revision:
1.13
Author
Nhan Tran

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

Definition at line 48 of file TrackerGeometryCompare.h.

Member Typedef Documentation

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

Definition at line 52 of file TrackerGeometryCompare.h.

typedef AlignTransform TrackerGeometryCompare::SurveyValue

Definition at line 50 of file TrackerGeometryCompare.h.

typedef Alignments TrackerGeometryCompare::SurveyValues

Definition at line 51 of file TrackerGeometryCompare.h.

Constructor & Destructor Documentation

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

Do nothing. Required by framework.

Definition at line 58 of file TrackerGeometryCompare.cc.

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

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

Member Function Documentation

void TrackerGeometryCompare::addSurveyInfo ( Alignable *  ali)
private

Definition at line 880 of file TrackerGeometryCompare.cc.

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

880  {
881 
882  const std::vector<Alignable*>& comp = ali->components();
883 
884  unsigned int nComp = comp.size();
885 
886  for (unsigned int i = 0; i < nComp; ++i) addSurveyInfo(comp[i]);
887 
888  const SurveyError& error = theSurveyErrors->m_surveyErrors[theSurveyIndex];
889 
890  if ( ali->geomDetId().rawId() != error.rawId() ||
891  ali->alignableObjectId() != error.structureType() )
892  {
893  throw cms::Exception("DatabaseError")
894  << "Error reading survey info from DB. Mismatched id!";
895  }
896 
897  const CLHEP::Hep3Vector& pos = theSurveyValues->m_align[theSurveyIndex].translation();
898  const CLHEP::HepRotation& rot = theSurveyValues->m_align[theSurveyIndex].rotation();
899 
900  AlignableSurface surf( align::PositionType( pos.x(), pos.y(), pos.z() ),
901  align::RotationType( rot.xx(), rot.xy(), rot.xz(),
902  rot.yx(), rot.yy(), rot.yz(),
903  rot.zx(), rot.zy(), rot.zz() ) );
904 
905  surf.setWidth( ali->surface().width() );
906  surf.setLength( ali->surface().length() );
907 
908  ali->setSurvey( new SurveyDet( surf, error.matrix() ) );
909 
910  ++theSurveyIndex;
911 
912 }
AlignableSurface::width
align::Scalar width() const
Definition: AlignableSurface.h:36
i
int i
Definition: DBlmapReader.cc:9
SurveyError::matrix
ErrorMatrix matrix() const
Definition: SurveyError.h:72
TrackerGeometryCompare::theSurveyValues
const Alignments * theSurveyValues
Definition: TrackerGeometryCompare.h:102
TrackerGeometryCompare::addSurveyInfo
void addSurveyInfo(Alignable *ali)
Definition: TrackerGeometryCompare.cc:880
SurveyError::structureType
uint8_t structureType() const
Definition: SurveyError.h:62
Alignable::components
virtual Alignables components() const =0
Return vector of all direct components.
Alignments::m_align
std::vector< AlignTransform > m_align
Definition: Alignments.h:14
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:45
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
SurveyError::rawId
align::ID rawId() const
Definition: SurveyError.h:67
Alignable::surface
const AlignableSurface & surface() const
Return the Surface (global position and orientation) of the object.
Definition: Alignable.h:126
AlignableSurface::length
align::Scalar length() const
Definition: AlignableSurface.h:38
Alignable::setSurvey
void setSurvey(const SurveyDet *)
Set survey info.
Definition: Alignable.cc:268
TrackerGeometryCompare::theSurveyErrors
const SurveyErrors * theSurveyErrors
Definition: TrackerGeometryCompare.h:103
SurveyErrors::m_surveyErrors
std::vector< SurveyError > m_surveyErrors
Definition: SurveyErrors.h:21
Alignable::geomDetId
const DetId & geomDetId() const
Definition: Alignable.h:177
void TrackerGeometryCompare::analyze ( const edm::Event &  ,
const edm::EventSetup &  iSetup 
)
virtual

Implements edm::EDAnalyzer.

Definition at line 229 of file TrackerGeometryCompare.cc.

References _inputTree11, _inputTree12, _setCommonTrackerSystem, _writeToDB, AlignableTracker::alignmentErrors(), AlignableTracker::alignments(), cond::service::PoolDBOutputService::beginOfTime(), compareGeometries(), compareSurfaceDeformations(), createROOTGeometry(), currentTracker, firstEvent_, edm::Service< T >::isAvailable(), referenceTracker, setCommonTrackerSystem(), and cond::service::PoolDBOutputService::writeOne().

229  {
230 
231  if (firstEvent_) {
232 
233  //upload the ROOT geometries
234  createROOTGeometry(iSetup);
235 
236  //set common tracker system first
237  // if setting the tracker common system
238  if (_setCommonTrackerSystem != "NONE"){
239  setCommonTrackerSystem();
240  }
241 
242  //compare the goemetries
243  compareGeometries(referenceTracker,currentTracker);
244  compareSurfaceDeformations(_inputTree11, _inputTree12);
245 
246  //write out ntuple
247  //might be better to do within output module
248 
249  if (_writeToDB){
250  Alignments* myAlignments = currentTracker->alignments();
251  AlignmentErrors* myAlignmentErrors = currentTracker->alignmentErrors();
252 
253  // 2. Store alignment[Error]s to DB
254  edm::Service<cond::service::PoolDBOutputService> poolDbService;
255  // Call service
256  if( !poolDbService.isAvailable() ) // Die if not available
257  throw cms::Exception("NotAvailable") << "PoolDBOutputService not available";
258 
259  poolDbService->writeOne<Alignments>(&(*myAlignments), poolDbService->beginOfTime(), "TrackerAlignmentRcd");
260  poolDbService->writeOne<AlignmentErrors>(&(*myAlignmentErrors), poolDbService->beginOfTime(), "TrackerAlignmentErrorRcd");
261 
262  }
263 
264  firstEvent_ = false;
265  }
266 }
TrackerGeometryCompare::compareGeometries
void compareGeometries(Alignable *refAli, Alignable *curAli)
Definition: TrackerGeometryCompare.cc:578
edm::Service::isAvailable
bool isAvailable() const
Definition: Service.h:47
AlignableTracker::alignmentErrors
AlignmentErrors * alignmentErrors() const
Return alignment errors, sorted by DetId.
Definition: AlignableTracker.cc:305
cond::service::PoolDBOutputService::writeOne
void writeOne(T *payload, Time_t time, const std::string &recordName, bool withlogging=false)
Definition: PoolDBOutputService.h:116
TrackerGeometryCompare::currentTracker
AlignableTracker * currentTracker
Definition: TrackerGeometryCompare.h:99
TrackerGeometryCompare::referenceTracker
AlignableTracker * referenceTracker
Definition: TrackerGeometryCompare.h:97
TrackerGeometryCompare::createROOTGeometry
void createROOTGeometry(const edm::EventSetup &iSetup)
Definition: TrackerGeometryCompare.cc:268
AlignableTracker::alignments
Alignments * alignments() const
Return alignments, sorted by DetId.
Definition: AlignableTracker.cc:282
TrackerGeometryCompare::compareSurfaceDeformations
void compareSurfaceDeformations(TTree *_inputTree11, TTree *_inputTree12)
Definition: TrackerGeometryCompare.cc:435
void TrackerGeometryCompare::beginJob ( void  )
virtual

Read from DB and print survey info.

Reimplemented from edm::EDAnalyzer.

Definition at line 205 of file TrackerGeometryCompare.cc.

References firstEvent_.

205  {
206  firstEvent_ = true;
207 }
void TrackerGeometryCompare::compareGeometries ( Alignable *  refAli,
Alignable *  curAli 
)
private

Definition at line 578 of file TrackerGeometryCompare.cc.

References _weightBy, _weightById, _weightByIdVector, Alignable::alignableObjectId(), CastorDataFrameFilter_impl::check(), Alignable::components(), cond::rpcobgas::detid, diffTreeTool::diff, align::diffAlignables(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, alignCSCRings::e, edm::hlt::Exception, fillTree(), Alignable::geomDetId(), i, Alignable::id(), m_theLevels, PV3DBase< T, PVType, FrameType >::mag(), align::moveAlignable(), DetId::rawId(), and makeMuonMisalignmentScenario::rot.

Referenced by analyze().

578  {
579 
580  using namespace align ;
581 
582  const std::vector<Alignable*>& refComp = refAli->components();
583  const std::vector<Alignable*>& curComp = curAli->components();
584 
585  unsigned int nComp = refComp.size();
586  //only perform for designate levels
587  bool useLevel = false;
588  for (unsigned int i = 0; i < m_theLevels.size(); ++i){
589  if (refAli->alignableObjectId() == m_theLevels[i]) useLevel = true;
590  }
591 
592  //another added level for difference between det and detunit
593  //if ((refAli->alignableObjectId()==2)&&(nComp == 1)) useLevel = false;
594 
595  //coordinate matching, etc etc
596  if (useLevel){
597  DetId detid(refAli->id());
598 
599  CLHEP::Hep3Vector Rtotal, Wtotal, lRtotal, lWtotal;
600  Rtotal.set(0.,0.,0.);
601  Wtotal.set(0.,0.,0.);
602  lRtotal.set(0.,0.,0.);
603  lWtotal.set(0.,0.,0.);
604 
605  for (int i = 0; i < 100; i++){
606  AlgebraicVector diff = align::diffAlignables(refAli,curAli, _weightBy, _weightById, _weightByIdVector);
607  CLHEP::Hep3Vector dR(diff[0],diff[1],diff[2]);
608  Rtotal+=dR;
609  CLHEP::Hep3Vector dW(diff[3],diff[4],diff[5]);
610  CLHEP::HepRotation rot(Wtotal.unit(),Wtotal.mag());
611  CLHEP::HepRotation drot(dW.unit(),dW.mag());
612  rot*=drot;
613  Wtotal.set(rot.axis().x()*rot.delta(), rot.axis().y()*rot.delta(), rot.axis().z()*rot.delta());
614  // local coordinates
615  lRtotal.set(diff[6],diff[7],diff[8]);
616  lWtotal.set(diff[9],diff[10],diff[11]);
617  align::moveAlignable(curAli, diff);
618  float tolerance = 1e-7;
619  AlgebraicVector check = align::diffAlignables(refAli,curAli, _weightBy, _weightById, _weightByIdVector);
620  align::GlobalVector checkR(check[0],check[1],check[2]);
621  align::GlobalVector checkW(check[3],check[4],check[5]);
622  if ((checkR.mag() > tolerance)||(checkW.mag() > tolerance)){
623  edm::LogInfo("TrackerGeometryCompare") << "Tolerance Exceeded!(alObjId: " << refAli->alignableObjectId()
624  << ", rawId: " << refAli->geomDetId().rawId()
625  << ", subdetId: "<< detid.subdetId() << "): " << diff;
626  throw cms::Exception("Tolerance in TrackerGeometryCompare exceeded");
627  }
628  else{
629  break;
630  }
631  }
632 
633  AlgebraicVector TRtot(12);
634  // global
635  TRtot(1) = Rtotal.x(); TRtot(2) = Rtotal.y(); TRtot(3) = Rtotal.z();
636  TRtot(4) = Wtotal.x(); TRtot(5) = Wtotal.y(); TRtot(6) = Wtotal.z();
637  // local
638  TRtot(7) = lRtotal.x(); TRtot(8) = lRtotal.y(); TRtot(9) = lRtotal.z();
639  TRtot(10) = lWtotal.x(); TRtot(11) = lWtotal.y(); TRtot(12) = lWtotal.z();
640 
641  fillTree(refAli, TRtot);
642  }
643 
644  // another added level for difference between det and detunit
645  for (unsigned int i = 0; i < nComp; ++i)
646  compareGeometries(refComp[i],curComp[i]);
647 
648 }
TrackerGeometryCompare::compareGeometries
void compareGeometries(Alignable *refAli, Alignable *curAli)
Definition: TrackerGeometryCompare.cc:578
Alignable::id
align::ID id() const
Return the ID of Alignable, i.e. DetId of &#39;first&#39; component GeomDet(Unit).
Definition: Alignable.h:180
i
int i
Definition: DBlmapReader.cc:9
TrackerGeometryCompare::m_theLevels
std::vector< align::StructureType > m_theLevels
Definition: TrackerGeometryCompare.h:74
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 Alignables components() const =0
Return vector of all direct components.
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:45
CastorDataFrameFilter_impl::check
bool check(const DataFrame &df, bool capcheck, bool dvercheck)
Definition: CastorDataFrameFilter.cc:6
TrackerGeometryCompare::fillTree
void fillTree(Alignable *refAli, AlgebraicVector diff)
Definition: TrackerGeometryCompare.cc:746
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.dR
tuple dR
Definition: PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.py:19
DetId
Definition: DetId.h:20
AlgebraicVector
CLHEP::HepVector AlgebraicVector
Definition: AlgebraicObjects.h:12
TrackerGeometryCompare::_weightByIdVector
std::vector< unsigned int > _weightByIdVector
Definition: TrackerGeometryCompare.h:117
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:177
void TrackerGeometryCompare::compareSurfaceDeformations ( TTree *  _inputTree11,
TTree *  _inputTree12 
)
private

Definition at line 435 of file TrackerGeometryCompare.cc.

References _inputFilename1, _inputFilename2, _inputRootFile1, _inputRootFile2, _inputTreenameDeform, _surfDeform, m_h1, m_nBins, m_rangeHigh, m_rangeLow, m_vtkmap, and hitfit::return.

Referenced by analyze().

435  {
436 
437  if (_inputFilename1 != "IDEAL" && _inputFilename2 != "IDEAL") {
438 
439  int inputRawid1;
440  int inputRawid2;
441  int inputSubdetid1, inputSubdetid2 ;
442  int inputDtype1, inputDtype2 ;
443  std::vector<double> inputDpar1;
444  std::vector<double> inputDpar2 ;
445  std::vector<double>* p_inputDpar1 = &inputDpar1;
446  std::vector<double>* p_inputDpar2 = &inputDpar2;
447 
448  TTree* refTree = (TTree*) _inputRootFile1->Get(_inputTreenameDeform.c_str());
449  refTree->SetBranchAddress("irawid", &inputRawid1);
450  refTree->SetBranchAddress("subdetid", &inputSubdetid1);
451  refTree->SetBranchAddress("dtype", &inputDtype1);
452  refTree->SetBranchAddress("dpar", &p_inputDpar1);
453 
454  TTree* curTree = (TTree*) _inputRootFile2->Get(_inputTreenameDeform.c_str());
455  curTree->SetBranchAddress("irawid", &inputRawid2);
456  curTree->SetBranchAddress("subdetid", &inputSubdetid2);
457  curTree->SetBranchAddress("dtype", &inputDtype2);
458  curTree->SetBranchAddress("dpar", &p_inputDpar2);
459 
460  unsigned int nEntries11 = refTree->GetEntries();
461  unsigned int nEntries12 = curTree->GetEntries();
462 
463  if (nEntries11 != nEntries12) {
464  edm::LogError("TrackerGeometryCompare") << " Surface deformation parameters in two geometries differ!\n" ;
465  return ;
466  }
467 
468  for (unsigned int iEntry = 0; iEntry < nEntries12; ++iEntry) {
469  refTree->GetEntry(iEntry) ;
470  curTree->GetEntry(iEntry) ;
471  for (int ii = 0; ii < 13; ++ii) { _surfDeform[ii] = -1.0 ; }
472  for (int npar = 0; npar < int(inputDpar2.size()); ++npar ) {
473  if (inputRawid1 == inputRawid2) {
474  _surfDeform[npar] = inputDpar2.at(npar) - inputDpar1.at(npar) ;
475  std::stringstream histname0 ;
476  histname0 << "SurfDeform_Par_" << npar ;
477  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname0.str()]->Fill(_surfDeform[npar]) ;
478  if (inputSubdetid1 == 1 && inputSubdetid2 == 1) {
479  std::stringstream histname1 ;
480  histname1 << "SurfDeform_PixelBarrel_Par_" << npar ;
481  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname1.str()]->Fill(_surfDeform[npar]) ;
482  }
483  if (inputSubdetid1 == 2 && inputSubdetid2 == 2) {
484  std::stringstream histname2 ;
485  histname2 << "SurfDeform_PixelEndcap_Par_" << npar ;
486  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname2.str()]->Fill(_surfDeform[npar]) ;
487  }
488  (m_vtkmap.at(npar)).fill_current_val(inputRawid1,_surfDeform[npar]) ;
489  }
490  }
491  }
492 
493  } else if ( _inputFilename1 == "IDEAL" && _inputFilename2 != "IDEAL" ) {
494 
495  int inputRawid2;
496  int inputSubdetid2 ;
497  int inputDtype2 ;
498  std::vector<double> inputDpar2 ;
499  std::vector<double>* p_inputDpar2 = &inputDpar2;
500 
501  TTree* curTree = (TTree*) _inputRootFile2->Get(_inputTreenameDeform.c_str());
502  curTree->SetBranchAddress("irawid", &inputRawid2);
503  curTree->SetBranchAddress("subdetid", &inputSubdetid2);
504  curTree->SetBranchAddress("dtype", &inputDtype2);
505  curTree->SetBranchAddress("dpar", &p_inputDpar2);
506 
507  unsigned int nEntries12 = curTree->GetEntries();
508 
509  for (unsigned int iEntry = 0; iEntry < nEntries12; ++iEntry) {
510  curTree->GetEntry(iEntry) ;
511  for (int ii = 0; ii < 12; ++ii) { _surfDeform[ii] = -1.0 ; }
512  for (int npar = 0; npar < int(inputDpar2.size()); ++npar ) {
513  _surfDeform[npar] = inputDpar2.at(npar) ;
514  std::stringstream histname0 ;
515  histname0 << "SurfDeform_Par_" << npar ;
516  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname0.str()]->Fill(_surfDeform[npar]) ;
517  if (inputSubdetid2 == 1) {
518  std::stringstream histname1 ;
519  histname1 << "SurfDeform_PixelBarrel_Par_" << npar ;
520  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname1.str()]->Fill(_surfDeform[npar]) ;
521  }
522  if (inputSubdetid2 == 2) {
523  std::stringstream histname2 ;
524  histname2 << "SurfDeform_PixelEndcap_Par_" << npar ;
525  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname2.str()]->Fill(_surfDeform[npar]) ;
526  }
527  (m_vtkmap.at(npar)).fill_current_val(inputRawid2,_surfDeform[npar]) ;
528  }
529  }
530 
531  } else if ( _inputFilename1 != "IDEAL" && _inputFilename2 == "IDEAL" ) {
532 
533  int inputRawid1;
534  int inputSubdetid1 ;
535  int inputDtype1 ;
536  std::vector<double> inputDpar1;
537  std::vector<double>* p_inputDpar1 = &inputDpar1;
538 
539  TTree* refTree = (TTree*) _inputRootFile1->Get(_inputTreenameDeform.c_str());
540  refTree->SetBranchAddress("irawid", &inputRawid1);
541  refTree->SetBranchAddress("subdetid", &inputSubdetid1);
542  refTree->SetBranchAddress("dtype", &inputDtype1);
543  refTree->SetBranchAddress("dpar", &p_inputDpar1);
544 
545  unsigned int nEntries11 = refTree->GetEntries();
546 
547  for (unsigned int iEntry = 0; iEntry < nEntries11; ++iEntry) {
548  refTree->GetEntry(iEntry) ;
549  for (int ii = 0; ii < 12; ++ii) { _surfDeform[ii] = -1.0 ; }
550  for (int npar = 0; npar < int(inputDpar1.size()); ++npar ) {
551  _surfDeform[npar] = - inputDpar1.at(npar) ;
552  std::stringstream histname0 ;
553  histname0 << "SurfDeform_Par_" << npar ;
554  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname0.str()]->Fill(_surfDeform[npar]) ;
555  if (inputSubdetid1 == 1) {
556  std::stringstream histname1 ;
557  histname1 << "SurfDeform_PixelBarrel_Par_" << npar ;
558  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname1.str()]->Fill(_surfDeform[npar]) ;
559  }
560  if (inputSubdetid1 == 2) {
561  std::stringstream histname2 ;
562  histname2 << "SurfDeform_PixelEndcap_Par_" << npar ;
563  if ( TMath::Abs(_surfDeform[npar]) > (m_rangeHigh - m_rangeLow)/(10.*m_nBins) ) m_h1[histname2.str()]->Fill(_surfDeform[npar]) ;
564  }
565  (m_vtkmap.at(npar)).fill_current_val(inputRawid1,_surfDeform[npar]) ;
566  }
567  }
568 
569  } else if ( _inputFilename1 == "IDEAL" && _inputFilename2 == "IDEAL" ) {
570 
571  edm::LogInfo("TrackerGeometryCompare") << ">>>> Comparing IDEAL with IDEAL: nothing to do! <<<<\n" ;
572 
573  }
574 
575  return ;
576 }
TrackerGeometryCompare::m_vtkmap
std::vector< TrackerMap > m_vtkmap
Definition: TrackerGeometryCompare.h:155
TrackerGeometryCompare::m_h1
std::map< std::string, TH1D * > m_h1
Definition: TrackerGeometryCompare.h:157
void TrackerGeometryCompare::createROOTGeometry ( const edm::EventSetup &  iSetup)
private

Definition at line 268 of file TrackerGeometryCompare.cc.

References _inputFilename1, _inputFilename2, _inputRootFile1, _inputRootFile2, _inputTree01, _inputTree02, _inputTree11, _inputTree12, _inputTreenameAlign, _inputTreenameDeform, GeometryAligner::applyAlignments(), TrackerGeomBuilderFromGeometricDet::build(), SurfaceDeformationFactory::create(), currentTracker, Alignable::deepComponents(), align::DetectorGlobalPosition(), edm::EventSetup::get(), edm::eventsetup::EventSetupRecord::get(), i, Alignments::m_align, AlignmentErrors::m_alignError, referenceTracker, python.multivaluedict::sort(), and DetId::Tracker.

Referenced by analyze().

268  {
269 
270  int inputRawId1, inputRawId2;
271  double inputX1, inputY1, inputZ1, inputX2, inputY2, inputZ2;
272  double inputAlpha1, inputBeta1, inputGamma1, inputAlpha2, inputBeta2, inputGamma2;
273 
274  //declare alignments
275  Alignments* alignments1 = new Alignments();
276  AlignmentErrors* alignmentErrors1 = new AlignmentErrors();
277  if (_inputFilename1 != "IDEAL"){
278  _inputRootFile1 = new TFile(_inputFilename1.c_str());
279  TTree* _inputTree01 = (TTree*) _inputRootFile1->Get(_inputTreenameAlign.c_str());
280  _inputTree01->SetBranchAddress("rawid", &inputRawId1);
281  _inputTree01->SetBranchAddress("x", &inputX1);
282  _inputTree01->SetBranchAddress("y", &inputY1);
283  _inputTree01->SetBranchAddress("z", &inputZ1);
284  _inputTree01->SetBranchAddress("alpha", &inputAlpha1);
285  _inputTree01->SetBranchAddress("beta", &inputBeta1);
286  _inputTree01->SetBranchAddress("gamma", &inputGamma1);
287 
288  int nEntries1 = _inputTree01->GetEntries();
289  //fill alignments
290  for (int i = 0; i < nEntries1; ++i){
291 
292  _inputTree01->GetEntry(i);
293  CLHEP::Hep3Vector translation1(inputX1, inputY1, inputZ1);
294  CLHEP::HepEulerAngles eulerangles1(inputAlpha1,inputBeta1,inputGamma1);
295  uint32_t detid1 = inputRawId1;
296  AlignTransform transform1(translation1, eulerangles1, detid1);
297  alignments1->m_align.push_back(transform1);
298 
299  //dummy errors
300  CLHEP::HepSymMatrix clhepSymMatrix(3,0);
301  AlignTransformError transformError(clhepSymMatrix, detid1);
302  alignmentErrors1->m_alignError.push_back(transformError);
303  }
304 
305  // to get the right order
306  std::sort( alignments1->m_align.begin(), alignments1->m_align.end(), lessAlignmentDetId<AlignTransform>() );
307  std::sort( alignmentErrors1->m_alignError.begin(), alignmentErrors1->m_alignError.end(), lessAlignmentDetId<AlignTransformError>() );
308  }
309  //------------------
310  Alignments* alignments2 = new Alignments();
311  AlignmentErrors* alignmentErrors2 = new AlignmentErrors();
312  if (_inputFilename2 != "IDEAL"){
313  _inputRootFile2 = new TFile(_inputFilename2.c_str());
314  TTree* _inputTree02 = (TTree*) _inputRootFile2->Get(_inputTreenameAlign.c_str());
315  _inputTree02->SetBranchAddress("rawid", &inputRawId2);
316  _inputTree02->SetBranchAddress("x", &inputX2);
317  _inputTree02->SetBranchAddress("y", &inputY2);
318  _inputTree02->SetBranchAddress("z", &inputZ2);
319  _inputTree02->SetBranchAddress("alpha", &inputAlpha2);
320  _inputTree02->SetBranchAddress("beta", &inputBeta2);
321  _inputTree02->SetBranchAddress("gamma", &inputGamma2);
322 
323  int nEntries2 = _inputTree02->GetEntries();
324  //fill alignments
325  for (int i = 0; i < nEntries2; ++i){
326 
327  _inputTree02->GetEntry(i);
328  CLHEP::Hep3Vector translation2(inputX2, inputY2, inputZ2);
329  CLHEP::HepEulerAngles eulerangles2(inputAlpha2,inputBeta2,inputGamma2);
330  uint32_t detid2 = inputRawId2;
331  AlignTransform transform2(translation2, eulerangles2, detid2);
332  alignments2->m_align.push_back(transform2);
333 
334  //dummy errors
335  CLHEP::HepSymMatrix clhepSymMatrix(3,0);
336  AlignTransformError transformError(clhepSymMatrix, detid2);
337  alignmentErrors2->m_alignError.push_back(transformError);
338  }
339 
340  //to get the right order
341  std::sort( alignments2->m_align.begin(), alignments2->m_align.end(), lessAlignmentDetId<AlignTransform>() );
342  std::sort( alignmentErrors2->m_alignError.begin(), alignmentErrors2->m_alignError.end(), lessAlignmentDetId<AlignTransformError>() );
343  }
344 
345  //accessing the initial geometry
346  edm::ESTransientHandle<DDCompactView> cpv;
347  iSetup.get<IdealGeometryRecord>().get(cpv);
348  edm::ESHandle<GeometricDet> theGeometricDet;
349  iSetup.get<IdealGeometryRecord>().get(theGeometricDet);
350  TrackerGeomBuilderFromGeometricDet trackerBuilder;
351 
352  edm::ESHandle<Alignments> globalPositionRcd;
353  iSetup.get<TrackerDigiGeometryRecord>().getRecord<GlobalPositionRcd>().get(globalPositionRcd);
354 
355  //reference tracker
356  TrackerGeometry* theRefTracker = trackerBuilder.build(&*theGeometricDet); //DM_534??
357  if (_inputFilename1 != "IDEAL"){
358  GeometryAligner aligner1;
359  aligner1.applyAlignments<TrackerGeometry>( &(*theRefTracker), &(*alignments1), &(*alignmentErrors1),
360  align::DetectorGlobalPosition(*globalPositionRcd, DetId(DetId::Tracker)));
361  }
362  referenceTracker = new AlignableTracker(&(*theRefTracker));
363  //referenceTracker->setSurfaceDeformation(surfDef1, true) ;
364 
365  int inputRawid1;
366  int inputRawid2;
367  int inputDtype1, inputDtype2 ;
368  std::vector<double> inputDpar1;
369  std::vector<double> inputDpar2 ;
370  std::vector<double>* p_inputDpar1 = &inputDpar1;
371  std::vector<double>* p_inputDpar2 = &inputDpar2;
372 
373  const std::vector<Alignable*> comp1 = referenceTracker->deepComponents();
374 
375  SurfaceDeformation * surfDef1;
376  if (_inputFilename1 != "IDEAL"){
377  TTree* _inputTree11 = (TTree*) _inputRootFile1->Get(_inputTreenameDeform.c_str());
378  _inputTree11->SetBranchAddress("irawid", &inputRawid1);
379  _inputTree11->SetBranchAddress("dtype", &inputDtype1);
380  _inputTree11->SetBranchAddress("dpar", &p_inputDpar1);
381 
382  unsigned int nEntries11 = _inputTree11->GetEntries();
383  edm::LogInfo("TrackerGeometryCompare") << " nentries11 = " << nEntries11 << std::endl ;
384  for (unsigned int iEntry = 0; iEntry < nEntries11; ++iEntry) {
385  _inputTree11->GetEntry(iEntry) ;
386 
387  surfDef1 = SurfaceDeformationFactory::create( inputDtype1, inputDpar1);
388 
389  if (int(comp1[iEntry]->id()) == inputRawid1) {
390  comp1[iEntry]->setSurfaceDeformation(surfDef1, true) ;
391  }
392 
393  }
394  }
395 
396  //currernt tracker
397  TrackerGeometry* theCurTracker = trackerBuilder.build(&*theGeometricDet); //DM_534??
398  if (_inputFilename2 != "IDEAL"){
399  GeometryAligner aligner2;
400  aligner2.applyAlignments<TrackerGeometry>( &(*theCurTracker), &(*alignments2), &(*alignmentErrors2),
401  align::DetectorGlobalPosition(*globalPositionRcd, DetId(DetId::Tracker)));
402  }
403  currentTracker = new AlignableTracker(&(*theCurTracker));
404 
405  const std::vector<Alignable*> comp2 = currentTracker->deepComponents();
406 
407  SurfaceDeformation * surfDef2 ;
408  if (_inputFilename2 != "IDEAL"){
409  TTree* _inputTree12 = (TTree*) _inputRootFile2->Get(_inputTreenameDeform.c_str());
410  _inputTree12->SetBranchAddress("irawid", &inputRawid2);
411  _inputTree12->SetBranchAddress("dtype", &inputDtype2);
412  _inputTree12->SetBranchAddress("dpar", &p_inputDpar2);
413 
414  unsigned int nEntries12 = _inputTree12->GetEntries();
415  edm::LogInfo("TrackerGeometryCompare") << " nentries12 = " << nEntries12 << std::endl ;
416  for (unsigned int iEntry = 0; iEntry < nEntries12; ++iEntry) {
417  _inputTree12->GetEntry(iEntry) ;
418 
419  surfDef2 = SurfaceDeformationFactory::create( inputDtype2, inputDpar2);
420 
421  if (int(comp2[iEntry]->id()) == inputRawid2) {
422  comp2[iEntry]->setSurfaceDeformation(surfDef2, true) ;
423  }
424 
425  }
426  }
427 
428  delete alignments1;
429  delete alignmentErrors1;
430  delete alignments2;
431  delete alignmentErrors2;
432 
433 }
i
int i
Definition: DBlmapReader.cc:9
GeometryAligner
Class to update a given geometry with a set of alignments.
Definition: GeometryAligner.h:32
AlignmentErrors::m_alignError
std::vector< AlignTransformError > m_alignError
Definition: AlignmentErrors.h:14
Alignments::m_align
std::vector< AlignTransform > m_align
Definition: Alignments.h:14
edm::eventsetup::EventSetupRecord::get
void get(HolderT &iHolder) const
Definition: EventSetupRecord.h:87
GeometryAligner::applyAlignments
void applyAlignments(C *geometry, const Alignments *alignments, const AlignmentErrors *alignmentErrors, const AlignTransform &globalCoordinates)
Definition: GeometryAligner.h:54
DetId
Definition: DetId.h:20
TrackerGeometryCompare::currentTracker
AlignableTracker * currentTracker
Definition: TrackerGeometryCompare.h:99
Alignable::deepComponents
const Alignables & deepComponents() const
Definition: Alignable.h:71
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
TrackerGeomBuilderFromGeometricDet::build
TrackerGeometry * build(const GeometricDet *gd)
Definition: TrackerGeomBuilderFromGeometricDet.cc:43
TrackerGeometryCompare::referenceTracker
AlignableTracker * referenceTracker
Definition: TrackerGeometryCompare.h:97
align::DetectorGlobalPosition
const AlignTransform & DetectorGlobalPosition(const Alignments &allGlobals, const DetId &id)
Definition: DetectorGlobalPosition.cc:10
SurfaceDeformationFactory::create
SurfaceDeformation * create(int type, const std::vector< double > &params)
Definition: SurfaceDeformationFactory.cc:30
void TrackerGeometryCompare::diffCommonTrackerSystem ( Alignable *  refAli,
Alignable *  curAli 
)
private

Definition at line 687 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(), i, and makeMuonMisalignmentScenario::rot.

Referenced by setCommonTrackerSystem().

687  {
688 
689  const std::vector<Alignable*>& refComp = refAli->components();
690  const std::vector<Alignable*>& curComp = curAli->components();
691 
692  unsigned int nComp = refComp.size();
693  //only perform for designate levels
694  bool useLevel = false;
695  if (refAli->alignableObjectId() == _commonTrackerLevel) useLevel = true;
696 
697  //useLevel = false;
698  if (useLevel){
699  CLHEP::Hep3Vector Rtotal, Wtotal;
700  Rtotal.set(0.,0.,0.); Wtotal.set(0.,0.,0.);
701 
702  AlgebraicVector diff = align::diffAlignables(refAli,curAli, _weightBy, _weightById, _weightByIdVector);
703  CLHEP::Hep3Vector dR(diff[0],diff[1],diff[2]);
704  Rtotal+=dR;
705  CLHEP::Hep3Vector dW(diff[3],diff[4],diff[5]);
706  CLHEP::HepRotation rot(Wtotal.unit(),Wtotal.mag());
707  CLHEP::HepRotation drot(dW.unit(),dW.mag());
708  rot*=drot;
709  Wtotal.set(rot.axis().x()*rot.delta(), rot.axis().y()*rot.delta(), rot.axis().z()*rot.delta());
710  /*
711  //std::cout << "a";
712  //if (refAli->alignableObjectId() == 1) std::cout << "DIFF: " << diff << std::endl;
713  align::moveAlignable(curAli, diff);
714  float tolerance = 1e-7;
715  AlgebraicVector check = align::diffAlignables(refAli,curAli, _weightBy, _weightById, _weightByIdVector);
716  align::GlobalVector checkR(check[0],check[1],check[2]);
717  align::GlobalVector checkW(check[3],check[4],check[5]);
718  DetId detid(refAli->id());
719  if ((checkR.mag() > tolerance)||(checkW.mag() > tolerance)){
720  edm::LogInfo("TrackerGeometryCompare") << "Tolerance Exceeded!(alObjId: " << refAli->alignableObjectId()
721  << ", rawId: " << refAli->geomDetId().rawId()
722  << ", subdetId: "<< detid.subdetId() << "): " << diff;
723  }
724  else{
725  break;
726  }
727  }
728  */
729 
730  //_TrackerCommonT.set(Rtotal.x(), Rtotal.y(), Rtotal.z());
731  _TrackerCommonT = align::GlobalVector(Rtotal.x(), Rtotal.y(), Rtotal.z());
732  _TrackerCommonR = align::GlobalVector(Wtotal.x(), Wtotal.y(), Wtotal.z());
733  _TrackerCommonCM = curAli->globalPosition();
734  //_TrackerCommonTR(1) = Rtotal.x(); _TrackerCommonTR(2) = Rtotal.y(); _TrackerCommonTR(3) = Rtotal.z();
735  //_TrackerCommonTR(4) = Wtotal.x(); _TrackerCommonTR(5) = Wtotal.y(); _TrackerCommonTR(6) = Wtotal.z();
736 
737 
738  }
739  else{
740  for (unsigned int i = 0; i < nComp; ++i) diffCommonTrackerSystem(refComp[i],curComp[i]);
741  }
742 
743 
744 }
i
int i
Definition: DBlmapReader.cc:9
TrackerGeometryCompare::_TrackerCommonR
align::GlobalVector _TrackerCommonR
Definition: TrackerGeometryCompare.h:122
align::GlobalVector
Vector3DBase< Scalar, GlobalTag > GlobalVector
Definition: Definitions.h:33
TrackerGeometryCompare::_TrackerCommonT
align::GlobalVector _TrackerCommonT
Definition: TrackerGeometryCompare.h:121
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:687
Alignable::components
virtual Alignables components() const =0
Return vector of all direct components.
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.dR
tuple dR
Definition: PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi.py:19
TrackerGeometryCompare::_commonTrackerLevel
align::StructureType _commonTrackerLevel
Definition: TrackerGeometryCompare.h:120
TrackerGeometryCompare::_TrackerCommonCM
align::PositionType _TrackerCommonCM
Definition: TrackerGeometryCompare.h:123
AlgebraicVector
CLHEP::HepVector AlgebraicVector
Definition: AlgebraicObjects.h:12
TrackerGeometryCompare::_weightByIdVector
std::vector< unsigned int > _weightByIdVector
Definition: TrackerGeometryCompare.h:117
Alignable::globalPosition
const PositionType & globalPosition() const
Return the global position of the object.
Definition: Alignable.h:129
void TrackerGeometryCompare::endJob ( void  )
virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 209 of file TrackerGeometryCompare.cc.

References _alignTree, _theFile, and m_vtkmap.

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

Definition at line 927 of file TrackerGeometryCompare.cc.

References _identifiers, PXFDetId::blade(), gather_cfg::cout, PXFDetId::disk(), PXBDetId::ladder(), PXBDetId::layer(), TOBDetId::layer(), TIBDetId::layer(), PXBDetId::module(), PXFDetId::module(), TOBDetId::module(), TIBDetId::module(), TIDDetId::module(), TECDetId::module(), PXFDetId::panel(), TECDetId::petal(), TIDDetId::ring(), TECDetId::ring(), TOBDetId::rod(), PXFDetId::side(), TIDDetId::side(), TECDetId::side(), TIBDetId::string(), TIDDetId::wheel(), and TECDetId::wheel().

Referenced by fillTree().

927  {
928 
929 
930  switch( subdetlevel ){
931 
932  case 1:
933  {
934  PXBDetId pxbid( rawid );
935  _identifiers[0] = pxbid.module();
936  _identifiers[1] = pxbid.ladder();
937  _identifiers[2] = pxbid.layer();
938  _identifiers[3] = 999;
939  _identifiers[4] = 999;
940  _identifiers[5] = 999;
941  break;
942  }
943  case 2:
944  {
945  PXFDetId pxfid( rawid );
946  _identifiers[0] = pxfid.module();
947  _identifiers[1] = pxfid.panel();
948  _identifiers[2] = pxfid.blade();
949  _identifiers[3] = pxfid.disk();
950  _identifiers[4] = pxfid.side();
951  _identifiers[5] = 999;
952  break;
953  }
954  case 3:
955  {
956  TIBDetId tibid( rawid );
957  _identifiers[0] = tibid.module();
958  _identifiers[1] = tibid.string()[0];
959  _identifiers[2] = tibid.string()[1];
960  _identifiers[3] = tibid.string()[2];
961  _identifiers[4] = tibid.layer();
962  _identifiers[5] = 999;
963  break;
964  }
965  case 4:
966  {
967  TIDDetId tidid( rawid );
968  _identifiers[0] = tidid.module()[0];
969  _identifiers[1] = tidid.module()[1];
970  _identifiers[2] = tidid.ring();
971  _identifiers[3] = tidid.wheel();
972  _identifiers[4] = tidid.side();
973  _identifiers[5] = 999;
974  break;
975  }
976  case 5:
977  {
978  TOBDetId tobid( rawid );
979  _identifiers[0] = tobid.module();
980  _identifiers[1] = tobid.rod()[0];
981  _identifiers[2] = tobid.rod()[1];
982  _identifiers[3] = tobid.layer();
983  _identifiers[4] = 999;
984  _identifiers[5] = 999;
985  break;
986  }
987  case 6:
988  {
989  TECDetId tecid( rawid );
990  _identifiers[0] = tecid.module();
991  _identifiers[1] = tecid.ring();
992  _identifiers[2] = tecid.petal()[0];
993  _identifiers[3] = tecid.petal()[1];
994  _identifiers[4] = tecid.wheel();
995  _identifiers[5] = tecid.side();
996  break;
997  }
998  default:
999  {
1000  std::cout << "Error: bad subdetid!!" << std::endl;
1001  break;
1002  }
1003 
1004  }
1005 }
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
void TrackerGeometryCompare::fillTree ( Alignable *  refAli,
AlgebraicVector  diff 
)
private

Definition at line 746 of file TrackerGeometryCompare.cc.

References _alignTree, _alphaVal, _betaVal, _dalphaVal, _daVal, _dbetaVal, _dbVal, _detDim, _detIdFlag, _dgammaVal, _dgVal, _dphiVal, _drVal, _duVal, _dvVal, _dwVal, _dxVal, _dyVal, _dzVal, _etaVal, _gammaVal, _id, _level, _mid, _mlevel, _phiVal, _rVal, _sublevel, _surLength, _surRot, _surWidth, _useDetId, _xVal, _yVal, _zVal, align::AlignableDet, align::AlignableDetUnit, Alignable::alignableObjectId(), cond::rpcobgas::detid, PV3DBase< T, PVType, FrameType >::eta(), fillIdentifiers(), g, Alignable::geomDetId(), Alignable::globalPosition(), Alignable::globalRotation(), Alignable::id(), 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().

746  {
747 
748  _id = refAli->id();
749  _level = refAli->alignableObjectId();
750  //need if ali has no mother
751  if (refAli->mother()){
752  _mid = refAli->mother()->geomDetId().rawId();
753  _mlevel = refAli->mother()->alignableObjectId();
754  }
755  else{
756  _mid = -1;
757  _mlevel = -1;
758  }
759  DetId detid(_id);
760  _sublevel = detid.subdetId();
761  fillIdentifiers( _sublevel, _id );
762  _xVal = refAli->globalPosition().x();
763  _yVal = refAli->globalPosition().y();
764  _zVal = refAli->globalPosition().z();
765  align::GlobalVector vec(_xVal,_yVal,_zVal);
766  _rVal = vec.perp();
767  _phiVal = vec.phi();
768  _etaVal = vec.eta();
769  align::RotationType rot = refAli->globalRotation();
770  align::EulerAngles eulerAngles = align::toAngles(rot);
771  _alphaVal = eulerAngles[0];
772  _betaVal = eulerAngles[1];
773  _gammaVal = eulerAngles[2];
774  // global
775  _dxVal = diff[0];
776  _dyVal = diff[1];
777  _dzVal = diff[2];
778  // local
779  _duVal = diff[6];
780  _dvVal = diff[7];
781  _dwVal = diff[8];
782  //...TODO...
783  align::GlobalVector g(_dxVal, _dyVal, _dzVal);
784  //getting dR and dPhi
785  align::GlobalVector vRef(_xVal,_yVal,_zVal);
786  align::GlobalVector vCur(_xVal + _dxVal, _yVal + _dyVal, _zVal + _dzVal);
787  _drVal = vCur.perp() - vRef.perp();
788  _dphiVal = vCur.phi() - vRef.phi();
789  // global
790  _dalphaVal = diff[3];
791  _dbetaVal = diff[4];
792  _dgammaVal = diff[5];
793  // local
794  _daVal = diff[9];
795  _dbVal = diff[10];
796  _dgVal = diff[11];
797 
798  //detIdFlag
799  if (refAli->alignableObjectId() == align::AlignableDetUnit){
800  if (_detIdFlag){
801  if ((passIdCut(refAli->id()))||(passIdCut(refAli->mother()->id()))){
802  _useDetId = 1;
803  }
804  else{
805  _useDetId = 0;
806  }
807  }
808  }
809  // det module dimension
810  if (refAli->alignableObjectId() == align::AlignableDetUnit){
811  if (refAli->mother()->alignableObjectId() != align::AlignableDet) _detDim = 1;
812  else if (refAli->mother()->alignableObjectId() == align::AlignableDet) _detDim = 2;
813  }
814  else _detDim = 0;
815 
816  _surWidth = refAli->surface().width();
817  _surLength = refAli->surface().length();
818  align::RotationType rt = refAli->globalRotation();
819  _surRot[0] = rt.xx(); _surRot[1] = rt.xy(); _surRot[2] = rt.xz();
820  _surRot[3] = rt.yx(); _surRot[4] = rt.yy(); _surRot[5] = rt.yz();
821  _surRot[6] = rt.zx(); _surRot[7] = rt.zy(); _surRot[8] = rt.zz();
822 
823  //Fill
824  _alignTree->Fill();
825 
826 }
TkRotation::xx
T xx() const
Definition: newTkRotation.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:180
PV3DBase::y
T y() const
Definition: PV3DBase.h:62
TkRotation::yx
T yx() const
Definition: newTkRotation.h:254
Alignable::globalRotation
const RotationType & globalRotation() const
Return the global orientation of the object.
Definition: Alignable.h:132
g
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g
Definition: Activities.doc:4
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:45
TkRotation::zx
T zx() const
Definition: newTkRotation.h:257
TkRotation::xy
T xy() const
Definition: newTkRotation.h:252
TkRotation::zz
T zz() const
Definition: newTkRotation.h:259
PV3DBase::z
T z() const
Definition: PV3DBase.h:63
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
TkRotation::zy
T zy() const
Definition: newTkRotation.h:258
align::toAngles
EulerAngles toAngles(const RotationType &)
Convert rotation matrix to angles about x-, y-, z-axes (frame rotation).
Definition: Utilities.cc:7
TkRotation::yy
T yy() const
Definition: newTkRotation.h:255
Alignable::surface
const AlignableSurface & surface() const
Return the Surface (global position and orientation) of the object.
Definition: Alignable.h:126
DetId
Definition: DetId.h:20
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)
Definition: TrackerGeometryCompare.cc:927
TkRotation::xz
T xz() const
Definition: newTkRotation.h:253
Alignable::globalPosition
const PositionType & globalPosition() const
Return the global position of the object.
Definition: Alignable.h:129
PV3DBase::x
T x() const
Definition: PV3DBase.h:61
Alignable::mother
Alignable * mother() const
Return pointer to container alignable (if any)
Definition: Alignable.h:85
TkRotation::yz
T yz() const
Definition: newTkRotation.h:256
Alignable::geomDetId
const DetId & geomDetId() const
Definition: Alignable.h:177
bool TrackerGeometryCompare::passIdCut ( uint32_t  id)
private

Definition at line 914 of file TrackerGeometryCompare.cc.

References _detIdFlagVector, and i.

Referenced by fillTree().

914  {
915 
916  bool pass = false;
917  int nEntries = _detIdFlagVector.size();
918 
919  for (int i = 0; i < nEntries; i++){
920  if (_detIdFlagVector[i] == id) pass = true;
921  }
922 
923  return pass;
924 
925 }
i
int i
Definition: DBlmapReader.cc:9
TrackerGeometryCompare::_detIdFlagVector
std::vector< uint32_t > _detIdFlagVector
Definition: TrackerGeometryCompare.h:119
void TrackerGeometryCompare::setCommonTrackerSystem ( )
private

Definition at line 650 of file TrackerGeometryCompare.cc.

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

Referenced by analyze().

650  {
651 
652  edm::LogInfo("TrackerGeometryCompare") << "Setting Common Tracker System....";
653 
654  AlignableObjectId dummy; // DM_534??
655  _commonTrackerLevel = dummy.nameToType(_setCommonTrackerSystem); // DM_534??
656 
657  diffCommonTrackerSystem(referenceTracker, currentTracker);
658 
659  align::EulerAngles dOmega(3); dOmega[0] = _TrackerCommonR.x() ; dOmega[1] = _TrackerCommonR.y(); dOmega[2] = _TrackerCommonR.z();
660  align::RotationType rot = align::toMatrix( dOmega );
661  align::GlobalVector theR = _TrackerCommonT;
662 
663  std::cout << "what we get from overlaying the pixels..." << theR << ", " << rot << std::endl;
664 
665  //transform to the Tracker System
666  align::PositionType trackerCM = currentTracker->globalPosition();
667  align::GlobalVector cmDiff( trackerCM.x()-_TrackerCommonCM.x(), trackerCM.y()-_TrackerCommonCM.y(), trackerCM.z()-_TrackerCommonCM.z() );
668 
669  std::cout << "Pixel CM: " << _TrackerCommonCM << ", tracker CM: " << trackerCM << std::endl;
670 
671  //adjust translational difference factoring in different rotational CM
672  //needed because rotateInGlobalFrame is about CM of alignable, not Tracker
673  align::GlobalVector::BasicVectorType lpvgf = cmDiff.basicVector();
674  align::GlobalVector moveV( rot.multiplyInverse(lpvgf) - lpvgf);
675  align::GlobalVector theRprime(theR + moveV);
676 
677  AlgebraicVector TrackerCommonTR(6);
678  TrackerCommonTR(1) = theRprime.x(); TrackerCommonTR(2) = theRprime.y(); TrackerCommonTR(3) = theRprime.z();
679  TrackerCommonTR(4) = _TrackerCommonR.x(); TrackerCommonTR(5) = _TrackerCommonR.y(); TrackerCommonTR(6) = _TrackerCommonR.z();
680 
681  std::cout << "and after the transformation: " << TrackerCommonTR << std::endl;
682 
683  align::moveAlignable(currentTracker, TrackerCommonTR );
684 
685 }
TrackerGeometryCompare::_TrackerCommonR
align::GlobalVector _TrackerCommonR
Definition: TrackerGeometryCompare.h:122
TrackerGeometryCompare::_TrackerCommonT
align::GlobalVector _TrackerCommonT
Definition: TrackerGeometryCompare.h:121
PV3DBase::y
T y() const
Definition: PV3DBase.h:62
TrackerGeometryCompare::diffCommonTrackerSystem
void diffCommonTrackerSystem(Alignable *refAli, Alignable *curAli)
Definition: TrackerGeometryCompare.cc:687
PV3DBase::z
T z() const
Definition: PV3DBase.h:63
AlignableObjectId
Allows conversion between type and name, and vice-versa.
Definition: AlignableObjectId.h:10
TrackerGeometryCompare::_commonTrackerLevel
align::StructureType _commonTrackerLevel
Definition: TrackerGeometryCompare.h:120
TrackerGeometryCompare::_TrackerCommonCM
align::PositionType _TrackerCommonCM
Definition: TrackerGeometryCompare.h:123
AlgebraicVector
CLHEP::HepVector AlgebraicVector
Definition: AlgebraicObjects.h:12
align::EulerAngles
AlgebraicVector EulerAngles
Definition: Definitions.h:36
TrackerGeometryCompare::currentTracker
AlignableTracker * currentTracker
Definition: TrackerGeometryCompare.h:99
AlignableObjectId::nameToType
align::StructureType nameToType(const std::string &name) const
Convert name to type.
Definition: AlignableObjectId.cc:90
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:40
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
Alignable::globalPosition
const PositionType & globalPosition() const
Return the global position of the object.
Definition: Alignable.h:129
TkRotation::multiplyInverse
Basic3DVector< T > multiplyInverse(const Basic3DVector< T > &v) const
Definition: newTkRotation.h:178
PV3DBase::x
T x() const
Definition: PV3DBase.h:61
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,
AlignmentErrors *  alignErrors 
)
private

Definition at line 828 of file TrackerGeometryCompare.cc.

References filterCSVwithJSON::copy, AlignableTracker::endcapGeomDets(), i, AlignableTracker::innerBarrelGeomDets(), j, gen::k, Alignments::m_align, AlignmentErrors::m_alignError, AlignableTracker::outerBarrelGeomDets(), AlignableTracker::pixelEndcapGeomDets(), AlignableTracker::pixelHalfBarrelGeomDets(), pos, SurveyDet::position(), makeMuonMisalignmentScenario::rot, SurveyDet::rotation(), python.multivaluedict::sort(), AlignableTracker::TIDGeomDets(), and create_public_pileup_plots::transform.

828  {
829 
830  //getting the right alignables for the alignment record
831  std::vector<Alignable*> detPB = ali->pixelHalfBarrelGeomDets();
832  std::vector<Alignable*> detPEC = ali->pixelEndcapGeomDets();
833  std::vector<Alignable*> detTIB = ali->innerBarrelGeomDets();
834  std::vector<Alignable*> detTID = ali->TIDGeomDets();
835  std::vector<Alignable*> detTOB = ali->outerBarrelGeomDets();
836  std::vector<Alignable*> detTEC = ali->endcapGeomDets();
837 
838  std::vector<Alignable*> allGeomDets;
839  std::copy(detPB.begin(), detPB.end(), std::back_inserter(allGeomDets));
840  std::copy(detPEC.begin(), detPEC.end(), std::back_inserter(allGeomDets));
841  std::copy(detTIB.begin(), detTIB.end(), std::back_inserter(allGeomDets));
842  std::copy(detTID.begin(), detTID.end(), std::back_inserter(allGeomDets));
843  std::copy(detTOB.begin(), detTOB.end(), std::back_inserter(allGeomDets));
844  std::copy(detTEC.begin(), detTEC.end(), std::back_inserter(allGeomDets));
845 
846  std::vector<Alignable*> rcdAlis;
847  for (std::vector<Alignable*>::iterator i = allGeomDets.begin(); i!= allGeomDets.end(); i++){
848  if ((*i)->components().size() == 1){
849  rcdAlis.push_back((*i));
850  }
851  else if ((*i)->components().size() > 1){
852  rcdAlis.push_back((*i));
853  std::vector<Alignable*> comp = (*i)->components();
854  for (std::vector<Alignable*>::iterator j = comp.begin(); j != comp.end(); j++){
855  rcdAlis.push_back((*j));
856  }
857  }
858  }
859 
860  //turning them into alignments
861  for(std::vector<Alignable*>::iterator k = rcdAlis.begin(); k != rcdAlis.end(); k++){
862 
863  const SurveyDet* surveyInfo = (*k)->survey();
864  align::PositionType pos(surveyInfo->position());
865  align::RotationType rot(surveyInfo->rotation());
866  CLHEP::Hep3Vector clhepVector(pos.x(),pos.y(),pos.z());
867  CLHEP::HepRotation clhepRotation( CLHEP::HepRep3x3(rot.xx(),rot.xy(),rot.xz(),rot.yx(),rot.yy(),rot.yz(),rot.zx(),rot.zy(),rot.zz()));
868  AlignTransform transform(clhepVector, clhepRotation, (*k)->id());
869  AlignTransformError transformError(CLHEP::HepSymMatrix(3,1), (*k)->id());
870  alignVals->m_align.push_back(transform);
871  alignErrors->m_alignError.push_back(transformError);
872  }
873 
874  //to get the right order
875  std::sort( alignVals->m_align.begin(), alignVals->m_align.end(), lessAlignmentDetId<AlignTransform>() );
876  std::sort( alignErrors->m_alignError.begin(), alignErrors->m_alignError.end(), lessAlignmentDetId<AlignTransformError>() );
877 
878 }
i
int i
Definition: DBlmapReader.cc:9
AlignableTracker::pixelHalfBarrelGeomDets
Alignables & pixelHalfBarrelGeomDets()
Return pixel barrel GeomDets.
Definition: AlignableTracker.h:52
AlignmentErrors::m_alignError
std::vector< AlignTransformError > m_alignError
Definition: AlignmentErrors.h:14
Alignments::m_align
std::vector< AlignTransform > m_align
Definition: Alignments.h:14
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:48
AlignableTracker::TIDGeomDets
Alignables & TIDGeomDets()
Return TID GeomDets.
Definition: AlignableTracker.h:56
j
int j
Definition: DBlmapReader.cc:9
AlignableTracker::endcapGeomDets
Alignables & endcapGeomDets()
Return endcap GeomDets.
Definition: AlignableTracker.h:54
AlignableTracker::pixelEndcapGeomDets
Alignables & pixelEndcapGeomDets()
Return pixel endcap GeomDets.
Definition: AlignableTracker.h:58
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:81
AlignableTracker::outerBarrelGeomDets
Alignables & outerBarrelGeomDets()
Return outer barrel GeomDets.
Definition: AlignableTracker.h:50
create_public_pileup_plots.transform
transform
Definition: create_public_pileup_plots.py:254

Member Data Documentation

TTree* TrackerGeometryCompare::_alignTree
private

Definition at line 128 of file TrackerGeometryCompare.h.

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

float TrackerGeometryCompare::_alphaVal
private

Definition at line 138 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_betaVal
private

Definition at line 138 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

align::StructureType TrackerGeometryCompare::_commonTrackerLevel
private

Definition at line 120 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

float TrackerGeometryCompare::_dalphaVal
private

Definition at line 140 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_daVal
private

Definition at line 142 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dbetaVal
private

Definition at line 140 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dbVal
private

Definition at line 142 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_detDim
private

Definition at line 137 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

bool TrackerGeometryCompare::_detIdFlag
private

Definition at line 113 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_detIdFlagFile
private

Definition at line 114 of file TrackerGeometryCompare.h.

Referenced by TrackerGeometryCompare().

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

Definition at line 119 of file TrackerGeometryCompare.h.

Referenced by passIdCut(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dgammaVal
private

Definition at line 140 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dgVal
private

Definition at line 142 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dphiVal
private

Definition at line 140 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_drVal
private

Definition at line 140 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_duVal
private

Definition at line 142 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dvVal
private

Definition at line 142 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dwVal
private

Definition at line 142 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dxVal
private

Definition at line 140 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dyVal
private

Definition at line 140 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_dzVal
private

Definition at line 140 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_etaVal
private

Definition at line 138 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_filename
private

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

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_id
private

\ Tree variables

Definition at line 137 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

uint32_t TrackerGeometryCompare::_identifiers[6]
private

Definition at line 144 of file TrackerGeometryCompare.h.

Referenced by fillIdentifiers(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_inputFilename1
private

Definition at line 106 of file TrackerGeometryCompare.h.

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

std::string TrackerGeometryCompare::_inputFilename2
private

Definition at line 107 of file TrackerGeometryCompare.h.

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

TFile* TrackerGeometryCompare::_inputRootFile1
private

Definition at line 129 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and createROOTGeometry().

TFile* TrackerGeometryCompare::_inputRootFile2
private

Definition at line 130 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree01
private

Definition at line 131 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree02
private

Definition at line 132 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree11
private

Definition at line 133 of file TrackerGeometryCompare.h.

Referenced by analyze(), and createROOTGeometry().

TTree* TrackerGeometryCompare::_inputTree12
private

Definition at line 134 of file TrackerGeometryCompare.h.

Referenced by analyze(), and createROOTGeometry().

std::string TrackerGeometryCompare::_inputTreenameAlign
private

Definition at line 108 of file TrackerGeometryCompare.h.

Referenced by createROOTGeometry(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_inputTreenameDeform
private

Definition at line 109 of file TrackerGeometryCompare.h.

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

int TrackerGeometryCompare::_level
private

Definition at line 137 of file TrackerGeometryCompare.h.

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

int TrackerGeometryCompare::_mid
private

Definition at line 137 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

int TrackerGeometryCompare::_mlevel
private

Definition at line 137 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_phiVal
private

Definition at line 138 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_rVal
private

Definition at line 138 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_setCommonTrackerSystem
private

Definition at line 112 of file TrackerGeometryCompare.h.

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

int TrackerGeometryCompare::_sublevel
private

Definition at line 137 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

double TrackerGeometryCompare::_surfDeform[13]
private

Definition at line 147 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_surLength
private

Definition at line 143 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

double TrackerGeometryCompare::_surRot[9]
private

Definition at line 145 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_surWidth
private

Definition at line 143 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

TFile* TrackerGeometryCompare::_theFile
private

Definition at line 127 of file TrackerGeometryCompare.h.

Referenced by endJob(), and TrackerGeometryCompare().

align::PositionType TrackerGeometryCompare::_TrackerCommonCM
private

Definition at line 123 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

align::GlobalVector TrackerGeometryCompare::_TrackerCommonR
private

Definition at line 122 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

align::GlobalVector TrackerGeometryCompare::_TrackerCommonT
private

Definition at line 121 of file TrackerGeometryCompare.h.

Referenced by diffCommonTrackerSystem(), and setCommonTrackerSystem().

int TrackerGeometryCompare::_type
private

Definition at line 146 of file TrackerGeometryCompare.h.

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

int TrackerGeometryCompare::_useDetId
private

Definition at line 137 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

std::string TrackerGeometryCompare::_weightBy
private

Definition at line 111 of file TrackerGeometryCompare.h.

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

bool TrackerGeometryCompare::_weightById
private

Definition at line 115 of file TrackerGeometryCompare.h.

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

std::string TrackerGeometryCompare::_weightByIdFile
private

Definition at line 116 of file TrackerGeometryCompare.h.

Referenced by TrackerGeometryCompare().

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

Definition at line 117 of file TrackerGeometryCompare.h.

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

bool TrackerGeometryCompare::_writeToDB
private

Definition at line 110 of file TrackerGeometryCompare.h.

Referenced by analyze(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_xVal
private

Definition at line 138 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_yVal
private

Definition at line 138 of file TrackerGeometryCompare.h.

Referenced by fillTree(), and TrackerGeometryCompare().

float TrackerGeometryCompare::_zVal
private

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

Referenced by analyze(), and beginJob().

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

Definition at line 157 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

int TrackerGeometryCompare::m_nBins
private

Definition at line 149 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

edm::ParameterSet TrackerGeometryCompare::m_params
private

Definition at line 73 of file TrackerGeometryCompare.h.

double TrackerGeometryCompare::m_rangeHigh
private

Definition at line 151 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

double TrackerGeometryCompare::m_rangeLow
private

Definition at line 150 of file TrackerGeometryCompare.h.

Referenced by compareSurfaceDeformations(), and TrackerGeometryCompare().

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

Definition at line 74 of file TrackerGeometryCompare.h.

Referenced by compareGeometries(), and TrackerGeometryCompare().

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

Definition at line 155 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.5