python.LArCondContChannels.LArCondContChannels Class Reference

Inheritance diagram for python.LArCondContChannels.LArCondContChannels:

Collaboration diagram for python.LArCondContChannels.LArCondContChannels:

Public Member Functions
def	__init__ (self)
def	isUnknown (self, type)
def	isSingleGroup (self, type)
def	isSubDetectorGrouping (self, type)
def	isExtSubDetectorGrouping (self, type)
def	isFeedThroughGrouping (self, type)
def	isExtFeedThroughGrouping (self, type)
def	folderFeedThruGroupChanSel (self, feedThruGroup, gainList=[0, 1, 2])
def	folderFeedThruChannelSelection (self, negB_FTList, posB_FTList, negEC_FTList, posEC_FTList, gainList, isCorrection=False)
def	folderExtFeedThruChannelSelection (self, negB_FTList, posB_FTList, negEC_FTList, posEC_FTList, gainList, isCorrection=False)
def	feedThruChannelSelection (self, feedThruList, gainList, posNeg, isBarrel=True, isCorrection=False)
def	extFeedThruChannelSelection (self, feedThruList, gainList, posNeg, isBarrel=True, isCorrection=False)
def	channelSelection (self, channels)
def	subDetChannelSelection (self, subDetName, gain)
def	decodeFeedThruChannelNumber (self, channelNumber)
def	decodeExtFeedThruChannelNumber (self, channelNumber)
def	decodeSubDetChannelNumber (self, channelNumber)

Public Attributes
	Unknown
	SingleGroup
	SubDetectorGrouping
	FeedThroughGrouping
	ExtFeedThroughGrouping
	ExtSubDetectorGrouping
	offsetFtNegBarrel
	offsetFtPosBarrel
	offsetFtNegEndcap
	offsetFtPosEndCap
	nFT
	nFTandCorr
	ftPerGain
	nFTAcc
	offsetFtNegBarrelPS
	offsetFtPosBarrelPS
	offsetFtNegEndcapPS
	offsetFtPosEndCapPS
	nFTPS
	nChannelsPerGain
	nGains
	subDetsOffset
	nSubDets
	subDetGainCorrOffset

Detailed Description

Definition at line 12 of file LArCondContChannels.py.

Constructor & Destructor Documentation

__init__()

def python.LArCondContChannels.LArCondContChannels.__init__

(

self

)

Definition at line 13 of file LArCondContChannels.py.

  def __init__(self) :
    self.Unknown              = 0
    self.SingleGroup          = 1
    self.SubDetectorGrouping  = 2
    self.FeedThroughGrouping  = 3
    self.ExtFeedThroughGrouping  = 4
    self.ExtSubDetectorGrouping  = 5
    
    # Offset values
    #self.offsetCorrs         =   3
    self.offsetFtNegBarrel    =   3
    self.offsetFtPosBarrel    =  35
    self.offsetFtNegEndcap    =  67
    self.offsetFtPosEndCap    =  92
    self.nFT                  = 114
    self.nFTandCorr           = 117
    self.ftPerGain            = self.nFT
 
    # For extended FT grouping:
    self.nFTAcc               = 117
    self.offsetFtNegBarrelPS  =   3 + self.nFTAcc #= 120
    self.offsetFtPosBarrelPS  =  35 + self.nFTAcc #= 152 
    self.offsetFtNegEndcapPS  =  67 + self.nFTAcc #= 184
    self.offsetFtPosEndCapPS  =  92 + self.nFTAcc #= 209
    self.nFTPS                = 117 + self.nFTAcc #= 231
    
    self.nChannelsPerGain     =   236
    self.nGains               =   3
    self.subDetsOffset        =   3
    self.nSubDets             =   4
    self.subDetGainCorrOffset = self.subDetsOffset + self.nSubDets    
  

Member Function Documentation

channelSelection()

def python.LArCondContChannels.LArCondContChannels.channelSelection	(		self,
			channels
	)

Definition at line 396 of file LArCondContChannels.py.

  def channelSelection(self, channels):
    chans = channels
    chans.sort()
    chanSel = "<channelSelection>"
    first   = True
    for c in chans:
      if first:
        first = False
      else:
        chanSel += ', '
      chanSel += str(c)
    chanSel += "</channelSelection>"
    return chanSel
 
 

decodeExtFeedThruChannelNumber()

def python.LArCondContChannels.LArCondContChannels.decodeExtFeedThruChannelNumber	(		self,
			channelNumber
	)

