communicator.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//                   Riccardo Rossi
//
//
 
 
 
#if !defined(KRATOS_COMMUNICATOR_H_INCLUDED )
#define  KRATOS_COMMUNICATOR_H_INCLUDED
 
 
 
// System includes
#include <string>
#include <iostream>
#include <sstream>
#include <cstddef>
 
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/condition.h"
#include "includes/element.h"
#include "includes/mesh.h"
 
namespace Kratos
{
 
 
 
 
 
 
// Forward declaration of DataCommunicator
class DataCommunicator;
 
 
class KRATOS_API(KRATOS_CORE) Communicator
{
public:
 
 
 
    KRATOS_CLASS_POINTER_DEFINITION(Communicator);
 
    typedef unsigned int IndexType;
 
    typedef unsigned int SizeType;
 
    typedef Node NodeType;
 
    typedef Properties PropertiesType;
 
    typedef Element ElementType;
 
    typedef Condition ConditionType;
 
    typedef DenseVector<int> NeighbourIndicesContainerType;
 
    typedef Mesh<NodeType, PropertiesType, ElementType, ConditionType> MeshType;
 
    typedef PointerVector<MeshType> MeshesContainerType;
 
    typedef MeshType::NodesContainerType NodesContainerType;
 
    typedef MeshType::NodeIterator NodeIterator;
 
    typedef MeshType::NodeConstantIterator NodeConstantIterator;
 
    typedef MeshType::PropertiesContainerType PropertiesContainerType;
 
    typedef MeshType::PropertiesIterator PropertiesIterator;
 
    typedef MeshType::PropertiesConstantIterator PropertiesConstantIterator;
 
    typedef MeshType::ElementsContainerType ElementsContainerType;
 
    typedef MeshType::ElementIterator ElementIterator;
 
    typedef MeshType::ElementConstantIterator ElementConstantIterator;
 
    typedef MeshType::ConditionsContainerType ConditionsContainerType;
 
    typedef MeshType::ConditionIterator ConditionIterator;
 
    typedef MeshType::ConditionConstantIterator ConditionConstantIterator;
 
 
    Communicator();
 
 
    Communicator(const DataCommunicator& rDataCommunicator);
 
    Communicator(Communicator const& rOther);
 
    virtual ~Communicator() = default;
 
    virtual Communicator::Pointer Create(const DataCommunicator& rDataCommunicator) const;
 
    Communicator::Pointer Create() const;
 
 
    Communicator & operator=(Communicator const& rOther) = delete;
 
 
    virtual bool IsDistributed() const;
 
    virtual int MyPID() const;
 
    virtual int TotalProcesses() const;
 
    SizeType GlobalNumberOfNodes() const;
 
    SizeType GlobalNumberOfElements() const;
 
    SizeType GlobalNumberOfConditions() const;
 
    SizeType GlobalNumberOfMasterSlaveConstraints() const;
 
    SizeType GetNumberOfColors() const;
 
    void SetNumberOfColors(SizeType NewNumberOfColors);
 
    void AddColors(SizeType NumberOfAddedColors);
 
    NeighbourIndicesContainerType& NeighbourIndices();
 
    NeighbourIndicesContainerType const& NeighbourIndices() const;
 
    void SetLocalMesh(MeshType::Pointer pGivenMesh);
 
    MeshType::Pointer pLocalMesh();
 
    MeshType::Pointer pGhostMesh();
 
    MeshType::Pointer pInterfaceMesh();
 
    const MeshType::Pointer pLocalMesh() const;
 
    const MeshType::Pointer pGhostMesh() const;
 
    const MeshType::Pointer pInterfaceMesh() const;
 
    MeshType::Pointer pLocalMesh(IndexType ThisIndex);
 
    MeshType::Pointer pGhostMesh(IndexType ThisIndex);
 
    MeshType::Pointer pInterfaceMesh(IndexType ThisIndex);
 
    const MeshType::Pointer pLocalMesh(IndexType ThisIndex) const;
 
    const MeshType::Pointer pGhostMesh(IndexType ThisIndex) const;
 
    const MeshType::Pointer pInterfaceMesh(IndexType ThisIndex) const;
 
    MeshType& LocalMesh();
 
    MeshType& GhostMesh();
 
    MeshType& InterfaceMesh();
 
    MeshType const& LocalMesh() const;
 
