adding the solution of week8

exercises/week8/particles/solution/.clang-format

+---
+Language:                            Cpp
+BasedOnStyle:                        LLVM
+Standard:                            Cpp11
+AlwaysBreakTemplateDeclarations:     true
+PointerAlignment:                    Left
+SpacesBeforeTrailingComments:        2
+#FixNamespaceComments:		     true
+...

exercises/week8/particles/solution/.gitignore

+step-*.csv
+build
+starting_point
\ No newline at end of file

exercises/week8/particles/solution/CMakeLists.txt

+
+cmake_minimum_required (VERSION 2.6)
+project (Particles)
+
+set(CMAKE_CXX_STANDARD 14)
+
+add_executable(particles
+  main.cc
+  vector.cc
+  compute_boundary.cc
+  compute_verlet_integration.cc 
+  particle.cc 
+  planet.cc
+  compute_gravity.cc 
+  csv_reader.cc 
+  particles_factory_interface.cc 
+  planets_factory.cc 
+  compute_contact.cc 
+  compute_kinetic_energy.cc 
+  csv_writer.cc 
+  system.cc 
+  compute_energy.cc 
+  compute_potential_energy.cc 
+  ping_pong_ball.cc 
+  system_evolution.cc 
+  ping_pong_balls_factory.cc 
+  compute_interaction.cc)
+

exercises/week8/particles/solution/circle_orbit.csv

+0 0 0 0 0 0 1e-4 0 0 1 sun
+1 0 0 0 1 0 -1e-4 0 0 1e-4 earth

exercises/week8/particles/solution/compute.hh

+#ifndef __COMPUTE__HH__
+#define __COMPUTE__HH__
+
+/* -------------------------------------------------------------------------- */
+#include "system.hh"
+/* -------------------------------------------------------------------------- */
+
+//! Base class for all compute
+class Compute {
+public:
+  //! Virtual destructor needed because we have subclasses
+  virtual ~Compute() = default;
+
+  /* ------------------------------------------------------------------------ */
+  /* Methods                                                                  */
+  /* ------------------------------------------------------------------------ */
+public:
+  //! Compute is pure virtual
+  virtual void compute(System& system) = 0;
+};
+
+/* -------------------------------------------------------------------------- */
+#endif  //__COMPUTE__HH__

exercises/week8/particles/solution/compute_boundary.cc

+#include "compute_boundary.hh"
+/* -------------------------------------------------------------------------- */
+ComputeBoundary::ComputeBoundary(const Vector& xmin, const Vector& xmax) {}
+/* -------------------------------------------------------------------------- */
+
+void ComputeBoundary::compute(System& system) {}
+
+/* -------------------------------------------------------------------------- */

exercises/week8/particles/solution/compute_boundary.hh

+#ifndef __COMPUTE_BOUNDARY__HH__
+#define __COMPUTE_BOUNDARY__HH__
+
+/* -------------------------------------------------------------------------- */
+#include "compute.hh"
+/* -------------------------------------------------------------------------- */
+
+//! Compute interaction with simulation box
+class ComputeBoundary : public Compute {
+  // Constructors/Destructors
+public:
+  ComputeBoundary(const Vector& xmin, const Vector& xmax);
+
+  // Methods
+public:
+  void compute(System& system) override;
+
+  // Members
+protected:
+  Vector xmin, xmax;
+};
+
+/* -------------------------------------------------------------------------- */
+#endif  //__COMPUTE_BOUNDARY__HH__

exercises/week8/particles/solution/compute_contact.cc

+#include "compute_contact.hh"
+#include "ping_pong_ball.hh"
+#include <cmath>
+/* -------------------------------------------------------------------------- */
+void ComputeContact::setPenalty(Real penalty) {}
+/* -------------------------------------------------------------------------- */
+void ComputeContact::compute(System& system) {}

exercises/week8/particles/solution/compute_contact.hh

+#ifndef __COMPUTE_CONTACT__HH__
+#define __COMPUTE_CONTACT__HH__
+
+/* -------------------------------------------------------------------------- */
+#include "compute_interaction.hh"
+
+//! Compute contact interaction between ping-pong balls
+class ComputeContact : public ComputeInteraction {
+
+  // Virtual implementation
+public:
+  //! Penalty contact implementation
+  void compute(System& system) override;
+
+  // Accessors
+public:
+  //! Set penalty
+  void setPenalty(Real penalty);
+
+  // Members
+protected:
+  Real penalty;
+};
+
+/* -------------------------------------------------------------------------- */
+#endif  //__COMPUTE_CONTACT__HH__

exercises/week8/particles/solution/compute_energy.cc

+#include "compute_energy.hh"
+/* -------------------------------------------------------------------------- */

exercises/week8/particles/solution/compute_energy.hh

+#ifndef __COMPUTE_ENERGY__HH__
+#define __COMPUTE_ENERGY__HH__
+
+/* -------------------------------------------------------------------------- */
+#include "compute.hh"
+
+//! Base class for energy computation
+class ComputeEnergy : public Compute {
+
+  // Methods
+public:
+  Real getValue() { return value; }
+
+protected:
+  Real value;
+};
+
+/* -------------------------------------------------------------------------- */
+#endif  //__COMPUTE_ENERGY__HH__

