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