File fieldgenerators.hxx¶

These classes are used by FieldFactory

Typedefs

using single_arg_op = BoutReal (*)(BoutReal)¶: Template class to define generators around a C function.

using double_arg_op = BoutReal (*)(BoutReal, BoutReal)¶: Template for a FieldGenerator with two input arguments.

class FieldValuePtr : public FieldGenerator ¶

#include <fieldgenerators.hxx>

Creates a Field Generator using a pointer to value WARNING: The value pointed to must remain in scope until this generator is finished

Public Functions

inline FieldValuePtr(BoutReal *val)¶

inline virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

inline virtual BoutReal generate(const bout::generator::Context&) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

Private Members

BoutReal *ptr¶

template<single_arg_op Op> class FieldGenOneArg : public FieldGenerator ¶

Public Functions

inline FieldGenOneArg(FieldGeneratorPtr g, const std::string &name = ~~"function"~~)¶: < Template for single-argument function

inline virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

inline virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

inline virtual std::string str() const override¶: Create a string representation of the generator, for debugging output.

Private Members

FieldGeneratorPtr gen¶

std::string name¶: A string describing the function, to be printed in error messages.

template<double_arg_op Op> class FieldGenTwoArg : public FieldGenerator ¶

Public Functions

inline FieldGenTwoArg(FieldGeneratorPtr a, FieldGeneratorPtr b, const std::string &name = ~~"function"~~)¶: < Template for two-argument function

inline virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

inline virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

inline virtual std::string str() const override¶: Create a string representation of the generator, for debugging output.

Private Members

FieldGeneratorPtr A¶

FieldGeneratorPtr B¶

std::string name¶: The name of the function, to be printed in error messages.

class FieldATan : public FieldGenerator ¶

#include <fieldgenerators.hxx>

Arc (Inverse) tangent. Either one or two argument versions.

Public Functions

inline FieldATan(FieldGeneratorPtr a, FieldGeneratorPtr b = nullptr)¶

inline virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

inline virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

Private Members

FieldGeneratorPtr A¶

FieldGeneratorPtr B¶

class FieldGaussian : public FieldGenerator ¶

#include <fieldgenerators.hxx>

Gaussian distribution, taking mean and width arguments.

Public Functions

inline FieldGaussian(FieldGeneratorPtr xin, FieldGeneratorPtr sin)¶

virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

Private Members

FieldGeneratorPtr X¶

FieldGeneratorPtr s¶

class FieldHeaviside : public FieldGenerator ¶

#include <fieldgenerators.hxx>

Heaviside function, switches between 0 and 1.

Public Functions

inline FieldHeaviside(FieldGeneratorPtr g)¶

virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

inline virtual std::string str() const override¶: Create a string representation of the generator, for debugging output.

Private Members

FieldGeneratorPtr gen¶

class FieldMin : public FieldGenerator ¶

#include <fieldgenerators.hxx>

Minimum.

Public Functions

FieldMin() = default¶

inline FieldMin(const std::list<FieldGeneratorPtr> args)¶

inline virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

inline virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

Private Members

std::list<FieldGeneratorPtr> input¶

class FieldMax : public FieldGenerator ¶

#include <fieldgenerators.hxx>

Maximum.

Public Functions

FieldMax() = default¶

inline FieldMax(const std::list<FieldGeneratorPtr> args)¶

inline virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

inline virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

Private Members

std::list<FieldGeneratorPtr> input¶

class FieldClamp : public FieldGenerator ¶

#include <fieldgenerators.hxx>

Clamp

Force a value to be in specified range Also called clip e.g. in NumPy, but in C++17 std::clamp is in <algorithm>

Note that the result is not well defined if low > high

Public Functions

FieldClamp() = default¶

inline FieldClamp(FieldGeneratorPtr value, FieldGeneratorPtr low, FieldGeneratorPtr high)¶

inline virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

inline virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

Private Members

FieldGeneratorPtr value¶: The value to be clamped.

FieldGeneratorPtr low¶

FieldGeneratorPtr high¶: The range within which the result will be.

class FieldRound : public FieldGenerator ¶

#include <fieldgenerators.hxx>

Generator to round to the nearest integer.

Public Functions

inline FieldRound(FieldGeneratorPtr g)¶

inline virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

inline virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

Private Members

FieldGeneratorPtr gen¶

class FieldBallooning : public FieldGenerator ¶

Public Functions

inline FieldBallooning(Mesh *m, FieldGeneratorPtr a = nullptr, int n = 3)¶

virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

Private Members

Mesh *mesh¶

FieldGeneratorPtr arg¶

int ball_n¶

class FieldMixmode : public FieldGenerator ¶

Public Functions

FieldMixmode(FieldGeneratorPtr a = nullptr, BoutReal seed = 0.5)¶

virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

Private Functions

BoutReal genRand(BoutReal seed)¶

Generate a random number between 0 and 1 (exclusive) given an arbitrary seed value

This PRNG has no memory, i.e. you need to call it with a different seed each time.

Private Members

FieldGeneratorPtr arg¶

BoutReal phase[14]¶

class FieldTanhHat : public FieldGenerator ¶

Public Functions

inline FieldTanhHat(FieldGeneratorPtr xin, FieldGeneratorPtr widthin, FieldGeneratorPtr centerin, FieldGeneratorPtr steepnessin)¶

virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

virtual BoutReal generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

Private Members

FieldGeneratorPtr X¶

FieldGeneratorPtr width¶

FieldGeneratorPtr center¶

FieldGeneratorPtr steepness¶

class FieldWhere : public FieldGenerator ¶

Public Functions

inline FieldWhere(FieldGeneratorPtr test, FieldGeneratorPtr gt0, FieldGeneratorPtr lt0)¶

inline virtual FieldGeneratorPtr clone(const std::list<FieldGeneratorPtr> args) override¶

Virtual constructor. Makes a copy of this FieldGenerator, initialised with the given list of arguments. It is up to the implementations to test whether the correct number of arguments is passed.

Parameters: args – [in] A (possibly empty) list of arguments to the generator function

inline virtual double generate(const bout::generator::Context &pos) override¶

Generate a value at the given coordinates (x,y,z,t) This should be deterministic, always returning the same value given the same inputs

Note: The default implementations of generate call each other; the implementor of a FieldGenerator type must implement one of them or an infinite recursion results. This is for backward compatibility for users and implementors. In a future version this function will be made pure virtual.

inline virtual std::string str() const override¶: Create a string representation of the generator, for debugging output.

Private Members

FieldGeneratorPtr test¶

FieldGeneratorPtr gt0¶

FieldGeneratorPtr lt0¶