A multi-physics multi-domain solver. More...

#include <Cgmp.h>

Inheritance diagram for Cgmp:

Collaboration diagram for Cgmp:

Public Types
enum	InterfaceValueEnum { doNotSaveInterfaceValues, saveInterfaceTimeHistoryValues, saveInterfaceIterateValues }

Public Types inherited from DomainSolver
enum	{ defaultValue =-1234567 }

enum	ForcingTypeEnum { computeForcing, computeTimeDerivativeOfForcing }

enum	BoundaryConditionPredictorEnum { predictPressure, predictPressureAndVelocity }

enum	InterfaceOptionsEnum { getInterfaceRightHandSide, setInterfaceRightHandSide }

enum	Dimensions { maximumNumberOfGridFunctionsToUse =4, maximumNumberOfExtraFunctionsToUse =4 }

enum	ChangesEnum { gridWasAdded =1, gridWasChanged, gridWasRemoved, refinementWasAdded, refinementWasRemoved }

Public Member Functions
	Cgmp (CompositeGrid &cg, GenericGraphicsInterface ps=NULL, Ogshow show=NULL, const int &plotOption=1)

virtual	~Cgmp ()

virtual int	assignInterfaceBoundaryConditions (std::vector< int > &newIndex, const real dt)
	: Assign the boundary conditions at an internal interface by solving the coupled interface equations.

virtual int	assignInterfaceRightHandSide (int d, real t, real dt, int correct, std::vector< int > &gfIndex)
	Assign the RHS for the interface equations on the target domain d.

virtual int	assignInterfaceRightHandSideOld (int d, real t, real dt, int correct, std::vector< int > &gfIndex)

virtual DomainSolver *	buildModel (const aString &modelName, CompositeGrid &cg, GenericGraphicsInterface ps=NULL, Ogshow show=NULL, const int &plotOption=1)

virtual int	buildRunTimeDialog ()
	Build the run time dialog. This dialog appears while a Domain solver is time stepping.

virtual int	buildTimeSteppingDialog (DialogData &dialog)
	Build the dialog that shows the various options for time stepping.

bool	checkInterfaceForConvergence (const int correct, const int numberOfCorrectorSteps, const int numberOfRequiredCorrectorSteps, const real tNew, const bool alwaysSetBoundaryData, std::vector< int > &gfIndex, std::vector< real > &oldResidual, std::vector< real > &initialResidual, std::vector< real > &firstResidual, std::vector< real > &maxResidual, bool &interfaceIterationsHaveConverged)
	Check that the interface equations have converged to the required tolerance or if the maximum number of corrections has been reached.

virtual int	cycleZero ()
	last minute checks and setups prior to actually running

bool	checkIfInterfacesMatch (Mapping &map1, int &dir1, int &side1, Mapping &map2, int &dir2, int &side2)

virtual int	finishAdvance ()
	perform tasks needed right after an advance (nothing right now), returns nonzero if the computation is finished

virtual int	getInterfaceResiduals (real t, real dt, std::vector< int > &gfIndex, std::vector< real > &maxResidual, InterfaceValueEnum saveInterfaceValues=doNotSaveInterfaceValues)
	Evaluate the residuals in the interface equation and/or save a time history of interface values.

virtual int	getInterfaceResidualsOld (real t, real dt, std::vector< int > &gfIndex, std::vector< real > &maxResidual, InterfaceValueEnum saveInterfaceValues=doNotSaveInterfaceValues)

virtual int	getModelInfo (std::vector< aString > &modelName)

virtual real	getTimeStep (GridFunction &gf)

virtual int	getTimeSteppingOption (const aString &answer, DialogData &dialog)
	Look for a time stepping option in the string "answer.

virtual int	initializeInterfaceBoundaryConditions (real t, real dt, std::vector< int > &gfIndex)
	Initialize the interface boundary conditions when they are solved by iteration.

virtual int	initializeInterfaces (std::vector< int > &newIndex)
	Find the interfaces and initialize the work-space.

virtual int	interfaceProjection (real t, real dt, int correct, std::vector< int > &gfIndex, int option)
	Project values on the interface to stabilize the scheme.

virtual int	multiDomainAdvance (real &t, real &tFinal)
	Multi-domain explicit/implicit time stepping.

virtual int	multiDomainAdvanceNew (real &t, real &tFinal)
	Multi-domain explicit/implicit time stepping, NEW VERSION that supports AMR.

virtual int	plot (const real &t, const int &optionIn, real &tFinal)

int	plotDomainQuantities (std::vector< realCompositeGridFunction * > u, real t)
	Utility routine to plot contours, streamlines, grids etc. in the different domains.

virtual int	printStatistics (FILE *file=stdout)
	Output timing statistics.

virtual void	printTimeStepInfo (const int &step, const real &t, const real &cpuTime)

virtual int	setParametersInteractively (bool runSetupOnExit=true)
	Setup the solvers and parameters for different domains.

virtual int	setupAdvance ()
	perform tasks needed prior to an actual advance (file io stuff mostly), returns nonzero if the computation is finished

virtual int	setupDomainSolverParameters (int domain, std::vector< aString > &modelNames)
	Setup the solver and parameters for a given domain.

virtual int	setupPde (aString &reactionName, bool restartChosen, IntegerArray &originalBoundaryCondition)
	A virtual function to setup the PDE to be solved.

virtual void	setup (const real &time=0.)
	Setup routine.

virtual void	setTopLabel (std::vector< realCompositeGridFunction * > u, real t)

virtual void	saveShow (GridFunction &gf)
	Save a solution in the show file.

virtual int	advance (real &tFinal)
	Advance the solution to time tFinal.

virtual int	solve ()
	The main routine to advance and plot the solution.

Public Member Functions inherited from DomainSolver
	DomainSolver (Parameters &par, CompositeGrid &cg, GenericGraphicsInterface ps=NULL, Ogshow show=NULL, const int &plotOption=1)
	This is the constructor for the base class DomainSolver.

virtual	~DomainSolver ()
	Destructor.

virtual int	adaptGrids (GridFunction &gf0, int numberOfGridFunctionsToUpdate=0, realCompositeGridFunction cgf=NULL, realCompositeGridFunction uWork=NULL)

virtual int	addArtificialDissipation (realCompositeGridFunction &u, real dt)

virtual int	addArtificialDissipation (realMappedGridFunction &u, real dt, int grid)

virtual int	addConstraintEquation (Parameters &parameters, Oges &solver, realCompositeGridFunction &coeff, realCompositeGridFunction &ucur, realCompositeGridFunction &rhs, const int &numberOfComponents)

virtual void	addForcing (realMappedGridFunction &dvdt, const realMappedGridFunction &u, int iparam[], real rparam[], realMappedGridFunction &dvdtImplicit=Overture::nullRealMappedGridFunction(), realMappedGridFunction *referenceFrameVelocity=NULL)

virtual int	addGrids ()

virtual void	advanceAdamsPredictorCorrector (real &t0, real &dt0, int &numberOfSubSteps, int &init, int initialStep)

