find_nodal_neighbours_surface_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main author:     Alex Jarauta
//  Co-author  :     Elaf Mahrous
 
 
#if !defined(KRATOS_FIND_NODAL_NEIGHBOURS_SURFACE_PROCESS_H_INCLUDED )
#define  KRATOS_FIND_NODAL_NEIGHBOURS_SURFACE_PROCESS_H_INCLUDED
 
 
 
// System includes
#include <string>
#include <iostream>
 
 
// External includes
 
 
// Project includes
#include <pybind11/pybind11.h>
#include "includes/define.h"
#include "includes/define_python.h"
 
#include "processes/process.h"
#include "includes/node.h"
// #include "includes/element.h"
#include "includes/condition.h"
#include "includes/model_part.h"
 
 
namespace Kratos
{
 
 
typedef  ModelPart::NodesContainerType NodesContainerType;
// typedef  ModelPart::ElementsContainerType ElementsContainerType;
typedef  ModelPart::ConditionsContainerType ConditionsContainerType;
 
 
 
 
 
 
class FindNodalNeighboursSurfaceProcess
    : public Process
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(FindNodalNeighboursSurfaceProcess);
 
 
    FindNodalNeighboursSurfaceProcess(ModelPart& model_part, const int avg_conds = 8, const int avg_nodes = 8)
        : mr_model_part(model_part)
    {
        mavg_conds = avg_conds;
        mavg_nodes = avg_nodes;
    }
 
    ~FindNodalNeighboursSurfaceProcess() override
    {
    }
 
 
 
    void operator()()
    {
        Execute();
    }
 
 
 
    void Execute() override
    {
        NodesContainerType& rNodes = mr_model_part.Nodes();
    ConditionsContainerType& rConds = mr_model_part.Conditions();
 
        //first of all the neighbour nodes and conditions array are initialized to the guessed size
        //and empties the old entries
        for(NodesContainerType::iterator in = rNodes.begin(); in!=rNodes.end(); ++in)
        {
            (in->GetValue(NEIGHBOUR_NODES)).reserve(mavg_nodes);
            GlobalPointersVector<Node >& rN = in->GetValue(NEIGHBOUR_NODES);
            rN.erase(rN.begin(),rN.end() );
        
            (in->GetValue(NEIGHBOUR_CONDITIONS)).reserve(mavg_conds);
            GlobalPointersVector<Condition >& rC = in->GetValue(NEIGHBOUR_CONDITIONS);
            rC.erase(rC.begin(),rC.end() );     
        }
 
        //add the neighbour conditions to all the nodes in the mesh
        for(ConditionsContainerType::iterator ic = rConds.begin(); ic!=rConds.end(); ++ic)
        {
            Condition::GeometryType& pGeom = ic->GetGeometry();
            for(unsigned int i = 0; i < pGeom.size(); i++)
            {
                //KRATOS_WATCH( pGeom[i] );
                (pGeom[i].GetValue(NEIGHBOUR_CONDITIONS)).push_back( Condition::WeakPointer( *(ic.base()) ) );
                //KRATOS_WATCH( (pGeom[i].GetValue(NEIGHBOUR_ELEMENTS)).size() );
            }
        }
 
        //adding the neighbouring nodes
        for(NodesContainerType::iterator in = rNodes.begin(); in!=rNodes.end(); ++in)
        {
            GlobalPointersVector<Condition >& rC = in->GetValue(NEIGHBOUR_CONDITIONS);
 
            for(unsigned int ic = 0; ic < rC.size(); ic++)
            {
                Condition::GeometryType& pGeom = rC[ic].GetGeometry();
                for(unsigned int i = 0; i < pGeom.size(); i++)
                {
                    if(pGeom[i].Id() != in->Id() )
                    {
//                         Element::NodeType::WeakPointer temp = pGeom(i);
            //NOT SURE ABOUT THIS!!!!!!!!!
                        Condition::NodeType::WeakPointer temp = pGeom(i);           
                        AddUniqueWeakPointer< Node >(in->GetValue(NEIGHBOUR_NODES), temp);
                    }
                }
            }
        }
    }
 
    void ClearNeighbours()
    {
        NodesContainerType& rNodes = mr_model_part.Nodes();
        for(NodesContainerType::iterator in = rNodes.begin(); in!=rNodes.end(); ++in)
        {
            GlobalPointersVector<Condition >& rC = in->GetValue(NEIGHBOUR_CONDITIONS);
            rC.erase(rC.begin(),rC.end());
 
            GlobalPointersVector<Node >& rN = in->GetValue(NEIGHBOUR_NODES);
            rN.erase(rN.begin(),rN.end() );
        }
    }
 
 
 
 
 
 
    std::string Info() const override
    {
        return "FindNodalNeighboursSurfaceProcess";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "FindNodalNeighboursSurfaceProcess";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
    ModelPart& mr_model_part;
    int mavg_conds;
    int mavg_nodes;
 
 
 
    //******************************************************************************************
    //******************************************************************************************
    template< class TDataType > void  AddUniqueWeakPointer
    (GlobalPointersVector< TDataType >& v, const typename TDataType::WeakPointer candidate)
    {
        typename GlobalPointersVector< TDataType >::iterator i = v.begin();
        typename GlobalPointersVector< TDataType >::iterator endit = v.end();
        while ( i != endit && (i)->Id() != (candidate.lock())->Id())
        {
            i++;
        }
        if( i == endit )
        {
            v.push_back(candidate);
        }
 
    }
 
 
 
 
 
 
 
 
    FindNodalNeighboursSurfaceProcess& operator=(FindNodalNeighboursSurfaceProcess const& rOther);
 
    //FindNodalNeighboursSurfaceProcess(FindNodalNeighboursSurfaceProcess const& rOther);
 
 
 
}; // Class FindNodalNeighboursSurfaceProcess
 
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  FindNodalNeighboursSurfaceProcess& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const FindNodalNeighboursSurfaceProcess& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_FIND_NODAL_NEIGHBOURS_SURFACE_PROCESS_H_INCLUDED  defined