CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
MuonAlignmentInputXML.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: MuonAlignment
4 // Class : MuonAlignmentInputXML
5 //
6 // Implementation:
7 // <Notes on implementation>
8 //
9 // Original Author: Jim Pivarski
10 // Created: Mon Mar 10 16:37:40 CDT 2008
11 //$Id: MuonAlignmentInputXML.cc,v 1.16 2011/03/22 09:49:50 innocent Exp $
12 //
13 
14 // system include files
15 #include "FWCore/Framework/interface/ESHandle.h"
16 #include "Utilities/Xerces/interface/Xerces.h"
17 
18 // Xerces include files
19 #include "xercesc/parsers/XercesDOMParser.hpp"
20 #include "xercesc/dom/DOM.hpp"
21 #include "xercesc/sax/HandlerBase.hpp"
22 #include "xercesc/util/XMLString.hpp"
23 #include "xercesc/util/PlatformUtils.hpp"
24 #include "xercesc/util/XercesDefs.hpp"
25 XERCES_CPP_NAMESPACE_USE
26 
27 // user include files
28 #include "Alignment/MuonAlignment/interface/MuonAlignmentInputXML.h"
29 #include "Alignment/CommonAlignment/interface/StructureType.h"
30 #include "Alignment/CommonAlignment/interface/AlignableObjectId.h"
31 #include "DataFormats/MuonDetId/interface/CSCDetId.h"
32 #include "DataFormats/MuonDetId/interface/GEMDetId.h"
33 #include "DataFormats/MuonDetId/interface/DTLayerId.h"
34 #include "Alignment/CommonAlignment/interface/SurveyDet.h"
35 #include "DataFormats/GeometryCommonDetAlgo/interface/AlignmentPositionError.h"
36 #include "Geometry/Records/interface/MuonGeometryRecord.h"
37 
38 //
39 // constants, enums and typedefs
40 //
41 
42 //
43 // static data member definitions
44 //
45 
46 //
47 // constructors and destructor
48 //
49 MuonAlignmentInputXML::MuonAlignmentInputXML(const std::string &fileName,
50  const DTGeometry *dtGeometry,
51  const CSCGeometry *cscGeometry,
52  const GEMGeometry *gemGeometry,
53  const DTGeometry *dtGeometryIdeal,
54  const CSCGeometry *cscGeometryIdeal,
55  const GEMGeometry *gemGeometryIdeal)
56  : m_fileName(fileName),
57  dtGeometry_(dtGeometry),
58  cscGeometry_(cscGeometry),
59  gemGeometry_(gemGeometry),
60  dtGeometryIdeal_(dtGeometryIdeal),
61  cscGeometryIdeal_(cscGeometryIdeal),
62  gemGeometryIdeal_(gemGeometryIdeal) {
63  cms::concurrency::xercesInitialize();
64  str_operation = XMLString::transcode("operation");
65  str_collection = XMLString::transcode("collection");
66  str_name = XMLString::transcode("name");
67  str_DTBarrel = XMLString::transcode("DTBarrel");
68  str_DTWheel = XMLString::transcode("DTWheel");
69  str_DTStation = XMLString::transcode("DTStation");
70  str_DTChamber = XMLString::transcode("DTChamber");
71  str_DTSuperLayer = XMLString::transcode("DTSuperLayer");
72  str_DTLayer = XMLString::transcode("DTLayer");
73  str_CSCEndcap = XMLString::transcode("CSCEndcap");
74  str_CSCStation = XMLString::transcode("CSCStation");
75  str_CSCRing = XMLString::transcode("CSCRing");
76  str_CSCChamber = XMLString::transcode("CSCChamber");
77  str_CSCLayer = XMLString::transcode("CSCLayer");
78  str_GEMEndcap = XMLString::transcode("GEMEndcap");
79  str_GEMStation = XMLString::transcode("GEMStation");
80  str_GEMRing = XMLString::transcode("GEMRing");
81  str_GEMSuperChamber = XMLString::transcode("GEMSuperChamber");
82  str_GEMChamber = XMLString::transcode("GEMChamber");
83  str_GEMEtaPartition = XMLString::transcode("GEMEtaPartition");
84  str_setposition = XMLString::transcode("setposition");
85  str_setape = XMLString::transcode("setape");
86  str_setsurveyerr = XMLString::transcode("setsurveyerr");
87  str_moveglobal = XMLString::transcode("moveglobal");
88  str_movelocal = XMLString::transcode("movelocal");
89  str_rotatelocal = XMLString::transcode("rotatelocal");
90  str_rotatebeamline = XMLString::transcode("rotatebeamline");
91  str_rotateglobalaxis = XMLString::transcode("rotateglobalaxis");
92  str_relativeto = XMLString::transcode("relativeto");
93  str_rawId = XMLString::transcode("rawId");
94  str_wheel = XMLString::transcode("wheel");
95  str_station = XMLString::transcode("station");
96  str_sector = XMLString::transcode("sector");
97  str_superlayer = XMLString::transcode("superlayer");
98  str_layer = XMLString::transcode("layer");
99  str_endcap = XMLString::transcode("endcap");
100  str_ring = XMLString::transcode("ring");
101  str_chamber = XMLString::transcode("chamber");
102  str_superChamber = XMLString::transcode("SuperChamber");
103  str_etaPartition = XMLString::transcode("etaPartition");
104  str_axisx = XMLString::transcode("axisx");
105  str_axisy = XMLString::transcode("axisy");
106  str_axisz = XMLString::transcode("axisz");
107  str_angle = XMLString::transcode("angle");
108  str_x = XMLString::transcode("x");
109  str_y = XMLString::transcode("y");
110  str_z = XMLString::transcode("z");
111  str_phix = XMLString::transcode("phix");
112  str_phiy = XMLString::transcode("phiy");
113  str_phiz = XMLString::transcode("phiz");
114  str_alpha = XMLString::transcode("alpha");
115  str_beta = XMLString::transcode("beta");
116  str_gamma = XMLString::transcode("gamma");
117  str_rphi = XMLString::transcode("rphi");
118  str_phi = XMLString::transcode("phi");
119  str_xx = XMLString::transcode("xx");
120  str_xy = XMLString::transcode("xy");
121  str_xz = XMLString::transcode("xz");
122  str_xa = XMLString::transcode("xa");
123  str_xb = XMLString::transcode("xb");
124  str_xc = XMLString::transcode("xc");
125  str_yy = XMLString::transcode("yy");
126  str_yz = XMLString::transcode("yz");
127  str_ya = XMLString::transcode("ya");
128  str_yb = XMLString::transcode("yb");
129  str_yc = XMLString::transcode("yc");
130  str_zz = XMLString::transcode("zz");
131  str_za = XMLString::transcode("za");
132  str_zb = XMLString::transcode("zb");
133  str_zc = XMLString::transcode("zc");
134  str_aa = XMLString::transcode("aa");
135  str_ab = XMLString::transcode("ab");
136  str_ac = XMLString::transcode("ac");
137  str_bb = XMLString::transcode("bb");
138  str_bc = XMLString::transcode("bc");
139  str_cc = XMLString::transcode("cc");
140  str_none = XMLString::transcode("none");
141  str_ideal = XMLString::transcode("ideal");
142  str_container = XMLString::transcode("container");
143 }
144 
145 // MuonAlignmentInputXML::MuonAlignmentInputXML(const MuonAlignmentInputXML& rhs)
146 // {
147 // // do actual copying here;
148 // }
149 
150 MuonAlignmentInputXML::~MuonAlignmentInputXML() {
151  XMLString::release(&str_operation);
152  XMLString::release(&str_collection);
153  XMLString::release(&str_name);
154  XMLString::release(&str_DTBarrel);
155  XMLString::release(&str_DTWheel);
156  XMLString::release(&str_DTStation);
157  XMLString::release(&str_DTChamber);
158  XMLString::release(&str_DTSuperLayer);
159  XMLString::release(&str_DTLayer);
160  XMLString::release(&str_CSCEndcap);
161  XMLString::release(&str_CSCStation);
162  XMLString::release(&str_CSCRing);
163  XMLString::release(&str_CSCChamber);
164  XMLString::release(&str_CSCLayer);
165  XMLString::release(&str_GEMEndcap);
166  XMLString::release(&str_GEMStation);
167  XMLString::release(&str_GEMRing);
168  XMLString::release(&str_GEMSuperChamber);
169  XMLString::release(&str_GEMChamber);
170  XMLString::release(&str_GEMEtaPartition);
171  XMLString::release(&str_setposition);
172  XMLString::release(&str_setape);
173  XMLString::release(&str_setsurveyerr);
174  XMLString::release(&str_moveglobal);
175  XMLString::release(&str_movelocal);
176  XMLString::release(&str_rotatelocal);
177  XMLString::release(&str_rotatebeamline);
178  XMLString::release(&str_rotateglobalaxis);
179  XMLString::release(&str_relativeto);
180  XMLString::release(&str_rawId);
181  XMLString::release(&str_wheel);
182  XMLString::release(&str_station);
183  XMLString::release(&str_sector);
184  XMLString::release(&str_superlayer);
185  XMLString::release(&str_layer);
186  XMLString::release(&str_endcap);
187  XMLString::release(&str_ring);
188  XMLString::release(&str_chamber);
189  XMLString::release(&str_superChamber);
190  XMLString::release(&str_etaPartition);
191  XMLString::release(&str_axisx);
192  XMLString::release(&str_axisy);
193  XMLString::release(&str_axisz);
194  XMLString::release(&str_angle);
195  XMLString::release(&str_x);
196  XMLString::release(&str_y);
197  XMLString::release(&str_z);
198  XMLString::release(&str_phix);
199  XMLString::release(&str_phiy);
200  XMLString::release(&str_phiz);
201  XMLString::release(&str_alpha);
202  XMLString::release(&str_beta);
203  XMLString::release(&str_gamma);
204  XMLString::release(&str_rphi);
205  XMLString::release(&str_phi);
206  XMLString::release(&str_xx);
207  XMLString::release(&str_xy);
208  XMLString::release(&str_xz);
209  XMLString::release(&str_xa);
210  XMLString::release(&str_xb);
211  XMLString::release(&str_xc);
212  XMLString::release(&str_yy);
213  XMLString::release(&str_yz);
214  XMLString::release(&str_ya);
215  XMLString::release(&str_yb);
216  XMLString::release(&str_yc);
217  XMLString::release(&str_zz);
218  XMLString::release(&str_za);
219  XMLString::release(&str_zb);
220  XMLString::release(&str_zc);
221  XMLString::release(&str_aa);
222  XMLString::release(&str_ab);
223  XMLString::release(&str_ac);
224  XMLString::release(&str_bb);
225  XMLString::release(&str_bc);
226  XMLString::release(&str_cc);
227  XMLString::release(&str_none);
228  XMLString::release(&str_ideal);
229  XMLString::release(&str_container);
230  cms::concurrency::xercesTerminate();
231 }
232 
233 //
234 // assignment operators
235 //
236 // const MuonAlignmentInputXML& MuonAlignmentInputXML::operator=(const MuonAlignmentInputXML& rhs)
237 // {
238 // //An exception safe implementation is
239 // MuonAlignmentInputXML temp(rhs);
240 // swap(rhs);
241 //
242 // return *this;
243 // }
244 
245 //
246 // member functions
247 //
248 
249 void MuonAlignmentInputXML::recursiveGetId(std::map<unsigned int, Alignable *> &alignableNavigator,
250  const align::Alignables &alignables) const {
251  for (align::Alignables::const_iterator ali = alignables.begin(); ali != alignables.end(); ++ali) {
252  if ((*ali)->alignableObjectId() == align::AlignableDetUnit || (*ali)->alignableObjectId() == align::AlignableDet ||
253  (*ali)->alignableObjectId() == align::AlignableDTChamber ||
254  (*ali)->alignableObjectId() == align::AlignableDTSuperLayer ||
255  (*ali)->alignableObjectId() == align::AlignableDTLayer ||
256  (*ali)->alignableObjectId() == align::AlignableCSCChamber ||
257  (*ali)->alignableObjectId() == align::AlignableCSCLayer ||
258  (*ali)->alignableObjectId() == align::AlignableGEMSuperChamber ||
259  (*ali)->alignableObjectId() == align::AlignableGEMChamber ||
260  (*ali)->alignableObjectId() == align::AlignableGEMEtaPartition) {
261  alignableNavigator[(*ali)->geomDetId().rawId()] = *ali;
262  }
263  recursiveGetId(alignableNavigator, (*ali)->components());
264  }
265 }
266 
267 void MuonAlignmentInputXML::fillAliToIdeal(std::map<Alignable *, Alignable *> &alitoideal,
268  const align::Alignables &alignables,
269  const align::Alignables &ideals) const {
270  align::Alignables::const_iterator alignable = alignables.begin();
271  align::Alignables::const_iterator ideal = ideals.begin();
272 
273  while (alignable != alignables.end() && ideal != ideals.end()) {
274  alitoideal[*alignable] = *ideal;
275 
276  fillAliToIdeal(alitoideal, (*alignable)->components(), (*ideal)->components());
277 
278  ++alignable;
279  ++ideal;
280  }
281 
282  if (alignable != alignables.end() || ideal != ideals.end()) {
283  throw cms::Exception("Alignment")
284  << "alignable and ideal-alignable trees are out of sync (this should never happen)";
285  }
286 }
287 
288 AlignableMuon *MuonAlignmentInputXML::newAlignableMuon() const {
289  AlignableMuon *alignableMuon = new AlignableMuon(dtGeometry_, cscGeometry_, gemGeometry_);
290  std::map<unsigned int, Alignable *> alignableNavigator; // real AlignableNavigators don't have const methods
291  recursiveGetId(alignableNavigator, alignableMuon->DTBarrel());
292  recursiveGetId(alignableNavigator, alignableMuon->CSCEndcaps());
293  recursiveGetId(alignableNavigator, alignableMuon->GEMEndcaps());
294 
295  AlignableMuon *ideal_alignableMuon = new AlignableMuon(dtGeometryIdeal_, cscGeometryIdeal_, gemGeometryIdeal_);
296  std::map<unsigned int, Alignable *> ideal_alignableNavigator; // real AlignableNavigators don't have const methods
297  recursiveGetId(ideal_alignableNavigator, ideal_alignableMuon->DTBarrel());
298  recursiveGetId(ideal_alignableNavigator, ideal_alignableMuon->CSCEndcaps());
299  recursiveGetId(ideal_alignableNavigator, ideal_alignableMuon->GEMEndcaps());
300 
301  try {
302  cms::concurrency::xercesInitialize();
303  } catch (const XMLException &toCatch) {
304  throw cms::Exception("XMLException") << "Xerces XML parser threw an exception on initialization." << std::endl;
305  }
306 
307  XercesDOMParser *parser = new XercesDOMParser();
308  parser->setValidationScheme(XercesDOMParser::Val_Always);
309 
310  XERCES_CPP_NAMESPACE::ErrorHandler *errHandler = (XERCES_CPP_NAMESPACE::ErrorHandler *)(new HandlerBase());
311  parser->setErrorHandler(errHandler);
312 
313  try {
314  parser->parse(m_fileName.c_str());
315  } catch (const XMLException &toCatch) {
316  char *message = XMLString::transcode(toCatch.getMessage());
317  throw cms::Exception("XMLException") << "Xerces XML parser threw this exception: " << message << std::endl;
318  } catch (const DOMException &toCatch) {
319  char *message = XMLString::transcode(toCatch.msg);
320  throw cms::Exception("XMLException") << "Xerces XML parser threw this exception: " << message << std::endl;
321  } catch (const SAXException &toCatch) {
322  char *message = XMLString::transcode(toCatch.getMessage());
323  throw cms::Exception("XMLException") << "Xerces XML parser threw this exception: " << message << std::endl;
324  }
325 
326  DOMDocument *doc = parser->getDocument();
327  DOMElement *node_MuonAlignment = doc->getDocumentElement();
328  DOMNodeList *collections = doc->getElementsByTagName(str_collection);
329  DOMNodeList *operations = doc->getElementsByTagName(str_operation);
330 
331  std::map<Alignable *, Alignable *> alitoideal;
332  fillAliToIdeal(alitoideal, alignableMuon->DTBarrel(), ideal_alignableMuon->DTBarrel());
333  fillAliToIdeal(alitoideal, alignableMuon->CSCEndcaps(), ideal_alignableMuon->CSCEndcaps());
334  fillAliToIdeal(alitoideal, alignableMuon->GEMEndcaps(), ideal_alignableMuon->GEMEndcaps());
335 
336  const auto &alignableObjectId = alignableMuon->objectIdProvider();
337  std::map<std::string, std::map<Alignable *, bool> > alicollections;
338  for (unsigned int i = 0; i < collections->getLength(); i++) {
339  DOMElement *collection = (DOMElement *)(collections->item(i));
340  if (collection->getParentNode() == node_MuonAlignment) {
341  DOMNodeList *children = collection->getChildNodes();
342 
343  DOMAttr *node_name = collection->getAttributeNode(str_name);
344  if (node_name == nullptr) {
345  throw cms::Exception("XMLException") << "<collection> requires a name attribute" << std::endl;
346  }
347  char *ascii_name = XMLString::transcode(node_name->getValue());
348  std::string name(ascii_name);
349  XMLString::release(&ascii_name);
350 
351  std::map<Alignable *, bool> aliset;
352  for (unsigned int j = 0; j < children->getLength(); j++) {
353  DOMNode *node = children->item(j);
354 
355  if (node->getNodeType() == DOMNode::ELEMENT_NODE) {
356  Alignable *ali = getNode(alignableNavigator, (DOMElement *)(node), alignableObjectId);
357  if (ali == nullptr) {
358  throw cms::Exception("XMLException") << "<collection> must contain only alignables" << std::endl;
359  }
360 
361  aliset[ali] = true;
362  } // end if this node is an element
363  } // end loop over collection's children
364 
365  alicollections[name] = aliset;
366  } // end if this is a top-level collection
367  } // end loop over collections
368 
369  for (unsigned int i = 0; i < operations->getLength(); i++) {
370  DOMElement *operation = (DOMElement *)(operations->item(i));
371  if (operation->getParentNode() != node_MuonAlignment) {
372  throw cms::Exception("XMLException") << "All operations must be top-level elements" << std::endl;
373  }
374 
375  DOMNodeList *children = operation->getChildNodes();
376 
377  std::map<Alignable *, bool> aliset;
378  std::vector<DOMNode *> nodesToRemove;
379  for (unsigned int j = 0; j < children->getLength(); j++) {
380  DOMNode *node = children->item(j);
381 
382  if (node->getNodeType() == DOMNode::ELEMENT_NODE) {
383  Alignable *ali = getNode(alignableNavigator, (DOMElement *)(node), alignableObjectId);
384  if (ali != nullptr) {
385  aliset[ali] = true;
386  nodesToRemove.push_back(node);
387  } // end if this node is an alignable
388 
389  else if (XMLString::equals(node->getNodeName(), str_collection)) {
390  DOMAttr *node_name = ((DOMElement *)(node))->getAttributeNode(str_name);
391  if (node_name == nullptr) {
392  throw cms::Exception("XMLException") << "<collection> requires a name attribute" << std::endl;
393  }
394  char *ascii_name = XMLString::transcode(node_name->getValue());
395  std::string name(ascii_name);
396  XMLString::release(&ascii_name);
397 
398  std::map<std::string, std::map<Alignable *, bool> >::const_iterator alicollections_iter =
399  alicollections.find(name);
400  if (alicollections_iter == alicollections.end()) {
401  throw cms::Exception("XMLException")
402  << "<collection name=\"" << name << "\"> hasn't been defined" << std::endl;
403  }
404 
405  for (std::map<Alignable *, bool>::const_iterator aliiter = alicollections_iter->second.begin();
406  aliiter != alicollections_iter->second.end();
407  ++aliiter) {
408  aliset[aliiter->first] = true;
409  } // end loop over alignables in this collection
410 
411  nodesToRemove.push_back(node);
412  } // end if this node is a collection
413 
414  else {
415  } // anything else? assume it's a position/rotation directive
416 
417  } // end if node is node is an element
418  } // end first loop over operation's children
419 
420  // from now on, we only want to see position/rotation directives
421  for (std::vector<DOMNode *>::const_iterator node = nodesToRemove.begin(); node != nodesToRemove.end(); ++node) {
422  operation->removeChild(*node);
423  }
424  children = operation->getChildNodes();
425 
426  for (unsigned int j = 0; j < children->getLength(); j++) {
427  DOMNode *node = children->item(j);
428  if (node->getNodeType() == DOMNode::ELEMENT_NODE) {
429  if (XMLString::equals(node->getNodeName(), str_setposition)) {
430  do_setposition((DOMElement *)(node), aliset, alitoideal);
431  }
432 
433  else if (XMLString::equals(node->getNodeName(), str_setape)) {
434  do_setape((DOMElement *)(node), aliset, alitoideal);
435  }
436 
437  else if (XMLString::equals(node->getNodeName(), str_setsurveyerr)) {
438  do_setsurveyerr((DOMElement *)(node), aliset, alitoideal);
439  }
440 
441  else if (XMLString::equals(node->getNodeName(), str_moveglobal)) {
442  do_moveglobal((DOMElement *)(node), aliset, alitoideal);
443  }
444 
445  else if (XMLString::equals(node->getNodeName(), str_movelocal)) {
446  do_movelocal((DOMElement *)(node), aliset, alitoideal);
447  }
448 
449  else if (XMLString::equals(node->getNodeName(), str_rotatelocal)) {
450  do_rotatelocal((DOMElement *)(node), aliset, alitoideal);
451  }
452 
453  else if (XMLString::equals(node->getNodeName(), str_rotatebeamline)) {
454  do_rotatebeamline((DOMElement *)(node), aliset, alitoideal);
455  }
456 
457  else if (XMLString::equals(node->getNodeName(), str_rotateglobalaxis)) {
458  do_rotateglobalaxis((DOMElement *)(node), aliset, alitoideal);
459  }
460 
461  else {
462  char *message = XMLString::transcode(node->getNodeName());
463  throw cms::Exception("XMLException") << "Unrecognized operation: \"" << message << "\"" << std::endl;
464  }
465 
466  } // end if node is an element
467  } // end second loop over operation's children
468  } // end loop over operations
469 
470  delete parser;
471  delete errHandler;
472 
473  cms::concurrency::xercesTerminate();
474 
475  delete ideal_alignableMuon;
476  return alignableMuon;
477 }
478 
479 Alignable *MuonAlignmentInputXML::getNode(std::map<unsigned int, Alignable *> &alignableNavigator,
480  const XERCES_CPP_NAMESPACE::DOMElement *node,
481  const AlignableObjectId &alignableObjectId) const {
482  if (XMLString::equals(node->getNodeName(), str_DTBarrel))
483  return getDTnode(align::AlignableDTBarrel, alignableNavigator, node, alignableObjectId);
484  else if (XMLString::equals(node->getNodeName(), str_DTWheel))
485  return getDTnode(align::AlignableDTWheel, alignableNavigator, node, alignableObjectId);
486  else if (XMLString::equals(node->getNodeName(), str_DTStation))
487  return getDTnode(align::AlignableDTStation, alignableNavigator, node, alignableObjectId);
488  else if (XMLString::equals(node->getNodeName(), str_DTChamber))
489  return getDTnode(align::AlignableDTChamber, alignableNavigator, node, alignableObjectId);
490  else if (XMLString::equals(node->getNodeName(), str_DTSuperLayer))
491  return getDTnode(align::AlignableDTSuperLayer, alignableNavigator, node, alignableObjectId);
492  else if (XMLString::equals(node->getNodeName(), str_DTLayer))
493  return getDTnode(align::AlignableDetUnit, alignableNavigator, node, alignableObjectId);
494  else if (XMLString::equals(node->getNodeName(), str_CSCEndcap))
495  return getCSCnode(align::AlignableCSCEndcap, alignableNavigator, node, alignableObjectId);
496  else if (XMLString::equals(node->getNodeName(), str_CSCStation))
497  return getCSCnode(align::AlignableCSCStation, alignableNavigator, node, alignableObjectId);
498  else if (XMLString::equals(node->getNodeName(), str_CSCRing))
499  return getCSCnode(align::AlignableCSCRing, alignableNavigator, node, alignableObjectId);
500  else if (XMLString::equals(node->getNodeName(), str_CSCChamber))
501  return getCSCnode(align::AlignableCSCChamber, alignableNavigator, node, alignableObjectId);
502  else if (XMLString::equals(node->getNodeName(), str_CSCLayer))
503  return getCSCnode(align::AlignableDetUnit, alignableNavigator, node, alignableObjectId);
504  else if (XMLString::equals(node->getNodeName(), str_GEMEndcap))
505  return getGEMnode(align::AlignableGEMEndcap, alignableNavigator, node, alignableObjectId);
506  else if (XMLString::equals(node->getNodeName(), str_GEMStation))
507  return getGEMnode(align::AlignableGEMStation, alignableNavigator, node, alignableObjectId);
508  else if (XMLString::equals(node->getNodeName(), str_GEMRing))
509  return getGEMnode(align::AlignableGEMRing, alignableNavigator, node, alignableObjectId);
510  else if (XMLString::equals(node->getNodeName(), str_GEMSuperChamber))
511  return getGEMnode(align::AlignableGEMSuperChamber, alignableNavigator, node, alignableObjectId);
512  else if (XMLString::equals(node->getNodeName(), str_GEMChamber))
513  return getGEMnode(align::AlignableGEMChamber, alignableNavigator, node, alignableObjectId);
514  else if (XMLString::equals(node->getNodeName(), str_GEMEtaPartition))
515  return getGEMnode(align::AlignableDetUnit, alignableNavigator, node, alignableObjectId);
516  else
517  return nullptr;
518 }
519 
520 Alignable *MuonAlignmentInputXML::getDTnode(align::StructureType structureType,
521  std::map<unsigned int, Alignable *> &alignableNavigator,
522  const XERCES_CPP_NAMESPACE::DOMElement *node,
523  const AlignableObjectId &alignableObjectId) const {
524  unsigned int rawId = 0;
525 
526  DOMAttr *node_rawId = node->getAttributeNode(str_rawId);
527  if (node_rawId != nullptr) {
528  try {
529  rawId = XMLString::parseInt(node_rawId->getValue());
530  } catch (const XMLException &toCatch) {
531  throw cms::Exception("XMLException") << "Value of \"rawId\" must be an integer" << std::endl;
532  }
533  } else {
534  int wheel, station, sector, superlayer, layer;
535  wheel = station = sector = superlayer = layer = 1;
536 
537  if (structureType != align::AlignableDTBarrel) {
538  DOMAttr *node_wheel = node->getAttributeNode(str_wheel);
539  if (node_wheel == nullptr)
540  throw cms::Exception("XMLException") << "DT node is missing required \"wheel\" attribute" << std::endl;
541  try {
542  wheel = XMLString::parseInt(node_wheel->getValue());
543  } catch (const XMLException &toCatch) {
544  throw cms::Exception("XMLException") << "Value of \"wheel\" must be an integer" << std::endl;
545  }
546 
547  if (structureType != align::AlignableDTWheel) {
548  DOMAttr *node_station = node->getAttributeNode(str_station);
549  if (node_station == nullptr)
550  throw cms::Exception("XMLException") << "DT node is missing required \"station\" attribute" << std::endl;
551  try {
552  station = XMLString::parseInt(node_station->getValue());
553  } catch (const XMLException &toCatch) {
554  throw cms::Exception("XMLException") << "Value of \"station\" must be an integer" << std::endl;
555  }
556 
557  if (structureType != align::AlignableDTStation) {
558  DOMAttr *node_sector = node->getAttributeNode(str_sector);
559  if (node_sector == nullptr)
560  throw cms::Exception("XMLException") << "DT node is missing required \"sector\" attribute" << std::endl;
561  try {
562  sector = XMLString::parseInt(node_sector->getValue());
563  } catch (const XMLException &toCatch) {
564  throw cms::Exception("XMLException") << "Value of \"sector\" must be an integer" << std::endl;
565  }
566 
567  if (structureType != align::AlignableDTChamber) {
568  DOMAttr *node_superlayer = node->getAttributeNode(str_superlayer);
569  if (node_superlayer == nullptr)
570  throw cms::Exception("XMLException")
571  << "DT node is missing required \"superlayer\" attribute" << std::endl;
572  try {
573  superlayer = XMLString::parseInt(node_superlayer->getValue());
574  } catch (const XMLException &toCatch) {
575  throw cms::Exception("XMLException") << "Value of \"superlayer\" must be an integer" << std::endl;
576  }
577 
578  if (structureType != align::AlignableDTSuperLayer) {
579  DOMAttr *node_layer = node->getAttributeNode(str_layer);
580  if (node_layer == nullptr)
581  throw cms::Exception("XMLException") << "DT node is missing required \"layer\" attribute" << std::endl;
582  try {
583  layer = XMLString::parseInt(node_layer->getValue());
584  } catch (const XMLException &toCatch) {
585  throw cms::Exception("XMLException") << "Value of \"layer\" must be an integer" << std::endl;
586  }
587 
588  } // end if we need a layer number
589  } // end if we need a superlayer number
590  } // end if we need a sector number
591  } // end if we need a station number
592  } // end if we need a wheel number
593 
594  DTLayerId layerId(wheel, station, sector, superlayer, layer);
595  rawId = layerId.rawId();
596  } // end if it's specified by wheel, station, sector, superlayer, layer
597 
598  Alignable *ali = alignableNavigator[rawId];
599  if (ali == nullptr)
600  throw cms::Exception("XMLException") << "rawId \"" << rawId << "\" is not recognized" << std::endl;
601 
602  while (ali->alignableObjectId() != structureType) {
603  ali = ali->mother();
604 
605  if (ali == nullptr) {
606  throw cms::Exception("XMLException")
607  << "rawId \"" << rawId << "\" is not a " << alignableObjectId.idToString(structureType) << std::endl;
608  }
609  }
610  return ali;
611 }
612 
613 Alignable *MuonAlignmentInputXML::getCSCnode(align::StructureType structureType,
614  std::map<unsigned int, Alignable *> &alignableNavigator,
615  const XERCES_CPP_NAMESPACE::DOMElement *node,
616  const AlignableObjectId &alignableObjectId) const {
617  unsigned int rawId;
618 
619  DOMAttr *node_rawId = node->getAttributeNode(str_rawId);
620  if (node_rawId != nullptr) {
621  try {
622  rawId = XMLString::parseInt(node_rawId->getValue());
623  } catch (const XMLException &toCatch) {
624  throw cms::Exception("XMLException") << "Value of \"rawId\" must be an integer" << std::endl;
625  }
626  } else {
627  int endcap, station, ring, chamber, layer;
628  endcap = station = ring = chamber = layer = 1;
629 
630  DOMAttr *node_endcap = node->getAttributeNode(str_endcap);
631  if (node_endcap == nullptr)
632  throw cms::Exception("XMLException") << "CSC node is missing required \"endcap\" attribute" << std::endl;
633  try {
634  endcap = XMLString::parseInt(node_endcap->getValue());
635  } catch (const XMLException &toCatch) {
636  throw cms::Exception("XMLException") << "Value of \"endcap\" must be an integer" << std::endl;
637  }
638  if (endcap == -1)
639  endcap = 2;
640 
641  if (structureType != align::AlignableCSCEndcap) {
642  DOMAttr *node_station = node->getAttributeNode(str_station);
643  if (node_station == nullptr)
644  throw cms::Exception("XMLException") << "CSC node is missing required \"station\" attribute" << std::endl;
645  try {
646  station = XMLString::parseInt(node_station->getValue());
647  } catch (const XMLException &toCatch) {
648  throw cms::Exception("XMLException") << "Value of \"station\" must be an integer" << std::endl;
649  }
650 
651  if (structureType != align::AlignableCSCStation) {
652  DOMAttr *node_ring = node->getAttributeNode(str_ring);
653  if (node_ring == nullptr)
654  throw cms::Exception("XMLException") << "CSC node is missing required \"ring\" attribute" << std::endl;
655  try {
656  ring = XMLString::parseInt(node_ring->getValue());
657  } catch (const XMLException &toCatch) {
658  throw cms::Exception("XMLException") << "Value of \"ring\" must be an integer" << std::endl;
659  }
660 
661  if (structureType != align::AlignableCSCRing) {
662  DOMAttr *node_chamber = node->getAttributeNode(str_chamber);
663  if (node_chamber == nullptr)
664  throw cms::Exception("XMLException") << "CSC node is missing required \"chamber\" attribute" << std::endl;
665  try {
666  chamber = XMLString::parseInt(node_chamber->getValue());
667  } catch (const XMLException &toCatch) {
668  throw cms::Exception("XMLException") << "Value of \"chamber\" must be an integer" << std::endl;
669  }
670 
671  if (structureType != align::AlignableCSCChamber) {
672  DOMAttr *node_layer = node->getAttributeNode(str_layer);
673  if (node_layer == nullptr)
674  throw cms::Exception("XMLException") << "CSC node is missing required \"layer\" attribute" << std::endl;
675  try {
676  layer = XMLString::parseInt(node_layer->getValue());
677  } catch (const XMLException &toCatch) {
678  throw cms::Exception("XMLException") << "Value of \"layer\" must be an integer" << std::endl;
679  }
680 
681  } // end if we need a layer number
682  } // end if we need a chamber number
683  } // end if we need a ring number
684  } // end if we need a station number
685 
686  CSCDetId layerId(endcap, station, ring, chamber, layer);
687  rawId = layerId.rawId();
688  } // end if it's specified by endcap, station, ring, chamber, layer
689 
690  Alignable *ali = alignableNavigator[rawId];
691  if (ali == nullptr)
692  throw cms::Exception("XMLException") << "rawId \"" << rawId << "\" is not recognized" << std::endl;
693 
694  while (ali->alignableObjectId() != structureType) {
695  ali = ali->mother();
696 
697  if (ali == nullptr) {
698  throw cms::Exception("XMLException")
699  << "rawId \"" << rawId << "\" is not a " << alignableObjectId.idToString(structureType) << std::endl;
700  }
701  }
702  return ali;
703 }
704 
705 Alignable *MuonAlignmentInputXML::getGEMnode(align::StructureType structureType,
706  std::map<unsigned int, Alignable *> &alignableNavigator,
707  const XERCES_CPP_NAMESPACE::DOMElement *node,
708  const AlignableObjectId &alignableObjectId) const {
709  unsigned int rawId;
710 
711  DOMAttr *node_rawId = node->getAttributeNode(str_rawId);
712  if (node_rawId != nullptr) {
713  try {
714  rawId = XMLString::parseInt(node_rawId->getValue());
715  } catch (const XMLException &toCatch) {
716  throw cms::Exception("XMLException") << "Value of \"rawId\" must be an integer" << std::endl;
717  }
718  } else {
719  int endcap, station, ring, superChamber, chamber;
720  endcap = station = ring = superChamber = chamber = 1;
721 
722  DOMAttr *node_endcap = node->getAttributeNode(str_endcap);
723  if (node_endcap == nullptr)
724  throw cms::Exception("XMLException") << "GEM node is missing required \"endcap\" attribute" << std::endl;
725  try {
726  endcap = XMLString::parseInt(node_endcap->getValue());
727  } catch (const XMLException &toCatch) {
728  throw cms::Exception("XMLException") << "Value of \"endcap\" must be an integer" << std::endl;
729  }
730 
731  if (structureType != align::AlignableGEMEndcap) {
732  DOMAttr *node_station = node->getAttributeNode(str_station);
733  if (node_station == nullptr)
734  throw cms::Exception("XMLException") << "GEM node is missing required \"station\" attribute" << std::endl;
735  try {
736  station = XMLString::parseInt(node_station->getValue());
737  } catch (const XMLException &toCatch) {
738  throw cms::Exception("XMLException") << "Value of \"station\" must be an integer" << std::endl;
739  }
740 
741  if (structureType != align::AlignableGEMStation) {
742  DOMAttr *node_ring = node->getAttributeNode(str_ring);
743  if (node_ring == nullptr)
744  throw cms::Exception("XMLException") << "GEM node is missing required \"ring\" attribute" << std::endl;
745  try {
746  ring = XMLString::parseInt(node_ring->getValue());
747  } catch (const XMLException &toCatch) {
748  throw cms::Exception("XMLException") << "Value of \"ring\" must be an integer" << std::endl;
749  }
750 
751  if (structureType != align::AlignableGEMRing) {
752  DOMAttr *node_superChamber = node->getAttributeNode(str_chamber);
753  if (node_superChamber == nullptr)
754  throw cms::Exception("XMLException")
755  << "GEM node is missing required \"superChamber\" attribute" << std::endl;
756  try {
757  superChamber = XMLString::parseInt(node_superChamber->getValue());
758  } catch (const XMLException &toCatch) {
759  throw cms::Exception("XMLException") << "Value of \"superChamber\" must be an integer" << std::endl;
760  }
761 
762  if (structureType != align::AlignableGEMSuperChamber) {
763  DOMAttr *node_chamber = node->getAttributeNode(str_chamber);
764  if (node_chamber == nullptr)
765  throw cms::Exception("XMLException") << "GEM node is missing required \"chamber\" attribute" << std::endl;
766  try {
767  chamber = XMLString::parseInt(node_chamber->getValue());
768  } catch (const XMLException &toCatch) {
769  throw cms::Exception("XMLException") << "Value of \"chamber\" must be an integer" << std::endl;
770  }
771 
772  } // end if we need a layer number
773  } // end if we need a chamber number
774  } // end if we need a ring number
775  } // end if we need a station number
776 
777  GEMDetId chamberId(endcap, station, ring, 0, chamber, 0);
778  rawId = chamberId.rawId();
779  } // end if it's specified by endcap, station, ring, chamber, layer
780 
781  Alignable *ali = alignableNavigator[rawId];
782  if (ali == nullptr)
783  throw cms::Exception("XMLException") << "rawId \"" << rawId << "\" is not recognized" << std::endl;
784 
785  while (ali->alignableObjectId() != structureType) {
786  ali = ali->mother();
787 
788  if (ali == nullptr) {
789  throw cms::Exception("XMLException")
790  << "rawId \"" << rawId << "\" is not a " << alignableObjectId.idToString(structureType) << std::endl;
791  }
792  }
793  return ali;
794 }
795 
796 double MuonAlignmentInputXML::parseDouble(const XMLCh *str, const char *attribute) const {
797  unsigned int len = XMLString::stringLen(str);
798  char *cstr = XMLString::transcode(str);
799  std::stringstream errmessage;
800  errmessage << "Value of \"" << attribute << "\" must be a double, not \"" << cstr << "\"" << std::endl;
801 
802  unsigned int i = 0;
803 
804  bool minus = false;
805  if (cstr[i] == '-') {
806  minus = true;
807  i++;
808  } else if (cstr[i] == '+')
809  i++;
810 
811  double output = 0.;
812 
813  while (cstr[i] != '.' && cstr[i] != 'e' && cstr[i] != 'E' && i < len) {
814  if (cstr[i] < '0' || cstr[i] > '9') {
815  XMLString::release(&cstr);
816  throw cms::Exception("XMLException") << errmessage.str();
817  }
818 
819  output *= 10;
820  output += cstr[i] - '0';
821  i++;
822  }
823 
824  if (cstr[i] == '.') {
825  double place = 0.1;
826  i++;
827 
828  while (cstr[i] != 'e' && cstr[i] != 'E' && i < len) {
829  if (cstr[i] < '0' || cstr[i] > '9') {
830  XMLString::release(&cstr);
831  throw cms::Exception("XMLException") << errmessage.str();
832  }
833 
834  output += (cstr[i] - '0') * place;
835  place /= 10.;
836  i++;
837  }
838  }
839 
840  if (cstr[i] == 'e' || cstr[i] == 'E') {
841  i++;
842 
843  int exponent = 0;
844  bool expminus = false;
845  if (cstr[i] == '-') {
846  expminus = true;
847  i++;
848  } else if (cstr[i] == '+')
849  i++;
850 
851  while (i < len) {
852  if (cstr[i] < '0' || cstr[i] > '9') {
853  XMLString::release(&cstr);
854  throw cms::Exception("XMLException") << errmessage.str();
855  }
856 
857  exponent *= 10;
858  exponent += cstr[i] - '0';
859  i++;
860  }
861 
862  if (expminus)
863  exponent *= -1;
864 
865  output *= pow(10., exponent);
866  }
867 
868  if (minus)
869  output *= -1.;
870 
871  XMLString::release(&cstr);
872  return output;
873 }
874 
875 void MuonAlignmentInputXML::do_setposition(const XERCES_CPP_NAMESPACE::DOMElement *node,
876  std::map<Alignable *, bool> &aliset,
877  std::map<Alignable *, Alignable *> &alitoideal) const {
878  DOMAttr *node_relativeto = node->getAttributeNode(str_relativeto);
879  if (node_relativeto == nullptr)
880  throw cms::Exception("XMLException") << "<setposition> is missing required \"relativeto\" attribute" << std::endl;
881 
882  int relativeto = 0;
883  if (XMLString::equals(node_relativeto->getValue(), str_none)) {
884  relativeto = 0;
885  } else if (XMLString::equals(node_relativeto->getValue(), str_ideal)) {
886  relativeto = 1;
887  } else if (XMLString::equals(node_relativeto->getValue(), str_container)) {
888  relativeto = 2;
889  } else {
890  char *message = XMLString::transcode(node_relativeto->getValue());
891  throw cms::Exception("XMLException") << "relativeto must be \"none\", \"ideal\", or \"container\", not \""
892  << message << "\"" << std::endl;
893  }
894 
895  for (std::map<Alignable *, bool>::const_iterator aliiter = aliset.begin(); aliiter != aliset.end(); ++aliiter) {
896  // first reconstruct the old position: how it would look in this coordinate system
897 
898  Alignable *ali = aliiter->first;
899  Alignable *ideal = alitoideal[ali];
900 
901  align::PositionType oldpos = ali->globalPosition();
902  align::RotationType oldrot = ali->globalRotation();
903 
904  if (relativeto == 0) {
905  }
906 
907  else if (relativeto == 1) {
908  const align::PositionType &idealPosition = ideal->globalPosition();
909  align::RotationType idealRotation = ideal->globalRotation();
910 
911  oldpos = align::PositionType(idealRotation * (oldpos.basicVector() - idealPosition.basicVector()));
912  oldrot = oldrot * idealRotation.transposed();
913  }
914 
915  else if (relativeto == 2 && ali->mother() != nullptr) {
916  align::PositionType globalPosition = ali->mother()->globalPosition();
917  align::RotationType globalRotation = ali->mother()->globalRotation();
918 
919  oldpos = align::PositionType(globalRotation * (oldpos.basicVector() - globalPosition.basicVector()));
920  oldrot = oldrot * globalRotation.transposed();
921  }
922 
923  double x = oldpos.x();
924  double y = oldpos.y();
925  double z = oldpos.z();
926 
927  double phix = atan2(oldrot.yz(), oldrot.zz());
928  double phiy = asin(-oldrot.xz());
929  double phiz = atan2(oldrot.xy(), oldrot.xx());
930 
931  align::EulerAngles oldEulerAngles = align::toAngles(oldrot);
932  double alpha = oldEulerAngles(1);
933  double beta = oldEulerAngles(2);
934  double gamma = oldEulerAngles(3);
935 
936  // now get the new information; if it's incomplete, use the old position for those coordinates
937 
938  DOMAttr *node_x = node->getAttributeNode(str_x);
939  DOMAttr *node_y = node->getAttributeNode(str_y);
940  DOMAttr *node_z = node->getAttributeNode(str_z);
941 
942  if (node_x != nullptr)
943  x = parseDouble(node_x->getValue(), "x");
944  if (node_y != nullptr)
945  y = parseDouble(node_y->getValue(), "y");
946  if (node_z != nullptr)
947  z = parseDouble(node_z->getValue(), "z");
948  align::PositionType pos(x, y, z);
949 
950  DOMAttr *node_phix = node->getAttributeNode(str_phix);
951  DOMAttr *node_phiy = node->getAttributeNode(str_phiy);
952  DOMAttr *node_phiz = node->getAttributeNode(str_phiz);
953  DOMAttr *node_alpha = node->getAttributeNode(str_alpha);
954  DOMAttr *node_beta = node->getAttributeNode(str_beta);
955  DOMAttr *node_gamma = node->getAttributeNode(str_gamma);
956  align::RotationType rot;
957 
958  bool phixyz = (node_phix != nullptr || node_phiy != nullptr || node_phiz != nullptr);
959  bool alphabetagamma = (node_alpha != nullptr || node_beta != nullptr || node_gamma != nullptr);
960  if (phixyz && alphabetagamma)
961  throw cms::Exception("XMLException")
962  << "<setposition> must either have phix, phiy, and phiz or alpha, beta, and gamma, but not both" << std::endl;
963  if (!phixyz && !alphabetagamma)
964  alphabetagamma = true;
965 
966  if (phixyz) {
967  if (node_phix != nullptr)
968  phix = parseDouble(node_phix->getValue(), "phix");
969  if (node_phiy != nullptr)
970  phiy = parseDouble(node_phiy->getValue(), "phiy");
971  if (node_phiz != nullptr)
972  phiz = parseDouble(node_phiz->getValue(), "phiz");
973 
974  // the angle convention originally used in alignment, also known as "non-standard Euler angles with a Z-Y-X convention"
975  // this also gets the sign convention right
976  align::RotationType rotX(1., 0., 0., 0., cos(phix), sin(phix), 0., -sin(phix), cos(phix));
977  align::RotationType rotY(cos(phiy), 0., -sin(phiy), 0., 1., 0., sin(phiy), 0., cos(phiy));
978  align::RotationType rotZ(cos(phiz), sin(phiz), 0., -sin(phiz), cos(phiz), 0., 0., 0., 1.);
979 
980  rot = rotX * rotY * rotZ;
981  }
982 
983  else if (alphabetagamma) {
984  if (node_alpha != nullptr)
985  alpha = parseDouble(node_alpha->getValue(), "alpha");
986  if (node_beta != nullptr)
987  beta = parseDouble(node_beta->getValue(), "beta");
988  if (node_gamma != nullptr)
989  gamma = parseDouble(node_gamma->getValue(), "gamma");
990 
991  // standard Euler angles (how they're internally stored in the database)
992  align::EulerAngles eulerAngles(3);
993  eulerAngles(1) = alpha;
994  eulerAngles(2) = beta;
995  eulerAngles(3) = gamma;
996  rot = align::RotationType(align::toMatrix(eulerAngles));
997  }
998 
999  else
1000  assert(false); // see above
1001 
1002  if (relativeto == 0) {
1003  set_one_position(aliiter->first, pos, rot);
1004  } // end relativeto="none"
1005 
1006  else if (relativeto == 1) {
1007  Alignable *ali = aliiter->first;
1008  Alignable *ideal = alitoideal[ali];
1009 
1010  const align::PositionType &idealPosition = ideal->globalPosition();
1011  align::RotationType idealRotation = ideal->globalRotation();
1012  align::PositionType newpos =
1013  align::PositionType(idealRotation.transposed() * pos.basicVector() + idealPosition.basicVector());
1014  align::RotationType newrot = rot * idealRotation;
1015 
1016  set_one_position(ali, newpos, newrot);
1017  } // end relativeto="ideal"
1018 
1019  else if (relativeto == 2) {
1020  Alignable *ali = aliiter->first;
1021  Alignable *container = ali->mother();
1022 
1023  if (container != nullptr) {
1024  const align::PositionType &globalPosition = container->globalPosition();
1025  align::RotationType globalRotation = container->globalRotation();
1026  align::PositionType newpos =
1027  align::PositionType(globalRotation.transposed() * pos.basicVector() + globalPosition.basicVector());
1028  align::RotationType newrot = rot * globalRotation;
1029  set_one_position(ali, newpos, newrot);
1030  } else {
1031  set_one_position(ali, pos, rot);
1032  }
1033  } // end relativeto="container"
1034 
1035  } // end loop over alignables
1036 }
1037 
1038 void MuonAlignmentInputXML::set_one_position(Alignable *ali,
1039  const align::PositionType &pos,
1040  const align::RotationType &rot) const {
1041  const align::PositionType &oldpos = ali->globalPosition();
1042  const align::RotationType &oldrot = ali->globalRotation();
1043 
1044  // shift needed to move from current to new position
1045  align::GlobalVector posDiff = pos - oldpos;
1046  align::RotationType rotDiff = oldrot.multiplyInverse(rot);
1047  align::rectify(rotDiff); // correct for rounding errors
1048  ali->move(posDiff);
1049  ali->rotateInGlobalFrame(rotDiff);
1050 
1051  // // check for consistency
1052  // const align::PositionType& newpos = ali->globalPosition();
1053  // const align::RotationType& newrot = ali->globalRotation();
1054  // align::GlobalVector posDiff2 = pos - newpos;
1055  // align::RotationType rotDiff2 = newrot.multiplyInverse(rot);
1056  // align::rectify(rotDiff2); // correct for rounding errors
1057 
1058  // if (fabs(posDiff2.x()) > 1e-6 || fabs(posDiff2.y()) > 1e-6 || fabs(posDiff2.z()) > 1e-6) {
1059  // std::cout << "zeropos " << posDiff2 << std::endl;
1060  // }
1061  // if (fabs(rotDiff2.xx() - 1.) > 1e-4 ||
1062  // fabs(rotDiff2.yy() - 1.) > 1e-4 ||
1063  // fabs(rotDiff2.zz() - 1.) > 1e-4 ||
1064  // fabs(rotDiff2.xy()) > 1e-8 ||
1065  // fabs(rotDiff2.xz()) > 1e-8 ||
1066  // fabs(rotDiff2.yz()) > 1e-8) {
1067  // std::cout << "zerorot " << rotDiff2 << std::endl;
1068  // }
1069 
1070  align::ErrorMatrix matrix6x6 = ROOT::Math::SMatrixIdentity();
1071  matrix6x6 *= 1000.; // initial assumption: infinitely weak constraint
1072 
1073  const SurveyDet *survey = ali->survey();
1074  if (survey != nullptr) {
1075  matrix6x6 = survey->errors(); // save the constraint information
1076  }
1077  ali->setSurvey(new SurveyDet(ali->surface(), matrix6x6));
1078 }
1079 
1080 void MuonAlignmentInputXML::do_setape(const XERCES_CPP_NAMESPACE::DOMElement *node,
1081  std::map<Alignable *, bool> &aliset,
1082  std::map<Alignable *, Alignable *> &alitoideal) const {
1083  DOMAttr *node_xx = node->getAttributeNode(str_xx);
1084  DOMAttr *node_xy = node->getAttributeNode(str_xy);
1085  DOMAttr *node_xz = node->getAttributeNode(str_xz);
1086  DOMAttr *node_xa = node->getAttributeNode(str_xa);
1087  DOMAttr *node_xb = node->getAttributeNode(str_xb);
1088  DOMAttr *node_xc = node->getAttributeNode(str_xc);
1089  DOMAttr *node_yy = node->getAttributeNode(str_yy);
1090  DOMAttr *node_yz = node->getAttributeNode(str_yz);
1091  DOMAttr *node_ya = node->getAttributeNode(str_ya);
1092  DOMAttr *node_yb = node->getAttributeNode(str_yb);
1093  DOMAttr *node_yc = node->getAttributeNode(str_yc);
1094  DOMAttr *node_zz = node->getAttributeNode(str_zz);
1095  DOMAttr *node_za = node->getAttributeNode(str_za);
1096  DOMAttr *node_zb = node->getAttributeNode(str_zb);
1097  DOMAttr *node_zc = node->getAttributeNode(str_zc);
1098  DOMAttr *node_aa = node->getAttributeNode(str_aa);
1099  DOMAttr *node_ab = node->getAttributeNode(str_ab);
1100  DOMAttr *node_ac = node->getAttributeNode(str_ac);
1101  DOMAttr *node_bb = node->getAttributeNode(str_bb);
1102  DOMAttr *node_bc = node->getAttributeNode(str_bc);
1103  DOMAttr *node_cc = node->getAttributeNode(str_cc);
1104 
1105  if (node_xx == nullptr)
1106  throw cms::Exception("XMLException") << "<setape> is missing required \"xx\" attribute" << std::endl;
1107  if (node_xy == nullptr)
1108  throw cms::Exception("XMLException") << "<setape> is missing required \"xy\" attribute" << std::endl;
1109  if (node_xz == nullptr)
1110  throw cms::Exception("XMLException") << "<setape> is missing required \"xz\" attribute" << std::endl;
1111  if (node_xa == nullptr)
1112  throw cms::Exception("XMLException") << "<setape> is missing required \"xa\" attribute" << std::endl;
1113  if (node_xb == nullptr)
1114  throw cms::Exception("XMLException") << "<setape> is missing required \"xb\" attribute" << std::endl;
1115  if (node_xc == nullptr)
1116  throw cms::Exception("XMLException") << "<setape> is missing required \"xc\" attribute" << std::endl;
1117  if (node_yy == nullptr)
1118  throw cms::Exception("XMLException") << "<setape> is missing required \"yy\" attribute" << std::endl;
1119  if (node_yz == nullptr)
1120  throw cms::Exception("XMLException") << "<setape> is missing required \"yz\" attribute" << std::endl;
1121  if (node_ya == nullptr)
1122  throw cms::Exception("XMLException") << "<setape> is missing required \"ya\" attribute" << std::endl;
1123  if (node_yb == nullptr)
1124  throw cms::Exception("XMLException") << "<setape> is missing required \"yb\" attribute" << std::endl;
1125  if (node_yc == nullptr)
1126  throw cms::Exception("XMLException") << "<setape> is missing required \"yc\" attribute" << std::endl;
1127  if (node_zz == nullptr)
1128  throw cms::Exception("XMLException") << "<setape> is missing required \"zz\" attribute" << std::endl;
1129  if (node_za == nullptr)
1130  throw cms::Exception("XMLException") << "<setape> is missing required \"za\" attribute" << std::endl;
1131  if (node_zb == nullptr)
1132  throw cms::Exception("XMLException") << "<setape> is missing required \"zb\" attribute" << std::endl;
1133  if (node_zc == nullptr)
1134  throw cms::Exception("XMLException") << "<setape> is missing required \"zc\" attribute" << std::endl;
1135  if (node_aa == nullptr)
1136  throw cms::Exception("XMLException") << "<setape> is missing required \"aa\" attribute" << std::endl;
1137  if (node_ab == nullptr)
1138  throw cms::Exception("XMLException") << "<setape> is missing required \"ab\" attribute" << std::endl;
1139  if (node_ac == nullptr)
1140  throw cms::Exception("XMLException") << "<setape> is missing required \"ac\" attribute" << std::endl;
1141  if (node_bb == nullptr)
1142  throw cms::Exception("XMLException") << "<setape> is missing required \"bb\" attribute" << std::endl;
1143  if (node_bc == nullptr)
1144  throw cms::Exception("XMLException") << "<setape> is missing required \"bc\" attribute" << std::endl;
1145  if (node_cc == nullptr)
1146  throw cms::Exception("XMLException") << "<setape> is missing required \"cc\" attribute" << std::endl;
1147 
1148  align::ErrorMatrix matrix6x6;
1149  matrix6x6(0, 0) = parseDouble(node_xx->getValue(), "xx");
1150  matrix6x6(0, 1) = parseDouble(node_xy->getValue(), "xy");
1151  matrix6x6(0, 2) = parseDouble(node_xz->getValue(), "xz");
1152  matrix6x6(0, 3) = parseDouble(node_xa->getValue(), "xa");
1153  matrix6x6(0, 4) = parseDouble(node_xb->getValue(), "xb");
1154  matrix6x6(0, 5) = parseDouble(node_xc->getValue(), "xc");
1155  matrix6x6(1, 1) = parseDouble(node_yy->getValue(), "yy");
1156  matrix6x6(1, 2) = parseDouble(node_yz->getValue(), "yz");
1157  matrix6x6(1, 3) = parseDouble(node_ya->getValue(), "ya");
1158  matrix6x6(1, 4) = parseDouble(node_yb->getValue(), "yb");
1159  matrix6x6(1, 5) = parseDouble(node_yc->getValue(), "yc");
1160  matrix6x6(2, 2) = parseDouble(node_zz->getValue(), "zz");
1161  matrix6x6(2, 3) = parseDouble(node_za->getValue(), "za");
1162  matrix6x6(2, 4) = parseDouble(node_zb->getValue(), "zb");
1163  matrix6x6(2, 5) = parseDouble(node_zc->getValue(), "zc");
1164  matrix6x6(3, 3) = parseDouble(node_aa->getValue(), "aa");
1165  matrix6x6(3, 4) = parseDouble(node_ab->getValue(), "ab");
1166  matrix6x6(3, 5) = parseDouble(node_ac->getValue(), "ac");
1167  matrix6x6(4, 4) = parseDouble(node_bb->getValue(), "bb");
1168  matrix6x6(4, 5) = parseDouble(node_bc->getValue(), "bc");
1169  matrix6x6(5, 5) = parseDouble(node_cc->getValue(), "cc");
1170 
1171  for (std::map<Alignable *, bool>::const_iterator aliiter = aliset.begin(); aliiter != aliset.end(); ++aliiter) {
1172  // this sets APEs at this level and (since 2nd argument is true) all lower levels
1173  aliiter->first->setAlignmentPositionError(AlignmentPositionError(matrix6x6), true);
1174  }
1175 }
1176 
1177 void MuonAlignmentInputXML::do_setsurveyerr(const XERCES_CPP_NAMESPACE::DOMElement *node,
1178  std::map<Alignable *, bool> &aliset,
1179  std::map<Alignable *, Alignable *> &alitoideal) const {
1180  DOMAttr *node_xx = node->getAttributeNode(str_xx);
1181  DOMAttr *node_xy = node->getAttributeNode(str_xy);
1182  DOMAttr *node_xz = node->getAttributeNode(str_xz);
1183  DOMAttr *node_xa = node->getAttributeNode(str_xa);
1184  DOMAttr *node_xb = node->getAttributeNode(str_xb);
1185  DOMAttr *node_xc = node->getAttributeNode(str_xc);
1186  DOMAttr *node_yy = node->getAttributeNode(str_yy);
1187  DOMAttr *node_yz = node->getAttributeNode(str_yz);
1188  DOMAttr *node_ya = node->getAttributeNode(str_ya);
1189  DOMAttr *node_yb = node->getAttributeNode(str_yb);
1190  DOMAttr *node_yc = node->getAttributeNode(str_yc);
1191  DOMAttr *node_zz = node->getAttributeNode(str_zz);
1192  DOMAttr *node_za = node->getAttributeNode(str_za);
1193  DOMAttr *node_zb = node->getAttributeNode(str_zb);
1194  DOMAttr *node_zc = node->getAttributeNode(str_zc);
1195  DOMAttr *node_aa = node->getAttributeNode(str_aa);
1196  DOMAttr *node_ab = node->getAttributeNode(str_ab);
1197  DOMAttr *node_ac = node->getAttributeNode(str_ac);
1198  DOMAttr *node_bb = node->getAttributeNode(str_bb);
1199  DOMAttr *node_bc = node->getAttributeNode(str_bc);
1200  DOMAttr *node_cc = node->getAttributeNode(str_cc);
1201 
1202  if (node_xx == nullptr)
1203  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"xx\" attribute" << std::endl;
1204  if (node_xy == nullptr)
1205  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"xy\" attribute" << std::endl;
1206  if (node_xz == nullptr)
1207  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"xz\" attribute" << std::endl;
1208  if (node_xa == nullptr)
1209  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"xa\" attribute" << std::endl;
1210  if (node_xb == nullptr)
1211  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"xb\" attribute" << std::endl;
1212  if (node_xc == nullptr)
1213  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"xc\" attribute" << std::endl;
1214  if (node_yy == nullptr)
1215  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"yy\" attribute" << std::endl;
1216  if (node_yz == nullptr)
1217  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"yz\" attribute" << std::endl;
1218  if (node_ya == nullptr)
1219  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"ya\" attribute" << std::endl;
1220  if (node_yb == nullptr)
1221  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"yb\" attribute" << std::endl;
1222  if (node_yc == nullptr)
1223  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"yc\" attribute" << std::endl;
1224  if (node_zz == nullptr)
1225  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"zz\" attribute" << std::endl;
1226  if (node_za == nullptr)
1227  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"za\" attribute" << std::endl;
1228  if (node_zb == nullptr)
1229  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"zb\" attribute" << std::endl;
1230  if (node_zc == nullptr)
1231  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"zc\" attribute" << std::endl;
1232  if (node_aa == nullptr)
1233  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"aa\" attribute" << std::endl;
1234  if (node_ab == nullptr)
1235  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"ab\" attribute" << std::endl;
1236  if (node_ac == nullptr)
1237  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"ac\" attribute" << std::endl;
1238  if (node_bb == nullptr)
1239  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"bb\" attribute" << std::endl;
1240  if (node_bc == nullptr)
1241  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"bc\" attribute" << std::endl;
1242  if (node_cc == nullptr)
1243  throw cms::Exception("XMLException") << "<setsurveyerr> is missing required \"cc\" attribute" << std::endl;
1244 
1245  align::ErrorMatrix matrix6x6;
1246  matrix6x6(0, 0) = parseDouble(node_xx->getValue(), "xx");
1247  matrix6x6(0, 1) = parseDouble(node_xy->getValue(), "xy");
1248  matrix6x6(0, 2) = parseDouble(node_xz->getValue(), "xz");
1249  matrix6x6(0, 3) = parseDouble(node_xa->getValue(), "xa");
1250  matrix6x6(0, 4) = parseDouble(node_xb->getValue(), "xb");
1251  matrix6x6(0, 5) = parseDouble(node_xc->getValue(), "xc");
1252  matrix6x6(1, 1) = parseDouble(node_yy->getValue(), "yy");
1253  matrix6x6(1, 2) = parseDouble(node_yz->getValue(), "yz");
1254  matrix6x6(1, 3) = parseDouble(node_ya->getValue(), "ya");
1255  matrix6x6(1, 4) = parseDouble(node_yb->getValue(), "yb");
1256  matrix6x6(1, 5) = parseDouble(node_yc->getValue(), "yc");
1257  matrix6x6(2, 2) = parseDouble(node_zz->getValue(), "zz");
1258  matrix6x6(2, 3) = parseDouble(node_za->getValue(), "za");
1259  matrix6x6(2, 4) = parseDouble(node_zb->getValue(), "zb");
1260  matrix6x6(2, 5) = parseDouble(node_zc->getValue(), "zc");
1261  matrix6x6(3, 3) = parseDouble(node_aa->getValue(), "aa");
1262  matrix6x6(3, 4) = parseDouble(node_ab->getValue(), "ab");
1263  matrix6x6(3, 5) = parseDouble(node_ac->getValue(), "ac");
1264  matrix6x6(4, 4) = parseDouble(node_bb->getValue(), "bb");
1265  matrix6x6(4, 5) = parseDouble(node_bc->getValue(), "bc");
1266  matrix6x6(5, 5) = parseDouble(node_cc->getValue(), "cc");
1267 
1268  for (std::map<Alignable *, bool>::const_iterator aliiter = aliset.begin(); aliiter != aliset.end(); ++aliiter) {
1269  Alignable *ali = aliiter->first;
1270  ali->setSurvey(new SurveyDet(ali->surface(), matrix6x6));
1271  }
1272 }
1273 
1274 void MuonAlignmentInputXML::do_moveglobal(const XERCES_CPP_NAMESPACE::DOMElement *node,
1275  std::map<Alignable *, bool> &aliset,
1276  std::map<Alignable *, Alignable *> &alitoideal) const {
1277  DOMAttr *node_x = node->getAttributeNode(str_x);
1278  DOMAttr *node_y = node->getAttributeNode(str_y);
1279  DOMAttr *node_z = node->getAttributeNode(str_z);
1280  if (node_x == nullptr)
1281  throw cms::Exception("XMLException") << "<moveglobal> is missing required \"x\" attribute" << std::endl;
1282  if (node_y == nullptr)
1283  throw cms::Exception("XMLException") << "<moveglobal> is missing required \"y\" attribute" << std::endl;
1284  if (node_z == nullptr)
1285  throw cms::Exception("XMLException") << "<moveglobal> is missing required \"z\" attribute" << std::endl;
1286 
1287  double x = parseDouble(node_x->getValue(), "x");
1288  double y = parseDouble(node_y->getValue(), "y");
1289  double z = parseDouble(node_z->getValue(), "z");
1290  align::GlobalVector vect(x, y, z);
1291 
1292  for (std::map<Alignable *, bool>::const_iterator aliiter = aliset.begin(); aliiter != aliset.end(); ++aliiter) {
1293  Alignable *ali = aliiter->first;
1294 
1295  ali->move(vect);
1296 
1297  align::ErrorMatrix matrix6x6 = ROOT::Math::SMatrixIdentity();
1298  matrix6x6 *= 1000.; // initial assumption: infinitely weak constraint
1299 
1300  const SurveyDet *survey = ali->survey();
1301  if (survey != nullptr) {
1302  matrix6x6 = survey->errors(); // save the constraint information
1303  }
1304  ali->setSurvey(new SurveyDet(ali->surface(), matrix6x6));
1305  } // end loop over alignables
1306 }
1307 
1308 void MuonAlignmentInputXML::do_movelocal(const XERCES_CPP_NAMESPACE::DOMElement *node,
1309  std::map<Alignable *, bool> &aliset,
1310  std::map<Alignable *, Alignable *> &alitoideal) const {
1311  DOMAttr *node_x = node->getAttributeNode(str_x);
1312  DOMAttr *node_y = node->getAttributeNode(str_y);
1313  DOMAttr *node_z = node->getAttributeNode(str_z);
1314  if (node_x == nullptr)
1315  throw cms::Exception("XMLException") << "<movelocal> is missing required \"x\" attribute" << std::endl;
1316  if (node_y == nullptr)
1317  throw cms::Exception("XMLException") << "<movelocal> is missing required \"y\" attribute" << std::endl;
1318  if (node_z == nullptr)
1319  throw cms::Exception("XMLException") << "<movelocal> is missing required \"z\" attribute" << std::endl;
1320 
1321  double x = parseDouble(node_x->getValue(), "x");
1322  double y = parseDouble(node_y->getValue(), "y");
1323  double z = parseDouble(node_z->getValue(), "z");
1324  align::LocalVector vect(x, y, z);
1325 
1326  for (std::map<Alignable *, bool>::const_iterator aliiter = aliset.begin(); aliiter != aliset.end(); ++aliiter) {
1327  Alignable *ali = aliiter->first;
1328 
1329  align::GlobalVector globalVector = ali->surface().toGlobal(vect);
1330  ali->move(globalVector);
1331 
1332  align::ErrorMatrix matrix6x6 = ROOT::Math::SMatrixIdentity();
1333  matrix6x6 *= 1000.; // initial assumption: infinitely weak constraint
1334 
1335  const SurveyDet *survey = ali->survey();
1336  if (survey != nullptr) {
1337  matrix6x6 = survey->errors(); // save the constraint information
1338  }
1339  ali->setSurvey(new SurveyDet(ali->surface(), matrix6x6));
1340  } // end loop over alignables
1341 }
1342 
1343 void MuonAlignmentInputXML::do_rotatelocal(const XERCES_CPP_NAMESPACE::DOMElement *node,
1344  std::map<Alignable *, bool> &aliset,
1345  std::map<Alignable *, Alignable *> &alitoideal) const {
1346  DOMAttr *node_axisx = node->getAttributeNode(str_axisx);
1347  DOMAttr *node_axisy = node->getAttributeNode(str_axisy);
1348  DOMAttr *node_axisz = node->getAttributeNode(str_axisz);
1349  DOMAttr *node_angle = node->getAttributeNode(str_angle);
1350  if (node_axisx == nullptr)
1351  throw cms::Exception("XMLException") << "<rotatelocal> is missing required \"axisx\" attribute" << std::endl;
1352  if (node_axisy == nullptr)
1353  throw cms::Exception("XMLException") << "<rotatelocal> is missing required \"axisy\" attribute" << std::endl;
1354  if (node_axisz == nullptr)
1355  throw cms::Exception("XMLException") << "<rotatelocal> is missing required \"axisz\" attribute" << std::endl;
1356  if (node_angle == nullptr)
1357  throw cms::Exception("XMLException") << "<rotatelocal> is missing required \"angle\" attribute" << std::endl;
1358 
1359  double x = parseDouble(node_axisx->getValue(), "x");
1360  double y = parseDouble(node_axisy->getValue(), "y");
1361  double z = parseDouble(node_axisz->getValue(), "z");
1362  double angle = parseDouble(node_angle->getValue(), "angle");
1363  align::LocalVector vect(x, y, z);
1364 
1365  for (std::map<Alignable *, bool>::const_iterator aliiter = aliset.begin(); aliiter != aliset.end(); ++aliiter) {
1366  Alignable *ali = aliiter->first;
1367 
1368  ali->rotateAroundLocalAxis(vect, angle);
1369 
1370  align::ErrorMatrix matrix6x6 = ROOT::Math::SMatrixIdentity();
1371  matrix6x6 *= 1000.; // initial assumption: infinitely weak constraint
1372 
1373  const SurveyDet *survey = ali->survey();
1374  if (survey != nullptr) {
1375  matrix6x6 = survey->errors(); // save the constraint information
1376  }
1377  ali->setSurvey(new SurveyDet(ali->surface(), matrix6x6));
1378  } // end loop over alignables
1379 }
1380 
1381 void MuonAlignmentInputXML::do_rotatebeamline(const XERCES_CPP_NAMESPACE::DOMElement *node,
1382  std::map<Alignable *, bool> &aliset,
1383  std::map<Alignable *, Alignable *> &alitoideal) const {
1384  DOMAttr *node_rphi = node->getAttributeNode(str_rphi);
1385  DOMAttr *node_phi = node->getAttributeNode(str_phi);
1386  if (node_rphi == nullptr && node_phi == nullptr)
1387  throw cms::Exception("XMLException") << "<rotatebeamline> is missing required \"*phi\" attribute" << std::endl;
1388  if (node_rphi != nullptr && node_phi != nullptr)
1389  throw cms::Exception("XMLException") << "<rotatebeamline> can't have both an \"rphi\" and a \"phi\" attribute"
1390  << std::endl;
1391 
1392  double value;
1393  if (node_rphi != nullptr) {
1394  value = parseDouble(node_rphi->getValue(), "rphi");
1395  } else {
1396  value = parseDouble(node_phi->getValue(), "phi");
1397  }
1398 
1399  for (std::map<Alignable *, bool>::const_iterator aliiter = aliset.begin(); aliiter != aliset.end(); ++aliiter) {
1400  Alignable *ali = aliiter->first;
1401 
1402  align::GlobalPoint pos = ali->surface().toGlobal(align::LocalPoint(0, 0, 0));
1403 
1404  double radius = pos.perp();
1405  double phi0 = pos.phi();
1406  double deltaphi = value;
1407  if (node_rphi != nullptr)
1408  deltaphi = value / radius;
1409 
1410  ali->rotateAroundGlobalZ(deltaphi);
1411  ali->move(align::GlobalVector(
1412  radius * (cos(phi0 + deltaphi) - cos(phi0)), radius * (sin(phi0 + deltaphi) - sin(phi0)), 0.));
1413 
1414  align::ErrorMatrix matrix6x6 = ROOT::Math::SMatrixIdentity();
1415  matrix6x6 *= 1000.; // initial assumption: infinitely weak constraint
1416 
1417  const SurveyDet *survey = ali->survey();
1418  if (survey != nullptr) {
1419  matrix6x6 = survey->errors(); // save the constraint information
1420  }
1421  ali->setSurvey(new SurveyDet(ali->surface(), matrix6x6));
1422  } // end loop over alignables
1423 }
1424 
1425 void MuonAlignmentInputXML::do_rotateglobalaxis(const XERCES_CPP_NAMESPACE::DOMElement *node,
1426  std::map<Alignable *, bool> &aliset,
1427  std::map<Alignable *, Alignable *> &alitoideal) const {
1428  DOMAttr *node_x = node->getAttributeNode(str_x);
1429  DOMAttr *node_y = node->getAttributeNode(str_y);
1430  DOMAttr *node_z = node->getAttributeNode(str_z);
1431  DOMAttr *node_angle = node->getAttributeNode(str_angle);
1432  if (node_x == nullptr)
1433  throw cms::Exception("XMLException") << "<rotateglobalaxis> is missing required \"x\" attribute" << std::endl;
1434  if (node_y == nullptr)
1435  throw cms::Exception("XMLException") << "<rotateglobalaxis> is missing required \"y\" attribute" << std::endl;
1436  if (node_z == nullptr)
1437  throw cms::Exception("XMLException") << "<rotateglobalaxis> is missing required \"z\" attribute" << std::endl;
1438  if (node_angle == nullptr)
1439  throw cms::Exception("XMLException") << "<rotateglobalaxis> is missing required \"angle\" attribute" << std::endl;
1440 
1441  double x = parseDouble(node_x->getValue(), "x");
1442  double y = parseDouble(node_y->getValue(), "y");
1443  double z = parseDouble(node_z->getValue(), "z");
1444  double angle = parseDouble(node_angle->getValue(), "angle");
1445 
1446  for (std::map<Alignable *, bool>::const_iterator aliiter = aliset.begin(); aliiter != aliset.end(); ++aliiter) {
1447  Alignable *ali = aliiter->first;
1448  align::GlobalPoint pos = ali->surface().toGlobal(align::LocalPoint(0, 0, 0));
1449 
1450  ali->rotateAroundGlobalAxis(align::GlobalVector(x, y, z), angle);
1451 
1452  double aprime = x / sqrt(x * x + y * y + z * z);
1453  double bprime = y / sqrt(x * x + y * y + z * z);
1454  double cprime = z / sqrt(x * x + y * y + z * z);
1455  double q0 = cos(angle / 2.);
1456  double q1 = sin(angle / 2.) * aprime;
1457  double q2 = sin(angle / 2.) * bprime;
1458  double q3 = sin(angle / 2.) * cprime;
1459 
1460  double pos2x = (q0 * q0 + q1 * q1 - q2 * q2 - q3 * q3) * pos.x() + 2. * (q1 * q2 - q0 * q3) * pos.y() +
1461  2. * (q1 * q3 + q0 * q2) * pos.z();
1462  double pos2y = 2. * (q2 * q1 + q0 * q3) * pos.x() + (q0 * q0 - q1 * q1 + q2 * q2 - q3 * q3) * pos.y() +
1463  2. * (q2 * q3 - q0 * q1) * pos.z();
1464  double pos2z = 2. * (q3 * q1 - q0 * q2) * pos.x() + 2. * (q3 * q2 + q0 * q1) * pos.y() +
1465  (q0 * q0 - q1 * q1 - q2 * q2 + q3 * q3) * pos.z();
1466 
1467  double movex = pos2x - pos.x();
1468  double movey = pos2y - pos.y();
1469  double movez = pos2z - pos.z();
1470  ali->move(align::GlobalVector(movex, movey, movez));
1471 
1472  align::ErrorMatrix matrix6x6 = ROOT::Math::SMatrixIdentity();
1473  matrix6x6 *= 1000.; // initial assumption: infinitely weak constraint
1474 
1475  const SurveyDet *survey = ali->survey();
1476  if (survey != nullptr) {
1477  matrix6x6 = survey->errors(); // save the constraint information
1478  }
1479  ali->setSurvey(new SurveyDet(ali->surface(), matrix6x6));
1480  } // end loop over alignables
1481 }
1482 
1483 //
1484 // const member functions
1485 //
1486 
1487 //
1488 // static member functions
1489 //
TkRotation::xx
T xx() const
Definition: extTkRotation.h:193
MuonAlignmentInputXML::do_setsurveyerr
void do_setsurveyerr(const XERCES_CPP_NAMESPACE::DOMElement *node, std::map< Alignable *, bool > &aliset, std::map< Alignable *, Alignable * > &alitoideal) const
Definition: MuonAlignmentInputXML.cc:1177
align::RotationType
TkRotation< Scalar > RotationType
Definition: Definitions.h:27
alpha
float alpha
Definition: AMPTWrapper.h:105
mps_fire.i
i
Definition: mps_fire.py:428
PV3DBase::perp
T perp() const
Definition: PV3DBase.h:69
MuonAlignmentInputXML::getNode
Alignable * getNode(std::map< unsigned int, Alignable * > &alignableNavigator, const XERCES_CPP_NAMESPACE::DOMElement *node, const AlignableObjectId &) const
Definition: MuonAlignmentInputXML.cc:479
fetchall_from_DQM_v2.release
tuple release
Definition: fetchall_from_DQM_v2.py:111
Alignable::rotateAroundLocalAxis
virtual void rotateAroundLocalAxis(const LocalVector &axis, Scalar radians)
Rotation around arbitratry local axis.
Definition: Alignable.cc:143
Reference_intrackfit_cff.endcap
endcap
Definition: Reference_intrackfit_cff.py:82
MuonAlignmentInputXML::newAlignableMuon
AlignableMuon * newAlignableMuon() const override
Definition: MuonAlignmentInputXML.cc:288
MuonAlignmentInputXML::parseDouble
double parseDouble(const XMLCh *str, const char *attribute) const
Definition: MuonAlignmentInputXML.cc:796
MuonAlignmentInputXML::do_rotatelocal
void do_rotatelocal(const XERCES_CPP_NAMESPACE::DOMElement *node, std::map< Alignable *, bool > &aliset, std::map< Alignable *, Alignable * > &alitoideal) const
Definition: MuonAlignmentInputXML.cc:1343
cms::concurrency::xercesTerminate
void xercesTerminate()
Definition: Xerces.cc:23
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
AlignableMuon::DTBarrel
align::Alignables DTBarrel()
Definition: AlignableMuon.cc:396
Alignable::survey
const SurveyDet * survey() const
Return survey info.
Definition: Alignable.h:216
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
MuonAlignmentInputXML::getCSCnode
Alignable * getCSCnode(align::StructureType structureType, std::map< unsigned int, Alignable * > &alignableNavigator, const XERCES_CPP_NAMESPACE::DOMElement *node, const AlignableObjectId &) const
Definition: MuonAlignmentInputXML.cc:613
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
MuonAlignmentInputXML::dtGeometryIdeal_
const DTGeometry * dtGeometryIdeal_
Definition: MuonAlignmentInputXML.h:114
Alignable::globalRotation
const RotationType & globalRotation() const
Return the global orientation of the object.
Definition: Alignable.h:138
MuonAlignmentInputXML::do_movelocal
void do_movelocal(const XERCES_CPP_NAMESPACE::DOMElement *node, std::map< Alignable *, bool > &aliset, std::map< Alignable *, Alignable * > &alitoideal) const
Definition: MuonAlignmentInputXML.cc:1308
Alignable::move
virtual void move(const GlobalVector &displacement)=0
Movement with respect to the global reference frame.
MuonAlignmentInputXML::do_moveglobal
void do_moveglobal(const XERCES_CPP_NAMESPACE::DOMElement *node, std::map< Alignable *, bool > &aliset, std::map< Alignable *, Alignable * > &alitoideal) const
Definition: MuonAlignmentInputXML.cc:1274
SurveyDet::errors
const align::ErrorMatrix & errors() const
Definition: SurveyDet.h:62
cms::concurrency::xercesInitialize
void xercesInitialize()
Definition: Xerces.cc:18
cms::cuda::assert
assert(be >=bs)
AlignableMuon::objectIdProvider
const AlignableObjectId & objectIdProvider() const
Return muon alignable object ID provider derived from the muon system geometry.
Definition: AlignableMuon.h:92
Alignable::rotateAroundGlobalAxis
virtual void rotateAroundGlobalAxis(const GlobalVector &axis, Scalar radians)
Rotation around arbitratry global axis.
Definition: Alignable.cc:138
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
MuonAlignmentInputXML::dtGeometry_
const DTGeometry * dtGeometry_
Definition: MuonAlignmentInputXML.h:111
HLT_FULL_cff.beta
tuple beta
Definition: HLT_FULL_cff.py:7581
phase1PixelTopology::layer
constexpr std::array< uint8_t, layerIndexSize > layer
Definition: SimplePixelTopology.h:138
Alignable::rotateAroundGlobalZ
virtual void rotateAroundGlobalZ(Scalar radians)
Rotation around global z-axis.
Definition: Alignable.cc:176
MuonAlignmentInputXML::do_rotatebeamline
void do_rotatebeamline(const XERCES_CPP_NAMESPACE::DOMElement *node, std::map< Alignable *, bool > &aliset, std::map< Alignable *, Alignable * > &alitoideal) const
Definition: MuonAlignmentInputXML.cc:1381
align::PositionType
Point3DBase< Scalar, GlobalTag > PositionType
Definition: Definitions.h:28
TkRotation::xy
T xy() const
Definition: extTkRotation.h:194
TkRotation::zz
T zz() const
Definition: extTkRotation.h:201
AlignableMuon::CSCEndcaps
align::Alignables CSCEndcaps()
Definition: AlignableMuon.cc:439
align::rectify
void rectify(RotationType &)
Correct a rotation matrix for rounding errors.
Definition: Utilities.cc:185
MillePedeFileConverter_cfg.fileName
tuple fileName
Definition: MillePedeFileConverter_cfg.py:32
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
MuonAlignmentInputXML::recursiveGetId
void recursiveGetId(std::map< unsigned int, Alignable * > &alignableNavigator, const align::Alignables &alignables) const
Definition: MuonAlignmentInputXML.cc:249
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
Alignable::alignableObjectId
virtual StructureType alignableObjectId() const =0
Return the alignable type identifier.
MuonAlignmentInputXML::do_setape
void do_setape(const XERCES_CPP_NAMESPACE::DOMElement *node, std::map< Alignable *, bool > &aliset, std::map< Alignable *, Alignable * > &alitoideal) const
Definition: MuonAlignmentInputXML.cc:1080
AlignableObjectId
Allows conversion between type and name, and vice-versa.
Definition: AlignableObjectId.h:13
align::toAngles
EulerAngles toAngles(const RotationType &)
Convert rotation matrix to angles about x-, y-, z-axes (frame rotation).
Definition: Utilities.cc:8
MuonAlignmentInputXML::getGEMnode
Alignable * getGEMnode(align::StructureType structureType, std::map< unsigned int, Alignable * > &alignableNavigator, const XERCES_CPP_NAMESPACE::DOMElement *node, const AlignableObjectId &) const
Definition: MuonAlignmentInputXML.cc:705
Alignable::surface
const AlignableSurface & surface() const
Return the Surface (global position and orientation) of the object.
Definition: Alignable.h:132
MuonAlignmentInputXML::gemGeometryIdeal_
const GEMGeometry * gemGeometryIdeal_
Definition: MuonAlignmentInputXML.h:116
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:72
align::EulerAngles
AlgebraicVector EulerAngles
Definition: Definitions.h:34
equals
bool equals(const edm::RefToBase< Jet > &j1, const edm::RefToBase< Jet > &j2)
Definition: DeepCMVATagInfoProducer.cc:56
AlignableObjectId::idToString
const char * idToString(align::StructureType type) const
Definition: AlignableObjectId.cc:273
Alignable::rotateInGlobalFrame
virtual void rotateInGlobalFrame(const RotationType &rotation)=0
MuonAlignmentInputXML::gemGeometry_
const GEMGeometry * gemGeometry_
Definition: MuonAlignmentInputXML.h:113
MuonAlignmentInputXML::MuonAlignmentInputXML
MuonAlignmentInputXML(const std::string &fileName, const DTGeometry *dtGeometry, const CSCGeometry *cscGeometry, const GEMGeometry *gemGeometry, const DTGeometry *dtGeometryIdeal, const CSCGeometry *cscGeometryIdeal, const GEMGeometry *gemGeometryIdeal)
Definition: MuonAlignmentInputXML.cc:49
Alignable::setSurvey
void setSurvey(const SurveyDet *)
Set survey info.
Definition: Alignable.cc:266
MuonAlignmentInputXML::cscGeometryIdeal_
const CSCGeometry * cscGeometryIdeal_
Definition: MuonAlignmentInputXML.h:115
align::Alignables
std::vector< Alignable * > Alignables
Definition: Utilities.h:31
AlignableMuon::GEMEndcaps
align::Alignables GEMEndcaps()
Definition: AlignableMuon.cc:504
TkRotation::xz
T xz() const
Definition: extTkRotation.h:195
TkRotation::transposed
TkRotation transposed() const
Definition: extTkRotation.h:136
AlignableSurface::toGlobal
align::GlobalPoints toGlobal(const align::LocalPoints &) const
Return in global coord given a set of local points.
Definition: AlignableSurface.cc:15
align::toMatrix
RotationType toMatrix(const EulerAngles &)
Convert rotation angles about x-, y-, z-axes to matrix.
Definition: Utilities.cc:34
HLT_FULL_cff.exponent
tuple exponent
Definition: HLT_FULL_cff.py:38543
MuonAlignmentInputXML::do_rotateglobalaxis
void do_rotateglobalaxis(const XERCES_CPP_NAMESPACE::DOMElement *node, std::map< Alignable *, bool > &aliset, std::map< Alignable *, Alignable * > &alitoideal) const
Definition: MuonAlignmentInputXML.cc:1425
Alignable::globalPosition
const PositionType & globalPosition() const
Return the global position of the object.
Definition: Alignable.h:135
align::ErrorMatrix
math::Error< 6 >::type ErrorMatrix
Definition: Definitions.h:37
MuonAlignmentInputXML::getDTnode
Alignable * getDTnode(align::StructureType structureType, std::map< unsigned int, Alignable * > &alignableNavigator, const XERCES_CPP_NAMESPACE::DOMElement *node, const AlignableObjectId &) const
Definition: MuonAlignmentInputXML.cc:520
MuonAlignmentInputXML::fillAliToIdeal
void fillAliToIdeal(std::map< Alignable *, Alignable * > &alitoideal, const align::Alignables &alignables, const align::Alignables &ideals) const
Definition: MuonAlignmentInputXML.cc:267
MuonAlignmentInputXML::do_setposition
void do_setposition(const XERCES_CPP_NAMESPACE::DOMElement *node, std::map< Alignable *, bool > &aliset, std::map< Alignable *, Alignable * > &alitoideal) const
Definition: MuonAlignmentInputXML.cc:875
TkRotation::multiplyInverse
Basic3DVector< T > multiplyInverse(const Basic3DVector< T > &v) const
Definition: extTkRotation.h:144
MuonAlignmentInputXML::set_one_position
void set_one_position(Alignable *ali, const align::PositionType &pos, const align::RotationType &rot) const
Definition: MuonAlignmentInputXML.cc:1038
str
#define str(s)
Definition: TestProcessor.cc:54
AlignableMuon
Constructor of the full muon geometry.
Definition: AlignableMuon.h:38
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
PV3DBase::basicVector
const BasicVectorType & basicVector() const
Definition: PV3DBase.h:53
CosmicsPD_Skims.radius
tuple radius
Definition: CosmicsPD_Skims.py:135
Alignable::mother
Alignable * mother() const
Return pointer to container alignable (if any)
Definition: Alignable.h:91
TkRotation::yz
T yz() const
Definition: extTkRotation.h:198
MuonAlignmentInputXML::cscGeometry_
const CSCGeometry * cscGeometry_
Definition: MuonAlignmentInputXML.h:112
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
angle
T angle(T x1, T y1, T z1, T x2, T y2, T z2)
Definition: angle.h:11
Generated for CMSSW Reference Manual by doxygen 1.8.5