def translatePosteriorQuantitiesTom(self): "Returns posterior summary shorthands useful for computation of posterior quantities e.g. posterior mean" "These quantities translate from Murphy's notation to Griffiths&Sanborn's notation" if self.observations != None: "Prior Params" a0 = dc(self.v0) sigma0 = dc(self.sigma0) u0 = dc(self.mu0) lambda0 = dc(self.k0) "Empirical Moments 1&2" s2 = np.var(self.observations) # Variance in the data? xbar = np.mean(self.observations) #sample mean of the data? "Posterior Params" lambdai = lambda0 + self.n ai = a0 + self.n ui = ((lambda0*u0)+(self.n*xbar))/(lambda0 + self.n) sigmai_topleft = (a0*sigma0)+((self.n-1)*s2) sigmai_topright = ((lambda0*self.n)/(lambda0+self.n))*pow(u0-xbar,2) sigmai_bottom = a0+self.n sigmai = (sigmai_topleft+sigmai_topright)/sigmai_bottom return ui,lambdai,ai,sigmai else: return None, None, None, None
def start_split_data(data_list):
random_list = dc(data_list)
random.shuffle(random_list)
mark = 0
acc_list = []
for i in range(1): # fold range
test_list = []
training_list = []
index = 0
while (mark < int(len(random_list))):
for train_e in range(0, mark):
training_list.append(random_list[train_e])
else:
index = mark
mark = int(len(random_list) / 10) + index
for test_element in range(index, mark):
test_list.append(random_list[test_element])
for training_element in range(mark, int(len(random_list))):
training_list.append(random_list[training_element])
# fold completion
root = Node(training_list)
root.node_type = 'root'
build_tree(root)
predicted_list = []
temp = dc(root)
for element in test_list:
predicted_list.append(class_finder(element, temp))
acc_list.append(accuracy(test_list, predicted_list))
break
print(mean(acc_list))
def __init__(self,system, epsAgent = RandomAgent(),
gamma = 0.9, lam = 0.9, eps = 0.05):
self.system = dc(system)
self.epsAgent = dc(epsAgent)
self.numTrt = Agent.numTrt(system)
self.numNodes = system.network.numNodes
self.numValidTrt = Agent.numValidTrt(numNodes,numTrt)
self.iters = 0
self.q = [[0]*numValidTrt for i in range(1 << numNodes)]
self.e = [[0]*numValidTrt for i in range(1 << numNodes)]
self.c = [[0]*numValidTrt for i in range(1 << numNodes)]
self.gamma = gamma
self.lam = lam
self.eps = eps
self.system.cleanse()
self.system.wipeTrt()
self.system.start()
self.epsAgent.applyTrt(self.system)
self.st = self.system.infInd()
self.at = combo2Ind(self.system.trtInd(),numNodes,numTrt)
def update_info(self,infojson,globalpath):
l1("Updating content for %s"%self.oname)
# reset
self.content['fields'] = dc(self.basefields)
self.content['trigger'] = dc(self.basetrigger)
# update
for f in sorted(self.content['files'].keys()):
l2("%s: "%f)
for field in self.content['files'][f].keys():
if field=='colour': new_value = raw_input("%s? [%s(%s)]"%(field,str(self.content['files'][f][field]),str(infojson['colours'][self.content['files'][f]['tag']])))
elif field=='xsec': new_value = raw_input("%s? [%s(%s)]"%(field,str(self.content['files'][f][field]),str(infojson['crosssections'][self.content['files'][f]['tag']])))
elif field=='trigger':
rootf = TFile.Open(os.path.join(globalpath,f))
h2 = rootf.FindObjectAny('TriggerNames;1')
if not h2: sys.exit('TriggerNames;1 problematic for %s. Exiting'%f)
trigarray = self.help_TrigArray(h2)
rootf.Close()
self.content['files'][f][field] = ','.join(trigarray)
print "trigger: %s"%(self.content['files'][f][field])
elif field=='npassed':
rootf = TFile.Open(os.path.join(globalpath,f))
h1 = rootf.FindObjectAny('TriggerPass;1')
if not h1: sys.exit('TriggerPass;1 problematic for %s. Exiting'%f)
npassed = h1.GetBinContent(1)
rootf.Close()
self.content['files'][f][field] = "%d"%npassed
print "npassed: %s"%(self.content['files'][f][field])
else: new_value = raw_input("%s? [%s]"%(field,str(self.content['files'][f][field])))
if not new_value == "": self.content['files'][f][field] = new_value
for field in ['scale']:
new_value = raw_input("%s? [%s]"%(field,"%f"%(float(self.content['files'][f]['npassed'])/float(self.content['files'][f]['xsec'])) if not float(self.content['files'][f]['xsec'])==-1 else "-1"))
if not new_value == "": self.content['files'][f][field] = new_value
else: self.content['files'][f][field] = "%f"%(float(self.content['files'][f]['npassed'])/float(self.content['files'][f]['xsec'])) if not float(self.content['files'][f]['xsec'])==-1 else "-1"
self.print_info()
self.write_info()
def getKFWght(opts,loadedSamples,sel,trg):
inroot('float nDat=0.0, nQCD=0.0, nBkg=0.0;')
inroot('TH1F *hDat = new TH1F("hDat","hDat",1,0,1);')
inroot('TH1F *hQCD = new TH1F("hQCD","hQCD",1,0,1);')
inroot('TH1F *hBkg = new TH1F("hBkg","hBkg",1,0,1);')
### LOOP over samples
for s in loadedSamples:
### Skip some
if any([x in s['tag'] for x in ['JetMon','VBF','GluGlu']]): continue
if opts.debug: l3("%sSample: %s%s"%(purple,s['tag'],plain))
### Clean some
if opts.debug and 'KFAC' in opts.weight[1]: l3("Option specified k-factor and puWt ignored in k-factor calculation.")
opts.weightlocal = dc(opts.weight)
opts.weightlocal[1] = list(set(opts.weight[1])-set(['KFAC','PU']))
### Get cut and weight
trg,trg_orig = trigData(opts,s,trg)
cut = write_cuts(sel,trg,sample=s['tag'],jsonsamp=opts.jsonsamp,jsoncuts=opts.jsoncuts,weight=opts.weightlocal,trigequal=trigTruth(opts.usebool))[0]
trg = dc(trg_orig)
if opts.debug: l3("Cut: %s"%cut)
### Data
if 'Data' in s['tag'] or 'DataV' in s['tag']:
inroot('%s.draw("%s","%s","%s")'%(s['pointer'],ROOT.hDat.GetName(),"0.5",cut))
### QCD
elif 'QCD' in s['tag']:
inroot('%s.draw("%s","%s","%s")'%(s['pointer'],ROOT.hQCD.GetName(),"0.5",cut))
### Bkg
else:
inroot('%s.draw("%s","%s","%s")'%(s['pointer'],ROOT.hBkg.GetName(),"0.5",cut))
print "Data: %8.2f | Bkg: %8.2f | QCD: %8.2f"%(ROOT.hDat.Integral(),ROOT.hBkg.Integral(),ROOT.hQCD.Integral())
### finish
KFWght = (ROOT.hDat.Integral()-ROOT.hBkg.Integral())/ROOT.hQCD.Integral()
inroot('delete hDat; delete hQCD; delete hBkg;')
if opts.debug: l2("KFWght calculated at: %f"%KFWght)
return KFWght
def __init__(self, inhibitory = 1.0,initialQ = 0.0, delta_c = 0.0, tau_c = 1.0, tau_r = 0.00000001, tau_e = 10.0*ms):
assert(tau_c > 0)
assert(tau_r > 0)
assert(tau_e > 0)
assert(delta_c >= 0)
assert(inhibitory == 1 or inhibitory == -1)
self.inhibitory = inhibitory
self.q = dc(initialQ)
self.delta_c = dc(delta_c)
self.c = 0.0
self.tau_c = dc(tau_c)
self.tau_r = dc(tau_r)
self.tau_e = dc(tau_e)
self.state = 'A'
self.trace_e = 0.0
self.spiked = False
self.etrack = 0
self.epsilonsqtrack = 0
self.epsilontrack = 0
self.correctedcounter =0
self.errorcorrelation = 0
self.errortrack = 0
self.avcounter = 1
self.processed = False
self.grad = 0
self.samples = 0
def doRatio( num, den ) : num1 = dc(num) den1 = dc(den) ratio = dc(num1) ratio.Divide(num1,den1,1.,1.,'b') ratio.SetMinimum(0.7) ratio.SetMaximum(1.1) return ratio
def bulk_process(folder, start_eid, her_name): searchstr = folder + '*.xml' cur_eid = dc(start_eid) for filename in glob.glob(searchstr): print filename next = process(filename, cur_eid, her_name) cur_eid = dc(next) + 1
def __init__(self,oname):
self.oname = oname
self.content = {}
self.content['files'] = {}
self.content['other'] = []
self.content['fields'] = {'fname':35,'npassed':12,'xsec':12,'scale':15,'tag':18,'trigger':35,'colour':8} # field lengths
self.content['trigger'] = ['HLT_QuadPFJet75_55_35_20_BTagCSV_VBF_v* OR HLT_QuadPFJet75_55_38_20_BTagCSV_VBF_v* OR HLT_QuadPFJet78_61_44_31_BTagCSV_VBF_v* OR HLT_QuadPFJet82_65_48_35_BTagCSV_VBF_v*','HLT_QuadJet75_55_35_20_BTagIP_VBF_v* OR HLT_QuadJet75_55_38_20_BTagIP_VBF_v*','HLT_QuadPFJet75_55_35_20_BTagCSV_VBF_v*','HLT_QuadPFJet75_55_38_20_BTagCSV_VBF_v*','HLT_QuadPFJet78_61_44_31_BTagCSV_VBF_v*','HLT_QuadPFJet82_65_48_35_BTagCSV_VBF_v*','HLT_QuadJet75_55_35_20_BTagIP_VBF_v*','HLT_QuadJet75_55_38_20_BTagIP_VBF_v*','HLT_DiJet35_MJJ650_AllJets_DEta3p5_VBF_v*','HLT_DiJet35_MJJ700_AllJets_DEta3p5_VBF_v*','HLT_DiJet35_MJJ750_AllJets_DEta3p5_VBF_v*','HLT_QuadJet50_v*','HLT_PFJet80_v*','HLT_DiPFJetAve40_v*','HLT_DiPFJetAve80_v*']
self.basefields = dc(self.content['fields'])
self.basetrigger = dc(self.content['trigger'])
self.read_info()
def start_split_data(data_list):
random_list = dc(data_list)
random.shuffle(random_list)
mark = 0
acc_list = []
test_list = []
training_list = []
for i in range(10): # fold range
test_list = []
training_list = []
index = 0
while (mark < int(len(random_list))):
for train_ele in range(0, mark):
training_list.append(random_list[train_ele])
else:
index = mark
mark = int(len(random_list) / 10) + index
for test_element in range(index, mark):
test_list.append(random_list[test_element])
for training_element in range(mark, int(len(random_list))):
training_list.append(random_list[training_element])
# print(training_list)
# fold completion
# creating validation set
v_list = random.sample(list(training_list),
int(len(training_list) * 0.25))
for v_item in v_list:
if v_item in training_list:
training_list.remove(v_item)
# print(len(training_list))
# print(len(v_list))
Node.v_list = v_list
Node.children = []
Node.leaf_children = []
Node.temp_children = []
Node.new_children = []
Node.len_training_list = len(training_list)
Node.old_pessi_err = \
(node_err_cal(training_list, max_class(training_list,
class_column),
class_column) + 1) / Node.len_training_list
root = Node(training_list)
Node.root = root
# print(root.data)
root.node_type = 'root'
build_tree(root)
predicted_list = []
temp_root = dc(root)
for test_element in test_list:
predicted_list.append(class_finder(test_element,
temp_root))
acc_list.append(
accuracy(test_list, predicted_list, class_column))
break
print(mean(acc_list))
def nuts(atoms, e, iterations, wtraj=None):
traj = [atoms]
configuration_list = []
try:
for m in range(iterations):
# XXX ERRORR HERE
# initialize momenta
rand_momenta = np.random.normal(0, 1, (len(atoms), 3))
atoms.set_momenta(rand_momenta)
# get slice variable
u = np.random.uniform(0, np.exp(-1 * traj[-1].get_total_energy()))
# u = np.random.uniform(0, traj[-1].get_total_energy())
# print u
# initialize negative and positive directions
neg_atoms = dc(traj[-1])
pos_atoms = dc(traj[-1])
c = [dc(traj[-1])]
j, s = 0, 1
while s == 1:
print('depth', j, 'samples', 2 ** j)
v = np.random.choice([-1, 1])
if v == -1:
# build tree in negative direction
neg_atoms, _, cp, sp = buildtree(neg_atoms, u, v, j, e)
else:
_, pos_atoms, cp, sp = buildtree(pos_atoms, u, v, j, e)
if sp == 1:
c += cp
datoms = pos_atoms.positions - neg_atoms.positions
s = sp * \
(np.dot(datoms.flatten(),
neg_atoms.get_momenta().flatten()) >= 0) * \
(np.dot(datoms.flatten(),
pos_atoms.get_momenta().flatten()) >= 0)
j += 1
print(m, len(c))
configuration_list.append(c)
energies = np.asarray([atoms.get_total_energy() for atoms in c])
sample_pos = np.random.choice(range(len(c)),
p=np.exp(-energies) / np.exp(
-energies).sum())
# sample_pos = np.random.choice(range(len(C)))
# sample_pos = np.argmin(energies)
# XXX ERROR HERE
if wtraj is not None:
wtraj.write(atoms)
traj.append(c[sample_pos])
except KeyboardInterrupt:
if wtraj is not None:
wtraj.write(atoms)
return traj, configuration_list
def trigData(opts,s,trg): #print "in: ",trg if s=="" and (not opts.datatrigger==[]): trg_orig = dc(trg) trg = opts.datatrigger[opts.trigger.index(trg)] elif (not s==None) and (not opts.datatrigger==[]) and any([x in s['tag'] for x in ['Data','DataV','JetMon']]): trg_orig = dc(trg) trg = opts.datatrigger[opts.trigger.index(trg)] else: trg_orig = dc(trg) #print "out: ",trg,trg_orig return trg, trg_orig
def __init__(self, atoms, restart=None, logfile=None, trajectory=None,
seed=None,
verbose=False):
Optimizer.__init__(self, atoms, restart, logfile, trajectory)
atoms.get_forces()
atoms.get_potential_energy()
if seed is None:
seed = np.random.randint(0, 2 ** 31)
self.verbose = verbose
self.random_state = RandomState(seed)
self.starting_atoms = dc(atoms)
self.traj = [dc(atoms)]
self.pe = []
self.metadata = {'seed': seed}
def do_fill(opts,fout,s,v,sel,trg,ref,KFWght=None,skipWght=None):
# info
l2("Filling for %s"%v['var'])
# containers
cuts = {}
cutlabels = {}
names = {}
canvas = TCanvas("cfill","cfill",1200,1000)
# trg
trg, trg_orig = trigData(opts,s,trg)
# names
jsoninfo = json.loads(filecontent(opts.jsoninfo))
names['global'] = getNames(opts,s,v,sel,trg_orig,ref)
keepMapInfo = None
if skipWght==True:
keepMapInfo = [x for x in opts.weight[1] if (x[0:3]=='MAP' or x[0:3]=='FUN' or x[0:3]=='COR')]
opts.weight[1] = [dc(x) for x in opts.weight[1] if not (x[0:3]=='MAP' or x[0:3] == 'FUN' or x[0:3]=='COR')]
wpars = weightInfo(opts.weight,KFWght)
# TEffi object
TEffi = TEffiType(v)
# looping over different tags
for tag in ['Num','Den']:
# cuts
cuts[tag],cutlabels[tag] = write_cuts(sel,trg if tag=='Num' else ['None'],reftrig=ref,sample=s['tag'],jsonsamp=opts.jsonsamp,jsoncuts=opts.jsoncuts,weight=opts.weight,KFWght=KFWght,varskip=opts.skip+[v['root']],trigequal=trigTruth(opts.usebool))
if opts.debug: l3("Cut %s: %s%s%s: %s"%(tag,blue,cutlabels[tag],plain,cuts[tag]))
# loading/filling
names[tag] = getNames(opts,s,v,sel,trg_orig if tag=='Num' else ['None'],ref,tag)
if not s['tag'] in TEffi.h[tag] or TEffi.h[tag][s['tag']]==None:
fout.Delete(names[tag]['hist'])
TEffi.fill(s['pointer'],s['tag'],tag,names[tag],cuts[tag])
if opts.debug: l3("%sFilled: %40s(N=%9d, Int=%9d)%s"%(yellow,TEffi.h[tag][s['tag']].GetName(),TEffi.h[tag][s['tag']].GetEntries(),TEffi.h[tag][s['tag']].Integral(),plain))
# consider ratio
tag = 'Rat'
names[tag] = getNames(opts,s,v,sel,trg_orig,ref,tag)
TEffi.effi(names[tag],jsoninfo['colours'][s['tag']],markerStyle(s['tag'],jsoninfo['markers'][s['tag']],opts))
# write histogram to file
path = "%s/%s/%s"%('turnonCurves',wpars,names['global']['path-turnon'])
TEffi.write(fout,path)
# clean
#TEffi.delete()
canvas.Close()
trg = dc(trg_orig)
if skipWght==True:
opts.weight[1] += keepMapInfo
def start_split_data(data_list):
random_list = dc(data_list)
random.shuffle(random_list)
mark = 0
acc_list = []
class_count = len(set(list(c[class_column] for c in data_list)))
for i in range(10): # fold range
test_list = []
training_list = []
index = 0
while (mark < int(len(random_list))):
for train_ele in range(0, mark):
training_list.append(random_list[train_ele])
else:
index = mark
mark = int(len(random_list) / 10) + index
for test_element in range(index, mark):
test_list.append(random_list[test_element])
for training_element in range(mark, int(len(random_list))):
training_list.append(random_list[training_element])
# print(training_list)
# fold completion
Node.children = []
Node.leaf_children = []
Node.temp_children = []
Node.new_children = []
Node.len_training_list = len(training_list)
Node.class_count = class_count
Node.old_mdl = \
(Node.node_count - Node.leaf_node_count) * \
log2(len(column_names)) \
+ \
(Node.leaf_node_count * log2(Node.class_count))\
+\
(len(data_list) * log2(len(data_list)))
root = Node(training_list)
# print(root.data)
root.node_type = 'root'
build_tree(root)
predicted_list = []
temp_root = dc(root)
for test_element in test_list:
predicted_list.append(
class_finder(test_element, temp_root))
acc_list.append(
accuracy(test_list, predicted_list, class_column))
break
print(mean(acc_list))
def check_dict_alg(dic, validator, entry_list, messages, whole_validator, current_elem):
"""This function does the real validation work by working through the validator.
:param dic: The dictionary you want to validate.
:type dic: dict
:param validator: The validator you want to validate against.
:type validator: dict
:param entry_list: This list contains all keys you have to traverse to get the correct value in the dictionary.
:type entry_list: list
:param messages: The message list you want to append the error messages to.
:type messages: dict
:param whole_validator: This is a copy of the whole validator needed when referencing to a top level key.
:type whole_validator: dict
:param current_elem: The current element the alg is checking.
:type current_elem: str
:return: Nothing.
"""
for node in validator:
print("Checking node ", node)
new_list = dc(entry_list)
node_value = validator[node]
if node != 'isReference':
if not ('isReference' in node_value and len(entry_list) == 0):
if is_operator(node):
handle_operator(node, dic, validator, new_list, messages, whole_validator, current_elem)
elif is_leaf(node_value):
new_list.append(node)
check_leaf(node_value, dic, new_list, messages, current_elem)
else:
new_list.append(node)
check_dict_alg(dic, node_value, new_list, messages, whole_validator, current_elem)
def fromPol(cls,pol,copyPol=True):
a = cls()
if copyPol:
a.pol = dc(pol)
else:
a.pol = pol
return a
def shell_dynstep_sort(sequence):
'''
希尔排序
动态改变步长
'''
seq = dc(sequence)
pass
def svd(self):
"""SVD filter"""
self.fspec=np.zeros(self.spec.shape)
self.u=[]
self.s=[]
self.v=[]
for k in range(self.nscan):
sind=self.getscanind(k)
x=self.spec[sind]
x[np.isnan(x)]=0
u,s,v=np.linalg.svd(x,full_matrices=True)
ss=dc(s)
ss[0]=0
SS=np.zeros(x.shape)
sz=x.shape[0]
SS[:sz,:sz]=np.diag(ss);
z=np.dot(u,np.dot(SS,v))
#for k in range(sz):
# y=z[k];ind=np.arange(500,1000);p=np.polyfit(self.f[ind],y[ind],deg=3);
# z[k]=y-np.poly1d(p)(self.f);
self.fspec[sind]=z
self.u.append(u)
self.s.append(s)
self.v.append(v)
return u,s,v,self.fspec
def runsim(din=None):
if din is None:
# Dummy trajectory
din=reduc_spec.data((2016,6,25,5,13,45),(2016,6,25,5,45,0))
d=dc(din)
# Sky model, only atmosphere and CMB (included as T0 param to am) for now
#sm=skymodel(comp=['atm','cmb'])
sm=skymodel(comp=['atm'])
# Signal only (in K)
d=gensig().run(d,sm)
# Add noise
d=addTrx(d,Trx=150)
# Mock ambient temp cal stares
d=makecal(d)
# Convert to power units
d=T2I(d)
# Multiply by gain
d=multgain(d)
# Add non-linearity
d=addnonlin(d,0.01)
return d
def convert_adjacency(cells, spacing, J, adj=None):
"""Convert the J matrix of a QCACircuit to the specified adjacency type."""
if adj is None:
return dc(J)
params = prepare_convert_adj(cells, spacing, J)
if adj == "full":
J_ = convert_to_full_adjacency(J, *params)
elif adj == "lim":
J_ = convert_to_lim_adjacency(J, *params)
else:
J_ = dc(J)
return J_
def infer_diag_post(self,X_ii,D_i):
X_i = dc(X_ii)
ns = len(D_i)
X_i.resize([ns,self.D])
[m,V] = self.infer_diag(X_i,D_i)
if sp.amin(V)<=-0.:
class MJMError(Exception):
pass
print "negative/eq variance"
print [m,V,X_i,D_i]
print "_______________"
#self.printc()
raise(MJMError)
if sp.amin(sp.var(m,axis=0))<-0.:
class MJMError(Exception):
pass
print "negativevar of mean"
print X_i.shape
print [m,V,sp.var(m,axis=0),X_i,D_i]
print "_______________"
#self.printc()
raise(MJMError)
return [sp.mean(m,axis=0).reshape([1,ns]),(sp.mean(V,axis=0)+sp.var(m,axis=0)).reshape([1,ns])]
def convert_adjacency(cells, spacing, J, adj=None):
'''Convert the J matrix of a QCACircuit to the specified adjacency type.'''
if adj is None:
return dc(J) # deepcopy
params = prepare_convert_adj(cells, spacing, J)
if adj=='full':
J_ = convert_to_full_adjacency(J, *params)
elif adj=='lim':
J_ = convert_to_lim_adjacency(J, *params)
else:
J_ = dc(J)
return J_
def check_dict_alg(dic, validator, entry_list, messages, whole_validator, current_elem):
"""This function does the real validation work by working through the validation.
Args:
dic(dict): The dictionary you want to validate.
validator(dict): The validation you want to validate against.
entry_list(list: list): This list contains all keys you have to traverse to get the correct value in the dictionary.
messages(dict): The message list you want to append the error messages to.
whole_validator(dict): This is a copy of the whole validation needed when referencing to a top level key.
current_elem(str): The current element the alg is checking.
entry_list:
Returns:
"""
for node in validator:
new_list = dc(entry_list)
node_value = validator[node]
if node != 'isReference':
if not ('isReference' in node_value and len(entry_list) == 0):
if is_operator(node):
handle_operator(
node, dic, validator, new_list, messages, whole_validator, current_elem
)
elif is_leaf(node_value):
new_list.append(node)
check_leaf(node_value, dic, new_list, messages, current_elem)
else:
new_list.append(node)
check_dict_alg(
dic, node_value, new_list, messages, whole_validator, current_elem
)
def leapfrog(atoms, step, center=True):
"""
Propagate the dynamics of the system via the leapfrog algorithm one step
Parameters
-----------
atoms: ase.Atoms
The atomic configuration for the system
step: float
The step size for the simulation, the new momentum/velocity is step *
the force
center: bool
If true, center the atoms in the cell after moving them
Returns
-------
ase.Atoms
The new atomic positions and velocities
"""
latoms = dc(atoms)
latoms.set_momenta(latoms.get_momenta() + 0.5 * step * latoms.get_forces())
latoms.positions += step * latoms.get_velocities()
latoms.set_momenta(latoms.get_momenta() + 0.5 * step * latoms.get_forces())
if center:
latoms.center()
return latoms
def do_fill(opts,fout,s,v,sel,trg,ref,KFWght=None):
trg,trg_orig = trigData(opts,s,trg)
# cut
cut,cutlabel = write_cuts(sel,trg,reftrig=ref,sample=s['tag'],jsonsamp=opts.jsonsamp,jsoncuts=opts.jsoncuts,weight=opts.weight,KFWght=KFWght,trigequal=trigTruth(opts.usebool))
if opts.debug: l3("Cut: %s%s%s: %s"%(blue,cutlabel,plain,cut))
# names
sample = s['pointer']
names = getNames(opts,s,v,sel,trg_orig,ref)
wpars = weightInfo(opts.weight,KFWght)
# containers
canvas = TCanvas("cfill","cfill",1200,800)
fout.Delete(names['hist'])
h = TH1F(names['hist'],names['hist-title'],int(v['nbins_x']),float(v['xmin']),float(v['xmax']))
h.Sumw2()
# do actual filling
inroot('%s.draw("%s","%s","%s")'%(sample,h.GetName(),v['root'],cut))
if opts.debug: l3("%sFilled: %40s(N=%9d, Int=%9d)%s"%(yellow,h.GetName(),h.GetEntries(),h.Integral(),plain))
# write histogram to file
gDirectory.cd('%s:/'%fout.GetName())
path = "%s/%s/%s"%('plots',wpars,names['path-hist'])
makeDirsRoot(fout,path)
gDirectory.cd(path)
h.Write(h.GetName(),TH1.kOverwrite)
gDirectory.cd('%s:/'%fout.GetName())
# clean
h.Delete()
canvas.Close()
trg = dc(trg_orig)
def fromQ(cls,q,copyQ=True):
a = cls()
if copyQ:
a.q = dc(q)
else:
a.q = q
return a
def __init__(self,h=None): # initialization using a hamiltonian
self.file_right_green = "green_right.dat" # in/out file for right green
self.file_left_green = "green_left.dat" # in/out file for left green
self.file_heff = "heff.dat" # out for the effective hamiltonian
self.scale_rc = 1.0 # scale coupling to the right lead
self.scale_lc = 1.0 # scale coupling to the left lead
self.is_sparse = False
self.dimensionality = 1 # default is one dimensional
self.delta = 0.0001
self.interpolated_selfenergy = False
self.block_diagonal = False
if h is not None:
self.heff = None # effective hamiltonian
self.right_intra = h.intra # intraterm in the right lead
self.right_inter = h.inter # interterm in the right lead (to the right)
self.right_green = None # right green function
self.left_intra = h.intra # intraterm in the left lead
self.left_inter = h.inter.H # interterm in the left lead (to the left)
self.left_green = None # left green function
self.central_intra = h.intra # intraterm in the center
self.right_coupling = h.inter # coupling from the center to the right lead
self.left_coupling = h.inter.H # coupling from the center to the left lead
# geometry of the central part
gc = dc(h.geometry)
self.central_geometry = gc # geometry of the central part
# additional degrees of freedom
self.has_spin = h.has_spin # spin degree of freedom
self.has_eh = h.has_eh # electron hole pairs
def bellRes(iters,system,agent,q,gamma = 0.9):
system = dc(system)
numNodes = system.network.numNodes
iters = iter(iters)
sa = iters.next()
system.infCmb(cmb = sa[0])
system.trtCmb(cmb = sa[1])
q0 = q(system)
br = 0.0
nIters = 0
for sap in iters:
system.infCmb(cmb = sap[0])
system.wipeTrt()
r = systems.reward(sa[0],sa[1],sap[0],numNodes)
agent.applyTrt(system)
q1 = q(system)
br += q0 - r - gamma * q1
nIters += 1
br /= float(nIters)
return br
def ring_blur_mask(img, geometry, alpha, bins=None, mask=None):
if mask is None:
mask = np.zeros(img.shape).astype(bool)
r = geometry.rArray(img.shape)
int_r = np.around(r / geometry.pixel1).astype(int)
if bins is None:
bins = int_r.max() + 1
mr = dc(r)
mr[mask] = -1
# integration
mean = sts.binned_statistic(mr.ravel(), img.ravel(), bins=bins,
range=[0, mr.max()], statistic='mean')[0]
std = sts.binned_statistic(mr.ravel(), img.ravel(), bins=bins,
range=[0, mr.max()], statistic=np.std)[0]
threshold = alpha * std
lower = mean - threshold
upper = mean + threshold
# single out the too low and too high pixels
too_low = img < lower[int_r]
too_hi = img > upper[int_r]
mask = mask | too_low | too_hi
return mask.astype(int)
def del_atom(atoms, chem_potentials, beta, random_state):
"""
Parameters
----------
atoms: ase.Atoms object
The atomic configuration
chem_potentials: dict
A dictionary of {"Chemical Symbol": mu} where mu is a float denoting
the chemical potential
beta: float
The thermodynamic beta
random_state: np.random.RandomState object
The random state to be used
Returns
-------
atoms or None:
If the new configuration is accepted then the new atomic configuration
is returned, else None
"""
if len(atoms) <= 1:
return None
print(len(atoms))
# make the proposed system
atoms_prime = dc(atoms)
e0 = atoms.get_potential_energy()
del_atom_index = random_state.choice(range(len(atoms)))
del_symbol = atoms_prime[del_atom_index].symbol
# append new atom to system
del atoms_prime[del_atom_index]
# get new energy
delta_energy = atoms_prime.get_potential_energy() - e0
# get chemical potential
# print delta_energy
mu = chem_potentials[del_symbol]
# calculate acceptance
if np.random.random() < np.exp(
min([0, -1. * beta * delta_energy - beta * mu
])) and not np.isnan(delta_energy):
return atoms_prime
else:
return None
def train(self, iterations=10, maxmiss=10):
"""
Train using Recommended Greedy Algorithm
"""
scores = {
'Iteration': [],
#'Network':[],
'Score': []
}
score_check = maxmiss
niter = iterations
best = score_pom(export_pom(self.net, by='label'), self.data)
#print("START LOOP")
while score_check > 0 and niter > 0:
n = dc(self.net)
upd = set()
ops = [n.add_edge, n.del_edge, n.rev_edge]
for f in ops:
edge = rn.sample(self.E, 1)[0]
f(edge[0], edge[1])
upd.add(edge[0])
upd.add(edge[1])
if n.acyclic():
n.calc_cpt(self.data, alpha=self.alpha, change=upd)
score = score_pom(export_pom(n, by='label'), self.data)
scores['Iteration'].append(iterations - niter)
#scores['Network'].append(n)
scores['Score'].append(score)
#print(best, score, niter, score_check)
if score > best:
self.net = n
best = score
niter = niter - 1
score_check = maxmiss
continue
else:
score_check = score_check - 1
niter = niter - 1
continue
else:
niter = niter - 1
continue
self.scores = scores
def next_move(obj, piece, pre, board, move_number, depth):
'''CORE CONTROLLER'''
if move_number == 1:
return (2, 1)
if move_number == 2:
options = [(2, 1), (2, 2), (2, 3), (1, 2), (3, 2), (1, 1), (3, 3)]
for opt in options:
if board[opt[0]][opt[1]] == 0 and obj.get_liberty_single(
opt[0], opt[1])[1] == 4:
return opt
obj1 = dc(obj)
available = obj1.get_valid_locations(piece)
if len(available) == 0 or move_number > 24:
return "PASS"
if depth == -100:
# greedy
bestEval = -float('inf')
for child in available:
val = greedy(obj1, piece, child[0], child[1])
if val > bestEval:
bestEval = val
best_child = child
else:
best_child = available[0]
best_immediate = available[0]
maxEval = -float('inf')
maxImm = -float('inf')
for child in available:
md = depth
immediate_kills = greedy(obj1, piece, child[0], child[1])
if immediate_kills > maxImm:
maxImm = immediate_kills
best_immediate = child
if maxImm > 1:
return best_immediate
for child in available:
md = depth
val = alphabeta(obj1, piece, child[0], child[1], md, -float('inf'),
float('inf'), True, move_number)
if val > maxEval:
best_child = child
maxEval = val
return best_child
def periodic_standardize(self, factor: str, prefix: str = 'std_'):
"""
Standardize a factor periodically.
:param factor: (str) The name of factor will be standardized.
:param prefix: (str) The prefix preceding a name of standardized factor.
:return standardized_companies: (DataFrame) Standardized companies for each period by factor.
"""
unstandardized_companies = dc(self.loc[~np.isnan(self[factor]), :])
unstandardized_companies[prefix +
factor] = unstandardized_companies.groupby(
by=[DATE])[factor].transform(
lambda x: (x - x.mean()) / x.std())
standardized_companies = unstandardized_companies
return standardized_companies
def hidden_board(Ctn):
hidden_indexes = set(range(len(Ctn.hexagons)))
prmpt = 'Choose yellow tile number to reveal (or type quit to exit): '
clear_Catan(Ctn)
distribute_resources(Ctn)
distribute_numbers(Ctn)
nIMG = dc(Ctn.IMG)
for i in range(len(Ctn.hexagons)):
hexagon = Ctn.hexagons[i]
nIMG = replace_with_res(nIMG, Ctn.unit_hex, hexagon, Ctn.Res, 'water')
nIMG = place_unplotted_number(nIMG, i, hexagon)
plot_board(nIMG)
print("You have the following options: ")
print("1) Type quit to exit out of the program.")
print("2) Type an integer of a yellow number hex to reveal it.")
print("3) To reveal multiple hexes at a time, separate the integers "+\
"with a comma with no space inbetween (e.g. 3,4,6)")
print("4) Type all to reveal the remaining hidden hexes.")
while len(hidden_indexes) != 0:
reveal_index = input(prmpt)
if reveal_index == 'quit':
break
elif reveal_index == 'all':
for i in hidden_indexes:
hexagon = Ctn.hexagons[i]
nIMG = replace_with_res(nIMG, Ctn.unit_hex, hexagon, Ctn.Res)
nIMG = place_number(nIMG, hexagon.number, Ctn.Nums, hexagon)
plot_board(nIMG)
break
indexes = reveal_index.split(',')
for hex_index in indexes:
try:
i = int(hex_index)
except ValueError:
print("Unrecognized value entered. Make sure it is an "+\
"integer which has not been revealed yet. Try again... ")
continue
if i not in hidden_indexes:
print("Either this number has already been revealed or it "+\
"is not on the board. Try again... ")
continue
hexagon = Ctn.hexagons[i]
nIMG = replace_with_res(nIMG, Ctn.unit_hex, hexagon, Ctn.Res)
nIMG = place_number(nIMG, hexagon.number, Ctn.Nums, hexagon)
hidden_indexes.remove(i)
plot_board(nIMG)
def quicksort(numere):
lista = dc(numere)
less = []
equal = []
greater = []
if len(lista) > 1:
pivot = lista[0]
for x in lista:
if x < pivot:
less.append(x)
elif x == pivot:
equal.append(x)
elif x > pivot:
greater.append(x)
return quicksort(less) + equal + quicksort(greater)
else:
return lista
def sub_mean(matrix_, type='user'):
matrix = dc(matrix_)
c = Counter(matrix.nonzero()[0])
means_matrix = matrix.sum(axis=1)
means_matrix = np.reshape(means_matrix, [means_matrix.shape[0], 1])
for i in range(means_matrix.shape[0]):
if i in list(c.keys()):
means_matrix[i, 0] = means_matrix[i, 0] / float(c[i])
else:
means_matrix[i, 0] = 0
mask = matrix != 0
nz_val = np.array(np.nonzero(matrix))
nz_val = list(zip(nz_val[0], nz_val[1]))
for val in nz_val:
matrix[val[0], val[1]] -= means_matrix[val[0]]
return matrix
def obl_parametry(self, arg, wart):
"""
dopasowuje parametry funkcji scatcharda do danych b i b/F -
:return: zapisuje parametry jako self.parametry
"""
#TODO NIE WYCH
something_is = False
nr_comb = 0
max_r = 0
while True:
try:
parametry_wejsciowe = np.array(comb[nr_comb])
except:
if something_is:
pass
# print("znaleziono nieoptymalne parametry")
else:
print("NIE znaleziono optymalnych parametrów")
break
nr_comb += 1
# print(comb[nr_comb])
try:
# if len(arg) <= 4 or len(wart) != len(arg):
# print(len(arg),len(wart))
# if len(arg) <= 2:
# print(self.nazwa, self.zwrot_ok(), len(self.szczury))
parametry = curve_fit(scatchard_curv,
arg,
wart,
p0=parametry_wejsciowe,
bounds=[0, 300])[0]
r = get_r(*self.zwrot_ok()[0:2], parametry)
if r > max_r:
max_r = r
self.parametry = dc(parametry)
if r >= 0.98:
with open("optimal_start_params.txt", 'a') as plik:
plik.write(str(parametry_wejsciowe) + '\n')
print('znaleziono optymalne parametry')
break
something_is = True
with open("good_start_params.txt", 'a') as plik:
plik.write(str(parametry_wejsciowe) + '\n')
except:
pass
def build_flash_data(data, required_measures):
flash_data = {}
for sensor_id in required_measures:
sensor_type = required_measures[sensor_id]["type"]
sensor_period = required_measures[sensor_id]["period"]
flash_data[sensor_id] = dc(data[sensor_type])
flash_data[sensor_id]["records"] = []
flash_data[sensor_id]["type"] = sensor_type
flash_data[sensor_id]["period"] = sensor_period
# build an array containing boolean value corresponding to the item in the array of the possible measurment
for measure in data[sensor_type]["value"]:
flash_data[sensor_id]["records"].append(
measure in required_measures[sensor_id]["measure"])
return flash_data
def Fill(self):
if self.legpos == 0: self.leg = ROOT.TLegend(0.5, 0.3, 0.88, 0.6)
if self.legpos == 1: self.leg = ROOT.TLegend(0.35, 0.73, 0.88, 0.88)
if self.legpos == 2: self.leg = ROOT.TLegend(0.4, 0.25, 0.88, 0.7)
if self.legpos == 3: self.leg = ROOT.TLegend(0.5, 0.7, 0.88, 0.88)
if self.legpos == 4: self.leg = ROOT.TLegend(0.4, 0.16, 0.88, 0.35)
if self.legpos == 5: self.leg = ROOT.TLegend(0.4, 0.16, 0.88, 0.5)
if self.legpos == 6: self.leg = ROOT.TLegend(0.25, 0.16, 0.88, 0.5)
if self.legpos == 7: self.leg = ROOT.TLegend(0.6, 0.2, 0.88, 0.3)
if self.legpos == 8: self.leg = ROOT.TLegend(0.3, 0.16, 0.88, 0.35)
if self.legpos == 9: self.leg = ROOT.TLegend(0.3, 0.16, 0.88, 0.5)
if self.legpos == 10: self.leg = ROOT.TLegend(0.22, 0.16, 0.88, 0.35)
self.leg.SetTextSize(0.027)
self.leg.SetFillColor(ROOT.kWhite)
self.leg.SetLineColor(ROOT.kWhite)
myjson = {}
for i, graph in enumerate(self.graphs):
if graph.function:
print '\n=====> Fitting %s' % graph.graph
fitter = Fitter(graph.graph,
graph.function,
colour=graph.colour)
graph.graph, graph.grapherror, results = fitter._fit()
graph.fittedfunction = dc(graph.function)
graph.fittedfunction.SetName(graph.fittedfunction.GetName() +
'%d' % i)
self.graphse.append(graph.grapherror)
if self.json:
if not self.json.endswith('.json'):
self.json = json + '.json'
myjson.update({
graph.legend: {
results.GetParameterName(i): results.GetParams()[i]
for i in range(results.NPar())
}
})
self.Add(graph.graph)
self.leg.AddEntry(graph.graph, graph.legend, graph.legendOpt)
f1 = open(self.json, 'a')
print >> f1, json.dumps(myjson, indent=4)
f1.close()
def findMonster(image, monsterStruct):
def isMatch(mask, toCheck):
for (x, y) in zip(mask, toCheck):
if x == '#' and y == '.':
return False
return True
res = 0
for flip, rotate in tileCombi:
modImage = modified(dc(image), flip, rotate)
for rowIdx, row in enumerate(modImage[1:-1]):
for offset in range(len(modImage) - len(monsterImg[1])):
if isMatch(monsterImg[1], row[offset:]) and \
isMatch(monsterImg[0], modImage[rowIdx][offset:]) and \
isMatch(monsterImg[2], modImage[rowIdx+2][offset:]):
res += 1
return res
def get_src_trace(detailed_config, out_folder):
# process the cmd
trace_cmd = detailed_config['trace_cmd']
poc = detailed_config['poc']
replace_idx = np.where(np.asarray(trace_cmd) == '***')[0]
cmd = dc(trace_cmd)
replace_num = len(replace_idx)
for id in range(replace_num):
cmd[replace_idx[id]] = poc[id]
# write the cmd
cmd_path = os.path.join(out_folder, 'cmd.txt')
utils.write_txt(cmd_path, [' '.join(cmd)])
# get binary path
bin_path = detailed_config['bin_path']
# get the source trace
tmp_folder = './tempDr'
if not os.path.exists(tmp_folder):
os.mkdir(tmp_folder)
my_parser = parse_dwarf.DwarfParser(bin_path)
flineNumberDict, fileBoundRangesList, fileBoundIndexList, src_filepath = my_parser.get_main_addr(
)
ifSrcList = tracer.findIfSrcInOrderDyn(bin_path,
src_filepath,
flineNumberDict,
fileBoundRangesList,
fileBoundIndexList,
cmdFile=cmd_path)
logging.info("Got the source trace!")
# process the source trace
insn2src = {}
src2insn = {}
for item in ifSrcList:
insn = item[0]
src = '-'.join(item[1:3])
if insn not in insn2src:
insn2src[insn] = src
if src in src2insn:
src2insn[src].add(insn)
else:
src2insn[src] = {insn}
info = {'raw': ifSrcList, 'insn2src': insn2src, 'src2insn': src2insn}
# write the source trace
output_path = os.path.join(out_folder, 'poc_source_trace.pkl')
utils.write_pkl(output_path, info)
logging.info("Recorded the source trace -> %s" % output_path)
return insn2src, src2insn
def exploit_explore(self):
#EXPLOIT/EXPLOIT: Truncation Selection/Perturb
ranks = self.ranker()#Gives indicies from best to worst score
num = int(np.ceil(0.2*self.pop_size))
best = ranks[:num]
worst = ranks[-num:]
for idx in range(num):
self.population[worst[idx]].model.model.set_weights(self.population[best[idx]].model.model.get_weights())
new_hyperparameters = dc(self.population[best[idx]].config['hyperparameters'])
if np.random.uniform() < 0.5:
factor = self.explore[0]
else:
factor = self.explore[1]
for param,value in new_hyperparameters.items():
new_hyperparameters[param] = value * factor
self.population[worst[idx]].model.set_hyperparameters(**new_hyperparameters)
def step(self, action, action_type='swap', state=None, rewire_edges=True):
if state is None:
state = self.g
if action_type == 'swap':
i, j = action
if i + j == 0:
return state, torch.tensor(.0)
old_S = self.calc_S(g=state)
# swap two nodes
tmp = dc(state.nodes[i].data['label'])
state.nodes[i].data['label'] = state.nodes[j].data['label']
state.nodes[j].data['label'] = tmp
# rewire edges
if rewire_edges:
state.edata['e_type'][:, 1] = torch.mm(state.ndata['label'], state.ndata['label'].t()).view(-1)[
self.graph_generator.nonzero_idx]
elif action_type == 'flip':
i = action[0]
target_label = action[1]
i_label = state.nodes[i].data['label'].argmax().item()
if i_label == target_label or i + target_label < 0:
return state, torch.tensor(.0)
old_S = self.calc_S(g=state)
# flip node
state.nodes[i].data['label'] = torch.nn.functional.one_hot(torch.tensor([target_label]), self.k).float()
# rewire edges
if rewire_edges:
state.edata['e_type'][:, 1] = torch.mm(state.ndata['label'], state.ndata['label'].t()).view(-1)[
self.graph_generator.nonzero_idx]
new_S = self.calc_S(g=state)
reward = old_S - new_S
if state is None:
self.S -= reward
return state, reward
def main():
with open('day22.txt', 'r') as f:
data = f.read()
decks = []
for player in data.split("\n\n"):
deck = dq()
player = player.split("\n")
for line in player:
if not "Player" in line:
deck.appendleft(int(re.search(r'\d+', line).group()))
decks.append(deck)
_, d = play(dc(decks))
print("P1: {}".format(score(d)))
_, d = playtwo(decks)
print("P2: {}".format(score(d)))
async def on_guild_join(guild=None):
global configs
# deepcopy because it if not its going to make copies and send more than one more time in one guild
configs.update({"a" + str(guild.id): dc(defaultconfigs)})
# Log join guild
logging.info("Joined guild {} at {}".format(
guild.id,
datetime.datetime.now().strftime("%x %X:%f")))
# Send guild
await [
i for i in guild.channels if type(i) == discord.TextChannel
][0].send(
"Thanks for inviting me to the channel.\n Please type `>help` to see what I can do!"
)
# update configs
generalconfigs()
return
def remove_preseason_games(self, args=None ):
'''This function removes preseason games based on the start of the season
arguments:
args - This should contain a start date that is a datetime.datetime object. defaults to None
'''
if args == None:
start = self.args['start']
games1 = self.games
games2 = dc(games1)
print "len of list one is {0} and len of list two is {1}".format(len(games1), len(games2))
for i in range(0, len(games1)):
for j in range(0, len(games1[0])):
game = games1[i][j]
if game.date < start:
games2.pop(0)
break
self.games = games2
def number_of_dependency_tags(self, sent):
"""
Find a dependency tag for each token within a sentence and add their amount
to a dictionary, depending how many times that particular tag appears.
"""
dep_dict = dc(self.dep_dict)
for token in sent:
if token.dep_ == '':
dep_dict['TRAILING_DEP'] += 1
else:
try:
dep_dict[token.dep_] += 1
except:
print('Unknown dependency for token: "' + token.orth_ +'". Passing.')
return dep_dict
def removeHorizontalSeam(self, seam): # function the will remove the seam
if (seam == None): # exception handling
raise ValueError("Seam argument is null")
imgArr = np.array(self.image, dtype='int64') # image to array
if (self.image.size[1] == 1): # exception handling
raise ValueError("Current height of image is 1")
newArr = dc(
imgArr[:-1]) # new array made with 1 pixel less in the height
for i in range(
len(newArr[0])
): # each pixel is copied to the new array except the one in the seam
for j in range(seam[i]):
newArr[j][i] = imgArr[j][i]
for j in range(seam[i], len(newArr)):
newArr[j][i] = imgArr[j + 1][i]
self.image = Image.fromarray(
newArr.astype('uint8')) # the image is updated
def EvalData(self, data):
eData = False
log("Server", 'EvalData', repr(data))
try:
eData = dc(json.loads(data))
except:
err1 = sys.exc_info()
try:
eData = eval(data)
except:
PE("Server", "EvalData", "Error 1", err1, "Error 2",
sys.exc_info())
eData = False
finally:
if eData:
self.DataReadThread(eData)
def check_direction(self, start, dir):
end = (start[0] + dir[0], start[1] + dir[1])
board = dc(self.game_board)
if start[0] < 0 or start[0] > self.board_size or end[0] <= 0 or end[0] >= self.board_size - 1 \
or start[1] < 0 or start[1] > self.board_size or end[1] <= 0 or end[1] >= self.board_size - 1:
return -1, []
# swap
board[start[0]][start[1]], board[end[0]][end[1]] = board[end[0]][
end[1]], board[start[0]][start[1]]
score_start, start_board = self.evaluate_board(start, end, board)
score_end, end_board = self.evaluate_board(end, start, board)
if score_start > score_end:
return score_start, [start, end]
else:
return score_end, [end, start]
def get_teeth_neol_chances(self, drawn_teeth):
"""
Method to return the chance to keep the teeth
failing order from initialisation to neol
"""
chances = np.ones((self.no_teeth))
# Get initial Order of teeth
teeth_init_order = dc(self.state0['tooth'].to_list())
teeth_init_order = pd.Series(teeth_init_order)
# Check if tooth already drawn
for i, tooth_i in enumerate(teeth_init_order):
if tooth_i in drawn_teeth:
chances[i] = 0
# Get current number of teeth remaining
tooth_i = len(drawn_teeth)
chances[tooth_i] = chances[tooth_i] * self.keeporder_chance
return (np.array(chances))
def vis_g(problem, k=None, name='test', topo='knn'):
plt.figure()
if isinstance(problem, dgl.DGLGraph):
g = problem
k = k
else:
k = problem.k
g = problem.g
X = g.ndata['x'].cpu()
n = X.shape[0]
label = g.ndata['label'].cpu()
link = dc(g.edata['e_type'].view(n, n - 1, 2).cpu())
# c = ['r', 'b', 'y']
plt.cla()
c = ['r', 'b', 'y', 'k', 'g', 'c', 'm', 'tan', 'peru', 'pink']
for i in range(k):
a = X[(label[:, i] > 0).nonzero().squeeze()]
if a.shape[0] > .5:
a = a.view(-1, 2)
plt.scatter(a[:, 0], a[:, 1], s=60, c=[c[i]] * (n // k))
for i in range(n):
plt.annotate(str(i), xy=(X[i, 0], X[i, 1]))
for j in range(n - 1):
if link[i, j][0].item() == 1:
j_ = j
if j >= i:
j_ = j + 1
plt.plot([X[i, 0], X[j_, 0]], [X[i, 1], X[j_, 1]],
':',
color='k')
if topo == 'cut':
for j in range(n - 1):
if link[i, j][1].item() + link[i, j][0].item() > 1.5:
j_ = j
if j >= i:
j_ = j + 1
plt.plot([X[i, 0], X[j_, 0]], [X[i, 1], X[j_, 1]],
'-',
color='k')
plt.savefig(name + '.png')
plt.close()
def expand_field(field: list[list[list[bool]]]):
step = dc(field)
outer = dc(step[0])
for i, _ in enumerate(outer):
for j, _ in enumerate(outer[i]):
outer[i][j] = False
step.insert(0, dc(outer))
step.append(dc(outer))
line = dc(step[0][0])
for z in step:
z.insert(0, dc(line))
z.append(dc(line))
for y in z:
y.insert(0, False)
y.append(False)
return step
def getState(self, PLowSat, PHighSat, P, T):
"""
For Rankine, we exit pump at P=PHigh, T4=T3=Tsat for PLow.
#case 1: PLow<=P<=PHigh
For the states between P=PLow to PHigh, T=T3: h=h3+(P-PLow)*v3, v=v3 (i.e., incompressible), s=s3 (i.e., isentropic efficiency of pump = 1.0)
#case 2: P=PHigh, T3<=T<=T5
Between states (P=PHigh, T4) to (P=PHigh, T5=Tsat,PHigh), I will assume P and T vary linearly, so:
z=(T-T4)/(T5-T4)
h4=h3+(PHigh-PLow)v3
h5, s5, v5=hf, sf, vf for PHigh
h=h4 +(h5-h4)*z
s=s3+(s5-s3)*z
v=v3+(v5-v3)*z
general function to retrieve the thermodynamic state object (TSat, P, h, s, v)
:param PLow: in kPa
:param PHigh: in kPa
:param P: in kPa
:param T: in C
:return: a deep copy of a thermodynamic state object
"""
state=stateProps()
case = 1 if (T<=PLowSat.Tsat) else 2
if case ==1:
z=(P-PLowSat.Psat)/(PHighSat.Psat-PLowSat.Psat)
state.h=PLowSat.hf+z*(PHighSat.Psat-PLowSat.Psat)*PLowSat.vf
state.s=PLowSat.sf
state.v=PLowSat.vf
state.T=PLowSat.Tsat
state.P=P
else:
z=(T-PLowSat.Tsat)/(PHighSat.Tsat-PLowSat.Tsat)
h4=PLowSat.hf+(PHighSat.Psat-PLowSat.Psat)*PLowSat.vf
s4=PLowSat.sf
v4=PLowSat.vf
h5=PHighSat.hf
s5=PHighSat.sf
v5=PHighSat.vf
state.h=h4+z*(h5-h4)
state.s=s4+z*(s5-s4)
state.v=v4+z*(v5-v4)
state.P=P
state.T=T
name='subcooled'
state.x=-0.1
return dc(state)
def getState(self, P_Bar=None, P_kPa=None, T=None, h=None, s=None, v=None, x=None):
"""
general function to retrieve the thermodynamic state object (TSat, PSat, h, s, v)
For this to work properly, need to give a (pressure or a temperature) + one other property
:param P: pressure in bar (but output in kPa)
:param T: temperature in C
:param h: specific enthalpy in kJ/kg
:param s: specific entropy in kJ/kg*K
:param v: specific volume in m^3/kg
:param x: quality
:return: a thermodynamic state object
"""
state = stateProps()
state.region = 'saturated'
sats=satProps()
if P_Bar is not None:
sats = self.getSatProps(P_Bar=P_Bar)
if P_kPa is not None:
sats=self.getSatProps(P_kPa=P_Bar)
if T is not None:
sats = self.getSatProps(T=T)
state.P = sats.Psat
state.T = sats.Tsat
if h is not None:
state.h = h
state.x = (state.h - sats.hf) / sats.hgf
state.s = sats.sf + state.x * sats.sgf
state.v = sats.vf + state.x * sats.vgf
elif s is not None:
state.s = s
state.x = (state.s - sats.sf) / sats.sgf
state.h = sats.hf + state.x * sats.hgf
state.v = sats.vf + state.x * sats.vgf
elif v is not None:
state.v = v
state.x = (state.v - sats.vf) / sats.vgf
state.h = sats.hf + state.x * sats.hgf
state.s = sats.sf + state.x * sats.sgf
elif x is not None:
state.x = x
state.h = sats.hf + state.x * sats.hgf
state.s = sats.sf + state.x * sats.sgf
state.v = sats.vf + state.x * sats.vgf
return dc(state)
def __init__(self, h): # initialization using a hamiltonian
self.heff = None # effective hamiltonian
self.right_intra = h.intra # intraterm in the right lead
self.right_inter = h.inter # interterm in the right lead (to the right)
self.right_green = None # right green function
self.left_intra = h.intra # intraterm in the left lead
self.left_inter = h.inter.H # interterm in the left lead (to the left)
self.left_green = None # left green function
self.central_intra = h.intra # intraterm in the center
self.right_coupling = h.inter # coupling from the center to the right lead
self.left_coupling = h.inter.H # coupling from the center to the left lead
# geometry of the central part
gc = dc(h.geometry)
# gc.set_finite()
self.central_geometry = gc # geometry of the central part
# additional degrees of freedom
self.has_spin = h.has_spin # spin degree of freedom
self.has_eh = h.has_eh # electron hole pairs
def test_save_load_basevae(invariances):
data_dim = (5, 8, 8)
coord = 0
if invariances is not None:
coord = len(invariances)
if 't' in invariances:
coord = coord + 1
vae = models.base.baseVAE()
encoder_net = nets.fcEncoderNet(data_dim[1:], 2 + coord, 0)
dnet = nets.sDecoderNet if 0 < coord < 5 else nets.fcDecoderNet
decoder_net = dnet(data_dim, 2, 0)
vae.set_encoder(encoder_net)
vae.set_decoder(decoder_net)
weights_init = dc(vae.state_dict())
vae.save_weights("my_weights")
vae.load_weights("my_weights.pt")
weights_loaded = vae.state_dict()
assert_(assert_weights_equal(weights_loaded, weights_init))
def Load(self, fInfo):
res = self.File.Load(fInfo)
if res:
lineNum = 0
for i, line in enumerate(res):
if line == '*'*50+'\n': lineNum = i+4
res = res[lineNum:]
fileLen = len(res)
for i in range(fileLen):
items = res.pop(0).strip()
if not items: continue
items = items.split(' '*5)
itemLen = len(items)
res += [[]]
for i in range(itemLen):
item = items.pop(0).strip()
if item: res[len(res)-1] += [item]
return dc(res)
def Save(self, saveInfo, saveList):
saveList = dc(saveList)
writeString = ''
if saveList and saveList != self.Load(saveInfo[0]):
minSpace = 5
saveList.insert(0, ['Source', 'Class', 'Type', 'Target'])
maxLen = [minSpace*2]*len(saveList[0])
for line in saveList:
maxLen = [max(maxLen[i], len(item)) for i, item in enumerate(line)]
saveList.insert(1, ['-'*(i+minSpace) for i in maxLen])
writeString = '\n'+('*'*50)+'\n\n'
for items in saveList:
for i, item in enumerate(items):
writeString += item+' '*((maxLen[i]-len(item))+minSpace) \
if item != '-'*(maxLen[i]+minSpace) else item
writeString += '\n'
writeString += '\n'
self.File.Save(saveInfo, writeString)
