Common class#

template<class T> struct add_pointer#

#include <variant_lite.hpp>

Public Types

typedef remove_reference<T>::type *type#

struct aligned_storage_t#

#include <optional_lite.hpp>

Public Members

align_as_type data[1 + (sizeof(value_type) - 1) / sizeof(align_as_type)]#

union aligned_storage_t#

Public Members

align_as_type data[1 + (data_size - 1) / sizeof(align_as_type)]#

template<size_t A, size_t S> struct alignment_logic#

#include <optional_lite.hpp>

Public Types

: Values:

template<size_t A, size_t S> struct alignment_logic#

#include <variant_lite.hpp>

Public Types

enum V#: Values:

template<typename T> struct alignment_of#

#include <optional_lite.hpp>

Public Types

Values:

enumerator value#

template<typename T> struct alignment_of#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<typename T> struct alignment_of_hack#

#include <optional_lite.hpp>

Public Functions

alignment_of_hack()#

Public Members

char c#

T t#

template<typename T> struct alignment_of_hack#

#include <variant_lite.hpp>

Public Functions

alignment_of_hack()#

Public Members

char c#

T t#

class AsciiDocExporter : public tabulate::Exporter #

#include <asciidoc_exporter.hpp>

Public Functions

inline virtual std::string dump(Table &table) override#

inline virtual ~AsciiDocExporter()#

Private Functions

inline std::string add_formatted_cell(Cell &cell) const#

inline std::string add_alignment_header(Table &table)#

Private Static Attributes

static const char new_line = '\n'#

class Cell#

#include <cell.hpp>

Public Functions

inline explicit Cell(std::shared_ptr<class Row> parent)#

inline void set_text(const std::string &text)#

inline const std::string &get_text()#

inline size_t size()#

inline std::string locale()#

inline Format &format()#

inline bool is_multi_byte_character_support_enabled()#

Private Members

std::string data_#

std::weak_ptr<class Row> parent_#

optional<Format> format_#

class CellIterator#

#include <column.hpp>

Public Functions

inline explicit CellIterator(std::vector<std::reference_wrapper<Cell>>::iterator ptr)#

inline CellIterator operator++()#

inline bool operator!=(const CellIterator &other) const#

inline Cell &operator*()#

Private Members

std::vector<std::reference_wrapper<Cell>>::iterator ptr#

class CellIterator#

#include <row.hpp>

Public Functions

inline explicit CellIterator(std::vector<std::shared_ptr<Cell>>::iterator ptr)#

inline CellIterator operator++()#

inline bool operator!=(const CellIterator &other) const#

inline Cell &operator*()#

Private Members

std::vector<std::shared_ptr<Cell>>::iterator ptr#

class Column#

#include <column.hpp>

Public Functions

inline explicit Column(std::shared_ptr<class TableInternal> parent)#

inline void add_cell(Cell &cell)#

inline Cell &operator[](size_t index)#

inline std::vector<std::reference_wrapper<Cell>> cells() const#

inline size_t size() const#

inline ColumnFormat format()#

inline auto begin() -> CellIterator #

inline auto end() -> CellIterator #

Private Functions

inline size_t get_configured_width()#

inline size_t get_computed_width()#

inline size_t get_cell_width(size_t cell_index)#

Private Members

std::vector<std::reference_wrapper<Cell>> cells_#

std::weak_ptr<class TableInternal> parent_#

Friends

friend class ColumnFormat

friend class Printer

class ColumnFormat : public tabulate::Format #

#include <column_format.hpp>

Public Functions

inline explicit ColumnFormat(class Column &column)#

inline ColumnFormat &width(size_t value)#

inline ColumnFormat &height(size_t value)#

inline ColumnFormat &padding(size_t value)#

inline ColumnFormat &padding_left(size_t value)#

inline ColumnFormat &padding_right(size_t value)#

inline ColumnFormat &padding_top(size_t value)#

inline ColumnFormat &padding_bottom(size_t value)#

inline ColumnFormat &border(const std::string &value)#

inline ColumnFormat &border_color(Color value)#

inline ColumnFormat &border_background_color(Color value)#

inline ColumnFormat &border_left(const std::string &value)#

inline ColumnFormat &border_left_color(Color value)#

inline ColumnFormat &border_left_background_color(Color value)#

inline ColumnFormat &border_right(const std::string &value)#

inline ColumnFormat &border_right_color(Color value)#

inline ColumnFormat &border_right_background_color(Color value)#

inline ColumnFormat &border_top(const std::string &value)#

inline ColumnFormat &border_top_color(Color value)#

inline ColumnFormat &border_top_background_color(Color value)#

inline ColumnFormat &border_bottom(const std::string &value)#

inline ColumnFormat &border_bottom_color(Color value)#

inline ColumnFormat &border_bottom_background_color(Color value)#

inline ColumnFormat &corner(const std::string &value)#

inline ColumnFormat &corner_color(Color value)#

inline ColumnFormat &corner_background_color(Color value)#

inline ColumnFormat &column_separator(const std::string &value)#

inline ColumnFormat &column_separator_color(Color value)#

inline ColumnFormat &column_separator_background_color(Color value)#

inline ColumnFormat &font_align(FontAlign value)#

inline ColumnFormat &font_style(const std::vector<FontStyle> &style)#

inline ColumnFormat &font_color(Color value)#

inline ColumnFormat &font_background_color(Color value)#

inline ColumnFormat &color(Color value)#

inline ColumnFormat &background_color(Color value)#

inline ColumnFormat &multi_byte_characters(bool value)#

inline ColumnFormat &locale(const std::string &value)#

Private Members

std::reference_wrapper<class Column> column_#

template<class Variant> struct Comparator#

#include <variant_lite.hpp>

Public Static Functions

static inline bool equal(Variant const &v, Variant const &w)#

static inline bool less_than(Variant const &v, Variant const &w)#

template<bool B, typename T, typename F> struct conditional#

#include <optional_lite.hpp>

Public Types

typedef T type#

template<bool Cond, class Then, class Else> struct conditional#

template<typename T, typename F> struct conditional<false, T, F>#

#include <optional_lite.hpp>

Public Types

typedef F type#

template<class Then, class Else> struct conditional<false, Then, Else>#

#include <variant_lite.hpp>

Public Types

typedef Else type#

template<class Then, class Else> struct conditional<true, Then, Else>#

#include <variant_lite.hpp>

Public Types

typedef Then type#

class csvfile#

#include <csvfile.h>

Public Functions

inline csvfile(const std::string filename, const std::string separator = ";")#

inline ~csvfile()#

inline void flush()#

inline void endrow()#

inline csvfile &operator<<(csvfile &(*val)(csvfile&))#

inline csvfile &operator<<(const char *val)#

inline csvfile &operator<<(const std::string &val)#

template<typename T> inline csvfile &operator<<(const T &val)#

Private Functions

template<typename T> inline csvfile &write(const T &val)#

inline std::string escape(const std::string &val)#

Private Members

std::ofstream fs_#

bool is_first_#

const std::string separator_#

const std::string escape_seq_#

const std::string special_chars_#

struct energy_type#

#include <openfdem_general.h>

Public Functions

inline energy_type()#

Public Members

Real external_work = 0.0#

Real internal_energy = 0.0#

Real gravity_energy = 0.0#

Real kinetic_energy = 0.0#

Real damping_energy = 0.0#

Real absorbing_energy = 0.0#

Real contactFrictionEnergy = 0.0#

Real contactNormalEnergy = 0.0#

Real element_energy = 0.0#

Real cohesive_energy = 0.0#

Real kinetic_ratio = 0.0#

class Exporter#

#include <exporter.hpp>

Subclassed by tabulate::AsciiDocExporter, tabulate::LatexExporter, tabulate::MarkdownExporter

Public Functions

virtual std::string dump(Table &table) = 0#

inline virtual ~Exporter()#

class ExportOptions#

#include <latex_exporter.hpp>

Public Functions

inline ExportOptions &indentation(std::size_t value)#

Private Members

optional<size_t> indentation_#

Friends

friend class LatexExporter

class Format#

#include <format.hpp>

Subclassed by tabulate::ColumnFormat

Public Functions

inline Format &width(size_t value)#

inline Format &height(size_t value)#

inline Format &padding(size_t value)#

inline Format &padding_left(size_t value)#

inline Format &padding_right(size_t value)#

inline Format &padding_top(size_t value)#

inline Format &padding_bottom(size_t value)#

inline Format &border(const std::string &value)#

inline Format &border_color(Color value)#

inline Format &border_background_color(Color value)#

inline Format &border_left(const std::string &value)#

inline Format &border_left_color(Color value)#

inline Format &border_left_background_color(Color value)#

inline Format &border_right(const std::string &value)#

inline Format &border_right_color(Color value)#

inline Format &border_right_background_color(Color value)#

inline Format &border_top(const std::string &value)#

inline Format &border_top_color(Color value)#

inline Format &border_top_background_color(Color value)#

inline Format &border_bottom(const std::string &value)#

inline Format &border_bottom_color(Color value)#

inline Format &border_bottom_background_color(Color value)#

inline Format &show_border()#

inline Format &hide_border()#

inline Format &show_border_top()#

inline Format &hide_border_top()#

inline Format &show_border_bottom()#

inline Format &hide_border_bottom()#

inline Format &show_border_left()#

inline Format &hide_border_left()#

inline Format &show_border_right()#

inline Format &hide_border_right()#

inline Format &corner(const std::string &value)#

inline Format &corner_color(Color value)#

inline Format &corner_background_color(Color value)#

inline Format &corner_top_left(const std::string &value)#

inline Format &corner_top_left_color(Color value)#

inline Format &corner_top_left_background_color(Color value)#

inline Format &corner_top_right(const std::string &value)#

inline Format &corner_top_right_color(Color value)#

inline Format &corner_top_right_background_color(Color value)#

inline Format &corner_bottom_left(const std::string &value)#

inline Format &corner_bottom_left_color(Color value)#

inline Format &corner_bottom_left_background_color(Color value)#

inline Format &corner_bottom_right(const std::string &value)#

inline Format &corner_bottom_right_color(Color value)#

inline Format &corner_bottom_right_background_color(Color value)#

inline Format &column_separator(const std::string &value)#

inline Format &column_separator_color(Color value)#

inline Format &column_separator_background_color(Color value)#

inline Format &font_align(FontAlign value)#

inline Format &font_style(const std::vector<FontStyle> &style)#

inline Format &font_color(Color value)#

inline Format &font_background_color(Color value)#

inline Format &color(Color value)#

inline Format &background_color(Color value)#

inline Format &multi_byte_characters(bool value)#

inline Format &locale(const std::string &value)#

Public Static Functions

static inline std::string word_wrap(const std::string &str, size_t width, const std::string &locale, bool is_multi_byte_character_support_enabled)#

static inline std::vector<std::string> split_lines(const std::string &text, const std::string &delimiter, const std::string &locale, bool is_multi_byte_character_support_enabled)#

static inline Format merge(Format first, Format second)#

Private Functions

inline void set_defaults()#

Private Members

optional<size_t> width_ = {}#

optional<size_t> height_ = {}#

optional<FontAlign> font_align_ = {}#

optional<std::vector<FontStyle>> font_style_ = {}#

optional<Color> font_color_ = {}#

optional<Color> font_background_color_ = {}#

optional<size_t> padding_left_ = {}#

optional<size_t> padding_top_ = {}#

optional<size_t> padding_right_ = {}#

optional<size_t> padding_bottom_ = {}#

optional<bool> show_border_top_ = {}#

optional<std::string> border_top_ = {}#

optional<Color> border_top_color_ = {}#

optional<Color> border_top_background_color_ = {}#

optional<bool> show_border_bottom_ = {}#

optional<std::string> border_bottom_ = {}#

optional<Color> border_bottom_color_ = {}#

optional<Color> border_bottom_background_color_ = {}#

optional<bool> show_border_left_ = {}#

optional<std::string> border_left_ = {}#

optional<Color> border_left_color_ = {}#

optional<Color> border_left_background_color_ = {}#

optional<bool> show_border_right_ = {}#

optional<std::string> border_right_ = {}#

optional<Color> border_right_color_ = {}#

optional<Color> border_right_background_color_ = {}#

optional<std::string> corner_top_left_ = {}#

optional<Color> corner_top_left_color_ = {}#

optional<Color> corner_top_left_background_color_ = {}#

optional<std::string> corner_top_right_ = {}#

optional<Color> corner_top_right_color_ = {}#

optional<Color> corner_top_right_background_color_ = {}#

optional<std::string> corner_bottom_left_ = {}#

optional<Color> corner_bottom_left_color_ = {}#

optional<Color> corner_bottom_left_background_color_ = {}#

optional<std::string> corner_bottom_right_ = {}#

optional<Color> corner_bottom_right_color_ = {}#

optional<Color> corner_bottom_right_background_color_ = {}#

optional<std::string> column_separator_ = {}#

optional<Color> column_separator_color_ = {}#

optional<Color> column_separator_background_color_ = {}#

optional<bool> multi_byte_characters_ = {}#

optional<std::string> locale_ = {}#

Private Static Functions

static inline std::string trim_left(const std::string &input_string)#

static inline std::string trim_right(const std::string &input_string)#

static inline std::string trim(const std::string &input_string)#

static inline size_t index_of_any(const std::string &input, size_t start_index, const std::vector<std::string> &split_characters)#

static inline std::vector<std::string> explode_string(const std::string &input, const std::vector<std::string> &split_characters)#

Friends

friend class Cell

friend class Row

friend class Column

friend class TableInternal

friend class Printer

friend class MarkdownExporter

friend class LatexExporter

friend class AsciiDocExporter

struct General_structure#

#include <openfdem_general.h>

Public Functions

void resize(Int size, Int initialsize = 0)#

void clear()#

Public Members

char RunTime[Openfdem_ARGC_LENGTH] = "\0"#

char InputFileName[Openfdem_ARGC_LENGTH] = "\0"#

char save_path[Openfdem_ARGC_LENGTH] = "\0"#

char save_filename[Openfdem_ARGC_LENGTH] = "\0"#

FILE *inputfile = nullptr#

FILE *logfile = nullptr#

FILE *FilePointer[Openfdem_FILE_LIMIT]#

short FileID = 0#

Int thread = 1#

Int TotalStep = 0#

Int NowStep = 0#

Int ShowIntervalonScreen = 2000#

Int ShowIntervalinLog = 2000#

Int remeshinterval = 0#

Int inletInterval = 0#

Int nodebeforeRead = 0#

Real TimeStep = 0.0#

Real Creepdt = 0.0#

Real CurrentTime = 0.0#

Real remeshTime = 0.0#

Real global_damp = 0.7#

Real massScale = 1.0#

Real solveratio = 1.0e-5#

bool useSolveMode = false#

bool debug = true#

bool is_save_results = false#

bool save_flag = false#

bool update_dt = false#

bool fixeddt = false#

bool check_dt = false#

bool useFastMode = false#

bool usrdefined_dt = false#

Vector2 gravity#

energy_type energy#

solver_base solver#

config config_type = config::PLANESTRESS #

model_t model#

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> struct helper#

#include <variant_lite.hpp>

Public Types

typedef signed char type_index_t#

Public Functions

typedef variant_TL16 (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) variant_types

Public Static Functions

template<class U> static inline U *as(void *data)#

template<class U> static inline U const *as(void const *data)#

static inline type_index_t to_index_t(std::size_t index)#

static inline void destroy(type_index_t index, void *data)#

static inline type_index_t copy_construct(type_index_t const from_index, const void *from_value, void *to_value)#

static inline type_index_t copy_assign(type_index_t const from_index, const void *from_value, void *to_value)#

template<std::size_t K> struct in_place_index_tag#: #include <optional_lite.hpp>

struct in_place_t#: #include <optional_lite.hpp>

template<class T> struct in_place_type_tag#: #include <optional_lite.hpp>

struct init#: #include <optional_lite.hpp>

struct Keywords#

#include <openfdem_struct.h>

Public Functions

inline Keywords()#

inline void clean()#

Public Members

char copy[MAX_CHARACTER]#

char *keywords[MAX_KEYWORDS]#

Int MAXNUM = MAX_KEYWORDS#

Int count = 0#

bool findbracket = false#

class LatexExporter : public tabulate::Exporter #

#include <latex_exporter.hpp>

Public Functions

inline ExportOptions &configure()#

inline virtual std::string dump(Table &table) override#

inline virtual ~LatexExporter()#

Private Functions

inline std::string add_alignment_header(Table &table)#

Private Members

ExportOptions options_#

Private Static Attributes

static const char new_line = '\n'#

class Logger#

#include <logger.h>

Logger class used by OOFEM to print information during analysis. Prints warnings and errors into a separate stream from normal output.

Public Types

enum logLevelType#

Type defining basic log levels.

Values:

enumerator LOG_LEVEL_FORCED#

enumerator LOG_LEVEL_FATAL#

enumerator LOG_LEVEL_ERROR#

enumerator LOG_LEVEL_WARNING#

enumerator LOG_LEVEL_RELEVANT#

enumerator LOG_LEVEL_INFO#

enumerator LOG_LEVEL_ALL#

