def push_array():
global array_template, current_array
if array_template is None:
array_template = arr('I')
array_template.append(0)
while len(array_template) < STATE_SIZE:
array_template.extend(array_template)
assert len(array_template) == STATE_SIZE
result = arr('I', array_template)
current_array = result
arrays.append(result)
def _labels(data):
orig = sys.gettrace()
sys.settrace(None)
try:
labels = arr('I')
for i in _range(len(data)):
a = i << 4
b = data[i]
if b > 0:
labels.append(a + 1)
if b > 1:
labels.append(a + 2)
if b > 2:
labels.append(a + 3)
if b > 3:
labels.append(a + 4)
if b > 4:
labels.append(a + 5)
if b > 8:
labels.append(a + 6)
if b > 16:
labels.append(a + 7)
if b > 32:
labels.append(a + 8)
if b > 64:
labels.append(a + 9)
if b > 128:
labels.append(a + 10)
return labels
finally:
sys.settrace(orig)
def minimize(self, final_fit=True, log_print_level=2):
'''Do the minimization. This calls `Minuit`'s algorithms ``MIGRAD``
for minimization and, if `final_fit` is `True`, also ``HESSE``
for computing/checking the parameter error matrix.'''
# Set the FCN again. This HAS to be done EVERY
# time the minimize method is called because of
# the implementation of SetFCN, which is not
# object-oriented but sets a global pointer!!!
logger.debug("Updating current FCN")
self.__gMinuit.SetFCN(self.FCN_wrapper)
# Run minimization algorithm (MIGRAD + HESSE)
error_code = Long(0)
prefix = "Minuit run on" # set the timestamp prefix
# insert timestamp
self.out_file.write('\n')
self.out_file.write('#'*(len(prefix)+4+20))
self.out_file.write('\n')
self.out_file.write("# %s " % (prefix,) +
strftime("%Y-%m-%d %H:%M:%S #\n", gmtime()))
self.out_file.write('#'*(len(prefix)+4+20))
self.out_file.write('\n\n')
self.out_file.flush()
# save the old stdout stream
old_out_stream = os.dup(sys.stdout.fileno())
os.dup2(self.out_file.fileno(), sys.stdout.fileno())
self.__gMinuit.SetPrintLevel(log_print_level) # set Minuit print level
logger.debug("Running MIGRAD")
self.__gMinuit.mnexcm("MIGRAD",
arr('d', [self.max_iterations, self.tolerance]),
2, error_code)
if(final_fit):
logger.debug("Running HESSE")
self.__gMinuit.mnexcm("HESSE", arr('d', [self.max_iterations]), 1, error_code)
# return to normal print level
self.__gMinuit.SetPrintLevel(self.print_level)
# restore the previous output stream
os.dup2(old_out_stream, sys.stdout.fileno())
def set_err(self, up_value=1.0):
'''Sets the ``UP`` value for Minuit.
*up_value* : float (optional, default: 1.0)
This is the value by which `FCN` is expected to change.
'''
# Tell TMinuit to use an up-value of 1.0
error_code = Long(0)
# execute SET ERR command
self.__gMinuit.mnexcm("SET ERR", arr('d', [up_value]), 1, error_code)
def set_strategy(self, strategy_id=1):
'''Sets the strategy Minuit.
*strategy_id* : int (optional, default: 1 (optimized))
Tells ``TMinuit`` to use a certain strategy. Refer to ``TMinuit``'s
documentation for available strategies.
'''
error_code = Long(0)
# execute SET STRATEGY command
self.__gMinuit.mnexcm("SET STRATEGY",
arr('d', [strategy_id]), 1, error_code)
def fix_parameter(self, parameter_number):
'''
Fix parameter number <`parameter_number`>.
**parameter_number** : int
Number of the parameter to fix.
'''
error_code = Long(0)
logger.info("Fixing parameter %d in Minuit" % (parameter_number,))
# execute FIX command
self.__gMinuit.mnexcm("FIX",
arr('d', [parameter_number+1]), 1, error_code)
def release_parameter(self, parameter_number):
'''
Release parameter number <`parameter_number`>.
**parameter_number** : int
Number of the parameter to release.
'''
error_code = Long(0)
logger.info("Releasing parameter %d in Minuit" % (parameter_number,))
# execute RELEASE command
self.__gMinuit.mnexcm("RELEASE",
arr('d', [parameter_number+1]), 1, error_code)
def get_error_matrix(self):
'''Retrieves the parameter error matrix from TMinuit.
return : `numpy.matrix`
'''
# set up an array of type `double' to pass to TMinuit
tmp_array = arr('d', [0.0]*(self.number_of_parameters**2))
# get parameter covariance matrix from TMinuit
self.__gMinuit.mnemat(tmp_array, self.number_of_parameters)
# reshape into 2D array
return np.asmatrix(
np.reshape(
tmp_array,
(self.number_of_parameters, self.number_of_parameters)
)
)
def minos_errors(self):
'''
Get (asymmetric) parameter uncertainties from MINOS
algorithm. This calls `Minuit`'s algorithms ``MINOS``,
which determines parameter uncertainties using profiling
of the chi2 function.
returns : tuple
A tuple of [err+, err-, parabolic error, global correlation]
'''
# Set the FCN again. This HAS to be done EVERY
# time the minimize method is called because of
# the implementation of SetFCN, which is not
# object-oriented but sets a global pointer!!!
logger.debug("Updating current FCN")
self.__gMinuit.SetFCN(self.FCN_wrapper)
# save the old stdout stream
old_out_stream = os.dup(sys.stdout.fileno())
os.dup2(self.out_file.fileno(), sys.stdout.fileno())
self.__gMinuit.SetPrintLevel(1) # verboseness level 1 is sufficient
logger.debug("Running MINOS")
error_code = Long(0)
self.__gMinuit.mnexcm("MINOS", arr('d', [self.max_iterations]), 1, error_code)
# return to normal print level
self.__gMinuit.SetPrintLevel(self.print_level)
# restore the previous output stream
os.dup2(old_out_stream, sys.stdout.fileno())
output = []
errpos=Double(0) # positive parameter error
errneg=Double(0) # negative parameter error
err=Double(0) # parabolic error
gcor=Double(0) # global correlation coefficient
for i in xrange(0, self.number_of_parameters):
self.__gMinuit.mnerrs(i, errpos, errneg, err, gcor)
output.append([float(errpos),float(errneg),float(err),float(gcor)])
return output
def minos_errors(self, log_print_level=1):
'''
Get (asymmetric) parameter uncertainties from MINOS
algorithm. This calls `Minuit`'s algorithms ``MINOS``,
which determines parameter uncertainties using profiling
of the chi2 function.
returns : tuple
A tuple of [err+, err-, parabolic error, global correlation]
'''
# Set the FCN again. This HAS to be done EVERY
# time the minimize method is called because of
# the implementation of SetFCN, which is not
# object-oriented but sets a global pointer!!!
logger.debug("Updating current FCN")
self.__gMinuit.SetFCN(self.FCN_wrapper)
# redirect stdout stream
_redirection_target = None
if log_print_level >= 0:
_redirection_target = self.out_file
with redirect_stdout_to(_redirection_target):
self.__gMinuit.SetPrintLevel(log_print_level)
logger.debug("Running MINOS")
error_code = Long(0)
self.__gMinuit.mnexcm("MINOS", arr('d', [self.max_iterations]), 1, error_code)
# return to normal print level
self.__gMinuit.SetPrintLevel(self.print_level)
output = []
errpos=Double(0) # positive parameter error
errneg=Double(0) # negative parameter error
err=Double(0) # parabolic error
gcor=Double(0) # global correlation coefficient
for i in range(0, self.number_of_parameters):
self.__gMinuit.mnerrs(i, errpos, errneg, err, gcor)
output.append([float(errpos),float(errneg),float(err),float(gcor)])
return output
def merge_arrays(x, y):
result = arr('I')
xi = 0
yi = 0
while xi < len(x) and yi < len(y):
xv = x[xi]
yv = y[yi]
if xv < yv:
result.append(xv)
xi += 1
elif xv > yv:
result.append(yv)
yi += 1
else:
result.append(xv)
xi += 1
yi += 1
while xi < len(x):
result.append(x[xi])
xi += 1
while yi < len(y):
result.append(y[yi])
yi += 1
return result
# arg2 can be specified as "bkg" or "sig" for background and signal modeling
#Example1(plot default efficiencies): python Step2_PlotAll.py
#Example2(systematic -- bkg modeling): python Step2_PlotAll.py /uscms/home/zhangjin/nobackup/ bkg
#Example3(systematic -- sig modeling): python Step2_PlotAll.py /uscms/home/zhangjin/nobackup/ sig
#Example2 and 3 are used for systematic calculation.
##################################################################################
from ROOT import *
from numpy import *
from Config import *
gROOT.SetStyle("Plain")
gStyle.SetPaintTextFormat("0.3g")
gStyle.SetOptStat(0)
from array import array as arr
Red = arr('d',[0.00, 0.00, 0.00, 1.00, 1.00])
Green = arr('d',[0.00, 0.10, 1.00, 1.00, 0.00])
Blue = arr('d',[1.00, 0.90, 0.00, 0.00, 0.00])
Length = arr('d',[0.00, 0.85, 0.90, 0.95, 1.00])
TColor.CreateGradientColorTable(5,Length,Red,Green,Blue,500)
gStyle.SetNumberContours(500)
import sys,os
if (sys.argv[0] == "python"): args=sys.argv[2:]
else: args=sys.argv[1:]
Prefix=""
Postfix=""
if len(args)>0:
Prefix=args[0]
if Prefix[-1] != "/":
global kor_matrix
kor_matrix=[[0,0,0],[0,0,0],[0,0,0]]
for i in range(3):
kor_matrix[i][i] = error[i]*error[i]
print 'error = ',error[i]
global kor_matrix_inv
kor_matrix_inv = inv(kor_matrix)
#print kor_matrix_inv
minuit = TMinuit(npar) #initialize TMinuit with a maximum of 2 params
minuit.SetFCN(fcn)
arglist = arr('d', 2*[0.01])
ierflg = Long(0)
arglist[0] = 1.
minuit.mnexcm("SET ERR", arglist, 1, ierflg)
# Set starting values and step sizes for parameters
vstart = [8., 1.]
step = [0.01 , 0.01]
minuit.mnparm(0, "y", vstart[0], step[0], 0,0,ierflg)
minuit.mnparm(1, "N", vstart[1], step[1], 0,0,ierflg)
# Now ready for minimization step
arglist[0] = 500
arglist[1] = 1.
,'f_s_mKK2'
,'delta_s_perp_mKK2'
,'f_s_mKK3'
,'delta_s_perp_mKK3'
,'f_s_mKK4'
,'delta_s_perp_mKK4'
,'f_s_mKK5'
,'delta_s_perp_mKK5'
]
names = ['phis','lambda']
#names = ['gamma_act', 'd_gamma', 'ap_zero_2', 'ap_perp_2']
for i in range(num_params):
minuit.mnparm(i, names[i], 0.0, 0.01, 0, 0, error_code)
minuit.mnexcm("migrad", arr('d', [6000, 0.01]), 2, error_code)
minuit.mnexcm("hesse", arr('d', [6000]), 1, error_code)
if (false): # for making NLL scans
for i in range(num_params):
c = ROOT.TCanvas()
minuit.mnexcm("SCAN", arr('d', [i, 20]), 2, error_code);
gr = minuit.GetPlot()
gr.Draw("AL")
gr.GetXaxis().SetTitle(names[i])
c.SaveAs(names[i]+".pdf")
#par0, par1 = ROOT.Double(0), ROOT.Double(0)
#par0e, par1e = ROOT.Double(0), ROOT.Double(0)
#minuit.GetParameter(0, par0, par0e)
#minuit.GetParameter(1, par1, par1e)
#Green = arr('d',[0.00, 0.10, 1.00, 1.00, 0.00])
#Blue = arr('d',[1.00, 0.90, 0.00, 0.00, 0.00])
#Length = arr('d',[0.00, 0.40, 0.60, 0.80, 1.00])
#TColor.CreateGradientColorTable(5,Length,Red,Green,Blue,500)
#Red = arr('d',[.00, 1.00, 1.00])
#Green = arr('d',[1.00, 1.00, 0.00])
#Blue = arr('d',[0.00, 0.00, 0.00])
#Length = arr('d',[0.00, 0.5, 1.00])
#TColor.CreateGradientColorTable(3,Length,Red,Green,Blue,500)
#Red = arr('d',[1.00, 1.00, 1.00, .00])
#Green = arr('d',[0., 0.00, 1.00, 1.00])
#Blue = arr('d',[1.00, 0.00, 0.00, 0.00])
#Length = arr('d',[0.00, 0.1, 0.55, 1.00])
#TColor.CreateGradientColorTable(4,Length,Red,Green,Blue,500)
Red = arr('d',[0.,1.00, 1.00, 1.00, .00])
Green = arr('d',[0.,0., 0.00, 1.00, 1.00])
Blue = arr('d',[1.0,1.00, 0.00, 0.00, 0.00])
Length = arr('d',[0.00, 0.4, 0.6, 0.8, 1.00])
TColor.CreateGradientColorTable(5,Length,Red,Green,Blue,500)
gStyle.SetNumberContours(500)
def unshitify(pave):
pave.SetFillStyle(0)
pave.SetBorderSize(0)
cms_label = ROOT.TPaveText(0.06, 0.84, 0.9, 1.0, "NDC")
unshitify(cms_label)
cms_label.SetTextSize(0.03)
cms_label.SetTextAlign(12)
from array import array as arr
def IPtoBinary(addr):
return unpack("!L", socket.inet_aton(addr))[0]
version = 5
numFlows = int(raw_input("Enter number of flows: "))
uptime = int(raw_input("Enter device uptime (millis): "))
epochMillis = int(raw_input("Enter system clock in millis (since Epoch): "))
epochNano = int(raw_input("Residual nanoseconds (since Epoch): "))
totalFlowsSeen = int(raw_input("Total flows seen since boot: "))
engineType = int(raw_input("Engine type: "))
engineID = int(raw_input("Engine ID: "))
samplingInterval = int(raw_input("Sampling Interval: "))
pktPayload = arr("c", (24 + (numFlows * 48)) * "\0")
pack_into("!HHLLLLBBH", pktPayload, 0, version, numFlows, uptime, epochMillis, epochNano, totalFlowsSeen, engineType, engineID, samplingInterval)
offset = 24
for i in range(numFlows):
print "=== Flow #"+str(i+1)+" ==="
srcIP = IPtoBinary(raw_input("Source IP: "))
dstIP = IPtoBinary(raw_input("Destination IP: "))
nextIP = IPtoBinary(raw_input("IP of next hop: "))
ifIn = int(raw_input("SNMP Input Index: "))
ifOut = int(raw_input("SNMP Output Index: "))
numPkts = int(raw_input("Number of Packets in Flow: "))
l3bytes = int(raw_input("Total Layer 3 Bytes: "))
flowStart = int(raw_input("Flow Start Time: "))
def get_profile(self, parid, n_points=21):
'''
Returns a list of points (2-tuples) the profile
the :math:`\\chi^2` of the TMinuit fit.
**parid** : int
ID of the parameter to be displayed on the `x`-axis.
*n_points* : int (optional)
number of points used for profile. Default is 21.
*returns* : two arrays, par. values and corresp. :math:`\\chi^2`
containing ``n_points`` sampled profile points.
'''
self.out_file.write('\n')
# entry in log-file
self.out_file.write('\n')
self.out_file.write('#'*(2+26))
self.out_file.write('\n')
self.out_file.write("# Profile for parameter %2d #\n" % (parid))
self.out_file.write('#'*(2+26))
self.out_file.write('\n\n')
self.out_file.flush()
# redirect stdout stream
_redirection_target = None
## -- disable redirection completely, for now
##if log_print_level >= 0:
## _redirection_target = self.out_file
with redirect_stdout_to(_redirection_target):
pv = []
chi2 = []
error_code = Long(0)
self.__gMinuit.mnexcm("SET PRINT",
arr('d', [0.0]), 1, error_code) # no printout
# first, make sure we are at minimum, i.e. re-minimize
self.minimize(final_fit=True, log_print_level=0)
minuit_id = Double(parid + 1) # Minuit parameter numbers start with 1
# retrieve information about parameter with id=parid
pmin = Double(0)
perr = Double(0)
self.__gMinuit.GetParameter(parid, pmin, perr) # retrieve fitresult
# fix parameter parid ...
self.__gMinuit.mnexcm("FIX",
arr('d', [minuit_id]),
1, error_code)
# ... and scan parameter values, minimizing at each point
for v in np.linspace(pmin - 3.*perr, pmin + 3.*perr, n_points):
pv.append(v)
self.__gMinuit.mnexcm("SET PAR",
arr('d', [minuit_id, Double(v)]),
2, error_code)
self.__gMinuit.mnexcm("MIGRAD",
arr('d', [self.max_iterations, self.tolerance]),
2, error_code)
chi2.append(self.get_fit_info('fcn'))
# release parameter to back to initial value and release
self.__gMinuit.mnexcm("SET PAR",
arr('d', [minuit_id, Double(pmin)]),
2, error_code)
self.__gMinuit.mnexcm("RELEASE",
arr('d', [minuit_id]),
1, error_code)
return pv, chi2
# Green = arr('d',[0.00, 0.10, 1.00, 1.00, 0.00])
# Blue = arr('d',[1.00, 0.90, 0.00, 0.00, 0.00])
# Length = arr('d',[0.00, 0.40, 0.60, 0.80, 1.00])
# TColor.CreateGradientColorTable(5,Length,Red,Green,Blue,500)
# Red = arr('d',[.00, 1.00, 1.00])
# Green = arr('d',[1.00, 1.00, 0.00])
# Blue = arr('d',[0.00, 0.00, 0.00])
# Length = arr('d',[0.00, 0.5, 1.00])
# TColor.CreateGradientColorTable(3,Length,Red,Green,Blue,500)
# Red = arr('d',[1.00, 1.00, 1.00, .00])
# Green = arr('d',[0., 0.00, 1.00, 1.00])
# Blue = arr('d',[1.00, 0.00, 0.00, 0.00])
# Length = arr('d',[0.00, 0.1, 0.55, 1.00])
# TColor.CreateGradientColorTable(4,Length,Red,Green,Blue,500)
Red = arr("d", [0.0, 1.00, 1.00, 1.00, 0.00])
Green = arr("d", [0.0, 0.0, 0.00, 1.00, 1.00])
Blue = arr("d", [1.0, 1.00, 0.00, 0.00, 0.00])
Length = arr("d", [0.00, 0.4, 0.6, 0.8, 1.00])
TColor.CreateGradientColorTable(5, Length, Red, Green, Blue, 500)
gStyle.SetNumberContours(500)
def unshitify(pave):
pave.SetFillStyle(0)
pave.SetBorderSize(0)
cms_label = ROOT.TPaveText(0.06, 0.84, 0.9, 1.0, "NDC")
unshitify(cms_label)
#Example1(plot default efficiencies): python Step2_PlotAll.py
#Example2(systematic -- bkg modeling): python Step2_PlotAll.py /uscms/home/zhangjin/nobackup/ bkg
#Example3(systematic -- sig modeling): python Step2_PlotAll.py /uscms/home/zhangjin/nobackup/ sig
#Example4(systematic -- MCTruth ): python Step2_PlotAll.py /uscms/home/zhangjin/nobackup/ mc
#Example2-4 are used for systematic calculation.
##################################################################################
from ROOT import *
from numpy import *
from Config import *
gROOT.SetStyle("Plain")
gStyle.SetPaintTextFormat("0.3g")
gStyle.SetOptStat(0)
from array import array as arr
Red = arr('d',[0.00, 0.00, 0.00, 1.00, 1.00])
Green = arr('d',[0.00, 0.10, 1.00, 1.00, 0.00])
Blue = arr('d',[1.00, 0.90, 0.00, 0.00, 0.00])
Length = arr('d',[0.00, 0.40, 0.60, 0.80, 1.00])
TColor.CreateGradientColorTable(5,Length,Red,Green,Blue,500)
gStyle.SetNumberContours(500)
import sys,os,re
if (sys.argv[0] == "python"): args=sys.argv[2:]
else: args=sys.argv[1:]
Prefix=""
Postfix=""
TagProbeFitResult=TagProbeFitResult.split("/")[-1]
ResultPlotsFileName=ResultPlotsFileName.split("/")[-1]
if len(args)>0:
for i in range(len(error_w1)):
g1 += error_w1[i]**2
g2 += error_w2[i]**2
s = error_w1[3]*error_w2[3]
t = error_w1[4]*error_w2[4]
global kor_matirx
kor_matirx = np.array([[g1, s+t], [ s+t, g2]])
kor_matirx_inv = inv(kor_matirx)
print kor_matirx
# --> set up MINUIT
myMinuit = TMinuit(npar) # initialize TMinuit with maximum of npar parameters
myMinuit.SetFCN(fcn) # set function to minimize
arglist = arr('d', 2*[0.01]) # set error definition
ierflg = Long(0)
arglist[0] = 1. # 1 sigma is Delta chi^2 = 1
myMinuit.mnexcm("SET ERR", arglist ,1,ierflg)
# --> Set starting values and step sizes for parameters
# Define the parameters for the fit
myMinuit.mnparm(1, "mean", 400, 0.001, 0,0,ierflg)
arglist[0] = 6000 # Number of calls to FCN before giving up.
arglist[1] = 0.3 # Tolerance
myMinuit.mnexcm("MIGRAD", arglist ,2,ierflg) # execute the minimisation
# --> check TMinuit status
amin, edm, errdef = Double(0.), Double(0.), Double(0.)
def _hesse(self, max_calls=6000):
# need to set the FCN explicitly before every call
self._get_gMinuit().SetFCN(self._minuit_fcn)
error_code = Long(0)
self._get_gMinuit().mnexcm("HESSE", arr('d', [max_calls]), 1, error_code)
