body_normal_calculation_utils.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics 
//
//  License:         BSD License 
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//                    
//
 
 
#include "includes/model_part.h"
 
#if !defined(KRATOS_BODY_NORMAL_CALCULATION_UTILS )
#define  KRATOS_BODY_NORMAL_CALCULATION_UTILS
 
 
/* System includes */
 
 
/* External includes */
 
 
/* Project includes */
//#include "utilities/math_utils.h"
#include "utilities/geometry_utilities.h"
 
 
namespace Kratos
{
 
class BodyNormalCalculationUtils
{
public:
    typedef ModelPart::NodesContainerType NodesArrayType;
    typedef ModelPart::ElementsContainerType ElementsArrayType;
    //***********************************************************************
    //***********************************************************************
 
    void CalculateBodyNormals(
        ModelPart& r_model_part,
        int dimension)
    {
        KRATOS_TRY
 
        ModelPart::ElementsContainerType& rElements = r_model_part.Elements();
 
        //resetting the normals - only for the nodes on which we will do the calculate
        array_1d<double,3> zero = ZeroVector(3);
    
    for(ModelPart::NodesContainerType::iterator it =  r_model_part.NodesBegin();
                it !=r_model_part.NodesEnd(); it++)
        {
            noalias(it->FastGetSolutionStepValue(NORMAL)) = zero;
        }
 
//         for(ModelPart::ElementsContainerType::iterator it =  rElements.begin();
//                 it !=rElements.end(); it++)
//         {
//             Element::GeometryType& rNodes = it->GetGeometry();
//             for(unsigned int in = 0; in<rNodes.size(); in++)
//                 noalias((rNodes[in]).FastGetSolutionStepValue(NORMAL)) = zero;
//         }
 
 
        //calculating the normals and storing on the conditions
        array_1d<double,3> An;
        if(dimension == 2)
        {
            BoundedMatrix<double,3,2> DN_DX;
            array_1d<double,3> N;
            double Volume;
            for(ModelPart::ElementsContainerType::iterator it =  rElements.begin(); it !=rElements.end(); it++)
            {
                Element::GeometryType& geom = it->GetGeometry();
                GeometryUtils::CalculateGeometryData(geom, DN_DX, N, Volume);
 
                for(unsigned int i = 0; i<geom.size(); i++)
                {
                    array_1d<double,3>& normal = geom[i].FastGetSolutionStepValue(NORMAL);
                    for(unsigned int j=0; j<2; j++)
                    {
                        normal[j] += Volume*DN_DX(i,j);
                    }
                }
            }
        }
        else if(dimension == 3)
        {
            BoundedMatrix<double,4,3> DN_DX;
            array_1d<double,4> N;
            double Volume;
            for(ModelPart::ElementsContainerType::iterator it =  rElements.begin(); it !=rElements.end(); it++)
            {
                Element::GeometryType& geom = it->GetGeometry();
                GeometryUtils::CalculateGeometryData(geom, DN_DX, N, Volume);
 
                for(unsigned int i = 0; i<geom.size(); i++)
                {
                    array_1d<double,3>& normal = geom[i].FastGetSolutionStepValue(NORMAL);
                    for(unsigned int j=0; j<3; j++)
                    {
                        normal[j] += Volume*DN_DX(i,j);
                    }
                }
            }
        }
 
        r_model_part.GetCommunicator().AssembleCurrentData(NORMAL);
//          r_model_part.GetCommunicator().AssembleCurrentData(PRESSURE);
 
 
        KRATOS_CATCH("")
 
    }
 
 
 
private:
    //this function adds the Contribution of one of the geometries
    //to the corresponding nodes
 
    //BodyNormalCalculationUtils(void);
 
    //BodyNormalCalculationUtils(BodyNormalCalculationUtils& rSource);
 
 
}; /* Class ClassName */
 
}  /* namespace Kratos.*/
 
#endif /* KRATOS_BODY_NORMAL_CALCULATION_UTILS defined */