Inheritance diagram for python.subdetectors.tile.Tile:

Collaboration diagram for python.subdetectors.tile.Tile:

Public Member Functions
def	lrange (a, b)

def	calculate_dead_fraction (self, since, until, output_channel, states, state_iovs)

def	__init__ (self, args, *kwargs)

def	run (self, lbtime, run_iovs=None)

def	__repr__ (self)

def	get_variable (self, name)

def	set_input_mapping (self, what, mapping)

def	evaluate_inputs (self, lbtime)

def	merge_variable_states (self, states)

def	merge_inputs (self, channel, *inputs)

def	merge_input_information (self, channel, *inputs)

def	merge_input_variables (self, inputs)

def	map_inputs_to_outputs (self, inputs)

def	input_channel_set (self)

def	get_name_for_input_channel (self, input_channel)

def	get_ids_which_are (self, output_channel, states, what)

def	debug_what_changed (self, runlb, prev_states, states)

def	calculate_dead_fraction_all (self, output_channel, local_variables)

def	dq_worst (self, states)

def	merge_globals (self, output_channel, dead_frac_iovs, global_variables)

def	calculate_result_for_output (self, output_channel, local_variables, global_variables)

def	select_globals (self, output_channel, input_globals)

def	calculate_result (self, inputs_by_output, global_variables)

def	start (self)

def	done (self)

Static Public Member Functions
def	color_to_defect_translator (inflag, outdefect, badcolors=[RED])

Public Attributes
	translators

	keep_dcsofl

	input_to_output_map

	channel_indices

	run_iovs

Static Public Attributes
string	folder_base = "/TILE/DCS"

dictionary	mapping

	mapping2

list	variables

float	dead_fraction_caution = 0.01

float	dead_fraction_bad = 0.75

dictionary	dead_fraction_map

Detailed Description

Check the TILE/DCS/STATES FORDAQ_MBHV code for modules in a good state.
Excludes modules which are known to be entirely bad due to No HV so that 
shifters will notice problems with the STATE which are unrelated to this
known problem.

Definition at line 123 of file tile.py.

Constructor & Destructor Documentation

◆ init()

def python.subdetectors.tile.Tile.__init__	(		self,
		*	args,
		**	kwargs
	)

Definition at line 358 of file tile.py.

     def __init__(self, *args, **kwargs):
         #kwargs['keep_dcsofl'] = True
         super(Tile, self).__init__(*args, **kwargs)
         self.translators = [Tile.color_to_defect_translator(flag, defect, [RED, YELLOW])
                             for flag, defect in ((TILBA, 'TILE_LBA_TRIP'),
                                                  (TILBC, 'TILE_LBC_TRIP'),
                                                  (TIEBA, 'TILE_EBA_TRIP'),
                                                  (TIEBC, 'TILE_EBC_TRIP'),
                                                  )]
         self.set_input_mapping("/TILE/OFL02/STATUS/ADC", self.mapping2)

Member Function Documentation

◆ repr()

def python.subdetector.DCSC_Subdetector.__repr__ ( self )

inherited

Definition at line 39 of file subdetector.py.

     def __repr__(self):
         return self.__class__.__name__
     

◆ calculate_dead_fraction()

def python.subdetectors.tile.Tile.calculate_dead_fraction	(	self,
		since,
		until,
		output_channel,
		states,
		state_iovs
	)

This is for masking the unpowered Tile Cells.  It returns the actual fraction of Tile that is off
but the R/Y/G is adjusted so that the unpowered modules don't hide new problems.

Reimplemented from python.subdetector.DCSC_Subdetector.

Definition at line 337 of file tile.py.

     def calculate_dead_fraction(self, since, until, output_channel, states, 
                                 state_iovs):
         """
         This is for masking the unpowered Tile Cells.  It returns the actual fraction of Tile that is off
         but the R/Y/G is adjusted so that the unpowered modules don't hide new problems.  
         """
         cdf = super(Tile, self).calculate_dead_fraction
         result = cdf(since, until, output_channel, states, state_iovs)
         
         code, dead_fraction, thrust, n_config, n_working = result
  
         # Don't include channels which are "out of config" (see Tile_NoHighVoltage)
         dead_fraction = 1 - (n_working / n_config)
  
         # If n_working == n_config then we're good.
         if dead_fraction == 0:
             # Mask dead channels
             code = GREEN
         
         return code, dead_fraction, thrust, n_config, n_working
  

