makeFecCableMap-Old.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'
#
# ! For RPCs only !


import math
from GaudiPython import gbl

# Make shortcuts to DayaBay classes
Detector = gbl.DayaBay.Detector
Site = gbl.Site
DetectorId = gbl.DetectorId
HardwareId = gbl.DayaBay.HardwareId
Hardware = gbl.DayaBay.Hardware

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

## file variables
# list of RPC subsystems
RpcDetectors = [  Detector(Site.kDayaBay, DetectorId.kRPC),
            Detector(Site.kLingAo, DetectorId.kRPC),
            Detector(Site.kFar, DetectorId.kRPC) ]

# global constants
nFecConnectorsPerBoard = 32

def getRpcDetectors():
    "Return a list of the RPC Detectors"
    global RpcDetectors
    return RpcDetectors

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

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

def getFecChannelIds():
    "Return a list of the FEC channel IDs"
    '''FECs are identified as 0xRC, where R goes from 'A' to 'F'
    for near site, opposite  direction than Row convention. C goes from
    1 to 9'''

    global nFecConnectorsPerBoard
    nearrows = [row for row in reversed(range(0x0,0xF+1))]
    farrows = [row for row in reversed(range(0x0,0x8+1))]
    cols = [col for col in range(0x0,0x8+1)]
    boards = {}
    boardsnear = [row<<4|col for row in nearrows for col in cols]
    boardsfar = [row<<4|col for row in farrows for col in cols]
    fecIds = {}
    detectors = getRpcDetectors()
    rpcSensors = getRpcSensors()
    for detector in detectors:
        if detector.site() == Site.kFar:
            boards[detector] = boardsfar
        else:
            boards[detector] = boardsnear

    for detector in detectors:
        if detector.site() == Site.kFar:
            fecIds[detector] = [FecChannelId(board, connector,
                                             detector.site(),
                                             detector.detectorId())
                                for board in boardsfar
                                for connector in range(1,nFecConnectorsPerBoard+1)]
        else :
            fecIds[detector] = [FecChannelId(board, connector,
                                             detector.site(),
                                             detector.detectorId())
                                for board in boardsnear
                                for connector in range(1,nFecConnectorsPerBoard+1)]

    return fecIds

def getRpcHardwareIds():
    '''Return unique ids of RPC modules, packed together with layer and strip info.
    For now, the module number is simply ordinal number site by site.
    In future there should be file specifying IDs of actual modules installed,
    and we can read from there'''
    return None

def getFecHardwareIds():
    '''Return unique ids of RPC FECs, packed together with channel number.
    For now, the card number is simply ordinal number site by site.
    In future there should be file specifying IDs of actual FECs installed on the modules,
    and we will read from there'''
    return None

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 printFecCableMap():
    "Print a map of the cable connections"
    detectors = getRpcDetectors()
    rpcIds = getRpcSensors()
    channelIds = getFecChannelIds()
    boardHardwareNumber = {}
    nextFecBoardNumber = 1
    print "#  ChannelID" "\t\t" "Description" "\t"\
        "ElecHardwareId" "\t\t" "Description" "\t"\
        "SensorID" "\t\t" "Description" "\t"\
        "SensorHardwareID" "\t\t" "Description"
    for detector in detectors:
        rpcIndex = 0
        siteRpcs = rpcIds[detector] # Sensitive detectors
        nRpcs = len(siteRpcs) # How many do we have
        for channelId in channelIds[detector]:
            # Go through all expected channels for the site.
            # Begining at col 1 and row 1, which is at the corner
            # close to electronics room (for DB hall) and further from
            # hall entrance. Iterating row-vise.
            rpcId = None
            rpcHardwareId = None
            if rpcIndex < nRpcs: # We still have a Sensor for this channel
                rpcId = siteRpcs[rpcIndex] # Current Sensor
                #iPanel = int(math.ceil(len(channelIds[detector])/nFecConnectorsPerBoard)) # number of FEC boards in total, equivalent to number of RPC modules
                #iPanel = rpcIndex
                #rpcHardwareId = RpcHardwareId(iPanel, rpcId.layer(), rpcId.strip())
                rpcHardwareId = RpcHardwareId(nextFecBoardNumber, rpcId.layer(), rpcId.strip())
            else: # We don't have any Sensor left, create new empty one. Create empty hardware representation, too.
                rpcId = RpcSensor()
                rpcHardwareId = HardwareId()
            boardId = channelId.boardId().fullPackedData()
            if not boardHardwareNumber.has_key( boardId ):
                # Add an unique FEC board id into the map
                boardHardwareNumber[boardId] = nextFecBoardNumber
                nextFecBoardNumber += 1
            # create unique hardware channel id
            fecHardwareId = FecHardwareId(boardHardwareNumber[boardId],
                                          channelId.connector())
            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__":
    printFecCableMap()  #FEC