exercises/week8/particles/solution/compute_gravity.cc

+#include "compute_gravity.hh"
+#include <cmath>
+/* -------------------------------------------------------------------------- */
+void ComputeGravity::compute(System& system) {
+  UInt size = system.getNbParticles();
+
+  // the force vector
+  Vector force;
+  // the distance vector
+  Vector v_r;
+  // the normalized vector
+  Vector v_nr;
+  // the square of the distance
+  Real r2 = 0.;
+  // the distance
+  Real r = 0.;
+
+  for (UInt p1 = 0; p1 < size; ++p1) {
+    Particle& par1 = system.getParticle(p1);
+    for (UInt p2 = p1 + 1; p2 < size; ++p2) {
+      Particle& par2 = system.getParticle(p2);
+
+      // compute the distance vector and the square of distance
+
+      v_r = par2.getPosition() - par1.getPosition();
+      r2 = v_r.squaredNorm();
+
+      if (r2 == 0.)
+        continue;
+      // compute the distance
+      r = sqrt(r2);
+      v_nr = v_r / r;
+
+      // compute the pair force
+      force = par1.getMass() * par2.getMass() * G / r2 * v_nr;
+
+      // add up the force for both concerned particles
+      par2.getForce() -= force;
+      par1.getForce() += force;
+    }
+  }
+}

exercises/week8/particles/solution/compute_gravity.hh

+#ifndef __COMPUTE_GRAVITY__HH__
+#define __COMPUTE_GRAVITY__HH__
+
+/* -------------------------------------------------------------------------- */
+#include "compute_interaction.hh"
+
+//! Compute Newton gravity interaction
+class ComputeGravity : public ComputeInteraction {
+
+  // Virtual implementation
+public:
+  //! Newton gravity implementation
+  void compute(System& system) override;
+
+  // Accessors
+public:
+  //! set the gravitational constant
+  void setG(Real G);
+
+  // Members
+private:
+  //! newton constant
+  Real G = 1.;
+};
+
+/* -------------------------------------------------------------------------- */
+#endif  //__COMPUTE_GRAVITY__HH__

exercises/week8/particles/solution/compute_interaction.cc

+#include "compute_interaction.hh"
+#include <cmath>
+/* -------------------------------------------------------------------------- */

exercises/week8/particles/solution/compute_interaction.hh

+#ifndef __COMPUTE_INTERACTION__HH__
+#define __COMPUTE_INTERACTION__HH__
+
+/* -------------------------------------------------------------------------- */
+#include "compute.hh"
+
+//! Base class for interaction computation
+class ComputeInteraction : public Compute {
+};
+
+/* -------------------------------------------------------------------------- */
+#endif  //__COMPUTE_INTERACTION__HH__

exercises/week8/particles/solution/compute_kinetic_energy.cc

+#include "compute_kinetic_energy.hh"
+/* -------------------------------------------------------------------------- */
+
+void ComputeKineticEnergy::compute(System& system) {}
+
+/* -------------------------------------------------------------------------- */

exercises/week8/particles/solution/compute_kinetic_energy.hh

+#ifndef __COMPUTE_KINETIC_ENERGY__HH__
+#define __COMPUTE_KINETIC_ENERGY__HH__
+
+/* -------------------------------------------------------------------------- */
+#include "compute_energy.hh"
+
+//! Compute kinetic energy of system
+class ComputeKineticEnergy : public ComputeEnergy {
+public:
+  void compute(System& system) override;
+};
+
+/* -------------------------------------------------------------------------- */
+#endif  //__COMPUTE_KINETIC_ENERGY__HH__

exercises/week8/particles/solution/compute_potential_energy.cc

+#include "compute_potential_energy.hh"
+/* -------------------------------------------------------------------------- */
+
+ComputePotentialEnergy::ComputePotentialEnergy(ComputeInteraction& cForces)
+    : cForces(cForces) {}
+
+/* -------------------------------------------------------------------------- */
+
+void ComputePotentialEnergy::compute(System& system) {}

exercises/week8/particles/solution/compute_potential_energy.hh

+#ifndef __COMPUTE_POTENTIAL_ENERGY__HH__
+#define __COMPUTE_POTENTIAL_ENERGY__HH__
+
+/* -------------------------------------------------------------------------- */
+#include "compute_energy.hh"
+#include "compute_interaction.hh"
+/* -------------------------------------------------------------------------- */
+
+//! Compute potential energy of system
+class ComputePotentialEnergy : public ComputeEnergy {
+
+  /* ------------------------------------------------------------------------ */
+  /* Constructors/Destructors                                                 */
+  /* ------------------------------------------------------------------------ */
+
+public:
+  ComputePotentialEnergy(ComputeInteraction& cForces);
+
+  /* ------------------------------------------------------------------------ */
+  /* Methods                                                                  */
+  /* ------------------------------------------------------------------------ */
+
+public:
+  void compute(System& system) override;
+
+  /* ------------------------------------------------------------------------ */
+  /* Members                                                                  */
+  /* ------------------------------------------------------------------------ */
+
+protected:
+  ComputeInteraction& cForces;
+};
+
+/* -------------------------------------------------------------------------- */
+#endif  //__COMPUTE_POTENTIAL_ENERGY__HH__