*Creation des interacteurs, une maniere de gerer les interactions entre particules orientee evenement.

*Completion de commentaires de tous les fichiers de main
*Reponses aux questions

19 files changed, 324 insertions, 59 deletions

diff --git a/reponses.lyx b/reponses.lyx
index dffa544..92ae2c6 100644
--- a/reponses.lyx
+++ b/reponses.lyx
@@ -642,24 +642,64 @@ Question P10.2
 \end_layout
 
 \begin_layout Standard
-Dans le cadre de la programmation oritentée-objets, il s'agit, pour ne faire
- qu'une seule fois appel à la méthode
-\family typewriter
-\size small
- Printable
-\family default
-\size default
-, de la redéfinir.
+Dans le cadre de la programmation oritentée-objets, on créerait une classe
+ abstraite (p.ex.
+ 
+\begin_inset Quotes eld
+\end_inset
+
+Dessinable
+\begin_inset Quotes erd
+\end_inset
+
+) contenant la methode dessine() virtuelle pure.
+ Tout objet dessinable hériterait ensuite de cette classe et implémenterait
+ la méthode.
 \end_layout
 
 \begin_layout Section*
 Question P10.3
 \end_layout
 
+\begin_layout Standard
+La reponse à la dernière question n'implique pas de changement de notre
+ code car, depuis le début du projet, nous avons défini la classe 
+\begin_inset Quotes eld
+\end_inset
+
+Printable
+\begin_inset Quotes erd
+\end_inset
+
+ (
+\begin_inset Quotes eld
+\end_inset
+
+Dessinable
+\begin_inset Quotes erd
+\end_inset
+
+ ci-dessus) et tout nos objets dessinables (notamment l'accelerateur, les
+ particules et les elements) heritent de cette dernière et implémentent
+ la méthode virtuelle pure 
+\begin_inset Quotes eld
+\end_inset
+
+print()
+\begin_inset Quotes erd
+\end_inset
+
+ qui affiche l'objet.
+\end_layout
+
 \begin_layout Section*
 Question P10.4
 \end_layout
 
+\begin_layout Standard
+Voir réponse à question P10.3.
+\end_layout
+
 \begin_layout Section*
 Question P12.1
 \end_layout
diff --git a/src/gui/Main.cc b/src/gui/Main.cc
index 4c2d62f..b3964d1 100644
--- a/src/gui/Main.cc
+++ b/src/gui/Main.cc
@@ -164,10 +164,10 @@ Une particule :
 	double A_22 = 4;//E-19; // s² m-1 (dépend totalement de l'accélérateur)
 	double length = 300E-12 * constants::C;
 	double stdDev = 0.1;
-	acc->add(Bunch(p1, 500, 1, stdDev, length, emittance, A_12, A_22));
+	acc->add(Bunch(p1, 5, 1, stdDev, length, emittance, A_12, A_22));
 
 	Foo* foo = new Foo;
-	Bunch& bch = (Bunch&) acc->add(Bunch(ap1, 500, 1, stdDev, length, emittance, A_12, A_22));
+	Bunch& bch = (Bunch&) acc->add(Bunch(ap1, 5, 1, stdDev, length, emittance, A_12, A_22));
 	bch.Publisher<ParticleAddedEvent>::subscribe(foo);
 	bch.Publisher<ParticleRemovedEvent>::subscribe(foo);
 
diff --git a/src/main/Accelerator.cc b/src/main/Accelerator.cc
index 40b9ff7..165d607 100644
--- a/src/main/Accelerator.cc
+++ b/src/main/Accelerator.cc
@@ -9,6 +9,7 @@
 #include "Accelerator.h"
 #include "exceptions.h"
 #include "SingleBeam.h"
+#include "BruteForceInteractor.h"
 
 using namespace std;
 
@@ -18,8 +19,11 @@ Accelerator::Accelerator():
 		elements(0),
 		beams(0),
 		allowLinear(false),
