myprojects-hg-reborn

Fork

Now cluster_functions.R also saves some extra features of the aggregate
which are used for the post-processing.

Now plot_statistics.py includes some of the features of
plot_statistics2.py and can calculate the radius of gyration of the
aggregate and print the histograms of the number and radius of gyration
distributions.

Now in plot_statistics.py I can specify the initial configuration I was
reading, the final one and the step.

Now read_test.tcl is able to read configurations from a selected one to
a final one (specified by the user) and with a given spacing.

Now cluster_functions.R contains a new function which is used by
plot_statistics2.py to calculate the radius of gyration of the clusters
in a configuration.

Now test_visual.py is also able to display an animation.

Now plot_statistics2.py is also able to calculate the radius of gyration
for a given particle configuration.

Now test_visual.py is able to calculate the histogram corresponding to
the number distribution of the various clusters and can also re-write
the particle positions in an "ordered" way which is much easier to deal
with for calculating e.g. the radius of gyration or for plotting them.

I added the small code plot_statistics2.py which does some further
post-processing on the cluster number.

now test_interaction.tcl accepts the number of particles and the density
as inputs parameters and works out the box size accordingly.

Now plot_statistics.py accepts number of particles and density as inputs
and works out the box size.

I added test_visual.py, a small code using visual python to visualize
the results of my simulations.

Now plot_statistics.py also saves the cluster particle distribution.

I reorganized plot_statistics.py which now first works out the structure
(how many of them, how many particles in each) of the clusters and then
works out the radius of gyration. It depends on a fortran90 compiled
routine and on an R script.

cluster_functions.R now returns both the number of clusters and their
structure as a matrix (I have to declare that explicitely) which is then
accessed by SciPy.

I simply re-organized the loops in the routine to calculate the
"correct" distances.

I added the code distance_calc.f90 which is what is used to generate a
module used by the script plot_statistics.py.

I modified the code plot_statistics.py, now it calculates properly the
number of clusters (I added a compiled fortran code) which evaluates
properly the relative distances. However, now the calculation of the
radius of gyration is spoilt and has to be fixed.

I added the code test_graph.R to perform some tests on a couple of
configurations [=sets of particle positions] in order to investigate the
number of aggregates, their composition etc...

I added the code cluster_functions.R which does the same things as
cluster.R but using functions which can be imported in Python via Rpy.
Beware that the <- of R have to be replaced by = and when you specify
the value which a function has to return in its declaration, use e.g.
return(z), with brackets and no spaces.

Now the code plot_statistics.py is able to call some R functions to
study the number of aggregates, but this still has to be fixed/tested.

I added the code cluster.R; it generates a set of random particles in
2D, then works out the distance matrix and then counts how many
aggregates/clusters there are (I give a specified distance threshold)
and also spells out their composition. It relies on the igraph package.
Since this package was originally written in C, the numbering of
particles start with zero (C-style) instead of one (R-style).

I simply modified the definition of the length I am using in the routine
for numerical derivatives; now it is worked out correctly every time I
define a new r vector where r is the independent variable.

I removed some redundant calls or references to VMD in the code
test_interaction.tcl (the visualization is intact, but the code is now
more correct).

I made small modifications to plot_potential.py, which is now saving
more quantities and also opening windows to see the potential and the
resulting force.

I modified the way in which I call VMD (now only when I am saving a
configuration, NOT at every time step).
However, this has not been tested throughly yet.

I modified plot_potential.py which is now able to save the potential,
the force and the distance in a way suitable for Espresso.
However, one still has to modify a bit by hand the tabulated potential
(e.g. the number of particles has to be an integer and the first line of
the tabulated potential has to be a #).

I modified test_interaction.tcl which is now able to use a tabulated
interaction potential I can generate myself. The code is still
experimental; in particular the equilibration part is now useless and
should be either removed or fixed (since I am doing nothing there; it is
just a loop where there is no evolution of the system, since the part
with the "integrate" command is now commented out.

I modified the code plot_potential.py which now calculates a new binding
potential I "invented" after chatting with Yannis (I can now specify
separately the depth, the position of the minimum and the cut-off). The
code now needs to import a module which is compiled Fortran 90 code (see
file derivative.f90 in the f2py folder). That compiled code is used to
calculate numerically the derivative of the potential (to get the force
after reversing its sign).

I added a couple of lines to derivative.f90: they tell how to compile
the routine.