set_moving_load_process.h

Go to the documentation of this file.

// KRATOS  ___|  |                   |                   |
//       \___ \  __|  __| |   |  __| __| |   |  __| _` | |
//             | |   |    |   | (    |   |   | |   (   | |
//       _____/ \__|_|   \__,_|\___|\__|\__,_|_|  \__,_|_| MECHANICS
//
//  License:         BSD License
//                   license: StructuralMechanicsApplication/license.txt
//
//  Main authors:    Aron Noordam
//
 
#pragma once
 
// System includes
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "processes/process.h"
#include "includes/model_part.h"
#include "includes/kratos_parameters.h"
 
#include "utilities/function_parser_utility.h"
#include "utilities/mortar_utilities.h"
namespace Kratos {
 
 
 
 
class KRATOS_API(STRUCTURAL_MECHANICS_APPLICATION) SetMovingLoadProcess : public Process
{
public:
    
 
    KRATOS_CLASS_POINTER_DEFINITION(SetMovingLoadProcess);
 
    typedef std::size_t SizeType;
 
 
    SetMovingLoadProcess(ModelPart& rModelPart,
                                  Parameters Parameters);
 
 
    void ExecuteInitialize() override;
 
    void ExecuteInitializeSolutionStep() override;
 
    void ExecuteFinalizeSolutionStep() override;
 
 
 
    virtual std::string Info() const override {
        return "SetMovingLoadProcess";
    }
 
    void PrintInfo(std::ostream& rOStream) const override {
        rOStream << "SetMovingLoadProcess";
    }
 
    void PrintData(std::ostream& rOStream) const override {
    }
 
 
private:
 
    ModelPart& mrModelPart;
    Parameters mParameters;
 
    // vector of sorted conditions
    std::vector<Condition> mSortedConditions;
 
    // vector of booleans which indicate if the nodes in the condition are in reversed order with respect to the direction of the moving load
    std::vector<bool> mIsCondReversedVector;
 
    // point of origin of the moving load
    array_1d<double, 3> mOriginPoint;
 
    // array of directions, of the moving load. This array indicates if the load moves in positive or negative direction with respect to the global
    // axis
    array_1d<int,3> mDirection;
 
    // distance of the load, with respect to the first node of the first condition in the sorted conditions vector
    double mCurrentDistance;
 
    // bool which indicates if a load function is used to determine the value of the load
    bool mUseLoadFunction;
 
    // bool which indicates of velocity function is used to determine the value of the load velocity
    bool mUseVelocityFunction;
 
    // vector of load functions
    std::vector<BasicGenericFunctionUtility> mLoadFunctions;
 
 
    static std::vector<IndexType> FindNonRepeatingIndices(const std::vector<IndexType> IndicesVector);
 
    std::vector<Condition> FindEndConditions();
 
    std::vector<Condition> SortConditions(ModelPart::ConditionsContainerType& rUnsortedConditions, Condition& rFirstCondition);
 
    static bool IsConditionReversed(const Condition& rCondition, const array_1d<int, 3> Direction);
 
    static Condition& GetFirstCondition(const Point FirstPoint, const Point SecondPoint, const array_1d<int, 3> Direction, std::vector<Condition>& rEndConditions);
 
    static Condition& GetFirstConditionFromCoord(const double FirstCoord, const double SecondCoord, const int Direction, std::vector<Condition>& EndConditions);
 
    static bool IsSwapPoints(const double FirstCoord, const double SecondCoord, const int Direction);
 
    void InitializeDistanceLoadInSortedVector();
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override;
    void load(Serializer& rSerializer) override;
 
 
}; // Class SetMovingLoadProcess
 
 
}  // namespace Kratos.