#include <Ogmg.h>

Collaboration diagram for Ogmg:

Public Types
enum	TransferTypesEnum { fullWeighting =0, restrictedFullWeighting, injection }

enum	OptionEnum { assumeSparseStencilOnRectangularGrids }

enum	SmootherTypeEnum { Jacobi =OgmgParameters::Jacobi, GaussSeidel =OgmgParameters::GaussSeidel, redBlack =OgmgParameters::redBlack, lineJacobiInDirection1 =OgmgParameters::lineJacobiInDirection1, lineJacobiInDirection2 =OgmgParameters::lineJacobiInDirection2, lineJacobiInDirection3 =OgmgParameters::lineJacobiInDirection3, lineZebraInDirection1 =OgmgParameters::lineZebraInDirection1, lineZebraInDirection2 =OgmgParameters::lineZebraInDirection2, lineZebraInDirection3 =OgmgParameters::lineZebraInDirection3, alternatingLineJacobi =OgmgParameters::alternatingLineJacobi, alternatingLineZebra =OgmgParameters::alternatingLineZebra, numberOfSmoothers }

enum	{ allGrids =-99, allLevels =-100 }

enum	Timing { timeForDefect =0, timeForSmooth, timeForFineToCoarse, timeForFineToCoarseBC, timeForCoarseToFine, timeForDirectSolver, timeForSolve, timeForInterpolation, timeForBoundaryConditions, timeForDefectInSmooth, timeForTridiagonalSolverInSmooth, timeForTridiagonalFactorInSmooth, timeForRelaxInSmooth, timeForBoundarySmooth, timeForInterpolationSmooth, timeForInitialize, timeForBuildExtraLevels, timeForOperatorAveraging, timeForBuildPredefinedEquations, timeForFullMultigrid, timeForDefectNorm, timeForOgesSmootherInit, timeForMiscellaneous, timeForGhostBoundaryUpdate, timeForInterpolateCoarseFromFine, numberOfThingsToTime }

enum	InterpolationQualityEnum { canInterpolateQuality1 =0, canInterpolateQuality2, canInterpolateQuality3, canInterpolateWithExtrapolation, canInterpolateQualityBad, canInterpolateQualityVeryBad, canNotInterpolate }

enum	StencilTypeEnum { general =0, sparse =1, constantCoeff =2, sparseConstantCoefficients =3, variableCoefficients =4, sparseVariableCoefficients =5 }

enum	CycleResultsEnum { defectPerCycle =0, workUnitsPerCycle, grid0DefectPerCycle, numberOfCycleResults }

Public Member Functions
	Ogmg ()

	Ogmg (CompositeGrid &mg, GenericGraphicsInterface *ps=0)

	~Ogmg ()
	/brief Destructor.

void	displaySmoothers (const aString &label, FILE *file=stdout)

CompositeGrid &	getCompositeGrid ()

FILE *	getInfoFile ()

FILE *	getCheckFile ()

realCompositeGridFunction &	getDefect ()

void	computeDefect (int level)

realCompositeGridFunction &	getRhs ()

real	getMaximumResidual () const

real	getMean (realCompositeGridFunction &u)

int	getNumberOfIterations () const

int	getOrderOfExtrapolation (const int level) const
	Return the order of extrapolation to use for a given order of accuracy and level.

void	set (GenericGraphicsInterface *ps)

void	set (MultigridCompositeGrid &mgcg)
	Supply a MultigridCompositeGrid to use.

void	setGridName (const aString &name)

void	setSolverName (const aString &name)

int	setOgmgParameters (OgmgParameters &parameters)

int	setOption (OptionEnum option, bool trueOrFalse)
	Assign an option.

int	setOrderOfAccuracy (const int &orderOfAccuracy)

int	setCoefficientArray (realCompositeGridFunction &coeff, const IntegerArray &boundaryConditions=Overture::nullIntArray(), const RealArray &bcData=Overture::nullRealArray())

int	setCornerBoundaryConditions (BoundaryConditionParameters &bcParams, const int level)
	Set the boundary condition parameters for edges and corners.

int	setEquationAndBoundaryConditions (OgesParameters::EquationEnum equation, CompositeGridOperators &op, const IntegerArray &boundaryConditions, const RealArray &bcData, const RealArray &constantCoeff=Overture::nullRealArray(), realCompositeGridFunction *variableCoeff=NULL)
	Specify the (predefined) equation to solve. this is not finished yet .

virtual real	sizeOf (FILE *file=NULL) const

int	chooseBestSmoother ()

int	update (GenericGraphicsInterface &gi)

int	update (GenericGraphicsInterface &gi, CompositeGrid &cg)

void	updateToMatchGrid (CompositeGrid &mg)

int	solve (realCompositeGridFunction &u, realCompositeGridFunction &f)

void	printStatistics (FILE *file=stdout) const

int	smoothTest (GenericGraphicsInterface &ps, int plotOption)

int	coarseToFineTest ()

int	fineToCoarseTest ()

int	bcTest ()

int	coarseGridSolverTest (int plotOption=0)

int	applyInitialConditions ()

int	applyFinalConditions ()

void	assignBoundaryConditionCoefficients (realMappedGridFunction &coeff, int grid, int level, int sideToCheck=-1, int axisToCheck=-1)

void	checkParameters ()
	Check the validity of parameters.

void	init ()

void	setup (CompositeGrid &mg)

void	setMean (realCompositeGridFunction &u, const real meanValue, int level)
	Set the "mean" of a grid function The mean is just the sum of all points with mask!=0.

real	l2Norm (const realCompositeGridFunction &e)

real	l2Norm (const realMappedGridFunction &e)

real	maxNorm (const realCompositeGridFunction &e)

real	maxNorm (const realMappedGridFunction &e)

real	l2Error (const realCompositeGridFunction &u, const realCompositeGridFunction &v)

int	initializeBoundaryConditions (realCompositeGridFunction &coeff)

int	initializeConstantCoefficients ()

int	createNullVector ()

int	saveLeftNullVector ()

int	readLeftNullVector ()

real	rightNullVectorDotU (const int &level, const RealCompositeGridFunction &u)

int	buildExtraLevels (CompositeGrid &mg)

int	buildExtraLevelsNew (CompositeGrid &mg)

int	buildPredefinedEquations (CompositeGridOperators &cgop)
	build the predefined equations

int	buildPredefinedCoefficientMatrix (int level, bool buildRectangular, bool buildCurvilinear)
	Build the coefficient matrix for the predefined equations on a given level.

int	buildPredefinedVariableCoefficients (RealCompositeGridFunction &coeff, const int level)

int	cycle (const int &level, const int &iteration, real &maximumDefect, const int &numberOfCycleIterations)

OgmgParameters::FourthOrderBoundaryConditionEnum	getGhostLineBoundaryCondition (int bc, int ghostLine, int grid, int level, int &orderOfExtrapolation, aString *bcName=NULL) const

int	setBoundaryConditions (const IntegerArray &boundaryConditions, const RealArray &bcData=Overture::nullRealArray())

void	smooth (const int &level, int numberOfSmoothingSteps, int cycleNumber)

void	smoothJacobi (const int &level, const int &grid, int smootherChoice=0)

void	smoothGaussSeidel (const int &level, const int &grid)

void	smoothRedBlack (const int &level, const int &grid)

void	smoothLine (const int &level, const int &grid, const int &direction, bool useZebra=true, const int smoothBoundarySide=-1)

void	alternatingLineSmooth (const int &level, const int &grid, bool useZebra=true)

void	applyOgesSmoother (const int level, const int grid)

void	smoothBoundary (int level, int grid, int bcOption[6], int numberOfLayers=1, int numberOfIterations=1)

void	smoothInterpolationNeighbours (int level, int grid)

void	computeDefectRatios (int level)

bool	useEquationOnGhostLineForDirichletBC (MappedGrid &mg, int level)

bool	useEquationOnGhostLineForNeumannBC (MappedGrid &mg, int level)

void	defect (const int &level)

void	defect (const int &level, const int &grid)

void	fineToCoarse (const int &level, bool transferForcing=false)

void	fineToCoarse (const int &level, const int &grid, bool transferForcing=false)

void	coarseToFine (const int &level)

void	coarseToFine (const int &level, const int &grid)

real	defectMaximumNorm (const int &level, int approximationStride=1)

real	defectNorm (const int &level, const int &grid, int option=0, int approximationStride=8)

real	getDefect (const int &level, const int &grid, realArray &f, realArray &u, const Index &I1, const Index &I2, const Index &I3, realArray &defect, const int lineSmoothOption=-1, const int defectOption=0, real &defectL2Norm=bogusRealArgument1, real &defectMaxNorm=bogusRealArgument2)

void	evaluateTheDefectFormula (const int &level, const int &grid, const realArray &c, const realArray &u, const realArray &f, realArray &defect, MappedGrid &mg, const Index &I1, const Index &I2, const Index &I3, const Index &I1u, const Index &I2u, const Index &I3u, const int lineSmoothOption)

int	fullMultigrid ()