enumerator LOG_LEVEL_DEBUG#

Public Functions

Logger(logLevelType level)#

~Logger()#

void appendLogTo(const std::string &fname)#: Redirects log output to given file name (with path).

void appendErrorTo(const std::string &fname)#: Redirects error output to given file name (with path).

void appendLogTo(FILE *stream)#: Redirects log output to given stream.

void appendErrorTo(FILE *stream)#: Redirects error output to given stream.

void writeLogMsg(logLevelType level, const char *format, ...)#: Writes the normal log message.

void writeELogMsg(logLevelType level, const char *_func, const char *_file, int _line, const char *format, ...)#: Writes extended log message with file and line info.

void writeExitMsg(const char *_func, const char *_file, int _line)#: Writes exit information.

void writeImplementLogMsg(const char *_func, const char *_file, int _line)#: write information to be implemented

inline void flush()#: Flushes the log stream.

inline void setLogLevel(logLevelType level)#: Sets log level to given one. Only log messages with level less or equal given threshold will be printed.

void setLogLevel(int level)#: Sets log level to given one. Only log messages with level less or equal given threshold will be printed.

inline void incrementErrorCounter()#: Increment error count by one.

void printStatistics()#: Prints number of errors and warning logged.

Protected Functions

const char *giveLevelName(logLevelType l) const#

Protected Attributes

FILE *logStream#: Stream used for logging.

FILE *errStream#

bool closeFlag#: flag indicating whether to close mylogStream.

bool errCloseFlag#

logLevelType logLevel#: Current log level, messages with higher level are not reported.

int numberOfWrn#: Counter of all warning and error messages.

int numberOfErr#

class MarkdownExporter : public tabulate::Exporter #

#include <markdown_exporter.hpp>

Public Functions

inline virtual std::string dump(Table &table) override#

inline virtual ~MarkdownExporter()#

Private Functions

inline void add_alignment_header_row(Table &table)#

inline void remove_alignment_header_row(Table &table)#

inline void apply_markdown_format(Table &table)#

inline void restore_table_format(Table &table)#

Private Members

std::vector<Format> formats_#

class Matrix#

#include <openfdem_matrix.h>

Class : dynamic Matrix (Real), it is used to create dynamic matrix assigned by the user according to the row and coloumn of the matrix

Used to manage Matrix The matrix is a dynamic matrix composed by _rows x _cols, 2 x 2 matrix should use the specific type: Matrix2.

Public Functions

Matrix(const Int = 2, const Int = 2, const Real = 0.0)#

Constructor to create a 2x2 matrix with initial value 0.0.

Attention: The matrix class will generate dynamic memory

Parameters:

cloumn – [in] - Matrix column
row – [in] - Matrix row
value – [in] - Initial matrix value

Returns:

The initial matrix

Matrix(const Matrix&)#

constructor by copy from the matrix.

Param :

Matrix(Int rows, Int cols, Real firstValue, Real secondValue, ...)#

constructor by several arguments input.

Parameters:

rows –
cols –
firstValue –
secondValue –

Param :

~Matrix()#: deconstructor.

void allocate(const Int row, const Int coloumn)#

allocate the size of this matrix.

param

Param :

void desallocate()#: freeup the dynamic memory.

inline Real &operator()(Int row, Int coloumn)#

return the matrix compoment. matrix(0,2)

Parameters:

row –
coloumn –

Returns:

Matrix &operator=(const Real &val)#

set the matrix equals to a double value. M = a;

Parameters:: val –
Returns:

Matrix &operator=(const Matrix&)#

set the matrix equals to another matrix. two matrixs should have the same dimension, otherwise resize

M = N;

return

Param :

void operator-=(const Matrix&)#

minus a matrix. M = M - N;

Param :

void operator*=(const Real&)#

element-wise multiply and store the new value in this matrix.

M = M * a;

Param :

void operator/=(const Real&)#

element-wise divid. M = M / a;

Param :

void operator+=(const Matrix&)#

matrix add. M = M + N;

Param :

void print(std::ostream&) const#

log this matrix.

Param :

inline bool indexCheck(Int, Int) const#

check the index of the matrix.

param

Param :
Returns:

bool operator!=(const Matrix&) const#

identify the bool between two matrixs. return true when M != N; otherwise false

return

Param :

bool operator==(const Matrix&) const#

return true when M == N, otherwise false.

return

Param :

Real doubleProduct() const#

This method defines a Real contracted product of two second order tensors. The result of this operation is a scalar defined by:

\[ s = A : B \]

s = T : U = T.ij * U.ji Example :

Tensor tensor1,tensor2;
Real s;
s = tensor1.doubleProduct(tensor2); // Real contracted product

tensor2 Second second order tensor to use for the operation

Returns:

Real getAverageTrace() const#

This method calculates the average of the trace of a square matrix Return: value of the average of the trace of the matrix. s = M.trace / row

Returns:

Real getDeterminant2x2() const#

return the determinant of a 2x2 matrix.

Returns:

Real getDeterminant3x3() const#

return the determinant of a 3x3 matrix.

Returns:

Real getTrace() const#

return the trace of the matrix. s = M.ii

Returns:

Real maxAbsoluteValue() const#

returns the maximum absolute component of a matrix.

Returns:

Real maxValue() const#

returns the maximum component of a matrix.

Returns:

Real minAbsoluteValue() const#

returns the minmum absolute component of a matrix.

Returns:

Real minValue() const#

returns the minmum component of a matrix.

Returns:

inline Real operator()(Int row, Int coloumn) const#

return the compoment of the matrix.

param

Param :
Returns:

inline Real sumTerms() const#

sum the matrix compoment.

Returns:

Int Memory() const#

return the memory size of the matrix.

Returns:

Matrix getSkewSymetricPart() const#

This method extracts the anti-symmetric part of a matrix and returns it

Warning

This method is only available for matrices of size 2 and 3. Return: anti-symmetric part of the matrix.

Returns:

Matrix getSymetricPart() const#

This method extracts the symmetric part of a matrix and returns it

Warning

This method is only available for matrices of size 2 and 3. Return: symmetric part of the matrix.

Returns:

Matrix getTranspose() const#

return the transpose of the matrix.

Returns:

Matrix operator-() const#

negatie a matrix. M = -M

Returns:

Matrix operator-(const Matrix&) const#

minus a matrix. A = M -N

Returns:

Matrix operator*(const Real&) const#

multiply a value and return a new matrix. A = M * c

return

Param :

Matrix operator/(const Real&) const#

divid a value and return a new matrix. A = M /c

return

Param :

Matrix operator+(const Matrix&) const#

add a new matrix. A = M + N

return

Param :

Vector columnSum() const#

return a dynamic vector of the row.

Returns:

Vector getColumn(Int) const#

return a dynamic vector of a assigned column.

return

Param :

Vector getRow(Int) const#

return a dynamic vector of the assigned row.

return

Param :

Vector rowSum() const#

return a vector to sum up the row.

Returns:

void computeInverse2x2(Real det, Matrix &inverse) const#

return the inverse matrix of 2x2 matrix.

Parameters:

det –
inverse –

void computeInverse3x3(Real det, Matrix &inverse) const#

return the inverse matrix of a 3x3 matrix and out the reuslt in a dynamic matrix

Parameters:

det –
inverse –

void computeInverse2x2(Real det, Matrix2 &inverse) const#

return the inverse matrix of a 3x3 matrix and ouput the result in a 3x3 matrix.

Parameters:

det –
inverse –

void resize(const Int, const Int)#

resize the dimension of the matrix.

param

Param :

void setToUnity()#: set the matrix to unit matrix.

void setToValue(Real)#

set the matrix an assigned value.

Param :

Private Members

Int _rows#

Int _cols#

Int _dataLength#

Real *_data#

Friends

friend class Vector

friend Matrix operator*(const Real &val, const Matrix&)#: element-wise multiply a real value M = a * N;

class Matrix2#

#include <openfdem_matrix2x2.h>

Class : Matrix2 (Real) Used to manage Matrix2 The matrix is a fixed matrix composed by _rows x _cols, 2 x 2 matrix should use the specific type .

Public Functions

Matrix2(const Real = 0.0)#: constructor

Matrix2(const Matrix2&)#

Matrix2(Real firstValue, Real secondValue, ...)#

~Matrix2()#

inline Real &operator()(Int row, Int coloumn)#

return the compoment of M(i,j).

Parameters:

row –
coloumn –

Returns:

Matrix2 &operator=(const Real &val)#

set the matrix equals to a double value. M = a;

Parameters:: val –
Returns:

Matrix2 &operator=(const Matrix2&)#

set the matrix equals to another matrix. two matrixs should have the same dimension, otherwise resize

M = N;

return

Param :

Matrix2 &operator=(const Real array[2][2])#

set the matrix equals to another matrix. two matrixs should have the same dimension, otherwise resize

M = N;

return

Param :

void operator-=(const Matrix2&)#

minus a matrix. M = M - N;

Param :

void operator*=(const Real&)#

element-wise multiply and store the new value in this matrix.

M = M * a;

Param :

void operator/=(const Real&)#

element-wise divid. M = M / a;

Param :

void operator+=(const Matrix2&)#

matrix add. M = M + N;

Param :

void print(std::ostream&) const#

log this matrix.

Param :

inline void timesby(const Matrix2&, const Real)#

this = A * s.

param

Param :

inline void addby(const Matrix2&, const Matrix2&)#

get the matrix from two matrixs. this = A + B

param

Param :

inline bool indexCheck(Int row, Int coloumn) const#

check the index of the matrix.

param

Param :
Returns:

bool operator!=(const Matrix2&) const#

identify the bool between two matrixs. return true when M != N; otherwise false

return

Param :

bool operator==(const Matrix2&) const#

return true when M == N, otherwise false.

return

Param :

Real doubleProduct() const#

This method defines a Real contracted product of two second order tensors. The result of this operation is a scalar defined by:

\[ s = A : B \]

s = T : U = T.ij * U.ji Example :

Tensor tensor1,tensor2;
Real s;
s = tensor1.doubleProduct(tensor2); // Real contracted product

tensor2 Second second order tensor to use for the operation

Returns:

Real getAverageTrace() const#

This method calculates the average of the trace of a square matrix Return: value of the average of the trace of the matrix. s = M.trace / row

Returns:

Real getDeterminant() const#

return the determinant of a matrix.

Returns:

Real getTrace() const#

return the trace of the matrix. s = M.ii

Returns:

Real maxAbsoluteValue() const#

returns the maximum absolute component of a matrix.

Returns:

Real maxValue() const#

returns the maximum component of a matrix.

Returns:

Real minAbsoluteValue() const#

returns the minmum absolute component of a matrix.

Returns:

Real minValue() const#

returns the minmum component of a matrix.

Returns:

inline Real operator()(Int, Int) const#

return the compoment of the matrix.

param

Param :
Returns:

inline Real sumTerms() const#

Int Memory() const#

return the memory size of the matrix.

Returns:

Matrix2 getSkewSymetricPart() const#

Matrix2 getSymetricPart() const#

Matrix2 getTranspose() const#

return the transpose of the current matrix.

Returns:

void getTransposefrom(const Matrix2 &matrix)#

compute the transpose of existed matrix and store the result in current matrix.

Parameters:: matrix –

Matrix2 operator-() const#

negatie a matrix. M = -M

Returns:

Matrix2 operator-(const Matrix2&) const#

minus a matrix. A = M -N

Returns:

Matrix2 operator*(const Real&) const#

multiply a value and return a new matrix. A = M * c

return

Param :

Matrix2 operator*(const Matrix2&) const#

multiply a matrix and return a new 2x2 matrix.

return

Param :

Vector2 operator*(const Vector2&) const#

multiply a vector and return a vector. v = M * vc

return

Param :

Matrix2 operator/(const Real&) const#

divid a value and return a new matrix. A = M /c

return

Param :

Matrix2 operator+(const Matrix2&) const#

add a new matrix. A = M + N

return

Param :

Vector2 columnSum() const#

Vector2 getColumn(Int) const#

Vector2 getRow(Int) const#

Vector2 rowSum() const#

void computeInverse(Real det, Matrix2 &inverse) const#

return the inverse matrix of a 3x3 matrix and out the reuslt in a matrix

Parameters:

det –
inverse –

void computeInverse(Matrix2 &inverse) const#: set the matrix to unit matrix.

void setToUnity()#: set the matrix to unit matrix.

void setToValue(Real)#

set the matrix an assigned value.

Param :

void setToZero()#

set the matrix an assigned value.

Param :

void addI()#

Public Members

Real _data[MAX_MATRIX2_SIZE]#

Private Members

friend Matrix

Friends

friend Matrix2 operator*(const Real &val, const Matrix2&)#: return a new matrix by multiply a value with a matrix.

class model : public OpenFdemAbstract#

#include <openfdem_base.h>

Public Functions

inline model()#

inline ~model()#

void initialize(Openfdem openfdem)#

model initialization to set memory of the main structres. the classes will be constructered automatically and double-checked at this step.

Parameters:: openfdem –

void setenvironment(Openfdem openfdem, int argc, char **argv)#

set a new environment for the model.

Parameters:

openfdem –
argc –
argv –

void finalize(Int ret)#

finalize the run. all created variables will be earsed and memory is released in the heap.

Parameters:: ret –

void Run(Openfdem openfdem)#

main run function for the calculation.

Parameters:: openfdem –

Int readRunFile(Openfdem openfdem, char **argv)#

parse the input file.

Parameters:

openfdem –
argv –

Returns:

Private Members

char inputFileFullPath[Openfdem_ARGC_LENGTH]#

char inputFileWithSuffix[Openfdem_ARGC_LENGTH]#

char inputFileName[Openfdem_ARGC_LENGTH]#

struct model_t#

#include <openfdem_general.h>

Public Functions

inline model_t()#

Public Members

bool has_mazars = false#

bool has_JH2 = false#

bool has_Yang = false#

bool has_TCK = false#

bool has_dfb = false#

bool has_plastic = false#

bool has_viscous = false#

bool has_JWL = false#

bool has_nonlocal = false#

bool has_cohesive = false#

bool has_phasefield = false#

bool use_largedeformation = false#

bool has_contact = true#

bool has_blast = false#

bool has_dynamic = false#

bool has_thermal = false#

bool has_hydro = false#

bool has_remesh = false#

bool has_AMR = false#

bool has_AMRdynamic = false#

bool has_GBM = false#

bool has_mmg = false#

bool has_quadratic = false#

bool has_extrinsic = false#

bool has_rigid = false#

bool has_deformable = false#

bool has_particle = false#

bool has_mpm = false#

bool usedu = false#

bool gravityzero = true#

bool has_dynamicCZM = false#

bool useConnect = false#

bool has_hetCZM = false#

class monostate#: #include <variant_lite.hpp>

struct nullopt_t#

#include <optional_lite.hpp>

disengaged state tag

Public Functions

inline explicit optional_constexpr nullopt_t (init) optional_noexcept

struct nulltype#: #include <optional_lite.hpp>

struct nulltype#: #include <variant_lite.hpp>

class OpenFdemAbstract#

#include <openfdem_abstract.h>

Subclassed by ns_common::OpenFDEMTools

Public Functions

OpenFdemAbstract()#

virtual ~OpenFdemAbstract()#

class OpenFDEMchrono#

#include <openfdem_chrono.h>

Public Static Functions

static inline void DateTime(char *date_time)#

static inline void StampTime(void)#

static inline double openfdem_time_count()#

class OpenFDEMmanager#

#include <openfdem_manager.h>

Public Static Functions

static inline void usehelp(char *prog)#

Print help for common options of the 3 codes (first section).

Parameters:: *prog – pointer toward the program name.

static inline bool checkLicense()#

static inline void foldercfg(int argc, char **argv, char *inputFileFullPath, char *inputFileWithSuffix, char *inputFileName, General general)#

static inline void printversion()#

static inline void printCopyrightPage()#

static inline void writepage(FILE *fileptr)#

class OpenFDEMmessage#

#include <openfdem_message.h>

Public Static Functions

static inline void Runtime_message(const char *c1)#

print a string to screen.

Runtime_message("exit with error.");
=> exit with error.\n

Parameters:: c1 –

static inline void RuntimeInfo(const char *c1)#

print a string to screen.

Runtime_message("exit with error.");
=>Info     :exit with error.\n

Parameters:: c1 –

static inline void Runtime_strformat(const char *c1)#

print a formated string to screen.

Runtime_strformat("exit with error.");
=>Info     :exit with error.\n

Parameters:: c1 –

static inline void RuntimeKeywordError(const char *s1, int i1)#

print error message for keword parsing.

RuntimeKeywordError("geometry",12)
=>Info     :Error: unknow keyword [geometry] at line [12]. \n

Parameters:

s1 –
i1 –

static inline void RuntimeStringIntStringInt(const char *s1, int i1, const char *s2, int i2)#

static inline void RuntimeStringtoFile(FILE *fileptr, const char *c1)#

print a string to file.

Runtime_message("exit with error.");
=< exit with error.\n

Parameters:: c1 –

static inline void RuntimebackStringString(const char *c1, const char *c2)#

print a sentence composed by two strings.