◆ calculate_dead_fraction_all()

def python.subdetector.DCSC_Subdetector.calculate_dead_fraction_all	(	self,
		output_channel,
		local_variables
	)

inherited

Definition at line 336 of file subdetector.py.

     def calculate_dead_fraction_all(self, output_channel, local_variables):
         
         log.debug("Calculating dead fractions for output: %i", output_channel)
  
         # local_variables is a list of IOVSets (one for each input channel), 
         # for this output channel.
         # Why would you call it local_variables?
         
         #prev_states = []
         
         dead_frac_iovs = IOVSet()
         calc_dead_frac = self.calculate_dead_fraction
         # loop over smallest IOV chunks for this output channel
         for since, until, states in process_iovs(self.run_iovs, *local_variables):
             run_iov = states[0]
             # state_iovs is now a list of iovs, one for each input channel mapped
             # to this output channel
             state_iovs = states[1:]
             
             states = [s.good for s in state_iovs]
                 
             if run_iov._is_empty:
                 # Ignore regions outside runs.
                 continue
             
             iov_state = calc_dead_frac(since, until, output_channel, 
                                        states, state_iovs)
                                        
             #dead_frac_iovs.add(since, until, output_channel, *iov_state)
             result_iov = DCSOFL_IOV(since, until, output_channel, *iov_state)
             result_iov._orig_iovs = state_iovs
             dead_frac_iovs.append(result_iov)
             
         return dead_frac_iovs#.solidify(DCSOFL_IOV)
     

◆ calculate_result()

def python.subdetector.DCSC_Subdetector.calculate_result	(	self,
		inputs_by_output,
		global_variables
	)

inherited

Terrible name for a method.
Calculate the iov extents and dead fractions for all output channels.
In other words, the IoVs to be written to DCSOFL for this subdetector.

Definition at line 464 of file subdetector.py.

     def calculate_result(self, inputs_by_output, global_variables):
         """
         Terrible name for a method.
         Calculate the iov extents and dead fractions for all output channels.
         In other words, the IoVs to be written to DCSOFL for this subdetector.
         """
         result = IOVSet(iov_type=DCSOFL_IOV)
         
         # loop over output channel dictionary
         for channel, input_iovs in sorted(six.iteritems(inputs_by_output)):
             these_globals = self.select_globals(channel, global_variables)
             args = channel, input_iovs, these_globals
             result.extend(self.calculate_result_for_output(*args))
             
         return result
         

◆ calculate_result_for_output()

def python.subdetector.DCSC_Subdetector.calculate_result_for_output	(	self,
		output_channel,
		local_variables,
		global_variables
	)

inherited

Calculate the iov extents and dead fractions for one output channel

* If there are 'non-global' variables, evaluate the dead fraction, which
  effectively becomes a new global variable.
* If there are no global variables, return the above as a result
* If there are global variables, merge them together.

Definition at line 426 of file subdetector.py.

     def calculate_result_for_output(self, output_channel,
                                     local_variables, global_variables):
         """
         Calculate the iov extents and dead fractions for one output channel
         
         * If there are 'non-global' variables, evaluate the dead fraction, which
           effectively becomes a new global variable.
         * If there are no global variables, return the above as a result
         * If there are global variables, merge them together.
         """
         
         dead_frac_iovs = IOVSet(iov_type=DCSOFL_IOV)
         
         if local_variables:
             dead_frac_iovs = self.calculate_dead_fraction_all(output_channel, 
                                                               local_variables)
         
         if not global_variables:
             # There are no globals, we're done.
             return dead_frac_iovs
         
         return self.merge_globals(output_channel, dead_frac_iovs, global_variables)
         

◆ color_to_defect_translator()

def python.subdetector.DCSC_DefectTranslate_Subdetector.color_to_defect_translator	(	inflag,
		outdefect,
		badcolors = `[RED]`
	)

staticinherited