Definition at line 478 of file LArCondContChannels.py.

  def decodeExtFeedThruChannelNumber(self, channelNumber):
    # initial values
    isBarrel = True
    posNeg   = -1
    feedThru = -1
    gain     = channelNumber
 
    if channelNumber < self.offsetFtNegBarrel:
      # is a correction
      return (isBarrel, posNeg, feedThru, gain)
 
    chanNum  = channelNumber - self.offsetFtNegBarrel
    gain     = chanNum/self.nChannelsPerGain
    chanNum  = chanNum - gain*self.nChannelsPerGain + self.offsetFtNegBarrel
 
    if chanNum < self.offsetFtPosBarrel:
      # is negative barrel
      feedThru = chanNum - self.offsetFtNegBarrel
      posNeg=-1
      isBarrel=True
    elif chanNum < self.offsetFtNegEndcap:
      # is positive barrel
      feedThru = chanNum - self.offsetFtPosBarrel
      posNeg   = 1
      isBarrel= True
    elif chanNum < self.offsetFtPosEndCap:
      # is negative endcap
      feedThru = chanNum - self.offsetFtNegEndcap
      posNeg=-1
      isBarrel = False
    elif chanNum < self.nFTAcc:
      # is positive endcap
      feedThru = chanNum - self.offsetFtPosEndCap
      posNeg   = 1
      isBarrel = False
    elif chanNum < self.offsetFtNegEndcapPS:
      feedThru = chanNum - self.offsetFtNegBarrelPS
      posNeg=-1
      isBarrel=True
    elif chanNum < self.offsetFtNegEndcapPS:
      # is positive barrel
      feedThru = chanNum - self.offsetFtPosBarrelPS
      posNeg   = 1
      isBarrel= True
    elif chanNum < self.offsetFtPosEndCapPS:
      # is negative endcap
      feedThru = chanNum - self.offsetFtNegEndcapPS
      posNeg=-1
      isBarrel = False
    elif chanNum < self.nFTPS:
      # is positive endcap
      feedThru = chanNum - self.offsetFtPosEndCapPS
      posNeg   = 1
      isBarrel = False
    elif chanNum == 228+3:
      feedThru = 3
      posNeg   = -1
      isBarrel = False
    elif chanNum == 229+3:
      feedThru = 3
      posNeg   = 1
      isBarrel = False
    elif chanNum == 230+3:
      feedThru = 10
      posNeg   = -1
      isBarrel = False
    elif chanNum == 231+3:
      feedThru = 10
      posNeg   = 1
      isBarrel = False
    elif chanNum == 232+3:
      feedThru = 16
      posNeg   = -1
      isBarrel = False
    elif chanNum == 233+3:
      feedThru = 16
      posNeg   = 1
      isBarrel = False
    elif chanNum == 234+3:
      feedThru = 22
      posNeg   = -1
      isBarrel = False
    elif chanNum == 235+3:
      feedThru = 22
      posNeg   = 1
      isBarrel = False
    else: #should never happen
      feedThru = -999
      posNeg   = -999
      isBarrel = False
 
    return (isBarrel, posNeg, feedThru, gain)
 
 

decodeFeedThruChannelNumber()

def python.LArCondContChannels.LArCondContChannels.decodeFeedThruChannelNumber	(		self,
			channelNumber
	)

Definition at line 443 of file LArCondContChannels.py.

  def decodeFeedThruChannelNumber(self, channelNumber):
    # initial values
    isBarrel = True
    posNeg   = -1
    feedThru = -1
    gain     = channelNumber
 
    if channelNumber < self.offsetFtNegBarrel:
      # is a correction
      return (isBarrel, posNeg, feedThru, gain)
 
    chanNum  = channelNumber - self.offsetFtNegBarrel
    gain     = chanNum/self.ftPerGain
    chanNum  = chanNum - gain*self.ftPerGain + self.offsetFtNegBarrel
 
    if chanNum < self.offsetFtPosBarrel:
      # is negative barrel
      feedThru = chanNum - self.offsetFtNegBarrel
    elif chanNum < self.offsetFtNegEndcap:
      # is positive barrel
      feedThru = chanNum - self.offsetFtPosBarrel
      posNeg   = 1
    elif chanNum < self.offsetFtPosEndCap:
      # is negative endcap
      feedThru = chanNum - self.offsetFtNegEndcap
      isBarrel = False
    else:
      # is positive endcap
      feedThru = chanNum - self.offsetFtPosEndCap
      posNeg   = 1
      isBarrel = False
 
    return (isBarrel, posNeg, feedThru, gain)
 
  