int	interpolate (realCompositeGridFunction &u, const int &grid=-1, int level=-1)

int	applyBoundaryConditions (const int &level, const int &grid, RealMappedGridFunction &u, RealMappedGridFunction &f)

int	applyBoundaryConditions (const int &level, RealCompositeGridFunction &u, RealCompositeGridFunction &f)

int	operatorAveraging (RealCompositeGridFunction &coeff, const int &level)

int	operatorAveraging (RealMappedGridFunction &coeffFine, RealMappedGridFunction &coeffCoarse, const IntegerArray &coarseningRatio, int grid=0, int level=0)

int	averageCoefficients (Index &I1, Index &I2, Index &I3, Index &I1p, Index &I2p, Index &I3p, Index &J1, Index &J2, Index &J3, TransferTypesEnum option[3], const realSerialArray &cFine, realSerialArray &cCoarse, int ipar[])

int	markGhostPoints (CompositeGrid &cg)

int	getInterpolationCoordinates (CompositeGrid &cg0, CompositeGrid &cg1, const IntegerArray &ib, const int grid, const IntegerArray &gridsToCheck, realSerialArray &rb, const bool isRectangular, int iv0[3], real dx0[3], real xab0[2][3], int iv1[3], real dx1[3], real xab1[2][3])

int	getInterpolationCoordinates (CompositeGrid &cg0, CompositeGrid &cg1, const IntegerArray &ib, const int grid, const IntegerArray &gridsToCheck, realSerialArray &rb, const bool isRectangular, int iv0[3], real dx0[3], real xab0[2][3], int iv1[3], real dx1[3], real xab1[2][3], InterpolationData &ipd)

int	getInterpolationCoordinatesNew (CompositeGrid &cg0, CompositeGrid &cg1, const IntegerArray &ib, const RealArray &xa, const int grid, const IntegerArray &gridsToCheck, realSerialArray &rb, const bool isRectangular, int iv0[3], real dx0[3], real xab0[2][3], int iv1[3], real dx1[3], real xab1[2][3], InterpolationData &ipd, IntegerArray &ia0, realSerialArray &donorDist)

int	getInterpolationCoordinatesNewOld (CompositeGrid &cg0, CompositeGrid &cg1, const IntegerArray &ib, const RealArray &xa, const int grid, const IntegerArray &gridsToCheck, realSerialArray &rb, const bool isRectangular, int iv0[3], real dx0[3], real xab0[2][3], int iv1[3], real dx1[3], real xab1[2][3], InterpolationData &ipd)

int	getInterpolationCoordinates (CompositeGrid &cg0, CompositeGrid &cg1, int i, int grid, int iv[], int jv[], realSerialArray &r, bool isRectangular, int iv0[3], real dx0[3], real xab0[2][3], int iv1[3], real dx[3], real xab[2][3])

InterpolationQualityEnum	getInterpolationStencil (CompositeGrid &cg0, CompositeGrid &cg1, int i, int iv[3], int grid, int l, intSerialArray &inverseGrid, intSerialArray &interpoleeGrid, intSerialArray &interpoleeLocation, intSerialArray &interpolationPoint, intSerialArray &variableInterpolationWidth, realSerialArray &interpolationCoordinates, realSerialArray &inverseCoordinates)

int	checkForBetterQualityInterpolation (realSerialArray &x, int gridI, InterpolationQualityEnum &interpolationQuality, CompositeGrid &cg0, CompositeGrid &cg1, int i, int iv[3], int grid, int l, intSerialArray &inverseGrid, intSerialArray &interpoleeGrid, intSerialArray &interpoleeLocation, intSerialArray &interpolationPoint, intSerialArray &variableInterpolationWidth, realSerialArray &interpolationCoordinates, realSerialArray &inverseCoordinates)
	Check to see if a point x can interpolate from gridI with a better quality interpolation.

int	outputCycleInfo ()
	Output results about the cycle convergence rates etc. in a form suitable for matlab.

int	outputResults (const int &level, const int &iteration, real &maximumDefect, real &defectNew, real &defectOld)
	Output results for this multigrid cycle.

int	buildCoefficientArrays ()
	Once the coefficient matrix is known on the finest level we can automatically build the coeff matrices on coarser levels.

int	addAdjustmentForSingularProblem (int level, int iteration)
	Adjust the right-hand-side for a singular problem.

int	removeAdjustmentForSingularProblem (int level, int iteration)
	Remove the adjustment to the right-handside for a singular problem.

int	getSingularParameter (int level)

int	computeLeftNullVector ()

Public Attributes
OgmgParameters	parameters

Oges	directSolver

Oges *	ogesSmoother

MultigridCompositeGrid	multigridCompositeGrid

aString	gridName

aString	solverName

realCompositeGridFunction	uMG

realCompositeGridFunction	fMG

realCompositeGridFunction	defectMG

realCompositeGridFunction	cMG

realCompositeGridFunction	rightNullVector

realCompositeGridFunction *	leftNullVector

bool	leftNullVectorIsComputed

realCompositeGridFunction *	v

realCompositeGridFunction	uOld

bool	useForcingAsBoundaryConditionOnAllLevels

RealArray	alpha

RealArray	workUnits

RealArray	constantCoefficients

RealArray	equationCoefficients

realCompositeGridFunction *	varCoeff

RealArray	cycleResults

IntegerArray	interpolantWasCreated

IntegerArray	lineSmoothIsInitialized

IntegerArray	boundaryCondition

bool	bcSupplied

bool	bcDataSupplied

IntegerArray	bc

RealArray	boundaryConditionData

int	subSmoothReferenceGrid

RealArray	defectRatio

IntegerArray	isConstantCoefficients

IntegerArray	active

BoundaryConditionParameters	bcParams

TridiagonalSolver ****	tridiagonalSolver

CompositeGridOperators *	operatorsForExtraLevels

Interpolant **	interpolant

GenericGraphicsInterface *	ps

GraphicsParameters	psp

int	myid

FILE *	debugFile

FILE *	pDebugFile

FILE *	infoFile

FILE *	checkFile

FILE *	gridCheckFile

bool	initialized

bool	assumeSparseStencilForRectangularGrids

int	orderOfAccuracy

int	width1

int	width2

int	width3

int	halfWidth1

int	halfWidth2

int	halfWidth3

int	numberOfGridPoints

int	numberOfSolves

int	totalNumberOfCycles

int	numberOfCycles

int	numberOfIterations

int	numberOfExtraLevels

int	levelZero

int *	iterationCount

real	workUnit

real	timeForAddition

real	timeForMultiplication

real	timeForDivision

real	totalWorkUnits

real	totalResidualReduction

real	fullMultigridWorkUnits

real	averageEffectiveConvergenceRate

real	sumTotalWorkUnits

real	l2NormRightHandSide

real	maximumResidual

real	tm [numberOfThingsToTime]

int	timerGranularity

int	totalNumberOfCoarseGridIterations

OgesParameters::EquationEnum	equationToSolve

Interpolate	interp

char	buff [100]

int *	nipn

int *	ndipn

int **	ipn

int	numberOfIBSArrays

Static Public Attributes
static int	debug =0

static OGFunction *	pExactSolution =NULL

static aString	infoFileCaption [5]

static int	numberOfInstances =0

static real	bogusRealArgument1 =0.

static real	bogusRealArgument2 =0.

Member Enumeration Documentation

anonymous enum

Enumerator
allGrids
allLevels

enum Ogmg::CycleResultsEnum

Enumerator
defectPerCycle
workUnitsPerCycle
grid0DefectPerCycle
numberOfCycleResults

enum Ogmg::InterpolationQualityEnum

Enumerator
canInterpolateQuality1
canInterpolateQuality2
canInterpolateQuality3
canInterpolateWithExtrapolation
canInterpolateQualityBad
canInterpolateQualityVeryBad
canNotInterpolate

enum Ogmg::OptionEnum

Enumerator
assumeSparseStencilOnRectangularGrids

enum Ogmg::SmootherTypeEnum

Enumerator
Jacobi
GaussSeidel
redBlack
lineJacobiInDirection1
lineJacobiInDirection2
lineJacobiInDirection3
lineZebraInDirection1
lineZebraInDirection2
lineZebraInDirection3
alternatingLineJacobi
alternatingLineZebra
numberOfSmoothers

enum Ogmg::StencilTypeEnum

Enumerator
general
sparse
constantCoeff
sparseConstantCoefficients
variableCoefficients
sparseVariableCoefficients

enum Ogmg::Timing

Enumerator
timeForDefect
timeForSmooth
timeForFineToCoarse
timeForFineToCoarseBC
timeForCoarseToFine
timeForDirectSolver
timeForSolve
timeForInterpolation
timeForBoundaryConditions
timeForDefectInSmooth
timeForTridiagonalSolverInSmooth
timeForTridiagonalFactorInSmooth
timeForRelaxInSmooth
timeForBoundarySmooth
timeForInterpolationSmooth
timeForInitialize
timeForBuildExtraLevels
timeForOperatorAveraging
timeForBuildPredefinedEquations
timeForFullMultigrid
timeForDefectNorm
timeForOgesSmootherInit
timeForMiscellaneous
timeForGhostBoundaryUpdate
timeForInterpolateCoarseFromFine
numberOfThingsToTime

