diff --git a/src/amdis/AdaptInfo.cpp b/src/amdis/AdaptInfo.cpp
index d26d861dc6340aefc94e323f57f0f8211dd42fb9..21a1e68bbf15d931d1b273eda137d8bd711f6392 100644
--- a/src/amdis/AdaptInfo.cpp
+++ b/src/amdis/AdaptInfo.cpp
@@ -1,8 +1,8 @@
#include "AdaptInfo.hpp"
// std c++ headers
-#include <string>
#include <iostream>
+#include <string>
#include <amdis/Initfile.hpp>
@@ -16,8 +16,6 @@ namespace AMDiS
Parameters::get(prefix + "->time relative tolerance", timeRelativeTolerance);
Parameters::get(prefix + "->coarsen allowed", coarsenAllowed);
Parameters::get(prefix + "->refinement allowed", refinementAllowed);
- Parameters::get(prefix + "->refine bisections", refineBisections);
- Parameters::get(prefix + "->coarsen bisections", coarseBisections);
Parameters::get(prefix + "->sum factor", fac_sum);
Parameters::get(prefix + "->max factor", fac_max);
@@ -27,7 +25,7 @@ namespace AMDiS
}
- AdaptInfo::AdaptInfo(std::string name, int size)
+ AdaptInfo::AdaptInfo(std::string name)
: name(name)
{
// init();
@@ -43,37 +41,24 @@ namespace AMDiS
Parameters::get(name + "->max timestep", maxTimestep);
Parameters::get(name + "->number of timesteps", nTimesteps);
Parameters::get(name + "->time tolerance", globalTimeTolerance);
-
- for (int i = 0; i < size; i++)
- scalContents.emplace_back(new ScalContent(name + "[" + std::to_string(i) + "]"));
- }
-
-
- void AdaptInfo::setScalContents(int newSize)
- {
- int oldSize = int(scalContents.size());
-
- if (newSize > oldSize) {
- for (int i = oldSize; i < newSize; ++i)
- scalContents.emplace_back(new ScalContent(name + "[" + std::to_string(i) + "]"));
- }
}
void AdaptInfo::printTimeErrorLowInfo() const
{
- for (std::size_t i = 0; i < scalContents.size(); i++)
+ for (auto const& scalContent : scalContents)
{
+ auto i = scalContent.first;
std::cout << " Time error estimate ["<<i<<"] = "
<< getTimeEstCombined(i) << "\n"
<< " Time error estimate sum ["<<i<<"] = "
- << scalContents[i]->est_t_sum << "\n"
+ << scalContent.second.est_t_sum << "\n"
<< " Time error estimate max ["<<i<<"] = "
- << scalContents[i]->est_t_max << "\n"
+ << scalContent.second.est_t_max << "\n"
<< " Time error low bound ["<<i<<"] = "
- << scalContents[i]->timeErrLow << "\n"
+ << scalContent.second.timeErrLow << "\n"
<< " Time error high bound ["<<i<<"] = "
- << scalContents[i]->timeTolerance << "\n";
+ << scalContent.second.timeTolerance << "\n";
}
}
diff --git a/src/amdis/AdaptInfo.hpp b/src/amdis/AdaptInfo.hpp
index 6b7d6baec565469610bdaba8689160d83eb1d191..b573492993edd31f3e9c02f8706621eacab28fb3 100644
--- a/src/amdis/AdaptInfo.hpp
+++ b/src/amdis/AdaptInfo.hpp
@@ -4,12 +4,15 @@
#include <algorithm>
#include <cmath>
#include <limits>
+#include <map>
#include <string>
-#include <vector>
+#include <utility>
// AMDiS includes
#include <amdis/Output.hpp>
+#include <amdis/common/ConceptsBase.hpp>
#include <amdis/common/Math.hpp>
+#include <amdis/utility/TreePath.hpp>
namespace AMDiS
{
@@ -18,11 +21,13 @@ namespace AMDiS
* \ingroup Adaption
*
* \brief
- * Holds adapt parameters and infos about the problem. Base class
- * for AdaptInfoScal and AdaptInfoVec.
+ * Holds adapt parameters and infos about the problem.
*/
class AdaptInfo
{
+ public:
+ using Key = std::string;
+
protected:
/** \brief
* Stores adapt infos for a scalar problem or for one component of a
@@ -66,25 +71,11 @@ namespace AMDiS
/// true if refinement is allowed, false otherwise.
int refinementAllowed = 1;
-
- /** \brief
- * parameter to tell the marking strategy how many bisections should be
- * performed when an element is marked for refinement; usually the value is
- * 1 or DIM
- */
- int refineBisections = 1;
-
- /** \brief
- * parameter to tell the marking strategy how many bisections should
- * be undone when an element is marked for coarsening; usually the value is
- * 1 or DIM
- */
- int coarseBisections = 1;
};
public:
/// Constructor.
- explicit AdaptInfo(std::string name, int size = 1);
+ explicit AdaptInfo(std::string name);
/// Destructor.
virtual ~AdaptInfo() {}
@@ -95,61 +86,78 @@ namespace AMDiS
/// Returns whether space tolerance is reached.
virtual bool spaceToleranceReached() const
{
- for (std::size_t i = 0; i < scalContents.size(); i++)
- {
- if (!(scalContents[i]->est_sum < scalContents[i]->spaceTolerance))
+ for (auto const& scalContent : scalContents) {
+ if (!(scalContent.second.est_sum < scalContent.second.spaceTolerance))
return false;
}
return true;
}
- /// Returns whether space tolerance of component i is reached.
- virtual bool spaceToleranceReached(int i) const
+ /// Returns whether space tolerance of component associated with key is reached.
+ virtual bool spaceToleranceReached(Key key) const
{
- if (!(scalContents[i]->est_sum < scalContents[i]->spaceTolerance))
+ if (!(getScalContent(key).est_sum < getScalContent(key).spaceTolerance))
return false;
else
return true;
}
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ bool spaceToleranceReached(const TP& tp) const
+ {
+ return spaceToleranceReached(to_string(tp));
+ }
+
/// Returns whether time tolerance is reached.
virtual bool timeToleranceReached() const
{
- for (std::size_t i = 0; i < scalContents.size(); i++)
- if (!(getTimeEstCombined(i) < scalContents[i]->timeTolerance))
+ for (auto const& scalContent : scalContents)
+ if (!(getTimeEstCombined(scalContent.first) < scalContent.second.timeTolerance))
return false;
return true;
}
- /// Returns whether time tolerance of component i is reached.
- virtual bool timeToleranceReached(int i) const
+ /// Returns whether time tolerance of component associated with key is reached.
+ virtual bool timeToleranceReached(Key key) const
{
- if (!(getTimeEstCombined(i) < scalContents[i]->timeTolerance))
+ if (!(getTimeEstCombined(key) < getScalContent(key).timeTolerance))
return false;
else
return true;
}
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ bool timeToleranceReached(const TP& tp) const
+ {
+ return timeToleranceReached(to_string(tp));
+ }
+
/// Returns whether time error is under its lower bound.
virtual bool timeErrorLow() const
{
- for (std::size_t i = 0; i < scalContents.size(); i++)
- if (!(getTimeEstCombined(i) < scalContents[i]->timeErrLow))
+ for (auto const& scalContent : scalContents)
+ if (!(getTimeEstCombined(scalContent.first) < scalContent.second.timeErrLow))
return false;
return true;
}
+
/// Returns the time estimation as a combination
/// of maximal and integral time error
- double getTimeEstCombined(std::size_t i) const
+ double getTimeEstCombined(Key key) const
{
return
- scalContents[i]->est_t_max * scalContents[i]->fac_max +
- scalContents[i]->est_t_sum * scalContents[i]->fac_sum;
+ getScalContent(key).est_t_max * getScalContent(key).fac_max +
+ getScalContent(key).est_t_sum * getScalContent(key).fac_sum;
}
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ double getTimeEstCombined(const TP& tp) const
+ {
+ return getTimeEstCombined(to_string(tp));
+ }
/// Print debug information about time error and its bound.
void printTimeErrorLowInfo() const;
@@ -275,63 +283,111 @@ namespace AMDiS
}
/// Sets \ref est_sum.
- void setEstSum(double e, int index)
+ void setEstSum(double e, Key key)
{
- scalContents[index]->est_sum = e;
+ getScalContent(key).est_sum = e;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ void setEstSum(double e, const TP& tp)
+ {
+ setEstSum(e, to_string(tp));
}
/// Sets \ref est_max.
- void setEstMax(double e, int index)
+ void setEstMax(double e, Key key)
+ {
+ getScalContent(key).est_max = e;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ void setEstMax(double e, const TP& tp)
{
- scalContents[index]->est_max = e;
+ setEstMax(e, to_string(tp));
}
/// Sets \ref est_max.
- void setTimeEstMax(double e, int index)
+ void setTimeEstMax(double e, Key key)
+ {
+ getScalContent(key).est_t_max = e;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ void setTimeEstMax(double e, const TP& tp)
{
- scalContents[index]->est_t_max = e;
+ setTimeEstMax(e, to_string(tp));
}
/// Sets \ref est_t_sum.
- void setTimeEstSum(double e, int index)
+ void setTimeEstSum(double e, Key key)
+ {
+ getScalContent(key).est_t_sum = e;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ void setTimeEstSum(double e, const TP& tp)
{
- scalContents[index]->est_t_sum = e;
+ setTimeEstSum(e, to_string(tp));
}
/// Returns \ref est_sum.
- double getEstSum(int index) const
+ double getEstSum(Key key) const
{
- AMDIS_FUNCNAME_DBG("AdaptInfo::getEstSum()");
- test_exit_dbg(size_t(index) < scalContents.size(), "Wrong index for adaptInfo!\n");
+ return getScalContent(key).est_sum;
+ }
- return scalContents[index]->est_sum;
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ double getEstSum(const TP& tp)
+ {
+ return getEstSum(to_string(tp));
}
/// Returns \ref est_t_sum.
- double getEstTSum(int index) const
+ double getEstTSum(Key key) const
+ {
+ return getScalContent(key).est_t_sum;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ double getEstTSum(const TP& tp)
{
- return scalContents[index]->est_t_sum;
+ return getEstTSum(to_string(tp));
}
/// Returns \ref est_max.
- double getEstMax(int index) const
+ double getEstMax(Key key) const
{
- AMDIS_FUNCNAME_DBG("AdaptInfo::getEstSum()");
- test_exit_dbg(size_t(index) < scalContents.size(), "Wrong index for adaptInfo!\n");
+ return getScalContent(key).est_max;
+ }
- return scalContents[index]->est_max;
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ double getEstMax(const TP& tp)
+ {
+ return getEstMax(to_string(tp));
}
/// Returns \ref est_max.
- double getTimeEstMax(int index) const
+ double getTimeEstMax(Key key) const
+ {
+ return getScalContent(key).est_t_max;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ double getTimeEstmax(const TP& tp)
{
- return scalContents[index]->est_t_max;
+ return getTimeEstMax(to_string(tp));
}
/// Returns \ref est_t_sum.
- double getTimeEstSum(int index) const
+ double getTimeEstSum(Key key) const
+ {
+ return getScalContent(key).est_t_sum;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ double getTimeEstSum(const TP& tp)
{
- return scalContents[index]->est_t_sum;
+ return getTimeEstSum(to_string(tp));
}
/// Returns \ref est_t the estimated overall time error
@@ -346,27 +402,51 @@ namespace AMDiS
}
/// Returns \ref spaceTolerance.
- double getSpaceTolerance(int index) const
+ double getSpaceTolerance(Key key) const
+ {
+ return getScalContent(key).spaceTolerance;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ double getSpaceTolerance(const TP& tp)
{
- return scalContents[index]->spaceTolerance;
+ return getSpaceTolerance(to_string(tp));
}
/// Sets \ref spaceTolerance.
- void setSpaceTolerance(int index, double tol)
+ void setSpaceTolerance(Key key, double tol)
{
- scalContents[index]->spaceTolerance = tol;
+ getScalContent(key).spaceTolerance = tol;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ void setSpaceTolerance(const TP& tp, double tol)
+ {
+ return setSpaceTolerance(to_string(tp), tol);
}
/// Returns \ref timeTolerance.
- double getTimeTolerance(int index) const
+ double getTimeTolerance(Key key) const
+ {
+ return getScalContent(key).timeTolerance;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ double getTimeTolerance(const TP& tp)
{
- return scalContents[index]->timeTolerance;
+ return getTimeTolerance(to_string(tp));
}
/// Returns \ref timeRelativeTolerance.
- double getTimeRelativeTolerance(int index) const
+ double getTimeRelativeTolerance(Key key) const
+ {
+ return getScalContent(key).timeRelativeTolerance;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ double getTimeRelativeTolerance(const TP& tp)
{
- return scalContents[index]->timeRelativeTolerance;
+ return getTimeRelativeTolerance(to_string(tp));
}
/// Sets \ref time
@@ -488,45 +568,63 @@ namespace AMDiS
}
/// Returns \ref timeErrLow.
- double getTimeErrLow(int index) const
+ double getTimeErrLow(Key key) const
+ {
+ return getScalContent(key).timeErrLow;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ double getTimeErrLow(const TP& tp)
{
- return scalContents[index]->timeErrLow;
+ return getTimeErrLow(to_string(tp));
}
/// Returns whether coarsening is allowed or not.
- bool isCoarseningAllowed(int index) const
+ bool isCoarseningAllowed(Key key) const
{
- return (scalContents[index]->coarsenAllowed == 1);
+ return (getScalContent(key).coarsenAllowed == 1);
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ bool isCoarseningAllowed(const TP& tp)
+ {
+ return isCoarseningAllowed(to_string(tp));
}
/// Returns whether coarsening is allowed or not.
- bool isRefinementAllowed(int index) const
+ bool isRefinementAllowed(Key key) const
{
- return (scalContents[index]->refinementAllowed == 1);
+ return (getScalContent(key).refinementAllowed == 1);
}
- ///
- void allowRefinement(bool allow, int index)
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ bool isRefinementAllowed(const TP& tp)
{
- scalContents[index]->refinementAllowed = allow;
+ return isRefinementAllowed(to_string(tp));
}
///
- void allowCoarsening(bool allow, int index)
+ void allowRefinement(bool allow, Key key)
{
- scalContents[index]->coarsenAllowed = allow;
+ getScalContent(key).refinementAllowed = allow;
}
- /// Returns \ref refineBisections
- int getRefineBisections(int index) const
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ void allowRefinement(bool allow, const TP& tp)
{
- return scalContents[index]->refineBisections;
+ return allowRefinement(allow, to_string(tp));
}
- /// Returns \ref coarseBisections
- int getCoarseBisections(int index) const
+ ///
+ void allowCoarsening(bool allow, Key key)
+ {
+ getScalContent(key).coarsenAllowed = allow;
+ }
+
+ template <class TP, REQUIRES( Concepts::PreTreePath<TP> )>
+ void allowCoarsening(bool allow, const TP& tp)
{
- return scalContents[index]->coarseBisections;
+ return allowCoarsening(allow, to_string(tp));
}
int getSize() const
@@ -596,9 +694,6 @@ namespace AMDiS
rosenbrockMode = b;
}
- /// Creates new scalContents with the given size.
- void setScalContents(int newSize);
-
/** \brief
* Resets timestep, current time and time boundaries without
* any check. Is used by the parareal algorithm.
@@ -614,6 +709,13 @@ namespace AMDiS
timestepNumber = 0;
}
+ private:
+ ScalContent& getScalContent(Key key) const
+ {
+ auto result = scalContents.emplace(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(name + "[" + key + "]") );
+ return result.first->second;
+ }
+
protected:
/// Name.
std::string name;
@@ -648,7 +750,7 @@ namespace AMDiS
/// Final time
double endTime = 1.0;
- ///Time step size to be used
+ /// Time step size to be used
double timestep = 0.0;
/// Last processed time step size of finished iteration
@@ -685,8 +787,8 @@ namespace AMDiS
/// tolerance for the overall time error
double globalTimeTolerance = 1.0;
- /// Scalar adapt infos.
- std::vector<std::unique_ptr<ScalContent>> scalContents;
+ /// Scalar adapt infos
+ mutable std::map<Key, ScalContent> scalContents;
/// Is true, if the adaptive procedure was deserialized from a file. TODO: remove deserialization
bool deserialized = false;
diff --git a/test/AdaptInfoTest.cpp b/test/AdaptInfoTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..78bc27336d92d9ffad68d2f712ba07b0d8a385e9
--- /dev/null
+++ b/test/AdaptInfoTest.cpp
@@ -0,0 +1,38 @@
+#include <amdis/AdaptInfo.cpp>
+#include <amdis/AMDiS.hpp>
+
+#include <amdis/common/Literals.hpp>
+
+#include <amdis/utility/TreePath.hpp>
+
+#include "Tests.hpp"
+
+using namespace AMDiS;
+
+int main()
+{
+ AdaptInfo adaptInfo("adapt");
+
+ auto root_tp = treepath();
+ auto tp = treepath(0_c);
+ std::string str = "0";
+
+ adaptInfo.setEstSum(0.1, tp);
+ AMDIS_TEST_EQ(adaptInfo.getEstSum(tp), 0.1);
+
+ adaptInfo.setEstSum(0.2, root_tp);
+ AMDIS_TEST_EQ(adaptInfo.getEstSum(root_tp), 0.2);
+
+ AMDIS_TEST_EQ(adaptInfo.getSize(), 2);
+
+ adaptInfo.setEstSum(0.3, "0");
+ AMDIS_TEST_EQ(adaptInfo.getEstSum(tp), 0.3);
+
+ adaptInfo.setEstSum(0.4, 0_c);
+ AMDIS_TEST_EQ(adaptInfo.getEstSum(tp), 0.4);
+
+ adaptInfo.setEstSum(0.5, str);
+ AMDIS_TEST_EQ(adaptInfo.getEstSum(tp), 0.5);
+
+ return report_errors();
+}
\ No newline at end of file
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index bd94e1043332446607227a6b4955e6a78473d066..73701a09ed01b65438f4cf3c7bab0ad55c500955 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,4 +1,7 @@
+dune_add_test(SOURCES AdaptInfoTest.cpp
+ LINK_LIBRARIES amdis)
+
dune_add_test(SOURCES ClonablePtrTest.cpp
LINK_LIBRARIES amdis)