MutableVertexMesh.hpp

/*
 
Copyright (c) 2005-2024, University of Oxford.
All rights reserved.
 
University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.
 
This file is part of Chaste.
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
 * Redistributions of source code must retain the above copyright notice,
   this list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.
 * Neither the name of the University of Oxford nor the names of its
   contributors may be used to endorse or promote products derived from this
   software without specific prior written permission.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
*/
#ifndef MUTABLEVERTEXMESH_HPP_
#define MUTABLEVERTEXMESH_HPP_
 
// Forward declaration prevents circular include chain
template<unsigned ELEMENT_DIM, unsigned SPACE_DIM>
class VertexMeshWriter;
 
#include <iostream>
#include <map>
#include <algorithm>
 
#include "ChasteSerialization.hpp"
#include <boost/serialization/vector.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/split_member.hpp>
 
#include "VertexMesh.hpp"
#include "EdgeHelper.hpp"
#include "RandomNumberGenerator.hpp"
 
#include "VertexMeshOperationRecorder.hpp"
template<unsigned ELEMENT_DIM, unsigned SPACE_DIM>
class MutableVertexMesh : public VertexMesh<ELEMENT_DIM, SPACE_DIM>
{
    friend class TestMutableVertexMesh;
    friend class TestMutableVertexMeshReMesh;
    friend class TestMutableVertexMeshRosetteMethods;
    friend class TestMutableVertexEdges;
    friend class TestCellEdgeInteriorSrn;
    friend class TestMutableVertexMeshOperationsWithPopulationSrn;
protected:
    bool mTrackMeshOperations = false;
 
    VertexMeshOperationRecorder<ELEMENT_DIM, SPACE_DIM> mOperationRecorder = (VertexMeshOperationRecorder<ELEMENT_DIM, SPACE_DIM>());
 
    double mCellRearrangementThreshold;
 
    double mCellRearrangementRatio;
 
    double mT2Threshold;
 
    double mProtorosetteFormationProbability;
 
    double mProtorosetteResolutionProbabilityPerTimestep;
 
    double mRosetteResolutionProbabilityPerTimestep;
 
    bool mCheckForInternalIntersections;
 
    bool mCheckForT3Swaps;
 
    std::vector<unsigned> mDeletedNodeIndices;
 
    std::vector<unsigned> mDeletedElementIndices;
 
    double mDistanceForT3SwapChecking;
 
    c_vector<double, SPACE_DIM> mLastT2SwapLocation;
 
    std::vector< c_vector<double, SPACE_DIM> > mLocationsOfIntersectionSwaps;
 
    unsigned DivideElement(VertexElement<ELEMENT_DIM, SPACE_DIM>* pElement,
                           unsigned nodeAIndex,
                           unsigned nodeBIndex,
                           bool placeOriginalElementBelow=false);
 
    virtual bool CheckForSwapsFromShortEdges();
 
    bool CheckForIntersections();
 
    virtual void IdentifySwapType(Node<SPACE_DIM>* pNodeA, Node<SPACE_DIM>* pNodeB);
public:
    void PerformNodeMerge(Node<SPACE_DIM>* pNodeA, Node<SPACE_DIM>* pNodeB);
private:
    void PerformT1Swap(Node<SPACE_DIM>* pNodeA, Node<SPACE_DIM>* pNodeB, std::set<unsigned>& rElementsContainingNodes);
 
    void PerformIntersectionSwap(Node<SPACE_DIM>* pNode, unsigned elementIndex);
 
    void PerformT2Swap(VertexElement<ELEMENT_DIM, SPACE_DIM>& rElement);
 
    void PerformT3Swap(Node<SPACE_DIM>* pNode, unsigned elementIndex);
 
    void PerformVoidRemoval(Node<SPACE_DIM>* pNodeA, Node<SPACE_DIM>* pNodeB, Node<SPACE_DIM>* pNodeC);
 
    virtual void HandleHighOrderJunctions(Node<SPACE_DIM>* pNodeA, Node<SPACE_DIM>* pNodeB);
 
    void PerformRosetteRankIncrease(Node<SPACE_DIM>* pNodeA, Node<SPACE_DIM>* pNodeB);
 
    void PerformProtorosetteResolution(Node<SPACE_DIM>* pProtorosetteNode);
 
    void PerformRosetteRankDecrease(Node<SPACE_DIM>* pRosetteNode);
 
    void CheckForRosettes();
 
    c_vector<double, 2> WidenEdgeOrCorrectIntersectionLocationIfNecessary(unsigned indexA, unsigned indexB, c_vector<double, 2> intersection);
 
    friend class boost::serialization::access;
 
