GEOS
CoupledSolver.hpp
Go to the documentation of this file.
1 /*
2  * ------------------------------------------------------------------------------------------------------------
3  * SPDX-License-Identifier: LGPL-2.1-only
4  *
5  * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
6  * Copyright (c) 2018-2024 TotalEnergies
7  * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
8  * Copyright (c) 2023-2024 Chevron
9  * Copyright (c) 2019- GEOS/GEOSX Contributors
10  * All rights reserved
11  *
12  * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
13  * ------------------------------------------------------------------------------------------------------------
14  */
15 
21 #ifndef GEOS_PHYSICSSOLVERS_MULTIPHYSICS_COUPLEDSOLVER_HPP_
22 #define GEOS_PHYSICSSOLVERS_MULTIPHYSICS_COUPLEDSOLVER_HPP_
23 
26 
27 #include <tuple>
28 
29 namespace geos
30 {
31 
32 template< typename ... SOLVERS >
34 {
35 
36 public:
37 
43  CoupledSolver( const string & name,
44  Group * const parent )
45  : PhysicsSolverBase( name, parent )
46  {
47  forEachArgInTuple( m_solvers, [&]( auto solver, auto idx )
48  {
49  using SolverType = TYPEOFPTR( solver );
50  string const key = SolverType::coupledSolverAttributePrefix() + "SolverName";
51  registerWrapper( key, &m_names[idx()] ).
52  setRTTypeName( rtTypes::CustomTypes::groupNameRef ).
54  setDescription( "Name of the " + SolverType::coupledSolverAttributePrefix() + " solver used by the coupled solver" );
55  } );
56 
57  this->getWrapper< string >( PhysicsSolverBase::viewKeyStruct::discretizationString() ).
58  setInputFlag( dataRepository::InputFlags::FALSE );
59 
60  addLogLevel< logInfo::Coupling >();
61  }
62 
64  CoupledSolver( CoupledSolver const & ) = delete;
65 
67  CoupledSolver( CoupledSolver && ) = default;
68 
70  CoupledSolver & operator=( CoupledSolver const & ) = delete;
71 
74 
75 
79  void
81  {
82  forEachArgInTuple( m_solvers, [&]( auto & solver, auto idx )
83  {
84  using SolverPtr = TYPEOFREF( solver );
85  using SolverType = TYPEOFPTR( SolverPtr {} );
86  auto const & solverName = m_names[idx()];
87  auto const & solverType = LvArray::system::demangleType< SolverType >();
88  solver = this->getParent().template getGroupPointer< SolverType >( solverName );
89  GEOS_THROW_IF( solver == nullptr,
90  GEOS_FMT( "{}: Could not find solver '{}' of type {}",
92  solverName, solverType ),
93  InputError );
94  GEOS_LOG_LEVEL_RANK_0( logInfo::Coupling,
95  GEOS_FMT( "{}: found {} solver named {}",
96  getName(), solver->getCatalogName(), solverName ) );
97  } );
98  }
99 
100 
106  virtual void
108  DofManager & dofManager ) const
109  { GEOS_UNUSED_VAR( domain, dofManager ); }
110 
120  virtual void
122  real64 const dt,
123  DomainPartition const & domain,
124  DofManager const & dofManager,
125  CRSMatrixView< real64, globalIndex const > const & localMatrix,
126  arrayView1d< real64 > const & localRhs )
127  { GEOS_UNUSED_VAR( time_n, dt, domain, dofManager, localMatrix, localRhs ); }
128 
136  void
137  setupDofs( DomainPartition const & domain,
138  DofManager & dofManager ) const override
139  {
140  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
141  {
142  solver->setupDofs( domain, dofManager );
143  } );
144 
145  setupCoupling( domain, dofManager );
146  }
147 
148  virtual void
149  implicitStepSetup( real64 const & time_n,
150  real64 const & dt,
151  DomainPartition & domain ) override
152  {
153  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
154  {
155  solver->implicitStepSetup( time_n, dt, domain );
156  } );
157  }
158 
159  virtual void
160  implicitStepComplete( real64 const & time_n,
161  real64 const & dt,
162  DomainPartition & domain ) override
163  {
164  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
165  {
166  solver->implicitStepComplete( time_n, dt, domain );
167  } );
168  }
169 
170  // general version of assembleSystem function, keep in mind many solvers will override it
171  virtual void
172  assembleSystem( real64 const time_n,
173  real64 const dt,
174  DomainPartition & domain,
175  DofManager const & dofManager,
176  CRSMatrixView< real64, globalIndex const > const & localMatrix,
177  arrayView1d< real64 > const & localRhs ) override
178  {
180 
181  // 1. Assemble matrix blocks of each individual solver
182  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
183  {
184  solver->assembleSystem( time_n, dt, domain, dofManager, localMatrix, localRhs );
185  } );
186 
187  // 2. Assemble coupling blocks
188  assembleCouplingTerms( time_n, dt, domain, dofManager, localMatrix, localRhs );
189  }
190 
191  virtual void
192  applySystemSolution( DofManager const & dofManager,
193  arrayView1d< real64 const > const & localSolution,
194  real64 const scalingFactor,
195  real64 const dt,
196  DomainPartition & domain ) override
197  {
198  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
199  {
200  solver->applySystemSolution( dofManager, localSolution, scalingFactor, dt, domain );
201  } );
202  }
203 
204  virtual void
205  updateState( DomainPartition & domain ) override
206  {
207  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
208  {
209  solver->updateState( domain );
210  } );
211  }
212 
213  virtual void
215  {
216  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
217  {
218  solver->resetStateToBeginningOfStep( domain );
219  } );
220  }
221 
224  real64
225  solverStep( real64 const & time_n,
226  real64 const & dt,
227  int const cycleNumber,
228  DomainPartition & domain ) override final
229  {
231 
233  {
234  return fullyCoupledSolverStep( time_n, dt, cycleNumber, domain );
235  }
237  {
238  return sequentiallyCoupledSolverStep( time_n, dt, cycleNumber, domain );
239  }
240  else
241  {
242  GEOS_ERROR( getDataContext() << ": Invalid coupling type option." );
243  return 0;
244  }
245 
246  }
247 
248 
249  virtual void
250  updateAndWriteConvergenceStep( real64 const & time_n, real64 const & dt,
251  integer const cycleNumber, integer const iteration ) override
252  {
253  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
254  {
255  if( m_writeStatisticsCSV >= 2 )
256  {
257  solver->updateAndWriteConvergenceStep( time_n, dt, cycleNumber, iteration );
258  }
259  } );
260  }
261 
262  virtual real64
263  calculateResidualNorm( real64 const & time_n,
264  real64 const & dt,
265  DomainPartition const & domain,
266  DofManager const & dofManager,
267  arrayView1d< real64 const > const & localRhs ) override
268  {
269  real64 norm = 0.0;
270  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
271  {
272  real64 const singlePhysicsNorm = solver->calculateResidualNorm( time_n, dt, domain, dofManager, localRhs );
273  norm += singlePhysicsNorm * singlePhysicsNorm;
274  } );
275 
276  return sqrt( norm );
277  }
278 
279  virtual void
281  real64 const dt,
282  DomainPartition & domain,
283  DofManager const & dofManager,
284  CRSMatrixView< real64, globalIndex const > const & localMatrix,
285  arrayView1d< real64 > const & localRhs ) override
286  {
287  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
288  {
289  solver->applyBoundaryConditions( time_n, dt, domain, dofManager, localMatrix, localRhs );
290  } );
291  }
292 
293  virtual bool
295  DofManager const & dofManager,
296  arrayView1d< real64 const > const & localSolution,
297  real64 const scalingFactor ) override
298  {
299  bool validSolution = true;
300  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
301  {
302  bool const validSinglePhysicsSolution = solver->checkSystemSolution( domain, dofManager, localSolution, scalingFactor );
303  if( !validSinglePhysicsSolution )
304  {
305  GEOS_LOG_RANK_0( GEOS_FMT( " {}/{}: Solution check failed. Newton loop terminated.", getName(), solver->getName()) );
306  }
307  validSolution = validSolution && validSinglePhysicsSolution;
308  } );
309  return validSolution;
310  }
311 
312  virtual real64
314  DofManager const & dofManager,
315  arrayView1d< real64 const > const & localSolution ) override
316  {
317  real64 scalingFactor = PhysicsSolverBase::scalingForSystemSolution( domain, dofManager, localSolution );
318  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
319  {
320  real64 const singlePhysicsScalingFactor = solver->scalingForSystemSolution( domain, dofManager, localSolution );
321  scalingFactor = LvArray::math::min( scalingFactor, singlePhysicsScalingFactor );
322  } );
323  return scalingFactor;
324  }
325 
326  virtual real64
327  setNextDt( real64 const & currentTime,
328  real64 const & currentDt,
329  DomainPartition & domain ) override
330  {
331  real64 nextDt = PhysicsSolverBase::setNextDt( currentTime, currentDt, domain );
332  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
333  {
334  real64 const singlePhysicsNextDt =
335  solver->setNextDt( currentTime, currentDt, domain );
336  nextDt = LvArray::math::min( singlePhysicsNextDt, nextDt );
337  } );
338  return nextDt;
339  }
340 
341  virtual void cleanup( real64 const time_n,
342  integer const cycleNumber,
343  integer const eventCounter,
344  real64 const eventProgress,
345  DomainPartition & domain ) override
346  {
347  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
348  {
349  solver->cleanup( time_n, cycleNumber, eventCounter, eventProgress, domain );
350  } );
351  PhysicsSolverBase::cleanup( time_n, cycleNumber, eventCounter, eventProgress, domain );
352  }
353 
356  virtual bool checkSequentialSolutionIncrements( DomainPartition & domain ) const override
357  {
358  bool isConverged = true;
359  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
360  {
361  isConverged &= solver->checkSequentialSolutionIncrements( domain );
362  } );
363  return isConverged;
364  }
365 
366  virtual bool updateConfiguration( DomainPartition & domain,
367  integer const configurationLoopIter ) override
368  {
369  bool result = true;
370  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
371  {
372  result &= solver->updateConfiguration( domain, configurationLoopIter );
373  } );
374  return result;
375  }
376 
377  virtual void outputConfigurationStatistics( DomainPartition const & domain ) const override
378  {
379  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
380  {
381  solver->outputConfigurationStatistics( domain );
382  } );
383  }
384 
385  virtual void resetConfigurationToBeginningOfStep( DomainPartition & domain ) override
386  {
387  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
388  {
389  solver->resetConfigurationToBeginningOfStep( domain );
390  } );
391  }
392 
393  virtual bool resetConfigurationToDefault( DomainPartition & domain ) const override
394  {
395  bool result = true;
396  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
397  {
398  result &= solver->resetConfigurationToDefault( domain );
399  } );
400  return result;
401  }
402 
403 protected:
404 
414  virtual real64 fullyCoupledSolverStep( real64 const & time_n,
415  real64 const & dt,
416  int const cycleNumber,
417  DomainPartition & domain )
418  {
419  return PhysicsSolverBase::solverStep( time_n, dt, cycleNumber, domain );
420  }
421 
432  virtual real64 sequentiallyCoupledSolverStep( real64 const & time_n,
433  real64 const & dt,
434  integer const cycleNumber,
435  DomainPartition & domain )
436  {
438 
439  // Only build the sparsity pattern if the mesh has changed
440  Timestamp const meshModificationTimestamp = getMeshModificationTimestamp( domain );
441  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
442  {
443  if( meshModificationTimestamp > solver->getSystemSetupTimestamp() )
444  {
445  solver->setupSystem( domain,
446  solver->getDofManager(),
447  solver->getLocalMatrix(),
448  solver->getSystemRhs(),
449  solver->getSystemSolution() );
450  solver->setSystemSetupTimestamp( meshModificationTimestamp );
451  }
452  } );
453 
454  implicitStepSetup( time_n, dt, domain );
455 
457  integer const maxNumberDtCuts = solverParams.m_maxTimeStepCuts;
458  real64 const dtCutFactor = solverParams.m_timeStepCutFactor;
459  integer & dtAttempt = solverParams.m_numTimeStepAttempts;
460 
461  bool isConverged = false;
462  // dt may be cut during the course of this step, so we are keeping a local
463  // value to track the achieved dt for this step.
464  real64 stepDt = dt;
465 
466  // outer loop attempts to apply full timestep, and managed the cutting of the timestep if
467  // required.
468  for( dtAttempt = 0; dtAttempt < maxNumberDtCuts; ++dtAttempt )
469  {
470  // TODO configuration loop
471 
472  // Reset the states of all solvers if any of them had to restart
473  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
474  {
475  solver->resetStateToBeginningOfStep( domain );
476  solver->getIterationStats().resetCurrentTimeStepStatistics(); // initialize counters for subsolvers
477  } );
478  resetStateToBeginningOfStep( domain );
479 
480  integer & iter = solverParams.m_numNewtonIterations;
481 
483  for( iter = 0; iter < solverParams.m_maxIterNewton; iter++ )
484  {
485  // Increment the solver statistics for reporting purposes
487 
488  startSequentialIteration( iter, domain );
489 
490  // Solve the subproblems nonlinearly
491  forEachArgInTuple( m_solvers, [&]( auto & solver, auto idx )
492  {
493  GEOS_LOG_LEVEL_RANK_0( logInfo::NonlinearSolver,
494  GEOS_FMT( " Iteration {:2}: {}", iter + 1, solver->getName() ) );
495  real64 solverDt = solver->nonlinearImplicitStep( time_n,
496  stepDt,
497  cycleNumber,
498  domain );
499 
500  // save fields (e.g. pressure and temperature) after inner solve
501  if( solver->getNonlinearSolverParameters().couplingType() == NonlinearSolverParameters::CouplingType::Sequential )
502  {
503  solver->saveSequentialIterationState( domain );
504  }
505 
506  mapSolutionBetweenSolvers( domain, idx() );
507 
508  if( solverDt < stepDt ) // subsolver had to cut the time step
509  {
510  iter = 0; // restart outer loop
511  stepDt = solverDt; // sync time step
513  }
514  } );
515  // Check convergence of the outer loop
516  isConverged = checkSequentialConvergence( cycleNumber,
517  iter,
518  time_n,
519  stepDt,
520  domain );
521 
522  if( isConverged )
523  {
524  // we still want to count current iteration
525  ++iter;
526  // exit outer loop
527  break;
528  }
529  else
530  {
531  finishSequentialIteration( iter, domain );
532  }
533  }
534 
535  if( isConverged )
536  {
537  // Save time step statistics for the subsolvers
538  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
539  {
540  solver->getIterationStats().iterateTimeStepStatistics();
541  } );
542  // get out of the time loop
543  break;
544  }
545  else
546  {
547  // cut timestep, go back to beginning of step and restart the Newton loop
548  stepDt *= dtCutFactor;
550  GEOS_LOG_LEVEL_RANK_0( logInfo::TimeStep, GEOS_FMT( "New dt = {}", stepDt ) );
551 
552  // notify the solver statistics counter that this is a time step cut
554  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
555  {
556  solver->getIterationStats().updateTimeStepCut();
557  } );
558  }
559  }
560 
561  if( !isConverged )
562  {
563  GEOS_LOG_RANK_0( "Convergence not achieved." );
564 
566  {
567  GEOS_LOG_RANK_0( "The accepted solution may be inaccurate." );
568  }
569  else
570  {
571  GEOS_ERROR( "Nonconverged solutions not allowed. Terminating..." );
572  }
573  }
574 
575  implicitStepComplete( time_n, stepDt, domain );
576 
577  return stepDt;
578  }
579 
587  integer const solverType )
588  {
589  GEOS_UNUSED_VAR( domain, solverType );
590  }
591 
592  virtual bool checkSequentialConvergence( integer const cycleNumber,
593  integer const iter,
594  real64 const & time_n,
595  real64 const & dt,
596  DomainPartition & domain )
597  {
599  bool isConverged = true;
600 
601  if( params.m_subcyclingOption == 0 )
602  {
603  GEOS_LOG_LEVEL_RANK_0( logInfo::Convergence, "***** Single Pass solver, no subcycling *****" );
604  }
605  else
606  {
607  GEOS_LOG_LEVEL_RANK_0( logInfo::Convergence, GEOS_FMT( " Iteration {:2}: outer-loop convergence check", iter + 1 ) );
608 
610  {
611  real64 residualNorm = 0;
612 
613  // loop over all the single-physics solvers
614  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
615  {
616 
617  solver->getLocalMatrix().toViewConstSizes().zero();
618  solver->getSystemRhs().zero();
619  arrayView1d< real64 > const localRhs = solver->getSystemRhs().open();
620 
621  // for each solver, we have to recompute the residual (and Jacobian, although not necessary)
622  solver->assembleSystem( time_n,
623  dt,
624  domain,
625  solver->getDofManager(),
626  solver->getLocalMatrix().toViewConstSizes(),
627  localRhs );
628  solver->applyBoundaryConditions( time_n,
629  dt,
630  domain,
631  solver->getDofManager(),
632  solver->getLocalMatrix().toViewConstSizes(),
633  localRhs );
634  solver->getSystemRhs().close();
635 
636  // once this is done, we recompute the single-physics residual
637  real64 const singlePhysicsNorm =
638  solver->calculateResidualNorm( time_n,
639  dt,
640  domain,
641  solver->getDofManager(),
642  solver->getSystemRhs().values() );
643  residualNorm += singlePhysicsNorm * singlePhysicsNorm;
644  } );
645 
646  // finally, we perform the convergence check on the multiphysics residual
647  residualNorm = sqrt( residualNorm );
648  GEOS_LOG_LEVEL_RANK_0( logInfo::ResidualNorm,
649  GEOS_FMT( " ( R ) = ( {:4.2e} )", residualNorm ) );
650  getConvergenceStats().setResidualValue( "R", residualNorm );
651  updateAndWriteConvergenceStep( time_n, dt, cycleNumber, iter );
652 
653  isConverged = ( residualNorm < params.m_newtonTol );
654 
655  }
657  {
658  // TODO also make recursive?
659  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
660  {
661  NonlinearSolverParameters const & singlePhysicsParams = solver->getNonlinearSolverParameters();
662  if( singlePhysicsParams.m_numNewtonIterations > singlePhysicsParams.m_minIterNewton )
663  {
664  isConverged = false;
665  }
666  } );
667  }
669  {
670  isConverged = checkSequentialSolutionIncrements( domain );
671  }
672  else
673  {
674  GEOS_ERROR( getDataContext() << ": Invalid sequential convergence criterion." );
675  }
676 
677  if( isConverged )
678  {
679  GEOS_LOG_LEVEL_RANK_0( logInfo::Convergence,
680  GEOS_FMT( "***** The iterative coupling has converged in {} iteration(s) *****", iter + 1 ) );
681  }
682  }
683  return isConverged;
684  }
685 
686  virtual void
688  {
689  setSubSolvers();
690 
692 
695  GEOS_THROW_IF( isSequential && usesLineSearch,
696  GEOS_FMT( "{}: line search is not supported by the coupled solver when {} is set to `{}`. Please set {} to `{}` to remove this error",
697  getNonlinearSolverParameters().getWrapperDataContext( NonlinearSolverParameters::viewKeysStruct::couplingTypeString() ),
698  NonlinearSolverParameters::viewKeysStruct::couplingTypeString(),
700  NonlinearSolverParameters::viewKeysStruct::lineSearchActionString(),
702  InputError );
703 
704  if( !isSequential )
705  {
707  }
708 
710  {
711  validateNonlinearAcceleration();
712  }
713  }
714 
715  virtual void validateNonlinearAcceleration()
716  {
717  GEOS_THROW ( GEOS_FMT( "{}: Nonlinear acceleration {} is not supported by {} solver '{}'",
718  getWrapperDataContext( NonlinearSolverParameters::viewKeysStruct::nonlinearAccelerationTypeString() ),
720  getCatalogName(), getName()),
721  InputError );
722  }
723 
724  virtual void
726  {
727  forEachArgInTuple( m_solvers, [&]( auto & solver, auto )
728  {
729  solver->getNonlinearSolverParameters() = getNonlinearSolverParameters();
730  } );
731  }
732 
733  virtual void startSequentialIteration( integer const & iter,
734  DomainPartition & domain )
735  {
736  GEOS_UNUSED_VAR( iter, domain );
737  }
738 
739  virtual void finishSequentialIteration( integer const & iter,
740  DomainPartition & domain )
741  {
742  GEOS_UNUSED_VAR( iter, domain );
743  }
744 
745 protected:
746 
748  std::tuple< SOLVERS *... > m_solvers;
749 
751  std::array< string, sizeof...( SOLVERS ) > m_names;
752 };
753 
754 } /* namespace geos */
755 
756 #endif /* GEOS_PHYSICSSOLVERS_MULTIPHYSICS_COUPLEDSOLVER_HPP_ */
#define GEOS_UNUSED_VAR(...)
Mark an unused variable and silence compiler warnings.
Definition: GeosxMacros.hpp:84
#define GEOS_THROW(msg, TYPE)
Throw an exception.
Definition: Logger.hpp:164
#define GEOS_ERROR(msg)
Raise a hard error and terminate the program.
Definition: Logger.hpp:157
#define GEOS_LOG_RANK_0(msg)
Log a message on screen on rank 0.
Definition: Logger.hpp:101
#define GEOS_THROW_IF(EXP, msg, TYPE)
Conditionally throw an exception.
Definition: Logger.hpp:151
#define GEOS_MARK_FUNCTION
Mark function with both Caliper and NVTX if enabled.
virtual void assembleCouplingTerms(real64 const time_n, real64 const dt, DomainPartition const &domain, DofManager const &dofManager, CRSMatrixView< real64, globalIndex const > const &localMatrix, arrayView1d< real64 > const &localRhs)
Utility function to compute coupling terms.
CoupledSolver & operator=(CoupledSolver const &)=delete
deleted assignment operator
virtual real64 fullyCoupledSolverStep(real64 const &time_n, real64 const &dt, int const cycleNumber, DomainPartition &domain)
Fully coupled solution approach solution step.
virtual bool resetConfigurationToDefault(DomainPartition &domain) const override
resets the configuration to the default value.
CoupledSolver(const string &name, Group *const parent)
main constructor for CoupledSolver Objects
virtual void outputConfigurationStatistics(DomainPartition const &domain) const override
CoupledSolver(CoupledSolver &&)=default
default move constructor
virtual void resetConfigurationToBeginningOfStep(DomainPartition &domain) override
resets the configuration to the beginning of the time-step.
virtual real64 sequentiallyCoupledSolverStep(real64 const &time_n, real64 const &dt, integer const cycleNumber, DomainPartition &domain)
Sequentially coupled solver step. It solves a nonlinear system of equations using a sequential approa...
CoupledSolver(CoupledSolver const &)=delete
deleted copy constructor
virtual void synchronizeNonlinearSolverParameters() override
synchronize the nonlinear solver parameters.
virtual void setupCoupling(DomainPartition const &domain, DofManager &dofManager) const
Utility function to set the coupling between degrees of freedom.
virtual bool checkSequentialSolutionIncrements(DomainPartition &domain) const override
Check if the solution increments are ok to use.
virtual bool updateConfiguration(DomainPartition &domain, integer const configurationLoopIter) override
updates the configuration (if needed) based on the state after a converged Newton loop.
virtual void postInputInitialization() override
std::array< string, sizeof...(SOLVERS) > m_names
Names of the single-physics solvers.
std::tuple< SOLVERS *... > m_solvers
Pointers of the single-physics solvers.
CoupledSolver & operator=(CoupledSolver &&)=delete
deleted move operator
void setSubSolvers()
Utility function to set the subsolvers pointers using the names provided by the user.
virtual void mapSolutionBetweenSolvers(DomainPartition &domain, integer const solverType)
Maps the solution obtained from one solver to the fields used by the other solver(s)
The DoFManager is responsible for allocating global dofs, constructing sparsity patterns,...
Definition: DofManager.hpp:45
Partition of the decomposed physical domain. It also manages the connexion information to its neighbo...
void updateNonlinearIteration(integer const numLinearIterations)
Tell the solverStatistics that we have done a newton iteration.
void updateTimeStepCut()
Tell the solverStatistics that we cut the time step and we increment the cumulative counters for disc...
SequentialConvergenceCriterion sequentialConvergenceCriterion() const
Getter for the sequential convergence criterion.
integer m_allowNonConverged
Flag to allow for a non-converged nonlinear solution and continue with the problem.
real64 m_newtonTol
The tolerance for the nonlinear convergence check.
NonlinearAccelerationType m_nonlinearAccelerationType
Type of nonlinear acceleration for sequential solver.
integer m_maxIterNewton
The maximum number of nonlinear iterations that are allowed.
real64 m_timeStepCutFactor
Factor by which the time step will be cut if a timestep cut is required.
integer m_numNewtonIterations
The number of nonlinear iterations that have been exectued.
integer m_numTimeStepAttempts
Number of times that the time-step had to be cut.
integer m_maxTimeStepCuts
Max number of time step cuts.
CouplingType couplingType() const
Getter for the coupling type.
LineSearchAction m_lineSearchAction
Flag to apply a line search.
@ ResidualNorm
convergence achieved when the residual drops below a given norm
@ NumberOfNonlinearIterations
convergence achieved when the subproblems convergence is achieved in less than minNewtonIteration
@ SolutionIncrements
convergence achieved when the solution increments are small enough
integer m_subcyclingOption
Flag to specify whether subcycling is allowed or not in sequential schemes.
Base class for all physics solvers.
virtual string getCatalogName() const =0
IterationsStatistics & getIterationStats()
integer m_numTimestepsSinceLastDtCut
Number of cycles since last timestep cut.
virtual void cleanup(real64 const time_n, integer const cycleNumber, integer const eventCounter, real64 const eventProgress, DomainPartition &domain) override
Called as the code exits the main run loop.
Timestamp getMeshModificationTimestamp(DomainPartition &domain) const
getter for the timestamp of the mesh modification on the mesh levels
virtual void postInputInitialization() override
ConvergenceStatistics & getConvergenceStats()
NonlinearSolverParameters & getNonlinearSolverParameters()
accessor for the nonlinear solver parameters.
NonlinearSolverParameters m_nonlinearSolverParameters
Nonlinear solver parameters.
Wrapper< TBASE > & registerWrapper(string const &name, wrapperMap::KeyIndex::index_type *const rkey=nullptr)
Create and register a Wrapper around a new object.
DataContext const & getDataContext() const
Definition: Group.hpp:1345
string const & getName() const
Get group name.
Definition: Group.hpp:1331
Group & getParent()
Access the group's parent.
Definition: Group.hpp:1364
DataContext const & getWrapperDataContext(KEY key) const
Definition: Group.hpp:1356
#define GEOS_LOG_LEVEL_RANK_0(logInfoStruct, msg)
Output messages (only on rank 0) based on current Group's log level.
virtual void implicitStepSetup(real64 const &time_n, real64 const &dt, DomainPartition &domain) override
function to perform setup for implicit timestep
virtual void cleanup(real64 const time_n, integer const cycleNumber, integer const eventCounter, real64 const eventProgress, DomainPartition &domain) override
Called as the code exits the main run loop.
virtual real64 scalingForSystemSolution(DomainPartition &domain, DofManager const &dofManager, arrayView1d< real64 const > const &localSolution) override
Function to determine if the solution vector should be scaled back in order to maintain a known const...
virtual void updateAndWriteConvergenceStep(real64 const &time_n, real64 const &dt, integer const cycleNumber, integer const iteration) override
Update the convergence information and write then into a CSV file.
virtual void updateState(DomainPartition &domain) override
Recompute all dependent quantities from primary variables (including constitutive models)
virtual void implicitStepComplete(real64 const &time_n, real64 const &dt, DomainPartition &domain) override
perform cleanup for implicit timestep
virtual void applyBoundaryConditions(real64 const time_n, real64 const dt, DomainPartition &domain, DofManager const &dofManager, CRSMatrixView< real64, globalIndex const > const &localMatrix, arrayView1d< real64 > const &localRhs) override
apply boundary condition to system
virtual real64 scalingForSystemSolution(DomainPartition &domain, DofManager const &dofManager, arrayView1d< real64 const > const &localSolution)
Function to determine if the solution vector should be scaled back in order to maintain a known const...
virtual real64 calculateResidualNorm(real64 const &time_n, real64 const &dt, DomainPartition const &domain, DofManager const &dofManager, arrayView1d< real64 const > const &localRhs) override
calculate the norm of the global system residual
real64 solverStep(real64 const &time_n, real64 const &dt, int const cycleNumber, DomainPartition &domain) override final
virtual real64 setNextDt(real64 const &currentTime, real64 const &currentDt, DomainPartition &domain) override
function to set the next time step size
virtual real64 solverStep(real64 const &time_n, real64 const &dt, integer const cycleNumber, DomainPartition &domain)
entry function to perform a solver step
void setupDofs(DomainPartition const &domain, DofManager &dofManager) const override
Populate degree-of-freedom manager with fields relevant to this solver.
virtual void applySystemSolution(DofManager const &dofManager, arrayView1d< real64 const > const &localSolution, real64 const scalingFactor, real64 const dt, DomainPartition &domain) override
Function to apply the solution vector to the state.
virtual real64 setNextDt(real64 const &currentTime, real64 const &currentDt, DomainPartition &domain)
function to set the next time step size
virtual void assembleSystem(real64 const time_n, real64 const dt, DomainPartition &domain, DofManager const &dofManager, CRSMatrixView< real64, globalIndex const > const &localMatrix, arrayView1d< real64 > const &localRhs) override
function to assemble the linear system matrix and rhs
virtual bool checkSystemSolution(DomainPartition &domain, DofManager const &dofManager, arrayView1d< real64 const > const &localSolution, real64 const scalingFactor) override
Function to check system solution for physical consistency and constraint violation.
virtual void resetStateToBeginningOfStep(DomainPartition &domain) override
reset state of physics back to the beginning of the step.
@ FALSE
Not read from input.
@ REQUIRED
Required in input.
ArrayView< T, 1 > arrayView1d
Alias for 1D array view.
Definition: DataTypes.hpp:179
unsigned long long int Timestamp
Timestamp type (used to perform actions such a sparsity pattern computation after mesh modifications)
Definition: DataTypes.hpp:126
std::string string
String type.
Definition: DataTypes.hpp:90
double real64
64-bit floating point type.
Definition: DataTypes.hpp:98
LvArray::CRSMatrixView< T, COL_INDEX, INDEX_TYPE const, LvArray::ChaiBuffer > CRSMatrixView
Alias for CRS Matrix View.
Definition: DataTypes.hpp:309
int integer
Signed integer type.
Definition: DataTypes.hpp:81
Provides enum <-> string conversion facilities.
Exception class used to report errors in user input.
Definition: Logger.hpp:464
static constexpr char const * discretizationString()