Inheritance diagram for python.LArCellConditionsAlg.LArCellConditionsAlg:

Collaboration diagram for python.LArCellConditionsAlg.LArCellConditionsAlg:

Public Member Functions
	__init__ (self, name="LArCellConditionsAlg", **kw)
	initialize (self)
	execute (self)
	printChannelInfo (self, id, chid)
	finalize (self)
	output (self, out, file=None)
	readInput (self)
	IdentifiersToString (self, chid, id)
	getOfflineIDFromString (self, input)
	getOnlineIDFromString (self, input)
	search (self, input)
	printHelp (self)
virtual StatusCode	reinitialize () override
virtual StatusCode	start () override
virtual StatusCode	stop () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const char *	typeName () const override
	return the `std::type_info` name of the underlying py-component This is used by concrete implementations to connect a python component to its C++ counter-part
virtual PyObject *	self () override
	return associated python object.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Public Attributes
	includeConditions = kw.get('printConditions',False)
	includeLocation = kw.get('printLocation',False)
	includeDSPTh = kw.get('printDSPTh',False)
int	nLinesPrinted = 0
int	nEvts = 0
	onlineID = self._detStore.retrieve("LArOnlineID","LArOnlineID")
	offlineID = self._detStore.retrieve("CaloCell_ID","CaloCell_ID")
	bc_packing = LArBadChanBitPacking()
int	noisepattern = 0
int	deadpattern = 0
	noid = Identifier()
	larPedestal = None
	larMphysOverMcal = None
	larRamp = None
	larDAC2uA = None
	laruA2MeV = None
	larhvScaleCorr = None
	larDSPThr = None
	larCabling = condCont.find(eid)
	badChannels = condCont.find(eid)
	caloDDM = condCont.find(eid)

Protected Member Functions
virtual bool	setPyAttr (PyObject *pyobj) override
	attach the C++ component to its python cousin
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
	_detStore = PyAthena.py_svc('StoreGateSvc/DetectorStore')
	note that we are using the python logging service and that the PyAthena.Alg base class has already initialized it for us
	_condStore = PyAthena.py_svc('StoreGateSvc/ConditionStore')
str	_onlErrStr
str	_oflErrStr
PyObject *	m_self
	Pointer to self (from the python world)

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

This class is an Athena algorithm although it doesn't quite behave like one.
It's purpose is to interactivly convert LAr Online/Offline identifiers and
prints the bad channel status and optionally some calibration constants for
the given channel identifier.

Definition at line 26 of file LArCellConditionsAlg.py.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ init()

python.LArCellConditionsAlg.LArCellConditionsAlg.__init__	(		self,
			name = "LArCellConditionsAlg",
		**	kw )

Definition at line 34 of file LArCellConditionsAlg.py.

    def __init__(self, name="LArCellConditionsAlg", **kw):
        
        kw['name'] = name
        super(LArCellConditionsAlg,self).__init__(**kw)
 
        self.includeConditions=kw.get('printConditions',False)
        self.includeLocation=kw.get('printLocation',False)
        self.includeDSPTh=kw.get('printDSPTh',False)
        self.nLinesPrinted=0
        self.nEvts=0
        
        return
    
 

Member Function Documentation

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

python.LArCellConditionsAlg.LArCellConditionsAlg.execute ( self )