decodeSubDetChannelNumber()

def python.LArCondContChannels.LArCondContChannels.decodeSubDetChannelNumber	(		self,
			channelNumber
	)

Definition at line 582 of file LArCondContChannels.py.

  def decodeSubDetChannelNumber(self, channelNumber):
    # initial values
    subDet   = "Unknown"
    gain     = -1
    if channelNumber < self.subDetsOffset:
      # is a correction
      subDet   = "Corr"
      gain     = channelNumber
    else:
      chanSD = channelNumber - self.subDetsOffset
      gain   = chanSD/self.nSubDets
      chanSD = chanSD - gain*self.nSubDets
      if chanSD == 0:
        subDet   = "EMB"
      elif chanSD == 1:
        subDet   = "EMEC"
      elif chanSD == 2:
        subDet   = "HEC"
      elif chanSD == 3:
        subDet   = "FCAL"
 
    return (subDet, gain)
 
    

extFeedThruChannelSelection()

def python.LArCondContChannels.LArCondContChannels.extFeedThruChannelSelection	(		self,
			feedThruList,
			gainList,
			posNeg,
			isBarrel = True,
			isCorrection = False
	)

Definition at line 323 of file LArCondContChannels.py.

  def extFeedThruChannelSelection(self,
                               feedThruList,
                               gainList,
                               posNeg,
                               isBarrel=True,
                               isCorrection=False):
    # allow for single values rather than lists
    fts   = feedThruList
    if operator.isNumberType(feedThruList): fts = [feedThruList]
    gains = gainList
    if operator.isNumberType(gainList): gains = [gainList]
    fts.sort()
    # Check value for posNeg
    if posNeg != -1 and posNeg != +1:
      print(__name__)
      raise RuntimeError (__name__ +"posNeg must be either +/-1, found: " + str(posNeg))
 
    offset = 0
    # First get offset per gain
    if isBarrel:
      if posNeg == -1:
        offset   = self.offsetFtNegBarrel
        offsetPS = self.offsetFtNegBarrelPS
      else:
        offset   = self.offsetFtPosBarrel
        offsetPS = self.offsetFtPosBarrelPS
    else:
      # Endcap
      if posNeg == -1:
        offset = self.offsetFtNegEndcap
        offsetPS = self.offsetFtNegEndcapPS
      else:
        offset = self.offsetFtPosEndCap
        offsetPS = self.offsetFtPosEndCapPS
 
    # Now get channels
    chans = []
    # Now loop over gains and add in a FT for each gain
    for gain in gains:
      offset1 = offset + gain*self.nChannelsPerGain
      offset1PS = offsetPS + gain*self.nChannelsPerGain
      # Calculate channels for FT list
      for ft in fts:
        chans += [ft + offset1] #Standard channel
        chans += [ft + offset1PS] #Corresponding PS channel
        # add the EMEC in HEC channels
        if not isBarrel:
          if (posNeg == -1 and ft==3): # C-Side
            chans+=[228+3+gain*self.nChannelsPerGain]
          if (posNeg == -1 and ft==10):# C-Side
            chans+=[230+3+gain*self.ChannelsPerGain]
          if (posNeg == -1 and ft==16):# C-Side
            chans+=[232+3+gain*self.ChannelsPerGain]
          if (posNeg == -1 and ft==22):# C-Side
            chans+=[234+3+gain*self.ChannelsPerGain]
          if (posNeg == 1 and ft==3): # A-Side
            chans+=[229+3+gain*self.ChannelsPerGain]
          if (posNeg == 1 and ft==10):# A-Side
            chans+=[231+3+gain*self.ChannelsPerGain]
          if (posNeg == 1 and ft==16):# A-Side
            chans+=[233+3+gain*self.ChannelsPerGain]
          if (posNeg == 1 and ft==22):# A-Side
            chans+=[235+3+gain*self.ChannelsPerGain]
 
 
    # Return channels
    return chans
 

feedThruChannelSelection()

def python.LArCondContChannels.LArCondContChannels.feedThruChannelSelection	(		self,
			feedThruList,
			gainList,
			posNeg,
			isBarrel = True,
			isCorrection = False
	)

