base_particle_generator.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_GENERATOR_H
#define BASE_PARTICLE_GENERATOR_H

#include "base_data_package.h"
#include "sph_data_containers.h"
#include "large_data_containers.h"

namespace SPH
{

    class SPHBody;
    class BaseParticles;
    class InOutput;

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

        virtual void initializeGeometricVariables() = 0;

    protected:
        BaseParticles *base_particles_;
        StdLargeVec<Vecd> &pos_;           
        StdLargeVec<size_t> &unsorted_id_; 
        virtual void initializePosition(const Vecd &position);
    };

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

    protected:
        StdLargeVec<Real> &Vol_; 
        virtual void initializePositionAndVolumetricMeasure(const Vecd &position, Real volumetric_measure);
    };

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

    protected:
        StdLargeVec<Vecd> &n_;         
        StdLargeVec<Real> &thickness_; 
        virtual void initializeSurfaceProperties(const Vecd &surface_normal, Real thickness);
    };

    class ObserverParticleGenerator : public ParticleGenerator
    {
    public:
        explicit ObserverParticleGenerator(SPHBody &sph_body)
            : ParticleGenerator(sph_body){};
        ObserverParticleGenerator(SPHBody &sph_body, const StdVec<Vecd> &positions)
            : ParticleGenerator(sph_body), positions_(positions){};
        virtual ~ObserverParticleGenerator(){};

        virtual void initializeGeometricVariables() override;

    protected:
        StdVec<Vecd> positions_;
    };

    class ParticleGeneratorReload : public ParticleGenerator
    {
        std::string file_path_;

    public:
        ParticleGeneratorReload(SPHBody &sph_body, InOutput &in_output, const std::string &reload_body_name);
        virtual ~ParticleGeneratorReload(){};
        virtual void initializeGeometricVariables() override;
    };
}
#endif // BASE_PARTICLE_GENERATOR_H