-		closed(false)
-	{};
+		closed(false),
+		interactor(NULL)
+	{
+	interactor = new BruteForceInteractor;
+	};
 
 Accelerator::~Accelerator() {
 	clear();
@@ -83,6 +87,8 @@ Element& Accelerator::add(const Element& element) {
 Beam& Accelerator::add(const Beam& beam) {
 	Beam* b = beam.clone();
 	beams.push_back(b);
+	b->Publisher<ParticleAddedEvent>::subscribe(interactor);
+	b->Publisher<ParticleRemovedEvent>::subscribe(interactor);
 	closed = false;
 	return *b;
 }
@@ -154,6 +160,8 @@ void Accelerator::clear() {
 void Accelerator::step(double dt) {
 	if (!closed) close();
 
+	interactor->applyInteractions();
+
 	for (BeamCollection::iterator i = beams.begin(); i != beams.end(); ++i) {
 		(**i).step(dt);
 	}
@@ -196,4 +204,5 @@ std::string Accelerator::toString() const {
 	return s.str();
 }
 
+
 } //vhc
diff --git a/src/main/Accelerator.h b/src/main/Accelerator.h
index 9f990af..32889ff 100644
--- a/src/main/Accelerator.h
+++ b/src/main/Accelerator.h
@@ -12,6 +12,7 @@
 #include "Particle.h"
 #include "Beam.h"
 #include "Element.h"
+#include "Interactor.h"
 
 namespace vhc {
 
@@ -37,8 +38,12 @@ public:
 	 *  L'accelerateur est ouvert en ajoutant un element. */
 	Element& add(const Element& element);
 
+	/** Copie un faisceau dans cet accelerateur. */
 	Beam& add(const Beam& beam);
 
+	/** Copie une particule dans cet accelerateur.
+	 *  Comme un accelerateur ne contient plus explicitement des particules, un faisceau a une particule et cree.
+	 *  Cet methode reste pour des raisons de compatibilites. */
 	Beam& add(const Particle& particle);
 
 	/** Retourne la liste d'elements contenus dans cet accelerateur.
@@ -49,6 +54,7 @@ public:
 	 *  <b>ATTENTION:</b> les particules peuvent etre supprimes sans preavis par l'accelerateur! */
 	const ParticleCollection & getParticles() const;
 
+	/** Retourne tous les faisceaux de cet accelerateur. */
 	const BeamCollection& getBeams() const;
 
 	/** Ferme l'accelerateur.
@@ -85,8 +91,13 @@ protected:
 	/** Collection d'elements contenus dans cet accelerateur. */
 	ElementCollection elements;
 
+	/** Collection de faisceaux contenus dans cet accelerateur. */
 	BeamCollection beams;
 
+	/** Interacteur de particules.
+	 *  @see vhc::Interactor */
+	Interactor* interactor;
+
 	/** Autorise les accelerateurs lineaires.
 	 *  @see enableLinear */
 	bool allowLinear;
diff --git a/src/main/Beam.h b/src/main/Beam.h
index f5998c9..1e71b15 100644
--- a/src/main/Beam.h
+++ b/src/main/Beam.h
@@ -22,7 +22,7 @@ public:
 
 	typedef std::list<Particle*> ParticleCollection;
 
-	/** Cree un nouveau faisceaux.
+	/** Cree un nouveau faisceau.
 	 *  @param refererenceParticle particule de reference (son element ne joue pas de role)
 	 *  @param quantity la quantite de particules a generer
 	 *  @param lambda le facteur de macroparticules (il y aura lambda fois moins de particules dans le faisceau mais a charges et masses lambdas fois plus grands)
@@ -32,7 +32,7 @@ public:
 
 	virtual ~Beam();
 
-
+	/** Retourne tous les particules contenus dans ce faisceau. */
 	ParticleCollection& getParticles();
 
 	/** Met a jour les particules en leur attribuant l'element dans lequel ils sont contenus.
@@ -78,9 +78,6 @@ public:
 
 	virtual Beam* clone() const = 0;
 
-
-
-
 	//-------------------------------------------------------------------
 
 	/** Retourne coefficient des ellipses de phases vertical. */
@@ -115,13 +112,16 @@ protected:
 	/** Quantite de particules contenus dans ce faisceau. */
 	int quantity;
 
-	/** Methode qui doit etre appelee par toute sous-classe pour ajouter une particule au faisceau. */
+	/** Methode qui doit etre appelee par toute sous-classe pour ajouter une particule au faisceau.
+	 *  Publie un <code>ParticleAddedEvent</code>. */
 	void add(Particle* particle);
 
-	/** Methode qui doit etre appelee par toute sous-classe pour supprimer une particule du faisceau. */
+	/** Methode qui doit etre appelee par toute sous-classe pour supprimer une particule du faisceau.
+	 *  Publie un <code>ParticleRemovedEvent</code>. */
 	void remove(Particle* particle);
 
-	/** Methode qui doit etre appelee par toute sous-classe pour supprimer une particule du faisceau. */
+	/** Methode qui doit etre appelee par toute sous-classe pour supprimer une particule du faisceau.
+	 *  Publie un <code>ParticleRemovedEvent</code>. */
 	ParticleCollection::iterator erase(ParticleCollection::iterator i);
 
 	/** Retourne la moyenne de la distribution horizontale de la position des particules.
@@ -148,8 +148,6 @@ protected:
 	 *  (<r*v>^2 vertical du complement) */
 	double getVRV2() const;
 
-
-
 };
 
 }
diff --git a/src/main/BruteForceInteractor.cc b/src/main/BruteForceInteractor.cc
new file mode 100644
index 0000000..7ad8374
--- /dev/null
+++ b/src/main/BruteForceInteractor.cc
@@ -0,0 +1,42 @@
+/*
+ * BruteForceInteractor.cc
+ *
+ *  Created on: May 26, 2011
+ *      Author: jakob
+ */
+
+#include <iostream>
+#include "BruteForceInteractor.h"
+
+using namespace std;
+
+namespace vhc {
+
+BruteForceInteractor::BruteForceInteractor(): particles(0) {}
+
+BruteForceInteractor::~BruteForceInteractor() {}
+
+void BruteForceInteractor::applyInteractions() {
+	for (list< Particle* >::iterator i = particles.begin(); i != particles.end(); ++i) {
+		for (list< Particle* >::iterator j = particles.begin(); j != particles.end(); ++j) if (i != j) {
+			double r = ((**j).getPosition() - (**i).getPosition()).norm();
+			if (r != 0) {
+				Vector3D d = ((**j).getPosition() - (**i).getPosition()).unit();
+				Vector3D force = d * (**i).getCharge() * (**i).getCharge() /
+								(4 * M_PI * constants::EPSILON_ZERO * r * r * r * (**i).getGamma() * (**i).getGamma());
+				(**i).applyForce(force);
+				(**j).applyForce(-force);
+			}
+		}
+	}
+}
+void BruteForceInteractor::acceleratorClosed() {}
+
+void BruteForceInteractor::react(const ParticleAddedEvent& event) {
+	particles.push_back(event.getParticle());
+}
+void BruteForceInteractor::react(const ParticleRemovedEvent& event) {
+	particles.remove(event.getParticle());
+}
+
+}
diff --git a/src/main/BruteForceInteractor.h b/src/main/BruteForceInteractor.h
new file mode 100644
index 0000000..ba1688a
--- /dev/null
+++ b/src/main/BruteForceInteractor.h
@@ -0,0 +1,42 @@
+/*
+ * BruteForceInteractor.h
+ *
+ *  Created on: May 26, 2011
+ *      Author: jakob
+ */
+
+#ifndef BRUTEFORCEINTERACTOR_H_
+#define BRUTEFORCEINTERACTOR_H_
+
+#include <list>
+#include "Interactor.h"
+#include "Particle.h"
+
+namespace vhc {
+
+/** Represente un interacteur de particules a force brute.
+ *  Cet interacteur considere les interactions entre tous les particules. Il n'est donc pas tres efficace (compexite O(n^2)). */
+class BruteForceInteractor: public Interactor {
+
+private:
+
+	/** Particules simules par cet interacteur. */
+	std::list<Particle*> particles;
+
+public:
+	BruteForceInteractor();
+	virtual ~BruteForceInteractor();
+
+	virtual void applyInteractions();
+	virtual void acceleratorClosed();
+
+	/** Appelee lors de l'ajout d'une particule. Ajoute la particule au particules simules par cet interacteur. */
+	virtual void react(const ParticleAddedEvent& event);
+
+	/** Appelee lors de l'enlevement d'une particule. Enleve la particule des particules simules par cet interacteur. */
+	virtual void react(const ParticleRemovedEvent& event);
+};
+
+}
+
+#endif /* BRUTEFORCEINTERACTOR_H_ */
diff --git a/src/main/Bunch.cc b/src/main/Bunch.cc
index 4a4844b..9f8bb38 100644
--- a/src/main/Bunch.cc
+++ b/src/main/Bunch.cc
@@ -26,7 +26,7 @@ Bunch::~Bunch() {
 }
 
 void Bunch::initializeParticles() {
-	create(getLength());
+	create(getLength() * referenceParticle.getVelocity().norm());
 }
 
 void Bunch::create(double dt) {
diff --git a/src/main/Element.h b/src/main/Element.h
index a3c26ff..99a4e88 100644
--- a/src/main/Element.h
+++ b/src/main/Element.h
@@ -21,12 +21,6 @@ namespace vhc {
 /** Classe abstraite representant un element d'un accelerateur. */
 class Element: public Printable, public Cloneable {
 
-private:
-
-	/** Empêche la copie d'éléments par le constructeur de copie.
-	 *  Si on veut explicitement copier un element utiliser <code>clone()</code>.*/
-	//Element(const Element& e);
-
 protected:
 
 	/** Position du centre de la face d'entrée. */
@@ -46,6 +40,8 @@ protected:
 	 *  NULL si aucun element n'existe. */
 	Element *next;
 
+
+
 public:
 
 	/** Constructeur d'elements.
@@ -101,6 +97,7 @@ public:
 	/** Retourne le rayon de la section de cet element. */
 	double getSectionRadius() const;
 
+	/** Retourne la longueur de cet element. */
 	virtual double getLength() const = 0;
 
 	/** Assigne le rayon de la section de cet element. */
@@ -118,7 +115,7 @@ public:
 	/** Assigne un pointeur sur l'element suivant. */
 	void setNext(Element* n);
 
-	/** Retourne vrai si cet element est connecte a un element suivant, faux sinon. */
+	/** Retourne vrai si cet element est connecte a un element precedent et suivant, faux sinon. */
 	bool isConnected() const;
 
 	/** Retourne une representation en chaine du type de cet element, i.e. du nom de la classe.
diff --git a/src/main/InteractionDetector.h b/src/main/InteractionDetector.h
deleted file mode 100644
index f165a46..0000000
--- a/src/main/InteractionDetector.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * InteractionDetector.h
- *
- *  Created on: May 24, 2011
- *      Author: jakob
- */
-
-#ifndef INTERACTIONDETECTOR_H_
-#define INTERACTIONDETECTOR_H_
-
-namespace vhc {
-
-class InteractionDetector {
-public:
-	InteractionDetector();
-	virtual ~InteractionDetector();
-};
-
-}
-
-#endif /* INTERACTIONDETECTOR_H_ */
diff --git a/src/main/Interactor.cc b/src/main/Interactor.cc
new file mode 100644
index 0000000..9808b69
--- /dev/null
+++ b/src/main/Interactor.cc
@@ -0,0 +1,16 @@
+/*
+ * Interactor.cc
+ *
+ *  Created on: May 26, 2011
+ *      Author: jakob
+ */
+
+#include "Interactor.h"
+
+namespace vhc {
+
+Interactor::Interactor() {}
+
+Interactor::~Interactor() {}
+
+}
diff --git a/src/main/Interactor.h b/src/main/Interactor.h
new file mode 100644
index 0000000..59170c9
--- /dev/null
+++ b/src/main/Interactor.h
@@ -0,0 +1,42 @@
+/*
+ * Interactor.h
+ *
+ *  Created on: May 26, 2011
+ *      Author: jakob
+ */
+
+#ifndef INTERACTOR_H_
+#define INTERACTOR_H_
+
+#include "events.h"
+
+namespace vhc {
+
+/** Classe de base representant un moyen d'inclure les forces inter-particules dans la simulation.
+ *  D'abord on souscrit un interacteur a une source d'evenements de paticules (typiquement des faisceaux).
+ *  Lors de l'ajout d'une particule, l'interacteur a donc la possibilite d'inclure la particule dans
+ *  la simulation de forces inter-particules.
+ *  Quand la methode <code>applyInteractions()</code> est appelee, les forces inter-particules de tous
+ *  les particules de cet interacteur sont appliques. */
+class Interactor: public Listener< ParticleAddedEvent >, public Listener< ParticleRemovedEvent > {
+
+public:
+	Interactor();
+	virtual ~Interactor();
+
+	/** Simule tous les interactions entre particules. */
+	virtual void applyInteractions() = 0;
+
+	/** Appelee quand l'accelerateur contenant cet interacteur est ferme. */
+	virtual void acceleratorClosed() = 0;
+
+	/** Appelee lors de l'ajout d'une particule. Ajoute typiquement la particule au particules simules par cet interacteur. */
+	virtual void react(const ParticleAddedEvent& event) = 0;
+
+	/** Appelee lors de l'enlevement d'une particule. Enleve typiquement la particule des particules simules par cet interacteur. */
+	virtual void react(const ParticleRemovedEvent& event) = 0;
+};
+
+}
+
+#endif /* INTERACTOR_H_ */
diff --git a/src/main/Makefile b/src/main/Makefile
index b9a0e5d..28a663d 100644
--- a/src/main/Makefile
+++ b/src/main/Makefile
@@ -16,7 +16,7 @@ LOCALDIR = main
 LOCALOBJS = Vector3D.o Particle.o Printable.o Element.o CurvedElement.o StraightElement.o \
 			CompositeElement.o Dipole.o Quadrupole.o FODO.o ElementVisitor.o Cloneable.o \
 			Accelerator.o exceptions.o Stepper.o Beam.o SingleBeam.o CircularBeam.o \
-			random.o Bunch.o events.o
+			random.o Bunch.o events.o Interactor.o BruteForceInteractor.o
 
 OBJS=$(addprefix $(BINDIR)/$(LOCALDIR)/,$(LOCALOBJS))
 .PHONY = all checkdirs lib
diff --git a/src/main/Particle.h b/src/main/Particle.h
index 43e059d..1228740 100644
--- a/src/main/Particle.h
+++ b/src/main/Particle.h
@@ -20,7 +20,7 @@ namespace vhc {
 class Element; //forward declaration
 
 /** Classe représentant une particule
- * TODO poser question sur l'energie, gamma, qdm*/
+ *  TODO ajouter constructeur qdm*/
 class Particle: public Printable, public Cloneable {
 
 private:
@@ -62,7 +62,6 @@ public:
 	 *  @param direction direction de mouvement de la particule (la longueur du vecteur n'a aucune importance) */
 	Particle(const Vector3D& position, double mass, double charge, double energy, const Vector3D& direction);
 
-
 	/** Retourne la position de cette particule. [m] */
 	Vector3D getPosition() const;
 
@@ -114,7 +113,10 @@ public:
 
 	virtual Particle* clone() const;
 
+	/** Retourne l'element dans lequel cette particule est contenue. */
 	Element* getElement() const;
+
+	/** Affecte l'element dans lequel cette particule est contenue. */
 	void setElement(Element* element);
 
 };
diff --git a/src/main/InteractionDetector.cc b/src/main/SAP.cc
index 667c14f..820ad47 100644
--- a/src/main/InteractionDetector.cc
+++ b/src/main/SAP.cc
@@ -1,20 +1,20 @@
 /*
- * InteractionDetector.cc
+ * SAP.cc
  *
  *  Created on: May 24, 2011
  *      Author: jakob
  */
 
-#include "InteractionDetector.h"
+#include "SAP.h"
 
 namespace vhc {
 
-InteractionDetector::InteractionDetector() {
+SAP::SAP() {
 	// TODO Auto-generated constructor stub
 
 }
 
-InteractionDetector::~InteractionDetector() {
+SAP::~SAP() {
 	// TODO Auto-generated destructor stub
 }
 
diff --git a/src/main/SAP.h b/src/main/SAP.h
new file mode 100644
index 0000000..8b0c1aa
--- /dev/null
+++ b/src/main/SAP.h
@@ -0,0 +1,41 @@
+/*
+ * SAP.h
+ *
+ *  Created on: May 24, 2011
+ *      Author: jakob
+ */
+
+#ifndef SAP_H_
+#define SAP_H_
+
+#include <vector>
+#include "InteractionDetector.h"
+#include "Particle.h"
+#include "Element.h"
+
+namespace vhc {
+
+class SAP {
+
+private:
+	vector<Particle*> particles;
+	element->localpos
+	particle->localpos
+
+public:
+
+	//static const double THRESHOLD_RADIUS;
+
+	SAP();
+	virtual ~SAP();
+
+	virtual void applyInteractions();
+	virtual void acceleratorClosed();
+
+	virtual void react(const ParticleAddedEvent& event) = 0;
+	virtual void react(const ParticleRemovedEvent& event) = 0;
+};
+
+}
+
+#endif /* SAP_H_ */
diff --git a/src/main/constants.h b/src/main/constants.h
index 8e0331d..e02351e 100644
--- a/src/main/constants.h
+++ b/src/main/constants.h
@@ -28,8 +28,12 @@ const double PROTON_MASS = 1.672623E-27;
 /** Masse d'un électron [kg]. */
 const double ELECTRON_MASS = 9.109383E-31;
 
+/** Conversion de GeV en SI */
 const double GeV = 1E9 * E;
 
+/** Permitivite du vide. */
+const double EPSILON_ZERO = 8.85E-12;
+
 }
 
 }
diff --git a/src/main/events.h b/src/main/events.h
index f9a6be3..14b170e 100644
--- a/src/main/events.h
+++ b/src/main/events.h
@@ -9,63 +9,95 @@
 #define EVENTS_H_
 
 #include <list>
-#include <algorithm>
 #include "Particle.h"
 
 namespace vhc {
 
+/** Classe de base de tout evenement. */
 class Event {
 
 private:
+
+	/** Pointeur sur le createur de cet evenement. */
 	void *const sender;
 
 public:
+
 	Event(void *const sender);
 	virtual ~Event();
 
+	/** Retourne le createur de cet evenement. */
 	void *const getSender() const;
 
 };
 
+/** Classe de base de tout evenement de particules. */
 class ParticleEvent: public Event {
 private:
+
+	/** Pointeur sur la particule de cet evenement. */
 	Particle *const particle;
+
 public:
 
 	ParticleEvent(void *const sender, Particle *const particle);
 	virtual ~ParticleEvent();
 
+	/** Retourne la particule consideree lors de cet evenement. */
 	Particle *const getParticle() const;
 
 };
 
+/** Evenemnt representant l'ajout d'une particule. */
 class ParticleAddedEvent: public ParticleEvent {
+
 public:
+
+	/** Cree un nouveau evenement d'ajout de particule.
+	 *  @param sender origine de cet evenement
+	 *  @param particle particule ajoutee */
 	ParticleAddedEvent(void *const sender, Particle *const particle);
+
 	virtual ~ParticleAddedEvent();
 };
 
+/** Evenemnt representant l'enlevement d'une particule. */
 class ParticleRemovedEvent: public ParticleEvent {
 public:
+
+	/** Cree un nouveau evenement d'enlevement de particule.
+	 *  @param sender origine de cet evenement
+	 *  @param particle particule enlevee */
 	ParticleRemovedEvent(void *const sender, Particle *const particle);
 	virtual ~ParticleRemovedEvent();
 };
 
 template<typename T>
+/** Represente un ecouteur d'evenements. Tout ecouteur peur se souscrire a un publicateur d'evenements pour ainsi etre
+ *  informee de tout evenement.
+ *  @see vhc::Publisher */
 class Listener {
 
 public:
 
+	/** Methode appelee par un publicateur lors d'un evenement. Cette methode
+	 *  represente la reaction de l'ecouteur lors d'un evenement et est a
+	 *  implementer par tout ecouteur concret. */
 	virtual void react(const T& event) = 0;
 
 };
 
 template<typename T>
+/** Represente un publicateur d'evenements. Un publicateur peut publier un evenement a tous ses ecouteurs souscrits.
+ *  @see vhc::Listener */
 class Publisher {
 
 private:
 
+	/** Type de collection des ecouteurs. */
 	typedef std::list< Listener<T> * > ListenerCollection;
+
+	/** Ecouteurs souscrits a ce publicateur. */
 	ListenerCollection listeners;
 
 protected:
@@ -73,6 +105,7 @@ protected:
 	Publisher(): listeners(0) {};
 	virtual ~Publisher() {};
 
+	/** Publie un evenement a tous les ecouteurs de ce publicateur. */
 	void publish(const T& event) {
 		for (typename ListenerCollection::iterator i = listeners.begin(); i != listeners.end(); ++i) {
 			(**i).react(event);
@@ -81,10 +114,12 @@ protected:
 
 public:
 
+	/** Souscrit l'ecouteur donne a ce publicateur. */
 	void subscribe(Listener<T>* listener) {
 		listeners.push_back(listener);
 	}
 
+	/** Retire l'ecouteur donne de ce publicateur. */
 	void unsubscribe(Listener<T>* listener) {
 		listeners.remove(listener);
 	}
diff --git a/src/main/random.h b/src/main/random.h
index 6ba6264..05d02a8 100644
--- a/src/main/random.h
+++ b/src/main/random.h
@@ -12,12 +12,19 @@
 
 namespace vhc {
 
+/** Contient des methodes pour la generation de nombres aleatoires. */
 namespace random {
 
+/** Affecte la "graine" des nombres aleatoires generees par la suite.
+ *  @param s graine (si zero, le temps actuel du systeme est utilise) */
 void seed(unsigned int s);
 
+/** Genere un nombre aleatoire de probabilite equivalente sur l'interval [a, b]. */
 double uniform(double a, double b);
 
+/** Genere un nombre aleatoire reparti de facon gausienne.
+ *  @param average moyenne
+ *  @param standardDeviation ecart-type */
 double gaussian(double average, double standardDeviation);
 
 } //random