In This Package:

de_search.py

Go to the documentation of this file.

#!/usr/bin/env python

import PyCintex
gbl = PyCintex.makeNamespace("")

import xmldetdesc
xmldetdesc.config()

from Gaudi.Configuration import *
conf = ApplicationMgr()

from GaudiPython.GaudiAlgs import GaudiAlgo
from GaudiPython import *
class MyAlg(GaudiAlgo):
    def __init__(self,name):
        GaudiAlgo.__init__(self,name)
        print "Making MyAlg",name
        self.depth = 0

    def tab(self):
        return "  "*self.depth
    def out(self,*stuff):
        #print self.tab()+" ".join(stuff)
        return

    def dump_all(self):
        from GaudiPython import AppMgr
        app = AppMgr()
        det = app.detsvc()
        lar = det['/dd/Structure/Sites/la-rock']
        self.dump_de(lar,None)
        return

    def initialize(self):
        status = GaudiAlgo.initialize(self)
        print "Init MyAlg",self.name
        if status.isFailure(): return status

        app = AppMgr()
        self.det = app.detsvc()

        import time
        for n in range(0,10):
            start = time.time()
            self.do_one()
            stop = time.time()
            print "Run %d all AD PMTs in %f seconds"%(n,stop-start)

        return SUCCESS

    def do_one(self):

        touchable_history_template = [
            "/dd/Geometry/PMT/lvPmtHemiVacuum#pvPmtHemiCathode",
            "/dd/Geometry/PMT/lvPmtHemi#pvPmtHemiVacuum",
            "/dd/Geometry/AD/lvOIL#pvAdPmtArray#pvAdPmtArrayRotated#pvAdPmtRingInCyl:%(ring)d#pvAdPmtInRing:%(col)d#pvAdPmtUnit",
            "/dd/Geometry/AD/lvSST#pvOIL",
            "/dd/Geometry/AD/lvADE#pvSST",
            "/dd/Geometry/Pool/lvNearPoolIWS#pvNearADE%(nad)d",
            "/dd/Geometry/Pool/lvNearPoolCurtain#pvNearPoolIWS",
            "/dd/Geometry/Pool/lvNearPoolOWS#pvNearPoolCurtain",
            "/dd/Geometry/Pool/lvNearPoolLiner#pvNearPoolOWS",
            "/dd/Geometry/Pool/lvNearPoolDead#pvNearPoolLiner",
            "/dd/Geometry/Sites/lvNearHallBot#pvNearPoolDead",
            "/dd/Geometry/Sites/lvNearSiteRock#pvNearHallBot",
            "/dd/Structure/Sites/%(site)s-rock"
            ]


        for site in ['la','db']:
            for nad in range(0,2):
                nad += 1
                for ring in range(0,8):
                    ring += 1
                    for col in range(0,24):
                        col += 1
                        
                        params = { 'ring':ring,'col':col,'nad':nad,'site':site }
                        
                        th = " ".join(touchable_history_template)%params
                        touchableHistory = th.split(" ")
                        
                        self.fix_th(touchableHistory)
                        de = self.th2de(touchableHistory)
                        if not de:
                            print "Failed, remaining TH is:\n%s"%"\n".join(touchableHistory)
                            continue
                        continue
                    continue
                continue
        return

    def fix_th(self,th):
        "Expand multiple pv chains"

        th.reverse()

        index = 0
        for entry in th:
            index += 1
            names = entry.split("#")
            if len(names) <= 2: continue
            th.pop(index-1)
            th.insert(index-1,"%s#%s"%(names[0],names[1]))

            lv = self.det[names[0]]
            pv = lv[names[1]]
            lv = pv.lvolume()

            for pvname in names[2:]:
                pv = lv[pvname]
                th.insert(index,"%s#%s"%(lv.name(),pv.name()))
                index += 1
                lv = pv.lvolume()
                continue
            continue
        return

    def th2de(self,th):
        "Return the DetectorElement matching the TouchableHistory"

        if not "/dd/Structure" in th[0]:
            print "TouchableHistory not grounded in a structure:",th[0]

            return None
        from GaudiPython import AppMgr
        de = self.det[th.pop(0)]
        return self.find_de(de,th)

    def support_path(self,gi):
        "Returns a list of (lv,pv) tuples that is the support path"
        if not gi.hasSupport(): return []
        support_gi = gi.supportIGeometryInfo()
        rpath = gi.supportPath()
        lv = support_gi.lvolume()

        sp = []
        for depth in range(0,rpath.size()):
            pv = lv.pvolumes()[rpath[depth]]
            sp.append((lv,pv))
            self.out("sp: %d %s#%s"%(depth,lv.name(),pv.name()))
            lv = pv.lvolume()
            continue
        return sp

    def support_check(self,sp,th):
        "Return index of  history the support path sp spans, o.w. -1"

        index = 0
        for lv,pv in sp:
            self.out("lv#pv=%s#%s th[%d]=%s"%(lv.name(),pv.name(),index,th[index]))
            names = th[index].split("#")
            if not lv.name() == names[0]: return -1
            if not pv.name() == names[1]: return -1
            index += 1
            continue
        self.out("passed with index %d"%index)
        return index

    def find_child_de(self,de,th):
        """
        Find the immediate child of de that has a support consistent
        with upper parts of th and remove those parts from th.
        
        """
        self.out("Checking children of %s(%s)"%(de.name(),de.geometry().lvolumeName()))
        self.depth += 1
        children = de.childIDetectorElements()
        for ichild in range(0,children.size()):
            child = children[ichild]
            self.out("child %s(%s)"%(child.name(),child.geometry().lvolumeName()))
            sp = self.support_path(child.geometry())
            index = self.support_check(sp,th)

            if index < 0: continue

            del th[:index]

            self.out("remaining th:\n%s"%"\n".join(th))
            self.depth -= 1
            return child

        self.depth -= 1
        return None
        

    def find_de(self,de,th):
        # Exhausted the th so current DE must be the one
        if not th: return de

        names = th[0].split("#")
        lvname = names.pop(0)

        de_lvname = de.geometry().lvolumeName()

        self.out('de="%s"("%s") th="%s"[%s]'%(de.name(),de_lvname,lvname,",".join(names)))

        if lvname != de_lvname:
            print 'Given mismatched DE and TH top "%s" != "%s"'%(lvname,de_lvname)
            return None

        # The touchable history to match the next child DE
        child_de = self.find_child_de(de,th)
        if child_de: return self.find_de(child_de,th)

        # if we get here, we have reached the end of possible DEs.
        # Pop off the touchable history coresponding to current DE
        th.pop(0)
        return de

        

    def dump_de(self,de,parent_de):
        gi = de.geometry()
        self.out(de.name(),gi.lvolumeName())

        self.depth += 1
        count = 0
        for lv,pv in self.support_path(gi):
            self.out("%d:%s#%s"%(count,lv.name(),pv.name()))
            count += 1
        self.depth -= 1

        self.depth += 2
        children = de.childIDetectorElements()
        for ichild in range(0,children.size()):
            child = children[ichild]
            self.dump_de(child,de)
        self.depth -= 2

        return

    def execute(self):
        print "execute"
        return SUCCESS

    pass



from GaudiPython import AppMgr
app = AppMgr()
app.EvtSel = "NONE"


myalg = MyAlg("MyAlg")
print 'myalg="%s"'%str(myalg)
app.setAlgorithms( [ myalg ] )
print ' running'
app.run(1)

---