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' )