BaseParticle.h

Go to the documentation of this file.

//Copyright (c) 2013-2014, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef BASEPARTICLE_H
#define BASEPARTICLE_H

#include <vector>
#include <iostream>
#include "../ExtendedMath.h"
#include "../Vector.h"

class ParticleHandler;
class HGrid;
class CSpecies;

#ifdef ContactListHgrid
    class PossibleContact;
#endif

class BaseParticle
{
public:
    BaseParticle();
    
    BaseParticle(const BaseParticle &p);
    
    virtual ~BaseParticle();
    
    virtual BaseParticle* copy() const;

    Mdouble get_Volume(std::vector<CSpecies>& Species) const;
    
    void fixParticle();
    
    bool isFixed();
    
    void unfix(std::vector<CSpecies>& Species);
    
    void compute_particle_mass(std::vector<CSpecies>& Species);

    friend inline std::ostream& operator<<(std::ostream& os, const BaseParticle &b);
    
    friend inline std::istream& operator>>(std::istream& is, BaseParticle &b);
    
    virtual void read(std::istream& is);
    
    virtual void print(std::ostream& os) const;
    
    virtual void moveInHandler(int newPos);
    
    void print_HGRID(std::ostream& os);
    
    int              get_HGRID_Level() const;
    BaseParticle*        get_HGRID_NextObject() const;
    BaseParticle*        get_HGRID_PrevObject() const;
#ifdef ContactListHgrid
    PossibleContact* get_FirstPossibleContact() const;
#endif
    int              get_HGRID_x() const;
    int              get_HGRID_y() const;
    int              get_HGRID_z() const;
    int              get_Index()     const;
    Mdouble          get_Inertia() const;
    Mdouble          get_InvInertia() const;
    Mdouble          get_InvMass() const;
    Mdouble          get_KineticEnergy() const;
    Mdouble          get_Mass() const;
    BaseParticle*    get_PeriodicFromParticle() const;
    const Vec3D&     get_Position() const;
    Mdouble          get_Radius() const;
    Mdouble          get_InteractionRadius() const;
    Mdouble          get_WallInteractionRadius() const;
    int              get_Species() const;
    int              get_IndSpecies() const;
    int              get_Id() const;
    const Vec3D&     get_Velocity() const;
    const Vec3D&     get_Angle() const;
    const Vec3D&     get_AngularVelocity() const; 
    const Vec3D&     get_Force() const;
    const Vec3D&     get_Torque() const;
    const Vec3D&     get_Displacement() const;
    const Vec3D&     get_PreviousPosition() const;
    ParticleHandler* getHandler() const;
    const Vec3D      get_Displacement2 (Mdouble xmin, Mdouble xmax, Mdouble ymin, Mdouble ymax, Mdouble zmin, Mdouble zmax, Mdouble t) const;
    
    void set_inertia                    (const Mdouble _new);
    void set_infiniteInertia            ();
    void set_periodicFromParticle       (BaseParticle* _new);
    void set_species                    (const int _new);
    void set_Index                      (const int _new);
    void set_HGRID_x                    (const int _new);
    void set_HGRID_y                    (const int _new);
    void set_HGRID_z                    (const int _new);
    void set_HGRID_Level                (const int _new);
    void set_HGRID_NextObject           (BaseParticle* _new);
    void set_HGRID_PrevObject           (BaseParticle* _new);
#ifdef ContactListHgrid
    void set_FirstPossibleContact       (const PossibleContact* PC);
#endif
    void set_Radius                     (const Mdouble _new);
    void set_IndSpecies                 (const int _new);
    void set_Id                         (const int _new);
    void set_Mass                       (const Mdouble _new);
    void set_Velocity                   (const Vec3D& _new);
    void set_Position                   (const Vec3D& _new);
    void set_Displacement               (const Vec3D& _new);
    void set_PreviousPosition           (const Vec3D& _new);
    void set_Angle                      (const Vec3D& _new);
    void set_AngularVelocity            (const Vec3D& _new);
    void set_Force                      (const Vec3D& _new);
    void set_Torque                     (const Vec3D& _new);
    
    void setHandler                    (ParticleHandler* handler);
    
    void move                           (const Vec3D& _new);
    void movePrevious                   (const Vec3D& _new);
    void accelerate                     (const Vec3D& _new);
    void rotate                         (const Vec3D& _new);
    void angularAccelerate              (const Vec3D& _new);
    void add_Displacement               (const Vec3D& _new);
    void add_Force                      (const Vec3D& _new);
    void add_Torque                     (const Vec3D& _new);

#ifdef USE_SIMPLE_VERLET_INTEGRATION
    void set_PrevPosition               (const Vec3D& _new);
    void prevMove                       (const Vec3D& _new);
    const Vec3D&    get_PrevPosition();
#endif
    
private:
#ifdef ContactListHgrid
    PossibleContact* firstPossibleContact;
#endif

    ParticleHandler* handler;
    //HGrid* hGrid;

    int HGRID_x, HGRID_y, HGRID_z;              
    int HGRID_Level;                            
    BaseParticle* HGRID_NextObject;                 
    BaseParticle* HGRID_PrevObject;                 
    
    int _index;                                  
    Mdouble mass;                               
    Mdouble invMass;                            
    Mdouble inertia;                            
    Mdouble invInertia;                         
    Mdouble radius;                             
    BaseParticle * periodicFromParticle;        
    int indSpecies;                             
    int _id;                                     
    
    Vec3D angle;                                
    Vec3D angularVelocity;                      
    Vec3D position;                             
    Vec3D velocity;                             

    Vec3D force;                                
    Vec3D torque;                               

    Vec3D displacement;                         
    Vec3D previousPosition;
#ifdef USE_SIMPLE_VERLET_INTEGRATION
    Vec3D prevPosition;                         
#endif 
};

inline std::ostream& operator<<(std::ostream& os, const BaseParticle &p)
{
    p.print(os);
    return os;
}

inline std::istream& operator>>(std::istream& is, BaseParticle &p)
{
    p.read(is);
    return(is);
}

#endif