Commit 5f3e56fc authored by Emil Gallyamov's avatar Emil Gallyamov
Browse files

Week7 solution + week8 exercise

parent f17d735f
This diff is collapsed.
step-*.csv
\ No newline at end of file
class Real(double)
class UInt(unsigned int)
class Vector
public Vector(UInt dim);
public ~Vector();
public Real & operator[](UInt i);
private Real * values;
private UInt dim;
class Particle
public Particle();
public ~Particle();
public Real & getMass();
public Vector & getPosition();
public Vector & getVelocity();
public Vector & getForce();
protected Real mass;
protected Vector position;
protected Vector velocity;
protected Vector force;
class PingPongBall(Particle)
public PingPongBall();
public ~PingPongBall();
public Real & getRadius();
public Real & getContactDissipation();
private Real radius;
private Real contact_dissipation;
class Planet(Particle)
public Planet();
public ~Planet();
public std::string & getName();
private std::string name;
class Compute
public Compute();
public ~Compute();
public pure virtual void compute(System & system);
class ComputeInteraction(Compute)
public ComputeInteraction();
public ~ComputeInteraction();
public pure virtual void compute(System & system);
class ComputeContact(ComputeInteraction)
public ComputeContact();
public ~ComputeContact();
public void compute(System & system);
class ComputeGravity(ComputeInteraction)
public ComputeGravity();
public ~ComputeGravity();
public void compute(System & system);
class CsvReader(Compute)
public CsvReader(const std::string & filename);
public ~CsvReader();
public void read(System & system);
public void compute(System & system);
protected std::string filename;
class CsvWriter(Compute)
public CsvWriter(const std::string & filename);
public ~CsvWriter();
public void write(System& system);
public void compute(System & system);
protected std::string filename;
class ComputeVerletIntegration(Compute)
public ComputeVerletIntegration(Real dt);
public ~ComputeVerletIntegration();
public void compute(System& system);
public void addInteraction(std::shared_ptr<ComputeInteraction> interaction);
public setDeltaT(Real dt);
private Real dt;
private InteractionList interactions;
class System
public System()
public ~System()
public UInt getListSize();
public Particle & getParticle(UInt i);
public addParticle(Particle& new_particle);
public removeParticle(UInt particle);
private ListParticles list_particles;
class SystemEvolution
public SystemEvolution(System & system);
public evolve();
protected std::vector<Compute *> computes;
protected System & system;
class ListParticles(std::vector<Particle*>)
\ No newline at end of file
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)
#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__
#include "compute_boundary.hh"
/* -------------------------------------------------------------------------- */
ComputeBoundary::ComputeBoundary(const Vector& xmin, const Vector& xmax)
: xmin(xmin), xmax(xmax) {
Vector d = xmax - xmin;
for (UInt i = 0; i < Vector::dim; ++i)
if (d[i] < 0) {
std::cout << "XMax and XMin do not form a domain range" << std::endl;
std::exit(1);
}
}
/* -------------------------------------------------------------------------- */
void ComputeBoundary::compute(System& system) {
}
/* -------------------------------------------------------------------------- */
#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__
#include "compute_contact.hh"
#include "ping_pong_ball.hh"
#include <cmath>
/* -------------------------------------------------------------------------- */
void ComputeContact::setPenalty(Real penalty) {
}
/* -------------------------------------------------------------------------- */
void ComputeContact::compute(System& system) {
}
#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__
#include "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__
#include "compute_gravity.hh"
#include <cmath>
/* -------------------------------------------------------------------------- */
void ComputeGravity::compute(System& system) {
}
#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__
#include "compute_interaction.hh"
#include <cmath>
/* -------------------------------------------------------------------------- */
#ifndef __COMPUTE_INTERACTION__HH__
#define __COMPUTE_INTERACTION__HH__
/* -------------------------------------------------------------------------- */
#include "compute.hh"
//! Base class for interaction computation
class ComputeInteraction : public Compute {
};
/* -------------------------------------------------------------------------- */
#endif //__COMPUTE_INTERACTION__HH__
#include "compute_kinetic_energy.hh"
/* -------------------------------------------------------------------------- */
void ComputeKineticEnergy::compute(System& system) {}
/* -------------------------------------------------------------------------- */
#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__
#include "compute_potential_energy.hh"
/* -------------------------------------------------------------------------- */
ComputePotentialEnergy::ComputePotentialEnergy(ComputeInteraction& cForces)
: cForces(cForces) {}
/* -------------------------------------------------------------------------- */
void ComputePotentialEnergy::compute(System& system) {}
#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__
#include "compute_verlet_integration.hh"
ComputeVerletIntegration::ComputeVerletIntegration(Real dt) : dt(dt) {}
/* -------------------------------------------------------------------------- */
void ComputeVerletIntegration::setDeltaT(Real dt) {
}
/* -------------------------------------------------------------------------- */
void ComputeVerletIntegration::compute(System& system) {
}
/* -------------------------------------------------------------------------- */
void ComputeVerletIntegration::addInteraction(
std::shared_ptr<ComputeInteraction> interaction) {
}
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment