Implementation de faisceaux.

13 files changed, 326 insertions, 2 deletions

diff --git a/reponses.lyx b/reponses.lyx
index cc63b8c..dffa544 100644
--- a/reponses.lyx
+++ b/reponses.lyx
@@ -660,5 +660,14 @@ Question P10.3
 Question P10.4
 \end_layout
 
+\begin_layout Section*
+Question P12.1
+\end_layout
+
+\begin_layout Standard
+Comme tous ces propriétés changent pendant l'evolution de la simulation,
+ nous les avons implémentés en tant que méthodes.
+\end_layout
+
 \end_body
 \end_document
diff --git a/src/main/Accelerator.h b/src/main/Accelerator.h
index 4c40cef..175529b 100644
--- a/src/main/Accelerator.h
+++ b/src/main/Accelerator.h
@@ -26,8 +26,7 @@ public:
 	typedef ParticleCollection::iterator ParticleIterator;
 	typedef ElementCollection::iterator ElementIterator;
 
-	/** Cree un nouveau accelerateur vide.
-	 *  */
+	/** Cree un nouveau accelerateur vide. */
 	Accelerator ();
 
 	virtual ~Accelerator();
diff --git a/src/main/Beam.cc b/src/main/Beam.cc
new file mode 100644
index 0000000..f01368e
--- /dev/null
+++ b/src/main/Beam.cc
@@ -0,0 +1,131 @@
+/*
+ * Beam.cc
+ *
+ *  Created on: May 6, 2011
+ *      Author: jakob
+ */
+
+#include <math.h>
+#include "Beam.h"
+#include "Element.h"
+
+using namespace std;
+
+namespace vhc {
+
+Beam::Beam(const Particle& referenceParticle, int quantity, int lambda): referenceParticle(referenceParticle), quantity(quantity), lambda(lambda) {
+	init(referenceParticle, quantity, lambda);
+}
+
+Beam::~Beam() {
+	for (list<Particle*>::iterator i = particles.begin(); i != particles.end(); ++i) {
+		delete *i;
+		*i = NULL;
+	}
+	particles.clear();
+}
+
+int Beam::getSize() const {
+	return particles.size();
+}
+
+int Beam::getLambda() const {
+	return lambda;
+}
+
+const Particle& Beam::getReferenceParticle() const {
+	return referenceParticle;
+}
+
+double Beam::getVR2() const {
+	double z2 = 0;
+	for (list<Particle*>::const_iterator i = particles.begin(); i != particles.end(); ++i) {
+		z2 += (**i).getPosition().getZ() * (**i).getPosition().getZ();
+	}
+	return sqrt(z2 / particles.size());
+}
+
+double Beam::getVV2() const {
+	double v2 = 0;
+	for (list<Particle*>::const_iterator i = particles.begin(); i != particles.end(); ++i) {
+		v2 += (**i).getVelocity().getZ() * (**i).getVelocity().getZ();
+	}
+	return v2 / particles.size();
+}
+
+double Beam::getVRV2() const {
+	double vz = 0;
+	for (list<Particle*>::const_iterator i = particles.begin(); i != particles.end(); ++i) {
+		vz += (**i).getPosition().getZ();
+	}
+	return (vz / particles.size()) * (vz / particles.size());
+}
+
+double Beam::getHR2() const {
+	double r2 = 0;
+	for (list<Particle*>::const_iterator i = particles.begin(); i != particles.end(); ++i) {
+		Vector3D u = ((**i).getElement())->getHorizontalAt((**i).getPosition());
+		r2 += (**i).getPosition().dot(u) * (**i).getPosition().dot(u);
+	}
+	return r2 / particles.size();
+}
+
+double Beam::getHV2() const {
+	double v2 = 0;
+	for (list<Particle*>::const_iterator i = particles.begin(); i != particles.end(); ++i) {
+		Vector3D u = ((**i).getElement())->getHorizontalAt((**i).getPosition());
+		v2 += (**i).getVelocity().dot(u) * (**i).getVelocity().dot(u);
+	}
+	return v2 / particles.size();
+}
+
+double Beam::getHRV2() const {
+	double vr = 0;
+	for (list<Particle*>::const_iterator i = particles.begin(); i != particles.end(); ++i) {
+		Vector3D u = ((**i).getElement())->getHorizontalAt((**i).getPosition());
+		vr += (**i).getPosition().dot(u) * (**i).getVelocity().dot(u);
+	}
+	return (vr / particles.size()) * (vr / particles.size());
+}
+
+double Beam::getAverageEnergy() const {
+	double e = 0;
+	for (list<Particle*>::const_iterator i = particles.begin(); i != particles.end(); ++i) {
+		e += (**i).getEnergy();
+	}
+	return e / particles.size();
+}
+
+double Beam::getVerticalEmittance() const {
+	return sqrt(getVR2() * getVV2() - getVRV2());
+}
+
+double Beam::getHorizontalEmittance() const {
+	return sqrt(getHR2() * getHV2() - getHRV2());
+}
+
+double Beam::getVerticalA11() const {
+	return getVR2() / getVerticalEmittance();
+}
+
+double Beam::getVerticalA12() const {
+	return -getVRV2() / getVerticalEmittance();
+}
+
+double Beam::getVerticalA22() const {
+	return getVV2() / getVerticalEmittance();
+}
+
+double Beam::getHorizontalA11() const {
+	return getHR2() / getHorizontalEmittance();
+}
+
+double Beam::getHorizontalA12() const {
+	return -getHRV2() / getVerticalEmittance();
+}
+
+double Beam::getHorizontalA22() const {
+	return getHV2() / getHorizontalEmittance();
+}
+
+}
diff --git a/src/main/Beam.h b/src/main/Beam.h
new file mode 100644
index 0000000..f03af97
--- /dev/null
+++ b/src/main/Beam.h
@@ -0,0 +1,110 @@
+/*
+ * Beam.h
+ *
+ *  Created on: May 6, 2011
+ *      Author: jakob
+ */
+#ifndef BEAM_H_
+#define BEAM_H_
+
+#include <list>
+#include "Cloneable.h"
+#include "Particle.h"
+#include "Vector3D.h"
+
+namespace vhc {
+
+class Beam {
+
+protected:
+
+	/** Particule de reference. */
+	Particle referenceParticle;
+
+	/** Particules contenus dans ce faisceau. */
+	std::list<Particle*> particles;
+
+	/** Coefficient des macrosparticules. */
+	int lambda;
+
+	int quantity;
+
+	/** Retourne la moyenne de la distribution horizontale de la position des particules.
+	 *  (<r^2> horizontal du complement) */
+	double getHR2() const;
+
+	/** Retourne la moyenne de la distribution horizontale de la vitesse des particules.
+	 *  (<v^2> horizontal du complement) */
+	double getHV2() const;
+
+	/** Retourne la moyenne de la distribution horizontale du produit de la position et de la vitesse des particules.
+	 *  (<r*v>^2 horizontal du complement) */
+	double getHRV2() const;
+
+	/** Retourne la moyenne de la distribution verticale de la position des particules.
+	 *  (<r^2> vertical du complement) */
+	double getVR2() const;
+
+	/** Retourne la moyenne de la distribution verticale de la vitesse des particules.
+	 *  (<v^2> vertical du complement) */
+	double getVV2() const;
+
+	/** Retourne la moyenne de la distribution verticale du produit de la position et de la vitesse des particules.
+	 *  (<r*v>^2 vertical du complement) */
+	double getVRV2() const;
+
+	/** Initialise ce faisceau a partir de la particule de reference. Comme il s'agit d'une sorte de factory method (au sens vraiment large),
+	 *  la responsabilite de gestion des particules appartient a ce faisceau (et non a la sous-classe). */
+	virtual void init(const Particle& referenceParticle, int quantity, int lambda) = 0;
+
+
+public:
+
+	/** Cree un nouveau faisceaux.
+	 *  <b>ATTENTION:</b> un `Beam' est abstrait et n'initialise pas les particules a partir de la reference.
+	 *  C'est au client de faire cela! */
+	Beam(const Particle& referenceParticle, int quantity, int lambda);
+
+	virtual ~Beam();
+
+	/** Retourne la quantite de particules contenus dans ce faisceau. */
+	int getSize() const;
+
+	/** Retourne le coefficient des macroparticules. */
+	int getLambda() const;
+
+	/** Retourne la particule de reference. */
+	const Particle& getReferenceParticle() const;
+
+	/** Retourne l'energie moyenne des particules dans ce faisceau. */
+	double getAverageEnergy() const;
+
+	/** Retourne l'emmitance verticale de ce faisceau. */
+	double getVerticalEmittance() const;
+
+	/** Retourne l'emmitance horizontale de ce faisceau. */
+	double getHorizontalEmittance() const;
+
+	/** Retourne coefficient des ellipses de phases vertical. */
+	double getVerticalA11() const;
+
+	/** Retourne coefficient des ellipses de phases vertical. */
+	double getVerticalA12() const;
+
+	/** Retourne coefficient des ellipses de phases vertical. */
+	double getVerticalA22() const;
+
+	/** Retourne coefficient des ellipses de phases horizontal. */
+	double getHorizontalA11() const;
+
+	/** Retourne coefficient des ellipses de phases horizontal. */
+	double getHorizontalA12() const;
+
+	/** Retourne coefficient des ellipses de phases horizontal. */
+	double getHorizontalA22() const;
+
+};
+
+}
+
+#endif /* BEAM_H_ */
diff --git a/src/main/CircularBeam.cc b/src/main/CircularBeam.cc
new file mode 100644
index 0000000..ee2fa9d
--- /dev/null
+++ b/src/main/CircularBeam.cc
@@ -0,0 +1,21 @@
+/*
+ * CircularBeam.cc
+ *
+ *  Created on: May 17, 2011
+ *      Author: jakob
+ */
+
+#include "CircularBeam.h"
+
+namespace vhc {
+
+CircularBeam::CircularBeam(const Particle& referenceParticle, int quantity, int lambda): Beam(referenceParticle, quantity, lambda) {
+
+}
+
+CircularBeam::~CircularBeam() {}
+
+CircularBeam::init(const Particle& referenceParticle, int quantity, int lambda) {
+
+}
+}
diff --git a/src/main/CircularBeam.h b/src/main/CircularBeam.h
new file mode 100644
index 0000000..086abfb
--- /dev/null
+++ b/src/main/CircularBeam.h
@@ -0,0 +1,30 @@
+/*
+ * CircularBeam.h
+ *
+ *  Created on: May 17, 2011
+ *      Author: jakob
+ */
+
+#ifndef CIRCULARBEAM_H_
+#define CIRCULARBEAM_H_
+
+#include "Beam.h"
+
+namespace vhc {
+
+class CircularBeam: public Beam {
+
+protected:
+
+	virtual void init(const Particle& referenceParticle, int quantity, int lambda) = 0;
+
+public:
+	CircularBeam(const Particle& referenceParticle, int quantity, int lambda);
+	virtual ~CircularBeam();
+
+	virtual CircularBeam* clone() const;
+};
+
+}
+
+#endif /* CIRCULARBEAM_H_ */
diff --git a/src/main/CompositeElement.cc b/src/main/CompositeElement.cc
index 48e5757..9bc8ff6 100644
--- a/src/main/CompositeElement.cc
+++ b/src/main/CompositeElement.cc
@@ -40,6 +40,14 @@ Vector3D CompositeElement::magneticFieldAt(const Vector3D& position) const {
 	return b;
 }
 
