python.variable.DCSC_Variable Class Reference

Inheritance diagram for python.variable.DCSC_Variable:

Collaboration diagram for python.variable.DCSC_Variable:

Public Member Functions
def	__init__ (self, folder_name, evaluator, **kwargs)
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	quantize (self, lbtime, iovs)
def	make_good_iov (self, iov)
def	make_good_iovs (self, iovs)
def	calculate_good_iovs (self, lbtime, subdetector)

Public Attributes
	input_db
	folder_name
	evaluator
	fetch_args
	input_hashes
	subdetector
	iovs

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

Detailed Description

Class which encapsulates logic behind an input variable.

This class is responsible for:

* Reading data from COOL / CoraCOOL
* Evaluating the 'good' state of a variable once read from the database
* Quantizing the state from time-based intervals of validity to lumiblock

It is subclassed for configuration variables and "global" variables.

Definition at line 33 of file variable.py.

Constructor & Destructor Documentation

__init__()

def python.variable.DCSC_Variable.__init__	(		self,
			folder_name,
			evaluator,
		**	kwargs
	)

Reimplemented in python.variable.DCSC_Defect_Global_Variable.

Definition at line 51 of file variable.py.

    def __init__(self, folder_name, evaluator, **kwargs):
        if not hasattr(self, 'input_db'):
            self.input_db = 'COOLOFL_DCS/CONDBR2'
        self.folder_name = folder_name
        self.evaluator = evaluator
        if not hasattr(self, "fetch_args"):
            self.fetch_args = {}
        self.__dict__.update(kwargs)
        self.input_hashes = []
    

Member Function Documentation

__hash__()

def python.variable.DCSC_Variable.__hash__

(

self

)

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

)

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
	)

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_Variable.make_good_iov	(		self,
			iov
	)

Determine if one input iov is good.

Reimplemented in python.variable.DCSC_Global_Variable, and python.subdetectors.tile.Tile_NoHighVoltage.

Definition at line 165 of file variable.py.

    def make_good_iov(self, iov):
        """
        Determine if one input iov is good.
        """
        giov = GoodIOV(iov.since, iov.until, iov.channel, self.evaluator(iov))
        giov._orig_iov = iov
        return giov
    

make_good_iovs()

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

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
	)

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
	)

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_Variable.quantize	(		self,
			lbtime,
			iovs
	)

Quantize "good state" timewise-iovs to lumiblocks.
OUT_OF_CONFIG gets priority over BAD if BAD and OUT_OF_CONFIG overlap
the same lumiblock.

Reimplemented in python.variable.DCSC_Defect_Global_Variable, and python.variable.DCSC_Global_Variable.

Definition at line 148 of file variable.py.

    def quantize(self, lbtime, iovs):
        """
        Quantize "good state" timewise-iovs to lumiblocks.
        OUT_OF_CONFIG gets priority over BAD if BAD and OUT_OF_CONFIG overlap
        the same lumiblock.
        """
        IOVSet = iovs.empty
        iovs = [iovs_ for c, iovs_ in sorted(iovs.by_channel.items())]
        
        def quantizer (iovs):
            return min(i.good for i in iovs) if iovs else None
        
        result = quantize_iovs_slow_mc(lbtime, iovs, quantizer)
        return IOVSet(GoodIOV(*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
	)

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

evaluator

python.variable.DCSC_Variable.evaluator

Definition at line 55 of file variable.py.

fetch_args

python.variable.DCSC_Variable.fetch_args

Definition at line 57 of file variable.py.

folder_name

python.variable.DCSC_Variable.folder_name

Definition at line 54 of file variable.py.

input_db

python.variable.DCSC_Variable.input_db

Definition at line 53 of file variable.py.

input_hashes

python.variable.DCSC_Variable.input_hashes

Definition at line 59 of file variable.py.

iovs

python.variable.DCSC_Variable.iovs

Definition at line 221 of file variable.py.

is_config_variable

bool python.variable.DCSC_Variable.is_config_variable = False

static

Definition at line 48 of file variable.py.

is_global

bool python.variable.DCSC_Variable.is_global = False

static

Definition at line 47 of file variable.py.

subdetector

python.variable.DCSC_Variable.subdetector

Definition at line 185 of file variable.py.

timewise_folder

bool python.variable.DCSC_Variable.timewise_folder = True

static

Definition at line 49 of file variable.py.

---

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

• variable.py