python.variable.DCSC_Global_Variable Class Reference

Inheritance diagram for python.variable.DCSC_Global_Variable:

Collaboration diagram for python.variable.DCSC_Global_Variable:

Public Member Functions
def	__init__ (self, folder_name, evaluator, caution_evaluator=None, **kwargs)
def	make_good_iov (self, iov)
def	quantize (self, lbtime, iovs)
def	__hash__ (self)
def	__repr__ (self)
def	read (self, query_range, folder_base, folder_name)
def	print_time_info (self, iovs)
def	map_input_channels (self, iovs)
def	make_good_iovs (self, iovs)
def	calculate_good_iovs (self, lbtime, subdetector)

Public Attributes
	caution_evaluator
	input_db
	folder_name
	evaluator
	fetch_args
	input_hashes
	subdetector
	iovs

Static Public Attributes
bool	is_global = True
bool	is_config_variable = False
bool	timewise_folder = True

Detailed Description

A global variable.

This class over-rides the behaviour for evaluating the "goodness" of an 
input channel. It allows for an intermediate state (caution) between good
and bad.

Definition at line 232 of file variable.py.

Constructor & Destructor Documentation

__init__()

def python.variable.DCSC_Global_Variable.__init__	(		self,
			folder_name,
			evaluator,
			caution_evaluator = None,
		**	kwargs
	)

Definition at line 242 of file variable.py.

    def __init__(self, folder_name, evaluator, caution_evaluator=None, **kwargs):
        super(DCSC_Global_Variable, self).__init__(folder_name, evaluator, **kwargs)
        
        self.caution_evaluator = caution_evaluator
        

Member Function Documentation

__hash__()

def python.variable.DCSC_Variable.__hash__ (   self )

inherited

Useful for verifying if input variables have changed.

Definition at line 61 of file variable.py.

    def __hash__(self):
        """
        Useful for verifying if input variables have changed.
        """
        # Consider the fact that hash((hash(x), hash(y))) == hash((x, y)) where
        # x and y are tuples.
        return hash(tuple(self.input_hashes))
    

__repr__()

def python.variable.DCSC_Variable.__repr__ (   self )

inherited

Definition at line 69 of file variable.py.

    def __repr__(self):
        return "<DCSCVariable %s>" % self.folder_name
    

calculate_good_iovs()

def python.variable.DCSC_Variable.calculate_good_iovs (   self,   lbtime,   subdetector  )

inherited

Calculate LB-wise "good" states

Definition at line 180 of file variable.py.

    def calculate_good_iovs(self, lbtime, subdetector):
        """
        Calculate LB-wise "good" states
        """
 
        self.subdetector = subdetector
        
        if self.timewise_folder:
            query_range = RANGEIOV_VAL(lbtime.first.since, lbtime.last.until)
        else:
            a, b = lbtime.first, lbtime.last
            query_range = RANGEIOV_VAL(RunLumi(a.Run, a.LumiBlock), 
                                       RunLumi(b.Run, b.LumiBlock))
        
        # Read the database
        iovs = self.read(query_range, subdetector.folder_base, self.folder_name)
        #iovs.pprint()
 
        # Decide the states of the input iovs
        iovs = self.make_good_iovs(iovs)
        #iovs.pprint()
        
        # Apply a mapping for input channels if necessary
        # This only does something for variables that require additional mapping
        # i.e., if the channel numbers for different DCS variables don't match up
        iovs = self.map_input_channels(iovs)
 
        if self.timewise_folder and not config.opts.timewise:
            # we might already know the defect mapping
            with timer("Quantize %s (%i iovs over %i lbs)" % 
                       (self.folder_name, len(iovs), len(lbtime))):
                # Quantize to luminosity block
                iovs = self.quantize(lbtime, iovs)
        #iovs.pprint()
            
        # Debug printout of problematic channels
        # DQUtils messes with the logging and isEnabledFor doesn't work
        #if log.isEnabledFor(logging.DEBUG):
        #log.verbose("Bad input channels for %s:", self.folder_name)
        #log.verbose("= [%r]", ", ".join(str(i.channel) for i in iovs if not i.good))
 
        self.iovs = iovs
        
        return self
 

make_good_iov()

def python.variable.DCSC_Global_Variable.make_good_iov	(		self,
			iov
	)

Determine DQ colour for this global variable iov.

Reimplemented from python.variable.DCSC_Variable.

Definition at line 247 of file variable.py.

    def make_good_iov(self, iov):
        """
        Determine DQ colour for this global variable iov.
        """
        
        if self.evaluator(iov):
            state = GREEN
            
        elif self.caution_evaluator and self.caution_evaluator(iov):
            state = YELLOW
        
        else:
            state = RED
            
        return CodeIOV(iov.since, iov.until, iov.channel, state)
 

make_good_iovs()

def python.variable.DCSC_Variable.make_good_iovs (   self,   iovs  )

inherited

Determine whether each iov signifies a good or bad state.

Reimplemented in python.subdetectors.tile.Tile_NoHighVoltage, and python.subdetectors.sct.DCSC_Variable_SCT_Config.

Definition at line 173 of file variable.py.

    def make_good_iovs(self, iovs):
        """
        Determine whether each iov signifies a good or bad state.
        """
        make_good_iov = self.make_good_iov
        return IOVSet(make_good_iov(iov) for iov in iovs)
    

map_input_channels()