enum Ogmg::TransferTypesEnum

Enumerator
fullWeighting
restrictedFullWeighting
injection

Constructor & Destructor Documentation

Ogmg::Ogmg ( )

Referenced by main().

Ogmg::Ogmg	(	CompositeGrid &	mg,
		GenericGraphicsInterface *	ps = `0`
	)

Ogmg::~Ogmg ( )

/brief Destructor.

Member Function Documentation

int Ogmg::addAdjustmentForSingularProblem	(	int	level,
		int	iteration
	)

void Ogmg::alternatingLineSmooth	(	const int &	level,
		const int &	grid,
		bool	useZebra = `true`
	)

References assert, axis1, axis2, axis3, multigridCompositeGrid, numberOfCycles, GridCollection::numberOfDimensions(), parameters, smoothLine(), smoothRedBlack(), and OgmgParameters::useSplitStepLineSolver.

Referenced by smooth(), and smoothLine().

int Ogmg::applyBoundaryConditions	(	const int &	level,
		const int &	grid,
		RealMappedGridFunction &	u,
		RealMappedGridFunction &	f
	)

References BoundaryConditionParameters::a, Overture::abort(), MappedGridOperators::applyBoundaryCondition(), assert, aString, bc, bcOpt, bcParams, bcSupplied, BCTypes::boundary1, boundaryCondition, MappedGrid::boundaryCondition(), boundaryConditionData, buff, c, MappedGrid::center(), SparseRepForMGF::classify, cMG, debug, debugFile, defect(), defectMG, MappedGrid::dimension(), OgmgParameters::dirichlet, OgmgParameters::dirichletFirstGhostLineBC, OgmgParameters::dirichletSecondGhostLineBC, display(), dx, End, OgmgParameters::equation, equationToSolve, evaluateTheDefectFormula(), extendedGridIndexRange(), MappedGrid::extendedIndexRange(), OgesParameters::extrapolate, OgmgParameters::extrapolate, BoundaryConditionParameters::extrapolateCorner, SparseRepForMGF::extrapolation, fabs(), GenericMappedGridOperators::finishBoundaryConditions(), OgmgParameters::fourthOrderBoundaryConditionOption, fPrintF(), getCPU(), getCPUOpt, MappedGrid::getDeltaX(), getGhostIndex(), getGhostLineBoundaryCondition(), getIndex(), ParallelGridUtility::getLocalIndexBoundsAndBoundaryConditions(), doubleMappedGridFunction::getOperators(), getOrderOfExtrapolation(), MappedGrid::gridIndexRange(), MappedGrid::gridSpacing(), i2, ia, MappedGrid::inverseVertexDerivative(), MappedGridOperators::isRectangular(), levelZero, BoundaryConditionParameters::lineToAssign, OgmgParameters::lowerLevelDirichletFirstGhostLineBC, OgmgParameters::lowerLevelDirichletSecondGhostLineBC, OgmgParameters::lowerLevelNeumannFirstGhostLineBC, OgmgParameters::lowerLevelNeumannSecondGhostLineBC, M123, M2, M3, mask, MappedGrid::mask(), max(), min(), BCTypes::mixed, OgesParameters::mixed, multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, myid, BCTypes::neumann, OgesParameters::neumann, OgmgParameters::neumannFirstGhostLineBC, OgmgParameters::neumannSecondGhostLineBC, nr, NULL, BoundaryConditionParameters::numberOfCornerGhostLinesToAssign, MappedGrid::numberOfDimensions(), orderOfAccuracy, BoundaryConditionParameters::orderOfExtrapolation, OgmgParameters::orderOfExtrapolationForDirichlet, OgmgParameters::orderOfExtrapolationForDirichletOnLowerLevels, OgmgParameters::orderOfExtrapolationForNeumann, OgmgParameters::orderOfExtrapolationForNeumannOnLowerLevels, OV_ABORT, parameters, pDebugFile, pExactSolution, printF(), REAL_EPSILON, BoundaryConditionParameters::setCornerBoundaryCondition(), MappedGridOperators::setTwilightZoneFlow(), OgmgParameters::solveEquationWithBoundaryConditions, doubleMappedGridFunction::sparse, sPrintF(), Start, BoundaryConditionParameters::taylor2ndOrderEvenCorner, BoundaryConditionParameters::taylor4thOrderEvenCorner, MappedGrid::THEcenter, MappedGrid::THEinverseVertexDerivative, MappedGrid::THEvertex, timeForBC, timeForBCOpt, timeForBCUpdateGeometry, timeForBoundaryConditions, timeForExtrapolationBC, timeForFinishBC, timeForGeneralNeumannBC, timeForGhostBoundaryUpdate, timeForNeumannBC, timeForSetupBC, tm, GenericMappedGridOperators::twilightZoneFlow, MappedGrid::update(), useEquationOnGhostLineForDirichletBC(), OgmgParameters::useEquationToSecondOrder, OgmgParameters::useExtrapolation, useForcingAsBoundaryConditionOnAllLevels, OgmgParameters::useOptimizedVersion, OgesParameters::userDefined, OgmgParameters::useSymmetry, and OgmgParameters::useSymmetryCornerBoundaryCondition.

Referenced by applyBoundaryConditions(), applyInitialConditions(), bcTest(), coarseToFine(), smoothBoundary(), smoothJacobi(), smoothLine(), and smoothRedBlack().

int Ogmg::applyBoundaryConditions	(	const int &	level,
		RealCompositeGridFunction &	u,
		RealCompositeGridFunction &	f
	)

References applyBoundaryConditions(), and doubleGridCollectionFunction::numberOfComponentGrids().

int Ogmg::applyFinalConditions ( )

References boundaryCondition, MappedGrid::boundaryCondition(), End, OgmgParameters::extrapolate, getCPU(), getGhostIndex(), MappedGrid::gridIndexRange(), multigridCompositeGrid, CompositeGrid::multigridLevel, GridCollection::numberOfDimensions(), orderOfAccuracy, Start, timeForBCFinal, and uMG.

void Ogmg::applyOgesSmoother	(	const int	level,
		const int	grid
	)

References OgmgParameters::activeGrids, bcParams, cMG, debug, GenericCompositeGridOperators::finishBoundaryConditions(), fMG, Oges::get(), getCPU(), Oges::getMaximumResidual(), Oges::getNumberOfIterations(), interpolate(), mask, multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, NULL, nullRange, numberOfGridPoints, GenericGridCollection::numberOfMultigridLevels(), OgmgParameters::numberOfSubSmooths, ogesSmoother, OgmgParameters::ogesSmoothParameters, operatorsForExtraLevels, parameters, printF(), Oges::set(), Oges::setCoefficientArray(), Oges::setGridsToUse(), Oges::setOgesParameters(), Oges::solve(), OgesParameters::THEmaximumNumberOfIterations, OgesParameters::THEnumberOfIncompleteLULevels, timeForInitialize, timeForOgesSmootherInit, timeForSmooth, tm, uMG, Oges::updateToMatchGrid(), and workUnits.

Referenced by smooth().

void Ogmg::assignBoundaryConditionCoefficients	(	realMappedGridFunction &	coeff,
		int	grid,
		int	level,
		int	sideToCheck = `-1`,
		int	axisToCheck = `-1`
	)

References BoundaryConditionParameters::a, Overture::abort(), doubleMappedGridFunction::applyBoundaryConditionCoefficients(), assert, MappedGridOperators::assignCoefficients(), bc, bcParams, BCTypes::boundary(), boundaryCondition, MappedGrid::boundaryCondition(), boundaryConditionData, debug, debugFile, BCTypes::dirichlet, OgmgParameters::dirichlet, display(), dr, dx, equationToSolve, BCTypes::evenSymmetry, BCTypes::extrapolate, OgmgParameters::extrapolate, FOR_3D, FOR_M, fPrintF(), getBoundaryIndex(), MappedGrid::getDeltaX(), getGhostIndex(), ParallelUtility::getLocalArrayBounds(), doubleMappedGridFunction::getOperators(), getOrderOfExtrapolation(), SparseRepForMGF::ghost1, SparseRepForMGF::ghost2, BoundaryConditionParameters::ghostLineToAssign, MappedGrid::gridIndexRange(), MappedGrid::gridSpacing(), i2, ig1, MappedGrid::inverseVertexDerivative(), MappedGrid::isRectangular(), OgesParameters::laplaceEquation, MappedGridOperators::laplacianOperator, OgmgParameters::lowerLevelNeumannFirstGhostLineBC, mask, MappedGrid::mask(), BCTypes::mixed, OgmgParameters::mixed, multigridCompositeGrid, CompositeGrid::multigridLevel, BCTypes::neumann, OgmgParameters::neumann, GridCollection::numberOfDimensions(), MappedGrid::numberOfDimensions(), orderOfAccuracy, BoundaryConditionParameters::orderOfExtrapolation, OV_ABORT, OV_GET_SERIAL_ARRAY_CONST, parameters, printF(), RX, SparseRepForMGF::setClassify(), SparseRepForMGF::setCoefficientIndex(), GenericMappedGridOperators::setExtrapolationCoefficients(), MappedGridOperators::setOrderOfAccuracy(), doubleMappedGridFunction::sparse, SQR, MappedGrid::THEvertexBoundaryNormal, MappedGrid::update(), useEquationOnGhostLineForDirichletBC(), useEquationOnGhostLineForNeumannBC(), OgmgParameters::useEquationToSecondOrder, and OgmgParameters::useSymmetryForNeumannOnLowerLevels.

