particle.h

Go to the documentation of this file.

/* This file is part of StepCore library.
   Copyright (C) 2007 Vladimir Kuznetsov <ks.vladimir@gmail.com>

   StepCore library is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   StepCore library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with StepCore; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef STEPCORE_PARTICLE_H
#define STEPCORE_PARTICLE_H

#include "world.h"
#include "vector.h"
#include "object.h"

namespace StepCore {

class Particle;
class ChargedParticle;

class ParticleErrors: public ObjectErrors
{
    STEPCORE_OBJECT(ParticleErrors)

public:
    ParticleErrors(Item* owner = 0)
        : ObjectErrors(owner), _positionVariance(0,0), _velocityVariance(0,0),
          _forceVariance(0,0), _massVariance(0) {}

    Particle* particle() const;

    const Vector2d& positionVariance() const { return _positionVariance; }
    void setPositionVariance(const Vector2d& positionVariance) {
        _positionVariance = positionVariance; }

    const Vector2d& velocityVariance() const { return _velocityVariance; }
    void setVelocityVariance(const Vector2d& velocityVariance) {
        _velocityVariance = velocityVariance; }

    Vector2d accelerationVariance() const;

    const Vector2d& forceVariance() const { return _forceVariance; }
    void setForceVariance(const Vector2d& forceVariance) {
        _forceVariance = forceVariance; }

    void applyForceVariance(const Vector2d& forceVariance) {
        _forceVariance += forceVariance; }

    double massVariance() const { return _massVariance; }
    void   setMassVariance(double massVariance) {
        _massVariance = massVariance; }

    Vector2d momentumVariance() const;
    void setMomentumVariance(const Vector2d& momentumVariance);

    double kineticEnergyVariance() const;
    void setKineticEnergyVariance(double kineticEnergyVariance);

protected:
    Vector2d _positionVariance;
    Vector2d _velocityVariance;
    Vector2d _forceVariance;
    double _massVariance;
    friend class Particle;
};

class Particle: public Item, public Body
{
    STEPCORE_OBJECT(Particle)

public:
    enum {
        PositionOffset = 0 
    };

    explicit Particle(Vector2d position = Vector2d::Zero(),
            Vector2d velocity = Vector2d::Zero(), double mass = 1);

    const Vector2d& position() const { return _position; }
    void setPosition(const Vector2d& position) { _position = position; }

    const Vector2d& velocity() const { return _velocity; }
    void setVelocity(const Vector2d& velocity) { _velocity = velocity; }

    Vector2d acceleration() const { return _force/_mass; }

    const Vector2d& force() const { return _force; }
    void setForce(const Vector2d& force) { _force = force; }

    void applyForce(const Vector2d& force) { _force += force; }

    double mass() const { return _mass; }
    void   setMass(double mass) { _mass = mass; }

    Vector2d momentum() const { return _velocity * _mass; }
    void setMomentum(const Vector2d& momentum) { _velocity = momentum / _mass; }

    double kineticEnergy() const { return _mass * _velocity.squaredNorm()/2; }
    void setKineticEnergy(double kineticEnergy);

    int  variablesCount() { return 2; }
    void getVariables(double* position, double* velocity,
                          double* positionVariance, double* velocityVariance);
    void setVariables(const double* position, const double* velocity,
              const double* positionVariance, const double* velocityVariance);
    void addForce(const double* force, const double* forceVariance);
    void resetForce(bool resetVariance);
    void getAccelerations(double* acceleration, double* accelerationVariance);
    void getInverseMass(VectorXd* inverseMass,
                        DynSparseRowMatrix* variance, int offset);

    ParticleErrors* particleErrors() {
        return static_cast<ParticleErrors*>(objectErrors()); }

protected:
    ObjectErrors* createObjectErrors() { return new ParticleErrors(this); }

    Vector2d _position;
    Vector2d _velocity;
    Vector2d _force;
    double _mass;
};

class ChargedParticleErrors: public ParticleErrors
{
    STEPCORE_OBJECT(ChargedParticleErrors)

public:
    ChargedParticleErrors(Item* owner = 0)
        : ParticleErrors(owner), _chargeVariance(0) {}

    ChargedParticle* chargedParticle() const;

    double chargeVariance() const { return _chargeVariance; }
    void   setChargeVariance(double chargeVariance) {
        _chargeVariance = chargeVariance; }

protected:
    double _chargeVariance;
    friend class ChargedParticle;
};


class ChargedParticle: public Particle
{
    STEPCORE_OBJECT(ChargedParticle)

public:
    explicit ChargedParticle(Vector2d position = Vector2d::Zero(),
            Vector2d velocity = Vector2d::Zero(), double mass = 1, double charge = 0)
                : Particle(position, velocity, mass), _charge(charge) {}

    double charge() const { return _charge; }
    void setCharge(double charge) { _charge = charge; }

    ChargedParticleErrors* chargedParticleErrors() {
        return static_cast<ChargedParticleErrors*>(objectErrors()); }

protected:
    ObjectErrors* createObjectErrors() { return new ChargedParticleErrors(this); }

    double _charge;
};

} // namespace StepCore

#endif