+double CompositeElement::getLength() const {
+	double l = 0;
+	for (int i(0); i < elements.size(); ++i) {
+		l += elements[i]->getLength();
+	}
+	return l;
+}
+
 Vector3D CompositeElement::electricFieldAt(const Vector3D& position) const {
 	MutableVector3D e = Vector3D::Null;
 	for (int i(0); i < elements.size(); i++) {
diff --git a/src/main/CompositeElement.h b/src/main/CompositeElement.h
index 60e0a44..3440bbe 100644
--- a/src/main/CompositeElement.h
+++ b/src/main/CompositeElement.h
@@ -38,6 +38,8 @@ public:
 
 	virtual bool isAfter(const Vector3D& position) const;
 
+	virtual double getLength() const;
+
 	virtual Vector3D magneticFieldAt(const Vector3D& position) const;
 
 	virtual Vector3D electricFieldAt(const Vector3D& position) const;
diff --git a/src/main/CurvedElement.cc b/src/main/CurvedElement.cc
index d30bff4..834484e 100644
--- a/src/main/CurvedElement.cc
+++ b/src/main/CurvedElement.cc
@@ -59,6 +59,10 @@ bool CurvedElement::isAfter(const Vector3D& position) const {
 	return (position - exitPosition).dot(out) > 0;
 }
 
+double CurvedElement::getLength() const {
+	return getAngle() / getCurvature();
+}
+
 Vector3D CurvedElement::getHorizontalAt(const Vector3D& position) const {
 	Vector3D X(position - curvatureCenter);
 	return (X - position.getZ() * Vector3D::k).unit();
diff --git a/src/main/CurvedElement.h b/src/main/CurvedElement.h
index 846f279..6e5deae 100644
--- a/src/main/CurvedElement.h
+++ b/src/main/CurvedElement.h
@@ -56,6 +56,8 @@ public:
 
 	virtual Vector3D getHorizontalAt(const Vector3D& position) const;
 
+	virtual double getLength() const;
+
 	/** Retourne la courbure. */
 	double getCurvature() const;
 
diff --git a/src/main/Element.h b/src/main/Element.h
index 3722be2..a3c26ff 100644
--- a/src/main/Element.h
+++ b/src/main/Element.h
@@ -101,6 +101,8 @@ public:
 	/** Retourne le rayon de la section de cet element. */
 	double getSectionRadius() const;
 
+	virtual double getLength() const = 0;
+
 	/** Assigne le rayon de la section de cet element. */
 	//void setSectionRadius(double r) {sectionRadius = r;}
 
diff --git a/src/main/StraightElement.cc b/src/main/StraightElement.cc
index 05e88c6..ab73a71 100644
--- a/src/main/StraightElement.cc
+++ b/src/main/StraightElement.cc
@@ -31,6 +31,10 @@ bool StraightElement::isAfter(const Vector3D& position) const {
 	return getDiagonal().dot(v) > 0;
 }
 
+double StraightElement::getLength() const {
+	return getDiagonal().norm();
+}
+
 Vector3D StraightElement::getHorizontalAt(const Vector3D& position) const {
 	return Vector3D::k.cross(getDiagonal());
 }
diff --git a/src/main/StraightElement.h b/src/main/StraightElement.h
index 14d21aa..84ad4c4 100644
--- a/src/main/StraightElement.h
+++ b/src/main/StraightElement.h
@@ -30,6 +30,8 @@ public:
 
 	virtual bool isAfter(const Vector3D& position) const;
 
+	virtual double getLength() const;
+
 	virtual std::string getType() const;
 	virtual std::string toString() const;