00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042 #include "NOX_StatusTest_NormF.H"
00043 #include "NOX_Common.H"
00044 #include "NOX_Abstract_Vector.H"
00045 #include "NOX_Abstract_Group.H"
00046 #include "NOX_Solver_Generic.H"
00047 #include "NOX_Utils.H"
00048
00049 NOX::StatusTest::NormF::
00050 NormF(double tolerance,
00051 NOX::Abstract::Vector::NormType ntype, ScaleType stype,
00052 const NOX::Utils* u) :
00053 status(Unevaluated),
00054 normType(ntype),
00055 scaleType(stype),
00056 toleranceType(Absolute),
00057 specifiedTolerance(tolerance),
00058 initialTolerance(1.0),
00059 trueTolerance(tolerance),
00060 normF(0.0)
00061 {
00062 if (u != NULL)
00063 utils = *u;
00064 }
00065
00066 NOX::StatusTest::NormF::
00067 NormF(double tolerance, ScaleType stype,
00068 const NOX::Utils* u) :
00069 status(Unevaluated),
00070 normType(NOX::Abstract::Vector::TwoNorm),
00071 scaleType(stype),
00072 toleranceType(Absolute),
00073 specifiedTolerance(tolerance),
00074 initialTolerance(1.0),
00075 trueTolerance(tolerance),
00076 normF(0.0)
00077 {
00078 if (u != NULL)
00079 utils = *u;
00080 }
00081
00082 NOX::StatusTest::NormF::
00083 NormF(NOX::Abstract::Group& initialGuess, double tolerance,
00084 NOX::Abstract::Vector::NormType ntype,
00085 NOX::StatusTest::NormF::ScaleType stype,
00086 const NOX::Utils* u) :
00087 status(Unevaluated),
00088 normType(ntype),
00089 scaleType(stype),
00090 toleranceType(Relative),
00091 specifiedTolerance(tolerance),
00092 initialTolerance(0.0),
00093 trueTolerance(0.0),
00094 normF(0.0)
00095 {
00096 if (u != NULL)
00097 utils = *u;
00098
00099 relativeSetup(initialGuess);
00100 }
00101
00102
00103 NOX::StatusTest::NormF::
00104 NormF(NOX::Abstract::Group& initialGuess, double tolerance, ScaleType stype,
00105 const NOX::Utils* u) :
00106 status(Unevaluated),
00107 normType(NOX::Abstract::Vector::TwoNorm),
00108 scaleType(stype),
00109 toleranceType(Relative),
00110 specifiedTolerance(tolerance),
00111 initialTolerance(0.0),
00112 trueTolerance(0.0),
00113 normF(0.0)
00114 {
00115 if (u != NULL)
00116 utils = *u;
00117
00118 relativeSetup(initialGuess);
00119 }
00120
00121 NOX::StatusTest::NormF::~NormF()
00122 {
00123 }
00124
00125 void NOX::StatusTest::NormF::relativeSetup(NOX::Abstract::Group& initialGuess)
00126 {
00127 NOX::Abstract::Group::ReturnType rtype;
00128 rtype = initialGuess.computeF();
00129 if (rtype != NOX::Abstract::Group::Ok)
00130 {
00131 utils.err() << "NOX::StatusTest::NormF::NormF - Unable to compute F"
00132 << endl;
00133 throw "NOX Error";
00134 }
00135
00136 initialTolerance = computeNorm(initialGuess);
00137 trueTolerance = specifiedTolerance * initialTolerance;
00138 }
00139
00140 void NOX::StatusTest::NormF::reset(double tolerance)
00141 {
00142 specifiedTolerance = tolerance;
00143
00144 if (toleranceType == Absolute)
00145 trueTolerance = tolerance;
00146 else
00147 trueTolerance = specifiedTolerance * initialTolerance;
00148 }
00149
00150 void NOX::StatusTest::NormF::reset(NOX::Abstract::Group& initialGuess,
00151 double tolerance)
00152 {
00153 specifiedTolerance = tolerance;
00154 relativeSetup(initialGuess);
00155 }
00156
00157 double NOX::StatusTest::NormF::computeNorm(const NOX::Abstract::Group& grp)
00158 {
00159 if (!grp.isF())
00160 return -1.0;
00161
00162 double norm;
00163 int n = grp.getX().length();
00164
00165 switch (normType)
00166 {
00167
00168 case NOX::Abstract::Vector::TwoNorm:
00169 norm = grp.getNormF();
00170 if (scaleType == Scaled)
00171 norm /= sqrt(1.0 * n);
00172 break;
00173
00174 default:
00175 norm = grp.getF().norm(normType);
00176 if (scaleType == Scaled)
00177 norm /= n;
00178 break;
00179
00180 }
00181
00182 return norm;
00183 }
00184
00185
00186 NOX::StatusTest::StatusType NOX::StatusTest::NormF::
00187 checkStatus(const NOX::Solver::Generic& problem,
00188 NOX::StatusTest::CheckType checkType)
00189 {
00190 if (checkType == NOX::StatusTest::None)
00191 {
00192 normF = 0.0;
00193 status = Unevaluated;
00194 }
00195 else
00196 {
00197 normF = computeNorm( problem.getSolutionGroup() );
00198 status = ((normF != -1) && (normF < trueTolerance)) ? Converged : Unconverged;
00199 }
00200
00201 return status;
00202 }
00203
00204 NOX::StatusTest::StatusType NOX::StatusTest::NormF::getStatus() const
00205 {
00206 return status;
00207 }
00208
00209 ostream& NOX::StatusTest::NormF::print(ostream& stream, int indent) const
00210 {
00211 for (int j = 0; j < indent; j ++)
00212 stream << ' ';
00213 stream << status;
00214 stream << "F-Norm = " << Utils::sciformat(normF,3);
00215 stream << " < " << Utils::sciformat(trueTolerance, 3);
00216 stream << "\n";
00217
00218 for (int j = 0; j < indent; j ++)
00219 stream << ' ';
00220 stream << setw(13) << " ";
00221 stream << "(";
00222
00223 if (scaleType == Scaled)
00224 stream << "Length-Scaled";
00225 else
00226 stream << "Unscaled";
00227
00228 stream << " ";
00229
00230 if (normType == NOX::Abstract::Vector::TwoNorm)
00231 stream << "Two-Norm";
00232 else if (normType == NOX::Abstract::Vector::OneNorm)
00233 stream << "One-Norm";
00234 else if (normType == NOX::Abstract::Vector::MaxNorm)
00235 stream << "Max-Norm";
00236
00237 stream << ", ";
00238
00239 if (toleranceType == Absolute)
00240 stream << "Absolute Tolerance";
00241 else
00242 stream << "Relative Tolerance";
00243
00244 stream << ")";
00245
00246 stream << endl;
00247
00248 return stream;
00249 }
00250
00251
00252 double NOX::StatusTest::NormF::getNormF() const
00253 {
00254 return normF;
00255 }
00256
00257 double NOX::StatusTest::NormF::getTrueTolerance() const
00258 {
00259 return trueTolerance;
00260 }
00261
00262 double NOX::StatusTest::NormF::getSpecifiedTolerance() const
00263 {
00264 return specifiedTolerance;
00265 }
00266
00267 double NOX::StatusTest::NormF::getInitialTolerance() const
00268 {
00269 return initialTolerance;
00270 }