Definition at line 106 of file LArCellConditionsAlg.py.

    def execute(self):
        #self.msg.info('running execute...')
 
        #for debugging purposes:
        #sgdump = open("sgdump.txt", 'w')
        #self._condStore.dump(sgdump)
        #sgdump.close()
 
        eid=ROOT.Gaudi.Hive.currentContext().eventID()
 
        try:
            condCont=self._condStore.retrieve("CondCont<LArOnOffIdMapping>","LArOnOffIdMap")
            self.larCabling=condCont.find(eid)
        except Exception:
            print("ERROR, failed to get LArCabling")
            return StatusCode.Failure
 
 
        try:
            condCont=self._condStore.retrieve("CondCont<LArBadChannelCont>","LArBadChannel")
            self.badChannels=condCont.find(eid)
        except Exception:
            print("ERROR, failed to get LArBadChannels")
            return StatusCode.Failure
            
        if self.includeConditions:
            try:
                condCont=self._condStore.retrieve("CondCont<ILArPedestal>","LArPedestal")
                self.larPedestal=condCont.find(eid)
            except Exception:
                print ("WARNING: Failed to retrieve Pedestal from DetStore")
                import traceback
                traceback.print_exc()
                self.larPedestal=None
                
            try:
                condCont=self._condStore.retrieve("CondCont<ILArMphysOverMcal>","LArMphysOverMcal")
                self.larMphysOverMcal=condCont.find(eid)
            except Exception:
                print ("WARNING: Failed to retrieve MphysOverMcal from DetStore")
                import traceback
                traceback.print_exc()
                self.larMphysOverMcal=None
 
            try:
                condCont=self._condStore.retrieve("CondCont<ILArRamp>","LArRamp")
                self.larRamp=condCont.find(eid)
            except Exception:
                print ("WARNING: Failed to retrieve LArRamp from DetStore")
                import traceback
                traceback.print_exc()
                self.larRamp=None
                
            try:
                condCont=self._condStore.retrieve("CondCont<ILArDAC2uA>","LArDAC2uA")
                self.larDAC2uA=condCont.find(eid)
            except Exception:
                print ("WARNING: Failed to retrieve LArDAC2uA from DetStore")
                import traceback
                traceback.print_exc()
                self.larDAC2uA=None
 
            try:
                condCont=self._condStore.retrieve("CondCont<ILAruA2MeV>","LAruA2MeV")
                self.laruA2MeV=condCont.find(eid)
            except Exception:
                print ("WARNING: Failed to retrieve LAruA2MeV from DetStore")
                import traceback
                traceback.print_exc()
                self.laruA2MeV=None
 
            try:
                condCont=self._condStore.retrieve("CondCont<ILArHVScaleCorr>","LArHVScaleCorr")
                self.larhvScaleCorr=condCont.find(eid)
            except Exception:
                print ("WARNING: Failed to retrieve LArHVScaleCorr from DetStore")
                import traceback
                traceback.print_exc()
                self.larhvScaleCorr=None
                
        if self.includeDSPTh:
            try:
                self.larDSPThr=self._detStore.retrieve("LArDSPThresholdsComplete","LArDSPThresholds")
            except Exception:
                print ("WARNING: Failed to retrieve LArDPSThresholds from DetStore")
                import traceback
                traceback.print_exc()
                self.larDSPThr=None   
 
        
        if self.includeLocation:
            try:
                condCont=self._condStore.retrieve("CondCont<CaloDetDescrManager>","CaloDetDescrManager")
                self.caloDDM = condCont.find(eid)
            except Exception:
                print("Failed to retrieve CaloDDM")
                return StatusCode.Failure            
 
        if self.nEvts==0:
            self.nEvts+=1
            #Process one 'dummy' event to make sure all DB connections get closed
            #print ("Dummy event...")
            return StatusCode.Success
 
        self.onlineID.set_do_checks(True)
        self.offlineID.set_do_checks(True)
        
        while (1):
            id=None
            chid=None
            rep_in=self.readInput() #"Enter Id >").upper().strip()
            #rep_in="EMBA 0 0 60 2"
            rep=rep_in.upper()
            
            #Quit
            if len(rep)==0 or rep=="QUIT" or rep=="EXIT" or rep==".Q": break
 
                               
            if rep.startswith("SEARCH"):
                inp=rep_in[6:].strip()
                starttime=time.time()
                self.search(inp)
                print("seach time %.1f sec" % (time.time()-starttime))
                continue
 
            #Help
            if rep=="HELP":
                self.printHelp()
                continue
 
 
 
            try:
                t_int=int(rep,10)
                t=Identifier(c_uint(t_int))
                if self.onlineID.is_lar(t):
                    print(t.get_identifier32().get_compact()," IsLAr (online)")
                if self.offlineID.is_lar(t):
                    print(t.get_identifier32().getCompact()," isLAr (offline)")
            except Exception:
                pass
 
 
 
            
 
            if rep.startswith("ON"):
                s=rep.find(" ")
                if s==-1:s=0
                chid=self.getOnlineIDFromString(rep[s:])
                if chid is not None and self.onlineID.is_lar(chid):
                    id=self.larCabling.cnvToIdentifier(chid)
                    if id is None: id=self.noid
                    self.printChannelInfo(id,chid)
                else:
                    print("ERROR: Could not interpret input.")
                    print("Interpretation as online ID gave:",self._onlErrStr)
                continue
 
            if rep.startswith("OF"):
                s=rep.find(" ")
                if s==-1:s=0
                id=self.getOfflineIDFromString(rep[s:])
                if id is not None and self.offlineID.is_lar(id):
                    chid=self.larCabling.createSignalChannelID(id)
                    self.printChannelInfo(id,chid)
                else:
                    print("ERROR: Could not interpret input.")
                    print("Interpretation as offline ID gave:",self._oflErrStr)
                continue
 
            #Try to interpet input as identifiers
            chid=self.getOnlineIDFromString(rep)
            if chid is not None and self.onlineID.is_lar(chid):
                id=self.larCabling.cnvToIdentifier(chid)
            else: #try interpret at offline ID
                id=self.getOfflineIDFromString(rep)
                if id is not None and self.offlineID.is_lar(id):
                     chid=self.larCabling.createSignalChannelID(id)
                     
            if chid is None or id is None:
                print( "ERROR: Could not interpret input.")
                print( "Interpretation as online ID gave:",self._onlErrStr)
                print( "Interpretation as offline ID gave:",self._oflErrStr)
                continue
 
            self.printChannelInfo(id,chid)
            #break
        return StatusCode.Success
 

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

◆ finalize()

python.LArCellConditionsAlg.LArCellConditionsAlg.finalize ( self )

Definition at line 362 of file LArCellConditionsAlg.py.

    def finalize(self):
        self.msg.info('finalizing...')
        return StatusCode.Success
 
 

◆ getOfflineIDFromString()

python.LArCellConditionsAlg.LArCellConditionsAlg.getOfflineIDFromString	(		self,
			input )

