Belos Version of the Day
Loading...
Searching...
No Matches
BelosTypes.cpp
Go to the documentation of this file.
1//@HEADER
2// ************************************************************************
3//
4// Belos: Block Linear Solvers Package
5// Copyright 2004 Sandia Corporation
6//
7// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
8// the U.S. Government retains certain rights in this software.
9//
10// Redistribution and use in source and binary forms, with or without
11// modification, are permitted provided that the following conditions are
12// met:
13//
14// 1. Redistributions of source code must retain the above copyright
15// notice, this list of conditions and the following disclaimer.
16//
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// 3. Neither the name of the Corporation nor the names of the
22// contributors may be used to endorse or promote products derived from
23// this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36//
37// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
38//
39// ************************************************************************
40//@HEADER
41
42#include <BelosTypes.hpp>
43#include <vector>
44
45namespace Belos {
46
47 namespace {
48 const char*
49 convertStatusTypeToRawString (const StatusType status)
50 {
51 if (status == Passed) {
52 return "Passed";
53 } else if (status == Failed) {
54 return "Failed";
55 } else if (status == Undefined) {
56 return "Undefined";
57 } else {
58 TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
59 "Belos::convertStatusTypeToRawString: Invalid StatusType enum value "
60 << status << ".");
61 }
62 }
63 } // namespace (anonymous)
64
65 std::string
67 {
68 return convertStatusTypeToRawString (status);
69 }
70
72 convertStringToStatusType (const std::string& status)
73 {
74 if (status == "Passed") {
75 return Passed;
76 } else if (status == "Failed") {
77 return Failed;
78 } else if (status == "Undefined") {
79 return Undefined;
80 } else {
81 TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
82 "Belos::convertStringToStatusType: Invalid string \"" << status
83 << "\".");
84 }
85 }
86
88 convertStringToNormType (const std::string& normType)
89 {
90 if (normType == "OneNorm") {
91 return Belos::OneNorm;
92 } else if (normType == "TwoNorm") {
93 return Belos::TwoNorm;
94 } else if (normType == "InfNorm") {
95 return Belos::InfNorm;
96 } else if (normType == "PreconditionerNorm") {
98 } else {
99 TEUCHOS_TEST_FOR_EXCEPTION( true, std::logic_error,
100 "Belos::convertStringToNormType(): Invalid norm type \""
101 << normType << "\".");
102 }
103 }
104
106 convertStringToScaleType (const std::string& scaleType)
107 {
108 if (scaleType == "Norm of Initial Residual") {
110 } else if (scaleType == "Norm of Preconditioned Initial Residual") {
112 } else if (scaleType == "Norm of RHS") {
113 return Belos::NormOfRHS;
114 } else if (scaleType == "None") {
115 return Belos::None;
116 } else if (scaleType == "User Provided") {
117 return Belos::UserProvided;
118 } else {
119 TEUCHOS_TEST_FOR_EXCEPTION( true, std::logic_error,
120 "Belos::convertStringToScaleType(): Invalid residual scaling type \""
121 << scaleType << "\".");
122 }
123 }
124
125 std::string
127 {
128 if (scaleType == Belos::NormOfInitRes) {
129 return "Norm of Initial Residual";
130 } else if (scaleType == Belos::NormOfPrecInitRes) {
131 return "Norm of Preconditioned Initial Residual";
132 } else if (scaleType == Belos::NormOfRHS) {
133 return "Norm of RHS";
134 } else if (scaleType == Belos::None) {
135 return "None";
136 } else if (scaleType == Belos::UserProvided) {
137 return "User Provided";
138 } else {
139 TEUCHOS_TEST_FOR_EXCEPTION( true, std::logic_error,
140 "Belos::convertScaleTypeToString(): Invalid residual scaling type "
141 "value " << scaleType << ".");
142 }
143 }
144
145 std::string
147 {
148 typedef std::vector<int>::size_type size_type;
149
150 // Wouldn't it be nice if C++ enums had introspection and could
151 // be enumerated?
152 const size_type numValidTypes = 8;
153 const int validTypes[] = {
162 };
163 const char* typeNames[] = {
164 "Errors",
165 "Warnings",
166 "IterationDetails",
167 "OrthoDetails",
168 "FinalSummary",
169 "TimingDetails",
170 "StatusTestDetails",
171 "Debug"
172 };
173
174 // We first generate a list, and only then build a single string.
175 // This helps us decide where to put the commas. The list just
176 // uses the indices of the valid names, rather than the valid
177 // names themselves, in order to save space and time. We use
178 // size_type for the indices to avoid signed/unsigned comparisons.
179 std::vector<size_type> theList;
180 for (size_type nameIndex = 0; nameIndex < numValidTypes; ++nameIndex) {
181 if (msgType & validTypes[nameIndex]) {
182 theList.push_back (nameIndex);
183 }
184 }
185 std::ostringstream os;
186 for (size_type k = 0; k < theList.size(); ++k) {
187 const size_type nameIndex = theList[k];
188 os << typeNames[nameIndex];
189 if (nameIndex < theList.size() - 1) {
190 os << ",";
191 }
192 }
193 return os.str();
194 }
195
196 std::string
198 {
199 if (result == Belos::Converged) {
200 return "Converged";
201 } else if (result == Belos::Unconverged) {
202 return "Unconverged";
203 } else {
204 TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
205 "Belos::convertReturnTypeToString: Invalid ReturnType enum value "
206 << result << ".");
207 }
208 }
209
210 // Initialize DefaultSolverParameters. Has to be done this way because
211 // the "static consexpr double blah = ...;" pattern can create ODR-used
212 // linking errors (usually in debug builds).
213 const double DefaultSolverParameters::convTol = 1.0e-8;
214 const double DefaultSolverParameters::polyTol = 1.0e-12;
215 const double DefaultSolverParameters::orthoKappa = -1.0;
217 const double DefaultSolverParameters::impTolScale = 10.0;
218
219} // end Belos namespace
220
Collection of types and exceptions used within the Belos solvers.
std::string convertMsgTypeToString(const MsgType msgType)
Show MsgType as a comma-delimited list of names.
Definition: BelosTypes.cpp:146
ScaleType convertStringToScaleType(const std::string &scaleType)
Convert the given string to its ScaleType enum value.
Definition: BelosTypes.cpp:106
NormType
The type of vector norm to compute.
Definition: BelosTypes.hpp:97
@ InfNorm
Definition: BelosTypes.hpp:99
@ OneNorm
Definition: BelosTypes.hpp:97
@ PreconditionerNorm
Definition: BelosTypes.hpp:100
@ TwoNorm
Definition: BelosTypes.hpp:98
MsgType
Available message types recognized by the linear solvers.
Definition: BelosTypes.hpp:254
@ OrthoDetails
Definition: BelosTypes.hpp:258
@ StatusTestDetails
Definition: BelosTypes.hpp:261
@ FinalSummary
Definition: BelosTypes.hpp:259
@ TimingDetails
Definition: BelosTypes.hpp:260
@ IterationDetails
Definition: BelosTypes.hpp:257
@ Warnings
Definition: BelosTypes.hpp:256
StatusType
Whether the StatusTest wants iteration to stop.
Definition: BelosTypes.hpp:189
@ Undefined
Definition: BelosTypes.hpp:191
NormType convertStringToNormType(const std::string &normType)
Convert the given string to its NormType enum value.
Definition: BelosTypes.cpp:88
ReturnType
Whether the Belos solve converged for all linear systems.
Definition: BelosTypes.hpp:155
@ Unconverged
Definition: BelosTypes.hpp:157
@ Converged
Definition: BelosTypes.hpp:156
std::string convertScaleTypeToString(const ScaleType scaleType)
Convert the given ScaleType enum value to its corresponding string.
Definition: BelosTypes.cpp:126
std::string convertStatusTypeToString(const StatusType status)
The string name corresponding to the given StatusType enum value.
Definition: BelosTypes.cpp:66
ScaleType
The type of scaling to use on the residual norm value.
Definition: BelosTypes.hpp:120
@ UserProvided
Definition: BelosTypes.hpp:124
@ NormOfPrecInitRes
Definition: BelosTypes.hpp:122
@ NormOfInitRes
Definition: BelosTypes.hpp:121
@ NormOfRHS
Definition: BelosTypes.hpp:120
std::string convertReturnTypeToString(const ReturnType result)
Convert the given ReturnType enum value to its corresponding string.
Definition: BelosTypes.cpp:197
StatusType convertStringToStatusType(const std::string &status)
The StatusType enum value corresponding to the given string name.
Definition: BelosTypes.cpp:72
static const double resScaleFactor
User-defined residual scaling factor.
Definition: BelosTypes.hpp:302
static const double impTolScale
"Implicit Tolerance Scale Factor"
Definition: BelosTypes.hpp:305
static const double convTol
Default convergence tolerance.
Definition: BelosTypes.hpp:293
static const double orthoKappa
DGKS orthogonalization constant.
Definition: BelosTypes.hpp:299
static const double polyTol
Relative residual tolerance for matrix polynomial construction.
Definition: BelosTypes.hpp:296

Generated for Belos by doxygen 1.9.6