    MeshType const& GhostMesh() const;
 
    MeshType const& InterfaceMesh() const;
 
    MeshType& LocalMesh(IndexType ThisIndex);
 
    MeshType& GhostMesh(IndexType ThisIndex);
 
    MeshType& InterfaceMesh(IndexType ThisIndex);
 
    MeshType const& LocalMesh(IndexType ThisIndex) const;
 
    MeshType const& GhostMesh(IndexType ThisIndex) const;
 
    MeshType const& InterfaceMesh(IndexType ThisIndex) const;
 
    MeshesContainerType& LocalMeshes();
 
    MeshesContainerType& GhostMeshes();
 
    MeshesContainerType& InterfaceMeshes();
 
    MeshesContainerType const& LocalMeshes() const;
 
    MeshesContainerType const& GhostMeshes() const;
 
    MeshesContainerType const& InterfaceMeshes() const;
 
    virtual const DataCommunicator& GetDataCommunicator() const;
 
 
    virtual bool SynchronizeNodalSolutionStepsData();
 
    virtual bool SynchronizeDofs();
 
    virtual bool SynchronizeVariable(Variable<int> const& rThisVariable);
 
    virtual bool SynchronizeVariable(Variable<double> const& rThisVariable);
 
    virtual bool SynchronizeVariable(Variable<bool> const& rThisVariable);
 
    virtual bool SynchronizeVariable(Variable<array_1d<double, 3 > > const& rThisVariable);
 
    virtual bool SynchronizeVariable(Variable<array_1d<double, 4 > > const& rThisVariable);
 
    virtual bool SynchronizeVariable(Variable<array_1d<double, 6 > > const& rThisVariable);
 
    virtual bool SynchronizeVariable(Variable<array_1d<double, 9 > > const& rThisVariable);
 
    virtual bool SynchronizeVariable(Variable<Vector> const& rThisVariable);
 
    virtual bool SynchronizeVariable(Variable<Matrix> const& rThisVariable);
 
    virtual bool SynchronizeVariable(Variable<Quaternion<double>> const& rThisVariable);
 
    virtual bool SynchronizeNonHistoricalVariable(Variable<int> const& rThisVariable);
 
    virtual bool SynchronizeNonHistoricalVariable(Variable<double> const& rThisVariable);
 
    virtual bool SynchronizeNonHistoricalVariable(Variable<bool> const& rThisVariable);
 
    virtual bool SynchronizeNonHistoricalVariable(Variable<array_1d<double, 3 > > const& rThisVariable);
 
    virtual bool SynchronizeNonHistoricalVariable(Variable<array_1d<double, 4 > > const& rThisVariable);
 
    virtual bool SynchronizeNonHistoricalVariable(Variable<array_1d<double, 6 > > const& rThisVariable);
 
    virtual bool SynchronizeNonHistoricalVariable(Variable<array_1d<double, 9 > > const& rThisVariable);
 
    virtual bool SynchronizeNonHistoricalVariable(Variable<Vector> const& rThisVariable);
 
    virtual bool SynchronizeNonHistoricalVariable(Variable<Matrix> const& rThisVariable);
 
    virtual bool SynchronizeNonHistoricalVariable(Variable<Quaternion<double>> const& rThisVariable);
 
    virtual bool SynchronizeCurrentDataToMax(Variable<double> const& ThisVariable);
 
    virtual bool SynchronizeNonHistoricalDataToMax(Variable<double> const& ThisVariable);
 
    virtual bool SynchronizeCurrentDataToAbsMax(Variable<double> const& ThisVariable);
 
    virtual bool SynchronizeNonHistoricalDataToAbsMax(Variable<double> const& ThisVariable);
 
    virtual bool SynchronizeCurrentDataToMin(Variable<double> const& ThisVariable);
 
    virtual bool SynchronizeNonHistoricalDataToMin(Variable<double> const& ThisVariable);
 
    virtual bool SynchronizeCurrentDataToAbsMin(Variable<double> const& ThisVariable);
 
    virtual bool SynchronizeNonHistoricalDataToAbsMin(Variable<double> const& ThisVariable);
 
    virtual bool SynchronizeElementalFlags();
 
    virtual bool AssembleCurrentData(Variable<int> const& ThisVariable);
 
    virtual bool AssembleCurrentData(Variable<double> const& ThisVariable);
 
