def connectResultFile(filename):
''' Given the result file produced by the Aligot extraction module, builds
a list of LDFs. '''
f = open(filename, 'r')
# Jump over the header
f.readline()
f.readline()
f.readline()
dbLDF = list()
for line in f:
inputs = line.split(":")[0]
outputs = line.split(":")[1].rstrip()
curLDF = LDF()
for inputParam in inputs.split(','):
inputAddr = inputParam.split('|')[0]
inputVal = inputParam.split('|')[1]
byteLength = len(inputVal)/2
if byteLength < curLDF.minLengthInput:
curLDF.minLengthInput = byteLength
if byteLength > curLDF.maxLengthInput:
curLDF.maxLengthInput = byteLength
p = parameter.parameter(inputAddr,byteLength, inputVal)
newId = len(curLDF.inputParameters.keys())
curLDF.inputParameters[newId] = p
for outputParam in outputs.split(','):
outputAddr = outputParam.split('|')[0]
outputVal = outputParam.split('|')[1]
byteLength = len(outputVal)/2
if byteLength < curLDF.minLengthOutput:
curLDF.minLengthOutput = byteLength
if byteLength > curLDF.maxLengthOutput:
curLDF.maxLengthOutput = byteLength
p = parameter.parameter(outputAddr,byteLength,outputVal)
newId = len(curLDF.outputParameters.keys())
curLDF.outputParameters[newId] = p
dbLDF.append(curLDF)
f.close()
return dbLDF
def connectResultFile(filename):
''' Given the result file produced by the Aligot extraction module, builds
a list of LDFs. '''
f = open(filename, 'r')
# Jump over the header
f.readline()
f.readline()
f.readline()
dbLDF = list()
for line in f:
inputs = line.split(":")[0]
outputs = line.split(":")[1].rstrip()
curLDF = LDF()
for inputParam in inputs.split(','):
inputAddr = inputParam.split('|')[0]
inputVal = inputParam.split('|')[1]
byteLength = len(inputVal) / 2
if byteLength < curLDF.minLengthInput:
curLDF.minLengthInput = byteLength
if byteLength > curLDF.maxLengthInput:
curLDF.maxLengthInput = byteLength
p = parameter.parameter(inputAddr, byteLength, inputVal)
newId = len(curLDF.inputParameters.keys())
curLDF.inputParameters[newId] = p
for outputParam in outputs.split(','):
outputAddr = outputParam.split('|')[0]
outputVal = outputParam.split('|')[1]
byteLength = len(outputVal) / 2
if byteLength < curLDF.minLengthOutput:
curLDF.minLengthOutput = byteLength
if byteLength > curLDF.maxLengthOutput:
curLDF.maxLengthOutput = byteLength
p = parameter.parameter(outputAddr, byteLength, outputVal)
newId = len(curLDF.outputParameters.keys())
curLDF.outputParameters[newId] = p
dbLDF.append(curLDF)
f.close()
return dbLDF
def is_done(self, job_id):
"""
Monitor AD Job is over
:param job_id:
:return:
"""
para = parameter.parameter(0, job_id)
friday_run = para.is_finish()
run_job = Execute.execute(self.version)
response = run_job.post(friday_run)
print("1************************")
print(response.status_code)
if response.status_code is not 200:
return None
else:
return_object = json.loads(json.loads(response.text)["string"])
if int(str(return_object["errorCode"])) == 200:
print(
"monitor",
str(job_id) + ": " + str(return_object["data"]["isDone"]))
return str(return_object["data"]["isDone"])
else:
return None
def run_ad(self, job_id):
"""
Monitor run ad number
:param job_id:
:return:
"""
para = parameter.parameter(0, job_id)
run_parameter = para.go_on_ad_to_order()
run_job = Execute.execute(self.version)
response = run_job.post(run_parameter)
print("1************************")
print(response.status_code)
if response.status_code is not 200:
return None
else:
return_object = json.loads(json.loads(response.text)["string"])
if int(str(return_object["errorCode"])) == 200:
implementation = return_object["data"]["totalAdCount"]
# for country in implementation:
# print("monitor", country)
return implementation
else:
return None
def run(self, version, is_all, week_id):
"""
Run AD Job
:return:
"""
parameter_function = parameter.parameter(week_id, 0)
if str("all") == str(is_all):
run_country = parameter_function.AllCountry()
elif str("jpn") == str(is_all):
run_country = parameter_function.JPN()
elif str("chn") == str(is_all):
run_country = parameter_function.CHN()
elif str("usa") == str(is_all):
run_country = parameter_function.USA()
else:
run_country = parameter_function.Other()
run_job = Execute.execute(version)
response = run_job.post(run_country)
print("1************************")
print(response.status_code)
if response.status_code is not 200:
return None
else:
return json.loads(response.text)["string"]
def __init__(self,obs,user_param,mat_mask):
self.obs = obs
self.hist_ELBO = []
self.hist_convergence = []
self.hist_sum_rmse = []
self.hist_rmse = [[]] * self.obs.N
self.hist_r2 = [[]] * self.obs.N
self.hist_rp = [[]] * self.obs.N
self.converged = False
self.user_param = user_param
self.mat_mask = mat_mask
self.isProgramError = False
self.param = parameter(self.obs,user_param)
self.param.rand_init(self.obs,self.user_param)
#==============================================================================
# Initialise auxillary variables
#==============================================================================
self.aux = aux_variable.aux_variable(self.obs)
for n in xrange(self.obs.N):
self.aux.R[n] = (self.param.Z[n] - aux_variable.get_F(self.param,n)) * self.mat_mask[n] # Signed zeros
#==============================================================================
# Initialise warping fucntion object
#==============================================================================
self.warping = [[]] * self.obs.N
for n in xrange(self.obs.N):
self.warping[n] = warping_functions.composite_warping(self.user_param.I_list,self.user_param.func_type_list)
def run_ad(self) -> json:
"""
Run ad use
:return: service return json
"""
print(self.url)
para = parameter.parameter(self.week, 0)
friday_run = para.AllCountry()
print(friday_run)
encode_str = DataEncoding.DataEncoding(json.dumps(friday_run))
encode_body = encode_str.DesEncrypt()
self.data["data"] = str(encode_body.replace(b'\n', b'').decode('utf-8'))
operation = json.dumps(self.data)
# print(operation)
response = requests.post(self.url, headers=self.headers, timeout=3,
data=operation)
# print(response.text)
return json.loads(response.text)["string"]
def is_done(self, job_id, url):
"""
Check job is done
:param job_id:
:return:
"""
para = parameter(0, job_id)
friday_run = para.is_finish()
encode_str = DataEncoding.DataEncoding(json.dumps(friday_run))
encode_body = encode_str.DesEncrypt()
self.data["data"] = str(
encode_body.replace(b'\n', b'').decode('utf-8'))
operation = json.dumps(self.data)
response = requests.post(url,
headers=self.headers,
timeout=5,
data=operation)
return_object = json.loads(json.loads(response.text)["string"])
if int(str(return_object["errorCode"])) == 200:
# print("job id :", job_id, "done is ", str(return_object["data"]["isDone"]))
logger.info("job id " + ":" + str(job_id) + "---" + "done is " +
str(return_object["data"]["isDone"]))
return str(return_object["data"]["isDone"])
else:
return None
def knotenCreation(name, nodetyp, options, fiList, kManager):
nodeTypes = "uniform", "normal", "exponential", "custom", "discrete", "percentage", "if", "switch", "function", "AND", "OR", "XOR", "NAND", "NOR", "XNOR", "==", ">", "<", ">=", "<=", "constraint", "Add", "Subtract", "Multiply", "Divide", "Sine", "Cosine", "Tangent", "Arcsine", "Arccosine", "Arctangent", "Power", "Logarithm", "Minimum", "Maximum", "Round", "Modulo", "Absolute", "stringlist", "output"
if nodetyp not in nodeTypes:
print("Error: no type")
return
#options zerstückeln
optionList = options.split(",")
df = pandas.read_csv("knotenlist.csv")
functionTypeParameters = df[nodetyp]
knotentyp = functionTypeParameters['Knoten']
newFunction = fi.functioninstance(name, nodetyp, knotentyp)
fiList.append(newFunction)
anzPara = functionTypeParameters['anzPara']
anzPara = np.int_(anzPara)
for x in range(anzPara):
print(np.int_(functionTypeParameters[x + 2]))
p = parameter.parameter(np.int_(functionTypeParameters[x + 2]), name,
kManager, optionList[x])
newFunction.addParameter(p, optionList[x])
print(functionTypeParameters)
print("create function Instance")
jw.printToJSON(fiList)
def inputMemoryAdjacency(ldf): ''' We group together input parameters that are adjacent in memory. ''' newInputParameters = dict() # id -> parameter memoryMap = dict() # addr (int) -> value (string) for ip in ldf.inputParameters.values(): # don't apply to registers|constants, we keep them as it if ip.startAddress == 'R' or ip.startAddress == 'C': newInputParameters[len(newInputParameters.keys())] = ip else: # feed the memory map for count in range(ip.length): byteAddr = int(ip.startAddress,16) + count if byteAddr in memoryMap.keys(): print 'ERROR: Already seen address (heuristics.outputMemoryAdjacency())' quit() memoryMap[byteAddr] = ip.value[count*2:(count*2)+2] curP = None for k in sorted(memoryMap.keys()): if curP is None: curP = parameter.parameter(hex(k)[2:],1,memoryMap[k]) else: # is it adjacent ? if k == (int(curP.startAddress,16) + curP.length): curP.incrementSize(memoryMap[k]) else: newInputParameters[len(newInputParameters.keys())] = curP curP = parameter.parameter(hex(k)[2:],1,memoryMap[k]) newInputParameters[len(newInputParameters.keys())] = curP l = list() for v in newInputParameters.values(): l.append(v.length) ldf.maxLengthInput = max(l) ldf.minLengthInput = min(l) ldf.inputParameters = newInputParameters
def inputMemoryAdjacency(ldf):
'''
We group together input parameters that are adjacent in memory.
'''
newInputParameters = dict() # id -> parameter
memoryMap = dict() # addr (int) -> value (string)
for ip in ldf.inputParameters.values():
# don't apply to registers|constants, we keep them as it
if ip.startAddress == 'R' or ip.startAddress == 'C':
newInputParameters[len(newInputParameters.keys())] = ip
else:
# feed the memory map
for count in range(ip.length):
byteAddr = int(ip.startAddress, 16) + count
if byteAddr in memoryMap.keys():
print 'ERROR: Already seen address (heuristics.outputMemoryAdjacency())'
quit()
memoryMap[byteAddr] = ip.value[count * 2:(count * 2) + 2]
curP = None
for k in sorted(memoryMap.keys()):
if curP is None:
curP = parameter.parameter(hex(k)[2:], 1, memoryMap[k])
else:
# is it adjacent ?
if k == (int(curP.startAddress, 16) + curP.length):
curP.incrementSize(memoryMap[k])
else:
newInputParameters[len(newInputParameters.keys())] = curP
curP = parameter.parameter(hex(k)[2:], 1, memoryMap[k])
newInputParameters[len(newInputParameters.keys())] = curP
l = list()
for v in newInputParameters.values():
l.append(v.length)
ldf.maxLengthInput = max(l)
ldf.minLengthInput = min(l)
ldf.inputParameters = newInputParameters
def _parse_next_sample(file, ports, format):
"""Parse the parameters for the next frequency point"""
data = _get_next_line_data(file)
# data lines always contain an even number of values (2 values
# per parameter), *unless* a frequency value is included in
# front
assert len(data) % 2 == 1
freq = data[0]
data = data[1:]
count = 0
port1 = port2 = 1
matrix = np.array([[None for i in range(ports)] for j in range(ports)],
dtype=complex)
while True:
for i in range(len(data) / 2):
index = 2 * i
args = {}
args[keys[format][0]] = data[index]
args[keys[format][1]] = data[index + 1]
try:
if ports == 2:
matrix[port1 - 1, port2 - 1] = parameter.parameter(**args)
else:
matrix[port2 - 1, port1 - 1] = parameter.parameter(**args)
except IndexError:
raise Exception("more ports than reported in the file "
"extension")
port1 += 1
if port1 > ports:
port2 += 1
port1 = 1
count += len(data) / 2
if port2 > ports:
break
data = _get_next_line_data(file)
if len(data) % 2 != 0:
raise Exception("less ports than reported in the file extension")
assert count == ports**2
return (freq, matrix)
def _parse_next_sample(file, ports, format):
"""Parse the parameters for the next frequency point"""
data = _get_next_line_data(file)
# data lines always contain an even number of values (2 values
# per parameter), *unless* a frequency value is included in
# front
assert len(data) % 2 == 1
freq = data[0]
data = data[1:]
count = 0
port1 = port2 = 1
matrix = np.array([[None for i in range(ports)]
for j in range(ports)], dtype=complex)
while True:
for i in range(len(data) / 2):
index = 2 * i
args = {}
args[keys[format][0]] = data[index]
args[keys[format][1]] = data[index + 1]
try:
if ports == 2:
matrix[port1 - 1, port2 - 1] = parameter.parameter(**args)
else:
matrix[port2 - 1, port1 - 1] = parameter.parameter(**args)
except IndexError:
raise Exception("more ports than reported in the file "
"extension")
port1 += 1
if port1 > ports:
port2 += 1
port1 = 1
count += len(data) / 2
if port2 > ports:
break
data = _get_next_line_data(file)
if len(data) % 2 != 0:
raise Exception("less ports than reported in the file extension")
assert count == ports**2
return (freq, matrix)
def payment(self, version, week_id):
"""
Run AD payment
:return:
"""
parameter_function = parameter.parameter(week_id, 0)
run_payment = parameter_function.payment()
run_job = Execute.execute(version)
response = run_job.post(run_payment)
if response.status_code is not 200:
return None
else:
return json.loads(response.text)["string"]
def generate_bmv2_parser(self):
available_structs = scope.get_available_types(only_type="struct")
self.struct_name = available_structs.keys()[randomizer.randint(
0,
len(available_structs) - 1)]
scope.start_local()
_parameter = parameter(type_ref=prefixed_type(
value={self.struct_name: available_structs[self.struct_name]}))
scope.insert_parameter("meta", "struct", _parameter)
_parser_states = parser_states()
_parser_states.randomize()
_parser_local_elements = parser_local_elements()
_parser_local_elements.randomize()
code = "parser ParserImpl(packet_in packet,\nout headers_t hdr,\ninout " + self.struct_name + " meta,\ninout standard_metadata_t standard_metadata) {\n" + _parser_local_elements.generate_code(
) + "\n" + _parser_states.generate_code() + "\n}\n\n"
scope.stop_local()
return code
def generate_netfpga_parser(self):
available_structs = scope.get_available_types(only_type="struct")
self.struct_name = available_structs.keys()[randomizer.randint(
0,
len(available_structs) - 1)]
scope.start_local()
_parameter = parameter(type_ref=prefixed_type(
value={self.struct_name: available_structs[self.struct_name]}))
scope.insert_parameter("user_metadata", "struct", _parameter)
_parser_states = parser_states()
_parser_states.randomize()
_parser_local_elements = parser_local_elements()
_parser_local_elements.randomize()
code = "parser TopParser(packet_in b,\nout Parsed_packet p,\nout " + self.struct_name + " user_metadata,\nout digest_data_t digest_data,\ninout sume_metadata_t sume_metadata) {\n" + _parser_local_elements.generate_code(
) + "\n" + _parser_states.generate_code() + "\n}\n\n"
scope.stop_local()
return code
def generate_netfpga_controls(self):
available_structs = scope.get_available_types(only_type="struct")
scope.start_local()
_parameter = parameter(type_ref=prefixed_type(
value={self.struct_name: available_structs[self.struct_name]}))
scope.insert_parameter("user_metadata", "struct", _parameter)
scope.start_local()
_control_local_declarations = control_declaration_creation()
_control_local_declarations.randomize()
available_tables = scope.get_available_tables()
table = available_tables.keys()[randomizer.randint(
0,
len(available_tables) - 1)]
scope.stop_local()
code = "control TopPipe(inout Parsed_packet headers,\ninout " + self.struct_name + " user_metadata,\ninout digest_data_t digest_data,\ninout sume_metadata_t sume_metadata) {\n" + _control_local_declarations.generate_code(
) + "\napply {\n" + table + ".apply();\n}\n}\n\n"
scope.stop_local()
code += "control TopDeparser(packet_out b, in Parsed_packet p, in " + self.struct_name + " user_metadata,\ninout digest_data_t digest_data,\ninout sume_metadata_t sume_metadata) {\napply {\n}\n}\n\n"
return code
def is_error(self, job_id, url):
"""
Check job is done
:param job_id:
:return:
"""
para = parameter(0, job_id)
friday_run = para.is_error()
encode_str = DataEncoding.DataEncoding(json.dumps(friday_run))
encode_body = encode_str.DesEncrypt()
self.data["data"] = str(
encode_body.replace(b'\n', b'').decode('utf-8'))
operation = json.dumps(self.data)
response = requests.post(url,
headers=self.headers,
timeout=10,
data=operation)
return_object = json.loads(json.loads(response.text)["string"])
# print(return_object)
job_str = "job id: " + str(job_id)
# print(str(job_str).center(50, '='))
number = 0
if int(str(return_object["errorCode"])) == 200:
items = list(
return_object["data"]["jobProcessedRecordExecResultList"])
# print(str(items).center(50, '='))
for item in items:
if int(item["errorCode"]) != 200:
number += 1
logger.info(item)
# logger.info(str(item))
logger.info(
(str(job_str) + ' error number: ' + str(number)).center(
50, '='))
def command(self,cmd):
print "Engine Command"
data=cmd.split()
if data[0] == "GET":
print "GET"
if len(data) == 2:
key=data[1]
return self.param[ key ].getValue()
elif data[0] == "SET":
print "SET"
if len(data) == 3:
key=data[1]
val=data[2]
if self.param.has_key( key ):
print "Param Exists"
return self.param[ key ].setValue(val)
else:
print "Param Create"
public=True
self.param[ key ] = p.parameter( val, public )
return "OK"
elif data[0] == "DUMP":
print "DUMP"
elif data[0] == "SUB":
if len(data) == 3:
key=data[1]
qid=data[2]
if self.param.has_key( key ):
self.param[ key ].subscribe(qid)
else:
print "What ? ", cmd
def generate_bmv2_controls(self):
available_structs = scope.get_available_types(only_type="struct")
scope.start_local()
_parameter = parameter(type_ref=prefixed_type(
value={self.struct_name: available_structs[self.struct_name]}))
scope.insert_parameter("meta", "struct", _parameter)
scope.start_local()
_control_local_declarations = control_declaration_creation()
_control_local_declarations.randomize()
available_tables = scope.get_available_tables()
table = available_tables.keys()[randomizer.randint(
0,
len(available_tables) - 1)]
scope.stop_local()
code = "control IngressImpl(inout headers_t hdr,\ninout " + self.struct_name + " meta,\ninout standard_metadata_t standard_metadata) {\n" + _control_local_declarations.generate_code(
) + "\napply {\n" + table + ".apply();\n}\n}\n\n"
scope.stop_local()
code += "control EgressImpl(inout headers_t hdr,\ninout " + self.struct_name + " meta,\ninout standard_metadata_t standard_metadata) {\napply {\n\n}\n}\n\n"
code += "control VerifyChecksumImpl(inout headers_t hdr, inout " + self.struct_name + " meta) {\napply {\n\n}\n}\n\n"
code += "control ComputeChecksumImpl(inout headers_t hdr, inout " + self.struct_name + " meta) {\napply {\n}\n}\n\n"
code += "control DeparserImpl(packet_out packet, in headers_t hdr) {\napply {\n}\n}\n\n"
return code
def checkparam(self):
#check and fill in all the default parameters
#need to modify the value depend on q1 and q2
if 'u1' not in self.paradic or 'u2' not in self.paradic:
if 'q1' not in self.paradic or 'q2' not in self.paradic:
self.paramarr.append(parameter(self.requiredpara['u1'],0.,0.,'u1'))
self.paradic['u1']=len(self.paramarr)-1
self.paramarr.append(parameter(self.requiredpara['u2'],0.,0.,'u2'))
self.paradic['u2']=len(self.paramarr)-1
else:
u1,u2=self.cal_LD_qtou(self.readpara('q1').val,self.readpara('q2').val)
self.paramarr.append(parameter(u1,0.,0.,'u1'))
self.paradic['u1']=len(self.paramarr)-1
self.paramarr.append(parameter(u2,0.,0.,'u2'))
self.paradic['u2']=len(self.paramarr)-1
if 'b2' not in self.paradic:
if 'b' not in self.paradic:
self.paramarr.append(parameter(self.requiredpara['b'],0.,0.,'b'))
self.paramarr.append(parameter(self.requiredpara['b2'],0.,0.,'b2'))
else:
para_b=copy.deepcopy(self.readpara('b'))
para_b2=parameter(para_b.val**2.,para_b.upper**2.,para_b.lower**2.,'b2',fitflag=para_b.fitflag,xmin=0,xmax=1)
if para_b.fitflag==1:
#print self.paradic['b']
self.paramarr[int(self.paradic['b'])]=para_b2
self.paradic['b2']=self.paradic['b']
#self.paramarr.append(para_b)
#self.paradic['b']=len(self.paramarr)-1
#self.readpara('b').fitflag=0
for key,value in self.requiredpara.iteritems():
if key not in self.paradic:
self.paramarr.append(parameter(value,0.,0.,key))
self.paradic[key]=len(self.paramarr)-1
return
def parameter(self, week, type):
data = {"data": None}
# 1. run weekId
para = parameter.parameter(week)
fridayRun = ""
if str("All") == type:
fridayRun = para.AllCountry()
elif str("JPN") == type:
fridayRun = para.JPN
elif str("CHN") == type:
fridayRun = para.CHN()
elif str("USA") == type:
fridayRun = para.USA()
elif str("Other") == type:
fridayRun = para.Other()
encodestr = DataEncoding.DataEncoding(json.dumps(fridayRun))
encodebody = encodestr.DesEncrypt()
data["data"] = str(encodebody.replace(b'\n', b'').decode('utf-8'))
Operation = json.dumps(data)
return Operation
def parameter(self, varname, prop):
''' add parameter to the paralist'''
lib = self.get_lib(prop['lib'])
var = lib[prop['obj']].get(prop['prop'])
self.paralist[varname] = parameter(var)
#!/usr/bin/env python
import parameter as p
fred=p.parameter("TEST")
print fred.getValue()
stuff={}
stuff["NAME"]=fred
tst=stuff["NAME"]
print tst.getValue()
#-*- coding: utf-8 -*-
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
import time
from datetime import datetime
from selenium.webdriver.support.ui import WebDriverWait
import logging
import os
lis=0
from parameter import parameter
from system import system
par=parameter()
syst=system()
if not os.path.isdir('c:\\TEST_log\\niutouwenxinlog\\'):
os.makedirs('c:\\TEST_log\\niutouwenxinlog\\')
logFileName = 'c:\\TEST_log\\niutouwenxinlog\\%s.log' %time.strftime("%m-%d-%H-%M-%S",time.localtime(time.time()))
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', filename=logFileName, level=logging.DEBUG)
#################################################################################################
#定义一个StreamHandler，将INFO级别或更高的日志信息打印到标准错误，并将其添加到当前的日志处理对象#
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
#################################################################################################
logging.info('####################')
logging.info('# Begin Test #')
logging.info('####################')
num_list[i] = text.text_get()
i = i + 1
print(num_list)
area = num_list[0] * num_list[1] + 3.14 * (
num_list[2] / 2)**2 + num_list[3] * num_list[4] / 2
area = round(area, 3)
result = StringVar()
result_input = StringVar()
if num_list[0] != 0:
result_input = '矩形 ' + '长：' + str(num_list[0]) + '厘米 ' + '宽：' + str(
num_list[1]) + '厘米 '
elif num_list[2] != 0:
result_input = '圆 ' + '直径：' + str(num_list[2]) + '厘米 '
elif num_list[3] != 0:
result_input = '三角形 ' + '底：' + str(num_list[3]) + '厘米 ' + '高：' + str(
num_list[4]) + '厘米 '
result_area = str(area)
result = result_input + '面积：' + result_area + '平方厘米'
contentVar_area.set(result)
print(area)
window.title('面积计算器')
paramparameter1 = parameter(num_list, contentVar_area)
tkinter.Button(window, text="英尺转化为厘米",
command=partial(unit, paramparameter1)).grid(row=6, column=1)
tkinter.Button(window, text="确定", command=partial(getarea,
area)).grid(row=6, column=2)
mainloop()
def run_ad(self, job_id, url, total_count):
"""
Get job executing statistic result
:param job_id:
:return:
"""
total_processed_count = 0
para = parameter(0, job_id)
friday_run = para.go_on_ad_to_order()
encode_str = DataEncoding.DataEncoding(json.dumps(friday_run))
encode_body = encode_str.DesEncrypt()
self.data["data"] = str(
encode_body.replace(b'\n', b'').decode('utf-8'))
operation = json.dumps(self.data)
# print(url)
# print(friday_run)
response = requests.post(url,
headers=self.headers,
timeout=5,
data=operation)
# print(response.text)
# print(json.loads(response.text)["string"])
return_object = json.loads(json.loads(response.text)["string"])
if int(str(return_object["errorCode"])) == 200:
if return_object["data"]["totalAdCount"] is not None:
total_ad_count = list(return_object["data"]["totalAdCount"])
# print("*******************************************")
# print(total_ad_count)
for item in total_ad_count:
country_item = dict(item)
# print(country_item["countryCode"], country_item["totalProcessedCount"])
logger.info(country_item["countryCode"] + "---" +
str(country_item["totalProcessedCount"]))
total_processed_count += int(
country_item["totalProcessedCount"])
# print("job id :", job_id, "total count :", total_processed_count)
logger.info("job id:" + str(job_id) + " --- total count: " +
str(total_count) + ", Run total count: " +
str(total_processed_count))
if any(self.job_processed_total_count) is False:
# print('test 1')
self.job_processed_total_count[job_id] = total_processed_count
self.job_stop_count[job_id] = 1
else:
# print('test 2')
hasCount = 0
# print("test count")
for key in self.job_processed_total_count.keys():
# print('test 2')
if int(key) == job_id:
hasCount = 1
# print('hasCount = 1')
# print(self.job_processed_total_count[key])
# print('total_processed_count = %s' % total_processed_count)
if int(self.job_processed_total_count[key]
) == total_processed_count:
self.job_stop_count[job_id] += 1
else:
self.job_stop_count[job_id] = 1
if hasCount == 0:
# print('hasCount = 0')
self.job_processed_total_count[job_id] = total_processed_count
self.job_stop_count[job_id] = 1
# print('job stop count')
for key in self.job_stop_count.keys():
# print('error ?')
# print(self.job_stop_count[key])
if int(self.job_stop_count[key]) > 6:
logger.info(
"Job id: %s stop run. please Restart the new thread." %
key)
# print(self.job_stop_count)
# print(total_count[0])
# print(total_processed_count)
return int(total_count[0]) - int(total_processed_count)
def __init__(self,obs,user_param,mat_mask):
self.obs = obs
self.hist_ELBO = []
self.hist_sum_rmse = []
self.hist_convergence = []
self.hist_rmse = [[]] * self.obs.N
self.converged = False
self.user_param = user_param
self.mat_mask = mat_mask
self.isProgramError = False
#==============================================================================
# Initialise parameters
#==============================================================================
self.param = parameter(self.obs,user_param)
self.param.rand_init(self.obs,self.user_param)
#==============================================================================
# Initialise auxillary variables
#==============================================================================
print 'Aux initialising ...'
self.aux = aux_variable.aux_variable(self.obs,self.user_param)
if self.obs.decomposed_u:
self.aux.P_u = self.obs.P_u.copy()
self.aux.Q_u = self.obs.Q_u.copy()
self.aux.Q_u_inv = self.obs.Q_u_inv.copy()
else:
if self.obs.Sigma_u.shape[0] == self.obs.Sigma_u.shape[1]:
self.aux.P_u,self.aux.Q_u,self.aux.Q_u_inv,self.param.delta_u = aux_variable.svd(self.obs.Sigma_u,self.user_param.R[0])
else:
self.aux.P_u,self.aux.Q_u_inv,self.aux.Q_u,self.param.delta_u = aux_variable.svd(numpy.linalg.pinv(self.obs.Sigma_u.T))
self.aux.PQinvPt_u = self.aux.P_u.dot(self.aux.Q_u_inv).dot(self.aux.P_u.T)
self.aux.inv_Sigma_u = self.aux.PQinvPt_u + numpy.diag(numpy.full((self.obs.D),self.param.delta_u))
self.aux.Sigma_u = aux_variable.matrix_inv(numpy.full((self.obs.D),self.param.delta_u),self.aux.P_u,self.aux.Q_u_inv)
self.aux.logdet_Sigma_u = numpy.linalg.slogdet(self.aux.Sigma_u)[1]
if self.obs.decomposed_v:
self.aux.P_v = self.obs.P_v.copy()
self.aux.Q_v = self.obs.Q_v.copy()
self.aux.Q_v_inv = self.obs.Q_v_inv.copy()
else:
if self.obs.Sigma_v.shape[0] == self.obs.Sigma_v.shape[1]:
self.aux.P_v,self.aux.Q_v,self.aux.Q_v_inv,self.param.delta_v = aux_variable.svd(self.obs.Sigma_v.T,self.user_param.R[1])
else:
self.aux.P_v,self.aux.Q_v_inv,self.aux.Q_v,self.param.delta_v = aux_variable.svd(numpy.linalg.pinv(self.obs.Sigma_v.T))
self.aux.PQinvPt_v = self.aux.P_v.dot(self.aux.Q_v_inv).dot(self.aux.P_v.T)
self.aux.inv_Sigma_v = self.aux.PQinvPt_v + numpy.diag(numpy.full((self.obs.G),self.param.delta_v))
self.aux.Sigma_v = aux_variable.matrix_inv(numpy.full((self.obs.G),self.param.delta_v),self.aux.P_v,self.aux.Q_v_inv)
self.aux.logdet_Sigma_v = numpy.linalg.slogdet(self.aux.Sigma_v)[1]
for n in xrange(self.obs.N):
self.aux.R[n] = (self.param.Z[n] - aux_variable.get_F(self.param,n)) * self.mat_mask[n] # Signed zeros
for k in xrange(self.user_param.K):
self.aux.S_u[:,k] = numpy.diag(self.param.C_u[k])
self.aux.S_v[:,k] = numpy.diag(self.param.C_v[k])
#==============================================================================
# Initialise warping fucntion object
#==============================================================================
self.warping = [[]] * self.obs.N
for n in xrange(self.obs.N):
self.warping[n] = warping_functions.composite_warping(self.user_param.I_list,self.user_param.func_type_list)
def __init__(self):
self.funktionsList = {}
self.nameList = []
self.connectionList = []
print("funktionsmanager created")
mathnodes = [
"Add", "Subtract", "Multiply", "Divide", "Sine", "Cosine",
"Tangent", "Arcsine", "Arccosine", "Arctangent", "Power",
"Logarithm", "Minimum", "Maximum", "Round", "Modulo", "Absolute"
]
for a in mathnodes:
add = funktion.funktion(a, "MathNode", self)
addp1 = parameter.parameter("Value 1", "Number")
addp2 = parameter.parameter("Value 2", "Number")
addOut = parameter.parameter("Result", "Number")
add.parameterList.append(addp1)
add.parameterList.append(addp2)
add.setOutput(addOut)
self.funktionsList[add.getName()] = add
output = funktion.funktion("Output", "OutputNode", self)
outputp1 = parameter.parameter("Input", "Number")
output.parameterList.append(outputp1)
self.funktionsList[output.getName()] = output
uniform = funktion.funktion("Uniform", "UniformNode", self)
uni1 = parameter.parameter("Seed", "Number")
uni2 = parameter.parameter("Min", "Number")
uni3 = parameter.parameter("Max", "Number")
uni4 = parameter.parameter("Discrete", "Boolean")
uniout = parameter.parameter("Output", "Number")
uniform.parameterList.append(uni1)
uniform.parameterList.append(uni2)
uniform.parameterList.append(uni3)
uniform.parameterList.append(uni4)
uniform.setOutput(uniout)
self.funktionsList[uniform.getName()] = uniform
normal = funktion.funktion("Normal", "NormalNode", self)
nor1 = parameter.parameter("Seed", "Number")
nor2 = parameter.parameter("Mean", "Number")
nor3 = parameter.parameter("Std. Dev.", "Number")
nor4 = parameter.parameter("Discrete", "Boolean")
norout = parameter.parameter("Output", "Number")
normal.parameterList.append(nor1)
normal.parameterList.append(nor2)
normal.parameterList.append(nor3)
normal.parameterList.append(nor4)
normal.setOutput(norout)
self.funktionsList[normal.getName()] = normal
exponential = funktion.funktion("Exponential", "ExponentialNode", self)
exp1 = parameter.parameter("Seed", "Number")
exp2 = parameter.parameter("Lambda", "Number")
exp3 = parameter.parameter("Discrete", "Boolean")
expout = parameter.parameter("Output", "Number")
exponential.parameterList.append(exp1)
exponential.parameterList.append(exp2)
exponential.parameterList.append(exp3)
exponential.setOutput(expout)
self.funktionsList[exponential.getName()] = exponential
percentage = funktion.funktion("Percentage", "PercentageNode", self)
per1 = parameter.parameter("Value", "Number")
per2 = parameter.parameter("Seed", "Number")
per3 = parameter.parameter("Percentage", "Number")
per4 = parameter.parameter("Discrete", "Boolean")
perout = parameter.parameter("Output", "Number")
percentage.parameterList.append(per1)
percentage.parameterList.append(per2)
percentage.parameterList.append(per3)
percentage.parameterList.append(per4)
percentage.setOutput(perout)
self.funktionsList[percentage.getName()] = percentage
logicnodes = ["AND", "OR", "XOR", "NAND", "NOR", "XNOR"]
for a in logicnodes:
add = funktion.funktion(a, "LogicNode", self)
addp1 = parameter.parameter("A", "Boolean")
addp2 = parameter.parameter("B", "Boolean")
addOut = parameter.parameter("Result", "Boolean")
add.parameterList.append(addp1)
add.parameterList.append(addp2)
add.setOutput(addOut)
self.funktionsList[add.getName()] = add
logicnodes = [
"Equals", "Greater", "Smaller", "GreaterThan", "SmallerThan"
]
for i in logicnodes:
add = funktion.funktion(i, "BooleanNode", self)
addp1 = parameter.parameter("Value 1", "Number")
addp2 = parameter.parameter("Value 2", "Number")
addp3 = parameter.parameter("Round Values", "Boolean")
addp4 = parameter.parameter("Invert Output", "Boolean")
addOut = parameter.parameter("Result", "Boolean")
add.parameterList.append(addp1)
add.parameterList.append(addp2)
add.parameterList.append(addp3)
add.parameterList.append(addp4)
add.setOutput(addOut)
self.funktionsList[add.getName()] = add
index = funktion.funktion("Index", "IndexValueNode", self)
indout = parameter.parameter("Output", "Number")
index.setOutput(indout)
self.funktionsList[index.getName()] = index
custom = funktion.funktion("Custom", "CustomNode", self)
cus1 = parameter.parameter("Seed", "String")
cus2 = parameter.parameter("Min", "Number")
cus3 = parameter.parameter("Max", "Number")
cus4 = parameter.parameter("Discrete", "Boolean")
cusout = parameter.parameter("Output", "Number")
custom.parameterList.append(cus1)
custom.parameterList.append(cus2)
custom.parameterList.append(cus3)
custom.parameterList.append(cus4)
custom.setOutput(cusout)
self.funktionsList[custom.getName()] = custom
discrete = funktion.funktion("Discrete", "DiscreteNode", self)
dis1 = parameter.parameter("Seed", "String")
dis2 = parameter.parameter("Min", "Number")
dis3 = parameter.parameter("Max", "Number")
disout = parameter.parameter("Output", "Number")
discrete.parameterList.append(dis1)
discrete.parameterList.append(dis2)
discrete.parameterList.append(dis3)
discrete.setOutput(disout)
self.funktionsList[discrete.getName()] = discrete
ifnode = funktion.funktion("If", "IfNode", self)
if1 = parameter.parameter("Condition", "Boolean")
if2 = parameter.parameter("True Value", "Boolean")
if3 = parameter.parameter("False Value", "Boolean")
ifout = parameter.parameter("Output", "Boolean")
ifnode.parameterList.append(if1)
ifnode.parameterList.append(if2)
ifnode.parameterList.append(if3)
ifnode.setOutput(ifout)
self.funktionsList[ifnode.getName()] = ifnode
switch = funktion.funktion("Switch", "SwitchNode", self)
sw1 = parameter.parameter("Switch", "Boolean")
sw2 = parameter.parameter("Value 1", "Boolean")
sw3 = parameter.parameter("Value 2", "Boolean")
swout = parameter.parameter("Output", "Boolean")
sw2.setCustom()
sw3.setCustom()
switch.parameterList.append(sw1)
switch.parameterList.append(sw2)
switch.parameterList.append(sw3)
switch.setOutput(swout)
self.funktionsList[switch.getName()] = switch
func = funktion.funktion("Function", "FunctionNode", self)
f1 = parameter.parameter("input", "Boolean")
f1.setCustom()
fout = parameter.parameter("output", "Boolean")
func.parameterList.append(f1)
func.setOutput(fout)
self.funktionsList[func.getName()] = func
con = funktion.funktion("Constraint", "ConstraintNode", self)
con1 = parameter.parameter("Is Valid", "Boolean")
con.parameterList.append(con1)
self.funktionsList[con.getName()] = con
stringl = funktion.funktion("StringList", "StringListNode", self)
s1 = parameter.parameter("Index", "Number")
sout = parameter.parameter("String", "String")
stringl.parameterList.append(s1)
stringl.setOutput(sout)
self.funktionsList[stringl.getName()] = stringl
def fitlc_parse(options):
p = ConfigParser.RawConfigParser()
try:
p.read(options.cfgfile)
except IOError:
print "configure file missing"
raise
# parse lc format
try:
setattr(options.lc, "infile", p.get("Section LC", "infile"))
setattr(options.lc, "cadence", eval(p.get("Section LC", "cadence")))
if options.infile == "":
if options.lc.infile == "":
delattr(options.lc, "infile")
raise ConfigParser.NoOptionError(p, "infile")
else:
setattr(options.lc, "infile", options.infile)
except ConfigParser.MissingSectionHeaderError:
raise "Error: Section LC missing, excute set_parse to see example.cfg"
except ConfigParser.NoOptionError:
try:
setattr(options.lc, "inlist", p.get("Section LC", "inlist"))
except ConfigParser.NoOptionError:
raise "Error: Can not find neither a light curve file and its cadence or a list of light curve files for fitting purpose"
try:
setattr(options.lc, "inpath", p.get("Section LC", "inpath"))
except ConfigParser.NoOptionError:
print "Warning: Can not find the input path of light curves, use current directory by default"
setattr(options.lc, "inpath", "")
try:
setattr(options.lc, "coljd", int(p.get("Section LC", "coljd")))
except ConfigParser.NoOptionError:
print "Warning: Can not find the input column of jds in light curves, use column 1 by default"
setattr(options.lc, "coljd", 1)
try:
setattr(options.lc, "colmag", int(p.get("Section LC", "colmag")))
except ConfigParser.NoOptionError:
print "Warning: Can not find the input column of jds in light curves, use column 2 by default"
setattr(options.lc, "colmag", 2)
# parse fitting options
setattr(options.mcmc, "nwalkers", int(p.get("Section MCMC", "nwalkers")))
setattr(options.mcmc, "nburn", int(p.get("Section MCMC", "nburn")))
setattr(options.mcmc, "niter", int(p.get("Section MCMC", "niter")))
setattr(options.mcmc, "nthreads", int(p.get("Section MCMC", "nthreads")))
if options.output == "":
setattr(options.mcmc, "output", p.get("Section MCMC", "output"))
else:
setattr(options.mcmc, "output", options.output)
# parse parameter options
freeparams = p.get("Section FreeParameters", "freeparams").split(",")
for i in xrange(len(freeparams)):
try:
freeargs = p.get("Section FreeParameters", freeparams[i]).split(",")
if len(freeargs) == 3:
val, upper, lower = freeargs
options.params.append(parameter(float(val), float(upper), float(lower), freeparams[i], fitflag=1))
elif len(freeargs) == 5:
val, upper, lower, xmin, xmax = freeargs
options.params.append(
parameter(float(val), float(upper), float(lower), freeparams[i], fitflag=1, xmin=xmin, xmax=xmax)
)
else:
raise ValueError
except ValueError:
raise ValueError, "Free Parameters %s need to be given as val,upper,lower (,xmin,xmax) format in configure file" % freeparams[
i
]
fixparams = p.get("Section FixedParameters", "fixparams").split(",")
for i in xrange(len(fixparams)):
options.params.append(
parameter(float(p.get("Section FixedParameters", fixparams[i])), 0, 0, fixparams[i], fitflag=0)
)
return
def randomize(self): rnd = randomizer.randint(self.min_list_size, self.max_list_size) for x in range(0, rnd): _parameter = parameter() _parameter.randomize() self.parameter_list.append(_parameter)
def parameter(self,varname,prop):
''' add parameter to the paralist'''
lib = self.get_lib(prop['lib'])
var = lib[prop['obj']].get(prop['prop'])
self.paralist[varname] = parameter(var)
#-*- coding: utf-8 -*-
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
import time
from datetime import datetime
from selenium.webdriver.support.ui import WebDriverWait
import logging
import os
from parameter import parameter
from system import system
para=parameter()
syst=system()
lis=0
if not os.path.isdir('c:\\TEST_log\\iheimalog\\'):
os.makedirs('c:\\TEST_log\\iheimalog\\')
logFileName = 'c:\\TEST_log\\iheimalog\\%s.log' %time.strftime("%m-%d-%H-%M-%S",time.localtime(time.time()))
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', filename=logFileName, level=logging.DEBUG)
logging.info('####################')
logging.info('# Begin Test #')
logging.info('####################')
def strB2Q(ustring):
"""半角转全角"""
rstring = ""
for uchar in ustring:
inside_code=ord(uchar)
if inside_code == 32: #半角空格直接转化
Dmax = 300
U_hubbard = 0.5 # density interaction
JH = 0.1 # Hund's
U = {
'12': U_hubbard,
'13': U_hubbard - 0.5 * JH,
'14': U_hubbard,
'23': U_hubbard,
'24': U_hubbard - 0.5 * JH,
'34': U_hubbard
}
J = -0.5 * JH
ed = np.ones(4) * (-1.5 * U_hubbard) #fix half filling
E0 = 0.0
para = parameter(D=Dmax, ed=ed, U=U, J=J, E0=E0, N_=1000)
#--------------------------------
# init solver
#--------------------------------
st = time.time()
solver = dmft_self_consistent(para)
solver.initialize_()
solver.dmft_iteration()
print("One iter time = ", (time.time() - st) / 60.0)
