for l in range(N):

# what is the distace between the lth fiducial particle adn the perturbed?

lth_distance,across_seam = distance(x_unpurt,x_purt,l,N)

# if the distace is shorter across the seam of the boundary (across_seam = True) then set

# the purtubed particle position to +- 2pi so the points are next to eachother. if the

# purturbed particle position is less than the unpurturbed add 2pi. if the otherway around

# minus 2pi

if across_seam:

if x_unpurt[l+N] < x_purt[l+N]:

x_purt[l+N] = x_purt[l+N]-2.0*pl.pi

if x_unpurt[l+N] > x_purt[l+N]:

x_purt[l+N] = x_purt[l+N]+2.0*pl.pi

# check new distance

temp_dist,temp_across = distance(x_unpurt,x_purt,l,N)

print('fixed a distance in shuff. New dist is: ' +str(temp_dist))

x_new = pl.copy(x0)

print('getting the first initial condition')

print('fiducial initial: '+str(x0))

# multi particle array layout [nth particle v, (n-1)th particle v , ..., 0th v, nth particle x, x, ... , 0th particle x]

# we will use a change of coordinates to get the location of the particle relative to x0. First

# we just find some random point a distace epsilon from the origin.

# need 2DN random angles

angle_arr = pl.array([])

purturbs = pl.array([])

# This is just an n-sphere

for i in range(2*N):

angle_arr = pl.append(angle_arr,random.random()*2.0*pl.pi)

cur_purt = epsilon

for a,b in enumerate(angle_arr[:-1]):

cur_purt *= pl.sin(b)

if i == (2*N-1):

cur_purt = pl.sin(angle_arr[i])

else:

cur_purt = pl.cos(angle_arr[i])

purturbs = pl.append(purturbs,cur_purt)

print('sqrt of sum of squars should be epsilon -> is it? --> ' +str(pl.sqrt(pl.dot(purturbs,purturbs))))

print('len(purturbs) == 2N ? ' +str(len(purturbs)==(2*N)))

# see weather the particle is closer in the normal way or across the seam of the bounday.

x_normal = abs(x1[N+particle]-x2[N+particle])

print('x_normal: ' + str(x_normal))

x_period = abs(2.0*pl.pi - x_normal)

print('x_periodi: ' + str(x_period))

if x_normal < x_period:

#print('x_normal < x_period (distance NOT across boundry is smaller)')

across_seam = False

x_sqrd = x_normal**2

if x_normal > x_period:

#print('x_normal > x_period (distance across boundry is smaller)')

across_seam = True

x_sqrd = x_period**2

vx_sqrd = (x1[particle]-x2[particle])**2

dist = pl.sqrt(vx_sqrd + x_sqrd)

#if dist>2.0*pl.pi:

# dist -= 2.0*pl.pi

print('returning across_seam = ' +str(across_seam))

xnew = pl.copy(x_unpurt)

# first determine which trajectories get to small

# this variable is the amount by which a trajectory must grow otherwise it is going to get set

# to fiducial position and prbably will not grow after that

check = total_epsilon/pl.sqrt(N)/2.0

# keep track of the index of particles that are "chaotic"

chaotic = pl.array([])

# keep track of their final distances too

chaotic_dists = pl.array([])

# now check

for l in range(N):

# what is the distace between the lth fiducial particle adn the perturbed?

lth_distance,across_seam = distance(x_unpurt,x_purt,l,N)

# if the distace is shorter across the seam of the boundary (across_seam = True) then set

# the purtubed particle position to +- 2pi so the points are next to eachother. if the

# purturbed particle position is less than the unpurturbed add 2pi. if the otherway around

# minus 2pi

if across_seam:

if x_unpurt[l+N] < x_purt[l+N]:

x_purt[l+N] = x_purt[l+N]-2.0*pl.pi

if x_unpurt[l+N] > x_purt[l+N]:

x_purt[l+N] = x_purt[l+N]+2.0*pl.pi

# check new distance

temp_dist,temp_across = distance(x_unpurt,x_purt,l,N)

print('fixed a distance in renormalize. New dist is: ' +str(temp_dist))

# after all this we need to re modulus the system --> at the end of this function

if lth_distance < check:

# set velocity to fiducial

xnew[l] = x_unpurt[l]

# set position to fiducial

xnew[N+l] = x_unpurt[N+l]

else:

chaotic = pl.append(chaotic,l)

chaotic_dists = pl.append(chaotic_dists,lth_distance)

print('number of chaotic is: ' + str(len(chaotic)))

# If there are no chaotic paticles than it is still useful to measure the

# negative LE. To do this --> if there are no chaotic particle --> make a randome set of

# purturbed initial conditions just like whats done in for the very first set of initial

# conditions

if len(chaotic)==0:

for k in range(N):

xnew = get_first_init(xnew,total_epsilon/pl.sqrt(N),k,N)

else:

# The best we can do is split the total epsilon up evenly between the chaotic particles.

to_perturb = total_epsilon/pl.sqrt(float(len(chaotic)))

# where len(chaotic) is the number of chaotic particles

# enumerate chaotic for the indicies of particles to renormalize to distance to_perturb from

# fiducial

for n,m in enumerate(chaotic):

# particle m will be chaotic_dists[n] from fudical

# velocity

xnew[m] = x_unpurt[m] + (to_perturb/chaotic_dists[n])*(x_purt[m]-x_unpurt[m])

# position

xnew[N+m] = x_unpurt[N+m] + (to_perturb/chaotic_dists[n])*(x_purt[N+m]-x_unpurt[N+m])

# because of seam checking we need to re modulus the system

xnew[N:]=xnew[N:]%(2.0*pl.pi)

# BEFORE ANYTHING: make sure particles near boundaries are shuffeled into places where where the

# seam is not between any purturbed and fudicial trajectories.

x_unpurt,x_purt = shuff(x_unpurt,x_purt,N)

# The trajectory we are going to be returning is going to be the new one for the next run. lets

# call it

x_new = pl.copy(x_unpurt)

# copied it because we are going to add the small amounts to it to purturb it.

# lets find a vector pointing in the direction of the trajectories path. For this we need the

# fiducual point at t-dt, which is given to us in the function as x_before. find the vector

# between x_before and x_unpurt

traj_vec = x_unpurt-x_before

# normalize it

traj_vec = traj_vec/pl.sqrt(pl.dot(traj_vec,traj_vec))

print('traj_vec magnitude (should be 1): ' + str(pl.sqrt(pl.dot(traj_vec,traj_vec))))

# Now lets see how close the vector pointing from the fidicial to the perturbed trajectorie is

# to orthogonal with the trajectory... should get closer to 1 as we check more because it should

# be aligning itself with the axis of greatest expansion and that should be orthogonal.

# First normalize the difference vector

diff_vec = x_unpurt - x_purt

# normalize it

diff_vec = diff_vec/pl.sqrt(pl.dot(diff_vec,diff_vec))

print('diff_vec magnitude (should be 1): ' + str(pl.sqrt(pl.dot(diff_vec,diff_vec))))

print('normalized(x_unpurt-x_purt)dot(traj_vec) (should get close to 0): '+ str(pl.dot(diff_vec,traj_vec)))

# for now lets just return a point moved back along the difference vector. no gram shmidt or

# anything.

poin = get_poin(sol,dt)

poin[:,2]=poin[:,2]%(2*pl.pi)

first_fig = pl.figure()

first_ax = first_fig.add_subplot(111)

first_ax.scatter(poin[:,2],poin[:,0],color="Black",s=.1)

first_ax.set_xlabel("$x_1$",fontsize=25)

first_ax.set_ylabel("$x_2$",fontsize=25)

#first_ax.set_xlim([0,2*pl.pi])

#first_ax.set_ylim([-1.3,1.3])

first_fig.savefig("first_plot.png")

# Structure:

# 1) take multi particle run of interest -> this is fiducial trajectory.

# 1a) slice the data

# 2) throw awway transients

# 3) take PC of fiducal as initial conditions for a seperate run

# 4) purturb ALL the partiicls epsilon/N

# 5) Run puturbed version of system for a period

# 6) measure All the distance between the fiducial trajectories and the new trajectories after

# the one period. Store the sum of these distances and each of them individualy. FOR ALL PARTICLES.

# 7) move all particles back along line to fiducial particls to get expansion to get iniitial conditinos for next run.

