def parameter(name):
# read parameters when needed
try: mass
except NameError: mass=read_input(1.,'.mass',doc='mass(es) in the system')
try: kappa
except NameError: kappa=read_input(1.,'.kappa',doc='kappa: harmonic constant')
try: langl
except NameError: langl=read_input(10,'.angular momentum',doc='angular momentum')
try: peak_field
except NameError: peak_field=read_input(0.,'.laser',1,doc='maximal field strength')
try: frequency
except NameError: frequency=read_input(1.,'.laser',2,doc='laser frequency')
def _mass(t): return mass
def _plus_mass_half(t): return mass/2.
def _minus_mass_half(t): return -mass/2.
def _kappa(t): return kappa
def _kappa_half(t): return kappa/2.
def _plus_one(t): return 1.
def _minus_one(t): return -1.
def _lsq_mass_half(t): return 0.5/mass*langl*(langl+1)
def _laserpulse(t): return peak_field*cos(2*myPi*frequency*t)
# assign according to name
if name.strip() == 'mass': return _mass
elif name.strip() == 'kappa': return _kappa
elif name.strip() == 'kappa/2': return _kappa_half
elif name.strip() == '-1': return _minus_one
elif name.strip() == '+1': return _plus_one
elif name.strip() == '1': return _plus_one
elif name.strip() == '-1/2m': return _minus_mass_half
elif name.strip() == '1/2m': return _plus_mass_half
elif name.strip() == '+l(l+1)/2m':return _lsq_mass_half
elif name.strip() == 'laser(t)': return _laserpulse
else: sys.exit('unknown parameter name "'+name.strip()+'"')
def read(cls,l=0):
"""read axis parameters from file as below and set up, and return axis
.coordinate axis
str name,int n,float lb,float up,str type,int order
"""
name=read_input('none','.coordinate axis',1,l+1,'axis name: r,x,z,...',True)
n=read_input(0,'.coordinate axis',2,l+1,'numer of discretization coefficients',True)
lb=read_input(0.,'.coordinate axis',3,l+1,'lower boundary of axis',True)
ub=read_input(0.,'.coordinate axis',4,l+1,'upper boundary of axis',True)
typ=read_input('fem(legendre)','.coordinate axis',5,l+1,'type: fem,legendre...',False)
order=read_input(4,'.coordinate axis',6,l+1,'finite element order',False)
kappa=typ.rpartition('(')[2].partition(')')[0]
typ=typ.partition('(')[0]
typ=typ.strip('(')
ax=Axis(name,n,lb,ub,typ,order,axpar=[kappa])
return ax
def read(cls):
"""read definition of one or several pulses"""
i = 0
wave_length = read_input(800.0, ".laser pulse", 1, i + 1, doc="carrier wave length (nm)")
duration = read_input(1.0, ".laser pulse", 2, i + 1, doc="FWHM of pulse duration (optical cycles)")
peak_intensity = read_input(1.0e-14, ".laser pulse", 3, i + 1, doc="peak intensity (W/cm^2)")
pulse_shape = read_input("cossq", ".laser pulse", 4, i + 1, doc="shapes: cossq,gauss,trapez,file,...")
phase = read_input(0.0, ".laser pulse", 5, i + 1, doc="carrier-envelope offset phase (optical cycles)")
delay = read_input(0.0, ".laser pulse", 6, i + 1, doc="time delay of the pulse (fs)")
# convert to internal units
Units(au())
print "wave length", SI().length(wave_length * 1.0e-9)
print "speed of light", SI().length(speed_of_light)
print "duration", OptCyc(wave_length * 1.0e-9).time(duration)
laser = SinglePulse(
SI().length(wave_length * 1.0e-9),
OptCyc(wave_length * 1.0e-9).time(duration),
SI().intensity(peak_intensity * 1.0e-4),
pulse_shape,
phase / (2.0 * myPi),
SI().time(delay * 1.0e-9),
)
return laser
"float",
[FLAGS.batch_size, None, h, w, channels]) #shape=(24, ?, 128, 257, 3)
Y = tf.placeholder(
"float", [FLAGS.batch_size, None, h, w, 1]) #shape=(24, ?, 128, 257, 1)
timesteps = tf.shape(X)[1]
h = tf.shape(X)[2]
w = tf.shape(X)[3]
prediction, last_state = ConvLSTM(X) #shape=(24, ?, 256, 513, 1)
loss_op = tf.losses.mean_pairwise_squared_error(Y, prediction)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)
#3 :Training
with tf.Session() as sess:
# Initialize all variables
saver = tf.train.Saver()
init = tf.global_variables_initializer()
sess.run(init)
train_X, train_Y, test_X, test_Y, val_X, val_Y = read_input(
"/export/kim79/h2/TC_labeled_dataset/2_new_dataset_for_heatmap_generation_normalized/"
)
print("finished collecting data")
for ii in range(1000):
train(sess, loss_op, train_op, X, Y, train_X, train_Y, val_X, val_Y,
prediction, last_state, fout_log)
name = str(ii)
test(name, sess, loss_op, train_op, X, Y, test_X, test_Y, prediction,
last_state, fout_log)
fout_log.close()
X = tf.placeholder("float", [FLAGS.batch_size, None, h, w, channels])
#SH: Need to correct y placeholder to get the exact corrdinate value: something like [FLAGS.batch_size, None, 1,1,1] where axis=2 getting x-coordinate, axis=3 getting y-coordinate, axis=4 getting confidence score: design by your own depending on shape of output label
Y = tf.placeholder("float", [FLAGS.batch_size, None, h, w, 1])
timesteps = tf.shape(X)[1]
h = tf.shape(X)[2]
w = tf.shape(X)[3]
#SH: Need to correct ConvLSTM function in a way to regress out the exact coordinate(in rnn.py)
prediction, last_state = ConvLSTM(X)
loss_op = tf.losses.mean_pairwise_squared_error(Y, prediction)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)
#3 :Training
with tf.Session() as sess:
# Initialize all variables
saver = tf.train.Saver()
init = tf.global_variables_initializer()
sess.run(init)
train_X, train_Y, test_X, test_Y, val_X, val_Y = read_input("./")
print("finished collecting data")
test("temp", sess, loss_op, train_op, X, Y, test_X, test_Y, prediction,
last_state, fout_log)
for ii in range(1000):
train(sess, loss_op, train_op, X, Y, train_X, train_Y, val_X, val_Y,
prediction, last_state, fout_log)
name = str(ii)
test(name, sess, loss_op, train_op, X, Y, test_X, test_Y, prediction,
last_state, fout_log)
fout_log.close()
from read_input import *
def calculate_paper(box):
lw = box.length * box.width
wh = box.width * box.height
hl = box.height * box.length
area = (2 * lw) + (2 * wh) + (2 * hl)
smallest_side = min([lw, wh, hl])
return area + smallest_side
if __name__ == "__main__":
total = 0
for box_dimension in read_input():
total += calculate_paper(box_dimension)
print(total)
timesteps = tf.shape(X)[1]
h = tf.shape(X)[2] #h:256
w = tf.shape(X)[3] #w:513
prediction, last_state = ConvLSTM(X)
loss_op = tf.losses.mean_pairwise_squared_error(Y, prediction)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)
#3 :Training
with tf.Session() as sess:
# Initialize all variables
saver = tf.train.Saver()
init = tf.global_variables_initializer()
sess.run(init)
test("0", sess, loss_op, train_op, X, Y, prediction, last_state, fout_log)
start = [0, 20, 40, 60, 80]
end = [20, 40, 60, 80, 102]
for ii in range(1000):
name = str(ii)
for k in range(len(start)):
train_X, train_Y, val_X, val_Y = read_input(
"./data_ts3/", start[k], end[k])
train(sess, loss_op, train_op, X, Y, train_X, train_Y, val_X,
val_Y, prediction, last_state, fout_log)
if ii > 3:
test(name, sess, loss_op, train_op, X, Y, prediction, last_state,
fout_log)
save_path = saver.save(sess, "./model_" + str(ii) + ".ckpt")
fout_log.close()
#! /usr/bin/env python
import numpy as np
import matplotlib.pyplot as plt
from read_input import *
from axis import *
from tensor import *
from myeigen import inversiter
# open the first string after the program name as input file
read_input_open(sys.argv[1])
# read system parameters
field=read_input(0.,'.system parameters',1,doc='field strength (a.u.)')
lmin =read_input(0, '.system parameters',2,doc='minimal angular momentum')
lmax =read_input(0, '.system parameters',3,doc='maximal angular momentum')
mqn =read_input(0, '.system parameters',4,doc='m quantum number')
steps=read_input(0,'.field steps',1,doc='increase to field strength in steps')
nplot=read_input(0,'.field steps',2,doc='number of energies to plot')
metho=read_input('full','.field steps',3,doc='how to find roots: full,invit')
theta=read_input(0.,'.complex scaling angle',1,doc='how to find roots: full,invit')
lmin=max(mqn,lmin) # minimal angular momentum cannot be below m-quantum number
ax=axis_read(0) # read the axis
# check input, write docu-file
read_input_finish()
# hydrogen atom (L=0)
print 'hydrogen atom'
from read_input import *
UP = '('
DOWN = ')'
if __name__ == '__main__':
for item in read_input('../input.txt'):
print(item.count(UP) - item.count(DOWN))
#! /usr/bin/env python import numpy as np import matplotlib.pyplot as plt from read_input import * from axis import * from tensor import * from myeigen import inversiter # open the first string after the program name as input file read_input_open(sys.argv[1]) # read system parameters field=read_input(0.,'.system parameters',1,doc='field strength (a.u.)') lmin =read_input(0, '.system parameters',2,doc='minimal angular momentum') lmax =read_input(0, '.system parameters',3,doc='maximal angular momentum') mqn =read_input(0, '.system parameters',4,doc='m quantum number') theta=read_input(0.,'.complex scaling angle',1,doc='how to find roots: full,invit') steps=read_input(3, '.complex scaling angle',2,doc='repeat calculation steps times with different angles') lmin=max(mqn,lmin) # minimal angular momentum cannot be below m-quantum number ax=axis_read(0) # read the axis # check input, write docu-file read_input_finish() # hydrogen atom (L=0) print 'hydrogen atom' hamr=np.zeros((ax.n,ax.n)) kinr=np.zeros((ax.n,ax.n)) potr=np.zeros((ax.n,ax.n))
from read_input import *
train_X3, train_Y3, test_X3, test_Y3, val_X3, val_Y3 = read_input(
"/export/kim79/h2/TC_labeled_dataset/3_dataset_track_only_one_storm_at_a_time_CAM5/R2/",
600, 900)
import matplotlib.pyplot as plt
import scipy.linalg as la
from math import *
from cmath import *
from read_input import *
from matplotlib import colors, ticker
from mytimer import *
from my_constants import He_ground
tm=create(20)
# inputs
read_input_open(sys.argv[1])
chrg=read_input(2., ".nuclear charge",doc="nuclear charge")
xsym=read_input(1, ".exchange symmetry",doc="exchange symmetry = +1 or -1")
alfa=read_input(1., ".interparticle basis",1,doc="r1-exponent",force=True)
beta=read_input(alfa,".interparticle basis",2,doc="r2-exponent")
psum=read_input(0, ".interparticle basis",3,doc="maximal sum of powers",force=True)
mmax=read_input(psum,".interparticle basis",4,doc="maximal r1 power")
nmax=read_input(psum,".interparticle basis",5,doc="maximal r2 power")
kmax=read_input(psum,".interparticle basis",6,doc="maximal r3 power")
thet=read_input(0.,".complex scaling angle",doc="complex scaling angle in rad")
read_input_finish()
if chrg <=0: exit("need positive nuclear charge, is: "+str(chrg))
integral_table=[]
def factorial(n):
map.add(current)
for d in directions:
current = functions.get(d)(current)
map.add(current)
return len(map)
def process_robot(directions):
current_santa = (0, 0)
current_robo = (0, 0)
map_santa = set()
map_robo = set()
map_santa.add(current_santa)
map_robo.add(current_robo)
for i, h in enumerate(directions):
if i % 2 == 0:
current_santa = functions.get(h)(current_santa)
map_santa.add(current_santa)
else:
current_robo = functions.get(h)(current_robo)
map_robo.add(current_robo)
return len(set(map_santa).union(map_robo))
if __name__ == '__main__':
for direction in read_input():
print(process_santa(direction))
print(process_robot(direction))
prediction_image, last_state = ConvLSTM(X)
loss_op_heatmap=tf.losses.mean_pairwise_squared_error(Y_heatmap,prediction_image)
prediction = Multi_CNN(prediction_image)
print(prediction.get_shape())
loss_op_hwxy=tf.losses.mean_squared_error(Y_hwxy,prediction)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
loss_op = loss_op_hwxy+loss_op_heatmap
train_op = optimizer.minimize(loss_op)
#3 :Training
with tf.Session() as sess:
# Initialize all variables
saver = tf.train.Saver()
init = tf.global_variables_initializer()
sess.run(init)
#test_gt("temp",sess,train_op,X,prediction_image, prediction,last_state)
start=[0,10,20,30,40,50,60,70,80,90]
end = [10,20,30,40,50,60,70,80,90,100]
for ii in range(1000):
name=str(ii)
for k in range(len(start)):
train_X,train_Y_heatmap,train_Y_hwxy,val_X,val_Y_heatmap,val_Y_hwxy=read_input("/export/kim79/convLSTM_for_ETC/Model_ts10/tracking_module_test_2_follow_started_hurricane_moving_mnist_test2/PETS200999_ts5_downsample/soo_ts10_downsample4xr_pet09_output_heatmap/data_ts10_ds4x4/",start[k],end[k])
train(ii,sess,loss_op,train_op,X,Y_heatmap, Y_hwxy,train_X,train_Y_heatmap,train_Y_hwxy,val_X,val_Y_heatmap,val_Y_hwxy,prediction, last_state,fout_log)
if ii>0 and ii%10==0:
test_gt(name,sess,train_op,X,prediction_image, prediction,last_state)
#test(name,sess,train_op,prediction,last_state)
save_path = saver.save(sess, "./model_"+str(ii)+".ckpt")
fout_log.close();
def read(cls):
"""everything that defines the physical system"""
mass=read_input(1.,'mass',doc='mass of the system')
potential=Potential.read()
timdep=LaserField.read()
return PhysicalSystem(name,mass,potential,timedep)
RULE_1 = re.compile(r'[aeiou].*[aeiou].*[aeiou]')
RULE_2 = re.compile(r'([a-z])\1')
RULE_3 = re.compile(r'(ab|cd|pq|xy)')
RULE_4 = re.compile(r'([a-z][a-z]).*\1')
RULE_5 = re.compile(r'([a-z]).\1')
def validate(s):
if RULE_1.search(s) and RULE_2.search(s) and not RULE_3.search(s):
return True
return False
def validate2(s):
if RULE_4.search(s) and RULE_5.search(s):
return True
return False
total = 0
for line in read_input():
if validate(line):
total += 1
print(total)
total = 0
for line in read_input():
if validate2(line):
total += 1
print(total)