virtual void	advanceAdamsPredictorCorrectorNew (real &t0, real &dt0, int &numberOfSubSteps, int &init, int initialStep)
	Advance using an Adams predictor corrector method (new way)

virtual void	advanceADI (real &t, real &dt, int &numberOfSubSteps, int &init, int initialStep)

void	advanceForwardEulerNew (real &t0, real &dt0, int &numberOfSubSteps, int &init, int initialStep)
	Advance using an "forward-Euler" method (new way)

virtual void	advanceImplicitMultiStep (real &t0, real &dt0, int &numberOfSubSteps, int &init, int initialStep)

virtual void	advanceImplicitMultiStepNew (real &t0, real &dt0, int &numberOfSubSteps, int &init, int initialStep)
	Generic advance routine that uses the separate time sub-step functions.

virtual int	advanceLineSolve (LineSolve &lineSolve, const int grid, const int direction, realCompositeGridFunction &u0, realMappedGridFunction &f, realMappedGridFunction &residual, const bool refactor, const bool computeTheResidual=false)

virtual void	advanceMidPoint (real &t0, real &dt0, int &numberOfSubSteps, int initialStep)

virtual void	advanceNewton (real &t0, real &dt0, int &numberOfSubSteps, int &init, int initialStep)

virtual void	advanceSecondOrderSystem (real &t0, real &dt0, int &numberOfSubSteps, int &init, int initialStep)

virtual void	advanceSteadyStateRungeKutta (real &t0, real &dt0, int &numberOfSubSteps, int &init, int initialStep)

virtual void	advanceTrapezoidal (real &t0, real &dt0, int &numberOfSubSteps, int &init, int initialStep)

virtual void	advanceVariableTimeStepAdamsPredictorCorrector (real &t0, real &dt0, int &numberOfSubSteps, int &init, int initialStep)

virtual void	allSpeedImplicitTimeStep (GridFunction &gf, real &t, real &dt0, int &numberOfTimeSteps, const real &nextTimeToPrint)

virtual int	applyBoundaryConditions (GridFunction &cgf, const int &option=-1, int grid_=-1, GridFunction *puOld=NULL, const real &dt=-1.)

virtual int	applyBoundaryConditions (const real &t, realMappedGridFunction &u, realMappedGridFunction &gridVelocity, const int &grid, const int &option=-1, realMappedGridFunction puOld=NULL, realMappedGridFunction pGridVelocityOld=NULL, const real &dt=-1.)

virtual int	applyBoundaryConditionsForImplicitTimeStepping (GridFunction &cgf)

virtual int	applyBoundaryConditionsForImplicitTimeStepping (realMappedGridFunction &u, realMappedGridFunction &uL, realMappedGridFunction &gridVelocity, real t, int scalarSystem, int grid)

virtual int	assignInitialConditions (int gfIndex)
	Assign initial conditions.

virtual int	applyFilter (int gfIndex)
	This function applies a spatial filter to the solution in gf[gfIndex].

virtual int	assignInterfaceBoundaryConditions (GridFunction &cgf, const int &option=-1, int grid_=-1, GridFunction *puOld=NULL, const real &dt=-1.)

virtual void	assignTestProblem (GridFunction &gf)

virtual void	bodyForcingCleanup ()
	This routine is called when DomainSolver is finished and can be used to clean up memory.

virtual int	boundaryConditionPredictor (const BoundaryConditionPredictorEnum bcpOption, const AdamsPCData &adamsData, const int orderOfExtrapolation, const int mNew, const int mCur, const int mOld, realCompositeGridFunction puga=NULL, realCompositeGridFunction pugb=NULL, realCompositeGridFunction pugc=NULL, realCompositeGridFunction pugd=NULL)
	Apply operations required before applying the boundary conditions. E.g. extrapolate the pressure in time for fourth-order INS.

virtual int	buildAdaptiveGridOptionsDialog (DialogData &dialog)
	Build the dialog that shows the various general options.

virtual int	buildAmrGridsForInitialConditions ()
	Build the AMR hierarchy of grids for the initial conditions.

virtual int	buildForcingOptionsDialog (DialogData &dialog)
	Build the dialog that shows the various forcing options.

virtual int	buildGeneralOptionsDialog (DialogData &dialog)
	Build the dialog that shows the various general options.

virtual int	buildGrid (Mapping *&newMapping, int newGridNumber, IntegerArray &sharedBoundaryCondition)

virtual int	buildOutputOptionsDialog (DialogData &dialog)
	Build the output options dialog.

virtual void	buildImplicitSolvers (CompositeGrid &cg)

virtual int	buildMovingGridOptionsDialog (DialogData &dialog)
	Build the dialog that shows the various general options.

virtual int	buildPlotOptionsDialog (DialogData &dialog)
	Build the plot options dialog.

void	checkArrays (const aString &label)

void	checkSolution (const realGridCollectionFunction &u, const aString &title, bool printResults=false)

int	checkSolution (realMappedGridFunction &u, const aString &title, bool printResults, int grid, real &maxVal, bool printResultsOnFailure=false)

virtual void	cleanupInitialConditions ()
	Cleanup routines after the initial conditions have been assigned.

virtual int	computeBodyForcing (GridFunction &gf, const real &tForce)
	Compute the body forcing such as drag models, wake models and heat sources.

virtual void	computeNumberOfStepsAndAdjustTheTimeStep (const real &t, const real &tFinal, const real &nextTimeToPrint, int &numberOfSubSteps, real &dtNew, const bool &adjustTimeStep=true)

virtual void	correctMovingGrids (const real t1, const real t2, GridFunction &cgf1, GridFunction &cgf2)
	Corrector step for moving grids.

const int &	debug () const

virtual void	determineErrors (GridFunction &cgf, const aString &label=nullString)

virtual void	determineErrors (realCompositeGridFunction &u, realMappedGridFunction **gridVelocity, const real &t, const int options, RealArray &err, const aString &label=nullString)

virtual void	determineErrors (realMappedGridFunction &v, const real &t)

virtual void	displayBoundaryConditions (FILE *file=stdout)

virtual int	displayParameters (FILE *file=stdout)
	Display DomainSolver parameters.

virtual int	endTimeStep (real &t0, real &dt0, AdvanceOptions &advanceOptions)
	End an individual time step (a time sub-step function).

virtual int	endTimeStepFE (real &t0, real &dt0, AdvanceOptions &advanceOptions)
	End an individual time step (a time sub-step function).

virtual int	endTimeStepIM (real &t0, real &dt0, AdvanceOptions &advanceOptions)
	End an individual time step (a time sub-step function).

virtual int	endTimeStepPC (real &t0, real &dt0, AdvanceOptions &advanceOptions)
	End an individual time step (a time sub-step function).

virtual int	endTimeStepAF (real &t0, real &dt0, AdvanceOptions &advanceOptions)
	End an individual time step (a time sub-step function).

virtual void	eulerStep (const real &t1, const real &t2, const real &t3, const real &dt0, GridFunction &cgf1, GridFunction &cgf2, GridFunction &cgf3, realCompositeGridFunction &ut, realCompositeGridFunction &uti, int stepNumber, int &numberOfSubSteps)