RuntimebackStringString("geometry group is","rock.")
=>Info     : geometry group is [rock]. \n

Parameters:

c1 –
c2 –

static inline void RuntimeIntStringString(int n1, const char *c1, const char *c2)#

print a sentence composed by two strings.

   RuntimebackStringString("mesh.msh"," file is imported.")
   =>Info     : [mesh.msh] file is imported. \n
  
   \param c1
   \param c2
  /
static void RuntimefrontStringString(const char* c1, const char* c2)  // print message out to screen
{
    printf("Info     :");
    writeCharValue(stdout, "[");
    writeCharValue(stdout, c1);
    writeCharValue(stdout, "] ");
    writeCharValue(stdout, c2);
    writeCharValue(stdout, "\n");
}

Parameters:

n1 –
c1 –
c2 –

static inline void RuntimeStringInt(const char *c1, int c2)#

print a sentence composed by a string and integer.

RuntimeStringInt("The count of node in the model is ","2300")
=>Info     : The count of node in the model is [2300]. \n

Parameters:

c1 –
c2 –

static inline void RuntimeString(std::string c1)#

static inline void RuntimeStringReal(const char *c1, double c2)#

print a sentence composed by a string and double value.

RuntimeStringReal("The stiffness of the rock is ","1.2e9")
=>Info     : The stiffness of the rock is [1.2e9]. \n

Parameters:

c1 –
c2 –

static inline void RuntimeIntString(int c2, const char *c1)#

print a sentence composed by a integer and a string.

RuntimeStringReal("20","nodes are added in the model.")
=>Info     : [20] nodes are added in the model. \n

Parameters:

c1 –
c2 –

static inline void RuntimeStringIntString(const char *s1, int c2, const char *s2)#

print a sentence composed by a string, integer and a string.

RuntimeStringReal("Congratulation,","20","nodes are added in the model.")
=>Info     :Congratulation, [20] nodes are added in the model. \n

Parameters:

s1 –
c2 –
s2 –

static inline void RuntimeStringStringString(const char *s1, const char *c2, const char *s2)#

print a sentence composed by a string, integer and a string.

RuntimeStringReal("Congratulation,","20","nodes are added in the model.")
=>Info     :Congratulation, [20] nodes are added in the model. \n

Parameters:

s1 –
c2 –
s2 –

static inline void Runtime_writelogs(FILE *checkfile, const char *keyword)#

write parsing log to log file.

Parameters:

checkfile –
keyword –

class OpenFDEMTools : public ns_common::OpenFdemAbstract #

#include <openfdem_tools.h>

Public Static Functions

static void checkmodule(Openfdem openfdem)#

check the module and print out.

Parameters:: openfdem –

static void checkMeshInfo(Openfdem openfdem)#

check mesh and print out info.

Parameters:: openfdem –

static void checkBoundaryInfo(Openfdem openfdem)#

check boundary condition and print out info.

Parameters:: openfdem –

static void checkMaterials(Openfdem openfdem)#

check material and print out info.

Parameters:: openfdem –

static void PrintProgressInfo(Openfdem openfdem)#

print the running progress.

Parameters:: openfdem –

template<typename T> class optional#

#include <optional_lite.hpp>

class optional

optional access error

optional

Public Types

typedef T value_type#

Public Functions

inline optional_constexpr optional () optional_noexcept

inline optional_constexpr optional (nullopt_t) optional_noexcept

inline optional_constexpr14 optional(optional const &other)#

template<typename U> inline optional(optional<U> const &other)#

inline optional(value_type const &value)#

inline ~optional()#

inline optional & operator= (nullopt_t) optional_noexcept

inline optional &operator=(optional const &other)#

template<typename U> inline optional &operator=(U const &value)#

template<typename U> inline optional &operator=(optional<U> const &other)#

inline void swap(optional &other)#

inline optional_constexpr value_type const * operator-> () const

inline optional_constexpr14 value_type * operator-> ()

inline optional_constexpr value_type const & operator* () const optional_ref_qual

inline optional_constexpr14 value_type & operator* () optional_ref_qual

inline optional_constexpr operator safe_bool () const optional_noexcept

inline optional_constexpr bool has_value () const optional_noexcept

inline optional_constexpr14 value_type const & value () const optional_ref_qual

inline optional_constexpr14 value_type & value () optional_ref_qual

template<typename U> inline optional_constexpr value_type value_or (U const &v) const

inline void reset () optional_noexcept

Private Types

typedef void (optional::* safe_bool)() const#

Private Functions

inline void this_type_does_not_support_comparisons() const#

template<typename V> inline void initialize(V const &value)#

Private Members

bool has_value_#

detail::storage_t<value_type> contained#

Friends

friend class optional

class Printer#

#include <printer.hpp>

Public Static Functions

static inline std::pair<std::vector<size_t>, std::vector<size_t>> compute_cell_dimensions(TableInternal &table)#

static inline void print_table(std::ostream &stream, TableInternal &table)#

static inline void print_row_in_cell(std::ostream &stream, TableInternal &table, const std::pair<size_t, size_t> &index, const std::pair<size_t, size_t> &dimension, size_t num_columns, size_t row_index)#

static inline bool print_cell_border_top(std::ostream &stream, TableInternal &table, const std::pair<size_t, size_t> &index, const std::pair<size_t, size_t> &dimension, size_t num_columns)#

static inline bool print_cell_border_bottom(std::ostream &stream, TableInternal &table, const std::pair<size_t, size_t> &index, const std::pair<size_t, size_t> &dimension, size_t num_columns)#

static inline void apply_element_style(std::ostream &stream, Color foreground_color, Color background_color, const std::vector<FontStyle> &font_style)#

static inline void reset_element_style(std::ostream &stream)#

Private Static Functions

static inline void print_content_left_aligned(std::ostream &stream, const std::string &cell_content, const Format &format, size_t text_with_padding_size, size_t column_width)#

static inline void print_content_center_aligned(std::ostream &stream, const std::string &cell_content, const Format &format, size_t text_with_padding_size, size_t column_width)#

static inline void print_content_right_aligned(std::ostream &stream, const std::string &cell_content, const Format &format, size_t text_with_padding_size, size_t column_width)#

static inline void apply_font_style(std::ostream &stream, FontStyle style)#

static inline void apply_foreground_color(std::ostream &stream, Color foreground_color)#

static inline void apply_background_color(std::ostream &stream, Color background_color)#

template<class T> struct remove_const#

#include <variant_lite.hpp>

Public Types

typedef T type#

template<class T> struct remove_const<const T>#

#include <variant_lite.hpp>

Public Types

typedef T type#

template<class T> struct remove_cv#

#include <variant_lite.hpp>

Public Types

typedef remove_volatile<typenameremove_const<T>::type>::type type#

template<class T> struct remove_reference#

#include <variant_lite.hpp>

Public Types

typedef T type#

template<class T> struct remove_reference<T&>#

#include <variant_lite.hpp>

Public Types

typedef T type#

template<class T> struct remove_volatile#

#include <variant_lite.hpp>

Public Types

typedef T type#

template<class T> struct remove_volatile<volatile T>#

#include <variant_lite.hpp>

Public Types

typedef T type#

class Row#

#include <row.hpp>

Public Functions

inline explicit Row(std::shared_ptr<class TableInternal> parent)#

inline void add_cell(std::shared_ptr<Cell> cell)#

inline Cell &operator[](size_t index)#

inline Cell &cell(size_t index)#

inline std::vector<std::shared_ptr<Cell>> cells() const#

inline size_t size() const#

inline Format &format()#

inline auto begin() -> CellIterator #

inline auto end() -> CellIterator #

Private Functions

inline size_t get_configured_height()#

inline size_t get_computed_height(const std::vector<size_t> &column_widths)#

inline size_t get_cell_height(size_t cell_index, size_t column_width)#

Private Members

std::vector<std::shared_ptr<Cell>> cells_#

std::weak_ptr<class TableInternal> parent_#

optional<Format> format_#

Friends

friend class Printer

class RowIterator#

#include <table.hpp>

Public Functions

inline explicit RowIterator(std::vector<std::shared_ptr<Row>>::iterator ptr)#

inline RowIterator operator++()#

inline bool operator!=(const RowIterator &other) const#

inline Row &operator*()#

Private Members

std::vector<std::shared_ptr<Row>>::iterator ptr#

class RuntimeException : public std::exception#

#include <openfdem_error.h>

Public Functions

RuntimeException(const char *_func, const char *_file, int _line, const char *format, ...)#

const char *what() const noexcept override#

Public Members

std::string msg#

struct S0#: #include <variant_lite.hpp>

struct S1#: #include <variant_lite.hpp>

struct S10#: #include <variant_lite.hpp>

struct S11#: #include <variant_lite.hpp>

struct S12#: #include <variant_lite.hpp>

struct S13#: #include <variant_lite.hpp>

struct S14#: #include <variant_lite.hpp>

struct S15#: #include <variant_lite.hpp>

struct S2#: #include <variant_lite.hpp>

struct S3#: #include <variant_lite.hpp>

struct S4#: #include <variant_lite.hpp>

struct S5#: #include <variant_lite.hpp>

struct S6#: #include <variant_lite.hpp>

struct S7#: #include <variant_lite.hpp>

struct S8#: #include <variant_lite.hpp>

struct S9#: #include <variant_lite.hpp>

struct solver_base#

#include <openfdem_general.h>

Public Functions

inline solver_base()#

Public Members

UInt previousCountofNode = 0#

UInt previousCountofElement = 0#

UInt previousCountofCohele = 0#

UInt finishedExcavationSteps = 0#

UInt run_times = 0#

union storage_t#

#include <optional_lite.hpp>

C++03 constructed union to hold value.

Public Types

typedef T value_type#

Public Functions

inline storage_t () optional_is_default explicit storage_t(value_type const &v)

inline void construct_value(value_type const &v)#

inline void destruct_value()#

inline optional_nodiscard value_type const * value_ptr () const

inline value_type *value_ptr()#

inline optional_nodiscard value_type const & value () const optional_ref_qual

inline value_type & value () optional_ref_qual

typedef optional_ALIGN_AS (value_type) align_as_type

inline optional_nodiscard void * ptr () optional_noexcept

inline optional_nodiscard void const * ptr () const optional_noexcept

template<typename U> inline optional_nodiscard U * as ()

template<typename U> inline optional_nodiscard U const * as () const

Public Members

aligned_storage_t data#

class String : public std::string#

#include <openfdem_string.h>

Public Functions

String()#

String(const char*)#

String(const std::string&)#

String(const String&)#

~String()#

String &operator=(const char*)#

bool contains(char c, int = 0) const#

bool contains(const String&, int = 0) const#

bool containsWithCase(const String&, bool) const#

bool empty() const#

bool ok() const#

bool popInt(long&, String = " ")#

bool popReal(double&, String = " ")#

bool popString(String&, String = " ")#

bool scanFileLine(FILE*)#

char firstchar() const#

char lastchar() const#

const char *chars() const#

double getReal() const#

double getRealAtPos(int, String = " ")#

int containsWithCaseSub(const String&, bool) const#

int search(char c, int = 0) const#

int search(const String&, int = 0) const#

long getInt() const#

String &convert(const double, const char* = "%lf")#

String &convert(const int, short leading = 0)#

String &convert(const long, short leading = 0)#

String &replace(const char, const char)#

String &replace(const String&, const String&)#

String afterItem(char c, int = 0) const#

String afterItem(const String&, int = 0) const#

String afterItem(int) const#

String afterLast(const String&) const#

String atItem(char c, int = 0) const#

String atItem(const String&, int = 0) const#

String atItem(int, int) const#

String beforeItem(char c, int = 0) const#

String beforeItem(const String&, int = 0) const#

String beforeItem(int) const#

String beforeLast(const String&) const#

String fromItem(char c, int = 0) const#

String fromItem(const String&, int = 0) const#

String fromItem(int) const#

String operator()(int, int) const#

String subString(int, int) const#

String throughItem(char c, int = 0) const#

String throughItem(const String&, int = 0) const#

String throughItem(int) const#

void addExtension(String)#

void remove(char, int = 0)#

void remove(const String&, int = 0)#

void remove(int, int)#

void fromFile(FILE*)#

void lowerCase()#

void dump(const String&) const#

void strip()#

void toFile(FILE*)#

void upperCase()#

template<typename T> struct struct_t#

#include <optional_lite.hpp>

Public Members

T _#

template<typename T> struct struct_t#

#include <variant_lite.hpp>

Public Members

T _#

class Table#

#include <table.hpp>

Public Types

using Row_t = std::vector<variant<std::string, const char*, string_view, Table>>#

Public Functions

inline Table()#

inline Table &add_row(const Row_t &cells)#

inline Row &operator[](size_t index)#

inline Row &row(size_t index)#

inline Column column(size_t index)#

inline Format &format()#

inline void print(std::ostream &stream)#

inline std::string str()#

inline std::pair<size_t, size_t> shape()#

inline auto begin() -> RowIterator #

inline auto end() -> RowIterator #

Private Members

size_t rows_ = {0}#

size_t cols_ = {0}#

std::shared_ptr<TableInternal> table_#

Friends

friend class MarkdownExporter

friend class LatexExporter

friend class AsciiDocExporter

friend std::ostream &operator<<(std::ostream &stream, const Table &table)#

class TableInternal : public std::enable_shared_from_this<TableInternal>#

#include <table_internal.hpp>

Public Functions

inline void add_row(const std::vector<std::string> &cells)#

inline Row &operator[](size_t index)#

inline const Row &operator[](size_t index) const#

inline Column column(size_t index)#

inline size_t size() const#

inline std::pair<size_t, size_t> shape()#

inline Format &format()#

inline void print(std::ostream &stream)#

inline size_t estimate_num_columns() const#

Public Static Functions

static inline std::shared_ptr<TableInternal> create()#

Private Functions

inline TableInternal()#

TableInternal &operator=(const TableInternal&)#

TableInternal(const TableInternal&)#

Private Members

std::vector<std::shared_ptr<Row>> rows_#

Format format_#

Friends

friend class Table

friend class MarkdownExporter

class Tensor#

#include <openfdem_tensor.h>

Class : Tensor (Real) Used to manage Tensor The second order tensor is constructured as xx, xy, null yx, yy, null null, null, zz

Public Functions

Tensor()#: constructor.

Tensor(Real, Real, Real, Real, Real)#

constructor by input compoments.

param

Param :
Param :
Param :

Tensor(const Tensor&)#

void copy(const Tensor&)#

~Tensor()#

inline Real &operator()(Int, Int)#

return the compoment of T(i,j).

Parameters:

row –
coloumn –

Returns:

inline Real &operator[](Int)#

operator to directly get the compoment using [].

Parameters:: i –
Returns:

inline Real &xx()#

inline Real &xy()#

inline Real &yx()#

inline Real &yy()#

inline Real &zz()#

inline Tensor &operator=(const Real&)#

inline Tensor &operator=(const Real list[])#

inline void getData(Real *list) const#

inline void getData(std::vector<Real> &list) const#

inline Tensor &operator=(const Tensor&)#

build a tensor from a existed tensor.

return

Param :

Tensor &operator=(const Matrix2 &matrix)#

build a tensor from 2x2 matrix, whereas zz is 0.0.

Parameters:: matrix –
Returns:

inline void operator=(const Real tensor[2][2])#

build a tensor from 2x2 array, zz is initialized to 0.0.

Parameters:: tensor –
Returns:

inline void operator=(const Real tensor[3][3])#

inline void operator-=(const Tensor&)#

minus a symmertic tensor.

Param :

inline void operator*=(const Real)#

inline void operator/=(const Real)#

inline void operator+=(const Tensor&)#

void print(std::ostream&) const#

bool operator!=(const Tensor&) const#

bool operator==(const Tensor&) const#

inline void timesby(const Tensor&, const Real)#

inline void addby(const Tensor&, const Tensor&)#

void updateTrialStress(const Tensor&, Real e1, Real e2, Real g)#

void updateTrialfullStress(const Tensor&, Real e1, Real e2, Real g)#

Real doubleProduct() const#

:Tensor::doubleProduct()

:Double contracted product of a second order tensor by itself.

This method defines a Real contracted product of a second order tensor by itself. The result of this operation is a scalar defined by: \begin{equation*} s = \A : \A = \sum_{i=1}^{3} \sum_{j=1}^{3} A_{ij}\times A_{ij} \end{equation*} where $\A$ is a second order tensor.

Returns:

Real doubleProduct(const Tensor&) const#

:Tensor::doubleProduct(Tensor)

:Double contracted product of 2 second order tensors.

This method defines a Real contracted product of two second order tensors. The result of this operation is a scalar defined by: \begin{equation*} s = \A : \B = \sum_{i=1}^{3} \sum_{j=1}^{3} A_{ij}\times B_{ij} \end{equation*} where $\A$ and $\B$ are two second order tensors.

return

Param :

inline Real getDeterminant() const#

get the determinant of the tensor, the zz compoment is ignored.

Returns:

inline Real getJ2() const#

