MoFEM::TimeScale Struct Reference

Force scale operator for reading two columns. More...

#include <src/boundary_conditions/ScalingMethod.hpp>

Inheritance diagram for MoFEM::TimeScale:

Collaboration diagram for MoFEM::TimeScale:

Public Member Functions
	TimeScale (std::string file_name="", bool error_if_file_not_given=false)
	TimeScale constructor. More...
	TimeScale (std::string file_name, std::string delimiter, bool error_if_file_not_given=false)
	TimeScale constructor. More...
double	getScale (const double time)
	Get scaling at a given time. More...
Public Member Functions inherited from MoFEM::ScalingMethod
	ScalingMethod ()=default
virtual	~ScalingMethod ()=default

Private Member Functions
MoFEMErrorCode	timeData (std::string fileName, std::string delimiter)
double	getScaleFromData (const double time)
	Get scaling at a given time when the scalar values have been provided. Uses linear interpolation on the nearest time range to calculate scaling if the provided time is not present in the data. More...
double	getLinearScale (const double time)
	Returns the value of time. More...

Private Attributes
std::map< double, double >	tSeries
std::string	fileName = ""
std::string	fileNameFlag = "-time_scalar_file"
bool	errorIfFileNotGiven
std::function< double(double)>	scalingMethod

Static Private Attributes
static const std::string	defaultDelimiter
	comma or space More...

Detailed Description

Force scale operator for reading two columns.

Examples

dynamic_first_order_con_law.cpp, and plastic.cpp.

Definition at line 32 of file ScalingMethod.hpp.

Constructor & Destructor Documentation

TimeScale() [1/2]

MoFEM::TimeScale::TimeScale	(	std::string	file_name = "",
		bool	error_if_file_not_given = false
	)

TimeScale constructor.

Parameters

file_name	Path to input CSV data file
error_if_file_not_given	If file name is not provided, the constructor will throw an error if this flag is set to true or throw a warning and use linear scaling if this flag is set to false

Examples

dynamic_first_order_con_law.cpp, and plastic.cpp.

Definition at line 22 of file ScalingMethod.cpp.

    : TimeScale(file_name, defaultDelimiter, error_if_file_not_given) {}

TimeScale() [2/2]

MoFEM::TimeScale::TimeScale	(	std::string	file_name,
		std::string	delimiter,
		bool	error_if_file_not_given = false
	)

TimeScale constructor.

Parameters

file_name	Path to input CSV data file
delimiter	Character which is used to separate the data in a csv row, by default it is ','
error_if_file_not_given	If file name is not provided, the constructor will throw an error if this flag is set to true or throw a warning and use linear scaling if this flag is set to false

Definition at line 25 of file ScalingMethod.cpp.

    : fileName(file_name), errorIfFileNotGiven(error_if_file_not_given) {
  CHK_THROW_MESSAGE(timeData(file_name, delimiter),
                    "Error in reading time data");
}

Member Function Documentation

getLinearScale()

double MoFEM::TimeScale::getLinearScale ( const double  time )

private

Returns the value of time.

Returns

double

Definition at line 103 of file ScalingMethod.cpp.

{ return time; }

getScale()

double MoFEM::TimeScale::getScale ( const double  time )

virtual

Get scaling at a given time.

Parameters

time

Returns

double

Reimplemented from MoFEM::ScalingMethod.

Reimplemented in Example::DynamicFirstOrderConsConstantTimeScale, Example::DynamicFirstOrderConsSinusTimeScale, LinMomTimeScale, Example::ScaledTimeScale, and Contact::ScaledTimeScale.

Examples

dynamic_first_order_con_law.cpp, and plastic.cpp.

Definition at line 133 of file ScalingMethod.cpp.

{ return scalingMethod(time); }

getScaleFromData()

double MoFEM::TimeScale::getScaleFromData ( const double  time )

private

Get scaling at a given time when the scalar values have been provided. Uses linear interpolation on the nearest time range to calculate scaling if the provided time is not present in the data.

Returns

double

Definition at line 105 of file ScalingMethod.cpp.

                                                    {
  if (tSeries.empty())
    return 0.;
 
  auto it = tSeries.find(time);
  if (it != tSeries.end()) {
    return it->second;
  } else {
    auto it = tSeries.lower_bound(time);
    if (it == tSeries.end()) {
      return (--it)->second;
    }
    if (it == tSeries.begin()) {
      return it->second;
    }
    auto upper = *(it);
    it--;
    if (it == tSeries.end()) {
      return upper.second;
    }
    auto lower = *it;
    double t = (time - lower.first) / (upper.first - lower.first);
    double scale1 = upper.second;
    double scale0 = lower.second;
    return scale0 + t * (scale1 - scale0);
  }
}

