base_particles.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_PARTICLES_H
#define BASE_PARTICLES_H

#include "base_data_package.h"
#include "sph_data_containers.h"
#include "base_material.h"
#include "xml_engine.h"

#include <fstream>

namespace SPH
{

    class SPHBody;
    class BaseMaterial;
    class ParticleGenerator;
    class BodySurface;
    template <class ReturnType>
    class ParticleDynamics;

    class BaseParticles
    {
    private:
        UniquePtrKeepers<ParticleDynamics<void>> derived_particle_data_;

    public:
        explicit BaseParticles(SPHBody &sph_body, BaseMaterial *base_material);
        virtual ~BaseParticles(){};

        StdLargeVec<Vecd> pos_;       
        StdLargeVec<Vecd> vel_;       
        StdLargeVec<Vecd> acc_;       
        StdLargeVec<Vecd> acc_prior_; 
        StdLargeVec<Real> Vol_;  
        StdLargeVec<Real> rho_;  
        StdLargeVec<Real> mass_; 
        //----------------------------------------------------------------------
        // Global information for all particles
        //----------------------------------------------------------------------
        Real rho0_;             
        Real sigma0_;           
        Real speed_max_;        
        Real signal_speed_max_; 
        //----------------------------------------------------------------------
        // Global information for defining particle groups
        //----------------------------------------------------------------------
        size_t total_real_particles_;
        size_t real_particles_bound_; 
        size_t total_ghost_particles_;
        //----------------------------------------------------------------------
        //      Generalized particle data for parameterized management
        //----------------------------------------------------------------------
        ParticleData all_particle_data_;
        ParticleDataMap all_variable_maps_;
        StdVec<ParticleDynamics<void> *> derived_variables_;
        ParticleVariableList variables_to_write_;

        template <typename VariableType>
        void registerVariable(StdLargeVec<VariableType> &variable_addrs,
                              const std::string &variable_name, VariableType initial_value = VariableType(0));

        template <typename VariableType, class InitializationFunction>
        void registerVariable(StdLargeVec<VariableType> &variable_addrs, const std::string &variable_name,
                              const InitializationFunction &initialization);

        template <typename VariableType>
        StdLargeVec<VariableType> *getVariableByName(const std::string &variable_name);

        template <typename VariableType>
        void addVariableNameToList(ParticleVariableList &variable_name_list, const std::string &variable_name);

        template <typename VariableType>
        void addVariableToWrite(const std::string &variable_name);

        template <class DerivedVariableMethod>
        void addDerivedVariableToWrite();

        template <typename VariableType>
        void addVariableToRestart(const std::string &variable_name);

        template <typename VariableType>
        void addVariableToReload(const std::string &variable_name);

        //----------------------------------------------------------------------
        //      Particle data for sorting
        //----------------------------------------------------------------------
        StdLargeVec<size_t> unsorted_id_; 
        StdLargeVec<size_t> sorted_id_;   
        StdLargeVec<size_t> sequence_;    
        ParticleData sortable_data_;
        ParticleDataMap sortable_variable_maps_;

        template <typename VariableType>
        void registerSortableVariable(const std::string &variable_name);

        SPHBody *getSPHBody() { return sph_body_; };
        virtual void initializeOtherVariables();
        void addBufferParticles(size_t buffer_size);
        void copyFromAnotherParticle(size_t this_index, size_t another_index);
        void updateFromAnotherParticle(size_t this_index, size_t another_index);
        size_t insertAGhostParticle(size_t index_i);
        void switchToBufferParticle(size_t index_i);

        template <typename OutStreamType>
        void writeParticlesToVtk(OutStreamType &output_stream);
        void writeParticlesToPltFile(std::ofstream &output_file);
        virtual void writeSurfaceParticlesToVtuFile(std::ostream &output_file, BodySurface &surface_particles);

        void resizeXmlDocForParticles(XmlEngine &xml_engine);
        void writeParticlesToXmlForRestart(std::string &filefullpath);
        void readParticleFromXmlForRestart(std::string &filefullpath);
        XmlEngine *getReloadXmlEngine() { return &reload_xml_engine_; };
        void writeToXmlForReloadParticle(std::string &filefullpath);
        void readFromXmlForReloadParticle(std::string &filefullpath);

        virtual BaseParticles *ThisObjectPtr() { return this; };

        virtual Vecd getKernelGradient(size_t index_i, size_t index_j, Real dW_ij, Vecd &e_ij)
        {
            return dW_ij * e_ij;
        };

        virtual Vecd ParticleTotalAcceleration(size_t index_i) { return acc_[index_i] + acc_prior_[index_i]; }
        virtual Real ParticleVolume(size_t index_i) { return Vol_[index_i]; }
        virtual Real ParticleMass(size_t index_i) { return mass_[index_i]; }

    protected:
        SPHBody *sph_body_; 
        std::string body_name_;
        XmlEngine restart_xml_engine_;
        XmlEngine reload_xml_engine_;
        ParticleVariableList variables_to_restart_;
        ParticleVariableList variables_to_reload_;
        void addAParticleEntry();

        virtual void writePltFileHeader(std::ofstream &output_file);
        virtual void writePltFileParticleData(std::ofstream &output_file, size_t index_i);

        template <typename VariableType>
        struct resizeParticleData
        {
            void operator()(ParticleData &particle_data, size_t new_size) const;
        };

        template <typename VariableType>
        struct addAParticleDataValue
        {
            void operator()(ParticleData &particle_data) const;
        };

        template <typename VariableType>
        struct copyAParticleDataValue
        {
            void operator()(ParticleData &particle_data, size_t this_index, size_t another_index) const;
        };

        DataAssembleOperation<resizeParticleData> resize_particle_data_;
        DataAssembleOperation<addAParticleDataValue> add_a_particle_value_;
        DataAssembleOperation<copyAParticleDataValue> copy_a_particle_value_;
    };

    struct WriteAParticleVariableToXml
    {
        XmlEngine &xml_engine_;
        size_t &total_real_particles_;
        WriteAParticleVariableToXml(XmlEngine &xml_engine, size_t &total_real_particles)
            : xml_engine_(xml_engine), total_real_particles_(total_real_particles){};

        template <typename VariableType>
        void operator()(std::string &variable_name, StdLargeVec<VariableType> &variable) const;
    };

    struct ReadAParticleVariableFromXml
    {
        XmlEngine &xml_engine_;
        size_t &total_real_particles_;
        ReadAParticleVariableFromXml(XmlEngine &xml_engine, size_t &total_real_particles)
            : xml_engine_(xml_engine), total_real_particles_(total_real_particles){};

        template <typename VariableType>
        void operator()(std::string &variable_name, StdLargeVec<VariableType> &variable) const;
    };

    template <typename VariableType>
    class BaseDerivedVariable
    {
    public:
        using DerivedVariableType = VariableType;
        std::string variable_name_;

        BaseDerivedVariable(const SPHBody &sph_body, const std::string &variable_name);
        virtual ~BaseDerivedVariable(){};

    protected:
        StdLargeVec<VariableType> derived_variable_;
    };
}
#endif // BASE_PARTICLES_H