Delaunay.hpp

Go to the documentation of this file.

#ifndef DELAUNAY_HPP
#define DELAUNAY_HPP 1
#include "facet.hpp"
#include <algorithm>
#include <vector>
#include <stack>
#include <climits>
#include "geometry.hpp"
#include "../misc/universal_error.hpp"
#include "HilbertOrder.hpp"
#include "geotests.hpp"
#include "../misc/utils.hpp"
#include "delaunay_logger.hpp"
#include "Edge.hpp"
#include "../newtonian/two_dimensional/OuterBoundary.hpp"
#include "shape_2d.hpp"
#include "../misc/int2str.hpp"
#include "../newtonian/two_dimensional/diagnostics.hpp"
#ifdef RICH_MPI
#include "find_affected_cells.hpp"
#endif

class Delaunay
{
private:
#ifdef RICH_MPI
        int findSomeOuterPoint(void);

        pair<vector<vector<int> >, vector<vector<int> > > findOuterPoints(const Tessellation& t_proc,
                const vector<Edge>& edge_list, const vector<Edge>& box_edges, vector<vector<int> > &NghostIndex, bool periodic,
                std::vector<int> &cpu_neigh, std::vector<Vector2D> &periodic_add_self, std::vector<std::vector<Vector2D> >
                &periodic_add_others, Vector2D const &ll, Vector2D const &ur);

        std::pair<vector<vector<int> >, vector<int> > FindOuterPoints2
        (const Tessellation& t_proc,
                const vector<Edge>& edge_list,
                vector<vector<int> > &to_duplicate,
                vector<vector<int> >& self_points,
                const vector<Edge>& box_edges,
                vector<vector<int> > &NghostIndex,
                bool periodic,
                std::vector<int> &cpu_neigh, std::vector<Vector2D> &periodic_add_self, std::vector<std::vector<Vector2D> >
                &periodic_add_others, Vector2D const &ll, Vector2D const &ur);

        vector<vector<int> > boundary_intersection_check
        (const vector<Edge>& edges,
                const vector<vector<int> >& to_duplicate);
#endif // RICH_MPI

        enum Sides { RIGHT, UP, LEFT, DOWN, LU, LD, RU, RD };
        int lastFacet; //last facet to be checked in Walk
        bool CalcRadius;

        class DataOnlyForBuild
        {
        public:
                DataOnlyForBuild();
                DataOnlyForBuild(DataOnlyForBuild const& other);
                DataOnlyForBuild& operator=(DataOnlyForBuild const& other);
                vector<vector<char> > copied;
        };

        vector<double> radius;
        bool PointWasAdded;
        int last_facet_added;
        vector<facet> f;
        vector<Vector2D> cor;
        int length;
        size_t olength;
        int location_pointer;
        int last_loc;
        vector<int> OrgIndex;

        bool IsOuterFacet(int facet)const;
        void add_point(size_t index, stack<std::pair<size_t, size_t> > &flip_stack);
        void flip(size_t i, size_t j, stack<std::pair<size_t, size_t> > & flip_stack);
        size_t Walk(size_t point);
        double CalculateRadius(int facet);
        double CalcRadiusHiRes(int facet);
        int FindPointInFacet(int facet, int point);
        double FindMaxRadius(int point);
        void FindContainingTetras(int StartTetra, int point, vector<int> &tetras);
        vector<int> FindContainingTetras(int StartTetra, int point);
        vector<vector<int> > FindOuterPoints(vector<Edge> const& edges);
        void AddPeriodicMPI(std::vector<int>& toduplicate, std::vector<Vector2D>& periodic_add);
        vector<vector<int> > FindOuterPointsMPI(OuterBoundary const* obc, vector<Edge> const& edges,
                Tessellation const& tproc, vector<vector<int> > &Nghost, vector<int> &proclist);
        bool IsTripleOut(int index) const;
        int FindTripleLoc(facet const& f)const;
        void AddFacetDuplicate(int index, vector<vector<int> > &toduplicate, vector<Edge>
                const& edges, vector<bool> &checked)const;
        void AddOuterFacets(int tri, vector<vector<int> > &toduplicate, vector<Edge>
                const& edges, vector<bool> &checked);

        vector<vector<int> > AddOuterFacetsMPI(int point,vector<vector<int> > &toduplicate,vector<int> &neigh,
                vector<bool> &checked,const Tessellation& tproc,const vector<Edge>& own_edges,bool periodic, 
                std::vector<Vector2D> &periodic_add_self,std::vector<std::vector<Vector2D> >& periodic_add_others, 
                Vector2D const &ll, Vector2D const &ur, bool recursive = false);

        void AddRigid(vector<Edge> const& edges,vector<vector<int> > &toduplicate);
        vector<vector<int> > AddPeriodic(OuterBoundary const* obc, vector<Edge> const& edges,
                vector<vector<int> > &toduplicate);
        void AddHalfPeriodic(OuterBoundary const* obc, vector<Edge> const& edges,       vector<vector<int> > &toduplicate);
        double GetMaxRadius(int point, int startfacet);
        void SendRecvFirstBatch(vector<vector<Vector2D> > &tosend,vector<int> const& neigh, vector<vector<int> > &Nghost);
        vector<int> GetOuterFacets(int cur_facet, int real_point, int olength);

        Delaunay& operator=(const Delaunay& origin);

public:

        int GetOrgIndex(int index)const;

        void ChangeOlength(int n);

        void Changelength(int n);

        vector<Vector2D>& ChangeCor(void);

        const vector<Vector2D>& getCor(void) const;

        Delaunay(void);

        Delaunay(Delaunay const& other);

        ~Delaunay(void);

        void build_delaunay(vector<Vector2D>const& vp, std::vector<std::pair<Vector2D, Vector2D> >const & cpoints);

        void output(void);

        const facet& get_facet(int index) const;

        double get_facet_coordinate(int Facet, int vertice, int dim);

        Vector2D get_point(size_t index) const;

        double get_cor(int index, int dim) const;

        int get_num_facet(void)const;

        int get_length(void) const;

        int get_last_loc(void) const;

        void set_point(int index, Vector2D p);

        double triangle_area(int index);

        void update(const vector<Vector2D>& points, std::vector<std::pair<Vector2D, Vector2D> >const& cpoints);

        int GetOriginalIndex(int NewPoint) const;

        int GetOriginalLength(void) const;

        vector<Vector2D>& GetMeshPoints(void);

        int GetTotalLength(void);

        double GetFacetRadius(int facet) const;

        void AddAditionalPoint(Vector2D const& vec);
        int GetCorSize(void)const;

        Vector2D GetCircleCenter(int index, double &R)const;

        delaunay_loggers::DelaunayLogger* logger;
        void BuildBoundary(OuterBoundary const* obc, vector<Edge> const& edges);
        pair<vector<vector<int> >, vector<int> > BuildBoundary(OuterBoundary const* obc, Tessellation const& tproc,
                vector<vector<int> > &Nghost);
        void AddBoundaryPoints(vector<Vector2D> const& points);

        bool CheckCorrect(void);
};
#endif //DELAUNAYMPI_HPP