Definition at line 559 of file subdetector.py.

     def color_to_defect_translator(inflag, outdefect, badcolors=[RED]):
         def translator_core(flag_iovs):
             rv = [DefectIOV(since=iov.since, until=iov.until,
                             channel=outdefect, present=True,
                             comment='Bad Fraction: %.3f' % iov.deadFrac)
                   for iov in flag_iovs if iov.channel == inflag
                   and iov.Code in badcolors]
             
             return rv
         return translator_core
  

◆ debug_what_changed()

def python.subdetector.DCSC_Subdetector.debug_what_changed	(	self,
		runlb,
		prev_states,
		states
	)

inherited

Apparently not used

Definition at line 331 of file subdetector.py.

     def debug_what_changed(self, runlb, prev_states, states):
         """Apparently not used"""
         changes = [(a, b) for a, b in zip(prev_states, states) if a != b]
         log.debug("Changes at %s: %i: %s", runlb, len(changes), tally(changes))
             

◆ done()

def python.subdetector.DCSC_Subdetector.done ( self )

inherited

An empty function which can be overloaded to do any needed 
post-processing

Definition at line 526 of file subdetector.py.

     def done(self):
         """
         An empty function which can be overloaded to do any needed 
         post-processing
         """
  

◆ dq_worst()

def python.subdetector.DCSC_Subdetector.dq_worst	(	self,
		states
	)

inherited

Make a DQ-colour decision based on `states`

Definition at line 371 of file subdetector.py.

     def dq_worst(self, states):
         """
         Make a DQ-colour decision based on `states`
         """
         states = set([s.Code for s in states])
         if   RED    in states: return RED
         elif YELLOW in states: return YELLOW
         elif WHITE  in states: return WHITE
         elif GREEN  in states: return GREEN
         return RED
     

◆ evaluate_inputs()

def python.subdetector.DCSC_Subdetector.evaluate_inputs	(	self,
		lbtime
	)

inherited

Read the cool database and determine the state of the input channels
by luminosity block

Definition at line 64 of file subdetector.py.

     def evaluate_inputs(self, lbtime):
         """
         Read the cool database and determine the state of the input channels
         by luminosity block
         """
  
         # inputs is literally the same as self.variables
         #    # Is this true?? I don't think it is
         # calculate_good_iovs will calculate the goodness of all input channels
         # and remap the channel ids if necessary.  
         # TODO: This could be rewritten to be more clear.
         inputs = [v.calculate_good_iovs(lbtime, self) for v in self.variables]
  
         # Why do we care what the hash value is for the variables??
         if log.isEnabledFor(logging.INFO):
             log.info("lbtime hash = % 09x, inputs hash = %09x",
                      hash(lbtime), hash(tuple(self.variables)))
         return inputs
     

◆ get_ids_which_are()

def python.subdetector.DCSC_Subdetector.get_ids_which_are	(	self,
		output_channel,
		states,
		what
	)

inherited

Definition at line 258 of file subdetector.py.

     def get_ids_which_are(self, output_channel, states, what):
         indices = [i for i, x in enumerate(states) if x is what]
         chan_indices = self.channel_indices[output_channel]
         input_chan_name = self.get_name_for_input_channel
         return [input_chan_name(chan_indices[i]) for i in indices]
         

◆ get_name_for_input_channel()

def python.subdetector.DCSC_Subdetector.get_name_for_input_channel	(	self,
		input_channel
	)

inherited

If it is possible to give a logical name for an input channel, return
it here. These numbers are used for debugging purposes.

By default, do nothing. Over-ridden by subdetectors

Definition at line 249 of file subdetector.py.

     def get_name_for_input_channel(self, input_channel):
         """
         If it is possible to give a logical name for an input channel, return
         it here. These numbers are used for debugging purposes.
         
         By default, do nothing. Over-ridden by subdetectors
         """
         return input_channel
     

◆ get_variable()

def python.subdetector.DCSC_Subdetector.get_variable	(	self,
		name
	)

inherited

Get a DCS_Variable by name.

Definition at line 42 of file subdetector.py.

     def get_variable(self, name):
         """
         Get a DCS_Variable by name.
         """
         for variable in self.variables:
             if variable.folder_name == name:
                 return variable
                 
         raise RuntimeError("Folder '%s' not found" % name)
                 