void	extrapolateInterpolationNeighbours (GridFunction &gf, const Range &C)
	Extrapolate interpolation neighbours.

virtual int	fixupUnusedPoints (realCompositeGridFunction &u)

virtual void	formMatrixForImplicitSolve (const real &dt0, GridFunction &cgf1, GridFunction &cgf0)

virtual int	getAmrErrorFunction (realCompositeGridFunction &u, real t, intCompositeGridFunction &errorFlag, realCompositeGridFunction &error)

virtual int	getAmrErrorFunction (realCompositeGridFunction &u, real t, realCompositeGridFunction &error, bool computeOnFinestLevel=false)

virtual realCompositeGridFunction &	getAugmentedSolution (GridFunction &gf0, realCompositeGridFunction &v)

const aString &	getClassName () const

virtual int	getAdaptiveGridOption (const aString &answer, DialogData &dialog)
	: Look for a general option in the string "answer"

virtual int	getForcingOption (const aString &command, DialogData &dialog)
	: Look for a forcing option in the string "answer"

virtual int	getGeneralOption (const aString &answer, DialogData &dialog)
	: Look for a general option in the string "answer"

virtual void	getGridInfo (real &totalNumberOfGridPoints, real dsMin[3], real dsAve[3], real dsMax[3], real &maxMax, real &maxMin, real &minMin)
	Evaluate the min and max grid spacing, total number of grid points etc.

virtual void	getGridVelocity (GridFunction &gf0, const real &tGV)

virtual int	getInitialConditions (const aString &command=nullString, DialogData interface=NULL, GUIState guiState=NULL, DialogState *dialogState=NULL)
	Determine the type of initial conditions to assign.

virtual int	getInterfaceDataOptions (GridFaceDescriptor &info, int &interfaceDataOptions) const
	Return the interface data required for a given type of interface.

int	getMaterialProperties (GridFunction &solution, realCompositeGridFunction &matProp)
	Evaluate the variable material parameters (for plotting for example).

real	getMovingGridMaximumRelativeCorrection ()
	Return the maximum relative change in the moving grid correction scheme. This is usually only an issue for "light" bodies.

bool	getMovingGridCorrectionHasConverged ()
	Return true if the correction steps for moving grids have converged. This is usually only an issue for "light" bodies.

virtual int	getMovingGridOption (const aString &answer, DialogData &dialog)
	: Look for a general option in the string "answer"

const aString &	getName () const

virtual int	getOutputOption (const aString &command, DialogData &dialog)
	: Look for an output option in the string "answer"

const aString &	getPdeName () const

virtual int	getPlotOption (const aString &answer, DialogData &dialog)
	: Look for a plot option in the string "answer"

virtual int	getResidual (real t, real dt, GridFunction &cgf, realCompositeGridFunction &residual)
	Compute the residual for "steady state" solvers.

int	getResidualInfo (real t0, const realCompositeGridFunction &residual, real &maximumResidual, real &maximuml2, FILE *file=NULL)
	Compute the max and l2 residuals and optionally output the info to a file.

virtual void	getSolutionBounds (const realMappedGridFunction &u, realArray &uMin, realArray &uMax, real &uvMax)

virtual int	getTimeDependentBoundaryConditions (MappedGrid &mg, real t, int grid=0, int side0=-1, int axis0=-1, ForcingTypeEnum forcingType=computeForcing)

virtual int	getTimeDerivativeOfBoundaryValues (GridFunction &gf0, const real &t, const int &grid, int side=-1, int axis=-1)

virtual real	getTimeStep (MappedGrid &mg, realMappedGridFunction &u, realMappedGridFunction &gridVelocity, const Parameters::TimeSteppingMethod &timeSteppingMethod, const int &grid)

int	getTimeStepAndNumberOfSubSteps (GridFunction &cgf, int stepNumber, int &numberOfSubSteps, real &dt)
	Compute a new time step and the number sub-steps to reach the next time to print.

virtual void	getTimeSteppingEigenvalue (MappedGrid &mg, realMappedGridFunction &u, realMappedGridFunction &gridVelocity, real &reLambda, real &imLambda, const int &grid)

virtual void	getUt (GridFunction &cgf, const real &t, RealCompositeGridFunction &ut, real tForce)

virtual int	getUt (const realMappedGridFunction &v, const realMappedGridFunction &gridVelocity, realMappedGridFunction &dvdt, int iparam[], real rparam[], realMappedGridFunction &dvdtImplicit=Overture::nullRealMappedGridFunction(), MappedGrid pmg2=NULL, const realMappedGridFunction pGridVelocity2=NULL)

virtual void	implicitSolve (const real &dt0, GridFunction &cgf1, GridFunction &cgf0)

virtual int	initializeInterfaces (GridFunction &cgf)

virtual int	initializeSolution ()

virtual int	initializeTimeStepping (real &t0, real &dt0)
	Initialize the time stepping (a time sub-step function).

virtual int	initializeTimeSteppingFE (real &t0, real &dt0)
	Initialize the time stepping (a time sub-step function).

virtual int	initializeTimeSteppingIM (real &t0, real &dt0)
	Initialize the time stepping (a time sub-step function).

virtual int	initializeTimeSteppingPC (real &t0, real &dt0)
	Initialize the time stepping (a time sub-step function).

virtual int	initializeTimeSteppingAF (real &t0, real &dt0)
	Initialize the time stepping (a time sub-step function).

virtual int	initializeTurbulenceModels (GridFunction &cgf)

virtual int	interfaceRightHandSide (InterfaceOptionsEnum option, int interfaceDataOptions, GridFaceDescriptor &info, GridFaceDescriptor &gfd, int gfIndex, real t)

virtual int	interpolate (GridFunction &cgf, const Range &R=nullRange)

virtual int	interpolateAndApplyBoundaryConditions (GridFunction &cgf, GridFunction *uOld=NULL, const real &dt=-1.)

virtual bool	isImplicitMatrixSingular (realCompositeGridFunction &uL)

virtual int	jetInflow (GridFunction &cgf)

virtual void	moveGrids (const real &t1, const real &t2, const real &t3, const real &dt0, GridFunction &cgf1, GridFunction &cgf2, GridFunction &cgf3)

virtual bool	movingGridProblem () const

virtual int	newAdaptiveGridBuilt (CompositeGrid &cg, realCompositeGridFunction &u, bool updateSolution)

const int &	numberOfComponents () const

virtual int	output (GridFunction &gf0, int stepNumber)

virtual void	outputHeader ()
	Output the main header banner that includes info about the grid and parameters.

virtual int	outputProbes (GridFunction &gf0, int stepNumber)
	output probe information at a given time

virtual void	outputSolution (realCompositeGridFunction &u, const real &t, const aString &label=nullString, int printOption=0)

virtual void	outputSolution (const realMappedGridFunction &u, const real &t)

virtual int	parabolicInflow (GridFunction &cgf)

virtual int	printMemoryUsage (FILE *file=stdout)
	Output information about the memory usage.

void	printP (const char *format,...) const
	Domain solver print function with a prefix identifier string.

virtual int	project (GridFunction &cgf)

