Inheritance diagram for python.virtual_logic.DefectLogic:

Collaboration diagram for python.virtual_logic.DefectLogic:

Public Types
typedef HLT::TypeInformation::for_each_type_c< typenameEDMLIST::map, my_functor, my_result<>, my_arg< HLT::TypeInformation::get_cont, CONTAINER > >::type	result

Public Member Functions
None	__init__ (self, defect_iov)
DEFECT_IOV	bad_evaluator (self, states)
None	set_evaluation (self, bool full)
DEFECT_IOV	evaluate_full (self, Mapping[str, DEFECT_IOV] states)
DEFECT_IOV	evaluate_partial (self, Mapping[str, DEFECT_IOV] states)

Public Attributes
	name = defect_iov.channel
	clauses = defect_iov.clauses.split()
	operations = set()
	inverting = set()
	realclauses = set(_[1] for _ in self.operations)
	primary_defects = set()
DEFECT_IOV	evaluate = self.bad_evaluator
list	dependencies

Protected Member Functions
None	_operations_parse (self)
None	_populate (self, Mapping[str, DefectLogic] defect_logics)

Detailed Description

Definition at line 9 of file virtual_logic.py.

Member Typedef Documentation

◆ result

typedef HLT::TypeInformation::for_each_type_c<typenameEDMLIST::map,my_functor,my_result<>,my_arg<HLT::TypeInformation::get_cont,CONTAINER>>::type master_search< typenameEDMLIST::map, HLT::TypeInformation::get_cont, CONTAINER >::result

inherited

Definition at line 90 of file EDM_MasterSearch.h.

Constructor & Destructor Documentation

◆ init()

None python.virtual_logic.DefectLogic.__init__	(		self,
			defect_iov )

Definition at line 10 of file virtual_logic.py.

    def __init__(self, defect_iov) -> None:
        self.name = defect_iov.channel
        self.clauses = defect_iov.clauses.split()
        self.operations = set()
        self.inverting = set()
        self._operations_parse()
        self.realclauses = set(_[1] for _ in self.operations)
        self.primary_defects = set()
        self.evaluate = self.bad_evaluator
        

Member Function Documentation

◆ _operations_parse()

None python.virtual_logic.DefectLogic._operations_parse ( self )

protected

Definition at line 29 of file virtual_logic.py.

    def _operations_parse(self) -> None:
        from operator import truth, not_
        for name in self.clauses:
            if name[0] == '!':
                self.operations.add((not_, name[1:]))
                self.inverting.add(name[1:])
            else:
                self.operations.add((truth, name))
    

◆ _populate()

None python.virtual_logic.DefectLogic._populate	(		self,
		Mapping[str, DefectLogic]	defect_logics )

protected

Populate the dependencies with logic objects, and the primary defects.

Definition at line 38 of file virtual_logic.py.

    def _populate(self, defect_logics: Mapping[str, DefectLogic]) -> None:
        """
        Populate the dependencies with logic objects, and the primary defects.
        """
        self.dependencies = [defect_logics[name] for _, name in self.operations 
                             if name in defect_logics]
                             
        # Primary defects are those which aren't in the logics dictionary.
        self.primary_defects = set(c for _, c in self.operations
                                   if c not in defect_logics)
                                   

◆ bad_evaluator()

DEFECT_IOV python.virtual_logic.DefectLogic.bad_evaluator	(		self,
			states )

Definition at line 20 of file virtual_logic.py.

    def bad_evaluator(self, states) -> DEFECT_IOV:
        raise RuntimeError("bad_evaluator should never be called")
    

◆ evaluate_full()

DEFECT_IOV python.virtual_logic.DefectLogic.evaluate_full	(		self,
		Mapping[str, DEFECT_IOV]	states )

Evaluate this defect logic for a point in time.

Parameters
    `states` :

Definition at line 49 of file virtual_logic.py.

    def evaluate_full(self, states: Mapping[str, DEFECT_IOV]) -> DEFECT_IOV:
        """
        Evaluate this defect logic for a point in time.
        
        Parameters
            `states` :
        """
        from operator import not_
        inputs = [(op, states[c]) for op, c in self.operations if c in states if states[c]]
        #inputs = [x for x in inputs if x]
        uninverted = [_ for _ in self.inverting if _ not in states or not states[_]]
        if not inputs and not uninverted:
            return None
        return DEFECT_IOV(None, None, self.name,
            present    =reduce(bool.__or__,  (op(i.present)     for op, i in inputs), False) or len(uninverted),
            recoverable=reduce(bool.__and__, (not not i.recoverable for op, i in inputs
                                              if op(i.present)), False),
            user="sys:virtual",
            comment=" ".join(sorted([(('!' if op == not_ else '') + i.channel) for op, i in inputs if op(i.present)]
                             +['!'+_ for _ in uninverted]))
        )
        

◆ evaluate_partial()

DEFECT_IOV python.virtual_logic.DefectLogic.evaluate_partial	(		self,
		Mapping[str, DEFECT_IOV]	states )

Evaluate this defect logic for a point in time.

Parameters
    `states` :

Definition at line 71 of file virtual_logic.py.

    def evaluate_partial(self, states: Mapping[str, DEFECT_IOV]) -> DEFECT_IOV:
        """
        Evaluate this defect logic for a point in time.
        
        Parameters
            `states` :
        """
        inputs = [(op, states[c]) for op, c in self.operations if c in states and states[c]]
        #inputs = [x for x in inputs if x]
        uninverted = [_ for _ in self.inverting if _ not in states or not states[_]]
        if not inputs and not uninverted:
            return None
        return DEFECT_IOV(None, None, self.name,
            present    =reduce(bool.__or__,  (op(i.present)     for op, i in inputs), False) or len(uninverted),
            recoverable=False,
            user="sys:virtual",
            comment=""
        )

◆ set_evaluation()

None python.virtual_logic.DefectLogic.set_evaluation	(		self,
		bool	full )

Definition at line 23 of file virtual_logic.py.

    def set_evaluation(self, full: bool) -> None:
        if full:
            self.evaluate = self.evaluate_full
        else:
            self.evaluate = self.evaluate_partial
 

Member Data Documentation

◆ clauses

python.virtual_logic.DefectLogic.clauses = defect_iov.clauses.split()

Definition at line 12 of file virtual_logic.py.

◆ dependencies

list python.virtual_logic.DefectLogic.dependencies

Initial value:

= [defect_logics[name] for _, name in self.operations

if name in defect_logics]

Definition at line 42 of file virtual_logic.py.

◆ evaluate

DEFECT_IOV python.virtual_logic.DefectLogic.evaluate = self.bad_evaluator

Definition at line 18 of file virtual_logic.py.

◆ inverting

python.virtual_logic.DefectLogic.inverting = set()

Definition at line 14 of file virtual_logic.py.

◆ name

python.virtual_logic.DefectLogic.name = defect_iov.channel

Definition at line 11 of file virtual_logic.py.

◆ operations

python.virtual_logic.DefectLogic.operations = set()

Definition at line 13 of file virtual_logic.py.

◆ primary_defects

python.virtual_logic.DefectLogic.primary_defects = set()

Definition at line 17 of file virtual_logic.py.

◆ realclauses

python.virtual_logic.DefectLogic.realclauses = set(_[1] for _ in self.operations)

Definition at line 16 of file virtual_logic.py.

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

virtual_logic.py

Public Types

Public Member Functions

Public Attributes

Protected Member Functions