get the J2 equvalient stress. J2 = 1/2 s.ij x s.ij = 1/6 [(sig.x - sig.y)^2 + (sig.y - sig.z)^2 + (sig.z-sig.x)^2 + 6(tau.xy^2 + tau.yz^2 + tau.zx^2)]

Returns:

inline Real getNorm() const#

inline Real getSquareNorm() const#

inline Real getThirdTrace() const#

get the hydrostatic stress.

Returns:

inline Real getTrace() const#

get the trace of the tensor, considering the zz compoment.

Returns:

Real maxAbsoluteValue()#

Real maxValue()#

Real minAbsoluteValue()#

Real minValue()#

inline Real operator()(Int, Int) const#

inline Real xx() const#

inline Real xy() const#

inline Real yx() const#

inline Real yy() const#

inline Real zz() const#

Vector2 rowSum() const#

Vector2 columnSum() const#

Vector2 getRow(Int row) const#

Vector2 getColumn(Int col) const#

Tensor getDeviator() const#

:Tensor::getDeviator()

:Deviatoric part of a second order tensor.

This method defines the deviatoric part of a second second order tensor. The result of this operation is a second order tensor defined by the following equation: \begin{equation*} \Sig^d=\Sig-\frac{1}{3}\tr[\Sig].\Id \end{equation*} where $\Sig^d$ is the deviatoric part of the tensor, $\Sig$ is the tensor and $\Id$ is the unit tensor.

Returns:

inline Real getEnergy(Tensor &strain) const#

get the inverse of the tensor, ignore the zz compoment.

Returns:

Real getPrincipal(Real principal[], Real Q[2][2], UInt index[]) const#

Tensor getPrincipal(UInt index[]) const#

void getPrincipal2D(Real prin[]) const#

Real getPrincipalDirection2D() const#

void solveBack(Tensor &prin, Real theta, UInt index[])#

void solveBack(Tensor &prin, Real theta)#

void solveBack(Real prin[][3], Real theta)#

inline Real getPostiveNorm() const#

Tensor getInverse() const#

Tensor getSkewSymetricPart() const#

Tensor getSymetricPart() const#

Tensor getTranspose() const#

Tensor operator-() const#

Tensor operator-(const Tensor&) const#

Tensor operator*(const Real) const#

Tensor operator*(const Tensor&) const#

Tensor operator/(const Real) const#

Tensor operator+(const Tensor&) const#

Tensor operator+(const Real&) const#

Tensor singleProduct() const#

Vector2 operator*(const Vector2&) const#

:Tensor::operator*(Vec2D)

:Multiplication of a second order tensor by a vector. ignore the zz compoment

return

Param :

Vector2 solve(const Vector2&) const#

void addI()#

void setToUnity()#

inline void setToValue(const Real)#

void setToZero()#

Public Members

Real _data[MAX_TENSOR_SIZE]#

Private Functions

inline bool indexCheck(Int, Int) const#

Friends

friend class Matrix2

friend Tensor operator*(const Real&, const Tensor&)#

struct TensorIndex#

#include <openfdem_struct.h>

Public Members

short index[3][3]#

class Timer#

#include <timer.h>

Class implementing single timer, providing wall clock and user time capabilities.

Public Functions

Timer()#

void startTimer()#

void stopTimer()#

void pauseTimer()#

void resumeTimer()#

void initTimer()#

inline bool isRunning()#

double getUtime()#: Returns total user time elapsed in seconds.

double getWtime()#: Returns total elapsed wall clock time in seconds.

void toString(char *buff)#: Prints receiver state into a string.

void updateElapsedTime()#

Public Static Functions

static void convert2HMS(int &nhrs, int &nmin, int &nsec, double tsec)#

Converts total seconds into hours, minutes and remaining seconds

Parameters:

nhrs – [out] Number of hours.
nmin – [out] Number of minutes.
nsec – [out] Number of seconds.
tsec – [in] Total time in seconds.

Private Functions

void getUtime(std::chrono::duration<double> &answer)#: Platform independent wrapper for user time.

void getTime(std::chrono::time_point<std::chrono::high_resolution_clock> &answer)#: Platform independent wrapper for wall time.

Private Members

std::chrono::time_point<std::chrono::high_resolution_clock> start_wtime#: Wall clock time markers.

std::chrono::time_point<std::chrono::high_resolution_clock> end_wtime#

std::chrono::duration<double> start_utime#: User time.

std::chrono::duration<double> end_utime#

std::chrono::duration<double> elapsedWTime#: Accumulated wtime and utime (in seconds) from start.

std::chrono::duration<double> elapsedUTime#

bool running#: Flag indicating whether timer is running.

double start_time#

double end_time#

double elapsed_time#

template<class T> struct TX : public T #

#include <variant_lite.hpp>

Public Functions

inline TX<T> operator+() const#

inline TX<T> operator-() const#

inline TX<T> operator!() const#

inline TX<T> operator~() const#

inline TX<T> *operator&() const#

template<class U> inline TX<T> operator*(U const&) const#

template<class U> inline TX<T> operator/(U const&) const#

template<class U> inline TX<T> operator%(U const&) const#

template<class U> inline TX<T> operator+(U const&) const#

template<class U> inline TX<T> operator-(U const&) const#

template<class U> inline TX<T> operator<<(U const&) const#

template<class U> inline TX<T> operator>>(U const&) const#

inline bool operator==(T const&) const#

inline bool operator<(T const&) const#

template<class U> inline TX<T> operator&(U const&) const#

template<class U> inline TX<T> operator|(U const&) const#

template<class U> inline TX<T> operator^(U const&) const#

template<class U> inline TX<T> operator&&(U const&) const#

template<class U> inline TX<T> operator||(U const&) const#

template<typename List, size_t N> struct type_of_size#

#include <optional_lite.hpp>

Public Types

typedef std11::conditional<N == sizeof(typenameList::head), typenameList::head, typenametype_of_size<typenameList::tail, N>::type>::type type#

template<typename List, size_t N> struct type_of_size#

#include <variant_lite.hpp>

Public Types

typedef std11::conditional<N == sizeof(typenameList::head), typenameList::head, typenametype_of_size<typenameList::tail, N>::type>::type type#

template<size_t N> struct type_of_size<nulltype, N>#

#include <optional_lite.hpp>

Public Types

typedef optional_CONFIG_ALIGN_AS_FALLBACK type#

template<size_t N> struct type_of_size<nulltype, N>#

#include <variant_lite.hpp>

Public Types

typedef variant_CONFIG_ALIGN_AS_FALLBACK type#

template<size_t NumVars, typename R, typename Visitor, typename T1, typename T2 = S0, typename T3 = S0, typename T4 = S0, typename T5 = S0> struct TypedVisitorUnwrapper#

template<typename R, typename Visitor, typename T2> struct TypedVisitorUnwrapper<2, R, Visitor, T2>#

#include <variant_lite.hpp>

Public Functions

inline TypedVisitorUnwrapper(const Visitor &visitor_, T2 const &val2_)#

template<typename T> inline R operator()(const T &val1) const#

Public Members

const Visitor &visitor#

T2 const &val2#

template<typename R, typename Visitor, typename T2, typename T3> struct TypedVisitorUnwrapper<3, R, Visitor, T2, T3>#

#include <variant_lite.hpp>

Public Functions

inline TypedVisitorUnwrapper(const Visitor &visitor_, T2 const &val2_, T3 const &val3_)#

template<typename T> inline R operator()(const T &val1) const#

Public Members

const Visitor &visitor#

T2 const &val2#

T3 const &val3#

template<typename R, typename Visitor, typename T2, typename T3, typename T4> struct TypedVisitorUnwrapper<4, R, Visitor, T2, T3, T4>#

#include <variant_lite.hpp>

Public Functions

inline TypedVisitorUnwrapper(const Visitor &visitor_, T2 const &val2_, T3 const &val3_, T4 const &val4_)#

template<typename T> inline R operator()(const T &val1) const#

Public Members

const Visitor &visitor#

T2 const &val2#

T3 const &val3#

T4 const &val4#

template<typename R, typename Visitor, typename T2, typename T3, typename T4, typename T5> struct TypedVisitorUnwrapper<5, R, Visitor, T2, T3, T4, T5>#

#include <variant_lite.hpp>

Public Functions

inline TypedVisitorUnwrapper(const Visitor &visitor_, T2 const &val2_, T3 const &val3_, T4 const &val4_, T5 const &val5_)#

template<typename T> inline R operator()(const T &val1) const#

Public Members

const Visitor &visitor#

T2 const &val2#

T3 const &val3#

T4 const &val4#

T5 const &val5#

template<typename Head, typename Tail> struct typelist#

#include <optional_lite.hpp>

Public Types

typedef Head head#

typedef Tail tail#

template<class Head, class Tail> struct typelist#

#include <variant_lite.hpp>

Public Types

typedef Head head#

typedef Tail tail#

template<class List, class T> struct typelist_index_of#

template<class T> struct typelist_index_of<nulltype, T>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<class Head, class Tail, class T> struct typelist_index_of<typelist<Head, Tail>, T>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

Private Types

enum TV#

Values:

enumerator nextVal#

template<class Tail, class T> struct typelist_index_of<typelist<T, Tail>, T>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<class List> struct typelist_max#

template<> struct typelist_max<nulltype>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

typedef void type#

template<class Head, class Tail> struct typelist_max<typelist<Head, Tail>>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

typedef std11::conditional<(sizeof(Head) > tail_value), Head, tail_type>::type type#

Private Types

enum TV#

Values:

enumerator tail_value#

typedef typelist_max<Tail>::type tail_type#

template<class List> struct typelist_size#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<nulltype>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T0>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T1>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T10>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T11>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T12>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T13>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T14>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T15>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T2>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T3>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T4>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T5>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T6>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T7>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T8>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<> struct typelist_size<T9>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<class Head, class Tail> struct typelist_size<typelist<Head, Tail>>#

#include <variant_lite.hpp>

Public Types

enum V#

Values:

enumerator value#

template<class List, std::size_t i> struct typelist_type_at#

template<class Head, class Tail> struct typelist_type_at<typelist<Head, Tail>, 0>#

#include <variant_lite.hpp>

Public Types

typedef Head type#

template<class Head, class Tail, std::size_t i> struct typelist_type_at<typelist<Head, Tail>, i>#

#include <variant_lite.hpp>

Public Types

typedef typelist_type_at<Tail, i - 1>::type type#

template<class T0, class T1 = detail::T1, class T2 = detail::T2, class T3 = detail::T3, class T4 = detail::T4, class T5 = detail::T5, class T6 = detail::T6, class T7 = detail::T7, class T8 = detail::T8, class T9 = detail::T9, class T10 = detail::T10, class T11 = detail::T11, class T12 = detail::T12, class T13 = detail::T13, class T14 = detail::T14, class T15 = detail::T15> class variant#

#include <variant_lite.hpp>

Public Functions

inline variant()#

inline variant(T0 const &t0)#

inline variant(T1 const &t1)#

inline variant(T2 const &t2)#

inline variant(T3 const &t3)#

inline variant(T4 const &t4)#

inline variant(T5 const &t5)#

inline variant(T6 const &t6)#

inline variant(T7 const &t7)#

inline variant(T8 const &t8)#

inline variant(T9 const &t9)#

inline variant(T10 const &t10)#

inline variant(T11 const &t11)#

inline variant(T12 const &t12)#

inline variant(T13 const &t13)#

inline variant(T14 const &t14)#

inline variant(T15 const &t15)#

inline variant(variant const &other)#

inline ~variant()#

inline variant &operator=(variant const &other)#

inline variant &operator=(T0 const &t0)#

inline variant &operator=(T1 const &t1)#

inline variant &operator=(T2 const &t2)#

inline variant &operator=(T3 const &t3)#

inline variant &operator=(T4 const &t4)#

inline variant &operator=(T5 const &t5)#

inline variant &operator=(T6 const &t6)#

inline variant &operator=(T7 const &t7)#

inline variant &operator=(T8 const &t8)#

inline variant &operator=(T9 const &t9)#

inline variant &operator=(T10 const &t10)#

inline variant &operator=(T11 const &t11)#

inline variant &operator=(T12 const &t12)#

inline variant &operator=(T13 const &t13)#

inline variant &operator=(T14 const &t14)#

inline variant &operator=(T15 const &t15)#

inline std::size_t index() const#

inline bool valueless_by_exception() const#

inline void swap(variant &other)#

template<class T> inline T &get()#

template<class T> inline T const &get() const#

template<std::size_t K> inline variant_alternative<K, variant>::type &get()#

template<std::size_t K> inline variant_alternative<K, variant>::type const &get() const#

Public Static Functions

template<class T> static inline variant_constexpr std::size_t index_of () variant_noexcept

Private Types

Values:

enumerator data_size#

typedef detail::helper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> helper_type#

typedef helper_type::type_index_t type_index_t#

typedef detail::typelist_max<variant_types>::type max_type#

Private Functions

typedef variant_TL16 (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) variant_types

inline void * ptr () variant_noexcept

inline void const * ptr () const variant_noexcept

template<class U> inline U *as()#

template<class U> inline U const *as() const#

inline variant_constexpr type_index_t variant_npos_internal () const variant_noexcept

inline variant &copy_assign(variant const &other)#

template<std::size_t K, class T> inline variant &assign_value(T const &value)#

inline void swap_value(type_index_t index, variant &other)#

typedef variant_ALIGN_AS (max_type) align_as_type

Private Members

aligned_storage_t data#

type_index_t type_index#

Private Static Functions

template<class U> static inline variant_constexpr std::size_t to_size_t (U index)

template<std::size_t K, class T> struct variant_alternative#

template<std::size_t K, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> struct variant_alternative<K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>>#

#include <variant_lite.hpp>

Public Types

typedef detail::typelist_type_at<variant_TL16(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), K>::type type#

template<class T> struct variant_size#

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> struct variant_size<variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>>#

#include <variant_lite.hpp>

Public Types

enum _#

Values:

enumerator value#

class Vector#

#include <openfdem_vector.h>

Class : Arbitary Vector

Used to manage Vector used in FDEM project, the vector is dynamic memory, which can be transfered from Vector3, matrix, tensor and symtensor

Public Functions

Vector(Int = 2, Real = 0.0)#

constructor the fixed length of the vector and set initial value.

param

Param :

Vector(const Vector&)#

constructor from a vector.

Param :

Vector(const Vector2 &vect)#

constructor a dynamic vector from a vector2.

Parameters:: vect –

~Vector()#: deconstructor.

inline Real &operator()(Int)#

return the compoment.

return

Param :

Vector operator=(const Real*)#

multiply a real value and return a vector.

return

Param :

Vector operator=(const Vector&)#

return a new vector.

return

Param :

Vector operator=(Real)#

vector equals to a scalar.

return

Param :

Vector(Int vectorLength, Real firstValue, Real secondValue, ...)#

void operator-=(const Vector&)#

minus a vector.

Param :

void operator*=(const Real)#

multiply a real value.

Param :

void operator/=(const Real)#

divid a real value.

Param :

void operator+=(const Vector&)#

add a vector.

Param :

void print(std::ostream&) const#

inline bool indexCheck(Int) const#

bool operator!=(const Vector&) const#

identify the euqlity of two vectors.

return

Param :

bool operator==(const Vector&) const#

Real distance(const Vector&) const#

return the distance of two vector. the norm of the sub vector

return

Param :

Real dotProduct(const Vector&) const#

dot of two vectors and return a real value. s = Va * Vb

return

Param :

Real getNorm()#

the norm of a vector.

Returns:

Real innerProduct()#

inner product of a vector.

Returns:

Real maxAbsoluteValue()#

Real maxValue()#

Real minAbsoluteValue()#

Real minValue()#

inline Real operator()(Int) const#

return the compoment.

return

Param :

Real squareDistance(const Vector&) const#

square distance of two vectors .

return

Param :

inline Int getSize() const#

get the length of the vector.

Returns:

Matrix dyadicProduct()#

Matrix dyadicProduct(const Vector&)#

Vector getNormalized()#

Vector operator-() const#

Vector operator-(const Vector&) const#

Vector operator*(const Real) const#

Vector operator/(const Real) const#

Vector operator+(const Vector&) const#

Vector crossProduct(const Vector&) const#

void normalize()#

void redim(const Int)#

void resizeVector(const Int)#

void setToValue(Real)#

void swapWith(Vector&)#

Vector EWInverse()#

Vector EWExp()#

Vector EWAddReal(const Real)#

Vector EWSquare()#

Vector EWMultiply(const Vector&)#

Private Functions

void allocate(const Int)#

void desallocate()#

Private Members

UInt _dataLength#

Real *_data#

Friends

friend class Matrix

friend Vector operator*(const Real, const Vector&)#: compute the vector multiply a scalar.

struct Vector2#

#include <openfdem_vector2.h>

The base vector2 class.

Public Functions

inline Real normal() const#

return vector normal, read only.

Returns:

inline Real shear() const#

return vector shear, read only.

Returns:

inline Real &normal()#

return vector normal, read-write.

Returns:

inline Real &shear()#

return vector shear, read-write.

Returns:

inline Real n() const#

return vector n, read only.

Returns:

inline Real s() const#

return vector s, read only.

Returns:

inline Real &n()#

