Inheritance diagram for geometryXMLparser.MuonGeometry:

Public Member Functions
def	__init__ (self, stream=None)

def	endElement (self, tag)

def	startElement (self, tag, attrib)

def	xml (self, stream=None, precision=10)

Public Attributes
	csc

	dt

Private Attributes
	_operation

Detailed Description

Definition at line 99 of file geometryXMLparser.py.

Constructor & Destructor Documentation

◆ init()

def geometryXMLparser.MuonGeometry.__init__	(	self,
		stream = `None`
	)

Definition at line 100 of file geometryXMLparser.py.

     def __init__(self, stream=None):
         self.dt = {}
         self.csc = {}
         self._operation = None
 
         if stream is not None:
           parser = xml.sax.make_parser()
           parser.setContentHandler(self)
           parser.parse(stream)
 

Member Function Documentation

◆ endElement()

def geometryXMLparser.MuonGeometry.endElement	(	self,
		tag
	)

Definition at line 157 of file geometryXMLparser.py.

References geometryXMLparser.MuonGeometry._operation, geometryXMLparser.MuonGeometry.csc, and geometryXMLparser.MuonGeometry.dt.

     def endElement(self, tag):
         if tag == "operation":
             if self._operation is None: raise Exception("Unbalanced <operation></operation>")
             for c in self._operation.chambers:
                 c.__dict__.update(self._operation.setposition)
                 c.__dict__.update(self._operation.setape)
                 if isinstance(c, DTAlignable): self.dt[c.index()] = c
                 elif isinstance(c, CSCAlignable): self.csc[c.index()] = c
 

◆ startElement()

def geometryXMLparser.MuonGeometry.startElement	(	self,
		tag,
		attrib
	)

Definition at line 111 of file geometryXMLparser.py.

References geometryXMLparser.MuonGeometry._operation, nano_mu_digi_cff.float, createfilelist.int, and str.

     def startElement(self, tag, attrib):
         attrib = dict(attrib.items())
         if "rawId" in attrib: raise Exception("Please use \"rawIds = false\"")
         if "aa" in attrib: raise Exception("Please use \"survey = false\"")
 
         if tag == "MuonAlignment": pass
 
         elif tag == "collection": raise NotImplementedError("<collection /> and <collection> blocks aren't implemented yet")
 
         elif tag == "operation":
             self._operation = Operation()
 
         elif self._operation is None: raise Exception("All chambers and positions must be enclosed in <operation> blocks")
 
         elif tag == "setposition":
             self._operation.setposition["relativeto"] = str(attrib["relativeto"])
 
             for name in "x", "y", "z":
                 self._operation.setposition[name] = float(attrib[name])
             try:
                 for name in "phix", "phiy", "phiz":
                     self._operation.setposition[name] = float(attrib[name])
             except KeyError:
                 for name in "alpha", "beta", "gamma":
                     self._operation.setposition[name] = float(attrib[name])
 
         elif tag == "setape":
             for name in "xx", "xy", "xz", "xa", "xb", "xc", "yy", "yz", "ya", "yb", "yc", "zz", "za", "zb", "zc", "aa", "ab", "ac", "bb", "bc", "cc":
                 self._operation.setposition[name] = float(attrib[name])
 
         elif tag[0:2] == "DT":
             alignable = DTAlignable()
             for name in "wheel", "station", "sector", "superlayer", "layer":
                 if name in attrib:
                     alignable.__dict__[name] = int(attrib[name])
             self._operation.chambers.append(alignable)
 
         # <CSC...>: print endcap/station/ring/chamber/layer
         elif tag[0:3] == "CSC":
             alignable = CSCAlignable()
             for name in "endcap", "station", "ring", "chamber", "layer":
                 if name in attrib:
                     alignable.__dict__[name] = int(attrib[name])
             self._operation.chambers.append(alignable)
 

◆ xml()

def geometryXMLparser.MuonGeometry.xml	(	self,
		stream = `None`,
		precision = `10`
	)

Definition at line 167 of file geometryXMLparser.py.

References geometryXMLparser.MuonGeometry.csc, geometryXMLparser.MuonGeometry.dt, f, join(), relativeConstraints.keys, str, and reco.zip().

     def xml(self, stream=None, precision=10):
       if precision == None: format = "%g"
       else: format = "%." + str(precision) + "f"
 
       if stream == None:
         output = []
         writeline = lambda x: output.append(x)
       else:
         writeline = lambda x: stream.write(x)
 
       writeline("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
       writeline("<?xml-stylesheet type=\"text/xml\" href=\"MuonAlignment.xsl\"?>\n")
       writeline("<MuonAlignment>\n\n")
 
       dtkeys = self.dt.keys()
       dtkeys.sort(dtorder)
       csckeys = self.csc.keys()
       csckeys.sort(cscorder)
 
       def f(number): return format % number
 
       def position_ape(ali, attributes):
         writeline("  <%s%s />\n" % (level, attributes))
         writeline("  <setposition relativeto=\"%s\" x=\"%s\" y=\"%s\" z=\"%s\" phix=\"%s\" phiy=\"%s\" phiz=\"%s\" />\n" % \
                   (ali.relativeto, f(ali.x), f(ali.y), f(ali.z), f(ali.phix), f(ali.phiy), f(ali.phiz)))
 
         if "xx" in ali.__dict__:
           writeline("  <setape xx=\"%s\" xy=\"%s\" xz=\"%s\" xa=\"%s\" xb=\"%s\" xc=\"%s\" yy=\"%s\" yz=\"%s\" ya=\"%s\" yb=\"%s\" yc=\"%s\" zz=\"%s\" za=\"%s\" zb=\"%s\" zc=\"%s\" aa=\"%s\" ab=\"%s\" ac=\"%s\" bb=\"%s\" bc=\"%s\" cc=\"%s\" />\n" % \
                     (f(ali.xx), f(ali.xy), f(ali.xz), f(ali.xa), f(ali.xb), f(ali.xc), f(ali.yy), f(ali.yz), f(ali.ya), f(ali.yb), f(ali.yc), f(ali.zz), f(ali.za), f(ali.zb), f(ali.zc), f(ali.aa), f(ali.ab), f(ali.ac), f(ali.bb), f(ali.bc), f(ali.cc)))
 
       for key in dtkeys:
         writeline("<operation>\n")
 
         if len(key) == 0: level = "DTBarrel"
         elif len(key) == 1: level = "DTWheel "
         elif len(key) == 2: level = "DTStation "
         elif len(key) == 3: level = "DTChamber "
         elif len(key) == 4: level = "DTSuperLayer "
         elif len(key) == 5: level = "DTLayer "
 
         ali = self.dt[key]
         attributes = " ".join(["%s=\"%d\"" % (name, value) for name, value in zip(("wheel", "station", "sector", "superlayer", "layer"), key)])
         position_ape(ali, attributes)
 
         writeline("</operation>\n\n")
 
       for key in csckeys:
         writeline("<operation>\n")
 
         if len(key) == 1: level = "CSCEndcap "
         elif len(key) == 2: level = "CSCStation "
         elif len(key) == 3: level = "CSCRing "
         elif len(key) == 4: level = "CSCChamber "
         elif len(key) == 5: level = "CSCLayer "
 
         ali = self.csc[key]
         attributes = " ".join(["%s=\"%d\"" % (name, value) for name, value in zip(("endcap", "station", "ring", "chamber", "layer"), key)])
         position_ape(ali, attributes)
 
         writeline("</operation>\n\n")
 
       writeline("</MuonAlignment>\n")
       if stream == None: return "".join(output)