algorithm.h

#ifndef ALGORITHM_H
#define ALGORITHM_H
#include "physics2d.h"
#include "multiqueue.h"
#include <mutex>

class Algorithm
{
public:
    Algorithm(double xIn, double yIn);

    Algorithm(double xIn, double yIn, double zIn);

    Algorithm(double xIn, double yIn, double zIn, double centerMass);

    virtual ~Algorithm();

    std::vector<Particle*> getParticles();

    std::queue<Collision*>* getCollisions();

    MultiQueue* getPositionQueue();

    std::mutex* getCollisionMutex();

    Particle* getCenterOfGravity();

    int getNumParts();

    int getTimestep();

    double getSystemKE();

    double getSystemPE();

    Physics* getPhysics();

    void setNumParts(int numParticles);

    void createParticles2D(int numParticles);

    void createParticles3D(int numParticles);

    void createParticlesOrbit(int numParticles);

    // IS THIS SOMETHING WE WANT?
    void respawnParticle(Particle* particle);

    void enqueueCollisions(std::vector<Collision*> collisions);

    void runOneTimestep();

    // WHAT do these actually do?
    void run();
    void stop();

    void stepTime();

protected:
    std::vector<Particle*> particles;

    std::queue<Collision*> collisionQueue;
    std::mutex collisionMutex;

    MultiQueue* positionQueue;

    Physics* physics;
    bool running;
    int numParts;
    int timestep;
    double xWinSize;
    double yWinSize;
    double zWinSize;
    double systemKE;
    double systemPE;

    Particle* generateParticleIn2D(int i);
    Particle* generateParticleIn3D(int i);
    Particle* generateParticleInOrbit(int i);
    void regenerateParticleInOrbit(Particle* p);
    bool checkForOverlap(Particle* p);

    virtual void calculateNextTimestep() = 0;

    void enqueuePositions();

    void updateSystemKE();
    void updateSystemPE();
    void rescaleVelocities();

    void checkTimestep();
};

#endif // ALGORITHM_H