def main(directori, fitxer="posicions", out=None):
fitxer = os.path.join(directori, fitxer)
sys_info = SysInfo(open(fitxer).readlines()[0])
global particula
nparticules = sys_info.NX * sys_info.NY
if out is None:
out = default_out()
dsi_list = [DS(i) for i in range(nparticules)]
for frame_info, posicions in frames(fitxer, nparticules):
t = parse_time(frame_info)
extract_ds(posicions, t, dsi_list)
dsix_list = [DSx(i) for i in range(nparticules)]
for frame_info, posicions in frames(fitxer, nparticules):
t = parse_time(frame_info)
extract_ds(posicions, t, dsix_list)
dsiy_list = [DSy(i) for i in range(nparticules)]
for frame_info, posicions in frames(fitxer, nparticules):
t = parse_time(frame_info)
extract_ds(posicions, t, dsiy_list)
for index, dsi in enumerate(dsi_list):
print >> out, dsi.acumulated()
# es "legal" agafar una partícula at random?
particula = random.choice(range(nparticules))
dsi = dsi_list[particula]
fitxer_out = os.path.join(directori, "random_particle_ds.dat")
open(fitxer_out, "w").writelines(str(dsi))
print >> sys.stderr, "Escrivint %s" % fitxer_out
dsix = dsix_list[particula]
fitxer_out = os.path.join(directori, "random_particle_dsx.dat")
open(fitxer_out, "w").writelines(str(dsix))
print >> sys.stderr, "Escrivint %s" % fitxer_out
dsiy = dsiy_list[particula]
fitxer_out = os.path.join(directori, "random_particle_dsy.dat")
open(fitxer_out, "w").writelines(str(dsiy))
print >> sys.stderr, "Escrivint %s" % fitxer_out
#fitxer_out = open(fitxer_out, "w")
#for dsi in dsi_list:
#fitxer_out.writelines(str(dsi))
#fitxer_out.close()
#print >> sys.stderr, "Escrivint %s" % fitxer_out.__name__
fitxer_out = "ds_mean.dat"
fitxer_out = os.path.join(directori, fitxer_out)
ds_mean = statistics_ds(dsi_list)
open(fitxer_out, "w").writelines(str(ds_mean))
print >> sys.stderr, "Escrivint %s" % fitxer_out
participation_ratio(dsi_list)
def main(directori, n_trajectories):
nom_fitxer = os.path.join(directori,nom_fitxer_posicions)
counter = 0
title = ""
sys_info = SysInfo(open(nom_fitxer).readlines()[0])
#print sys_info
NX = sys_info.NX
V = sys_info.V
delta_x = sys_info.delta_x
NY = sys_info.NY
#elegidosi = [random.choice(range(NX * NY)) for i in range(n_trajectories)]
#for frame_info, posicions in frames(nom_fitxer, NX * NY):
#elegidos = [posicions[index] for index in elegidosi]
#print_trajectories(frame_info, posicions)#elegidos)
traj_list = [Trajectoria(i) for i in range(NX * NY)]
for frame_info, posicions in frames(nom_fitxer, NX * NY):
t = parse_time(frame_info)
extract_trajectories(posicions, t, traj_list)
#for traj in traj_list:
#print traj
elegidi = [random.choice(range(NX * NY)) for i in range(2)]
elegidos = [traj_list[i] for i in elegidi]
dif = diferences(elegidos)
for t, dr in dif:
print t, dr
def main(directori, fitxer="forces", out=None):
fitxer = os.path.join(directori, fitxer)
sys_info = SysInfo(open(fitxer).readlines()[0])
if out is None:
out = sys.stdout
for frame_info, forces in frames(fitxer, sys_info.NX * sys_info.NY):
t = parse_time(frame_info)
extract_forces(forces, t, dsf_list)
def affine_positions(sys_info, frame_info, posicions_inicials):
X = sys_info.NX * sys_info.delta_x
Y = sys_info.NY * sys_info.delta_y
x0 = X / 2.
y0 = Y / 2.
V = sys_info.V
t = parse_time(frame_info)
gamma = - V * t / X # ja es strain! no
for x,y in posicions_inicials:
xa = gamma * (x - x0) # hi falta el young en algun lloc
# utilitzar que nonaffine sera 0. per la component y mentre
# no hi hagi plástic, per trobar el módul de Young?
ya = 0. # provisional
yield xa, ya
def nonaffine_positions(sys_info, frame_info, posicions):
X = (sys_info.NX - 0.5) * sys_info.delta_x
Y = (sys_info.NY - 0.5) * sys_info.delta_y
x0 = X / 2.
y0 = Y / 2.
V = sys_info.V
t = parse_time(frame_info)
gamma = - V * t / X
nonaffine = []
for x,y in posicions:
xa = gamma * (x - x0)
xna = x - xa
yna = y # provisional
nonaffine.append((xna, yna))
return nonaffine
def main(directori, fitxer=None):
if fitxer is None:
fitxer = "posicions"
fitxer = os.path.join(directori, fitxer)
sys_info = SysInfo(open(fitxer).readlines()[0])
print sys_info
length0 = None
for frame_info, posicions in frames(fitxer, sys_info.phys_size):
xmaxtup = max(posicions)
xmintup = min(posicions)
xmax = xmaxtup[0]
xmin = xmintup[0]
if length0 is None:
length0 = xmax - xmin
strainReal = (xmax - xmin) / length0
t = parse_time(frame_info)
print frame_info[:-1], 1 - (xmax - xmin) / length0, 2 * sys_info.V * t / length0
