def call_systematics(args,
result=sys.stdout,
running=True,
log=lambda x: sys.stdout.write(str(x) + '\n')):
"""calling systematics from a list of arguments"""
input, output = args[0:2]
start_opts = 2
if output and output.startswith('-'):
start_opts = 1
output = input
opts = {}
for arg in args[start_opts:]:
if '=' in arg:
key, values = arg.split('=')
key = key.replace('-', '')
values = values.strip()
if values[0] in ["'", '"'] and values[-1] == values[0]:
values = values[1:-1]
values = values.split(',')
if key == 'together':
if key in opts:
opts[key].append(tuple(values))
else:
opts[key] = [tuple(values)]
elif key == 'result':
result = open(values[0], 'w')
elif key in ['start_event', 'stop_event', 'only_beam']:
opts[key] = banner_mod.ConfigFile.format_variable(
values[0], int, key)
elif key in ['write_banner', 'ion_scalling']:
opts[key] = banner_mod.ConfigFile.format_variable(
values[0], bool, key)
else:
if key in opts:
opts[key] += values
else:
opts[key] = values
else:
raise SystematicsError, "unknow argument %s" % arg
#load run_card and extract parameter if needed.
if 'from_card' in opts:
if opts['from_card'] != ['internal']:
card = banner.RunCard(opts['from_card'][0])
else:
for i in range(10):
try:
lhe = lhe_parser.EventFile(input)
break
except OSError, error:
print error
time.sleep(15 * (i + 1))
else:
raise
card = banner.RunCard(banner.Banner(lhe.banner)['mgruncard'])
lhe.close()
def __init__(
self,
input_file,
output_file,
start_event=0,
stop_event=sys.maxint,
write_banner=False,
mur=[0.5, 1, 2],
muf=[0.5, 1, 2],
alps=[1],
pdf='errorset', #[(id, subset)]
dyn=[-1, 1, 2, 3, 4],
together=[('mur', 'muf', 'dyn')],
remove_wgts=[],
keep_wgts=[],
start_id=None,
lhapdf_config=misc.which('lhapdf-config'),
log=lambda x: sys.stdout.write(str(x) + '\n')):
# INPUT/OUTPUT FILE
if isinstance(input_file, str):
self.input = lhe_parser.EventFile(input_file)
else:
self.input = input_file
self.output_path = output_file
if output_file != None:
if isinstance(output_file, str):
if output_file == input_file:
directory, name = os.path.split(output_file)
new_name = pjoin(directory, '.tmp_' + name)
self.output = lhe_parser.EventFile(new_name, 'w')
else:
self.output = lhe_parser.EventFile(output_file, 'w')
else:
self.output = output_file
self.log = log
#get some information from the run_card.
self.banner = banner_mod.Banner(self.input.banner)
self.force_write_banner = bool(write_banner)
self.orig_dyn = self.banner.get('run_card', 'dynamical_scale_choice')
self.orig_pdf = self.banner.run_card.get_lhapdf_id()
matching_mode = self.banner.get('run_card', 'ickkw')
#check for beam
beam1, beam2 = self.banner.get_pdg_beam()
if abs(beam1) != 2212 and abs(beam2) != 2212:
self.b1 = 0
self.b2 = 0
pdf = 'central'
#raise SystematicsError, 'can only reweight proton beam'
elif abs(beam1) != 2212:
self.b1 = 0
self.b2 = beam2 // 2212
elif abs(beam2) != 2212:
self.b1 = beam1 // 2212
self.b2 = 0
else:
self.b1 = beam1 // 2212
self.b2 = beam2 // 2212
if isinstance(self.banner.run_card, banner_mod.RunCardLO):
self.is_lo = True
if not self.banner.run_card['use_syst']:
raise SystematicsError, 'The events have not been generated with use_syst=True. Cannot evaluate systematics error on these events.'
else:
self.is_lo = False
if not self.banner.run_card['store_rwgt_info']:
raise SystematicsError, 'The events have not been generated with store_rwgt_info=True. Cannot evaluate systematics error on these events.'
# MUR/MUF/ALPS PARSING
if isinstance(mur, str):
mur = mur.split(',')
self.mur = [float(i) for i in mur]
if isinstance(muf, str):
muf = muf.split(',')
self.muf = [float(i) for i in muf]
if isinstance(alps, str):
alps = alps.split(',')
self.alps = [float(i) for i in alps]
# DYNAMICAL SCALE PARSING + together
if isinstance(dyn, str):
dyn = dyn.split(',')
self.dyn = [int(i) for i in dyn]
# For FxFx only mode -1 makes sense
if matching_mode == 3:
self.dyn = [-1]
# avoid sqrts at NLO if ISR is possible
if 4 in self.dyn and self.b1 and self.b2 and not self.is_lo:
self.dyn.remove(4)
if isinstance(together, str):
self.together = together.split(',')
else:
self.together = together
# START/STOP EVENT
self.start_event = int(start_event)
self.stop_event = int(stop_event)
if start_event != 0:
self.log("#starting from event #%s" % start_event)
if stop_event != sys.maxint:
self.log("#stopping at event #%s" % stop_event)
# LHAPDF set
if isinstance(lhapdf_config, list):
lhapdf_config = lhapdf_config[0]
lhapdf = misc.import_python_lhapdf(lhapdf_config)
if not lhapdf:
log('fail to load lhapdf: doe not perform systematics')
return
lhapdf.setVerbosity(0)
self.pdfsets = {}
if isinstance(pdf, str):
pdf = pdf.split(',')
if isinstance(pdf, list) and isinstance(pdf[0], (str, int)):
self.pdf = []
for data in pdf:
if data == 'errorset':
data = '%s' % self.orig_pdf
if data == 'central':
data = '%s@0' % self.orig_pdf
if '@' in data:
#one particular dataset
name, arg = data.rsplit('@', 1)
if int(arg) == 0:
if name.isdigit():
self.pdf.append(lhapdf.mkPDF(int(name)))
else:
self.pdf.append(lhapdf.mkPDF(name))
elif name.isdigit():
try:
self.pdf.append(lhapdf.mkPDF(int(name) + int(arg)))
except:
raise Exception, 'Individual error sets need to be called with LHAPDF NAME not with LHAGLUE NUMBER'
else:
self.pdf.append(lhapdf.mkPDF(name, int(arg)))
else:
if data.isdigit():
pdfset = lhapdf.mkPDF(int(data)).set()
else:
pdfset = lhapdf.mkPDF(data).set()
self.pdfsets[pdfset.lhapdfID] = pdfset
self.pdf += pdfset.mkPDFs()
else:
self.pdf = pdf
for p in self.pdf:
if p.lhapdfID == self.orig_pdf:
self.orig_pdf = p
break
else:
self.orig_pdf = lhapdf.mkPDF(self.orig_pdf)
if not self.b1 == 0 == self.b2:
self.log("# events generated with PDF: %s (%s)" %
(self.orig_pdf.set().name, self.orig_pdf.lhapdfID))
# create all the function that need to be called
self.get_all_fct() # define self.fcts and self.args
# For e+/e- type of collision initialise the running of alps
if self.b1 == 0 == self.b2:
try:
from models.model_reader import Alphas_Runner
except ImportError:
root_path = pjoin(root, os.pardir, os.pardir)
try:
import internal.madevent_interface as me_int
cmd = me_int.MadEventCmd(root_path, force_run=True)
except ImportError:
import internal.amcnlo_run_interface as me_int
cmd = me_int.Cmd(root_path, force_run=True)
if 'mg5_path' in cmd.options and cmd.options['mg5_path']:
sys.path.append(cmd.options['mg5_path'])
from models.model_reader import Alphas_Runner
if not hasattr(self.banner, 'param_card'):
param_card = self.banner.charge_card('param_card')
else:
param_card = self.banner.param_card
asmz = param_card.get_value('sminputs', 3, 0.13)
nloop = 2
zmass = param_card.get_value('mass', 23, 91.188)
cmass = param_card.get_value('mass', 4, 1.4)
if cmass == 0:
cmass = 1.4
bmass = param_card.get_value('mass', 5, 4.7)
if bmass == 0:
bmass = 4.7
self.alpsrunner = Alphas_Runner(asmz, nloop, zmass, cmass, bmass)
# Store which weight to keep/removed
self.remove_wgts = []
for id in remove_wgts:
if id == 'all':
self.remove_wgts = ['all']
break
elif ',' in id:
min_value, max_value = [int(v) for v in id.split(',')]
self.remove_wgts += [
i for i in range(min_value, max_value + 1)
]
else:
self.remove_wgts.append(id)
self.keep_wgts = []
for id in keep_wgts:
if id == 'all':
self.keep_wgts = ['all']
break
elif ',' in id:
min_value, max_value = [int(v) for v in id.split(',')]
self.remove_wgts += [
i for i in range(min_value, max_value + 1)
]
else:
self.remove_wgts.append(id)
# input to start the id in the weight
self.start_wgt_id = int(start_id[0]) if (start_id
is not None) else None
self.has_wgts_pattern = False # tag to check if the pattern for removing
def convertFile(input_dm_file,
output_root_file='rootfile_dm.root',
input_hadrons_file=None):
'''Convert outputs of MadDump in LHE files format to
ROOT files, hadronizing on the way. The input file should
conatain DIS in name is case of DIS scattering.'''
ESevent = True if "ES" in input_dm_file else False
DISevent = True if "DIS" in input_dm_file else False
assert ESevent != DISevent, "Both flags are {}".format(ESevent)
assert DISevent == (input_hadrons_file is not None),\
"DIS is {0} but hadron_file is {1}".format(DISevent, input_hadrons_file)
lhe = lhe_parser.EventFile(input_dm_file)
rootfile_dm = ROOT.TFile(output_root_file, "recreate")
tree_dm = ROOT.TTree("dmtree", "dmtree")
Edm = array('d', [0])
pxdm = array('d', [0])
pydm = array('d', [0])
pzdm = array('d', [0])
dmpdg = array('i', [0])
dis = array('i', [0])
el = array('i', [0])
E_2ry = array('d', [0] * 500)
px_2ry = array('d', [0] * 500)
py_2ry = array('d', [0] * 500)
pz_2ry = array('d', [0] * 500)
pdg_2ry = array('i', [0] * 500)
n_2ry = array('i', [0])
tree_dm.Branch('Edm', Edm, 'Edm,/D')
tree_dm.Branch('pxdm', pxdm, 'pxdm,/D')
tree_dm.Branch('pydm', pydm, 'pydm,/D')
tree_dm.Branch('pzdm', pzdm, 'pzdm,/D')
tree_dm.Branch('dmpdg', dmpdg, 'dmpdg,/I')
tree_dm.Branch('dis', dis, 'dis,/I')
tree_dm.Branch('el', el, 'el,/I')
tree_dm.Branch('E_2ry', E_2ry, 'E_2ry,/D')
tree_dm.Branch('px_2ry', px_2ry, 'px_2ry,/D')
tree_dm.Branch('py_2ry', py_2ry, 'py_2ry,/D')
tree_dm.Branch('pz_2ry', pz_2ry, 'pz_2ry,/D')
tree_dm.Branch('pdg_2ry', pdg_2ry, 'pdg_2ry,/I')
tree_dm.Branch('n_2ry', n_2ry, 'n_2ry,/I')
if DISevent:
print 'input file pythia: ', input_hadrons_file
P8gen = ROOT.TPythia8()
pythiagen = P8gen.Pythia8()
pythiagen.readString("Beams:frameType = 4")
pythiagen.readString("Beams:LHEF = {}".format(input_hadrons_file))
pythiagen.init()
# Cycle over events and particles within each event
for event in lhe:
index = 0
for particle in event:
el[0] = ESevent
dis[0] = DISevent
if particle.status == INITIAL_STATE and particle.pdg == DMpdgcode:
Edm[0] = particle.E
pxdm[0] = particle.px
pydm[0] = particle.py
pzdm[0] = particle.pz
dmpdg[0] = particle.pdg
if ESevent:
if particle.status == FINAL_STATE and particle.pdg != DMpdgcode:
E_2ry[index] = particle.E
px_2ry[index] = particle.px
py_2ry[index] = particle.py
pz_2ry[index] = particle.pz
pdg_2ry[index] = particle.pdg
index += 1
if DISevent:
if pythiagen.next():
for i in range(pythiagen.event.size()):
if pythiagen.event[i].isFinal() and\
pythiagen.event[i].id() != DMpdgcode:
E_2ry[index] = pythiagen.event[i].e()
px_2ry[index] = pythiagen.event[i].px()
py_2ry[index] = pythiagen.event[i].py()
pz_2ry[index] = pythiagen.event[i].pz()
pdg_2ry[index] = pythiagen.event[i].id()
index += 1
n_2ry[0] = index
tree_dm.Fill()
# Write the tree into the output file and close the file
rootfile_dm.Write()
rootfile_dm.Close()
print "----------------------------------------------------------------"
print "------------------------------------RootFile successfully saved!"
print "----------------------------------------------------------------"
return (rootfile_dm)
def convertDIS(inputFile_dm, inputFile_hadrons):
DISevent = True
lhe = lhe_parser.EventFile(inputFile_dm) # Load LHE file
rootfile_dm = r.TFile("rootfile_dm.root", "recreate")
tree_dm = r.TTree("dmtree", "dmtree")
Edm = array('d', [0])
pxdm = array('d', [0])
pydm = array('d', [0])
pzdm = array('d', [0])
dmpdg = array('i', [0])
dis = array('i', [0])
el = array('i', [0])
E_2ry = array('d', [0] * 500)
px_2ry = array('d', [0] * 500)
py_2ry = array('d', [0] * 500)
pz_2ry = array('d', [0] * 500)
pdg_2ry = array('i', [0] * 500)
n_2ry = array('i', [0])
tree_dm.Branch('Edm', Edm, 'Edm,/D')
tree_dm.Branch('pxdm', pxdm, 'pxdm,/D')
tree_dm.Branch('pydm', pydm, 'pydm,/D')
tree_dm.Branch('pzdm', pzdm, 'pzdm,/D')
tree_dm.Branch('dmpdg', dmpdg, 'dmpdg,/I')
tree_dm.Branch('dis', dis, 'dis,/I')
tree_dm.Branch('el', el, 'el,/I')
tree_dm.Branch('E_2ry', E_2ry, 'E_2ry,/D')
tree_dm.Branch('px_2ry', px_2ry, 'px_2ry,/D')
tree_dm.Branch('py_2ry', py_2ry, 'py_2ry,/D')
tree_dm.Branch('pz_2ry', pz_2ry, 'pz_2ry,/D')
tree_dm.Branch('pdg_2ry', pdg_2ry, 'pdg_2ry,/I')
tree_dm.Branch('n_2ry', n_2ry, 'n_2ry,/I')
print 'input file pythia: ', inputFile_hadrons
P8gen = r.TPythia8()
pythiagen = P8gen.Pythia8()
pythiagen.readString("Beams:frameType = 4")
pythiagen.readString("Beams:LHEF = " + str(inputFile_hadrons))
pythiagen.init()
for event in lhe:
index = 0
for particle in event:
if particle.status == initial_state and particle.pdg == DMpdgcode:
Edm[0] = particle.E
pxdm[0] = particle.px
pydm[0] = particle.py
pzdm[0] = particle.pz
dmpdg[0] = particle.pdg
el[0] = ESevent
dis[0] = DISevent
if not pythiagen.info.atEndOfFile():
pythiagen.next(
) # Generate events, and check whether generation failed
for i in range(pythiagen.event.size()):
if pythiagen.event[i].isFinal(
) and pythiagen.event[i].id() != DMpdgcode:
E_2ry[index] = pythiagen.event[i].e()
px_2ry[index] = pythiagen.event[i].px()
py_2ry[index] = pythiagen.event[i].py()
pz_2ry[index] = pythiagen.event[i].pz()
pdg_2ry[index] = pythiagen.event[i].id()
index += 1
n_2ry[0] = index
tree_dm.Fill()
pythiagen.stat()
# Write the tree into the output file and close the file
rootfile_dm.Write()
rootfile_dm.Close()
print "----------------------------------------------------------------"
print "-------STATUS INFO - LDM DISevents: ROOTfile successfully saved!"
print "----------------------------------------------------------------"
return (rootfile_dm)
def convertES(inputFile): # Convert LHE file's infos into a ROOT TTree
ESevent = True
lhe = lhe_parser.EventFile(inputFile) # Load LHE file
rootfile_dm = r.TFile("rootfile_dm.root", "recreate")
tree_dm = r.TTree("dmtree", "dmtree")
Edm = array('d', [0])
pxdm = array('d', [0])
pydm = array('d', [0])
pzdm = array('d', [0])
dmpdg = array('i', [0])
dis = array('i', [0])
el = array('i', [0])
E_2ry = array('d', [0] * 500)
px_2ry = array('d', [0] * 500)
py_2ry = array('d', [0] * 500)
pz_2ry = array('d', [0] * 500)
pdg_2ry = array('i', [0] * 500)
n_2ry = array('i', [0])
tree_dm.Branch('Edm', Edm, 'Edm,/D')
tree_dm.Branch('pxdm', pxdm, 'pxdm,/D')
tree_dm.Branch('pydm', pydm, 'pydm,/D')
tree_dm.Branch('pzdm', pzdm, 'pzdm,/D')
tree_dm.Branch('dmpdg', dmpdg, 'dmpdg,/I')
tree_dm.Branch('dis', dis, 'dis,/I')
tree_dm.Branch('el', el, 'el,/I')
tree_dm.Branch('E_2ry', E_2ry, 'E_2ry,/D')
tree_dm.Branch('px_2ry', px_2ry, 'px_2ry,/D')
tree_dm.Branch('py_2ry', py_2ry, 'py_2ry,/D')
tree_dm.Branch('pz_2ry', pz_2ry, 'pz_2ry,/D')
tree_dm.Branch('pdg_2ry', pdg_2ry, 'pdg_2ry,/I')
tree_dm.Branch('n_2ry', n_2ry, 'n_2ry,/I')
for event in lhe:
index = 0
for particle in event:
if particle.status == initial_state and particle.pdg == DMpdgcode:
Edm[0] = particle.E
pxdm[0] = particle.px
pydm[0] = particle.py
pzdm[0] = particle.pz
dmpdg[0] = particle.pdg
el[0] = ESevent
dis[0] = DISevent
elif particle.status == final_state and particle.pdg != DMpdgcode:
E_2ry[index] = particle.E
px_2ry[index] = particle.px
py_2ry[index] = particle.py
pz_2ry[index] = particle.pz
pdg_2ry[index] = particle.pdg
index += 1
n_2ry[0] = index
tree_dm.Fill()
# Write the tree into the output file and close the file
rootfile_dm.Write()
rootfile_dm.Close()
print "----------------------------------------------------------------"
print "--------STATUS INFO - LDM ESevents: ROOTfile successfully saved!"
print "----------------------------------------------------------------"
return (rootfile_dm)