Definition at line 465 of file LArCellConditionsAlg.py.

    def getOfflineIDFromString(self,input):
        self._oflErrStr=""
        
        upInput=input.upper().strip()
        if upInput.startswith('0X'):
            #hex-input
            try:
                id_int=int(upInput,16)
            except Exception:
                self._oflErrStr="Can't interpret hexadecimal identifier, got " + upInput
                return None
            id=Identifier(id_int << 32)
            if not self.offlineID.is_lar(id):
                self._oflErrStr="Not a LAR identifier: " + upInput
                return None
 
        elif upInput.isdigit():
            try:
                id_int=int(upInput,10)
            except Exception:
                self._oflErrStr="Can't interpret decimal identifier, got "+upInput
                return None
            id=Identifier(id_int << 32)
 
            if not self.offlineID.is_lar(id):
                self._oflErrStr="Not a LAR identifier: " + upInput
                return None
 
        else: #given as expanded ID
            tbl=str.maketrans(r",:;/\#","      ")
            fields=[]
            for f in upInput.translate(tbl).split():
                if len(f):
                    fields+=[f]
            if len(fields)<5:
                self._oflErrStr="Not enough fields to build offline id"
                return None
            
            #Format: Subdet/Side/Layer/Region/Eta/Phi
            if fields[0].startswith("EMB"):
                subcalo=self.offlineID.LAREM
                bepn=1
            elif fields[0].startswith("EMECOW"):
                subcalo=self.offlineID.LAREM
                bepn=2
            elif fields[0].startswith("EMECIW"):
                subcalo=self.offlineID.LAREM
                bepn=3
            elif fields[0].startswith("HE"):
                subcalo=self.offlineID.LARHEC
                bepn=2
            elif fields[0].startswith("F"):
                subcalo=self.offlineID.LARFCAL
                bepn=2
            else:
                self._oflErrStr="Can't interpret subcalo field, got "+fields[0]
                return None
 
            if len(fields)==6:
                sidefield=fields[1]
            elif len(fields)==5:
                sidefield=fields[0]
            else:
                self._oflErrStr="Can't interpret input: Expected 5 or 6 sub-fields, found "+str(len(fields))
                return None
 
            if sidefield.endswith("A") or sidefield.endswith("P") or sidefield.endswith("POS") or sidefield == '1':
                side=1
            elif sidefield.endswith("C") or sidefield.endswith("N") or sidefield.endswith("NEG") or sidefield == '0':
                side=-1
            else:
                self._oflErrStr="Can't interpret field for detector side, got "+ sidefield
                return None
 
            bepn=bepn*side
 
 
            if fields[-4].isdigit():
                layer=int(fields[-4])
            else:
                ls=fields[-4]
                if (ls=="PS" or ls.startswith("PRES")): layer=0
                elif (ls=="FRONT" or ls.startswith("STRIP")): layer=1
                elif ls.startswith("MID"): layer=2
                elif ls=="BACK": layer=3
                else:
                    self._oflErrStr="Can't interpet textual value for layer, got " + ls
                    return None  
            try:
                region=int(fields[-3])
                eta=int(fields[-2])
                phi=int(fields[-1])
            except Exception:
                self._oflErrStr="Not-numerical input for region, eta or phi"
                return None
 
            #print ("Got",subcalo,bepn,layer,region,eta,phi)
            #self.offlineID.set_do_checks(True)
            try: #Build Region ID
                regid=self.offlineID.region_id(subcalo,bepn,layer,region)
            except Exception:
                self._oflErrStr="Failed to build offline region identifier. Layer/region values inconsistent?"
                return None   
                
            etamin=self.offlineID.eta_min(regid)
            etamax=self.offlineID.eta_max(regid)
            
            if (eta<etamin or eta>etamax):
                self._oflErrStr="Eta must be between %i and %i for this region, got %i" % (etamin,etamax,eta)
                return None
 
            phimin=self.offlineID.phi_min(regid)
            phimax=self.offlineID.phi_max(regid)
            if (phi<phimin or phi>phimax):
                self._oflErrStr="Phi must be between %i and %i for this region, got %i" % (phimin,phimax,phi)
                return None
 
            id=None
            try:
                id=self.offlineID.cell_id(regid,eta,phi)
                #id=self.offlineID.cell_id(subcalo,bepn,layer,region,eta,phi)
            except Exception:
                self._oflErrStr="Failed to build offline identifier. One or more values out-of-range?"
                id=None
                
            #self.offlineID.set_do_checks(False)
        return id
            
            

◆ getOnlineIDFromString()

python.LArCellConditionsAlg.LArCellConditionsAlg.getOnlineIDFromString	(		self,
			input )

Definition at line 594 of file LArCellConditionsAlg.py.

    def getOnlineIDFromString(self,input):
        #print ("onfline id input=[%s]" % input)
        self._onlErrStr=""
        upInput=input.upper().strip()
        if upInput.startswith('0X'):
            #hex-input
            try:
                id_int=int(upInput,16)
            except Exception:
                self._onlErrStr="Can't interpret hexadecimal online identifier, got "+input
                return None
 
            if (id_int < 0x38000000 or id_int > 0x3bc68000):
                self._onlErrStr="Outside of numerical range of online identifiers"
                return None
 
 
            id=HWIdentifier(id_int<<32)
            if not self.onlineID.is_lar(id):
                self._onlErrStr="Not a LAR identifier:" + input
                return None
            
        elif upInput.isdigit():
            try:
                id_int=int(upInput,10)
            except Exception:
                self._onlErrStr="Can't interpret decimal online identifier, got "+input
                return None
            
            if (id_int < 0x38000000 or id_int > 0x3bc68000):
                self._onlErrStr="Outside of numerical range of online identifiers"
                return None
 
            id=HWIdentifier(id_int<<32)
            if not self.onlineID.is_lar(id):
                self._onlErrStr="Not a LAR identifier:" + input
                return None
 
        else: #given as expanded ID
            tbl=str.maketrans(r",:;/\#","      ")
            fields=[]
            for f in upInput.translate(tbl).split():
                if len(f):
                    fields+=[f]
 
            #fields is now a 'clean array' of input
            #Format: B/EC Side FT Slot Chan
            if len(fields)==4:
                sideField=fields[0]
            elif len(fields)==5: # and len(fields[1])==1:
                sideField=fields[1]
            else:
                self._onlErrStr="Expected 4 or 5 fields, found "+str(len(fields))
                return None  
            
            if "BARREL".find(fields[0][0:6])==0:
                bec=0
            elif "ENDCAP".find(fields[0][0:6])==0:
                bec=1
            elif "EC".find(fields[0][0:2])==0:
                bec=1
            else:
                self._onlErrStr="Can't interpret field for Barrel/Endcap, got "+fields[0]
                return None 
            
            if sideField.endswith("A") or sideField=="1" or sideField.startswith("P"):
                side=1
            elif sideField.endswith("C") or sideField=="0" or sideField.startswith("N"):
                side=0
            else:
                self._onlErrStr="Can't interpret field for detector side, got " + sideField
                return None 
            try:
                chan=int(fields[-1])
                slot=int(fields[-2])
                ft=int(fields[-3])
            except Exception:
                self._onlErrStr="Not-numerical input for FT slot or channel"
                return None
 
            if bec==0:
                if ft<0 or ft>31:
                    self._onlErrStr="Barrel feedthrough number must be between 0 and 31, got "+str(slot)
                    return None
            else:
                if ft<0 or ft>24:
                    self._onlErrStr="Endcap feedthrough number must be between 0 and 24, got "+str(slot)
                    return None
 
            if slot<1 or slot>15:
                self._onlErrStr="Slot number must be between 1 and 15, got "+str(slot)
                return None
 
            if chan<0 or chan>127:
                self._onlErrStr="Channel number must be between 0 and 127, got "+str(chan)
                return None
            
            
            id=None  
            #self.onlineID.set_do_checks(True)
            try:
                id=self.onlineID.channel_Id(bec,side,ft,slot,chan)
            except Exception:
                self._onlErrStr="Failed to build online identifier. One or more values out-of-range?"
                id=None
            #self.onlineID.set_do_checks(False)
        return id
 
 

