Rename get-methods

examples/convection_diffusion.cc

@@ -35,7 +35,7 @@ int main(int argc, char** argv)
   prob.addDirichletBC(predicate, 0, 0, dbcValues);
 
   AdaptInfo adaptInfo("adapt");
-  prob.buildAfterAdapt(adaptInfo, Flag(0));
+  prob.assemble(adaptInfo);
   prob.solve(adaptInfo);
   prob.writeFiles(adaptInfo, true);
 

examples/ellipt.cc

@@ -38,14 +38,14 @@ int main(int argc, char** argv)
   prob.initialize(INIT_ALL);
 
   auto opL = makeOperator(tag::gradtest_gradtrial{}, 1.0);
-  prob.addMatrixOperator(opL, _0, _0);
+  prob.addMatrixOperator(opL, 0, 0);
 
   auto opForce = makeOperator(tag::test{}, f, 6);
-  prob.addVectorOperator(opForce, _0);
+  prob.addVectorOperator(opForce, 0);
 
   // set boundary condition
   auto boundary = [](auto const& x){ return x[0] < 1.e-8 || x[1] < 1.e-8 || x[0] > 1.0-1.e-8 || x[1] > 1.0-1.e-8; };
-  prob.addDirichletBC(boundary, _0, _0, g);
+  prob.addDirichletBC(boundary, 0, 0, g);
 
   AdaptInfo adaptInfo("adapt");
 
@@ -62,17 +62,17 @@ int main(int argc, char** argv)
     widths.push_back(h);
 
     prob.globalBasis().update(gridView);
-    prob.buildAfterAdapt(adaptInfo, Flag(0));
+    prob.assemble(adaptInfo);
     prob.solve(adaptInfo);
 
-    double errorL2 = integrate(sqr(g - prob.getSolution(_0)), gridView, 6);
+    double errorL2 = integrate(sqr(g - prob.solution(0)), gridView, 6);
     errL2.push_back(std::sqrt(errorL2));
-    double errorH1 = errorL2 + integrate(unary_dot(grad_g - gradientAtQP(prob.getSolution(_0))), gridView, 6);
+    double errorH1 = errorL2 + integrate(unary_dot(grad_g - gradientAtQP(prob.solution(0))), gridView, 6);
     errH1.push_back(std::sqrt(errorH1));
 
 #if WRITE_FILES
     Dune::VTKWriter<typename ElliptProblem::GridView> vtkWriter(gridView);
-    vtkWriter.addVertexData(prob.getSolution(_0), Dune::VTK::FieldInfo("u", Dune::VTK::FieldInfo::Type::scalar, 1));
+    vtkWriter.addVertexData(prob.solution(0), Dune::VTK::FieldInfo("u", Dune::VTK::FieldInfo::Type::scalar, 1));
     vtkWriter.write("u_" + std::to_string(i));
 #endif
   }

examples/heat.cc

@@ -31,16 +31,16 @@ int main(int argc, char** argv)
 
   AdaptInfo adaptInfo("adapt");
 
-  auto* invTau = probInstat.getInvTau();
+  auto invTau = std::ref(probInstat.invTau());
 
-  auto opTimeLhs = makeOperator(tag::test_trial{}, std::ref(*invTau));
+  auto opTimeLhs = makeOperator(tag::test_trial{}, invTau);
   prob.addMatrixOperator(opTimeLhs, 0, 0);
 
   auto opL = makeOperator(tag::gradtest_gradtrial{}, 1.0);
   prob.addMatrixOperator(opL, 0, 0);
 
   auto opTimeRhs = makeOperator(tag::test{},
-    invokeAtQP([invTau](double u) { return u * (*invTau); }, prob.getSolution(0)), 2);
+    invokeAtQP([invTau](double u) { return u * invTau.get(); }, prob.solution(0)), 2);
   prob.addVectorOperator(opTimeRhs, 0);
 
   auto opForce = makeOperator(tag::test{}, [](auto const& x) { return -1.0; }, 0);

examples/navier_stokes.cc