return vector n, read-write.

Returns:

inline Real &s()#

return vector s, read-write.

Returns:

inline void create(Real x, Real y)#

constructor by two real values.

Parameters:

inputx –
inputy –

inline void create()#: initialize.

inline void create(const Vector2 &copy)#

constructor from a vector.

Parameters:: B –

inline void addby(const Vector2&)#

this += B.

Parameters:: B –

inline void multiplyby(const Real scale, Vector2 &vector)#

compute the vector multiplied by a scalar, and save to current vector.

Parameters:

scale –
vector –

inline void subby(const Vector2 &vectorA, const Vector2 &vectorB)#

this = A -B .

Parameters:

vectorA –
vectorB –

inline void addby(const Vector2 &vectorA, const Vector2 &vectorB)#

this = A + B.

Parameters:

vectorA –
vectorB –

inline void averageby(const Vector2 &vectorA, const Vector2 &vectorB)#

this = 0.5 *( A + B).

Parameters:

vectorA –
vectorB –

inline void triaverageby(const Vector2 &vectorA, const Vector2 &vectorB, const Vector2 &vectorC)#

this = 1/3 * (A + B + C).

Parameters:

vectorA –
vectorB –
vectorC –

inline void normalized()#: normalize this vector.

inline Real getSlope()#

get the slope of the vector, in y/x

Returns:

inline Real getTheta()#

get the slope of the vector, atan value, in rad

Returns:

inline Real getDistancefrom(const Vector2 &n)#

compute distance of two vectors.

Parameters:: n –
Returns:

inline Real getSquaredDistancefrom(const Vector2 &n)#

compute squared distance of two vectors.

Parameters:: n –
Returns:

inline void normalizedby(const Vector2&)#

get the normalize from another vector.

Parameters:: vector –

inline Real getNorm() const#

return the norm of this vector.

Returns:

inline Real getSquaredNorm() const#

return the squared norm of this vector.

Returns:

inline void operator-=(const Vector2 &b)#

operator -=.

Parameters:: b –

inline void operator+=(const Vector2 &b)#

operator +=.

Parameters:: b –

inline void operator*=(const Real &b)#

operator *= with a scalar.

Parameters:: b –

inline void operator/=(const Real &b)#

operator /= with a scalar.

Parameters:: b –

inline void operator*=(const Vector2 &b)#

operator *= with another vector, by elementwise.

Parameters:: b –

inline void operator/=(const Vector2 &b)#

operator /= with another vector, by elementwise. v.x = v.x / b.x

Parameters:: b –

inline Vector2 getNormalVectorInward(const Vector2 &b)#

compute inward normal of current and another vectors, right-hand rule, z x (b - this) return the normal vector

Parameters:: b –
Returns:

inline void getNormalVectorInwardfrom(const Vector2 &a, const Vector2 &b)#

compute inward normal of two vectors, right-hand rule, z x (b - a).

Parameters:

a –
b –

inline Vector2 getNormalVectorOutward(const Vector2 &b)#

compute outward normal of current and another vectors, right-hand rule, -z x (b - this) return the normal vector

Parameters:: b –
Returns:

inline void getNormalVectorOutwardfrom(const Vector2 &a, const Vector2 &b)#

compute outward normal of two vectors, right-hand rule, -z x (b - a).

Parameters:

a –
b –

inline Real getPostiveMag()#

compute vector magnitude .

Returns:

inline Real getdot(const Vector2 &vector)#

return the vector dot. return = this * A return = this.x * A.x + this.y * A.y

Parameters:: vector –
Returns:

inline Real getcross(const Vector2 &vector)#

return the cross of this vector with A. return = this x A

Parameters:: vector –
Returns:

inline void Zero()#: zero the vector.

Public Members

Real x = 0.0#

Real y = 0.0#

struct Vector3#

#include <openfdem_vector3.h>

The base vector3 class. This vector is special for rigid 2D body if 3 dofs are considered. for example, the velocity can be [x, y, rotation] and the movement can be [translation.x translation.y angle]

Public Functions

inline Real angular() const#

inline Real &angular()#

inline Real moment() const#

inline Real &moment()#

inline Real n() const#

inline Real &n()#

inline Real t() const#

inline Real &t()#

inline Real r() const#

inline Real &r()#

inline void create(Real x, Real y, Real omega)#

inline void create()#

inline void create(const Vector3 &copy)#

inline void addby(const Vector3&)#

inline void multiplyby(const Real scale, Vector3 &vector)#

inline void subby(const Vector3 &vectorA, const Vector3 &vectorB)#

inline void addby(const Vector3 &vectorA, const Vector3 &vectorB)#

inline void averageby(const Vector3 &vectorA, const Vector3 &vectorB)#

inline void triaverageby(const Vector3 &vectorA, const Vector3 &vectorB, const Vector3 &vectorC)#

inline Real getSlope()#

inline Real getDistancefrom(const Vector3 &n)#

inline Real getSquaredDistancefrom(const Vector3 &n)#

inline void operator-=(const Vector3 &b)#

inline void operator+=(const Vector3 &b)#

inline void operator*=(const Real &b)#

inline void operator/=(const Real &b)#

inline void operator*=(const Vector3 &b)#

inline void operator/=(const Vector3 &b)#

inline Real getPostiveMag()#

inline void Zero()#

Public Members

Real x = 0.0#

Real y = 0.0#

Real omega = 0.0#

template<typename R> struct VisitorApplicator#

#include <variant_lite.hpp>

Public Static Functions

template<typename Visitor, typename V1> static inline R apply(const Visitor &v, const V1 &arg)#

template<size_t Idx, typename Visitor, typename V1> static inline R apply_visitor(const Visitor &v, const V1 &arg)#

template<typename Visitor, typename V1, typename V2> static inline R apply(const Visitor &v, V1 const &arg1, V2 const &arg2)#

template<typename Visitor, typename V1, typename V2, typename V3> static inline R apply(const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3)#

template<typename Visitor, typename V1, typename V2, typename V3, typename V4> static inline R apply(const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3, V4 const &arg4)#

template<typename Visitor, typename V1, typename V2, typename V3, typename V4, typename V5> static inline R apply(const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3, V4 const &arg4, V5 const &arg5)#

template<typename R, typename VT> struct VisitorApplicatorImpl#

#include <variant_lite.hpp>

Public Static Functions

template<typename Visitor, typename T> static inline R apply(Visitor const &v, T const &arg)#

template<typename R, typename VT> struct VisitorApplicatorImpl<R, TX<VT>>#

#include <variant_lite.hpp>

Public Static Functions

template<typename Visitor, typename T> static inline R apply(Visitor const&, T)#

template<typename R, typename Visitor, typename V2> struct VisitorUnwrapper#

#include <variant_lite.hpp>

Public Functions

inline VisitorUnwrapper(const Visitor &visitor_, const V2 &r_)#

template<typename T1> inline R operator()(T1 const &val1) const#

template<typename T1, typename T2> inline R operator()(T1 const &val1, T2 const &val2) const#

template<typename T1, typename T2, typename T3> inline R operator()(T1 const &val1, T2 const &val2, T3 const &val3) const#

template<typename T1, typename T2, typename T3, typename T4> inline R operator()(T1 const &val1, T2 const &val2, T3 const &val3, T4 const &val4) const#

template<typename T1, typename T2, typename T3, typename T4, typename T5> inline R operator()(T1 const &val1, T2 const &val2, T3 const &val3, T4 const &val4, T5 const &val5) const#

Public Members

const Visitor &visitor#

const V2 &r#

namespace nonstd#

Functions

template<class T> inline in_place_t in_place(detail::in_place_type_tag<T> = detail::in_place_type_tag<T>())#

template<std::size_t K> inline in_place_t in_place(detail::in_place_index_tag<K> = detail::in_place_index_tag<K>())#

template<class T> inline in_place_t in_place_type(detail::in_place_type_tag<T> = detail::in_place_type_tag<T>())#

template<std::size_t K> inline in_place_t in_place_index(detail::in_place_index_tag<K> = detail::in_place_index_tag<K>())#

namespace detail#

namespace optional_lite#

Functions

template<typename T, typename U> inline optional_constexpr bool operator== (optional< T > const &x, optional< U > const &y)

template<typename T, typename U> inline optional_constexpr bool operator!= (optional< T > const &x, optional< U > const &y)

template<typename T, typename U> inline optional_constexpr bool operator< (optional< T > const &x, optional< U > const &y)

template<typename T, typename U> inline optional_constexpr bool operator> (optional< T > const &x, optional< U > const &y)

template<typename T, typename U> inline optional_constexpr bool operator<= (optional< T > const &x, optional< U > const &y)

template<typename T, typename U> inline optional_constexpr bool operator>= (optional< T > const &x, optional< U > const &y)

template<typename T> inline optional_constexpr bool operator== (optional< T > const &x, nullopt_t) optional_noexcept

template<typename T> inline optional_constexpr bool operator== (nullopt_t, optional< T > const &x) optional_noexcept

template<typename T> inline optional_constexpr bool operator!= (optional< T > const &x, nullopt_t) optional_noexcept

template<typename T> inline optional_constexpr bool operator!= (nullopt_t, optional< T > const &x) optional_noexcept

template<typename T> inline optional_constexpr bool operator< (optional< T > const &, nullopt_t) optional_noexcept

template<typename T> inline optional_constexpr bool operator< (nullopt_t, optional< T > const &x) optional_noexcept

template<typename T> inline optional_constexpr bool operator<= (optional< T > const &x, nullopt_t) optional_noexcept

template<typename T> inline optional_constexpr bool operator<= (nullopt_t, optional< T > const &) optional_noexcept

template<typename T> inline optional_constexpr bool operator> (optional< T > const &x, nullopt_t) optional_noexcept

template<typename T> inline optional_constexpr bool operator> (nullopt_t, optional< T > const &) optional_noexcept

template<typename T> inline optional_constexpr bool operator>= (optional< T > const &, nullopt_t) optional_noexcept

template<typename T> inline optional_constexpr bool operator>= (nullopt_t, optional< T > const &x) optional_noexcept

template<typename T, typename U> inline optional_constexpr bool operator== (optional< T > const &x, U const &v)

template<typename T, typename U> inline optional_constexpr bool operator== (U const &v, optional< T > const &x)

template<typename T, typename U> inline optional_constexpr bool operator!= (optional< T > const &x, U const &v)

template<typename T, typename U> inline optional_constexpr bool operator!= (U const &v, optional< T > const &x)

template<typename T, typename U> inline optional_constexpr bool operator< (optional< T > const &x, U const &v)

template<typename T, typename U> inline optional_constexpr bool operator< (U const &v, optional< T > const &x)

template<typename T, typename U> inline optional_constexpr bool operator<= (optional< T > const &x, U const &v)

template<typename T, typename U> inline optional_constexpr bool operator<= (U const &v, optional< T > const &x)

template<typename T, typename U> inline optional_constexpr bool operator> (optional< T > const &x, U const &v)

template<typename T, typename U> inline optional_constexpr bool operator> (U const &v, optional< T > const &x)

template<typename T, typename U> inline optional_constexpr bool operator>= (optional< T > const &x, U const &v)

template<typename T, typename U> inline optional_constexpr bool operator>= (U const &v, optional< T > const &x)

template<typename T> void swap(optional<T> &x, optional<T> &y)#

template<typename T> optional<T> make_optional(T const &value)#

Variables

const nullopt_t nullopt ((nullopt_t::init()))

namespace detail#

Typedefs

typedef nulltype alignment_types#

Functions

typedef optional_ALIGN_TYPE (char)

typedef optional_ALIGN_TYPE (short)

typedef optional_ALIGN_TYPE (int)

typedef optional_ALIGN_TYPE (long)

typedef optional_ALIGN_TYPE (float)

typedef optional_ALIGN_TYPE (double)

typedef optional_ALIGN_TYPE (long double)

typedef optional_ALIGN_TYPE (char *)

typedef optional_ALIGN_TYPE (short *)

typedef optional_ALIGN_TYPE (int *)

typedef optional_ALIGN_TYPE (long *)

typedef optional_ALIGN_TYPE (float *)

typedef optional_ALIGN_TYPE (double *)

typedef optional_ALIGN_TYPE (long double *)

typedef optional_ALIGN_TYPE (Unknown(*)(Unknown))

typedef optional_ALIGN_TYPE (Unknown *Unknown::*)

typedef optional_ALIGN_TYPE (Unknown(Unknown::*)(Unknown))

namespace std11#

Functions

template<typename T> T &move(T &t)#

namespace sv_lite#

Functions

template<class CharT, class Traits> std::basic_string<CharT, Traits> to_string(basic_string_view<CharT, Traits> v)#

template<class CharT, class Traits, class Allocator> std::basic_string<CharT, Traits, Allocator> to_string(basic_string_view<CharT, Traits> v, Allocator const &a)#

template<class CharT, class Traits, class Allocator> basic_string_view<CharT, Traits> to_string_view(std::basic_string<CharT, Traits, Allocator> const &s)#

namespace variants#

Functions

inline variant_constexpr bool operator< (monostate, monostate) variant_noexcept

inline variant_constexpr bool operator> (monostate, monostate) variant_noexcept

inline variant_constexpr bool operator<= (monostate, monostate) variant_noexcept

inline variant_constexpr bool operator>= (monostate, monostate) variant_noexcept

inline variant_constexpr bool operator== (monostate, monostate) variant_noexcept

inline variant_constexpr bool operator!= (monostate, monostate) variant_noexcept

template<class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline bool holds_alternative (variant< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 > const &v) variant_noexcept

template<class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline R &get(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> &v, nonstd_lite_in_place_type_t(R) = nonstd_lite_in_place_type(R))#

template<class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline R const &get(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &v, nonstd_lite_in_place_type_t(R) = nonstd_lite_in_place_type(R))#

template<std::size_t K, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline variant_alternative<K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>>::type &get(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> &v, nonstd_lite_in_place_index_t(K) = nonstd_lite_in_place_index(K))#

template<std::size_t K, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline variant_alternative<K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>>::type const &get(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &v, nonstd_lite_in_place_index_t(K) = nonstd_lite_in_place_index(K))#

template<class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline std11::add_pointer<T>::type get_if(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> *pv, nonstd_lite_in_place_type_t(T) = nonstd_lite_in_place_type(T))#

template<class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline std11::add_pointer<constT>::type get_if(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const *pv, nonstd_lite_in_place_type_t(T) = nonstd_lite_in_place_type(T))#

template<std::size_t K, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline std11::add_pointer<typenamevariant_alternative<K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>>::type>::type get_if(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> *pv, nonstd_lite_in_place_index_t(K) = nonstd_lite_in_place_index(K))#

template<std::size_t K, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline std11::add_pointer<consttypenamevariant_alternative<K, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>>::type>::type get_if(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const *pv, nonstd_lite_in_place_index_t(K) = nonstd_lite_in_place_index(K))#

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline void swap(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> &a, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> &b)#

template<typename R, typename Visitor, typename V1> inline R visit(const Visitor &v, V1 const &arg1)#

template<typename R, typename Visitor, typename V1, typename V2> inline R visit(const Visitor &v, V1 const &arg1, V2 const &arg2)#

template<typename R, typename Visitor, typename V1, typename V2, typename V3> inline R visit(const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3)#

template<typename R, typename Visitor, typename V1, typename V2, typename V3, typename V4> inline R visit(const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3, V4 const &arg4)#

template<typename R, typename Visitor, typename V1, typename V2, typename V3, typename V4, typename V5> inline R visit(const Visitor &v, V1 const &arg1, V2 const &arg2, V3 const &arg3, V4 const &arg4, V5 const &arg5)#

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline bool operator==(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &v, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &w)#

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline bool operator!=(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &v, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &w)#

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline bool operator<(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &v, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &w)#

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline bool operator>(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &v, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &w)#

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline bool operator<=(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &v, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &w)#

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15> inline bool operator>=(variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &v, variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> const &w)#

Variables

static const std::size_t variant_npos = static_cast<std::size_t>(-1)#

namespace detail#

Typedefs

typedef TX<S0> T0#

typedef TX<S1> T1#

typedef TX<S2> T2#

typedef TX<S3> T3#

typedef TX<S4> T4#

typedef TX<S5> T5#

typedef TX<S6> T6#

typedef TX<S7> T7#

typedef TX<S8> T8#

typedef TX<S9> T9#

typedef TX<S10> T10#

typedef TX<S11> T11#

typedef TX<S12> T12#

typedef TX<S13> T13#

typedef TX<S14> T14#

typedef TX<S15> T15#

typedef nulltype alignment_types#

Functions

typedef variant_ALIGN_TYPE (char)

typedef variant_ALIGN_TYPE (short)

typedef variant_ALIGN_TYPE (int)

typedef variant_ALIGN_TYPE (long)

typedef variant_ALIGN_TYPE (float)

typedef variant_ALIGN_TYPE (double)

typedef variant_ALIGN_TYPE (long double)

typedef variant_ALIGN_TYPE (char *)

typedef variant_ALIGN_TYPE (short *)

typedef variant_ALIGN_TYPE (int *)

typedef variant_ALIGN_TYPE (long *)

