makeFeeCableMap.py

Go to the documentation of this file.

#!/usr/bin/env python
#
# Make a text table of the mapping between:
#  Detector Sensors:         Identifies PMT/RPC by geometry in the experiment
#  Electronics Channels IDs: Identifies crate/board/connectors in electronics
#  Hardware IDs:             Identifies specific pieces of hardware/barcodes
#
# Unconnected channels/hardware are identified using IDs of type 'Unknown'

import math
from GaudiPython import gbl

# Make shortcuts to DayaBay classes
Detector = gbl.DayaBay.Detector
Site = gbl.Site
DetectorId = gbl.DetectorId
AdPmtSensor = gbl.DayaBay.AdPmtSensor
PoolPmtSensor = gbl.DayaBay.PoolPmtSensor
FeeChannelId = gbl.DayaBay.FeeChannelId
HardwareId = gbl.DayaBay.HardwareId
PmtHardwareId = gbl.DayaBay.PmtHardwareId
FeeHardwareId = gbl.DayaBay.FeeHardwareId
Hardware = gbl.DayaBay.Hardware

#for RPC
FecChannelId = gbl.DayaBay.FecChannelId
HardwareId = gbl.DayaBay.HardwareId
RpcSensor = gbl.DayaBay.RpcSensor
RpcHardwareId = gbl.DayaBay.RpcHardwareId
FecHardwareId = gbl.DayaBay.FecHardwareId

def getRpcIds():
    "Return a list of the RPC Detectors"
    global RpcIds
    return RpcIds

def getRpcSensorIds():
    "Return a map of the RPC sensors by detector"
    RpcRows = range(1,10)
    NearRpcColumns = range(1,7)
    FarRpcColumns = range(1,10)
    RpcLayers = range(1,5)
    RpcStrips = range(1,9)
    NearRpcSensors= [ [row, column, layer, strip] for row in RpcRows for column in NearRpcColumns for layer in RpcLayers for strip in RpcStrips ]
    FarRpcSensors= [ [row, column, layer, strip] for row in RpcRows for column in FarRpcColumns for layer in RpcLayers for strip in RpcStrips ]

    RpcSensorIds = {}
    for detector in getRpcIds():
        rpcSensors = []
        if detector.site() == Site.kFar:
            rpcSensors = FarRpcSensors
        else:
            rpcSensors = NearRpcSensors
        RpcSensorIds[detector] = [ RpcSensor(row, column, layer, strip,
                                           detector.site(),
                                           detector.detectorId())
                               for [row, column, layer, strip] in rpcSensors]
    return RpcSensorIds

def getFecChannelIds():
    "Return a list of the FEC channel IDs"
    nFecConnectorsPerBoard = 32
    #nFeeBoardsAd = 13
    #nFeeBoardsNearIws = 8
    #nFeeBoardsNearOws = 11
    #nFeeBoardsFarIws = 10
    #nFeeBoardsFarOws = 14

    fecIds = {}
    detectors = getRpcIds()
    rpcIds = getRpcSensorIds()
    for detector in detectors:
        nBoards = int(math.ceil( len(rpcIds[detector])
                                 / float(nFecConnectorsPerBoard) ) ) 
        fecIds[detector] = [FecChannelId(board, connector,
                                         detector.site(),
                                         detector.detectorId())
                            for board in range(1,nBoards+1)
                            for connector in range(1,nFecConnectorsPerBoard+1)]

    return fecIds

RpcIds = [  Detector(Site.kDayaBay, DetectorId.kRPC),
            Detector(Site.kLingAo, DetectorId.kRPC),
            Detector(Site.kFar, DetectorId.kRPC) ]

AdIds = [ Detector(Site.kDayaBay, DetectorId.kAD1),
          Detector(Site.kDayaBay, DetectorId.kAD2),
          Detector(Site.kLingAo, DetectorId.kAD1),
          Detector(Site.kLingAo, DetectorId.kAD2),
          Detector(Site.kFar, DetectorId.kAD1),
          Detector(Site.kFar, DetectorId.kAD2),
          Detector(Site.kFar, DetectorId.kAD3),
          Detector(Site.kFar, DetectorId.kAD4) ]

WaterVetoIds = [ Detector(Site.kDayaBay, DetectorId.kIWS),
                     Detector(Site.kDayaBay, DetectorId.kOWS),
                     Detector(Site.kLingAo, DetectorId.kIWS),
                     Detector(Site.kLingAo, DetectorId.kOWS),
                     Detector(Site.kFar, DetectorId.kIWS),
                     Detector(Site.kFar, DetectorId.kOWS) ]

def getAdIds():
    "Return a list of the AD Detectors"
    global AdIds
    return AdIds

