assign_torque_field_about_an_axis_to_conditions_process.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosSolidMechanicsApplication $
//   Created by:          $Author:            JMCarbonell $
//   Last modified by:    $Co-Author:                     $
//   Date:                $Date:             January 2018 $
//   Revision:            $Revision:                  0.0 $
//
//
 
#if !defined(KRATOS_ASSIGN_TORQUE_FIELD_ABOUT_AN_AXIS_TO_CONDITIONS_PROCESS_H_INCLUDED)
#define  KRATOS_ASSIGN_TORQUE_FIELD_ABOUT_AN_AXIS_TO_CONDITIONS_PROCESS_H_INCLUDED
 
 
 
// System includes
 
// External includes
 
// Project includes
#include "custom_processes/assign_torque_about_an_axis_to_conditions_process.hpp"
 
namespace Kratos
{
 
 
 
class AssignTorqueFieldAboutAnAxisToConditionsProcess : public AssignTorqueAboutAnAxisToConditionsProcess
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(AssignTorqueFieldAboutAnAxisToConditionsProcess);
 
 
    AssignTorqueFieldAboutAnAxisToConditionsProcess(ModelPart& model_part,
                            pybind11::object& pPyObject,
                            const std::string& pPyMethodName,
                            const bool SpatialFieldFunction,
                            Parameters rParameters
                                             ) : AssignTorqueAboutAnAxisToConditionsProcess(model_part)
    {
        KRATOS_TRY
 
        Parameters default_parameters( R"(
            {
                "model_part_name":"MODEL_PART_NAME",
                "variable_name": "VARIABLE_NAME",
                "modulus" : 1.0,
                "direction" : [],
                "center" : []
            }  )" );
 
 
        // Validate against defaults -- this ensures no type mismatch
        rParameters.ValidateAndAssignDefaults(default_parameters);
 
        mvariable_name = rParameters["variable_name"].GetString();
 
    if( KratosComponents< Variable<array_1d<double, 3> > >::Has( mvariable_name ) ) //case of array_1d variable
        {
 
        mPyObject      =  pPyObject;
        mPyMethodName  =  pPyMethodName;
 
        mIsSpatialField = SpatialFieldFunction;
 
 
        for( unsigned int i=0; i<3; i++)
        {
        mdirection[i] = rParameters["direction"][i].GetDouble();
        mcenter[i] = rParameters["center"][i].GetDouble();
        }
 
        double norm = norm_2(mdirection);
        if(norm!=0)
        mdirection/=norm;
    }
    else //case of other variable type
        {
      KRATOS_ERROR << "trying to set a variable that is not in the model_part - variable name is " << mvariable_name <<std::endl;
    }
 
        KRATOS_CATCH("");
    }
 
 
    ~AssignTorqueFieldAboutAnAxisToConditionsProcess() override {}
 
 
 
    void operator()()
    {
        Execute();
    }
 
 
 
 
    void Execute()  override
    {
 
        KRATOS_TRY;
 
 
    if( ! mIsSpatialField ){
 
      const ProcessInfo& rCurrentProcessInfo = mrModelPart.GetProcessInfo();
      const double& rCurrentTime  = rCurrentProcessInfo[TIME];
 
      this->CallTimeFunction(rCurrentTime, mvalue);
 
      AssignTorqueAboutAnAxisToConditionsProcess::Execute();
 
    }
    else //no spatial fields accepted (it have to be implemented if needed
        {
      KRATOS_ERROR << "trying to set an spatial field....not implemented" << mvariable_name <<std::endl;
    }
 
 
        KRATOS_CATCH("");
 
    }
 
    void ExecuteInitialize() override
    {
    }
 
    void ExecuteBeforeSolutionLoop() override
    {
    }
 
 
    void ExecuteInitializeSolutionStep() override
    {
    }
 
    void ExecuteFinalizeSolutionStep() override
    {
    }
 
 
    void ExecuteBeforeOutputStep() override
    {
    }
 
 
    void ExecuteAfterOutputStep() override
    {
    }
 
 
    void ExecuteFinalize() override
    {
    AssignTorqueAboutAnAxisToConditionsProcess::ExecuteFinalize();
    }
 
 
 
 
 
 
 
    std::string Info() const override
    {
        return "AssignTorqueFieldAboutAnAxisToConditionsProcess";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "AssignTorqueFieldAboutAnAxisToConditionsProcess";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
 
 
protected:
 
 
    pybind11::object mPyObject;
    std::string mPyMethodName;
 
    bool mIsSpatialField;
 
 
    AssignTorqueFieldAboutAnAxisToConditionsProcess(AssignTorqueFieldAboutAnAxisToConditionsProcess const& rOther);
 
 
private:
 
 
 
 
 
    void CallFunction(const Node::Pointer& pNode, const double& time, double& rValue)
    {
      KRATOS_TRY
 
      if( mIsSpatialField ){
 
    double x = pNode->X(), y = pNode->Y(), z = pNode->Z();
 
       rValue = mPyObject.attr(mPyMethodName.c_str())(x,y,z,time).cast<double>();
      }
      else{
 
        rValue = mPyObject.attr(mPyMethodName.c_str())(0.0,0.0,0.0,time).cast<double>();
      }
 
     KRATOS_CATCH( "" )
 
    }
 
    void CallTimeFunction(const double& time, double& rValue)
    {
 
      KRATOS_TRY
 
      rValue = mPyObject.attr(mPyMethodName.c_str())(0.0,0.0,0.0,time).cast<double>();
 
      KRATOS_CATCH( "" )
 
    }
 
 
 
    AssignTorqueFieldAboutAnAxisToConditionsProcess& operator=(AssignTorqueFieldAboutAnAxisToConditionsProcess const& rOther);
 
 
 
}; // Class AssignTorqueFieldAboutAnAxisToConditionsProcess
 
 
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  AssignTorqueFieldAboutAnAxisToConditionsProcess& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const AssignTorqueFieldAboutAnAxisToConditionsProcess& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_ASSIGN_TORQUE_FIELD_ABOUT_AN_AXIS_TO_CONDITIONS_PROCESS_H_INCLUDED  defined