    virtual bool AssembleCurrentData(Variable<array_1d<double, 3 > > const& ThisVariable);
 
    virtual bool AssembleCurrentData(Variable<Vector> const& ThisVariable);
 
    virtual bool AssembleCurrentData(Variable<Matrix> const& ThisVariable);
 
    virtual bool AssembleNonHistoricalData(Variable<int> const& ThisVariable);
 
    virtual bool AssembleNonHistoricalData(Variable<double> const& ThisVariable);
 
    virtual bool AssembleNonHistoricalData(Variable<array_1d<double, 3 > > const& ThisVariable);
 
    virtual bool AssembleNonHistoricalData(Variable<DenseVector<array_1d<double,3> > > const& ThisVariable);
 
    virtual bool AssembleNonHistoricalData(Variable<Vector> const& ThisVariable);
 
    virtual bool AssembleNonHistoricalData(Variable<Matrix> const& ThisVariable);
 
    virtual bool SynchronizeElementalNonHistoricalVariable(Variable<int> const& ThisVariable);
 
    virtual bool SynchronizeElementalNonHistoricalVariable(Variable<double> const& ThisVariable);
 
    virtual bool SynchronizeElementalNonHistoricalVariable(Variable<array_1d<double, 3 > > const& ThisVariable);
 
    virtual bool SynchronizeElementalNonHistoricalVariable(Variable<DenseVector<array_1d<double,3> > > const& ThisVariable);
 
    virtual bool SynchronizeElementalNonHistoricalVariable(Variable<DenseVector<int> > const& ThisVariable);
 
    virtual bool SynchronizeElementalNonHistoricalVariable(Variable<Vector> const& ThisVariable);
 
    virtual bool SynchronizeElementalNonHistoricalVariable(Variable<Matrix> const& ThisVariable);
 
    virtual bool TransferObjects(std::vector<NodesContainerType>& SendObjects, std::vector<NodesContainerType>& RecvObjects);
 
    virtual bool TransferObjects(std::vector<ElementsContainerType>& SendObjects, std::vector<ElementsContainerType>& RecvObjects);
 
    virtual bool TransferObjects(std::vector<ConditionsContainerType>& SendObjects, std::vector<ConditionsContainerType>& RecvObjects);
 
    virtual bool TransferObjects(std::vector<NodesContainerType>& SendObjects, std::vector<NodesContainerType>& RecvObjects,Kratos::Serializer& particleSerializer);
 
    virtual bool TransferObjects(std::vector<ElementsContainerType>& SendObjects, std::vector<ElementsContainerType>& RecvObjects,Kratos::Serializer& particleSerializer);
 
    virtual bool TransferObjects(std::vector<ConditionsContainerType>& SendObjects, std::vector<ConditionsContainerType>& RecvObjects,Kratos::Serializer& particleSerializer);
 
    virtual bool SynchronizeOrNodalFlags(const Flags& TheFlags);
 
    virtual bool SynchronizeAndNodalFlags(const Flags& TheFlags);
 
    virtual bool SynchronizeNodalFlags();
 
    void Clear();
 
 
    virtual std::string Info() const;
 
    virtual void PrintInfo(std::ostream& rOStream) const;
 
    virtual void PrintData(std::ostream& rOStream, std::string const& rPrefixString="") const;
 
 
 
 
 
protected:
 
 
    SizeType mNumberOfColors;
 
    NeighbourIndicesContainerType mNeighbourIndices;
 
    // To store all local entities
    MeshType::Pointer mpLocalMesh;
 
    // To store all ghost entities
    MeshType::Pointer mpGhostMesh;
 
    // To store all interface entities
    MeshType::Pointer mpInterfaceMesh;
 
    // To store interfaces local entities
    MeshesContainerType mLocalMeshes;
 
    // To store interfaces ghost entities
    MeshesContainerType mGhostMeshes;
 
    // To store interfaces ghost+local entities
    MeshesContainerType mInterfaceMeshes;
 
    // Interface to MPI communication
    const DataCommunicator& mrDataCommunicator;
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
}; // Class Communicator
 
 
 
 
 
 
inline std::istream & operator >>(std::istream& rIStream,
                                  Communicator& rThis);
 
 
inline std::ostream & operator <<(std::ostream& rOStream,
                                  const Communicator& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
} // namespace Kratos.
 
#endif // KRATOS_COMMUNICATOR_H_INCLUDED  defined