def getAdPmtIds():
    "Return a map of the AD PMTs by detector"
    AdRings = range(1,9)
    AdColumns = range(1,25)
    AdPmts8Inch = [ [ring, column] for ring in AdRings for column in AdColumns ]
    nCalibPmts = 6
    AdPmts2Inch = [ [0, calibIndex] for calibIndex in range(1,nCalibPmts + 1) ]
    AdPmts = AdPmts8Inch + AdPmts2Inch

    AdPmtIds = {}
    for detector in getAdIds():
        AdPmtIds[detector] = [ AdPmtSensor(ring, column,
                                           detector.site(),
                                           detector.detectorId())
                               for [ring,column] in AdPmts]
    return AdPmtIds

def getWaterVetoIds():
    "Return a list of the Water Veto Detectors"
    global WaterVetoIds
    return WaterVetoIds

def getWaterVetoPmtIds():
    "Return a map of the Water Veto PMTs by detector"
    # Taken from:
    #  dybgaudi/Detector/XmlDetDesc/python/XmlDetDescGen/PoolPmtStructure/gen.py
    wallcounts = [9,    9,   8]
    nearInFin = [10,8,24,8,10,8,24,8,20]
    nearOutFin = [8,8,16,8,8,8,16,8,29]
    nearOutFout = [4,8,12,8,4,8,12,8]
    farInFin = [24,8,24,8,24,8,24,8,32]
    farOutFin = [16,8,16,8,16,8,16,8,32]
    farOutFout = [16,8,16,8,16,8,16,8]

    nearIwsPmts = []
    for wallNumber in range(1, wallcounts[0]+1):
        for wallSpot in range(1, nearInFin[wallNumber-1]+1):
            nearIwsPmts.append( [wallSpot, wallNumber, 1] )
            
    nearOwsPmts = []
    for wallNumber in range(1, wallcounts[1]+1):
        for wallSpot in range(1, nearOutFin[wallNumber-1]+1):
            nearOwsPmts.append( [wallSpot, wallNumber, 1] )
    for wallNumber in range(1, wallcounts[2]+1):
        for wallSpot in range(1, nearOutFout[wallNumber-1]+1):
            nearOwsPmts.append( [wallSpot, wallNumber, 0] )

    farIwsPmts = []
    for wallNumber in range(1, wallcounts[0]+1):
        for wallSpot in range(1, farInFin[wallNumber-1]+1):
            farIwsPmts.append( [wallSpot, wallNumber, 1] )

    farOwsPmts = []
    for wallNumber in range(1, wallcounts[1]+1):
        for wallSpot in range(1, farOutFin[wallNumber-1]+1):
            farOwsPmts.append( [wallSpot, wallNumber, 1] )
    for wallNumber in range(1, wallcounts[2]+1):
        for wallSpot in range(1, farOutFout[wallNumber-1]+1):
            farOwsPmts.append( [wallSpot, wallNumber, 0] )

    PoolPmtIds = {}
    for detector in getWaterVetoIds():
        poolPmts = []
        if detector.site() == Site.kFar:
            if detector.detectorId() == DetectorId.kIWS:
                poolPmts = farIwsPmts
            else:
                poolPmts = farOwsPmts
        else:
            if detector.detectorId() == DetectorId.kIWS:
                poolPmts = nearIwsPmts
            else:
                poolPmts = nearOwsPmts
        PoolPmtIds[detector] = [ PoolPmtSensor(wallNumber,
                                               wallSpot,
                                               inwardFacing,
                                               detector.site(),
                                               detector.detectorId())
                                 for [wallSpot, wallNumber, inwardFacing] in poolPmts]
    return PoolPmtIds

def getAllPmtIds():
    "Return all PMT IDs"
    pmtIds = {}
    pmtIds.update(getAdPmtIds())
    pmtIds.update(getWaterVetoPmtIds())
    return pmtIds
    
def getFeeChannelIds():
    "Return a list of the FEE channel IDs"
    nFeeConnectorsPerBoard = 16
    #nFeeBoardsAd = 13
    #nFeeBoardsNearIws = 8
    #nFeeBoardsNearOws = 11
    #nFeeBoardsFarIws = 10
    #nFeeBoardsFarOws = 14

    feeIds = {}
    detectors = getAdIds() + getWaterVetoIds()
    pmtIds = getAllPmtIds()
    for detector in detectors:
        nBoards = int(math.ceil( len(pmtIds[detector])
                                 / float(nFeeConnectorsPerBoard) ) ) 
        feeIds[detector] = [FeeChannelId(board, connector,
                                         detector.site(),
                                         detector.detectorId())
                            for board in range(1,nBoards+1)
                            for connector in range(1,nFeeConnectorsPerBoard+1)]

    return feeIds

def pmtDescription(pmtId):
    "Return a string representation of PMT ID"
    if pmtId.detectorId() == DetectorId.kIWS:
        return "%s-wall%d-spot%d" % (pmtId.detName(),
                                     pmtId.wallNumber(),
                                     pmtId.wallSpot())
    elif pmtId.detectorId() == DetectorId.kOWS:
        facing = None
        if pmtId.inwardFacing(): facing = "in"
        else: facing = "out"
        return "%s-wall%d-spot%d-%s" % (pmtId.detName(),
                                        pmtId.wallNumber(),
                                        pmtId.wallSpot(),
                                        facing)
    else:
        return "%s-ring%02d-column%02d" % (pmtId.detName(),
                                           pmtId.ring(),
                                           pmtId.column())

