Mesh.h

Go to the documentation of this file.

#ifndef MESH_H_INCLUDED
#define MESH_H_INCLUDED
/*
 * Copyright 2011-2016 Universiteit Antwerpen
 *
 * Licensed under the EUPL, Version 1.1 or  as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl5
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing
 * permissions and limitations under the Licence.
 */
#include "Cell.h"
#include "NeighborNodes.h"
#include "Node.h"
#include "util/container/SegmentedVector.h"

#include <boost/property_tree/ptree.hpp>
#include <array>
#include <list>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <tuple>
#include <vector>

namespace SimPT_Editor {
        class EditableMesh;
}

namespace SimPT_Sim {

class Edge;
class Node;
class MeshState;
class Wall;


class Mesh
{
public:
        Mesh(unsigned int num_chemicals);

        void AddNodeToCell(Cell* c, Node* n, Node* nb1, Node* nb2);

        Cell* BuildBoundaryPolygon(const std::vector<unsigned int>& node_ids);

        Cell* BuildCell();

        Cell* BuildCell(const std::vector<unsigned int>& node_ids);

        Cell* BuildCell(unsigned int id, const std::vector<unsigned int>& node_ids);

        Node* BuildNode(const std::array<double, 3>& vec, bool at_boundary);

        Node* BuildNode(unsigned int id, const std::array<double, 3>& vec, bool at_boundary);

        Wall* BuildWall(Node* n1, Node* n2, Cell* c1, Cell* c2);

        Wall* BuildWall(unsigned int id, Node* n1, Node* n2, Cell* c1, Cell* c2);

        void ConstructNeighborList(Cell* cell);

        //void ConstructNeighborList(Cell* cell) { ConstructNeighborList(cell); }

        void Derivatives(double* derivs);

        Cell* FindEdgeNeighbor(Cell* cell, Edge edge) const;

        Wall* FindWall(const Edge& edge) const;

        Cell* GetBoundaryPolygon() const { return m_boundary_polygon; }

        const std::vector<Cell*>& GetCells() const { return m_cells; }

        std::vector<Cell*>& GetCells() { return m_cells; }

        std::vector<NeighborNodes> GetEdgeOwners(const Edge& edge) const;

        std::list<Cell*> const& GetNeighbors(Cell* c) const { return m_wall_neighbors.at(c); }

        std::list<Cell*>& GetNeighbors(Cell* c) { return m_wall_neighbors[c]; }

        std::list<NeighborNodes>& GetNodeOwningNeighbors(Node* n) { return m_node_owning_neighbors[n]; }

        const std::list<NeighborNodes>& GetNodeOwningNeighbors(Node* n) const { return m_node_owning_neighbors.at(n); }

        std::list<Wall*>& GetNodeOwningWalls(Node* n) { return m_node_owning_walls[n]; }

        const std::list<Wall*>& GetNodeOwningWalls(Node* n) const { return m_node_owning_walls.at(n); }

        const std::vector<Node*>& GetNodes() const { return m_nodes; }

        std::vector<Node*>& GetNodes() { return m_nodes; }

        // The chemical count.
        unsigned int GetNumChemicals() const { return m_num_chemicals; }

        MeshState GetState() const;

        const std::vector<Wall*>& GetWalls() const { return m_walls; }

        std::vector<Wall*>& GetWalls() { return m_walls; }

        bool IsAtBoundary(const Edge* e) const;

        bool IsAtBoundary(Wall* w) const;

        bool IsInBoundaryPolygon(Node* n) const;

        std::ostream& Print(std::ostream& os) const;

        void RemoveFromNeighborList(Cell* cell);

        void RemoveNodeFromOwnerLists(Node* node);

        boost::property_tree::ptree ToPtree() const;

        void UpdateNodeOwningNeighbors(Cell* cell);

        //void UpdateNodeOwningNeighbors(Cell* cell) { UpdateNodeOwningNeighbors(cell); }

        void UpdateNodeOwningWalls(Wall *wall);

        //void UpdateNodeOwningWalls(Wall* wall) { UpdateNodeOwningWalls(wall); }

public:
        void getValues(double* values);

        void setValues(double x, double* y);

private:
        friend class MeshCheck;
        friend class CBMBuilder;
        friend class SimPT_Editor::EditableMesh;

private:
        void AddConsecutiveNodeToCell(Cell* c, Node* n, Node* nb1, Node* nb2);

        Node* FindNextBoundaryNode(Node*) const;

        void FixWallIDs();

        void FixNodeIDs();

        void FixCellIDs();

private:
        Cell*  m_boundary_polygon;

        SimPT_Sim::Container::SegmentedVector<Cell>  m_cell_storage;

        std::vector<Cell*>  m_cells;

        unsigned int m_cell_next_id;

        SimPT_Sim::Container::SegmentedVector<Node>  m_node_storage;

        std::vector<Node*>  m_nodes;

        unsigned int m_node_next_id;

        std::map<Node*, std::list<NeighborNodes>> m_node_owning_neighbors;

        std::map<Node*, std::list<Wall*>> m_node_owning_walls;

        const unsigned int m_num_chemicals;

        SimPT_Sim::Container::SegmentedVector<Wall>  m_wall_storage;

        std::vector<Wall*>   m_walls;

        unsigned int m_wall_next_id;

        std::map<Cell*, std::list<Cell*>>  m_wall_neighbors;
};

}

#endif // end_of_include_guard