@@ -48,12 +48,16 @@ int main(int argc, char** argv)
   auto _v = Dune::Indices::_0;
   auto _p = Dune::Indices::_1;
 
+  auto invTau = std::ref(probInstat.invTau());
+
   // <1/tau * u, v>
-  auto opTime = makeOperator(tag::testvec_trialvec{}, density);
+  auto opTime = makeOperator(tag::testvec_trialvec{},
+    density * invTau);
   prob.addMatrixOperator(opTime, _v, _v);
 
   // <1/tau * u^old, v>
-  auto opTimeOld = makeOperator(tag::testvec{}, density * prob.getSolution(_v));
+  auto opTimeOld = makeOperator(tag::testvec{},
+    density * invTau * prob.solution(_v));
   prob.addVectorOperator(opTimeOld, _v);
 
 
@@ -62,17 +66,20 @@ int main(int argc, char** argv)
   prob.addMatrixOperator(opStokes, treepath(), treepath());
 
   // <(u * nabla)u_i^old, v_i>
-  auto opNonlin1 = makeOperator(tag::testvec_trialvec{}, density * trans(gradientAtQP(prob.getSolution(_v))));
+  auto opNonlin1 = makeOperator(tag::testvec_trialvec{},
+    density * trans(gradientAtQP(prob.solution(_v))));
   prob.addMatrixOperator(opNonlin1, _v, _v);
 
   for (std::size_t i = 0; i < AMDIS_DOW; ++i) {
     // <(u^old * nabla)u_i, v_i>
-    auto opNonlin2 = makeOperator(tag::test_gradtrial{}, density * prob.getSolution(_v));
+    auto opNonlin2 = makeOperator(tag::test_gradtrial{},
+      density * prob.solution(_v));
     prob.addMatrixOperator(opNonlin2, treepath(_v,i), treepath(_v,i));
   }
 
   // <(u^old * grad(u_i^old)), v_i>
-  auto opNonlin3 = makeOperator(tag::testvec{}, trans(gradientAtQP(prob.getSolution(_v))) * prob.getSolution(_v));
+  auto opNonlin3 = makeOperator(tag::testvec{},
+    trans(gradientAtQP(prob.solution(_v))) * prob.solution(_v));
   prob.addVectorOperator(opNonlin3, _v);
 
   // define boundary regions
@@ -98,8 +105,8 @@ int main(int argc, char** argv)
   prob.addDirichletBC([](auto const& x) { return x[0] < 1.e-8 && x[1] < 1.e-8; }, _p, _p, 0.0);
 
   // set initial conditions
-  prob.getSolution(_v).interpolate(parabolic_y);
-  prob.getSolution(_p).interpolate(0.0);
+  prob.solution(_v).interpolate(parabolic_y);
+  prob.solution(_p).interpolate(0.0);
 
   AdaptInstationary adapt("adapt", prob, adaptInfo, probInstat, adaptInfo);
   adapt.adapt();

examples/stokes0.cc

@@ -78,13 +78,13 @@ int main(int argc, char** argv)
   AdaptInfo adaptInfo("adapt");
 
   // assemble and solve system
-    prob.buildAfterAdapt(adaptInfo, Flag(0));
+  prob.assemble(adaptInfo);
 
 #ifdef DEBUG_MTL
   // write matrix to file
   mtl::io::matrix_market_ostream out("matrix_stokes0.mtx");
-    out << prob.getSystemMatrix().matrix();
-    std::cout << prob.getSystemMatrix().matrix() << '\n';
+  out << prob.systemMatrix().matrix();
+  std::cout << prob.systemMatrix().matrix() << '\n';
 #endif
 
   prob.solve(adaptInfo);

examples/stokes1.cc

@@ -79,13 +79,13 @@ int main(int argc, char** argv)
   AdaptInfo adaptInfo("adapt");
 
   // assemble and solve system
-    prob.buildAfterAdapt(adaptInfo, Flag(0));
+  prob.assemble(adaptInfo);
 
 #ifdef DEBUG_MTL
   // write matrix to file
   mtl::io::matrix_market_ostream out("matrix_stokes1.mtx");