# 8) do this many times and average the total separations to find LE

# 1)

# getting the data

parser = argparse.ArgumentParser()

# d is for directory

parser.add_argument('-d',action='store',dest = 'd',type = str, required = False, default = './')

# f is for file

parser.add_argument('-f',action='store',dest = 'f',type = str, required = False)

# n is for the particle of interest

#parser.add_argument('-n',action='store',dest = 'n',type = int, required = True)

# eplsilon should be passable. THis is total epsilon

parser.add_argument('-e',action='store',dest = 'e',type = float, required = False,default = 1e-4)

inargs = parser.parse_args()

d = inargs.d

f = inargs.f

#particle = inargs.n

# distances from fidicual are stored

final_dist_arr = pl.array([])

# get system info

qq,dt,beta,A_sweep_str,cycles,N,x_num_cell,y_num_cell,order,sweep_str,Dim = of.get_system_info()

print("A from get_system_info() is: " +str(A_sweep_str))

file_object = open(f,'r')

first_line = file_object.readline()

print('first line of data file: ' +str(first_line))

A = pl.zeros(N)+float(first_line.split()[-1])

print("A from working file is: " + str(A))

data = pl.genfromtxt(file_object)

print('shape of fiducial data before doing anything: ' +str(pl.shape(data)))

# 1a)

# first lets slice the data so that we have poincare sections of minimum field potential. This

# should make it so slight errors in initial conditions of unpurturbed particles are less

# prevelent. Why? Because small error in position when \Phi not zero means an error in evergy as

# well. This will happen with the velocities (KE) but we can minimizi it by using zerro

# potential poincare sections.

# data for values of t=pi(2*n + 1/2) (zero potential poincare seciton)

new_data = pl.array([])

# also want data for time RIGHT BEFORE slice point --> why? --> see renormalize function

new_before = pl.array([])

checked = True

for i in range(len(data)):

# This is getting values of time that are at makimum potentials!!! WRONG

# check_time = i*dt%(pl.pi*2.0)

# Right

check_time = (i*dt+pl.pi/2.0)%(pl.pi*2.0)

if check_time < dt and check_time > 0.0:

new_data = pl.append(new_data,data[i,:])

new_before = pl.append(new_before,data[i-1,:])

if checked:

first_i = i

checked=False

sliced_data = new_data.reshape(-1,2*N)

sliced_before = new_before.reshape(-1,2*N)

print('shape of sliced fiducial data before doing anything: ' +str(pl.shape(sliced_data)))

sliced_data[:,N:] = sliced_data[:,N:]%(2.0*pl.pi)

# for full data set just throw away the first few points so it lines up with the sliced data

# startwise

data = data[first_i:,:]

# SETTING SOME OTHER VARIABLS NOW

# the perturb distance for INDIVIDUAL particles is different from THE SYSTEM PURTERBATION

epsilon = inargs.e

print('epsilon: ' + str(epsilon))

# good

#epsilon = 1.0e-10

# works

# epsilon = 1.0e-10

# 1.0e-13

# period variable should probably just be kept at the actual period (2*pl.pi) but the purpose of

# this variable is to alow us to changhe the lenght of time we wate before we colect the

# distance information and renormalize. This is also nesssasary in the final calculation of the

# LE becae LE = 1/period * ln(rm/r0).

period = 2.0*pl.pi

print('period is: ' + str(period))

# time array of one period. BE CAREFULL -> must start at pi/2 and go to

t = pl.arange(3.0*pl.pi/2.0,3.0*pl.pi/2.0+2.0*pl.pi,dt)

# 2)

# throw awway transients

# fiducial run is probably not very long becasue of the need for a high time resolution so lets

# throw awway the whole first half

sliced_data = sliced_data[(len(sliced_data[:,0])/2):,:]

print('shape of sliced fiducial data after getting rid of transients: ' +str(pl.shape(sliced_data)))

# 3) get our initial conditions for the purturbed run

fiducial_start = sliced_data[0,:]

print('First fiducial: '+str(fiducial_start))

# 4) purturb all particles by epsilon

init = get_first_init(fiducial_start,epsilon,N)

print('first purturbed initial conditions: '+str(init))