def python.variable.DCSC_Variable.map_input_channels (   self,   iovs  )

inherited

By default, do nothing. Overloaded by DCSC_Variable_With_Mapping.

Reimplemented in python.variable.DCSC_Variable_With_Mapping.

Definition at line 142 of file variable.py.

    def map_input_channels(self, iovs):
        """
        By default, do nothing. Overloaded by DCSC_Variable_With_Mapping.
        """
        return iovs
    

print_time_info()

def python.variable.DCSC_Variable.print_time_info (   self,   iovs  )

inherited

Logs the first and last insertion times of the IoVs, and their ranges.

Definition at line 125 of file variable.py.

    def print_time_info(self, iovs):
        """
        Logs the first and last insertion times of the IoVs, and their ranges.
        """
        first_value, last_value = iovs.range_iov
        
        log.info("Times for %s:", self)
        log.info("  IoV      : (first)%26s (last)%26s", 
                    first_value.date, last_value.date)
        
        if not hasattr(iovs.first, "insertion_time"):
            log.info("Insertion time not available")
        else:
            insertion_times = [iov.insertion_time for iov in iovs]
            log.info("  Insertion: (first)%26s (last)%26s", 
                        min(insertion_times), max(insertion_times))
    

quantize()

def python.variable.DCSC_Global_Variable.quantize	(		self,
			lbtime,
			iovs
	)

Needs a different quantizer. (The default DQ quantizer will do)

Reimplemented from python.variable.DCSC_Variable.

Definition at line 263 of file variable.py.

    def quantize(self, lbtime, iovs):
        """
        Needs a different quantizer. (The default DQ quantizer will do)
        """
        iovs = [iovs_ for c, iovs_ in sorted(iovs.by_channel.items())]
        # Custom quantizer not needed        
        result = quantize_iovs_slow_mc(lbtime, iovs)
        return IOVSet(CodeIOV(*iov) 
                      for iovs in result 
                      for iov in iovs 
                      if iov[0].run == iov[1].run)
 

read()

def python.variable.DCSC_Variable.read (   self,   query_range,   folder_base,   folder_name  )

inherited

Read the relevant data from COOL for this variable

Definition at line 72 of file variable.py.

    def read(self, query_range, folder_base, folder_name):
        """
        Read the relevant data from COOL for this variable
        """
        if folder_name.startswith("/"):
            folder_path = folder_name
        else:
            # For relative folders prepend the folder_base
            folder_path = "/".join((folder_base, folder_name))
        
        log.info("Querying COOL folder %s", folder_path)
        
        if config.opts.check_input_time:
            self.fetch_args["with_time"] = True
        
        # Massage DB access
        if '/' in self.input_db:
            newdbstring = self.input_db.rsplit('/', 1)[0]
        else:
            newdbstring = self.input_db
        if config.opts.input_database.startswith('sqlite'):
            self.fetch_args['database'] = config.opts.input_database
        else:
            self.fetch_args['database'] = ('%s/%s' % (newdbstring, config.opts.input_database))
        if self.fetch_args:
            log.debug("Fetching with args: %r", self.fetch_args)
            
        iovs = fetch_iovs(folder_path, *query_range, **self.fetch_args)
 
        # Prints even when not doing debug.
        # TODO: fix this. Might be broken in DQUtils.logger
        #if log.isEnabledFor(logging.DEBUG):
        #    log.debug("Dumping input IOVs:")
        #    for iov in iovs:
        #        print iov
 
        #Remove Old TGC Chambers
        original_length=len(list(iovs))
        if folder_path=='/TGC/DCS/PSHVCHSTATE':
            for i in range(original_length-1, -1, -1):
                if  list(iovs)[i].channel in range(5504,5552) or list(iovs)[i].channel in range(7362,7411):
                    iovs.pop(i)
        
        if config.opts.check_input_time:
            self.print_time_info(iovs)
            
        if log.isEnabledFor(logging.INFO):
            input_hash = hash(iovs)
            self.input_hashes.append(input_hash)
            log.info("  -> Input hash: % 09x (len=%i)", input_hash, len(iovs))
            
        return iovs
    

Member Data Documentation

caution_evaluator

python.variable.DCSC_Global_Variable.caution_evaluator

Definition at line 245 of file variable.py.

evaluator

python.variable.DCSC_Variable.evaluator

inherited

Definition at line 55 of file variable.py.

fetch_args

python.variable.DCSC_Variable.fetch_args

inherited

Definition at line 57 of file variable.py.

folder_name

python.variable.DCSC_Variable.folder_name

inherited

Definition at line 54 of file variable.py.

input_db

python.variable.DCSC_Variable.input_db

inherited

Definition at line 53 of file variable.py.

input_hashes

python.variable.DCSC_Variable.input_hashes

inherited

Definition at line 59 of file variable.py.

iovs

python.variable.DCSC_Variable.iovs

inherited

Definition at line 221 of file variable.py.

is_config_variable

bool python.variable.DCSC_Variable.is_config_variable = False

staticinherited

Definition at line 48 of file variable.py.

is_global

bool python.variable.DCSC_Global_Variable.is_global = True

static

Definition at line 240 of file variable.py.

subdetector

python.variable.DCSC_Variable.subdetector

inherited

Definition at line 185 of file variable.py.

timewise_folder

bool python.variable.DCSC_Variable.timewise_folder = True

staticinherited

Definition at line 49 of file variable.py.

---

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

• variable.py