Definition at line 278 of file LArCondContChannels.py.

  def feedThruChannelSelection(self,
                               feedThruList,
                               gainList,
                               posNeg,
                               isBarrel=True,
                               isCorrection=False):
    # allow for single values rather than lists
    fts   = feedThruList
    if operator.isNumberType(feedThruList): fts = [feedThruList]
    gains = gainList
    if operator.isNumberType(gainList): gains = [gainList]
    fts.sort()
    # Check value for posNeg
    if posNeg != -1 and posNeg != +1:
      print(__name__)
      raise RuntimeError (__name__ +"posNeg must be either +/-1, found: " + str(posNeg))
 
    offset = 0
    # First get offset per gain
    if isBarrel:
      if posNeg == -1:
        offset = self.offsetFtNegBarrel
      else:
        offset = self.offsetFtPosBarrel
    else:
      # Endcap
      if posNeg == -1:
        offset = self.offsetFtNegEndcap
      else:
        offset = self.offsetFtPosEndCap
 
    # Now get channels
    chans = []
    # Now loop over gains and add in a FT for each gain
    for gain in gains:
      offset1 = offset + gain*self.ftPerGain
      # Calculate channels for FT list
      for ft in fts:
        chans += [ft + offset1]
 
    # Return channels
    return chans
 
 
  

folderExtFeedThruChannelSelection()

def python.LArCondContChannels.LArCondContChannels.folderExtFeedThruChannelSelection	(		self,
			negB_FTList,
			posB_FTList,
			negEC_FTList,
			posEC_FTList,
			gainList,
			isCorrection = False
	)

Definition at line 210 of file LArCondContChannels.py.

  def folderExtFeedThruChannelSelection(self,
                                     negB_FTList,
                                     posB_FTList,
                                     negEC_FTList,
                                     posEC_FTList,
                                     gainList,
                                     isCorrection=False):
    chans = []
    # Check that the lists are not empty
    if len(negB_FTList)   == 0 and \
       len(posB_FTList)   == 0 and \
       len(negEC_FTList)  == 0 and \
       len(posEC_FTList)  == 0:
 
      print("LArCondContChannels.folderFeedThruChannelSelection Warning: FeedThru lists are all empty - no channels selected")
 
    elif len(gainList) == 0:
      print("LArCondContChannels.folderFeedThruChannelSelection Warning: Gain list is empty - no channels selected")
    else:
      if len(negB_FTList)   > 0:
        chans += self.extFeedThruChannelSelection(
          negB_FTList,
          gainList,
          -1,
          True,
          isCorrection)
      if len(posB_FTList)   > 0:
        chans += self.extFeedThruChannelSelection(
          posB_FTList,
          gainList,
          1,
          True,
          isCorrection)
      if len(negEC_FTList)  > 0:
        chans += self.extFeedThruChannelSelection(
          negEC_FTList,
          gainList,
          -1,
          False,
          isCorrection)
      if len(posEC_FTList)  > 0:
        chans += self.extFeedThruChannelSelection(
          posEC_FTList,
          gainList,
          1,
          False,
          isCorrection)
 
    print("chans ",chans)
    chanSel = self.channelSelection(chans)
    return chanSel
 
 
 
 
 
 

folderFeedThruChannelSelection()

def python.LArCondContChannels.LArCondContChannels.folderFeedThruChannelSelection	(		self,
			negB_FTList,
			posB_FTList,
			negEC_FTList,
			posEC_FTList,
			gainList,
			isCorrection = False
	)

Definition at line 154 of file LArCondContChannels.py.

  def folderFeedThruChannelSelection(self,
                                     negB_FTList,
                                     posB_FTList,
                                     negEC_FTList,
                                     posEC_FTList,
                                     gainList,
                                     isCorrection=False):
    chans = []
    # Check that the lists are not empty
    if len(negB_FTList)   == 0 and \
       len(posB_FTList)   == 0 and \
       len(negEC_FTList)  == 0 and \
       len(posEC_FTList)  == 0:
 
      print("LArCondContChannels.folderFeedThruChannelSelection Warning: FeedThru lists are all empty - no channels selected")
 
    elif len(gainList) == 0:
      print("LArCondContChannels.folderFeedThruChannelSelection Warning: Gain list is empty - no channels selected")
    else:
      if len(negB_FTList)   > 0:
        chans += self.feedThruChannelSelection(
          negB_FTList,
          gainList,
          -1,
          True,
          isCorrection)
      if len(posB_FTList)   > 0:
        chans += self.feedThruChannelSelection(
          posB_FTList,
          gainList,
          1,
          True,
          isCorrection)
      if len(negEC_FTList)  > 0:
        chans += self.feedThruChannelSelection(
          negEC_FTList,
          gainList,
          -1,
          False,
          isCorrection)
      if len(posEC_FTList)  > 0:
        chans += self.feedThruChannelSelection(
          posEC_FTList,
          gainList,
          1,
          False,
          isCorrection)
 
    print("chans ",chans)
    chanSel = self.channelSelection(chans)
    return chanSel
 
 
 
 
 