timeData()

MoFEMErrorCode MoFEM::TimeScale::timeData ( std::string  fileName, std::string  delimiter  )

private

Definition at line 32 of file ScalingMethod.cpp.

                                                        {
  MoFEMFunctionBegin;
  MOFEM_LOG_CHANNEL("WORLD");
  // Set the argument found flag to false as default
  PetscBool arg_found = PETSC_FALSE;
  char time_file_name[255] = {'\0'};
  // Check to see if a filename has been provided
  if (fileName.empty()) {
    // If no filename, look for command line argument
    CHKERR PetscOptionsGetString(PETSC_NULL, PETSC_NULL, fileNameFlag.c_str(),
                                 time_file_name, 255, &arg_found);
    if (arg_found) {
      fileName = std::string(time_file_name);
    }
  } else {
    // Set the command line flag to true for correct flow control using provided
    // filename
    arg_found = PETSC_TRUE;
  }
  if (!arg_found && fileName.empty() && errorIfFileNotGiven) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "*** ERROR %s (time_data FILE NEEDED)", fileName.c_str());
  } else if (!arg_found && fileName.empty() && !errorIfFileNotGiven) {
    MOFEM_LOG_C("WORLD", Sev::warning,
                "The %s file not provided. Loading scaled with time.",
                fileName.c_str());
    scalingMethod = [this](double time) { return this->getLinearScale(time); };
    MoFEMFunctionReturnHot(0);
  }
 
  std::ifstream in_file_stream(fileName);
  if (!in_file_stream.is_open() && errorIfFileNotGiven) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "*** ERROR data file < %s > open unsuccessful", fileName.c_str());
  } else if (!in_file_stream.is_open() && !errorIfFileNotGiven) {
    MOFEM_LOG("WORLD", Sev::warning)
        << "*** Warning data file " << fileName
        << " open unsuccessful. Using linear time scaling.";
    scalingMethod = [this](double time) { return this->getLinearScale(time); };
    MoFEMFunctionReturnHot(0);
  }
 
  in_file_stream.seekg(0);
  std::string line;
  double time = 0.0, value = 0.0;
  tSeries[time] = value;
 
  std::regex rgx(delimiter.c_str());
  std::sregex_token_iterator end;
  while (std::getline(in_file_stream, line)) {
    std::sregex_token_iterator iter(line.begin(), line.end(), rgx, -1);
    auto time_str = iter;
    auto value_str = ++iter;
    if (time_str == end || value_str == end) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "*** ERROR read data file error (check input time data file) ");
    }
    time = std::stod(time_str->str());
    value = std::stod(value_str->str());
    tSeries[time] = value;
  }
  in_file_stream.close();
  scalingMethod = [this](double time) { return this->getScaleFromData(time); };
  if (in_file_stream.is_open()) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "*** ERROR file close unsuccessful");
  }
  MoFEMFunctionReturn(0);
}

Member Data Documentation

defaultDelimiter

const std::string MoFEM::TimeScale::defaultDelimiter

staticprivate

Initial value:

=
    "(\\s*,\\s*|\\s+)"

comma or space

Definition at line 87 of file ScalingMethod.hpp.

errorIfFileNotGiven

bool MoFEM::TimeScale::errorIfFileNotGiven

private

Definition at line 89 of file ScalingMethod.hpp.

fileName

std::string MoFEM::TimeScale::fileName = ""

private

Definition at line 83 of file ScalingMethod.hpp.

fileNameFlag

std::string MoFEM::TimeScale::fileNameFlag = "-time_scalar_file"

private

Definition at line 84 of file ScalingMethod.hpp.

scalingMethod

std::function<double(double)> MoFEM::TimeScale::scalingMethod

private

Initial value:

= [](double time) {
    return time;
  }

Definition at line 90 of file ScalingMethod.hpp.

tSeries

std::map<double, double> MoFEM::TimeScale::tSeries

private

Definition at line 82 of file ScalingMethod.hpp.

---

The documentation for this struct was generated from the following files:

• src/boundary_conditions/ScalingMethod.hpp
• src/boundary_conditions/impl/ScalingMethod.cpp