virtual int	readRestartFile (realCompositeGridFunction &v, real &t, const aString &restartFileName=nullString)

virtual int	readRestartFile (GridFunction &cgf, const aString &restartFileName=nullString)

virtual int	saveSequenceInfo (real t0, const realCompositeGridFunction &residual)
	Save sequence info (such as the norm of the residual) into the time history arrays.

virtual int	saveSequencesToShowFile ()
	Save sequence info to the show file.

virtual int	saveRestartFile (const GridFunction &cgf, const aString &restartFileName)

virtual void	saveShowFileComments (Ogshow &show)
	Save comments in the show file.

virtual int	setBoundaryConditionsInteractively (const aString &answer, const IntegerArray &originalBoundaryCondition)

virtual int	setDefaultDataForBoundaryConditions ()

virtual int	setFinalTime (const real &tFinal)
	Set the time to integrate to.

virtual void	setInterfacesAtPastTimes (const real &t1, const real &t2, const real &t3, const real &dt0, GridFunction &cgf1, GridFunction &cgf2, GridFunction &cgf3)
	Assign interface positions for "negative" times.

virtual int	setInterfaceBoundaryCondition (GridFaceDescriptor &info)
	Setup an interface boundary condition.

void	setName (const aString &name)

void	setNameOfGridFile (const aString &name)
	Provide the name of the file from which the overlapping grid was read.

virtual int	setOgesBoundaryConditions (GridFunction &cgf, IntegerArray &boundaryConditions, RealArray &boundaryConditionData, const int imp)

virtual int	setPlotTitle (const real &t, const real &dt)
	Set the plot titles for interactive plotting.

virtual void	setSensitivity (GUIState &dialog, bool trueOrFalse)

virtual int	setSolverParameters (const aString &command=nullString, DialogData *interface=NULL)
	Prompt for changes in the solver parameters.

virtual int	setupGridFunctions ()
	Allocate and initialize grid functions, based on the time-stepping method.

virtual int	setupUserDefinedForcing ()

virtual int	setupUserDefinedInitialConditions ()

virtual int	setupUserDefinedMaterialProperties ()
	Interactively choose material properties (e.g. rho,mu,lambda for elasticity)

virtual int	setVariableBoundaryValues (const real &t, GridFunction &gf0, const int &grid, int side0=-1, int axis0=-1, ForcingTypeEnum forcingType=computeForcing)
	Assign the right-hand-side for variable boundary conditions.

virtual int	setVariableMaterialProperties (GridFunction &gf, const real &t)
	Assign variable material properties: user-defined or "body-force" regions.

virtual real	sizeOf (FILE *file=NULL) const

virtual void	smoothVelocity (GridFunction &cgf, const int numberOfSmooths)

virtual void	solveForTimeIndependentVariables (GridFunction &cgf, bool updateSolutionDependentEquations=false)
	: Solve for the pressure given the velocity.

virtual int	startTimeStep (real &t0, real &dt0, int &currentGF, int &nextGF, AdvanceOptions &advanceOptions)
	Start an individual time step (a time sub-step function).

virtual int	startTimeStepFE (real &t0, real &dt0, int &currentGF, int &nextGF, AdvanceOptions &advanceOptions)
	Start an individual time step (a time sub-step function).

virtual int	startTimeStepIM (real &t0, real &dt0, int &currentGF, int &nextGF, AdvanceOptions &advanceOptions)
	Start an individual time step (a time sub-step function).

virtual int	startTimeStepPC (real &t0, real &dt0, int &currentGF, int &nextGF, AdvanceOptions &advanceOptions)
	Start an individual time step (a time sub-step function).

virtual int	startTimeStepAF (real &t0, real &dt0, int &currentGF, int &nextGF, AdvanceOptions &advanceOptions)
	Start an individual time step (a time sub-step function) for an approximate factorization method.

virtual void	takeOneStep (real &t, real &dt, int stepNumber, int &numberOfSubSteps)
	Advance one time-step. This function is used by the multi-physics solver Cgmp.

virtual int	takeTimeStep (real &t0, real &dt0, int correction, AdvanceOptions &advanceOptions)
	Take a single time step (a time sub-step function).

virtual int	takeTimeStepFE (real &t0, real &dt0, int correction, AdvanceOptions &advanceOptions)
	Take a single time step (a time sub-step function).

virtual int	takeTimeStepIM (real &t0, real &dt0, int correction, AdvanceOptions &advanceOptions)
	Take a single time step (a time sub-step function).

virtual int	takeTimeStepPC (real &t0, real &dt0, int correction, AdvanceOptions &advanceOptions)
	Take a single time step (a time sub-step function).

virtual int	takeTimeStepAF (real &t0, real &dt0, int correction, AdvanceOptions &advanceOptions)
	Take a time step using the approximate factored scheme.

virtual int	timeIndependentBoundaryConditions (GridFunction &cgf)

virtual void	initializeFactorization ()

virtual int	tracking (GridFunction &gf0, int stepNumber)

const bool &	twilightZoneFlow () const

virtual int	userDefinedBoundaryValues (const real &t, GridFunction &gf0, const int &grid, int side0=-1, int axis0=-1, ForcingTypeEnum forcingType=computeForcing)
	Assign user specific values for boundary conditions.

virtual void	userDefinedCleanup ()
	This routine is called when DomainSolver is finished and can be used to clean up memory.

virtual int	userDefinedGrid (GridFunction &gfct, Mapping *&newMapping, int newGridNumber, IntegerArray &sharedBoundaryCondition)

virtual int	userDefinedForcing (realCompositeGridFunction &f, GridFunction &gf, const real &tForce)
	User defined forcing. Compute a user defined forcing that will be added to the right-hand side of the equations. This function is called to actually evaluate the user defined forcing The function setupUserDefinedForcing is first called to assign the option and parameters. Rewrite or add new options to this function and to setupUserDefinedForcing to supply your own forcing option.

virtual void	userDefinedForcingCleanup ()
	This routine is called when DomainSolver is finished and can be used to clean up memory.

virtual int	userDefinedInitialConditions (CompositeGrid &cg, realCompositeGridFunction &u)

virtual void	userDefinedInitialConditionsCleanup ()

virtual int	userDefinedMaterialProperties (GridFunction &gf)
	Assign the user defined material properties.

virtual void	userDefinedMaterialPropertiesCleanup ()
	This routine is called when DomainSolver is finished and can be used to clean up memory.

virtual int	userDefinedOutput (GridFunction &gf, int stepNumber)

virtual int	updateForAdaptiveGrids (CompositeGrid &cg)

virtual int	updateForMovingGrids (GridFunction &cgf)
	Update the DomainSolver after grids have moved or have been adapted.

virtual int	updateForNewTimeStep (GridFunction &gf, const real &dt)
	Update the geometry arrays.

virtual int	updateGeometryArrays (GridFunction &cgf)
	Update geometry arrays, solution at old times etc. after the time step has changed.

virtual int	updateToMatchGrid (CompositeGrid &cg)

virtual int	updateToMatchNewGrid (CompositeGrid &cgNew, IntegerArray &changes, IntegerArray &sharedBoundaryCondition, GridFunction &gf0)