typedef variant_ALIGN_TYPE (float *)

typedef variant_ALIGN_TYPE (double *)

typedef variant_ALIGN_TYPE (long double *)

typedef variant_ALIGN_TYPE (Unknown(*)(Unknown))

typedef variant_ALIGN_TYPE (Unknown *Unknown::*)

typedef variant_ALIGN_TYPE (Unknown(Unknown::*)(Unknown))

namespace std11#

namespace std17#: type traits C++17:

namespace ns_common

Functions

void malloc1Darray(Int size, Real **array, Real value = 0.)#

void malloc1Darray(Int size, Int **array, Int value = 0)#

void malloc1Darray(Int size, UInt **array, UInt value = 0)#

void malloc1Darray(Int size, int **array, int value = 0)#

void malloc1Darray(Int size, bool **array, bool value = false)#

void malloc1Darray(Int size, Vector2 **array, Real value = 0.0)#

void malloc1Darray(Int size, Vector2 **array, Vector2 value)#

void malloc2Darray(Int rowsize, Int cloumnsize, Int ***array, Int value = 0)#

void malloc2Darray(Int rowsize, Int cloumnsize, UInt ***array, UInt value = 0)#

void malloc2Darray(Int rowsize, Int cloumnsize, int ***array, int value = 0)#

void malloc2Darray(Int rowsize, Int cloumnsize, Real ***array, Real value = 0.)#

void malloc2Darray(Int rowsize, Int cloumnsize, bool ***array, bool value = false)#

UInt *realloc1Darray(UInt *array, UInt size)#

int *realloc1Darray(int *array, UInt size)#

Int *realloc1Darray(Int *array, UInt size)#

bool *realloc1Darray(bool *array, UInt size)#

Real *realloc1Darray(Real *array, UInt size)#

void parsemeomory(FILE *fileptr, Real value, Vector2 **array, Int size, Int capacity)#

void parsemeomory(FILE *fileptr, Int value, Int **array, Int size, Int capacity)#

void parsemeomory(FILE *fileptr, int value, int **array, Int size, Int capacity)#

void parsemeomory(FILE *fileptr, UInt value, UInt **array, Int size, Int capacity)#

void parsemeomory(FILE *fileptr, Real value, Real **array, Int size, Int capacity)#

void parsemeomory(FILE *fileptr, node_type **array, Int oldsize, Int newsize)#

void buildmemory(Real **targetContainer, const Int size1, Int size0 = 0, Real value = 0.0)#