◆ IdentifiersToString()

python.LArCellConditionsAlg.LArCellConditionsAlg.IdentifiersToString	(	self,
		chid,
		id )

Definition at line 389 of file LArCellConditionsAlg.py.

    def IdentifiersToString(self,chid,id):
        onlName="None"
        oflName="None"
        if chid is not None:
            onlName=str(chid.get_identifier32().get_compact())+" " #+str(chid.get_compact())+" "
            #onlName=self.onlineID.channel_name(chid)
            bec=self.onlineID.barrel_ec(chid)
            side=self.onlineID.pos_neg(chid)
            ft=self.onlineID.feedthrough(chid)
            slot=self.onlineID.slot(chid)
            chan=self.onlineID.channel(chid)
            ftname=self.onlineID.feedthrough_name(chid) 
            
            if bec==0:
                onlName+="[BARREL/"
            else:
                onlName+="[ENDCAP/"
                
            if side==0:
                onlName+="C/"
            else:
                onlName+="A/"
 
            onlName+="FT "+str(ft)+"("+ftname+")/Slot "+str(slot)+"/Chan "+str(chan)
 
            try:
                calibLines=self.larCabling.calibSlotLine(chid)
                if (len(calibLines)):
                    onlName+="/CL"
                    for calib_chid in calibLines:
                        onlName+=" "+str(self.onlineID.channel(calib_chid))
            except Exception:
                pass
 
            onlName+=']'
            
        if id is not None:
 
            oflName=str(id.get_identifier32().get_compact()) + " "# +str(id.get_compact())+" "
 
            if (id==self.noid):#0xFFFFFFFF):
                oflName += "[disconnected]"
            else:
                subcalo=self.offlineID.sub_calo(id)
                side=self.offlineID.pos_neg(id)
                layer=self.offlineID.sampling(id)
                region=self.offlineID.region(id)
                eta=self.offlineID.eta(id)
                phi=self.offlineID.phi(id)
 
                if subcalo is self.offlineID.LAREM:
                    if abs(side)==1:
                        oflName+="[EMB"
                    elif abs(side)==2:
                        oflName+="[EMECOW"
                    elif abs(side)==3:
                        oflName+="[EMECIW"
                    else:
                        oflName+="[UNKNOWN"
                elif subcalo is self.offlineID.LARHEC:
                    oflName+="[HEC"
                elif subcalo is self.offlineID.LARFCAL:
                    oflName+="[FCAL"
                else:
                    oflName+="[UNKNOWN"
 
                oflName+="/"
                if side>0:
                    oflName+="A/"
                else:
                    oflName+="C/"
 
                oflName+="Lay "+str(layer)+"/Reg "+str(region)+"/Eta "+str(eta)+"/Phi "+str(phi) +"]"
        return onlName+" = "+oflName
        
        

◆ initialize()

python.LArCellConditionsAlg.LArCellConditionsAlg.initialize ( self )

Definition at line 48 of file LArCellConditionsAlg.py.

    def initialize(self):
        
 
        # Get DetectorStore...
 
        self._detStore =  PyAthena.py_svc('StoreGateSvc/DetectorStore')
        if self._detStore is None:
            self.msg.error("Failed to get DetectorStore")
            return StatusCode.Failure
 
        self._condStore = PyAthena.py_svc('StoreGateSvc/ConditionStore')
        if (self._condStore is None):
            self.msg.error("Failed to get ConditionStore")
            return StatusCode.Failure
 
        # Get LArOnlineID helper class
        self.onlineID=self._detStore.retrieve("LArOnlineID","LArOnlineID")
        if self.onlineID is None:
            self.msg.error("Failed to get LArOnlineID")
            return StatusCode.Failure
 
        # Get CaloCell_ID
        self.offlineID=self._detStore.retrieve("CaloCell_ID","CaloCell_ID")
        if self.offlineID is None:
            self.msg.error("Failed to get CaloCell_ID")
            return StatusCode.Failure
 
        self.bc_packing=LArBadChanBitPacking()
 
        self.noisepattern=0
        for n in ("lowNoiseHG","highNoiseHG","unstableNoiseHG","lowNoiseMG","highNoiseMG","unstableNoiseMG","lowNoiseLG","highNoiseLG","unstableNoiseLG","sporadicBurstNoise"):
            stat=self.bc_packing.enumName(n)
            if stat[0]:
                self.noisepattern |= 1<<stat[1]
 
        self.deadpattern=0
        for n in ("deadReadout","deadPhys","almostDead"):
            stat=self.bc_packing.enumName(n)
            if stat[0]:
                self.deadpattern |= 1<<stat[1]
 
        self.noid=Identifier()
 
    
 
        self.larPedestal=None
        self.larMphysOverMcal=None
        self.larRamp=None
        self.larDAC2uA=None
        self.laruA2MeV=None
        self.larhvScaleCorr=None
        self.larDSPThr=None
 
        return StatusCode.Success
 
        

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ output()