◆ input_channel_set()

def python.subdetector.DCSC_Subdetector.input_channel_set ( self )

inherited

Return a set containing the all input channel IDs for this subdetector

Definition at line 243 of file subdetector.py.

     def input_channel_set(self):
         """
         Return a set containing the all input channel IDs for this subdetector
         """
         return set(v for vals in self.mapping.values() for v in vals)
     

◆ lrange()

def python.subdetectors.tile.Tile.lrange	(	a,
		b
	)

Definition at line 146 of file tile.py.

146 def lrange(a, b): return list(range(a,b))

◆ map_inputs_to_outputs()

def python.subdetector.DCSC_Subdetector.map_inputs_to_outputs	(	self,
		inputs
	)

inherited

Determine which input channels belong to which output channels.
inputs is a list of IOVSets, exactly one per channel.

Definition at line 200 of file subdetector.py.

     def map_inputs_to_outputs(self, inputs):
         """
         Determine which input channels belong to which output channels.
         inputs is a list of IOVSets, exactly one per channel.
         """
         # Per output object, store a list of iov lists.
         result = {}
         
         # Keep a record of the channels we have seen, and what their index
         # will be in the states list. This is so that we can determine later
         # which channel a state belongs to. (For empty IoVs, for instance)
         self.channel_indices = {}
         seen_channels = set()
         
         empty_iovset_types = [iovs.empty_maker() for iovs in inputs]
         
         # input to output map is the inverse map with
         # key=input_channel and val=output_channel
         mapping = self.input_to_output_map
  
         # Loop over channels
         for iovs in inputs:
             if not iovs: continue # Can this happen?
             input_channel = iovs[0].channel
             if input_channel not in mapping: 
                 raise RuntimeError("channel not found in mapping: " + str(input_channel))
             seen_channels.add(input_channel)
             output_channel = mapping[input_channel]
             result.setdefault(output_channel, []).append(iovs)
             self.channel_indices.setdefault(output_channel, []).append(input_channel)
         
         missing_channels = self.input_channel_set - seen_channels
         
         for channel, make_iovset in zip(missing_channels, empty_iovset_types):
             # No IoVs for this channel. Append an empty IoV range.
             output_channel = mapping[channel]
             result.setdefault(output_channel, []).append(make_iovset())
             (self.channel_indices.setdefault(output_channel, [])
                                  .append(channel))
             
         return result
     

◆ merge_globals()

def python.subdetector.DCSC_Subdetector.merge_globals	(	self,
		output_channel,
		dead_frac_iovs,
		global_variables
	)

inherited

Merge together global states to decide a final code

If the dead fraction is unavailable, writes -1.

Definition at line 382 of file subdetector.py.

     def merge_globals(self, output_channel, dead_frac_iovs, global_variables):
         """
         Merge together global states to decide a final code
         
         If the dead fraction is unavailable, writes -1.
         """
         result_iovs = IOVSet()
         if self.run_iovs is not None:
             # run_iovs are used to constrain to what runs the calculator will
             # write. If there is a hole in `run_iovs`, then no records are emitted.
             state_ranges = process_iovs(self.run_iovs, dead_frac_iovs, *global_variables)
         else:
             state_ranges = process_iovs(dead_frac_iovs, *global_variables)
             
         for since, until, states in state_ranges:
             if self.run_iovs:
                 # No run_iovs were specified, so run for all available input data
                 run_iov, dead_frac_iov = states[:2]
                 
                 if run_iov._is_empty:
                     # We're outside of a run, don't write an IoV.
                     continue
                     
                 states = states[1:]
             else:
                 dead_frac_iov = states[0]
             
             if not dead_frac_iov._is_empty:
                 dead_fraction, thrust, n_config, n_working = dead_frac_iov[4:]
             else:
                 dead_fraction, thrust, n_config, n_working = -1., 0., -1, -1
                 states = states[1:]
             
             code = self.dq_worst(states)
             state = dead_fraction, thrust, n_config, n_working
             
             if code is WHITE:
                 # Don't write empty regions
                 continue
             
             result_iovs.add(since, until, output_channel, code, *state)
         
         return result_iovs.solidify(DCSOFL_IOV)            
     