Referenced by buildPredefinedCoefficientMatrix(), and operatorAveraging().

int Ogmg::averageCoefficients	(	Index &	I1,
		Index &	I2,
		Index &	I3,
		Index &	I1p,
		Index &	I2p,
		Index &	I3p,
		Index &	J1,
		Index &	J2,
		Index &	J3,
		TransferTypesEnum	option[3],
		const realSerialArray &	cFine,
		realSerialArray &	cCoarse,
		int	ipar[]
	)

References Overture::abort(), assert, averageOpt, debug, debugFile, fPrintF(), fullWeighting, FW0_1D_0, FW0_1D_1, FW0_1D_2, FW1_1D_0, FW1_1D_1, FW1_1D_2, FW2_1D_0, FW2_1D_1, FW2_1D_2, injection, INJECTION_1D_0, INJECTION_1D_1, INJECTION_1D_2, mask, max(), min(), multigridCompositeGrid, GridCollection::numberOfDimensions(), orderOfAccuracy, OV_ABORT, and restrictedFullWeighting.

Referenced by operatorAveraging().

int Ogmg::buildCoefficientArrays ( )

Once the coefficient matrix is known on the finest level we can automatically build the coeff matrices on coarser levels.

Referenced by buildPredefinedEquations().

int Ogmg::buildExtraLevels ( CompositeGrid & mg )

int Ogmg::buildExtraLevelsNew ( CompositeGrid & mg )

Referenced by buildExtraLevels().

int Ogmg::buildPredefinedCoefficientMatrix	(	int	level,
		bool	buildRectangular,
		bool	buildCurvilinear
	)

Build the coefficient matrix for the predefined equations on a given level.

Parameters

buildRectangular	(input) : if true build coeff matrices for curvilinear grids. If true build matrices for rectangular ONLY. This is normally only done on the coarsest level if we have to call a direct solver.
buildCurvilinear	(input) if true, build coefficients for curvilinear grids.

References Overture::abort(), assert, assignBoundaryConditionCoefficients(), buff, cc, cMG, COEFFA, MappedGridOperators::coefficients(), CONC, constantCoefficients, debug, debugFile, displayCoeff(), MappedGridOperators::divergenceScalarGradient, OgesParameters::divScalarGradHeatEquationOperator, OgesParameters::divScalarGradOperator, equationCoefficients, equationToSolve, fabs(), FOR_3, getIndex(), ParallelUtility::getLocalArrayBounds(), getLocalArrayWithGhostBoundaries(), doubleMappedGridFunction::getOperators(), MappedGrid::gridIndexRange(), OgesParameters::heatEquationOperator, i2, MappedGrid::isRectangular(), OgesParameters::laplaceEquation, MappedGridOperators::laplacianOperator, mask, MappedGrid::mask(), multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, multiply(), NULL, GenericGridCollection::numberOfComponentGrids(), GridCollection::numberOfDimensions(), GenericGridCollection::numberOfMultigridLevels(), orderOfAccuracy, pow(), printF(), MappedGridOperators::setOrderOfAccuracy(), MappedGridOperators::setStencilSize(), sPrintF(), varCoeff, and OgesParameters::variableHeatEquationOperator.

Referenced by buildPredefinedEquations(), and operatorAveraging().

int Ogmg::buildPredefinedEquations ( CompositeGridOperators & cgop )

build the predefined equations

References assert, buildCoefficientArrays(), buildPredefinedCoefficientMatrix(), cMG, doubleGridCollectionFunction::destroy(), getCPU(), initializeConstantCoefficients(), multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, doubleGridCollectionFunction::numberOfComponentGrids(), GridCollection::numberOfDimensions(), numberOfExtraLevels, orderOfAccuracy, parameters, pow(), doubleGridCollectionFunction::setDataAllocationOption(), doubleCompositeGridFunction::setIsACoefficientMatrix(), doubleCompositeGridFunction::setOperators(), GenericCompositeGridOperators::setOrderOfAccuracy(), GenericCompositeGridOperators::setStencilSize(), timeForBuildPredefinedEquations, timeForInitialize, tm, doubleCompositeGridFunction::updateToMatchGrid(), OgmgParameters::useDirectSolverForOneLevel, and OgmgParameters::useDirectSolverOnCoarseGrid.

int Ogmg::buildPredefinedVariableCoefficients	(	RealCompositeGridFunction &	coeff,
		const int	level
	)

int Ogmg::checkForBetterQualityInterpolation	(	realSerialArray &	x,
		int	gridI,
		InterpolationQualityEnum &	interpolationQuality,
		CompositeGrid &	cg0,
		CompositeGrid &	cg1,
		int	i,
		int	iv[3],
		int	grid,
		int	l,
		intSerialArray &	inverseGrid,
		intSerialArray &	interpoleeGrid,
		intSerialArray &	interpoleeLocation,
		intSerialArray &	interpolationPoint,
		intSerialArray &	variableInterpolationWidth,
		realSerialArray &	interpolationCoordinates,
		realSerialArray &	inverseCoordinates
	)

Check to see if a point x can interpolate from gridI with a better quality interpolation.

/param gridI (input): try interpolating from this grid. /param interpolationQuality (input/output) : on input the current quality, on output the new quality /param inverseGrid, inverseCoordinates (input/output) :

References OgmgParameters::allowExtrapolationOfInterpolationPoints, assert, canInterpolateWithExtrapolation, debug, dr, End, fabs(), getInterpolationStencil(), i2, max(), min(), GenericGridCollection::numberOfComponentGrids(), GridCollection::numberOfDimensions(), parameters, pDebugFile, r, and Start.

Referenced by buildExtraLevels().

void Ogmg::checkParameters ( )

Check the validity of parameters.

Not all parameter values are valid or implemented, depending on the equation being solved, order of accuracy, etc.

References OgmgParameters::dirichletFirstGhostLineBC, equationToSolve, OgmgParameters::fourthOrderBoundaryConditionOption, OgesParameters::laplaceEquation, OgmgParameters::lowerLevelDirichletSecondGhostLineBC, OgmgParameters::lowerLevelNeumannSecondGhostLineBC, OgmgParameters::neumannSecondGhostLineBC, orderOfAccuracy, parameters, printF(), OgmgParameters::useEquationForDirichletOnLowerLevels, OgmgParameters::useEquationToSecondOrder, OgmgParameters::useExtrapolation, and OgmgParameters::useSymmetryForNeumannOnLowerLevels.

int Ogmg::chooseBestSmoother ( )

int Ogmg::coarseGridSolverTest ( int plotOption = 0 )

References BoundaryConditionParameters::a, axis1, axis2, bcParams, MappedGrid::boundaryCondition(), MappedGrid::center(), PlotIt::contour(), Oges::debug, MappedGrid::dimension(), directSolver, OgmgParameters::dirichlet, doubleGridCollectionFunction::display(), equationCoefficients, equationToSolve, fabs(), fMG, ForBoundary, getBoundaryIndex(), doubleCompositeGridFunction::getCompositeGrid(), getGhostIndex(), Overture::getGraphicsInterface(), getIndex(), ParallelUtility::getLocalArrayBounds(), getLocalArrayWithGhostBoundaries(), Oges::getMaximumResidual(), ParallelUtility::getMaxValue(), Oges::getNumberOfIterations(), GI_TOP_LABEL, MappedGrid::gridIndexRange(), OgesParameters::heatEquationOperator, MappedGrid::isRectangular(), Oges::isSolverIterative(), Mapping::mappingName, MappedGrid::mask(), max(), OgmgParameters::mixed, multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, normal, GenericGridCollection::numberOfComponentGrids(), GridCollection::numberOfDimensions(), MappedGrid::numberOfDimensions(), GenericGridCollection::numberOfMultigridLevels(), orderOfAccuracy, OV_GET_SERIAL_ARRAY, printF(), ps, psp, REAL_EPSILON, Oges::set(), GraphicsParameters::set(), Oges::solve(), MappedGrid::THEcenter, OgesParameters::THEmaximumNumberOfIterations, OgesParameters::THErelativeTolerance, MappedGrid::THEvertex, MappedGrid::THEvertexBoundaryNormal, uMG, MappedGrid::update(), MappedGrid::vertexBoundaryNormal(), and MappedGrid::vertexBoundaryNormalArray().