python.LArCellConditionsAlg.LArCellConditionsAlg.output	(	self,
		out,
		file = None )

Definition at line 367 of file LArCellConditionsAlg.py.

    def output(self,out,file=None):
        if file is not None: file.write(out+"\n")
        print(out)
        self.nLinesPrinted=self.nLinesPrinted+1
        if self.nLinesPrinted%40 == 0:
            c=input("Press 'q' to quit, 'a' for all ...")
            if c.upper().startswith("Q"):
                return True
            if c.upper().startswith("A"):
                self.nLinesPrinted=0xFFFFFFFF
        return False
 
 

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ printChannelInfo()

python.LArCellConditionsAlg.LArCellConditionsAlg.printChannelInfo	(	self,
		id,
		chid )

Definition at line 296 of file LArCellConditionsAlg.py.

    def printChannelInfo(self,id,chid):
        bc=self.badChannels.status(chid)
        print(self.IdentifiersToString(chid,id)+ " " + self.bc_packing.stringStatus(bc))
        if id!=self.noid: #Don't try to show anything more for disconnected channels
            if self.includeLocation:
                try:
                    #idHash=self.offlineID.calo_cell_hash(id)
                    theDDE=self.caloDDM.get_element(id)
                    print("raw Eta= %.3f, Phi=%.3f r=%.3f" % (theDDE.eta_raw(),theDDE.phi_raw(),theDDE.r_raw()))
                    print("raw x=%.3f, y=%.3f, z=%.3f" % (theDDE.x(),theDDE.y(),theDDE.z_raw()))
                except Exception as e:
                    print(e)
               
            if self.includeConditions:
                if self.larDAC2uA is not None:
                    print("DAC2uA: %.3f" % self.larDAC2uA.DAC2UA(chid), end="")
                else:
                    print("DAC2uA: None",end="")
                        
                if self.laruA2MeV is not None:
                    print(" uA2MeV: %.3f" % self.laruA2MeV.UA2MEV(chid),end="")
                else:
                    print(" uA2MeV: None",end="")
 
                if self.larhvScaleCorr is not None:
                    print(" HVScaleCorr: %.3f" % self.larhvScaleCorr.HVScaleCorr(chid))
                else:
                    print(" HVScaleCorr: None")
                          
                for gain,gainname in ((0,"HG"),(1,"MG"),(2,"LG")):
                    print(gainname,end="")
                    if self.larPedestal is not None:
                        ped=self.larPedestal.pedestal(chid,gain)
                        pedRMS=self.larPedestal.pedestalRMS(chid,gain)
                    else:
                        ped=-9999
                        pedRMS=-9999
 
                    print (" Ped: %.3f " % ped,end="")
                    print (" PedRMS: %.3f" % pedRMS,end="")
 
                    if self.larRamp is not None:
                        ramp=self.larRamp.ADC2DAC(chid,gain)
                        if len(ramp)>1:
                            print(" Ramp: %.3f" % ramp[1],end="")
                        else:
                            print(" Ramp: Empty",end="")
                    else:
                        print(" Ramp: None",end="")
 
                    if self.larMphysOverMcal is not None:
                        mpmc=self.larMphysOverMcal.MphysOverMcal(chid,gain)
                        print (" MphysOverMcal: %.5f" % mpmc,end="")
                    else:
                        print (" MphysOverMcal: None",end="")
                    print ("")
            if self.includeDSPTh:
                if self.larDSPThr is not None:
                    tQThr=self.larDSPThr.tQThr(chid)
                    samThr=self.larDSPThr.samplesThr(chid)
                    trgSumTrh=self.larDSPThr.trigSumThr(chid)
                    print("DSP Thresholds: tQ:%f, samples:%f, trigSum:%f" % (tQThr,samThr,trgSumTrh))
                else:
                    print("DSP Thresholds: None")
 
 

◆ printHelp()

python.LArCellConditionsAlg.LArCellConditionsAlg.printHelp ( self )

Definition at line 911 of file LArCellConditionsAlg.py.

    def printHelp(self):
        print( "First mode of operation:")
        print( "Enter a channel identifier (online or offline). Allowed forms are:")
        print( "  Decimal or hexadecimal compact identifier, eg. 'online 0x39000000'")
        print( "  Expanded identifer like")
        print( "     'online Bar C 1 1 1' (Barrel C FT 1, Slot 1 channel 1)")
        print( "     'offline FCAL A 1 0 1 1' (FCAL A, Layer 1, Region 0, Eta 1 Phi 1)")
        print( "    Offline ids must start with one of the following subdetectors names:")
        print( "     EMB, EMECIW, EMECOW, HEC, FCAL")
        print( "    Online ids must start with either 'BAR' or 'END'")
        print( "  If the prefix 'online' or 'offline' is omitted both are tried.")
        print( "\nSecond mode of operation:")
        print( "Search <keyword> <keyword> ..")
        print( "  Keywords are: 'barrel', 'endcap', A', 'C', or any bad-channel type")
        print( "  Keywords with arguments are: 'eta', 'phi', 'layer', 'FT', 'Slot' and 'CL'")
        print( "\nType 'quit' to terminate'")
 
 

◆ readInput()

python.LArCellConditionsAlg.LArCellConditionsAlg.readInput ( self )

Definition at line 380 of file LArCellConditionsAlg.py.

    def readInput(self):
        self.nLinesPrinted=0
        try:
            rep=input("Enter Id >")
        except Exception:
            return ""
 
        return rep.strip()
 

◆ reinitialize()

StatusCode Alg::reinitialize ( )

overridevirtualinherited

Definition at line 67 of file PyAthenaAlg.cxx.

{
  ATH_MSG_INFO("Re-Initializing " << name() << "...");
  return PyAthena::callPyMethod( m_self, "sysReinitialize" );
}

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ search()

