Class xlifepp::Unknown

class Unknown

end user’s class to manage problem unknowns

Subclassed by xlifepp::ComponentOfUnknown, xlifepp::ComponentsOfUnknown, xlifepp::TestFunction

Public Functions

Unknown()

default constructor

inline Unknown(const string_t &na, Space *sp, dimen_t nc, bool co, Unknown *du, number_t ra, bool iu)

full explicit constructor

Unknown(const string_t &nm, Space &sp, dimen_t d = 1, number_t r = 0)

unknown constructor from space, d is the number of components (user), r the unknown rank

Unknown(Space &sp, const char *nm, dimen_t d = 1, number_t r = 0)

unknown constructor from space, d is the number of components (user), r the unknown rank

Unknown(Space &sp, const string_t &nm, dimen_t d = 1, number_t r = 0)

unknown constructor from space, d is the number of components (user), r the unknown rank

inline virtual const ComponentOfUnknown *asComponent() const

return Unknown as a ComponentOfUnknown if it is

inline virtual dimen_t componentIndex() const

return component index if a ComponentOfUnknown, 0 if not

inline bool &conjugate()

return the conjugate state (true/false) flag

inline bool conjugate() const

return the conjugate state (true/false) flag

inline void conjugate(bool v) const

set the conjugate state flag

number_t degree() const

order of polynom used by unknown (degree od basis), decreased by order of derivation as we use numtype (order of interpolation) we distinguish Pk or Qk using a ShapeType argument

order of polynoms used by unknown (degree of basis) if FE space !

inline virtual dimen_t dimFun() const

dimension of basis functions

const Unknown &dual() const

return the dual unknown

inline Unknown *dual_p() const

return the pointer to dual unknown

inline bool extensionRequired() const

if FEspace, max degree of polynoms else return 5

true if unknown space has no trace space

number_t index() const

return index of unknown (its rank in the Unknows vector)

inline virtual bool isComponent() const

true if a ComponentOfUnknown

inline bool isFE() const

true if FE unknown (FE space)

inline bool isSpectral() const

true if spectral unknown (spectral space)

inline string_t name() const

return name

inline virtual dimen_t nbOfComponents() const

dimension of unknown

EssentialCondition operator=(const complex_t&)

construct equation u = c

EssentialCondition operator=(const Function&)

construct equation u = f

EssentialCondition operator=(const real_t&)

construct equation u = r

EssentialCondition operator=(const TermVector&)

construct equation u = TermVector (implemented in TermVector.cpp)

Unknown &operator[](dimen_t)

create in memory the ComponentOfUnknown u_i

inline virtual const Unknown *parent() const

return parent (itself)

inline number_t rank() const

return the unknown rank (const)

void setRank(number_t)

set the rank, checking it is not used by another unknown (resp.

set the rank of unknown the rank must not be used by another unknown (resp.

test function)

test function); unknowns and test functions are ranked separately (by default a test function has the rank of its unknown)

inline Space *space() const

return pointer to space

StrucType strucType() const

return the structure type of an unknown (scalar or vector)

UnknownType type() const

return type of unknown

Public Members

bool isUnknown

true if it is an unknown, false if it is a test function (see constructor)

mutable number_t nbEcShare = 0

special counter used by the Essential condition machinery (ghost row unknown space)

Public Static Functions

static void clearGlobalVector()

delete all unknown objects

static Unknown *findUnknown(const string_t&)

find unknown by its name

static void printAllUnknowns(std::ostream&)

print the list of Unknown objects in memory

Public Static Attributes

static number_t last_rank = 0

last rank to set unique unknown rank

static std::vector<Unknown*> theUnknowns

list of pointers of all Unknowns

Friends

friend Unknown &conj(Unknown&)

set to true or false the temporary conjugate flag

friend std::ostream &operator<<(std::ostream&, const Unknown&)

print an unknown

friend void setRanks(std::vector<Unknown*>&, const std::vector<number_t>&)

set ranks of unknowns