# 5) Run puturbed version of system for a period

elec = ec.Sin1D(qq,A,beta,x_num_cell)

watch = pl.array([])

watch_le = 0.0

# In order to watch whats happening we are going to add some plotting stuff that we can put in

# "if" or just comment out later

os.mkdir('WatchingLE')

#for i in range(1,len(sliced_data)-1):

for i in range(1,50):

print(i)

purt_sol = odeint(elec.f,init,t)

#print('init: ' + str(init))

#print('sliced_data[i-1,:] = ' + str(sliced_data[i-1,:]))

# Lets see what happens when we run the fudicial trajectory again with (see how much the

# time step maters).

#test_sol = odeint(elec.f,sliced_data[i-1,:],t)

#test_sol[:,N:(2*N)] = test_sol[:,N:(2*N)]%(2.0*pl.pi)

# make sure particle are in the right modulus space

#purt_sol[:,N:(2*N)] = purt_sol[:,N:(2*N)]%(2.0*pl.pi)

# 6) measure the distance between the fiducial trajectores and the new trajectories after the one period

fiducial_end = sliced_data[i,:]

before_end = sliced_before[i,:]

purt_end = purt_sol[-1,:]

#purt_end = test_sol[-1,:]

#first_fig = pl.figure()

#first_ax = first_fig.add_subplot(111)

#for gamma in range(N):

# first_ax.scatter(purt_sol[:,gamma+N],purt_sol[:,gamma],color="Red",s=5)

# first_ax.scatter(data[(int(2.0*pl.pi/.001)*(i-1)):(int(2.0*pl.pi/.001)*i),gamma+N],data[(int(2.0*pl.pi/.001)*(i-1)):(int(2.0*pl.pi/.001)*i),gamma],color="Blue",s=5)

# if gamma == 1:

# first_ax.annotate('start',xy=(purt_sol[0,gamma+N],purt_sol[0,gamma]),xytext=(pl.pi/2,-1.5),arrowprops=dict(facecolor='black',shrink=0.05))

# first_ax.annotate('stop' ,xy=(purt_sol[-1,gamma+N],purt_sol[-1,gamma]),xytext=(pl.pi/2,1.5) ,arrowprops=dict(facecolor='black',shrink=0.05))

#first_ax.set_xlim([0.0,2.0*pl.pi])

#first_ax.set_ylim([-2.0,2.0])

##first_ax.set_xlabel("$x_1$",fontsize=25)

##first_ax.set_ylabel("$x_2$",fontsize=25)

##first_ax.set_xlim([0,2*pl.pi])

##first_ax.set_ylim([-1.3,1.3])

#first_fig.savefig('WatchingLE/'+str(i)+".png")

#pl.close(first_fig)

# get the distance between the fudicial and the purturbed trajectory

final_dist = full_distace(fiducial_end,purt_end,N)

print('final distance: ' +str(final_dist))

final_dist_arr = pl.append(final_dist_arr,final_dist)

# 7) set up new initial condition

init = renormalize(fiducial_end,before_end,purt_end,epsilon,N)

print('renormalized... new initial conditions are: ' + str(init))

print('compair above to fiducial final position ->: ' + str(fiducial_end))

print('epsilon: ' + str(epsilon))

print('one minus the other sqrd sqrted (should be epsilon): '+

str(pl.sqrt(((init-fiducial_end)**2).sum())))

watch_le += pl.log(final_dist_arr[-1]/epsilon)

cur_avg = watch_le/i/period

watch = pl.append(watch,cur_avg)

eps_arr = pl.zeros(len(final_dist_arr))+epsilon

le = pl.log(pl.sqrt(abs(final_dist_arr))/epsilon)/period

print('mean LE (LE is): ' +str(le.mean()))

print('standard deviation LE: ' +str(le.std()))

fig = pl.figure()

ax = fig.add_subplot(111)

ax.scatter(pl.arange(len(watch)),watch,s=.1)

#ax.set_xlabel("$x_1$",fontsize=25)

#ax.set_ylabel("$x_2$",fontsize=25)

#ax.set_xlim([0,2*pl.pi])

#ax.set_ylim([-1.3,1.3])

#fig.tight_layout()

fig.savefig("convergence_LE.png")