python.LArCellConditionsAlg.LArCellConditionsAlg.search	(		self,
			input )

Definition at line 703 of file LArCellConditionsAlg.py.

    def search(self,input):
 
        subcalo=None
        eta=None
        phi=None
        bec=None
        side=None
        ft=None
        slot=None
        bctypes=0
        outname=None
        outfile=None
        layer=None
        cl=None
        tbl=str.maketrans(",:;#=","     ")
        tokens=[]
        for t in input.translate(tbl).split():
            if len(t):
                if (len(tokens)>0) and not tokens[-1].isalpha() and not t[0].isalpha():
                    tokens[-1]+=t
                else:
                    tokens+=[t]
                    
        def interpretToken(input):
            pos=input[1:].find("+-")
            if pos==-1:
                pos=input[1:].find("-")
                if pos==-1:
                    uplow=None
                    pos=len(input)-1
                else:
                    uplow=True
            else:
                uplow=False
 
 
            pos=pos+1
            try:
                e1=float(input[:pos])
            except Exception:
                print("Expected numerical value, got",input[:pos] )
                return None
 
            if uplow is not None:
                try:
                    e2=float(input[pos+1:])
                except Exception:
                    print("Expected numerical value after '+-', got",input[pos+1:])
                    return None
 
            
                if uplow:
                    ret=[e1,e2]
                else:
                    ret=[e1-e2,e1+e2]
            else:
                ret=[e1-0.025,e1+0.025]
            ret.sort()
            return ret
 
        i=0
        while (i<len(tokens)):
            if tokens[i].upper()=="OUT" and i+1<len(tokens):
                outname=tokens[i+1]
                i=i+1
            elif tokens[i].upper()=="ETA" and i+1<len(tokens):
                eta=interpretToken(tokens[i+1])
                i=i+1
            elif tokens[i].upper()=="LAYER" and i+1<len(tokens):
                layer=interpretToken(tokens[i+1])
                i=i+1
            elif tokens[i].upper()=="PHI" and i+1<len(tokens):
                phi=interpretToken(tokens[i+1])
                i=i+1
            elif tokens[i].upper()=="FT" and i+1<len(tokens):
                ft=interpretToken(tokens[i+1])
                i=i+1
            elif tokens[i].upper()=="SLOT" and i+1<len(tokens):
                 slot=interpretToken(tokens[i+1])
                 i=i+1
            elif tokens[i].upper()=="BAD":
                bctypes=0xFFFFFFFF
            elif tokens[i].upper()=="NOISE" or tokens[i].upper()=="NOISY":
                bctypes |= self.noisepattern
            elif tokens[i].upper()=="DEAD":
                bctypes |= self.deadpattern
            elif tokens[i].upper().startswith("BAR"):
                bec=0
            elif tokens[i].upper().startswith("END"):
                bec=1
            elif tokens[i].upper()=="EM":
                subcalo=self.offlineID.LAREM
            elif tokens[i].upper()=="HEC":
                subcalo=self.offlineID.LARHEC
            elif tokens[i].upper()=="FCAL":
                subcalo=self.offlineID.LARFCAL
            elif tokens[i].upper()=="A" or tokens[i]=="P":
                side=1
            elif tokens[i].upper()=="C" or tokens[i]=="N":
                side=0
            elif tokens[i].upper()=="CL" and tokens[i+1].isdigit():
                cl=int(tokens[i+1])
                i=i+1
            else:
                stat=self.bc_packing.enumName(tokens[i])
                if stat[0]:
                    bctypes |= 1<<stat[1]
                else:
                    print("Unknown Keyword",tokens[i]    )
            i=i+1
 
        print("Searching for cells with ",end="")
        if eta is not None: print(" %.3f <= eta <= %.3f" % (eta[0],eta[1]),end="")
        if phi is not None: print(" %.3f <= phi <= %.3f" % (phi[0],phi[1]),end="")
        if layer is not None: print(" %.0f <= layer <= %.0f" % (layer[0],layer[1]),end="")
 
        if bec==0: print(" Barrel",end="")
        if bec==1: print(" Endcap",end="")
 
        if side==1: print(" A Side",end="")
        if side==0: print(" C Side",end="")
 
        if ft is not None: print(" %.0f <= FT <= %.0f" % (ft[0],ft[1]),end="")
        if slot is not None: print(" %.0f <= Slot <= %.0f" % (slot[0],slot[1]),end="")
        
        if bctypes!=0:
            print (" "+self.bc_packing.stringStatus(LArBadChannel(bctypes)),end="")
 
        if phi is None and eta is None and bctypes==0 and ft is None and side is None and bec is None and slot is None and layer and subcalo is None:
            print ("No search criteria set!")
            return
 
 
        if cl is not None: print(" CL:",cl,end="")
 
        print(os.linesep)
 
        if not self.includeLocation and (eta is not None or phi is not None):
            print("ERROR: GeoModel not activated, run with -g option")
            return
            
        if outname is not None:
            try:
                outfile=open(outname,"w")
            except IOError:
                print ("ERROR failed to open file",outname)
                import traceback
                traceback.print_exc()
                outfile=None
                outname=None
                
          
        #for idH in range(self.offlineID.calo_cell_hash_max()): //This one includes also tile cells
        for idH in range(182468):
            idHash=IdentifierHash(idH)
            chid=self.larCabling.createSignalChannelIDFromHash(idHash)
            
            #print ("Loop hash=%i , on: %x , off: %x" % (idH, chid.get_identifier32().get_compact(), self.offlineID.cell_id(idHash).get_identifier32().get_compact()))
            #Check Bad-Channel Status
            bcstat=self.badChannels.status(chid)
            if bctypes!=0:
                bcw=bcstat.packedData()
                if bcw & bctypes == 0: continue
 
                    
            #Check Online Id
            if bec is not None and bec!=self.onlineID.barrel_ec(chid): continue
            if side is not None and side!=self.onlineID.pos_neg(chid): continue
            if ft is not None and (self.onlineID.feedthrough(chid)<ft[0] or self.onlineID.feedthrough(chid)>ft[1]): continue
            if slot is not None and (self.onlineID.slot(chid)<slot[0] or self.onlineID.slot(chid)>slot[1]): continue
 
            if cl is not None:
                try:
                    calibLines=self.larCabling.calibSlotLine(chid)
                    keep=False
                    for foundCLs in calibLines:
                        if self.onlineID.channel(foundCLs) == cl:
                            keep=True
                            break
                        
                    if not keep: continue
                                        
                except Exception:
                    print ("Failed to get calib line:")
                    import traceback
                    traceback.print_exc()
                    continue
 
            #Check geometrical location
            ep=""
            if eta is not None or phi is not None:
                theDDE=self.caloDDM.get_element(idHash)
                e=theDDE.eta()
                p=theDDE.phi()
                if eta is not None and (e<eta[0] or e>eta[1]): continue
                if phi is not None and (p<phi[0] or p>phi[1]): continue
                ep=" eta=%.3f phi=%.3f " % (e,p)
                
            id=self.offlineID.cell_id(idHash)
            if subcalo is not None and subcalo!=self.offlineID.sub_calo(id): continue
            if layer is not None and (self.offlineID.sampling(id)<layer[0] or self.offlineID.sampling(id)>layer[1]): continue
 
            br=self.output(self.IdentifiersToString(chid,id) + " " +ep+self.bc_packing.stringStatus(bcstat),outfile)
            if br: break
            
        if outfile is not None: outfile.close()
        return
  

