from heptools.collider import delphes @delphes.activate def photon(i, photons): if i > 1000: delphes.deactivate(photon) for p1, p2 in itertools.combinations(photons, 2): do_something() delphes.load_root_file(SOME_ROOT_FILE) ''' from ROOT import gSystem gSystem.Load('libDelphes') from ROOT import TChain, ExRootTreeReader import inspect DELPHES_BRANCH = 'Delphes' delphes_name = [ 'Event', 'Particle', 'Track', 'Tower', 'EFlowTrack', 'EFlowPhoton', 'EFlowNeutralHadron', 'GenJet', 'Jet', 'Electron', 'Photon', 'Muon', 'MissingET', 'ScalarHT' ] callback_functions = {}
gStyle.SetOptStat(000000) gStyle.SetOptTitle(0); gStyle.SetTitleFont(43) gStyle.SetTitleFont(43, "XYZ") gStyle.SetTitleSize(30, "XYZ") gStyle.SetLabelFont(43, "XYZ") gStyle.SetLabelSize(24, "XYZ") gStyle.SetPadTopMargin(0.07); gStyle.SetPadRightMargin(0.05); gStyle.SetPadBottomMargin(0.16); gStyle.SetPadLeftMargin(0.18); gSystem.Load("RooUnfold/libRooUnfold.so") from ROOT import RooUnfoldResponse from ROOT import RooUnfold from ROOT import RooUnfoldBayes from ROOT import RooUnfoldSvd # ------------------------------------------------------------------------------------- # cross sections, efficiencies, total number of events # ------------------------------------------------------------------------------------- lum = 12337.98 # was 12358.75 (pb-1), but missing some data if options.lepType == "ele": lum = 12267.67 # was 12295.65 (pb-1), but missing some data
pfreconstruct.detector = clic from heppy.analyzers.PDebugger import PDebugger pdebug = cfg.Analyzer( PDebugger, output_to_stdout=False, #optional debug_filename=None #No output ) # definition of a sequence of analyzers, # the analyzers will process each event in this order sequence = cfg.Sequence( source, pdebug, # gen_particles_stable, papas_sequence, sum_particles, sum_gen, zed_tree, display) # Specifics to read FCC events from ROOT import gSystem gSystem.Load("libdatamodelDict") from EventStore import EventStore as Events config = cfg.Config(components=selectedComponents, sequence=sequence, services=[], events_class=Events)
import sys if len(sys.argv) < 2: msg = '\n' msg += "Usage 1: %s $INPUT_ROOT_FILE\n" % sys.argv[0] msg += '\n' sys.stderr.write(msg) sys.exit(1) from ROOT import larlite as fmwk from ROOT import gSystem gSystem.Load('libKalekoAna_LArSoftImport') # Create ana_processor instance my_proc = fmwk.ana_processor() # Set input root file for x in xrange(len(sys.argv)): if x == 0: continue my_proc.add_input_file(sys.argv[x]) # Specify IO mode my_proc.set_io_mode(fmwk.storage_manager.kREAD) # Specify output root file name my_proc.set_ana_output_file("testmultiscatterpid_output.root"); # Attach a template process my_proc.add_process(fmwk.TestMultiScatterPID()); print
print "TTree entries: ", entries print "Compiling...." #Some system have problem runnig compilation (missing glibc-static library?). #First we try to compile, and only then we start time consuming cmssw assert gSystem.CompileMacro('HTTEvent.cxx', 'k') assert gSystem.CompileMacro('utils/TauTriggerSFs2017/src/TauTriggerSFs2017.cc', 'k') assert gSystem.CompileMacro('HTXSClassification.cc', 'k') assert gSystem.CompileMacro('EventWriter.C', 'k') #status *= gSystem.CompileMacro('NanoEventsSkeleton.C') #RECOMPILE IF IT CHANGES! assert gSystem.CompileMacro('NanoEventsSkeleton.C', 'k') gSystem.Load('$CMSSW_BASE/lib/$SCRAM_ARCH/libTauAnalysisClassicSVfit.so') gSystem.Load('$CMSSW_BASE/lib/$SCRAM_ARCH/libTauAnalysisSVfitTF.so') gSystem.Load( '$CMSSW_BASE/lib/$SCRAM_ARCH/libHTT-utilitiesRecoilCorrections.so') assert gSystem.CompileMacro('HTauTauTreeFromNanoBase.C', 'k') from ROOT import HTTParticle, HTTAnalysis if channel == 'mt': assert gSystem.CompileMacro('HMuTauhTreeFromNano.C', 'k') from ROOT import HMuTauhTreeFromNano as Ntuplizer if channel == 'et': assert gSystem.CompileMacro('HElTauhTreeFromNano.C', 'k') from ROOT import HElTauhTreeFromNano as Ntuplizer
import os import sys import math as m import numpy as n import ROOT as r import os.path import os from scipy.signal import argrelextrema, savgol_filter, find_peaks_cwt, argrelmax from ROOT import gSystem result = gSystem.Load("libDDCorePlugins") from ROOT import dd4hep if result < 0: print "No lib loadable!" system_decoder = dd4hep.DDSegmentation.BitFieldCoder("system:4") ecalBarrel_decoder = dd4hep.DDSegmentation.BitFieldCoder( "system:4,cryo:1,type:3,subtype:3,layer:8,eta:11,phi:10") hcalBarrel_decoder = dd4hep.DDSegmentation.BitFieldCoder( "system:4,module:8,row:9,layer:5") hcalExtBarrel_decoder = dd4hep.DDSegmentation.BitFieldCoder( "system:4,module:8,row:9,layer:5") ecalEndcap_decoder = dd4hep.DDSegmentation.BitFieldCoder( "system:4,subsystem:1,type:3,subtype:3,layer:8,eta:10,phi:10") hcalEndcap_decoder = dd4hep.DDSegmentation.BitFieldCoder( "system:4,subsystem:1,type:3,subtype:3,layer:8,eta:10,phi:10") ecalFwd_decoder = dd4hep.DDSegmentation.BitFieldCoder( "system:4,subsystem:1,type:3,subtype:3,layer:8,eta:11,phi:10") hcalFwd_decoder = dd4hep.DDSegmentation.BitFieldCoder( "system:4,subsystem:1,type:3,subtype:3,layer:8,eta:11,phi:10") trackerBarrel_decoder = dd4hep.DDSegmentation.BitFieldCoder(
def loadModule( name ): stat = gSystem.Load( name ) if stat < 0: __log.error( 'could not load [' + name + ']' ) raise RuntimeError
from ROOT import gSystem import os, logging, platform if platform.system() == "Darwin": gSystem.SetDynamicPath(os.environ['DD4HEP_LIBRARY_PATH']) gSystem.Load('libDDPython') from ROOT import dd4hep as Core logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG) name_space = __import__(__name__) def import_namespace_item(ns, nam): scope = getattr(name_space, ns) attr = getattr(scope, nam) setattr(name_space, nam, attr) return attr def a_func(): logging.info('Hello world') return 1 class a_class: def __init__(self): pass def fcn(self): logging.info('Hello world from member function fcn')
''' Created on 31 Oct 2012 @author: kreczko ''' from ROOT import gSystem, cout, TDecompSVD import config.RooUnfold as unfoldCfg from tools.hist_utilities import hist_to_value_error_tuplelist, fix_overflow gSystem.Load( unfoldCfg.library ) from ROOT import RooUnfoldResponse, RooUnfoldParms, RooUnfold, RooUnfoldBayes, RooUnfoldSvd from ROOT import RooUnfoldBinByBin, RooUnfoldInvert, RooUnfoldTUnfold from ROOT import TSVDUnfold from ROOT import TH2D, TH1D from rootpy import asrootpy from rootpy.plotting import Hist, Hist2D from math import sqrt class Unfolding: def __init__( self, truth, measured, response, fakes = None, method = 'RooUnfoldSvd', tau = unfoldCfg.SVD_tau_value, k_value = unfoldCfg.SVD_k_value, n_toy = unfoldCfg.SVD_n_toy, Bayes_n_repeat = unfoldCfg.Bayes_n_repeat, error_treatment = unfoldCfg.error_treatment, measured_truth_without_fakes = None,
import math import re import ROOT from ROOT import gSystem from PhysicsTools.Heppy.analyzers.core.Analyzer import Analyzer from PhysicsTools.Heppy.analyzers.core.AutoHandle import AutoHandle from PhysicsTools.Heppy.physicsobjects.Jet import Jet from PhysicsTools.HeppyCore.utils.deltar import cleanObjectCollection gSystem.Load("libCMGToolsH2TauTau") from ROOT import HTTRecoilCorrector as RC LorentzVector = ROOT.Math.LorentzVector(ROOT.Math.PxPyPzE4D("double")) def get_final_ptcs(ptc): if ptc.numberOfDaughters() == 0: return [ptc] else: final_ptcs = [] for i_daughter in range(ptc.numberOfDaughters()): l = get_final_ptcs(ptc.daughter(i_daughter)) final_ptcs += l return final_ptcs
import sys from ROOT import gSystem gSystem.Load("libKazuAna_Boke") from ROOT import sample try: print "PyROOT recognized your class %s" % str(sample) except NameError: print "Failed importing Boke..." sys.exit(0)
# # Example PyROOT script to run analysis module, ana_base. # The usage is same for inherited analysis class instance. # # Load libraries import os, ROOT, sys from ROOT import gSystem gSystem.Load("libAnalysis") gSystem.Load("libLArUtil") gSystem.Load("libDavidAna") # Now import ana_processor & your class. For this example, ana_base. from ROOT import larlight as fmwk infilename = sys.argv[1] outfilename = "hits.root" # Create ana_processor instance my_proc = fmwk.ana_processor() # Specify IO mode my_proc.set_io_mode(fmwk.storage_manager.BOTH) #my_proc.set_io_mode(storage_manager.WRITE) #my_proc.set_io_mode(fmwk.storage_manager.BOTH) # Specify what data to read my_proc.set_data_to_read(fmwk.DATA.TPCFIFO) #my_proc.set_data_to_read(fmwk.DATA.FFTHit) #my_proc.set_data_to_read(fmwk.DATA.MCTruth)
* Script : SysTable.py * * Created : November 2012 * * * * Description: * * Script for producing publication-quality systematics breakdown tables * * * * Authors: * * HistFitter group * * * * Redistribution and use in source and binary forms, with or without * * modification, are permitted according to the terms listed in the file * * LICENSE. * """ from ROOT import gROOT, gSystem, gDirectory gSystem.Load("libSusyFitter.so") from ROOT import ConfigMgr, FitConfig #this module comes from gSystem.Load("libSusyFitter.so") gROOT.Reset() from ROOT import TFile, RooWorkspace, TObject, TString, RooAbsReal, RooRealVar, RooFitResult, RooDataSet, RooAddition, RooArgSet, RooAbsData, RooRandom, RooArgList from ROOT import Util, TMath from ROOT import RooFit from ROOT import RooExpandedFitResult from cmdLineUtils import getPdfInRegions, getName import os import sys from sys import exit from SysTableTex import *
''' Look at STK cluster width and see if there is value to them ''' from __future__ import division import numpy as np import math import os import pickle from ROOT import gSystem gSystem.Load("libDmpEvent.so") import ROOT import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt from getXTRL import calcRMS, CalcPosition, computeCOG, getEdep, cuts def run(fname, pfile): with open(fname, 'r') as f: allF = [] for line in f: allF.append(line.replace('\n', '')) chain = ROOT.DmpChain("CollectionTree")
import sys from ROOT import gSystem from TextFile import ReadTextFile from Directory import Directory from ROOTFile import ROOTFile P0DBANFF = os.getenv('P0DBANFFROOT') RUNLISTS = P0DBANFF + '/run_lists' RDP6M = 'rdp6_Spin_M' MCP6B = 'mcp6_Spin_B/neut' MCP6BANTI = 'mcp6_Spin_B/anti-neut' MCP6LANTI = 'mcp6_Spin_L/anti-neut' # this library helps ROOT not complain about missing dictionaries gSystem.Load('%s/liboaAnalysisReader.so' % ( os.path.join(P0DBANFF, 'T2KReWeight/libReadoaAnalysis'))) def check_oaanalysis_files(file_list, file_list_name): """loop over run list file and check contents""" if not isinstance(file_list, list): file_list = ReadTextFile(file_list).get_file_as_list() for analysis_file in file_list: test_file = ROOTFile(analysis_file) if not (test_file.contains(RDP6M) or test_file.contains(MCP6B) or test_file.contains(MCP6BANTI) or test_file.contains(MCP6LANTI)): print 'ROOT file \"%s\" does not contain right \ file path in %s' % (analysis_file, file_list_name) elif test_file.checkfile() is not ROOTFile.IS_GOOD: print 'ROOT file \"%s\" is BAD in %s' % \ (analysis_file, file_list_name)
def load_lib(libpath): PInfo('PandaCore.Tools.Load', 'Loading %s' % libpath) gSystem.Load(libpath)
'''Shows how to load a C++ class without dictionary in root 6.''' from ROOT import gSystem, gROOT import os os.chdir('build/') gROOT.ProcessLine('#include "hello.h"') gSystem.Load('libhello') from ROOT import Hello hello = Hello() hello.Print()
import sys if len(sys.argv) < 2: msg = '\n' msg += "Usage 1: %s $INPUT_ROOT_FILE\n" % sys.argv[0] msg += '\n' sys.stderr.write(msg) sys.exit(1) from ROOT import gSystem gSystem.Load("libSNCompression") from ROOT import larlight as fmwk # Create ana_processor instance my_proc = fmwk.ana_processor() # Set input root file my_proc.add_input_file(sys.argv[1]) # Specify IO mode my_proc.set_io_mode(fmwk.storage_manager.READ) # Specify input TDirectory name if given if len(sys.argv) > 2: my_proc.set_input_rootdir(sys.argv[2]) # Specify output root file name my_proc.set_ana_output_file("from_test_ana_you_can_remove_me.root") # Attach a template process
import ROOT, math, sys import numpy as np import pandas, root_numpy from copy import deepcopy as dc from ROOT import gSystem gSystem.Load('libRooFit') from ROOT import RooFit, RooRealVar, RooDataSet, RooArgList, RooTreeData, RooArgSet, RooAddPdf, RooFormulaVar, RooExtendPdf from ROOT import RooGaussian, RooExponential, RooChebychev ROOT.gROOT.SetBatch(True) # ROOT.gErrorIgnoreLevel = ROOT.kFatal # ROOT.RooMsgService.instance().setSilentMode(True) B0Mass_ = 5.27958 JPsiMass_ = 3.096916 PsiPMass_ = 3.686109 KStMass_ = 0.896 B0Mass = RooRealVar("B0Mass", "B0Mass", B0Mass_) JPsiMass = RooRealVar("JPsiMass", "JPsiMass", JPsiMass_) PsiPMass = RooRealVar("PsiPMass", "PsiPMass", PsiPMass_) KStMass = RooRealVar("KStMass", "KStMass", KStMass_) nSigma_psiRej = 3. outfile = ROOT.TFile('outcome_wp_finding_massFlatten_onlyRT_NoB0PsiCut.root', 'recreate') n_bdt_points = 15 sample_range = 11
from Centella.AAlgo import AAlgo from Centella.physical_constants import * from Centella.system_of_units import * from Util import * from Nh5 import * import numpy as np import tables from time import time from ROOT import gSystem gSystem.Load("$GATE_DIR/lib/libGATE") from ROOT import gate from math import sqrt class MCWF(AAlgo): def __init__(self, param=False, level=1, label="", **kargs): """ """ self.name = 'MCWaveform' AAlgo.__init__(self, param, level, self.name, 0, label, kargs) def initialize(self): """ tables.EArray(parentnode, name, atom=None, shape=None, title='', filters=None, expectedrows=None,
## LOGGER import logging import logging.config logger = logging.getLogger(__name__) logging.basicConfig(format="%(asctime)-15s %(levelname)s - %(message)s",datefmt='%Y-%m-%d %H:%M:%S') logger= logging.getLogger(__name__) logger.setLevel(logging.INFO) ## ROOT + CAESAR try: ## ROOT import ROOT from ROOT import gSystem, gROOT, AddressOf ## CAESAR gSystem.Load('libCaesar.so') from ROOT import Caesar from ROOT.Caesar import Image except: logger.error("Cannot load ROOT & Caesar modules!") exit(1) def make_caesar_source(source_data,source_name,source_id,source_type,offsetx=0,offsety=0,beamArea=0): """ Create Caesar source from source data array """ # - Create Caesar source source= Caesar.Source() # - Get source indexes and fill pixels in Caesar source
import os import ROOT from CMGTools.RootTools.RootTools import * from ROOT import gSystem gSystem.Load('CMGToolsHToZZTo4Leptons') from ROOT import KD # you can even create a python class for high level stuff, like this: class KDCalculator(object): '''This class Calculates the KDs .''' def __init__(self): self.KD = KD() def calculate(self, FL): if FL.M() < 0: FL.KD = -99. FL.pseudoKD = -99. FL.graviKD = -99. return l1 = ROOT.TLorentzVector(FL.leg1.leg1.px(), FL.leg1.leg1.py(), FL.leg1.leg1.pz(), FL.leg1.leg1.energy()) l2 = ROOT.TLorentzVector(FL.leg1.leg2.px(), FL.leg1.leg2.py(), FL.leg1.leg2.pz(), FL.leg1.leg2.energy()) l3 = ROOT.TLorentzVector(FL.leg2.leg1.px(), FL.leg2.leg1.py(), FL.leg2.leg1.pz(), FL.leg2.leg1.energy())
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration import os import sys, string, commands from datetime import datetime ## Needed to correct ROOT behavior; see below CWD = os.getcwd() import ROOT ## Importing gSystem may change the current directory to one of the ## command-line arguments; chdir to original directory to have ## predictable behavior from ROOT import gSystem os.chdir(CWD) ## Import the ROOT library for reading han results gSystem.Load('libGoodRunsListsLib') from ROOT import Root ## read the goodrunslist xml file(s) reader = Root.TGoodRunsListReader() reader.SetXMLFile('Cosmics_DQgood_runlist.xml') reader.Interpret() grl = reader.GetMergedGoodRunsList() ## show summary of content grl.Summary() ## Detailed: Summary(True) ### read grl cosmics all #reader.SetXMLFile('Cosmics_ProcessedLBsNoDQSelection.xml') #reader.Interpret() #grl_all = reader.GetMergedGoodRunsList()
# For the licensing terms see $DD4hepINSTALL/LICENSE. # For the list of contributors see $DD4hepINSTALL/doc/CREDITS. # # ========================================================================== # from __future__ import absolute_import, unicode_literals import traceback import sys from ROOT import gSystem import os import logging import platform if platform.system() == "Darwin": gSystem.SetDynamicPath(os.environ['DD4HEP_LIBRARY_PATH']) gSystem.Load('libglapi') gSystem.Load('libDDPython') from ROOT import dd4hep as Core # noqa logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.INFO) logger = logging.getLogger(__name__) name_space = __import__(__name__) def import_namespace_item(ns, nam): scope = getattr(name_space, ns) attr = getattr(scope, nam) setattr(name_space, nam, attr) return attr
import sys from ROOT import gSystem gSystem.Load("libCommissioning_MakeWFTTree") from ROOT import sample try: print "PyROOT recognized your class %s" % str(sample) except NameError: print "Failed importing MakeWFTTree..." sys.exit(0)
import sys if len(sys.argv) < 2: msg = '\n' msg += "Usage 1: %s $INPUT_ROOT_FILE\n" % sys.argv[0] msg += '\n' sys.stderr.write(msg) sys.exit(1) from ROOT import gSystem gSystem.Load("libKalekoAna") from ROOT import larlight as fmwk from ROOT import kaleko # Create ana_processor instance my_proc = fmwk.ana_processor() my_proc.set_verbosity(fmwk.MSG.NORMAL) # Set input root file my_proc.add_input_file(sys.argv[1]) # Have it find the scanner directory #fmwk.storage_manager.get().set_in_rootdir("scanner") fmwk.storage_manager.get().set_data_to_read(fmwk.DATA.MCTruth,False) fmwk.storage_manager.get().set_data_to_read(fmwk.DATA.Calorimetry,False) fmwk.storage_manager.get().set_data_to_read(fmwk.DATA.Shower,False) #fmwk.storage_manager.get().set_data_to_read(fmwk.DATA.ShowerAngleCluster,False) # Specify IO mode my_proc.set_io_mode(fmwk.storage_manager.READ)
#if (ievt % 1000) == 0: # print "Processing event: %i" % ievt self.process(evt) yield evt return def process(self, event): self.getHandles(event) return def getHandles(self, event): for k, v in self.handles.iteritems(): label = self.handle_labels[k] event.getByLabel(label, v) return # ______________________________________________________________________________ if __name__ == "__main__": print "Loading FW Lite" gSystem.Load("libFWCoreFWLite") gROOT.ProcessLine("FWLiteEnabler::enable();") #gSystem.Load("libDataFormatsFWLite.so") #gSystem.Load("libDataFormatsPatCandidates.so") #gSystem.Load("libDataFormatsL1TMuon.so") analyzer = FWLiteAnalyzer(inputFiles='pippo.root') analyzer.analyze()
import sys if len(sys.argv) < 2: msg = '\n' msg += "Usage 1: %s $INPUT_ROOT_FILE\n" % sys.argv[0] msg += '\n' sys.stderr.write(msg) sys.exit(1) from ROOT import gSystem gSystem.Load("libArianaPi0Test") from ROOT import larlight as fmwk # Create ana_processor instance my_proc = fmwk.ana_processor() #my_proc.add_input_file(sys.argv[1]) # Set input root file for x in xrange(len(sys.argv)-1): my_proc.add_input_file(sys.argv[x+1]) #my_proc.add_input_file("~/WorkArea/data/NewFiles/LArLight/pdg_111/combined_cluster_00.root") # Specify IO mode my_proc.set_io_mode(fmwk.storage_manager.READ) my_proc.set_rootdir("scanner") # Specify output root file name my_proc.set_ana_output_file("ana.root");
#!/usr/bin/python import os import sys, string, commands from datetime import datetime ## Needed to correct ROOT behavior; see below CWD = os.getcwd() import ROOT ## Importing gSystem may change the current directory to one of the ## command-line arguments; chdir to original directory to have ## predictable behavior from ROOT import gSystem os.chdir(CWD) ## Import the ROOT library for reading han results gSystem.Load('../StandAlone/libGoodRunsLists.so') from ROOT import Root ## read the goodrunslist xml file(s) reader = Root.TGoodRunsListReader('LumiRangeCollectionA.xml') #reader.AddXMLFile('LumiRangeCollectionB.xml') reader.Interpret() goodrunslist = reader.GetMergedGRLCollection() ## show summary of content goodrunslist.Summary() ## Detailed: Summary(True) ## constains run and/or lumiblock ? if goodrunslist.HasRun(90210): print "Foo!" # contains run 90210 ? if goodrunslist.HasRunLumiBlock(90210, 7): print "Bar!" # run 90210, lb 7 ?
from ROOT import gSystem gSystem.Load("libanalysiscpp-myanalysis") from ROOT import MyAnalysis, TCanvas, gPad ma = MyAnalysis() ma.loop("example.root") c1 = TCanvas() c1.Divide(2,1) c1.cd(1) ma.m_hjetenergy.Draw() c1.cd(2) ma.m_hjetnparts.Draw() gPad.Update()