def __init__( self, outputFile, **kw ): Logger.__init__(self,kw) if not outputFile.endswith('.root'): outputFile += '.root' # Use this property to rebuild the storegate from a root file self._restoreStoreGate=retrieve_kw(kw,'restoreStoreGate',False) filterDirs=retrieve_kw(kw,'filterDirs', None) #Create TFile object to hold everything from ROOT import TFile outputFile = expandPath( outputFile ) if self._restoreStoreGate: import os.path if not os.path.exists( outputFile ): raise ValueError("File '%s' does not exist" % outputFile) self._file = TFile( outputFile, "read") else: self._file = TFile( outputFile, "recreate") self._currentDir = "" self._objects = dict() self._dirs = list() import os self._outputFile = os.path.abspath(outputFile) if self._restoreStoreGate: retrievedObjs = self.__restore(self._file, filterDirs=filterDirs) for name, obj in retrievedObjs: self._dirs.append(name) self._objects[name]=obj
def __init__(self, w, b, **kwargs): Logger.__init__(self) self.layer = retrieve_kw(kwargs, 'Layer' ,0 ) self.funcName = retrieve_kw(kwargs, 'funcName' ,None ) checkForUnusedVars(kwargs) self.W = np.matrix(w) self.b = np.transpose( np.matrix(b) )
def __call__(self, objList, **kwargs): ylimits = retrieve_kw(kwargs, 'ylimits', [(0.7, 1.1)]) legends = retrieve_kw(kwargs, 'legends', None) hist_names = retrieve_kw(kwargs, 'hist_names', ['eff_et', 'eff_eta', 'eff_mu']) drawSame = retrieve_kw(kwargs, 'drawSame', False) doEffLabel = retrieve_kw(kwargs, 'doEffLabel', True) if 'level' in kwargs: self.level = kw.pop('level') #checkForUnusedVars( kwargs, self._logger.warning ) # protection for legends list parameter if not legends: legends = [] for o in objList: legends.append(o['rawInfo']['algname']) llabel = objList[0]['rawInfo']['outputname'].split('/')[0] # fix y axis size # protection in axis if len(ylimits) == 1: l = ylimits ylimits = [l for i in hist_names] # ready for plots... efficiencies_objects = self.__convert(objList) oname = kwargs.pop('oname') # TODO: make eff label for future eff = [] for index, e in enumerate(efficiencies_objects['eff']): passed = efficiencies_objects['passed'][index] total = efficiencies_objects['total'][index] s = ('%s: %1.2f%% (%d/%d)') % (llabel, e, passed, total) eff.append(s) # Add efficiency label into the plot (only for ratio plots) if doEffLabel: kwargs['eff_label'] = eff if drawSame: self.__plot_profiles_in_same_canvas(efficiencies_objects, hist_names, legends, ylimits, oname=oname, **kwargs) return [oname + '.pdf'] else: figures = [] for i, eff in enumerate(hist_names): self.__plot_profiles(efficiencies_objects[eff], legends, ylimits[i], oname=oname + '_' + eff, **kwargs) figures.append(oname + '_' + eff + '.pdf') return figures
def add_quadrant(self, branch_x, branch_y, **kwargs): dependence_item = retrieve_kw(kwargs, 'dependence_item', 1) alias = retrieve_kw(kwargs, 'alias', []) # check correct value if dependence_item > 1: self._logger.fatal( 'The third argument must be -1 (no NN dependence), 0 (first alg) or 1 (second alg)' ) self._quadrantNames.append( (branch_x, branch_y, dependence_item, alias))
def __init__(self, **kw): EventBase.__init__(self, **kw) self._algTools = list() self._level = retrieve_kw(kw, 'level', LoggingLevel.INFO) #checkForUnusedVars(kw) del kw self._initialized = StatusTool.NOT_INITIALIZED self._finalized = StatusTool.NOT_FINALIZED self._logger.info('Created with id (%d)', self._id)
def gen_table(self, store, algname, subdirs, **kwargs): basepath = retrieve_kw(kwargs, 'basepath', 'HLT/Egamma/Expert') dirname = retrieve_kw(kwargs, 'dirname', 'Efficiency') path = basepath + '/' + algname + '/' + dirname self._logger.info('{:-^79}'.format((' %s ') % (algname))) for dir in subdirs: obj, eff, passed, total = self.__retrieve_efficiencies( store, path, dir + '/', dir + '/match_') eff = ('%1.2f') % (eff) passed = ('%d') % (passed) total = ('%d') % (total) stroutput = '| {0:<40} |{1:<10}| {2:<5} ({3:<5}, {4:<5}) |'.format( algname, dir, eff, passed, total) self._logger.info(stroutput) self._logger.info('{:-^79}'.format(''))
def __call__(self, store, algname, **kwargs): basepath = retrieve_kw(kwargs, 'basepath', 'HLT/Egamma/Expert') dirname = retrieve_kw(kwargs, 'dirname', 'Efficiency') input_name = retrieve_kw(kwargs, 'inputname', 'HLT/') output_name = retrieve_kw(kwargs, 'outputname', 'HLT/match_') if 'level' in kwargs: self.level = kw.pop('level') checkForUnusedVars(kwargs, self._logger.warning) input_name = input_name.replace('//', '/') output_name = output_name.replace('//', '/') # some info to hold rawInfo = {'inputname': input_name,\ 'outputname' : output_name,\ 'basepath': basepath,\ 'dirname':dirname,\ 'algname':algname} # This can be: # Egamma/algname/Efficiency/L1Calo/match_eta path = (basepath + '/' + algname + '/' + dirname).replace('//', '/') try: # protection self._logger.debug( 'Extracting efficiencies information for %s from %s', algname, path) obj, eff, passed, total = self.__retrieve_efficiencies(store, path,\ input_name, output_name) except RuntimeError: self._logger.error( ('Can not extract the efficiencies for this path %s') % (path)) raise RuntimeError( 'loop error in retrieve_efficiencies private method') # hold efficiencies values eobj = {'eff_et':obj['eff_et'], 'eff_eta':obj['eff_eta'], 'eff_mu':obj['eff_mu'],'eff_nvtx':obj['eff_nvtx'], \ 'eff':eff, 'passed':passed, 'total':total, 'rawInfo':rawInfo} self._logger.debug(('%s with efficiency: %1.2f (%d/%d)')%\ (algname, eff, passed, total)) return eobj
def __init__(self, **kw): Logger.__init__(self, **kw) self._maxPileupLinearCorrectionValue = retrieve_kw( kw, 'maxPileupLinearCorrectionValue', 100) self._removeOutputTansigTF = retrieve_kw(kw, 'removeOutputTansigTF', True) self._useEtaVar = retrieve_kw(kw, 'useEtaVar', False) self._useLumiVar = retrieve_kw(kw, 'useLumiVar', False) self._toPython = retrieve_kw(kw, 'toPython', True) self._doPileupCorrection = retrieve_kw(kw, 'doPileupCorrection', True) self._toPickle = retrieve_kw(kw, 'toPickle', False)
def __init__(self, **kw): Logger.__init__(self, kw) # Retrieve all information needed self._fList = retrieve_kw(kw, 'inputFiles', NotSet) self._ofile = retrieve_kw(kw, 'outputFile', "histos.root") self._treePath = retrieve_kw(kw, 'treePath', NotSet) self._dataframe = retrieve_kw(kw, 'dataframe', DataframeEnum.SkimmedNtuple) self._nov = retrieve_kw(kw, 'nov', -1) self._fList = csvStr2List(self._fList) self._fList = expandFolders(self._fList) # Loading libraries if ROOT.gSystem.Load('libTuningTools') < 0: self._fatal("Could not load TuningTools library", ImportError) self._containersSvc = {} self._storegateSvc = NotSet import random import time random.seed(time.time()) # return a random number self._id = random.randrange(100000)
def __init__( self, dataCurator, d, **kw ): Logger.__init__( self, kw ) d.update( kw ); del kw # Define discriminator type (for now we only have one discriminator type): # FIXME This chould be configured using coreDef try: try: from libTuningTools import DiscriminatorPyWrapper except ImportError: from libTuningToolsLib import DiscriminatorPyWrapper except ImportError: self._fatal("Cannot use FastNet DiscriminatorPyWrapper: library is not available!") self.dataCurator = dataCurator # Discriminator parameters: self.DiscrClass = DiscriminatorPyWrapper self.removeOutputTansigTF = retrieve_kw(d, 'removeOutputTansigTF', True ) # Decision making parameters: self.thresEtBins = retrieve_kw( d, 'thresEtBins', None) self.thresEtaBins = retrieve_kw( d, 'thresEtaBins', None) # TODO There is no need to require this from user self.method = DecisionMakingMethod.retrieve( retrieve_kw(d, 'decisionMakingMethod', DecisionMakingMethod.LHLinearApproach ) ) # Pileup limits specification self.pileupRef = None self.pileupLimits = retrieve_kw( d, 'pileupLimits', None) self.maxCorr = retrieve_kw( d, 'maxCorr', None) self.frMargin = retrieve_kw( d, 'frMargin', [1.05, 1.1, 1.15, 1.25, 1.5, 2.0]) if self.method is DecisionMakingMethod.LHLinearApproach: self._info("Using limits: %r", self.pileupLimits) if not 'pileupRef' in d: self._fatal("pileupRef must specified in order to correctly label the xaxis.") if 'pileupRef' in d: self.pileupRef = PileupReference.retrieve( retrieve_kw( d, 'pileupRef' ) ) # Linear LH Threshold Correction methods #self.maxFRMultipler = retrieve_kw( d, 'maxFRMultipler', None) #checkForUnusedVars( d ) # TODO: Add fix fraction allowing to load a module and a table of values if self.method is DecisionMakingMethod.LHLinearApproach: try: import ElectronIDDevelopment except ImportError: self._warning("Using a standalone version of the pile-up fitting version which may not be the latest.")
def __call__(self, **kwargs): key = retrieve_kw(kwargs, 'key', None) outputdir = retrieve_kw(kwargs, 'outputdir', 'plots') drawSame = retrieve_kw(kwargs, 'drawsame', True) atlaslabel = retrieve_kw(kwargs, 'atlaslabel', 'Internal') isBackground = retrieve_kw(kwargs, 'isbackground', False) doRatio = retrieve_kw(kwargs, 'doRatio', False) doEffLabel = retrieve_kw(kwargs, 'doEffLabel', True) checkForUnusedVars(kwargs, self._logger.warning) import os localpath = os.getcwd() + '/' + outputdir try: os.mkdir(localpath) except: self._logger.warning('The director %s exist.', localpath) import base64 if key: if not ':' in key: key = base64.b64decode(key) self._logger.info('Translate key to: %s', key) key = key.split(',') cList = self.translate(key) else: self.display() key = input('Write the configuration: ') self._logger.info( 'Use this key %s if you want to reproduce this plot', base64.b64encode(key)) key = key.split(',') cList = self.translate(key) # FIXME: The subdirs must be the same for all configuration subdirs = cList[0]['subdirs'] figures = [] for subdir in subdirs: eff_list = list() legends = list() algnames = None for index, c in enumerate(cList): effObj = self._effReader(self._store[c['file']], c['algname'], basepath=c['basepath'], dirname=c['dirname'], inputname=subdir + '/', outputname=subdir + '/match_') eff_list.append(effObj) legends.append(c['legend']) if not algnames: algnames = c['algname'] else: algnames += '_' + c['algname'] f = profile( eff_list, ylimits = [ (0.0, 1.4) , (0.0, 1.2), (0.0, 1.4), (0.0, 1.4) ] \ if not isBackground else [(-0.3,0.1),(-0.3,0.4),(-0.3,0.4),(-0.3, 0.4)], ylabel = 'Trigger Efficiency', hist_names = ['eff_et','eff_eta','eff_mu'], legend_header = '', legend_prefix = '', legends = legends, region_label = '', oname = localpath+'/'+subdir+'_'+ algnames, drawSame = drawSame, doRatio = doRatio, atlaslabel = atlaslabel, ) figures.extend(f) f = profile( eff_list, ylimits = [ (0.0, 1.4) , (0.0, 1.4), (0.0, 1.4), (0.0, 1.4) ] \ if not isBackground else [(-0.3,0.1),(-0.3,0.4),(-0.3,0.4),(-0.3, 0.4)], ylabel = 'Trigger Efficiency', hist_names = ['eff_et','eff_eta','eff_mu'], legend_header = '', legend_prefix = '', legends = legends, region_label = '', oname = localpath+'/'+subdir+'_'+ algnames, drawSame = False, doRatio = True, doEffLabel = doEffLabel, atlaslabel = atlaslabel, ) figures.extend(f) for c in cList: self._effReader.gen_table(self._store[c['file']], c['algname'], c['subdirs'], basepath=c['basepath'], dirname=c['dirname']) return figures
def plot(self, **kw): dirname = retrieve_kw(kw, 'dirname', 'Quadrant') aliasMap = retrieve_kw( kw, 'alias_map', { 'xx': 'BothPassed', 'oo': 'BothReject', 'xo': 'OnlyPassedLH', 'ox': 'OnlyPassedRinger' }) pdftitle = retrieve_kw(kw, 'pdftitle', 'Quadrant') pdfoutput = retrieve_kw(kw, 'pdfoutput', 'quadrant') import os # Organize outputs (.py and .pdf) prefix = self._basepath.split('/')[-1] localpath = os.getcwd() + '/' + dirname + '/' + prefix try: if not os.path.exists(localpath): os.makedirs(localpath) except: self._logger.warning('The director %s exist.', localpath) hist_names = [ 'et', 'eta', 'mu', 'nvtx', 'reta', 'eratio', 'weta2', 'rhad', 'rphi', 'f1', 'f3' ] hist_labels = [ 'E_{T}', "#eta", "<#mu>", 'N_{vtx}', 'R_{eta}', 'E_{ratio}', 'W_{eta2}', 'R_{had}', 'R_{phi}', 'f_{1}', 'f_{3}' ] def sumAllRegions(histname): h = None for etBinIdx in range(len(self._etBins) - 1): for etaBinIdx in range(len(self._etaBins) - 1): binningname = ('et%d_eta%d') % (etBinIdx, etaBinIdx) path = (histname) % (binningname) if h: h += self.storeSvc().histogram(path).ProjectionY() else: h = self.storeSvc().histogram( path).ProjectionY().Clone() return h collection = [] for info in self._quadrantNames: for idx, hist in enumerate(hist_names): name = info[0] + '_X_' + info[1] dirname = self._basepath + '/' + name + '/%s' h_xx = sumAllRegions(dirname + '/passed_passed/' + hist) h_xo = sumAllRegions(dirname + '/passed_rejected/' + hist) h_ox = sumAllRegions(dirname + '/rejected_passed/' + hist) h_oo = sumAllRegions(dirname + '/rejected_rejected/' + hist) # Loop over histograms plotname1 = localpath + '/' + prefix + '_' + name + '_' + hist + '.pdf' plotname2 = localpath + '/' + prefix + '_' + name + '_' + hist + '_logscale.pdf' plotname3 = localpath + '/' + prefix + '_' + name + '_' + hist + '_agreement.pdf' plotname4 = localpath + '/' + prefix + '_' + name + '_' + hist + '_agreement_logscale.pdf' #self.__plot_quadrant_template1(h_oo.Clone(),h_xo.Clone(),h_ox.Clone(),h_xx.Clone(),aliasMap,hist_labels[idx],plotname1,False) #self.__plot_quadrant_template1(h_oo.Clone(),h_xo.Clone(),h_ox.Clone(),h_xx.Clone(),aliasMap,hist_labels[idx],plotname2,True ) #self.__plot_quadrant_template2(h_oo.Clone(),h_xo.Clone(),h_ox.Clone(),h_xx.Clone(),aliasMap,hist_labels[idx],plotname3,False ) #self.__plot_quadrant_template2(h_oo.Clone(),h_xo.Clone(),h_ox.Clone(),h_xx.Clone(),aliasMap,hist_labels[idx],plotname4,True ) collection.append((h_xx, h_xo, h_ox, h_oo)) #toPDF=False toPDF = True if toPDF: #from RingerCore.tex.TexAPI import * from RingerCore.tex.BeamerAPI import BeamerTexReportTemplate1,BeamerSection,BeamerSubSection,\ BeamerMultiFigureSlide,BeamerFigureSlide # apply beamer with BeamerTexReportTemplate1(theme='Berlin', _toPDF=True, title=pdftitle, outputFile=pdfoutput, font='structurebold'): for info in self._quadrantNames: name = info[0] + '_X_' + info[1] section_name = info[3][0].replace('_', '\_') subsection_name = info[3][1].replace('_', '\_') with BeamerSection(name=section_name): with BeamerSubSection(name=subsection_name): figures = { 'linear': [], 'log': [], 'diff_linear': [], 'diff_log': [] } for idx, hist in enumerate(hist_names): figures['linear'].append(localpath + '/' + prefix + '_' + name + '_' + hist + '.pdf') figures['log'].append(localpath + '/' + prefix + '_' + name + '_' + hist + '_logscale.pdf') figures['diff_linear'].append(localpath + '/' + prefix + '_' + name + '_' + hist + '_agreement.pdf') figures['diff_log'].append( localpath + '/' + prefix + '_' + name + '_' + hist + '_agreement_logscale.pdf') BeamerMultiFigureSlide( title='Offline Calo Variables', paths=figures['linear'], nDivWidth=4 # x , nDivHeight=3 # y , texts=None, fortran=False, usedHeight=0.6, usedWidth=0.9) BeamerMultiFigureSlide( title= 'Offline Calo Variables (shown on log scale)', paths=figures['log'], nDivWidth=4 # x , nDivHeight=3 # y , texts=None, fortran=False, usedHeight=0.6, usedWidth=0.9) BeamerMultiFigureSlide( title= 'Offline Calo Variables (Agreement and Disagrement)', paths=figures['diff_linear'], nDivWidth=4 # x , nDivHeight=3 # y , texts=None, fortran=False, usedHeight=0.6, usedWidth=0.9) BeamerMultiFigureSlide( title= 'Offline Calo Variables (Agreement and Disagrement show on log scale)', paths=figures['diff_log'], nDivWidth=4 # x , nDivHeight=3 # y , texts=None, fortran=False, usedHeight=0.6, usedWidth=0.9) return StatusCode.SUCCESS
def __call__( self, fList, ringerOperation, **kw): """ Read ntuple and return patterns and efficiencies. Arguments: - fList: The file path or file list path. It can be an argument list of two types: o List: each element is a string path to the file; o Comma separated string: each path is separated via a comma o Folders: Expand folders recursively adding also files within them to analysis - ringerOperation: Set Operation type. It can be both a string or the RingerOperation Optional arguments: - filterType [None]: whether to filter. Use FilterType enumeration - reference [Truth]: set reference for targets. Use Reference enumeration - treePath [Set using operation]: set tree name on file, this may be set to use different sources then the default. Default for: o Offline: Offline/Egamma/Ntuple/electron o L2: Trigger/HLT/Egamma/TPNtuple/e24_medium_L1EM18VH - l1EmClusCut [None]: Set L1 cluster energy cut if operating on the trigger - l2EtCut [None]: Set L2 cluster energy cut value if operating on the trigger - offEtCut [None]: Set Offline cluster energy cut value - nClusters [None]: Read up to nClusters. Use None to run for all clusters. - getRatesOnly [False]: Read up to nClusters. Use None to run for all clusters. - etBins [None]: E_T bins (GeV) where the data should be segmented - etaBins [None]: eta bins where the data should be segmented - ringConfig [100]: A list containing the number of rings available in the data for each eta bin. - crossVal [None]: Whether to measure benchmark efficiency splitting it by the crossVal-validation datasets - extractDet [None]: Which detector to export (use Detector enumeration). Defaults are: o L2Calo: Calorimetry o L2: Tracking o Offline: Calorimetry o Others: CaloAndTrack - standardCaloVariables [False]: Whether to extract standard track variables. - useTRT [False]: Whether to export TRT information when dumping track variables. - supportTriggers [True]: Whether reading data comes from support triggers """ # Offline information branches: __offlineBranches = ['el_et', 'el_eta', #'el_loose', #'el_medium', #'el_tight', 'el_lhLoose', 'el_lhMedium', 'el_lhTight', 'mc_hasMC', 'mc_isElectron', 'mc_hasZMother', 'el_nPileupPrimaryVtx', ] # Online information branches __onlineBranches = [] __l2stdCaloBranches = ['trig_L2_calo_et', 'trig_L2_calo_eta', 'trig_L2_calo_phi', 'trig_L2_calo_e237', # rEta 'trig_L2_calo_e277', # rEta 'trig_L2_calo_fracs1', # F1: fraction sample 1 'trig_L2_calo_weta2', # weta2 'trig_L2_calo_ehad1', # energy on hadronic sample 1 'trig_L2_calo_emaxs1', # eratio 'trig_L2_calo_e2tsts1', # eratio 'trig_L2_calo_wstot',] # wstot __l2trackBranches = [ # Do not add non patter variables on this branch list #'trig_L2_el_pt', #'trig_L2_el_eta', #'trig_L2_el_phi', #'trig_L2_el_caloEta', #'trig_L2_el_charge', #'trig_L2_el_nTRTHits', #'trig_L2_el_nTRTHiThresholdHits', 'trig_L2_el_etOverPt', 'trig_L2_el_trkClusDeta', 'trig_L2_el_trkClusDphi',] # Retrieve information from keyword arguments filterType = retrieve_kw(kw, 'filterType', FilterType.DoNotFilter ) reference = retrieve_kw(kw, 'reference', Reference.Truth ) l1EmClusCut = retrieve_kw(kw, 'l1EmClusCut', None ) l2EtCut = retrieve_kw(kw, 'l2EtCut', None ) efEtCut = retrieve_kw(kw, 'efEtCut', None ) offEtCut = retrieve_kw(kw, 'offEtCut', None ) treePath = retrieve_kw(kw, 'treePath', None ) nClusters = retrieve_kw(kw, 'nClusters', None ) getRates = retrieve_kw(kw, 'getRates', True ) getRatesOnly = retrieve_kw(kw, 'getRatesOnly', False ) etBins = retrieve_kw(kw, 'etBins', None ) etaBins = retrieve_kw(kw, 'etaBins', None ) crossVal = retrieve_kw(kw, 'crossVal', None ) ringConfig = retrieve_kw(kw, 'ringConfig', 100 ) extractDet = retrieve_kw(kw, 'extractDet', None ) standardCaloVariables = retrieve_kw(kw, 'standardCaloVariables', False ) useTRT = retrieve_kw(kw, 'useTRT', False ) supportTriggers = retrieve_kw(kw, 'supportTriggers', True ) monitoring = retrieve_kw(kw, 'monitoring', None ) pileupRef = retrieve_kw(kw, 'pileupRef', NotSet ) import ROOT, pkgutil #gROOT.ProcessLine (".x $ROOTCOREDIR/scripts/load_packages.C"); #ROOT.gROOT.Macro('$ROOTCOREDIR/scripts/load_packages.C') if not( bool( pkgutil.find_loader( 'libTuningTools' ) ) and ROOT.gSystem.Load('libTuningTools') >= 0 ) and \ not( bool( pkgutil.find_loader( 'libTuningToolsLib' ) ) and ROOT.gSystem.Load('libTuningToolsLib') >= 0 ): #ROOT.gSystem.Load('libTuningToolsPythonLib') < 0: self._fatal("Could not load TuningTools library", ImportError) if 'level' in kw: self.level = kw.pop('level') # and delete it to avoid mistakes: checkForUnusedVars( kw, self._warning ) del kw ### Parse arguments # Mutual exclusive arguments: if not getRates and getRatesOnly: self._logger.error("Cannot run with getRates set to False and getRatesOnly set to True. Setting getRates to True.") getRates = True # Also parse operation, check if its type is string and if we can # transform it to the known operation enum: fList = csvStr2List ( fList ) fList = expandFolders( fList ) ringerOperation = RingerOperation.retrieve(ringerOperation) reference = Reference.retrieve(reference) if isinstance(l1EmClusCut, str): l1EmClusCut = float(l1EmClusCut) if l1EmClusCut: l1EmClusCut = 1000.*l1EmClusCut # Put energy in MeV __onlineBranches.append( 'trig_L1_emClus' ) if l2EtCut: l2EtCut = 1000.*l2EtCut # Put energy in MeV __onlineBranches.append( 'trig_L2_calo_et' ) if efEtCut: efEtCut = 1000.*efEtCut # Put energy in MeV __onlineBranches.append( 'trig_EF_calo_et' ) if offEtCut: offEtCut = 1000.*offEtCut # Put energy in MeV __offlineBranches.append( 'el_et' ) if not supportTriggers: __onlineBranches.append( 'trig_L1_accept' ) # Check if treePath is None and try to set it automatically if treePath is None: treePath = 'Offline/Egamma/Ntuple/electron' if ringerOperation < 0 else \ 'Trigger/HLT/Egamma/TPNtuple/e24_medium_L1EM18VH' # Check whether using bins useBins=False; useEtBins=False; useEtaBins=False nEtaBins = 1; nEtBins = 1 # Set the detector which we should extract the information: if extractDet is None: if ringerOperation < 0: extractDet = Detector.Calorimetry elif ringerOperation is RingerOperation.L2Calo: extractDet = Detector.Calorimetry elif ringerOperation is RingerOperation.L2: extractDet = Detector.Tracking else: extractDet = Detector.CaloAndTrack else: extractDet = Detector.retrieve( extractDet ) if etaBins is None: etaBins = npCurrent.fp_array([]) if type(etaBins) is list: etaBins=npCurrent.fp_array(etaBins) if etBins is None: etBins = npCurrent.fp_array([]) if type(etBins) is list: etBins=npCurrent.fp_array(etBins) if etBins.size: etBins = etBins * 1000. # Put energy in MeV nEtBins = len(etBins)-1 if nEtBins >= np.iinfo(npCurrent.scounter_dtype).max: self._fatal(('Number of et bins (%d) is larger or equal than maximum ' 'integer precision can hold (%d). Increase ' 'TuningTools.coreDef.npCurrent scounter_dtype number of bytes.'), nEtBins, np.iinfo(npCurrent.scounter_dtype).max) # Flag that we are separating data through bins useBins=True useEtBins=True self._debug('E_T bins enabled.') if not type(ringConfig) is list and not type(ringConfig) is np.ndarray: ringConfig = [ringConfig] * (len(etaBins) - 1) if etaBins.size else 1 if type(ringConfig) is list: ringConfig=npCurrent.int_array(ringConfig) if not len(ringConfig): self._fatal('Rings size must be specified.'); if etaBins.size: nEtaBins = len(etaBins)-1 if nEtaBins >= np.iinfo(npCurrent.scounter_dtype).max: self._fatal(('Number of eta bins (%d) is larger or equal than maximum ' 'integer precision can hold (%d). Increase ' 'TuningTools.coreDef.npCurrent scounter_dtype number of bytes.'), nEtaBins, np.iinfo(npCurrent.scounter_dtype).max) if len(ringConfig) != nEtaBins: self._fatal(('The number of rings configurations (%r) must be equal than ' 'eta bins (%r) region config'),ringConfig, etaBins) useBins=True useEtaBins=True self._debug('eta bins enabled.') else: self._debug('eta/et bins disabled.') ### Prepare to loop: # Open root file t = ROOT.TChain(treePath) for inputFile in progressbar(fList, len(fList), logger = self._logger, prefix = "Creating collection tree "): # Check if file exists f = ROOT.TFile.Open(inputFile, 'read') if not f or f.IsZombie(): self._warning('Couldn''t open file: %s', inputFile) continue # Inform user whether TTree exists, and which options are available: self._debug("Adding file: %s", inputFile) obj = f.Get(treePath) if not obj: self._warning("Couldn't retrieve TTree (%s)!", treePath) self._info("File available info:") f.ReadAll() f.ReadKeys() f.ls() continue elif not isinstance(obj, ROOT.TTree): self._fatal("%s is not an instance of TTree!", treePath, ValueError) t.Add( inputFile ) # Turn all branches off. t.SetBranchStatus("*", False) # RingerPhysVal hold the address of required branches event = ROOT.RingerPhysVal() # Add offline branches, these are always needed cPos = 0 for var in __offlineBranches: self.__setBranchAddress(t,var,event) # Add online branches if using Trigger if ringerOperation > 0: for var in __onlineBranches: self.__setBranchAddress(t,var,event) ## Allocating memory for the number of entries entries = t.GetEntries() nobs = entries if (nClusters is None or nClusters > entries or nClusters < 1) \ else nClusters ## Retrieve the dependent operation variables: if useEtBins: etBranch = 'el_et' if ringerOperation < 0 else 'trig_L2_calo_et' self.__setBranchAddress(t,etBranch,event) self._debug("Added branch: %s", etBranch) if not getRatesOnly: npEt = npCurrent.scounter_zeros(shape=npCurrent.shape(npat = 1, nobs = nobs)) self._debug("Allocated npEt with size %r", npEt.shape) if useEtaBins: etaBranch = "el_eta" if ringerOperation < 0 else "trig_L2_calo_eta" self.__setBranchAddress(t,etaBranch,event) self._debug("Added branch: %s", etaBranch) if not getRatesOnly: npEta = npCurrent.scounter_zeros(shape=npCurrent.shape(npat = 1, nobs = nobs)) self._debug("Allocated npEta with size %r", npEta.shape) # The base information holder, such as et, eta and pile-up if pileupRef is NotSet: if ringerOperation > 0: pileupRef = PileupReference.avgmu else: pileupRef = PileupReference.nvtx pileupRef = PileupReference.retrieve( pileupRef ) self._info("Using '%s' as pile-up reference.", PileupReference.tostring( pileupRef ) ) if pileupRef is PileupReference.nvtx: pileupBranch = 'el_nPileupPrimaryVtx' pileupDataType = np.uint16 elif pileupRef is PileupReference.avgmu: pileupBranch = 'avgmu' pileupDataType = np.float32 else: raise NotImplementedError("Pile-up reference %r is not implemented." % pileupRef) baseInfoBranch = BaseInfo((etBranch, etaBranch, pileupBranch, 'el_phi' if ringerOperation < 0 else 'trig_L2_el_phi',), (npCurrent.fp_dtype, npCurrent.fp_dtype, npCurrent.fp_dtype, pileupDataType) ) baseInfo = [None, ] * baseInfoBranch.nInfo # Make sure all baseInfoBranch information is available: for idx in baseInfoBranch: self.__setBranchAddress(t,baseInfoBranch.retrieveBranch(idx),event) # Allocate numpy to hold as many entries as possible: if not getRatesOnly: # Retrieve the rings information depending on ringer operation ringerBranch = "el_ringsE" if ringerOperation < 0 else \ "trig_L2_calo_rings" self.__setBranchAddress(t,ringerBranch,event) if ringerOperation > 0: if ringerOperation is RingerOperation.L2: for var in __l2trackBranches: self.__setBranchAddress(t,var,event) if standardCaloVariables: if ringerOperation in (RingerOperation.L2, RingerOperation.L2Calo,): for var in __l2stdCaloBranches: self.__setBranchAddress(t, var, event) else: self._warning("Unknown standard calorimeters for Operation:%s. Setting operation back to use rings variables.", RingerOperation.tostring(ringerOperation)) t.GetEntry(0) npat = 0 if extractDet in (Detector.Calorimetry, Detector.CaloAndTrack, Detector.All): if standardCaloVariables: npat+= 6 else: npat += ringConfig.max() if extractDet in (Detector.Tracking, Detector.CaloAndTrack, Detector.All): if ringerOperation is RingerOperation.L2: if useTRT: self._info("Using TRT information!") npat += 2 __l2trackBranches.append('trig_L2_el_nTRTHits') __l2trackBranches.append('trig_L2_el_nTRTHiThresholdHits') npat += 3 for var in __l2trackBranches: self.__setBranchAddress(t,var,event) self.__setBranchAddress(t,"trig_L2_el_pt",event) elif ringerOperation < 0: # Offline self._warning("Still need to implement tracking for the ringer offline.") npPatterns = npCurrent.fp_zeros( shape=npCurrent.shape(npat=npat, #getattr(event, ringerBranch).size() nobs=nobs) ) self._debug("Allocated npPatterns with size %r", npPatterns.shape) # Add E_T, eta and luminosity information npBaseInfo = [npCurrent.zeros( shape=npCurrent.shape(npat=1, nobs=nobs ), dtype=baseInfoBranch.dtype(idx) ) for idx in baseInfoBranch] else: npPatterns = npCurrent.fp_array([]) npBaseInfo = [deepcopy(npCurrent.fp_array([])) for _ in baseInfoBranch] ## Allocate the branch efficiency collectors: if getRates: if ringerOperation < 0: benchmarkDict = OrderedDict( [( RingerOperation.Offline_CutBased_Loose , 'el_loose' ), ( RingerOperation.Offline_CutBased_Medium , 'el_medium' ), ( RingerOperation.Offline_CutBased_Tight , 'el_tight' ), ( RingerOperation.Offline_LH_Loose , 'el_lhLoose' ), ( RingerOperation.Offline_LH_Medium , 'el_lhMedium' ), ( RingerOperation.Offline_LH_Tight , 'el_lhTight' ), ]) else: benchmarkDict = OrderedDict( [( RingerOperation.L2Calo , 'trig_L2_calo_accept' ), ( RingerOperation.L2 , 'trig_L2_el_accept' ), ( RingerOperation.EFCalo , 'trig_EF_calo_accept' ), ( RingerOperation.HLT , 'trig_EF_el_accept' ), ]) from TuningTools.CreateData import BranchEffCollector, BranchCrossEffCollector branchEffCollectors = OrderedDict() branchCrossEffCollectors = OrderedDict() for key, val in benchmarkDict.iteritems(): branchEffCollectors[key] = list() branchCrossEffCollectors[key] = list() # Add efficincy branch: if getRates or getRatesOnly: self.__setBranchAddress(t,val,event) for etBin in range(nEtBins): if useBins: branchEffCollectors[key].append(list()) branchCrossEffCollectors[key].append(list()) for etaBin in range(nEtaBins): etBinArg = etBin if useBins else -1 etaBinArg = etaBin if useBins else -1 argList = [ RingerOperation.tostring(key), val, etBinArg, etaBinArg ] branchEffCollectors[key][etBin].append(BranchEffCollector( *argList ) ) if crossVal: branchCrossEffCollectors[key][etBin].append(BranchCrossEffCollector( entries, crossVal, *argList ) ) # etBin # etaBin # benchmark dict if self._logger.isEnabledFor( LoggingLevel.DEBUG ): self._debug( 'Retrieved following branch efficiency collectors: %r', [collector[0].printName for collector in traverse(branchEffCollectors.values())]) # end of (getRates) etaBin = 0; etBin = 0 step = int(entries/100) if int(entries/100) > 0 else 1 ## Start loop! self._info("There is available a total of %d entries.", entries) for entry in progressbar(range(entries), entries, step = step, logger = self._logger, prefix = "Looping over entries "): #self._verbose('Processing eventNumber: %d/%d', entry, entries) t.GetEntry(entry) # Check if it is needed to remove energy regions (this means that if not # within this range, it will be ignored as well for efficiency measuremnet) if event.el_et < offEtCut: self._verbose("Ignoring entry due to offline E_T cut.") continue # Add et distribution for all events if not monitoring is None: # Book all distribtions before the event selection self.__fillHistograms(monitoring,filterType,event,False) if ringerOperation > 0: # Remove events which didn't pass L1_calo if not supportTriggers and not event.trig_L1_accept: #self._verbose("Ignoring entry due to L1Calo cut (trig_L1_accept = %r).", event.trig_L1_accept) continue if event.trig_L1_emClus < l1EmClusCut: #self._verbose("Ignoring entry due to L1Calo E_T cut (%d < %r).", event.trig_L1_emClus, l1EmClusCut) continue if event.trig_L2_calo_et < l2EtCut: #self._verbose("Ignoring entry due to L2Calo E_T cut.") continue if efEtCut is not None and event.trig_L2_calo_accept : # EF calo is a container, search for electrons objects with et > cut trig_EF_calo_et_list = stdvector_to_list(event.trig_EF_calo_et) found=False for v in trig_EF_calo_et_list: if v < efEtCut: found=True if found: #self._verbose("Ignoring entry due to EFCalo E_T cut.") continue # Set discriminator target: target = Target.Unknown if reference is Reference.Truth: if event.mc_isElectron and event.mc_hasZMother: target = Target.Signal elif not (event.mc_isElectron and (event.mc_hasZMother or event.mc_hasWMother) ): target = Target.Background elif reference is Reference.Off_Likelihood: if event.el_lhTight: target = Target.Signal elif not event.el_lhLoose: target = Target.Background elif reference is Reference.AcceptAll: target = Target.Signal if filterType is FilterType.Signal else Target.Background else: if event.el_tight: target = Target.Signal elif not event.el_loose: target = Target.Background # Run filter if it is defined if filterType and \ ( (filterType is FilterType.Signal and target != Target.Signal) or \ (filterType is FilterType.Background and target != Target.Background) or \ (target == Target.Unknown) ): #self._verbose("Ignoring entry due to filter cut.") continue # Add et distribution for all events if not monitoring is None: # Book all distributions after the event selection self.__fillHistograms(monitoring,filterType,event,True) # Retrieve base information: for idx in baseInfoBranch: lInfo = getattr(event, baseInfoBranch.retrieveBranch(idx)) baseInfo[idx] = lInfo if not getRatesOnly: npBaseInfo[idx][cPos] = lInfo # Retrieve dependent operation region if useEtBins: etBin = self.__retrieveBinIdx( etBins, baseInfo[0] ) if useEtaBins: etaBin = self.__retrieveBinIdx( etaBins, np.fabs( baseInfo[1]) ) # Check if bin is within range (when not using bins, this will always be true): if (etBin < nEtBins and etaBin < nEtaBins): # Retrieve patterns: if not getRatesOnly: if useEtBins: npEt[cPos] = etBin if useEtaBins: npEta[cPos] = etaBin ## Retrieve calorimeter information: cPat = 0 caloAvailable = True if extractDet in (Detector.Calorimetry, Detector.CaloAndTrack, Detector.All): if standardCaloVariables: patterns = [] if ringerOperation is RingerOperation.L2Calo: from math import cosh cosh_eta = cosh( event.trig_L2_calo_eta ) # second layer ratio between 3x7 7x7 rEta = event.trig_L2_calo_e237 / event.trig_L2_calo_e277 base = event.trig_L2_calo_emaxs1 + event.trig_L2_calo_e2tsts1 # Ratio between first and second highest energy cells eRatio = ( event.trig_L2_calo_emaxs1 - event.trig_L2_calo_e2tsts1 ) / base if base > 0 else 0 # ratio of energy in the first layer (hadronic particles should leave low energy) F1 = event.trig_L2_calo_fracs1 / ( event.trig_L2_calo_et * cosh_eta ) # weta2 is calculated over the middle layer using 3 x 5 weta2 = event.trig_L2_calo_weta2 # wstot is calculated over the first layer using (typically) 20 strips wstot = event.trig_L2_calo_wstot # ratio between EM cluster and first hadronic layers: Rhad1 = ( event.trig_L2_calo_ehad1 / cosh_eta ) / event.trig_L2_calo_et # allocate patterns: patterns = [rEta, eRatio, F1, weta2, wstot, Rhad1] for pat in patterns: npPatterns[npCurrent.access( pidx=cPat, oidx=cPos) ] = pat cPat += 1 # end of ringerOperation else: # Remove events without rings if getattr(event,ringerBranch).empty(): caloAvailable = False # Retrieve rings: if caloAvailable: try: patterns = stdvector_to_list( getattr(event,ringerBranch) ) lPat = len(patterns) if lPat == ringConfig[etaBin]: npPatterns[npCurrent.access(pidx=slice(cPat,ringConfig[etaBin]),oidx=cPos)] = patterns else: oldEtaBin = etaBin if etaBin > 0 and ringConfig[etaBin - 1] == lPat: etaBin -= 1 elif etaBin + 1 < len(ringConfig) and ringConfig[etaBin + 1] == lPat: etaBin += 1 npPatterns[npCurrent.access(pidx=slice(cPat, ringConfig[etaBin]),oidx=cPos)] = patterns self._warning(("Recovered event which should be within eta bin (%d: %r) " "but was found to be within eta bin (%d: %r). " "Its read eta value was of %f."), oldEtaBin, etaBins[oldEtaBin:oldEtaBin+2], etaBin, etaBins[etaBin:etaBin+2], np.fabs( getattr(event,etaBranch))) except ValueError: self._logger.error(("Patterns size (%d) do not match expected " "value (%d). This event eta value is: %f, and ringConfig is %r."), lPat, ringConfig[etaBin], np.fabs( getattr(event,etaBranch)), ringConfig ) continue else: if extractDet is Detector.Calorimetry: # Also display warning when extracting only calorimetry! self._warning("Rings not available") continue self._warning("Rings not available") continue cPat += ringConfig.max() # which calo variables # end of (extractDet needed calorimeter) # And track information: if extractDet in (Detector.Tracking, Detector.CaloAndTrack, Detector.All): if caloAvailable or extractDet is Detector.Tracking: if ringerOperation is RingerOperation.L2: # Retrieve nearest deta/dphi only, so we need to find each one is the nearest: if event.trig_L2_el_trkClusDeta.size(): clusDeta = npCurrent.fp_array( stdvector_to_list( event.trig_L2_el_trkClusDeta ) ) clusDphi = npCurrent.fp_array( stdvector_to_list( event.trig_L2_el_trkClusDphi ) ) bestTrackPos = int( np.argmin( clusDeta**2 + clusDphi**2 ) ) for var in __l2trackBranches: npPatterns[npCurrent.access( pidx=cPat,oidx=cPos) ] = getattr(event, var)[bestTrackPos] cPat += 1 else: #self._verbose("Ignoring entry due to track information not available.") continue #for var in __l2trackBranches: # npPatterns[npCurrent.access( pidx=cPat,oidx=cPos) ] = np.nan # cPat += 1 elif ringerOperation < 0: # Offline pass # caloAvailable or only tracking # end of (extractDet needs tracking) # end of (getRatesOnly) ## Retrieve rates information: if getRates: for branch in branchEffCollectors.itervalues(): if not useBins: branch.update(event) else: branch[etBin][etaBin].update(event) if crossVal: for branchCross in branchCrossEffCollectors.itervalues(): if not useBins: branchCross.update(event) else: branchCross[etBin][etaBin].update(event) # end of (getRates) # We only increment if this cluster will be computed cPos += 1 # end of (et/eta bins) # Limit the number of entries to nClusters if desired and possible: if not nClusters is None and cPos >= nClusters: break # for end ## Treat the rings information if not getRatesOnly: ## Remove not filled reserved memory space: if npPatterns.shape[npCurrent.odim] > cPos: npPatterns = np.delete( npPatterns, slice(cPos,None), axis = npCurrent.odim) ## Segment data over bins regions: # Also remove not filled reserved memory space: if useEtBins: npEt = npCurrent.delete( npEt, slice(cPos,None)) if useEtaBins: npEta = npCurrent.delete( npEta, slice(cPos,None)) # Treat npObject = self.treatNpInfo(cPos, npEt, npEta, useEtBins, useEtaBins, nEtBins, nEtaBins, standardCaloVariables, ringConfig, npPatterns, ) data = [self.treatNpInfo(cPos, npEt, npEta, useEtBins, useEtaBins, nEtBins, nEtaBins, standardCaloVariables, ringConfig, npData) for npData in npBaseInfo] npBaseInfo = npCurrent.array( data, dtype=np.object ) else: npObject = npCurrent.array([], dtype=npCurrent.dtype) # not getRatesOnly if getRates: if crossVal: for etBin in range(nEtBins): for etaBin in range(nEtaBins): for branchCross in branchCrossEffCollectors.itervalues(): if not useBins: branchCross.finished() else: branchCross[etBin][etaBin].finished() # Print efficiency for each one for the efficiency branches analysed: for etBin in range(nEtBins) if useBins else range(1): for etaBin in range(nEtaBins) if useBins else range(1): for branch in branchEffCollectors.itervalues(): lBranch = branch if not useBins else branch[etBin][etaBin] self._info('%s',lBranch) if crossVal: for branchCross in branchCrossEffCollectors.itervalues(): lBranchCross = branchCross if not useBins else branchCross[etBin][etaBin] lBranchCross.dump(self._debug, printSort = True, sortFcn = self._verbose) # for branch # for eta # for et # end of (getRates) outputs = [] #if not getRatesOnly: outputs.extend((npObject, npBaseInfo)) #if getRates: outputs.extend((branchEffCollectors, branchCrossEffCollectors)) #outputs = tuple(outputs) return outputs
def __init__(self, **kw): Logger.__init__(self, kw) printArgs(kw, self._debug) self._nSorts = None self._nBoxes = None self._nTrain = None self._nValid = None self._nTest = None self._seed = None self._method = CrossValidMethod.retrieve( retrieve_kw(kw, 'method', CrossValidMethod.Standard)) if self._method is CrossValidMethod.Standard: self._nSorts = retrieve_kw(kw, 'nSorts', 50) self._nBoxes = retrieve_kw(kw, 'nBoxes', 10) self._nTrain = retrieve_kw(kw, 'nTrain', 6) self._nValid = retrieve_kw(kw, 'nValid', 4) self._nTest = retrieve_kw( kw, 'nTest', self._nBoxes - (self._nTrain + self._nValid)) self._seed = retrieve_kw(kw, 'seed', None) checkForUnusedVars(kw, self._warning) # Check if variables are ok: if (not self._nTest is None) and self._nTest < 0: self._fatal("Number of test clusters is lesser than zero", ValueError) totalSum = self._nTrain + self._nValid + (self._nTest) if self._nTest else \ self._nTrain + self._nValid if totalSum != self._nBoxes: self._fatal( "Sum of train, validation and test boxes doesn't match.", ValueError) np.random.seed(self._seed) # Test number of possible combinations (N!/((N-K)!(K)!) is greater # than the required sorts. If number of sorts (greater than half of the # possible cases) is close to the number of combinations, generate all # possible combinations and then gather the number of needed sorts. # However, as calculating factorial can be heavy, we don't do this if the # number of boxes is large. self._sort_boxes_list = [] useRandomCreation = True from math import factorial if self._nBoxes < 201: totalPossibilities = ( factorial( self._nBoxes ) ) / \ ( factorial( self._nTrain ) * \ factorial( self._nValid ) * \ factorial( self._nTest ) ) if self._nSorts > (totalPossibilities / 2): useRandomCreation = False if useRandomCreation: count = 0 while True: random_boxes = np.random.permutation(self._nBoxes) random_boxes = tuple( chain( sorted(random_boxes[0:self._nTrain]), sorted(random_boxes[self._nTrain:self._nTrain + self._nValid]), sorted(random_boxes[self._nTrain + self._nValid:]))) # Make sure we are not appending same sort again: if not random_boxes in self._sort_boxes_list: self._sort_boxes_list.append(random_boxes) count += 1 if count == self._nSorts: break else: self._sort_boxes_list = list( combinations_taken_by_multiple_groups( range(self._nBoxes), (self._nTrain, self._nValid, self._nTest))) for i in range(totalPossibilities - self._nSorts): self._sort_boxes_list.pop( np.random.random_integers(0, totalPossibilities)) elif self._method is CrossValidMethod.JackKnife: self._nBoxes = retrieve_kw(kw, 'nBoxes', 10) checkForUnusedVars(kw, self._warning) self._nSorts = self._nBoxes self._nTrain = self._nBoxes - 1 self._nValid = 1 self._nTest = 0 self._sort_boxes_list = list( combinations_taken_by_multiple_groups(range(self._nBoxes), ( 9, 1, ))) elif self._method is CrossValidMethod.StratifiedKFold: self._nBoxes = retrieve_kw(kw, 'nBoxes', 10) self._shuffle = retrieve_kw(kw, 'shuffle', False) checkForUnusedVars(kw, self._logger.warning) self._nSorts = self._nBoxes self._nTrain = self._nBoxes - 1 self._nValid = 1 self._nTest = 0
def plot(self, **kw): dirname = retrieve_kw(kw, 'dirname' , 'correction' ) pdftitle = retrieve_kw(kw, 'pdftitle' , 'Distributions') pdfoutput = retrieve_kw(kw, 'pdfoutput' , 'distributions') atlaslabel = retrieve_kw(kw, 'atlaslabel' , 'Internal' ) selectorDict = retrieve_kw(kw, 'selectorDict', None ) dovertical = retrieve_kw(kw, 'dovertical' , False ) import os # Organize outputs (.py and .pdf) from datetime import datetime localpath = os.getcwd()+'/'+dirname try: if not os.path.exists(localpath): os.makedirs(localpath) except: self._logger.warning('The director %s exist.', localpath) # create skeleton thrDict = {'version':1, 'type': ['Hypo'] , 'date':0, 'metadata':dict(), 'tuning':dict(), 'name':[self._alias]} thrDict['metadata'] = self._metadata self._logger.info('Applying correction...') for pidname, pair in self._algDictNames.iteritems(): # get the real reference values refValues = self.__retrieveTargetValues(pidname) algname = pair[0] tgtname = pair[1] # retrive the correct et/eta information if selectorDict: # retrieve from the expert input try: selector = selectorDict[algname] except KeyError: self._logger.fatal('Can not retrieve the algname %s',algname) else: # Retrieve from the framework if self._doTrigger: # Online obj = self.retrieve( "FastCalo" ); selector=obj.getDecor(algname+'_selector') else: # Offline obj = self.retrieve( "Electron" ); selector=obj.getDecor(algname+'_selector') # create new grid of thresholds objects selector.reset( self._thresholdEtBins, self._thresholdEtaBins ) useNoActivationFunctionInTheLastLayer=selector.useNoActivationFunctionInTheLastLayer for etBinIdx in range( len(self._thresholdEtBins)-1 ): for etaBinIdx in range( len(self._thresholdEtaBins)-1 ): binningname = ('et%d_eta%d') % (etBinIdx,etaBinIdx) ref = refValues[etBinIdx][etaBinIdx] # relax detection if needed ref = ref + ((1-ref)*self._percentage[pidname]) # Retrive histograms if self._doTrigger: path = self._basepath+'/probes/'+pidname+'/'+algname+'/'+binningname sgnHist2D = self.storeSvc().histogram(path+'/discriminantVsMu') path = self._basepath+'/fakes/'+pidname+'/'+algname+'/'+binningname bkgHist2D = self.storeSvc().histogram(path+'/discriminantVsMu') else: path = self._basepath+'/probes/'+pidname+'/'+algname+'/'+binningname sgnHist2D = self.storeSvc().histogram(path+'/discriminantVsNvtx') path = self._basepath+'/fakes/'+pidname+'/'+algname+'/'+binningname bkgHist2D = self.storeSvc().histogram(path+'/discriminantVsNvtx') plotname = localpath+'/eff_corr_'+algname+'_'+binningname b, a , b0 = self.__applyThresholdCorrection(ref,sgnHist2D.Clone(),bkgHist2D.Clone(),binningname, plotname, draw=True , xname = '<#mu>' if self._doTrigger else 'N_{vtx}', useNoActivationFunctionInTheLastLayer=useNoActivationFunctionInTheLastLayer, limits = self._limits, dolumi=False, # FIXME: need to add spaces here. Fix in AtlasStyle for future atlaslabel = ' '+atlaslabel, dovertical = dovertical ) selector.configureThresholdParam(binningname, a, b, b0) # Hold the thresholds objects thrDict['tuning'][selector.pidname] = {} thresholds = selector.thresholds for key in sorted(thresholds.keys()): thrDict['tuning'][selector.pidname][key] = thresholds[key].toRaw() # Create the athena/python conf file name=localpath+'/TrigL2CaloRingerThresholds.py' pyfile = open(name,'w') pyfile.write('def ThresholdsMap():\n') pyfile.write(' s=dict()\n') for key in thrDict.keys(): pyfile.write(' s["%s"]=%s\n' % (key, thrDict[key])) pyfile.write(' return s\n') from RingerCore.tex.BeamerAPI import BeamerTexReportTemplate1,BeamerSection,BeamerMultiFigureSlide,BeamerFigureSlide if not dovertical: self._logger.info('Do pdf maker...') # Slide maker with BeamerTexReportTemplate1( theme = 'Berlin' , _toPDF = True , title = pdftitle , outputFile = pdfoutput , font = 'structurebold' ): for pidname, pair in self._algDictNames.iteritems(): factor = self._percentage[pidname] with BeamerSection( name = pidname ): # get the real reference values refValues = self.__retrieveTargetValues(pidname) algname = pair[0] tgtname = pair[1] for etBinIdx in range( len(self._thresholdEtBins)-1 ): for etaBinIdx in range( len(self._thresholdEtaBins)-1 ): binningname = ('et%d_eta%d') % (etBinIdx,etaBinIdx) plotname = localpath+'/eff_corr_'+algname+'_'+binningname+'.pdf' BeamerMultiFigureSlide( title = ("%s, factor = %1.2f, (%s)")%(algname.replace('_','\_'), factor ,binningname.replace('_','\_') ) , paths = [plotname] , nDivWidth = 1 # x , nDivHeight = 1 # y , texts=None , fortran = False , usedHeight = 0.8 , usedWidth = 1.1 ) return StatusCode.SUCCESS
def __applyThresholdCorrection( self, refValue, sgn_hist2D, bkg_hist2D, partition_name, output_name, **kwargs): legend_position = retrieve_kw( kwargs, 'legend_position', (0.36,0.20,0.66,0.40)) useNoActivationFunctionInTheLastLayer=retrieve_kw(kwargs,'useNoActivationFunctionInTheLastLayer',False) xname = retrieve_kw( kwargs, 'xname', 'n_{vtx}' ) draw = retrieve_kw( kwargs, 'draw', False) limits = retrieve_kw( kwargs, 'limits', [0,10,20]) dovertical = retrieve_kw( kwargs, 'dovertical' , False) mumin = limits[0]; mumax=limits[-1] mubins = mumax-mumin from TrigEgammaDevelopments.helper.util import * sgn_hist2D = copy2DRegion(sgn_hist2D,1000,-12,7,mubins,mumin,mumax) bkg_hist2D = copy2DRegion(bkg_hist2D,1000,-12,7,mubins,mumin,mumax) from copy import deepcopy refValue_requested = refValue false_alarm = 1.0 false_alarm_limit = 0.20 while false_alarm > false_alarm_limit: # Calculate the original threshold b0, error = find_threshold(sgn_hist2D.ProjectionX(), refValue ) # Take eff points using uncorrection threshold discr_points, nvtx_points, error_points = calculate_dependent_discr_points(sgn_hist2D , refValue ) # Calculate eff without correction sgn_histNum, sgn_histDen, sgn_histEff, det0 = calculate_efficiency(sgn_hist2D, refValue, b0, 0, doCorrection=False) # Generate correction parameters and produce fixed plots sgn_histNum_corr, sgn_histDen_corr, sgn_histEff_corr, detection ,b, a = calculate_efficiency( sgn_hist2D, refValue, b0, 0, limits = limits, doCorretion=True) # Calculate eff without correction bkg_histNum, bkg_histDen, bkg_histEff, _ = calculate_efficiency(bkg_hist2D, refValue, b0, 0, doCorrection=False) # Calculate eff using the correction from signal bkg_histNum_corr, bkg_histDen_corr, bkg_histEff_corr, false_alarm = calculate_efficiency(bkg_hist2D, refValue, b, a, doCorrection=False) if false_alarm > false_alarm_limit: refValue-=0.025 # To np.array discr_points = np.array(discr_points) # Plot correction if draw: # Retrieve some usefull information y_max = sgn_hist2D.GetYaxis().GetXmax() y_min = sgn_hist2D.GetYaxis().GetXmin() x_min = y_min; x_max = y_max from ROOT import TCanvas, gStyle, TLegend, kRed, kBlue, kBlack,TLine from ROOT import TGraphErrors,TF1 gStyle.SetPalette(107) if dovertical: canvas = TCanvas('canvas','canvas',1600,2000) canvas.Divide(2,3) else: canvas = TCanvas('canvas','canvas',2800,1600) canvas.Divide(3,2) pad1= canvas.cd(1) sgn_histEff.SetTitle('Signal Efficiency in: '+partition_name) sgn_histEff.SetLineColor(kRed) sgn_histEff.SetMarkerColor(kRed) sgn_histEff.GetYaxis().SetTitle('#epsilon('+xname+')') sgn_histEff.GetXaxis().SetTitle(xname) sgn_histEff.GetYaxis().SetRangeUser( 0.6, 1.1 ) sgn_histEff.Draw() sgn_histEff_corr.SetLineColor(kBlack) sgn_histEff_corr.SetMarkerColor(kBlack) sgn_histEff_corr.Draw('sames') l0 = TLine(x_min,refValue_requested,x_max,refValue_requested) l0.SetLineColor(kBlack) l0.Draw() l1 = TLine(x_min,refValue,x_max,refValue) l1.SetLineColor(kBlack) l1.SetLineStyle(9) l1.Draw() leg1 = TLegend(legend_position[0],legend_position[1], legend_position[2],legend_position[3]) setLegend1(leg1) leg1.SetHeader('Signal efficiency in '+partition_name) leg1.AddEntry(sgn_histEff,('Old: d = %1.3f')%(b0),'p' ) lg1 = leg1.AddEntry(sgn_histEff_corr,('New: d = %1.3f + %s %1.3f')%(b,xname,a),'p' ) lg1.SetTextColor(kRed) leg1.AddEntry(l1,('Reference: %1.3f')%(refValue) ,'l') leg1.SetTextSize(0.03) leg1.SetBorderSize(0) leg1.Draw() atlas_template(pad1,**kwargs) pad2 = canvas.cd(2) if dovertical else canvas.cd(4) bkg_histEff.SetTitle('Background rejection in: '+partition_name) bkg_histEff.SetLineColor(kRed) bkg_histEff.SetMarkerColor(kRed) bkg_histEff.GetYaxis().SetTitle('#epsilon('+xname+')') bkg_histEff.GetXaxis().SetTitle(xname) bkg_histEff.Draw() bkg_histEff_corr.SetLineColor(kBlack) bkg_histEff_corr.SetMarkerColor(kBlack) bkg_histEff_corr.Draw('sames') l0.Draw() l1.Draw() leg2 = TLegend(legend_position[0],legend_position[1]+0.4, legend_position[2],legend_position[3]+0.4) setLegend1(leg2) leg2.SetHeader('Background rejection in '+partition_name) leg2.AddEntry(sgn_histEff,('Old: d = %1.3f')%(b0),'p' ) lg2 = leg2.AddEntry(sgn_histEff_corr,('New: d = %1.3f + %s %1.3f')%(b,xname,a),'p' ) lg2.SetTextColor(kRed) leg2.SetTextSize(0.03) leg2.SetBorderSize(0) leg2.Draw() atlas_template(pad2,**kwargs) pad3 = canvas.cd(3) if dovertical else canvas.cd(2) sgn_hist2D.SetTitle('Neural Network output as a function fo nvtx, '+partition_name) sgn_hist2D.GetXaxis().SetTitle('Neural Network output (Discriminant)') sgn_hist2D.GetYaxis().SetTitle(xname) sgn_hist2D.GetZaxis().SetTitle('') if not useNoActivationFunctionInTheLastLayer: sgn_hist2D.SetAxisRange(-1,1, 'X' ) sgn_hist2D.Draw('colz') pad3.SetLogz() # Add points g1 = TGraphErrors(len(discr_points), discr_points, np.array(nvtx_points)+limits[0], np.array(error_points), np.zeros(discr_points.shape)) g1.SetLineWidth(1) g1.SetLineColor(kBlue) g1.SetMarkerColor(kBlue) g1.Draw("P same") # Old threshold line l2 = TLine(b0,y_min,b0,y_max) l2.SetLineColor(kRed) l2.SetLineWidth(2) l2.Draw() # New threshold line l3 = TLine(b,y_min, a*y_max+b, y_max) l3.SetLineColor(kBlack) l3.SetLineWidth(2) l3.Draw() atlas_template(pad3,**kwargs) pad4 = canvas.cd(4) if dovertical else canvas.cd(5) bkg_hist2D.SetTitle('Neural Network output as a function fo nvtx, '+partition_name) bkg_hist2D.GetXaxis().SetTitle('Neural Network output (Discriminant)') bkg_hist2D.GetYaxis().SetTitle(xname) bkg_hist2D.GetZaxis().SetTitle('') if not useNoActivationFunctionInTheLastLayer: bkg_hist2D.SetAxisRange(-1,1, 'X' ) #sgn_hist2D.SetAxisRange(b+y_max*a-0.2,1, 'X' ) bkg_hist2D.Draw('colz') pad4.SetLogz() # Add points g2 = TGraphErrors(len(discr_points), discr_points, np.array(nvtx_points)+limits[0], np.array(error_points), np.zeros(discr_points.shape)) g2.SetLineWidth(1) g2.SetLineColor(kBlue) g2.SetMarkerColor(kBlue) g2.Draw("P same") # Old threshold line l4 = TLine(b0,y_min,b0,y_max) l4.SetLineColor(kRed) l4.SetLineWidth(2) l4.Draw() # New threshold line l5 = TLine(b,y_min, a*y_max+b, y_max) l5.SetLineColor(kBlack) l5.SetLineWidth(2) l5.Draw() atlas_template(pad4,**kwargs) from ROOT import TH1D, kAzure from TrigEgammaDevelopments.plots import AutoFixAxes pad5 = canvas.cd(5) if dovertical else canvas.cd(3) #pad5.SetLogy() h5 = TH1D(sgn_hist2D.ProjectionX()) h6 = TH1D(bkg_hist2D.ProjectionX()) if max(h5.GetMaximum(),h6.GetMaximum()) > 10*(min(h5.GetMaximum(),h6.GetMaximum())): pad5.SetLogy() h5.Rebin(10) h6.Rebin(10) h5.SetLineColor(kAzure+6) h5.SetFillColor(kAzure+6) h6.SetLineColor(kRed-7) h5.Draw() h6.Draw('sames') AutoFixAxes(pad5,False,False,1.5) atlas_template(pad5,**kwargs) pad6 = canvas.cd(6) #pad6.SetLogy() h7 = TH1D(bkg_hist2D.ProjectionX()) h8 = TH1D(sgn_hist2D.ProjectionX()) if max(h7.GetMaximum(),h8.GetMaximum()) > 10*(min(h7.GetMaximum(),h8.GetMaximum())): pad6.SetLogy() h7.Rebin(10) h8.Rebin(10) h7.SetLineColor(kRed-7) h7.SetFillColor(kRed-7) h8.SetLineColor(kAzure+6) h7.Draw() h8.Draw('sames') AutoFixAxes(pad6,False,False,1.5) atlas_template(pad6,**kwargs) canvas.SaveAs(output_name+'.pdf') return b,a,b0
def __plot_profiles_in_same_canvas(self, hist_objs, hist_names, legends, y_limits, **kwargs): legend_position = retrieve_kw(kwargs, 'legend_position', (0.36, 0.20, 0.66, 0.36)) legend_prefix = retrieve_kw(kwargs, 'legend_prefix', 'Z#rightarrowee, ') legend_header = retrieve_kw(kwargs, 'legend_header', 'Trigger step') ylabel = retrieve_kw(kwargs, 'ylabel', 'Trigger Efficiency') title = retrieve_kw(kwargs, 'title', 'Trigger Efficiency') oname = retrieve_kw(kwargs, 'oname', 'plot_efficiencys') column = retrieve_kw(kwargs, 'column', 2) doRatio = retrieve_kw(kwargs, 'doRatio', False) canvas_size = retrieve_kw(kwargs, 'canvas_size', (1800, 1500)) # FIXME: This must be disable for now, there is some problem into the xaxis scale # The top and bot axis must be match! tobject_collector = [] ratio_size_as_fraction = 0.35 from ROOT import TCanvas, TLegend, TProfile, TPad rows = int(round(len(hist_objs) / float(column))) canvas = TCanvas('canvas', 'canvas', canvas_size[0], canvas_size[1]) canvas.Divide(rows, column) leg_holder = [] for index, hist_str in enumerate(hist_names): hists = hist_objs[hist_str] pad = canvas.cd(index + 1) # Force disable if != of 2 if len(hists) != 2: doRatio = False if doRatio: drawopt = 'pE1' pad.cd() top = TPad("pad_top", "This is the top pad", 0.0, ratio_size_as_fraction, 1.0, 1.0) top.SetBottomMargin(0.0) top.SetBottomMargin(0.06 / float(top.GetHNDC())) #top.SetTopMargin (0.04/float(top.GetHNDC())) top.SetRightMargin(0.05) top.SetLeftMargin(0.16) top.SetFillColor(0) top.Draw(drawopt) tobject_collector.append(top) pad.cd() bot = TPad("pad_bot", "This is the bottom pad", 0.0, 0.0, 1.0, ratio_size_as_fraction) bot.SetBottomMargin(0.10 / float(bot.GetHNDC())) #bot.SetTopMargin (0.02/float(bot.GetHNDC())) bot.SetTopMargin(0.0) bot.SetRightMargin(0.05) bot.SetLeftMargin(0.16) bot.SetFillColor(0) bot.Draw(drawopt) tobject_collector.append(bot) if type(legend_prefix) is not list: legend_prefix = [legend_prefix] * len(legends) if doRatio: top.cd() leg = TLegend(legend_position[0], legend_position[1], legend_position[2], legend_position[3]) from AtlasStyle import setLegend1, atlas_template setLegend1(leg) leg.SetHeader(legend_header) for i, eff in enumerate(hists): eff.SetLineColor(self._curve_color[i]) eff.SetMarkerColor(self._curve_color[i]) eff.SetMarkerStyle(self._marker_style[i]) if type(eff) is TProfile: eff.SetStats(0) leg.AddEntry(eff, legend_prefix[i] + legends[i], 'p') if i is 0: eff.Draw() else: eff.Draw('same') leg.SetTextSize(0.03) leg.SetBorderSize(0) leg.Draw() if doRatio: top.Modified() top.Update pad.Modified() pad.Update() from ROOT import TProfile, TEfficiency, kFALSE xmin = 0 xmax = 999 if type(hists[0]) is TProfile: hists[0].GetYaxis().SetRangeUser(y_limits[index][0], y_limits[index][1]) elif type(hists[0]) is TEfficiency: hists[0].GetPaintedGraph().GetYaxis().SetRangeUser( y_limits[index][0], y_limits[index][1]) hists[0].GetPaintedGraph().GetYaxis().SetTitle('A') # Fix the X axis nbins = hists[0].GetTotalHistogram().GetNbinsX() xmin = hists[0].GetTotalHistogram().GetXaxis().GetBinLowEdge(1) xmax = hists[0].GetTotalHistogram().GetXaxis().GetBinLowEdge( nbins + 1) hists[0].GetPaintedGraph().GetXaxis().SetLimits(xmin, xmax) else: hists[0].GetYaxis().SetRangeUser(y_limits[index][0], y_limits[index][1]) pad.Modified() pad.Update() tobject_collector.append(leg) if doRatio: atlas_template(top, **kwargs) top.Update() from ROOT import TH1 divide = "" drawopt = 'pE1' bot.cd() ref = hists[0].GetPassedHistogram().Clone() h = hists[1].GetPassedHistogram().Clone() #ref = hists[0].Clone() #h = hists[1].Clone() ref.Sumw2() h.Sumw2() ref.Divide(hists[0].GetTotalHistogram().Clone()) h.Divide(hists[1].GetTotalHistogram().Clone()) #ratioplot = TEfficiency(h,ref) ratioplot = h.Clone() ratioplot.Sumw2() ratioplot.SetName(h.GetName() + '_ratio') ratioplot.Divide(h, ref, 1., 1., '') #ratioplot.Divide(ref) ratioplot.SetFillColor(0) ratioplot.SetFillStyle(0) ratioplot.SetMarkerColor(1) ratioplot.SetLineColor(kBlack) ratioplot.SetMarkerStyle(24) ratioplot.SetMarkerSize(1.2) ratioplot.GetYaxis().SetTitle('trigger / ref') ratioplot.GetYaxis().SetTitleSize(0.10) ratioplot.GetXaxis().SetTitleSize(0.10) ratioplot.GetXaxis().SetLabelSize(0.10) ratioplot.GetYaxis().SetLabelSize(0.10) ratioplot.GetYaxis().SetRangeUser(0.9, 1.07) ratioplot.Draw(drawopt) tobject_collector.append(ratioplot) #atlas_template(bot, **kwargs) from ROOT import TLine l1 = TLine(xmin, 1, xmax, 1) l1.SetLineColor(kRed) l1.SetLineStyle(2) l1.Draw() tobject_collector.append(l1) bot.Update() else: atlas_template(pad, **kwargs) pad.Update() canvas.SaveAs(oname + '.pdf')
def __call__(self, fList, ringerOperation, **kw): """ Read ntuple and return patterns and efficiencies. Arguments: - fList: The file path or file list path. It can be an argument list of two types: o List: each element is a string path to the file; o Comma separated string: each path is separated via a comma o Folders: Expand folders recursively adding also files within them to analysis - ringerOperation: Set Operation type. It can be both a string or the RingerOperation Optional arguments: - filterType [None]: whether to filter. Use FilterType enumeration - reference [Truth]: set reference for targets. Use Reference enumeration - treePath [Set using operation]: set tree name on file, this may be set to use different sources then the default. Default for: o Offline: Offline/Egamma/Ntuple/electron o L2: Trigger/HLT/Egamma/TPNtuple/e24_medium_L1EM18VH - l1EmClusCut [None]: Set L1 cluster energy cut if operating on the trigger - l2EtCut [None]: Set L2 cluster energy cut value if operating on the trigger - offEtCut [None]: Set Offline cluster energy cut value - nClusters [None]: Read up to nClusters. Use None to run for all clusters. - getRatesOnly [False]: Read up to nClusters. Use None to run for all clusters. - etBins [None]: E_T bins (GeV) where the data should be segmented - etaBins [None]: eta bins where the data should be segmented - ringConfig [100]: A list containing the number of rings available in the data for each eta bin. - crossVal [None]: Whether to measure benchmark efficiency splitting it by the crossVal-validation datasets - extractDet [None]: Which detector to export (use Detector enumeration). Defaults are: o L2Calo: Calorimetry o L2: Tracking o Offline: Calorimetry o Others: CaloAndTrack - standardCaloVariables [False]: Whether to extract standard track variables. - useTRT [False]: Whether to export TRT information when dumping track variables. - supportTriggers [True]: Whether reading data comes from support triggers """ __eventBranches = [ 'EventNumber', 'RunNumber', 'RandomRunNumber', 'MCChannelNumber', 'RandomLumiBlockNumber', 'MCPileupWeight', 'VertexZPosition', 'Zcand_M', 'Zcand_pt', 'Zcand_eta', 'Zcand_phi', 'Zcand_y', 'isTagTag' ] __trackBranches = [ 'elCand2_deltaeta1', 'elCand2_DeltaPOverP', 'elCand2_deltaphiRescaled', 'elCand2_d0significance', 'elCand2_trackd0pvunbiased', 'elCand2_eProbabilityHT' ] __monteCarloBranches = [ 'type', 'origin', 'originbkg', 'typebkg', 'isTruthElectronFromZ', 'TruthParticlePdgId', 'firstEgMotherPdgId', 'TruthParticleBarcode', 'firstEgMotherBarcode', 'MotherPdgId', 'MotherBarcode', 'FirstEgMotherTyp', 'FirstEgMotherOrigin', 'dRPdgId', ] __onlineBranches = ['match', 'ringerMatch', 'ringer_rings'] __offlineBranches = ['et', 'eta'] # The current pid map used as offline reference pidConfigs = { key: value for key, value in RingerOperation.efficiencyBranches().iteritems() if key in (RingerOperation.Offline_LH_Tight, RingerOperation.Offline_LH_Medium, RingerOperation.Offline_LH_Loose, RingerOperation.Offline_LH_VeryLoose) } # Retrieve information from keyword arguments filterType = retrieve_kw(kw, 'filterType', FilterType.DoNotFilter) reference = retrieve_kw(kw, 'reference', Reference.AcceptAll) offEtCut = retrieve_kw(kw, 'offEtCut', None) l2EtCut = retrieve_kw(kw, 'l2EtCut', None) treePath = retrieve_kw(kw, 'treePath', 'ZeeCandidate') nClusters = retrieve_kw(kw, 'nClusters', None) etBins = retrieve_kw(kw, 'etBins', None) etaBins = retrieve_kw(kw, 'etaBins', None) crossVal = retrieve_kw(kw, 'crossVal', None) ringConfig = retrieve_kw(kw, 'ringConfig', 100) monitoring = retrieve_kw(kw, 'monitoring', None) pileupRef = retrieve_kw(kw, 'pileupRef', NotSet) getRates = retrieve_kw(kw, 'getRates', True) getRatesOnly = retrieve_kw(kw, 'getRatesOnly', False) getTagsOnly = retrieve_kw(kw, 'getTagsOnly', False) extractDet = retrieve_kw(kw, 'extractDet', None) import ROOT #gROOT.ProcessLine (".x $ROOTCOREDIR/scripts/load_packages.C"); #ROOT.gROOT.Macro('$ROOTCOREDIR/scripts/load_packages.C') if ROOT.gSystem.Load('libTuningTools') < 0: self._fatal("Could not load TuningTools library", ImportError) if 'level' in kw: self.level = kw.pop('level') # and delete it to avoid mistakes: checkForUnusedVars(kw, self._warning) del kw ### Parse arguments # Also parse operation, check if its type is string and if we can # transform it to the known operation enum: fList = csvStr2List(fList) fList = expandFolders(fList) ringerOperation = RingerOperation.retrieve(ringerOperation) reference = Reference.retrieve(reference) # Offline E_T cut if offEtCut: offEtCut = 1000. * offEtCut # Put energy in MeV # Check whether using bins useBins = False useEtBins = False useEtaBins = False nEtaBins = 1 nEtBins = 1 if etaBins is None: etaBins = npCurrent.fp_array([]) if type(etaBins) is list: etaBins = npCurrent.fp_array(etaBins) if etBins is None: etBins = npCurrent.fp_array([]) if type(etBins) is list: etBins = npCurrent.fp_array(etBins) if etBins.size: etBins = etBins * 1000. # Put energy in MeV nEtBins = len(etBins) - 1 if nEtBins >= np.iinfo(npCurrent.scounter_dtype).max: self._fatal(( 'Number of et bins (%d) is larger or equal than maximum ' 'integer precision can hold (%d). Increase ' 'TuningTools.coreDef.npCurrent scounter_dtype number of bytes.' ), nEtBins, np.iinfo(npCurrent.scounter_dtype).max) # Flag that we are separating data through bins useBins = True useEtBins = True self._debug('E_T bins enabled.') if not type(ringConfig) is list and not type(ringConfig) is np.ndarray: ringConfig = [ringConfig] * (len(etaBins) - 1) if etaBins.size else 1 if type(ringConfig) is list: ringConfig = npCurrent.int_array(ringConfig) if not len(ringConfig): self._fatal('Rings size must be specified.') if etaBins.size: nEtaBins = len(etaBins) - 1 if nEtaBins >= np.iinfo(npCurrent.scounter_dtype).max: self._fatal(( 'Number of eta bins (%d) is larger or equal than maximum ' 'integer precision can hold (%d). Increase ' 'TuningTools.coreDef.npCurrent scounter_dtype number of bytes.' ), nEtaBins, np.iinfo(npCurrent.scounter_dtype).max) if len(ringConfig) != nEtaBins: self._fatal(( 'The number of rings configurations (%r) must be equal than ' 'eta bins (%r) region config'), ringConfig, etaBins) useBins = True useEtaBins = True self._debug('eta bins enabled.') else: self._debug('eta/et bins disabled.') # The base information holder, such as et, eta and pile-up if pileupRef is NotSet: if ringerOperation > 0: pileupRef = PileupReference.avgmu else: pileupRef = PileupReference.nvtx pileupRef = PileupReference.retrieve(pileupRef) self._info("Using '%s' as pile-up reference.", PileupReference.tostring(pileupRef)) # Candidates: (1) is tags and (2) is probes. Default is probes self._candIdx = 1 if getTagsOnly else 2 # Mutual exclusive arguments: if not getRates and getRatesOnly: self._logger.error( "Cannot run with getRates set to False and getRatesOnly set to True. Setting getRates to True." ) getRates = True ### Prepare to loop: t = ROOT.TChain(treePath) for inputFile in progressbar(fList, len(fList), logger=self._logger, prefix="Creating collection tree "): # Check if file exists f = ROOT.TFile.Open(inputFile, 'read') if not f or f.IsZombie(): self._warning('Couldn' 't open file: %s', inputFile) continue # Inform user whether TTree exists, and which options are available: self._debug("Adding file: %s", inputFile) obj = f.Get(treePath) if not obj: self._warning("Couldn't retrieve TTree (%s)!", treePath) self._info("File available info:") f.ReadAll() f.ReadKeys() f.ls() continue elif not isinstance(obj, ROOT.TTree): self._fatal("%s is not an instance of TTree!", treePath, ValueError) t.Add(inputFile) # Turn all branches off. t.SetBranchStatus("*", False) # RingerPhysVal hold the address of required branches event = ROOT.SkimmedNtuple() # Ready to retrieve the total number of events t.GetEntry(0) ## Allocating memory for the number of entries entries = t.GetEntries() nobs = entries if (nClusters is None or nClusters > entries or nClusters < 1) \ else nClusters ## Retrieve the dependent operation variables: if useEtBins: etBranch = ('elCand%d_et') % ( self._candIdx) if ringerOperation < 0 else ('fcCand%d_et') % ( self._candIdx) self.__setBranchAddress(t, etBranch, event) self._debug("Added branch: %s", etBranch) npEt = npCurrent.scounter_zeros( shape=npCurrent.shape(npat=1, nobs=nobs)) self._debug("Allocated npEt with size %r", npEt.shape) if useEtaBins: etaBranch = ('elCand%d_eta') % ( self._candIdx) if ringerOperation < 0 else ('fcCand%d_eta') % ( self._candIdx) self.__setBranchAddress(t, etaBranch, event) self._debug("Added branch: %s", etaBranch) npEta = npCurrent.scounter_zeros( shape=npCurrent.shape(npat=1, nobs=nobs)) self._debug("Allocated npEta with size %r", npEta.shape) if reference is Reference.Truth: self.__setBranchAddress(t, ('elCand%d_isTruthElectronFromZ') % (self._candIdx), event) for var in __offlineBranches: self.__setBranchAddress(t, ('elCand%d_%s') % (self._candIdx, var), event) #for var in pidConfigs.values(): # self.__setBranchAddress(t,var,event) for var in __trackBranches: self.__setBranchAddress(t, var, event) # Add online branches if using Trigger if ringerOperation > 0: for var in __onlineBranches: self.__setBranchAddress(t, ('fcCand%d_%s') % (self._candIdx, var), event) else: self.__setBranchAddress(t, ('elCand%d_%s') % (self._candIdx, 'ringer_rings'), event) if pileupRef is PileupReference.nvtx: pileupBranch = 'Nvtx' pileupDataType = np.uint16 elif pileupRef is PileupReference.avgmu: pileupBranch = 'averageIntPerXing' pileupDataType = np.float32 else: raise NotImplementedError( "Pile-up reference %r is not implemented." % pileupRef) #for var in __eventBranches + for var in [pileupBranch]: self.__setBranchAddress(t, var, event) ### Allocate memory if extractDet == (Detector.Calorimetry): npat = ringConfig.max() elif extractDet == (Detector.Tracking): npat = len(__trackBranches) # NOTE: Check if pat is correct for both Calo and track data elif extractDet in (Detector.CaloAndTrack, Detector.All): npat = ringConfig.max() + len(__trackBranches) npPatterns = npCurrent.fp_zeros(shape=npCurrent.shape( npat=npat, #getattr(event, ringerBranch).size() nobs=nobs)) self._debug("Allocated npPatterns with size %r", npPatterns.shape) baseInfoBranch = BaseInfo( (etBranch, etaBranch, pileupBranch), (npCurrent.fp_dtype, npCurrent.fp_dtype, pileupDataType)) baseInfo = [ None, ] * baseInfoBranch.nInfo # Add E_T, eta and luminosity information npBaseInfo = [ npCurrent.zeros(shape=npCurrent.shape(npat=1, nobs=nobs), dtype=baseInfoBranch.dtype(idx)) for idx in baseInfoBranch ] from TuningTools.CreateData import BranchEffCollector, BranchCrossEffCollector branchEffCollectors = OrderedDict() branchCrossEffCollectors = OrderedDict() if ringerOperation < 0: from operator import itemgetter benchmarkDict = OrderedDict( sorted([(key, value) for key, value in RingerOperation.efficiencyBranches().iteritems() if key < 0 and not (isinstance(value, (list, tuple)))], key=itemgetter(0))) else: benchmarkDict = OrderedDict() for key, val in benchmarkDict.iteritems(): branchEffCollectors[key] = list() branchCrossEffCollectors[key] = list() # Add efficincy branch: if ringerOperation < 0: self.__setBranchAddress(t, val, event) for etBin in range(nEtBins): if useBins: branchEffCollectors[key].append(list()) branchCrossEffCollectors[key].append(list()) for etaBin in range(nEtaBins): etBinArg = etBin if useBins else -1 etaBinArg = etaBin if useBins else -1 argList = [ RingerOperation.tostring(key), val, etBinArg, etaBinArg ] branchEffCollectors[key][etBin].append( BranchEffCollector(*argList)) if crossVal: branchCrossEffCollectors[key][etBin].append( BranchCrossEffCollector(entries, crossVal, *argList)) # etBin # etaBin # benchmark dict if self._logger.isEnabledFor(LoggingLevel.DEBUG): self._debug( 'Retrieved following branch efficiency collectors: %r', [ collector[0].printName for collector in traverse(branchEffCollectors.values()) ]) etaBin = 0 etBin = 0 step = int(entries / 100) if int(entries / 100) > 0 else 1 ## Start loop! self._info("There is available a total of %d entries.", entries) cPos = 0 ### Loop over entries for entry in progressbar(range(entries), entries, step=step, logger=self._logger, prefix="Looping over entries "): self._verbose('Processing eventNumber: %d/%d', entry, entries) t.GetEntry(entry) #print self.__getEt(event) if event.elCand2_et < offEtCut: self._debug( "Ignoring entry due to offline E_T cut. E_T = %1.3f < %1.3f MeV", event.elCand2_et, offEtCut) continue # Add et distribution for all events if ringerOperation > 0: if event.fcCand2_et < l2EtCut: self._debug("Ignoring entry due Fast Calo E_T cut.") continue # Add et distribution for all events # Set discriminator target: target = Target.Unknown # Monte Carlo cuts if reference is Reference.Truth: if getattr(event, ('elCand%d_isTruthElectronFromZ') % (self._candIdx)): target = Target.Signal elif not getattr(event, ('elCand%d_isTruthElectronFromZ') % (self._candIdx)): target = Target.Background # Offline Likelihood cuts elif reference is Reference.Off_Likelihood: if getattr(event, pidConfigs[RingerOperation.Offline_LH_Tight]): target = Target.Signal elif not getattr( event, pidConfigs[RingerOperation.Offline_LH_VeryLoose]): target = Target.Background # By pass everything (Default) elif reference is Reference.AcceptAll: target = Target.Signal if filterType is FilterType.Signal else Target.Background # Run filter if it is defined if filterType and \ ( (filterType is FilterType.Signal and target != Target.Signal) or \ (filterType is FilterType.Background and target != Target.Background) or \ (target == Target.Unknown) ): #self._verbose("Ignoring entry due to filter cut.") continue ## Retrieve base information and rings: for idx in baseInfoBranch: lInfo = getattr(event, baseInfoBranch.retrieveBranch(idx)) baseInfo[idx] = lInfo # Retrieve dependent operation region if useEtBins: etBin = self.__retrieveBinIdx(etBins, baseInfo[0]) if useEtaBins: etaBin = self.__retrieveBinIdx(etaBins, np.fabs(baseInfo[1])) # Check if bin is within range (when not using bins, this will always be true): if (etBin < nEtBins and etaBin < nEtaBins): if useEtBins: npEt[cPos] = etBin if useEtaBins: npEta[cPos] = etaBin # Online operation cPat = 0 caloAvailable = True if ringerOperation > 0 and self.__get_ringer_onMatch( event) < 1: continue # TODO Treat case where we don't use rings energy # Check if the rings empty if self.__get_rings_energy(event, ringerOperation).empty(): self._debug( 'No rings available in this event. Skipping...') caloAvailable = False # Retrieve rings: if extractDet in (Detector.Calorimetry, Detector.CaloAndTrack, Detector.All): if caloAvailable: try: pass patterns = stdvector_to_list( self.__get_rings_energy( event, ringerOperation)) lPat = len(patterns) if lPat == ringConfig[etaBin]: npPatterns[npCurrent.access( pidx=slice(cPat, ringConfig[etaBin]), oidx=cPos)] = patterns else: oldEtaBin = etaBin if etaBin > 0 and ringConfig[etaBin - 1] == lPat: etaBin -= 1 elif etaBin + 1 < len( ringConfig) and ringConfig[etaBin + 1] == lPat: etaBin += 1 npPatterns[npCurrent.access( pidx=slice(cPat, ringConfig[etaBin]), oidx=cPos)] = patterns self._warning(( "Recovered event which should be within eta bin (%d: %r) " "but was found to be within eta bin (%d: %r). " "Its read eta value was of %f."), oldEtaBin, etaBins[oldEtaBin:oldEtaBin + 2], etaBin, etaBins[etaBin:etaBin + 2], np.fabs(getattr( event, etaBranch))) except ValueError: self._logger.error(( "Patterns size (%d) do not match expected " "value (%d). This event eta value is: %f, and ringConfig is %r." ), lPat, ringConfig[etaBin], np.fabs( getattr(event, etaBranch)), ringConfig) continue cPat += ringConfig[etaBin] else: # Also display warning when extracting only calorimetry! self._warning("Rings not available") continue if extractDet in (Detector.Tracking, Detector.CaloAndTrack, Detector.All): for var in __trackBranches: npPatterns[npCurrent.access(pidx=cPat, oidx=cPos)] = getattr( event, var) if var == 'elCand2_eProbabilityHT': from math import log TRT_PID = npPatterns[npCurrent.access(pidx=cPat, oidx=cPos)] epsilon = 1e-99 if TRT_PID >= 1.0: TRT_PID = 1.0 - 1.e-15 elif TRT_PID <= 0.0: TRT_PID = epsilon tau = 15.0 TRT_PID = -(1 / tau) * log((1.0 / TRT_PID) - 1.0) npPatterns[npCurrent.access(pidx=cPat, oidx=cPos)] = TRT_PID cPat += 1 ## Retrieve rates information: if getRates and ringerOperation < 0: #event.elCand2_isEMVerLoose2015 = not( event.elCand2_isEMVeryLoose2015 & 34896 ) event.elCand2_isEMLoose2015 = not ( event.elCand2_isEMLoose2015 & 34896) event.elCand2_isEMMedium2015 = not ( event.elCand2_isEMMedium2015 & 276858960) event.elCand2_isEMTight2015 = not ( event.elCand2_isEMTight2015 & 281053264) for branch in branchEffCollectors.itervalues(): if not useBins: branch.update(event) else: branch[etBin][etaBin].update(event) if crossVal: for branchCross in branchCrossEffCollectors.itervalues( ): if not useBins: branchCross.update(event) else: branchCross[etBin][etaBin].update(event) # end of (getRates) if not monitoring is None: self.__fillHistograms(monitoring, filterType, pileupRef, pidConfigs, event) # We only increment if this cluster will be computed cPos += 1 # end of (et/eta bins) # Limit the number of entries to nClusters if desired and possible: if not nClusters is None and cPos >= nClusters: break # for end ## Treat the rings information ## Remove not filled reserved memory space: if npPatterns.shape[npCurrent.odim] > cPos: npPatterns = np.delete(npPatterns, slice(cPos, None), axis=npCurrent.odim) ## Segment data over bins regions: # Also remove not filled reserved memory space: if useEtBins: npEt = npCurrent.delete(npEt, slice(cPos, None)) if useEtaBins: npEta = npCurrent.delete(npEta, slice(cPos, None)) # Treat standardCaloVariables = False npObject = self.treatNpInfo( cPos, npEt, npEta, useEtBins, useEtaBins, nEtBins, nEtaBins, standardCaloVariables, ringConfig, npPatterns, ) data = [ self.treatNpInfo(cPos, npEt, npEta, useEtBins, useEtaBins, nEtBins, nEtaBins, standardCaloVariables, ringConfig, npData) for npData in npBaseInfo ] npBaseInfo = npCurrent.array(data, dtype=np.object) if getRates: if crossVal: for etBin in range(nEtBins): for etaBin in range(nEtaBins): for branchCross in branchCrossEffCollectors.itervalues( ): if not useBins: branchCross.finished() else: branchCross[etBin][etaBin].finished() # Print efficiency for each one for the efficiency branches analysed: for etBin in range(nEtBins) if useBins else range(1): for etaBin in range(nEtaBins) if useBins else range(1): for branch in branchEffCollectors.itervalues(): lBranch = branch if not useBins else branch[etBin][ etaBin] self._info('%s', lBranch) if crossVal: for branchCross in branchCrossEffCollectors.itervalues( ): lBranchCross = branchCross if not useBins else branchCross[ etBin][etaBin] lBranchCross.dump(self._debug, printSort=True, sortFcn=self._verbose) # for branch # for eta # for et else: branchEffCollectors = None branchCrossEffCollectors = None # end of (getRates) outputs = [] outputs.extend((npObject, npBaseInfo)) if getRates: outputs.extend((branchEffCollectors, branchCrossEffCollectors)) return outputs
def __call__(self, **kw): """ Create a collection of tuning job configuration files at the output folder. """ # Cross validation configuration outputFolder = retrieve_kw( kw, 'outputFolder', 'jobConfig' ) neuronBounds = retrieve_kw( kw, 'neuronBounds', SeqLoopingBounds(5, 20) ) sortBounds = retrieve_kw( kw, 'sortBounds', PythonLoopingBounds(50) ) nInits = retrieve_kw( kw, 'nInits', 100 ) # Output configuration nNeuronsPerJob = retrieve_kw( kw, 'nNeuronsPerJob', 1 ) nSortsPerJob = retrieve_kw( kw, 'nSortsPerJob', 1 ) nInitsPerJob = retrieve_kw( kw, 'nInitsPerJob', 100 ) compress = retrieve_kw( kw, 'compress', True ) if 'level' in kw: self.level = kw.pop('level') # Make sure that bounds variables are LoopingBounds objects: if not isinstance( neuronBounds, SeqLoopingBounds ): neuronBounds = SeqLoopingBounds(neuronBounds) if not isinstance( sortBounds, SeqLoopingBounds ): sortBounds = PythonLoopingBounds(sortBounds) # and delete it to avoid mistakes: checkForUnusedVars( kw, self._logger.warning ) del kw if nInits < 1: self._logger.fatal(("Cannot require zero or negative initialization " "number."), ValueError) # Do some checking in the arguments: nNeurons = len(neuronBounds) nSorts = len(sortBounds) if not nSorts: self._logger.fatal("Sort bounds is empty.") if nNeuronsPerJob > nNeurons: self._logger.warning(("The number of neurons per job (%d) is " "greater then the total number of neurons (%d), changing it " "into the maximum possible value."), nNeuronsPerJob, nNeurons ) nNeuronsPerJob = nNeurons if nSortsPerJob > nSorts: self._logger.warning(("The number of sorts per job (%d) is " "greater then the total number of sorts (%d), changing it " "into the maximum possible value."), nSortsPerJob, nSorts ) nSortsPerJob = nSorts # Create the output folder: mkdir_p(outputFolder) # Create the windows in which each job will loop upon: neuronJobsWindowList = \ CreateTuningJobFiles._retrieveJobLoopingBoundsCol( neuronBounds, nNeuronsPerJob ) sortJobsWindowList = \ CreateTuningJobFiles._retrieveJobLoopingBoundsCol( sortBounds, nSortsPerJob ) initJobsWindowList = \ CreateTuningJobFiles._retrieveJobLoopingBoundsCol( \ PythonLoopingBounds( nInits ), \ nInitsPerJob ) # Loop over windows and create the job configuration for neuronWindowBounds in neuronJobsWindowList(): for sortWindowBounds in sortJobsWindowList(): for initWindowBounds in initJobsWindowList(): self._logger.debug(('Retrieved following job configuration ' '(bounds.vec) : ' '[ neuronBounds=%s, sortBounds=%s, initBounds=%s]'), neuronWindowBounds.formattedString('hn'), sortWindowBounds.formattedString('s'), initWindowBounds.formattedString('i')) fulloutput = '{outputFolder}/job.{neuronStr}.{sortStr}.{initStr}'.format( outputFolder = outputFolder, neuronStr = neuronWindowBounds.formattedString('hn'), sortStr = sortWindowBounds.formattedString('s'), initStr = initWindowBounds.formattedString('i') ) savedFile = TuningJobConfigArchieve( fulloutput, neuronBounds = neuronWindowBounds, sortBounds = sortWindowBounds, initBounds = initWindowBounds ).save( compress ) self._logger.info('Saved job option configuration at path: %s', savedFile )
def __call__(self, **kw): """ Create a collection of tuning job configuration files at the output folder. """ # Cross validation configuration outputFolder = retrieve_kw( kw, 'outputFolder', 'jobConfig' ) neuronBounds = retrieve_kw( kw, 'neuronBounds', SeqLoopingBounds(5, 20) ) sortBounds = retrieve_kw( kw, 'sortBounds', PythonLoopingBounds(50) ) nInits = retrieve_kw( kw, 'nInits', 100 ) # Output configuration nNeuronsPerJob = retrieve_kw( kw, 'nNeuronsPerJob', 1 ) nSortsPerJob = retrieve_kw( kw, 'nSortsPerJob', 1 ) nInitsPerJob = retrieve_kw( kw, 'nInitsPerJob', 100 ) compress = retrieve_kw( kw, 'compress', True ) prefix = retrieve_kw( kw, 'prefix' , 'job' ) if 'level' in kw: self.level = kw.pop('level') # Make sure that bounds variables are LoopingBounds objects: if not isinstance( neuronBounds, SeqLoopingBounds ): neuronBounds = SeqLoopingBounds(neuronBounds) if not isinstance( sortBounds, SeqLoopingBounds ): sortBounds = PythonLoopingBounds(sortBounds) # and delete it to avoid mistakes: checkForUnusedVars( kw, self._warning ) del kw if nInits < 1: self._fatal(("Cannot require zero or negative initialization " "number."), ValueError) # Do some checking in the arguments: nNeurons = len(neuronBounds) nSorts = len(sortBounds) if not nSorts: self._fatal("Sort bounds is empty.") if nNeuronsPerJob > nNeurons: self._warning(("The number of neurons per job (%d) is " "greater then the total number of neurons (%d), changing it " "into the maximum possible value."), nNeuronsPerJob, nNeurons ) nNeuronsPerJob = nNeurons if nSortsPerJob > nSorts: self._warning(("The number of sorts per job (%d) is " "greater then the total number of sorts (%d), changing it " "into the maximum possible value."), nSortsPerJob, nSorts ) nSortsPerJob = nSorts # Create the output folder: mkdir_p(outputFolder) # Create the windows in which each job will loop upon: neuronJobsWindowList = \ CreateTuningJobFiles._retrieveJobLoopingBoundsCol( neuronBounds, nNeuronsPerJob ) sortJobsWindowList = \ CreateTuningJobFiles._retrieveJobLoopingBoundsCol( sortBounds, nSortsPerJob ) initJobsWindowList = \ CreateTuningJobFiles._retrieveJobLoopingBoundsCol( \ PythonLoopingBounds( nInits ), \ nInitsPerJob ) # Loop over windows and create the job configuration for neuronWindowBounds in neuronJobsWindowList(): for sortWindowBounds in sortJobsWindowList(): for initWindowBounds in initJobsWindowList(): self._debug(('Retrieved following job configuration ' '(bounds.vec) : ' '[ neuronBounds=%s, sortBounds=%s, initBounds=%s]'), neuronWindowBounds.formattedString('hn'), sortWindowBounds.formattedString('s'), initWindowBounds.formattedString('i')) fulloutput = '{outputFolder}/{prefix}.{neuronStr}.{sortStr}.{initStr}'.format( outputFolder = outputFolder, prefix = prefix, neuronStr = neuronWindowBounds.formattedString('hn'), sortStr = sortWindowBounds.formattedString('s'), initStr = initWindowBounds.formattedString('i') ) savedFile = TuningJobConfigArchieve( fulloutput, neuronBounds = neuronWindowBounds, sortBounds = sortWindowBounds, initBounds = initWindowBounds ).save( compress ) self._info('Saved job option configuration at path: %s', savedFile )
def plot(self, **kw): from ROOT import kRed dirname = retrieve_kw(kw, 'dirname', 'Distribution') basecolor = retrieve_kw(kw, 'basecolor', kRed - 7) pdftitle = retrieve_kw(kw, 'pdftitle', 'Distributions') pdfoutput = retrieve_kw(kw, 'pdfoutput', 'distributions') import os # Organize outputs (.py and .pdf) prefix = self._basepath.split('/')[-1] localpath = os.getcwd() + '/' + dirname + '/' + prefix try: if not os.path.exists(localpath): os.makedirs(localpath) except: self._logger.warning('The director %s exist.', localpath) hist_names = [ 'et', 'eta', 'mu', 'nvtx', 'reta', 'eratio', 'weta2', 'rhad', 'rphi', 'f1', 'f3' ] hist_labels = [ 'E_{T}', "#eta", "<#mu>", 'N_{vtx}', 'R_{eta}', 'E_{ratio}', 'W_{eta2}', 'R_{had}', 'R_{phi}', 'f_{1}', 'f_{3}' ] from ROOT import TCanvas, TH1F, gStyle, TLegend, TPad from ROOT import kGreen, kRed, kBlue, kBlack, kGray, gPad, kAzure from TrigEgammaDevelopments.plots.AtlasStyle import AtlasStyle, atlas_template, setLegend1 canvas1 = TCanvas('canvas1', 'canvas1', 2500, 1600) canvas1.Divide(4, 3) # Concatenate distributions for all regions def sumAllRegions(histname): h = None for etBinIdx in range(len(self._etBins) - 1): for etaBinIdx in range(len(self._etaBins) - 1): binningname = ('et%d_eta%d') % (etBinIdx, etaBinIdx) path = self._basepath + '/' + self.currentDir( ) + '/' + binningname if h: h += self.storeSvc().histogram(path + '/' + histname) else: h = self.storeSvc().histogram(path + '/' + histname).Clone() return h collector = [] figures = { 'rings': [], 'rnnOutput': [], 'ringer_profile': str(), 'shower_shapes': str() } """ Plot all shower shapes distributins """ for idx, histname in enumerate(hist_names): self.setDir('Data') h_data = sumAllRegions(histname) self.setDir('MonteCarlo') h_mc = sumAllRegions(histname) #h_mc, h_data = self.__scale_histograms(h_mc, h_data, 100, 0.01, 0.01) pad = canvas1.cd(idx + 1) gStyle.SetOptStat(110011) collector.append(pad) h_mc.SetFillColor(basecolor) h_mc.SetLineColor(basecolor) h_data.SetLineColor(kBlack) h_mc.Scale(1. / h_mc.GetMaximum()) h_data.Scale(1. / h_data.GetMaximum()) h_mc.Draw() h_data.Draw('same') leg1 = TLegend(0.2, 0.75, 0.5, 0.95) setLegend1(leg1) leg1.AddEntry(h_mc, 'MC') leg1.AddEntry(h_data, 'Data') leg1.Draw() collector[-1].Update() collector.append(h_mc) collector.append(h_data) collector.append(leg1) canvas1.SaveAs(localpath + '/shower_shapes_distributions.pdf') figures[ 'shower_shapes'] = localpath + '/shower_shapes_distributions.pdf' """ Plot all shower ringer shapes for each ring """ ratio_size_as_fraction = 0.35 from RingerCore import progressbar rings_localpath = [] for r in progressbar(range(100), 100, step=1, logger=self._logger, prefix="Looping over rings (Plotting...) "): canvas2 = TCanvas('canvas2', 'canvas2', 2500, 1600) drawopt = 'pE1' canvas2.cd() top = TPad("pad_top", "This is the top pad", 0.0, ratio_size_as_fraction, 1.0, 1.0) top.SetBottomMargin(0.0) top.SetBottomMargin(0.06 / float(top.GetHNDC())) #top.SetTopMargin (0.04/float(top.GetHNDC())) top.SetRightMargin(0.05) top.SetLeftMargin(0.16) top.SetFillColor(0) top.Draw(drawopt) canvas2.cd() bot = TPad("pad_bot", "This is the bottom pad", 0.0, 0.0, 1.0, ratio_size_as_fraction) bot.SetBottomMargin(0.10 / float(bot.GetHNDC())) #bot.SetTopMargin (0.02/float(bot.GetHNDC())) bot.SetTopMargin(0.0) bot.SetRightMargin(0.05) bot.SetLeftMargin(0.16) bot.SetFillColor(0) bot.Draw(drawopt) self.setDir('MonteCarlo') h_mc = sumAllRegions('rings/ring_' + str(r)) self.setDir('Data') h_data = sumAllRegions('rings/ring_' + str(r)) gStyle.SetOptStat(000000) h_mc, h_data = self.__scale_histograms(h_mc, h_data, 100, 0.0001, 0.025) h_mc.Scale(1. / h_mc.GetMaximum()) h_data.Scale(1. / h_data.GetMaximum()) from ROOT import TH1, kGray divide = "" drawopt = 'pE1' bot.cd() ref = h_mc.Clone() h = h_data.Clone() ref.Sumw2() h.Sumw2() ratioplot = h.Clone() ratioplot.Sumw2() ratioplot.SetName(h.GetName() + '_ratio') ratioplot.Divide(h, ref, 1., 1., '') ratioplot.SetFillColor(0) ratioplot.SetFillStyle(0) ratioplot.SetMarkerColor(1) ratioplot.SetLineColor(kGray) ratioplot.SetMarkerStyle(24) ratioplot.SetMarkerSize(1.2) ratioplot.GetYaxis().SetTitleSize(0.10) ratioplot.GetXaxis().SetTitleSize(0.10) ratioplot.GetXaxis().SetLabelSize(0.10) ratioplot.GetYaxis().SetLabelSize(0.10) ratioplot.GetYaxis().SetRangeUser(-1.6, 3.7) ratioplot.GetYaxis().SetTitleOffset(0.7) ratioplot.GetYaxis().SetTitle('Data/MC') ratioplot.GetXaxis().SetTitle('Ring #' + str(r + 1) + ' [MeV]') ratioplot.Draw(drawopt) from ROOT import TLine nbins = h_data.GetNbinsX() xmin = h_data.GetXaxis().GetBinLowEdge(1) xmax = h_data.GetXaxis().GetBinLowEdge(nbins + 1) l1 = TLine(xmin, 1, xmax, 1) l1.SetLineColor(kRed) l1.SetLineStyle(2) l1.Draw() bot.Update() top.cd() h_mc.SetFillColor(basecolor) h_mc.SetLineWidth(1) h_mc.SetLineColor(basecolor) h_data.SetLineColor(kBlack) h_data.SetLineWidth(1) h_mc.GetYaxis().SetTitle('Count') h_mc.Draw() h_data.Draw('same') leg1 = TLegend(0.8, 0.70, 0.95, 0.95) setLegend1(leg1) leg1.AddEntry(h_mc, 'MC') leg1.AddEntry(h_data, 'Data') leg1.Draw() atlas_template(top) top.Update() canvas2.SaveAs(localpath + '/distribution_ring_' + str(r + 1) + '.pdf') figures['rings'].append(localpath + '/distribution_ring_' + str(r + 1) + '.pdf') """ Plot ringer mean shapes """ h_mean_data = TH1F('h_mean_data', '', 100, 0, 100) h_mean_mc = TH1F('h_mean_mc', '', 100, 0, 100) for bin in range(100): self.setDir('MonteCarlo') h_mc = sumAllRegions('rings/ring_' + str(bin)) self.setDir('Data') h_data = sumAllRegions('rings/ring_' + str(bin)) h_mean_data.SetBinContent(bin + 1, h_data.GetMean()) h_mean_mc.SetBinContent(bin + 1, h_mc.GetMean()) canvas3 = TCanvas('canvas3', 'canvas3', 2500, 1600) drawopt = 'pE1' canvas3.cd() top = TPad("pad_top", "This is the top pad", 0.0, ratio_size_as_fraction, 1.0, 1.0) top.SetBottomMargin(0.0) top.SetBottomMargin(0.06 / float(top.GetHNDC())) #top.SetTopMargin (0.04/float(top.GetHNDC())) top.SetRightMargin(0.05) top.SetLeftMargin(0.16) top.SetFillColor(0) top.Draw(drawopt) canvas3.cd() bot = TPad("pad_bot", "This is the bottom pad", 0.0, 0.0, 1.0, ratio_size_as_fraction) bot.SetBottomMargin(0.10 / float(bot.GetHNDC())) #bot.SetTopMargin (0.02/float(bot.GetHNDC())) bot.SetTopMargin(0.0) bot.SetRightMargin(0.05) bot.SetLeftMargin(0.16) bot.SetFillColor(0) bot.Draw(drawopt) gStyle.SetOptStat(000000) from ROOT import TH1, kGray divide = "" drawopt = 'pE1' bot.cd() ref = h_mean_mc.Clone() h = h_mean_data.Clone() ref.Sumw2() h.Sumw2() ratioplot = h.Clone() ratioplot.Sumw2() ratioplot.SetName(h.GetName() + '_ratio') ratioplot.Divide(h, ref, 1., 1., '') ratioplot.SetFillColor(0) ratioplot.SetFillStyle(0) ratioplot.SetMarkerColor(1) ratioplot.SetLineColor(kGray) ratioplot.SetMarkerStyle(24) ratioplot.SetMarkerSize(1.2) ratioplot.GetYaxis().SetTitleSize(0.10) ratioplot.GetXaxis().SetTitleSize(0.10) ratioplot.GetXaxis().SetLabelSize(0.10) ratioplot.GetYaxis().SetLabelSize(0.10) ratioplot.GetYaxis().SetRangeUser(-1.6, 3.7) ratioplot.GetYaxis().SetTitleOffset(0.7) ratioplot.GetYaxis().SetTitle('Data/MC') ratioplot.GetXaxis().SetTitle('Rings') ratioplot.Draw(drawopt) from ROOT import TLine nbins = h_mean_data.GetNbinsX() xmin = h_mean_data.GetXaxis().GetBinLowEdge(1) xmax = h_mean_data.GetXaxis().GetBinLowEdge(nbins + 1) l1 = TLine(xmin, 1, xmax, 1) l1.SetLineColor(kRed) l1.SetLineStyle(2) l1.Draw() bot.Update() top.cd() h_mean_mc.SetFillColor(basecolor) h_mean_mc.SetLineWidth(1) h_mean_mc.SetLineColor(basecolor) h_mean_data.SetLineColor(kBlack) h_mean_data.SetLineWidth(1) #h_mean_mc.Scale( 1./h_mean_mc.GetEntries() ) #h_mean_data.Scale( 1./h_mean_data.GetEntries() ) if h_mean_mc.GetMaximum() > h_mean_data.GetMaximum(): ymin = h_mean_mc.GetMinimum() ymax = h_mean_mc.GetMaximum() h_mean_mc.Draw() h_mean_mc.GetYaxis().SetTitle('E[Ring] MeV') h_mean_data.Draw('same') else: ymin = h_mean_data.GetMinimum() ymax = h_mean_data.GetMaximum() h_mean_data.GetYaxis().SetTitle('E[Ring] MeV') h_mean_data.Draw() h_mean_mc.Draw('same') h_mean_data.Draw('same') # prepare ringer lines def gen_line_90(x, ymin, ymax, text): from ROOT import TLine, TLatex ymax = 1.05 * ymax l = TLine(x, ymin, x, ymax) l.SetLineStyle(2) l.Draw() txt = TLatex() txt.SetTextFont(12) txt.SetTextAngle(90) txt.SetTextSize(0.04) txt.DrawLatex(x - 1, (ymax - ymin) / 2., text) return l, txt l_ps, t_ps = gen_line_90(8, ymin, ymax, 'presampler') l_em1, t_em1 = gen_line_90(72, ymin, ymax, 'EM.1') l_em2, t_em2 = gen_line_90(80, ymin, ymax, 'EM.2') l_em3, t_em3 = gen_line_90(88, ymin, ymax, 'EM.3') l_had1, t_had1 = gen_line_90(92, ymin, ymax, 'Had.1') l_had2, t_had2 = gen_line_90(96, ymin, ymax, 'Had.2') l_had3, t_had3 = gen_line_90(100, ymin, ymax, 'Had.3') leg1 = TLegend(0.8, 0.70, 0.95, 0.95) setLegend1(leg1) leg1.AddEntry(h_mean_mc, 'MC') leg1.AddEntry(h_mean_data, 'Data') leg1.Draw() atlas_template(top) top.Update() canvas3.SaveAs(localpath + '/ringer_profile.pdf') figures['ringer_profile'] = localpath + '/ringer_profile.pdf' """ Plot all NN distributions for each calo region """ for algname in self._discrList: for etBinIdx in range(len(self._etBins) - 1): for etaBinIdx in range(len(self._etaBins) - 1): binningname = ('et%d_eta%d') % (etBinIdx, etaBinIdx) path = self._basepath + '/MonteCarlo/' + binningname h_mc = self.storeSvc().histogram( path + '/' + algname + '/discriminantVsMu').ProjectionX().Clone() path = self._basepath + '/Data/' + binningname h_data = self.storeSvc().histogram( path + '/' + algname + '/discriminantVsMu').ProjectionX().Clone() h_mc.Rebin(10) h_data.Rebin(10) h_mc.Scale(1. / h_mc.GetMaximum()) h_data.Scale(1. / h_data.GetMaximum()) canvas4 = TCanvas('canvas4', 'canvas4', 2500, 1600) drawopt = 'pE1' canvas4.cd() top = TPad("pad_top", "This is the top pad", 0.0, ratio_size_as_fraction, 1.0, 1.0) top.SetBottomMargin(0.0) top.SetBottomMargin(0.06 / float(top.GetHNDC())) #top.SetTopMargin (0.04/float(top.GetHNDC())) top.SetRightMargin(0.05) top.SetLeftMargin(0.16) top.SetFillColor(0) top.Draw(drawopt) canvas4.cd() bot = TPad("pad_bot", "This is the bottom pad", 0.0, 0.0, 1.0, ratio_size_as_fraction) bot.SetBottomMargin(0.10 / float(bot.GetHNDC())) bot.SetTopMargin(0.0) bot.SetRightMargin(0.05) bot.SetLeftMargin(0.16) bot.SetFillColor(0) bot.Draw(drawopt) gStyle.SetOptStat(000000) from ROOT import TH1, kGray divide = "" drawopt = 'pE1' bot.cd() ref = h_mc.Clone() h = h_data.Clone() ref.Sumw2() h.Sumw2() ratioplot = h.Clone() ratioplot.Sumw2() ratioplot.SetName(h.GetName() + '_ratio') ratioplot.Divide(h, ref, 1., 1., '') ratioplot.SetFillColor(0) ratioplot.SetFillStyle(0) ratioplot.SetMarkerColor(1) ratioplot.SetLineColor(kGray) ratioplot.SetMarkerStyle(24) ratioplot.SetMarkerSize(1.2) ratioplot.GetYaxis().SetTitleSize(0.10) ratioplot.GetXaxis().SetTitleSize(0.10) ratioplot.GetXaxis().SetLabelSize(0.10) ratioplot.GetYaxis().SetLabelSize(0.10) ratioplot.GetYaxis().SetRangeUser(-1.6, 3.7) ratioplot.GetYaxis().SetTitleOffset(0.7) ratioplot.GetYaxis().SetTitle('Data/MC') ratioplot.GetXaxis().SetTitle( 'Neural Network (Discriminant)') ratioplot.Draw(drawopt) from ROOT import TLine nbins = h_data.GetNbinsX() xmin = h_data.GetXaxis().GetBinLowEdge(1) xmax = h_data.GetXaxis().GetBinLowEdge(nbins + 1) l1 = TLine(xmin, 1, xmax, 1) l1.SetLineColor(kRed) l1.SetLineStyle(2) l1.Draw() bot.Update() top.cd() h_mc.SetFillColor(basecolor) h_mc.SetLineWidth(1) h_mc.SetLineColor(basecolor) h_data.SetLineColor(kBlack) h_data.SetLineWidth(1) h_mc.Scale(1. / h_mc.GetMaximum()) h_data.Scale(1. / h_data.GetMaximum()) h_mc.GetYaxis().SetTitle( ('Counts (%s)') % (binningname.replace('_', ','))) h_mc.Draw() h_data.Draw('same') leg1 = TLegend(0.8, 0.70, 0.95, 0.95) setLegend1(leg1) leg1.AddEntry(h_mc, 'MC') leg1.AddEntry(h_data, 'Data') leg1.Draw() atlas_template(top) top.Update() canvas4.SaveAs(localpath + '/' + algname + '_rnnOutput_' + binningname + '.pdf') figures['rnnOutput'].append(localpath + '/' + algname + '_rnnOutput_' + binningname + '.pdf') #from RingerCore.tex.TexAPI import * from RingerCore.tex.BeamerAPI import BeamerTexReportTemplate1, BeamerSection, BeamerMultiFigureSlide, BeamerFigureSlide with BeamerTexReportTemplate1(theme='Berlin', _toPDF=True, title=pdftitle, outputFile=pdfoutput, font='structurebold'): with BeamerSection(name='Shower Shapes'): BeamerMultiFigureSlide( title='Shower Shapes (MC and Data)', paths=[figures['shower_shapes']], nDivWidth=1 # x , nDivHeight=1 # y , texts=None, fortran=False, usedHeight=0.8, usedWidth=1.1) with BeamerSection(name='Ringer Shapes Profile'): BeamerMultiFigureSlide( title='Ringer Profile (MC and Data)', paths=[figures['ringer_profile']], nDivWidth=1 # x , nDivHeight=1 # y , texts=None, fortran=False, usedHeight=0.8, usedWidth=1.1) with BeamerSection(name='Ringer Shapes'): for s in range(4): paths1 = [ path for path in figures['rings'][s * 25:s * 25 + 25] ] BeamerMultiFigureSlide( title='Ringer Shapes (MC and Data)', paths=paths1, nDivWidth=5 # x , nDivHeight=5 # y , texts=None, fortran=False, usedHeight=0.8, usedWidth=1.1) for algname in self._discrList: with BeamerSection(name=('%s Neural Network Output') % (algname.replace('_', '\_'))): paths2 = [] for etBinIdx in range(len(self._etBins) - 1): for etaBinIdx in range(len(self._etaBins) - 1): binningname = ('et%d_eta%d') % (etBinIdx, etaBinIdx) paths2.append(localpath + '/' + algname + '_rnnOutput_' + binningname + '.pdf') BeamerMultiFigureSlide( title=algname.replace('_', '\_'), paths=paths2, nDivWidth=len(self._etaBins) # x , nDivHeight=len(self._etBins) # y , texts=None, fortran=False, usedHeight=1.0, usedWidth=1.1) return StatusCode.SUCCESS
def __init__(self, **kw): Logger.__init__(self, kw) self.references = ReferenceBenchmarkCollection([]) coreframe = coreConf.core_framework() self.doPerf = retrieve_kw(kw, 'doPerf', True) self.batchMethod = BatchSizeMethod.retrieve( retrieve_kw( kw, 'batchMethod', BatchSizeMethod.MinClassSize \ if not 'batchSize' in kw or kw['batchSize'] is NotSet else BatchSizeMethod.Manual ) ) self.batchSize = retrieve_kw(kw, 'batchSize', NotSet) epochs = retrieve_kw(kw, 'epochs', 10000) maxFail = retrieve_kw(kw, 'maxFail', 50) self.useTstEfficiencyAsRef = retrieve_kw(kw, 'useTstEfficiencyAsRef', False) self._merged = retrieve_kw(kw, 'merged', False) self.networks = retrieve_kw(kw, 'networks', NotSet) self.sortIdx = None if coreConf() is TuningToolCores.FastNet: seed = retrieve_kw(kw, 'seed', None) self._core = coreframe(level=LoggingLevel.toC(self.level), seed=seed) self._core.trainFcn = retrieve_kw(kw, 'algorithmName', 'trainrp') self._core.showEvo = retrieve_kw(kw, 'showEvo', 50) self._core.multiStop = retrieve_kw(kw, 'doMultiStop', True) self._core.epochs = epochs self._core.maxFail = maxFail # TODO Add properties elif coreConf() is TuningToolCores.keras: self._core = coreframe from keras import callbacks from keras.optimizers import RMSprop, SGD from TuningTools.keras_util.callbacks import PerformanceHistory self.trainOptions = dict() self.trainOptions['optmin_alg'] = retrieve_kw( kw, 'optmin_alg', RMSprop(lr=0.001, rho=0.9, epsilon=1e-08)) #self.trainOptions['optmin_alg'] = retrieve_kw( kw, 'optmin_alg', SGD(lr=0.1, decay=1e-6, momentum=0.7) ) self.trainOptions['costFunction'] = retrieve_kw( kw, 'binary_crossentropy', 'mean_squared_error' ) # 'binary_crossentropy' #'mean_squared_error' # self.trainOptions['metrics'] = retrieve_kw(kw, 'metrics', [ 'accuracy', ]) self.trainOptions['shuffle'] = retrieve_kw(kw, 'shuffle', True) self._multiStop = retrieve_kw(kw, 'doMultiStop', True) self.trainOptions['nEpochs'] = epochs self.trainOptions['nFails'] = maxFail #self._earlyStopping = callbacks.EarlyStopping( monitor='val_Tuning_L2Calo_SP_sp_value' # val_loss, self.trainOptions['metrics'][0] FIXME This must change # , patience=self.trainOptions['nFails'] # , verbose=0 # , mode='max') self._earlyStopping = callbacks.EarlyStopping( monitor='val_loss' # val_acc , patience=self.trainOptions['nFails'], verbose=0, mode='auto') self._historyCallback = PerformanceHistory( display=retrieve_kw(kw, 'showEvo', 50)) else: self._fatal("TuningWrapper not implemented for %s", coreConf) checkForUnusedVars(kw, self._debug) del kw # Set default empty values: if coreConf() is TuningToolCores.keras: self._emptyData = npCurrent.fp_array([]) elif coreConf() is TuningToolCores.FastNet: self._emptyData = list() self._emptyHandler = None if coreConf() is TuningToolCores.keras: self._emptyTarget = npCurrent.fp_array([[]]).reshape( npCurrent.access(pidx=1, oidx=0)) elif coreConf() is TuningToolCores.FastNet: self._emptyTarget = None # Set holders: self._trnData = self._emptyData self._valData = self._emptyData self._tstData = self._emptyData self._trnHandler = self._emptyHandler self._valHandler = self._emptyHandler self._tstHandler = self._emptyHandler self._trnTarget = self._emptyTarget self._valTarget = self._emptyTarget self._tstTarget = self._emptyTarget
def __init__(self, **kw): Logger.__init__(self,**kw) from TuningTools.export import TrigMultiVarHypo_v2 # hold the export tool used to transform the dict data to some format self._exportModel = retrieve_kw( kw, 'model', TrigMultiVarHypo_v2() )
def __init__(self, **kw ): Logger.__init__( self, kw ) printArgs( kw, self._logger.debug ) self._nSorts = None self._nBoxes = None self._nTrain = None self._nValid = None self._nTest = None self._seed = None self._method = CrossValidMethod.retrieve( retrieve_kw( kw, 'method', CrossValidMethod.Standard ) ) if self._method is CrossValidMethod.Standard: self._nSorts = retrieve_kw( kw, 'nSorts', 50 ) self._nBoxes = retrieve_kw( kw, 'nBoxes', 10 ) self._nTrain = retrieve_kw( kw, 'nTrain', 6 ) self._nValid = retrieve_kw( kw, 'nValid', 4 ) self._nTest = retrieve_kw( kw, 'nTest', self._nBoxes - ( self._nTrain + self._nValid ) ) self._seed = retrieve_kw( kw, 'seed', None ) checkForUnusedVars( kw, self._logger.warning ) # Check if variables are ok: if (not self._nTest is None) and self._nTest < 0: self._logger.fatal("Number of test clusters is lesser than zero", ValueError) totalSum = self._nTrain + self._nValid + (self._nTest) if self._nTest else \ self._nTrain + self._nValid if totalSum != self._nBoxes: self._logger.fatal("Sum of train, validation and test boxes doesn't match.", ValueError) np.random.seed(self._seed) # Test number of possible combinations (N!/((N-K)!(K)!) is greater # than the required sorts. If number of sorts (greater than half of the # possible cases) is close to the number of combinations, generate all # possible combinations and then gather the number of needed sorts. # However, as calculating factorial can be heavy, we don't do this if the # number of boxes is large. self._sort_boxes_list = [] useRandomCreation = True from math import factorial if self._nBoxes < 201: totalPossibilities = ( factorial( self._nBoxes ) ) / \ ( factorial( self._nTrain ) * \ factorial( self._nValid ) * \ factorial( self._nTest ) ) if self._nSorts > (totalPossibilities / 2): useRandomCreation = False if useRandomCreation: count = 0 while True: random_boxes = np.random.permutation(self._nBoxes) random_boxes = tuple(chain(sorted(random_boxes[0:self._nTrain]), sorted(random_boxes[self._nTrain:self._nTrain+self._nValid]), sorted(random_boxes[self._nTrain+self._nValid:]))) # Make sure we are not appending same sort again: if not random_boxes in self._sort_boxes_list: self._sort_boxes_list.append( random_boxes ) count += 1 if count == self._nSorts: break else: self._sort_boxes_list = list( combinations_taken_by_multiple_groups(range(self._nBoxes), (self._nTrain, self._nVal, self._nTest))) for i in range(totalPossibilities - self._nSorts): self._sort_boxes_list.pop( np.random_integers(0, totalPossibilities) ) elif self._method is CrossValidMethod.JackKnife: self._nBoxes = retrieve_kw( kw, 'nBoxes', 10 ) checkForUnusedVars( kw, self._logger.warning ) self._nSorts = self._nBoxes self._nTrain = self._nBoxes - 1 self._nValid = 1 self._nTest = 0 self._sort_boxes_list = list( combinations_taken_by_multiple_groups(range(self._nBoxes), (9, 1,)) )
def __init__( self, **kw ): Logger.__init__( self, kw ) self.references = ReferenceBenchmarkCollection( [] ) self.doPerf = retrieve_kw( kw, 'doPerf', True ) self.batchMethod = BatchSizeMethod.retrieve( retrieve_kw( kw, 'batchMethod', BatchSizeMethod.MinClassSize \ if not 'batchSize' in kw or kw['batchSize'] is NotSet else BatchSizeMethod.Manual ) ) self.batchSize = retrieve_kw( kw, 'batchSize', NotSet ) epochs = retrieve_kw( kw, 'epochs', 10000 ) maxFail = retrieve_kw( kw, 'maxFail', 50 ) self.useTstEfficiencyAsRef = retrieve_kw( kw, 'useTstEfficiencyAsRef', False ) self._core, self._coreEnum = retrieve_core() self.sortIdx = None if self._coreEnum is TuningToolCores.ExMachina: self.trainOptions = dict() self.trainOptions['algorithmName'] = retrieve_kw( kw, 'algorithmName', 'rprop' ) self.trainOptions['print'] = retrieve_kw( kw, 'showEvo', True ) self.trainOptions['networkArch'] = retrieve_kw( kw, 'networkArch', 'feedforward' ) self.trainOptions['costFunction'] = retrieve_kw( kw, 'costFunction', 'sp' ) self.trainOptions['shuffle'] = retrieve_kw( kw, 'shuffle', True ) self.trainOptions['nEpochs'] = epochs self.trainOptions['nFails'] = maxFail self.doMultiStop = False elif self._coreEnum is TuningToolCores.FastNet: seed = retrieve_kw( kw, 'seed', None ) self._core = self._core( level = LoggingLevel.toC(self.level), seed = seed ) self._core.trainFcn = retrieve_kw( kw, 'algorithmName', 'trainrp' ) self._core.showEvo = retrieve_kw( kw, 'showEvo', 50 ) self._core.multiStop = retrieve_kw( kw, 'doMultiStop', True ) self._core.epochs = epochs self._core.maxFail = maxFail else: self._logger.fatal("TuningWrapper not implemented for %s" % TuningToolCores.tostring(self._coreEnum)) checkForUnusedVars(kw, self._logger.debug ) del kw # Set default empty values: if self._coreEnum is TuningToolCores.ExMachina: self._emptyData = npCurrent.fp_array([]) elif self._coreEnum is TuningToolCores.FastNet: self._emptyData = list() self._emptyHandler = None if self._coreEnum is TuningToolCores.ExMachina: self._emptyTarget = npCurrent.fp_array([[]]).reshape( npCurrent.access( pidx=1, oidx=0 ) ) elif self._coreEnum is TuningToolCores.FastNet: self._emptyTarget = None # Set holders: self._trnData = self._emptyData self._valData = self._emptyData self._tstData = self._emptyData self._trnHandler = self._emptyHandler self._valHandler = self._emptyHandler self._tstHandler = self._emptyHandler self._trnTarget = self._emptyTarget self._valTarget = self._emptyTarget self._tstTarget = self._emptyTarget