virtual int	updateStateVariables (GridFunction &cgf, int stage=-1)
	Ths function is used to update state-variables. For example, the visco plastic viscosity.

virtual void	updateTimeIndependentVariables (CompositeGrid &cg0, GridFunction &cgf)

virtual int	updateVariableTimeInterpolation (int newGrid, GridFunction &cgf)

virtual int	updateWorkSpace (GridFunction &gf0)

virtual int	variableTimeStepBoundaryInterpolation (int grid, GridFunction &cgf)

virtual void	writeParameterSummary (FILE *file)

realCompositeGridFunction &	p () const

realCompositeGridFunction &	px () const

realCompositeGridFunction &	rL () const

realCompositeGridFunction &	pL () const

realCompositeGridFunction &	rho () const

realCompositeGridFunction &	gam () const

Public Attributes
std::vector< DomainSolver * >	domainSolver

Interpolant *	interpolant

Public Attributes inherited from DomainSolver
CompositeGrid &	cg

OgesParameters	pressureSolverParameters

OgesParameters	implicitTimeStepSolverParameters

CompositeGridOperators	finiteDifferenceOperators

real	dt

int	numberOfStepsTaken

Parameters &	parameters

GridFunction	gf [maximumNumberOfGridFunctionsToUse]

int	current

int	movieFrame

aString	movieFileName

int	numberOfGridFunctionsToUse

int	numberOfExtraFunctionsToUse

int	totalNumberOfArrays

realCompositeGridFunction	fn [maximumNumberOfExtraFunctionsToUse]

RealArray	variableDt

RealArray	variableTime

realArray *	ui

RealArray	tv

RealArray	tvb

RealArray	tv0

realCompositeGridFunction	coeff

int	numberOfImplicitSolvers

Oges *	implicitSolver

realCompositeGridFunction *	implicitCoeff

Oges *	poisson

realCompositeGridFunction	pressureRightHandSide

realCompositeGridFunction	poissonCoefficients

realCompositeGridFunction *	pp

realCompositeGridFunction *	ppx

realCompositeGridFunction *	prL

realCompositeGridFunction *	ppL

realCompositeGridFunction *	prho

realCompositeGridFunction *	pgam

realCompositeGridFunction *	pvIMS

realCompositeGridFunction *	pwIMS

realCompositeGridFunction *	previousPressure

realCompositeGridFunction *	puLinearized

realMappedGridFunction *	pGridVelocityLinearized

LineSolve *	pLineSolve

bool	gridHasMaterialInterfaces

realCompositeGridFunction *	pdtVar

std::vector< real >	hMin

std::vector< real >	hMax

std::vector< real >	numberOfGridPoints

std::vector< real >	dtv

std::vector< real >	realPartOfEigenvalue

std::vector< real >	imaginaryPartOfEigenvalue

int	numberSavedToShowFile

CG_ApproximateFactorization::FactorList	factors

Protected Member Functions
int	getInterfaceType (GridFaceDescriptor &gridDescriptor)
	Return the interface type for a given grid face on the interface.

Additional Inherited Members
Static Public Member Functions inherited from DomainSolver
static int	getBounds (const realCompositeGridFunction &u, RealArray &uMin, RealArray &uMax, real &uvMax)

static int	getOriginalBoundaryConditions (CompositeGrid &cg, IntegerArray &originalBoundaryCondition)
	Save the original boundary conditions from the CompositeGrid.

Protected Attributes inherited from DomainSolver
aString	name

aString	className

aString	pdeName

int	restartNumber

DialogData *	pUniformFlowDialog

DialogData *	pStepFunctionDialog

DialogData *	pShowFileDialog

DialogData *	pTzOptionsDialog

int	chooseAComponentMenuItem

int	numberOfPushButtons

int	numberOfTextBoxes

int	itemsToPlot

Detailed Description

A multi-physics multi-domain solver.

This solver can be use to solve multi-physics problems where different equations are solved in different domians. One such example would be to solve a thermal hydraulics problem where Cgins is used in the fluid domain and Cgad in the solid domain.

Member Enumeration Documentation

enum Cgmp::InterfaceValueEnum

Enumerator
doNotSaveInterfaceValues
saveInterfaceTimeHistoryValues
saveInterfaceIterateValues

Constructor & Destructor Documentation

Cgmp::Cgmp	(	CompositeGrid &	cg,
		GenericGraphicsInterface *	ps = `NULL`,
		Ogshow *	show = `NULL`,
		const int &	plotOption = `1`
	)

References DomainSolver::className, d, Parameters::dbase, domainSolver, interpolant, DomainSolver::name, and DomainSolver::parameters.

Cgmp::~Cgmp ( )

virtual

References d, domainSolver, ForDomain, interpolant, and DomainSolver::parameters.

Member Function Documentation

int Cgmp::advance ( real & tFinal )

virtual

Advance the solution to time tFinal.

This routine advances the solution a number of sub-steps.

Parameters

tFinal (input) : integrate in time to this value.

Reimplemented from DomainSolver.

References DomainSolver::current, Parameters::dbase, domainSolver, Parameters::forwardEuler, DomainSolver::gf, Parameters::implicit, multiDomainAdvance(), DomainSolver::parameters, printF(), and GridFunction::t.

Referenced by solve().

int Cgmp::assignInterfaceBoundaryConditions	(	std::vector< int > &	gfIndex,
		const real	dt
	)

virtual

: Assign the boundary conditions at an internal interface by solving the coupled interface equations.

Parameters

gfIndex (input) : Domain d should use the grid function : domainSolver[d]->gf[gfIndex[d]]

: This routine solves the coupled heatFlux boundary conditions directly.

References assert(), GridFaceDescriptor::axis, GridFunction::cg, d, Parameters::dbase, DomainSolver::debug(), dir, display(), GridFaceDescriptor::domain, domainSolver, DomainSolver::dt, dx1, ForDomain, getGhostIndex(), getIndex(), DomainSolver::gf, GridFaceDescriptor::grid, DomainSolver::gridHasMaterialInterfaces, InterfaceDescriptor::gridListSide1, InterfaceDescriptor::gridListSide2, gridType, I1, I2, I3, includeGhost, initializeInterfaceBoundaryConditions(), initializeInterfaces(), interfaceCgCm, J1, J2, J3, kappa, np, DomainSolver::parameters, printF(), GridFaceDescriptor::side, GridFunction::t, and GridFunction::u.

Referenced by multiDomainAdvance().

int Cgmp::assignInterfaceRightHandSide	(	int	d,
		real	t,
		real	dt,
		int	correct,
		std::vector< int > &	gfIndex
	)

virtual

Assign the RHS for the interface equations on the target domain d.

Assign values in the BoundaryDataArray : domainSolver[d]->getBoundaryData(grid); on domain d by evaluating the RHS for the interface equations. For example, the RHS may be the solution value "u" or the normal component of the "stress", k u.n from the opposite side of the interface.

Parameters

