Wall.h

Go to the documentation of this file.

#ifndef WALL_H_INCLUDED
#define WALL_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 "bio/WallAttributes.h"
#include "util/container/SegmentedVector.h"

#include <boost/property_tree/ptree.hpp>
#include <iosfwd>
#include <tuple>
#include <vector>

namespace SimPT_Editor {
        class EditableMesh;
}

namespace SimPT_Sim {

class Cell;
class Edge;
class NeighborNodes;
class Node;

class Wall : public WallAttributes
{
public:
        virtual ~Wall() {}

        Cell* GetC1() const { return m_c1; }

        Cell* GetC2() const { return m_c2; }

        std::vector<Edge> GetEdges() const;

        unsigned int GetIndex() const { return m_wall_index; }

        std::array<double, 3> GetInfluxVector(Cell* c) const;

        Node* GetN1() const { return m_n1; }

        Node* GetN2() const { return m_n2; }
        
        //double GetWallStrength() const { return m_wall_strength; }
        
        std::array<double, 3> GetWallVector(Cell* c) const;

        double GetLength() const;

        bool IncludesEdge(const Edge& edge) const;

        bool IncludesNode(const Node* node) const;

        bool IsAtBoundary() const;

        bool IsIntersectingWithDivisionPlane(const std::array<double, 3>& p1,
                                        const std::array<double, 3>& p2) const;

        bool IsSam() const;

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

        virtual void ReadPtree(boost::property_tree::ptree const& wall_pt);

        void SetC1(Cell* c) { m_c1 = c; }

        void SetC2(Cell* c) { m_c2 = c; }

        void SetN1(Node* n) { m_n1 = n; }

        void SetN2(Node* n) { m_n2 = n; }

        void SetLengthDirty() const { m_length_dirty = true; }

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

private:
        friend class Mesh;
        template<typename T, size_t N>
        friend class SimPT_Sim::Container::SegmentedVector;
        friend class SimPT_Editor::EditableMesh;

private:
        Wall(unsigned int index, Node* n1, Node* n2, Cell* c1, Cell* c2, unsigned int num_chem);
        Wall(const Wall& src);
        Wall& operator=(Wall const&);

private:
        void CalculateLength() const;

private:
        Cell*             m_c1;                
        Cell*             m_c2;                
        Node*             m_n1;                
        Node*             m_n2;                
        unsigned int      m_wall_index;        

private:
        mutable double    m_length;            
        mutable bool      m_length_dirty;      
};


std::ostream& operator<<(std::ostream& os, const Wall& w);

}

#endif // end_of_include_guard