makeFecCableMap.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 0xCF, where C stands for Control FPGA (CF) in
    an ROM and goes from 0 to 3 at near halls, and from 0 to 5 at far hall.
    Opposite  direction than Row convention. Each CF serves for up to 15 FECs.
    F stands for FEC id served by the CF, and runs from 0 to 14 for even CF Id,
    or from 0 to 11 for odd CF Id.'''

    global nFecConnectorsPerBoard
    boards = {}
    boardsnear = []
    boardsfar = []
    fecIds = {}
    detectors = getRpcDetectors()
    rpcSensors = getRpcSensors()

    # near sites
    for row in range(6) :
        for col in range(9) :
            cf = (1 - row/3)*2 + col/5
            fec = (2 - row%3)*(5 - (cf&0x1)) + col%5
            id = cf<<4|fec
            boardsnear.append(id)
            #print "(%d, %d) "%(cf,fec),
        #print ""

    # far site
    for row in range(9) :
        for col in range(9) :
            cf = (2 - row/3)*2 + col/5
            fec = (2 - row%3)*(5 - (cf&0x1)) + col%5
            id = cf<<4|fec
            boardsfar.append(id)
            #print "(%d, %d, %d) "%(cf,fec,id),
        #print ""

    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 getRotBoxNumber(site, row, column):
    rowLimitNear = 4
    rowLimitFar = 5
    columnLimit = 5
    rowLimit = 0
    if site == Site.kFar :
        rowLimit = rowLimitFar
    else :
        rowLimit = rowLimitNear
    rotNum = 0
    if row < rowLimit :
        rotNum += 2
    if column < columnLimit :
        rotNum += 1
    return rotNum

def printFecCableMap():
    "Print a map of the cable connections"
    detectors = getRpcDetectors()
    rpcIds = getRpcSensors()
    channelIds = getFecChannelIds()
    boardHardwareNumber = {}
    nextRomBoardSerial = 1
    nextRtmBoardSerial = 1
    nextRotBoxSerial = 1
    nextFecBoardSerial = 0
    romBoardNumber = 1
    rtmBoardNumber = 1
    rpcSerial = 0

    print "# Temporary fake map"
    print "#  site" "  " "detectorId" "  "\
        "romBoard" "  " "romBoardSerial" "  "\
        "rtmBoard" "  " "rtmBoardSerial" "  "\
        "rotBox" "  " "rotBoxSerial" "  "\
        "fecBoard" "  " "fecBoardSerial" "  "\
        "connector" "  "\
        "rpcRow" "  " "rpcColumn" "  " "rpcLayer" "  " "rpcStrip" "  "\
        "rpcModuleSerial"

    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
                rpcHardwareId = RpcHardwareId(nextFecBoardSerial, 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
                nextFecBoardSerial += 1
                rpcSerial += 1
                boardHardwareNumber[boardId] = nextFecBoardSerial
            # create unique hardware channel id
            fecHardwareId = FecHardwareId(boardHardwareNumber[boardId],
                                          channelId.connector())
            site = channelId.site()
            detectorId = channelId.detectorId()
            rotBoxNumber = getRotBoxNumber(site, rpcId.panelRow(), rpcId.panelColumn())
            rotBoxSerial = site * 10 + rotBoxNumber
            fecNumber = channelId.board()
            fecSerial = nextFecBoardSerial
            connector = channelId.connector()
            rpcRow = rpcId.panelRow()
            rpcColumn = rpcId.panelColumn()
            rpcLayer = rpcId.layer()
            rpcStrip = rpcId.strip()
            print "%4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d" % (
                site, detectorId, romBoardNumber, nextRomBoardSerial,
                rtmBoardNumber, nextRtmBoardSerial,
                rotBoxNumber, rotBoxSerial,
                fecNumber, fecSerial, connector,
                #rpcRow, rpcColumn, rpcLayer, rpcStrip, rpcSerial) # new geometry description, from r11988
                rpcColumn, rpcRow, rpcLayer, rpcStrip, rpcSerial) # old geometry description
            rpcIndex += 1
        nextRomBoardSerial += 1
        nextRtmBoardSerial += 1

if __name__ == "__main__":
    printFecCableMap()  #FEC