Referenced by main().

void Ogmg::coarseToFine ( const int & level )

void Ogmg::coarseToFine	(	const int &	level,
		const int &	grid
	)

int Ogmg::coarseToFineTest ( )

void Ogmg::computeDefect ( int level )

inline

References defect().

Referenced by main().

void Ogmg::computeDefectRatios ( int level )

References OgmgParameters::autoSubSmoothDetermination, defectMG, defectRatio, l2Norm(), multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, GenericGridCollection::numberOfComponentGrids(), parameters, and OgmgParameters::useNewAutoSubSmooth.

Referenced by cycle(), and smooth().

int Ogmg::computeLeftNullVector ( )

References SparseRepForMGF::boundary, c, CLASSIFY, cMG, OgmgParameters::computeAndSaveNullVector, debug, MappedGrid::dimension(), display(), doubleGridCollectionFunction::display(), FOR_3D, Oges::get(), getCPU(), getIndex(), ParallelUtility::getLocalArrayBounds(), Oges::getMaximumResidual(), Oges::getNumberOfIterations(), SparseRepForMGF::ghost1, SparseRepForMGF::ghost2, i2, Oges::initialize(), SparseRepForMGF::interior, Oges::isSolverIterative(), Integrate::leftNullVector(), leftNullVector, leftNullVectorIsComputed, mask, multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, NULL, NULLVECTOR, OgmgParameters::nullVectorOption, OgmgParameters::nullVectorParameters, GenericGridCollection::numberOfComponentGrids(), GridCollection::numberOfDimensions(), numberOfGridPoints, GenericGridCollection::numberOfMultigridLevels(), orderOfAccuracy, OV_GET_SERIAL_ARRAY, OV_GET_SERIAL_ARRAY_CONST, parameters, printF(), readLeftNullVector(), OgmgParameters::readOrComputeAndSaveNullVector, REAL_EPSILON, saveLeftNullVector(), Oges::set(), Oges::setCoefficientArray(), Oges::setExtraEquationValues(), Oges::setOgesParameters(), Oges::solve(), doubleGridCollectionFunction::sparse, sPrintF(), OgesParameters::THEabsoluteTolerance, OgesParameters::THEbestIterativeSolver, OgesParameters::THEcompatibilityConstraint, OgesParameters::THEfixupRightHandSide, OgesParameters::THErelativeTolerance, OgesParameters::THEsolveForTranspose, OgesParameters::THEtolerance, Oges::updateToMatchGrid(), and OgmgParameters::useDirectSolverOnCoarseGrid.

Referenced by addAdjustmentForSingularProblem().

int Ogmg::cycle	(	const int &	level,
		const int &	iteration,
		real &	maximumDefect,
		const int &	numberOfCycleIterations
	)

References OgmgParameters::absoluteTolerance, addAdjustmentForSingularProblem(), assign(), buff, coarseToFine(), computeDefectRatios(), PlotIt::contour(), OgmgParameters::convergenceCriteria, OgmgParameters::cycleType, OgmgParameters::cycleTypeF, debug, debugFile, defect(), defectMaximumNorm(), defectMG, defectNorm(), defectRatio, directSolver, GenericGraphicsInterface::erase(), fineToCoarse(), fMG, fullMultigridWorkUnits, getCPU(), Oges::getNumberOfIterations(), GI_TOP_LABEL, GenericGraphicsInterface::isGraphicsWindowOpen(), Oges::isSolverIterative(), iterationCount, l2NormRightHandSide, max(), maxNorm(), OgmgParameters::meanValueForSingularProblem, OgmgParameters::minimumNumberOfInitialSmooths, multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, OgmgParameters::numberOfCycles, numberOfCycles, GridCollection::numberOfDimensions(), numberOfGridPoints, OgmgParameters::numberOfIterationsOnCoarseGrid, GenericGridCollection::numberOfMultigridLevels(), OgmgParameters::numberOfSmooths, orderOfAccuracy, outputResults(), parameters, pow(), printF(), OgmgParameters::problemIsSingular, ps, psp, REAL_MAX, OgmgParameters::residualConverged, OgmgParameters::residualConvergedOldWay, OgmgParameters::residualTolerance, GraphicsParameters::set(), Oges::setExtraEquationValues(), setMean(), OgmgParameters::showSmoothingRates, smooth(), Oges::solve(), sPrintF(), timeForDirectSolver, tm, totalNumberOfCoarseGridIterations, uMG, OgmgParameters::useDirectSolverOnCoarseGrid, and workUnits.

Referenced by fullMultigrid().

void Ogmg::defect ( const int & level )

Referenced by applyBoundaryConditions(), coarseToFine(), computeDefect(), cycle(), defectNorm(), evaluateTheDefectFormula(), fullMultigrid(), getDefect(), main(), outputResults(), smooth(), smoothBoundary(), smoothInterpolationNeighbours(), smoothJacobi(), smoothLine(), smoothRedBlack(), and smoothTest().

void Ogmg::defect	(	const int &	level,
		const int &	grid
	)

real Ogmg::defectMaximumNorm	(	const int &	level,
		int	approximationStride = `1`
	)

References defectNorm(), max(), multigridCompositeGrid, and CompositeGrid::multigridLevel.

Referenced by cycle().

real Ogmg::defectNorm	(	const int &	level,
		const int &	grid,
		int	option = `0`,
		int	approximationStride = `8`
	)

void Ogmg::displaySmoothers	(	const aString &	label,
		FILE *	file = `stdout`
	)

References fPrintF(), multigridCompositeGrid, GenericGridCollection::numberOfComponentGrids(), GenericGridCollection::numberOfMultigridLevels(), OgmgParameters::numberOfSmooths, parameters, smooth(), OgmgParameters::smootherName, and OgmgParameters::smootherType.

void Ogmg::evaluateTheDefectFormula	(	const int &	level,
		const int &	grid,
		const realArray &	c,
		const realArray &	u,
		const realArray &	f,
		realArray &	defect,
		MappedGrid &	mg,
		const Index &	I1,
		const Index &	I2,
		const Index &	I3,
		const Index &	I1u,
		const Index &	I2u,
		const Index &	I3u,
		const int	lineSmoothOption
	)

void Ogmg::fineToCoarse	(	const int &	level,
		bool	transferForcing = `false`
	)

void Ogmg::fineToCoarse	(	const int &	level,
		const int &	grid,
		bool	transferForcing = `false`
	)

References assert, assign(), axis1, axis2, axis3, bc, bcSupplied, BOUNDARY_DEFECT_2D, BOUNDARY_DEFECT_3D, boundaryCondition, boundaryConditionData, cf, defectMG, End, OgmgParameters::equation, equationToSolve, OgesParameters::extrapolate, OgmgParameters::extrapolate, fabs(), fineToCoarseBoundaryConditions, OgmgParameters::fineToCoarseTransferWidth, fMG, ForBoundary, FULL_WEIGHTING_1D, FULL_WEIGHTING_2D, FULL_WEIGHTING_3D, Interpolate::fullWeighting100, Interpolate::fullWeighting110, Interpolate::fullWeighting111, getBoundaryIndex(), getCPU(), getGhostIndex(), getIndex(), ParallelUtility::getLocalArrayBounds(), getLocalArrayWithGhostBoundaries(), MappedGrid::gridIndexRange(), IndexBB(), MappedGrid::indexRange(), Interpolate::injection, interp, Interpolate::interpolateCoarseFromFine(), mask, MappedGrid::mask(), max(), min(), OgesParameters::mixed, CompositeGrid::multigridCoarseningRatio, multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, OgesParameters::neumann, MappedGrid::numberOfDimensions(), OV_ABORT, parameters, printF(), Start, timeForFineToCoarseBC, timeForGhostBoundaryUpdate, timeForInterpolateCoarseFromFine, tm, update(), OgmgParameters::useNewFineToCoarseBC, and OgesParameters::userDefined.

int Ogmg::fineToCoarseTest ( )

References debug, debugFile, defectMG, MappedGrid::dimension(), display(), doubleGridCollectionFunction::display(), extendedGridIndexRange(), fabs(), fineToCoarse(), fMG, fPrintF(), getCPU(), getIndex(), ParallelUtility::getLocalArrayBounds(), getLocalArrayWithGhostBoundaries(), ParallelUtility::getMaxValue(), i2, il, CompositeGrid::interpolationPoint, CompositeGrid::interpoleeLocation, ip, MappedGrid::mask(), max(), multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, GenericGridCollection::numberOfComponentGrids(), GridCollection::numberOfDimensions(), CompositeGrid::numberOfInterpolationPoints, GenericGridCollection::numberOfMultigridLevels(), printF(), sPrintF(), MappedGrid::THEcenter, MappedGrid::THEvertex, timeForInterpolateCoarseFromFine, tm, uMG, CompositeGrid::update(), and CompositeGrid::variableInterpolationWidth.

Referenced by main().

FILE* Ogmg::getCheckFile ( )

inline

References checkFile.

Referenced by main().

