def __init__(self):
"""Initialize whatever is needed"""
self.my_logger = Logger()
#self.log = Logger().getLogger(self.__class__.__name__, 10)
self.log = self.my_logger.getLogger(self.__class__.__name__, 10)
#}
self.DEBUG = self.my_logger.is_debug()
self.pp = pprint.PrettyPrinter(indent=4)
#initialize RooFit
gSystem.Load("libHiggsAnalysisCombinedLimit.so")
self.output_filename = 'worskapce_with_embedded_toys.root'
def __init__(self,name = "plotters_base_functionality" ):
self.log = Logger().getLogger(self.__class__.__name__, 10)
self.name = name
#ROOT.gSystem.AddIncludePath("-I$ROOFITSYS/include/");
#ROOT.gROOT.ProcessLine(".L tdrstyle.cc")
#from ROOT import setTDRStyle
#ROOT.setTDRStyle(True)
#ROOT.gStyle.SetPalette(1)
#ROOT.gStyle.SetOptStat(0)
self.copy_to_web_dir = False
self.webdir = ""
self.save_extensions = ['png','pdf','eps']
def __init__(self, datacard_name, datacard_input):
self.my_logger = Logger()
self.log = self.my_logger.getLogger(self.__class__.__name__, 10)
self.DEBUG = self.my_logger.is_debug()
self.pp = pprint.PrettyPrinter(indent=4)
#
self.datacard_name = datacard_name
self.d_input = datacard_input
self.log.debug('Datacard: {0} Datacard input: {1}'.format(self.datacard_name, self.d_input))
#self.not_a_process = ['observation','functions_and_definitions', 'setup']
self.not_a_process = self.d_input['setup']['reserved_sections']
self.lumi_scaling = 1.0
#process lists
self.signal_process_list = self._get_processes('signal')
self.bkg_process_list = self._get_processes('background')
self.process_list = self.signal_process_list+self.bkg_process_list
self.log.debug('Processes: {0}'.format(self.process_list))
#self.n_systematics, self.systematics_lines = self._get_systematics_lines()
self.card_header='' #set of information lines os a header of the card.
def __init__(self, run_data_name, run_dict):
"""Set the values from configuration"""
self.log = Logger().getLogger(self.__class__.__name__, 10)
self.run_dict = run_dict
self.create_cards_dir="/afs/cern.ch/work/r/roko/Stat/CMSSW_611_JCP/src/HZZ4L_Combination/CombinationPy/CreateDatacards/"
self.version= "v1"
self.sqrts_dc="8TeV"
self.sqrts_plot="14"
self.fs="2e2mu"
self.lumi="19.79"
self.lumi_zfill="19.79"
self.discriminant="D_{0-}(90^{o})"
self.MY_CUR_WWW_SUBDIR=""
self.append_name_base = run_data_name
self.MY_CUR_WWW_SUBDIR = self.append_name_base
self.POIs = list(self.run_dict['POI'])
self.poi = self.run_dict['POI_setup']
self.termNames = self.run_dict['termNames']
self.templatedir = self.run_dict['templatedir']
self.discriminant = self.run_dict['discriminant_name']
self.additional_options = self.run_dict['additional_options']
self.fs = self.run_dict['final_state']
self.www_dir = "/afs/cern.ch/user/r/roko/www/html/Geoloc/{0}".format(self.MY_CUR_WWW_SUBDIR)
self.do_copy_to_webdir = True
print "Setting web directory to: {0}".format(self.www_dir)
self.do_cmd = ""
#self.poi= {"k2k1_ratio":{"switch":0, "range":"-100,100", "name":"k2k1", "nice_name":"k_{2}/k_{1}", "value":"0"},
#"k3k1_ratio":{"switch":0, "range":"-100,100", "name":"k3k1", "nice_name":"k_{3}/k_{1}", "value":"0"}}
self.setup_POI_related_stuff()
def __init__(self):
"""Initialize whatever is needed"""
self.my_logger = Logger()
#self.log = Logger().getLogger(self.__class__.__name__, 10)
self.log = self.my_logger.getLogger(self.__class__.__name__, 10)
#}
self.DEBUG = self.my_logger.is_debug()
self.pp = pprint.PrettyPrinter(indent=4)
#initialize RooFit
gSystem.Load("libHiggsAnalysisCombinedLimit.so")
self.output_filename = 'worskapce_with_embedded_toys.root'
def __init__(self,name = "templates" ):
self.log = Logger().getLogger(self.__class__.__name__, 10)
self.name = name
#ROOT.gSystem.AddIncludePath("-I$ROOFITSYS/include/");
ROOT.gROOT.ProcessLine(".L tdrstyle.cc")
from ROOT import setTDRStyle
ROOT.setTDRStyle(True)
ROOT.gStyle.SetPalette(1)
ROOT.gStyle.SetOptStat(0)
self.copy_to_web_dir = False
self.webdir = ""
self.pp = pprint.PrettyPrinter(indent=4)
self.k2k1_ratio=0
self.k3k1_ratio=0
self.total_pdf=0
class DatacardBuilder(object):
"""
Class for building datacards, both textual and workspace part
EXAMPLE_____________________________________________________________
#*** HEADER ***
imax 1 number of bins
jmax 5 number of processes minus 1
kmax 14 number of nuisance parameters
----------------------------------------------------------------------------------------------------------------------------------
shapes * ch1 hzz4l_2e2muS_8TeV_xs_SM_125_mass4l_v3.Databin0.root w:$PROCESS
----------------------------------------------------------------------------------------------------------------------------------
bin ch1
observation 8.0
#***PER-PROCESS INFORMATION ***
----------------------------------------------------------------------------------------------------------------------------------
bin ch1 ch1 ch1 ch1 ch1 ch1
process trueH2e2muBin0_8 bkg_zjets_8 bkg_ggzz_8 bkg_qqzz_8 out_trueH_8 fakeH_8
process 0 1 2 3 4 5
rate 1.0000 1.0526 0.3174 5.7443 1.0000 0.5684
----------------------------------------------------------------------------------------------------------------------------------
CMS_eff_e lnN 1.046 - 1.046 1.046 1.046 1.046
EXAMPLE_____________________________________________________________
"""
def __init__(self, datacard_name, datacard_input):
self.my_logger = Logger()
self.log = self.my_logger.getLogger(self.__class__.__name__, 10)
self.DEBUG = self.my_logger.is_debug()
self.pp = pprint.PrettyPrinter(indent=4)
#
self.datacard_name = datacard_name
self.d_input = datacard_input
self.log.debug('Datacard: {0} Datacard input: {1}'.format(self.datacard_name, self.d_input))
#self.not_a_process = ['observation','functions_and_definitions', 'setup']
self.not_a_process = self.d_input['setup']['reserved_sections']
self.lumi_scaling = 1.0
#process lists
self.signal_process_list = self._get_processes('signal')
self.bkg_process_list = self._get_processes('background')
self.process_list = self.signal_process_list+self.bkg_process_list
self.log.debug('Processes: {0}'.format(self.process_list))
#self.n_systematics, self.systematics_lines = self._get_systematics_lines()
self.card_header='' #set of information lines os a header of the card.
def make_txt_card(self):
"""Make text part of the datacard and dump to a file.
- loop on processes and fill in txt card lines
"""
self.process_lines = self._get_process_lines()
self.n_systematics, self.systematics_lines = self._get_systematics_lines()
txt_card = """
Datacard for event category: {cat}
{card_header}
---------------------------------------
imax 1 number of bins
jmax {jmax} number of processes minus 1
kmax {kmax} number of nuisance parameters
---------------------------------------
{shapes_line}
---------------------------------------
bin cat_{cat}
observation {n_observed}
---------------------------------------
bin {process_cat}
process {process_name}
process {process_number}
rate {process_rate}
---------------------------------------
""".format(cat = self.datacard_name,
jmax = (len(self.process_list)-1),
kmax = self.n_systematics,
shapes_line = self._get_shapes_line(),
n_observed = self._get_observation(),
process_cat = self.process_lines['bin'],
process_name = self.process_lines['name'],
process_number = self.process_lines['number'],
process_rate = self.process_lines['rate'],
#process_systematics = self.systematics_lines,
card_header = self.card_header
)
txt_card = textwrap.dedent(txt_card)
txt_card+= textwrap.dedent(self.systematics_lines)
print txt_card
file_datacard_name = self.datacard_name+'.txt'
if self.lumi_scaling != 1.0:
file_datacard_name = file_datacard_name.replace('.txt', '.lumi_scale_{0:3.2f}.txt'.format(self.lumi_scaling))
with open(file_datacard_name, 'w') as file_datacard:
file_datacard.write(textwrap.dedent(txt_card))
file_datacard.write(textwrap.dedent(self.systematics_lines))
self.log.info('Datacard saved: {0}'.format(file_datacard_name))
def _get_shapes_line(self):
"""
Gets the line with shape
shapes * {cat} {cat}.root w:$PROCESS
"""
self.shapes_exist = False
for p in self.process_list:
self.log.debug('Checking for shape in {0}/{1}'.format(self.datacard_name, p))
try:
self.d_input[p]['shape']
except KeyError:
pass
else:
if self.d_input[p]['shape']:
self.shapes_exist = True
self.shapes_output_file = "{0}.input.root".format(self.datacard_name)
if self.lumi_scaling != 1.0:
self.shapes_output_file = self.shapes_output_file.replace('input','lumi_scale_{0:3.2f}.input'.format(self.lumi_scaling))
break
if self.shapes_exist:
return "shapes * cat_{cat} {shapes_output_file} w:$PROCESS".format(cat = self.datacard_name, shapes_output_file = self.shapes_output_file)
else:
return "#shapes are not used - counting experiment card"
def _get_processes(self, process_type='signal,background'):
"""Read the input dictionary and count processes.
"""
sig_process_list = []
bkg_process_list = []
process_list=[]
for p in self.d_input.keys():
if p not in self.not_a_process:
if self.d_input[p]['is_signal']:
sig_process_list.append(p)
else:
bkg_process_list.append(p)
if 'signal' in process_type.lower():
process_list+=sorted(sig_process_list)
if 'background' in process_type.lower():
process_list+=sorted(bkg_process_list)
return process_list
def _get_process_lines(self):
"""
Gets and formats lines coresponding to processes from the self.process_list
"""
process_lines = {'bin': '', 'name':'', 'number':'', 'rate':'','sys':''}
#get enumerates from signal and background processes
#signal_process_list = []
#bkg_process_list = []
#for p in self.process_list:
#if self.d_input[p]['is_signal']:
#signal_process_list.append(p)
#else:
#bkg_process_list.append(p)
#self.signal_process_list = sorted(signal_process_list)
#self.bkg_process_list = sorted(bkg_process_list)
signal_process_dict = dict(enumerate(self.signal_process_list, start=-(len(self.signal_process_list)-1)))
bkg_process_dict = dict(enumerate(self.bkg_process_list, start=1))
#constructing the lines
is_first = True
for p_number in sorted(signal_process_dict.keys()):
#delimiter = '\t\t'
delimiter = ' '
if is_first:
delimiter = ''
is_first = False
p_name = signal_process_dict[p_number]
process_lines['bin'] += ( delimiter + 'cat_' + str(self.datacard_name) )
process_lines['name'] += ( delimiter + str(p_name) )
process_lines['number'] += ( delimiter + str(p_number) )
process_lines['rate'] += ( delimiter + str(float(self.d_input[p_name]['rate']) * self.lumi_scaling) )
process_lines['sys'] = "#systematics line: not implemented yet!!!"
for p_number in sorted(bkg_process_dict.keys()):
#delimiter = '\t\t'
delimiter = ' '
if is_first:
delimiter = ''
is_first = False
p_name = bkg_process_dict[p_number]
process_lines['bin'] += ( delimiter + 'cat_' + str(self.datacard_name) )
process_lines['name'] += ( delimiter + str(p_name) )
process_lines['number'] += ( delimiter + str(p_number) )
process_lines['rate'] += ( delimiter + str(float(self.d_input[p_name]['rate']) * self.lumi_scaling) )
process_lines['sys'] = "#systematics line: not implemented yet!!!"
return process_lines
def _get_observation(self):
"""
Read the data from trees and applies a cut.
So far, we only get rate directly as a number.
"""
return self.d_input['observation']['rate']
def _get_systematics_lines(self):
"""
Find systematics and construct a table/dict
"""
systematics_lines_list = []
sys_dict = self.d_input['systematics']
#loop on keys, i.e. sys names and append value if process found, otherwise, append '-'
for sys_id in sys_dict.keys():
values = []
for sig_id in self.signal_process_list:
try:
value = sys_dict[sys_id][sig_id]
except KeyError:
value = '-'
values.append(str(value))
for bkg_id in self.bkg_process_list:
try:
value = sys_dict[sys_id][bkg_id]
except KeyError:
value = '-'
values.append(str(value))
if sys_dict[sys_id]['type'].startswith('param'): values=[]
systematics_lines_list.append('{0} {1} {2}'.format(sys_id, sys_dict[sys_id]['type'],string.join(values,' ') ))
self.log.debug('Systematic line: {0} '.format(systematics_lines_list[-1])) #show the last one
systematics_lines = ''
n_systematics = 0
for line in systematics_lines_list:
systematics_lines += line
systematics_lines += '\n'
n_systematics += 1
return (n_systematics, systematics_lines)
def make_workspace(self):
"""Make RooWorkspace and dump to a file"""
gSystem.AddIncludePath("-I$CMSSW_BASE/src/ ");
gSystem.Load("$CMSSW_BASE/lib/slc5_amd64_gcc472/libHiggsAnalysisCombinedLimit.so");
gSystem.AddIncludePath("-I$ROOFITSYS/include");
self.w = RooWorkspace('w')
#run all functions_and_definitions:
for factory_statement in self.d_input['functions_and_definitions']:
self.w.factory(factory_statement)
for p in self.process_list:
self.log.debug('Checking for shape in {0}/{1}'.format(self.datacard_name, p))
try:
self.d_input[p]['shape']
except KeyError:
pass
else:
if self.d_input[p]['shape']:
self.shapes_exist = True
self.w.factory(self.d_input[p]['shape'])
self.log.debug('Printing workspace...')
self.data_obs = self.w.pdf('ggH').generate(RooArgSet(self.w.var('mass4l')), self._get_observation())
self.data_obs.SetNameTitle('data_obs','data_obs')
getattr(self.w,'import')(self.data_obs)
if self.DEBUG:
print 20*"----"
self.w.Print()
print 20*"----"
self.w.writeToFile(self.shapes_output_file)
self.log.debug('Datacard workspace written to {0}'.format(self.shapes_output_file))
def scale_lumi_by(self, lumi_scaling):
"""
Scales luminosity in datacards by a fixed factor. This can be
used to get exclusion limits projections with higher luminosities.
"""
self.lumi_scaling = lumi_scaling
if self.lumi_scaling != 1.0:
self.card_header+='Rates in datacard are scaled by a factor of {0}'.format(self.lumi_scaling)
self.log.debug('Rates in datacards will be scaled by a factor of {0}'.format(self.lumi_scaling))
class TemplatesPlotter(PlotPolisher):
def __init__(self,name = "templates" ):
self.log = Logger().getLogger(self.__class__.__name__, 10)
self.name = name
#ROOT.gSystem.AddIncludePath("-I$ROOFITSYS/include/");
ROOT.gROOT.ProcessLine(".L tdrstyle.cc")
from ROOT import setTDRStyle
ROOT.setTDRStyle(True)
ROOT.gStyle.SetPalette(1)
ROOT.gStyle.SetOptStat(0)
self.copy_to_web_dir = False
self.webdir = ""
self.pp = pprint.PrettyPrinter(indent=4)
self.k2k1_ratio=0
self.k3k1_ratio=0
self.total_pdf=0
def set_k2k1_and_k3k1(self, k2k1, k3k1):
self.k2k1_ratio = k2k1
self.k3k1_ratio = k3k1
def setName(self, newname): self.name = newname
def get_scale_factors(self):
factors = {'lambda12_cosP' : 0.0,
'lambda13_cosP' : 0.0,
'lambda23_cosN' : 0.0,
'lambda23_cosP' : 0.0,
'gamma33' : 0.034,
'gamma13' : 0.0,
'gamma12' : -0.269303399267,
'gamma11' : 1.0,
'lambda13_cosN' : 0.0,
'lambda12_sinN' : 0.0,
'lambda12_cosN' : 0.538606798534,
'gamma22' : 0.09,
'gamma23' : 0.0,
}
nominator={
'ggH_shape' : '{0}'.format(factors['gamma11']),
'gg0Ph_shape' : '{0}*{1}*{1}'.format(factors['gamma22'],self.k2k1_ratio), # @0 = k2k1_ratio
'gg0M_shape' : '{0}*{1}*{1}'.format(factors['gamma33'],self.k3k1_ratio), # @1 = k3k1_ratio
'ggInt_12P_shape': '{0}*{1}'.format(factors['lambda12_cosP'],self.k2k1_ratio),
'ggInt_12N_shape': '{0}*{1}*(-1)'.format(factors['lambda12_cosN'],self.k2k1_ratio),
'ggInt_13P_shape': '{0}*{1}'.format(factors['lambda13_cosP'],self.k3k1_ratio),
'ggInt_13N_shape': '{0}*{1}*(-1)'.format(factors['lambda13_cosN'],self.k3k1_ratio),
'ggInt_23P_shape': '{0}*{1}*{2}'.format(factors['lambda23_cosP'],self.k2k1_ratio,self.k3k1_ratio),
'ggInt_23N_shape':'{0}*{1}*{2}*(-1)'.format(factors['lambda23_cosN'],self.k2k1_ratio,self.k3k1_ratio)
}
return nominator
def set_total_pdf(self, plot, root_file):
f = TFile(root_file,"READ")
nominator= self.get_scale_factors()
for i_pdf in range(len(plot['histos'])):
if i_pdf==0:
total_pdf = f.Get(plot['histos'][i_pdf])
total_pdf.Scale(eval(nominator[plot['histos'][i_pdf]]))
self.log.debug('TOTAL_PDF -> Picking up the first term {0} and the scale {1}. The histo is TH2: {2}'.format(plot['histos'][i_pdf], eval(nominator[plot['histos'][i_pdf]]), isinstance(total_pdf,TH2)))
if plot['histos'][i_pdf]=="TOTAL_PDF":
break
another_template = f.Get(plot['histos'][i_pdf])
another_template.Scale(float(eval(nominator[plot['histos'][1]])))
self.log.debug('TOTAL_PDF -> Adding up term {0} and the scale {1} to histo TH2:{2}'.format(plot['histos'][i_pdf], eval(nominator[plot['histos'][i_pdf]]),isinstance(total_pdf,TH2)))
total_pdf.Add(another_template)
self.total_pdf = total_pdf
self.log.debug('TOTAL_PDF -> Added all terms and now the histo is TH2:{0} ... returning the value.'.format(isinstance(self.total_pdf,TH2)))
def makePlot(self, data):
self.c1 =ROOT.TCanvas("cc1","Templates",1000,800)
self.c1.cd()
ROOT.gPad.SetRightMargin(0.2)
try:
data['content']
except KeyError:
raise KeyError, "Canvas \'content\' dictionary is not provided in config file."
try:
data['setup']
except KeyError:
print "@@@@ Canvas \'setup\' dictionary is not provided. "
self.setup_exist=False
else:
self.arrangeCanvas(self.c1, data['setup'])
self.setup_exist=True
try:
self.leg
except AttributeError:
self.leg_exist=False
else:
self.leg_exist=True
print data['setup']['add_text']
try:
data['setup']['add_text']
except KeyError:
self.add_text_exist=False
else:
self.add_text_exist=True
i=0
#rat = RootAttributeTranslator()
for plot in data['content']:
try:
plot['POI']
except KeyError:
self.plot_total_pdf=False
else:
self.plot_total_pdf=True
plot['histos'].append("TOTAL_PDF")
for fs in data['setup']['final_states']:
print 100*"-"
theTemplFile = plot['file']+"_"+fs+".root"
interference_tag = "13"
if ('ggInt_13P_shape' in plot['histos']) and ('ggInt_13N_shape' in plot['histos']):
plot['histos'].append("ggInt_13_shape")
interference_tag = "13"
elif ('ggInt_12P_shape' in plot['histos']) and ('ggInt_12N_shape' in plot['histos']):
plot['histos'].append("ggInt_12_shape")
interference_tag = "12"
if self.plot_total_pdf:
self.set_total_pdf(plot, theTemplFile)
self.log.debug('TOTAL_PDF -> Returned histo is TH2:{0}'.format(isinstance(self.total_pdf,TH2)))
for theTemplate in plot['histos']:
doSum = False
if theTemplate == "ggInt_{0}_shape".format(interference_tag) :
doSum = True
self.log.debug("Running on file:{0} template:{1}".format(theTemplFile, theTemplate))
if DEBUG:
pp.pprint(plot)
th2 = SimplePlotter()
#plot['th2'] = th2.getTH2(theTemplFile, theTemplate)
if theTemplate=="TOTAL_PDF":
plot['th2'] = self.total_pdf
self.log.debug('TOTAL_PDF -> The addition is over. Going to plot now.' )
elif not doSum:
f = TFile(theTemplFile,"READ")
plot['th2'] = f.Get(theTemplate)
else:
self.log.debug('Summing up the interference template, which has been divided into positive and negative part.')
f = TFile(theTemplFile,"READ")
th2_P = f.Get("ggInt_{0}P_shape".format(interference_tag))
th2_N = f.Get("ggInt_{0}N_shape".format(interference_tag))
#get lamda factors
tree=f.Get('factors')
factors={}
for fn in ['lambda{0}_cosP'.format(interference_tag),'lambda{0}_cosN'.format(interference_tag)]:
factors[fn] = array('d',[0])
tree.SetBranchAddress(fn,factors[fn])
tree.GetEntry(0)
for fn in factors.keys(): factors[fn] = factors[fn][0]
print "Lambdas:",factors['lambda{0}_cosP'.format(interference_tag)], factors['lambda{0}_cosN'.format(interference_tag)]
th2_P.Scale(factors['lambda{0}_cosP'.format(interference_tag)])
th2_N.Scale(factors['lambda{0}_cosN'.format(interference_tag)])
th2_P.Add(th2_N, -1)
plot['th2'] = th2_P
if self.setup_exist: self.arrangeAxis(plot['th2'],data['setup'])
if self.leg_exist:
self.leg.AddEntry(plot['th2'],plot['legend']['text'],plot['legend']['opt']);
try:
plot['draw_opt']
except KeyError:
draw_opt = "COLZ"
else:
draw_opt = str(plot['draw_opt'])
if draw_opt.lower()=="surf":
self.c1.SetTheta(16.56)
self.c1.SetPhi(57.83133)
plot['th2'].Draw(draw_opt)
if self.leg_exist: self.leg.Draw()
template_name={
'ggH_shape':"T_{11}",
'gg0M_shape':'T_{33}',
'ggInt_13P_shape':'T_{13}',
'ggInt_13N_shape':'T_{13}',
'ggInt_13_shape':'T_{13}',
'gg0Ph_shape':'T_{22}',
'ggInt_12P_shape':'T_{12}',
'ggInt_12N_shape':'T_{12}',
'ggInt_12_shape':'T_{12}',
'qqZZ_shape':'T_{qqZZ}',
'TOTAL_PDF' : 'Total PDF'
}
if self.add_text_exist:
data['setup']['add_text'][0]['text'] = "{0}(X,Y), {1}, GEN level, 8TeV".format(template_name[theTemplate], fs)
if theTemplate=="TOTAL_PDF":
data['setup']['add_text'][0]['text']+=", Parameters: k2/k1={0}, k3/k1={1}".format(self.k2k1_ratio,self.k3k1_ratio)
self.add_text(data['setup']['add_text'])
plot_name = "{0}_{1}_{2}".format(theTemplFile.replace("/","_"), theTemplate, draw_opt)
#plot_name = self.name
self.save_extensions = ['png','pdf','eps']
try:
data['setup']['save_ext']
except KeyError:
self.log.info("No extensions are provided in setup. Using default: ", self.save_extensions)
else:
self.save_extensions = list(data['setup']['save_ext'])
self.save(self.c1, plot_name, self.save_extensions)
def setCopyToWebDir(self,doCopy=False,webdir=""):
if doCopy:
self.copy_to_web_dir = True
if webdir!="":
self.webdir = webdir
else:
raise ValueError, "You have to provide a webdir path if you want to copy the files."
else:
self.copy_to_web_dir = False
self.webdir = ""
return 0
def doCopyToWebDir(self,plot_name, newname=""):
if newname=="":
newname = plot_name
if self.webdir!="" :
misctools.make_sure_path_exists(self.webdir)
if not os.path.exists("{0}/index.php".format(self.webdir)) : shutil.copy("/afs/cern.ch/user/r/roko/www/html/index.php",self.webdir)
shutil.copy(plot_name,self.webdir+"/"+newname)
self.log.info("Copied {0} to webdir {1}".format(plot_name,self.webdir+"/"+newname))
else :
raise ValueError, "You have to provide a webdir path if you want to copy the files."
return 0
def save(self, canv, plot_name, extensions=[]):
#extensions = ['.png','.pdf','.eps','.root']
if len(extensions)==0: extensions=['']
for ext in extensions:
postfix = "."+ext
if ext=='': postfix=''
canv.SaveAs(plot_name+postfix)
self.log.debug("Saving to: {0}.*".format(plot_name))
if self.copy_to_web_dir :
self.doCopyToWebDir(plot_name+postfix)
def prepare_asimov_toy_datasets_for_sync():
#parseOptions()
DEBUG = False
if opt.verbosity != 10:
os.environ['PYTHON_LOGGER_VERBOSITY'] = str(opt.verbosity)
if opt.verbosity >= 4:
DEBUG = True
#1) RooDataSet with all processes for one sqrts and final state
#- have RooCategory for sqrts and final state
#chan = [1_7, 2_7, 3_7, 1_8,2_8,3_8]
#cat.defineType(chan[j],j); j=0..6
#cat.setLabel(chan[j]);
#2) finally append all toys to same RooDataSet
log = Logger().getLogger("prepare_toy_datasets_for_sync", 10)
toy_manager = ToyDataSetManager()
#toy_manager.set_workspace_path(opt.ws_path)
#path_to_tree, tree_variables, weight = "1", dataset_name = "my_dataset"):
#shapes * ch1_ch1 hzz4l_4muS_7TeV.input.root w:$PROCESS
#shapes * ch1_ch2 hzz4l_4eS_7TeV.input.root w:$PROCESS
#shapes * ch1_ch3 hzz4l_2e2muS_7TeV.input.root w:$PROCESS
#shapes * ch2_ch1 hzz4l_4muS_8TeV.input.root w:$PROCESS
#shapes * ch2_ch2 hzz4l_4eS_8TeV.input.root w:$PROCESS
#shapes * ch2_ch3 hzz4l_2e2muS_8TeV.input.root w:$PROCESS
model = "trees_SM"
#model = "trees_Mix_fa2"
#model = "trees_Mix_fa3"
toys_dir = "/afs/cern.ch/user/r/roko/wd_datacards/CreateFullSimToys/{0}".format(
model)
#Christoys:
#toys_dir = "/afs/cern.ch/work/c/chmartin/public/ForEmbedded/Final_v2/"
#chan_path_dict = {
#'ch1_ch1' : "{0}/Toys_CJLSTntuple_7TeV_4mu_*.root/SelectedTree".format(toys_dir),
#'ch1_ch2' : "{0}/Toys_CJLSTntuple_7TeV_4e_*.root/SelectedTree".format(toys_dir),
#'ch1_ch3' : "{0}/Toys_CJLSTntuple_7TeV_2e2mu_*.root/SelectedTree".format(toys_dir),
#'ch2_ch1' : "{0}/Toys_CJLSTntuple_8TeV_4mu_*.root/SelectedTree".format(toys_dir),
#'ch2_ch2' : "{0}/Toys_CJLSTntuple_8TeV_4e_*.root/SelectedTree".format(toys_dir),
#'ch2_ch3' : "{0}/Toys_CJLSTntuple_8TeV_2e2mu_*.root/SelectedTree".format(toys_dir)
#}
chan_path_dict = {
'ch1_ch1': "{0}/DTree_7TeV_4mu_*.root/selectedEvents".format(toys_dir),
'ch1_ch2': "{0}/DTree_7TeV_4e_*.root/selectedEvents".format(toys_dir),
'ch1_ch3':
"{0}/DTree_7TeV_2e2mu_*.root/selectedEvents".format(toys_dir),
'ch2_ch1': "{0}/DTree_8TeV_4mu_*.root/selectedEvents".format(toys_dir),
'ch2_ch2': "{0}/DTree_8TeV_4e_*.root/selectedEvents".format(toys_dir),
'ch2_ch3':
"{0}/DTree_8TeV_2e2mu_*.root/selectedEvents".format(toys_dir)
}
pp = pprint.PrettyPrinter(indent=4)
#if DEBUG:
#log.debug('Initial dictionary:')
#pp.pprint(chan_path_dict)
channel_name = sorted(chan_path_dict.keys())
cat = RooCategory("CMS_channel", "CMS_channel")
for cat_idx, cat_name in enumerate(channel_name):
cat.defineType(cat_name, cat_idx)
cat.setLabel(cat_name)
if DEBUG:
log.debug('Category : {0}'.format(cat_idx))
cat.Print('v')
my_vars = []
if ("fa3" in model) and ("fa2" in model):
my_vars = [
'D_bkg', 'D_0m', 'D_cp', 'D_0hp', 'D_int', 'Weight', 'mass4l'
]
elif "fa3" in model:
my_vars = ['D_bkg', 'D_0m', 'D_cp', 'Weight', 'mass4l']
elif "fa2" in model:
my_vars = ['D_bkg', 'D_0hp', 'D_int', 'Weight', 'mass4l']
else:
my_vars = [
'D_bkg', 'D_0m', 'D_cp', 'D_0hp', 'D_int', 'Weight', 'mass4l'
]
my_rrv = dict()
my_rrv['D_bkg'] = RooRealVar('D_bkg', 'D_bkg', 0, 1.)
my_rrv['D_0m'] = RooRealVar('D_0m', 'D_0m', 0, 1.)
my_rrv['D_cp'] = RooRealVar('D_cp', 'D_cp', -0.5, 0.5)
my_rrv['D_0hp'] = RooRealVar('D_0hp', 'D_0hp', 0, 1.)
my_rrv['D_int'] = RooRealVar('D_int', 'D_int', -0.2, 1)
my_rrv['mass4l'] = RooRealVar('mass4l', 'mass4l', 100, 1000.)
my_rrv['Weight'] = RooRealVar('Weight', 'Weight', 1.)
my_rrv['D_bkg'].setBins(5)
#my_rrv['D_bkg'].setBins(50)
my_rrv['D_0m'].setBins(50)
my_rrv['D_cp'].setBins(50)
my_rrv['D_0hp'].setBins(50)
my_rrv['D_int'].setBins(50)
my_arg_set = RooArgSet()
for var_name in my_vars:
#TODO implement check that branch exist
#my_rrv[var_name] = RooRealVar(var_name,var_name,-999999999,999999999)
my_arg_set.add(my_rrv[var_name])
my_arg_set.add(cat)
if DEBUG:
log.debug('RooArgSet is now:')
my_arg_set.Print('v')
if os.path.exists(opt.output_filename):
log.debug("Removing file: {0}".format(opt.output_filename))
os.remove(opt.output_filename)
import lib.RootHelpers.RootHelperBase as rhb
root_helper = rhb.RootHelperBase()
my_arg_set = RooArgSet()
for var_name in my_vars:
#TODO implement check that branch exist
#my_rrv[var_name] = RooRealVar(var_name,var_name,-999999999,999999999)
my_arg_set.add(my_rrv[var_name])
my_arg_set.add(cat)
if DEBUG:
log.debug('RooArgSet is now:')
my_arg_set.Print('v')
#import asimov dataset
for cat_idx, cat_name in enumerate(channel_name):
my_path_to_tree = chan_path_dict[cat_name]
log.debug("my_path_to_tree: {0} ".format(my_path_to_tree))
the_dataset = toy_manager.get_dataset_from_tree(
path_to_tree=my_path_to_tree,
tree_variables=my_vars,
weight="(mass4l<140.6&&mass4l>105.6)",
dataset_name="toys/toy_asimov_v0_{0}".format(cat_idx),
basket=False,
weight_var_name="Weight")
the_dataset_with_cat = RooDataSet(
"toys/toy_asimov_{0}".format(cat_idx),
"toys/toy_asimov_{0}".format(cat_idx), my_arg_set,
RooFit.Index(cat), RooFit.Import(cat_name, the_dataset),
RooFit.WeightVar("Weight"))
log.debug('RooDataSet the_dataset_with_cat contains {0} events'.format(
the_dataset_with_cat.sumEntries()))
the_dataset_with_cat.Print()
if cat_idx == 0:
combined_dataset = the_dataset_with_cat
else:
combined_dataset.append(the_dataset_with_cat)
log.debug('RooDataSet combined_dataset contains {0} events'.format(
combined_dataset.sumEntries()))
combined_dataset.Print()
combined_dataset.Print("v")
#combined_dataset.SetNameTitle("toys/embedded_asimov","toys/embedded_asimov")
#toy_manager.add_to_basket(combined_dataset)
toy_manager.add_to_basket(combined_dataset,
new_name="toys/embedded_asimov",
new_title="toys/embedded_asimov")
toy_manager.dump_datasets_to_file(opt.output_filename,
'UPDATE') #this one can receive both
def prepare_toy_datasets_for_sync():
#parseOptions()
DEBUG = False
if opt.verbosity != 10:
os.environ['PYTHON_LOGGER_VERBOSITY'] = str(opt.verbosity)
if opt.verbosity >= 4:
DEBUG = True
#1) RooDataSet with all processes for one sqrts and final state
#- have RooCategory for sqrts and final state
#chan = [1_7, 2_7, 3_7, 1_8,2_8,3_8]
#cat.defineType(chan[j],j); j=0..6
#cat.setLabel(chan[j]);
#2) finally append all toys to same RooDataSet
log = Logger().getLogger("prepare_toy_datasets_for_sync", 10)
toy_manager = ToyDataSetManager()
#toy_manager.set_workspace_path(opt.ws_path)
#path_to_tree, tree_variables, weight = "1", dataset_name = "my_dataset"):
#shapes * ch1_ch1 hzz4l_4muS_7TeV.input.root w:$PROCESS
#shapes * ch1_ch2 hzz4l_4eS_7TeV.input.root w:$PROCESS
#shapes * ch1_ch3 hzz4l_2e2muS_7TeV.input.root w:$PROCESS
#shapes * ch2_ch1 hzz4l_4muS_8TeV.input.root w:$PROCESS
#shapes * ch2_ch2 hzz4l_4eS_8TeV.input.root w:$PROCESS
#shapes * ch2_ch3 hzz4l_2e2muS_8TeV.input.root w:$PROCESS
#model = "trees_v3/bkg_only"
#model = "trees_v3/bkg_only/zjets"
#model = "trees_v3/bkg_only/qqZZ"
#model = "trees_v3/bkg_only/ggZZ"
model = "trees_v3/SM"
#model = "trees_v3/Mixed_fa3"
#model = "trees_v3/Mixed_fa2"
#model = "trees_v2/SM"
#model = "trees_v2/Mixed_fa3"
#model = "trees_v2/Mixed_fa2"
#model = "trees_v0/SM"
#model = "trees_v0/Mixed_fa3"
#model = "trees_v0/Mixed_fa2"
toys_dir = "/afs/cern.ch/work/r/roko/Stat/CMSSW_611_JCP/src/HZZ4L_Combination/CombinationPy/CreateDatacards/CMSdata/SYNC/{0}".format(
model)
#Christoys:
#toys_dir = "/afs/cern.ch/work/c/chmartin/public/ForEmbedded/Final_v2/"
chan_path_dict = {
'ch1_ch1':
"{0}/Toys_CJLSTntuple_7TeV_4mu_*.root/ToyEvents".format(toys_dir),
'ch1_ch2':
"{0}/Toys_CJLSTntuple_7TeV_4e_*.root/ToyEvents".format(toys_dir),
'ch1_ch3':
"{0}/Toys_CJLSTntuple_7TeV_2e2mu_*.root/ToyEvents".format(toys_dir),
'ch2_ch1':
"{0}/Toys_CJLSTntuple_8TeV_4mu_*.root/ToyEvents".format(toys_dir),
'ch2_ch2':
"{0}/Toys_CJLSTntuple_8TeV_4e_*.root/ToyEvents".format(toys_dir),
'ch2_ch3':
"{0}/Toys_CJLSTntuple_8TeV_2e2mu_*.root/ToyEvents".format(toys_dir)
}
pp = pprint.PrettyPrinter(indent=4)
#if DEBUG:
#log.debug('Initial dictionary:')
#pp.pprint(chan_path_dict)
channel_name = sorted(chan_path_dict.keys())
cat = RooCategory("CMS_channel", "CMS_channel")
for cat_idx, cat_name in enumerate(channel_name):
cat.defineType(cat_name, cat_idx)
cat.setLabel(cat_name)
if DEBUG:
log.debug('Category : {0}'.format(cat_idx))
cat.Print('v')
my_vars = []
if ("fa3" in model) and ("fa2" in model):
my_vars = [
'D_bkg', 'D_0m', 'D_cp', 'D_0hp', 'D_int', 'Weight', 'ZZMass'
]
elif "fa3" in model:
my_vars = ['D_bkg', 'D_0m', 'D_cp', 'Weight', 'ZZMass']
elif "fa2" in model:
my_vars = ['D_bkg', 'D_0hp', 'D_int', 'Weight', 'ZZMass']
else:
my_vars = [
'D_bkg', 'D_0m', 'D_cp', 'D_0hp', 'D_int', 'Weight', 'ZZMass'
]
my_rrv = dict()
my_rrv['D_bkg'] = RooRealVar('D_bkg', 'D_bkg', 0, 1.)
my_rrv['D_0m'] = RooRealVar('D_0m', 'D_0m', 0, 1.)
my_rrv['D_cp'] = RooRealVar('D_cp', 'D_cp', -0.5, 0.5)
my_rrv['D_0hp'] = RooRealVar('D_0hp', 'D_0hp', 0, 1.)
my_rrv['D_int'] = RooRealVar('D_int', 'D_int', -0.2, 1)
my_rrv['ZZMass'] = RooRealVar('ZZMass', 'ZZMass', 100, 1000.)
my_rrv['Weight'] = RooRealVar('Weight', 'Weight', 1.)
#my_rrv['D_bkg'].setBins(2)
my_rrv['D_bkg'].setBins(50)
my_rrv['D_0m'].setBins(50)
my_rrv['D_cp'].setBins(50)
my_rrv['D_0hp'].setBins(50)
my_rrv['D_int'].setBins(50)
my_arg_set = RooArgSet()
for var_name in my_vars:
#TODO implement check that branch exist
#my_rrv[var_name] = RooRealVar(var_name,var_name,-999999999,999999999)
my_arg_set.add(my_rrv[var_name])
my_arg_set.add(cat)
if DEBUG:
log.debug('RooArgSet is now:')
my_arg_set.Print('v')
if os.path.exists(opt.output_filename):
log.debug("Removing file: {0}".format(opt.output_filename))
os.remove(opt.output_filename)
###run on all toys
#for idx in range(0,1000): #run on toy numbers
#log.debug('Running on toy number : {0}'.format(idx))
##run on each channel (sqrts+finalstate)
#for cat_idx, cat_name in enumerate( channel_name ):
#my_path_to_tree = chan_path_dict[cat_name]
#log.debug("my_path_to_tree: {0}".format(my_path_to_tree ))
#the_dataset = toy_manager.get_dataset_from_tree(path_to_tree = my_path_to_tree, tree_variables=my_vars,
#weight="ToyNumber=={0} && (ZZMass>105.6 && ZZMass<140.6)".format(idx),
#dataset_name="toys/toy_{0}_{1}".format(idx,cat_idx), basket = False)
#the_dataset_with_cat = RooDataSet(the_dataset.GetName(),the_dataset.GetName(), my_arg_set, RooFit.Index(cat),RooFit.Import(cat_name,the_dataset))
#log.debug('RooDataSet the_dataset_with_cat contains {0} events'.format(the_dataset_with_cat.sumEntries()))
#if cat_idx==0:
#combined_dataset = the_dataset_with_cat
#else:
#combined_dataset.append(the_dataset_with_cat)
#log.debug('RooDataSet combined_dataset contains {0} events'.format(combined_dataset.sumEntries()))
#combined_dataset.Print("v")
#toy_manager.add_to_basket(combined_dataset, new_name = "toys/comb_{0}".format(idx), new_title = "toys/comb_{0}".format(idx))
#toy_manager.dump_datasets_to_file(opt.output_filename,'UPDATE') #this one can receive both
import lib.RootHelpers.RootHelperBase as rhb
root_helper = rhb.RootHelperBase()
my_arg_set = RooArgSet()
for var_name in my_vars:
#TODO implement check that branch exist
#my_rrv[var_name] = RooRealVar(var_name,var_name,-999999999,999999999)
my_arg_set.add(my_rrv[var_name])
my_arg_set.add(cat)
if DEBUG:
log.debug('RooArgSet is now:')
my_arg_set.Print('v')
#import asimov dataset
for cat_idx, cat_name in enumerate(channel_name):
my_path_to_tree = chan_path_dict[cat_name]
log.debug("my_path_to_tree: {0} ".format(my_path_to_tree))
the_dataset = toy_manager.get_dataset_from_tree(
path_to_tree=my_path_to_tree,
tree_variables=my_vars,
weight="(ZZMass<140.6&&ZZMass>105.6)",
dataset_name="toys/toy_asimov_v0_{0}".format(cat_idx),
basket=False,
weight_var_name="Weight")
#mass_column = RooFormulaVar("CMS_zz4l_mass","CMS_zz4l_mass", "ZZMass", RooArgList(my_rrv['ZZMass']))
#the_dataset.addColumn(mass_column)
#my_arg_set.add(mass_column)
#my_tree = root_helper.get_TTree(my_path_to_tree, cut = "(ZZMass<140.6&&ZZMass>105.6)")
#log.debug('Selected tree contains {0} events'.format(my_tree.GetEntries()))
#the_dataset = RooDataSet("toys/toy_asimov_v0_{0}".format(cat_idx), "toys/toy_asimov_v0_{0}".format(cat_idx), my_tree, my_arg_set, "", "Weight")
the_dataset_with_cat = RooDataSet(
"toys/toy_asimov_{0}".format(cat_idx),
"toys/toy_asimov_{0}".format(cat_idx), my_arg_set,
RooFit.Index(cat), RooFit.Import(cat_name, the_dataset),
RooFit.WeightVar("Weight"))
#the_dataset_with_cat = RooDataSet(the_dataset.GetName(),the_dataset.GetName(), my_arg_set, RooFit.Index(cat),RooFit.Import(cat_name,the_dataset))
log.debug('RooDataSet the_dataset_with_cat contains {0} events'.format(
the_dataset_with_cat.sumEntries()))
the_dataset_with_cat.Print()
if cat_idx == 0:
combined_dataset = the_dataset_with_cat
else:
combined_dataset.append(the_dataset_with_cat)
log.debug('RooDataSet combined_dataset contains {0} events'.format(
combined_dataset.sumEntries()))
combined_dataset.Print()
combined_dataset.Print("v")
toy_manager.add_to_basket(combined_dataset,
new_name="toys/embedded_asimov",
new_title="toys/embedded_asimov")
toy_manager.dump_datasets_to_file(opt.output_filename,
'UPDATE') #this one can receive both
def prepare_toy_datasets_for_sync():
#parseOptions()
DEBUG = False
if opt.verbosity!=10:
os.environ['PYTHON_LOGGER_VERBOSITY'] = str(opt.verbosity)
if opt.verbosity >=4:
DEBUG = True
#1) RooDataSet with all processes for one sqrts and final state
#- have RooCategory for sqrts and final state
#chan = [1_7, 2_7, 3_7, 1_8,2_8,3_8]
#cat.defineType(chan[j],j); j=0..6
#cat.setLabel(chan[j]);
#2) finally append all toys to same RooDataSet
log = Logger().getLogger("prepare_toy_datasets_for_sync", 10)
toy_manager = ToyDataSetManager()
#toy_manager.set_workspace_path(opt.ws_path)
#path_to_tree, tree_variables, weight = "1", dataset_name = "my_dataset"):
#shapes * ch1_ch1 hzz4l_4muS_7TeV.input.root w:$PROCESS
#shapes * ch1_ch2 hzz4l_4eS_7TeV.input.root w:$PROCESS
#shapes * ch1_ch3 hzz4l_2e2muS_7TeV.input.root w:$PROCESS
#shapes * ch2_ch1 hzz4l_4muS_8TeV.input.root w:$PROCESS
#shapes * ch2_ch2 hzz4l_4eS_8TeV.input.root w:$PROCESS
#shapes * ch2_ch3 hzz4l_2e2muS_8TeV.input.root w:$PROCESS
#model = "trees_v3/bkg_only"
#model = "trees_v3/bkg_only/zjets"
#model = "trees_v3/bkg_only/qqZZ"
#model = "trees_v3/bkg_only/ggZZ"
model = "trees_v3/SM"
#model = "trees_v3/Mixed_fa3"
#model = "trees_v3/Mixed_fa2"
#model = "trees_v2/SM"
#model = "trees_v2/Mixed_fa3"
#model = "trees_v2/Mixed_fa2"
#model = "trees_v0/SM"
#model = "trees_v0/Mixed_fa3"
#model = "trees_v0/Mixed_fa2"
toys_dir = "/afs/cern.ch/work/r/roko/Stat/CMSSW_611_JCP/src/HZZ4L_Combination/CombinationPy/CreateDatacards/CMSdata/SYNC/{0}".format(model)
#Christoys:
#toys_dir = "/afs/cern.ch/work/c/chmartin/public/ForEmbedded/Final_v2/"
chan_path_dict = {
'ch1_ch1' : "{0}/Toys_CJLSTntuple_7TeV_4mu_*.root/ToyEvents".format(toys_dir),
'ch1_ch2' : "{0}/Toys_CJLSTntuple_7TeV_4e_*.root/ToyEvents".format(toys_dir),
'ch1_ch3' : "{0}/Toys_CJLSTntuple_7TeV_2e2mu_*.root/ToyEvents".format(toys_dir),
'ch2_ch1' : "{0}/Toys_CJLSTntuple_8TeV_4mu_*.root/ToyEvents".format(toys_dir),
'ch2_ch2' : "{0}/Toys_CJLSTntuple_8TeV_4e_*.root/ToyEvents".format(toys_dir),
'ch2_ch3' : "{0}/Toys_CJLSTntuple_8TeV_2e2mu_*.root/ToyEvents".format(toys_dir)
}
pp = pprint.PrettyPrinter(indent=4)
#if DEBUG:
#log.debug('Initial dictionary:')
#pp.pprint(chan_path_dict)
channel_name = sorted(chan_path_dict.keys())
cat = RooCategory("CMS_channel","CMS_channel")
for cat_idx, cat_name in enumerate( channel_name ):
cat.defineType(cat_name,cat_idx);
cat.setLabel(cat_name);
if DEBUG:
log.debug('Category : {0}'.format(cat_idx))
cat.Print('v')
my_vars = []
if ("fa3" in model) and ("fa2" in model):
my_vars = ['D_bkg','D_0m','D_cp', 'D_0hp','D_int','Weight','ZZMass']
elif "fa3" in model:
my_vars = ['D_bkg','D_0m','D_cp','Weight','ZZMass']
elif "fa2" in model:
my_vars = ['D_bkg', 'D_0hp','D_int','Weight','ZZMass']
else:
my_vars = ['D_bkg','D_0m','D_cp', 'D_0hp','D_int','Weight','ZZMass']
my_rrv = dict()
my_rrv['D_bkg'] = RooRealVar('D_bkg','D_bkg', 0,1.)
my_rrv['D_0m'] = RooRealVar('D_0m','D_0m', 0,1.)
my_rrv['D_cp'] = RooRealVar('D_cp','D_cp', -0.5,0.5)
my_rrv['D_0hp'] = RooRealVar('D_0hp','D_0hp', 0,1.)
my_rrv['D_int'] = RooRealVar('D_int','D_int', -0.2,1)
my_rrv['ZZMass'] = RooRealVar('ZZMass','ZZMass', 100,1000.)
my_rrv['Weight'] = RooRealVar('Weight','Weight', 1.)
#my_rrv['D_bkg'].setBins(2)
my_rrv['D_bkg'].setBins(50)
my_rrv['D_0m'].setBins(50)
my_rrv['D_cp'].setBins(50)
my_rrv['D_0hp'].setBins(50)
my_rrv['D_int'].setBins(50)
my_arg_set = RooArgSet()
for var_name in my_vars:
#TODO implement check that branch exist
#my_rrv[var_name] = RooRealVar(var_name,var_name,-999999999,999999999)
my_arg_set.add(my_rrv[var_name])
my_arg_set.add(cat)
if DEBUG:
log.debug('RooArgSet is now:')
my_arg_set.Print('v')
if os.path.exists(opt.output_filename):
log.debug("Removing file: {0}".format(opt.output_filename))
os.remove(opt.output_filename)
###run on all toys
#for idx in range(0,1000): #run on toy numbers
#log.debug('Running on toy number : {0}'.format(idx))
##run on each channel (sqrts+finalstate)
#for cat_idx, cat_name in enumerate( channel_name ):
#my_path_to_tree = chan_path_dict[cat_name]
#log.debug("my_path_to_tree: {0}".format(my_path_to_tree ))
#the_dataset = toy_manager.get_dataset_from_tree(path_to_tree = my_path_to_tree, tree_variables=my_vars,
#weight="ToyNumber=={0} && (ZZMass>105.6 && ZZMass<140.6)".format(idx),
#dataset_name="toys/toy_{0}_{1}".format(idx,cat_idx), basket = False)
#the_dataset_with_cat = RooDataSet(the_dataset.GetName(),the_dataset.GetName(), my_arg_set, RooFit.Index(cat),RooFit.Import(cat_name,the_dataset))
#log.debug('RooDataSet the_dataset_with_cat contains {0} events'.format(the_dataset_with_cat.sumEntries()))
#if cat_idx==0:
#combined_dataset = the_dataset_with_cat
#else:
#combined_dataset.append(the_dataset_with_cat)
#log.debug('RooDataSet combined_dataset contains {0} events'.format(combined_dataset.sumEntries()))
#combined_dataset.Print("v")
#toy_manager.add_to_basket(combined_dataset, new_name = "toys/comb_{0}".format(idx), new_title = "toys/comb_{0}".format(idx))
#toy_manager.dump_datasets_to_file(opt.output_filename,'UPDATE') #this one can receive both
import lib.RootHelpers.RootHelperBase as rhb
root_helper = rhb.RootHelperBase()
my_arg_set = RooArgSet()
for var_name in my_vars:
#TODO implement check that branch exist
#my_rrv[var_name] = RooRealVar(var_name,var_name,-999999999,999999999)
my_arg_set.add(my_rrv[var_name])
my_arg_set.add(cat)
if DEBUG:
log.debug('RooArgSet is now:')
my_arg_set.Print('v')
#import asimov dataset
for cat_idx, cat_name in enumerate( channel_name ):
my_path_to_tree = chan_path_dict[cat_name]
log.debug("my_path_to_tree: {0} ".format(my_path_to_tree ))
the_dataset = toy_manager.get_dataset_from_tree(path_to_tree = my_path_to_tree, tree_variables = my_vars,
weight="(ZZMass<140.6&&ZZMass>105.6)", dataset_name="toys/toy_asimov_v0_{0}".format(cat_idx), basket = False, weight_var_name = "Weight")
#mass_column = RooFormulaVar("CMS_zz4l_mass","CMS_zz4l_mass", "ZZMass", RooArgList(my_rrv['ZZMass']))
#the_dataset.addColumn(mass_column)
#my_arg_set.add(mass_column)
#my_tree = root_helper.get_TTree(my_path_to_tree, cut = "(ZZMass<140.6&&ZZMass>105.6)")
#log.debug('Selected tree contains {0} events'.format(my_tree.GetEntries()))
#the_dataset = RooDataSet("toys/toy_asimov_v0_{0}".format(cat_idx), "toys/toy_asimov_v0_{0}".format(cat_idx), my_tree, my_arg_set, "", "Weight")
the_dataset_with_cat = RooDataSet("toys/toy_asimov_{0}".format(cat_idx),"toys/toy_asimov_{0}".format(cat_idx), my_arg_set, RooFit.Index(cat), RooFit.Import(cat_name,the_dataset), RooFit.WeightVar("Weight"))
#the_dataset_with_cat = RooDataSet(the_dataset.GetName(),the_dataset.GetName(), my_arg_set, RooFit.Index(cat),RooFit.Import(cat_name,the_dataset))
log.debug('RooDataSet the_dataset_with_cat contains {0} events'.format(the_dataset_with_cat.sumEntries()))
the_dataset_with_cat.Print()
if cat_idx==0:
combined_dataset = the_dataset_with_cat
else:
combined_dataset.append(the_dataset_with_cat)
log.debug('RooDataSet combined_dataset contains {0} events'.format(combined_dataset.sumEntries()))
combined_dataset.Print()
combined_dataset.Print("v")
toy_manager.add_to_basket(combined_dataset, new_name = "toys/embedded_asimov", new_title = "toys/embedded_asimov")
toy_manager.dump_datasets_to_file(opt.output_filename,'UPDATE') #this one can receive both
class RootHelperBase(object):
"""
Class that helps to pick any object from any root file
by specifiying the path to the object like:
path/to/root_file.root/path/to/root_object.
Class can also check for type of object and return TypeError
in case the object is not of a desired type.
"""
def __init__(self):
self.log = Logger().getLogger(self.__class__.__name__, 10)
self.pp = pprint.PrettyPrinter(indent=4)
self.DEBUG = True
def check_in_opened_files_table(self, file_name, access):
"""
Makes a check in the open_files_table dictionary and returns
pointer to the file if file is opened correct access mode.
Returns:
--------
tuple (is_opened, pointer_to_file).
In case file doesn't exist (is_opened=False,pointer_to_file=None)
"""
try:
self.open_files_table[file_name][access]
except KeyError:
self.log.debug("File {0} is not opened in {1} mode.".format(file_name, access))
return (False, None)
else:
the_file = self.open_files_table[file_name][access]
if isinstance(the_file, TFile):
if the_file.IsOpen() and not the_file.IsZombie():
self.log.debug(
"File {0} is already opened in {1} mode. Return pointer to file.".format(file_name, access)
)
return (True, the_file)
else:
self.log.debug("File {0} in {1} mode is either closed or zombie.".format(file_name, access))
self.open_files_table[file_name][access] = None
return (False, None)
else:
self.log.debug("File {0} is not opened in {1} mode.".format(file_name, access))
return (False, None)
def update_opened_files_table(self, file_object, access):
"""
Update the status of files opened.
file_name: acces : file_pointer structure.
"""
try:
self.open_files_table
except AttributeError:
# self.open_files_table = collections.OrderedDict()
self.open_files_table = {}
self.open_files_table[file_object.GetName()] = {access: file_object}
else:
try:
self.open_files_table[file_object.GetName()]
except KeyError:
self.open_files_table[file_object.GetName()] = {access: file_object}
else:
self.open_files_table[file_object.GetName()].update({access: file_object})
# self.open_files_table['dummy'].update({access : file_object})
# self.open_files_table[file_object.GetName()][access] = file_object
if self.DEBUG:
self.pp.pprint(self.open_files_table)
return 0
def TFile_safe_open(self, file_name, access="READ"):
"""
Safely open TFile object. Memory is saved by cheking if the file is already
open by looking up in the list open_files_table.
"""
# check if file is already openedby looking-up the opend files dict
is_opened = False
rootfile = None
try:
self.open_files_table
except AttributeError:
pass
else:
is_opened, rootfile = self.check_in_opened_files_table(file_name, access)
if is_opened:
self.log.debug("Returning pointer to ROOT file: {0}".format(file_name))
return rootfile
self.log.debug("Opening ROOT file: {0}".format(file_name))
if access.upper() == "READ" and not os.path.exists(file_name):
raise IOError, "File path does not exist: {0}".format(file_name)
else:
base_dir = os.path.dirname(file_name)
misc.make_sure_path_exists(base_dir)
rootfile = TFile.Open(file_name, access)
self.update_opened_files_table(rootfile, access)
if not rootfile:
raise IOError, "The file {0} either doesn't exist or cannot be open".format(file_name)
return rootfile
def get_paths(self, path):
"""
Returns tuple (path_to_root_file, path_to_root_object_in_root_file)
"""
path_contains_file = ".root" in path
path_segments = path.split(".root")
if path.endswith(".root"): # only root file path exists
return (path, "")
# print path_segments
# assert 1<len(path_segments)<=2, 'Path should be in format <path/to/dir>root_object_file.root/path_to_root_object_in_file'
assert (
0 < len(path_segments) <= 2
), "Path should be in format <path/to/dir>root_object_file.root/path_to_root_object_in_file"
path_to_file = ""
if len(path_segments) == 2: # path contains file name and object path in the root file
path_to_file = path_segments[0] + ".root"
self.log.debug("Src root file: {0}".format(path_to_file))
# path_to_root_object = string.join(path_segments[-1].split('/')[1:],'/') #to remove the '/' after .root
if path_segments[-1].startswith("/"):
path_to_root_object = path_segments[-1][1:] # to remove the '/' after .root
else:
path_to_root_object = path_segments[-1] # there is no '/' at the beggining
self.log.debug("Src root_object name: {0}".format(path_to_root_object))
return (path_to_file, path_to_root_object)
# path_to_file = path_segments[0]+'.root'
# self.log.debug('Src root file: {0}'.format(path_to_file ))
# path_to_root_object = string.join(path_segments[-1].split('/')[1:],'/') #to remove the '/' after .root
# self.log.debug('Src root_object name: {0}'.format(path_to_root_object))
# return (path_to_file,path_to_root_object)
def get_object(self, path, object_type=None, clone=False):
"""
Get any root object copy from path and check it's type.
The object is copied from the file if needed.
"""
path_to_file, path_to_root_object = self.get_paths(path)
root_object_file = self.TFile_safe_open(path_to_file, "READ")
the_object = root_object_file.Get(path_to_root_object)
is_TTree = isinstance(the_object, TTree)
if clone:
if not is_TTree:
the_object = copy.deepcopy(root_object_file.Get(path_to_root_object))
self.log.debug("Coping root_object {0} of type={1}.".format(path_to_root_object, type(the_object)))
root_object_file.Close()
else:
# FIXME
self.log.warn("Cloning the full tree {0}. !!! Still not fully tested !!!".format(path_to_root_object))
the_object = root_object_file.Get(path_to_root_object).CloneTree()
# will not close file since it will destroy the object. Better to write the tree down first, then close file.
else:
self.log.debug(
"Pointer to root_object {0} of type={1} is returned.".format(path_to_root_object, type(the_object))
)
return the_object
def get_TTree(self, path, cut=None, clone=False):
"""
Get a tree from the path of format //machine/file_name.root/subdir/tree_name.
If path is list it will asume TChain. Wildcards can be used but ".root" has
to exost in the path name, otherwise 'segmentation violation'
"""
the_tree = TChain()
if isinstance(path, list):
tree_name = self.get_paths(path[0])[1]
the_tree.SetName(tree_name)
for item in path:
assert isinstance(item, str), "The tree path should be of string format and not: {0}".format(type(item))
add_result = the_tree.Add(item)
elif isinstance(path, str):
tree_name = self.get_paths(path)[1]
the_tree.SetName(tree_name)
add_result = the_tree.Add(path)
self.log.debug("TChain has been constructed from {0} files with correct tree names.".format(add_result))
if cut:
assert isinstance(cut, str), "The TTree cut has to be string value, not {0} !!!".format(type(cut))
clone = True
the_selection_tree = the_tree.CopyTree(cut)
return the_selection_tree
else:
return the_tree
def get_histogram(self, path, hist_type=TH1, clone=False):
"""
Get TH1 object or any other that inherits from TH1
"""
return self.get_object(path, hist_type, clone)
def get_embedded_object(
self, path_to_container, container_type=None, embedded_object=None, object_type=None, clone=False
):
"""
Get an object embedded into another class, like e.g. a TH1 from TCanvas
saved in file. In case only path_to_container is given, it will return the container
like with get_object method.
"""
pass
def add_to_basket(self, root_object, new_name=None, new_title=None):
"""
Add object to the basket with new_name and new_title.
If new_name contains "/" then a directory will be created inside the file. (TODO)
"""
if new_name:
# name_in_basket = new_name
new_name_no_subfolders = new_name.split("/")[-1] # remove subfolder name from the new_name
root_object.SetName(new_name_no_subfolders)
name_in_basket = new_name
else:
name_in_basket = root_object.GetName()
if new_title:
root_object.SetTitle(new_title)
try:
self.root_fruit_basket
except AttributeError:
self.root_fruit_basket = collections.OrderedDict()
self.log.debug("Creating new root-object basket.")
else:
if self.DEBUG and len(self.root_fruit_basket) < 10:
self.log.debug("Adding root-object to existing basket. Basket state (printed if less then 10 items):")
self.pp.pprint(self.root_fruit_basket)
self.root_fruit_basket[name_in_basket] = root_object
def _get_subfolders_and_name(self, path):
"""
Gives back the 2 element tuple with subfolder path and a name of root_object
"""
path_segments = path.split("/")
assert len(path_segments) > 0, "The name should not be empty string."
if len(path_segments) > 1:
# check if first is '/'
if path_segments[0] == "":
path_segments.pop(0)
subfolders = string.join(path_segments[:-1], "/")
root_object_name = path_segments[-1]
self.log.debug("Root-subfolder: {0}".format(subfolders))
self.log.debug("Root-object name: {0}".format(root_object_name))
return (subfolders, root_object_name)
else:
root_object_name = path_segments[-1]
return (None, root_object_name)
def _get_directory(self, root_file, path):
"""
Create and cd to the directory if given like a/b/c
"""
root_file.cd()
# subfolders = self._get_subfolders_and_name(path)[0]
if path:
self.log.debug("Creating root-subfolder {0}".format(path))
mkdir_res = root_file.mkdir(path)
self.log.info("Root-subfolder {0} created with code = {1}".format(path, mkdir_res))
root_file.cd(path)
else: # no subfolder will be created
root_file.cd()
self.log.debug("Current directory: {0}".format(gDirectory.GetPath()))
def flush_basket(self):
"""
Resets the basket content and delets the basket.
"""
try:
del self.root_fruit_basket
except:
raise RuntimeError, "Basket cannot be flushed and destroyed! It even doesn't exist ..."
else:
self.log.info("Basket flushed!")
return 0
def dump_basket_to_file(self, file_name, access="UPDATE"):
"""
Save what is in basket to a file. Create directories in the path if needed.
"""
out_file = self.TFile_safe_open(file_name, access)
out_file.cd()
if self.DEBUG:
self.pp.pprint(self.root_fruit_basket)
for item_name in self.root_fruit_basket.keys():
subfolders, root_object_name = self._get_subfolders_and_name(item_name)
self._get_directory(out_file, subfolders) # it will create and cd to the directory if given like a/b/c
self.log.debug(
"Writing root-object: {0} Object name: {1} ; Object title: {2}".format(
self.root_fruit_basket[item_name],
self.root_fruit_basket[item_name].GetName(),
self.root_fruit_basket[item_name].GetTitle(),
)
)
is_TTree = isinstance(self.root_fruit_basket[item_name], TTree)
if is_TTree:
self.log.debug("This is a TTree object : {0}".format(self.root_fruit_basket[item_name]))
copy_tree_name = self.root_fruit_basket[item_name].GetName()
copy_tree_title = self.root_fruit_basket[item_name].GetTitle()
tree_for_saving = self.root_fruit_basket[item_name].CloneTree(0)
copy_res = tree_for_saving.CopyEntries(self.root_fruit_basket[item_name])
tree_for_saving.SetNameTitle(copy_tree_name, copy_tree_title)
write_res = tree_for_saving.Write()
else:
write_res = self.root_fruit_basket[item_name].Write()
if write_res == 0:
self.log.error("The object {0} cannot be written into {1}".format(item_name, gDirectory.GetPath()))
else:
self.log.info("The object {0} has been written into {1}".format(item_name, gDirectory.GetPath()))
out_file.Close()
self.log.info(
"Saved the basket with {1} items into the file: {0}".format(file_name, len(self.root_fruit_basket))
)
self.flush_basket()
return 0
class ChainProcessor(object):
"""
Processes the configuration set for running the creation
of Datacards, combine fit and then plot unit
"""
def __init__(self, run_data_name, run_dict):
"""Set the values from configuration"""
self.log = Logger().getLogger(self.__class__.__name__, 10)
self.run_dict = run_dict
self.create_cards_dir="/afs/cern.ch/work/r/roko/Stat/CMSSW_611_JCP/src/HZZ4L_Combination/CombinationPy/CreateDatacards/"
self.version= "v1"
self.sqrts_dc="8TeV"
self.sqrts_plot="14"
self.fs="2e2mu"
self.lumi="19.79"
self.lumi_zfill="19.79"
self.discriminant="D_{0-}(90^{o})"
self.MY_CUR_WWW_SUBDIR=""
self.append_name_base = run_data_name
self.MY_CUR_WWW_SUBDIR = self.append_name_base
self.POIs = list(self.run_dict['POI'])
self.poi = self.run_dict['POI_setup']
self.termNames = self.run_dict['termNames']
self.templatedir = self.run_dict['templatedir']
self.discriminant = self.run_dict['discriminant_name']
self.additional_options = self.run_dict['additional_options']
self.fs = self.run_dict['final_state']
self.www_dir = "/afs/cern.ch/user/r/roko/www/html/Geoloc/{0}".format(self.MY_CUR_WWW_SUBDIR)
self.do_copy_to_webdir = True
print "Setting web directory to: {0}".format(self.www_dir)
self.do_cmd = ""
#self.poi= {"k2k1_ratio":{"switch":0, "range":"-100,100", "name":"k2k1", "nice_name":"k_{2}/k_{1}", "value":"0"},
#"k3k1_ratio":{"switch":0, "range":"-100,100", "name":"k3k1", "nice_name":"k_{3}/k_{1}", "value":"0"}}
self.setup_POI_related_stuff()
def setup_POI_related_stuff(self):
"""Sets up the information which is related
to POIs and is needed to run the commands.
"""
def _set_POI_range(self,this_poi):
"""We use this function to set ranges to parameters because we set them lumi-dependant.
"""
if this_poi=="k3k1_ratio":
theRange=""
if float(self.lumi) > 50:
theRange = "-10,10"
elif float(self.lumi) > 20:
theRange = "-20,20"
else :
theRange = "-30,30"
self.poi["k3k1_ratio"]["range"] = theRange
elif this_poi=="k2k1_ratio":
pass
#make list out of POI
if isinstance(self.run_dict['POI'],list):
pass
else:
tmp_list=[]
tmp_list.append(self.run_dict['POI'])
self.run_dict['POI'] = tmp_list
self.POIs = self.run_dict['POI']
self.log.debug('POI: {0}'.format(self.POIs))
assert len(self.POIs)>0 and len(self.POIs)<3 and ("k2k1_ratio" or "k3k1_ratio" in self.POIs), \
"You should provide at least one POI (k2k1_ratio, k3k1_ratio), while you provided {0}".format(self.POIs)
if "k3k1_ratio" in self.POIs and "k2k1_ratio" in self.POIs:
self.poi_physics_model = "HiggsAnalysis.CombinedLimit.GeoLocationModel:K1andK2andK3Model"
self.poi_ranges_string_t2w = "--PO range_k3k1_ratio={0} --PO range_k2k1_ratio={1}".format(self.poi["k3k1_ratio"]['range'],self.poi["k2k1_ratio"]['range'] )
_set_POI_range(self,"k3k1_ratio")
_set_POI_range(self,"k2k1_ratio")
self.poi_ranges_string_fit = "k3k1_ratio={0}:k2k1_ratio={1}".format(self.poi["k3k1_ratio"]['range'],self.poi["k2k1_ratio"]['range'])
self.poi_name_value_plot = "{0}={2} {1}={3}".format(self.poi["k3k1_ratio"]['nice_name'],self.poi["k2k1_ratio"]['nice_name'],self.poi["k3k1_ratio"]['value'], self.poi["k2k1_ratio"]['value'])
self.poi_name_value = "k3k1_ratio={0},k2k1_ratio={1}".format(self.poi["k3k1_ratio"]['value'],self.poi["k2k1_ratio"]['value'])
self.poi_name_value_filename = "k3k1_ratio_{0}_k2k1_ratio_{1}".format(self.poi["k3k1_ratio"]['value'],self.poi["k2k1_ratio"]['value'])
self.pois = "k2k1_ratio,k3k1_ratio"
self.poi_n_points = str(self.poi["k2k1_ratio"]['n_scan_points']*self.poi["k3k1_ratio"]['n_scan_points'])
self.log.debug('Set up the {0}'.format(self.poi_physics_model))
elif "k2k1_ratio" in self.POIs:
self.poi_physics_model = "HiggsAnalysis.CombinedLimit.GeoLocationModel:K1andK2Model"
self.poi_ranges_string_t2w = "--PO range_k2k1_ratio={0}".format(self.poi["k2k1_ratio"]['range'] )
_set_POI_range(self,"k2k1_ratio")
self.poi_ranges_string_fit = "k2k1_ratio={0}".format(self.poi["k2k1_ratio"]['range'])
self.poi_name_value_plot = "{0}={1}".format(self.poi["k2k1_ratio"]['nice_name'],self.poi["k2k1_ratio"]['value'])
self.poi_name_value = "k2k1_ratio={0}".format(self.poi["k2k1_ratio"]['value'])
self.poi_name_value_filename = "k2k1_ratio_{0}".format(self.poi["k2k1_ratio"]['value'])
self.pois = "k2k1_ratio"
self.poi_n_points = str(self.poi["k2k1_ratio"]['n_scan_points'])
self.log.debug('Set up the {0}'.format(self.poi_physics_model))
elif "k3k1_ratio" in self.POIs:
self.poi_physics_model = "HiggsAnalysis.CombinedLimit.GeoLocationModel:K1andK3Model"
self.poi_ranges_string_t2w = "--PO range_k3k1_ratio={0}".format(self.poi["k3k1_ratio"]['range'] )
_set_POI_range(self,"k3k1_ratio")
self.poi_ranges_string_fit = "k3k1_ratio={0}".format(self.poi["k3k1_ratio"]['range'])
self.poi_name_value_plot = "{0}={1}".format(self.poi["k3k1_ratio"]['nice_name'],self.poi["k3k1_ratio"]['value'])
self.poi_name_value = "k3k1_ratio={0}".format(self.poi["k3k1_ratio"]['value'])
self.poi_name_value_filename = "k3k1_ratio_{0}".format(self.poi["k3k1_ratio"]['value'])
self.pois = "k3k1_ratio"
self.poi_n_points = str(self.poi["k3k1_ratio"]['n_scan_points'])
self.log.debug('Set up the {0}'.format(self.poi_physics_model))
self.log.debug("poi_physics_model ={0}".format(self.poi_physics_model))
self.log.debug("poi_ranges_string_t2w ={0}".format(self.poi_ranges_string_t2w))
self.log.debug("poi_ranges_string_fit ={0}".format(self.poi_ranges_string_fit))
self.log.debug("poi_name_value_plot ={0}".format(self.poi_name_value_plot))
self.log.debug("poi_name_value ={0}".format(self.poi_name_value))
self.log.debug("poi_name_value_filename ={0}".format(self.poi_name_value_filename))
self.log.debug("poi_n_points ={0}".format(self.poi_n_points))
self.log.debug("pois ={0}".format(self.pois))
def process(self, do_cmd=""):
self.do_cmd = do_cmd
self.setup_POI_related_stuff()
import lib.util.MiscTools as misc
#print self.__dict__
self.fs_expanded = self.fs
if self.fs.lower() == "4l":
self.fs_expanded = "4e,4#mu,2e2#mu"
os.environ['PLOT_TAG'] = "Asimov data %(poi_name_value_plot)s | Discrim. %(discriminant)s | L=%(lumi)s fb^{-1} @ %(sqrts_plot)s TeV | Fin. state = %(fs_expanded)s" %self.__dict__
cmd = {}
cmd['createCards'] = "rm -r cards_%(append_name_base)s; python makeDCsandWSs.py -b -i SM_inputs_8TeV_CJLST -a %(append_name_base)s -t %(templatedir)s --terms %(termNames)s %(additional_options)s" %self.__dict__
cmd['combCards'] = "rm -rf hzz4l_4lS_%(sqrts_dc)s_ALT.txt; combineCards.py hzz4l_4muS_%(sqrts_dc)s_ALT.txt hzz4l_4eS_%(sqrts_dc)s_ALT.txt hzz4l_2e2muS_%(sqrts_dc)s_ALT.txt> hzz4l_4lS_%(sqrts_dc)s_ALT.txt" %self.__dict__
cmd['t2w'] = "text2workspace.py hzz4l_%(fs)sS_%(sqrts_dc)s_ALT.txt -m 126 -P %(poi_physics_model)s %(poi_ranges_string_t2w)s --PO muFloating -o combine.ws.%(fs)s.%(version)s.root" %self.__dict__
cmd['gen'] = "combine -M GenerateOnly combine.ws.%(fs)s.%(version)s.root -m 126 -t -1 --expectSignal=1 --saveToys --setPhysicsModelParameters %(poi_name_value)s,cmshzz4l_lumi=%(lumi)s -S 0" %self.__dict__
cmd['addasimov'] = "root -b -l -q %(create_cards_dir)s/addToyDataset.C\(\\\"combine.ws.%(fs)s.%(version)s.root\\\",\\\"higgsCombineTest.GenerateOnly.mH126.123456.root\\\",\\\"toy_asimov\\\",\\\"workspaceWithAsimov_%(poi_name_value_filename)s_lumi_%(lumi)s.root\\\"\)" %self.__dict__
cmd['fit'] = "combine -M MultiDimFit workspaceWithAsimov_%(poi_name_value_filename)s_lumi_%(lumi)s.root --algo=grid --points %(poi_n_points)s -m 126 -n .asimov.%(fs)s.%(poi_name_value_filename)s.lumi_%(lumi_zfill)s -D toys/toy_asimov -S 0 --setPhysicsModelParameters cmshzz4l_lumi=%(lumi)s --setPhysicsModelParameterRanges %(poi_ranges_string_fit)s" %self.__dict__
cmd['plot'] = "root -l -b -q %(create_cards_dir)s/plotLimit.C\(\\\"higgsCombine.asimov.%(fs)s.%(poi_name_value_filename)s.lumi_%(lumi_zfill)s.MultiDimFit.mH126.root\\\",\\\"%(pois)s\\\",\\\"environ PLOT_TAG\\\" \)" %self.__dict__
if "createCards" in do_cmd:
print "--------------------------------------------------------"
print "Cards for Lumi=%(lumi)s and tag=%(append_name_base)s terms=%(termNames)s template=%(templatedir)s discriminant=%(discriminant)s additional_options=%(additional_options)s" %self.__dict__
misc.processCmd(cmd['createCards'])
print "--------------------------------------------------------"
if "combCards" in do_cmd: misc.processCmd(cmd['combCards'])
if "t2w" in do_cmd: misc.processCmd(cmd['t2w'])
if "gen" in do_cmd: misc.processCmd(cmd['gen'])
if "addasimov" in do_cmd: misc.processCmd(cmd['addasimov'])
if "fit" in do_cmd: misc.processCmd(cmd['fit'])
if "plot" in do_cmd:
misc.processCmd(cmd['plot'])
import lib.util.MiscTools as misc
misc.make_sure_path_exists(self.www_dir)
shutil.copy("/afs/cern.ch/user/r/roko/www/html/index.php",self.www_dir)
for self.x in ['AxisK3K1', 'AxisArctanGamK3K1', 'AxisArctanK3K1', 'AxisFa3', 'AxisK2K1']:
#print "cp higgsCombine.asimov.{fs}.{poi_name_value}.MultiDimFit.mH126.root*png {www_dir}/exp.{fs}.{poi_name_value_filename}.mH126.{x}.png".format(**self.__dict__)
#shutil.copy("higgsCombine.asimov.{fs}.{poi_name_value_filename}.lumi_{lumi_zfill}.MultiDimFit.mH126.root.{x}.png".format(**self.__dict__), \
#"{www_dir}/exp.{fs}.{poi_name_value_filename}.mH126.{x}.{lumi_zfill}ifb.png".format(**self.__dict__))
file_2_copy = "higgsCombine.asimov.{fs}.{poi_name_value_filename}.lumi_{lumi_zfill}.MultiDimFit.mH126.root.{x}.png".format(**self.__dict__)
if os.path.exists(file_2_copy):
shutil.copy(file_2_copy,"{www_dir}/exp.{fs}.{poi_name_value_filename}.mH126.{x}.{lumi_zfill}ifb.png".format(**self.__dict__))
print "{www_dir}/?match=exp.{fs}.{poi_name_value_filename}.mH126.*.png".format(**self.__dict__).replace("/afs/cern.ch/user/r/roko/www/html/","https://roko.web.cern.ch/roko/")
def get_table_row(self, col_names=False) :
if col_names:
return "LUMI BF UL68 UL95 WF\n".lower()
import lib.util.MiscTools as misc
limit_file = "higgsCombine.asimov.%(fs)s.%(poi_name_value_filename)s.lumi_%(lumi_zfill)s.MultiDimFit.mH126.root.limits" %self.__dict__
self.log.debug("Searching for limits info in file: {0}".format(limit_file))
BF = misc.grep("BF", limit_file)[0].split(":")[1].strip()
UL68 = misc.grep("UL68", limit_file)[0].split(":")[1].strip()
UL95 = misc.grep("UL95", limit_file)[0].split(":")[1].strip()
WF = misc.grep("WF", limit_file)[0].split(":")[1].strip()
table_raw = "{0} {1} {2} {3} {4}\n".format(self.lumi, BF, UL68,UL95, WF)
print "Table raw: ", table_raw
return table_raw
def set_lumi(self, lumi, n_digits=0) :
self.lumi = str(lumi)
self.lumi_zfill = self.lumi.zfill(n_digits)
def set_sqrts_dc(self, sqrts) : self.sqrts_dc = str(sqrts)
def set_sqrts_plot(self, sqrts) : self.sqrts_plot = str(sqrts)
def set_poi_value(self, poi_name, value) : self.poi[poi_name]['value']= str(value)
def get_webdir(self): return self.www_dir
def set_do_copy_to_webdir(self, do_copy=True): self.do_copy_to_webdir = do_copy
def get_sqrts_dc(self): return self.sqrts_dc
def get_fs(self): return self.fs
def get_cmd(self): return self.do_cmd
def get_poi_name_value(self) : return self.poi_name_value
def get_poi_name_value_filename(self) : return self.poi_name_value_filename
def get_run_data(self): return self.run_dict
def get_poi_name_value_filename(self) : return self.poi_name_value_filename
def get_run_data(self): return self.run_dict
if __name__ == "__main__":
"""
This script can create datacards, make toy datasets, fit and plt results.
Finally it is coping the relevalnt output to the web directory...
"""
# parse the arguments and options
global opt, args
parseOptions()
log = Logger().getLogger(__name__, 10)
#read configuration
import lib.util.UniversalConfigParser as ucp
cfg_reader = ucp.UniversalConfigParser(cfg_type="YAML",file_list = opt.config_filename)
cfg_reader.setLogLevel(10)
full_config = cfg_reader.get_dict()
run_data = full_config["COMMON"]
run_data.update(full_config[opt.run_data_name])
pp = pprint.PrettyPrinter(indent=4)
#pp.pprint(full_config)
print "@@@@ THE RUN DATA: YAML -> DICT"
pp.pprint(run_data)
if opt.print_config_and_exit:
quit()
def __init__(self):
self.log = Logger().getLogger(self.__class__.__name__, 10)
self.pp = pprint.PrettyPrinter(indent=4)
self.DEBUG = True
class RootHelperBase(object):
"""
Class that helps to pick any object from any root file
by specifiying the path to the object like:
path/to/root_file.root/path/to/root_object.
Class can also check for type of object and return TypeError
in case the object is not of a desired type.
"""
def __init__(self):
self.log = Logger().getLogger(self.__class__.__name__, 10)
self.pp = pprint.PrettyPrinter(indent=4)
self.DEBUG = True
def check_in_opened_files_table(self, file_name,access):
"""
Makes a check in the open_files_table dictionary and returns
pointer to the file if file is opened correct access mode.
Returns:
--------
tuple (is_opened, pointer_to_file).
In case file doesn't exist (is_opened=False,pointer_to_file=None)
"""
try:
self.open_files_table[file_name][access]
except KeyError:
self.log.debug('File {0} is not opened in {1} mode.'.format(file_name, access))
return (False, None)
else:
the_file = self.open_files_table[file_name][access]
if isinstance(the_file,TFile):
if (the_file.IsOpen() and not the_file.IsZombie()):
self.log.debug('File {0} is already opened in {1} mode. Return pointer to file.'.format(file_name, access))
return (True, the_file)
else:
self.log.debug('File {0} in {1} mode is either closed or zombie.'.format(file_name, access))
self.open_files_table[file_name][access] = None
return (False, None)
else:
self.log.debug('File {0} is not opened in {1} mode.'.format(file_name, access))
return (False, None)
def update_opened_files_table(self, file_object, access):
"""
Update the status of files opened.
file_name: acces : file_pointer structure.
"""
try:
self.open_files_table
except AttributeError:
#self.open_files_table = collections.OrderedDict()
self.open_files_table = {}
self.open_files_table[file_object.GetName()] = {access : file_object}
else:
try:
self.open_files_table[file_object.GetName()]
except KeyError:
self.open_files_table[file_object.GetName()] = {access : file_object}
else:
self.open_files_table[file_object.GetName()].update({access : file_object})
#self.open_files_table['dummy'].update({access : file_object})
#self.open_files_table[file_object.GetName()][access] = file_object
if self.DEBUG:
self.pp.pprint(self.open_files_table)
return 0
def TFile_safe_open(self, file_name, access = 'READ'):
"""
Safely open TFile object. Memory is saved by cheking if the file is already
open by looking up in the list open_files_table.
"""
#check if file is already openedby looking-up the opend files dict
is_opened=False
rootfile= None
try:
self.open_files_table
except AttributeError:
pass
else:
is_opened, rootfile = self.check_in_opened_files_table(file_name,access)
if is_opened:
self.log.debug('Returning pointer to ROOT file: {0}'.format(file_name))
return rootfile
self.log.debug('Opening ROOT file: {0}'.format(file_name))
if access.upper() == 'READ' and not os.path.exists(file_name):
raise IOError, 'File path does not exist: {0}'.format(file_name)
else:
base_dir = os.path.dirname(file_name)
misc.make_sure_path_exists(base_dir)
rootfile = TFile.Open(file_name,access)
self.update_opened_files_table(rootfile, access)
if not rootfile:
raise IOError, 'The file {0} either doesn\'t exist or cannot be open'.format(file_name)
return rootfile
def get_paths(self, path):
"""
Returns tuple (path_to_root_file, path_to_root_object_in_root_file)
"""
path_contains_file = ('.root' in path)
path_segments = path.split('.root')
if path.endswith('.root'): #only root file path exists
return (path,"")
#print path_segments
#assert 1<len(path_segments)<=2, 'Path should be in format <path/to/dir>root_object_file.root/path_to_root_object_in_file'
assert 0<len(path_segments)<=2, 'Path should be in format <path/to/dir>root_object_file.root/path_to_root_object_in_file'
path_to_file = ""
if len(path_segments)==2: #path contains file name and object path in the root file
path_to_file = path_segments[0]+'.root'
self.log.debug('Src root file: {0}'.format(path_to_file ))
#path_to_root_object = string.join(path_segments[-1].split('/')[1:],'/') #to remove the '/' after .root
if path_segments[-1].startswith('/'):
path_to_root_object = path_segments[-1][1:] #to remove the '/' after .root
else:
path_to_root_object = path_segments[-1] #there is no '/' at the beggining
self.log.debug('Src root_object name: {0}'.format(path_to_root_object))
return (path_to_file,path_to_root_object)
#path_to_file = path_segments[0]+'.root'
#self.log.debug('Src root file: {0}'.format(path_to_file ))
#path_to_root_object = string.join(path_segments[-1].split('/')[1:],'/') #to remove the '/' after .root
#self.log.debug('Src root_object name: {0}'.format(path_to_root_object))
#return (path_to_file,path_to_root_object)
def get_object(self, path, object_type=None, clone=False):
"""
Get any root object copy from path and check it's type.
The object is copied from the file if needed.
"""
path_to_file, path_to_root_object = self.get_paths(path)
root_object_file = self.TFile_safe_open(path_to_file, 'READ')
the_object = root_object_file.Get(path_to_root_object)
is_TTree = isinstance(the_object,TTree)
if clone:
if not is_TTree:
the_object = copy.deepcopy(root_object_file.Get(path_to_root_object))
self.log.debug('Coping root_object {0} of type={1}.'.format(path_to_root_object, type(the_object)))
root_object_file.Close()
else:
#FIXME
self.log.warn('Cloning the full tree {0}. !!! Still not fully tested !!!'.format(path_to_root_object))
the_object = root_object_file.Get(path_to_root_object).CloneTree()
#will not close file since it will destroy the object. Better to write the tree down first, then close file.
else:
self.log.debug('Pointer to root_object {0} of type={1} is returned.'.format(path_to_root_object, type(the_object)))
return the_object
def get_TTree(self,path , cut = None, clone = False):
"""
Get a tree from the path of format //machine/file_name.root/subdir/tree_name.
If path is list it will asume TChain. Wildcards can be used but ".root" has
to exost in the path name, otherwise 'segmentation violation'
"""
the_tree = TChain()
if isinstance(path, list):
tree_name = self.get_paths(path[0])[1]
the_tree.SetName(tree_name)
for item in path:
assert isinstance(item,str),'The tree path should be of string format and not: {0}'.format(type(item))
add_result = the_tree.Add(item)
elif isinstance(path, str):
tree_name = self.get_paths(path)[1]
the_tree.SetName(tree_name)
add_result = the_tree.Add(path)
self.log.debug('TChain has been constructed from {0} files with correct tree names.'.format(add_result))
if cut:
assert isinstance(cut, str), 'The TTree cut has to be string value, not {0} !!!'.format(type(cut))
clone = True
the_selection_tree = the_tree.CopyTree(cut)
return the_selection_tree
else:
return the_tree
def get_histogram(self,path, hist_type = TH1, clone = False):
"""
Get TH1 object or any other that inherits from TH1
"""
return self.get_object(path,hist_type, clone)
def get_embedded_object(self, path_to_container, container_type = None, embedded_object = None, object_type = None, clone = False):
"""
Get an object embedded into another class, like e.g. a TH1 from TCanvas
saved in file. In case only path_to_container is given, it will return the container
like with get_object method.
"""
pass
def add_to_basket(self,root_object, new_name = None, new_title = None):
"""
Add object to the basket with new_name and new_title.
If new_name contains "/" then a directory will be created inside the file. (TODO)
"""
if new_name:
#name_in_basket = new_name
new_name_no_subfolders = new_name.split('/')[-1] #remove subfolder name from the new_name
root_object.SetName(new_name_no_subfolders)
name_in_basket = new_name
else:
name_in_basket = root_object.GetName()
if new_title:
root_object.SetTitle(new_title)
try:
self.root_fruit_basket
except AttributeError:
self.root_fruit_basket = collections.OrderedDict()
self.log.debug('Creating new root-object basket.')
else:
if self.DEBUG and len(self.root_fruit_basket)<10:
self.log.debug('Adding root-object to existing basket. Basket state (printed if less then 10 items):')
self.pp.pprint(self.root_fruit_basket)
self.root_fruit_basket[name_in_basket] = root_object
def _get_subfolders_and_name(self,path):
"""
Gives back the 2 element tuple with subfolder path and a name of root_object
"""
path_segments = path.split('/')
assert len(path_segments)>0, 'The name should not be empty string.'
if len(path_segments) > 1:
#check if first is '/'
if path_segments[0]=='': path_segments.pop(0)
subfolders = string.join(path_segments[:-1],'/')
root_object_name = path_segments[-1]
self.log.debug('Root-subfolder: {0}'.format(subfolders))
self.log.debug('Root-object name: {0}'.format(root_object_name))
return (subfolders, root_object_name)
else:
root_object_name = path_segments[-1]
return (None, root_object_name)
def _get_directory(self,root_file, path):
"""
Create and cd to the directory if given like a/b/c
"""
root_file.cd()
#subfolders = self._get_subfolders_and_name(path)[0]
if path:
self.log.debug('Creating root-subfolder {0}'.format(path))
mkdir_res = root_file.mkdir(path)
self.log.info('Root-subfolder {0} created with code = {1}'.format(path, mkdir_res))
root_file.cd(path)
else: #no subfolder will be created
root_file.cd()
self.log.debug('Current directory: {0}'.format(gDirectory.GetPath()))
def flush_basket(self):
"""
Resets the basket content and delets the basket.
"""
try:
del self.root_fruit_basket
except:
raise RuntimeError, 'Basket cannot be flushed and destroyed! It even doesn\'t exist ...'
else:
self.log.info('Basket flushed!')
return 0
def dump_basket_to_file(self, file_name, access = 'UPDATE'):
"""
Save what is in basket to a file. Create directories in the path if needed.
"""
out_file = self.TFile_safe_open(file_name, access)
out_file.cd()
if self.DEBUG:
self.pp.pprint(self.root_fruit_basket)
for item_name in self.root_fruit_basket.keys():
subfolders, root_object_name = self._get_subfolders_and_name(item_name)
self._get_directory(out_file, subfolders) #it will create and cd to the directory if given like a/b/c
self.log.debug('Writing root-object: {0} Object name: {1} ; Object title: {2}'.format(self.root_fruit_basket[item_name],self.root_fruit_basket[item_name].GetName(),self.root_fruit_basket[item_name].GetTitle()))
is_TTree = isinstance(self.root_fruit_basket[item_name],TTree)
if is_TTree:
self.log.debug('This is a TTree object : {0}'.format(self.root_fruit_basket[item_name]))
copy_tree_name = self.root_fruit_basket[item_name].GetName()
copy_tree_title = self.root_fruit_basket[item_name].GetTitle()
tree_for_saving = self.root_fruit_basket[item_name].CloneTree(0)
copy_res = tree_for_saving.CopyEntries(self.root_fruit_basket[item_name])
tree_for_saving.SetNameTitle(copy_tree_name,copy_tree_title)
write_res = tree_for_saving.Write()
else:
write_res = self.root_fruit_basket[item_name].Write()
if write_res == 0 :
self.log.error('The object {0} cannot be written into {1}'.format(item_name, gDirectory.GetPath()))
else:
self.log.info('The object {0} has been written into {1}'.format(item_name, gDirectory.GetPath()))
out_file.Close()
self.log.info('Saved the basket with {1} items into the file: {0}'.format(file_name, len(self.root_fruit_basket)))
self.flush_basket()
return 0
def prepare_asimov_toy_datasets_for_sync():
#parseOptions()
DEBUG = False
if opt.verbosity!=10:
os.environ['PYTHON_LOGGER_VERBOSITY'] = str(opt.verbosity)
if opt.verbosity >=4:
DEBUG = True
#1) RooDataSet with all processes for one sqrts and final state
#- have RooCategory for sqrts and final state
#chan = [1_7, 2_7, 3_7, 1_8,2_8,3_8]
#cat.defineType(chan[j],j); j=0..6
#cat.setLabel(chan[j]);
#2) finally append all toys to same RooDataSet
log = Logger().getLogger("prepare_toy_datasets_for_sync", 10)
toy_manager = ToyDataSetManager()
#toy_manager.set_workspace_path(opt.ws_path)
#path_to_tree, tree_variables, weight = "1", dataset_name = "my_dataset"):
#shapes * ch1_ch1 hzz4l_4muS_7TeV.input.root w:$PROCESS
#shapes * ch1_ch2 hzz4l_4eS_7TeV.input.root w:$PROCESS
#shapes * ch1_ch3 hzz4l_2e2muS_7TeV.input.root w:$PROCESS
#shapes * ch2_ch1 hzz4l_4muS_8TeV.input.root w:$PROCESS
#shapes * ch2_ch2 hzz4l_4eS_8TeV.input.root w:$PROCESS
#shapes * ch2_ch3 hzz4l_2e2muS_8TeV.input.root w:$PROCESS
model = "trees_SM"
#model = "trees_Mix_fa2"
#model = "trees_Mix_fa3"
toys_dir = "/afs/cern.ch/user/r/roko/wd_datacards/CreateFullSimToys/{0}".format(model)
#Christoys:
#toys_dir = "/afs/cern.ch/work/c/chmartin/public/ForEmbedded/Final_v2/"
#chan_path_dict = {
#'ch1_ch1' : "{0}/Toys_CJLSTntuple_7TeV_4mu_*.root/SelectedTree".format(toys_dir),
#'ch1_ch2' : "{0}/Toys_CJLSTntuple_7TeV_4e_*.root/SelectedTree".format(toys_dir),
#'ch1_ch3' : "{0}/Toys_CJLSTntuple_7TeV_2e2mu_*.root/SelectedTree".format(toys_dir),
#'ch2_ch1' : "{0}/Toys_CJLSTntuple_8TeV_4mu_*.root/SelectedTree".format(toys_dir),
#'ch2_ch2' : "{0}/Toys_CJLSTntuple_8TeV_4e_*.root/SelectedTree".format(toys_dir),
#'ch2_ch3' : "{0}/Toys_CJLSTntuple_8TeV_2e2mu_*.root/SelectedTree".format(toys_dir)
#}
chan_path_dict = {
'ch1_ch1' : "{0}/DTree_7TeV_4mu_*.root/selectedEvents".format(toys_dir),
'ch1_ch2' : "{0}/DTree_7TeV_4e_*.root/selectedEvents".format(toys_dir),
'ch1_ch3' : "{0}/DTree_7TeV_2e2mu_*.root/selectedEvents".format(toys_dir),
'ch2_ch1' : "{0}/DTree_8TeV_4mu_*.root/selectedEvents".format(toys_dir),
'ch2_ch2' : "{0}/DTree_8TeV_4e_*.root/selectedEvents".format(toys_dir),
'ch2_ch3' : "{0}/DTree_8TeV_2e2mu_*.root/selectedEvents".format(toys_dir)
}
pp = pprint.PrettyPrinter(indent=4)
#if DEBUG:
#log.debug('Initial dictionary:')
#pp.pprint(chan_path_dict)
channel_name = sorted(chan_path_dict.keys())
cat = RooCategory("CMS_channel","CMS_channel")
for cat_idx, cat_name in enumerate( channel_name ):
cat.defineType(cat_name,cat_idx);
cat.setLabel(cat_name);
if DEBUG:
log.debug('Category : {0}'.format(cat_idx))
cat.Print('v')
my_vars = []
if ("fa3" in model) and ("fa2" in model):
my_vars = ['D_bkg','D_0m','D_cp', 'D_0hp','D_int','Weight','mass4l']
elif "fa3" in model:
my_vars = ['D_bkg','D_0m','D_cp','Weight','mass4l']
elif "fa2" in model:
my_vars = ['D_bkg', 'D_0hp','D_int','Weight','mass4l']
else:
my_vars = ['D_bkg','D_0m','D_cp', 'D_0hp','D_int','Weight','mass4l']
my_rrv = dict()
my_rrv['D_bkg'] = RooRealVar('D_bkg','D_bkg', 0,1.)
my_rrv['D_0m'] = RooRealVar('D_0m','D_0m', 0,1.)
my_rrv['D_cp'] = RooRealVar('D_cp','D_cp', -0.5,0.5)
my_rrv['D_0hp'] = RooRealVar('D_0hp','D_0hp', 0,1.)
my_rrv['D_int'] = RooRealVar('D_int','D_int', -0.2,1)
my_rrv['mass4l'] = RooRealVar('mass4l','mass4l', 100,1000.)
my_rrv['Weight'] = RooRealVar('Weight','Weight', 1.)
my_rrv['D_bkg'].setBins(5)
#my_rrv['D_bkg'].setBins(50)
my_rrv['D_0m'].setBins(50)
my_rrv['D_cp'].setBins(50)
my_rrv['D_0hp'].setBins(50)
my_rrv['D_int'].setBins(50)
my_arg_set = RooArgSet()
for var_name in my_vars:
#TODO implement check that branch exist
#my_rrv[var_name] = RooRealVar(var_name,var_name,-999999999,999999999)
my_arg_set.add(my_rrv[var_name])
my_arg_set.add(cat)
if DEBUG:
log.debug('RooArgSet is now:')
my_arg_set.Print('v')
if os.path.exists(opt.output_filename):
log.debug("Removing file: {0}".format(opt.output_filename))
os.remove(opt.output_filename)
import lib.RootHelpers.RootHelperBase as rhb
root_helper = rhb.RootHelperBase()
my_arg_set = RooArgSet()
for var_name in my_vars:
#TODO implement check that branch exist
#my_rrv[var_name] = RooRealVar(var_name,var_name,-999999999,999999999)
my_arg_set.add(my_rrv[var_name])
my_arg_set.add(cat)
if DEBUG:
log.debug('RooArgSet is now:')
my_arg_set.Print('v')
#import asimov dataset
for cat_idx, cat_name in enumerate( channel_name ):
my_path_to_tree = chan_path_dict[cat_name]
log.debug("my_path_to_tree: {0} ".format(my_path_to_tree ))
the_dataset = toy_manager.get_dataset_from_tree(path_to_tree = my_path_to_tree, tree_variables = my_vars,
weight="(mass4l<140.6&&mass4l>105.6)", dataset_name="toys/toy_asimov_v0_{0}".format(cat_idx), basket = False, weight_var_name = "Weight")
the_dataset_with_cat = RooDataSet("toys/toy_asimov_{0}".format(cat_idx),"toys/toy_asimov_{0}".format(cat_idx), my_arg_set, RooFit.Index(cat), RooFit.Import(cat_name,the_dataset), RooFit.WeightVar("Weight"))
log.debug('RooDataSet the_dataset_with_cat contains {0} events'.format(the_dataset_with_cat.sumEntries()))
the_dataset_with_cat.Print()
if cat_idx==0:
combined_dataset = the_dataset_with_cat
else:
combined_dataset.append(the_dataset_with_cat)
log.debug('RooDataSet combined_dataset contains {0} events'.format(combined_dataset.sumEntries()))
combined_dataset.Print()
combined_dataset.Print("v")
#combined_dataset.SetNameTitle("toys/embedded_asimov","toys/embedded_asimov")
#toy_manager.add_to_basket(combined_dataset)
toy_manager.add_to_basket(combined_dataset, new_name = "toys/embedded_asimov", new_title = "toys/embedded_asimov")
toy_manager.dump_datasets_to_file(opt.output_filename,'UPDATE') #this one can receive both
class RootPlottersBase(RootHelperBase):
"""Class as a base class for many plotters containing the structure, common functions...
"""
def __init__(self,name = "plotters_base_functionality" ):
self.log = Logger().getLogger(self.__class__.__name__, 10)
self.name = name
#ROOT.gSystem.AddIncludePath("-I$ROOFITSYS/include/");
#ROOT.gROOT.ProcessLine(".L tdrstyle.cc")
#from ROOT import setTDRStyle
#ROOT.setTDRStyle(True)
#ROOT.gStyle.SetPalette(1)
#ROOT.gStyle.SetOptStat(0)
self.copy_to_web_dir = False
self.webdir = ""
self.save_extensions = ['png','pdf','eps']
#self.pp = pprint.PrettyPrinter(indent=4)
def setName(self, newname): self.name = newname
def make_plot(self, data):
print "This is a default method for plotters. It has to be implemented in derived classes"
pass
def setCopyToWebDir(self,doCopy=False,webdir=""):
if doCopy:
self.copy_to_web_dir = True
if webdir:
self.webdir = webdir
else:
raise ValueError, "You have to provide a webdir path if you want to copy the files."
else:
self.copy_to_web_dir = False
self.webdir = ""
return 0
def get_webdir(self):
return self.webdir
def copy_index_html(self, full_path_dir):
"""
Walk to all subdirs and put index.php if not present.
"""
for root, dirs, files in os.walk(full_path_dir):
#print root
if not os.path.exists("{0}/index.php".format(root)) :
#shutil.copy("/afs/cern.ch/user/r/roko/www/html/index.php",root)
self.put_index_php_structure(root)
def doCopyToWebDir(self,file_name, newname=""):
if newname=="":
newname = file_name
if self.webdir :
full_path = self.webdir+"/"+newname
full_path_dir = os.path.dirname(full_path)
#misctools.make_sure_path_exists(self.webdir)
misctools.make_sure_path_exists(full_path_dir)
#if not os.path.exists("{0}/index.php".format(self.webdir)) :
self.copy_index_html(self.webdir)
if not os.path.exists("{0}/index.php".format(full_path_dir)) :
#shutil.copy("/afs/cern.ch/user/r/roko/www/html/index.php",full_path_dir)
self.put_index_php_structure(full_path_dir)
self.log.debug("Copying {0} to webdir {1}".format(file_name,full_path))
shutil.copy(file_name,full_path)
self.log.info("Copied {0} to webdir {1}".format(file_name,full_path))
else :
raise ValueError, "You have to provide a webdir path if you want to copy the files."
return 0
def save(self, canv, plot_name, extensions=['png','root']):
#extensions = ['.png','.pdf','.eps','.root']
if len(extensions)==0:
extensions=['']
for ext in extensions:
postfix = "."+ext
if ext=='':
postfix=''
canv.SaveAs(plot_name+postfix)
self.log.debug("Saving to: {0}.{1}".format(plot_name,ext))
if self.copy_to_web_dir :
self.doCopyToWebDir(plot_name+postfix)
def XtoNDC(self, x):
gPad.Update() #this is necessary!
return (x - gPad.GetX1())/(gPad.GetX2()-gPad.GetX1())
def YtoNDC(self, y):
gPad.Update() #this is necessary!
return (y - gPad.GetY1())/(gPad.GetY2()-gPad.GetY1())
def get_histDim(self,input_hist):
n_dim = None
if (isinstance(input_hist, TH3)): n_dim = 3
elif (isinstance(input_hist, TH2)): n_dim = 2
elif (isinstance(input_hist, TH1)): n_dim = 1
else:
raise TypeError, '[RootPlottersBase::get_histDim] The input to this function should be a histogram. Check your inputs!'
return n_dim
def put_index_php_structure(self, www_dir):
"""
Copies the structure of index.php file to the www_dir.
"""
index_php = """
<html>
<head>
<title><?php echo getcwd(); ?></title>
<style type='text/css'>
body {
font-family: "Candara", sans-serif;
font-size: 9pt;
line-height: 10.5pt;
}
div.pic h3 {
font-size: 11pt;
margin: 0.5em 1em 0.2em 1em;
}
div.pic p {
font-size: 11pt;
margin: 0.2em 1em 0.1em 1em;
}
div.pic {
display: block;
float: left;
background-color: white;
border: 1px solid #ccc;
padding: 2px;
text-align: center;
margin: 2px 10px 10px 2px;
-moz-box-shadow: 7px 5px 5px rgb(80,80,80); /* Firefox 3.5 */
-webkit-box-shadow: 7px 5px 5px rgb(80,80,80); /* Chrome, Safari */
box-shadow: 7px 5px 5px rgb(80,80,80); /* New browsers */
}
a { text-decoration: none; color: rgb(80,0,0); }
a:hover { text-decoration: underline; color: rgb(255,80,80); }
figure {
display: table;
width: 1px; /* This can be any width, so long as it's narrower than any image */
}
img, figcaption {
display: table-row;
}
</style>
</head>
<body>
<h4>© G. Petrucciani (CERN), R. Plestina (IHEP-CAS)</h4>
<?PHP
if (file_exists("title.txt")){
$page_title = file_get_contents("title.txt");
print "<h1>$page_title</h1>";
}
print "<h3>".getcwd()."</h3>";
if (file_exists("basic.info")){
print "<h2><a name='basic_info'>Basic information</a></h2>";
$file_handle = fopen("basic.info", "rb");
while (!feof($file_handle) ) {
$line_of_text = fgets($file_handle);
$parts = explode('=', $line_of_text);
print $parts[0] . $parts[1]. "<BR>";
}
fclose($file_handle);
}
?>
<h2><a name="plots">Plots</a></h2>
<p>
<form>Filter:
<input type="text" name="match" size="30" value="<?php if (isset($_GET['match'])) print htmlspecialchars($_GET['match']); ?>" /><input type="Submit" value="Search" />
</form>
</p>
<div>
<?PHP
// ____________________________________________________________________________________________________________
$displayed = array();
if ($_GET['noplots']) {
print "Plots will not be displayed.\n";
} else {
$other_exts = array('.pdf', '.cxx', '.eps', '.root', '.txt','.C','.gif');
$filenames = glob("*.png"); sort($filenames);
foreach ($filenames as $filename) {
if (isset($_GET['match']) && !fnmatch('*'.$_GET['match'].'*', $filename)) continue;
array_push($displayed, $filename);
print "<div class='pic'>\n";
print "<h3><a href=\"$filename\">$filename</a></h3>";
// print "<a href=\"$filename\"><img src=\"$filename\" style=\"border: none; width: 300px; \"></a>";
$others = array();
$caption_text = '';
foreach ($other_exts as $ex) {
$other_filename = str_replace('.png', $ex, $filename);
if (file_exists($other_filename)) {
// array_push($others, "<a class=\"file\" href=\"$other_filename\">[" . $ex . "]</a>");
if ($ex != '.txt') {
array_push($others, "<a class=\"file\" href=\"$other_filename\">[" . $ex . "]</a>");
array_push($displayed, $other_filename);
}
else {
$caption_text = file_get_contents($other_filename);
}
}
}
// print "<a href=\"$filename\"><figure><img src=\"$filename\" style=\"border: none; width: 300px; \"><figcaption>$caption_text</figcaption></figure></a>";
print "<figure><a href=\"$filename\"><img src=\"$filename\" style=\"border: none; width: 300px; \"></a><figcaption>$caption_text</figcaption></figure>";
if ($others) print "<p>View as ".implode(', ',$others)."</p>";
print "</div>";
}
}
// ____________________________________________________________________________________________________________
?>
</div>
<div style="display: block; clear:both;">
<h2><a name="files">Other</a></h2>
<ul>
<?PHP
// ____________________________________________________________________________________________________________
foreach (glob("*") as $filename) {
if ($_GET['noplots'] || !in_array($filename, $displayed)) {
if (isset($_GET['match']) && !fnmatch('*'.$_GET['match'].'*', $filename)) continue;
if ($filename=='index.php') continue;
if (is_dir($filename)) {
print "<b><li><a href=\"$filename\">$filename</a></li></b>";
} else {
print "<li><a href=\"$filename\">$filename</a></li>";
}
}
}
// ____________________________________________________________________________________________________________
?>
</ul>
</div>
</body>
</html>
"""
with open(www_dir+'/index.php','w') as f:
f.write(index_php)
class ToyDataSetManager(RootHelperBase):
def __init__(self):
"""Initialize whatever is needed"""
self.my_logger = Logger()
#self.log = Logger().getLogger(self.__class__.__name__, 10)
self.log = self.my_logger.getLogger(self.__class__.__name__, 10)
#}
self.DEBUG = self.my_logger.is_debug()
self.pp = pprint.PrettyPrinter(indent=4)
#initialize RooFit
gSystem.Load("libHiggsAnalysisCombinedLimit.so")
self.output_filename = 'worskapce_with_embedded_toys.root'
def set_toys_path(self, toys_path):
"""
Set the path for the toy dataset.There is aleays one active toy held in self.toys.
"""
self.toys_path = toys_path
self.toys = self.get_object(path=toys_path,
object_type=RooAbsData,
clone=False)
def set_workspace_path(self, ws_path):
"""
Set the path for the workspace where toys will be included.
There is only one workspace that can be active in the class.
"""
self.ws = self.get_object(path=ws_path,
object_type=RooWorkspace,
clone=False)
def set_output_file_name(self, output_filename):
"""
Set the name of the output root file.
"""
self.output_filename = output_filename
def set_new_toys_name(self, new_toys_name):
"""
Set name for toys in the workspace
"""
self.new_toys_name = new_toys_name
def import_toys_to_ws(self,
ws_path=None,
toys_path=None,
output_filename=None,
new_toys_name=None):
"""
Imports a given toys dataset (or multiple toys) into the workspace and dumps to new root file.
Parameters:
-----------
ws_path : path to exisitng workspace (string)
toys_path : path or list of paths to toys.TODO add regexp parsing to import matching toys.
output_filename : file name of the output workspace
new_toys_name : in case of one toy import, a new name can be set. In case of list, the name is set
to be the same as in the source file.
Returns:
--------
Returns 0 in case it goes trough without erorrs(?).
"""
#TODO set checks for the input provided
if ws_path:
self.set_workspace_path(ws_path)
if output_filename:
self.set_output_file_name(output_filename)
if new_toys_name:
self.set_new_toys_name(new_toys_name)
try:
self.ws
except AttributeError:
raise AttributeError, 'You need to provide workspace path.'
if toys_path:
toys_path_list = []
if isinstance(toys_path, list):
toys_path_list = toys_path
elif isinstance(toys_path, str):
toys_path_list = [toys_path]
for the_toy in toys_path_list:
self.set_toys_path(the_toy)
toys_name = self.get_paths(the_toy)[
-1] #just getthe name of toys object in the root file.
self.log.info(
'Setting toys name in workspace to: {0}'.format(toys_name))
self.set_new_toys_name(toys_name)
self.toys.SetName(self.new_toys_name)
getattr(self.ws, 'import')(self.toys)
self.log.info(
"Imported DataSet '{0}' into workspace '{1}'.".format(
self.toys.GetName(), self.ws.GetName()))
else:
try:
self.toys
except AttributeError:
raise AttributeError, 'You need to provide toys path.'
try:
self.new_toys_name
except AttributeError:
toys_name = self.get_paths(self.toys_path)[
-1] #just getthe name of toys object in the root file.
self.log.info(
'Setting toys name in workspace to: {0}'.format(toys_name))
self.set_new_toys_name(toys_name)
self.toys.SetName(self.new_toys_name)
getattr(self.ws, 'import')(self.toys)
self.log.info(
"Imported DataSet '{0}' into workspace '{1}'.".format(
self.toys.GetName(), self.ws.GetName()))
self.ws.data(self.toys.GetName()).Print()
self.ws.data(self.toys.GetName()).Print("v")
#write workspace
self.ws.writeToFile(self.output_filename)
self.log.info("Writing workspace '{0}' to file {1}".format(
self.ws.GetName(), self.output_filename))
return 0
def set_dataset_name(self, dataset_name):
"""
Set name of the dataset in workspace.
"""
self.dataset_name = dataset_name
def import_dataset_to_ws(self,
dataset,
workspace,
output_filename=None,
new_name=None):
"""
Import dataset to worspace workspace.
"""
if new_name:
dataset.SetName(new_name)
if output_filename:
self.set_output_file_name(output_filename)
self.log.info(
"Imported DataSet '{0}' into workspace '{1}' and written to file {2}."
.format(dataset.GetName(), workspace.GetName(),
self.output_filename))
pass
def set_workspace(self, workspace):
"""
Provide workspace from path naload it to self.ws or
provide directly workspace and load it to self.ws
"""
if isinstance(workspace, RooWorkspace):
self.ws = workspace
self.log.debug('Loaded in workspace {0}.'.format(
self.ws.GetName()))
elif isinstance(workspace, str):
self.set_workspace_path(self, workspace)
self.log.debug(
'Loaded in workspace {0} from path: '.format(workspace))
def dump_datasets_to_file(self, output_filename=None, access='RECREATE'):
"""
Write all datasets collected in the basket(RootHelperBase) to a file.
"""
if output_filename:
self.set_output_file_name(output_filename)
self.dump_basket_to_file(self.output_filename, access)
self.log.info(
'All items from the basket have been written to file: {0}'.format(
self.output_filename))
return 0
def get_dataset_from_tree(self,
path_to_tree,
tree_variables,
weight="1==1",
weight_var_name=0,
dataset_name="my_dataset",
basket=True,
category=None):
"""
Creates RooDataSet from a plain root tree given:
- variables name list
- weight expression. It works in the same way as TTree cut.
Returns:
--------
- RooDataSet
- also fills the basket with datasets (basket inhereted from RootHelperBase class)
TODO
----
- add implementation for category setting(check in prepare_toy_datasets_for_sync)
- check if adding toy dataset to each channel workspace individually behaves well
after combineCards.py.
"""
#make RooRelVars from tree_variables
my_arg_set = RooArgSet()
my_rrv = dict()
for var_name in tree_variables:
#TODO implement check that branch exist
my_rrv[var_name] = RooRealVar(var_name, var_name, -999999999,
999999999)
my_arg_set.add(my_rrv[var_name])
if self.DEBUG:
self.log.debug('RooArgSet is now:')
my_arg_set.Print()
#get the tree from path_to_tree
my_tree = self.get_TTree(path_to_tree, cut=weight)
self.log.debug('Selected tree contains {0} events'.format(
my_tree.GetEntries()))
#create RooDataSet and reduce tree if needed
#self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, weight).reduce(my_arg_set)
self.dataset_from_tree = RooDataSet(dataset_name, dataset_name,
my_tree, my_arg_set)
#self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, "", weight_var_name)
#data[j]=new RooDataSet(Form("data%d",j),Form("data%d",j),outTree,RooArgSet(rCMS_zz4l_widthKD,rCMS_zz4l_widthMass,rweightFit),"","_weight_");
self.log.debug('RooDataSet contains {0} events'.format(
self.dataset_from_tree.sumEntries()))
#.reduce(ROOT.RooArgSet(self.D0))
self.current_arg_set = my_arg_set
#add dataset to basket
if basket:
self.add_to_basket(self.dataset_from_tree,
new_name=dataset_name,
new_title=dataset_name)
return self.dataset_from_tree
def get_current_arg_set(self):
"""
Return last dataset setup used by get_dataset_from_tree().
"""
return self.current_arg_set
class ToyDataSetManager(RootHelperBase):
def __init__(self):
"""Initialize whatever is needed"""
self.my_logger = Logger()
#self.log = Logger().getLogger(self.__class__.__name__, 10)
self.log = self.my_logger.getLogger(self.__class__.__name__, 10)
#}
self.DEBUG = self.my_logger.is_debug()
self.pp = pprint.PrettyPrinter(indent=4)
#initialize RooFit
gSystem.Load("libHiggsAnalysisCombinedLimit.so")
self.output_filename = 'worskapce_with_embedded_toys.root'
def set_toys_path(self,toys_path):
"""
Set the path for the toy dataset.There is aleays one active toy held in self.toys.
"""
self.toys_path = toys_path
self.toys = self.get_object(path = toys_path, object_type = RooAbsData, clone=False)
def set_workspace_path(self,ws_path):
"""
Set the path for the workspace where toys will be included.
There is only one workspace that can be active in the class.
"""
self.ws = self.get_object(path = ws_path, object_type = RooWorkspace, clone=False)
def set_output_file_name(self,output_filename):
"""
Set the name of the output root file.
"""
self.output_filename = output_filename
def set_new_toys_name(self, new_toys_name):
"""
Set name for toys in the workspace
"""
self.new_toys_name = new_toys_name
def import_toys_to_ws(self, ws_path = None, toys_path = None, output_filename = None, new_toys_name = None):
"""
Imports a given toys dataset (or multiple toys) into the workspace and dumps to new root file.
Parameters:
-----------
ws_path : path to exisitng workspace (string)
toys_path : path or list of paths to toys.TODO add regexp parsing to import matching toys.
output_filename : file name of the output workspace
new_toys_name : in case of one toy import, a new name can be set. In case of list, the name is set
to be the same as in the source file.
Returns:
--------
Returns 0 in case it goes trough without erorrs(?).
"""
#TODO set checks for the input provided
if ws_path:
self.set_workspace_path(ws_path)
if output_filename:
self.set_output_file_name(output_filename)
if new_toys_name:
self.set_new_toys_name(new_toys_name)
try:
self.ws
except AttributeError:
raise AttributeError, 'You need to provide workspace path.'
if toys_path:
toys_path_list = []
if isinstance(toys_path,list):
toys_path_list = toys_path
elif isinstance(toys_path,str):
toys_path_list = [toys_path]
for the_toy in toys_path_list:
self.set_toys_path(the_toy)
toys_name = self.get_paths(the_toy)[-1] #just getthe name of toys object in the root file.
self.log.info('Setting toys name in workspace to: {0}'.format(toys_name))
self.set_new_toys_name(toys_name)
self.toys.SetName(self.new_toys_name)
getattr(self.ws,'import')(self.toys)
self.log.info("Imported DataSet '{0}' into workspace '{1}'.".format(self.toys.GetName(), self.ws.GetName()))
else:
try:
self.toys
except AttributeError:
raise AttributeError, 'You need to provide toys path.'
try:
self.new_toys_name
except AttributeError:
toys_name = self.get_paths(self.toys_path)[-1] #just getthe name of toys object in the root file.
self.log.info('Setting toys name in workspace to: {0}'.format(toys_name))
self.set_new_toys_name(toys_name)
self.toys.SetName(self.new_toys_name)
getattr(self.ws,'import')(self.toys)
self.log.info("Imported DataSet '{0}' into workspace '{1}'.".format(self.toys.GetName(), self.ws.GetName()))
self.ws.data(self.toys.GetName()).Print()
self.ws.data(self.toys.GetName()).Print("v")
#write workspace
self.ws.writeToFile(self.output_filename)
self.log.info("Writing workspace '{0}' to file {1}".format(self.ws.GetName(), self.output_filename))
return 0
def set_dataset_name(self, dataset_name):
"""
Set name of the dataset in workspace.
"""
self.dataset_name = dataset_name
def import_dataset_to_ws(self, dataset, workspace, output_filename = None, new_name = None):
"""
Import dataset to worspace workspace.
"""
if new_name:
dataset.SetName(new_name)
if output_filename:
self.set_output_file_name(output_filename)
self.log.info("Imported DataSet '{0}' into workspace '{1}' and written to file {2}.".format(dataset.GetName(), workspace.GetName(), self.output_filename))
pass
def set_workspace(self,workspace):
"""
Provide workspace from path naload it to self.ws or
provide directly workspace and load it to self.ws
"""
if isinstance(workspace,RooWorkspace):
self.ws = workspace
self.log.debug('Loaded in workspace {0}.'.format(self.ws.GetName()))
elif isinstance(workspace,str):
self.set_workspace_path(self,workspace)
self.log.debug('Loaded in workspace {0} from path: '.format(workspace))
def dump_datasets_to_file(self,output_filename = None, access='RECREATE'):
"""
Write all datasets collected in the basket(RootHelperBase) to a file.
"""
if output_filename:
self.set_output_file_name(output_filename)
self.dump_basket_to_file(self.output_filename, access)
self.log.info('All items from the basket have been written to file: {0}'.format(self.output_filename))
return 0
def get_dataset_from_tree(self,path_to_tree, tree_variables, weight = "1==1", weight_var_name=0, dataset_name = "my_dataset", basket=True, category = None):
"""
Creates RooDataSet from a plain root tree given:
- variables name list
- weight expression. It works in the same way as TTree cut.
Returns:
--------
- RooDataSet
- also fills the basket with datasets (basket inhereted from RootHelperBase class)
TODO
----
- add implementation for category setting(check in prepare_toy_datasets_for_sync)
- check if adding toy dataset to each channel workspace individually behaves well
after combineCards.py.
"""
#make RooRelVars from tree_variables
my_arg_set = RooArgSet()
my_rrv = dict()
for var_name in tree_variables:
#TODO implement check that branch exist
my_rrv[var_name] = RooRealVar(var_name,var_name,-999999999,999999999)
my_arg_set.add(my_rrv[var_name])
if self.DEBUG:
self.log.debug('RooArgSet is now:')
my_arg_set.Print()
#get the tree from path_to_tree
my_tree = self.get_TTree(path_to_tree, cut = weight)
self.log.debug('Selected tree contains {0} events'.format(my_tree.GetEntries()))
#create RooDataSet and reduce tree if needed
#self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, weight).reduce(my_arg_set)
self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set)
#self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, "", weight_var_name)
#data[j]=new RooDataSet(Form("data%d",j),Form("data%d",j),outTree,RooArgSet(rCMS_zz4l_widthKD,rCMS_zz4l_widthMass,rweightFit),"","_weight_");
self.log.debug('RooDataSet contains {0} events'.format(self.dataset_from_tree.sumEntries()))
#.reduce(ROOT.RooArgSet(self.D0))
self.current_arg_set = my_arg_set
#add dataset to basket
if basket:
self.add_to_basket(self.dataset_from_tree, new_name = dataset_name, new_title = dataset_name)
return self.dataset_from_tree
def get_current_arg_set(self):
"""
Return last dataset setup used by get_dataset_from_tree().
"""
return self.current_arg_set
def __init__(self):
self.log = Logger().getLogger(self.__class__.__name__, 10)
self.pp = pprint.PrettyPrinter(indent=4)
self.DEBUG = True
class TotalPdfPlotter(PlotPolisher, RootPlottersBase):
"""Plots PDF from input templates without using nusance.
This is because, sometimes it happens that the templates
are negative for some values of parameter. In that case
the RooFit gives errors.
"""
def __init__(self,name = "templates" ):
self.log = Logger().getLogger(self.__class__.__name__, 10)
self.name = name
#ROOT.gSystem.AddIncludePath("-I$ROOFITSYS/include/");
ROOT.gROOT.ProcessLine(".L tdrstyle.cc")
from ROOT import setTDRStyle
ROOT.setTDRStyle(True)
ROOT.gStyle.SetPalette(1)
ROOT.gStyle.SetOptStat(0)
self.copy_to_web_dir = False
self.webdir = ""
self.pp = pprint.PrettyPrinter(indent=4)
self.k2k1_ratio=0
self.k3k1_ratio=0
self.total_pdf=0
def set_k2k1_and_k3k1(self, k2k1, k3k1):
self.k2k1_ratio = k2k1
self.k3k1_ratio = k3k1
def get_scale_factors(self):
factors = {'lambda12_cosP' : 0.0,
'lambda13_cosP' : 0.0,
'lambda23_cosN' : 0.0,
'lambda23_cosP' : 0.0,
'gamma33' : 0.034,
'gamma13' : 0.0,
'gamma12' : -0.290992,
'gamma11' : 1.0,
'lambda13_cosN' : 0.0,
'lambda12_sinN' : 0.0,
'lambda12_cosN' : 0.581984,
'gamma22' : 0.09,
'gamma23' : 0.0,
}
nominator={
'ggH_shape' : '{0}'.format(factors['gamma11']),
'gg0Ph_shape' : '{0}*{1}*{1}'.format(factors['gamma22'],self.k2k1_ratio), # @0 = k2k1_ratio
'gg0M_shape' : '{0}*{1}*{1}'.format(factors['gamma33'],self.k3k1_ratio), # @1 = k3k1_ratio
'ggInt_12P_shape': '{0}*{1}'.format(factors['lambda12_cosP'],self.k2k1_ratio),
'ggInt_12N_shape': '{0}*{1}*(-1)'.format(factors['lambda12_cosN'],self.k2k1_ratio),
'ggInt_13P_shape': '{0}*{1}'.format(factors['lambda13_cosP'],self.k3k1_ratio),
'ggInt_13N_shape': '{0}*{1}*(-1)'.format(factors['lambda13_cosN'],self.k3k1_ratio),
'ggInt_23P_shape': '{0}*{1}*{2}'.format(factors['lambda23_cosP'],self.k2k1_ratio,self.k3k1_ratio),
'ggInt_23N_shape':'{0}*{1}*{2}*(-1)'.format(factors['lambda23_cosN'],self.k2k1_ratio,self.k3k1_ratio)
}
denominator = "1"
#denominator_geoloc = "({0}+{1}*@0*@0+{2}*@1*@1+2*(({3}*@0)+({4}*@1)+({5}*@0*@1)))" ### added factor 2 for mixed terms
##denominator = denominator_geoloc.format(factors['gamma11'],factors['gamma22'],factors['gamma33'],
##factors['gamma12'],factors['gamma13'],factors['gamma23'])
#denominator = "{0}+{1}+{2}".format(_getDenominatorSegment(1,denominator_geoloc),_getDenominatorSegment(2,denominator_geoloc),_getDenominatorSegment(3,denominator_geoloc))
#denominator = "0.354301097432*(1.0+0.0*@0*@0+0.034*@1*@1+(0.0*@0)+(0.0*@1)+(0.0*@0*@1))
#+0.184149324322*(1.0+0.0*@0*@0+0.034*@1*@1+(0.0*@0)+(0.0*@1)+(0.0*@0*@1))
#+0.461549578246*(1.0+0.0*@0*@0+0.040*@1*@1+(0.0*@0)+(0.0*@1)+(0.0*@0*@1))"
norm={}
for nom in nominator.keys():
norm[nom] = eval("({0})/({1})".format(nominator[nom], denominator))
self.log.debug('Norm for {0} = {1}'.format(nom, norm[nom]))
return norm
def make_animated_gif(self, list_for_animated_gif, name_animated_gif, delay=100, loop=True):
#import lib.util.MiscTools as misctools
try:
delay = int(delay)
except ValueError:
raise ValueError, "Delay must be an integer."
loop_string = ""
if loop:
loop_string = " -loop 0"
self.log.info('Creating animated gif: {0}'.format(name_animated_gif))
misctools.processCmd("convert -delay {2} {0}{3} {1} ".format(" ".join("%s"%(one_gif) for one_gif in list_for_animated_gif), name_animated_gif, delay, loop_string))
self.doCopyToWebDir(name_animated_gif)
def makePlot(self, data):
#self.c_big = ROOT.TCanvas("c_big","Template Components",1200,1200)
#self.c_big.Divide(len())
self.c1 =ROOT.TCanvas("cc1","Templates",1000,800)
#pdf_components = {}
self.c1.cd()
ROOT.gPad.SetRightMargin(0.2)
try:
data['content']
except KeyError:
raise KeyError, "Canvas \'content\' dictionary is not provided in config file."
try:
data['setup']
except:
print "@@@@ Canvas \'setup\' dictionary is not provided. "
self.setup_exist=False
else:
self.arrangeCanvas(self.c1, data['setup'])
self.setup_exist=True
try:
self.leg
except AttributeError:
self.leg_exist=False
else:
self.leg_exist=True
print data['setup']['add_text']
try:
data['setup']['add_text']
except KeyError:
self.add_text_exist=False
else:
self.add_text_exist=True
i=0
for plot in data['content']:
list_for_animated_gif=[]
list_for_animated_gif_components=[]
try:
plot['POI']
except KeyError:
raise KeyError, "You chould provide POI dictionary with values in your confguration."
else:
self.plot_total_pdf=True
if isinstance(plot['POI'], dict):
if "k2k1_ratio" in plot['POI'].keys():
k2k1_list = list(plot['POI']['k2k1_ratio'])
self.log.debug('k2k1_list = {0}'.format(", ".join([str(k) for k in k2k1_list])))
if "k3k1_ratio" in plot['POI'].keys():
k3k1_list = list(plot['POI']['k3k1_ratio'])
self.log.debug('k3k1_list = {0}'.format(", ".join([str(k) for k in k3k1_list])))
for k2k1 in k2k1_list:
for k3k1 in k3k1_list:
self.set_k2k1_and_k3k1(k2k1, k3k1)
self.log.debug('Seting parameters to k2k1 = {0} and k3k1 = {1}'.format(self.k2k1_ratio,self.k3k1_ratio) )
n_components = len(plot['histos'])+1 #we include the total pdf into computation
self.c_big = ROOT.TCanvas("c_big","Template Components",int(500*n_components),400)
#self.c_big = ROOT.TCanvas("c_big","Template Components",1600,800)
self.c_big.Divide(n_components,1)
self.log.debug("Canvas is divided to N = {0}".format(n_components))
pdf_components = cols.OrderedDict()
pdf_components_minmax = cols.OrderedDict()
#pdf_components_order = []
for fs in data['setup']['final_states']:
print 200*"_"
theTemplFile = plot['file']+"_"+fs+".root"
if DEBUG:
pp.pprint(plot)
f = TFile(theTemplFile,"READ")
self.log.debug("Running on file: {0}".format(theTemplFile))
norm= self.get_scale_factors()
for i_pdf in range(len(plot['histos'])):
if i_pdf==0:
total_pdf = f.Get(plot['histos'][i_pdf])
total_pdf.Scale(norm[plot['histos'][i_pdf]])
pdf_components[plot['histos'][i_pdf]] = copy.deepcopy(total_pdf)
self.log.debug('TOTAL_PDF -> Picking up the first term {0} and the scale {1}. The histo is TH2: {2}'.format(plot['histos'][i_pdf], norm[plot['histos'][i_pdf]], isinstance(total_pdf,TH2)))
#pdf_components_order.append(plot['histos'][i_pdf])
another_template = f.Get(plot['histos'][i_pdf])
another_template.Scale(float(norm[plot['histos'][i_pdf]]))
pdf_components[plot['histos'][i_pdf]] = copy.deepcopy(another_template)
#pdf_components_order.append(plot['histos'][i_pdf])
self.log.debug('TOTAL_PDF -> Adding up term {0} and the scale {1} to histo TH2:{2}'.format(plot['histos'][i_pdf], norm[plot['histos'][i_pdf]],isinstance(total_pdf,TH2)))
total_pdf.Add(another_template)
self.total_pdf = total_pdf
self.log.debug('TOTAL_PDF -> Added all terms and now the histo is TH2:{0}'.format(isinstance(self.total_pdf,TH2)))
bins_x, bins_y = self.total_pdf.GetXaxis().GetNbins(), self.total_pdf.GetYaxis().GetNbins()
self.log.debug('Size of template (x,y) = ({0},{1})'.format(bins_x, bins_y))
pdf_components["TotalPDF"] = copy.deepcopy(self.total_pdf)
for x_bin in range(1,bins_x+1):
for y_bin in range(1,bins_y+1):
bin_content = self.total_pdf.GetBinContent(x_bin, y_bin)
#self.log.debug("Bin (i,j) = {0},{1} value = {2}".format(x_bin,y_bin, bin_content))
if bin_content <= 0:
raise ValueError, "!!! PDF CANNOT BE 0 or NEGATIVE !!!"
assert bin_content > 0, "!!! PDF CANNOT BE 0 or NEGATIVE !!! Check your tamplates. Bin (i,j) = {0},{1} value = {2}".format(x_bin,y_bin, bin_content)
### settup for the plot: text, legend and save
self.c1.cd()
if self.setup_exist:
self.arrangeAxis(self.total_pdf,data['setup'])
if self.leg_exist:
self.leg.AddEntry(self.total_pdf,plot['legend']['text'],plot['legend']['opt']);
try:
plot['draw_opt']
except KeyError:
draw_opt = "COLZ"
else:
draw_opt = str(plot['draw_opt'])
if draw_opt.lower()=="surf":
self.c1.SetTheta(16.56)
self.c1.SetPhi(57.83133)
self.total_pdf.SetMaximum(0.033)
self.total_pdf.SetMinimum(-0.005)
self.total_pdf.Draw(draw_opt)
if self.leg_exist: self.leg.Draw()
if self.add_text_exist:
data['setup']['add_text'][0]['text'] = "Total PDF(X,Y), {0}, GEN level, 8TeV".format(fs)
data['setup']['add_text'][0]['text']+=", k2/k1 ={0: >6.2f}, k3/k1 ={1: >6.2f}".format(self.k2k1_ratio,self.k3k1_ratio)
self.add_text(data['setup']['add_text'])
### saving the plot and copyng to webdir(if configured)
plot_name = "TotalPdf_{0}_{1}_k2k1_{2}_k3k1_{3}".format(theTemplFile.replace("/","_"), draw_opt,self.k2k1_ratio,self.k3k1_ratio)
#plot_name = self.name
self.save_extensions = ['png','pdf','eps', 'gif']
try:
data['setup']['save_ext']
except KeyError:
self.log.info("No extensions are provided in setup. Using default: ", self.save_extensions)
else:
self.save_extensions = list(data['setup']['save_ext'])
self.save(self.c1, plot_name, self.save_extensions)
list_for_animated_gif.append(plot_name+".gif")
#### Plot in the same canvas
i_div = 1
print "COMPONENTS :", pdf_components.keys()
for comp in pdf_components.keys():
self.c_big.cd(i_div)
ROOT.gPad.SetRightMargin(0.2)
ROOT.gPad.SetLeftMargin(0.1)
i_div+=1
### settup for the plot: text, legend and save
if self.setup_exist:
self.arrangeAxis(pdf_components[comp],data['setup'])
if self.leg_exist:
self.leg.AddEntry(pdf_components[comp],plot['legend']['text'],plot['legend']['opt']);
try:
plot['draw_opt']
except KeyError:
draw_opt = "COLZ"
else:
draw_opt = str(plot['draw_opt'])
if draw_opt.lower()=="surf":
self.c_big.SetTheta(16.56)
self.c_big.SetPhi(57.83133)
pdf_components[comp].SetMaximum(0.033)
pdf_components[comp].SetMinimum(-0.033)
pdf_components[comp].GetYaxis().SetTitleOffset(0.7)
if (i_div-1)>1:
pdf_components[comp].GetYaxis().SetLabelOffset(999)
pdf_components[comp].GetYaxis().SetLabelSize(0)
pdf_components[comp].GetYaxis().SetTitle("")
pdf_components[comp].Draw(draw_opt)
if self.leg_exist: self.leg.Draw()
if self.add_text_exist:
data['setup']['add_text'][0]['text'] = "{1}(X,Y), {0}, GEN level, 8TeV".format(fs,comp )
data['setup']['add_text'][0]['text']+=", k2/k1 ={0: >6.2f}, k3/k1 ={1: >6.2f}".format(self.k2k1_ratio,self.k3k1_ratio)
self.add_text(data['setup']['add_text'])
### saving the plot and copyng to webdir(if configured)
plot_name = "TotalPdfComponents_{0}_{1}_k2k1_{2}_k3k1_{3}".format(theTemplFile.replace("/","_"), draw_opt,self.k2k1_ratio,self.k3k1_ratio)
#plot_name = self.name
self.save_extensions = ['png','pdf','eps', 'gif']
try:
data['setup']['save_ext']
except KeyError:
self.log.info("No extensions are provided in setup. Using default: ", self.save_extensions)
else:
self.save_extensions = list(data['setup']['save_ext'])
self.save(self.c_big, plot_name, self.save_extensions)
list_for_animated_gif_components.append(plot_name+".gif")
name_animated_gif = "TotalPdf_{0}_{1}_ANIMATED_k2k1_{2}_k3k1_{3}.gif".format(theTemplFile.replace("/","_"),draw_opt,"_".join("{0}".format(one_k2k1) for one_k2k1 in k2k1_list), "_".join("{0}".format(one_k3k1) for one_k3k1 in k3k1_list))
self.make_animated_gif(list_for_animated_gif, name_animated_gif)
name_animated_gif = "TotalPdfComponents_{0}_{1}_ANIMATED_k2k1_{2}_k3k1_{3}.gif".format(theTemplFile.replace("/","_"),draw_opt,"_".join("{0}".format(one_k2k1) for one_k2k1 in k2k1_list), "_".join("{0}".format(one_k3k1) for one_k3k1 in k3k1_list))
self.make_animated_gif(list_for_animated_gif_components, name_animated_gif)