folderFeedThruGroupChanSel()

def python.LArCondContChannels.LArCondContChannels.folderFeedThruGroupChanSel	(		self,
			feedThruGroup,
			gainList = [0,1,2]
	)

Definition at line 87 of file LArCondContChannels.py.

  def folderFeedThruGroupChanSel(self, feedThruGroup, gainList=[0,1,2]):
    gains = gainList
    if operator.isNumberType(gainList): gains = [gainList]
    for g in gains:
      if g < 0 or g > 2:
        print("LArCondContChannels.folderFeedThruGroupChanSel: invalid gain value - must be 0-2 - ", g)
        return "<channelSelection>  </channelSelection>"
 
    if feedThruGroup == "negBarrel":
      feedThruList = []
      posNeg       = -1
      isBarrel     = True
      for ft in range(32):
        feedThruList += [ft]
      chans = self.feedThruChannelSelection(feedThruList, gains, posNeg, isBarrel)
    elif feedThruGroup == "posBarrel":
      feedThruList = []
      posNeg       = 1
      isBarrel     = True
      for ft in range(32):
        feedThruList += [ft]
      chans = self.feedThruChannelSelection(feedThruList, gains, posNeg, isBarrel)
    elif feedThruGroup == "negEndcap":
      feedThruList = []
      posNeg       = -1
      isBarrel     = False
      for ft in range(25):
        feedThruList += [ft]
      chans = self.feedThruChannelSelection(feedThruList, gains, posNeg, isBarrel)
    elif feedThruGroup == "posEndcap":
      feedThruList = []
      posNeg       = 1
      isBarrel     = False
      for ft in range(25):
        feedThruList += [ft]
      chans = self.feedThruChannelSelection(feedThruList, gains, posNeg, isBarrel)
    else:
      print("LArCondContChannels.folderFeedThruGroupChanSel: feedThru grouping, found", feedThruGroup)
      print("Allowed values: \"negBarrel\", \"posBarrel\", \"negEndcap\", \"posEndcap\"")
      return "<channelSelection>  </channelSelection>"
 
 
    chanSel = self.channelSelection(chans)
    return chanSel
 

isExtFeedThroughGrouping()

def python.LArCondContChannels.LArCondContChannels.isExtFeedThroughGrouping	(		self,
			type
	)

Definition at line 60 of file LArCondContChannels.py.

  def isExtFeedThroughGrouping(self, type):
    return type == self.ExtFeedThroughGrouping
 
    

isExtSubDetectorGrouping()

def python.LArCondContChannels.LArCondContChannels.isExtSubDetectorGrouping	(		self,
			type
	)

Definition at line 54 of file LArCondContChannels.py.

  def isExtSubDetectorGrouping(self, type):
    return type == self.ExtSubDetectorGrouping
 

isFeedThroughGrouping()

def python.LArCondContChannels.LArCondContChannels.isFeedThroughGrouping	(		self,
			type
	)

Definition at line 57 of file LArCondContChannels.py.

  def isFeedThroughGrouping(self, type):
    return type == self.FeedThroughGrouping
 

isSingleGroup()

def python.LArCondContChannels.LArCondContChannels.isSingleGroup	(		self,
			type
	)

Definition at line 48 of file LArCondContChannels.py.

  def isSingleGroup(self, type):
    return type == self.SingleGroup
 

isSubDetectorGrouping()

def python.LArCondContChannels.LArCondContChannels.isSubDetectorGrouping	(		self,
			type
	)

Definition at line 51 of file LArCondContChannels.py.

  def isSubDetectorGrouping(self, type):
    return type == self.SubDetectorGrouping
  

isUnknown()

def python.LArCondContChannels.LArCondContChannels.isUnknown	(		self,
			type
	)

Definition at line 45 of file LArCondContChannels.py.

  def isUnknown(self, type):
    return type == self.Unknown
 

subDetChannelSelection()

def python.LArCondContChannels.LArCondContChannels.subDetChannelSelection	(		self,
			subDetName,
			gain
	)