d	(input) : target domain, assign RHS for this domain.
t	(input) : current time
dt	(input) : current time step
correct	(input) : correction step number.
gfIndex	(input) : Domain d should use the grid function : domainSolver[d]->gf[gfIndex[d]]

Referenced by multiDomainAdvance(), and multiDomainAdvanceNew().

int Cgmp::assignInterfaceRightHandSideOld	(	int	d,
		real	t,
		real	dt,
		int	correct,
		std::vector< int > &	gfIndex
	)

virtual

References GridFaceDescriptor::a, a0, assert(), GridFaceDescriptor::axis, GridFunction::cg, InterfaceDataHistory::current, d, Parameters::dbase, DomainSolver::debug(), dir, display(), GridFaceDescriptor::domain, domainSolver, FOR_4IJD, getIndex(), DomainSolver::getInterfaceRightHandSide, GridFaceDescriptor::grid, grid, DomainSolver::gridHasMaterialInterfaces, InterfaceDescriptor::gridListSide1, InterfaceDescriptor::gridListSide2, Parameters::heatFluxInterface, i1, I1, i2, I2, i3, I3, initializeInterfaces(), GridFaceDescriptor::interfaceDataHistory, GridFaceDescriptor::interfaceDataIterates, InterfaceDataHistory::interfaceDataList, InterfaceDescriptor::interfaceOmega, InterfaceDescriptor::interfaceTransfer, J1, J2, J3, omega, OV_ABORT(), DomainSolver::parameters, printF(), DomainSolver::setInterfaceRightHandSide, GridFaceDescriptor::side, sourceArray, targetArray, tc, Parameters::tractionInterface, InterfaceTransfer::transferData(), GridFunction::u, GridFaceDescriptor::u, and uc.

Referenced by assignInterfaceRightHandSide().

DomainSolver * Cgmp::buildModel	(	const aString &	modelName,
		CompositeGrid &	cg,
		GenericGraphicsInterface *	ps = `NULL`,
		Ogshow *	show = `NULL`,
		const int &	plotOption = `1`
	)

virtual

References Parameters::dbase, DomainSolver::parameters, and printF().

int Cgmp::buildRunTimeDialog ( )

virtual

Build the run time dialog. This dialog appears while a Domain solver is time stepping.

Reimplemented from DomainSolver.

References assert(), DomainSolver::buildPlotOptionsDialog(), DomainSolver::cg, DomainSolver::current, d, Parameters::dbase, domainSolver, ForDomain, DomainSolver::gf, Parameters::isSteadyStateSolver(), m, n, DomainSolver::name, DomainSolver::numberOfComponents(), DomainSolver::numberOfPushButtons, DomainSolver::numberOfTextBoxes, DomainSolver::parameters, Parameters::setPdeParameters(), DomainSolver::setSolverParameters(), Parameters::steadyStateNewton, Parameters::steadyStateRungeKutta, u, and v.

Referenced by solve().

int Cgmp::buildTimeSteppingDialog ( DialogData & dialog )

virtual

Build the dialog that shows the various options for time stepping.

Parameters

dialog (input) :

Reimplemented from DomainSolver.

References assert(), DomainSolver::buildTimeSteppingDialog(), Parameters::dbase, Parameters::numberOfTimeSteppingMethods, and DomainSolver::parameters.

bool Cgmp::checkIfInterfacesMatch	(	Mapping &	map1,
		int &	dir1,
		int &	side1,
		Mapping &	map2,
		int &	dir2,
		int &	side2
	)

invert points from grid1 onto grid2

References a, r, s, and x.

Referenced by initializeInterfaces().

bool Cgmp::checkInterfaceForConvergence	(	const int	correct,
		const int	numberOfCorrectorSteps,
		const int	numberOfRequiredCorrectorSteps,
		const real	tNew,
		const bool	alwaysSetBoundaryData,
		std::vector< int > &	gfIndex,
		std::vector< real > &	oldResidual,
		std::vector< real > &	initialResidual,
		std::vector< real > &	firstResidual,
		std::vector< real > &	maxResidual,
		bool &	interfaceIterationsHaveConverged
	)

Check that the interface equations have converged to the required tolerance or if the maximum number of corrections has been reached.

Parameters

correct	(input) : current corrector step
numberOfCorrectorSteps	(input) : maximum number of corrector steps allowed.
numberOfRequiredCorrectorSteps	(input) : we must take at least this many corrector steps
tNew	(input) : current time.
alwaysSetBoundaryData	(input) :
gfIndex	(input) :
oldResidual,initialResidual,firstResidual	(input) :
maxResidual	(output) :
interfaceIterationsHaveConverged	(output) : true if the interface equations have converged to the requested tolerance

Returns: value: true if the interface equations have converged or if the maximum number of corrections has been reached, false otherwise.

References assert(), cr, Parameters::dbase, DomainSolver::debug(), DomainSolver::dt, getInterfaceResiduals(), DomainSolver::parameters, printF(), and saveInterfaceIterateValues.

Referenced by multiDomainAdvance(), and multiDomainAdvanceNew().

int Cgmp::cycleZero ( )

virtual

last minute checks and setups prior to actually running

References setupAdvance().

Referenced by solve().

int Cgmp::finishAdvance ( )

virtual

perform tasks needed right after an advance (nothing right now), returns nonzero if the computation is finished

Referenced by solve().

int Cgmp::getInterfaceResiduals	(	real	t,
		real	dt,
		std::vector< int > &	gfIndex,
		std::vector< real > &	maxResidual,
		InterfaceValueEnum	saveInterfaceValues = `doNotSaveInterfaceValues`
	)

virtual

Evaluate the residuals in the interface equation and/or save a time history of interface values.

This routine will query the domains for the current values of the interface variables. These interface variables may be then saved in a time history list (to be used with extrapolating forward in time or for computing time derivatives of the interface values). The interface values can also be used to evaluate the residual in the interface jump equations to see how well these equations are satisfied.

For interfaces with non-matching grid points we need to query the interface values from one side of the interface and then transfer (i.e. interpolate) these values to the grid on the other side of the interface (and vice versa) before we can compute the interface residuals.

Parameters

t	(input) : current time
dt	(input) : current time step
correct	(input) : correction step number.
gfIndex	(input) : Domain d should use the grid function : domainSolver[d]->gf[gfIndex[d]]
maxResidual	(output) : Maximum residual in the interface equations for each interface.
saveInterfaceValues	(input) : One of doNotSaveInterfaceValues, saveInterfaceTimeHistoryValues, or saveInterfaceIterateValues to indicate whether interface values should be saved in a list for later use.

Referenced by checkInterfaceForConvergence(), multiDomainAdvance(), and multiDomainAdvanceNew().

int Cgmp::getInterfaceResidualsOld	(	real	t,
		real	dt,
		std::vector< int > &	gfIndex,
		std::vector< real > &	maxResidual,
		InterfaceValueEnum	saveInterfaceValues = `doNotSaveInterfaceValues`
	)

virtual

