tfParticle.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of mdcore.
 * Coypright (c) 2010 Pedro Gonnet (pedro.gonnet@durham.ac.uk)
 * Coypright (c) 2017 Andy Somogyi (somogyie at indiana dot edu)
 * Copyright (c) 2022-2024 T.J. Sego
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/

 
#ifndef _MDCORE_INCLUDE_TFPARTICLE_H_
#define _MDCORE_INCLUDE_TFPARTICLE_H_
#include "tf_platform.h"
#include "tf_fptype.h"
#include <state/tfStateVector.h>
#include <types/tf_types.h>
#include "tfSpace_cell.h"
#include "tfAngle.h"
#include "tfBond.h"
#include "tfDihedral.h"
#include "tfParticleList.h"
#include "tfParticleTypeList.h"
#include <set>
#include <vector>

#define CLUSTER_PARTLIST_INCR 50
 
 
namespace TissueForge { 
 
 
    namespace rendering {
        struct Style;
    }
 
 
    typedef enum ParticleTypeFlags {
        PARTICLE_TYPE_NONE          = 0,
        PARTICLE_TYPE_INERTIAL      = 1 << 0,
        PARTICLE_TYPE_DISSAPATIVE   = 1 << 1,
    } ParticleTypeFlags;
 
    typedef enum ParticleDynamics {
        PARTICLE_NEWTONIAN          = 0,
        PARTICLE_OVERDAMPED         = 1,
    } ParticleDynamics;
 
    /* particle flags */
    typedef enum ParticleFlags {
        PARTICLE_NONE          = 0,
        PARTICLE_GHOST         = 1 << 0,
        PARTICLE_CLUSTER       = 1 << 1,
        PARTICLE_BOUND         = 1 << 2,
        PARTICLE_FROZEN_X      = 1 << 3,
        PARTICLE_FROZEN_Y      = 1 << 4,
        PARTICLE_FROZEN_Z      = 1 << 5,
        PARTICLE_FROZEN        = PARTICLE_FROZEN_X | PARTICLE_FROZEN_Y | PARTICLE_FROZEN_Z,
        PARTICLE_LARGE         = 1 << 6,
    } ParticleFlags;
 

    // CAPI_DATA(int) particle_err;
 
    struct Cluster;
    struct ClusterParticleHandle;

    struct CAPI_EXPORT Particle  {
        
        union {
            TF_ALIGNED(FPTYPE, 16) f[4];
            TF_ALIGNED(FVector3, 16) force;
            
            struct {
                FPTYPE __dummy0[3];
                FPTYPE number_density;
            };
        };
        
        union {
            TF_ALIGNED(FVector3, 16) force_i;
        };
 

        union {
            TF_ALIGNED(FPTYPE, 16) v[4];
            TF_ALIGNED(FVector3, 16) velocity;
            
            struct {
                FPTYPE __dummy1[3];
                FPTYPE inv_number_density;
            };
        };
 
        
        union {
            TF_ALIGNED(FPTYPE, 16) x[4];
            TF_ALIGNED(FVector3, 16) position;
 
            struct {
                FPTYPE __dummy2[3];
                uint32_t creation_time;
            };
        };
        

        union {
            TF_ALIGNED(FVector3, 16) persistent_force;
        };

        FPTYPE imass;

        FPTYPE radius;

        FPTYPE mass;

        FPTYPE q;
 
        // runge-kutta k intermediates.
        FVector3 p0;
        FVector3 v0;
        FVector3 xk[4];
        FVector3 vk[4];

        int id, vid;

        int16_t typeId;

        int32_t clusterId;

        uint16_t flags;

        struct ParticleHandle *_handle;

        struct ParticleHandle *handle();

        int32_t *parts;

        uint16_t nr_parts;

        uint16_t size_parts;

        HRESULT addpart(int32_t uid);

        HRESULT removepart(int32_t uid);

        Particle *particle(int i);

        rendering::Style *style;

        struct state::StateVector *state_vector;

        FVector3 global_position();

        void set_global_position(const FVector3& pos);
        
        bool verify();
 
        
        operator Cluster*();
        
        Particle();

        std::string toString();

        static Particle *fromString(const std::string &str);
    };

    HRESULT Particle_Verify();
 
    #ifndef NDEBUG
    #define VERIFY_PARTICLES() Particle_Verify()
    #else
    #define VERIFY_PARTICLES()
    #endif
 

    struct CAPI_EXPORT ParticleHandle {
        int id;

        Particle *part();

        Particle *get() { return part(); }

        ParticleType *type();
 
        ParticleHandle() : id(0) {}
        ParticleHandle(const int &id) : id(id) {}
 
        virtual std::string str() const;
 
        virtual ParticleHandle* fission();

        virtual ParticleHandle* split();

        virtual ParticleHandle* split(const FVector3& childDirection);

        virtual ParticleHandle* split(const FPTYPE& childRatio);

        virtual ParticleHandle* split(const std::vector<FPTYPE>& speciesRatios);

        virtual ParticleHandle* split(
            const FVector3& childDirection,
            const FPTYPE& childRatio,
            ParticleType* parentType=NULL,
            ParticleType* childType=NULL
        );

        virtual ParticleHandle* split(
            const FVector3& childDirection,
            const FPTYPE& childRatio,
            const std::vector<FPTYPE>& speciesRatios,
            ParticleType* parentType=NULL,
            ParticleType* childType=NULL
        );

        HRESULT destroy();

        FVector3 sphericalPosition(Particle *particle=NULL, FVector3 *origin=NULL);

        FVector3 relativePosition(const FVector3 &origin, const bool &comp_bc=true);

        virtual FMatrix3 virial(FPTYPE *radius=NULL);

        HRESULT become(ParticleType *type);

        ParticleList neighbors(const FPTYPE &distance, const TissueForge::ParticleTypeList &types);

        ParticleList neighbors(const FPTYPE &distance, const std::vector<ParticleType> &types);

        ParticleList neighbors(const FPTYPE &distance);

        ParticleList neighbors(const TissueForge::ParticleTypeList &types);

        ParticleList neighbors(const std::vector<ParticleType> &types);

        std::vector<int32_t> neighborIds(const FPTYPE &distance, const TissueForge::ParticleTypeList &types);

        std::vector<int32_t> neighborIds(const FPTYPE &distance, const std::vector<ParticleType> &types);

        std::vector<int32_t> neighborIds(const FPTYPE &distance=-FPTYPE_ONE);

        std::vector<int32_t> neighborIds(const TissueForge::ParticleTypeList &types);

        std::vector<int32_t> neighborIds(const std::vector<ParticleType> &types);

        ParticleList getBondedNeighbors();

        std::vector<int32_t> getBondedNeighborIds();

        FPTYPE distance(ParticleHandle *_other);

        std::vector<struct TissueForge::BondHandle> getBonds();

        std::vector<struct TissueForge::AngleHandle> getAngles();

        std::vector<struct TissueForge::DihedralHandle> getDihedrals();

        FPTYPE getCharge();

        void setCharge(const FPTYPE &charge);

        FPTYPE getMass();
        
        void setMass(const FPTYPE &mass);
        
        bool getFrozen();
        
        void setFrozen(const bool frozen);
        
        bool getFrozenX();
        
        void setFrozenX(const bool frozen);
        
        bool getFrozenY();
        
        void setFrozenY(const bool frozen);
        
        bool getFrozenZ();
        
        void setFrozenZ(const bool frozen);
        
        rendering::Style *getStyle();
        
        void setStyle(rendering::Style *style);
        
        FPTYPE getAge();
        
        FPTYPE getRadius();
        
        void setRadius(const FPTYPE &radius);

        FPTYPE getVolume();
        
        std::string getName();
        
        std::string getName2();
        
        FVector3 getPosition();
        
        void setPosition(FVector3 position);
        
        FVector3 &getVelocity();
        
        void setVelocity(FVector3 velocity);
        
        FVector3 getForce();
        
        FVector3 &getForceInit();
        
        void setForceInit(FVector3 force);
        
        int getId();
        
        int16_t getTypeId();
        
        int32_t getClusterId();
        
        uint16_t getFlags();
        
        state::StateVector *getSpecies();

        operator ClusterParticleHandle*();
    };

    struct CAPI_EXPORT ParticleType {
 
        static const int MAX_NAME = 64;

        int16_t id;

        uint32_t type_flags;

        uint16_t particle_flags;

        FPTYPE mass;
        
        FPTYPE imass;
        
        FPTYPE charge;

        FPTYPE radius;

        FPTYPE kinetic_energy;

        FPTYPE potential_energy;

        FPTYPE target_energy;

        FPTYPE minimum_radius;

        FPTYPE eps, rmin;

        unsigned char dynamics;

        char name[MAX_NAME];
        
        char name2[MAX_NAME];

        TissueForge::ParticleList parts;

        TissueForge::ParticleTypeList types;

        rendering::Style *style;

        struct state::SpeciesList *species = 0;

        HRESULT addpart(int32_t id);

        HRESULT del_part(int32_t id);

        TissueForge::Particle *particle(int i);

        static std::set<short int> particleTypeIds();

        bool isCluster();

        operator TissueForge::ClusterParticleType*();

        TissueForge::ParticleHandle *operator()(
            FVector3 *position=NULL,
            FVector3 *velocity=NULL,
            int *clusterId=NULL
        );
        
        TissueForge::ParticleHandle *operator()(const std::string &str, int *clusterId=NULL);

        std::vector<int> factory(
            unsigned int nr_parts=0, 
            std::vector<FVector3> *positions=NULL, 
            std::vector<FVector3> *velocities=NULL, 
            std::vector<int> *clusterIds=NULL
        );

        ParticleType* newType(const char *_name);

        bool has(const int32_t &pid);

        bool has(ParticleHandle *part);

        virtual HRESULT registerType();

        virtual void on_register() {}

        bool isRegistered();

        virtual ParticleType *get();
 
        ParticleType(const bool &noReg=false);
        virtual ~ParticleType() {}
 
        virtual std::string str() const;

        FPTYPE getVolume();

        bool getFrozen();
        
        void setFrozen(const bool &frozen);
        
        bool getFrozenX();
        
        void setFrozenX(const bool &frozen);
        
        bool getFrozenY();
        
        void setFrozenY(const bool &frozen);
        
        bool getFrozenZ();
        
        void setFrozenZ(const bool &frozen);
        
        FPTYPE getTemperature();
        
        FPTYPE getTargetTemperature();
        
        void setTargetTemperature(const FPTYPE &temperature);

        TissueForge::ParticleList &items();

        uint16_t getNumParts();

        std::vector<int32_t> getPartIds();

        std::string toString();

        static ParticleType *fromString(const std::string &str);
    };
 
    CAPI_FUNC(ParticleType*) Particle_GetType();
 
    CAPI_FUNC(ParticleType*) Cluster_GetType();

    ParticleType *ParticleType_ForEngine(
        struct engine *e, 
        FPTYPE mass, 
        FPTYPE charge,
        const char *name, 
        const char *name2
    );

    ParticleType* ParticleType_New(const char *_name);

    CAPI_FUNC(ParticleType*) ParticleType_FindFromName(const char* name);

    CAPI_FUNC(Particle*) Particle_Get(ParticleHandle *pypart);
 
 
    ParticleHandle* Particle_split(
        Particle* self,
        const FVector3& childDirection,
        const FPTYPE& childRatio,
        const std::vector<FPTYPE>* speciesRatios=NULL,
        ParticleType* parentType=NULL,
        ParticleType* childType=NULL
    );
 
    CAPI_FUNC(ParticleHandle*) Particle_New(
        ParticleType *type, 
        FVector3 *positn=NULL,
        FVector3 *velocity=NULL,
        int *clusterId=NULL
    );
 
    std::vector<int> Particles_New(
        std::vector<ParticleType*> types, 
        std::vector<FVector3> *positions=NULL, 
        std::vector<FVector3> *velocities=NULL, 
        std::vector<int> *clusterIds=NULL
    );
 
    std::vector<int> Particles_New(
        ParticleType *type, 
        unsigned int nr_parts=0, 
        std::vector<FVector3> *positions=NULL, 
        std::vector<FVector3> *velocities=NULL, 
        std::vector<int> *clusterIds=NULL
    );

    CAPI_FUNC(HRESULT) Particle_Become(Particle *part, ParticleType *type);

    CAPI_DATA(unsigned int) *Particle_Colors;
 
    // Returns 1 if a type has been registered, otherwise 0
    CAPI_FUNC(bool) ParticleType_checkRegistered(ParticleType *type);

    HRESULT _Particle_init();
 
    inline bool operator< (const TissueForge::ParticleHandle& lhs, const TissueForge::ParticleHandle& rhs) { return lhs.id < rhs.id; }
    inline bool operator> (const TissueForge::ParticleHandle& lhs, const TissueForge::ParticleHandle& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::ParticleHandle& lhs, const TissueForge::ParticleHandle& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::ParticleHandle& lhs, const TissueForge::ParticleHandle& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::ParticleHandle& lhs, const TissueForge::ParticleHandle& rhs) { return lhs.id == rhs.id; }
    inline bool operator!=(const TissueForge::ParticleHandle& lhs, const TissueForge::ParticleHandle& rhs) { return !(lhs == rhs); }
 
    inline bool operator< (const TissueForge::ParticleType& lhs, const TissueForge::ParticleType& rhs) { return lhs.id < rhs.id; }
    inline bool operator> (const TissueForge::ParticleType& lhs, const TissueForge::ParticleType& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::ParticleType& lhs, const TissueForge::ParticleType& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::ParticleType& lhs, const TissueForge::ParticleType& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::ParticleType& lhs, const TissueForge::ParticleType& rhs) { return lhs.id == rhs.id; }
    inline bool operator!=(const TissueForge::ParticleType& lhs, const TissueForge::ParticleType& rhs) { return !(lhs == rhs); }
 
 
};
 
 
inline std::ostream &operator<<(std::ostream& os, const TissueForge::ParticleHandle &p)
{
    os << p.str().c_str();
    return os;
}
 
inline std::ostream &operator<<(std::ostream& os, const TissueForge::ParticleType &p)
{
    os << p.str().c_str();
    return os;
}
 
#endif // _MDCORE_INCLUDE_TFPARTICLE_H_