fluid_boundary.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 FLUID_BOUNDARY_H
#define FLUID_BOUNDARY_H

#include "fluid_dynamics_inner.h"

namespace SPH
{
    namespace fluid_dynamics
    {
        class FlowRelaxationBuffer : public PartDynamicsByCell, public FluidDataSimple
        {
        public:
            FlowRelaxationBuffer(FluidBody &fluid_body, BodyPartByCell &body_part);
            virtual ~FlowRelaxationBuffer(){};

        protected:
            StdLargeVec<Vecd> &pos_, &vel_;
            Real relaxation_rate_;

            virtual Vecd getTargetVelocity(Vecd &position, Vecd &velocity) = 0;
            virtual void Update(size_t index_i, Real dt = 0.0) override;
        };

        class InflowBoundaryCondition : public FlowRelaxationBuffer
        {
        public:
            InflowBoundaryCondition(FluidBody &fluid_body, BodyAlignedBoxByCell &aligned_box_part);
            virtual ~InflowBoundaryCondition(){};

        protected:
            Transformd &transform_;
            Vecd halfsize_;

            virtual void Update(size_t index_i, Real dt = 0.0) override;
        };

        class DampingBoundaryCondition : public PartDynamicsByCell, public FluidDataSimple
        {
        public:
            DampingBoundaryCondition(FluidBody &fluid_body, BodyRegionByCell &body_part);
            virtual ~DampingBoundaryCondition(){};

        protected:
            StdLargeVec<Vecd> &pos_, &vel_;
            Real strength_;
            BoundingBox damping_zone_bounds_;
            virtual void Update(size_t index_particle_i, Real dt = 0.0) override;
        };

        class EmitterInflowCondition : public PartSimpleDynamicsByParticle, public FluidDataSimple
        {
        public:
            explicit EmitterInflowCondition(FluidBody &fluid_body, BodyAlignedBoxByParticle &aligned_box_part);
            virtual ~EmitterInflowCondition(){};

        protected:
            StdLargeVec<Vecd> &pos_, &vel_;
            StdLargeVec<Real> &rho_, &p_;
            Real inflow_pressure_;
            Real rho0_;
            AlignedBoxShape &aligned_box_;
            Transformd &updated_transform_, old_transform_;

            virtual void updateTransform(){};
            virtual Vecd getTargetVelocity(Vecd &position, Vecd &velocity) = 0;
            virtual void setupDynamics(Real dt = 0.0) override { updateTransform(); };
            virtual void Update(size_t unsorted_index_i, Real dt = 0.0) override;
        };

        class EmitterInflowInjecting : public PartSimpleDynamicsByParticle, public FluidDataSimple
        {
        public:
            explicit EmitterInflowInjecting(FluidBody &fluid_body, BodyAlignedBoxByParticle &aligned_box_part,
                                            size_t body_buffer_width, int axis_direction, bool positive);
            virtual ~EmitterInflowInjecting(){};

            virtual void parallel_exec(Real dt = 0.0) override { exec(); };
            AlignedBoxShape &getBodyPartByParticle(){};

        protected:
            StdLargeVec<Vecd> &pos_;
            StdLargeVec<Real> &rho_, &p_;
            const int axis_; 
            size_t body_buffer_width_;
            AlignedBoxShape &aligned_box_;

            virtual void checkLowerBound(size_t unsorted_index_i, Real dt = 0.0);
            virtual void checkUpperBound(size_t unsorted_index_i, Real dt = 0.0);
            ParticleFunctor checking_bound_;

            virtual void Update(size_t unsorted_index_i, Real dt = 0.0) override
            {
                checking_bound_(unsorted_index_i, dt);
            };
        };

        class StaticConfinementDensity : public PartDynamicsByCell, public FluidDataSimple
        {
        public:
            StaticConfinementDensity(FluidBody &fluid_body, NearShapeSurface &near_surface);
            virtual ~StaticConfinementDensity(){};

        protected:
            Real rho0_, inv_sigma0_;
            StdLargeVec<Real> &mass_, &rho_sum_;
            StdLargeVec<Vecd> &pos_;
            LevelSetShape *level_set_shape_;

            virtual void Update(size_t index_i, Real dt = 0.0) override;
        };

        class StaticConfinementPressureRelaxation : public PartDynamicsByCell, public FluidDataSimple
        {
        public:
            StaticConfinementPressureRelaxation(FluidBody &fluid_body, NearShapeSurface &near_surface);
            virtual ~StaticConfinementPressureRelaxation(){};

        protected:
            StdLargeVec<Real> &rho_, &p_;
            StdLargeVec<Vecd> &pos_, &vel_, &acc_;
            LevelSetShape *level_set_shape_;
            AcousticRiemannSolver riemann_solver_;

            virtual void Update(size_t index_i, Real dt = 0.0) override;
        };

        class StaticConfinementDensityRelaxation : public PartDynamicsByCell, public FluidDataSimple
        {
        public:
            StaticConfinementDensityRelaxation(FluidBody &fluid_body, NearShapeSurface &near_surface);
            virtual ~StaticConfinementDensityRelaxation(){};

        protected:
            StdLargeVec<Real> &rho_, &p_, &drho_dt_;
            StdLargeVec<Vecd> &pos_, &vel_;
            LevelSetShape *level_set_shape_;
            AcousticRiemannSolver riemann_solver_;

            virtual void Update(size_t index_i, Real dt = 0.0) override;
        };

        class StaticConfinement
        {
        public:
            StaticConfinementDensity density_summation_;
            StaticConfinementPressureRelaxation pressure_relaxation_;
            StaticConfinementDensityRelaxation density_relaxation_;

            StaticConfinement(FluidBody &fluid_body, NearShapeSurface &near_surface);
            virtual ~StaticConfinement(){};
        };

    }
}
#endif // FLUID_BOUNDARY_H