real_field_linear_time_dependant_coeff.h

Go to the documentation of this file.

#ifndef KRATOS_REAL_FIELD_LINEAR_TIME_DEPENDANT_COEFF_H
#define KRATOS_REAL_FIELD_LINEAR_TIME_DEPENDANT_COEFF_H
// /* External includes */
 
// System includes
 
// Project includes
#include "includes/variables.h"
 
/* System includes */
#include <limits>
#include <iostream>
#include <iomanip>
 
/* External includes */
#ifdef _OPENMP
#include <omp.h>
#endif
 
/* Project includes */
#include "includes/define.h"
#include "utilities/openmp_utils.h"
#include "real_field.h"
 
namespace Kratos
{
class LinearRealField: public RealField
{
public:
 
KRATOS_CLASS_POINTER_DEFINITION(LinearRealField);
 
 
LinearRealField(const double& a0, const double& b0, const double& c0,
                RealFunction& fa, RealFunction& fb, RealFunction& fc)
              : mX0(a0), mY0(b0), mZ0(c0), mFx(fa), mFy(fb), mFz(fc)
{}
 
 
virtual ~LinearRealField(){}
 
 
//***************************************************************************************************************
//***************************************************************************************************************
 
double Evaluate(const double time, const array_1d<double, 3>& coor) override
{
    return mX0 + mFx.Evaluate(time) * coor[0] + mY0 + mFy.Evaluate(time) * coor[1] + mZ0 + mFz.Evaluate(time) * coor[2];
}
 
//***************************************************************************************************************
//***************************************************************************************************************
 
double CalculateTimeDerivative(const double time, const array_1d<double, 3>& coor) override
{
    return mFx.CalculateDerivative(time) * coor[0] + mY0 + mFy.CalculateDerivative(time) * coor[1] + mZ0 + mFz.CalculateDerivative(time) * coor[2];;
}
 
//***************************************************************************************************************
//***************************************************************************************************************
 
void CalculateGradient(const double time, const array_1d<double, 3>& coor, array_1d<double, 3>& gradient) override
{
    gradient = ZeroVector(3);
}
 
//***************************************************************************************************************
//***************************************************************************************************************
 
void CalculateLaplacian(const double time, const array_1d<double, 3>& coor, array_1d<double, 3>& laplacian) override
{
    laplacian = ZeroVector(3);
}
 
//***************************************************************************************************************
//***************************************************************************************************************
 
 
 
 
 
virtual std::string Info() const override
{
return "";
}
 
 
virtual void PrintInfo(std::ostream& rOStream) const override
{
}
 
 
virtual void PrintData(std::ostream& rOStream) const override
{
}
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
double mX0;
double mY0;
double mZ0;
RealFunction& mFx;
RealFunction& mFy;
RealFunction& mFz;
 
 
 
 
 
 
 
 
 
LinearRealField & operator=(LinearRealField const& rOther);
 
 
 
}; // Class LinearRealField
 
 
 
 
 
} // namespace Kratos.
 
#endif // KRATOS_REAL_FIELD_LINEAR_TIME_DEPENDANT_COEFF_H