-    out << prob.getSystemMatrix().matrix();
-    std::cout << prob.getSystemMatrix().matrix() << '\n';
+  out << prob.systemMatrix().matrix();
+  std::cout << prob.systemMatrix().matrix() << '\n';
 #endif
 
   prob.solve(adaptInfo);

examples/stokes3.cc

@@ -62,8 +62,7 @@ int main(int argc, char** argv)
   AdaptInfo adaptInfo("adapt");
 
   // assemble and solve system
-  prob.buildAfterAdapt(adaptInfo, Flag(0));
-
+  prob.assemble(adaptInfo);
   prob.solve(adaptInfo);
 
   // output solution

examples/vecellipt.cc

@@ -46,9 +46,9 @@ int main(int argc, char** argv)
   // write matrix to file
   if (Parameters::get<int>("elliptMesh->global refinements").value_or(0) < 4) {
     mtl::io::matrix_market_ostream out("matrix.mtx");
-    out << prob.getSystemMatrix().matrix();
+    out << prob.systemMatrix().matrix();
 
-    std::cout << prob.getSystemMatrix().matrix() << '\n';
+    std::cout << prob.systemMatrix().matrix() << '\n';
   }
 #endif
 

src/amdis/AdaptBase.hpp

@@ -37,13 +37,13 @@ namespace AMDiS
     virtual int adapt() = 0;
 
     /// Returns \ref name
-    std::string const& getName() const
+    std::string const& name() const
     {
       return name_;
     }
 
     /// Returns \ref problemIteration
-    ProblemIterationInterface* getProblemIteration() const
+    ProblemIterationInterface* problemIteration() const
     {
       return problemIteration_;
     }
@@ -55,13 +55,13 @@ namespace AMDiS
     }
 
     /// Returns \ref adaptInfo
-    AdaptInfo& getAdaptInfo() const
+    AdaptInfo& adaptInfo() const
     {
       return adaptInfo_;
     }
 
     /// Returns \ref problemTime
-    ProblemTimeInterface* getProblemTime() const
+    ProblemTimeInterface* problemTime() const
     {
       return problemTime_;
     }
@@ -73,7 +73,7 @@ namespace AMDiS
     }
 
     /// Returns \ref initialAdaptInfo
-    AdaptInfo& getInitialAdaptInfo() const
+    AdaptInfo& initialAdaptInfo() const
     {
       return *initialAdaptInfo_;
     }

src/amdis/AdaptInfo.cpp

