Initial version

This is the draft version that I prepared and that we will use as
a starting point. Still it is a bit dirty, and I will try to improve
documentation and delete unused routines

.gitignore

+.DS_Store
 *~
+*.o
+*.so
+*.dylib
+makefile.dep
+/gromacs*
+/Makefile.conf
+/sourceme.sh
+/tmp
+*.swp
+core

Makefile

+-include Makefile.conf
+
+SUBDIRS = src extensions test
+     
+.PHONY: all clean $(SUBDIRS) doc docclean
+
+ifdef GCCDEP
+all: $(SUBDIRS)
+else
+all:
+	@echo No configuration available
+	@echo First run ./configure.sh
+endif
+     
+$(SUBDIRS):
+	$(MAKE) -C $@
+     
+# compile plumed before tests:
+test: src
+
+clean:
+	cd src && make clean
+	cd extensions && make clean
+	cd test && make clean
+	cd imd && make clean
+	rm -f *~ */*~ */*/*~
+
+fullclean:
+	make clean
+	rm -f Makefile.conf
+	rm -f sourceme.sh
+
+doc:
+	cd user-doc && make
+	cd developer-doc && make
+
+docclean:
+	cd user-doc && make clean
+	cd developer-doc && make clean
+
+

README

+DOCUMENTATION
+
+To build the documentation, type
+$ make doc
+You need doxygen (www.doxygen.org)
+installed to see the html documentation,
+and graphviz (www.graphviz.org/)
+if you want to see the graphs
+of class hierarichy.
+
+The starting point for user documentation is then
+user-doc/html/index.html
+
+The starting point for developer documentation is
+developer-doc/html/index.html
+

configurations/aix.mpi.xlc

+
+CHECK_BOUNDARIES=-D_GLIBCXX_DEBUG
+DOUBLEPRECISION=-qrealsize=8
+
+
+LIBS=-ldl
+DYNAMIC_LIBS=$(IMDLIB)
+
+CPPFLAGS=-D__PLUMED_MPI -D__PLUMED_HAS_DLOPEN $(CHECK_BOUNDARIES) -I. $(PLUMED_INCLUDE) $(IMDDEF)
+#CXXFLAGS=-pedantic -Wall -O -fPIC
+#CFLAGS=-pedantic -Wall -O -fPIC
+CXXFLAGS=-O0 -G -qpic -qrtti=all -qlanglvl=strict98 -qlonglong
+CFLAGS=-O0 -qpic
+
+LDFLAGS=-brtl -bdynamic -bexpall
+SOEXT=so
+LDSO=mpCC -G -qmkshrobj -bM:SRE $(CFLAGS)
+LD=mpCC
+LDF90=mpCC -lm -lxlf90
+CXX=mpCC
+CC=mpcc
+FC=mpxlf
+
+GCCDEP=g++
+
+
+
+
+

configurations/aix.xlc

+
+CHECK_BOUNDARIES=-D_GLIBCXX_DEBUG
+DOUBLEPRECISION=-qrealsize=8
+
+
+LIBS=-ldl
+DYNAMIC_LIBS=$(IMDLIB)
+
+CPPFLAGS=-D__PLUMED_HAS_DLOPEN $(CHECK_BOUNDARIES) -I. $(PLUMED_INCLUDE) $(IMDDEF)
+#CXXFLAGS=-pedantic -Wall -O -fPIC
+#CFLAGS=-pedantic -Wall -O -fPIC
+CXXFLAGS=-O0 -G -qpic -qrtti=all
+CFLAGS=-O0 -qpic
+
+LDFLAGS=-brtl -bdynamic -bexpall
+SOEXT=so
+LDSO=xlc++ -G -qmkshrobj -bM:SRE $(CFLAGS)
+LD=xlc++
+LDF90=xlc++ -lm -lxlf90
+CXX=xlc++
+CC=xlc
+FC=xlf
+
+GCCDEP=g++
+
+
+
+
+

configurations/linux.gcc

+
+#CHECK_BOUNDARIES=-D_GLIBCXX_DEBUG
+
+LIBS=-ldl
+
+DYNAMIC_LIBS=-lstdc++ $(IMDLIB)
+DOUBLEPRECISION=-fdefault-real-8
+
+
+CPPFLAGS=-D__PLUMED_HAS_DLOPEN $(CHECK_BOUNDARIES) -I. $(PLUMED_INCLUDE) $(IMDDEF)
+CXXFLAGS=-pedantic -Wall -O -fPIC -ansi
+CFLAGS=-pedantic -Wall -O -fPIC -ansi
+
+LDFLAGS=-rdynamic
+SOEXT=so
+LDSO=gcc -shared $(CFLAGS)
+LD=g++
+LDF90=gfortran
+CXX=g++
+CC=gcc
+FC=gfortran
+
+GCCDEP=g++
+
+
+
+
+

configurations/linux.icc

+
+#CHECK_BOUNDARIES=-D_GLIBCXX_DEBUG
+
+LIBS=-ldl
+DYNAMIC_LIBS=-lstdc++ $(IMDLIB)
+DOUBLEPRECISION=-r8
+
+CPPFLAGS=-D__PLUMED_HAS_DLOPEN $(CHECK_BOUNDARIES) -I. $(PLUMED_INCLUDE) $(IMDDEF)
+CXXFLAGS=-O -fPIC -Wall -wd981,383,1418
+CFLAGS=-O -fPIC -Wall
+
+LDFLAGS=-rdynamic
+SOEXT=so
+LDSO=icc -shared $(CFLAGS)
+LD=icpc
+LDF90=ifort
+CXX=icpc
+CC=icc
+FC=ifort
+
+GCCDEP=g++
+
+
+
+
+

configurations/linux.mpi.gcc

+
+#CHECK_BOUNDARIES=-D_GLIBCXX_DEBUG
+
+LIBS=-ldl
+DYNAMIC_LIBS=-lstdc++ -lmpi_cxx $(IMDLIB)
+DOUBLEPRECISION=-fdefault-real-8
+
+
+CPPFLAGS=-D__PLUMED_HAS_DLOPEN -D__PLUMED_MPI $(CHECK_BOUNDARIES) -I. $(PLUMED_INCLUDE) $(IMDDEF)
+CXXFLAGS=-Wall -O -fPIC -ansi
+CFLAGS=-Wall -O -fPIC -ansi
+
+LDFLAGS=-rdynamic
+SOEXT=so
+LDSO=mpicc -shared $(CFLAGS)
+LD=mpic++
+LDF90=mpif90
+CXX=g++
+CC=mpicc
+FC=mpif90
+
+GCCDEP=g++
+
+
+
+
+

configurations/linux.mpi.icc

+
+#CHECK_BOUNDARIES=-D_GLIBCXX_DEBUG
+
+LIBS=-ldl 
+DYNAMIC_LIBS=-lstdc++ $(IMDLIB)
+DOUBLEPRECISION=-r8
+
+CPPFLAGS=-D__PLUMED_HAS_DLOPEN -D__PLUMED_MPI $(CHECK_BOUNDARIES) -I. $(PLUMED_INCLUDE) $(IMDDEF)
+CXXFLAGS=-O -fPIC -Wall -wd981,383,1418
+CFLAGS=-O -fPIC -Wall
+
+LDFLAGS=-rdynamic
+SOEXT=so
+LDSO=mpicc -shared $(CFLAGS)
+LD=mpic++
+LDF90=mpif90
+CXX=mpic++
+CC=mpicc
+FC=mpif90
+
+GCCDEP=mpic++
+
+

configurations/linux.pgi

+
+#CHECK_BOUNDARIES=-D_GLIBCXX_DEBUG
+# NOTE:
+# I did not find the proper compilation flags for dynamic binding
+# moreover, I did not have a f90 license...
+
+LIBS=-ldl -lstdc++
+DOUBLEPRECISION=-fdefault-real-8
+
+
+CPPFLAGS=-D__PLUMED_HAS_DLOPEN $(CHECK_BOUNDARIES) -I. $(PLUMED_INCLUDE)
+CXXFLAGS=-O -fPIC
+CFLAGS=-O -fPIC
+
+LDFLAGS=-Bdynamic
+SOEXT=so
+LDSO=pgcc -shared $(CFLAGS)
+LD=pgcpp
+LDF90=pgf90
+CXX=pgcpp
+CC=pgcc
+FC=pgf90
+
+GCCDEP=g++
+
+
+
+
+

configurations/mac.gcc

+
+CHECK_BOUNDARIES=-D_GLIBCXX_DEBUG
+DOUBLEPRECISION=-fdefault-real-8
+
+LIBS=-ldl
+DYNAMIC_LIBS=-L/sw/lib -lmatheval -lstdc++ $(IMDLIB)
+
+WARNINGS=-pedantic -Wall -Wextra -Wfloat-equal -Wwrite-strings -Wpointer-arith -Wcast-qual \
+         -Wcast-align -Wconversion -Wshorten-64-to-32  \
+         -Wredundant-decls -Wvariadic-macros -Werror
+
+CPPFLAGS=-D__PLUMED_HAS_DLOPEN $(CHECK_BOUNDARIES) -I. $(PLUMED_INCLUDE) \
+         -I/sw/include -I/sw/include/openmpi -D__PLUMED_HAS_MATHEVAL $(IMDDEF)
+CXXFLAGS=-O -fPIC $(WARNINGS) -Wstrict-null-sentinel -Wold-style-cast
+CFLAGS=-O -fPIC $(WARNINGS) \
+       -Wdeclaration-after-statement -Wbad-function-cast -Wstrict-prototypes \
+       -Wold-style-definition -Wmissing-prototypes -Wmissing-declarations -Wnested-externs -Wno-int-to-pointer-cast
+
+LDFLAGS=
+SOEXT=dylib
+LDSO=g++ -undefined suppress -flat_namespace -dynamiclib
+LD=g++
+LDF90=gfortran
+CXX=g++
+CC=gcc
+FC=gfortran
+
+GCCDEP=g++
+
+
+
+
+

configurations/mac.mpi.gcc

+
+CHECK_BOUNDARIES=-D_GLIBCXX_DEBUG
+DOUBLEPRECISION=-fdefault-real-8
+
+
+LIBS=-ldl
+DYNAMIC_LIBS=-L/sw/lib -lmatheval -lmpi_cxx -lmpi_f77 -lstdc++ $(IMDLIB)
+
+CPPFLAGS=-D__PLUMED_MPI -D__PLUMED_HAS_DLOPEN $(CHECK_BOUNDARIES) -I. $(PLUMED_INCLUDE) \
+         -D_REENTRANT -I/sw/include -I/sw/include/openmpi -D__PLUMED_HAS_MATHEVAL $(IMDDEF)
+CXXFLAGS=-Wall -O -fPIC
+CFLAGS=-Wall -O -fPIC
+
+LDFLAGS=
+SOEXT=dylib
+LDSO=om-mpic++ -undefined suppress -flat_namespace -dynamiclib
+LD=om-mpic++
+LDF90=om-mpif90
+CXX=om-mpic++
+CC=gcc
+FC=om-mpif90
+
+GCCDEP=g++
+
+
+
+
+

configure.sh

+#! /bin/bash
+
+
+rm -f sourceme.sh Makefile.conf
+
+prefix=""
+case "$(uname)" in
+(Linux)  prefix=linux. ;;
+(AIX)    prefix=aix. ;;
+(Darwin) prefix=mac. ;;
+esac
+
+conflist=$(cd configurations ; echo $prefix*)
+
+PS3="Choose a configuration:"
+select conf in $conflist
+do
+  [[ -n "$conf" ]] && break
+done
+
+ln -s configurations/$conf Makefile.conf
+
+
+case "$conf" in
+(aix.*)
+  SOEXT=so
+  echo "On cineca, you may need to load the following modules:"
+  echo "module load make"
+  echo "module load sed"
+;;
+(mac.*)
+  SOEXT=dylib  
+;;
+(*)
+  SOEXT=so
+esac
+
+echo 'export PATH="$PATH:'"$PWD"'/tools/"' >> sourceme.sh
+# this is just for mac:
+echo 'export DYLD_LIBRARY_PATH="$DYLD_LIBRARY_PATH:'"$PWD"'/src/"' >> sourceme.sh
+
+cat << EOF >> sourceme.sh
+export PLUMED_KERNEL="$PWD/src/libplumedKernel.$SOEXT"
+export PLUMED_ROOT="$PWD"
+EOF
+

developer-doc/.gitignore

+/html
+/latex
+/*.tmp
+

developer-doc/Doc.txt

+// This document is formatted for Doxygen
+/**
+\mainpage A Plumed Clone
+
+\author Giovanni Bussi (as of now)
+\date 2011
+\version 1.9.x
+\warning Very, very unstable
+
+As it can be guessed from the version number, this is a candidate for PLUMED2
+which should be reviewed by a reasonable number the PLUMED developers.
+If it is not accepted as a full package, it can be considered as a repository
+of a few ideas which can be stolen and used in real PLUMED2 development.
+
+If accepted, a possible road map is:
+- 1.99 public release before end of 2011, cloning most PLUMED1 features.
+  It should be usable by (and useful for) developers and people
+  in the community willing to try it.
+- 2.0 public release before mid of 2012, possibly able to superseed completely PLUMED1.
+
+\section Motivation Motivation
+
+- Simpler interface with MD codes. PLUMED should compile by itself as a library,
+  using a proper configure/make procedure, so as to avoid learning all the compilation
+  details of each MD code. Patching a new code should just consist in the insertion of
+  proper function calls and minimal modification to Makefile (to link plumed library),
+  without the need of further hacking inside PLUMED.
+- PLUMED should be easy to extend. Adding a new method/CV should be possible
+  without touching the rest.
+- Other issues:
+  - More friendly units.
+  - More flexible CVs (such as function of other CVs).
+  - Possibility to re-read input.
+
+\section FeaturesAndChanges Features and changes
+
+- Re-designed from scratch, hopefully better.
+- Input is conceptually similar but NON compatible. It is difficult to automatically
+  convert old input files, but we could provide a short transition guide.
+  The new plumed.dat is a sort of script containing a list of actions to be performed at each step.
+  Notable differences in input:
+  - An Action is composed of a line (possibly with continuations) of
+    space-separated words, and corresponds more-or-less to a directive in PLUMED1.
+\verbatim
+DISTANCE ATOMS=0,300 LABEL=dist NOPBC
+\endverbatim
+    The first word (DISTANCE here) defines the directive type, all other words are arguments
+    Most arguments are named, and has the form "NAME=VALUE" (ATOMS and LABEL in the example).
+    Others are flags (NOPBC in the example).
+  - Continuation can be done with "..." syntax (notice the space between DISTANCE and dots):
+\verbatim
+DISTANCE ...
+  ATOMS=0,300
+  LABEL=dist
+  NOPBC
+... DISTANCE
+\endverbatim
+  - All directives can be labeled (LABEL=dist in the example)
+  - A bias can only act on a labeled colvar:
+\verbatim
+DISTANCE ATOMS=0,300 LABEL=dist
+# This is a harmonic restraint
+RESTRAINT ARG=dist KAPPA=1.0 AT=1.0
+\endverbatim
+  - Some colvars have extra named values, which can be accessed with "." syntax
+\verbatim
+DISTANCE ATOMS=1,10 LABEL=dist COMPONENTS
+RESTRAINT ARG=dist.x KAPPA=1.0 AT=1.0
+\endverbatim
+    Here COMPONENTS is telling to DISTANCE to also compute the three components.
+    This is expected to be useful for variables which have multiple components
+    but that are heavy and we would like to compute only once (e.g. components
+    of the inertia tensor of a large molecule).
+    Also methods can have extra named values, such as the energy for a restraint.
+  - to print a COLVAR-like file (name can be changed), use PRINT directive
+\verbatim
+PRINT ARG=d1,d1.x,d1.y,d1.z STRIDE=100 FILE=COLVAR
+# or
+PRINT ARG=d1.* STRIDE=100 FILE=COLVAR1
+# or, to print all the variables defined in the plumed.dat up to this point
+PRINT ARG=* STRIDE=100 FILE=COLVAR_ALL
+\endverbatim
+- The library has been written in C++ for a more flexible structure:
+  - Extensive use of STL containers for things such as lists/vectors/maps/...
+  - Polymorphism for collective variables/free energy methods
+  However, for compatibility, its main interface is in plain C (with FORTRAN
+  and C++ wrappers). All the C++ definitions are hidden in a PLMD namespace.
+- Hierarchy of classes describing each possible Action performed by PLUMED.
+  There is a class for each CV (e.g. PLMD::ColvarDistance, PLMD::ColvarEnergy,
+  PLMD::ColvarVolume), a class for each bias (e.g. PLMD::BiasRestraint, PLMD::BiasMovingRestraint),
+  and a class for each function (e.g. PLMD::FunctionCombine).
+  There are also auxiliary classes to write the output (PLMD::Print),
+  to set the units (PLMD::Units), to print dedug information (PLMD::Debug),
+  to flush the open files (PLMD::Flush), etc.
+  More or less, there should be a class for each possible directive of "plumed.dat".
+  To see the full hierarchy, look at PLMD::Action.
+- It should be possible to program Actions independently from each other. To this
+  aim, there is a register (PLMD::ActionRegister, contained in the function
+  PLMD::actionRegister()) where, during C++ initialization, each
+  Action registers itself. Thus, if a new CV or bias is added, there is no need
+  for recompilation. If dlopen() is available on a system, it should be possible
+  to load Actions runtime (using LOAD directive).
+  In the long run we can imagine libraries of CVs
+  suitable for different problems and, possibly, released independently from
+  the kernel. On a mainframe, one could add CVs without recompiling neither plumed
+  nor the MD engine.
+- There is an option to load the plumed kernel at runtime. If you patch with
+  --runtime, the plumed kernel is looked for at the path in variable PLUMED_KERNEL.
+  If the variable is not set, basic (un-plumed) version of MD is used.
+  On a mainframe, one can have multiple installed plumed versions.
+- Ideally, inside the kernel there is nothing related to specific CVs or FE-methods. Thus, CVs and 
+  methods are optional plugins for PLUMED. The only exception
+  are tools which are common to several CVs/methods, such as grid interpolators, etc.
+- Ideally, inside the kernel there is nothing related to specific MD code. The interface is kept
+  as standard as possibly. Anyway, all the details of the interaction PLUMED/MD are inside the
+  src/Atoms.cpp file.  E.g., there are two (templated) versionsi of class PLMD::MDAtoms,
+  one for double precision and the other
+  for single precision MD. Code specific tools could be added here. In the future, we may try to
+  design a plugin approach also for MD engines (similarly to CVs/methods).
+- To simplify interface, there is a single routine plumed_cmd which takes a string and a pointer.
+  It can be used to pass any information to plumed, such as:
+\verbatim
+plumed p=plumed_create();
+plumed_cmd(p,"setNatoms",&natoms);
+plumed_cmd(p,"setMDEngine","gromacs");
+plumed_cmd(p,"init",NULL);
+...
+plumed_cmd(plumedmain,"setPositions",pos);
+plumed_cmd(plumedmain,"setBox",box);
+plumed_cmd(plumedmain,"setEnergy",&energy);
+plumed_cmd(plumedmain,"setForces",forces);
+plumed_cmd(plumedmain,"setVirial",virial);
+plumed_cmd(plumedmain,"calc",NULL);
+...
+plumed_finalize(p);
+\endverbatim
+  Fortran/C++ interfaces are similar (see src/Plumed.c for details), and are based on the C interface
+  (wrappers).
+- Units: PLUMED reads and writes only in its internal units, which, by default, are
+  nm and kj/mol. In plumed.dat it is possible to change it to other choices:
+\verbatim
+UNITS ...
+  LENGTH=A
+  TIME=fs
+  ENERGY=kcal/mol
+... UNITS
+\endverbatim
+  The MD code should specify to plumed its internal units, so as to allow proper conversion.
+  E.g., a code using angstrom and kcal should do the following calls
+\verbatim
+double energyUnits=4.184;
+double lengthUnits=0.1;
+plumed_cmd(plumedmain,"setMDEnergyUnits",&energyUnits);
+plumed_cmd(plumedmain,"setMDLengthUnits",&lengthUnits);
+\endverbatim
+- Other cool features:
+  - Functions of colvars (or functions of functions) can be used. For example, defining:
+\verbatim
+COMBINE LABEL=sum2     ARG=dist.x,dist.y,dist.z POWERS=2,2,2
+COMBINE LABEL=sqrtsum2 ARG=sum2                 POWERS=0.5
+# The following two restraints are equivalent:
+RESTRAINT ARG=dist     AT=1.2 KAPPA=1.0
+RESTRAINT ARG=sqrtsum2 AT=1.2 KAPPA=1.0
+\endverbatim
+  - Multiple-time-step: biases can be applied with multiple-time-step using a stride. This should
+    help for variables which are heavy to compute but smooth
+\verbatim
+RESTRAINT ARG=dist AT=1.2 KAPPA=1.0 STRIDE=2
+\endverbatim
+  - It is possible to include other files:
+\verbatim
+INCLUDE anotherplumed.dat
+\endverbatim
+  - It is possible to load shared libraries implementing new CVs and methods:
+\verbatim
+LOAD share-object.so
+\endverbatim
+
+
+\section SharingPolicy Sharing Policy
+- I think that Plumed should become fully open, with a public-access shared repository.
+  I would like to switch from cvs to git, which allows for easier branch manipulation.
+  On the central repository, we should have a public master branch where we can
+  publish our work, but for which we do not provide support (developer version).
+  From time to time, as usual, we can provide a supported release (2.0, 2.1 ,...)
+- If it is necessary to work privately, it can be done on a local branch
+  (maybe shared among a few collaborators). Git easily allows to merge multiple times, so it should
+  be relatively easy to stay up do date with the master branch. Finally, when the work
+  is ready, we can merge it into the master branch.
+  This sort of private working should be discouraged for the development of PLUMED kernel.
+  However, it would be perfect to implement new CVs or new methods, since they are
+  completely decoupled from the rest.
+
+\section ToDo To Do
+
+\todo Pbc on COLVARs (possibly with some smart trick for functions-of-functions).
+\todo Optimize atoms sharing. "Calc" should be divided in more steps:
+* Finding list of atoms needed and requesting them (on NAMD, this goes at the
+end of the previous step).
+* Sending the atoms
+* Receiving the atoms and computing everything
+* Sending the forces back
+Moreover, it would be nice to allow PLUMED to be run only on a subset of
+the available processors.
+\todo Replica exchange.
+\todo Interfaces with other codes
+\todo Implementation of CVs
+\todo Implementation of free energy methods
+
+\section Install Install
+
+- Configure and compile your MD code
+- Configure and compile PLUMED, possibly using the same compiler:
+\verbatim
+$ ./configure.sh
+... choose your compiler interactively here ...
+... it may be necessary to edit the Makefile.conf file ...
+$ make -j 4
+\endverbatim
+- Source the ./sourceme.sh file
+\verbatim
+$ source sourceme.sh
+\endverbatim
+  \attention This should be done on every shell where you want to patch/run plumed
+- Go to your MD code directory and do the patch
+\verbatim
+$ plumed patch --patch
+\endverbatim
+  (use -h to get information about other options).  Also experiment other linking modes (e.g. --runtime)
+- Recompile your MD code (without necessarily cleaning it)
+
+\section Content Content
+
+src/
+Plumed library source code (C++) plus a two wrapper files (Plumed.c and PlumedStatic.cpp; the latter is just
+equivalent to the former but is compiled as cpp, for testing, and does not allow runtime binding).
+Sources are compiled into a libplumed.so library and a libplumedKernel.so library
+(replace .so with .dylib on Mac).
+The src/Plumed.inc file contains shortcuts for the compilation. Just include it in your makefile and:
+- link the src/Plumed.h file in an included directory
+- add to the linker command the $(PLUMED_LDFLAG) options, to have the proper link flags
+- add to the linker command the $(PLUMED_LIBS) variable, to link the proper external libraries
+- add to the linker command one of the following variables:
+  - (A) \$(PLUMED_OBJ) : plumed will be statically bound
+  - (B) \$(PLUMED_SHARED_OBJ) : plumed will be dynamically bound
+  - (C) \$(PLUMED_WRAPPER) : behavior depend on runtime value of the PLUMED_KERNEL environment variable.
+    If set to the full path of the libplumedKernel.so library, plumed will be available.
+    If unset, or if set to a wrong file, plumed will not be available.
+- The difference between (A) and (B) is that in case (B) if you recompile plumed and rerun MD your code
+  is automatically up to date.
+  The difference between (B) and (C) is that in case (C) the MD code is able to run also if plumed is
+  not available. This allows to have a single compiled MD code for both plumed users and others.
+  Moreover, in case (C) it is trivial to change plumed version at execution time, by properly setting
+  the PLUMED_KERNEL environment variable.
+  Notice that in (B) case the full path of the plumed library is recorded, thus it should not
+  be changed after patching, and it should be reachable from computing nodes.
+  All these task can be done automatically with "plumed patch" using respectively the flags:
+  - (A) --static
+  - (B) --shared
+  - (C) --runtime
+   
+extensions/ 
+   Plumed extensions (e.g. contributed collective variables, ...)
+   They are compiled into a libplumedExtensions.so file which can be loaded at runtime.
+   To load them, use LOAD command inside plumed.dat
+
+test/link/
+   A few simple executables to test compilation/linking
+   Executables are:
+-  (A) XXX-static statically linked with src/*.o (except src/Plumed.o)
+-  (B) XXX        dynamically linked with libplumed.so
+-  (C) XXX-dummy  statically linked with src/Plumed.o
+
+user-doc/
+   User documentation
+
+developer-doc/
+   Developer documentation
+
+\section Notes Notes
+
+Information about C++
+http://www.parashift.com/c++-faq-lite/
+
+Compiler options to use shared libraries on many architectures:
+http://www.fortran-2000.com/ArnaudRecipes/sharedlib.html
+
+\page HowToAddACollectiveVariable How to add a collective variable
+
+\page HowToAddAFunction How to add a function
+
+\page HowToAddABias How to add a biasing potential
+
+
+*/

developer-doc/Makefile

+
+.PHONY: all clean
+
+all:
+	doxygen
+
+clean:
+	rm -fr html latex *~

extensions/DoNothing.cpp

+#include "../src/ActionRegister.h"
+#include "../src/ActionSetup.h"
+
+using namespace std;
+
+namespace PLMD{
+
+/// Action which does nothing
+///
+/// It is here to test linking of external libraries
+class DoNothing:
+  public ActionSetup
+{
+public:
+  DoNothing(const ActionOptions&ao);
+};
+
+PLUMED_REGISTER_ACTION(DoNothing,"DONOTHING")
+
+DoNothing::DoNothing(const ActionOptions&ao):
+Action(ao),
+ActionSetup(ao)
+{
+}
+
+}
+

extensions/Makefile

+
+-include ../Makefile.conf
+
+SRC=$(wildcard *.cpp)
+
+OBJ=$(SRC:.cpp=.o)
+SOBJ=$(SRC:.cpp=.$(SOEXT))
+
+.PHONY: all clean
+
+ifdef GCCDEP
+all: libplumedExtensions.$(SOEXT) $(SOBJ)
+else
+all:
+	@echo No configuration available
+	@echo First run ./configure.sh in the root directory
+endif
+
+
+libplumedExtensions.$(SOEXT): $(OBJ)
+	$(LDSO) -o $@ $^
+
+clean:
+	rm -f makefile.dep
+	rm -f *.o
+ifdef SOEXT
+	rm -f *.$(SOEXT)
+endif
+
+makefile.dep : $(SRC) *.h
+ifdef GCCDEP
+	for i in $(ALL_SRC) ; do $(GCCDEP) $(CPPFLAGS) -MM "$${i}"; done > $@
+endif
+
+%.$(SOEXT) : %.o
+	$(LDSO) -o $@ $^
+
+-include makefile.dep
+

imd/.gitignore

+/*.c
+/*.h
+/Makefile.conf
+/imdapi*