GitLab

A lot of auxilliary functions called by the matrix creation methods where
still wrapped inside HYTEG_BUILD_WITH_PETSC. This is no longer necessary,
as they do no longer depend directly on PETSC. They don't use PetscInt or
PetscReal and work with the general SparseMatrixProxy.

Additionally replaces all matIdx_t by idx_t

All operators that are either currently refactored (P*__Operator_new), including
polynomial/surrogate, variable ops, and composites that are built upon those
are not yet equipped with the ::toMatrix() method.

Implementing toMatrix() methods for many operators. Also got rid of some free functions
but this needs some more work. Almost all cases in PetscMatrixAssemblyTest are compiling
but many still abort. Also refactored PETScSparseMatrix a little so that only one template
argument is necessary now (only the operator).

Added support for non-square sparse matrices.

Some things that are still open:
- get PetscMatrixAssemblyTest green, enabling all test cases
- remove all former createMatrix() free function calls and definitions
- replace matIdx_t with the new index type before/when merging
- check that no PetscInts remain
- remove all the Petsc ifdefs that are not required anymore
- remove the petsc namespace where they technically only wrap sparse matrix stuff
- discuss what to do with the P1*Operator_new versions

We now treat the special case of having a BlockFunction or GenericFunction
in the templated function numberOfLocal/GlobalDoFs directly using a
constexpr-if. Makes it much easier for the compiler, which otherwise
sometimes had problems finding the correct variant.

For this to work BlockFunction::ValueType was renamed to
BlockFunction::valueType like in the other functions and a similar
typedef was added to GenericFunction.

The new variant allows to pass a function object in place of a
PrimitiveStorage object to be used for determination of DoF counts.

Testing new approach in PetscMatrixAssemblyTest.

For similar reasons as explained in [11449739] we introduce a variant of
numberOfGlobalDoFs() that requires a function object.

Changing PetscInt to matIdx_t allows to remove the preprocessor checks
for HYTEG_BUILD_WITH_PETSC and should fix issue with pipeline on the
new toMatrix() method.

Commit also adds P1ElementwiseOperator::toMatrix() and makes Petsc-
MatrixAssembly test use the new API for testing P[12]ElementwiseOperator.

We start introduction member functions toMatrix() to operator classes.
These are intended to replace the createMatrix() free-functions.

We already individually test for some of the operators that they can be
assembled into a PetscSparseMatrix. This new test does this explicitely
for a wide range of operators/operator families, i.e. we it does not test
all P1ConstantOperators e.g. but only one of them.

Note that operators for which an assembly does currently not work are
only reported, but not tested, so the test succeeds currently.

The commit places the test together with PetscTest.cpp into a new Petsc
sub-directory.

Implements PETSc vector <-> function conversion for Block/GenericFunction

See merge request !447

For completeness we commit also adds a new fule FaceDoFPetsc.hpp.
Like DGPetsc.hpp it only contains dummy implementations for
- createVectorFromFunction()
- createFunctionFromVector()

Opposed to the library entities themselves the functions and objects
in our tests are usually not in the hyteg namespace. This generated a
problem (shadowing warning) for MatType used both by PETSc and inside
a function in SingleRowIntegrationTest. Commit changes the name and its
sibling RowType in the typedefs.

Commit wraps implementation in HYTEG_BUILD_WITH_PETSC macro guards.

The commit introduces implementations for two free functions
- createVectorFromFunction()
- createFunctionFromVector()
for arguments of type BlockFunction< PetscReal >.

BlockFunctionBasicTest gets extended to check that compilation and
execution works.

The commit introduces implementations of
- createVectorFromFunction()
- createFunctionFromVector()
for functions of type GenericFunction< PetscReal >.

The two free functions reside in the new file GenericFunctionPetsc.hpp.
Because of the peculiarities of GenericFunctions these free functions
are, however, only wrappers that call the corresponding one of the two
new member functions
- GenericFunction::toVector()
- GenericFunction::fromVector()
As usual these are pure virtual and the actual work happens inside
the member functions of the FunctionWrapper class.

We extend the FunctionWrapperTest to check compilation and execution
for various kinds of wrapped functions.

Note that due to instantiation requirements the commit also implements
- createVectorFromFunction()
- createFunctionFromVector()
for functions of type DGFunction. However, these implementations are
pseudo only and will abort.

Wagnandr/facedoffunction

See merge request !446

Additions for the upcoming createMatrix() implementation for BlockFunctions

See merge request !445