NodeToNodeMap.h

Go to the documentation of this file.

#ifndef included_AMP_NodeToNodeMap
#define included_AMP_NodeToNodeMap
 
 
#include <list>
#include <vector>
 
#include "AMP/operators/map/AsyncMapOperator.h"
#include "AMP/operators/map/NodeToNodeMapParameters.h"
 
#include "AMP/discretization/DOF_Manager.h"
#include "AMP/mesh/Mesh.h"
#include "AMP/utils/AMP_MPI.h"
#include "AMP/vectors/Vector.h"
 
 
namespace AMP::Operator {
 
 
class NodeToNodeMap : public AMP::Operator::AsyncMapOperator
{
public:
    typedef NodeToNodeMapParameters Parameters;
 
    std::string type() const override { return "NodeToNodeMap"; }
 
    static bool validMapType( const std::string &s );
 
    static const int CommTagBase = 10000;
 
    explicit NodeToNodeMap( std::shared_ptr<const AMP::Operator::OperatorParameters> params );
 
    virtual ~NodeToNodeMap();
 
    void applyStart( AMP::LinearAlgebra::Vector::const_shared_ptr u,
                     AMP::LinearAlgebra::Vector::shared_ptr f ) override;
 
    void applyFinish( AMP::LinearAlgebra::Vector::const_shared_ptr u,
                      AMP::LinearAlgebra::Vector::shared_ptr f ) override;
 
    void setVector( AMP::LinearAlgebra::Vector::shared_ptr p ) override;
 
    virtual AMP::LinearAlgebra::Vector::shared_ptr getVector();
 
    // Function to determine if a makeConsistentSet is required
    bool requiresMakeConsistentSet() override;
 
 
private:
    class Point
    {
    public:
        AMP::Mesh::MeshElementID id;
        double pos[3];
        int proc;
        Point();
        Point( const Point &rhs ) = default;
        Point &operator=( const Point &rhs ) = default;
        bool operator==( const Point &rhs ) const;
        bool operator!=( const Point &rhs ) const;
        bool operator<=( const Point &rhs ) const;
        bool operator>=( const Point &rhs ) const;
        bool operator<( const Point &rhs ) const;
        bool operator>( const Point &rhs ) const;
    };
 
    // Some basic variables
    AMP::Mesh::MeshIterator d_iterator1;
    AMP::Mesh::MeshIterator d_iterator2;
 
    // Store the pairs of points that are aligned for each mesh owned by the current processor
    std::vector<std::pair<Point, Point>> d_localPairsMesh1;
    std::vector<std::pair<Point, Point>> d_localPairsMesh2;
 
    // Variables for communication
    int d_commTag;
    std::vector<int> d_count;
    std::vector<int> d_displ;
    std::vector<double> d_sendBuffer;
    std::vector<double> d_recvBuffer;
 
    // Other data
    bool d_callMakeConsistentSet;
 
    // Function to compute the pairs of points for each mesh
    // Note: This function requires global communication across the map comm
    void createPairs( bool requireAllPaired = true );
 
    // Function to create the list of owned points from the iterator over the surface nodes
    std::vector<Point> createOwnedPoints( const AMP::Mesh::MeshIterator & );
 
    // Function to create the communication lists
    void buildSendRecvList();
 
protected:
    int dim;
    int DofsPerObj;
    // Lists of MeshElementIDs to send/recv for each processor (note: orders must match for each
    // processor)
    // We want to construct the lists so that we can do a global or pair-wise communication
    std::vector<AMP::Mesh::MeshElementID> d_sendList;
    std::vector<AMP::Mesh::MeshElementID> d_recvList;
};
} // namespace AMP::Operator
 
 
#endif