From dc2a0999d29f61582a795ec66d89d05888a27bdb Mon Sep 17 00:00:00 2001 From: Jakob Odersky Date: Tue, 17 May 2011 15:37:32 +0000 Subject: Implementation de faisceaux. --- reponses.lyx | 9 +++ src/main/Accelerator.h | 3 +- src/main/Beam.cc | 131 +++++++++++++++++++++++++++++++++++++++++++ src/main/Beam.h | 110 ++++++++++++++++++++++++++++++++++++ src/main/CircularBeam.cc | 21 +++++++ src/main/CircularBeam.h | 30 ++++++++++ src/main/CompositeElement.cc | 8 +++ src/main/CompositeElement.h | 2 + src/main/CurvedElement.cc | 4 ++ src/main/CurvedElement.h | 2 + src/main/Element.h | 2 + src/main/StraightElement.cc | 4 ++ src/main/StraightElement.h | 2 + 13 files changed, 326 insertions(+), 2 deletions(-) create mode 100644 src/main/Beam.cc create mode 100644 src/main/Beam.h create mode 100644 src/main/CircularBeam.cc create mode 100644 src/main/CircularBeam.h 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 +#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::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::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::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::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::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::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::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::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 +#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 particles; + + /** Coefficient des macrosparticules. */ + int lambda; + + int quantity; + + /** Retourne la moyenne de la distribution horizontale de la position des particules. + * ( horizontal du complement) */ + double getHR2() const; + + /** Retourne la moyenne de la distribution horizontale de la vitesse des particules. + * ( horizontal du complement) */ + double getHV2() const; + + /** Retourne la moyenne de la distribution horizontale du produit de la position et de la vitesse des particules. + * (^2 horizontal du complement) */ + double getHRV2() const; + + /** Retourne la moyenne de la distribution verticale de la position des particules. + * ( vertical du complement) */ + double getVR2() const; + + /** Retourne la moyenne de la distribution verticale de la vitesse des particules. + * ( vertical du complement) */ + double getVV2() const; + + /** Retourne la moyenne de la distribution verticale du produit de la position et de la vitesse des particules. + * (^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. + * ATTENTION: 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; -- cgit v1.2.3