vector_field.h

Go to the documentation of this file.

#if !defined(KRATOS_VECTOR_FIELD_H)
#define KRATOS_VECTOR_FIELD_H
 
/* System includes */
#include <limits>
#include <iostream>
#include <iomanip>
 
/* External includes */
#ifdef _OPENMP
#include <omp.h>
#endif
 
/* Project includes */
#include "includes/define.h"
#include "includes/variables.h"
#include "utilities/openmp_utils.h"
#include "real_functions.h"
#include "includes/variables.h"
#include "includes/model_part.h"
 
namespace Kratos
{
template<std::size_t TDim>
class VectorField
{
public:
 
KRATOS_CLASS_POINTER_DEFINITION(VectorField);
 
 
VectorField():
mUx(LinearFunction(0, 0)), mUy(LinearFunction(0, 0)), mUz(LinearFunction(0, 0)){}
 
VectorField(RealFunction& u_x, RealFunction& u_y, RealFunction& u_z):
mUx(u_x), mUy(u_y), mUz(u_z){}
 
virtual ~VectorField(){}
 
 
//***************************************************************************************************************
//***************************************************************************************************************
 
virtual void Evaluate(const double time, const array_1d<double, 3>& coor, array_1d<double, 3>& vector, const int i_thread = 0)
{
    vector[0] = 0.0;
    vector[1] = 0.0;
    vector[2] = 0.0;
}
 
virtual void CalculateTimeDerivative(const double time, const array_1d<double, 3>& coor, array_1d<double, 3>& deriv, const int i_thread = 0){}
 
virtual void CalculateGradient(const double time, const array_1d<double, 3>& coor, array_1d< array_1d<double, 3>, 3>& gradient, const int i_thread = 0){}
 
virtual double CalculateDivergence(const double time, const array_1d<double, 3>& coor, const int i_thread = 0){return 0.0;}
 
virtual void CalculateRotational(const double time, const array_1d<double, 3>& coor, array_1d<double, 3>& rot, const int i_thread = 0){}
 
virtual void CalculateLaplacian(const double time, const array_1d<double, 3>& coor, array_1d<double, 3>& lapl, const int i_thread = 0){}
 
virtual void Evaluate(const double time, const DenseVector<double>& coor, DenseVector<double>& result, const int i_thread = 0)
{
    result[0] = 0.0;
    result[1] = 0.0;
    result[2] = 0.0;
}
 
virtual void CalculateTimeDerivative(const double time, const DenseVector<double>& coor, DenseVector<double>& result, const int i_thread = 0){}
 
virtual double CalculateDivergence(const double time, const DenseVector<double>& coor, const int i_thread = 0){return 0.0;}
 
virtual void CalculateRotational(const double time, const DenseVector<double>& coor, DenseVector<double>& result, const int i_thread = 0){}
 
virtual void CalculateLaplacian(const double time, const DenseVector<double>& coor, DenseVector<double>& result, const int i_thread = 0){}
 
virtual void ResizeVectorsForParallelism(const int n_threads){}
 
virtual void ImposeFieldOnNodes(ModelPart& r_model_part, const VariablesList& variables_to_be_imposed){}
 
//virtual void ImposeVelocityOnNodes(ModelPart& r_model_part, const VariableData& container_variable){}
 
//***************************************************************************************************************
//***************************************************************************************************************
 
 
 
 
 
virtual std::string Info() const
{
    return "";
}
 
 
virtual void PrintInfo(std::ostream& rOStream) const
{
}
 
 
virtual void PrintData(std::ostream& rOStream) const
{
}
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
 
RealFunction mUx;
RealFunction mUy;
RealFunction mUz;
 
 
 
 
 
 
 
 
 
VectorField & operator=(VectorField const& rOther);
 
 
 
}; // Class VectorField
 
 
 
 
 
} // namespace Kratos.
 
#endif // KRATOS_VECTOR_FIELD_H defined