1. 28 Jul, 2022 1 commit
  2. 25 Jul, 2022 2 commits
  3. 19 Jul, 2022 2 commits
  4. 18 Jul, 2022 2 commits
  5. 22 Jun, 2022 1 commit
  6. 21 Jun, 2022 2 commits
  7. 25 Apr, 2022 2 commits
  8. 29 Mar, 2022 1 commit
  9. 25 Mar, 2022 3 commits
  10. 24 Mar, 2022 2 commits
    • Marcus Mohr's avatar
      Adds PrintInfoTest · 3077366c
      Marcus Mohr authored
      The test checks that we get neither compile- nor run-time errors, when
      trying to print meta information on the build using the functions from
      Git.hpp and BuildInfo.hpp.
      3077366c
    • Marcus Mohr's avatar
      Fixes bad_cast issue in P2P1ElementwiseBlendingStokesOperator · 892682d1
      Marcus Mohr authored
      The sub-operators of P2ElementwiseBlendingVectorLaplaceOperator are of type
      P2ElementwiseBlendingLaplaceOperator and not P2ElementwiseLaplaceOperator.
      
      Maybe it would be wiser to cast to
      P2ElementwiseBlendingVectorLaplaceOperator::scalarOpType
      892682d1
  11. 23 Mar, 2022 2 commits
    • Marcus Mohr's avatar
      Merge branch 'mohr/compilerInfo' into 'master' · c8217f27
      Marcus Mohr authored
      Updates BuildInfo
      
      See merge request !498
      c8217f27
    • Marcus Mohr's avatar
      Updates BuildInfo · e4095ff0
      Marcus Mohr authored
      - Commit adds a new function compilerInfo() that will return the
        compiler ID and version as obtained from CMake.
      - printBuildInfo() will now include this information.
      - We rename buildFlavour() to buildType() for naming consistency with cmake.
      e4095ff0
  12. 22 Mar, 2022 1 commit
  13. 21 Mar, 2022 1 commit
  14. 18 Mar, 2022 4 commits
    • Marcus Mohr's avatar
      Adds VectorToVectorOperatorChebyshevTest · 444b9388
      Marcus Mohr authored
      Commit adds a new test that checks that we can perform Chebyshev smoothing
      with different VectorLaplace, Epsilon and FullViscous operators.
      
      The test uses a small 2D problem and only checks application, but not
      convergence.
      444b9388
    • Marcus Mohr's avatar
      Updates VectorToVectorOperatorCGTest · 730324e2
      Marcus Mohr authored
      We now use different initial guesses for the x- and y-component
      730324e2
    • Marcus Mohr's avatar
      Fixes ChebyshevSmoother::apply() · 01d8c556
      Marcus Mohr authored
      When smoothing CSFVectorFunctions we cannot use getMaxMagnitude for
      checking whether the diagonal was computed.
      
      We should only perform calls to getInverseDiagonalValues() on upcasted
      operators. Otherwise we get compile-time errors instead of run-time
      aborts.
      01d8c556
    • Marcus Mohr's avatar
      Updates P[12]EpsilonOperators · 7237cacb
      Marcus Mohr authored
      Commit makes P1ConstantEpsilonOperator and P2ElementwiseEpsilonOperators
      children of OperatorWithInverseDiagonal and implements the required
      pure virtual functions, so that the classes becomes Chebyshev smoothable.
      7237cacb
  15. 17 Mar, 2022 14 commits
    • Marcus Mohr's avatar
      Fixes missing override specifiers · d04918e1
      Marcus Mohr authored
      d04918e1
    • Marcus Mohr's avatar
      Adds VectorToVectorOperatorCGTest · 71226698
      Marcus Mohr authored
      Commit adds a new test that checks that we can solve a simple 2D problem
      for VectorLaplace, Epsilon and FullViscous operators with CG.
      71226698
    • Marcus Mohr's avatar
      fff3c044
    • Marcus Mohr's avatar
      Updates composites/CMakeLists.txt · 3ac80a5d
      Marcus Mohr authored
      Rebase of branch brought the new CMake structure, but on the branch
      P1StokesLaplaceOperator.hpp had been removed.
      3ac80a5d
    • Marcus Mohr's avatar
      Enhances "smoothability" of VectorToVector operators · 5250aaff
      Marcus Mohr authored
      With respect to the smoothability of children of the VectorToVectorOperator
      class this commit performs the following changes/additions:
      
      - We extend the OperatorWithInverseDiagonal class by a second pure virtual
        function computeInverseDiagonalOperatorValues(). The rational for this is
        simple. A call to getInverseDiagonalValues() does not trigger computation
        of the diagonal resp. its inverse. Thus, a class that provides the one
        interface also needs to provide the other. Making the one trigger the
        other seems not sufficient either, as we need to be able to recompute,
        when the material parameter, e.g. viscosity, changes.
      - VectorToVectorOperator provides central implementations of both methods
        to which children need only delegate. This is the way we implement it
        in VectorLaplaceOperator and corresponding P1EpsilonOperator and
        P2FullViscousOperator cases.
      - The implementation in VectorToVectorOperator will throw, if the diagonal
        operator blocks do not have inherited the OperatorWithInverseDiagonal
        interface and abort, if the operator is not mapping between identical
        spaces.
      - NOTE:
        For this to work the commit makes a change to the P1Operator class.
        Its two public member functions compute[Inverse]DiagonalOperatorValues()
        allowed to provide and argument use_variable_stencil_assembly with a
        default value of false. Since this conflicts with the new inheritance
        and as noone ever calls them with a parameter the commit removes this
        argument.
      - The new implementation allows to fix the problems in SmoothableTest
        and test additional operators.
      5250aaff
    • Marcus Mohr's avatar
      484a50d6
    • Marcus Mohr's avatar
      Adds typedefs to VectorToVectorOperator · c57f6fd1
      Marcus Mohr authored
      In order to be compatible with the Operator class the commit adds
      typedefs for
      - srcType
      - dstType
      to the VectorToVectorOperator class. We keep the old (IMHO more talkative)
      - SrcVecFuncType
      - DstVecFuncType
      typedefs for the moment
      c57f6fd1
    • Marcus Mohr's avatar
      Make P2ConstantOperator throw instead of aborting · a82e1422
      Marcus Mohr authored
      If one of the smoothing methods of P2ConstantOperator is called for a
      dimension for which it is not (yet) implemented, we make the object
      throw a runtime_error instead of performing a WALBERLA_ABORT. This is
      more in the spirit of the whole inherit smoothable interfaces.
      a82e1422
    • Marcus Mohr's avatar
    • Marcus Mohr's avatar
      Extends VectorOperatorBasicTest · b8211a19
      Marcus Mohr authored
      We now also test our Epsilon and FullViscous operators. And hurrah. Testing
      revealed an issue with the P1EpsilonOperators. Explicit instantiations for
      some of their sub-operators was missing. Commit fixes this.
      b8211a19
    • Marcus Mohr's avatar
      Adds new constructor for vector functions · a6da698d
      Marcus Mohr authored
      The new constructor allows to construct a P[12]VectorFunction from an
      std::vector of shared pointers to its scalar component functions. We
      perform a minimal test of the constructor in VectorFunctionBasicTest.
      a6da698d
    • Marcus Mohr's avatar
      Fixes bug in P1EpsilonOperator · bd9c3b17
      Marcus Mohr authored
      Obviously, we cannot use a P2FenicsForm here. Must be a P1FenicsForm.
      bd9c3b17
    • Marcus Mohr's avatar
      Adds selected P1EpsilonOperators · 119dc716
      Marcus Mohr authored
      Commit adds a new file P1EpsilonOperator.hpp that defines the three classes
      - P1ConstantEpsilonOperator
      - P1ElementwiseAffineEpsilonOperator
      - P1ElementwiseBlendingEpsilonOperator
      The latter two allow to use a variable viscosity.
      
      Using the new operators we can significantly reduce coding in
      - P1P1ElementwiseAffineEpsilonStokesOperator
      - P1P1ElementwiseAffineEpsilonStokesBlockPreconditioner
      119dc716
    • Marcus Mohr's avatar
      Updates P2P1ElementwiseAffineEpsilonStokesOperator · fea682ea
      Marcus Mohr authored
      Commit significantly reduces code in P2P1ElementwiseAffineEpsilonStokesOperator
      by making the class use a P2ElementwiseAffineEpsilonOperator object instead
      of nine separate sub-operators.
      
      Similar commit reduces code in
      P2P1ElementwiseAffineEpsilonStokesBlockPreconditioner. However, here we
      use a P2ConstantEpsilonOperator. Before the preconditioner was using sub-
      operators based on the p2_epsiloncc_x_y_affine_q2 forms. Hence, it was
      unaware of viscosity anyhow. Instead of introducing a rather boring new
      operator the these forms we can also do with the stencil-based operator.
      fea682ea