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 main2(directori, fitxer, fitxer2):
fitxer = os.path.join(directori, fitxer)
fitxer2 = os.path.join(directori, fitxer2)
g = Gnuplot.Gnuplot()
sys_info = SysInfo(open(fitxer).readlines()[0])
print sys_info
fr1 = frames(fitxer, sys_info.sys_size)
fr2 = frames(fitxer2, sys_info.sys_size)
for fr1_info, fr1_pos in fr1:
fr2_info, fr2_pos = fr2.next()
title = "frame: %s t = %s" % tuple(fr2_info.split())
g("set title '%s'" % title)
g.plot(fr1_pos, fr2_pos)
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 main(directori, posicions="posicions"):
nom_fitxer = os.path.join(directori, posicions)
sys_info = SysInfo(open(nom_fitxer).readlines()[0])
out = None
printa_nonaffine_header(sys_info, out)
for frame_info, posicions in frames(nom_fitxer, sys_info.phys_size):
nonaffine = nonaffine_positions(sys_info, frame_info, posicions)
printa_nonaffine(frame_info, nonaffine, out)
def main(directori, fitxer=None):
if fitxer is None:
fitxer = nom_fitxer_posicions
fitxer = os.path.join(directori, fitxer)
g = Gnuplot.Gnuplot()
sys_info = SysInfo(open(fitxer).readlines()[0])
print sys_info
for frame_info, posicions in frames(fitxer, sys_info.sys_size):
title = "frame: %s t = %s" % tuple(frame_info.split())
g.reset()
g("set title '%s'" % title)
g.plot(Gnuplot.Data(posicions))
def main(directori):
posicionsf = os.path.join(directori, "posicions")
sys_info = SysInfo(open(posicionsf, 'r').readline())
triangulacionsf = os.path.join(directori, "triangulacions")
for frame_info, posicions in frames(posicionsf, sys_info.phys_size):
#sys.stderr.write(frame_info)
tri = Triangulation(posicions)
dislos = tri.dislocations()
#log("%s %d\n" % (frame_info[:-1], len(dislos)))
neig = tri.get_neighbours()
coords = map(len, neig.values())
coordM = sum(coords) / float(len(coords))
log("%s %f %d\n" % (frame_info[:-1], coordM, len(coords)))
def main(directori, fitxer="forces", out=None, acumulator=None):
fitxer = os.path.join(directori, fitxer)
sys_info = SysInfo(open(fitxer).readlines()[0])
global particula
particula = random.choice(range(sys_info.NX * sys_info.NY))
print >> sys.stderr, "particula", particula
if out is None:
out = default_out()
if acumulator is None:
acumulator = DefaultAcumulator()
# print >> out, sys_info
for frame_info, velos_snap in frames(fitxer, sys_info.NX * sys_info.NY):
# print >> sys.stderr, frame_info
acumulator.frame_info = frame_info
extract_velos(velos_snap, out, acumulator)
def main(directori):
g = Gnuplot.Gnuplot()
nom_fitxer = os.path.join(directori, nom_fitxer_stressos)
sys_info = SysInfo(open(nom_fitxer).readlines()[0])
print sys_info
for frame_info, stressos in frames(nom_fitxer, sys_info.phys_size):
g.reset()
g("set pm3d")
g("set dgrid %d,%d" % (sys_info.NX, sys_info.NY))
g("set hidden3d")
g("set ticslevel 0")
g("set title '%s'" % frame_info[:-1])
stressos = [(x, y, syy) for i, x, y, sxx, sxy, syy in stressos]
g.splot(Gnuplot.Data(stressos))
wait()
def energies(nom_fitxer, n):
for frame_info, posicions in frames(nom_fitxer, n):
enes = []
for punt1 in (posicions):
ei = 0.
xi,yi = punt1
for punt2 in (posicions):
if punt1 is not punt2:
xj,yj = punt2
r2 = (xj - xi) * (xj - xi) + (yj - yi) * (yj - yi)
over_r2 = 1./r2
over_r6 = over_r2 * over_r2 * over_r2
over_r12 = over_r6 * over_r6
ei = ei + 4. * (over_r12 - over_r6)
enes.append((xi, yi, ei))
yield frame_info, enes[:]
def main(directori, posicions="posicions"):
nom_fitxer = os.path.join(directori, posicions)
sys_info = SysInfo(open(nom_fitxer).readlines()[0])
out = None
printa_nonaffine_header(sys_info, out)
for index, frame_posicions in enumerate(frames(nom_fitxer,
sys_info.phys_size)):
frame_info, posicions = frame_posicions
if index == 0:
posicions_inicials = posicions
else:
nonaffine = nonaffine_positions(sys_info, frame_info, posicions,
posicions_inicials)
printa_nonaffine(frame_info, nonaffine, out)
def orderInFile(posicionsf):
sys_info = SysInfo(open(posicionsf, 'r').readline())
for frame_info, particules in frames(posicionsf, sys_info.sys_size):
tri = Triangulation(particules)
order = 0.
orderAbs = 0.
norm = 1. / float(len(tri.neighbours))
order2 = 0.
for center, neigh in tri.neighbours.iteritems():
if center in particules[:sys_info.phys_size]:
neig = [n for n in neigh
if n in particules[:sys_info.phys_size]]
order_ = moduloSix(center, neigh)
order = order + norm * order_
orderAbs = orderAbs + norm * abs(order_)
order2 = orderAbs + norm * order_ * order_
yield frame_info, order, order2, orderAbs
def mainG(directori):
import Gnuplot
posicions = os.path.join(directori, "posicions")
sys_info = SysInfo(open(posicions, 'r').readline())
g = Gnuplot.Gnuplot()
for frame_info, particules in frames(posicions, sys_info.phys_size):
g.reset()
g("set pm3d map")
g("set dgrid %d,%d" % (sys_info.NX, sys_info.NY))
g("set hidden3d")
g("set cbrange[0:2 * pi]")
g("set title '%s'" % frame_info[:-1])
tri = Triangulation(particules)
ordres = [(c,moduloSix(c, neigh)) for c, neigh
in tri.neighbours.iteritems()]
#moduls = [(c,abs(o)) for c,o in ordres]
args = [c + (arg(o),) for c,o in ordres]
g.splot(Gnuplot.Data(args))
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
def mainPelis(directori, fitxer=None):
if fitxer is None:
fitxer = nom_fitxer_posicions
fitxer = os.path.join(directori, fitxer)
g = Gnuplot.Gnuplot()
sys_info = SysInfo(open(fitxer).readlines()[0])
print sys_info
g("set term postscript enhanced color")
foto = 0
for frame_info, posicions in frames(fitxer, sys_info.sys_size):
title = "frame: %s t = %s" % tuple(frame_info.split())
if foto % 5 == 0:
g.reset()
g("set output 'foto%04d.eps'" % foto)
g("set title '%s'" % title)
g("set xrange[-5:35]")
g("set yrange[-20:60]")
g.plot(Gnuplot.Data(posicions))
foto = foto + 1
def mainPygame(directori, fitxer=None):
if fitxer is None: fitxer = nom_fitxer_posicions
fitxer = os.path.join(directori, fitxer)
sys_info = SysInfo(open(fitxer).readlines()[0])
print sys_info
import pygame
dimensionsInPixels = (640, 480)
dimensionsInPixels = (1024, 800)
srf = pygame.display.set_mode(dimensionsInPixels)
dimensionsInLengths = ((sys_info.NX + 2 + 2) * sys_info.delta_x,
(sys_info.NY + 2 * sys_info.ny_extra + 2 + 2) *
sys_info.delta_y)
def coord(x,y):
pixx, pixy = dimensionsInPixels
pixx, pixy = pixx - 10, pixy - 10
lx, ly = dimensionsInLengths
x0 = sys_info.delta_x * 2.1
y0 = sys_info.ny_extra * sys_info.delta_y
x = x + x0
y = y + y0
#print x,y
#assert (x >= 0)
#assert (y >= 0)
pix = int(x * pixx / lx) + 10 #+ pixx/2
piy = int(y * pixy / ly) + 10 #+ pixy/2
#print pix, piy
return pix, piy
radius = int(0.25 * dimensionsInPixels[0] * sys_info.delta_x / dimensionsInLengths[0])
#print "radius", radius
for frame_info, posicions in frames(fitxer, sys_info.sys_size):
srf.fill((255,255,255))
for (x,y) in posicions:
x,y = coord(x,y)
pygame.draw.circle(srf, (55, 0, 200), (x,y), radius, 0)
pygame.display.flip()
def __init__(self, filename):
self.sys_info = SysInfo(open(filename, 'r').readline())
self.frames = frames(filename, self.sys_info.sys_size)
