XmlDetDesc: /home/dayabay/installs/trunk_2011_04_11_opt/NuWa-trunk/dybgaudi/Detector/XmlDetDesc/python/XmlDetDescGen/PoolPmtStructure/gen.py Source File

00001 #!/usr/bin/env python
00002 
00003 """
00004 Generate Pool PMT Detector Elements.
00005 
00006 This generates the Structure XML for all Pool PMTs into the TDS at
00007 /dd/Structure/PoolPmts and files into DDDB/PoolPmtStructure/*.xml.
00008 
00009 This needs to match the hand-written XML in DDDB/PmtPanel/geometry.xml.
00010 
00011 """
00012 
00013 class PoolPmtStructure:
00014 
00015     sites = ['db', 'la', 'far']
00016 
00017     def write(self,outdir):
00018         from XmlDetDescGen.util import XmlFile, Comment
00019         from XmlDetDescGen.catalog import Catalog
00020         from XmlDetDescGen.reference import Reference
00021         from XmlDetDescGen.util import ExternalEntity
00022 
00023         topcat = Catalog('Structure');
00024         poolcat = Catalog('PoolPmtStructure');
00025         poolcat.refs = []
00026         poolcat.things = []
00027         topcat.refs = [ poolcat ]
00028         topcat.things = []
00029 
00030         ees = []
00031         for site in PoolPmtStructure.sites:
00032             cat = Catalog('%s-pool'%site);
00033             cat.refs=[]
00034             for ipool in PoolPmts.poolcounts:
00035                 eename="%s%spmts"%(site,ipool)
00036                 ees.append((eename,"%s%s.xml"%(site,ipool)))
00037                 cat.refs.append(ExternalEntity(eename))
00038                 continue
00039             poolcat.refs.append(cat)
00040 
00041         file = XmlFile(dtd="../DTD/structure.dtd",
00042                        external_entities=ees)
00043         file.objects = [ poolcat ]
00044         file.write(outdir+"/structure.xml")
00045 
00046 
00047 class PoolPmts:
00048 
00049     lvname="/dd/Geometry/PMT/lvPmtHemiFrame"
00050     siteids = [0x01,0x02,0x04]
00051     poolnums = [(5<<1)|1, (6<<1)|1, 6<<1] # encode detector ID + inwardFacing
00052     poolcounts = ['InnFin','OutFin','OutFout']
00053     wallcounts = [9,    9,   8]
00054     nearInFin = [8,8,24,8,8,8,24,8,20]
00055     nearOutFin = [8,8,16,8,8,8,16,8,29]
00056     nearOutFout = [4,8,12,8,4,8,12,8]
00057     farInFin = [24,8,24,8,24,8,24,8,32]
00058     farOutFin = [16,8,16,8,16,8,16,8,32]
00059     farOutFout = [16,8,16,8,16,8,16,8]
00060     npath=''
00061     support=''
00062     c4=4   ##column with 4 pmts
00063     c3=3   ##column with 3 pmts
00064 
00065     def __init__(self,site,siteid,poolcount,wallcount):
00066         self.site = site
00067         self.siteid = siteid
00068         self.poolcount = poolcount
00069         self.wallcount = wallcount
00070         pass
00071 
00072     # this must match what Conventions/Detectors does
00073     def pmtid(self,site,pooln,iid,iwall):
00074         # shift up pooln by only 15 since it was shifted one bit already
00075         inward = 0
00076         if pooln == 11 or pooln == 13:
00077             inward = 1
00078         return (site<<24)|(pooln&0xffe)<<15|inward<<12|(iwall<<8)|iid
00079 
00080     ##################Near Site npath and support defination ####################
00081 
00082     # tmp1=1,2   tmp2=1,2  tmp3=1,2,3,4
00083     def nearOutFinShort(self,data):
00084         PoolPmts.npath="pvNearOutPTE/pvNearOutPTEFinSide/pvNearShortPanelOutFinSide:%(tmp1)d/pvNearShortPanelOutFinQuad/pvNearShortPanelOutFinUnitPmt/pvShortPanelOutFinPmt:%(tmp2)d/pvVetoPmtOutFIn4:%(tmp3)d/pvVetoPmtUnit"%data
00085         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00086         return
00087 
00088     
00089     #tmp1=1,2   tmp2=1,2  tmp3=1,2  tmp4=1,2,3,4
00090     def nearOutFinCorner(self,data):
00091         PoolPmts.npath="pvNearOutPTE/pvNearOutPTEFinSide/pvNearCornerPanelOutFinSide:%(tmp1)d/pvNearCornerPanelOutFinQuad:%(tmp2)d/pvFarCornerPanelOutFinUnitPmt/pvCornerPanelOutFinPmt:%(tmp3)d/pvVetoPmtOutFIn4:%(tmp4)d/pvVetoPmtUnit"%data
00092         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00093         return
00094 
00095         
00096     #tmp1=1,2   tmp2=1,2,3,4  tmp3=1,2,3,4
00097     def nearOutFinLong(self,data):
00098         PoolPmts.npath="pvNearOutPTE/pvNearOutPTEFinSide/pvNearLongPanelOutFinSide:%(tmp1)d/pvNearLongPanelOutFinQuad/pvFarLongPanelOutFinUnitPmt/pvLongPanelOutFinPmt:%(tmp2)d/pvVetoPmtOutFIn4:%(tmp3)d/pvVetoPmtUnit"%data
00099         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00100         return
00101 
00102     #tmp1=1,2   tmp2=1,2  tmp3=1,2 tmp4=1~12
00103     def nearOutFinBott1(self,data):
00104         PoolPmts.npath="pvNearOutPTE/pvNearOutPTEBott/pvNearOutBott/pvVetoPmtNearOutBott:%(tmp1)d/pvVetoPmtNearOutBottHalf%(tmp2)d:%(tmp3)d/pvVetoPmtOutBot:%(tmp4)d/pvVetoPmtUnit"%data
00105         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00106         return
00107 
00108     #tmp1=3   tmp2=13,14,15,16,17  #for the center line
00109     def nearOutFinBott2(self,data):
00110         PoolPmts.npath="pvNearOutPTE/pvNearOutPTEBott/pvNearOutBott/pvVetoPmtNearOutBott:%(tmp1)d/pvVetoPmtOutBot:%(tmp2)d/pvVetoPmtUnit"%data
00111         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00112         return
00113 
00114     #tmp1=1,2   tmp2=1,2,3,4
00115     def nearOutFoutShort(self,data):
00116         PoolPmts.npath="pvNearOutPTE/pvNearOutPTEFoutSide/pvNearShortPanelOutFoutSide:%(tmp1)d/pvNearShortPanelOutFoutQuad/pvNearShortPanelOutFoutUnitPmt/pvShortPanelOutFoutPmt/pvVetoPmtIn4:%(tmp2)d/pvVetoPmtUnit"%data
00117         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00118         return
00119 
00120     #tmp1=1,2   tmp2=1,2, tmp3=1,2  tmp4=1,2,3,4
00121     def nearOutFoutCorner(self,data):
00122         PoolPmts.npath="pvNearOutPTE/pvNearOutPTEFoutSide/pvNearCornerPanelOutFoutSide:%(tmp1)d/pvNearCornerPanelOutFoutQuad:%(tmp2)d/pvFarCornerPanelOutFoutUnitPmt/pvCornerPanelOutFoutPmt:%(tmp3)d/pvVetoPmtIn4:%(tmp4)d/pvVetoPmtUnit"%data
00123         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00124         return
00125 
00126 
00127     #tmp1=1,2   tmp2=1,2,3 tmp3=1,2,3,4
00128     def nearOutFoutLong(self,data):
00129         PoolPmts.npath="pvNearOutPTE/pvNearOutPTEFoutSide/pvNearLongPanelOutFoutSide:%(tmp1)d/pvNearLongPanelOutFoutQuad/pvNearLongPanelOutFoutUnitPmt/pvNearLongPanelOutFoutPmt:%(tmp2)d/pvVetoPmtIn4:%(tmp3)d/pvVetoPmtUnit"%data
00130         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00131         return
00132 
00133     #tmp1=1,2   tmp2=1,2, tmp3=1,2,3,4
00134     def nearInFinShort(self,data):
00135         PoolPmts.npath="pvNearInPTE/pvNearInPTEFinSide/pvNearShortPanelInFinSide:%(tmp1)d/pvNearShortPanelInFinQuad/pvNearShortPanelInFinUnitPmt/pvShortPanelInFinPmt:%(tmp2)d/pvVetoPmtIn4:%(tmp3)d/pvVetoPmtUnit"%data
00136         PoolPmts.support="/dd/Structure/Pool/%(site)s-iws"%data
00137         return
00138 
00139     #tmp1=1,2 tmp2=1,2 tmp3=1,2 tmp4=1,2,3,4
00140     def nearInFinCorner(self,data):
00141         PoolPmts.npath="pvNearInPTE/pvNearInPTEFinSide/pvNearCornerPanelInFinSide:%(tmp1)d/pvNearCornerPanelInFinQuad:%(tmp2)d/pvFarCornerPanelInFinUnitPmt/pvCornerPanelInFinPmt:%(tmp3)d/pvVetoPmtIn4:%(tmp4)d/pvVetoPmtUnit"%data
00142         PoolPmts.support="/dd/Structure/Pool/%(site)s-iws"%data
00143         return
00144 
00145     #tmp1=1,2 tmp2=2,4,6 tmp3=1,2,3,4
00146     def nearInFinLong1(self,data):
00147         PoolPmts.npath="pvNearInPTE/pvNearInPTEFinSide/pvNearLongPanelInFinSide:%(tmp1)d/pvNearLongPanelInFinQuad/pvFarLongPanelInFinUnitPmt/pvLongPanelInFinPmt:%(tmp2)d/pvVetoPmtIn4:%(tmp3)d/pvVetoPmtUnit"%data
00148         PoolPmts.support="/dd/Structure/Pool/%(site)s-iws"%data
00149         return
00150 
00151     #tmp1=1,2 tmp2=1,3,5,7 tmp3=1,2,3
00152     def nearInFinLong2(self,data):
00153         PoolPmts.npath="pvNearInPTE/pvNearInPTEFinSide/pvNearLongPanelInFinSide:%(tmp1)d/pvNearLongPanelInFinQuad/pvFarLongPanelInFinUnitPmt/pvLongPanelInFinPmt:%(tmp2)d/pvVetoPmtFIn3:%(tmp3)d/pvVetoPmtUnit"%data
00154         PoolPmts.support="/dd/Structure/Pool/%(site)s-iws"%data
00155         return
00156 
00157     #tmp1=1,2 tmp2=1,2, tmp3=1,2, tmp4=1~10
00158     def nearInFinBott(self,data):
00159         PoolPmts.npath="pvNearInPTE/pvNearInPTEBott/pvNearInBott/pvVetoPmtNearInBott:%(tmp1)d/pvVetoPmtNearInBottHalf%(tmp2)d:%(tmp3)d/pvVetoPmtInBot:%(tmp4)d/pvVetoPmtUnit"%data
00160         PoolPmts.support="/dd/Structure/Pool/%(site)s-iws"%data
00161         return
00162 
00163     ##################Far Site npath and support defination ####################
00164 
00165     #tmp1=1,2,3,4   tmp2=1,2,3,4  tmp3=1,2,3,4
00166     def farOutFinLong(self,data):
00167         PoolPmts.npath="pvFarOutPTE/pvFarOutPTEFinSide/pvLongPanelOutFinSide:%(tmp1)d/pvFarLongPanelOutFinQuad/pvFarLongPanelOutFinUnitPmt/pvLongPanelOutFinPmt:%(tmp2)d/pvVetoPmtOutFIn4:%(tmp3)d/pvVetoPmtUnit"%data
00168         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00169         return
00170 
00171     #tmp1=1,2,3,4   tmp2=1,2   tmp3=1,2,3,4
00172     def farOutFinCorner(self,data):
00173         PoolPmts.npath="pvFarOutPTE/pvFarOutPTEFinSide/pvCornerPanelOutFinSide:%(tmp1)d/pvFarCornerPanelOutFinQuad/pvFarCornerPanelOutFinUnitPmt/pvCornerPanelOutFinPmt:%(tmp2)d/pvVetoPmtOutFIn4:%(tmp3)d/pvVetoPmtUnit"%data
00174         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00175         return
00176         
00177     #tmp1=1,2,3,4   tmp2=1,2,3,4,5,6,7 
00178     def farOutFinBott1(self,data):
00179         PoolPmts.npath="pvFarOutPTE/pvFarOutPTEBott/pvFarOutBott/pvVetoPmtFarOutBott:%(tmp1)d/pvVetoPmtOutBotF:%(tmp2)d/pvVetoPmtUnit"%data
00180         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00181         return
00182 
00183     #tmp1=5   tmp2=8,9,10,11   #for the center 
00184     def farOutFinBott2(self,data):
00185         PoolPmts.npath="pvFarOutPTE/pvFarOutPTEBott/pvFarOutBott/pvVetoPmtFarOutBott:%(tmp1)d/pvVetoPmtOutBotF:%(tmp2)d/pvVetoPmtUnit"%data
00186         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00187         return
00188 
00189     #tmp1=1,2,3,4   tmp2=1,2,3,4 tmp3=1,2,3,4
00190     def farOutFoutLong(self,data):
00191         PoolPmts.npath="pvFarOutPTE/pvFarOutPTEFoutSide/pvFarLongPanelOutFoutSide:%(tmp1)d/pvFarLongPanelOutFoutQuad/pvFarLongPanelOutFoutUnitPmt/pvFarLongPanelOutFoutPmt:%(tmp2)d/pvVetoPmtIn4:%(tmp3)d/pvVetoPmtUnit"%data
00192         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00193         return
00194 
00195     #tmp1=1,2,3,4   tmp2=1,2, tmp3=1,2,3,4
00196     def farOutFoutCorner(self,data):
00197         PoolPmts.npath="pvFarOutPTE/pvFarOutPTEFoutSide/pvFarCornerPanelOutFoutSide:%(tmp1)d/pvFarCornerPanelOutFoutQuad/pvFarCornerPanelOutFoutUnitPmt/pvCornerPanelOutFoutPmt:%(tmp2)d/pvVetoPmtIn4:%(tmp3)d/pvVetoPmtUnit"%data
00198         PoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00199         return
00200 
00201     #tmp1=1,2,3,4 tmp2=2,4,6 tmp3=1,2,3,4
00202     def farInFinLong1(self,data):
00203         PoolPmts.npath="pvFarInPTE/pvFarInPTEFinSide/pvLongPanelInFinSide:%(tmp1)d/pvFarLongPanelInFinQuad/pvFarLongPanelInFinUnitPmt/pvLongPanelInFinPmt:%(tmp2)d/pvVetoPmtIn4:%(tmp3)d/pvVetoPmtUnit"%data
00204         PoolPmts.support="/dd/Structure/Pool/%(site)s-iws"%data
00205         return
00206 
00207     #tmp1=1,2,3,4 tmp2=1,3,5,7 tmp3=1,2,3
00208     def farInFinLong2(self,data):
00209         PoolPmts.npath="pvFarInPTE/pvFarInPTEFinSide/pvLongPanelInFinSide:%(tmp1)d/pvFarLongPanelInFinQuad/pvFarLongPanelInFinUnitPmt/pvLongPanelInFinPmt:%(tmp2)d/pvVetoPmtFIn3:%(tmp3)d/pvVetoPmtUnit"%data
00210         PoolPmts.support="/dd/Structure/Pool/%(site)s-iws"%data
00211         return
00212 
00213     #tmp1=1,2,3,4 tmp2=1,2 tmp3=1,2,3,4
00214     def farInFinCorner(self,data):
00215         PoolPmts.npath="pvFarInPTE/pvFarInPTEFinSide/pvCornerPanelInFinSide:%(tmp1)d/pvFarCornerPanelInFinQuad/pvFarCornerPanelInFinUnitPmt/pvCornerPanelInFinPmt:%(tmp2)d/pvVetoPmtIn4:%(tmp3)d/pvVetoPmtUnit"%data
00216         PoolPmts.support="/dd/Structure/Pool/%(site)s-iws"%data
00217         return
00218 
00219     #tmp1=1,2,3,4  tmp2=1~7
00220     def farInFinBott1(self,data):
00221         PoolPmts.npath="pvFarInPTE/pvFarInPTEBott/pvFarInBott/pvVetoPmtFarInBott:%(tmp1)d/pvVetoPmtInBotF:%(tmp2)d/pvVetoPmtUnit"%data
00222         PoolPmts.support="/dd/Structure/Pool/%(site)s-iws"%data
00223         return
00224 
00225     #tmp1=5  tmp2=8,9,10,11
00226     def farInFinBott2(self,data):
00227         PoolPmts.npath="pvFarInPTE/pvFarInPTEBott/pvFarInBott/pvVetoPmtFarInBott:%(tmp1)d/pvVetoPmtInBotF:%(tmp2)d/pvVetoPmtUnit"%data
00228         PoolPmts.support="/dd/Structure/Pool/%(site)s-iws"%data
00229         return
00230     
00231     ###################Write PMT ID one by one on each wall ##################
00232 
00233     #########Near Site Pool #########
00234     #### Inner Face in ##########
00235     def fillNearInShort(self,iid,data):
00236         if iid<=4:
00237             data['tmp2']=1
00238             data['tmp3']=iid
00239         elif iid<=8 and iid>=5:
00240             data['tmp2']=2
00241             data['tmp3']=iid-PoolPmts.c4
00242         else:
00243             print 'iid=%d',iid
00244             print "find error 1"
00245             sys.exit(1)
00246         self.nearInFinShort(data)
00247         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00248         
00249 
00250     def fillNearInCorner(self,iid,data):
00251         if iid<=4:
00252             data['tmp3']=1
00253             data['tmp4']=iid
00254         elif iid<=8 and iid>=5:
00255             data['tmp3']=2
00256             data['tmp4']=iid-PoolPmts.c4
00257         else:
00258             print "find error 2"
00259             sys.exit(1)
00260         self.nearInFinCorner(data)
00261         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00262 
00263     def fillNearInLong(self,iid,data):
00264         if iid<=3:
00265             data['tmp2']=1
00266             data['tmp3']=iid
00267             self.nearInFinLong2(data)
00268         elif iid<=7 and iid>=4:
00269             data['tmp2']=2
00270             data['tmp3']=iid-PoolPmts.c3
00271             self.nearInFinLong1(data)
00272         elif iid>=8 and iid<=10:
00273             data['tmp2']=3
00274             data['tmp3']=iid-PoolPmts.c4-PoolPmts.c3
00275             self.nearInFinLong2(data)
00276         elif iid<=14 and iid>=11:
00277             data['tmp2']=4
00278             data['tmp3']=iid-PoolPmts.c4-2*PoolPmts.c3
00279             self.nearInFinLong1(data)
00280         elif iid>=15 and iid<=17:
00281             data['tmp2']=5
00282             data['tmp3']=iid-2*PoolPmts.c4-2*PoolPmts.c3
00283             self.nearInFinLong2(data)
00284         elif iid<=21 and iid>=18:
00285             data['tmp2']=6
00286             data['tmp3']=iid-2*PoolPmts.c4-3*PoolPmts.c3
00287             self.nearInFinLong1(data)
00288         elif iid>=22 and iid<=24:
00289             data['tmp2']=7
00290             data['tmp3']=iid-3*PoolPmts.c4-3*PoolPmts.c3
00291             self.nearInFinLong2(data)
00292         else:
00293             print "find error 3"
00294             sys.exit(1)
00295         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00296             
00297 
00298     def fillNearInBot(self,iid,data):
00299         if iid<=5:
00300             data['tmp1']=data['tmp2']=data['tmp3']=1
00301             data['tmp4']=iid;
00302         elif 6<=iid<=10:
00303             data['tmp1']=data['tmp2']=2
00304             data['tmp3']=1
00305             data['tmp4']=iid;
00306         elif 11<=iid<=15:
00307             data['tmp1']=data['tmp2']=1
00308             data['tmp3']=2
00309             data['tmp4']=iid-10;
00310         elif 16<=iid<=20:
00311             data['tmp1']=data['tmp2']=data['tmp3']=2
00312             data['tmp4']=iid-10;
00313         else:
00314             print "find error 4"
00315             sys.exit(1)
00316         self.nearInFinBott(data)
00317         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00318         return
00319 
00320     #####Outer face in #######
00321     
00322     def fillNearOutFinShort(self,iid,data):
00323         if iid<=4:
00324             data['tmp2']=1
00325             data['tmp3']=iid
00326         elif iid<=8 and iid>=5:
00327             data['tmp2']=2
00328             data['tmp3']=iid-PoolPmts.c4
00329         else:
00330             print 'iid=%d',iid
00331             print "find error 5"
00332             sys.exit(1)
00333         self.nearOutFinShort(data)
00334         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00335         return
00336     
00337     def fillNearOutFinCorner(self,iid,data):
00338         if iid<=4:
00339             data['tmp3']=1
00340             data['tmp4']=iid
00341         elif iid<=8 and iid>=5:
00342             data['tmp3']=2
00343             data['tmp4']=iid-PoolPmts.c4
00344         else:
00345             print 'iid=%d',iid
00346             print "find error 6"
00347             sys.exit(1)
00348         self.nearOutFinCorner(data)
00349         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00350         return
00351 
00352     def fillNearOutFinLong(self,iid,data):
00353         if iid<=4:
00354             data['tmp2']=1
00355             data['tmp3']=iid
00356         elif iid<=8 and iid>=5:
00357             data['tmp2']=2
00358             data['tmp3']=iid-PoolPmts.c4
00359         elif iid<=12 and iid>=9:
00360             data['tmp2']=3
00361             data['tmp3']=iid-2*PoolPmts.c4
00362         elif iid<=16 and iid>=13:
00363             data['tmp2']=4
00364             data['tmp3']=iid-3*PoolPmts.c4
00365         else:
00366             print 'iid=%d',iid
00367             print "find error 7"
00368             sys.exit(1)
00369         self.nearOutFinLong(data)
00370         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00371         return
00372 
00373    
00374     def fillNearOutFinBot(self,iid,data):
00375         if iid<=24:
00376             if iid<=6:
00377                 data['tmp1']=data['tmp2']=data['tmp3']=1
00378                 data['tmp4']=iid;
00379             elif 7<=iid<=12:
00380                 data['tmp1']=data['tmp2']=2
00381                 data['tmp3']=1
00382                 data['tmp4']=iid;
00383             elif 13<=iid<=18:
00384                 data['tmp1']=data['tmp2']=1
00385                 data['tmp3']=2
00386                 data['tmp4']=iid-12;
00387             elif 19<=iid<=24:
00388                 data['tmp1']=data['tmp2']=data['tmp3']=2
00389                 data['tmp4']=iid-12;
00390             else:
00391                 print "find error 4"
00392                 sys.exit(1)
00393             self.nearOutFinBott1(data)
00394                 
00395         elif iid<=29 and iid>=25:
00396             data['tmp1']=3
00397             data['tmp2']=iid-12
00398             self.nearOutFinBott2(data)
00399         else:
00400             print 'iid=%d',iid
00401             print "find error 8"
00402             sys.exit(1)
00403             data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00404         return
00405     
00406     ######Out face out#########
00407     
00408     def fillNearOutFoutShort(self,iid,data):
00409         if iid<=4:
00410             data['tmp2']=iid
00411         else:
00412             print 'iid=%d',iid
00413             print "find error 9"
00414             sys.exit(1)
00415         self.nearOutFoutShort(data)
00416         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00417         return
00418 
00419     def fillNearOutFoutCorner(self,iid,data):
00420         if iid<=4:
00421             data['tmp3']=1
00422             data['tmp4']=iid
00423         elif iid<=8 and iid>=5:
00424             data['tmp3']=2
00425             data['tmp4']=iid-PoolPmts.c4
00426         else:
00427             print 'iid=%d',iid
00428             print "find error 10"
00429             sys.exit(1)
00430         self.nearOutFoutCorner(data)
00431         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00432         return
00433 
00434 
00435     def fillNearOutFoutLong(self,iid,data):
00436         if iid<=4:
00437             data['tmp2']=1
00438             data['tmp3']=iid
00439         elif iid<=8 and iid>=5:
00440             data['tmp2']=2
00441             data['tmp3']=iid-PoolPmts.c4
00442         elif iid<=12 and iid>=9:
00443             data['tmp2']=3
00444             data['tmp3']=iid-2*PoolPmts.c4
00445         else:
00446             print 'iid=%d',iid
00447             print "find error 11"
00448             sys.exit(1)
00449         self.nearOutFoutLong(data)
00450         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00451         return
00452     
00453     ######### Far Site Pool #########    
00454     ####### Inner face in #######
00455     def fillFarInLong(self,iid,data):
00456         if iid<=3:
00457             data['tmp2']=1
00458             data['tmp3']=iid
00459             self.farInFinLong2(data)
00460         elif iid<=7 and iid>=4:
00461             data['tmp2']=2
00462             data['tmp3']=iid-PoolPmts.c3
00463             self.farInFinLong1(data)
00464         elif iid>=8 and iid<=10:
00465             data['tmp2']=3
00466             data['tmp3']=iid-PoolPmts.c4-PoolPmts.c3
00467             self.farInFinLong2(data)
00468         elif iid<=14 and iid>=11:
00469             data['tmp2']=4
00470             data['tmp3']=iid-PoolPmts.c4-2*PoolPmts.c3
00471             self.farInFinLong1(data)
00472         elif iid>=15 and iid<=17:
00473             data['tmp2']=5
00474             data['tmp3']=iid-2*PoolPmts.c4-2*PoolPmts.c3
00475             self.farInFinLong2(data)
00476         elif iid<=21 and iid>=18:
00477             data['tmp2']=6
00478             data['tmp3']=iid-2*PoolPmts.c4-3*PoolPmts.c3
00479             self.farInFinLong1(data)
00480         elif iid>=22 and iid<=24:
00481             data['tmp2']=7
00482             data['tmp3']=iid-3*PoolPmts.c4-3*PoolPmts.c3
00483             self.farInFinLong2(data)
00484         else:
00485             print "find error 12"
00486             sys.exit(1)
00487         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00488         return
00489 
00490     def fillFarInCorner(self,iid,data):
00491         if iid<=4:
00492             data['tmp2']=1
00493             data['tmp3']=iid
00494         elif iid<=8 and iid>=5:
00495             data['tmp2']=2
00496             data['tmp3']=iid-PoolPmts.c4
00497         else:
00498             print 'iid=%d',iid
00499             print "find error 13"
00500             sys.exit(1)
00501         self.farInFinCorner(data)
00502         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00503         return
00504 
00505     def fillFarInBot(self,iid,data):
00506         if iid<=28:
00507             if iid<=7:
00508                 data['tmp1']=1
00509                 data['tmp2']=iid
00510             elif iid>=8 and iid<=14:
00511                 data['tmp1']=2
00512                 data['tmp2']=iid-7
00513             elif iid>=15 and iid<=21:
00514                 data['tmp1']=3
00515                 data['tmp2']=iid-2*7
00516             elif iid>=22 and iid<=28:
00517                 data['tmp1']=4
00518                 data['tmp2']=iid-3*7
00519             self.farInFinBott1(data)
00520         elif iid<=32 and iid>=29:
00521             data['tmp1']=5
00522             data['tmp2']=iid-21
00523             self.farInFinBott2(data)
00524         else:
00525             print 'iid=%d',iid
00526             print "find error 14"
00527             sys.exit(1)
00528         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00529         return
00530 
00531     ### Outer face in ########
00532     def fillFarOutFinLong(self,iid,data):
00533         if iid<=4:
00534             data['tmp2']=1
00535             data['tmp3']=iid
00536         elif iid<=8 and iid>=5:
00537             data['tmp2']=2
00538             data['tmp3']=iid-PoolPmts.c4
00539         elif iid<=12 and iid>=9:
00540             data['tmp2']=3
00541             data['tmp3']=iid-2*PoolPmts.c4
00542         elif iid<=16 and iid>=13:
00543             data['tmp2']=4
00544             data['tmp3']=iid-3*PoolPmts.c4
00545         else:
00546             print 'iid=%d',iid
00547             print "find error 15"
00548             sys.exit(1)
00549         self.farOutFinLong(data)
00550         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00551         return
00552 
00553     def fillFarOutFinCorner(self,iid,data):
00554         if iid<=4:
00555             data['tmp2']=1
00556             data['tmp3']=iid
00557         elif iid<=8 and iid>=5:
00558             data['tmp2']=2
00559             data['tmp3']=iid-PoolPmts.c4
00560         else:
00561             print 'iid=%d',iid
00562             print "find error 16"
00563             sys.exit(1)
00564         self.farOutFinCorner(data)
00565         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00566         return
00567 
00568 
00569     def fillFarOutFinBot(self,iid,data):
00570         if iid<=28:
00571             if iid<=7:
00572                 data['tmp1']=1
00573                 data['tmp2']=iid
00574             elif iid>=8 and iid<=14:
00575                 data['tmp1']=2
00576                 data['tmp2']=iid-7
00577             elif iid>=15 and iid<=21:
00578                 data['tmp1']=3
00579                 data['tmp2']=iid-2*7
00580             elif iid>=22 and iid<=28:
00581                 data['tmp1']=4
00582                 data['tmp2']=iid-3*7
00583             self.farOutFinBott1(data)
00584             
00585         elif iid<=32 and iid>=29:
00586             data['tmp1']=5
00587             data['tmp2']=iid-21
00588             self.farOutFinBott2(data)
00589 
00590         else:
00591             print 'iid=%d',iid
00592             print "find error 17"
00593             sys.exit(1)
00594         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00595         return
00596 
00597     ###### Outer face out ####
00598 
00599     def fillFarOutFoutLong(self,iid,data):
00600         if iid<=4:
00601             data['tmp2']=1
00602             data['tmp3']=iid
00603         elif iid<=8 and iid>=5:
00604             data['tmp2']=2
00605             data['tmp3']=iid-PoolPmts.c4
00606         elif iid<=12 and iid>=9:
00607             data['tmp2']=3
00608             data['tmp3']=iid-2*PoolPmts.c4
00609         elif iid<=16 and iid>=13:
00610             data['tmp2']=4
00611             data['tmp3']=iid-3*PoolPmts.c4
00612         else:
00613             print 'iid=%d',iid
00614             print "find error 18"
00615             sys.exit(1)
00616         self.farOutFoutLong(data)
00617         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00618         return
00619 
00620     def fillFarOutFoutCorner(self,iid,data):
00621         if iid<=4:
00622             data['tmp2']=1
00623             data['tmp3']=iid
00624         elif iid<=8 and iid>=5:
00625             data['tmp2']=2
00626             data['tmp3']=iid-PoolPmts.c4
00627         else:
00628             print 'iid=%d',iid
00629             print "find error 19"
00630             sys.exit(1)
00631         self.farOutFoutCorner(data)
00632         data['tmp1']=data['tmp2']=data['tmp3']=data['tmp4']=0
00633         return
00634 
00635     
00636     def write(self,outdir):
00637         from XmlDetDescGen.util import XmlFile, Comment
00638         from XmlDetDescGen.structure import DetElem,UserParameter
00639 
00640         for poolp, pooln, walln in zip(PoolPmts.poolcounts,PoolPmts.poolnums,PoolPmts.wallcounts):
00641 
00642             pmts = []
00643 
00644 
00645             for iwall in range(0,walln): #max wallcount=9
00646                 
00647                 iwall += 1
00648 
00649                 if (site=='db') | (site=='la'):
00650                     if poolp==PoolPmts.poolcounts[0]:
00651                         ipmt =  PoolPmts.nearInFin[iwall-1]
00652                     elif poolp==PoolPmts.poolcounts[1]:
00653                         ipmt =  PoolPmts.nearOutFin[iwall-1]
00654                     elif poolp==PoolPmts.poolcounts[2]:
00655                         ipmt =  PoolPmts.nearOutFout[iwall-1]
00656                     else:
00657                         print "error found in near pool,exit"
00658                         sys.exit(1)
00659                     
00660                 elif site=='far':
00661                     if poolp==PoolPmts.poolcounts[0]:
00662                         ipmt =  PoolPmts.farInFin[iwall-1]
00663                     elif poolp==PoolPmts.poolcounts[1]:
00664                         ipmt =  PoolPmts.farOutFin[iwall-1]
00665                     elif poolp==PoolPmts.poolcounts[2]:
00666                         ipmt =  PoolPmts.farOutFout[iwall-1]
00667                     else:
00668                         print "error found in far pool,exit"
00669                         sys.exit(1)
00670 
00671                 #print "Number of PMT in this wall is %d"%ipmt
00672 
00673 
00674                 for iid in range(0,ipmt): #pmt number in that wall
00675                     iid += 1
00676                 
00677                     pmtid = self.pmtid(siteid,pooln,iid,iwall)
00678 
00679                     ####tmp1,2,3,4 are paramphy index numbers for different walls
00680                     tmp1=tmp2=tmp3=tmp4=0
00681                     
00682                     data = { 'site':site,'siteid':siteid,'poolpv':poolp,'poolnum':pooln,'wallnum':iwall,
00683                              'idnum':iid,'pmtid':pmtid,'tmp1':tmp1,'tmp2':tmp2,'tmp3':tmp3,'tmp4':tmp4 }
00684                     
00685                     if (site=='db') | (site=='la'):
00686                         if poolp==PoolPmts.poolcounts[0]:
00687                             if iwall==1:
00688                                 data['tmp1']=1
00689                                 self.fillNearInShort(iid,data)
00690 
00691                             elif iwall==2:
00692                                 data['tmp1']=data['tmp2']=1
00693                                 self.fillNearInCorner(iid,data)
00694                                 
00695                             elif iwall==3:
00696                                 data['tmp1']=1
00697                                 self.fillNearInLong(iid,data)
00698 
00699                             elif iwall==4:
00700                                 data['tmp1']=1
00701                                 data['tmp2']=2
00702                                 self.fillNearInCorner(iid,data)
00703 
00704                             elif iwall==5:
00705                                 data['tmp1']=2
00706                                 self.fillNearInShort(iid,data)
00707 
00708                             elif iwall==6:
00709                                 data['tmp1']=2
00710                                 data['tmp2']=1
00711                                 self.fillNearInCorner(iid,data)
00712 
00713                             elif iwall==7:
00714                                 data['tmp1']=2
00715                                 self.fillNearInLong(iid,data)
00716                                 
00717                             elif iwall==8:
00718                                 data['tmp1']=2
00719                                 data['tmp2']=2
00720                                 self.fillNearInCorner(iid,data)
00721                             elif iwall==9:
00722                                 self.fillNearInBot(iid,data)
00723                             else:
00724                                 print "error find in Near Inn face-in"
00725                                 sys.exit(1)
00726 
00727                         elif poolp==PoolPmts.poolcounts[1]:
00728                             if iwall==1:
00729                                 data['tmp1']=1
00730                                 self.fillNearOutFinShort(iid,data)
00731 
00732                             elif iwall==2:
00733                                 data['tmp1']=data['tmp2']=1
00734                                 self.fillNearOutFinCorner(iid,data)
00735                                 
00736                             elif iwall==3:
00737                                 data['tmp1']=1
00738                                 self.fillNearOutFinLong(iid,data)
00739 
00740                             elif iwall==4:
00741                                 data['tmp1']=1
00742                                 data['tmp2']=2
00743                                 self.fillNearOutFinCorner(iid,data)
00744 
00745                             elif iwall==5:
00746                                 data['tmp1']=2
00747                                 self.fillNearOutFinShort(iid,data)
00748 
00749                             elif iwall==6:
00750                                 data['tmp1']=2
00751                                 data['tmp2']=1
00752                                 self.fillNearOutFinCorner(iid,data)
00753 
00754                             elif iwall==7:
00755                                 data['tmp1']=2
00756                                 self.fillNearOutFinLong(iid,data)
00757                                 
00758                             elif iwall==8:
00759                                 data['tmp1']=2
00760                                 data['tmp2']=2
00761                                 self.fillNearOutFinCorner(iid,data)
00762                                 
00763                             elif iwall==9:
00764                                 self.fillNearOutFinBot(iid,data)
00765 
00766                             else:
00767                                 print "error find in Near Out face-in"
00768                                 sys.exit(1)
00769                             
00770                         elif poolp==PoolPmts.poolcounts[2]:
00771                             if iwall==1:
00772                                 data['tmp1']=1
00773                                 self.fillNearOutFoutShort(iid,data)
00774 
00775                             elif iwall==2:
00776                                 data['tmp1']=data['tmp2']=1
00777                                 self.fillNearOutFoutCorner(iid,data)
00778                                 
00779                             elif iwall==3:
00780                                 data['tmp1']=1
00781                                 self.fillNearOutFoutLong(iid,data)
00782 
00783                             elif iwall==4:
00784                                 data['tmp1']=1
00785                                 data['tmp2']=2
00786                                 self.fillNearOutFoutCorner(iid,data)
00787 
00788                             elif iwall==5:
00789                                 data['tmp1']=2
00790                                 self.fillNearOutFoutShort(iid,data)
00791 
00792                             elif iwall==6:
00793                                 data['tmp1']=2
00794                                 data['tmp2']=1
00795                                 self.fillNearOutFoutCorner(iid,data)
00796 
00797                             elif iwall==7:
00798                                 data['tmp1']=2
00799                                 self.fillNearOutFoutLong(iid,data)
00800                                 
00801                             elif iwall==8:
00802                                 data['tmp1']=2
00803                                 data['tmp2']=2
00804                                 self.fillNearOutFoutCorner(iid,data)
00805                             else:
00806                                 print "error find in Near Out face-out"
00807                                 sys.exit(1)
00808 
00809                             
00810                     elif site=='far':
00811                         if poolp==PoolPmts.poolcounts[0]:
00812                             if iwall==1:
00813                                 data['tmp1']=1
00814                                 self.fillFarInLong(iid,data)
00815 
00816                             elif iwall==2:
00817                                 data['tmp1']=1
00818                                 self.fillFarInCorner(iid,data)
00819                                 
00820                             elif iwall==3:
00821                                 data['tmp1']=2
00822                                 self.fillFarInLong(iid,data)
00823 
00824                             elif iwall==4:
00825                                 data['tmp1']=2
00826                                 self.fillFarInCorner(iid,data)
00827 
00828                             elif iwall==5:
00829                                 data['tmp1']=3
00830                                 self.fillFarInLong(iid,data)
00831 
00832                             elif iwall==6:
00833                                 data['tmp1']=3
00834                                 self.fillFarInCorner(iid,data)
00835 
00836                             elif iwall==7:
00837                                 data['tmp1']=4
00838                                 self.fillFarInLong(iid,data)
00839                                 
00840                             elif iwall==8:
00841                                 data['tmp1']=4
00842                                 self.fillFarInCorner(iid,data)
00843 
00844                             elif iwall==9:
00845                                 self.fillFarInBot(iid,data)
00846 
00847                             else:
00848                                 print "error find in Far Inn face-in"
00849                                 sys.exit(1)
00850 
00851                             
00852                         elif poolp==PoolPmts.poolcounts[1]:
00853                             if iwall==1:
00854                                 data['tmp1']=1
00855                                 self.fillFarOutFinLong(iid,data)
00856 
00857                             elif iwall==2:
00858                                 data['tmp1']=1
00859                                 self.fillFarOutFinCorner(iid,data)
00860                                 
00861                             elif iwall==3:
00862                                 data['tmp1']=2
00863                                 self.fillFarOutFinLong(iid,data)
00864 
00865                             elif iwall==4:
00866                                 data['tmp1']=2
00867                                 self.fillFarOutFinCorner(iid,data)
00868 
00869                             elif iwall==5:
00870                                 data['tmp1']=3
00871                                 self.fillFarOutFinLong(iid,data)
00872 
00873                             elif iwall==6:
00874                                 data['tmp1']=3
00875                                 self.fillFarOutFinCorner(iid,data)
00876 
00877                             elif iwall==7:
00878                                 data['tmp1']=4
00879                                 self.fillFarOutFinLong(iid,data)
00880                                 
00881                             elif iwall==8:
00882                                 data['tmp1']=4
00883                                 self.fillFarOutFinCorner(iid,data)
00884 
00885                             elif iwall==9:
00886                                 self.fillFarOutFinBot(iid,data)
00887 
00888                             else:
00889                                 print "error find in Far Out face-in"
00890                                 sys.exit(1)
00891 
00892                         elif poolp==PoolPmts.poolcounts[2]:
00893                             if iwall==1:
00894                                 data['tmp1']=1
00895                                 self.fillFarOutFoutLong(iid,data)
00896 
00897                             elif iwall==2:
00898                                 data['tmp1']=1
00899                                 self.fillFarOutFoutCorner(iid,data)
00900                                 
00901                             elif iwall==3:
00902                                 data['tmp1']=2
00903                                 self.fillFarOutFoutLong(iid,data)
00904 
00905                             elif iwall==4:
00906                                 data['tmp1']=2
00907                                 self.fillFarOutFoutCorner(iid,data)
00908 
00909                             elif iwall==5:
00910                                 data['tmp1']=3
00911                                 self.fillFarOutFoutLong(iid,data)
00912 
00913                             elif iwall==6:
00914                                 data['tmp1']=3
00915                                 self.fillFarOutFoutCorner(iid,data)
00916 
00917                             elif iwall==7:
00918                                 data['tmp1']=4
00919                                 self.fillFarOutFoutLong(iid,data)
00920                                 
00921                             elif iwall==8:
00922                                 data['tmp1']=4
00923                                 self.fillFarOutFoutCorner(iid,data)
00924                             else:
00925                                 print "error find in Far Out face-out"
00926                                 sys.exit(1)
00927 
00928                         else:
00929                             print "error found in far pool,exit"
00930                             sys.exit(1)
00931 
00932                     de = DetElem('%(site)s-%(poolpv)s-wall%(wallnum)d-id%(idnum)d'%data,
00933                                  self.lvname, PoolPmts.npath, PoolPmts.support)
00934                     
00935                     de.refs = [UserParameter("PmtID","int",['0x%x'%pmtid],desc="Packed PMT ID")]
00936                     
00937                     pmts.append(de)
00938                     continue
00939                 continue
00940 
00941             file = XmlFile()
00942             file.objects = pmts
00943             file.write(outdir+"/%s%s.xml"%(self.site,poolp))
00944             continue
00945 
00946 #---------------------------------------------------------------
00947 class NearPoolPmts:
00948 
00949     lvname="/dd/Geometry/PMT/lvPmtHemiFrame"
00950     siteids = [0x01,0x02,0x04]
00951     poolnums = [(5<<1)|1, (6<<1)|1, 6<<1] # encode detector ID + inwardFacing
00952     poolcounts = ['InnFin','OutFin','OutFout']
00953     wallcounts = [9,    9,   8]
00954     nearInFin = [10,8,24,8,10,8,24,8,21]
00955     nearOutFin = [8,8,16,8,8,8,16,8,23]
00956     nearOutFout = [4,8,12,8,4,8,12,8]
00957     npath=''
00958     support=''
00959 
00960     def __init__(self,site,siteid,poolcount,wallcount):
00961         self.site = site
00962         self.siteid = siteid
00963         self.poolcount = poolcount
00964         self.wallcount = wallcount
00965         pass
00966 
00967     # this must match what Conventions/Detectors does
00968     def pmtid(self,site,pooln,iid,iwall):
00969         # shift up pooln by only 15 since it was shifted one bit already
00970         inward = 0
00971         if pooln == 11 or pooln == 13:
00972             inward = 1
00973         return (site<<24)|(pooln&0xffe)<<15|inward<<12|(iwall<<8)|iid
00974 
00975     def fill(self,data):
00976         if data["poolnum"] == 11:
00977             NearPoolPmts.npath="pvVetoPmtNearInn/pvNearInnWall%(wallnum)d/pvNearInnWall%(wallnum)d:%(idnum)d/pvVetoPmtUnit"%data
00978             NearPoolPmts.support="/dd/Structure/Pool/%(site)s-iws"%data
00979         elif data["poolnum"] == 12:
00980             NearPoolPmts.npath="pvVetoPmtNearOutFaceout/pvNearOutFaceoutWall%(wallnum)d/pvNearOutFaceoutWall%(wallnum)d:%(idnum)d/pvVetoPmtUnit"%data
00981             NearPoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00982         elif data["poolnum"] == 13:
00983             NearPoolPmts.npath="pvVetoPmtNearOutFacein/pvNearOutFaceinWall%(wallnum)d/pvNearOutFaceinWall%(wallnum)d:%(idnum)d/pvVetoPmtUnit"%data
00984             NearPoolPmts.support="/dd/Structure/Pool/%(site)s-ows"%data
00985         return
00986     
00987     def write(self,outdir):
00988         from XmlDetDescGen.util import XmlFile, Comment
00989         from XmlDetDescGen.structure import DetElem,UserParameter
00990 
00991         for poolp, pooln, walln in zip(NearPoolPmts.poolcounts,NearPoolPmts.poolnums,NearPoolPmts.wallcounts):
00992 
00993             pmts = []
00994             for iwall in range(0,walln): #max wallcount=9
00995                 iwall += 1
00996                 counts = []
00997                 if pooln == 11:
00998                     counts = NearPoolPmts.nearInFin
00999                 if pooln == 12:
01000                     counts = NearPoolPmts.nearOutFout
01001                 if pooln == 13:
01002                     counts = NearPoolPmts.nearOutFin
01003                 for iid in range(0, counts[iwall-1]): #pmt number in that wall
01004                     iid += 1
01005                     
01006                     pmtid = self.pmtid(siteid,pooln,iid,iwall)
01007                     
01008                     data = { 'site':site,'siteid':siteid,'poolpv':poolp,'poolnum':pooln,'wallnum':iwall,'idnum':iid,'pmtid':pmtid}
01009 
01010                     self.fill(data)
01011 
01012                     de = DetElem('%(site)s-%(poolpv)s-Wall%(wallnum)d-No%(idnum)d'%data,
01013                                  self.lvname, NearPoolPmts.npath, NearPoolPmts.support)
01014                     
01015                     de.refs = [UserParameter("PmtID","int",['0x%x'%pmtid],desc="Packed PMT ID")]
01016                     
01017                     pmts.append(de)
01018                     continue
01019                 continue
01020 
01021             file = XmlFile()
01022             file.objects = pmts
01023             file.write(outdir+"/%s%s.xml"%(self.site,poolp))
01024             continue
01025 #-----------------------------------------------------
01026                              
01027 if '__main__' == __name__:
01028 
01029     import sys,os
01030     try:
01031         xddroot = sys.argv[1]
01032     except IndexError:
01033         xddroot = os.getenv("XMLDETDESCROOT")
01034 
01035     if not xddroot:
01036         print "No XMLDETDESCROOT directory given by environment or command line"
01037         print "Using current working directory"
01038         xddroot="."
01039 
01040     outdir=xddroot + "/DDDB/PoolPmtStructure"
01041     if not os.path.exists(outdir):
01042         print "Directory does not exist, please make first"
01043         print outdir
01044         sys.exit(1)
01045 
01046 
01047     for site,siteid,poolcount,wallcount in zip(PoolPmtStructure.sites,PoolPmts.siteids,PoolPmts.poolcounts,PoolPmts.wallcounts):
01048         aps = PoolPmts(site,siteid,poolcount,wallcount)
01049         aps.write(outdir)
01050         pass
01051     sites = ['db','la']
01052     for site,siteid,poolcount,wallcount in zip(sites,NearPoolPmts.siteids,NearPoolPmts.poolcounts,NearPoolPmts.wallcounts):
01053         aps = NearPoolPmts(site,siteid,poolcount,wallcount)
01054         aps.write(outdir)
01055 
01056     aps = PoolPmtStructure()
01057     aps.write(outdir)
01058 
01059
In This Package:

gen.py