@@ -29,28 +29,28 @@ namespace AMDiS
     : name_(name)
   {
     // init();
-    Parameters::get(name + "->start time", startTime);
-    time = startTime;
+    Parameters::get(name + "->start time", startTime_);
+    time_ = startTime_;
 
-    Parameters::get(name + "->timestep", timestep);
-    Parameters::get(name + "->end time", endTime);
-    Parameters::get(name + "->max iteration", maxSpaceIteration);
-    Parameters::get(name + "->max timestep iteration", maxTimestepIteration);
-    Parameters::get(name + "->max time iteration", maxTimeIteration);
-    Parameters::get(name + "->min timestep", minTimestep);
-    Parameters::get(name + "->max timestep", maxTimestep);
-    Parameters::get(name + "->number of timesteps", nTimesteps);
-    Parameters::get(name + "->time tolerance", globalTimeTolerance);
+    Parameters::get(name + "->timestep", timestep_);
+    Parameters::get(name + "->end time", endTime_);
+    Parameters::get(name + "->max iteration", maxSpaceIteration_);
+    Parameters::get(name + "->max timestep iteration", maxTimestepIteration_);
+    Parameters::get(name + "->max time iteration", maxTimeIteration_);
+    Parameters::get(name + "->min timestep", minTimestep_);
+    Parameters::get(name + "->max timestep", maxTimestep_);
+    Parameters::get(name + "->number of timesteps", nTimesteps_);
+    Parameters::get(name + "->time tolerance", globalTimeTolerance_);
   }
 
 
   void AdaptInfo::printTimeErrorLowInfo() const
   {
-    for (auto const& scalContent : scalContents)
+    for (auto const& scalContent : scalContents_)
     {
       auto i = scalContent.first;
       std::cout << "    Time error estimate     ["<<i<<"] = "
-                << getTimeEstCombined(i) << "\n"
+                << timeEstCombined(i) << "\n"
                 << "    Time error estimate sum ["<<i<<"] = "
                 << scalContent.second.est_t_sum << "\n"
                 << "    Time error estimate max ["<<i<<"] = "
@@ -64,17 +64,17 @@ namespace AMDiS
 
   void AdaptInfo::reset()
   {
-    spaceIteration = -1;
-    timestepIteration = 0;
-    timeIteration = 0;
-    time = 0.0;
-    timestep = 0.0;
-    timestepNumber = 0;
-    solverIterations = 0;
-    solverResidual = 0.0;
+    spaceIteration_ = -1;
+    timestepIteration_ = 0;
+    timeIteration_ = 0;
+    time_ = 0.0;
+    timestep_ = 0.0;
+    timestepNumber_ = 0;
+    solverIterations_ = 0;
+    solverResidual_ = 0.0;
 
-    Parameters::get(name_ + "->timestep", timestep);
-    lastProcessedTimestep=timestep;
+    Parameters::get(name_ + "->timestep", timestep_);
+    lastProcessedTimestep_ = timestep_;
   }
 
 } // end namespace AMDiS

src/amdis/AdaptInstationary.cpp

@@ -22,7 +22,7 @@ namespace AMDiS
     Parameters::get(name_ + "->time delta 2", timeDelta2_);
     Parameters::get(name_ + "->break when stable", breakWhenStable_);
 
-    fixedTimestep_ = (adaptInfo_.getMinTimestep() == adaptInfo_.getMaxTimestep());
+    fixedTimestep_ = (adaptInfo_.minTimestep() == adaptInfo_.maxTimestep());
   }
 
 
@@ -31,16 +31,16 @@ namespace AMDiS
     AMDIS_FUNCNAME("AdaptInstationary::explicitTimeStrategy()");
 
     // estimate before first adaption
-    if (adaptInfo_.getTime() <= adaptInfo_.getStartTime())
+    if (adaptInfo_.time() <= adaptInfo_.startTime())
       problemIteration_->oneIteration(adaptInfo_, ESTIMATE);
 
 
     // increment time
-    adaptInfo_.setTime(adaptInfo_.getTime() + adaptInfo_.getTimestep());
+    adaptInfo_.setTime(adaptInfo_.time() + adaptInfo_.timestep());
 
     problemTime_->setTime(adaptInfo_);
 
-    msg("time = {}, timestep = {}", adaptInfo_.getTime(), adaptInfo_.getTimestep());
+    msg("time = {}, timestep = {}", adaptInfo_.time(), adaptInfo_.timestep());
 
     adaptInfo_.setSpaceIteration(0);
 
@@ -48,7 +48,7 @@ namespace AMDiS
     problemIteration_->beginIteration(adaptInfo_);
     problemIteration_->oneIteration(adaptInfo_, FULL_ITERATION);
     problemIteration_->endIteration(adaptInfo_);
-    adaptInfo_.setLastProcessedTimestep(adaptInfo_.getTimestep());
+    adaptInfo_.setLastProcessedTimestep(adaptInfo_.timestep());
   }
 
 
