def infrastructure(data):
w.infWater(data.getEntities(), data.getHouseHold(), data.getWaterInf())
s.sanitation(data.getEntities(), data.getSanitationInf())
wm.wasteManagement(data.getEntities(), data.getWasteManagementInf())
e.energy(data.getGeneralForm(), data.getEntities(), data.getBusiness(),
data.getHouseHold(), data.getComunalServices(),
data.getWomenGroup(), data.getEnergyINF())
mb.mobility(data.getMobilityINF(), data.getGeneralForm())
def topology():
"Create a network."
net = Mininet_wifi(link=wmediumd, wmediumd_mode=interference)
info("*** Creating nodes\n")
sta1 = net.addStation('sta1',
position='5,5,0',
ip='10.0.0.1',
mac='00:00:00:00:00:01',
range=5)
sta2 = net.addStation('sta2',
position='15,5,0',
ip='10.0.0.2',
mac='00:00:00:00:00:02',
range=5)
ap1 = net.addAccessPoint('ap1',
ssid='ssid-ap1',
mode='g',
channel='1',
position='10,10,0',
range=40)
c1 = net.addController('c1')
net.setPropagationModel(model="logDistance", exp=2)
info("*** Configuring wifi nodes\n")
net.configureWifiNodes()
net.plotGraph(max_x=20, max_y=20)
ap1.setIP('10.0.0.3', intf='ap1-wlan1')
info("*** Creating links\n")
net.addLink(ap1, sta1)
net.addLink(ap1, sta2)
info("*** Starting network\n")
net.build()
c1.start()
ap1.start([c1])
info('*** Step 1.')
t0 = 5
t1 = 5
t2 = 10
info('*** Energy Harvest\n')
energy(sta1, ap1, t0)
info('***\n')
info("*** Running CLI\n")
CLI_wifi(net)
info("*** Stopping network\n")
net.stop()
def monteCarlo(m, num_rnd, num_rnd1, tempSA, piChange, e0, c0, jobNo=00):
np.random.seed() # initialize by random
print(" ", jobNo, energy.energy(m, c0))
i = 0
e1 = e0
m1 = copy.deepcopy(m)
m2 = copy.deepcopy(m)
# set energy for plots
stopIteration = False
while (not stopIteration):
i = i + 1
# select n random elements
rndAll = np.arange(1, m.psi.size - 1)
np.random.shuffle(rndAll)
rndIdx = rndAll[:num_rnd]
rndIdx2 = rndAll[num_rnd:num_rnd + num_rnd1]
rndIdx = np.int8(rndIdx)
rndIdx2 = np.int8(rndIdx2)
m2.psi[rndIdx] = piChange * (2 * np.random.random(num_rnd) - 1)
localVal = energy.findLocalMin(m2, rndIdx2, c0)
m2.psi[rndIdx2] = localVal
e2 = energy.energy(m2, c0)
# print(rndIdx, " - ", rndIdx2)
# print(m2.psi[rndIdx])
# decision process MC
if e2 <= e0:
m1 = copy.deepcopy(m2)
m = copy.deepcopy(m2)
e1 = e2.copy()
e0 = e2.copy()
noChange = 1
else:
paramSA = np.exp((e1 - e2) / tempSA)
#print(e0, e1, e2)
if paramSA > np.random.random():
m1 = copy.deepcopy(m2)
e1 = e2.copy()
print("-", jobNo, "-")
else:
m2 = copy.deepcopy(m1)
if i > 10:
stopIteration = True
# print("e1 = ", e1)
return (e1, m)
def main(molfile,method,tol):
universe = read_input.main(molfile)
ffield='gaff'
energy.energy(ffield,universe,noreport=False)
flat_coords = universe.get_flat_cartesian_atom_array()
res = scipy.optimize.minimize(wrap_energy_for_minimizer,flat_coords,args=(ffield,universe),
method=method,tol=tol,bounds=None)
energy.energy(ffield,universe,noreport=False)
print res
def main(molfile):
ts = 0.015 # make command line option, in picoseconds
nsteps = 10**3 # make command line option
universe = read_input.main(molfile)
update_universe_mass(universe,ffield)
# energy.energy(ffield,universe,noreport=False)
energy.energy(ffield,universe,noreport=True)
cartesians = universe.get_cartesian_atom_array()
universe.assign_random_velocity(100 * 10**-2) # angstroms/picosecond (400 * 10**-2)
#####################
simulate(universe,deltat=ts,steps=nsteps)
def __init__(self,
x_pixels_in_detector=3110,
y_pixels_in_detector=3269,
x_pixel_size=75e-6,
y_pixel_size=75e-6,
distance=None,
wavelength=None,
photon_energy=None,
test=False):
self.distance_motor = PyTango.DeviceProxy(
'i11-ma-cx1/dt/dtc_ccd.1-mt_ts')
self.horizontal_motor = PyTango.DeviceProxy(
'i11-ma-cx1/dt/dtc_ccd.1-mt_tx')
self.vertical_motor = PyTango.DeviceProxy(
'i11-ma-cx1/dt/dtc_ccd.1-mt_tz')
self.wavelength_motor = PyTango.DeviceProxy('i11-ma-c03/op/mono1')
self.energy_motor = energy()
self.bc = beam_center()
self.x_pixel_size = x_pixel_size
self.y_pixel_size = y_pixel_size
self.x_pixels_in_detector = x_pixels_in_detector
self.y_pixels_in_detector = y_pixels_in_detector
self.distance = distance
self.wavelength = wavelength
self.photon_energy = photon_energy
self.test = test
def init(self):
self.energy = energy()
self.energy_channel = self.getChannelObject("energy")
self.energy_channel.connectSignal("update", self.energy_changed)
self.state_channel = self.getChannelObject("state")
self.state_channel.connectSignal('update', self.energy_state_changed)
self.tunable = self.getProperty('tunable')
self.default_en = self.getProperty('default_energy')
self.minimum_energy = self.getProperty('min_energy')
self.maximum_energy = self.getProperty('max_energy')
self.current_energy = self.energy.get_energy() / kilo
self.current_wavelength = self.get_wavelegth_from_energy(
self.current_energy)
self.getWavelengthLimits = self.get_wavelength_limits
self.getEnergyLimits = self.get_energy_limits
self.getCurrentEnergy = self.get_current_energy
self.getCurrentWavelength = self.get_current_wavelength
self.checkLimits = self.check_limits
self.cancelMoveEnergy = self.cancel_move_energy
self.start_move_energy = self.move_energy
def findPitch(fs,x,method):
""" returns all the fundamental frequencies ( for each frame of the signal )
arguments:
fs: sampling frequency
x : the signal
method: 0 to use autocorrelation, 1 to use cepstrum based algorithm
returns:
F0s: array like, contains the fundamental frequency of each frame """
x=normalize(x)
FL=framing(fs,x)
VorU= [] #voice or unvoiced frame?
F0s=[]
threshold = 7
"""We observed and listened to 5 random signals.
We noticed that most of voiced sounds gave a corresponding energy superior to 7."""
for i in range (0,len(FL)):
Ef=energy(FL[i])
if method ==1:
w=signal.hamming(len(FL[i]))
FL[i]= w*FL[i]
if Ef > threshold:
VorU.append(1) # voiced
if method==0: F0s.append(xCorrF0(FL[i],fs))
if method==1: F0s.append(cepstrumF0(FL[i],fs))
else:
VorU.append(0) # unvoiced
F0s.append(0)
F0s=np.asarray(F0s)
return F0s
def init(self):
self.energy = energy()
self.energy_channel = self.getChannelObject("energy")
self.energy_channel.connectSignal("update", self.energy_changed)
self.state_channel = self.getChannelObject("state")
self.state_channel.connectSignal("update", self.energy_state_changed)
self.tunable = self.getProperty("tunable")
self.default_en = self.getProperty("default_energy")
self.minimum_energy = self.getProperty("min_energy")
self.maximum_energy = self.getProperty("max_energy")
self.current_energy = self.energy.get_energy() / kilo
self.current_wavelength = self.get_wavelegth_from_energy(self.current_energy)
self.getWavelengthLimits = self.get_wavelength_limits
self.getEnergyLimits = self.get_energy_limits
self.getCurrentEnergy = self.get_current_energy
self.getCurrentWavelength = self.get_current_wavelength
self.checkLimits = self.check_limits
self.cancelMoveEnergy = self.cancel_move_energy
self.start_move_energy = self.move_energy
def main(molfile):
ts = 0.015 # make command line option, in picoseconds
nsteps = 10**3 # make command line option
universe = read_input.main(molfile)
update_universe_mass(universe, ffield)
# energy.energy(ffield,universe,noreport=False)
energy.energy(ffield, universe, noreport=True)
cartesians = universe.get_cartesian_atom_array()
universe.assign_random_velocity(
100 * 10**-2) # angstroms/picosecond (400 * 10**-2)
#####################
simulate(universe, deltat=ts, steps=nsteps)
def wrap_energy_for_minimizer(flat_coords,ffield,universe):
c = flat_coords.reshape(-1,3)
for i in xrange(0,len(universe.atoms)):
universe.atoms[i].update_coords(c[i][0],c[i][1],c[i][2])
universe.write_xyz()
e = energy.energy(ffield,universe)
return e
def wrap_energy_for_minimizer(flat_coords, ffield, universe):
c = flat_coords.reshape(-1, 3)
for i in xrange(0, len(universe.atoms)):
universe.atoms[i].update_coords(c[i][0], c[i][1], c[i][2])
universe.write_xyz()
e = energy.energy(ffield, universe)
return e
def main(molfile, method, tol):
universe = read_input.main(molfile)
ffield = 'gaff'
energy.energy(ffield, universe, noreport=False)
flat_coords = universe.get_flat_cartesian_atom_array()
res = scipy.optimize.minimize(wrap_energy_for_minimizer,
flat_coords,
args=(ffield, universe),
method=method,
tol=tol,
bounds=None)
energy.energy(ffield, universe, noreport=False)
print res
def double_thresh(wave_data: np.ndarray,
Mh: float,
Ml: float,
Zs: float,
highframesthre=20,
filenum: int = 0) -> list:
wave_energy = energy(wave_data)
wave_zrate = zrate(wave_data)
labels = np.zeros(wave_energy.shape)
find = []
ans = []
row = wave_data.shape[0]
ans01 = np.zeros(row)
i = 0
counter = -1
while i < len(wave_energy):
if wave_energy[i] >= Mh:
start_high_pos = i
while wave_energy[i] >= Mh and i < row - 1:
i += 1
end_high_pos = i
if end_high_pos - start_high_pos >= highframesthre:
start_low_pos = start_high_pos
end_low_pos = end_high_pos
while wave_energy[end_low_pos] >= Ml and end_low_pos < row - 1:
end_low_pos += 1
while wave_energy[
start_low_pos] >= Ml and end_low_pos < row - 1:
if start_low_pos not in find:
start_low_pos -= 1
else:
break
start = start_low_pos
while wave_zrate[start] <= Zs and start > 0:
if start not in find:
start = start - 1
else:
break
# [start+1,end_low_pos)
for k in range(start + 1, end_low_pos):
labels[k] = 1 #语音
find.append(k)
counter += 1
#save('result/lab1_2/'+str(filenum)+'_'+str(counter)+'.pcm',wave_data,start+1,end_low_pos)
ans.append((start + 1, end_low_pos - 1))
for kk in range(start + 1, end_low_pos):
ans01[kk] = 1
i = end_low_pos
else:
i = start_high_pos + 1
else:
i += 1
ans01 = np.array(ans01)
return ans, ans01
def lab1_main():
for i in range(1, 11):
wave_data = get(i)
wave_energy = energy(wave_data)
wave_zrate = zrate(wave_data)
with open('../result/lab1/' + str(i) + '_en.txt', 'w') as f:
for num in wave_energy:
f.write(str(num) + '\n')
with open('../result/lab1/' + str(i) + '_zero.txt', 'w') as f:
for num in wave_zrate:
f.write(str(num) + '\n')
return wave_data
def calc_forces(universe, stepsize=0.0001):
'''
f(x+h) - f(x-h)
---------------
2h
'''
for i in xrange(0, universe.natoms()):
x, y, z = universe.atoms[i].x, universe.atoms[i].y, universe.atoms[i].z
p1 = copy.deepcopy(universe)
p1.atoms[i].update_coords(x - stepsize, y, z) # minus x universe
mxe = energy.energy(ffield, p1)
p1.atoms[i].update_coords(x + stepsize, y, z) # plus x universe
pxe = energy.energy(ffield, p1)
p1.atoms[i].update_coords(x, y - stepsize, z) # minus y universe
mye = energy.energy(ffield, p1)
p1.atoms[i].update_coords(x, y + stepsize, z) # plus y universe
pye = energy.energy(ffield, p1)
p1.atoms[i].update_coords(x, y, z - stepsize) # minus z universe
mze = energy.energy(ffield, p1)
p1.atoms[i].update_coords(x, y, z + stepsize) # plus z universe
pze = energy.energy(ffield, p1)
universe.atoms[i].forcevec = -1 * np.array([(pxe - mxe) /
(2.0 * stepsize),
(pye - mye) /
(2.0 * stepsize),
(pze - mze) /
(2.0 * stepsize)])
# forces are in kcal/mol/angstrom
print "p1: ", mxe, pxe, mye, pye, mze, pze
print "force vec: ", universe.atoms[i].forcevec
def calc_forces(universe,stepsize=0.0001):
'''
f(x+h) - f(x-h)
---------------
2h
'''
for i in xrange(0,universe.natoms()):
x,y,z = universe.atoms[i].x,universe.atoms[i].y,universe.atoms[i].z
p1 = copy.deepcopy(universe)
p1.atoms[i].update_coords( x-stepsize, y, z) # minus x universe
mxe = energy.energy(ffield,p1)
p1.atoms[i].update_coords( x+stepsize, y, z) # plus x universe
pxe = energy.energy(ffield,p1)
p1.atoms[i].update_coords( x , y-stepsize, z) # minus y universe
mye = energy.energy(ffield,p1)
p1.atoms[i].update_coords( x , y+stepsize, z) # plus y universe
pye = energy.energy(ffield,p1)
p1.atoms[i].update_coords( x , y, z-stepsize) # minus z universe
mze = energy.energy(ffield,p1)
p1.atoms[i].update_coords( x , y, z+stepsize) # plus z universe
pze = energy.energy(ffield,p1)
universe.atoms[i].forcevec = -1 * np.array(
[(pxe-mxe)/(2.0*stepsize), (pye-mye)/(2.0*stepsize), (pze-mze)/(2.0*stepsize)] )
# forces are in kcal/mol/angstrom
print "p1: ",mxe,pxe,mye,pye,mze,pze
print "force vec: ",universe.atoms[i].forcevec
def __init__(self, x_pixels_in_detector=3110, y_pixels_in_detector=3269, x_pixel_size=75e-6, y_pixel_size=75e-6, distance=None, wavelength=None, photon_energy=None, test=False):
self.distance_motor = PyTango.DeviceProxy('i11-ma-cx1/dt/dtc_ccd.1-mt_ts')
self.wavelength_motor = PyTango.DeviceProxy('i11-ma-c03/op/mono1')
self.energy_motor = energy()
self.bc = beam_center()
self.x_pixel_size = x_pixel_size
self.y_pixel_size = y_pixel_size
self.x_pixels_in_detector = x_pixels_in_detector
self.y_pixels_in_detector = y_pixels_in_detector
self.distance = distance
self.wavelength = wavelength
self.photon_energy = photon_energy
self.test = test
def min_cost_other_partitions(self, point, label):
"""Compute the minimal cost between 'point' with all the other
partitions.
"""
costs = []
for j in range(self.n_clusters):
if j == label:
costs.append(np.inf)
else:
points_in_partition = self.X[np.where(self.labels_ == j)]
n = len(points_in_partition)
cost = energy([point], points_in_partition) * (n / (n + 1))
costs.append(cost)
costs = np.array(costs)
min_index = costs.argmin()
min_cost = costs[min_index]
return min_cost, min_index
def min_cost_other_partitions(self, point, label):
"""Compute the minimal cost between 'point' with all the other
partitions.
"""
costs = []
for j in range(self.n_clusters):
if j == label:
costs.append(np.inf)
else:
points_in_partition = self.X[np.where(self.labels_ == j)]
n = len(points_in_partition)
cost = energy([point], points_in_partition)*(n/(n+1))
costs.append(cost)
costs = np.array(costs)
min_index = costs.argmin()
min_cost = costs[min_index]
return min_cost, min_index
def fullQM(L,suffix=''): coord = L[0] # main = L[1]# name of main fragment #N = int( L[2]) #no. of atoms in main fragment #scaling = float(L[3]) main_charge = int(L[1]) main_mult = int(L[2]) job = L[3] root = int(L[4]) name = coord+suffix make_fullQM_input.make_input(coord+'.xyz',job,name,main_charge,main_mult) #pc file not reqd. submit.submit(name+'_fullQM_'+job) #change inp filename as per make_input En = energy.energy(name+'_fullQM_'+job+'.out') #change inp filename as per make_input return En
def init(self):
self.energy = energy()
self.energy_channel = self.get_channel_object("energy")
self.energy_channel.connect_signal("update", self.energy_changed)
self.state_channel = self.get_channel_object("state")
self.state_channel.connect_signal("update", self.energy_state_changed)
self.tunable = self.get_property("tunable")
self.default_en = self.get_property("default_energy")
self.minimum_energy = self.get_property("min_energy")
self.maximum_energy = self.get_property("max_energy")
self.current_energy = self.energy.get_value() / kilo
self.current_wavelength = self.get_wavelegth_from_energy(self.current_energy)
self.checkLimits = self.check_limits
self.cancelMoveEnergy = self.cancel_move_energy
def monteCarlo(m, num_rnd, num_rnd1, tempSA, piChange, e0, var, jobNo=00):
np.random.seed() # initialize by random
m2 = copy.deepcopy(m)
# set energy for plots
# select n random elements
rndAll = np.arange(1, m.psi.size - 1)
np.random.shuffle(rndAll)
rndIdx = rndAll[:num_rnd]
rndIdx2 = rndAll[num_rnd:num_rnd + num_rnd1]
rndIdx = np.int8(rndIdx)
rndIdx.sort()
rndIdx2 = np.int8(rndIdx2)
rndIdx2.sort()
m2.psi[rndIdx] = m2.psi[rndIdx] + piChange * \
(2 * (np.random.random(num_rnd) - 0.5))
localVal = energy.findLocalMin(m2, rndIdx2, var)
m2.psi[rndIdx2] = localVal[1:]
m2.startZ = localVal[0]
# print('localVal', localVal)
# print('m2psi', m2.psi[rndIdx])
# print(energy.funZ_zero(localVal, m2, rndIdx2))
# if (abs(energy.funZ_zero(localVal, m2, rndIdx2)) > 1e-3):
# e2 = 1e5
# else:
e2 = energy.energy(m2, var)
# ipdb.set_trace()
# print(rndIdx, " - ", rndIdx2)
# print(m2.psi[rndIdx])
# print('e2', e2)
# print("e1 = ", e1)
return (e2, m2)
def energies(signal, fs, dt, bits=False):
"""
Calcule l'énergie contenue dans un signal segmenté par une certaine résolution temporelle.
:param signal: Signal d'entrée
:type signal: number
:param fs: Fréquence d'échantillonage
:type fs: number
:param dt: Résolution temporelle (celle-ci doit pouvoir être satisfaire par la valeur de fs)
:type dt: number
:param n: Nombre de bits utilisé pour codifier la valeur de l'énergie
:type n: number
:return: Liste des segments temporels et liste des séquences d'énergies
:rtype: number[], number[]
"""
# Energie
seqs = []
segs = np.arange(0, len(signal) / fs, dt)
for t in segs:
seqs.append(energy(signal, fs, t, t + dt))
# Codage
if bits != False:
seqs = np.round(np.array(seqs) / (np.max(seqs) / (2**bits - 1)))
return segs, seqs
"""energy.py
This script will be used as centralized parser, will extract few informatios from OUTCAR
"""
import os
import sys
import position as p
import magmom as m
import energy as e
import toten as t
import nelectrons as n
import merge as me
outcar = sys.argv[1]
p.position(outcar, 'POS')
m.magmom(outcar, 'MAGMOM')
e.energy(outcar, 'ENERGY')
t.toten(outcar, 'TOTEN')
n.nelectrons(outcar, 'NELECTRONS')
me.merge(outcar)
os.system('cat DATA')
def cost_current_partition(self, point, label):
"""Compute the cost of point with its current partition."""
points_in_partition = self.X[np.where(self.labels_ == label)]
n = len(points_in_partition)
cost = energy([point], points_in_partition) * (n / (n - 1))
return cost
url = "https://www.pokemon-card.com/card-search/details.php/card/" + str(
url_number) + "/regu/XY"
get_url_info = requests.get(url)
bs4obj = BeautifulSoup(get_url_info.text, 'lxml')
if bs4obj.select('.RightBox .mt20')[0].get_text() != '':
#ポケモン、グッズ、ポケモンのどうぐ、サポート、スタジアム、基本エネルギー、特殊エネルギーで処理ファイル分け
if bs4obj.select('.RightBox .mt20')[0].get_text() == 'グッズ':
goods.goods(bs4obj)
elif bs4obj.select('.RightBox .mt20')[0].get_text() == 'ポケモンのどうぐ':
goods.goods(bs4obj)
elif bs4obj.select('.RightBox .mt20')[0].get_text() == 'サポート':
suport.suport(bs4obj)
elif bs4obj.select('.RightBox .mt20')[0].get_text() == 'スタジアム':
stadium.stadium(bs4obj)
elif bs4obj.select('.RightBox .mt20')[0].get_text() == '基本エネルギー':
energy.energy(bs4obj)
elif bs4obj.select('.RightBox .mt20')[0].get_text() == '特殊エネルギー':
energy.energy(bs4obj)
#なぞの化石がページバグでトレーナーになっているため例外として処理
elif bs4obj.select('.RightBox .mt20')[0].get_text() == 'トレーナー':
goods.goods(bs4obj)
#ポケモンだけこの要素がポケモン名になっているためelseで処理
else:
pokemon.pokemon(bs4obj)
print(url_number)
print(pack)
print('/')
#テキストに対応するカード画像も取得
imgs = bs4obj.select('img')[2].get('src')
var.x2 = -nano_dist / 2 - var.r1 # testing shape startZ = var.hc0 + var.r1 endZ = 0 elementNum = 50 # numbers of elements membraneLength = 20.0 # membrane length elementPsi = np.zeros(elementNum) elementPsi[0] = 0 elementPsi[-1] = 0 elementLength = membraneLength / elementNum i = 0 m = membrane.Membrane(elementPsi, elementLength, startZ, endZ) e0 = energy.energy(m, var) # define parameters num_rnd = 5 num_rnd1 = 10 i = 0 tempSA = 1e2 piChange = 1 * const.pi / 180 numProcessors = 1 noChange = 1 e1 = e0 # set energy for plots eTotal = np.zeros(100) eMin = np.zeros(100)
gen_uracil_pc.gen_uracil_pc(n)
#for i in range (n):
# gen_water_pc.gen_water_pc(i+1)
make_input.make_input('uracil.xyz', 'uracil.pc')
#for i in range (n):
# make_input.make_input('Water'+str(i+1)+'.xyz','Water'+str(i+1)+'.pc')
submit.submit('uracil_pc')
#for i in range (n):
# submit.submit('Water'+str(i+1)+'_pc')
En = energy.energy('uracil_pc.out')
print En
replace_by_Q.replace_by_Q(
'uracil.xyz', 'uracil_pc.out') #update uracil charges from 1st iter
for i in range(n):
gen_water_pc.gen_water_pc(
i + 1) #gen. pc files for water using updated uracil charges
for i in range(n):
make_input.make_input('Water' + str(i + 1) + '.xyz',
'Water' + str(i + 1) + '.pc')
for i in range(n):
def __init__(self, point, color):
self.point = point
self.color = color
self.cluster = cluster(self)
self.status = status(np.random.randint(2), 10, 10)
self.energy = energy(1, np.random.randn(), np.random.randn(7) - 3)
def cost_current_partition(self, point, label):
"""Compute the cost of point with its current partition."""
points_in_partition = self.X[np.where(self.labels_ == label)]
n = len(points_in_partition)
cost = energy([point], points_in_partition)*(n/(n-1))
return cost
elementPsi = np.zeros(elementNum)
elementPsi[0] = 0
elementPsi[-1] = 0 # const.pi / 2
for nano_dist in np.append(np.append([0, 0.5, 1, 1.5, 1.8], np.linspace(2, 5, 31)), [5.5, 6, 6.5, 7, 7.5, 8, 10, 15, 16, 17]):
stopIteration = False
step = 0
noChange = 0
steps = np.zeros(100)
var.x1 = nano_dist / 2 + var.r1
var.x2 = -nano_dist / 2 - var.r1
tempSA = 1e2
piChange = 5 * const.pi / 180
m = membrane.Membrane(
elementPsi, elementLength, startZ, endZ)
e0 = energy.energy(m, var)
m1 = copy.deepcopy(m)
e1 = e0
while (not stopIteration):
step = step + 1
energyMC = []
membraneMC = []
tasksMC = []
pool = multiprocessing.Pool(numProcessors)
for i in range(numProcessors):
membraneMC.append(copy.deepcopy(m1))
energyMC.append(e0)
tasksMC.append((membraneMC[i], num_rnd, num_rnd1,
def topology():
"Create a network."
net = Mininet_wifi(link=wmediumd, wmediumd_mode=interference)
info("*** Creating nodes\n")
sta1 = net.addStation('sta1',
position='5,0,0',
ip='10.0.0.1',
mac='00:00:00:00:00:01',
range=5)
sta2 = net.addStation('sta2',
position='10,0,0',
ip='10.0.0.2',
mac='00:00:00:00:00:02',
range=5)
sta3 = net.addStation('sta3',
position='20,0,0',
ip='10.0.0.3',
mac='00:00:00:00:00:03',
range=5)
sta4 = net.addStation('sta4',
position='30,0,0',
ip='10.0.0.4',
mac='00:00:00:00:00:04',
range=5)
sta5 = net.addStation('sta5',
position='45,0,0',
ip='10.0.0.5',
mac='00:00:00:00:00:05',
range=5)
sta6 = net.addStation('sta6',
position='60,0,0',
ip='10.0.0.6',
mac='00:00:00:00:00:06',
range=5)
client = net.addStation('client',
position='9,2,0',
ip='10.0.0.7',
mac='00:00:00:00:00:07',
range=5)
ap1 = net.addAccessPoint('ap1',
ssid='ssid-ap1',
mode='g',
channel='1',
position='0,0,0',
range=40)
c1 = net.addController('c1')
net.setPropagationModel(model="logDistance", exp=2)
info("*** Configuring wifi nodes\n")
net.configureWifiNodes()
net.plotGraph(max_x=20, max_y=12)
ap1.setIP('10.0.0.3', intf='ap1-wlan1')
info("*** Creating links\n")
net.addLink(ap1, sta1)
net.addLink(ap1, sta2)
net.addLink(ap1, sta3)
net.addLink(ap1, sta4)
net.addLink(ap1, sta5)
net.addLink(ap1, sta6)
net.addLink(ap1, client)
info("*** Starting network\n")
net.build()
c1.start()
ap1.start([c1])
time = 0.03125
info('*** Energy Harvest\n')
energy(sta1, ap1, time)
energy(sta2, ap1, time)
energy(sta3, ap1, time)
energy(sta4, ap1, time)
energy(sta5, ap1, time)
energy(sta6, ap1, time)
info('***\n')
info("*** Running CLI\n")
CLI_wifi(net)
info("*** Stopping network\n")
net.stop()
def XPOL_n(L, iter_no):
coord = L[0] + '.xyz'
main = L[1] # name of main fragment
N = int(L[2]) #no. of atoms in main fragment
scaling = float(L[3])
main_charge = int(L[4])
main_mult = int(L[5])
job = L[6]
root = int(L[7])
f = open(main + '_time.txt', 'w')
f.close()
n = separate.separate(coord, main, N) # n is no. of water molecules
#replace_by_Q.replace_by_Q('uracil.xyz')
for i in range(n):
charge_water.pointcharge('Water' + str(i + 1) + '.xyz')
for i in range(n):
pc_water.pc_water(i + 1, n)
for k in range(iter_no):
gen_main_pc.gen_main_pc(main, n)
make_input.make_input(main + '.xyz', main + '.pc', main_charge,
main_mult)
submit.submit(main + '_pc')
time = comp_time.comp_time(main + '_pc.out') #comp. time calc.
s = 'Time taken for iteration number ' + str(
k + 1) + ' for main fragment :\n'
s += time + '\n\n'
f = open(main + '_time.txt', 'a')
f.write(s)
f.close()
En = energy.energy(main + '_pc.out')
f = open(main + '_energy.txt', 'a')
s = 'Energy after iteration no. ' + str(k +
1) + ' : ' + str(En) + '\n\n'
f.write(s)
f.close()
replace_by_Q.replace_by_Q(
main + '.xyz',
main + '_pc.out') #update uracil charges from 1st iter
for i in range(n):
gen_water_pc.gen_water_pc(
i + 1, main,
N) #gen. pc files for water using updated uracil charges
for i in range(n):
make_input.make_input('Water' + str(i + 1) + '.xyz',
'Water' + str(i + 1) + '.pc')
for i in range(n):
submit.submit('Water' + str(i + 1) + '_pc')
time = comp_time.comp_time('Water' + str(i + 1) +
'_pc.out') #comp. time calc.
s = 'Time taken for iteration number ' + str(
k + 1) + ' for water mol. no. ' + str(i + 1) + ' :\n'
s += time + '\n\n'
f = open(main + '_time.txt', 'a')
f.write(s)
f.close()
for i in range(n):
replace_by_Q.replace_by_Q('Water' + str(i + 1) + '.xyz',
'Water' + str(i + 1) +
'_pc.out') #update water charges
for i in range(n):
pc_water.pc_water(i + 1, n)
gen_main_pc.gen_main_pc(main, n) #gen. uracil pc file
# for i in range (n):
# gen_water_pc.gen_water_pc(i+1,main,N)#gen. water pc file
# make_input.make_input(main+'.xyz',main+'.pc',main_charge,main_mult)#make input files with updated charges
# for i in range (n):
# make_input.make_input('Water'+str(i+1)+'.xyz','Water'+str(i+1)+'.pc')
# submit.submit(main+'_pc')#submit input files
# for i in range (n):
# submit.submit('Water'+str(i+1)+'_pc')
# En = energy.energy(main+'_pc.out')
# print "Energy of "+main+" after iteration "+str(j)+" is "+str(En)
# print "delta E = " + str(abs(Eo-En))
## print 'Converged energy = '+str(En)+'\n\n'
## print 'Scaling the water point charges'
## for i in range(n):
## replace_by_Q.replace_by_Q('Water'+str(i+1)+'.xyz','Water'+str(i+1)+'_pc.out',scaling)
## for i in range (n):
## pc_water.pc_water(i+1,n)
## gen_main_pc.gen_main_pc(main,n)#gen. main fragment pc file
#############
# print 'Submitting EOM file'
# make_CIS_input.make_DLPNO_input(main+'.xyz',main+'.pc',job)
# submit.submit(main+'_'+job+'_CIS_pc')
#############
# submit_CHELPG.submit(main+'_'+job+'_CIS_pc-iroot'+str(root)+'.csp')
#Regenerating water charges from EE/IP/EA calc. of main frag.
# replace_by_Q_EOM.replace_by_Q_EOM(main+'.xyz',main+'_'+job+'_CIS_pc.root'+str(root)+'.'+job+'.out')
# for i in range (n):
# gen_water_pc.gen_water_pc(i+1,main,N)#gen. pc files for water using updated uracil charges
# for i in range (n):
# make_input.make_input('Water'+str(i+1)+'.xyz','Water'+str(i+1)+'.pc')
# for i in range (n):
# submit.submit('Water'+str(i+1)+'_pc')
# for i in range(n):
# replace_by_Q.replace_by_Q('Water'+str(i+1)+'.xyz','Water'+str(i+1)+'_pc.out')#update water charges
#Now we have final water charges
# gen_main_pc.gen_main_pc(main,n)#gen. main fragment pc file
# print 'Final files generated'
# print 'Submitting '+job+' file'
# make_DLPNO_input.make_DLPNO_input(main+'.xyz',main+'.pc')
# submit.submit(main+'_IP_DLPNO_pc')
# print 'IP values obtained'
# make_CIS_input.make_DLPNO_input(main+'.xyz',main+'.pc',job)
# submit.submit(main+'_'+job+'_CIS_pc')
# append_IROOT.append_IROOT(main+'_'+job+'_EOM_pc.out',main,root)
return En
def XPOL(L):
coord = L[0] + '.xyz'
main = L[1] # name of main fragment
N = int(L[2]) #no. of atoms in main fragment
scaling = float(L[3])
main_charge = int(L[4])
main_mult = int(L[5])
job = L[6]
root = L[7]
n = separate.separate(coord, main, N) # n is no. of water molecules
#replace_by_Q.replace_by_Q('uracil.xyz')
for i in range(n):
charge_water.pointcharge('Water' + str(i + 1) + '.xyz')
for i in range(n):
pc_water.pc_water(i + 1, n)
gen_main_pc.gen_main_pc(main, n)
#for i in range (n):
# gen_water_pc.gen_water_pc(i+1)
make_input.make_input(main + '.xyz', main + '.pc', main_charge, main_mult)
#for i in range (n):
# make_input.make_input('Water'+str(i+1)+'.xyz','Water'+str(i+1)+'.pc')
submit.submit(main + '_pc')
#for i in range (n):
# submit.submit('Water'+str(i+1)+'_pc')
En = energy.energy(main + '_pc.out')
print En
replace_by_Q.replace_by_Q(main + '.xyz', main +
'_pc.out') #update uracil charges from 1st iter
for i in range(n):
gen_water_pc.gen_water_pc(
i + 1, main,
N) #gen. pc files for water using updated uracil charges
for i in range(n):
make_input.make_input('Water' + str(i + 1) + '.xyz',
'Water' + str(i + 1) + '.pc')
for i in range(n):
submit.submit('Water' + str(i + 1) + '_pc')
Eo = 0
j = 0
epsilon = 0.000001
while (abs(Eo - En) >= epsilon):
j += 1
#print abs(Eo-En)
print 'Starting iteration no. ' + str(j)
Eo = En
replace_by_Q.replace_by_Q(main + '.xyz',
main + '_pc.out') #update uracil charges
for i in range(n):
replace_by_Q.replace_by_Q('Water' + str(i + 1) + '.xyz',
'Water' + str(i + 1) +
'_pc.out') #update water charges
for i in range(n):
pc_water.pc_water(i + 1, n)
gen_main_pc.gen_main_pc(main, n) #gen. uracil pc file
for i in range(n):
gen_water_pc.gen_water_pc(i + 1, main, N) #gen. water pc file
make_input.make_input(
main + '.xyz', main + '.pc', main_charge,
main_mult) #make input files with updated charges
for i in range(n):
make_input.make_input('Water' + str(i + 1) + '.xyz',
'Water' + str(i + 1) + '.pc')
submit.submit(main + '_pc') #submit input files
for i in range(n):
submit.submit('Water' + str(i + 1) + '_pc')
En = energy.energy(main + '_pc.out')
print "Energy of " + main + " after iteration " + str(
j) + " is " + str(En)
print "delta E = " + str(abs(Eo - En))
# print 'Converged energy = '+str(En)+'\n\n'
# print 'Scaling the water point charges'
# for i in range(n):
# replace_by_Q.replace_by_Q('Water'+str(i+1)+'.xyz','Water'+str(i+1)+'_pc.out',scaling)
# for i in range (n):
# pc_water.pc_water(i+1,n)
# gen_main_pc.gen_main_pc(main,n)#gen. main fragment pc file
print 'Submitting EOM file'
make_DLPNO_input.make_DLPNO_input(main + '.xyz', main + '.pc', job)
submit.submit(main + '_' + job + '_EOM_pc')
submit_CHELPG.submit(main + '_' + job + '_EOM_pc.root' + str(root) + '.' +
job)
#Regenerating water charges from EE/IP/EA calc. of main frag.
replace_by_Q_EOM.replace_by_Q_EOM(
main + '.xyz',
main + '_' + job + '_EOM_pc.root' + str(root) + '.' + job + '.out')
for i in range(n):
gen_water_pc.gen_water_pc(
i + 1, main,
N) #gen. pc files for water using updated uracil charges
for i in range(n):
make_input.make_input('Water' + str(i + 1) + '.xyz',
'Water' + str(i + 1) + '.pc')
for i in range(n):
submit.submit('Water' + str(i + 1) + '_pc')
for i in range(n):
replace_by_Q.replace_by_Q('Water' + str(i + 1) + '.xyz',
'Water' + str(i + 1) +
'_pc.out') #update water charges
#Now we have final water charges
gen_main_pc.gen_main_pc(main, n) #gen. main fragment pc file
print 'Final files generated'
print 'Submitting ' + job + ' file'
# make_DLPNO_input.make_DLPNO_input(main+'.xyz',main+'.pc')
# submit.submit(main+'_IP_DLPNO_pc')
# print 'IP values obtained'
make_DLPNO_input.make_DLPNO_input(main + '.xyz', main + '.pc', job)
submit.submit(main + '_' + job + '_EOM_pc')
return
u[m, 2] = x * exz + y * eyz + z * ezz
# RELAXATION LOOP
# (USER) kmax is the maximum number of times dembx will be called, with
# ldemb conjugate gradient steps performed during each call. The total
# number of conjugate gradient steps allowed for a given elastic
# computation is kmax*ldemb.
kmax = 40
ldemb = 50
ltot = 0
Lstep = 0
h = 0 #initialization
# Call energy to get initial energy and initial gradient
gb, utot = energy(ns, C, ib, u, pix, dk, b)
# gg is the norm squared of the gradient (gg=gb*gb)
gg = np.sum((gb**2))
print("Initial energy = {:.4f} gg = {:.4f}".format(utot, gg))
for kkk in range(kmax):
# call dembx to go into the conjugate gradient solver
if kkk == 0:
Ah, Lstep, h, u, gg = dembx(ns, Lstep, gg, dk, gtest, ldemb, kkk,
gb, ib, pix, u, gb.copy())
else:
Ah, Lstep, h, u, gg = dembx(ns, Lstep, gg, dk, gtest, ldemb, kkk,
gb, ib, pix, u, h)
print("piece1 = ",piece1)
print("piece2 = ",piece2)
print("piece3 = ",piece3)
E = 2/(R*R)*simps(d_rfs,d_rs)
E += omega*delta*delta/2*(3/4*delta*delta-1)
E += -(1+k24)/(R*R)*np.sin(d_psis[-1])+2*gamma/R
print("E python discrete from continuum integral = ",E)
E_d = energy(R,eta,delta,R_c,R_s,psip_c,psip_s,psip_R,
K33,Lambda,omega,k24,gamma)
print("E python discrete from discrete integral = ",E_d)
"""
fig, axarr = plt.subplots(2,sharex=True)
axarr[0].plot(c_rs,c_psis,'o',label='continuous')
axarr[0].plot(d_rs,d_psis,'.',label='discrete')
axarr[0].set_ylabel(r"$\psi(r)$")
axarr[1].plot(c_rs,c_rfs,'o',label='continuous')
axarr[1].plot(d_rs,d_rfs,'.',label='discrete')
axarr[1].set_ylabel(r"$rf(r)$")
axarr[1].set_xlabel(r"$r$")
var.r2 = nano_r
# testing shape
startZ = (var.hc0 + nano_r)
endZ = 0
elementPsi = np.zeros(elementNum)
elementPsi[0] = 0
elementPsi[-1] = 0 # const.pi / 2
# np.linspace(0, 40, 41):
for nano_dist in np.linspace(0, 20, 21):
var.x1 = nano_dist / 2 + var.r1
var.x2 = -nano_dist / 2 - var.r1
m = membrane.Membrane(elementPsi, elementLength, startZ,
endZ)
e0 = energy.energy(m, var)
# boundaries for psi values
boundPsi = [(var.hc0, var.hc0 + nano_r)]
for eachPsi in m.psi[2:-2]:
boundPsi.append((-np.pi / 2, np.pi / 2))
x01 = sp.optimize.minimize(energy.energyPsi,
np.append(
m.startZ, m.psi[2:-2]),
args=(m, var),
method='SLSQP',
bounds=boundPsi,
options={
'disp': True,
'maxiter': 1000
})