    template<class Archive>
    void serialize(Archive & archive, const unsigned int version)
    {
        // NOTE - Subclasses must archive their member variables BEFORE calling this method.
        archive & mCellRearrangementThreshold;
        archive & mCellRearrangementRatio;
        archive & mT2Threshold;
        archive & mProtorosetteFormationProbability;
        archive & mProtorosetteResolutionProbabilityPerTimestep;
        archive & mRosetteResolutionProbabilityPerTimestep;
        archive & mCheckForInternalIntersections;
        archive & mDeletedNodeIndices;
        archive & mDeletedElementIndices;
        archive & mDistanceForT3SwapChecking;
        archive & mOperationRecorder;
        archive & mCheckForT3Swaps;
        archive & mCheckForT3Swaps;
        archive & boost::serialization::base_object<VertexMesh<ELEMENT_DIM, SPACE_DIM> >(*this);
    }
public:
 
    MutableVertexMesh(std::vector<Node<SPACE_DIM>*> nodes,
                      std::vector<VertexElement<ELEMENT_DIM, SPACE_DIM>*> vertexElements,
                      double cellRearrangementThreshold=0.01,
                      double t2Threshold=0.001,
                      double cellRearrangementRatio=1.5,
                      double protorosetteFormationProbability=0.0,
                      double protorosetteResolutionProbabilityPerTimestep=0.0,
                      double rosetteResolutionProbabilityPerTimestep=0.0);
 
    MutableVertexMesh();
 
    virtual ~MutableVertexMesh();
 
    void SetCellRearrangementThreshold(double cellRearrangementThreshold);
 
    void SetT2Threshold(double t2Threshold);
 
    void SetCellRearrangementRatio(double cellRearrangementRatio);
 
    void SetProtorosetteFormationProbability(double protorosetteFormationProbability);
 
    void SetProtorosetteResolutionProbabilityPerTimestep(double protorosetteResolutionProbabilityPerTimestep);
 
    void SetRosetteResolutionProbabilityPerTimestep(double rosetteResolutionProbabilityPerTimestep);
 
    virtual void SetNode(unsigned nodeIndex, ChastePoint<SPACE_DIM> point);
 
    void SetCheckForInternalIntersections(bool checkForInternalIntersections);
 
    void SetCheckForT3Swaps(bool checkForT3Swaps);
 
    double GetCellRearrangementThreshold() const;
 
    double GetT2Threshold() const;
 
    double GetCellRearrangementRatio() const;
 
    double GetProtorosetteFormationProbability() const;
 
    double GetProtorosetteResolutionProbabilityPerTimestep() const;
 
    double GetRosetteResolutionProbabilityPerTimestep() const;
 
    void SetDistanceForT3SwapChecking( double distanceForT3SwapChecking );
 
    double GetDistanceForT3SwapChecking() const;
 
    unsigned GetNumNodes() const;
 
    unsigned GetNumElements() const;
 
    bool GetCheckForInternalIntersections() const;
 
    bool GetCheckForT3Swaps() const;
 
    std::vector< c_vector<double, SPACE_DIM> > GetLocationsOfT1Swaps();
 
    c_vector<double, SPACE_DIM> GetLastT2SwapLocation();
 
    std::vector< c_vector<double, SPACE_DIM> > GetLocationsOfT3Swaps();
 
    std::vector< c_vector<double, SPACE_DIM> > GetLocationsOfIntersectionSwaps();
 
    void ClearLocationsOfT1Swaps();
 
    void ClearLocationsOfT3Swaps();
 
    void ClearLocationsOfIntersectionSwaps();
 
    unsigned AddNode(Node<SPACE_DIM>* pNewNode);
 
    void DeleteElementPriorToReMesh(unsigned index);
 
    void DeleteNodePriorToReMesh(unsigned index);
 
    unsigned DivideElementAlongShortAxis(VertexElement<ELEMENT_DIM, SPACE_DIM>* pElement,
                                         bool placeOriginalElementBelow=false);
 
    unsigned DivideElementAlongGivenAxis(VertexElement<ELEMENT_DIM, SPACE_DIM>* pElement,
                                         c_vector<double, SPACE_DIM> axisOfDivision,
                                         bool placeOriginalElementBelow=false);
 
    unsigned AddElement(VertexElement<ELEMENT_DIM, SPACE_DIM>* pNewElement);
 
    bool CheckForT2Swaps(VertexElementMap& rElementMap);
 
    void Clear();
 
    void DivideEdge(Node<SPACE_DIM>* pNodeA, Node<SPACE_DIM>* pNodeB);
 
    void RemoveDeletedNodesAndElements(VertexElementMap& rElementMap);
 
    void RemoveDeletedNodes();
 
    virtual void ReMesh(VertexElementMap& rElementMap);
 
    void ReMesh();
 
    void SetMeshOperationTracking(const bool track);
 
    VertexMeshOperationRecorder<ELEMENT_DIM, SPACE_DIM>* GetOperationRecorder();
};
 
#include "SerializationExportWrapper.hpp"
EXPORT_TEMPLATE_CLASS_ALL_DIMS(MutableVertexMesh)
 
#endif /*MUTABLEVERTEXMESH_HPP_*/