@@ -58,10 +58,10 @@ namespace AMDiS
 
     do
     {
-      adaptInfo_.setTime(adaptInfo_.getTime() + adaptInfo_.getTimestep());
+      adaptInfo_.setTime(adaptInfo_.time() + adaptInfo_.timestep());
       problemTime_->setTime(adaptInfo_);
 
-      msg("time = {}, timestep = {}", adaptInfo_.getTime(), adaptInfo_.getTimestep());
+      msg("time = {}, timestep = {}", adaptInfo_.time(), adaptInfo_.timestep());
 
       problemIteration_->oneIteration(adaptInfo_, NO_ADAPTION);
 
@@ -69,11 +69,11 @@ namespace AMDiS
 
       if (!fixedTimestep_ &&
           !adaptInfo_.timeToleranceReached() &&
-          adaptInfo_.getTimestepIteration() <= adaptInfo_.getMaxTimestepIteration() &&
-          !(adaptInfo_.getTimestep() <= adaptInfo_.getMinTimestep()))
+          adaptInfo_.timestepIteration() <= adaptInfo_.maxTimestepIteration() &&
+          !(adaptInfo_.timestep() <= adaptInfo_.minTimestep()))
       {
-        adaptInfo_.setTime(adaptInfo_.getTime() - adaptInfo_.getTimestep());
-        adaptInfo_.setTimestep(adaptInfo_.getTimestep() * timeDelta1_);
+        adaptInfo_.setTime(adaptInfo_.time() - adaptInfo_.timestep());
+        adaptInfo_.setTimestep(adaptInfo_.timestep() * timeDelta1_);
         continue;
       }
 
@@ -83,7 +83,7 @@ namespace AMDiS
 
       // === Do space iterations only if the maximum is higher than 0. ===
 
-      if (adaptInfo_.getMaxSpaceIteration() > 0)
+      if (adaptInfo_.maxSpaceIteration() > 0)
       {
 
         // === Space iterations. ===
@@ -96,10 +96,10 @@ namespace AMDiS
           {
             if (!fixedTimestep_ &&
                 !adaptInfo_.timeToleranceReached() &&
-                !(adaptInfo_.getTimestep() <= adaptInfo_.getMinTimestep()))
+                !(adaptInfo_.timestep() <= adaptInfo_.minTimestep()))
             {
-              adaptInfo_.setTime(adaptInfo_.getTime() - adaptInfo_.getTimestep());
-              adaptInfo_.setTimestep(adaptInfo_.getTimestep() * timeDelta2_);
+              adaptInfo_.setTime(adaptInfo_.time() - adaptInfo_.timestep());
+              adaptInfo_.setTimestep(adaptInfo_.timestep() * timeDelta2_);
               problemIteration_->endIteration(adaptInfo_);
               adaptInfo_.incSpaceIteration();
               break;
@@ -111,7 +111,7 @@ namespace AMDiS
 
         }
         while (!adaptInfo_.spaceToleranceReached() &&
-               adaptInfo_.getSpaceIteration() <= adaptInfo_.getMaxSpaceIteration());
+               adaptInfo_.spaceIteration() <= adaptInfo_.maxSpaceIteration());
 
       }
       else
@@ -122,22 +122,22 @@ namespace AMDiS
 
     }
     while(!adaptInfo_.timeToleranceReached() &&
-          !(adaptInfo_.getTimestep() <= adaptInfo_.getMinTimestep()) &&
-          adaptInfo_.getTimestepIteration() <= adaptInfo_.getMaxTimestepIteration());
+          !(adaptInfo_.timestep() <= adaptInfo_.minTimestep()) &&
+          adaptInfo_.timestepIteration() <= adaptInfo_.maxTimestepIteration());
 
-    adaptInfo_.setLastProcessedTimestep(adaptInfo_.getTimestep());
+    adaptInfo_.setLastProcessedTimestep(adaptInfo_.timestep());
 
     // After successful iteration/timestep the timestep will be changed according
     // adaption rules for next timestep.
     // First, check for increase of timestep
     if (!fixedTimestep_ && adaptInfo_.timeErrorLow())
-      adaptInfo_.setTimestep(adaptInfo_.getTimestep() * timeDelta2_);
+      adaptInfo_.setTimestep(adaptInfo_.timestep() * timeDelta2_);
 
     // Second, check for decrease of timestep
     if (!fixedTimestep_ &&
         !adaptInfo_.timeToleranceReached() &&
-        !(adaptInfo_.getTimestep() <= adaptInfo_.getMinTimestep()))
-      adaptInfo_.setTimestep(adaptInfo_.getTimestep() * timeDelta1_);
+        !(adaptInfo_.timestep() <= adaptInfo_.minTimestep()))
+      adaptInfo_.setTimestep(adaptInfo_.timestep() * timeDelta1_);
   }
 
 