void buildmemory(Real ***targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(Int **targetContainer, const Int size1, Int size0 = 0, Int value = 0)#

void buildmemory(UInt **targetContainer, const Int size1, Int size0 = 0, UInt value = 0)#

void buildmemory(int **targetContainer, const Int size1, Int size0 = 0, int value = 0)#

void buildmemory(short **targetContainer, const Int size1, Int size0 = 0, short value = 0)#

void buildmemory(bool **targetContainer, const Int size1, Int size0 = 0, bool value = false)#

void buildmemory(char **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(char ***targetContainer, const Int size1, Int size0 = 0)#

void freememory(char *targetContainer)#

void freememory(char **targetContainer, const Int size)#

void freememory(bool *targetContainer)#

void freememory(bool **targetContainer, const Int size)#

void freememory(short *targetContainer)#

void freememory(short **targetContainer, const Int size)#

void freememory(int *targetContainer)#

void freememory(int **targetContainer, const Int size)#

void freememory(UInt *targetContainer)#

void freememory(UInt **targetContainer, const Int size)#

void freememory(Int *targetContainer)#

void freememory(Int **targetContainer, const Int size)#

void freememory(Real *targetContainer)#

void freememory(Real **targetContainer, const Int size)#

void buildmemory(Vector2 **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(Vector3 **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(Matrix2 **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(Matrix **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(Tensor **targetContainer, const Int size1, Int size0 = 0)#

void freememory(Vector2 *targetContainer)#

void freememory(Vector2 **targetContainer, const Int size)#

void freememory(Vector3 *targetContainer)#

void freememory(Vector3 **targetContainer, const Int size)#

void freememory(Matrix2 *targetContainer)#

void freememory(Matrix2 **targetContainer, const Int size)#

void freememory(Tensor *targetContainer)#

void freememory(Tensor **targetContainer, const Int size)#

void buildmemory(element_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(GaussPoint_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(damage_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(cohelement_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(fracture_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(cell_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(contact_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(node_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(edge_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(entity_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(particle_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(pContact_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(wContact_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(group_node_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(group_element_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(group_edge_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(group_particle_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(group_mpmpoints_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(group_gbm_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(group_cohelement_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(geo_node_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(geo_line_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(geo_curve_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(geo_surface_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(geo_group_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(geo_EmbededlineGroups_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(geo_particles_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(history_nodal_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(history_element_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(history_cohelement_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(history_contact_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(history_general_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(mat_element_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(mat_cohelement_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(mat_contact_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(mat_fluid_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(mat_fluid_element_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(mat_fluid_cohesive_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(mat_gas_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(mat_mpmfluid_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(mat_thermal_element_t **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(boudary_node_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(boudary_particle_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(boudary_ele_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(boudary_inletflow_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(boudary_outletflow_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(boudary_point_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(boudary_edge_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(table_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(boudary_flow_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(boudary_thermal_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(boudary_blast_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(mesh_insert_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(dfn_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(cohelement_enum **containerlist, const Int size1, Int size0)#

void buildmemory(ae_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(blast_type **targetContainer, const Int size1, Int size0 = 0)#

void buildmemory(caivity_type **targetContainer, const Int size1, Int size0 = 0)#

void get_filename_no_path(char *return_string, const char *input_string)#

copy no extension and path

Parameters:

return_string – to copy to
input_string – to copy from

void get_filename_with_extension(char *return_string, const char *input_string)#

copy no extension and path

Parameters:

return_string – to copy to
input_string – to copy from

void get_path(char *return_string, const char *input_string)#

copy path

Parameters:

return_string –
input_string –

void parseStringinQuotation(FILE *inputfile, char *string)#

parse string within quotoes and space “keyword” -> keword ‘keyword’ -> keyword keyword -> keyword

Parameters:

inputfile –
string –

void parse_string(FILE *inputfile, char *string)#

parse string with quotoes and space

Parameters:

inputfile –
string –

void parseStringinLine(FILE *inputfile, Keywords &keyword)#

parse strings in one line the line-string will splitted to several kewords by space the quotations will be removed “string1” ‘string2’ string3 -> string1 string2 string3

Parameters:

inputfile –
string –

void parseStringinLinetoChar(FILE *inputfile, char *keyword)#

char *chartoname(char *in)#: add [ ] for the string. ‘string’ -> [string]

void get_filename_no_suffix(char *return_string, char *input_string)#

Get filename without suffix.

input C:/usr/files/example.fdem, returen => C:/usr/files/example

Parameters:

return_string –
input_string –

void get_suffix(char *return_string, char *input_string)#

Get the suffix of the imported file.

input C:/usr/files/example.fdem, returen => fdem

Parameters:

return_string –
input_string –

void strip_ext(char *fname)#

Get the file name without path and suffix.

input C:/usr/files/example.fdem, return => example

Parameters:

return_string –
input_string –

int openfdem_run_usr_break(double dctime, long ncstep, long mcstep)#: terminate the calculation by user break.

long get_line_current_position(FILE *fileptr)#: return the line where the error comes.

void create_result_store_folder(char *Result_store_folder)#: create the path for the results.

void exportToBinary(const std::string &str, const std::string &filename)#: export string to binary.

void removeCharsBeforeSubstring(char *str, const char *substring)#

std::string readBinaryFromFile(const std::string &filename)#

std::string errorInfo(const char *func)#

Real random_normal(Real mu, Real sigma)#

void solveEigen2(Real A, Real B, Real C, Real *rt1, Real *rt2, Real *cs, Real *sn)#: Calculates the eigensystem of a real symmetric 2x2 matrix [ A B ] [ B C ] in the form [ A B ] = [ cs -sn ] [ rt1 0 ] [ cs sn ] [ B C ] [ sn cs ] [ 0 rt2 ] [ -sn cs ] where rt1 >= rt2. Note that this convention is different from the one used in the LAPACK routine DLAEV2, where |rt1| >= |rt2|..

Int solveEigenusingQL(Real A[3][3], Real Q[3][3], Real w[3])#

Solve eigen values of a symmetric tensor by using QL.

\detail Calculates the eigenvalues and normalized eigenvectors of a symmetric 3x3 matrix A using the QL algorithm with implicit shifts, preceded by a Householder reduction to tridiagonal form.

\dependence HouseholderTransform()

Note

The function accesses only the diagonal and upper triangular parts of A.

Parameters:

A – input symmetric matrix
Q – return matrix for eigenvectors
w – return buffer for eigenvalues

Returns:

0: Success

-1: Error (no convergence)

Int solveEigenusingJacobi(Real A[3][3], Real Q[3][3], Real w[3])#

Solve eigen values of a symmetric tensor by using Jacobi.

\detail Calculates the eigenvalues and normalized eigenvectors of a symmetric 3x3 matrix A using the Jacobi algorithm,The upper triangular part of A is destroyed during the calculation, the diagonal elements are read but not destroyed, and the lower triangular elements are not referenced at all.

\dependence HouseholderTransform()

Note

The function accesses only the diagonal and upper triangular parts of A.

Parameters:

A – input symmetric matrix
Q – return matrix for eigenvectors
w – return buffer for eigenvalues

Returns:

0: Success

-1: Error (no convergence)

Int solveEigenusingCuppen(Real A[3][3], Real Q[3][3], Real w[3])#

Solve eigen values of a symmetric tensor by using Jacobi.

\detail Calculates the eigenvalues and normalized eigenvectors of a symmetric 3x3 matrix A using the Cuppen’s Divide & Conquer algorithm,The upper triangular part of A is destroyed during the calculation, the diagonal elements are read but not destroyed, and the lower triangular elements are not referenced at all.

\dependence dsyev2(), solveSecularquation(), HouseholderTransform()

Note

The function accesses only the diagonal and upper triangular parts of A.

Parameters:

A – input symmetric matrix
Q – return matrix for eigenvectors
w – return buffer for eigenvalues

Returns:

0: Success

-1: Error (no convergence)

inline Real VectorNorm(const Vector2 &n)#

inline Real VectorSquareNorm(const Vector2 &n)#

inline Real VectorgetValue(const Vector2 &n, const Int indices)#

inline Real VectorPostiveMag2(const Vector2 &n)#

inline Real VectorSlope(const Vector2 &n)#

inline Vector2 VectorAdd(const Vector2 &n2, const Vector2 &n1)#

inline Real VectorDistance(const Vector2 &n2, const Vector2 &n1)#

inline Real VectorSquareDistance(const Vector2 &n2, const Vector2 &n1)#

inline Vector2 VectorAverage(const Vector2 &n2, const Vector2 &n1)#

inline Vector2 VectorSub(const Vector2 &n2, const Vector2 &n1)#

inline Vector2 VectorNormalInward(const Vector2 &n1, const Vector2 &n2)#

inline Vector2 VectorNormalOutward(const Vector2 &n1, const Vector2 &n2)#

inline Vector2 VectorMul(const Vector2 &n2, const Vector2 &n1)#

inline Vector2 VectorDiv(const Vector2 &n2, const Vector2 &n1)#

inline Vector2 VectorMulscalar(Real s, const Vector2 &n1)#

inline Real VectorDot(const Vector2 &n2, const Vector2 &n1)#

inline Real VectorCross(const Vector2 &v1, const Vector2 &v2)#

inline Vector2 VectorNormalize(const Vector2 &v1)#

inline Vector2 VectorCreate()#

inline Vector2 VectorCreate(const Vector2 &n)#

inline Vector2 VectorCreate(Real x, Real y)#

inline Vector2 VectorCreate(Real value)#

inline Vector2 VectorNormalVector(const Vector2 &v1)#

Variables

Logger logger#

namespace openfdem#

namespace std#

namespace tabulate#

Enums

enum class Color#

Values:

enumerator none#

enumerator grey#

enumerator red#

enumerator green#

enumerator yellow#

enumerator blue#

enumerator magenta#

enumerator cyan#

enumerator white#

enum class FontAlign#

Values:

enumerator left#

enumerator right#

enumerator center#

enum class FontStyle#

Values:

enumerator bold#

enumerator dark#

enumerator italic#

enumerator underline#

enumerator blink#

enumerator reverse#

enumerator concealed#

enumerator crossed#

Functions

inline std::ostream &operator<<(std::ostream &stream, const Table &table)#

inline size_t get_sequence_length(const std::string &text, const std::string &locale, bool is_multi_byte_character_support_enabled)#

file csvfile.h

#include <fstream>

#include <iostream>

#include <sstream>

#include <string>

Functions

static inline csvfile &endrow(csvfile &file)#

static inline csvfile &flush(csvfile &file)#

file logger.h

#include <cstdio>

#include <string>

Defines

OPENFDEM_DIVIDING_HEAD#

LOG_ERR_HEADER#

LOG_ERR_TAIL#

PRINT_HEADER(stream)#

PRINT_TAIL(stream)#

OPENFDEM_LOG_FATAL(...)#: Log reporting macros

OPENFDEM_LOG_ERROR(...)#

OPENFDEM_LOG_WARNING(...)#

OPENFDEM_TO_IMPLEMENT#

OPENFDEM_LOG_FORCED(...)#

OPENFDEM_LOG_RELEVANT(...)#

OPENFDEM_LOG_INFO(...)#

OPENFDEM_LOG_DEBUG(...)#

file memory_manager.h: #include <limits.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <iostream>

#include <contact/contact_utils/openfdem_cell.h>

#include “common/openfdem_matrix.h”

#include “common/openfdem_matrix2x2.h”

#include “common/openfdem_tensor.h”

#include “common/openfdem_vector.h”

#include “common/openfdem_vector2Utils.h”

#include “solver/openfdem.h”

file openfdem_abstract.h

Defines

_OPENFDEM_DEBUG_MODE_OFF#

file openfdem_base.h: #include “common/openfdem_chrono.h”

#include “common/openfdem_common.h”

#include “common/openfdem_config.h”

#include “common/openfdem_manager.h”

#include “common/openfdem_tools.h”

#include “openfdem.h”

#include “contact/solid_mechanics_contact_module.h”

#include “geometry/openfdem_geometry_module.h”

#include “initialize/solver_initialize_module.h”

#include “iohelper/dumper.h”

#include “iohelper/openfdem_io_module.h”

#include “mesh/globalAMR/mmgProcessmodule.h”

#include “mesh/group/group_module.h”

#include “mesh/openfdem_mesh_module.h”

#include “particles/openfdem_particle_module.h”

#include “solid/integration/solid_mechanics_update_kinematics.h”

#include “solid/solid_mechanics.h”

#include “solver/openfdem_solve_module.h”

#include “blast/openfdem_blast_module.h”

#include “hydro/openfdem_hydro_module.h”

#include “mpm/openfdem_MPM_module.h”

#include “phasefield/phase_field_model_module.h”

#include “thermal/openfdem_thermal_module.h”

file openfdem_chrono.h

#include <common/openfdem_macros.h>

#include <iomanip>

Defines

TIME_SIZE#

TIME_SIZE

file openfdem_classfactories.h

Defines

REGISTER_GENERAL#

REGISTER_ELEMENT#

REGISTER_INTERGRATION#

REGISTER_COHELEMENT#

REGISTER_CONTACT#

REGISTER_NODAL#

REGISTER_GROUP#

REGISTER_GEOMETRY#

REGISTER_MESH#

REGISTER_DFN#

REGISTER_HISTORY#

REGISTER_PARTICLE#

REGISTER_MPM#

REGISTER_EDGE#

REGISTER_BOUNDARY#

REGISTER_PARTICLECONTACT#

REGISTER_ENTITY#

REGISTER_SOLIDMATE#

REGISTER_HYDRO#

REGISTER_THERMAL#

REGISTER_BLAST#

REGISTER_SESMICITY#

REGISTER_FULL_CLASS#

file openfdem_common.h: #include <vector>

#include “common/openfdem_matrix.h”

#include “common/openfdem_matrix2x2.h”

#include “common/openfdem_tensor.h”

#include “common/openfdem_vector.h”

#include “common/openfdem_vector2.h”

#include “common/openfdem_vector2Utils.h”

#include “common/openfdem_vector3.h”

#include “openfdem_enum.h”

#include “openfdem_error.h”

#include “openfdem_math.h”

#include “openfdem_struct.h”

#include “timer.h”

file openfdem_config.h

Defines

PRG_VERSION#

OPENFDEM_WEBSITE#

OPENFDEM_COTACT#

OPENFDEM_COPYRIGHT#

HOST_TYPE#

HOST_NAME#

PRG_HEADER#

file openfdem_defines.h

#include <stdexcept>

#include <sstream>

Defines

OPENFDEM_ENV32#

file openfdem_enum.h

Enums

enum class config#

Values:

enumerator CONFIG_NONE#

enumerator PLANESTRESS#

enumerator PLANESTRAIN#

enum class elem_type#

Enum for element types will be used in OpenFDEM.

Values:

enumerator NONE#

enumerator LINE2#

enumerator TRIANGLE3#

enumerator QUADRANGLE4#

enumerator LINE3#

enumerator TRIANGLE6#

enumerator QUADRANGLE9#

enumerator QUADRANGLE8#

enumerator POLYGON#

enum class mesh_enum#

Enum for mesh processing treatment.

Values:

enumerator INSERT#

enumerator SPLIT#

enumerator REMESH3#

enumerator REMESH4#

enumerator REMESH6#

enumerator IMPLICIT#

enumerator REFINEMENT#

enum class meshtype#

Enum of the remesh type.

Values:

enumerator DEFAULT#

enumerator BARYCENTRIC#

enumerator TREFINE_R#

enumerator TREFINE_G#

enumerator TREFINE_G2#

enumerator TREFINE_B#

enumerator TREFINENVB#

enumerator BARYGB#

enum class nodalgrouptype#

Enum of method to find node. The default is from element by mesh importing More complex range can be defined using bool operator

Values:

enumerator SQUAREIN#

enumerator SQUAREOUT#

enumerator SQUAREON#

enumerator CIRCLEIN#

enumerator CIRCLEOUT#

enumerator CIRCLE#

enumerator PLANELEFT#

enumerator PLANERIGHT#

enumerator PLANE#

enumerator FROMELEMENT#

enumerator BOOL#

enumerator POLYGONIN#

enumerator POLYGONON#

enumerator POLYGONOUT#

enumerator DEFAULT#

enum class elementgrouptype#

Enum of method to find element groups.

Note

Element topology is defined by its barcentric point.

Values:

enumerator FROMMESH#

enumerator SQUAREIN#

enumerator SQUAREOUT#

enumerator SQUAREON#

enumerator CIRCLEIN#

enumerator CIRCLEON#

enumerator CIRCLEOUT#

enumerator PLANELEFT#

enumerator PLANEON#

enumerator PLANERIGHT#

enumerator BOOL#

enumerator POLYGONIN#

enumerator POLYGONON#

enumerator POLYGONOUT#

enum class rangeMethod#

Enum of Range method.

Values:

enumerator SQUAREIN#

enumerator SQUAREOUT#

enumerator SQUAREON#

enumerator CIRCLEIN#

enumerator CIRCLEON#

enumerator CIRCLEOUT#

enumerator PLANELEFT#

enumerator PLANEON#

enumerator PLANERIGHT#

enumerator POLYGONIN#

enumerator POLYGONON#

enumerator POLYGONOUT#

enum class edgegrouptype#

Enum of method to find face groups.

Values:

enumerator FROMMESH#

enumerator SQUAREIN#

enumerator SQUAREOUT#

enumerator SQUAREON#

enumerator CIRCLEIN#

enumerator CIRCLEON#

enumerator CIRCLEOUT#

enumerator PLANELEFT#

enumerator PLANEON#

enumerator PLANERIGHT#

enumerator BOOL#

enumerator FROMELEMENT#

enumerator FROCZM#

enumerator FRODFN#

enumerator POLYGONIN#

enumerator POLYGONON#

enumerator POLYGONOUT#

enum class metrictypetype#

Enum to compute remesh metrics.

Values:

enumerator VONMISESSTRESS#

enumerator PHASEFIELD#

enumerator DAMAGE#

enumerator COHESIVE#

enum class strategytype#

Remesh strategy.

Values:

enumerator DEFAULT#

enumerator BARYGB#

enumerator RGB#

enumerator RG#

enumerator NVB#

enum class meshpathtype#

Method to find the fractures in history.

Values:

enumerator NODE#

enumerator ELEMENT#

enumerator PATH#

enum class boundary_fluid_enum#

Boundary types for fluid module.

Values:

enumerator POREPRESSURE#

enumerator WATER_LEVEL#

enumerator PRESSURE#

enumerator INIPRESSURE#

enumerator FLOWRATE#

enumerator IMPERMABLE#

enumerator SATURATION#

enum class boundary_thermal_enum#

Boundary types for thermal module.

Values:

enumerator INI_TEMPERATURE#

enumerator TEMPERATURE#

enumerator CONVECTION#

enumerator FLUX#

enumerator RADIATION#

enumerator SOURCE#

enum class boundary_mechanical_enum#

Mechnical boundary types. Dirchlet boundary Neumann boundary

Values:

enumerator FORCE#

enumerator VEL#

enumerator INIVEL#

enumerator VISCOUS#

enumerator ACCEL_0#

enumerator FORCE_LOCAL#

enumerator VEL_LOCAL#

enumerator INIVEL_LOCAL#

enumerator ACCEL_LOCAL#

enumerator PRESSURE#

enumerator STRESS#

Element boundary types.

STRESS = 0, force in x direction GRADIENT_X = 1, force in y direction GRADIENT_Y= 2, velocity in x direction

enumerator GRADIENT_X#

enumerator GRADIENT_Y#

enum class cohelement_enum#

Failure type of the cohesive elements.

Values:

enumerator INTACT#

enumerator DAMAGE#

enumerator BROKEN#

enumerator BOUDARY#

enum class nonlocal_method#

method to compute nonlocal indicator.

Values:

enumerator WFT_BELL#

enumerator WFT_GAUSS#

enumerator WFT_EXP#

enumerator WFT_AVERAGE#

enum class DFN_enum#

DFN state.

Values:

enumerator NDFN#

enumerator DFN_COHESIVE#

enumerator DFN_BROKEN#

enum class module#

solver module types. MECHANICAL = 0, mechanical module HYDRO = 1, hydro module THERMAL = 2, thermal module BLAST = 3, blast module

Values:

enumerator MECHANICAL#

enumerator HYDRO#

enumerator THERMAL#

enumerator BLAST#

enumerator BLAST_HYDRO#

enumerator DYNAMIC#

enum class element_cons#

Values:

enumerator EXCAVATION#

enumerator ELASTIC#

enumerator NEO#

enumerator RIGID#

enumerator TRANSVERSE#

enumerator MC#

enumerator DP#

enumerator Hoek#

enumerator BURGERS#

enumerator VIS_POWER#

enumerator MAZARS#

enumerator JWL#

enumerator JH2#

enumerator TCK#

enumerator YANG#

enumerator DFB#

enumerator SNOW#

enumerator SAND#

enumerator OTHERS#

enum class cohelement_cons#

Values:

enumerator COH_EM#

enumerator COH_EM_FRIC#

enumerator COH_LINEAR#

enumerator COH_OP#

enumerator COH_BB#

enumerator COH_EM_HET#

enumerator COH_EM_ANI#

enumerator COH_EM_DYNAMIC#

enumerator COH_OTHERS#

enum class contact_cons#

enum of contact model types both for elements or particles. The default for element contact is dynamic friction model and the default for particle contact is standard

CON_MC = 0, Mohr-coulomb friction CON_ResidualMC = 1, dynamic friction consider residual friction CON_DYNAMIC_MC = 2, dynamic firction CON_HERTZ = 3, hertz contact model, which is nonliear in normal direction CON_BB = 4, Barton-bandies contact model CON_FRICTION = 5, RSF law for fault CON_GG_SHEAR = 6, Grasselli dilation shear model CON_STANDARD = 8, standard Mohr-coumlomb slide for particles CON_BOND = 9, bonded particle contact CON_RROTATION = 10, rontation resistance model for particle contact

Values:

enumerator CON_MC#

enumerator CON_ResidualMC#

enumerator CON_DYNAMIC_MC#

enumerator CON_HERTZ#

enumerator CON_BB#

enumerator CON_FRICTION#

enumerator CON_GG_SHEAR#

enumerator CON_OTHERS#

enumerator CON_STANDARD#

enumerator CON_BOND#

enumerator CON_RROTATION#

enum class contact_detection#

enum for contact rough search approach. The default is Li-Grasselli’s method, which is a time-dependent method

NBS = 1, default Munjiza’s method without CPU parallerization mNBS = 2, modifed Munjiza’s NBS method combining with time-dependent potentional element list and CPU parallerization CELL = 3, cell based method which is appicable for contact seceniro that the enetityes size are much different

Values:

enumerator LIG#

enumerator NBS#

enumerator mNBS#

enumerator CELL#

enum class contact_force#

enum for contact force potentinal method. the defualt is new potentional and can be extended to friction, RSF, residual friction, dilation law

DEFAULT_MUNJIZA = 0, Munjiza’s model, fails to be parallerized and is not applicable for shear sliding. LIF_F =1, new contact potential model can be applicable for arbitary-arbitary contact type

Values:

enumerator DEFAULT_MUNJIZA#

enumerator SHAPE_FUNCTION#

enum class random_method#

Values:

enumerator RANDOM_NULL#

enumerator RANDOM_CONSTANT#

enumerator RANDOM_GAUSSE#

enumerator RANDOM_UNIFORM#

enumerator RANDOM_EXPONENTINAL#

enumerator RANDOM_LOG_NORMAL#

enumerator RANDOM_POWER#

enumerator RANDOM_FISHER#

enum class his_nodal_t#

enum of history variable type for nodals.

Values:

enumerator HIS_DIS#

enumerator HIS_VEL#

enumerator HIS_FOR#

enumerator HIS_FLUID_P#

enumerator HIS_FRAC_P#

enumerator HIS_MATRIX_P#

enumerator HIS_TEMP#

enum class his_ele_t#

enum of history variable types for elements.

Values:

enumerator HIS_STRESS#

enumerator HIS_STRAIN#

enumerator HIS_STRAIN_R#

enumerator HIS_PLASTIC#

enum class his_cohele_t#

enum of history variable types for interface elements.

Values:

enumerator HIS_COH_DIS#

enumerator HIS_COH_FOR#

enumerator HIS_COH_VEL#

enumerator HIS_COH_SHEAR#

enum class his_contact_t#

Values:

enumerator HIS_CON_DIS#

enumerator HIS_CON_FOR#

enumerator HIS_CON_VEL#

enum class his_general_t#

Values:

enumerator HIS_TIME#

enumerator HIS_CYCLE#

enumerator HIS_N_FRACTURE#

enumerator HIS_N_DAMAGE#

enumerator HIS_N_AE#

enumerator HIS_ENERGY_KINETIC#

enumerator HIS_ENERGY_ELEMENT_STRAIN#

enumerator HIS_ENERGY_FRACTURE#

enumerator HIS_ENERGY_AE#

enumerator HIS_ENERGY_DAMP#

enumerator HIS_ENERGY_SLIP#

enumerator HIS_ENERGY_PLASTIC#

enumerator HIS_UNBALANCE_FORCE#

enumerator HIST_ENERGY_RATIO#

file openfdem_error.h

#include “logger.h”

#include <cstdio>

#include <cstdlib>

#include <set>

#include <sstream>

#include <stdexcept>

#include <string>

#include <typeinfo>

#include <utility>

Defines

OPENFDEM_DEBUG#

OPENFDEM_EXIT(code)#: Cause openfdem program termination by calling exit.

OPENFDEM_FATAL(...)#: Macros for printing errors. This macro can be used only within classes that implement errorInfo function.

OPENFDEM_ERROR(...)#

OPENFDEM_WARNING(...)#

OPENFDEM_SERROR(...)#

OPENFDEM_SWARNING(...)#

OPENFDEM_LOCATION#: Macros for debugging in function.

OPENFDEM_STRINGSTREAM_IN(_str, _sstr)#

OPENFDEM_DEBUG_(pref, info)#

OPENFDEM_DEBUG_IN()#

OPENFDEM_DEBUG_OUT()#

OPENFDEM_DEBUG_IN()

OPENFDEM_DEBUG_OUT()

file openfdem_general.h

#include “common/openfdem_common.h”

Typedefs

typedef struct General_structure *General#

file openfdem_macros.h

#include <cmath>

#include <string>

#include “openfdem_struct.h”

Defines

STRINGIZE_(x)#

STRINGIZE(x)#

FileNull#

Char2DNull#

Double1DNull#

Double2DNull#

Double3DNull#

Int1DNull#

Int2DNull#

NULL#

_USE_POLYGON_#

POLYGON_NODE_SIZE#

POLYFACE#

OPENFDEM_EXIT_SUCCESS#

OPENFDEM_EXIT_FAILURE#

_for(i, a, b)#

Ind(i, j, __rows, __cols)#

copyRawArray(from, destination, size)#

copyArray(from, destination, size)#

freeArray(list)#

copyVector(from, destination, size)#

freeVector(list, type)#

StringCompare(sting1, string2)#

StringCompareN(sting1, string2, n)#

copyChars(destination, from)#

isSameString(TestChar, TargetChar)#

isSamePrefix(TestChar, TargetChar, size)#

MAXARGC#

Openfdem_ARGC_LENGTH#

Openfdem_FILE_LIMIT#

OPENFDEM_DIMENSION#

CZM_NODE_SIZE#

CZM_EDGE_SIZE#

CZM_ELEMENT_SIZE#

RANGE_SIZE#

ID_RANGE_SIZE#

EDGE_NODE_SIZE#

NHALFCZMNODE#

NCZMGAUSS#

NMATRIXNODE#

NMATRIXGAUSS#

MAX_GROUP_SIZE#

MAX_MATERIAL_SIZE#

MAT_MATRIX_TYPE_ID#

MAT_CZM_TYPE_ID#

MAT_CONTACT_TYPE_ID#

MAT_HYDRO_TYPE_ID#

MAT_HYDRO_MATRIX_TYPE_ID#

MAT_HYDRO_FRACTURE_TYPE_ID#

MAT_HYDRO_FLUID_TYPE_ID#

MAT_HYDRO_GAS_TYPE_ID#

MAT_THERMAL_TYPE_ID#

MAX_BOUNDARY_SIZE#

BOU_ON_NODE_TYPE_ID#

BOU_ON_EDGE_TYPE_ID#

BOU_ON_ELEMENT_TYPE_ID#

BOU_ON_HYDRO_TYPE_ID#

BOU_ON_THERMAL_TYPE_ID#

precisionPolarDecompose#

Evans_Marathe_a#

Evans_Marathe_b#

Evans_Marathe_a

getIntValue(file, x)#

getRealValue(file, x)#

getCharValue(file, x)#

writeCharValue(file, x)#

writeIntValue(file, x, ndigit)#

writeRealValue(file, x, ndigit)#

writeStringValue(file, x, ndigit)#

Variables

static const UInt shear_now = 0x001#

static const UInt tension_now = 0x002#

static const UInt shear_past = 0x004#

static const UInt tension_past = 0x008#

const TensorIndex _internalIndexes = {0, 1, -1, 2, 3, -1, -1, -1, 4}#

static const Int TRITOEDGE[][2] = {{0, 1}, {1, 2}, {2, 0}}#

static const Int TRITOQUADEDGE[3] = {3, 4, 5}#

static const Int QUADTOEDGE[][2] = {{0, 1}, {1, 2}, {2, 3}, {3, 0}}#

static const Int QUADTOQUADEDGE[4] = {4, 5, 6, 7}#

static const char *DoubleString[20] = {"%le", "%+1.0le", "%+2.0le", "%+3.0le", "%+4.0le", "%+5.0le", "%+6.0le", "%+7.0le", "%+8.1le", "%+9.2le", "%+10.3le", "%+11.4le", "%+12.5le", "%+13.6le", "%+14.7le", "%+15.8le", "%+16.9le", "%+17.10le", "%+18.11le", "%+19.12le"}#

static const char *IntString[20] = {"%ld", "%1ld", "%2ld", "%3ld", "%4ld", "%5ld", "%6ld", "%7ld", "%8ld", "%9ld", "%10ld", "%11ld", "%12ld", "%13ld", "%14ld", "%15ld", "%16ld", "%17ld", "%18ld", "%19ld"}#

static const char *CharString[30] = {"%s", "%1s", "%2s", "%3s", "%4s", "%5s", "%6s", "%7s", "%8s", "%9s", "%10s", "%11s", "%12s", "%13s", "%14s", "%15s", "%16s", "%17s", "%18s", "%19s", "%20s", "%21s", "%22s", "%23s", "%24s", "%25s", "%26s", "%27s", "%28s", "%29s"}#

file openfdem_manager.h: #include <ctime>

#include <cmath>

#include <cstring>

#include <stdio.h>

#include <sys/stat.h>

#include “common/openfdem_message.h”

#include “common/openfdem_config.h”

#include “common/openfdem_general.h”

file openfdem_math.h

#include <math.h>

#include “openfdem_classfactories.h”

#include “openfdem_macros.h”

#include “openfdem_error.h”

Defines

Openfdem_pos_epsilon#

Openfdem_neg_epsilon#

Openfdem_max_value#

Openfdem_PI#

d4d3#

d2d3#

d1d3#

Openfdem_e#

MMG2D_ALPHAD#

Openfdem_sqrt32#

Openfdem_2PI#

Openfdem_Deg2Rad#

Openfdem_InvSqrt2#

Openfdem_InvSqrt3#

Openfdem_RadToDeg#

Openfdem_Sqrt2#

Openfdem_Sqrt23#

Openfdem_Sqrt3#

Openfdem_Sqrt32#

Openfdem_Sqrt3m1#

Openfdem_Sqrt3m2#

Openfdem_Sqrt3m3#

Openfdem_Sqrt3p1#

Openfdem_Sqrt3p2#

Openfdem_Sqrt3p3#

Openfdem_double_abs(x)#

openfdem_square(a)#

Openfdem_max(x, y)#

Openfdem_max3(a, b, c)#

Openfdem_max4(a, b, c, d)#

Openfdem_min(x, y)#

Openfdem_min3(a, b, c)#

Openfdem_sign(x)#

Openfdem_bracket(x)#

Openfdem_MacAuley(x)#

Openfdem_SurfTriangle(a, b, c)#

Openfdem_SurfTrianglePts(xa, ya, xb, yb, xc, yc)#

Openfdem_LinearInterp(x1, x2, dx)#

Openfdem_BetweenValues(a, b, c)#

Openfdem_BetweenValuesExclude(a, b, c)#

Openfdem_Kronecker(i, j)#

Matrix2Inverse(m, minv, det)#

Vector2DotProduct(s, x1, y1, x2, y2)#

Vector2Normalize(s, x1, y1)#

Vector2Cro(s, x1, y1, x2, y2)#

VectorPointDistance(l, x1, y1, x2, y2)#

VectorLength(x1, y1)#

NextVertex(i, nNodes)#

LastVertex(i, nNodes)#

Openfdem_LineNode(x)#

V2Darea(s, l1, l2, l3)#

file openfdem_matrix.h: #include <iostream>

#include <ostream>

#include “common/openfdem_math.h”

#include “common/openfdem_vector2.h”

#include “openfdem_struct.h”

file openfdem_matrix2x2.h

#include <iostream>

#include <ostream>

#include “common/openfdem_math.h”

#include “common/openfdem_vector2.h”

Defines

MAX_MATRIX2_SIZE#

MAX_MATRIX2_ROW#

MAX_MATRIX2_COL#

file openfdem_message.h: #include <common/openfdem_macros.h>

file openfdem_string.h: #include <string>

file openfdem_struct.h

#include <math.h>

#include <openfdem_defines.h>

#include <stdint.h>

#include <stdlib.h>

#include <omp.h>

Defines

MAX_KEYWORD_LENGTH#

MAX_KEYWORDS#

MAX_CHARACTER#

_OPENMPI_#

Typedefs

using UInt = unsigned int#

using Int = long#

using Real = double#

file openfdem_tensor.h

#include <array>

#include <string.h>

#include <string>

#include <vector>

#include “common/openfdem_math.h”

#include “common/openfdem_vector2.h”

Defines

MAX_TENSOR_SIZE#

file openfdem_tools.h: #include “common/openfdem_abstract.h”

#include “solver/openfdem.h”

file openfdem_vector.h: #include <string.h>

#include <string>

#include “openfdem_struct.h”

#include “common/openfdem_vector2.h”

file openfdem_vector2.h: #include <math.h>

#include “openfdem_math.h”

file openfdem_vector2Utils.h: #include <math.h>

#include <stdlib.h>

#include “common/openfdem_math.h”

#include “common/openfdem_vector2.h”

file openfdem_vector3.h: #include <math.h>

#include “openfdem_math.h”

file spdlog_common.h

#include “spdlog/cfg/env.h”

#include “spdlog/sinks/basic_file_sink.h”

#include “spdlog/sinks/rotating_file_sink.h”

#include “spdlog/spdlog.h”

Defines

SPDLOG_ACTIVE_LEVEL#

SPDLOG_INFO_FILE(...)#

SPDLOG_WARN_FILE(...)#

SPDLOG_ERROR_FILE(...)#

SPDLOG_CRITICAL_FILE(...)#

Variables

constexpr auto LOGGER_NAME = "openFDEM"#

constexpr auto LOGGER_SAVE_PATH = "logs/ofdem_log.txt"#

file asciidoc_exporter.hpp: #include <algorithm>

#include <optional>

#include <sstream>

#include <string>

#include <tabulate/exporter.hpp>

file cell.hpp: #include <iostream>

#include <memory>

#include <string>

#include <tabulate/format.hpp>

#include <tabulate/utf8.hpp>

#include <tabulate/optional_lite.hpp>

#include <vector>

file color.hpp: #include <tabulate/termcolor.hpp>

file column.hpp: #include <algorithm>

#include <functional>

#include <iostream>

#include <memory>

#include <tabulate/optional_lite.hpp>

#include <string>

#include <tabulate/cell.hpp>

#include <tabulate/column_format.hpp>

#include <vector>

file column_format.hpp

file exporter.hpp: #include <string>

#include <tabulate/table.hpp>

file font_align.hpp

file font_style.hpp

file format.hpp: #include <algorithm>

#include <cctype>

#include <cstddef>

#include <sstream>

#include <string>

#include <tabulate/color.hpp>

#include <tabulate/font_align.hpp>

#include <tabulate/font_style.hpp>

#include <tabulate/utf8.hpp>

#include <tabulate/optional_lite.hpp>

#include <vector>

file latex_exporter.hpp: #include <tabulate/exporter.hpp>

#include <tabulate/optional_lite.hpp>

file markdown_exporter.hpp: #include <tabulate/exporter.hpp>

file optional_lite.hpp

#include <cstddef>

#include <cassert>

#include <utility>

Defines

NONSTD_OPTIONAL_LITE_HPP#

optional_lite_MAJOR#

optional_lite_MINOR#

optional_lite_PATCH#

optional_lite_VERSION#

optional_STRINGIFY(x)#

optional_STRINGIFY_(x)#

optional_OPTIONAL_DEFAULT#

optional_OPTIONAL_NONSTD#

optional_OPTIONAL_STD#

optional_CONFIG_SELECT_OPTIONAL#

optional_CONFIG_NO_EXCEPTIONS#

optional_CPLUSPLUS#

optional_CPP98_OR_GREATER#

optional_CPP11_OR_GREATER#

optional_CPP11_OR_GREATER_#

optional_CPP14_OR_GREATER#

optional_CPP17_OR_GREATER#

optional_CPP20_OR_GREATER#

optional_CPLUSPLUS_V#

optional_HAVE_STD_OPTIONAL#

optional_USES_STD_OPTIONAL#

nonstd_lite_HAVE_IN_PLACE_TYPES#

nonstd_lite_in_place_t(T)#

nonstd_lite_in_place_type_t(T)#

nonstd_lite_in_place_index_t(K)#

nonstd_lite_in_place(T)#

nonstd_lite_in_place_type(T)#

nonstd_lite_in_place_index(K)#

optional_CONFIG_MAX_ALIGN_HACK#

optional_CONFIG_ALIGN_AS_FALLBACK#

optional_BETWEEN(v, lo, hi)#

optional_COMPILER_MSVC_VER#

optional_COMPILER_MSVC_VERSION#

optional_COMPILER_VERSION(major, minor, patch)#

optional_COMPILER_GNUC_VERSION#

optional_COMPILER_CLANG_VERSION#

optional_HAVE(FEATURE)#

optional_HAS_CPP0X#

optional_CPP11_90#

optional_CPP11_100#

optional_CPP11_110#

optional_CPP11_120#

optional_CPP11_140#

optional_CPP11_141#

optional_CPP11_140_490#

optional_CPP14_000#

optional_CPP17_000#

optional_HAVE_CONSTEXPR_11#

optional_HAVE_IS_DEFAULT#

optional_HAVE_NOEXCEPT#

optional_HAVE_NULLPTR#

optional_HAVE_REF_QUALIFIER#

optional_HAVE_INITIALIZER_LIST#

optional_HAVE_CONSTEXPR_14#

optional_HAVE_NODISCARD#

optional_HAVE_CONDITIONAL#

optional_HAVE_REMOVE_CV#

optional_HAVE_TYPE_TRAITS#

optional_HAVE_TR1_TYPE_TRAITS#

optional_HAVE_TR1_ADD_POINTER#

optional_constexpr#

optional_is_default#

optional_constexpr14#

optional_nodiscard#

optional_noexcept#

optional_nullptr#

optional_ref_qual#

optional_refref_qual#

optional_ALIGN_AS(to_align)#

optional_ALIGN_TYPE(type)#

file printer.hpp: #include <tabulate/color.hpp>

#include <tabulate/font_style.hpp>

#include <utility>

#include <vector>

file row.hpp: #include <iostream>

#include <memory>

#include <string>

#include <tabulate/cell.hpp>

#include <tabulate/optional_lite.hpp>

#include <vector>

file string_view_lite.hpp

#include <algorithm>

#include <cassert>

#include <iterator>

#include <limits>

#include <string>

#include <ostream>

Defines

NONSTD_SV_LITE_H_INCLUDED#

string_view_lite_MAJOR#

string_view_lite_MINOR#

string_view_lite_PATCH#

string_view_lite_VERSION#

nssv_STRINGIFY(x)#

nssv_STRINGIFY_(x)#

nssv_STRING_VIEW_DEFAULT#

nssv_STRING_VIEW_NONSTD#

nssv_STRING_VIEW_STD#

nssv_HAVE_TWEAK_HEADER#

nssv_CONFIG_SELECT_STRING_VIEW#

nssv_CONFIG_STD_SV_OPERATOR#

nssv_CONFIG_USR_SV_OPERATOR#

nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS#

nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS#

nssv_CONFIG_NO_STREAM_INSERTION#

nssv_CONFIG_NO_EXCEPTIONS#

nssv_CPLUSPLUS#

nssv_CPP98_OR_GREATER#

nssv_CPP11_OR_GREATER#

nssv_CPP11_OR_GREATER_#

nssv_CPP14_OR_GREATER#

nssv_CPP17_OR_GREATER#

nssv_CPP20_OR_GREATER#

nssv_HAVE_STD_STRING_VIEW#

nssv_USES_STD_STRING_VIEW#

nssv_HAVE_STARTS_WITH#

nssv_HAVE_ENDS_WITH#

nssv_COMPILER_MSVC_VER#

nssv_COMPILER_MSVC_VERSION#

nssv_COMPILER_VERSION(major, minor, patch)#

nssv_COMPILER_APPLECLANG_VERSION#

nssv_COMPILER_CLANG_VERSION#

nssv_COMPILER_GNUC_VERSION#

nssv_BETWEEN(v, lo, hi)#

nssv_HAS_CPP0X#

nssv_CPP11_90#

nssv_CPP11_100#

nssv_CPP11_110#

nssv_CPP11_120#

nssv_CPP11_140#

nssv_CPP11_141#

nssv_CPP14_000#

nssv_CPP17_000#

nssv_HAVE_CONSTEXPR_11#

nssv_HAVE_EXPLICIT_CONVERSION#

nssv_HAVE_INLINE_NAMESPACE#

nssv_HAVE_NOEXCEPT#

nssv_HAVE_NULLPTR#

nssv_HAVE_REF_QUALIFIER#

nssv_HAVE_UNICODE_LITERALS#

nssv_HAVE_USER_DEFINED_LITERALS#

nssv_HAVE_WCHAR16_T#

nssv_HAVE_WCHAR32_T#

nssv_HAVE_STD_DEFINED_LITERALS#

nssv_HAVE_CONSTEXPR_14#

nssv_HAVE_NODISCARD#

nssv_HAVE_STD_HASH#

nssv_HAVE_BUILTIN_VER#

nssv_HAVE_BUILTIN_CE#

nssv_HAVE_BUILTIN_MEMCMP#

nssv_HAVE_BUILTIN_STRLEN#

nssv_HAVE_BUILTIN(x)#

nssv_BUILTIN_MEMCMP#

nssv_BUILTIN_STRLEN#

nssv_constexpr#

nssv_constexpr14#

nssv_explicit#

nssv_inline_ns#

nssv_noexcept#

nssv_nullptr#

nssv_nodiscard#

nssv_SUPPRESS_MSGSL_WARNING(expr)#

nssv_SUPPRESS_MSVC_WARNING(code, descr)#

nssv_DISABLE_MSVC_WARNINGS(codes)#

nssv_RESTORE_WARNINGS()#

Functions

nssv_DISABLE_MSVC_WARNINGS (4455 26481 26472) namespace nonstd

file table.hpp: #include <tabulate/table_internal.hpp>

#include <tabulate/string_view_lite.hpp>

#include <tabulate/variant_lite.hpp>

#include <utility>

file table_internal.hpp: #include <algorithm>

#include <iostream>

#include <string>

#include <tabulate/column.hpp>

#include <tabulate/font_style.hpp>

#include <tabulate/printer.hpp>

#include <tabulate/row.hpp>

#include <tabulate/termcolor.hpp>

#include <vector>

file tabulate.hpp

Defines

TABULATE_VERSION_MAJOR#

TABULATE_VERSION_MINOR#

TABULATE_VERSION_PATCH#

TABULATE_CONCATENATE(A, B)#

TABULATE_CONCATENATE_IMPL(A, B)#

TABULATE_STRINGIFY(a)#

TABULATE_STRINGIFY_IMPL(a)#

file termcolor.hpp: #include <cstdio>

#include <iostream>

file utf8.hpp: #include <algorithm>

#include <cstdint>

#include <string>

#include <clocale>

#include <locale>

#include <cstdlib>

#include <tabulate/termcolor.hpp>

#include <wchar.h>

file variant_lite.hpp

#include <cstddef>

#include <limits>

#include <new>

#include <utility>

#include <cassert>

Defines

NONSTD_VARIANT_LITE_HPP#

variant_lite_MAJOR#

variant_lite_MINOR#

variant_lite_PATCH#

variant_lite_VERSION#

variant_STRINGIFY(x)#

variant_STRINGIFY_(x)#

variant_VARIANT_DEFAULT#

variant_VARIANT_NONSTD#

variant_VARIANT_STD#

variant_CONFIG_SELECT_VARIANT#

variant_CONFIG_OMIT_VARIANT_SIZE_V_MACRO#

variant_CONFIG_OMIT_VARIANT_ALTERNATIVE_T_MACRO#

variant_CONFIG_NO_EXCEPTIONS#

variant_CPLUSPLUS#

variant_CPP98_OR_GREATER#

variant_CPP11_OR_GREATER#

variant_CPP11_OR_GREATER_#

variant_CPP14_OR_GREATER#

variant_CPP17_OR_GREATER#

variant_CPP20_OR_GREATER#

variant_HAVE_STD_VARIANT#

variant_USES_STD_VARIANT#

nonstd_lite_HAVE_IN_PLACE_TYPES

nonstd_lite_in_place_t(T)

nonstd_lite_in_place_type_t(T)

nonstd_lite_in_place_index_t(K)

nonstd_lite_in_place(T)

nonstd_lite_in_place_type(T)

nonstd_lite_in_place_index(K)

variant_CONFIG_MAX_TYPE_COUNT#

variant_CONFIG_MAX_VISITOR_ARG_COUNT#

variant_CONFIG_MAX_ALIGN_HACK#

variant_CONFIG_ALIGN_AS_FALLBACK#

variant_BETWEEN(v, lo, hi)#

variant_COMPILER_MSVC_VER#

variant_COMPILER_MSVC_VERSION#

variant_COMPILER_VERSION(major, minor, patch)#

variant_COMPILER_CLANG_VERSION#

variant_COMPILER_GNUC_VERSION#

variant_HAVE(feature)#

variant_HAS_CPP0X#

variant_CPP11_90#

variant_CPP11_100#

variant_CPP11_110#

variant_CPP11_120#

variant_CPP11_140#

variant_CPP11_141#

variant_CPP14_000#

variant_CPP17_000#

variant_HAVE_CONSTEXPR_11#

variant_HAVE_INITIALIZER_LIST#

variant_HAVE_NOEXCEPT#

variant_HAVE_NULLPTR#

variant_HAVE_OVERRIDE#

variant_HAVE_CONSTEXPR_14#

variant_HAVE_CONDITIONAL#

variant_HAVE_REMOVE_CV#

variant_HAVE_STD_ADD_POINTER#

variant_HAVE_TYPE_TRAITS#

variant_HAVE_TR1_TYPE_TRAITS#

variant_HAVE_TR1_ADD_POINTER#

variant_constexpr#

variant_constexpr14#

variant_noexcept#

variant_nullptr#

variant_override#

variant_TL1(T1)#

variant_TL2(T1, T2)#

variant_TL3(T1, T2, T3)#

variant_TL4(T1, T2, T3, T4)#

variant_TL5(T1, T2, T3, T4, T5)#

variant_TL6(T1, T2, T3, T4, T5, T6)#

variant_TL7(T1, T2, T3, T4, T5, T6, T7)#

variant_TL8(T1, T2, T3, T4, T5, T6, T7, T8)#

variant_TL9(T1, T2, T3, T4, T5, T6, T7, T8, T9)#

variant_TL10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)#

variant_TL11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)#

variant_TL12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)#

variant_TL13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)#

variant_TL14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)#

variant_TL15(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)#

variant_TL16(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)#

variant_ALIGN_AS(to_align)#

variant_ALIGN_TYPE(type)#

variant_size_V(T)#

variant_alternative_T(K, T)#

file timer.h: #include <chrono>

dir common

dir src

dir tabulate