def __init__(self, config_dict):
Logger.__init__(self)
self.__table = None
# Check wanted key type
self.__config_dict = collections.OrderedDict(
config_dict) if type(config_dict) is dict else config_dict
def __init__( self, name, HistogramPath = "Expert", OutputLevel=1):
Logger.__init__(self)
self.__recoAlgs = []
self.__histpath = HistogramPath
self.__outputLevel = OutputLevel
self.configure()
def __init__(self, email, password, templates):
Logger.__init__(self)
self.__myEmail = email
self.__myPassword = password
self.__smtpServer = 'smtp.gmail.com'
self.__smtpPort = 587
self.__env = Environment(loader=FileSystemLoader(templates))
def __init__(self,
path,
model_idx,
str_et_bins=str_etbins_zee,
str_eta_bins=str_etabins):
'''
This class is a little monitoring tool for saphyra trained models.
Its use the dumped json history of a trained model. If you don't have this json
use the dump_all_traiplot_monitoringn_history from base_table in kolmov.
Arguments:
- path_to_history: the path to json history files
Ex.: /my_volume/my_history_files
- model_idx: the index of model that you want extract the monitoring info.
- str_et_bins: a list which contains the et boundaries.
The default values are the zee et binning, other are in constants.
'''
Logger.__init__(self)
self.plot_names = {
'loss': 'Loss Function Evolution',
'max_sp_val': r'$SP$ Index Evolution',
'max_sp_pd_val': r'$P_D$ Evolution',
'max_sp_fa_val': r'$F_A$ Evolution',
}
self.h_dict = self.load(path, model_idx)
self.sort_name_dict = {idx: 'Fold %i' % (idx + 1) for idx in range(10)}
self.et_range = str_et_bins
self.eta_range = str_eta_bins
def __init__(self):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzetti')
from ROOT import CaloPhiRange
# Create the algorithm
self.__core = CaloPhiRange()
def __init__( self, name, **kw ):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzetti')
from ROOT import RunManager, OptimalFilter
self.__core = OptimalFilter(name)
for key, value in kw.items():
self.setProperty( key, value )
def __init__( self, name, **kw ):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzett')
from ROOT import RunManager, CaloRingerBuilder
self.__core = CaloRingerBuilder(name)
for key, value in kw.items():
self.setProperty( key, value )
def __init__(self, name, **kw):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzett')
from ROOT import RunManager, PulseGenerator
self.__core = PulseGenerator(name)
for key, value in kw.items():
self.__core.setProperty(key, value)
def __init__(self, url):
Logger.__init__(self)
try:
self.__engine = create_engine(url)
Session = sessionmaker(bind=self.__engine)
self.__session = Session()
except Exception as e:
MSG_FATAL(self, e)
def __init__(self, name, **kw):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzetti')
from ROOT import RunManager, DetectorATLASConstruction
self.__core = DetectorATLASConstruction(name)
for key, value in kw.items():
self.setProperty(key, value)
def __init__( self, name, collectionKey, f, **kw ):
Logger.__init__(self)
self.name = name
self.CaloCellFile = f
self.CollectionKey = collectionKey
for key, value in kw.items():
if key in self.__allow_keys:
setattr( self, key , value )
else:
MSG_FATAL( self, "Property with name %s is not allow for %s object", key, self.__class__.__name__)
def __init__(self, name, **kw):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzetti')
from ROOT import generator
# Create the algorithm
self.__core = generator.ParticleGun()
for key, value in kw.items():
self.setProperty(key, value)
def __init__(self, name, **kw):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzetti')
from ROOT import RawNtupleMaker
self.__core = RawNtupleMaker(name)
for key, value in kw.items():
self.setProperty(key, value)
def __init__( self, name, **kw ):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzett')
from ROOT import JF17
# Create the algorithm
self.__core = JF17()
for key, value in kw.items():
self.setProperty( key,value )
def __init__(self, name, **kw):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzett')
from ROOT import RunManager, EventGenerator
# Create the algorithm
self.__core = EventGenerator()
for key, value in kw.items():
self.setProperty(key, value)
def __init__( self, name, **kw ):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzetti')
from ROOT import CaloCellMerge
# Create the algorithm
self.__core = CaloCellMerge(name)
for key, value in kw.items():
self.setProperty( key,value )
def __init__(self, name, **kw):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzetti')
from ROOT import TruthParticleMaker
# Create the algorithm
self.__core = TruthParticleMaker(name)
for key, value in kw.items():
self.setProperty(key, value)
def __init__(self, node, db, schedule, postman, master=True):
Logger.__init__(self)
self.__node = node
self.__schedule = schedule
self.__postman = postman
self.__db = db
self.__queue = {}
self.__master = master
self.__clock = Clock(10 * SECONDS)
def __init__( self , refFile=None, targets=None):
Logger.__init__(self)
self.__references = collections.OrderedDict()
# Set all references from the reference file and target list
if refFile and targets:
from saphyra.core import ReferenceReader
refObj = ReferenceReader().load(refFile)
for ref in targets:
pd = (refObj.getSgnPassed(ref[0]) , refObj.getSgnTotal(ref[0]))
fa = (refObj.getBkgPassed(ref[0]) , refObj.getBkgTotal(ref[0]))
self.add_reference( ref[0], ref[1], pd, fa )
def __init__(self, node, queuename, db=None, gpu=False, postman=None):
Logger.__init__(self,name=queuename)
self.__slots = list()
self.__available_nodes = list()
self.__gpu = gpu
self.__total = 0
self.__queuename = queuename
self.__db = db
self.__postman = postman
self.__node = node
def __init__(self, config_dict, etbins=None, etabins=None):
'''
The objective of this class is extract the tuning information from saphyra's output and
create a pandas DataFrame using then.
The informations used in this DataFrame are listed in info_dict, but the user can add more
information from saphyra summary for example.
Arguments:
- config_dict: a dictionary contains in keys the measures that user want to check and
the values need to be a empty list.
Ex.: info = collections.OrderedDict( {
"max_sp_val" : 'summary/max_sp_val',
"max_sp_pd_val" : 'summary/max_sp_pd_val#0',
"max_sp_fa_val" : 'summary/max_sp_fa_val#0',
"max_sp_op" : 'summary/max_sp_op',
"max_sp_pd_op" : 'summary/max_sp_pd_op#0',
"max_sp_fa_op" : 'summary/max_sp_fa_op#0',
'tight_pd_ref' : "reference/tight_cutbased/pd_ref#0",
'tight_fa_ref' : "reference/tight_cutbased/fa_ref#0",
'tight_pd_ref_passed' : "reference/tight_cutbased/pd_ref#1",
'tight_fa_ref_passed' : "reference/tight_cutbased/fa_ref#1",
'tight_pd_ref_total' : "reference/tight_cutbased/pd_ref#2",
'tight_fa_ref_total' : "reference/tight_cutbased/fa_ref#2",
'tight_pd_val_passed' : "reference/tight_cutbased/pd_val#1",
'tight_fa_val_passed' : "reference/tight_cutbased/fa_val#1",
'tight_pd_val_total' : "reference/tight_cutbased/pd_val#2",
'tight_fa_val_total' : "reference/tight_cutbased/fa_val#2",
'tight_pd_op_passed' : "reference/tight_cutbased/pd_op#1",
'tight_fa_op_passed' : "reference/tight_cutbased/fa_op#1",
'tight_pd_op_total' : "reference/tight_cutbased/pd_op#2",
'tight_fa_op_total' : "reference/tight_cutbased/fa_op#2",
} )
- etbins: a list of et bins edges used in training;
- etabins: a list of eta bins edges used in training;
'''
Logger.__init__(self)
self.__table = None
# Check wanted key type
self.__config_dict = collections.OrderedDict(
config_dict) if type(config_dict) is dict else config_dict
self.__etbins = etbins
self.__etabins = etabins
def __init__(self,
etbins,
etabins,
kf,
data_generator,
input_generator,
model_generator=my_model_generator):
# init base class
Logger.__init__(self)
self.etbins = etbins
self.etabins = etabins
self.__data_generator = data_generator
self.__input_generator = input_generator
self.__kf = kf
self.__model_generator = model_generator
def __init__(self, name, **kw):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzett')
from ROOT import EventReader as G4Gun
# Create the algorithm
self.__core = G4Gun(name)
for key, value in kw.items():
self.setProperty(key, value)
from ROOT import TFile, TTree
f = TFile(self.getProperty("FileName"))
t = f.Get("particles")
self.__nevents = t.GetEntries()
f.Close()
def __init__(self, name, detector, **kw):
Logger.__init__(self)
import ROOT
ROOT.gSystem.Load('liblorenzett')
from ROOT import RunManager
self.__core = RunManager(name)
self.__core.setDetectorConstruction(detector.core())
self.__numberOfEvents = 10000
for key, value in kw.items():
if key in self.__allow_keys:
setattr(self, '__' + key, value)
self.__core.setProperty(key, value)
else:
MSG_FATAL(self,
"Property with name %s is not allow for %s object",
key, self.__class__.__name__)
def __init__(self, raw_data):
'''
This class has the objective of transform the ringer data into pandas Dataframe
in order to make easer to manipulate and extract information.
Arguments:
- raw_data: the file .npz created in prometheus framework
Ex.:
my_data_path =data18_path some_path_to_data/meaninful_data_name_et%i_eta%i.npz')
et, eta = 2, 0
my_raw_data = dict(np.load(my_data_path %(et, eta)))
'''
Logger.__init__(self)
self.raw_data = raw_data
self.et_bin = raw_data['etBinIdx'].tolist()
self.eta_bin = raw_data['etaBinIdx'].tolist()
# create a pandas DataFrame
MSG_INFO(self, 'Creating a pandas Dataframe... ')
self.df_ = pd.DataFrame(data=self.raw_data['data'],
columns=self.raw_data['features'])
self.df_['target'] = self.raw_data['target']
def __init__(self, job, slot, db):
Logger.__init__(self)
self.__job = job
self.__db = db
self.__slot = slot
self.__pending = True
self.__broken = False
self.__killed = False
# compose the job name
hash_object = hashlib.md5(str.encode(job.execArgs))
self.__hash = hash_object.hexdigest()
self.__namespace = job.getTask().getUser().getUserName()
queuename = job.getQueueName()
self.__jobname = (queuename + '.user.' + self.__namespace + '.' +
self.__hash).replace('_', '-') # add protection name
# process
self.__proc = None
MSG_INFO(self, "Create consumer with name: %s for namespace: %s",
self.__jobname, self.__namespace)
def __init__(self, path, generator, **kw):
Logger.__init__(self)
self.__path = path
self.__generator = generator
self.__kw = kw
def __init__(self, feature_names, method):
Logger.__init__(self)
self.__feature_names = feature_names
self.__method = method
def __init__(self):
Logger.__init__(self)
self.__states = []
def __init__( self ): Logger.__init__(self)