CompositeGrid& Ogmg::getCompositeGrid ( )

inline

References multigridCompositeGrid.

Referenced by main().

realCompositeGridFunction& Ogmg::getDefect ( )

inline

References defectMG.

Referenced by defectNorm(), main(), smoothJacobi(), smoothLine(), and smoothRedBlack().

real Ogmg::getDefect	(	const int &	level,
		const int &	grid,
		realArray &	f,
		realArray &	u,
		const Index &	I1,
		const Index &	I2,
		const Index &	I3,
		realArray &	defect,
		const int	lineSmoothOption = `-1`,
		const int	defectOption = `0`,
		real &	defectL2Norm = `bogusRealArgument1`,
		real &	defectMaxNorm = `bogusRealArgument2`
	)

References assert, assumeSparseStencilForRectangularGrids, c, cMG, constantCoeff, constantCoefficients, defect(), defectNorm(), defectOpt, MappedGrid::dimension(), OgesParameters::divScalarGradHeatEquationOperator, OgesParameters::divScalarGradOperator, dx, equationToSolve, evaluateTheDefectFormula(), general, MappedGrid::getDeltaX(), getLocalArrayWithGhostBoundaries(), ParallelUtility::getMaxValue(), doubleMappedGridFunction::getOperators(), ParallelUtility::getSum(), ia, MappedGrid::isRectangular(), mask, MappedGrid::mask(), max(), min(), multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, nab, NULL, MappedGrid::numberOfDimensions(), numberOfExtraLevels, GenericGridCollection::numberOfMultigridLevels(), orderOfAccuracy, parameters, sparse, sparseConstantCoefficients, sparseVariableCoefficients, OgmgParameters::useOptimizedVersion, OgesParameters::userDefined, varCoeff, variableCoefficients, and OgesParameters::variableHeatEquationOperator.

OgmgParameters::FourthOrderBoundaryConditionEnum Ogmg::getGhostLineBoundaryCondition	(	int	bc,
		int	ghostLine,
		int	grid,
		int	level,
		int &	orderOfExtrapolation,
		aString *	bcName = `NULL`
	)		const

References Overture::abort(), assert, OgmgParameters::equation, OgmgParameters::extrapolate, MappedGrid::isRectangular(), OgesParameters::laplaceEquation, CompositeGrid::multigridLevel, NULL, OV_ABORT, sPrintF(), OgmgParameters::useEquationToFourthOrder, OgmgParameters::useEquationToSecondOrder, OgmgParameters::useExtrapolation, OgmgParameters::useSymmetry, and OgmgParameters::useUnknown.

Referenced by applyBoundaryConditions().

FILE* Ogmg::getInfoFile ( )

inline

References infoFile.

Referenced by main().

int Ogmg::getInterpolationCoordinates	(	CompositeGrid &	cg0,
		CompositeGrid &	cg1,
		const IntegerArray &	ib,
		const int	grid,
		const IntegerArray &	gridsToCheck,
		realSerialArray &	rb,
		const bool	isRectangular,
		int	iv0[3],
		real	dx0[3],
		real	xab0[2][3],
		int	iv1[3],
		real	dx1[3],
		real	xab1[2][3]
	)

References OgmgParameters::allowExtrapolationOfInterpolationPoints, Mapping::approximateGlobalInverse, assert, axis3, Mapping::bogus, MappedGrid::boundaryCondition(), MappedGrid::center(), CENTER, center, CENTER0, CENTER00, CENTER01, CENTER02, CENTER10, CENTER11, CENTER12, debug, MappedGrid::dimension(), dr, dx, End, MappedGrid::extendedIndexRange(), fabs(), ApproximateGlobalInverse::findNearestGridPoint(), MappedGrid::getDeltaX(), getLocalArrayWithGhostBoundaries(), MappingRC::getMapping(), MappedGrid::gridSpacing(), i2, ia, IA, IB, MappedGrid::indexRange(), CompositeGrid::interpolationCoordinates, INTERPOLATIONCOORDINATES0, CompositeGrid::interpolationPoint, INTERPOLATIONPOINT0, CompositeGrid::interpoleeGrid, INTERPOLEEGRID0, Mapping::inverseMap(), Mapping::inverseMapS(), MappedGrid::isRectangular(), MappedGrid::mapping(), max(), min(), GenericGridCollection::numberOfComponentGrids(), GridCollection::numberOfDimensions(), OV_ABORT, parameters, printF(), r, R, RB, Start, Mapping::useRobustInverse(), Mapping::usingRobustInverse(), X, x, and XR.

Referenced by buildExtraLevels().

int Ogmg::getInterpolationCoordinates	(	CompositeGrid &	cg0,
		CompositeGrid &	cg1,
		const IntegerArray &	ib,
		const int	grid,
		const IntegerArray &	gridsToCheck,
		realSerialArray &	rb,
		const bool	isRectangular,
		int	iv0[3],
		real	dx0[3],
		real	xab0[2][3],
		int	iv1[3],
		real	dx1[3],
		real	xab1[2][3],
		InterpolationData &	ipd
	)

References OgmgParameters::allowExtrapolationOfInterpolationPoints, Mapping::approximateGlobalInverse, assert, axis3, MappedGrid::boundaryCondition(), MappedGrid::center(), CENTER, center, CENTER0, CENTER00, CENTER01, CENTER02, CENTER10, CENTER11, CENTER12, ci0, debug, MappedGrid::dimension(), dr, dx, End, MappedGrid::extendedIndexRange(), fabs(), ApproximateGlobalInverse::findNearestGridPoint(), MappedGrid::getDeltaX(), getLocalArrayWithGhostBoundaries(), MappingRC::getMapping(), MappedGrid::gridIndexRange(), MappedGrid::gridSpacing(), i2, IA, IB, ig0, MappedGrid::indexRange(), InterpolationData::interpolationCoordinates, CompositeGrid::interpolationCoordinates, InterpolationData::interpolationPoint, CompositeGrid::interpolationPoint, InterpolationData::interpoleeGrid, CompositeGrid::interpoleeGrid, Mapping::inverseMap(), Mapping::inverseMapS(), ip0, MappedGrid::isRectangular(), MappedGrid::mapping(), Mapping::mapS(), max(), min(), NULL, GenericGridCollection::numberOfComponentGrids(), GridCollection::numberOfDimensions(), OV_ABORT, parameters, printF(), r, R, RB, Start, Mapping::useRobustInverse(), Mapping::usingRobustInverse(), X, x, XC, and XR.

int Ogmg::getInterpolationCoordinates	(	CompositeGrid &	cg0,
		CompositeGrid &	cg1,
		int	i,
		int	grid,
		int	iv[],
		int	jv[],
		realSerialArray &	r,
		bool	isRectangular,
		int	iv0[3],
		real	dx0[3],
		real	xab0[2][3],
		int	iv1[3],
		real	dx[3],
		real	xab[2][3]
	)

int Ogmg::getInterpolationCoordinatesNew	(	CompositeGrid &	cg0,
		CompositeGrid &	cg1,
		const IntegerArray &	ib,
		const RealArray &	xa,
		const int	grid,
		const IntegerArray &	gridsToCheck,
		realSerialArray &	rb,
		const bool	isRectangular,
		int	iv0[3],
		real	dx0[3],
		real	xab0[2][3],
		int	iv1[3],
		real	dx1[3],
		real	xab1[2][3],
		InterpolationData &	ipd,
		IntegerArray &	ia0,
		realSerialArray &	donorDist
	)

References abs(), OgmgParameters::allowExtrapolationOfInterpolationPoints, assert, axis1, axis2, axis3, Mapping::bogus, MappedGrid::boundaryCondition(), canInterpolateQuality1, canInterpolateQualityBad, canInterpolateQualityVeryBad, canInterpolateWithExtrapolation, canNotInterpolate, MappedGrid::center(), center, CENTER0, CENTER00, CENTER01, CENTER02, CENTER10, CENTER11, CENTER12, cf, ci0, debug, dr, dx, End, MappedGrid::extendedIndexRange(), fabs(), MappedGrid::getDeltaX(), getLocalArrayWithGhostBoundaries(), MappingRC::getMapping(), ParallelUtility::getMaxValue(), Mapping::getName(), MappedGrid::gridIndexRange(), MappedGrid::gridSpacing(), i2, IA, IA0, IB, ig0, InterpolationData::interpolationCoordinates, CompositeGrid::interpolationCoordinates, InterpolationData::interpolationPoint, CompositeGrid::interpolationPoint, InterpolationData::interpoleeGrid, CompositeGrid::interpoleeGrid, Mapping::inverseMap(), Mapping::inverseMapS(), ip0, MappedGrid::isRectangular(), MappedGrid::mapping(), Mapping::mappingName, Mapping::mapS(), max(), min(), CompositeGrid::multigridCoarseningRatio, multigridCompositeGrid, myid, GenericGridCollection::numberOfComponentGrids(), GridCollection::numberOfDimensions(), parameters, pDebugFile, r, R, RB, REAL_MAX, REAL_MIN, SQR, Start, Mapping::useRobustInverse(), X, x, XA, and XR.