@@ -146,27 +146,27 @@ namespace AMDiS
     AMDIS_FUNCNAME("AdaptInstationary::simpleAdaptiveTimeStrategy()");
 
     // estimate before first adaption
-    if (adaptInfo_.getTime() <= adaptInfo_.getStartTime())
+    if (adaptInfo_.time() <= adaptInfo_.startTime())
       problemIteration_->oneIteration(adaptInfo_, ESTIMATE);
 
-    adaptInfo_.setTime(adaptInfo_.getTime() + adaptInfo_.getTimestep());
+    adaptInfo_.setTime(adaptInfo_.time() + adaptInfo_.timestep());
     problemTime_->setTime(adaptInfo_);
 
-    msg("time = {}, timestep = {}", adaptInfo_.getTime(), adaptInfo_.getTimestep());
+    msg("time = {}, timestep = {}", adaptInfo_.time(), adaptInfo_.timestep());
 
     problemIteration_->oneIteration(adaptInfo_, FULL_ITERATION);
 
-    adaptInfo_.setLastProcessedTimestep(adaptInfo_.getTimestep());
+    adaptInfo_.setLastProcessedTimestep(adaptInfo_.timestep());
 
     // First, check for increase of timestep
     if (!fixedTimestep_ && adaptInfo_.timeErrorLow())
-      adaptInfo_.setTimestep(adaptInfo_.getTimestep() * timeDelta2_);
+      adaptInfo_.setTimestep(adaptInfo_.timestep() * timeDelta2_);
 
     // Second, check for decrease of timestep
     if (!fixedTimestep_ &&
         !adaptInfo_.timeToleranceReached() &&
-        !(adaptInfo_.getTimestep() <= adaptInfo_.getMinTimestep()))
-      adaptInfo_.setTimestep(adaptInfo_.getTimestep() * timeDelta1_);
+        !(adaptInfo_.timestep() <= adaptInfo_.minTimestep()))
+      adaptInfo_.setTimestep(adaptInfo_.timestep() * timeDelta1_);
   }
 
 
@@ -200,18 +200,18 @@ namespace AMDiS
     AMDIS_FUNCNAME("AdaptInstationary::adapt()");
     int errorCode = 0;
 
