Xyce  6.1
N_NLS_NLParams.h
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // Copyright Notice
3 //
4 // Copyright 2002 Sandia Corporation. Under the terms
5 // of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S.
6 // Government retains certain rights in this software.
7 //
8 // Xyce(TM) Parallel Electrical Simulator
9 // Copyright (C) 2002-2015 Sandia Corporation
10 //
11 // This program is free software: you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation, either version 3 of the License, or
14 // (at your option) any later version.
15 //
16 // This program is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU General Public License
22 // along with this program. If not, see <http://www.gnu.org/licenses/>.
23 //-----------------------------------------------------------------------------
24 
25 //-------------------------------------------------------------------------
26 // Filename : $RCSfile: N_NLS_NLParams.h,v $
27 //
28 // Purpose : Basic user-specifid parameters data structure.
29 //
30 // Special Notes :
31 //
32 // Creator : Scott A. Hutchinson, SNL, Parallel Computational Sciences
33 //
34 // Creation Date : 04/28/00
35 //
36 // Revision Information:
37 // ----------------------
38 //
39 // Revision Number: $Revision: 1.90.2.1 $
40 //
41 // Revision Date : $Date: 2015/04/02 18:20:17 $
42 //
43 // Current Owner : $Author $
44 //-------------------------------------------------------------------------
45 
46 #ifndef Xyce_N_NLS_NLParams_h
47 #define Xyce_N_NLS_NLParams_h
48 
49 // ---------- Standard Includes ----------
50 #include <N_UTL_Math.h>
51 #include <climits>
52 #include <assert.h>
53 
54 #include <N_IO_fwd.h>
55 #include <N_NLS_Manager.h>
56 #include <N_ERH_ErrorMgr.h>
57 #include <N_UTL_Diagnostic.h>
58 #include <N_UTL_MachDepParams.h>
59 
60 namespace Xyce {
61 namespace Nonlinear {
62 
63 // ---------- Enumerated Types ----------
64 
65 // Support line-search methods.
67  FULL, // Newton's Method, undamped.
68  DIVIDE, // Reduce step-size by successively halving the previous
69  // step.
70  BACKTRACK, // Backtrack using interpolation (ala Dennis & Schnabel).
71  BANK_ROSE, // Bank and Rose algorithm - see method notes.
72  DESCENT, // More'-Thuente line search
73  SIMPLE_BACKTRACK // Simple backtracking method
74 };
75 
76 // Search directions.
77 enum Direction {
78  NEWTON_DIR, // Newton's direction
79  GRADIENT_DIR, // Steepest descent direction
80  MOD_NEWTON_DIR // Modified Newton direction
81 };
82 
83 // Nonlinear solution "strategies".
84 enum NLStrategy {
85  NEWTON, // Pure Newton's method
86  GRADIENT, // Pure gradient method
87  NEWTON_GRADIENT, // Combined Newton/gradient method
88  MOD_NEWTON, // Pure modified Newton's method
89  MOD_NEWTON_GRADIENT // Combined modified-Newton/gradient method
90 };
91 
92 //-----------------------------------------------------------------------------
93 // Class : NLParams
94 // Purpose : Stores nonlinear solver user settings.
95 // Special Notes :
96 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
97 // Creation Date : 5/01/00
98 //-----------------------------------------------------------------------------
99 class NLParams
100 {
101 public:
102  //NLParams(AnalysisMode mode=DC_OP);
103  NLParams(AnalysisMode mode, const IO::CmdParse & cp);
104  NLParams(const NLParams & right);
105 
106  ~NLParams();
107 
108  NLParams & operator=(const NLParams & right);
109 
110  // ***** Accessor functions *****
111 
112  void setPrintParamsFlag();
113  void clearPrintParamsFlag();
114  bool getPrintParamsFlag() const;
115 
116  bool setOptions(const Util::OptionBlock & OB);
117  bool setCmdLineOptions ();
118 
119  inline void setNLStrategy(NLStrategy strategy);
120  inline void setNLStrategy(int strategy);
121  inline void resetNLStrategy();
122  inline NLStrategy getNLStrategy() const;
123 
124  inline void setSearchMethod(LineSearchMethod method);
125  inline void setSearchMethod(int method);
126  inline void resetSearchMethod();
127  inline LineSearchMethod getSearchMethod() const;
128 
129  inline void setDirection(Direction value);
130  inline void resetDirection();
131  inline Direction getDirection() const;
132 
133  inline void setDeltaXTol(double Tolerance);
134  inline void resetDeltaXTol();
135  inline double getDeltaXTol() const;
136 
137  inline void setSmallUpdateTol (double Tolerance);
138  inline void resetSmallUpdateTol ();
139  inline double getSmallUpdateTol () const;
140 
141  inline void setEnforceDeviceConvFlag (bool flag);
142  inline void resetEnforceDeviceConvFlag ();
143  inline bool getEnforceDeviceConvFlag () const;
144 
145  inline void setRHSTol(double Tolerance);
146  inline void resetRHSTol();
147  inline double getRHSTol() const;
148 
149  inline void setAbsTol(double Tolerance);
150  inline void resetAbsTol();
151  inline double getAbsTol() const;
152 
153  inline void setRelTol(double Tolerance);
154  inline void resetRelTol();
155  inline double getRelTol() const;
156 
157  inline void setMaxNewtonStep(unsigned maxNewtonStep);
158  inline void resetMaxNewtonStep();
159  inline unsigned getMaxNewtonStep() const;
160 
161  inline void setMaxSearchStep(unsigned maxSearchStep);
162  inline void resetMaxSearchStep();
163  inline unsigned getMaxSearchStep() const;
164 
165  inline void setForcingFlag(bool flag);
166  inline void resetForcingFlag();
167  inline bool getForcingFlag() const;
168 
169  inline void setForcingTerm(double value);
170  inline void resetForcingTerm();
171  inline double getForcingTerm() const;
172 
173  inline void setNormLevel(int level);
174  inline void resetNormLevel();
175  inline int getNormLevel() const;
176 
177  inline void setLinearOpt(bool flag);
178  inline void resetLinearOpt();
179  inline bool getLinearOpt() const;
180 
181  inline void setConstraintBT(bool flag);
182  inline void resetConstraintBT();
183  inline bool getConstraintBT() const;
184 
185  inline void setGlobalBTMax(double value);
186  inline void resetGlobalBTMax();
187  inline double getGlobalBTMax() const;
188 
189  inline void setGlobalBTMin(double value);
190  inline void resetGlobalBTMin();
191  inline double getGlobalBTMin() const;
192 
193  inline void setGlobalBTChange(double value);
194  inline void resetGlobalBTChange();
195  inline double getGlobalBTChange() const;
196 
197  void printParams(std::ostream &os);
198 
199  inline void setDebugLevel(int value);
200  inline void resetDebugLevel();
201  inline int getDebugLevel() const;
202 
203  inline void setDebugMinTimeStep(int value);
204  inline void resetDebugMinTimeStep();
205  inline int getDebugMinTimeStep() const;
206 
207  inline void setDebugMaxTimeStep(int value);
208  inline void resetDebugMaxTimeStep();
209  inline int getDebugMaxTimeStep() const;
210 
211  inline void setDebugMinTime(double value);
212  inline void resetDebugMinTime();
213  inline double getDebugMinTime() const;
214 
215  inline void setDebugMaxTime(double value);
216  inline void resetDebugMaxTime();
217  inline double getDebugMaxTime() const;
218 
219  inline void setScreenOutputFlag (bool bval);
220  inline void resetScreenOutputFlag ();
221  inline bool getScreenOutputFlag () const;
222 
223  inline void setMaskingFlag (bool bval);
224  inline void resetMaskingFlag ();
225  inline bool getMaskingFlag () const;
226 
227  inline void setMMFormat(bool value);
228  inline void resetMMFormat();
229  inline bool getMMFormat() const;
230 
231 protected:
232 private:
233 
234 public:
235 
236 protected:
237  // Print control flag
239 
240  // command line parser
241  const IO::CmdParse * commandLine_;
242 
243  // Calling solution method (e.g., DC Operation Point, Transient, etc.)
246 
247  // Nonlinear solution strategy
249 
250  // Damping method (e.g., Bank and Rose)
252 
253  // Direction flag - dictates which direction to take in advancing the
254  // nonlinear solver.
256 
257  // Absolute convergence tolerance for the norm of the residual.
258  double absTol_;
259 
260  // Relative convergence tolerance.
261  double relTol_;
262 
263  // Weighted deltaX (update) norm tolerance (Petzold)
264  double deltaXTol_;
265 
266  // Special deltaX (update) norm tolerance, used for the
267  // "small update" test.
269 
270  // Weighted RHS (residual) norm tolerance
271  double RHSTol_;
272 
273  // Maximum number of solution steps to attempt.
274  unsigned maxNewtonStep_;
275 
276  // maximum number of damping steps:
277  unsigned maxSearchStep_;
278 
279  // inexact-Newton forcing flag:
281 
282  // check device convergence flag:
284 
285  // inexact-Newton forcing term:
286  double eta_;
287 
288  // norm level:
290 
291  // linear optimization flag
293 
294  // Constraint backtracking flag
296 
297  // Backtracking constraint scalar values. Note that these are used to set
298  // vectors of values to these defaults but, in general, the constraints can
299  // be individually applied to all solution variables (see
300  // ConstraintBT.h).
301  double globalBTMax_;
302  double globalBTMin_;
304 
305  // Debug output options:
314 };
315 
316 //-----------------------------------------------------------------------------
317 // Function : NLParams::setPrintParamsFlag
318 // Purpose : Sets the flag which controls the printing of the nonlinear
319 // solver parameters list. This flag should be set anytime one
320 // of the parameters is modified as the code runs.
321 // Special Notes :
322 // Scope : public
323 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
324 // Creation Date : 01/16/01
325 //-----------------------------------------------------------------------------
327 {
328  printParamsFlag_ = true;
329 }
330 
331 //-----------------------------------------------------------------------------
332 // Function : NLParams::clearPrintParamsFlag
333 // Purpose : Clears the flag which controls the printing of the nonlinear
334 // solver parameters list. This flag is cleared once the
335 // output is printed.
336 // Special Notes :
337 // Scope : public
338 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
339 // Creation Date : 01/16/01
340 //-----------------------------------------------------------------------------
342 {
343  printParamsFlag_ = 0;
344 }
345 
346 //-----------------------------------------------------------------------------
347 // Function : NLParams::getPrintParamsFlag
348 // Purpose : Returns the flag value
349 // Special Notes :
350 // Scope : public
351 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
352 // Creation Date : 01/16/01
353 //-----------------------------------------------------------------------------
354 inline bool NLParams::getPrintParamsFlag() const
355 {
356  return printParamsFlag_;
357 }
358 
359 //-----------------------------------------------------------------------------
360 // Function : NLParams::setNLStrategy
361 // Purpose : Accessor method to set the nonlinear solver strategy.
362 // Special Notes :
363 // Scope : public
364 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
365 // Creation Date : 02/26/01
366 //-----------------------------------------------------------------------------
367 inline void NLParams::setNLStrategy(NLStrategy strategy)
368 {
369  nlStrategy_ = strategy;
370 
371  // Make sure the method selected is supported, otherwise revert to the
372  // default.
373  if (nlStrategy_ != NEWTON &&
374  nlStrategy_ != GRADIENT &&
376  nlStrategy_ != MOD_NEWTON &&
378  resetNLStrategy();
379 }
380 
381 //-----------------------------------------------------------------------------
382 // Function : NLParams::setNLStrategy
383 // Purpose : Accessor method to set the nonlinear solver strategy.
384 // Special Notes : Takes an integer argument
385 // Scope : public
386 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
387 // Creation Date : 02/26/01
388 //-----------------------------------------------------------------------------
389 inline void NLParams::setNLStrategy(int strategy)
390 {
391  nlStrategy_ = static_cast<NLStrategy> (strategy);
392 
393  // Make sure the method selected is supported, otherwise revert to the
394  // default.
395  if (nlStrategy_ != NEWTON &&
396  nlStrategy_ != GRADIENT &&
398  nlStrategy_ != MOD_NEWTON &&
400  resetNLStrategy();
401 }
402 
403 //-----------------------------------------------------------------------------
404 // Function : NLParams::resetNLStrategy
405 // Purpose : Accessor method to reset the nonlinear solver strategy to
406 // its default.
407 // Special Notes :
408 // Scope : public
409 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
410 // Creation Date : 02/26/01
411 //-----------------------------------------------------------------------------
413 {
415 }
416 
417 //-----------------------------------------------------------------------------
418 // Function : NLParams::getNLStrategy
419 // Purpose : Accessor method to return the nonlinear solver strategy.
420 // Special Notes :
421 // Scope : public
422 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
423 // Creation Date : 02/26/01
424 //-----------------------------------------------------------------------------
426 {
427  return nlStrategy_;
428 }
429 
430 //-----------------------------------------------------------------------------
431 // Function : NLParams::setSearchMethod
432 // Purpose : Accessor method to set the line-search method
433 // Special Notes :
434 // Scope : public
435 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
436 // Creation Date : 01/13/01
437 //-----------------------------------------------------------------------------
439 {
440  searchMethod_ = method;
441 
442  // Revert to the default if the method selected is not supported
443  if (searchMethod_ != FULL &&
444  searchMethod_ != DIVIDE &&
450 }
451 
452 //-----------------------------------------------------------------------------
453 // Function : NLParams::setSearchMethod
454 // Purpose : Accessor method to set the line-search method
455 // Special Notes : Takes and integer argument
456 // Scope : public
457 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
458 // Creation Date : 01/13/01
459 //-----------------------------------------------------------------------------
460 inline void NLParams::setSearchMethod(int method)
461 {
462  searchMethod_ = static_cast<LineSearchMethod> (method);
463 
464  // Revert to the default if the method selected is not supported
465  if (searchMethod_ != FULL &&
466  searchMethod_ != DIVIDE &&
472 }
473 
474 //-----------------------------------------------------------------------------
475 // Function : NLParams::resetSearchMethod
476 // Purpose : Accessor method to reset the default line-search method
477 // Special Notes :
478 // Scope : public
479 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
480 // Creation Date : 01/24/01
481 //-----------------------------------------------------------------------------
483 {
485 }
486 
487 //-----------------------------------------------------------------------------
488 // Function : NLParams::getSearchMethod
489 // Purpose : Accessor method to return the line-search method
490 // Special Notes :
491 // Scope : public
492 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
493 // Creation Date : 01/13/01
494 //-----------------------------------------------------------------------------
496 {
497  return searchMethod_;
498 }
499 
500 //-----------------------------------------------------------------------------
501 // Function : NLParams::setDirection
502 // Purpose : Accessor method to set the nonlinear direction flag.
503 // Special Notes :
504 // Scope : public
505 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
506 // Creation Date : 02/19/01
507 //-----------------------------------------------------------------------------
509 {
510 
511  // Make sure we have a valid value here.
512  assert(value >= 0);
513  direction_ = value;
514 }
515 
516 //-----------------------------------------------------------------------------
517 // Function : NLParams::resetDirection
518 // Purpose : Accessor method to reset the default nonlinear direction
519 // flag.
520 // Special Notes :
521 // Scope : public
522 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
523 // Creation Date : 02/19/01
524 //-----------------------------------------------------------------------------
526 {
528 }
529 
530 //-----------------------------------------------------------------------------
531 // Function : NLParams::getDirection
532 // Purpose : Accessor method to return the nonlinear diection flag.
533 // Special Notes :
534 // Scope : public
535 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
536 // Creation Date : 02/19/01
537 //-----------------------------------------------------------------------------
539 {
540  return direction_;
541 }
542 
543 //-----------------------------------------------------------------------------
544 // Function : NLParams::setDeltaXTol
545 // Purpose : Accessor method to set the deltaX (update) tolerance.
546 // Special Notes : This is used in combination with a WRMS norm.
547 // Scope : public
548 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
549 // Creation Date : 01/20/01
550 //-----------------------------------------------------------------------------
551 inline void NLParams::setDeltaXTol(double value)
552 {
553  deltaXTol_ = value;
554 }
555 
556 //-----------------------------------------------------------------------------
557 // Function : NLParams::resetDeltaXTol
558 // Purpose : Accessor method to reset the deltaX (update) tolerance to
559 // the default value.
560 // Special Notes : This is used in combination with a WRMS norm.
561 // Scope : public
562 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
563 // Creation Date : 01/20/01
564 //-----------------------------------------------------------------------------
566 {
567  deltaXTol_ = 1.0;
568 }
569 
570 //-----------------------------------------------------------------------------
571 // Function : NLParams::getDeltaXTol
572 // Purpose : Accessor method to return the deltaX (update) tolerance
573 // Special Notes : This is used in combination with a WRMS norm.
574 // Scope : public
575 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
576 // Creation Date : 01/20/01
577 //-----------------------------------------------------------------------------
578 inline double NLParams::getDeltaXTol() const
579 {
580  return deltaXTol_;
581 }
582 
583 //-----------------------------------------------------------------------------
584 // Function : NLParams::setSmallUpdateTol
585 // Purpose :
586 // Special Notes :
587 // Scope : public
588 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
589 // Creation Date : 07/02/03
590 //-----------------------------------------------------------------------------
591 inline void NLParams::setSmallUpdateTol (double value)
592 {
594 }
595 
596 //-----------------------------------------------------------------------------
597 // Function : NLParams::resetSmallUpdateTol
598 // Purpose :
599 // Special Notes :
600 // Scope : public
601 // Creator : Eric R. Keiter, SNL, Computational Sciences
602 // Creation Date : 07/02/03
603 //-----------------------------------------------------------------------------
605 {
606  smallUpdateTol_ = 1.0e-6;
607 }
608 
609 //-----------------------------------------------------------------------------
610 // Function : NLParams::getSmallUpdateTol
611 // Purpose :
612 // Special Notes :
613 // Scope : public
614 // Creator : Eric R. Keiter, SNL, Computational Sciences
615 // Creation Date : 07/02/03
616 //-----------------------------------------------------------------------------
617 inline double NLParams::getSmallUpdateTol () const
618 {
619  return smallUpdateTol_;
620 }
621 
622 //-----------------------------------------------------------------------------
623 // Function : NLParams::setRHSTol
624 // Purpose : Accessor method to set the RHS (residual) tolerance.
625 // Special Notes : This is used in combination with a WRMS norm.
626 // Scope : public
627 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
628 // Creation Date : 01/24/01
629 //-----------------------------------------------------------------------------
630 inline void NLParams::setRHSTol(double value)
631 {
632  RHSTol_ = value;
633 }
634 
635 //-----------------------------------------------------------------------------
636 // Function : NLParams::resetRHSTol
637 // Purpose : Accessor method to reset the RHS (residual) tolerance to
638 // the default value.
639 // Special Notes : This is used in combination with a WRMS norm.
640 // Scope : public
641 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
642 // Creation Date : 01/24/01
643 //-----------------------------------------------------------------------------
645 {
646  RHSTol_ = 1.0e-06;
647 }
648 
649 //-----------------------------------------------------------------------------
650 // Function : NLParams::getRHSTol
651 // Purpose : Accessor method to return the RHS (residual) tolerance
652 // Special Notes : This is used in combination with a WRMS norm.
653 // Scope : public
654 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
655 // Creation Date : 01/24/01
656 //-----------------------------------------------------------------------------
657 inline double NLParams::getRHSTol() const
658 {
659  return RHSTol_;
660 }
661 
662 //-----------------------------------------------------------------------------
663 // Function : NLParams::setAbsTol
664 // Purpose : Accessor method to set the absTol tolerance.
665 // Special Notes :
666 // Scope : public
667 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
668 // Creation Date : 01/22/01
669 //-----------------------------------------------------------------------------
670 inline void NLParams::setAbsTol(double value)
671 {
672  absTol_ = value;
673 }
674 
675 //-----------------------------------------------------------------------------
676 // Function : NLParams::resetAbsTol
677 // Purpose : Accessor method to reset the absTol tolerance to
678 // the default value.
679 // Special Notes :
680 // Scope : public
681 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
682 // Creation Date : 01/21/01
683 //-----------------------------------------------------------------------------
685 {
686  absTol_ = 1.0e-12;
687 }
688 
689 //-----------------------------------------------------------------------------
690 // Function : NLParams::getAbsTol
691 // Purpose : Accessor method to return the absTol tolerance
692 // Special Notes :
693 // Scope : public
694 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
695 // Creation Date : 01/21/01
696 //-----------------------------------------------------------------------------
697 inline double NLParams::getAbsTol() const
698 {
699  return absTol_;
700 }
701 
702 //-----------------------------------------------------------------------------
703 // Function : NLParams::setRelTol
704 // Purpose : Accessor method to set the relTol tolerance.
705 // Special Notes :
706 // Scope : public
707 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
708 // Creation Date : 01/22/01
709 //-----------------------------------------------------------------------------
710 inline void NLParams::setRelTol(double value)
711 {
712  relTol_ = value;
713 }
714 
715 //-----------------------------------------------------------------------------
716 // Function : NLParams::resetRelTol
717 // Purpose : Accessor method to reset the relTol tolerance to
718 // the default value.
719 // Special Notes :
720 // Scope : public
721 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
722 // Creation Date : 01/21/01
723 //-----------------------------------------------------------------------------
725 {
726  relTol_ = 1.0e-03;
727 }
728 
729 //-----------------------------------------------------------------------------
730 // Function : NLParams::getRelTol
731 // Purpose : Accessor method to return the relTol tolerance
732 // Special Notes :
733 // Scope : public
734 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
735 // Creation Date : 01/21/01
736 //-----------------------------------------------------------------------------
737 inline double NLParams::getRelTol() const
738 {
739  return relTol_;
740 }
741 
742 //-----------------------------------------------------------------------------
743 // Function : NLParams::setMaxNewtonStep
744 // Purpose : Accessor method to set the maximum number of Newton steps.
745 // Special Notes :
746 // Scope : public
747 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
748 // Creation Date : 01/24/01
749 //-----------------------------------------------------------------------------
750 inline void NLParams::setMaxNewtonStep(unsigned value)
751 {
753 }
754 
755 //-----------------------------------------------------------------------------
756 // Function : NLParams::resetMaxNewtonStep
757 // Purpose : Accessor method to reset the maximum number of Newton steps
758 // to the default.
759 // Special Notes :
760 // Scope : public
761 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
762 // Creation Date : 01/24/01
763 //-----------------------------------------------------------------------------
765 {
766  maxNewtonStep_ = 200;
767 }
768 
769 //-----------------------------------------------------------------------------
770 // Function : NLParams::getMaxNewtonStep
771 // Purpose : Accessor method to get the maximum number of Newton steps.
772 // Special Notes :
773 // Scope : public
774 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
775 // Creation Date : 01/24/01
776 //-----------------------------------------------------------------------------
777 inline unsigned NLParams::getMaxNewtonStep() const
778 {
779  return maxNewtonStep_;
780 }
781 
782 //-----------------------------------------------------------------------------
783 // Function : NLParams::setMaxSearchStep
784 // Purpose : Accessor method to set the maximum number of line-search
785 // steps.
786 // Special Notes :
787 // Scope : public
788 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
789 // Creation Date : 01/24/01
790 //-----------------------------------------------------------------------------
791 inline void NLParams::setMaxSearchStep(unsigned value)
792 {
794 }
795 
796 //-----------------------------------------------------------------------------
797 // Function : NLParams::resetMaxSearchStep
798 // Purpose : Accessor method to reset the maximum number of line-search
799 // steps to the default.
800 // Special Notes :
801 // Scope : public
802 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
803 // Creation Date : 01/24/01
804 //-----------------------------------------------------------------------------
806 {
807  maxSearchStep_ = 9;
808 }
809 
810 //-----------------------------------------------------------------------------
811 // Function : NLParams::getMaxSearchStep
812 // Purpose : Accessor method to get the maximum number of line-search
813 // steps.
814 // Special Notes :
815 // Scope : public
816 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
817 // Creation Date : 01/24/01
818 //-----------------------------------------------------------------------------
819 inline unsigned NLParams::getMaxSearchStep() const
820 {
821  return maxSearchStep_;
822 }
823 
824 //-----------------------------------------------------------------------------
825 // Function : NLParams::setForcingFlag
826 // Purpose : Accessor method to set the inexact-Newton forcing flag.
827 // Special Notes :
828 // Scope : public
829 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
830 // Creation Date : 05/04/01
831 //-----------------------------------------------------------------------------
833 {
834 
835  // Reset the linear solver tolerance if we're switching forcing off
836  // NOTE: I couldn't get this to work because we're instantiating several
837  // NLParams objects and the one for which the lasSolverPtr is getting set
838  // isn't the one needed. I've found a work-around for now but we'll need to
839  // fix this - SAH, 6/25/01
840 // if (INForcingFlag_ && !value)
841 // lasSolverPtr_->resetTolerance();
842 
844 }
845 
846 //-----------------------------------------------------------------------------
847 // Function : NLParams::resetForcingFlag
848 // Purpose : Accessor method to reset the default inexact-Newton forcing
849 // flag.
850 // Special Notes :
851 // Scope : public
852 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
853 // Creation Date : 05/04/01
854 //-----------------------------------------------------------------------------
856 {
857  INForcingFlag_ = false;
858 }
859 
860 //-----------------------------------------------------------------------------
861 // Function : NLParams::getForcingFlag
862 // Purpose : Accessor method to get the inexact-Newton forcing flag.
863 // Special Notes :
864 // Scope : public
865 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
866 // Creation Date : 05/04/01
867 //-----------------------------------------------------------------------------
868 inline bool NLParams::getForcingFlag() const
869 {
870  return INForcingFlag_;
871 }
872 
873 //-----------------------------------------------------------------------------
874 // Function : NLParams::setEnforceDeviceConvFlag
875 // Purpose : Accessor method to set the inexact-Newton forcing term.
876 // Special Notes :
877 // Scope : public
878 // Creator : Eric R. Keiter, SNL, Computational Sciences
879 // Creation Date : 06/30/05
880 //-----------------------------------------------------------------------------
881 inline void NLParams::setEnforceDeviceConvFlag (bool flag)
882 {
883  enforceDeviceConvFlag_ = flag;
884 }
885 
886 //-----------------------------------------------------------------------------
887 // Function : NLParams::resetEnforceDeviceConvFlag
888 // Purpose : Accessor method to reset the default inexact-Newton forcing
889 // value.
890 // Special Notes :
891 // Scope : public
892 // Creator : Eric R. Keiter, SNL, Computational Sciences
893 // Creation Date : 06/30/05
894 //-----------------------------------------------------------------------------
896 {
897  enforceDeviceConvFlag_ = true;
898 }
899 
900 //-----------------------------------------------------------------------------
901 // Function : NLParams::getEnforceDeviceConvFlag
902 // Purpose : Accessor method to get the inexact-Newton forcing term.
903 // Special Notes :
904 // Scope : public
905 // Creator : Eric R. Keiter, SNL, Computational Sciences
906 // Creation Date : 06/30/05
907 //-----------------------------------------------------------------------------
909 {
910  return enforceDeviceConvFlag_;
911 }
912 
913 //-----------------------------------------------------------------------------
914 // Function : NLParams::setForcingTerm
915 // Purpose : Accessor method to set the inexact-Newton forcing term.
916 // Special Notes :
917 // Scope : public
918 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
919 // Creation Date : 07/29/01
920 //-----------------------------------------------------------------------------
921 inline void NLParams::setForcingTerm(double value)
922 {
923  eta_ = value;
924 }
925 
926 //-----------------------------------------------------------------------------
927 // Function : NLParams::resetForcingTerm
928 // Purpose : Accessor method to reset the default inexact-Newton forcing
929 // value.
930 // Special Notes :
931 // Scope : public
932 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
933 // Creation Date : 07/29/01
934 //-----------------------------------------------------------------------------
936 {
937  eta_ = 1.0e-01;
938 }
939 
940 //-----------------------------------------------------------------------------
941 // Function : NLParams::getForcingTerm
942 // Purpose : Accessor method to get the inexact-Newton forcing term.
943 // Special Notes :
944 // Scope : public
945 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
946 // Creation Date : 06/29/01
947 //-----------------------------------------------------------------------------
948 inline double NLParams::getForcingTerm() const
949 {
950  return eta_;
951 }
952 
953 //-----------------------------------------------------------------------------
954 // Function : NLParams::setNormLevel
955 // Purpose : Accessor method to set the lp norm level (p).
956 // Special Notes :
957 // Scope : public
958 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
959 // Creation Date : 01/24/01
960 //-----------------------------------------------------------------------------
962 {
963  normLevel_ = value;
964 }
965 
966 //-----------------------------------------------------------------------------
967 // Function : NLParams::resetNormLevel
968 // Purpose : Accessor method to reset the lp norm level (p) to the
969 // default value.
970 // Special Notes :
971 // Scope : public
972 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
973 // Creation Date : 01/24/01
974 //-----------------------------------------------------------------------------
976 {
977  normLevel_ = 2;
978 }
979 
980 //-----------------------------------------------------------------------------
981 // Function : NLParams::getNormLevel
982 // Purpose : Accessor method to return the lp norm level (p).
983 // Special Notes :
984 // Scope : public
985 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
986 // Creation Date : 01/24/01
987 //-----------------------------------------------------------------------------
988 inline int NLParams::getNormLevel() const
989 {
990  return normLevel_;
991 }
992 
993 //-----------------------------------------------------------------------------
994 // Function : NLParams::setLinearOpt
995 // Purpose : Accessor method to set the linear optimization flag.
996 // Special Notes :
997 // Scope : public
998 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
999 // Creation Date : 01/24/01
1000 //-----------------------------------------------------------------------------
1001 inline void NLParams::setLinearOpt(bool flag)
1002 {
1003  linearOptimization_ = flag;
1004 }
1005 
1006 //-----------------------------------------------------------------------------
1007 // Function : NLParams::resetLinearOpt
1008 // Purpose : Accessor method to reset the default linear optimization
1009 // flag.
1010 // Special Notes :
1011 // Scope : public
1012 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1013 // Creation Date : 01/24/01
1014 //-----------------------------------------------------------------------------
1016 {
1017  linearOptimization_ = 0;
1018 }
1019 
1020 //-----------------------------------------------------------------------------
1021 // Function : NLParams::getLinearOpt
1022 // Purpose : Accessor method to return the linear optimization flag.
1023 // Special Notes :
1024 // Scope : public
1025 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1026 // Creation Date : 01/24/01
1027 //-----------------------------------------------------------------------------
1028 inline bool NLParams::getLinearOpt() const
1029 {
1030  return linearOptimization_;
1031 }
1032 
1033 //-----------------------------------------------------------------------------
1034 // Function : NLParams::setConstraintBT
1035 // Purpose : Accessor method to set the constraint backtracking flag.
1036 // Special Notes :
1037 // Scope : public
1038 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1039 // Creation Date : 02/06/01
1040 //-----------------------------------------------------------------------------
1041 inline void NLParams::setConstraintBT(bool flag)
1042 {
1043  constraintBT_ = flag;
1044 }
1045 
1046 //-----------------------------------------------------------------------------
1047 // Function : NLParams::resetConstraintBT
1048 // Purpose : Accessor method to reset the default constraint backtracking
1049 // flag.
1050 // Special Notes :
1051 // Scope : public
1052 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1053 // Creation Date : 02/06/01
1054 //-----------------------------------------------------------------------------
1056 {
1057  constraintBT_ = 0;
1058 }
1059 
1060 //-----------------------------------------------------------------------------
1061 // Function : NLParams::getConstraintBT
1062 // Purpose : Accessor method to return the constraint backtracking flag.
1063 // Special Notes :
1064 // Scope : public
1065 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1066 // Creation Date : 02/06/01
1067 //-----------------------------------------------------------------------------
1068 inline bool NLParams::getConstraintBT() const
1069 {
1070  return constraintBT_;
1071 }
1072 
1073 //-----------------------------------------------------------------------------
1074 // Function : NLParams::setGlobalBTMax
1075 // Purpose : Accessor method to set the constraint maximum value.
1076 // Special Notes :
1077 // Scope : public
1078 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1079 // Creation Date : 02/14/01
1080 //-----------------------------------------------------------------------------
1081 inline void NLParams::setGlobalBTMax(double value)
1082 {
1083  globalBTMax_ = value;
1084 }
1085 
1086 //-----------------------------------------------------------------------------
1087 // Function : NLParams::resetGlobalBTMax
1088 // Purpose : Accessor method to set the constraint maximum default value.
1089 // Special Notes :
1090 // Scope : public
1091 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1092 // Creation Date : 02/14/01
1093 //-----------------------------------------------------------------------------
1095 {
1096  globalBTMax_ = Util::MachineDependentParams::DoubleMax();
1097 }
1098 
1099 //-----------------------------------------------------------------------------
1100 // Function : NLParams::getGlobalBTMax
1101 // Purpose : Accessor method to return the constraint maximum value.
1102 // Special Notes :
1103 // Scope : public
1104 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1105 // Creation Date : 02/14/01
1106 //-----------------------------------------------------------------------------
1107 inline double NLParams::getGlobalBTMax() const
1108 {
1109  return globalBTMax_;
1110 }
1111 
1112 //-----------------------------------------------------------------------------
1113 // Function : NLParams::setGlobalBTMin
1114 // Purpose : Accessor method to set the constraint minimum value.
1115 // Special Notes :
1116 // Scope : public
1117 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1118 // Creation Date : 02/14/01
1119 //-----------------------------------------------------------------------------
1120 inline void NLParams::setGlobalBTMin(double value)
1121 {
1122  globalBTMin_ = value;
1123 }
1124 
1125 //-----------------------------------------------------------------------------
1126 // Function : NLParams::resetGlobalBTMin
1127 // Purpose : Accessor method to set the constraint minimum default value.
1128 // Special Notes :
1129 // Scope : public
1130 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1131 // Creation Date : 02/14/01
1132 //-----------------------------------------------------------------------------
1134 {
1135  globalBTMin_ = -Util::MachineDependentParams::DoubleMax();
1136 }
1137 
1138 //-----------------------------------------------------------------------------
1139 // Function : NLParams::getGlobalBTMin
1140 // Purpose : Accessor method to return the constraint minimum value.
1141 // Special Notes :
1142 // Scope : public
1143 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1144 // Creation Date : 02/14/01
1145 //-----------------------------------------------------------------------------
1146 inline double NLParams::getGlobalBTMin() const
1147 {
1148  return globalBTMin_;
1149 }
1150 
1151 //-----------------------------------------------------------------------------
1152 // Function : NLParams::setGlobalBTChange
1153 // Purpose : Accessor method to set the constraint percentage change
1154 // value.
1155 // Special Notes :
1156 // Scope : public
1157 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1158 // Creation Date : 02/14/01
1159 //-----------------------------------------------------------------------------
1161 {
1163 }
1164 
1165 //-----------------------------------------------------------------------------
1166 // Function : NLParams::resetGlobalBTChange
1167 // Purpose : Accessor method to set the constraint percentage change
1168 // default value.
1169 // Special Notes :
1170 // Scope : public
1171 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1172 // Creation Date : 02/14/01
1173 //-----------------------------------------------------------------------------
1175 {
1176  globalBTChange_ = sqrt(Util::MachineDependentParams::DoubleMax());
1177 }
1178 
1179 //-----------------------------------------------------------------------------
1180 // Function : NLParams::getGlobalBTChange
1181 // Purpose : Accessor method to return the constraint percentage change
1182 // value.
1183 // Special Notes :
1184 // Scope : public
1185 // Creator : Scott A. Hutchinson, SNL, Computational Sciences
1186 // Creation Date : 02/14/01
1187 //-----------------------------------------------------------------------------
1188 inline double NLParams::getGlobalBTChange() const
1189 {
1190  return globalBTChange_;
1191 }
1192 
1193 //-----------------------------------------------------------------------------
1194 // Function : NLParams::setDebugLevel
1195 // Purpose :
1196 // Special Notes :
1197 // Scope : public
1198 // Creator : Eric R. Keiter, SNL, Computational Sciences
1199 // Creation Date : 09/23/01
1200 //-----------------------------------------------------------------------------
1202 {
1203  debugLevel_ = value;
1204  setNonlinearDebugLevel(value);
1205 }
1206 
1207 //-----------------------------------------------------------------------------
1208 // Function : NLParams::resetDebugLevel
1209 // Purpose :
1210 // Special Notes :
1211 // Scope : public
1212 // Creator : Eric R. Keiter, SNL, Computational Sciences
1213 // Creation Date : 09/23/01
1214 //-----------------------------------------------------------------------------
1216 {
1217  debugLevel_ = 1;
1218 }
1219 
1220 //-----------------------------------------------------------------------------
1221 // Function : NLParams::getDebugLevel
1222 // Purpose :
1223 // Special Notes :
1224 // Scope : public
1225 // Creator : Eric R. Keiter, SNL, Computational Sciences
1226 // Creation Date : 09/23/01
1227 //-----------------------------------------------------------------------------
1228 inline int NLParams::getDebugLevel() const
1229 {
1230  return debugLevel_;
1231 }
1232 
1233 
1234 //-----------------------------------------------------------------------------
1235 // Function : NLParams::setDebugMinTimeStep
1236 // Purpose :
1237 // Special Notes :
1238 // Scope : public
1239 // Creator : Eric R. Keiter, SNL, Computational Sciences
1240 // Creation Date : 09/23/01
1241 //-----------------------------------------------------------------------------
1243 {
1245 }
1246 
1247 //-----------------------------------------------------------------------------
1248 // Function : NLParams::resetDebugMinTimeStep
1249 // Purpose :
1250 // Special Notes :
1251 // Scope : public
1252 // Creator : Eric R. Keiter, SNL, Computational Sciences
1253 // Creation Date : 09/23/01
1254 //-----------------------------------------------------------------------------
1256 {
1257  debugMinTimeStep_ = 0;
1258 }
1259 
1260 //-----------------------------------------------------------------------------
1261 // Function : NLParams::getDebugMinTimeStep
1262 // Purpose :
1263 // Special Notes :
1264 // Scope : public
1265 // Creator : Eric R. Keiter, SNL, Computational Sciences
1266 // Creation Date : 09/23/01
1267 //-----------------------------------------------------------------------------
1269 {
1270  return debugMinTimeStep_;
1271 }
1272 
1273 //-----------------------------------------------------------------------------
1274 // Function : NLParams::setDebugMaxTimeStep
1275 // Purpose :
1276 // Special Notes :
1277 // Scope : public
1278 // Creator : Eric R. Keiter, SNL, Computational Sciences
1279 // Creation Date : 09/23/01
1280 //-----------------------------------------------------------------------------
1282 {
1284 }
1285 
1286 //-----------------------------------------------------------------------------
1287 // Function : NLParams::resetDebugMaxTimeStep
1288 // Purpose :
1289 // Special Notes :
1290 // Scope : public
1291 // Creator : Eric R. Keiter, SNL, Computational Sciences
1292 // Creation Date : 09/23/01
1293 //-----------------------------------------------------------------------------
1295 {
1296  debugMaxTimeStep_ = Util::MachineDependentParams::IntMax();
1297 }
1298 
1299 //-----------------------------------------------------------------------------
1300 // Function : NLParams::getDebugMaxTimeStep
1301 // Purpose :
1302 // Special Notes :
1303 // Scope : public
1304 // Creator : Eric R. Keiter, SNL, Computational Sciences
1305 // Creation Date : 09/23/01
1306 //-----------------------------------------------------------------------------
1308 {
1309  return debugMaxTimeStep_;
1310 }
1311 
1312 //-----------------------------------------------------------------------------
1313 // Function : NLParams::setDebugMinTime
1314 // Purpose :
1315 // Special Notes :
1316 // Scope : public
1317 // Creator : Eric R. Keiter, SNL, Computational Sciences
1318 // Creation Date : 09/23/01
1319 //-----------------------------------------------------------------------------
1321 {
1322  debugMinTime_ = value;
1323 }
1324 
1325 //-----------------------------------------------------------------------------
1326 // Function : NLParams::resetDebugMinTime
1327 // Purpose :
1328 // Special Notes :
1329 // Scope : public
1330 // Creator : Eric R. Keiter, SNL, Computational Sciences
1331 // Creation Date : 09/23/01
1332 //-----------------------------------------------------------------------------
1334 {
1335  debugMinTime_ = 0.0;
1336 }
1337 
1338 //-----------------------------------------------------------------------------
1339 // Function : NLParams::getDebugMinTime
1340 // Purpose :
1341 // Special Notes :
1342 // Scope : public
1343 // Creator : Eric R. Keiter, SNL, Computational Sciences
1344 // Creation Date : 09/23/01
1345 //-----------------------------------------------------------------------------
1346 inline double NLParams::getDebugMinTime() const
1347 {
1348  return debugMinTime_;
1349 }
1350 
1351 //-----------------------------------------------------------------------------
1352 // Function : NLParams::setDebugMaxTime
1353 // Purpose :
1354 // Special Notes :
1355 // Scope : public
1356 // Creator : Eric R. Keiter, SNL, Computational Sciences
1357 // Creation Date : 09/23/01
1358 //-----------------------------------------------------------------------------
1360 {
1361  debugMaxTime_ = value;
1362 }
1363 
1364 //-----------------------------------------------------------------------------
1365 // Function : NLParams::resetDebugMaxTime
1366 // Purpose :
1367 // Special Notes :
1368 // Scope : public
1369 // Creator : Eric R. Keiter, SNL, Computational Sciences
1370 // Creation Date : 09/23/01
1371 //-----------------------------------------------------------------------------
1373 {
1374  debugMaxTime_ = Util::MachineDependentParams::DoubleMax();
1375 }
1376 
1377 //-----------------------------------------------------------------------------
1378 // Function : NLParams::getDebugMaxTime
1379 // Purpose :
1380 // Special Notes :
1381 // Scope : public
1382 // Creator : Eric R. Keiter, SNL, Computational Sciences
1383 // Creation Date : 09/23/01
1384 //-----------------------------------------------------------------------------
1385 inline double NLParams::getDebugMaxTime() const
1386 {
1387  return debugMaxTime_;
1388 }
1389 
1390 //-----------------------------------------------------------------------------
1391 // Function : NLParams::setScreenOutputFlag
1392 // Purpose :
1393 // Special Notes :
1394 // Scope : public
1395 // Creator : Eric R. Keiter, SNL, Computational Sciences
1396 // Creation Date : 04/25/04
1397 //-----------------------------------------------------------------------------
1398 inline void NLParams::setScreenOutputFlag (bool bval)
1399 {
1400  screenOutputFlag_ = bval;
1401 }
1402 
1403 //-----------------------------------------------------------------------------
1404 // Function : NLParams::resetScreenOutputFlag
1405 // Purpose :
1406 // Special Notes :
1407 // Scope : public
1408 // Creator : Eric R. Keiter, SNL, Computational Sciences
1409 // Creation Date : 04/25/04
1410 //-----------------------------------------------------------------------------
1412 {
1413  screenOutputFlag_ = false;
1414 }
1415 
1416 //-----------------------------------------------------------------------------
1417 // Function : NLParams::getScreenOutputFlag
1418 // Purpose :
1419 // Special Notes :
1420 // Scope : public
1421 // Creator : Eric R. Keiter, SNL, Computational Sciences
1422 // Creation Date : 04/25/04
1423 //-----------------------------------------------------------------------------
1424 inline bool NLParams::getScreenOutputFlag () const
1425 {
1426  return screenOutputFlag_;
1427 }
1428 
1429 //-----------------------------------------------------------------------------
1430 // Function : NLParams::setMaskingFlag
1431 // Purpose :
1432 // Special Notes :
1433 // Scope : public
1434 // Creator : Eric R. Keiter, SNL, Computational Sciences
1435 // Creation Date : 10/31/2014
1436 //-----------------------------------------------------------------------------
1437 inline void NLParams::setMaskingFlag (bool bval)
1438 {
1439  maskingFlag_ = bval;
1440 }
1441 
1442 //-----------------------------------------------------------------------------
1443 // Function : NLParams::resetMaskingFlag
1444 // Purpose :
1445 // Special Notes :
1446 // Scope : public
1447 // Creator : Eric R. Keiter, SNL, Computational Sciences
1448 // Creation Date : 10/31/2014
1449 //-----------------------------------------------------------------------------
1451 {
1452  maskingFlag_ = false;
1453 }
1454 
1455 //-----------------------------------------------------------------------------
1456 // Function : NLParams::getMaskingFlag
1457 // Purpose :
1458 // Special Notes :
1459 // Scope : public
1460 // Creator : Eric R. Keiter, SNL, Computational Sciences
1461 // Creation Date : 10/31/2014
1462 //-----------------------------------------------------------------------------
1463 inline bool NLParams::getMaskingFlag () const
1464 {
1465  return maskingFlag_;
1466 }
1467 
1468 //-----------------------------------------------------------------------------
1469 // Function : NLParams::setMMFormat
1470 // Purpose :
1471 // Special Notes :
1472 // Scope : public
1473 // Creator : Eric R. Keiter, SNL, Computational Sciences
1474 // Creation Date :
1475 //-----------------------------------------------------------------------------
1476 inline void NLParams::setMMFormat(bool value)
1477 {
1479 }
1480 
1481 //-----------------------------------------------------------------------------
1482 // Function : NLParams::resetMMFormat
1483 // Purpose :
1484 // Special Notes :
1485 // Scope : public
1486 // Creator : Eric R. Keiter, SNL, Computational Sciences
1487 // Creation Date :
1488 //-----------------------------------------------------------------------------
1490 {
1491  matrixMarketFormat_=false;
1492 }
1493 
1494 //-----------------------------------------------------------------------------
1495 // Function : NLParams::getMMFormat
1496 // Purpose :
1497 // Special Notes :
1498 // Scope : public
1499 // Creator : Eric R. Keiter, SNL, Computational Sciences
1500 // Creation Date :
1501 //-----------------------------------------------------------------------------
1502 inline bool NLParams::getMMFormat() const
1503 {
1504  return matrixMarketFormat_;
1505 }
1506 
1507 } // namespace Nonlinear
1508 } // namespace Xyce
1509 
1510 #endif // Xyce_N_NLS_NLParams_h
void setForcingFlag(bool flag)
void setSearchMethod(LineSearchMethod method)
void setGlobalBTMin(double value)
Pure virtual class to augment a linear system.
double getSmallUpdateTol() const
void setForcingTerm(double value)
void setDebugMinTime(double value)
unsigned getMaxNewtonStep() const
void setMaxSearchStep(unsigned maxSearchStep)
void setSmallUpdateTol(double Tolerance)
void setScreenOutputFlag(bool bval)
void setEnforceDeviceConvFlag(bool flag)
void setNLStrategy(NLStrategy strategy)
const T & value(const ParameterBase &entity, const Descriptor &descriptor)
Returns the value of the parameter for the entity.
Definition: N_DEV_Pars.h:1224
void setConstraintBT(bool flag)
NLParams(AnalysisMode mode, const IO::CmdParse &cp)
double getDebugMinTime() const
double getGlobalBTChange() const
void setDebugMinTimeStep(int value)
double getGlobalBTMax() const
void setGlobalBTChange(double value)
Direction getDirection() const
LineSearchMethod getSearchMethod() const
double getForcingTerm() const
void setDeltaXTol(double Tolerance)
NLParams & operator=(const NLParams &right)
bool getScreenOutputFlag() const
LineSearchMethod searchMethod_
void setDirection(Direction value)
double getDebugMaxTime() const
void setRelTol(double Tolerance)
void setDebugLevel(int value)
void setMaskingFlag(bool bval)
void setDebugMaxTimeStep(int value)
void setNormLevel(int level)
void setAbsTol(double Tolerance)
void setGlobalBTMax(double value)
const IO::CmdParse * commandLine_
void setMMFormat(bool value)
double getDeltaXTol() const
void printParams(std::ostream &os)
void setLinearOpt(bool flag)
void setMaxNewtonStep(unsigned maxNewtonStep)
double getGlobalBTMin() const
NLStrategy getNLStrategy() const
bool getPrintParamsFlag() const
bool setOptions(const Util::OptionBlock &OB)
void setRHSTol(double Tolerance)
bool getEnforceDeviceConvFlag() const
void setDebugMaxTime(double value)
unsigned getMaxSearchStep() const