Referenced by buildExtraLevelsNew().

int Ogmg::getInterpolationCoordinatesNewOld	(	CompositeGrid &	cg0,
		CompositeGrid &	cg1,
		const IntegerArray &	ib,
		const RealArray &	xa,
		const int	grid,
		const IntegerArray &	gridsToCheck,
		realSerialArray &	rb,
		const bool	isRectangular,
		int	iv0[3],
		real	dx0[3],
		real	xab0[2][3],
		int	iv1[3],
		real	dx1[3],
		real	xab1[2][3],
		InterpolationData &	ipd
	)

References abs(), OgmgParameters::allowExtrapolationOfInterpolationPoints, assert, axis1, axis2, axis3, Mapping::bogus, MappedGrid::boundaryCondition(), MappedGrid::center(), center, CENTER0, CENTER00, CENTER01, CENTER02, CENTER10, CENTER11, CENTER12, cf, ci0, debug, dr, dx, End, MappedGrid::extendedIndexRange(), fabs(), MappedGrid::getDeltaX(), getLocalArrayWithGhostBoundaries(), MappingRC::getMapping(), Mapping::getName(), MappedGrid::gridIndexRange(), MappedGrid::gridSpacing(), i2, IA, IB, ig0, InterpolationData::interpolationCoordinates, CompositeGrid::interpolationCoordinates, InterpolationData::interpolationPoint, CompositeGrid::interpolationPoint, InterpolationData::interpoleeGrid, CompositeGrid::interpoleeGrid, Mapping::inverseMap(), Mapping::inverseMapS(), ip0, MappedGrid::isRectangular(), MappedGrid::mapping(), Mapping::mappingName, Mapping::mapS(), max(), min(), CompositeGrid::multigridCoarseningRatio, multigridCompositeGrid, myid, GenericGridCollection::numberOfComponentGrids(), GridCollection::numberOfDimensions(), parameters, pDebugFile, r, R, RB, REAL_MIN, Start, Mapping::useRobustInverse(), X, x, XA, and XR.

Referenced by buildExtraLevelsNew().

Ogmg::InterpolationQualityEnum Ogmg::getInterpolationStencil	(	CompositeGrid &	cg0,
		CompositeGrid &	cg1,
		int	i,
		int	iv[3],
		int	grid,
		int	l,
		intSerialArray &	inverseGrid,
		intSerialArray &	interpoleeGrid,
		intSerialArray &	interpoleeLocation,
		intSerialArray &	interpolationPoint,
		intSerialArray &	variableInterpolationWidth,
		realSerialArray &	interpolationCoordinates,
		realSerialArray &	inverseCoordinates
	)

References Overture::abort(), assert, axis1, axis3, boundaryCondition, MappedGrid::boundaryCondition(), canInterpolateQuality1, canInterpolateQuality2, canInterpolateQuality3, canInterpolateQualityBad, canInterpolateWithExtrapolation, canNotInterpolate, debug, dr, End, extendedIndexRange, MappedGrid::extendedIndexRange(), FALSE, getLocalArrayWithGhostBoundaries(), gridSpacing, MappedGrid::gridSpacing(), i2, indexRange, MappedGrid::indexRange(), CompositeGrid::interpolationWidth, MappedGrid::isCellCentered(), MappedGrid::ISinterpolationPoint, MappedGrid::isPeriodic(), MappedGrid::mask(), MASK2, mask2, MASK2_W4B, MASK2_W4C, MASK2_W5B, MASK2_W5C, MASK2D, multigridCompositeGrid, GenericGridCollection::numberOfComponentGrids(), GridCollection::numberOfDimensions(), pDebugFile, printF(), SQR, Start, and TRUE.

Referenced by buildExtraLevels(), and checkForBetterQualityInterpolation().

real Ogmg::getMaximumResidual ( ) const

Referenced by main(), and MultigridEquationSolver::solve().

real Ogmg::getMean ( realCompositeGridFunction & u )

Referenced by main().

int Ogmg::getNumberOfIterations ( ) const

Referenced by main(), and MultigridEquationSolver::solve().

int Ogmg::getOrderOfExtrapolation ( const int level ) const

Return the order of extrapolation to use for a given order of accuracy and level.

References levelZero, and orderOfAccuracy.

Referenced by applyBoundaryConditions(), assignBoundaryConditionCoefficients(), and operatorAveraging().

realCompositeGridFunction& Ogmg::getRhs ( )

inline

References fMG.

Referenced by main().

int Ogmg::getSingularParameter ( int level )

problems: alpha(level) = (leftNullVector,f)/(leftNullVector,rightNullVector)

References alpha, debug, dimension, F, fMG, FOR_3D, getIndex(), ParallelUtility::getLocalArrayBounds(), ParallelUtility::getSums(), i2, LEFTNULL, multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, GenericGridCollection::numberOfComponentGrids(), GenericGridCollection::numberOfMultigridLevels(), OV_GET_SERIAL_ARRAY, printF(), RIGHTNULL, and rightNullVector.

Referenced by addAdjustmentForSingularProblem().

int Ogmg::initializeConstantCoefficients ( )

References Overture::abort(), assert, OgmgParameters::averagingOption, c, CC, cMG, constantCoefficients, OgesParameters::divScalarGradHeatEquationOperator, OgesParameters::divScalarGradOperator, OgmgParameters::doNotAverageCoarseGridEquations, dx, equationCoefficients, equationToSolve, MappedGrid::extendedIndexRange(), fabs(), FALSE, fPrintF(), MappedGrid::getDeltaX(), getIndex(), MappingRC::getName(), doubleMappedGridFunction::getOperators(), gridCheckFile, OgesParameters::heatEquationOperator, isConstantCoefficients, MappedGridOperators::isRectangular(), MappedGrid::isRectangular(), OgesParameters::laplaceEquation, MappedGrid::mapping(), Mapping::mappingName, mask, MappedGrid::mask(), max(), min(), multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, myid, NULL, GenericGridCollection::numberOfComponentGrids(), GridCollection::numberOfDimensions(), MappedGrid::numberOfDimensions(), GenericGridCollection::numberOfMultigridLevels(), orderOfAccuracy, parameters, pow(), REAL_EPSILON, OgmgParameters::saveGridCheckFile, TRUE, OgesParameters::userDefined, and OgesParameters::variableHeatEquationOperator.

Referenced by buildCoefficientArrays(), and buildPredefinedEquations().

int Ogmg::interpolate	(	realCompositeGridFunction &	u,
		const int &	grid = `-1`,
		int	level = `-1`
	)

real Ogmg::l2Norm ( const realCompositeGridFunction & e )

References c, MappedGrid::dimension(), evaluate(), getIndex(), doubleGridCollectionFunction::gridCollection, MappedGrid::gridIndexRange(), l2normOpt, mask, MappedGrid::mask(), max(), GenericGridCollection::numberOfComponentGrids(), parameters, and OgmgParameters::useOptimizedVersion.

Referenced by computeDefectRatios(), outputResults(), and smooth().

real Ogmg::l2Norm ( const realMappedGridFunction & e )

References evaluate(), getIndex(), getLocalArrayWithGhostBoundaries(), doubleMappedGridFunction::getMappedGrid(), ParallelUtility::getSum(), gid, MappedGrid::gridIndexRange(), l2normOpt, mask, MappedGrid::mask(), max(), min(), MappedGrid::numberOfDimensions(), parameters, and OgmgParameters::useOptimizedVersion.

int Ogmg::markGhostPoints ( CompositeGrid & cg )

Referenced by buildExtraLevels(), and buildExtraLevelsNew().

real Ogmg::maxNorm ( const realMappedGridFunction & e )

References fabs(), getIndex(), getLocalArrayWithGhostBoundaries(), doubleMappedGridFunction::getMappedGrid(), getMaxNormOpt, ParallelUtility::getMaxValue(), gid, MappedGrid::gridIndexRange(), MappedGrid::mask(), max(), maxNorm(), min(), MappedGrid::numberOfDimensions(), parameters, and OgmgParameters::useOptimizedVersion.

int Ogmg::operatorAveraging	(	RealCompositeGridFunction &	coeff,
		const int &	level
	)

int Ogmg::operatorAveraging	(	RealMappedGridFunction &	coeffFine,
		RealMappedGridFunction &	coeffCoarse,
		const IntegerArray &	coarseningRatio,
		int	grid = `0`,
		int	level = `0`
	)