-    test_exit(adaptInfo_.getTimestep() >= adaptInfo_.getMinTimestep(),
+    test_exit(adaptInfo_.timestep() >= adaptInfo_.minTimestep(),
               "timestep < min timestep");
-    test_exit(adaptInfo_.getTimestep() <= adaptInfo_.getMaxTimestep(),
+    test_exit(adaptInfo_.timestep() <= adaptInfo_.maxTimestep(),
               "timestep > max timestep");
 
-    test_exit(adaptInfo_.getTimestep() > 0, "timestep <= 0!");
+    test_exit(adaptInfo_.timestep() > 0, "timestep <= 0!");
 
-    if (adaptInfo_.getTimestepNumber() == 0)
+    if (adaptInfo_.timestepNumber() == 0)
     {
-      adaptInfo_.setTime(adaptInfo_.getStartTime());
-      initialAdaptInfo_->setStartTime(adaptInfo_.getStartTime());
-      initialAdaptInfo_->setTime(adaptInfo_.getStartTime());
+      adaptInfo_.setTime(adaptInfo_.startTime());
+      initialAdaptInfo_->setStartTime(adaptInfo_.startTime());
+      initialAdaptInfo_->setTime(adaptInfo_.startTime());
 
       problemTime_->setTime(adaptInfo_);
 
@@ -226,7 +226,7 @@ namespace AMDiS
       oneTimestep();
       problemTime_->closeTimestep(adaptInfo_);
 
-      if (breakWhenStable_ && (adaptInfo_.getSolverIterations() == 0))
+      if (breakWhenStable_ && (adaptInfo_.solverIterations() == 0))
         break;
     }
 

src/amdis/AdaptInstationary.hpp

@@ -38,7 +38,7 @@ namespace AMDiS
     }
 
     /// Returns \ref strategy
-    int getStrategy() const
+    int strategy() const
     {
       return strategy_;
     }

src/amdis/AdaptStationary.cpp

@@ -18,7 +18,7 @@ AdaptStationary::AdaptStationary(std::string const& name,
 int AdaptStationary::adapt()
 {
   // initial iteration
-  if (adaptInfo_.getSpaceIteration() == -1)
+  if (adaptInfo_.spaceIteration() == -1)
   {
     problemIteration_->beginIteration(adaptInfo_);
     problemIteration_->oneIteration(adaptInfo_, NO_ADAPTION);
@@ -28,8 +28,8 @@ int AdaptStationary::adapt()
 
   // adaption loop
   while (!adaptInfo_.spaceToleranceReached() &&
-          (adaptInfo_.getSpaceIteration() < adaptInfo_.getMaxSpaceIteration() ||
-          adaptInfo_.getMaxSpaceIteration() < 0) )
+          (adaptInfo_.spaceIteration() < adaptInfo_.maxSpaceIteration() ||
+          adaptInfo_.maxSpaceIteration() < 0) )
   {
 
     problemIteration_->beginIteration(adaptInfo_);

src/amdis/Assembler.hpp

@@ -10,17 +10,17 @@ namespace AMDiS
       ElementAssembler const& localAssembler)
   {
     // assemble element operators
-    localAssembler(element, operators.element);
+    localAssembler(element, operators.onElement());
 
     // assemble intersection operators
-    if (!operators.intersection.empty()
-        || (!operators.boundary.empty() && element.hasBoundaryIntersections()))
+    if (!operators.onIntersection().empty()
+        || (!operators.onBoundary().empty() && element.hasBoundaryIntersections()))
     {
       for (auto const& intersection : intersections(gridView, element)) {
         if (intersection.boundary())
-          localAssembler(intersection, operators.boundary);
+          localAssembler(intersection, operators.onBoundary());
         else
-          localAssembler(intersection, operators.intersection);
+          localAssembler(intersection, operators.onIntersection());
       }
     }
   }

src/amdis/FileWriter.hpp

@@ -99,7 +99,7 @@ namespace AMDiS
       test_exit(filesystem::exists(dir_), "Output directory '{}' does not exist!",dir_);
 
       if (vtkSeqWriter_)
-        vtkSeqWriter_->write(adaptInfo.getTime(), mode_);
+        vtkSeqWriter_->write(adaptInfo.time(), mode_);
       else if (vtkWriter_)
         vtkWriter_->write(filesystem::path({dir_, filename_}).string(), mode_);
     }

src/amdis/Flag.hpp

@@ -18,7 +18,7 @@ namespace AMDiS
 
     /// Constructs a Flag initialized by f
     constexpr Flag(const std::uint64_t f)
-      : flags(f)
+      : flags_(f)
     {}
 
     /// Copy constructor
@@ -30,7 +30,7 @@ namespace AMDiS
     /// Compares two Flags
     constexpr bool operator==(Flag const& f) const
     {
-      return (flags == f.flags);
+      return (flags_ == f.flags_);
     }
 
     /// Compares two Flags
@@ -43,7 +43,7 @@ namespace AMDiS
     constexpr Flag& operator=(Flag const& f)
     {
       if (this != &f)
-        flags = f.flags;
+        flags_ = f.flags_;
       return *this;
     }
 
@@ -53,109 +53,109 @@ namespace AMDiS
       return isAnySet();
     }
 
-    /// Set \ref flags
+    /// Set \ref flags_
     constexpr void setFlags(const std::uint64_t f)
     {
-      flags = f;
+      flags_ = f;
     }
 
-    /// Set \ref flags
+    /// Set \ref flags_
     constexpr void setFlags(Flag const& f)
     {
-      flags = f.flags;
+      flags_ = f.flags_;
     }
 
-    /// Sets \ref flags to \ref flags | f
+    /// Sets \ref flags_ to \ref flags_ | f
     constexpr void setFlag(const std::uint64_t f)
     {
-      flags |= f;
+      flags_ |= f;
     }