1. 18 Mar, 2022 2 commits
    • 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
  2. 17 Mar, 2022 19 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
    • Marcus Mohr's avatar
      Updating two StokesBlockPreconditioners · 1338975a
      Marcus Mohr authored
      The two preconditioners
      - P1StokesBlockPreconditioner.hpp
      - P2P1TaylorHoodStokesBlockPreconditioner.hpp
      now work with a ConstantVectorLaplaceOperator internally
      1338975a
    • Marcus Mohr's avatar
      Removes P1StockesBlockLaplaceOperator · 06c70a93
      Marcus Mohr authored
      The class is superseeded by the P1ConstantVectorLaplaceOperator and no
      longer need. To demonstrate this the commit changes P1StokesBlockCGTest
      into P1VectorLaplaceCGTest.
      06c70a93
    • Dominik Thoennes's avatar
      Merge branch 'thoennes/add-manual-no-werror-job-to-ci' into 'master' · fc9daee6
      Dominik Thoennes authored
      add manual job to CI that does not have the werror flag
      
      See merge request !496
      fc9daee6
    • Dominik Thoennes's avatar
      remove dependencies for no-werror jobs · d3b8eaf6
      Dominik Thoennes authored
      d3b8eaf6
    • Dominik Thoennes's avatar
  3. 16 Mar, 2022 5 commits
  4. 15 Mar, 2022 8 commits
    • Marcus Mohr's avatar
      Updates Stokes-type operators · 91307823
      Marcus Mohr authored
      All (besides those I might have missed) Stokes-type operators now use
      div and divT instead of div_{x,y,z} and divT_{x,y,z}.
      91307823
    • Marcus Mohr's avatar
      Fixes StokesPCGSolverOld · cf71fa90
      Marcus Mohr authored
      The solver was still using stokesOperator.A instead of the new
      stokesOperator.getA()
      cf71fa90
    • Marcus Mohr's avatar
    • Marcus Mohr's avatar
      "Vectorises" P2P1(Surrogate)TaylorHoodStokesOperator · 0511e103
      Marcus Mohr authored
      To do so for the P2P1SurrogateTaylorHoodStokesOperator we need to
      instantiate a P2SurrogateVectorLaplaceOperator. The latter has a longer
      parameter list for its constructor, though.
      
      To resolve this we template the constructor of the VectorLaplaceOperator
      class using a parameter pack.
      0511e103
    • Marcus Mohr's avatar
      c379a0f9
    • Marcus Mohr's avatar
      Resolves issue #176 · 3f15ff40
      Marcus Mohr authored
      Part 1:
      The commit introduces more generic versions of scalar-to-vector and
      vector-to-scalar operators. This allows to remove the individual
      implementation for different function space combinations.
      
      PArt2:
      The two classes ScalarToVectorOperator and VectorToScalarOperator now
      provide templated member functions getSubOperator. The template parameter
      determines the index {0,1,2} of the desired sub-operator.
      
      The new accessors allow to continue refactoring the elementwise Stokes
      operators.
      3f15ff40
    • Marcus Mohr's avatar
      Quells compiler warning on potential unitialised usage · e0bee70a
      Marcus Mohr authored
      Initialising local variables in two tests with zero to make GCC-10.2.0
      happy.
      e0bee70a
    • Marcus Mohr's avatar
      Step towards disentangling StokesOperators and Solvers/Preconditioners · fd46cdbf
      Marcus Mohr authored
      Most (I probably overlooked at least one) composite Stokes operators now
      provide a getA() member function to access to velocity block. Commit
      starts replacing explicit accesses to A by getA() in solvers and
      preconditioners. By far not complete, yet.
      
      Actually the A block gets removed by the commit as the composite Stokes
      operators now make use of VectorLaplaceOperators instead.
      
      We also add to many a div and divT operator that is a vector-to-scalar
      resp. scalar-to-vector operator. The old scalar sub-operators are kept
      for the moment, because removing them implies refactoring the whole
      Uzawa smoother.
      
      Additionally the elementwise Stokes operators cause a problem here due to
      the fact that we cannot call computeAndStoreLocalElementMatrices on
      div or divT and it is not straightforward to hand sub-operators back from
      these template classes.
      
      Implements toMatrix() method missing in some operators:
      - P1ScalarToP1VectorOperator
      - P1VectorToP1ScalarOperator
      - P2ScalarToP2VectorOperator
      - P2VectorToP2ScalarOperator
      fd46cdbf
  5. 14 Mar, 2022 1 commit
  6. 10 Mar, 2022 2 commits
  7. 08 Mar, 2022 3 commits
    • Marcus Mohr's avatar
      Merge branch 'mohr/VectorSmoothables-mc' into 'master' · eeeaea2e
      Marcus Mohr authored
      Make VectorLaplacOperator smoothable
      
      See merge request !491
      eeeaea2e
    • Marcus Mohr's avatar
      Commit formally makes VectorLaplaceOperator smoothable · d9e663ca
      Marcus Mohr authored
      The VectorLaplaceOperator class now publically inherits from
      - GSSmoothable
      - GSBackwardsSmoothable
      - SORSmoothable
      - SORBackwardsSmoothable
      and implements the associated pure virtual methods. The
      implementation in turn checks that the diagonal sub-operators
      have the corresponding interface and delegates work to them.
      
      Note: Of course a P2ElementwiseVectorLaplaceOperator is still
      not truely SORSmoothable. However, that will only be recognised
      on the sub-operator level.
      d9e663ca
    • Marcus Mohr's avatar
      Makes ChebyshevSmoother instantiable for "VectorOperators" · 7d5bcf8c
      Marcus Mohr authored
      Using constexpr if, we can make the ChebyshevSmoother formally
      be instantiable for operators whose SourceFunction is a child
      of CSFVectorFunction.
      
      The problem lies with the assertion calling getMaxMagnitude,
      which is currently not provided by CSFVectorFunction.
      
      Note that this is only a formal change. Since we have no
      vector operators that return their inverse "block" diagonal, and,
      thus, none that inherit from OperatorWithInverseDiagonal,
      the ChebyshevSmoother is still not usable with these kind of
      operators.
      7d5bcf8c