Definition at line 414 of file LArCondContChannels.py.

  def subDetChannelSelection(self, subDetName, gain):
    if gain >= self.nGains:
      print("invalid gain: range in 0 to",self.nGain-1)
      return -1
    offset = gain*self.nSubDets + self.subDetsOffset
    if subDetName == "Corr":
      return gain
    elif subDetName == "EMB":
      return offset
    elif subDetName == "EMEC":
      return offset + 1
    elif subDetName == "HEC":
      return offset + 2
    elif subDetName == "FCAL":
      return offset + 3
 
    

Member Data Documentation

ExtFeedThroughGrouping

python.LArCondContChannels.LArCondContChannels.ExtFeedThroughGrouping

Definition at line 18 of file LArCondContChannels.py.

ExtSubDetectorGrouping

python.LArCondContChannels.LArCondContChannels.ExtSubDetectorGrouping

Definition at line 19 of file LArCondContChannels.py.

FeedThroughGrouping

python.LArCondContChannels.LArCondContChannels.FeedThroughGrouping

Definition at line 17 of file LArCondContChannels.py.

ftPerGain

python.LArCondContChannels.LArCondContChannels.ftPerGain

Definition at line 29 of file LArCondContChannels.py.

nChannelsPerGain

python.LArCondContChannels.LArCondContChannels.nChannelsPerGain

Definition at line 39 of file LArCondContChannels.py.

nFT

python.LArCondContChannels.LArCondContChannels.nFT

Definition at line 27 of file LArCondContChannels.py.

nFTAcc

python.LArCondContChannels.LArCondContChannels.nFTAcc

Definition at line 32 of file LArCondContChannels.py.

nFTandCorr

python.LArCondContChannels.LArCondContChannels.nFTandCorr

Definition at line 28 of file LArCondContChannels.py.

nFTPS

python.LArCondContChannels.LArCondContChannels.nFTPS

Definition at line 37 of file LArCondContChannels.py.

nGains

python.LArCondContChannels.LArCondContChannels.nGains

Definition at line 40 of file LArCondContChannels.py.

nSubDets

python.LArCondContChannels.LArCondContChannels.nSubDets

Definition at line 42 of file LArCondContChannels.py.

offsetFtNegBarrel

python.LArCondContChannels.LArCondContChannels.offsetFtNegBarrel

Definition at line 23 of file LArCondContChannels.py.

offsetFtNegBarrelPS

python.LArCondContChannels.LArCondContChannels.offsetFtNegBarrelPS

Definition at line 33 of file LArCondContChannels.py.

offsetFtNegEndcap

python.LArCondContChannels.LArCondContChannels.offsetFtNegEndcap

Definition at line 25 of file LArCondContChannels.py.

offsetFtNegEndcapPS

python.LArCondContChannels.LArCondContChannels.offsetFtNegEndcapPS

Definition at line 35 of file LArCondContChannels.py.

offsetFtPosBarrel

python.LArCondContChannels.LArCondContChannels.offsetFtPosBarrel

Definition at line 24 of file LArCondContChannels.py.

offsetFtPosBarrelPS

python.LArCondContChannels.LArCondContChannels.offsetFtPosBarrelPS

Definition at line 34 of file LArCondContChannels.py.

offsetFtPosEndCap

python.LArCondContChannels.LArCondContChannels.offsetFtPosEndCap

Definition at line 26 of file LArCondContChannels.py.

offsetFtPosEndCapPS

python.LArCondContChannels.LArCondContChannels.offsetFtPosEndCapPS

Definition at line 36 of file LArCondContChannels.py.

SingleGroup

python.LArCondContChannels.LArCondContChannels.SingleGroup

Definition at line 15 of file LArCondContChannels.py.

SubDetectorGrouping

python.LArCondContChannels.LArCondContChannels.SubDetectorGrouping

Definition at line 16 of file LArCondContChannels.py.

subDetGainCorrOffset

python.LArCondContChannels.LArCondContChannels.subDetGainCorrOffset

Definition at line 43 of file LArCondContChannels.py.

subDetsOffset

python.LArCondContChannels.LArCondContChannels.subDetsOffset

Definition at line 41 of file LArCondContChannels.py.

Unknown

python.LArCondContChannels.LArCondContChannels.Unknown

Definition at line 14 of file LArCondContChannels.py.

---

The documentation for this class was generated from the following file:

• LArCondContChannels.py