◆ merge_input_information()

def python.subdetector.DCSC_Subdetector.merge_input_information	(		self,
			channel,
		*	inputs
	)

inherited

Join up the information which was used to make a decision across 
multiple variables.

Definition at line 137 of file subdetector.py.

     def merge_input_information(self, channel, *inputs):
         """
         Join up the information which was used to make a decision across 
         multiple variables.
         """
         result = IOVSet()
         for since, until, states in process_iovs(*inputs):
             info = tuple(state._orig_iov[3:] for state in states)
             result.add(since, until, channel, info)
             
         return result.solidify(GoodIOV) 
     

◆ merge_input_variables()

def python.subdetector.DCSC_Subdetector.merge_input_variables	(	self,
		inputs
	)

inherited

Merge multiple variables together for many channels.
Takes a list of IOVSets, one for each DCSC_Variable.

Definition at line 150 of file subdetector.py.

     def merge_input_variables(self, inputs):
         """
         Merge multiple variables together for many channels.
         Takes a list of IOVSets, one for each DCSC_Variable.
         """
  
         result = []
         info_states = IOVSet(iov_type=GoodIOV)
         
         # Reassign inputs to be a list of dictionaries with
         # Key=channel_id and Val=IOVSet
         inputs = [iovs.by_channel for iovs in inputs]
  
         # set of channel ids
         all_channels = sorted(set(y for x in inputs for y in x.keys()))
         
         tally_system_states = config.opts.tally_system_states
         
         for channel in all_channels:
  
             # Handle one channel at a time for variable merging
             c_inputs = [x[channel] for x in inputs]
             
             # Merge "good" state across multiple variables
             result.append(self.merge_inputs(channel, *c_inputs))
             
             if tally_system_states:
                 # Merge Input information across multiple variables
                 info_state = self.merge_input_information(channel, *c_inputs)
                 info_states.extend(info_state)
  
         
         if tally_system_states:
             # Print a tally of the states for the different systems
             from DQUtils.ext import tally
             def pretty(state):
                 return "/".join(x[0] for x in state)
             
             chans, iovs = zip(*sorted(six.iteritems(info_states.by_channel)))
             for since, until, states in process_iovs(self.run_iovs, *iovs):
                 if states[0]._is_empty:
                     # Not inside a run
                     continue
                 
                 statetally = tally(pretty(x.good) for x in states[1:])
                 
                 print(since, until, statetally)
             
         return result
         

◆ merge_inputs()

def python.subdetector.DCSC_Subdetector.merge_inputs	(		self,
			channel,
		*	inputs
	)

inherited

Merge multiple variables together for one input channel.
Each 'inputs' arg is an IOVSet that corresponds to this input channel.

Definition at line 121 of file subdetector.py.

     def merge_inputs(self, channel, *inputs):
         """
         Merge multiple variables together for one input channel.
         Each 'inputs' arg is an IOVSet that corresponds to this input channel.
         """
         # inputs must correspond to and be in sync with subdetector.variables...?
  
         result = IOVSet()
         # combine the IOVSets into smallest chunks using process_iovs
         for since, until, states in process_iovs(*inputs):
             # Get the worst state for the list of vectors
             state = self.merge_variable_states(states)
             result.add(since, until, channel, state)
             
         return result.solidify(GoodIOV)
     

◆ merge_variable_states()

def python.subdetector.DCSC_Subdetector.merge_variable_states	(	self,
		states
	)

inherited

Merge input channel states across variables, taking the worst.

For detector configuration variables, it is assumed that if no IoV 
exists for that channel in this variable, then it is in a good state.

Definition at line 83 of file subdetector.py.

     def merge_variable_states(self, states):
         """
         Merge input channel states across variables, taking the worst.
         
         For detector configuration variables, it is assumed that if no IoV 
         exists for that channel in this variable, then it is in a good state.
         """
  
         # Start off with a good result.
         result = True
  
         # This assumes that the states array is in sync with the variables array..
         # Maybe I could add an assert statement here.
         # WOA!  That's not cool!  TODO: MAKE THIS BETTER
         # I don't think it has broken anything before but depending on how the variables
         # are defined in a subdetector I think this could be very bad!!!
  
         # loop over states
         for state, variable in zip(states, self.variables):
             state = state.good if state else None
             if state == OUT_OF_CONFIG:
                 assert variable.is_config_variable, "OOC without is_config_variable!"
                 # If any state is out of config, we know the result.
                 return state
                 
             elif state is None or state < result:
                 if state is WHITE and variable.is_config_variable:
                     # Empty config variables are equivalent to "GOOD", so these
                     # states should be skipped.
                     continue
                 result = state
                 
         # More simplistic way of doing the above, but can't handle config vars:
         # return min(None if not state else state.good for state in states)
     
         return result
  
         

◆ run()

def python.subdetector.DCSC_DefectTranslate_Subdetector.run	(	self,
		lbtime,
		run_iovs = `None`
	)

inherited

Run the DCSC for this subdetector.

* Evaluate inputs
* Merge input variables together
* Calculate resulting IoVs to be written

Reimplemented from python.subdetector.DCSC_Subdetector.

Definition at line 544 of file subdetector.py.

     def run(self, lbtime, run_iovs=None):
         """
         Run the DCSC for this subdetector.
         
         * Evaluate inputs
         * Merge input variables together
         * Calculate resulting IoVs to be written
         """
         flag_iovs = super(DCSC_DefectTranslate_Subdetector, self).run(lbtime, run_iovs)
         translated = sum((func(flag_iovs) for func in self.translators), [])
         if self.keep_dcsofl:
             translated += flag_iovs
         return translated
  

◆ select_globals()

def python.subdetector.DCSC_Subdetector.select_globals	(	self,
		output_channel,
		input_globals
	)

inherited

Returns a list where each element is a list of (single channel) iovs.

The `input_globals` may contain a list of iovs which has multiple 
channels. This function may be over-ridden by inheriting classes to 
select channels for this output channel.

Reimplemented in python.subdetectors.lar.LAr.

Definition at line 449 of file subdetector.py.

     def select_globals(self, output_channel, input_globals):
         """
         Returns a list where each element is a list of (single channel) iovs.
         
         The `input_globals` may contain a list of iovs which has multiple 
         channels. This function may be over-ridden by inheriting classes to 
         select channels for this output channel.
         """
         global_iov_sets = []
         for input_global in input_globals:
             for channel, iovs in sorted(six.iteritems(input_global.by_channel)):
                 global_iov_sets.append(iovs)
             
         return global_iov_sets
         

◆ set_input_mapping()

def python.subdetector.DCSC_Subdetector.set_input_mapping	(	self,
		what,
		mapping
	)

inherited

Set mapping of input channels for a DCSC_Variable_With_Mapping.
Some input folders have different channel numbering conventions.

Definition at line 52 of file subdetector.py.

     def set_input_mapping(self, what, mapping):
         """
         Set mapping of input channels for a DCSC_Variable_With_Mapping.
         Some input folders have different channel numbering conventions.
         """
         variable = self.get_variable(what)
         # Mapping only makes sense for DCSC_Variable_With_Mapping
         if not isinstance(variable, DCSC_Variable_With_Mapping):
             raise RuntimeError("'%s' is not a DCSC_Variable_With_Mapping!")
             
         variable.input_channel_map = mapping
         

◆ start()

def python.subdetector.DCSC_Subdetector.start ( self )

inherited

Definition at line 523 of file subdetector.py.

     def start(self):
         "Empty function called at start"
         

Member Data Documentation

◆ channel_indices

python.subdetector.DCSC_Subdetector.channel_indices

inherited

Determine which input channels belong to which output channels.
inputs is a list of IOVSets, exactly one per channel.

Definition at line 211 of file subdetector.py.

◆ dead_fraction_bad

float python.subdetectors.tile.Tile.dead_fraction_bad = 0.75

static

Definition at line 175 of file tile.py.

◆ dead_fraction_caution

float python.subdetectors.tile.Tile.dead_fraction_caution = 0.01

static

Definition at line 174 of file tile.py.

◆ dead_fraction_map

dictionary python.subdetectors.tile.Tile.dead_fraction_map

static

Initial value:

=  {
        TILBA: dead_fraction_caution,
        TILBC: dead_fraction_caution,
        TIEBA: dead_fraction_caution,
        TIEBC: dead_fraction_caution
    }

Definition at line 329 of file tile.py.

◆ folder_base

string python.subdetectors.tile.Tile.folder_base = "/TILE/DCS"

static

Definition at line 131 of file tile.py.

◆ input_to_output_map

python.subdetector.DCSC_Subdetector.input_to_output_map

inherited

Definition at line 37 of file subdetector.py.

◆ keep_dcsofl

python.subdetector.DCSC_DefectTranslate_Subdetector.keep_dcsofl

inherited

Definition at line 542 of file subdetector.py.

◆ mapping

dictionary python.subdetectors.tile.Tile.mapping

static

Initial value:

=  {
        TILBA: lrange(49, 52) + [65] + [55] + lrange(61, 64) + [16] + 
               lrange(1, 16) + lrange(17, 49) + lrange(52, 55) + lrange(56, 61),
 
        TILBC: lrange(114, 118) + [121] + lrange(127, 130) +  [81] + lrange(66, 81) + 
               lrange(82, 114) + lrange(118, 121) + lrange( 122, 127),
 
        TIEBA: lrange(241, 245) + [248] + lrange(254, 257) + [208] + lrange(193, 208) + 
               lrange(209, 241) + lrange(245, 248) + lrange(249, 254),
 
        TIEBC: lrange(177, 181) + [184] + lrange(190, 193) + [145] + lrange(131, 134) + 
               [64] + lrange(134, 145) + lrange(146, 163) + [130] + lrange(163, 177) + 
               lrange(181, 184) + lrange(185, 190)
    }

Definition at line 147 of file tile.py.

◆ mapping2

python.subdetectors.tile.Tile.mapping2

static

Initial value:

=  dict( list(zip(range( 20,  84), mapping[TILBA])) +
                     list(zip(range( 84, 148), mapping[TILBC])) +
                     list(zip(range(148, 212), mapping[TIEBA])) +
                     list(zip(range(212, 276), mapping[TIEBC]))
                   )

Definition at line 162 of file tile.py.

◆ run_iovs

python.subdetector.DCSC_Subdetector.run_iovs

inherited

Run the DCSC for this subdetector.

* Evaluate inputs
* Merge input variables together
* Calculate resulting IoVs to be written

Definition at line 489 of file subdetector.py.

◆ translators

python.subdetectors.tile.Tile.translators

Definition at line 361 of file tile.py.

◆ variables

list python.subdetectors.tile.Tile.variables

static

Initial value:

=  [
        #DCSC_Variable("STATES", lambda iov: iov.FORDAQ_MBHV == 212222),
        DCSC_Variable("STATES", lambda iov: iov.FORDAQ_MBHV in (212222, 202221)),
        Tile_NoHighVoltage("/TILE/OFL02/STATUS/ADC", None)
    ]

Definition at line 168 of file tile.py.

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

tile.py

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __repr__()

◆ calculate_dead_fraction()

◆ calculate_dead_fraction_all()

◆ calculate_result()

◆ calculate_result_for_output()

◆ color_to_defect_translator()

◆ debug_what_changed()

◆ done()

◆ dq_worst()

◆ evaluate_inputs()

◆ get_ids_which_are()

◆ get_name_for_input_channel()

◆ get_variable()

◆ input_channel_set()

◆ lrange()

◆ map_inputs_to_outputs()

◆ merge_globals()

◆ merge_input_information()

◆ merge_input_variables()

◆ merge_inputs()

◆ merge_variable_states()

◆ run()

◆ select_globals()

◆ set_input_mapping()

◆ start()

Member Data Documentation

◆ channel_indices

◆ dead_fraction_bad

◆ dead_fraction_caution

◆ dead_fraction_map

◆ folder_base

◆ input_to_output_map

◆ keep_dcsofl

◆ mapping

◆ mapping2

◆ run_iovs

◆ translators

◆ variables

◆ init()

◆ repr()