References GridFaceDescriptor::a, assert(), GridFaceDescriptor::axis, GridFunction::cg, InterfaceDataHistory::current, Parameters::dbase, DomainSolver::debug(), dir, display(), GridFaceDescriptor::domain, domainSolver, FOR_4D, FOR_4IJ, FOR_4IJD, getIndex(), DomainSolver::getInterfaceRightHandSide, DomainSolver::getName(), GridFaceDescriptor::grid, DomainSolver::gridHasMaterialInterfaces, InterfaceDescriptor::gridListSide1, InterfaceDescriptor::gridListSide2, Parameters::heatFluxInterface, Parameters::heatFluxInterfaceData, i1, I1, i2, I2, i3, I3, GridFaceDescriptor::interfaceDataHistory, GridFaceDescriptor::interfaceDataIterates, InterfaceDataHistory::interfaceDataList, InterfaceDescriptor::interfaceTolerance, J1, J2, J3, OV_ABORT(), DomainSolver::parameters, printF(), DomainSolver::printP(), saveInterfaceIterateValues, saveInterfaceTimeHistoryValues, GridFaceDescriptor::side, Parameters::tractionInterface, GridFunction::u, GridFaceDescriptor::u, and DomainSolver::ui.

Referenced by getInterfaceResiduals().

int Cgmp::getInterfaceType ( GridFaceDescriptor & gridDescriptor )

protected

Return the interface type for a given grid face on the interface.

References GridFaceDescriptor::axis, dir, GridFaceDescriptor::domain, domainSolver, GridFaceDescriptor::grid, grid, side, and GridFaceDescriptor::side.

Referenced by interfaceProjection().

int Cgmp::getModelInfo ( std::vector< aString > & modelName )

virtual

real Cgmp::getTimeStep ( GridFunction & gf )

virtual

Reimplemented from DomainSolver.

References DomainSolver::cg, DomainSolver::current, d, DomainSolver::debug(), domainSolver, DomainSolver::dt, DomainSolver::getName(), printF(), and GridFunction::t.

Referenced by solve().

int Cgmp::getTimeSteppingOption	(	const aString &	answer,
		DialogData &	dialog
	)

virtual

Look for a time stepping option in the string "answer.

Parameters

answer	(input) : check this command for a change to the time stepping options
dialog	(input) :

Reimplemented from DomainSolver.

References Parameters::adamsPredictorCorrector2, assert(), Parameters::crankNicolson, Parameters::dbase, Parameters::forwardEuler, DomainSolver::getTimeSteppingOption(), Parameters::implicit, Parameters::midPoint, Parameters::notImplicit, DomainSolver::parameters, printF(), and Parameters::setGridIsImplicit().

int Cgmp::initializeInterfaceBoundaryConditions	(	real	t,
		real	dt,
		std::vector< int > &	gfIndex
	)

virtual

Initialize the interface boundary conditions when they are solved by iteration.

When we iterate to solve the interface conditions we need to specify what sub-set of the interface conditions we solve on each domain.

Parameters

t	(input) : current time
dt	(input) : current time step
gfIndex	(input) : Domain d should use the grid function : domainSolver[d]->gf[gfIndex[d]]

References GridFaceDescriptor::a, a11, assert(), axis, GridFaceDescriptor::axis, GridFunction::cg, d, Parameters::dbase, Parameters::dirichletInterface, GridFaceDescriptor::domain, domainSolver, GridFaceDescriptor::grid, DomainSolver::gridHasMaterialInterfaces, InterfaceDescriptor::gridListSide1, InterfaceDescriptor::gridListSide2, Parameters::heatFluxInterface, initializeInterfaces(), GridFaceDescriptor::interfaceBC, Parameters::neumannInterface, OV_ABORT(), DomainSolver::parameters, printF(), GridFaceDescriptor::side, Parameters::tractionInterface, and GridFunction::u.

Referenced by assignInterfaceBoundaryConditions(), multiDomainAdvance(), and multiDomainAdvanceNew().

int Cgmp::initializeInterfaces ( std::vector< int > & gfIndex )

virtual

Find the interfaces and initialize the work-space.

Interfaces are located by faces on different domains that have an interface BC and have the same share flag.

Parameters

gfIndex (input) : Domain d should use the grid function : domainSolver[d]->gf[gfIndex[d]] This function is called by setParametersInteractively

References assert(), GridFaceDescriptor::axis, boundaryCondition(), DomainSolver::cg, checkIfInterfacesMatch(), d, Parameters::dbase, dir, GridFaceDescriptor::domain, InterfaceDescriptor::domain1, InterfaceDescriptor::domain2, domainSolver, ForDomain, DomainSolver::getName(), GridFaceDescriptor::grid, grid, DomainSolver::gridHasMaterialInterfaces, InterfaceDescriptor::gridListSide1, InterfaceDescriptor::gridListSide2, I1, I2, I3, Parameters::icNames, Parameters::isAdaptiveGridProblem(), J1, J2, J3, mg, Parameters::noInterface, DomainSolver::parameters, printF(), s, side, and GridFaceDescriptor::side.

Referenced by assignInterfaceBoundaryConditions(), assignInterfaceRightHandSide(), assignInterfaceRightHandSideOld(), initializeInterfaceBoundaryConditions(), multiDomainAdvance(), and multiDomainAdvanceNew().

int Cgmp::interfaceProjection	(	real	t,
		real	dt,
		int	correct,
		std::vector< int > &	gfIndex,
		int	option
	)

virtual

Project values on the interface to stabilize the scheme.

For an interface between a compressible fluid and an elastic solid we adjust the velocity and stress on the interface so that the time stepping scheme remains stable for different material properties. For example this correction is useful for the case of a "light" solid next to a "heavy" fluid is

Parameters

t	(input) : current time
dt	(input) : current time step
correct	(input) : correction step number.
gfIndex	(input) : Domain d should use the grid function : domainSolver[d]->gf[gfIndex[d]]
option	(input) : 0=set values on the interface , 1=apply BC's to ghost points

References assert(), GridFaceDescriptor::axis, GridFunction::cg, DomainSolver::className, cp, d, Parameters::dbase, DomainSolver::debug(), dir, GridFaceDescriptor::domain, domainSolver, DomainSolver::dt, dx1, FOR_3D, ForDomain, GridFunction::getGridVelocity(), getInterfaceType(), getLocalBoundsAndBoundaryConditions(), DomainSolver::gf, GridFaceDescriptor::grid, DomainSolver::gridHasMaterialInterfaces, InterfaceDescriptor::gridListSide1, InterfaceDescriptor::gridListSide2, gridType, i1, I1, i2, I2, i3, I3, interfaceCnsSm, Parameters::isMovingGridProblem(), J1, J2, J3, lambda, mu, np, OV_ABORT(), DomainSolver::parameters, pc, printF(), s11c, s12c, s13c, s21c, s22c, s23c, s31c, s32c, s33c, GridFaceDescriptor::side, GridFunction::t, tc, Parameters::tractionInterface, GridFunction::u, uc, v1c, v2c, v3c, vc, and wc.

Referenced by multiDomainAdvanceNew().

int Cgmp::multiDomainAdvance	(	real &	t,
		real &	tFinal
	)

virtual

Multi-domain explicit/implicit time stepping.

Parameters

