expcalc.py

Go to the documentation of this file.

#!/usr/bin/env python
#
#  nuwa.py -m "expcalc -x 0.0*m -y 0.0*m -z 1.75*m -s DayaBay -d AD1"
#

# Load DybPythonAlg
from DybPython.DybPythonAlg import DybPythonAlg
from GaudiPython import SUCCESS, FAILURE
from GaudiPython import gbl, loaddict
from DybPython.Util import irange
from GaudiKernel import SystemOfUnits as units

import PyCintex
import ROOT
import re

from array import array

Detector = gbl.DayaBay.Detector
Site = gbl.Site
DetectorId = gbl.DetectorId

CLHEP = gbl.CLHEP

class expcalc(DybPythonAlg):
    "expcalc: calculate the expected charge pattern"
    def __init__(self,name):
        DybPythonAlg.__init__(self,name)
        
        self.vertex = CLHEP.Hep3Vector(0*units.mm, 0*units.mm, 0*units.mm)
        self.siteName = "DayaBay"
        self.detName = "AD1"
        self.siteIds = {
          'DayaBay' : gbl.Site.kDayaBay,
          'LingAo'  : gbl.Site.kLingAo,
          'Far'     : gbl.Site.kFar,
        }
        self.detIds = {
          'AD1'  :  gbl.DetectorId.kAD1,
          'AD2'  :  gbl.DetectorId.kAD2,
          'AD3'  :  gbl.DetectorId.kAD3,
          'AD4'  :  gbl.DetectorId.kAD4,
        }
        self.OutputFileName = "chargeMap.txt"
        return

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

        site = self.siteIds[self.siteName]
        detector = self.detIds[self.detName]

        qtool = self.tool('IReconHelperTool', 'ExpQCalcTool')
        expq = qtool.expqcalc(site, detector, self.vertex)

        tableLines = []
        normFactor = 1000.
        tableLines.append("# Vertex: %7.3fmm %7.3fmm %7.3fmm  \n"
                          % ( self.vertex.x(), self.vertex.y(), self.vertex.z())
                         )
        tableLines.append("# Expected Charge Map \n")
        tableLines.append("# Normalization Factor (total charge in the below map): %7.3f \n"
                          % normFactor)
        tableLines.append("#          [ring1] [ring2] [ring3] [ring4] [ring5] [ring6] [ring7] [ring8] \n")
        for col in range(0,24):
            line = ("#[column%2d] %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f \n"
                    % (col+1, 
                      expq[col]*normFactor, 
                      expq[col+24]*normFactor, 
                      expq[col+48]*normFactor,
                      expq[col+72]*normFactor, 
                      expq[col+96]*normFactor, 
                      expq[col+120]*normFactor,
                      expq[col+144]*normFactor, 
                      expq[col+168]*normFactor
                      )
                   )
            tableLines.append(line)

        outFile = open(self.OutputFileName,'w')
        outFile.writelines(tableLines)
        outFile.close()

        return SUCCESS

    def execute(self):
        print "Executing expcalc",self.name()
        return SUCCESS
        
    def finalize(self):        
        print "Finalizing expcalc",self.name()
        status = DybPythonAlg.finalize(self)
        return status

#####  Job Configuration for nuwa.py ########################################
options = None
def configure(argv = []):
    # Process module options
    global options
    from optparse import OptionParser
    
    parser = OptionParser()
    parser.add_option("-s", "--siteName", type="string",
          default="DayaBay",
          help="site name")
    parser.add_option("-d", "--detName", type="string",
          default="AD1",
          help="detector name")
    parser.add_option("-x", "--vertex-x", type="string",
          default="0*m",
          help="X coordinate of the given vertex")
    parser.add_option("-y", "--vertex-y", type="string",
          default="0*m",
          help="Y coordinate of the given vertex")
    parser.add_option("-z", "--vertex-z", type="string",
          default="0*m",
          help="Z coordinate of the given vertex")
    (options, args) = parser.parse_args(args=argv)

#    example for How to change the optical parameters 
#    for expected charge calculation

#    from AdRec.AdRecConf import ExpQCalcTool
#    mytool = ExpQCalcTool("expcalc.ExpQCalcTool")
#    mytool.AbsLength = 10470. # mm, default value in QMLFTool
#    mytool.TopRefZ = 2104.55  # mm, default value in QMLFTool
#    mytool.BotRefZ = -2027.5  # mm, default value in QMLFTool
#    mytool.TopReflectivity = 0.9786 # mm, default value in QMLFTool
#    mytool.TopReflectivity = 0.9786 # mm, default value in QMLFTool
    
def run(app):
    '''
    Configure and add an algorithm to job
    '''
    from DybPython.Tools import unitify
    
    calcAlg = expcalc("expcalc")
    x = unitify(options.vertex_x)
    y = unitify(options.vertex_y)
    z = unitify(options.vertex_z)
    calcAlg.vertex = CLHEP.Hep3Vector(x, y, z)
    calcAlg.siteName = options.siteName
    calcAlg.detName = options.detName
    app.addAlgorithm(calcAlg)
    
    pass