Unites convertis en unites SI pour l'utilisation interne.

9 files changed, 48 insertions, 36 deletions

diff --git a/reponses.lyx b/reponses.lyx
index bcfe8d8..096f8e4 100644
--- a/reponses.lyx
+++ b/reponses.lyx
@@ -734,7 +734,7 @@ Question P8.1
 En termes de POO, cela signifie que la méthode 
 \family typewriter
 \size small
-isOutside
+hasHit
 \family default
 \size default
  est virtuelle (même virtuelle pure à l'intérieur de la classe 
diff --git a/src/main/Accelerator.h b/src/main/Accelerator.h
index 06594f2..e0b99bc 100644
--- a/src/main/Accelerator.h
+++ b/src/main/Accelerator.h
@@ -80,8 +80,8 @@ public:
 	}
 
 
-	/** Fait évoluer l'accélérateur (pas de temps fixe). */
-	void step(){
+	/** Fait évoluer l'accélérateur d'un lapse de temps dt . */
+	void step(double dt) {
 
 	}
 
diff --git a/src/main/CompositeElement.cc b/src/main/CompositeElement.cc
index 44714ea..0c62a19 100644
--- a/src/main/CompositeElement.cc
+++ b/src/main/CompositeElement.cc
@@ -15,9 +15,9 @@ CompositeElement::CompositeElement(const Vector3D& entry, const Vector3D& exit,
 
 CompositeElement::~CompositeElement() {};
 
-bool CompositeElement::isOutside(const Particle& particle) const {
+bool CompositeElement::hasHit(const Particle& particle) const {
 	for (int i(0); i < elements.size(); ++i) {
-		if (elements[i]->isOutside(particle)) return true;
+		if (elements[i]->hasHit(particle)) return true;
 	}
 	return false;
 }
diff --git a/src/main/CompositeElement.h b/src/main/CompositeElement.h
index 90cb6a5..2c0c6d4 100644
--- a/src/main/CompositeElement.h
+++ b/src/main/CompositeElement.h
@@ -33,7 +33,7 @@ public:
 	virtual ~CompositeElement();
 
 	/** Determine si une particule a heurte le bord de cet element, donc d'un des elements composants. */
-	virtual bool isOutside(const Particle& particle) const;
+	virtual bool hasHit(const Particle& particle) const;
 
 	/** Determine si une particule a passe cet element, donc passe le dernier element composant. */
 	virtual bool isPast(const Particle& particle) const;
diff --git a/src/main/CurvedElement.h b/src/main/CurvedElement.h
index 036fe0e..0c76541 100644
--- a/src/main/CurvedElement.h
+++ b/src/main/CurvedElement.h
@@ -45,7 +45,7 @@ public:
 	virtual ~CurvedElement() {};
 	//virtual CurvedElement* clone() const {return new CurvedElement(*this);}
 
-	virtual bool isOutside(const Particle& particle) const {
+	virtual bool hasHit(const Particle& particle) const {
 		Vector3D x(particle.getPosition() - entryPosition);
 		if (x == Vector3D::Null) return false;
 		else return (x - Vector3D(x.getX(), x.getY(), 0).unit() / fabs(curvature)).norm() > sectionRadius;
diff --git a/src/main/Element.h b/src/main/Element.h
index a8b0e90..4ce1d00 100644
--- a/src/main/Element.h
+++ b/src/main/Element.h
@@ -73,7 +73,7 @@ public:
 	virtual Element* clone() const = 0;
 
 	/** Determine si la particule donnee a heurte le bord de cet element. */
-	virtual bool isOutside(const Particle& particle) const = 0;
+	virtual bool hasHit(const Particle& particle) const = 0;
 
 	/** Determine si la particule donnee a passe cet element. */
 	virtual bool isPast(const Particle& particle) const = 0;
diff --git a/src/main/Particle.h b/src/main/Particle.h
index 78d64a0..3e69f4e 100644
--- a/src/main/Particle.h
+++ b/src/main/Particle.h
@@ -25,26 +25,31 @@ class Particle: public Printable, public Cloneable {
 
 private:
 
-	/** Position de cette particule. */
+	/** Position de cette particule. [m] */
 	Vector3D position;
 
-	/** Vitesse de cette particule. */
+	/** Vitesse de cette particule. [m/s] */
 	Vector3D velocity;
 
-	/** Force résultante sur cette particule. */
+	/** Force résultante sur cette particule. [N] */
 	Vector3D force;
 
-	/** Masse de cette particule. */
+	/** Masse de cette particule. [kg] */
 	double mass;
 
-	/** Charge de cette particule. */
+	/** Charge de cette particule. [C] */
 	double charge;
 
+	/** Facteur gamma de cette particule. [1] */
 	double gamma;
 
 public:
 
 
+	/** Cree une nouvelle particule, de vitesse nulle.
+	 *  @param position position
+	 *  @param mass masse <b>[kg]</b>
+	 *  @param charge charge [C] */
 	Particle(const Vector3D& position, double mass, double charge):
 			position(position),
 			velocity(0, 0, 0),
@@ -53,9 +58,15 @@ public:
 			charge(charge)
 	{};
 
+	/** Cree une nouvelle particule avec les parametres donnees.
+	 *  @param position position
+	 *  @param mass masse <b>[kg]</b>
+	 *  @param charge charge [C]
+	 *  @param energy energie <b>[J]</b>
+	 *  @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):
 		position(position),
-		velocity(constants::c * sqrt(1 - (mass * mass) / (energy * energy)) * direction.unit()),
+		velocity(constants::c * sqrt(1 - (mass * mass * constants::c2 * constants::c2) / (energy * energy)) * direction.unit()),
 		gamma(energy / (mass * constants::c2)),
 		force(0, 0, 0),
 		mass(mass),
@@ -63,50 +74,52 @@ public:
 	{};
 
 
-	/** Retourne la position de cette particule. */
+	/** Retourne la position de cette particule. [m] */
 	Vector3D getPosition() const {return position;}
 
-	/** Affecte la position de cette particule. */
+	/** Affecte la position de cette particule. [m] */
 	void setPosition(const Vector3D& pos) {position = pos;}
 
-	/** Retourne la force résultante sur cette particule. */
+	/** Retourne la force résultante sur cette particule. [N] */
 	Vector3D getForce() const {return force;}
 
-	/** Affecte la force résultante sur cette particule. */
+	/** Affecte la force résultante sur cette particule. [N] */
 	void setForce(const Vector3D& f) {force = f;}
 
-	/** Applique une force sur cette particule. */
+	/** Applique une force sur cette particule. [N] */
 	void applyForce(const Vector3D& f) {force = force + f;}
 
 	/** Applique un champ magnetique sur cette particule durant un lapse de temps dt.
-	 *  Cette application change la force resultante de la particule. */
+	 *  Cette application change la force resultante de la particule. [T], [s] */
 	void applyMagneticForce(const Vector3D& b, double dt) {
 		if (b != Vector3D::Null) {
 			Vector3D f = charge * velocity.cross(b);
-			force = force + f.rotate(velocity.cross(f), (dt * f.norm()) / (2 * gamma * getMassKg() * velocity.norm()));
+			force = force + f.rotate(velocity.cross(f), (dt * f.norm()) / (2 * gamma * mass * velocity.norm()));
 		}
 	}
 
-	/** Retourne la masse de cette particule en GeV. */
+	/** Retourne la masse de cette particule. [kg] */
 	double getMass() const {return mass;}
 
-	/** Retourne la masse de cette particule en Kg. */
-	double getMassKg() const {return mass * 1E-9 * constants::e / constants::c2;}
+	///** Retourne la masse de cette particule en Kg. */
+	//double getMassGeV() const {return mass * 1E-9 * constants::e / constants::c2;}
 
-	/** Retourne la charge de cette particule. */
+	/** Retourne la charge de cette particule. [C] */
 	double getCharge() const {return charge;}
 
-	/** Retourne la vitesse de cette particule. */
+	/** Retourne la vitesse de cette particule. [m/s]*/
 	Vector3D getVelocity() const {return velocity;}
 
+	/** Affecte vitesse de cette particule. [m/s] */
 	void setVelocity(const Vector3D& v) {
 		velocity = v;
 		gamma = 1.0 / sqrt(1.0 - v.normSquare() / constants::c2);
 	}
 
-	//GeV
+	/** Retourne l'energie de cette particlue. [J] */
 	double getEnergy() const {return gamma * mass * constants::c2;}
 
+	/** Retourne le facteur gamma de cette particule. [1] */
 	double getGamma() const {return gamma;}
 
 	/** Retourne une représentation en chaîne de cette particule. */
@@ -126,7 +139,6 @@ public:
 	virtual Particle* clone() const {return new Particle(*this);}
 
 
-
 };
 
 }
diff --git a/src/main/StraightElement.h b/src/main/StraightElement.h
index 95b5ddf..3a7fcf4 100644
--- a/src/main/StraightElement.h
+++ b/src/main/StraightElement.h
@@ -28,7 +28,7 @@ public:
 
 	//virtual StraightElement* clone() const {return new StraightElement(*this);}
 
-	virtual bool isOutside(const Particle& particle) const {
+	virtual bool hasHit(const Particle& particle) const {
 		Vector3D a(particle.getPosition() - entryPosition);
 		const Vector3D b = (particle.getPosition() - entryPosition);
 		return (a.cross(b)).norm() / getDiagonal().norm() > sectionRadius;
diff --git a/src/test/ParticleTest.cc b/src/test/ParticleTest.cc
index d30aab0..b1e3788 100644
--- a/src/test/ParticleTest.cc
+++ b/src/test/ParticleTest.cc
@@ -35,13 +35,13 @@ int main() {
 	double curvature = 0.1;
 	Vector3D direction = entry.cross(Vector3D::k);
 
-	double mass = 5.1E-4; //GeV
-	double charge = constants::e; //C
-	double energy = 1; //GeV
+	double mass = 9.11E-31;
+	double charge = constants::e;
+	double energy = 1 * 1E9 * constants::e;
 
 
 	particle = new Particle(entry, mass, charge, energy, direction);
-	double Bz = particle->getGamma() * particle->getMassKg() * curvature * particle->getVelocity().norm() / particle->getCharge();
+	double Bz = particle->getGamma() * particle->getMass() * curvature * particle->getVelocity().norm() / particle->getCharge();
 	cout << Bz << endl;
 	element = new Dipole(entry, exit, sectionRadius, curvature, Vector3D::k * Bz);
 
@@ -51,7 +51,7 @@ int main() {
 	char c('0');
 	bool hit = false;
 	do {
-		if (element->isOutside(*particle)) hit = true;
+		if (element->hasHit(*particle)) hit = true;
 		cout << "t = " << t << endl;
 		step(h);
 		t += h;
@@ -70,12 +70,12 @@ int main() {
 }
 
 void step(double h) {
+	cout << *particle << endl;
 	particle->applyMagneticForce(element->magneticFieldAt(particle->getPosition()), h);
 
-	Vector3D a = particle->getForce() / (particle->getGamma() * particle->getMassKg());
+	Vector3D a = particle->getForce() / (particle->getGamma() * particle->getMass());
 	particle->setVelocity(particle->getVelocity() + a * h);
 	particle->setPosition(particle->getPosition() + particle->getVelocity() * h);
-	cout << *particle << endl;
 	particle->setForce(Vector3D::Null);
 }