t	(input/output) : current time
tFinal	(input) : integrate to this final time.

References assignInterfaceBoundaryConditions(), assignInterfaceRightHandSide(), checkInterfaceForConvergence(), DomainSolver::current, d, Parameters::dbase, DomainSolver::debug(), domainSolver, DomainSolver::dt, ForDomainOrdered, get< int >(), getInterfaceResiduals(), DomainSolver::getName(), DomainSolver::gf, i, init, initializeInterfaceBoundaryConditions(), initializeInterfaces(), Parameters::isAdaptiveGridProblem(), multiDomainAdvanceNew(), AdvanceOptions::noChangeToGrid, DomainSolver::numberOfStepsTaken, DomainSolver::parameters, printF(), saveInterfaceTimeHistoryValues, MpParameters::stepAllThenMatchMultiDomainAlgorithm, and GridFunction::t.

Referenced by advance().

int Cgmp::multiDomainAdvanceNew	(	real &	t,
		real &	tFinal
	)

virtual

Multi-domain explicit/implicit time stepping, NEW VERSION that supports AMR.

Parameters

t	(input/output) : current time
tFinal	(input) : integrate to this final time.

References AdvanceOptions::applyBoundaryConditionsOnly, assert(), assignInterfaceRightHandSide(), checkInterfaceForConvergence(), DomainSolver::current, d, Parameters::dbase, DomainSolver::debug(), domainSolver, DomainSolver::dt, ForDomainOrdered, get< int >(), getInterfaceResiduals(), DomainSolver::getName(), DomainSolver::gf, i, init, initializeInterfaceBoundaryConditions(), initializeInterfaces(), interfaceProjection(), Parameters::isAdaptiveGridProblem(), AdvanceOptions::noChangeToGrid, DomainSolver::numberOfStepsTaken, DomainSolver::parameters, printF(), saveInterfaceTimeHistoryValues, MpParameters::stepAllThenMatchMultiDomainAlgorithm, GridFunction::t, and AdvanceOptions::takeStepButDoNotApplyBoundaryConditions.

Referenced by multiDomainAdvance().

int Cgmp::plot	(	const real &	t,
		const int &	optionIn,
		real &	tFinal
	)

virtual

int Cgmp::plotDomainQuantities	(	std::vector< realCompositeGridFunction * >	u,
		real	t
	)

Utility routine to plot contours, streamlines, grids etc. in the different domains.

References d, Parameters::dbase, domainSolver, ForDomain, DomainSolver::parameters, and setTopLabel().

Referenced by plot().

int Cgmp::printStatistics ( FILE * file = stdout )

virtual

Output timing statistics.

This information is normally printed at the end of the run.

Parameters

file	(input) : output to this file.

Reimplemented from DomainSolver.

References DomainSolver::cg, d, Parameters::dbase, domainSolver, ForDomain, DomainSolver::getClassName(), DomainSolver::getName(), grid, i, Parameters::implicit, m, np, DomainSolver::numberOfGridPoints, DomainSolver::numberOfStepsTaken, DomainSolver::output(), DomainSolver::p(), DomainSolver::parameters, DomainSolver::poisson, printF(), s, and Parameters::timeSteppingName.

Referenced by main().

void Cgmp::printTimeStepInfo	(	const int &	step,
		const real &	t,
		const real &	cpuTime
	)

virtual

Reimplemented from DomainSolver.

References DomainSolver::cg, d, Parameters::dbase, domainSolver, DomainSolver::getClassName(), DomainSolver::getName(), DomainSolver::numberOfStepsTaken, DomainSolver::parameters, and printF().

Referenced by solve().

void Cgmp::saveShow ( GridFunction & gf0 )

virtual

Save a solution in the show file.

Parameters

gf0	(input) : save this grid function.

Note: The array of Strings, parameters.dbase.get<aString* >("showVariableName"), holds a list of the things to save in the show file.

Reimplemented from DomainSolver.

References assert(), DomainSolver::cg, d, Parameters::dbase, domainSolver, DomainSolver::dt, Parameters::isMovingGridProblem(), DomainSolver::numberSavedToShowFile, DomainSolver::parameters, and printF().

Referenced by solve().

int Cgmp::setParametersInteractively ( bool callSetup = true )

virtual

Setup the solvers and parameters for different domains.

Parameters

callSetup (input) : if true call setup.

Reimplemented from DomainSolver.

References cg, d, ForDomain, printF(), and DomainSolver::setParametersInteractively().

Referenced by main().

void Cgmp::setTopLabel	(	std::vector< realCompositeGridFunction * >	u,
		real	t
	)

virtual

References d, domainSolver, and ForDomain.

Referenced by plotDomainQuantities().

void Cgmp::setup ( const real & time = 0. )

virtual

Setup routine.

Parameters

time	(input) : current time.

Reimplemented from DomainSolver.

References axis, cg, d, MpParameters::defaultMultiDomainAlgorithm, grid, Parameters::noInitialConditionChosen, Parameters::parabolicInflow, side, MpParameters::stepAllThenMatchMultiDomainAlgorithm, Parameters::timeSteppingName, and u.

int Cgmp::setupAdvance ( )

virtual

perform tasks needed prior to an actual advance (file io stuff mostly), returns nonzero if the computation is finished

perform tasks needed prior to an actual advance (file io stuff mostly), returns nonzero if the computation is finished.

References d, domainSolver, DomainSolver::dt, ForDomain, and DomainSolver::gf.

Referenced by cycleZero(), and solve().

int Cgmp::setupDomainSolverParameters	(	int	domain,
		std::vector< aString > &	modelNames
	)

virtual

Setup the solver and parameters for a given domain.

Parameters

domain	(input) : domain number to setup.
modelNames	(input) : names of available models (PDE solvers).

References assert(), cg, i, printF(), and s.

int Cgmp::setupPde	(	aString &	reactionName,
		bool	restartChosen,
		IntegerArray &	originalBoundaryCondition
	)

virtual

A virtual function to setup the PDE to be solved.

This function is called at the very start in order to setup the equations to be solved etc.

Parameters

reactionName	(input) :
restartChosen	(input) :
originalBoundaryCondition	(input) :

Reimplemented from DomainSolver.

int Cgmp::solve ( )

virtual

The main routine to advance and plot the solution.

Reimplemented from DomainSolver.

References advance(), buildRunTimeDialog(), DomainSolver::cg, DomainSolver::computeNumberOfStepsAndAdjustTheTimeStep(), DomainSolver::current, cycleZero(), d, Parameters::dbase, DomainSolver::debug(), Parameters::defaultValue, domainSolver, DomainSolver::dt, finishAdvance(), ForDomain, getTimeStep(), DomainSolver::gf, Parameters::isMovingGridProblem(), Parameters::isSteadyStateSolver(), DomainSolver::numberOfStepsTaken, DomainSolver::parameters, plot(), printF(), printTimeStepInfo(), saveShow(), MovingGrids::saveToShowFile(), setupAdvance(), and GridFunction::t.

Referenced by main().

Member Data Documentation

Interpolant* Cgmp::interpolant

Referenced by Cgmp(), and ~Cgmp().

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation