base_particle_dynamics.h

Go to the documentation of this file.

/* -------------------------------------------------------------------------*
*                               SPHinXsys                                   *
* --------------------------------------------------------------------------*
* SPHinXsys (pronunciation: s'finksis) is an acronym from Smoothed Particle *
* Hydrodynamics for industrial compleX systems. It provides C++ APIs for    *
* physical accurate simulation and aims to model coupled industrial dynamic *
* systems including fluid, solid, multi-body dynamics and beyond with SPH   *
* (smoothed particle hydrodynamics), a meshless computational method using  *
* particle discretization.                                                  *
*                                                                           *
* SPHinXsys is partially funded by German Research Foundation               *
* (Deutsche Forschungsgemeinschaft) DFG HU1527/6-1, HU1527/10-1             *
* and HU1527/12-1.                                                          *
*                                                                           *
* Portions copyright (c) 2017-2020 Technical University of Munich and       *
* the authors' affiliations.                                                *
*                                                                           *
* Licensed under the Apache License, Version 2.0 (the "License"); you may   *
* not use this file except in compliance with the License. You may obtain a *
* copy of the License at http://www.apache.org/licenses/LICENSE-2.0.        *
*                                                                           *
* --------------------------------------------------------------------------*/
#ifndef BASE_PARTICLE_DYNAMICS_H
#define BASE_PARTICLE_DYNAMICS_H

#include "base_data_package.h"
#include "sph_data_containers.h"
#include "neighbor_relation.h"
#include "all_body_relations.h"
#include "base_body.h"

#include <functional>

using namespace std::placeholders;

namespace SPH
{


    typedef std::function<void(size_t, Real)> ParticleFunctor;
    template <class ReturnType>
    using ReduceFunctor = std::function<ReturnType(size_t, Real)>;

    void ParticleIterator(size_t total_real_particles, const ParticleFunctor &particle_functor, Real dt = 0.0);
    void ParticleIterator_parallel(size_t total_real_particles, const ParticleFunctor &particle_functor, Real dt = 0.0);

    template <class ReturnType, typename ReduceOperation>
    ReturnType ReduceIterator(size_t total_real_particles, ReturnType temp,
                              ReduceFunctor<ReturnType> &reduce_functor, ReduceOperation &reduce_operation, Real dt = 0.0);
    template <class ReturnType, typename ReduceOperation>
    ReturnType ReduceIterator_parallel(size_t total_real_particles, ReturnType temp,
                                       ReduceFunctor<ReturnType> &reduce_functor, ReduceOperation &reduce_operation, Real dt = 0.0);

    void ParticleIteratorSplittingSweep(SplitCellLists &split_cell_lists,
                                        const ParticleFunctor &particle_functor, Real dt = 0.0);
    void ParticleIteratorSplittingSweep_parallel(SplitCellLists &split_cell_lists,
                                                 const ParticleFunctor &particle_functor, Real dt = 0.0);

    template <class ReturnType>
    struct ReduceSum
    {
        ReturnType operator()(const ReturnType &x, const ReturnType &y) const { return x + y; };
    };
    struct ReduceMax
    {
        Real operator()(Real x, Real y) const { return SMAX(x, y); };
    };
    struct ReduceMin
    {
        Real operator()(Real x, Real y) const { return SMIN(x, y); };
    };
    struct ReduceOR
    {
        bool operator()(bool x, bool y) const { return x || y; };
    };
    struct ReduceAND
    {
        bool operator()(bool x, bool y) const { return x && y; };
    };
    struct ReduceLowerBound
    {
        Vecd operator()(const Vecd &x, const Vecd &y) const
        {
            Vecd lower_bound;
            for (int i = 0; i < lower_bound.size(); ++i)
                lower_bound[i] = SMIN(x[i], y[i]);
            return lower_bound;
        };
    };
    struct ReduceUpperBound
    {
        Vecd operator()(const Vecd &x, const Vecd &y) const
        {
            Vecd upper_bound;
            for (int i = 0; i < upper_bound.size(); ++i)
                upper_bound[i] = SMAX(x[i], y[i]);
            return upper_bound;
        };
    };

    class GlobalStaticVariables
    {
    public:
        explicit GlobalStaticVariables(){};
        virtual ~GlobalStaticVariables(){};

        static Real physical_time_;
    };

    template <class ReturnType = void>
    class ParticleDynamics : public GlobalStaticVariables
    {
    public:
        explicit ParticleDynamics(SPHBody &sph_body);
        virtual ~ParticleDynamics(){};

        SPHBody *getSPHBody() { return sph_body_; };
        virtual ReturnType exec(Real dt = 0.0) = 0;
        virtual ReturnType parallel_exec(Real dt = 0.0) = 0;

    protected:
        SPHBody *sph_body_;
        SPHAdaptation *sph_adaptation_;
        BaseParticles *base_particles_;

        void setBodyUpdated() { sph_body_->setNewlyUpdated(); };
        virtual void setupDynamics(Real dt = 0.0){};
    };

    class DataDelegateEmptyBase
    {
    public:
        explicit DataDelegateEmptyBase(SPHBody &sph_body){};
        virtual ~DataDelegateEmptyBase(){};
    };

    template <class BodyType = SPHBody,
              class ParticlesType = BaseParticles,
              class MaterialType = BaseMaterial>
    class DataDelegateSimple
    {
    public:
        explicit DataDelegateSimple(SPHBody &sph_body)
            : body_(DynamicCast<BodyType>(this, &sph_body)),
              particles_(DynamicCast<ParticlesType>(this, sph_body.base_particles_)),
              material_(DynamicCast<MaterialType>(this, sph_body.base_material_)),
              sorted_id_(sph_body.base_particles_->sorted_id_),
              unsorted_id_(sph_body.base_particles_->unsorted_id_){};
        virtual ~DataDelegateSimple(){};

        BodyType *getBody() { return body_; };
        ParticlesType *getParticles() { return particles_; };
        MaterialType *getMaterial() { return material_; };

    protected:
        BodyType *body_;
        ParticlesType *particles_;
        MaterialType *material_;
        StdLargeVec<size_t> &sorted_id_;
        StdLargeVec<size_t> &unsorted_id_;
    };

    template <class BodyType = SPHBody,
              class ParticlesType = BaseParticles,
              class MaterialType = BaseMaterial,
              class BaseDataDelegateType = DataDelegateSimple<BodyType, ParticlesType, MaterialType>>
    class DataDelegateInner : public BaseDataDelegateType
    {
    public:
        explicit DataDelegateInner(BaseBodyRelationInner &body_inner_relation)
            : BaseDataDelegateType(*body_inner_relation.sph_body_),
              inner_configuration_(body_inner_relation.inner_configuration_){};
        virtual ~DataDelegateInner(){};

    protected:
        ParticleConfiguration &inner_configuration_;
    };

    template <class BodyType = SPHBody,
              class ParticlesType = BaseParticles,
              class MaterialType = BaseMaterial,
              class ContactBodyType = SPHBody,
              class ContactParticlesType = BaseParticles,
              class ContactMaterialType = BaseMaterial,
              class BaseDataDelegateType = DataDelegateSimple<BodyType, ParticlesType, MaterialType>>
    class DataDelegateContact : public BaseDataDelegateType
    {
    public:
        explicit DataDelegateContact(BaseBodyRelationContact &body_contact_relation);
        virtual ~DataDelegateContact(){};

    protected:
        StdVec<ContactBodyType *> contact_bodies_;
        StdVec<ContactParticlesType *> contact_particles_;
        StdVec<ContactMaterialType *> contact_material_;
        StdVec<ParticleConfiguration *> contact_configuration_;
    };

    template <class BodyType = SPHBody,
              class ParticlesType = BaseParticles,
              class MaterialType = BaseMaterial,
              class ContactBodyType = SPHBody,
              class ContactParticlesType = BaseParticles,
              class ContactMaterialType = BaseMaterial>
    class DataDelegateComplex : public DataDelegateInner<BodyType, ParticlesType, MaterialType>,
                                public DataDelegateContact<BodyType, ParticlesType, MaterialType,
                                                           ContactBodyType, ContactParticlesType, ContactMaterialType, DataDelegateEmptyBase>
    {
    public:
        explicit DataDelegateComplex(ComplexBodyRelation &body_complex_relation)
            : DataDelegateInner<BodyType, ParticlesType, MaterialType>(body_complex_relation.inner_relation_),
              DataDelegateContact<BodyType, ParticlesType, MaterialType, ContactBodyType, ContactParticlesType,
                                  ContactMaterialType, DataDelegateEmptyBase>(body_complex_relation.contact_relation_){};
        virtual ~DataDelegateComplex(){};
    };

    template <class ParticleDynamicsInnerType, class ContactDataType>
    class ParticleDynamicsComplex : public ParticleDynamicsInnerType, public ContactDataType
    {
    public:
        ParticleDynamicsComplex(BaseBodyRelationInner &inner_relation,
                                BaseBodyRelationContact &contact_relation)
            : ParticleDynamicsInnerType(inner_relation), ContactDataType(contact_relation){};

        ParticleDynamicsComplex(ComplexBodyRelation &complex_relation,
                                BaseBodyRelationContact &extra_contact_relation);

        virtual ~ParticleDynamicsComplex(){};

    protected:
        virtual void prepareContactData() = 0;
    };
}
#endif //BASE_PARTICLE_DYNAMICS_H