cell_linked_list.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 MESH_CELL_LINKED_LIST_H
#define MESH_CELL_LINKED_LIST_H

#include "base_mesh.h"
#include "neighbor_relation.h"

namespace SPH
{

    class SPHSystem;
    class SPHBody;
    class BaseParticles;
    class Kernel;
    class SPHAdaptation;
    class CellList
    {
    public:
        ConcurrentIndexVector concurrent_particle_indexes_;
        ListDataVector cell_list_data_;
        IndexVector real_particle_indexes_;

        CellList();
        ~CellList(){};
    };

    class BaseCellLinkedList : public BaseMeshField
    {
    protected:
        RealBody &real_body_;
        Kernel &kernel_;
        BaseParticles *base_particles_;

        virtual void clearSplitCellLists(SplitCellLists &split_cell_lists);
        virtual void updateSplitCellLists(SplitCellLists &split_cell_lists) = 0;

    public:
        BaseCellLinkedList(RealBody &real_body, SPHAdaptation &sph_adaptation);
        virtual ~BaseCellLinkedList(){};

        virtual void assignBaseParticles(BaseParticles *base_particles) = 0;

        virtual void UpdateCellLists() = 0;
        virtual void insertACellLinkedParticleIndex(size_t particle_index, const Vecd &particle_position) = 0;
        virtual void InsertACellLinkedListDataEntry(size_t particle_index, const Vecd &particle_position) = 0;
        virtual ListData findNearestListDataEntry(const Vecd &position) = 0;
        virtual void computingSequence(StdLargeVec<size_t> &sequence) = 0;
        virtual void tagBodyPartByCell(CellLists &cell_lists, std::function<bool(Vecd, Real)> &check_included) = 0;
        virtual void tagBodyDomainBoundingCells(StdVec<CellLists> &cell_lists, BoundingBox &body_domain_bounds, int axis) = 0;
        virtual void tagMirrorBoundingCells(CellLists &cell_lists, BoundingBox &body_domain_bounds, int axis, bool positive) = 0;
    };

    class CellLinkedList : public BaseCellLinkedList, public Mesh
    {
    protected:
        MeshDataMatrix<CellList> cell_linked_lists_;

        virtual void updateSplitCellLists(SplitCellLists &split_cell_lists) override;

    public:
        CellLinkedList(BoundingBox tentative_bounds, Real grid_spacing,
                       RealBody &real_body, SPHAdaptation &sph_adaptation);
        virtual ~CellLinkedList() { deleteMeshDataMatrix(); };

        void allocateMeshDataMatrix(); 
        void deleteMeshDataMatrix();   
        virtual void assignBaseParticles(BaseParticles *base_particles) override;
        void clearCellLists();
        void UpdateCellListData();
        virtual void UpdateCellLists() override;
        void insertACellLinkedParticleIndex(size_t particle_index, const Vecd &particle_position) override;
        void InsertACellLinkedListDataEntry(size_t particle_index, const Vecd &particle_position) override;
        virtual ListData findNearestListDataEntry(const Vecd &position) override;
        virtual void computingSequence(StdLargeVec<size_t> &sequence) override;
        virtual void tagBodyPartByCell(CellLists &cell_lists, std::function<bool(Vecd, Real)> &check_included) override;
        virtual void tagBodyDomainBoundingCells(StdVec<CellLists> &cell_lists, BoundingBox &body_domain_bounds, int axis) override;
        virtual void tagMirrorBoundingCells(CellLists &cell_lists, BoundingBox &body_domain_bounds, int axis, bool positive) override;
        virtual void writeMeshFieldToPlt(std::ofstream &output_file) override;

        template <typename GetParticleIndex, typename GetSearchDepth, typename GetNeighborRelation>
        void searchNeighborsByParticles(size_t total_real_particles, BaseParticles &source_particles,
                                        ParticleConfiguration &particle_configuration, GetParticleIndex &get_particle_index,
                                        GetSearchDepth &get_search_depth, GetNeighborRelation &get_neighbor_relation);

        template <typename GetParticleIndex, typename GetSearchDepth, typename GetNeighborRelation, typename PartParticleCheck>
        void searchNeighborPartsByParticles(size_t total_real_particles, BaseParticles &source_particles,
                                            ParticleConfiguration &particle_configuration, GetParticleIndex &get_particle_index,
                                            GetSearchDepth &get_search_depth, GetNeighborRelation &get_neighbor_relation,
                                            PartParticleCheck &part_check);

        MeshDataMatrix<CellList> getCellLists() const { return cell_linked_lists_; }
    };

    class MultilevelCellLinkedList : public MultilevelMesh<BaseCellLinkedList, CellLinkedList, RefinedMesh<CellLinkedList>>
    {
    protected:
        StdLargeVec<Real> &h_ratio_;
        virtual void updateSplitCellLists(SplitCellLists &split_cell_lists) override{};
        inline size_t getMeshLevel(Real particle_cutoff_radius);

    public:
        MultilevelCellLinkedList(BoundingBox tentative_bounds, Real reference_grid_spacing,
                                 size_t total_levels, RealBody &real_body, SPHAdaptation &sph_adaptation);
        virtual ~MultilevelCellLinkedList(){};

        virtual void assignBaseParticles(BaseParticles *base_particles) override;
        virtual void UpdateCellLists() override;
        void insertACellLinkedParticleIndex(size_t particle_index, const Vecd &particle_position) override;
        void InsertACellLinkedListDataEntry(size_t particle_index, const Vecd &particle_position) override;
        virtual ListData findNearestListDataEntry(const Vecd &position) override { return ListData(0, Vecd(0)); };
        virtual void computingSequence(StdLargeVec<size_t> &sequence) override{};
        virtual void tagBodyPartByCell(CellLists &cell_lists, std::function<bool(Vecd, Real)> &check_included) override;
        virtual void tagBodyDomainBoundingCells(StdVec<CellLists> &cell_lists, BoundingBox &body_domain_bounds, int axis) override{};
        virtual void tagMirrorBoundingCells(CellLists &cell_lists, BoundingBox &body_domain_bounds, int axis, bool positive) override{};
    };
}
#endif // MESH_CELL_LINKED_LIST_H