Reference documentation for deal.II version 9.2.0
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
parsed_convergence_table.cc
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2019 - 2020 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
17 #include <deal.II/base/patterns.h>
18 #include <deal.II/base/utilities.h>
19 
21 
22 namespace
23 {
24  std::vector<std::string>
25  get_unique_component_names(const std::vector<std::string> &component_names)
26  {
27  auto elements = component_names;
28  auto last = std::unique(elements.begin(), elements.end());
29  elements.resize(last - elements.begin());
30  return elements;
31  }
32 
33 
34 
35  std::vector<ComponentMask>
36  get_unique_component_masks(const std::vector<std::string> &component_names)
37  {
38  const auto unique_component_names =
39  get_unique_component_names(component_names);
40 
41  std::vector<ComponentMask> masks;
42 
43  std::vector<std::vector<bool>> bools(
44  unique_component_names.size(),
45  std::vector<bool>(component_names.size(), false));
46 
47  unsigned int j = 0;
48  for (unsigned int i = 0; i < component_names.size(); ++i)
49  {
50  if (unique_component_names[j] != component_names[i])
51  masks.emplace_back(bools[j++]);
52  bools[j][i] = true;
53  }
54  masks.emplace_back(bools[j++]);
55  AssertDimension(j, unique_component_names.size());
56  return masks;
57  }
58 } // namespace
59 
60 
61 
63  const std::vector<std::string> & solution_names,
64  const std::vector<std::set<VectorTools::NormType>> &list_of_error_norms)
65  : ParsedConvergenceTable(solution_names,
66  list_of_error_norms,
67  2.0,
68  {"cells", "dofs"},
69  "dofs",
70  "reduction_rate_log2",
71  "",
72  3,
73  true)
74 {}
75 
76 
77 
79  const std::vector<std::string> & component_names,
80  const std::vector<std::set<VectorTools::NormType>> &list_of_error_norms,
81  const double exponent,
82  const std::set<std::string> & extra_columns,
83  const std::string & rate_key,
84  const std::string & rate_mode,
85  const std::string & error_file_name,
86  const unsigned int precision,
87  const bool compute_error)
88  : component_names(component_names)
89  , unique_component_names(get_unique_component_names(component_names))
90  , unique_component_masks(get_unique_component_masks(component_names))
91  , norms_per_unique_component(list_of_error_norms)
92  , exponent(exponent)
93  , extra_columns(extra_columns)
94  , rate_key(rate_key)
95  , rate_mode(rate_mode)
96  , precision(precision)
97  , error_file_name(error_file_name)
98  , compute_error(compute_error)
99 {
101  unique_component_names.size());
102 }
103 
104 
105 
106 void
108 {
109  prm.add_parameter("Enable computation of the errors",
111  "When set to false, no computations are performed.");
112 
113  prm.add_parameter("Error precision",
114  precision,
115  "Number of digits to use when printing the error.",
116  Patterns::Integer(0));
117 
118  prm.add_parameter("Error file name",
120  "Set this to a filename with extension .txt, .gpl, .org, "
121  "or .tex to enable writing the convergence table to a "
122  "file.");
123 
124  prm.add_parameter(
125  "List of error norms to compute",
127  "Each component is separated by a semicolon "
128  "and each norm by a comma. See the documentation of VectorTools::NormType "
129  "for a list of implemented norms. If you want to skip a component, leave "
130  "its entry empty.");
131 
132 
133  prm.add_parameter("Exponent for p-norms",
134  exponent,
135  "The exponent to use when computing p-norms.",
136  Patterns::Double(1));
137 
138  prm.add_parameter("Extra columns",
140  "Extra columns to add to the table. Available options "
141  "are dofs and cells.",
142  Patterns::List(Patterns::Selection("dofs|cells")));
143 
144  prm.add_parameter("Rate key",
145  rate_key,
146  "Key to use when computing convergence rates. If "
147  "this is set to a column that is not present, or to the "
148  "empty string, then no error rates are computed.");
149 
150  prm.add_parameter("Rate mode",
151  rate_mode,
152  "What type of error rate to compute. Available options are "
153  "reduction_rate_log2, reduction_rate, and none.",
155  "reduction_rate|reduction_rate_log2|none"));
156 }
157 
158 
159 
160 void
162 {
163  if (compute_error)
164  {
165  // Add convergence rates if the rate_key is not empty
166  if (rate_key != "")
167  {
168  bool has_key = false;
169  for (const auto &col : extra_columns)
170  {
171  if (rate_key == col)
172  has_key = true;
173 
174  if (col != "")
176  }
177 
178  for (const auto &extra_col : extra_column_functions)
179  if (extra_col.second.second == false)
180  {
181  if (rate_key == extra_col.first)
182  has_key = true;
184  extra_col.first);
185  }
186 
187  if (has_key)
188  {
189  if (rate_mode == "reduction_rate_log2")
192  else if (rate_mode == "reduction_rate")
195  else
196  {
197  Assert(rate_mode != "none", ExcInternalError());
198  }
199  }
200  else
201  {
202  AssertThrow(rate_key != "",
203  ExcMessage(
204  "You specified the key <" + rate_key +
205  "> to compute convergence rates, but that key does "
206  "not exist in the current table."));
207  }
208  }
209  }
210 }
211 
212 
213 
214 void
216 {
217  if (compute_error)
218  {
220  table.write_text(out);
221  output_table();
222  }
223 }
224 
225 
226 
227 void
229 {
230  if (compute_error && error_file_name != "")
231  {
233 
234  const std::string error_file_format =
235  error_file_name.substr(error_file_name.find_last_of('.') + 1);
236 
237  std::ofstream table_file(error_file_name);
238 
239  if (error_file_format == "tex")
240  table.write_tex(table_file);
241  else if (error_file_format == "txt")
242  table.write_text(table_file);
243  else if (error_file_format == "gpl")
244  table.write_text(table_file,
246  else if (error_file_format == "org")
248  else
249  {
250  AssertThrow(false,
252  std::string("Unrecognized file format: ") +
253  error_file_format));
254  }
255  table_file.close();
256  }
257 }
258 
259 
260 
261 void
263  const std::string & column_name,
264  const std::function<double()> &custom_function,
265  const bool compute_rate)
266 {
267  extra_column_functions[column_name] = {custom_function, compute_rate};
268 }
269 
ParsedConvergenceTable
The ParsedConvergenceTable class.
Definition: parsed_convergence_table.h:137
ParsedConvergenceTable::error_file_name
std::string error_file_name
Definition: parsed_convergence_table.h:472
ParsedConvergenceTable::rate_mode
std::string rate_mode
Definition: parsed_convergence_table.h:462
utilities.h
ConvergenceTable::reduction_rate_log2
@ reduction_rate_log2
Definition: convergence_table.h:88
ParsedConvergenceTable::exponent
double exponent
Definition: parsed_convergence_table.h:442
ParsedConvergenceTable::unique_component_names
const std::vector< std::string > unique_component_names
Definition: parsed_convergence_table.h:421
ParsedConvergenceTable::add_extra_column
void add_extra_column(const std::string &column_name, const std::function< double()> &custom_function, const bool compute_rate=true)
Definition: parsed_convergence_table.cc:262
ParsedConvergenceTable::precision
unsigned int precision
Definition: parsed_convergence_table.h:467
StandardExceptions::ExcMessage
static ::ExceptionBase & ExcMessage(std::string arg1)
TableHandler::org_mode_table
@ org_mode_table
Definition: table_handler.h:372
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:358
ParsedConvergenceTable::extra_column_functions
std::map< std::string, std::pair< std::function< double()>, bool > > extra_column_functions
Definition: parsed_convergence_table.h:432
ParsedConvergenceTable::compute_error
bool compute_error
Definition: parsed_convergence_table.h:478
ConvergenceTable::reduction_rate
@ reduction_rate
Definition: convergence_table.h:83
AssertDimension
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1579
Patterns::List
Definition: patterns.h:451
parsed_convergence_table.h
ParsedConvergenceTable::extra_columns
std::set< std::string > extra_columns
Definition: parsed_convergence_table.h:452
ParsedConvergenceTable::ParsedConvergenceTable
ParsedConvergenceTable(const std::vector< std::string > &component_names={"u"}, const std::vector< std::set< VectorTools::NormType >> &list_of_error_norms={ {VectorTools::H1_norm, VectorTools::L2_norm, VectorTools::Linfty_norm}})
Definition: parsed_convergence_table.cc:62
ParsedConvergenceTable::add_parameters
void add_parameters(ParameterHandler &prm)
Definition: parsed_convergence_table.cc:107
ParsedConvergenceTable::output_table
void output_table()
Definition: parsed_convergence_table.cc:228
ParsedConvergenceTable::table
ConvergenceTable table
Definition: parsed_convergence_table.h:447
TableHandler::table_with_separate_column_description
@ table_with_separate_column_description
Definition: table_handler.h:363
StandardExceptions::ExcInternalError
static ::ExceptionBase & ExcInternalError()
ParsedConvergenceTable::rate_key
std::string rate_key
Definition: parsed_convergence_table.h:457
Assert
#define Assert(cond, exc)
Definition: exceptions.h:1419
ParameterHandler::add_parameter
void add_parameter(const std::string &entry, ParameterType &parameter, const std::string &documentation="", const Patterns::PatternBase &pattern= *Patterns::Tools::Convert< ParameterType >::to_pattern(), const bool has_to_be_set=false)
Definition: parameter_handler.h:2328
ParameterHandler
Definition: parameter_handler.h:845
Patterns::Selection
Definition: patterns.h:383
ConvergenceTable::omit_column_from_convergence_rate_evaluation
void omit_column_from_convergence_rate_evaluation(const std::string &key)
Definition: convergence_table.cc:218
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:359
ConvergenceTable::evaluate_all_convergence_rates
void evaluate_all_convergence_rates(const std::string &reference_column_key, const RateMode rate_mode)
Definition: convergence_table.cc:230
patterns.h
ParsedConvergenceTable::norms_per_unique_component
std::vector< std::set< VectorTools::NormType > > norms_per_unique_component
Definition: parsed_convergence_table.h:437
AssertThrow
#define AssertThrow(cond, exc)
Definition: exceptions.h:1531
TableHandler::write_tex
void write_tex(std::ostream &file, const bool with_header=true) const
Definition: table_handler.cc:599
ParsedConvergenceTable::prepare_table_for_output
void prepare_table_for_output()
Definition: parsed_convergence_table.cc:161
Patterns::Double
Definition: patterns.h:293
TableHandler::write_text
void write_text(std::ostream &out, const TextOutputFormat format=table_with_headers) const
Definition: table_handler.cc:383
Patterns::Integer
Definition: patterns.h:190