def rpcDescription(rpcId):
    "Return a string representation of RPC ID"
    return "%s-row%02d-column%02d-layer%02d-strip-%02d" % (rpcId.detName(),
                                                           rpcId.panelRow(),
                                                           rpcId.panelColumn(),
                                                           rpcId.layer(),
                                                           rpcId.strip())

def channelDescription(channelId):
    "Return a string representation of FEE/FEC channel ID"
    return "%s-board%02d-connector%02d" % (channelId.detName(),
                                           channelId.board(),
                                           channelId.connector())

def hardwareDescription(hardwareId):
    "Return a string representation of the hardware ID"
    if hardwareId.type() == Hardware.kFee:
        return "%s-%d" % (Hardware.AsString(hardwareId.type()),
                          hardwareId.boardId())
    else:
        return "%s-%d" % (Hardware.AsString(hardwareId.type()),
                          hardwareId.id())

def printCableMap():
    "Print a map of the cable connections"
    detectors = getAdIds() + getWaterVetoIds()
    pmtIds = getAllPmtIds()
    channelIds = getFeeChannelIds()
    pmt8inchHardwareIndex = 1
    pmt2inchHardwareIndex = 1
    boardHardwareNumber = {}
    nextFeeBoardNumber = 1
    print "#  ChannelID                    Description ElecHardwareId Description     SensorID                       Description SensorHardwareID   Description"
    for detector in detectors:
        pmtIndex = 0
        currentPmts = pmtIds[detector]
        nPmts = len(currentPmts)
        for channelId in channelIds[detector]:
            pmtId = None
            pmtHardwareId = None
            if pmtIndex < nPmts:
                pmtId = currentPmts[pmtIndex]
                if pmtId.detName().find("AD")>0 and pmtId.ring() == 0:
                    pmtHardwareId = PmtHardwareId(pmt2inchHardwareIndex,
                                                  Hardware.kPmt2inch)
                    pmt2inchHardwareIndex += 1
                else:
                    pmtHardwareId = PmtHardwareId(pmt8inchHardwareIndex,
                                                  Hardware.kPmt8inch)
                    pmt8inchHardwareIndex += 1
            else:
                pmtId = AdPmtSensor()
                pmtHardwareId = HardwareId()
            boardId = channelId.boardId().fullPackedData()
            if not boardHardwareNumber.has_key( boardId ):
                boardHardwareNumber[boardId] = nextFeeBoardNumber
                nextFeeBoardNumber += 1
            feeHardwareId = FeeHardwareId(boardHardwareNumber[boardId],
                                          channelId.connector())
            print "%12d %30s %14d %11s %12d %33s %16d %13s" % (
                channelId.fullPackedData(),
                channelDescription(channelId),
                feeHardwareId.fullPackedData(),
                hardwareDescription(feeHardwareId),
                pmtId.fullPackedData(),
                pmtDescription(pmtId),
                pmtHardwareId.fullPackedData(),
                hardwareDescription(pmtHardwareId))
            pmtIndex += 1

def printFecCableMap():
    "Print a map of the cable connections"
    detectors = getRpcIds()
    rpcIds = getRpcSensorIds()
    channelIds = getFecChannelIds()
    boardHardwareNumber = {}
    nextFecBoardNumber = 1
#    print "#  ChannelID                    Description ElecHardwareId Description     SensorID                       Description SensorHardwareID   Description"
    for detector in detectors:
        rpcIndex = 0
        currentRpcs = rpcIds[detector]
        nRpcs = len(currentRpcs)
        for channelId in channelIds[detector]:
            rpcId = None
            rpcHardwareId = None
            if rpcIndex < nRpcs:
                rpcId = currentRpcs[rpcIndex]
                iPanel = int(math.ceil(len(channelIds)/32))
                rpcHardwareId = RpcHardwareId(iPanel, rpcId.layer(), rpcId.strip())
            else:
                rpcId = RpcSensor()
                rpcHardwareId = HardwareId()
            boardId = channelId.boardId().fullPackedData()
            if not boardHardwareNumber.has_key( boardId ):
                boardHardwareNumber[boardId] = nextFecBoardNumber
                nextFecBoardNumber += 1
            fecHardwareId = FecHardwareId(boardHardwareNumber[boardId],
                                          channelId.connector())
#            print channelId.fullPackedData(), rpcId.fullPackedData()
            print "%12d %30s %14d %11s %12d %33s %16d %13s" % (
                channelId.fullPackedData(),
                channelDescription(channelId),
                fecHardwareId.fullPackedData(),
                hardwareDescription(fecHardwareId),
                rpcId.fullPackedData(),
                rpcDescription(rpcId),
                rpcHardwareId.fullPackedData(),
                hardwareDescription(rpcHardwareId))
            rpcIndex += 1
if __name__ == "__main__":
    printCableMap() #FEE
    printFecCableMap()  #FEC