◆ self()

virtual PyObject * PyAthena::Alg::self ( )

inlineoverridevirtualinherited

return associated python object.

BORROWED reference.

Implements IPyComponent.

Definition at line 71 of file PyAthenaAlg.h.

71{ return m_self; }

◆ setPyAttr()

bool Alg::setPyAttr ( PyObject * pyobj )

overrideprotectedvirtualinherited

attach the C++ component to its python cousin

Implements IPyComponent.

Definition at line 143 of file PyAthenaAlg.cxx.

{
  // now we tell the PyObject which C++ object it is the cousin of.
  RootUtils::PyGILStateEnsure ensure;
  PyObject* pyobj = TPython::CPPInstance_FromVoidPtr
    ( (void*)this, this->typeName() );
  if ( !pyobj ) {
    PyErr_Clear();
    // try PyAthena::Alg
    pyobj = TPython::CPPInstance_FromVoidPtr ((void*)this, "PyAthena::Alg");
    ATH_MSG_INFO
      ("could not dyncast component [" << name() << "] to a python "
       << "object of type [" << this->typeName() << "] (probably a missing "
       << "dictionary)" << endmsg
       << "fallback to [PyAthena::Alg]...");
  }
  if ( !pyobj ) {
    PyErr_Clear();
    ATH_MSG_WARNING("Could not dyncast component ["
                    << name() << "] to a pyobject of type [" 
                    << this->typeName() << "]");
  } else {
    if ( -1 == PyObject_SetAttrString(o, "_cppHandle", pyobj) ) {
      PyErr_Clear();
      ATH_MSG_WARNING
        ("Could not attach C++ handle [" << name() << "] to its python "
         << "cousin !");
      if ( -1 == PyObject_SetAttrString(o, "_cppHandle", Py_None) ) {
        PyErr_Clear();
        ATH_MSG_WARNING
          ("could not attach a dummy C++ handle [" << name() << "] to its "
           "python cousin !");
      }
    } else {
      return true;
    }
  }
  return false;
}

◆ start()

StatusCode Alg::start ( )

overridevirtualinherited

Definition at line 74 of file PyAthenaAlg.cxx.

{ 
  return PyAthena::callPyMethod( m_self, "sysStart" );
}

◆ stop()

StatusCode Alg::stop ( )

overridevirtualinherited

Definition at line 80 of file PyAthenaAlg.cxx.

{
  return PyAthena::callPyMethod( m_self, "sysStop" );
}

◆ sysInitialize()

StatusCode Alg::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthAlgorithm.

Definition at line 105 of file PyAthenaAlg.cxx.

{
  ServiceHandle<IPyComponentMgr> pyMgr
    ( "PyAthena::PyComponentMgr/PyComponentMgr", name() );
  if ( !pyMgr.retrieve().isSuccess() ) {
    ATH_MSG_ERROR("Could not retrieve service [" << pyMgr.typeAndName()
                  << "] !!");
    return StatusCode::FAILURE;
  }
 
  // first retrieve our python object cousin...
  m_self = pyMgr->pyObject( this );
 
  if ( m_self == Py_None ) {
    ATH_MSG_ERROR("Wrapped PyObject is NONE !");
    return StatusCode::FAILURE;
  }
 
  // re-route to usual sysInit...
  return AlgBase_t::sysInitialize();
}

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ typeName()

const char * Alg::typeName ( ) const

overridevirtualinherited

return the std::type_info name of the underlying py-component This is used by concrete implementations to connect a python component to its C++ counter-part

Implements IPyComponent.

Definition at line 132 of file PyAthenaAlg.cxx.

{ 
  static const std::string tname = System::typeinfoName(typeid(*this));
  return tname.c_str();
}

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ _condStore

python.LArCellConditionsAlg.LArCellConditionsAlg._condStore = PyAthena.py_svc('StoreGateSvc/ConditionStore')

protected

Definition at line 60 of file LArCellConditionsAlg.py.

◆ _detStore

python.LArCellConditionsAlg.LArCellConditionsAlg._detStore = PyAthena.py_svc('StoreGateSvc/DetectorStore')

protected