References BoundaryConditionParameters::a, Overture::abort(), doubleMappedGridFunction::applyBoundaryConditionCoefficients(), assert, assignBoundaryConditionCoefficients(), MappedGridOperators::assignCoefficients(), aString, averageCoefficients(), OgmgParameters::averagingOption, axis1, axis2, axis3, bc, bcParams, BCTypes::boundary(), BCTypes::boundary1, OgmgParameters::boundaryAveragingOption, boundaryCondition, MappedGrid::boundaryCondition(), boundaryConditionData, doubleMappedGridFunction::breakReference(), buff, buildPredefinedCoefficientMatrix(), C, c, cf, MappedGridOperators::coefficients(), CopyArray::copyArray(), debug, debugFile, MappedGrid::dimension(), BCTypes::dirichlet, display(), displayCoeff(), OgmgParameters::doNotAverageCoarseCurvilinearGridEquations, OgmgParameters::doNotAverageCoarseGridEquations, E, End, OgmgParameters::equation, equationToSolve, BCTypes::evenSymmetry, BCTypes::extrapolate, OgesParameters::extrapolate, OgmgParameters::extrapolate, FOR_3, FOR_3D, ForStencil, OgmgParameters::fourthOrderBoundaryConditionOption, fPrintF(), fullWeighting, getBoundaryIndex(), getGhostIndex(), getIndex(), ParallelUtility::getLocalArrayBounds(), getLocalArrayWithGhostBoundaries(), doubleMappedGridFunction::getMappedGrid(), doubleMappedGridFunction::getOperators(), getOrderOfExtrapolation(), SparseRepForMGF::ghost1, OgmgParameters::ghostLineAveragingOption, BoundaryConditionParameters::ghostLineToAssign, gridCheckFile, MappedGrid::gridIndexRange(), i2, ia, ig1, OgmgParameters::imposeDirichlet, OgmgParameters::imposeExtrapolation, OgmgParameters::imposeNeumann, IndexBB(), MappedGrid::indexRange(), MappedGrid::isPeriodic(), MappedGrid::isRectangular(), OgesParameters::laplaceEquation, MappedGridOperators::laplacianOperator, OgmgParameters::lowerLevelNeumannFirstGhostLineBC, OgmgParameters::lumpedPartialWeighting, M123CE, MappedGrid::mask(), max(), BCTypes::mixed, OgmgParameters::mixed, multigridCompositeGrid, myid, BCTypes::neumann, OgmgParameters::neumann, Mapping::notPeriodic, NULL, GridCollection::numberOfDimensions(), MappedGrid::numberOfDimensions(), MappedGrid::numberOfGhostPoints(), GenericGridCollection::numberOfMultigridLevels(), orderOfAccuracy, BoundaryConditionParameters::orderOfExtrapolation, OgmgParameters::orderOfExtrapolationForDirichletOnLowerLevels, OV_ABORT, parameters, OgmgParameters::partialWeighting, pDebugFile, doubleMappedGridFunction::periodicUpdate(), pow(), printF(), doubleMappedGridFunction::reference(), restrictedFullWeighting, OgmgParameters::saveGridCheckFile, SparseRepForMGF::setClassify(), SparseRepForMGF::setCoefficientIndex(), GenericMappedGridOperators::setExtrapolationCoefficients(), MappedGridOperators::setOrderOfAccuracy(), MappedGridOperators::setStencilSize(), doubleMappedGridFunction::sparse, sPrintF(), Start, OgmgParameters::useDirectSolverOnCoarseGrid, useEquationOnGhostLineForDirichletBC(), useEquationOnGhostLineForNeumannBC(), OgmgParameters::useEquationToSecondOrder, OgesParameters::userDefined, OgmgParameters::useSymmetry, and OgmgParameters::useSymmetryForNeumannOnLowerLevels.

int Ogmg::outputCycleInfo ( )

Output results about the cycle convergence rates etc. in a form suitable for matlab.

References aString, OgmgParameters::autoSubSmoothDetermination, buff, cycleResults, OgmgParameters::cycleType, OgmgParameters::cycleTypeF, defectPerCycle, fPrintF(), grid0DefectPerCycle, infoFileCaption, max(), multigridCompositeGrid, myid, GenericGridCollection::numberOfComponentGrids(), OgmgParameters::numberOfCycles, numberOfCycles, numberOfGridPoints, numberOfIterations, GenericGridCollection::numberOfMultigridLevels(), OgmgParameters::numberOfSmooths, OgmgParameters::outputMatlabFile, parameters, pow(), OgmgParameters::showSmoothingRates, sPrintF(), and workUnitsPerCycle.

int Ogmg::outputResults	(	const int &	level,
		const int &	iteration,
		real &	maximumDefect,
		real &	defectNew,
		real &	defectOld
	)

Output results for this multigrid cycle.

References checkFile, cycleResults, debug, defect(), defectMG, defectPerCycle, defectRatio, fPrintF(), getCPU(), grid0DefectPerCycle, gridName, infoFile, l2Norm(), max(), maxNorm(), multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, myid, GenericGridCollection::numberOfComponentGrids(), numberOfCycles, GenericGridCollection::numberOfMultigridLevels(), OgmgParameters::numberOfSubSmooths, OgmgParameters::outputMatlabFile, parameters, pow(), printF(), REAL_MIN, OgmgParameters::showSmoothingRates, timeForMiscellaneous, tm, totalResidualReduction, totalWorkUnits, workUnits, and workUnitsPerCycle.

Referenced by cycle().

void Ogmg::printStatistics ( FILE * file = stdout ) const

Referenced by main().

int Ogmg::readLeftNullVector ( )

int Ogmg::removeAdjustmentForSingularProblem	(	int	level,
		int	iteration
	)

Remove the adjustment to the right-handside for a singular problem.

==================================================================================

References alpha, dimension, F, fMG, FOR_3D, getIndex(), ParallelUtility::getLocalArrayBounds(), i2, multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, GenericGridCollection::numberOfComponentGrids(), OV_GET_SERIAL_ARRAY, parameters, OgmgParameters::problemIsSingular, RIGHTNULL, and rightNullVector.

real Ogmg::rightNullVectorDotU	(	const int &	level,
		const RealCompositeGridFunction &	u
	)

References multigridCompositeGrid, doubleCompositeGridFunction::multigridLevel, CompositeGrid::multigridLevel, and rightNullVector.

Referenced by addAdjustmentForSingularProblem().

void Ogmg::set ( GenericGraphicsInterface * ps )

Referenced by main(), and MultigridEquationSolver::set().

void Ogmg::set ( MultigridCompositeGrid & mgcg )

Supply a MultigridCompositeGrid to use.

Parameters

mgcg	(input) : use this object to hold the multigrid hierarchy.

The MultigridCompositeGrid object can be used to share a multigrid hierarchy amongst different applications and means that the coarse grid levels need only be generated once.

int Ogmg::setBoundaryConditions	(	const IntegerArray &	boundaryConditions,
		const RealArray &	bcData = `Overture::nullRealArray()`
	)

int Ogmg::setCoefficientArray	(	realCompositeGridFunction &	coeff,
		const IntegerArray &	boundaryConditions = `Overture::nullIntArray()`,
		const RealArray &	bcData = `Overture::nullRealArray()`
	)

Referenced by main(), MultigridEquationSolver::setCoefficientArray(), MultigridEquationSolver::setCoefficientsAndBoundaryConditions(), and MultigridEquationSolver::solve().

int Ogmg::setCornerBoundaryConditions	(	BoundaryConditionParameters &	bcParams,
		const int	level
	)

Set the boundary condition parameters for edges and corners.

References BoundaryConditionParameters::numberOfCornerGhostLinesToAssign, orderOfAccuracy, BoundaryConditionParameters::orderOfExtrapolation, parameters, BoundaryConditionParameters::setCornerBoundaryCondition(), BoundaryConditionParameters::taylor2ndOrderEvenCorner, BoundaryConditionParameters::taylor4thOrderEvenCorner, and OgmgParameters::useSymmetryCornerBoundaryCondition.

Referenced by buildCoefficientArrays().

int Ogmg::setEquationAndBoundaryConditions	(	OgesParameters::EquationEnum	equation_,
		CompositeGridOperators &	op,
		const IntegerArray &	bc_,
		const RealArray &	bcData,
		const RealArray &	constantCoeff = `Overture::nullRealArray()`,
		realCompositeGridFunction *	variableCoeff = `NULL`
	)

Specify the (predefined) equation to solve. **this is not finished yet **.

Parameters

bc(0:1,0:2,numberOfComponentGrids)	(input): boundary conditions, Ogmg::dirichlet, neumann or mixed.
bcData(0:1,0:1,0:2,numberOfComponentGrids)	(input): For a neumann BC, a(0:1)=bcData(0:1,side,axis,grid) are the coefficients of u and du/dn : a(0)u + a(1)u.n
constantCoeff	(input) : For equation_==heatEquationOperator we solve constantCoeff(0,grid)I + constantCoeff(1,grid)Laplacian

Notes: updateToMatchGrid should be called before this function. It is assumed that the extra grid levels have already been generated. When calling MG through Oges, the MultigridEquationSolver: function setEquationAndBoundaryConditions will call Ogmg::updateToMatchGrid before calling this function.

Referenced by main(), and MultigridEquationSolver::setEquationAndBoundaryConditions().

void Ogmg::setGridName ( const aString & name )

/brief Set the name for the composite grid. /param name (input) : name for the composite grid (used for labels for e.g.)

Referenced by main(), and MultigridEquationSolver::MultigridEquationSolver().