raise RuntimeError
jetEfficiencyTF = None
if os.path.exists( 'bjetefficiency.tf' ):
jetEfficiencyTF = getattr( ROOT, 'JetEfficiencyTF' )( 'bjetefficiency.tf' )
else:
print 'ERROR [bjetefficiency.tf] file not found'
raise RuntimeError
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getVegasIntegrator( 0.025, 1.0e4, 1.0e5 ),
'backup' : getVegasIntegrator( 0.050, 1.0e5, 5.0e5 ),
'failsafe' : getVegasIntegrator( 0.100, 5.0e5, 1.0e6 ) }
# Configure the ME calculators
myMECalculation = toolFactory( 'TT1jSimple' )( integrator = myMEIntegrators['default'],
args = [ ROOT.TT1jSimple.kJET_8D ] )
myMECalculation.mehndl.setObservedJetTF( jetEnergyTF )
myMECalculation.mehndl.setInvisibleJetTF( jetEfficiencyTF )
# Set integration limits (use TF to set dynamic limits for jets)
m = myMECalculation.mehndl
m.setIntegrationLimits( m.getIPTJB(), 0, 70 )
m.setIntegrationLimits( m.getIETAJB(), -2.5, 2.5 )
m.setIntegrationLimits( m.getIPHIJB(), -math.pi, math.pi )
m.setIntegrationLimits( m.getIPTA(), 0, 150 )
m.setIntegrationLimits( m.getIPHIA(), -math.pi, math.pi )
m.setIntegrationLimits( m.getIPZA(), -200, 200 )
m.setIntegrationLimits( m.getIPZB(), -200, 200 )
jetEnergyTF = None
if os.path.exists( 'gluonjetresolution.tf' ):
jetEnergyTF = getattr( ROOT, 'JetEnergyResolutionTF' )( 'gluonjetresolution.tf' )
else:
print 'ERROR [gluonjetresolution.tf] file not found'
raise RuntimeError
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getDefaultIntegrator( 0.025, 5.0e4, 5.0e6 ),
'backup' : getDefaultIntegrator( 0.050, 5.0e4, 1.0e7 ),
'failsafe' : getDefaultIntegrator( 0.100, 5.0e4, 1.0e7 ) }
# Configure the ME calculators
myMECalculators = { 'HWW1j' : toolFactory( 'HWW1j' )( myMEIntegrators['default'],
args = [ mH, ROOT.HWW1j.kNEUTRINO_5D, None, jetEnergyTF ] ) }
# myMECalculators = { 'HWW1j' : toolFactory( 'HWW1j' )( myMEIntegrators['default'],
# args = [ mH, ROOT.HWW1j.kNEUTRINO_4D, None, None ] ) }
# Set integration limits (use TF to set dynamic limits for jets)
myMECalculators['HWW1j'].matrixElement.setWidth( wH )
myMECalculators['HWW1j'].matrixElement.setIntegrationLimits(0, 0, 250)
myMECalculators['HWW1j'].matrixElement.setIntegrationLimits( 1, -math.pi, math.pi )
myMECalculators['HWW1j'].matrixElement.setIntegrationLimits( 2, -500, 500 )
myMECalculators['HWW1j'].matrixElement.setIntegrationLimits( 3, -500, 500 )
# Set the jet multiplicity bin (determines which ME calculations are setup)
myMEJetN = 1
# Set the ME calculation to perform
mH = 125
wH = getHiggsWidth(mH) + math.pow(getHiggsWidth(mH), 1 / 6.0) / 2.0
wH = max(1, getHiggsWidth(mH))
recoilTF = getattr(ROOT, 'SystemBoostHybridTF')('recoilhyb_h125.tf')
# Configure default/backup/failsafe integrators
myMEIntegrators = {
'default': getDefaultIntegrator(0.010, 1.0e4, 2.5e6),
'backup': getDefaultIntegrator(0.025, 1.0e4, 5.0e6),
'failsafe': getDefaultIntegrator(0.100, 1.0e4, 1.0e7)
}
# Configure the ME calculaskype:bernd.stelzertors
myMECalculation = toolFactory('HWW')(
integrator=myMEIntegrators['default'],
args=[mH, ROOT.HWW.kNEUTRINO_6D, recoilTF])
# Set integration limits (use TF to set dynamic limits for jets)
mehndl = myMECalculation.mehndl
mehndl.setWidth(wH)
mehndl.setIntegrationLimits(0, 0, 250)
mehndl.setIntegrationLimits(1, -math.pi, math.pi)
mehndl.setIntegrationLimits(2, -500, 500)
mehndl.setIntegrationLimits(3, -500, 500)
# Use the SM kludge ?
mehndl.setUseSM(False)
# Set the jet multiplicity bin (determines which ME calculations are setup)
import math
from matrixelement import toolFactory
from matrixelement import getDefaultIntegrator
from matrixelement import getAlternateIntegrator
from matrixelement import getVegasIntegrator
from matrixelement import getMiserIntegrator
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getVegasIntegrator( 0.025, 2.5e4, 7.5e4 ),
'backup' : getVegasIntegrator( 0.050, 2.5e4, 5.0e5 ),
'failsafe' : getVegasIntegrator( 0.075, 2.5e4, 1.0e6 ) }
# Configure the ME calculators
myMECalculation = toolFactory( 'WW' )( integrator = myMEIntegrators['default'],
args = [ ROOT.WW.kWMASS_4D, None ] )
mehndl = myMECalculation.mehndl
# Gets integration limits for transformed Q^{2} variable
def solveq( m, w, qlow, qhigh ):
tlow = math.atan( (pow(qlow,2) - pow(m,2)) / (m * w) )
thigh = math.atan( (pow(qhigh,2) - pow(m,2)) / (m * w) )
return (tlow, thigh)
mW = ROOT.hepstd.wMass
wW = ROOT.hepstd.wWidth
a,b = solveq( mW, wW, 0, 160 )
# Set integration limits (use TF to set dynamic limits for jets)
recoilTF = None
allowNull = True # allow PH == 0, otherwise assume non-convergence and try with finer grid
useNarrowWidthApprox = True # remove integration over mH
useSMKludge = True # flag to use the SM kludge
# Configure default/backup/failsafe integrators
myMEIntegrators = {
'default': getVegasIntegrator(0.010, 2.5e5, 1.0e6),
'backup': getVegasIntegrator(0.025, 5.0e5, 1.5e6),
'failsafe': getVegasIntegrator(0.050, 7.5e5, 5.0e6)
}
# Configure the ME calculators
myMECalculation = toolFactory('HWW')(integrator=myMEIntegrators['default'],
args=(mH, ROOT.HWW.kWMASS_4D, recoilTF,
useNarrowWidthApprox))
# Set integration limits (use TF to set dynamic limits for jets)
myMECalculation.mehndl.setWidth(wH)
mehndl = myMECalculation.mehndl
# Gets integration limits for transformed Q^{2} variable
def solveq(m, w, qlow, qhigh):
tlow = math.atan((pow(qlow, 2) - pow(m, 2)) / (m * w))
thigh = math.atan((pow(qhigh, 2) - pow(m, 2)) / (m * w))
return (tlow, thigh)
from matrixelement import getHiggsWidth
jetEnergyTF = None
if os.path.exists( 'gluonjetresolution.tf' ):
jetEnergyTF = getattr( ROOT, 'JetEnergyResolutionTF' )( 'gluonjetresolution.tf' )
else:
print 'ERROR [gluonjetresolution.tf] file not found'
raise RuntimeError
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getDefaultIntegrator( 0.025, 5.0e4, 2.0e06 ),
'backup' : getDefaultIntegrator( 0.050, 5.0e4, 5.0e06 ),
'failsafe' : getDefaultIntegrator( 0.100, 5.0e4, 1.0e07 ) }
# Configure the ME calculators
myMECalculation = toolFactory( 'WW1j' )( integrator = myMEIntegrators['default'],
args = [ ROOT.WW1j.kNEUTRINO_5D, jetEnergyTF ] )
# Set integration limits (use TF to set dynamic limits for jets)
myMECalculation.mehndl.setIntegrationLimits( 0, 0, 250 )
myMECalculation.mehndl.setIntegrationLimits( 1, -math.pi, math.pi )
myMECalculation.mehndl.setIntegrationLimits( 2, -500, 500 )
myMECalculation.mehndl.setIntegrationLimits( 3, -500, 500 )
# Set the jet multiplicity bin (determines which ME calculations are setup)
# Set to use the strange PDF
myMECalculation.mehndl.setUseStrangePDF( True )
from matrixelement import getHiggsWidth
# Set the Higgs mass & width for H->WW matrix elements
mH = 125
wH = getHiggsWidth( mH ) + math.pow( getHiggsWidth( mH ) , 1/6.0 ) / 2.0
wH = max( 1, getHiggsWidth( mH ) )
recoilTF = getattr( ROOT, 'SystemBoostHybridTF' )( 'recoilhyb_h125.tf' )
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getDefaultIntegrator( 0.010, 1.0e4, 2.5e6 ),
'backup' : getDefaultIntegrator( 0.025, 1.0e4, 5.0e6 ),
'failsafe' : getDefaultIntegrator( 0.100, 1.0e4, 1.0e7 ) }
# Configure the ME calculaskype:bernd.stelzertors
myMECalculation = toolFactory( 'HWW' )( integrator = myMEIntegrators['default'],
args = [ mH, ROOT.HWW.kNEUTRINO_6D, recoilTF ] )
# Set integration limits (use TF to set dynamic limits for jets)
mehndl = myMECalculation.mehndl
mehndl.setWidth( wH )
mehndl.setIntegrationLimits( 0, 0, 250 )
mehndl.setIntegrationLimits( 1, -math.pi, math.pi )
mehndl.setIntegrationLimits( 2, -500, 500 )
mehndl.setIntegrationLimits( 3, -500, 500 )
# Use the SM kludge ?
mehndl.setUseSM( False )
# Set the jet multiplicity bin (determines which ME calculations are setup)
print 'ERROR [gluonjetresolution.tf] file not found'
raise RuntimeError
# Configure default/backup/failsafe integrators
myMEIntegrators = {
'default': getDefaultIntegrator(0.025, 5.0e4, 5.0e6),
'backup': getDefaultIntegrator(0.050, 5.0e4, 1.0e7),
'failsafe': getDefaultIntegrator(0.100, 5.0e4, 1.0e7)
}
# Configure the ME calculators
myMECalculators = {
'HWW1j':
toolFactory('HWW1j')(
myMEIntegrators['default'],
args=[mH, ROOT.HWW1j.kNEUTRINO_5D, jetEnergyTF, False])
}
# myMECalculators = { 'HWW1j' : toolFactory( 'HWW1j' )( myMEIntegrators['default'],
# args = [ mH, ROOT.HWW1j.kNEUTRINO_4D, None ] ) }
# Set integration limits (use TF to set dynamic limits for jets)
myMECalculators['HWW1j'].matrixElement.setWidth(wH)
myMECalculators['HWW1j'].matrixElement.setIntegrationLimits(0, 0, 250)
myMECalculators['HWW1j'].matrixElement.setIntegrationLimits(
1, -math.pi, math.pi)
myMECalculators['HWW1j'].matrixElement.setIntegrationLimits(2, -500, 500)
myMECalculators['HWW1j'].matrixElement.setIntegrationLimits(3, -500, 500)
# Set the jet multiplicity bin (determines which ME calculations are setup)
myMEIntegrators = None
# Configure default/backup/failsafe integrators
if strategy == ROOT.WFake.k1D:
myMEIntegrators = { 'default' : getLineIntegrator( 0.001, 1.0e3, 1.0e06 ),
'backup' : getLineIntegrator( 0.010, 1.0e3, 5.0e06 ),
'failsafe' : getLineIntegrator( 0.020, 1.0e3, 1.0e07 ) }
else:
myMEIntegrators = { 'default' : getVegasIntegrator( 0.010, 5.0e3, 1.0e04 ),
'backup' : getVegasIntegrator( 0.025, 1.0e4, 5.0e04 ),
'failsafe' : getVegasIntegrator( 0.050, 5.0e4, 1.0e06 ) }
convTF = ROOT.PhotonConversionTF( "conversion.tf" )
# Configure the ME calculators
myMECalculation = toolFactory( 'WFake' )( integrator = myMEIntegrators['default'],
args = [ strategy, convTF ] )
# Set the jet multiplicity bin (determines which ME calculations are setup)
# Gets integration limits for transformed Q^{2} variable
def solveq( m, w, qlow, qhigh ):
tlow = math.atan( (pow(qlow,2) - pow(m,2)) / (m * w) )
thigh = math.atan( (pow(qhigh,2) - pow(m,2)) / (m * w) )
return (tlow, thigh)
mW = ROOT.hepstd.wMass
wW = ROOT.hepstd.wWidth
a,b = solveq( mW, wW, 0, 300 )
myMECalculation.mehndl.setIntegrationLimits( 0, a, b )
jetEfficiencyTF = None
if os.path.exists('bjetefficiency.tf'):
jetEfficiencyTF = getattr(ROOT, 'JetEfficiencyTF')('bjetefficiency.tf')
else:
print 'ERROR [bjetefficiency.tf] file not found'
raise RuntimeError
# Configure default/backup/failsafe integrators
myMEIntegrators = {
'default': getVegasIntegrator(0.025, 1.0e4, 1.0e5),
'backup': getVegasIntegrator(0.050, 1.0e5, 5.0e5),
'failsafe': getVegasIntegrator(0.100, 5.0e5, 1.0e6)
}
# Configure the ME calculators
myMECalculation = toolFactory('TT1jSimple')(
integrator=myMEIntegrators['default'], args=[ROOT.TT1jSimple.kJET_8D])
myMECalculation.mehndl.setObservedJetTF(jetEnergyTF)
myMECalculation.mehndl.setInvisibleJetTF(jetEfficiencyTF)
# Set integration limits (use TF to set dynamic limits for jets)
m = myMECalculation.mehndl
m.setIntegrationLimits(m.getIPTJB(), 0, 70)
m.setIntegrationLimits(m.getIETAJB(), -2.5, 2.5)
m.setIntegrationLimits(m.getIPHIJB(), -math.pi, math.pi)
m.setIntegrationLimits(m.getIPTA(), 0, 150)
m.setIntegrationLimits(m.getIPHIA(), -math.pi, math.pi)
m.setIntegrationLimits(m.getIPZA(), -200, 200)
m.setIntegrationLimits(m.getIPZB(), -200, 200)
import ROOT
import math
from matrixelement import toolFactory
from matrixelement import getLineIntegrator
from matrixelement import getVegasIntegrator
#################################################################################
strategy = ROOT.DY2j.k4D
myMEIntegrators = { 'default' : getVegasIntegrator( 0.025, 1.0e3, 5.0e3 ),
'backup' : getVegasIntegrator( 0.050, 5.0e3, 1.0e4 ),
'failsafe' : getVegasIntegrator( 0.100, 1.0e4, 1.0e5 ) }
# Configure the ME calculator
myMECalculation = toolFactory( 'DY2j' )( integrator = myMEIntegrators['default'], args = [ strategy ] )
jetEnergyTF = None
if os.path.exists( 'gluonjetresolution.tf' ):
jetEnergyTF = getattr( ROOT, 'JetEnergyResolutionTF' )( 'gluonjetresolution.tf' )
else:
print 'ERROR [gluonjetresolution.tf] file not found'
raise RuntimeError
myMECalculation.mehndl.setJetTF( jetEnergyTF )
myMECalculation.mehndl.setPDF( 'ct10' )
print 'ERROR [gluonjetresolution.tf] file not found'
raise RuntimeError
useNarrowWidth = True
# Configure default/backup/failsafe integrators
myMEIntegrators = {
'default': getVegasIntegrator(0.015, 2.5e5, 5.0e5),
'backup': getVegasIntegrator(0.025, 5.0e5, 1.0e6),
'failsafe': getVegasIntegrator(0.050, 1.0e6, 2.0e6)
}
# Configure the ME calculators
myMECalculator = toolFactory('HWW1j')(
myMEIntegrators['default'],
args=[mH, ROOT.HWW1j.kWMASS_5D, jetEnergyTF, useNarrowWidth])
mehndl = myMECalculator.mehndl
# Gets integration limits for transformed Q^{2} variable
def solveq(m, w, qlow, qhigh):
print 'INFO calculating integration limits [%0.2f,%0.2f] for particle with m,w = (%0.1f, %0.1f)' % (
qlow, qhigh, m, w)
tlow = math.atan((pow(qlow, 2) - pow(m, 2)) / (m * w))
thigh = math.atan((pow(qhigh, 2) - pow(m, 2)) / (m * w))
return (tlow, thigh)
mW = ROOT.hepstd.wMass
from matrixelement import getVegasIntegrator
from matrixelement import getHiggsWidth
# Set the Higgs mass & width for H->WW matrix elements
mH = ??
wH = getHiggsWidth( mH ) ## + math.pow( getHiggsWidth( mH ) , 1/6.0 ) / 2.0
recoilTF = None ## = getattr( ROOT, 'SystemBoostAverageTF' )( 'recoilavg_ggh125.tf' )
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getVegasIntegrator( 0.010, 2.0e5, 5.0e6 ),
'backup' : getVegasIntegrator( 0.025, 2.0e5, 1.0e7 ),
'failsafe' : getVegasIntegrator( 0.100, 2.0e5, 5.0e7 ) }
# Configure the ME calculators
myMECalculators = { 'HWW' : toolFactory( 'HWW' )( myMEIntegrators['default'],
args = [ mH, ROOT.HWW.kWMASS_4D, recoilTF ] ) }
myMECalculators['HWW'].matrixElement.setUseBoostGammaXY( False )
# Set integration limits (use TF to set dynamic limits for jets)
myMECalculators['HWW'].matrixElement.setWidth( wH )
# Gets integration limits for transformed Q^{2} variable
def solveq( m, w, qlow, qhigh ):
tlow = math.atan( (pow(qlow,2) - pow(m,2)) / (m * w) )
thigh = math.atan( (pow(qhigh,2) - pow(m,2)) / (m * w) )
return (tlow, thigh)
db = ROOT.TDatabasePDG()
mW = db.GetParticle( 'W+' ).Mass()
if strategy == ROOT.WFake.k1D:
myMEIntegrators = { 'default' : getLineIntegrator( 0.01, 1.0e3, 5.0e03 ),
'backup' : getLineIntegrator( 0.01, 5.0e3, 1.0e04 ),
'failsafe' : getLineIntegrator( 0.01, 1.0e4, 5.0e04 ) }
else:
myMEIntegrators = { 'default' : getVegasIntegrator( 0.010, 1.0e3, 2.5e03 ),
'backup' : getVegasIntegrator( 0.025, 2.0e4, 1.0e05 ),
'failsafe' : getVegasIntegrator( 0.050, 1.0e5, 5.0e05 ) }
fakeTF = None
if strategy == ROOT.WFake.k2D:
fakeTF = ROOT.JetEnergyResolutionTF( "fakeresolution.tf" )
# Configure the ME calculators
myMECalculation = toolFactory( 'WFake' )( integrator = myMEIntegrators['default'],
args = [ strategy, fakeTF ] )
# Set the jet multiplicity bin (determines which ME calculations are setup)
# Gets integration limits for transformed Q^{2} variable
def solveq( m, w, qlow, qhigh ):
tlow = math.atan( (pow(qlow,2) - pow(m,2)) / (m * w) )
thigh = math.atan( (pow(qhigh,2) - pow(m,2)) / (m * w) )
return (tlow, thigh)
mW = ROOT.hepstd.wMass
wW = ROOT.hepstd.wWidth
a,b = solveq( mW, wW, 0, 400 )
mehndl = myMECalculation.mehndl
jetEfficiencyTF = None
if os.path.exists( 'bjetefficiency.tf' ):
jetEfficiencyTF = getattr( ROOT, 'JetEfficiencyTF' )( 'bjetefficiency.tf' )
else:
print 'ERROR [bjetefficiency.tf] file not found'
raise RuntimeError
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getVegasIntegrator( 0.050, 1.0e5, 5.0e5 ),
'backup' : getVegasIntegrator( 0.075, 2.5e5, 7.5e5 ),
'failsafe' : getVegasIntegrator( 0.100, 7.5e5, 1.5e6 ) }
# Configure the ME calculators
myMECalculators = { 'TT1j' : toolFactory( 'TT1j' )( myMEIntegrators['default'], args = [ ROOT.TT1j.kJET_WMASS_6D ] ) }
myMECalculators['TT1j'].mehndl.setObservedJetTF( jetEnergyTF )
myMECalculators['TT1j'].mehndl.setInvisibleJetTF( jetEfficiencyTF )
# Gets integration limits for transformed Q^{2} variable
def solveq( m, w, qlow, qhigh ):
tlow = math.atan( (pow(qlow,2) - pow(m,2)) / (m * w) )
thigh = math.atan( (pow(qhigh,2) - pow(m,2)) / (m * w) )
return (tlow, thigh)
mW = ROOT.hepstd.wMass
wW = ROOT.hepstd.wWidth
a,b = solveq( mW, wW, 70, 90 )
from matrixelement import toolFactory
from matrixelement import getDefaultIntegrator
from matrixelement import getAlternateIntegrator
from matrixelement import getVegasIntegrator
from matrixelement import getMiserIntegrator
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getVegasIntegrator( 0.025, 7.5e4, 1.5e5 ),
'backup' : getVegasIntegrator( 0.050, 1.5e5, 5.0e5 ),
'failsafe' : getVegasIntegrator( 0.075, 2.5e5, 1.0e6 ) }
recoilTF = getattr( ROOT, 'SystemBoostTF' )( 'recoil_ww_nj.tf' )
# Configure the ME calculators
myMECalculation = toolFactory( 'WW' )( integrator = myMEIntegrators['default'],
args = [ ROOT.WW.kWMASS_6D, recoilTF ] )
mehndl = myMECalculation.mehndl
# Gets integration limits for transformed Q^{2} variable
def solveq( m, w, qlow, qhigh ):
tlow = math.atan( (pow(qlow,2) - pow(m,2)) / (m * w) )
thigh = math.atan( (pow(qhigh,2) - pow(m,2)) / (m * w) )
return (tlow, thigh)
mW = ROOT.hepstd.wMass
wW = ROOT.hepstd.wWidth
a,b = solveq( mW, wW, 0, 160 )
# Set integration limits (use TF to set dynamic limits for jets)
if os.path.exists('gluonjetresolution.tf'):
jetEnergyTF = getattr(ROOT,
'JetEnergyResolutionTF')('gluonjetresolution.tf')
else:
print 'ERROR [gluonjetresolution.tf] file not found'
raise RuntimeError
# Configure default/backup/failsafe integrators
myMEIntegrators = {
'default': getDefaultIntegrator(0.025, 5.0e4, 2.0e06),
'backup': getDefaultIntegrator(0.050, 5.0e4, 5.0e06),
'failsafe': getDefaultIntegrator(0.100, 5.0e4, 1.0e07)
}
# Configure the ME calculators
myMECalculation = toolFactory('WW1j')(
integrator=myMEIntegrators['default'],
args=[ROOT.WW1j.kNEUTRINO_5D, jetEnergyTF])
# Set integration limits (use TF to set dynamic limits for jets)
myMECalculation.mehndl.setIntegrationLimits(0, 0, 250)
myMECalculation.mehndl.setIntegrationLimits(1, -math.pi, math.pi)
myMECalculation.mehndl.setIntegrationLimits(2, -500, 500)
myMECalculation.mehndl.setIntegrationLimits(3, -500, 500)
# Set the jet multiplicity bin (determines which ME calculations are setup)
# Set to use the strange PDF
myMECalculation.mehndl.setUseStrangePDF(True)
wH = getHiggsWidth( mH ) + math.pow( getHiggsWidth( mH ) , 1/6.0 ) / 2.0
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getDefaultIntegrator( 0.010, 4.0e4, 1.0e6 ),
'backup' : getDefaultIntegrator( 0.025, 4.0e4, 5.0e6 ),
'failsafe' : getDefaultIntegrator( 0.100, 4.0e4, 1.0e7 ) }
boostTF = None
if os.path.exists( 'recoil.tf' ):
boostTF = getattr( ROOT, 'SystemBoostTF' )( 'recoil.tf' )
else:
print 'ERROR [recoil.tf] file not found'
raise RuntimeError
# Configure the ME calculators
myMECalculators = { 'HWW' : toolFactory( 'HWW' )( myMEIntegrators['default'],
args = [ mH, ROOT.HWW.kNEUTRINO_6D, boostTF ] ) }
# Set integration limits (use TF to set dynamic limits for jets)
myME = myMECalculators['HWW'].matrixElement
myME.setWidth( wH )
myME.setIntegrationLimits( myME.getIPTA(), 0, 250 )
myME.setIntegrationLimits( myME.getIPHIA(), -math.pi, math.pi )
myME.setIntegrationLimits( myME.getIPZA(), -500, 500 )
myME.setIntegrationLimits( myME.getIPZB(), -500, 500 )
# Set the jet multiplicity bin (determines which ME calculations are setup)
myMEJetN = 0
# Set the ME calculation to perform
myMECalculation = myMECalculators['HWW']
#
# configure the matrix element (integrand)
#
if not os.path.exists( 'cteq6l.tbl' ):
log.debug( 'Fetching CTEQ6 PDF' )
commands.getstatusoutput( 'ln -s $HEPPY/higgs/mymeanalysis/exec/run/cteq6l.tbl .' )
if not os.path.exists( 'jetefficiency.tf' ):
commands.getstatusoutput( 'ln -s /home/dschouten/code/higgs/mymeanalysis/exec/run/jetefficiency.tf .' )
if 'tt' in matrix.lower():
jetEffTF = root.JetEfficiencyTF( 'bjetefficiency.tf' )
config += [ root.TT1j.kJET_3D ]
myme = matrixelement.toolFactory( matrix )( myint, args = config )
integrand = myme.matrixElement
integrand.setInvisibleJetTF( jetEffTF )
integrand.setIntegrationLimits( integrand.getIPTB(), 1, 100 )
integrand.setIntegrationLimits( integrand.getIPHIB(), -math.pi, math.pi )
integrand.setIntegrationLimits( integrand.getIETAB(), -4, 4 )
mymelist = [ myme ]
else:
config += [ root.WW1jLeptonsBaseIntegrand.kNEUTRINO_4D, None, None ]
myme = matrixelement.toolFactory( matrix )( myint, args = config )
integrand = myme.matrixElement
if 'hww' in matrix.lower():
integrand.setWidth( matrixelement.getHiggsWidth( integrand.mass() ) )
integrand.setUseSM( False )
integrand.setIntegrationLimits( integrand.getIPTA(), 0, 500 )
integrand.setIntegrationLimits( integrand.getIPHIA(), -math.pi, math.pi )
#
if not os.path.exists('cteq6l.tbl'):
log.debug('Fetching CTEQ6 PDF')
commands.getstatusoutput(
'ln -s $HEPPY/higgs/mymeanalysis/exec/run/cteq6l.tbl .')
if not os.path.exists('jetefficiency.tf'):
commands.getstatusoutput(
'ln -s /home/dschouten/code/higgs/mymeanalysis/exec/run/jetefficiency.tf .'
)
if 'tt' in matrix.lower():
jetEffTF = root.JetEfficiencyTF('bjetefficiency.tf')
config += [root.TT1j.kJET_3D]
myme = matrixelement.toolFactory(matrix)(myint, args=config)
integrand = myme.matrixElement
integrand.setInvisibleJetTF(jetEffTF)
integrand.setIntegrationLimits(integrand.getIPTB(), 1, 100)
integrand.setIntegrationLimits(integrand.getIPHIB(), -math.pi, math.pi)
integrand.setIntegrationLimits(integrand.getIETAB(), -4, 4)
mymelist = [myme]
else:
config += [root.WW1jLeptonsBaseIntegrand.kNEUTRINO_4D, None, None]
myme = matrixelement.toolFactory(matrix)(myint, args=config)
integrand = myme.matrixElement
if 'hww' in matrix.lower():
integrand.setWidth(matrixelement.getHiggsWidth(integrand.mass()))
integrand.setUseSM(False)
integrand.setIntegrationLimits(integrand.getIPTA(), 0, 500)
integrand.setIntegrationLimits(integrand.getIPHIA(), -math.pi, math.pi)
jetEfficiencyTF = getattr(ROOT, 'JetEfficiencyTF')('bjetefficiency.tf')
else:
print 'ERROR [bjetefficiency.tf] file not found'
raise RuntimeError
# Configure default/backup/failsafe integrators
myMEIntegrators = {
'default': getVegasIntegrator(0.050, 1.0e5, 5.0e5),
'backup': getVegasIntegrator(0.075, 2.5e5, 7.5e5),
'failsafe': getVegasIntegrator(0.100, 7.5e5, 1.5e6)
}
# Configure the ME calculators
myMECalculators = {
'TT1j':
toolFactory('TT1j')(myMEIntegrators['default'],
args=[ROOT.TT1j.kJET_WMASS_6D])
}
myMECalculators['TT1j'].mehndl.setObservedJetTF(jetEnergyTF)
myMECalculators['TT1j'].mehndl.setInvisibleJetTF(jetEfficiencyTF)
# Gets integration limits for transformed Q^{2} variable
def solveq(m, w, qlow, qhigh):
tlow = math.atan((pow(qlow, 2) - pow(m, 2)) / (m * w))
thigh = math.atan((pow(qhigh, 2) - pow(m, 2)) / (m * w))
return (tlow, thigh)
mW = ROOT.hepstd.wMass
wW = ROOT.hepstd.wWidth
if os.path.exists( 'gluonjetresolution.tf' ):
jetEnergyTF = getattr( ROOT, 'JetEnergyResolutionTF' )( 'gluonjetresolution.tf' )
else:
print 'ERROR [gluonjetresolution.tf] file not found'
raise RuntimeError
useNarrowWidth = True
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getVegasIntegrator( 0.015, 2.5e5, 5.0e5 ),
'backup' : getVegasIntegrator( 0.025, 5.0e5, 1.0e6 ),
'failsafe' : getVegasIntegrator( 0.050, 1.0e6, 2.0e6 ) }
# Configure the ME calculators
myMECalculator = toolFactory( 'HWW1j' )( myMEIntegrators['default'],
args = [ mH, ROOT.HWW1j.kWMASS_5D, jetEnergyTF, useNarrowWidth ] )
mehndl = myMECalculator.mehndl
# Gets integration limits for transformed Q^{2} variable
def solveq( m, w, qlow, qhigh ):
print 'INFO calculating integration limits [%0.2f,%0.2f] for particle with m,w = (%0.1f, %0.1f)'%( qlow, qhigh, m, w )
tlow = math.atan( (pow(qlow,2) - pow(m,2)) / (m * w) )
thigh = math.atan( (pow(qhigh,2) - pow(m,2)) / (m * w) )
return (tlow, thigh)
mW = ROOT.hepstd.wMass
wW = ROOT.hepstd.wWidth
# for low mass Higgs, one W is usually off-shell
a,b = 0,0
nGam = 10 # integration range around BW peaks in units of natural width
# SystemBoostTF/recoil.tf, SystemBoostAverageTF/recoilavg_h125.tf, SystemBoostHybrid/recoilhyb_h125.tf
recoilTF = getattr( ROOT, 'SystemBoostTF' )( 'recoil_ggf_ww_0j.tf' )
if (useSMKludge + useRSModel + useJHUModel) > 1:
print 'ERROR incompatible options !'
sys.exit( -1 )
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getVegasIntegrator( 0.025, 5.0e4, 1.5e5 ),
'backup' : getVegasIntegrator( 0.050, 1.5e5, 5.0e5 ),
'failsafe' : getVegasIntegrator( 0.100, 5.0e5, 1.5e6 ) }
# Configure the ME calculators
myMECalculation = toolFactory( 'HWW' )( integrator = myMEIntegrators['default'],
args = ( mH, ROOT.HWW.kWMASS_6D, recoilTF, useNarrowWidthApprox ) )
# Set integration limits (use TF to set dynamic limits for jets)
if not useNarrowWidthApprox:
myMECalculation.mehndl.setWidth( wH )
mehndl = myMECalculation.mehndl
mehndl.setUseBoxPS( useBoxPhaseSpace )
mehndl.setUseSM( useSMKludge )
mehndl.setUseRS( useRSModel )
# Gets integration limits for transformed Q^{2} variable
def solveq( m, w, qlow, qhigh ):
print 'INFO calculating integration limits [%0.2f,%0.2f] for particle with m,w = (%0.1f, %0.1f)'%( qlow, qhigh, m, w )
tlow = math.atan( (pow(qlow,2) - pow(m,2)) / (m * w) )
jetEfficiencyTF = None
if os.path.exists('bjetefficiency.tf'):
jetEfficiencyTF = getattr(ROOT, 'JetEfficiencyTF')('bjetefficiency.tf')
else:
print 'ERROR [bjetefficiency.tf] file not found'
raise RuntimeError
# Configure default/backup/failsafe integrators
myMEIntegrators = {
'default': getVegasIntegrator(0.100, 1.0e5, 2.5e5),
'backup': getVegasIntegrator(0.150, 5.0e5, 1.0e6),
'failsafe': getVegasIntegrator(0.200, 1.0e6, 2.0e6)
}
# Configure the ME calculator
myMECalculation = toolFactory('TT1j')(integrator=myMEIntegrators['default'],
args=[ROOT.TT1j.kJET_4D])
hndl = myMECalculation.mehndl
hndl.setObservedJetTF(jetEnergyTF)
hndl.setInvisibleJetTF(jetEfficiencyTF)
# Set integration limits (use TF to set dynamic limits for jets)
hndl.setIntegrationLimits(hndl.getIPTB(), 15, 80)
hndl.setIntegrationLimits(hndl.getIETAB(), -2, 2)
hndl.setIntegrationLimits(hndl.getIPHIB(), -math.pi, math.pi)
hndl.setPDF('ct10')
from matrixelement import toolFactory
from matrixelement import getLineIntegrator
from matrixelement import getVegasIntegrator
#################################################################################
strategy = ROOT.DY2j.k4D
myMEIntegrators = {
'default': getVegasIntegrator(0.025, 1.0e3, 5.0e3),
'backup': getVegasIntegrator(0.050, 5.0e3, 1.0e4),
'failsafe': getVegasIntegrator(0.100, 1.0e4, 1.0e5)
}
# Configure the ME calculator
myMECalculation = toolFactory('DY2j')(integrator=myMEIntegrators['default'],
args=[strategy])
jetEnergyTF = None
if os.path.exists('gluonjetresolution.tf'):
jetEnergyTF = getattr(ROOT,
'JetEnergyResolutionTF')('gluonjetresolution.tf')
else:
print 'ERROR [gluonjetresolution.tf] file not found'
raise RuntimeError
myMECalculation.mehndl.setJetTF(jetEnergyTF)
myMECalculation.mehndl.setPDF('ct10')
else:
print 'ERROR [bjetresolution.tf] file not found'
raise RuntimeError
jetEfficiencyTF = None
if os.path.exists( 'bjetefficiency.tf' ):
jetEfficiencyTF = getattr( ROOT, 'JetEfficiencyTF' )( 'bjetefficiency.tf' )
else:
print 'ERROR [bjetefficiency.tf] file not found'
raise RuntimeError
# Configure default/backup/failsafe integrators
myMEIntegrators = { 'default' : getVegasIntegrator( 0.100, 1.0e5, 2.5e5 ),
'backup' : getVegasIntegrator( 0.150, 5.0e5, 1.0e6 ),
'failsafe' : getVegasIntegrator( 0.200, 1.0e6, 2.0e6 ) }
# Configure the ME calculator
myMECalculation = toolFactory( 'TT1j' )( integrator = myMEIntegrators['default'], args = [ ROOT.TT1j.kJET_4D ] )
hndl = myMECalculation.mehndl
hndl.setObservedJetTF( jetEnergyTF )
hndl.setInvisibleJetTF( jetEfficiencyTF )
# Set integration limits (use TF to set dynamic limits for jets)
hndl.setIntegrationLimits( hndl.getIPTB(), 15, 80 )
hndl.setIntegrationLimits( hndl.getIETAB(), -2, 2 )
hndl.setIntegrationLimits( hndl.getIPHIB(), -math.pi, math.pi )
hndl.setPDF( 'ct10' )