note that we are using the python logging service and that the PyAthena.Alg base class has already initialized it for us

Definition at line 55 of file LArCellConditionsAlg.py.

◆ _oflErrStr

python.LArCellConditionsAlg.LArCellConditionsAlg._oflErrStr

protected

Definition at line 274 of file LArCellConditionsAlg.py.

◆ _onlErrStr

python.LArCellConditionsAlg.LArCellConditionsAlg._onlErrStr

protected

Definition at line 262 of file LArCellConditionsAlg.py.

◆ badChannels

python.LArCellConditionsAlg.LArCellConditionsAlg.badChannels = condCont.find(eid)

Definition at line 126 of file LArCellConditionsAlg.py.

◆ bc_packing

python.LArCellConditionsAlg.LArCellConditionsAlg.bc_packing = LArBadChanBitPacking()

Definition at line 77 of file LArCellConditionsAlg.py.

◆ caloDDM

python.LArCellConditionsAlg.LArCellConditionsAlg.caloDDM = condCont.find(eid)

Definition at line 199 of file LArCellConditionsAlg.py.

◆ deadpattern

int python.LArCellConditionsAlg.LArCellConditionsAlg.deadpattern = 0

Definition at line 85 of file LArCellConditionsAlg.py.

◆ includeConditions

python.LArCellConditionsAlg.LArCellConditionsAlg.includeConditions = kw.get('printConditions',False)

Definition at line 39 of file LArCellConditionsAlg.py.

◆ includeDSPTh

python.LArCellConditionsAlg.LArCellConditionsAlg.includeDSPTh = kw.get('printDSPTh',False)

Definition at line 41 of file LArCellConditionsAlg.py.

◆ includeLocation

python.LArCellConditionsAlg.LArCellConditionsAlg.includeLocation = kw.get('printLocation',False)

Definition at line 40 of file LArCellConditionsAlg.py.

◆ larCabling

python.LArCellConditionsAlg.LArCellConditionsAlg.larCabling = condCont.find(eid)

Definition at line 118 of file LArCellConditionsAlg.py.

◆ larDAC2uA

python.LArCellConditionsAlg.LArCellConditionsAlg.larDAC2uA = None

Definition at line 98 of file LArCellConditionsAlg.py.

◆ larDSPThr

python.LArCellConditionsAlg.LArCellConditionsAlg.larDSPThr = None

Definition at line 101 of file LArCellConditionsAlg.py.

◆ larhvScaleCorr

python.LArCellConditionsAlg.LArCellConditionsAlg.larhvScaleCorr = None

Definition at line 100 of file LArCellConditionsAlg.py.

◆ larMphysOverMcal

python.LArCellConditionsAlg.LArCellConditionsAlg.larMphysOverMcal = None

Definition at line 96 of file LArCellConditionsAlg.py.

◆ larPedestal

python.LArCellConditionsAlg.LArCellConditionsAlg.larPedestal = None

Definition at line 95 of file LArCellConditionsAlg.py.

◆ larRamp

python.LArCellConditionsAlg.LArCellConditionsAlg.larRamp = None

Definition at line 97 of file LArCellConditionsAlg.py.

◆ laruA2MeV

python.LArCellConditionsAlg.LArCellConditionsAlg.laruA2MeV = None

Definition at line 99 of file LArCellConditionsAlg.py.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_self

PyObject* PyAthena::Alg::m_self

protectedinherited

Pointer to self (from the python world)

Definition at line 96 of file PyAthenaAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ nEvts

int python.LArCellConditionsAlg.LArCellConditionsAlg.nEvts = 0

Definition at line 43 of file LArCellConditionsAlg.py.

◆ nLinesPrinted

int python.LArCellConditionsAlg.LArCellConditionsAlg.nLinesPrinted = 0

Definition at line 42 of file LArCellConditionsAlg.py.

◆ noid

python.LArCellConditionsAlg.LArCellConditionsAlg.noid = Identifier()

Definition at line 91 of file LArCellConditionsAlg.py.

◆ noisepattern

int python.LArCellConditionsAlg.LArCellConditionsAlg.noisepattern = 0

Definition at line 79 of file LArCellConditionsAlg.py.

◆ offlineID

python.LArCellConditionsAlg.LArCellConditionsAlg.offlineID = self._detStore.retrieve("CaloCell_ID","CaloCell_ID")

Definition at line 72 of file LArCellConditionsAlg.py.

◆ onlineID

python.LArCellConditionsAlg.LArCellConditionsAlg.onlineID = self._detStore.retrieve("LArOnlineID","LArOnlineID")

Definition at line 66 of file LArCellConditionsAlg.py.

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

LArCellConditionsAlg.py

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ getOfflineIDFromString()

◆ getOnlineIDFromString()

◆ IdentifiersToString()

◆ initialize()

◆ inputHandles()

◆ msg()

◆ msgLvl()

◆ output()

◆ outputHandles()

◆ printChannelInfo()

◆ printHelp()

◆ readInput()

◆ reinitialize()

◆ renounce()

◆ renounceArray()

◆ search()

◆ self()

◆ setPyAttr()

◆ start()

◆ stop()

◆ sysInitialize()

◆ sysStart()

◆ typeName()

◆ updateVHKA()

Member Data Documentation

◆ _condStore

◆ _detStore

◆ _oflErrStr

◆ _onlErrStr

◆ badChannels

◆ bc_packing

◆ caloDDM

◆ deadpattern

◆ includeConditions

◆ includeDSPTh

◆ includeLocation

◆ larCabling

◆ larDAC2uA

◆ larDSPThr

◆ larhvScaleCorr

◆ larMphysOverMcal

◆ larPedestal

◆ larRamp

◆ laruA2MeV

◆ m_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_self

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ nEvts

◆ nLinesPrinted

◆ noid

◆ noisepattern

◆ offlineID

◆ onlineID

◆ init()