apply_periodic_boundary_condition_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Aditya Ghantasala
//
//
 
#ifndef APPLY_PERIODIC_CONDITION_PROCESS_H
#define APPLY_PERIODIC_CONDITION_PROCESS_H
 
// System includes
// External includes
 
// Project includes
#include "includes/define.h"
#include "processes/process.h"
#include "utilities/math_utils.h"
#include "includes/kratos_parameters.h"
#include "includes/model_part.h"
 
namespace Kratos
{
 
class KRATOS_API(KRATOS_CORE) ApplyPeriodicConditionProcess : public Process
{
 
  public:
    KRATOS_CLASS_POINTER_DEFINITION(ApplyPeriodicConditionProcess);
 
    typedef Node                                         NodeType;
    typedef Variable<double>                                VariableType;
    typedef NodeType::IndexType                             IndexType;
    typedef ModelPart::NodeIterator                         NodeIteratorType;
    typedef Matrix                                          MatrixType;
    typedef Vector                                          VectorType;
    typedef Geometry<NodeType>                              GeometryType;
 
    ApplyPeriodicConditionProcess(ModelPart &rMasterModelPart, ModelPart &rSlaveModelPart,
                                  Parameters Settings);
 
    ~ApplyPeriodicConditionProcess();
 
    void ExecuteInitialize() override;
 
    void ExecuteInitializeSolutionStep() override;
 
    const Parameters GetDefaultParameters() const override;
 
    void PrintInfo(std::ostream& rOStream) const override;
 
    enum class TransformationType {
        TRANSLATION = 1,
        ROTATION = 2
    };
 
  private:
    MatrixType mTransformationMatrix; // This can be either for rotating or for translating the slave geometry to Master geometry
    MatrixType mTransformationMatrixVariable; // This can be either for rotating or for translating the master variable to slave geometry
    ModelPart &mrMasterModelPart;       // the master modelpart to which the master-slave constraints are added.
    ModelPart &mrSlaveModelPart;
    Parameters mParameters;          // parameters
    double mAngleOfRotation;
    DenseVector<double> mCenterOfRotation;
    DenseVector<double> mAxisOfRotationVector;
    ApplyPeriodicConditionProcess::TransformationType mTransformationType;
    double mDistance;
    DenseVector<double> mDirOfTranslation;
    double mSearchTolerance;
    IndexType mSearchMaxResults;
 
    void RemoveCommonNodesFromSlaveModelPart();
 
    template <int TDim>
    void ApplyConstraintsForPeriodicConditions();
 
    template <int TDim>
    void ConstraintSlaveNodeWithConditionForVectorVariable(NodeType& rSlaveNode, const GeometryType& rHostedGeometry, const VectorType& rWeights, const std::string& rVarName);
 
    template <int TDim>
    void ConstraintSlaveNodeWithConditionForScalarVariable(NodeType& rSlaveNode, const GeometryType& rHostedGeometry, const VectorType& rWeights, const std::string& rVarName);
 
    void CalculateTransformationMatrix();
 
    /*
     * @brief Transform the point(node_cords) using the mTransformationMatrix calculated in CalculateTransformationMatrix function
     * @param rCoordinates The original coordinates which have to be transformed
     * @param rTransformedCoordinates The new coordinates which are transformed with rTransformationMatrix.
     */
    void TransformNode(const array_1d<double, 3 >& rCoordinates, array_1d<double, 3 >& rTransformedCoordinates) const;
 
 
 
}; // Class
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // APPLY_PERIODIC_CONDITION_PROCESS_H  defined