This class represents a structure solver using the Finite Cell Method. More...

#include <fcsolver.h>

Inheritance diagram for FcSolver< nDim_ >:

Collaboration diagram for FcSolver< nDim_ >:

Public Types
using	Cell = typename maia::grid::tree::Tree< nDim >::Cell

using	SolverCell = FcCell

using	CartesianSolver = typename maia::CartesianSolver< nDim, FcSolver >

using	Grid = typename CartesianSolver::Grid

using	GridProxy = typename CartesianSolver::GridProxy

using	Fd = FcDescriptor< nDim >

using	Geom = Geometry< nDim >

Public Types inherited from maia::CartesianSolver< nDim_, FcSolver< nDim_ > >
using	Grid = CartesianGrid< nDim >

using	GridProxy = typename maia::grid::Proxy< nDim >

using	Geom = Geometry< nDim >

using	TreeProxy = maia::grid::tree::TreeProxy< nDim >

using	Cell = maia::grid::tree::Cell

Public Member Functions
MInt	noInternalCells () const override
	Return the number of internal cells within this solver. More...

MBool	a_isBndryCell (const MInt cellId) const
	Returns isBndryCell of the cell `CellId`. More...

maia::fc::cell::BitsetType::reference	a_isBndryCell (const MInt cellId)
	Returns isBndryCell of the cell `CellId`. More...

MBool	a_isWindow (const MInt cellId) const
	Returns isInterface of the cell `CellId`. More...

maia::fc::cell::BitsetType::reference	a_isWindow (const MInt cellId)
	Returns isInterface of the cell `CellId`. More...

MFloat &	a_alpha (const MInt cellId)
	Returns alpha of the cell `cellId`. More...

MFloat	a_alpha (const MInt cellId) const
	Returns alpha of the cell `cellId`. More...

MFloat &	a_poissonRatio (const MInt cellId)
	Returns poisson Ratio of the cell `cellId`. More...

MFloat	a_poissonRatio (const MInt cellId) const
	Returns poisson Ratio of the cell `cellId`. More...

MFloat &	a_invJacobian (const MInt cellId)
	Returns inverse Jacobian of the cell `cellId`. More...

MFloat	a_invJacobian (const MInt cellId) const
	Returns inverse Jacobian of the cell `cellId`. More...

MFloat &	a_nodePosition (const MInt cellId, const MInt dir)
	Returns the element `dir` from the legendre points of the cell `cellId`. More...

MFloat	a_nodePosition (const MInt cellId, const MInt dir) const
	Returns the element `dir` from the legendre points of the cell `cellId`. More...

MFloat &	a_dGamma (const MInt cellId, const MInt node)
	Returns delta gamma of node `node` of the cell `cellId`. More...

MFloat	a_dGamma (const MInt cellId, const MInt node) const
	Returns delta gamma of node `node` of the cell `cellId`. More...

MFloat &	a_epsilonBarP (const MInt cellId, const MInt node)
	Returns epsilon bar of node `node` of the cell `cellId`. More...

MFloat	a_epsilonBarP (const MInt cellId, const MInt node) const
	Returns epsilon bar of node `node` of the cell `cellId`. More...

MFloat &	a_elementDispl (const MInt cellId, const MInt dir)
	Returns the displacement `dir` of the cell `cellId`. More...

MFloat	a_elementDispl (const MInt cellId, const MInt dir) const
	Returns the element displacement `dir` of the cell `cellId`. More...

MFloat &	a_elementStrains (const MInt cellId, const MInt dir)
	Returns the element strain `dir` from the stain matrix of the cell `cellId`. More...

MFloat	a_elementStrains (const MInt cellId, const MInt dir) const
	Returns the elment strain `dir` from the strain matrix of the cell `cellId`. More...

MFloat &	a_nodalStrains (const MInt cellId, const MInt node, const MInt dir)
	Returns the nodal strains `dir` from the stain matrix of node `node` of cell `cellId`. More...

MFloat	a_nodalStrains (const MInt cellId, const MInt node, const MInt dir) const
	Returns the nodal strains `dir` from the stain matrix of node `node` of cell `cellId`. More...

MFloat	a_elementDevStrains (const MInt cellId, const MInt dir)
	Returns the deviatoric strain `dir` from the strain matrix of the cell `cellId`. More...

MFloat	a_nodalDevStrains (const MInt cellId, const MInt node, const MInt dir)
	Returns the nodal deviatoric strain `dir` from the strain matrix of node `node` of cell `cellId`. More...

MFloat &	a_elementStresses (const MInt cellId, const MInt dir)
	Returns the element stress `dir` from the stress matrix of the cell `cellId`. More...

MFloat	a_elementStresses (const MInt cellId, const MInt dir) const
	Returns the element stress `dir` from the stress matrix of the cell `cellId`. More...

MFloat &	a_nodalStresses (const MInt cellId, const MInt node, const MInt dir)
	Returns the nodal stress `dir` from the stress matrix of node `node` of cell `cellId`. More...

MFloat	a_nodalStresses (const MInt cellId, const MInt node, const MInt dir) const
	Returns the nodal stress `dir` from the stress matrix of node `node` of cell `cellId`. More...

MFloat	a_elementDevStresses (const MInt cellId, const MInt dir)
	Returns the deviatoric stress `dir` from the stress matrix of the cell `cellId`. More...

MFloat	a_nodalDevStresses (const MInt cellId, const MInt node, const MInt dir)
	Returns the nodal deviatoric stress `dir` from the stress matrix of node `node` of cell `cellId`. More...

MBool	a_hasProperty (const MInt cellId, const Cell p) const
	Returns property `p` of the cell `cellId`. More...

maia::fc::cell::BitsetType::reference	a_hasProperty (const MInt cellId, const SolverCell p)
	Returns solver cell property `p` of the cell `cellId`. More...

MBool	a_hasProperty (const MInt cellId, const SolverCell p) const
	Returns solver cell property `p` of the cell `cellId`. More...

MBool	a_needsSubCells (const MInt cellId) const
	Returns needsSubCells of the cell `CellId`. More...

maia::fc::cell::BitsetType::reference	a_needsSubCells (const MInt cellId)
	Returns needsSubCells of the cell `CellId`. More...

MInt &	a_noNodes (const MInt cellId)
	Returns number of elements of the cell `cellId`. More...

MInt	a_noNodes (const MInt cellId) const
	Returns number of elements of the cell `cellId`. More...

MInt &	a_bndId (const MInt cellId)
	Returns bndId of the cell `cellId`. More...

MInt	a_bndId (const MInt cellId) const
	Returns bndId of the cell `cellId`. More...

MInt &	a_pRfnmnt (const MInt cellId)
	Returns pRfnmnt of the cell `cellId`. More...

MInt	a_pRfnmnt (const MInt cellId) const
	Returns pRfnmnt of the cell `cellId`. More...

MInt &	a_maxSubCellLvl (const MInt cellId)
	Returns pRfnmnt of the cell `cellId`. More...

MInt	a_maxSubCellLvl (const MInt cellId) const
	Returns pRfnmnt of the cell `cellId`. More...

MInt &	a_nodeIdsLocal (const MInt cellId, const MInt nodeDir)
	Returns node ids of the cell `cellId`. More...

MInt	a_nodeIdsLocal (const MInt cellId, const MInt nodeDir) const
	Returns node ids of the cell `cellId`. More...

MInt &	a_nodeIdsGlobal (const MInt cellId, const MInt nodeDir)
	Returns node ids of the cell `cellId`. More...

MInt	a_nodeIdsGlobal (const MInt cellId, const MInt nodeDir) const
	Returns node ids of the cell `cellId`. More...

MFloat	c_cellLengthAtCell (const MInt cellId) const

MFloat	c_cellLengthAtLevel (const MInt level) const

MFloat	a_jacobianMatrix (const MInt cellId) const

const MFloat &	c_coordinate (const MInt gCellId, const MInt dim) const
	Returns the coordinate of the cell `cellId` for direction `dim`. More...

MInt &	c_neighborId (const MInt cellId, const MInt dir)
	Returns the neighbor id of the cell `cellId` for direction `dir`. More...

MInt	c_neighborId (const MInt cellId, const MInt dir) const
	Returns the neighbor id of the cell `cellId` for direction `dir`. More...

MInt	a_hasNeighbor (const MInt cellId, const MInt dir) const
	Returns noNeighborIds of the cell `CellId` for direction `dir`. More...

MBool	a_isHalo (const MInt cellId) const

maia::fc::cell::BitsetType::reference	a_isHalo (const MInt cellId)

MBool	a_isActive (const MInt cellId) const
	Returns isActive of the cell `CellId`. More...

maia::fc::cell::BitsetType::reference	a_isActive (const MInt cellId)
	Returns isActive of the cell `CellId`. More...

MBool	a_wasActive (const MInt cellId) const
	Returns isActive of the cell `CellId`. More...

maia::fc::cell::BitsetType::reference	a_wasActive (const MInt cellId)
	Returns isActive of the cell `CellId`. More...

void	a_resetPropertiesSolver (const MInt cellId)

MInt	c_globalId (const MInt cellId) const

MInt	getIdAtPoint (const MFloat *point, MBool NotUsed(globalUnique=false))

MFloat	getVolumetricStrains (const MFloat *strains)

MFloat	getHydrostaticPressure (const MFloat *stresses)

MInt	c_noCells () const
	Returns the number of grid-cells. More...

MInt	c_level (const MInt cellId) const

MInt	c_noChildren (const MInt cellId) const

MBool	c_isLeafCell (const MInt cellId) const

MInt	c_childId (const MInt cellId, const MInt childNumber) const

MInt	c_parentId (const MInt cellId) const

	FcSolver (MInt id, GridProxy &gridProxy_, Geometry< nDim > &geometry_, const MPI_Comm comm)

	~FcSolver () override

MBool	isActive () const override

void	updateCellCollectorFromGrid ()

void	setIntegrationWeights ()

void	initJacobianMatrix ()

void	initTimer ()

void	averageTimer ()

void	allocateNodeVectors ()

void	setGlobalNodeIds ()

void	correctGlobalNodeIds ()

void	exchangeNodeIds (MInt currentDomain)

void	exchangeVector (MFloat *vector)

void	createElementToNodeMapping ()

void	createElementToNodeMappingGlobal ()

void	consistencyCheck ()

void	consistencyCheck2 ()

void	reorderLocalNodeIds ()

void	deactivateCells ()

void	resetActiveState ()

void	calcElementDisplacements ()

void	getDisplacementsAtPoint (const MInt cellId, const MFloat z, const MFloat displ, MFloat *result)

void	calcElementStrains ()

void	getStrainsAtPoint (const MInt cellId, const MFloat z, const MFloat displ, MFloat *strains)

void	calcElementStresses ()

void	getStressesAtPoint (const MInt cellId, const MFloat z, const MFloat displ, MFloat *stresses)

void	getInternalLoadsFromStresses ()

void	getReactionForces ()

void	interpolateGeometry (const MInt pCellId, const MFloat x, MFloat z)

void	transformToLocal (const MInt pCellId, const MFloat z, MFloat x)

void	interpolateSubCellGeometry (const MInt pCellId, const MFloat z, MFloat x, const MInt subCellLevel, const MFloat *subCellCoord)

void	getCoordinatesOfNode (MInt node, MInt cell, MFloat *coordinates)

void	getDisplacementInterpolationMatrix (const MInt pCellId, const MFloat *z, MFloatScratchSpace &x)

void	getDerivativeOfDisplacementInterpolationMatrix (const MInt pCellId, const MFloat *z, MFloatScratchSpace &x)

void	getMaterialTensor (MFloatScratchSpace &C, const MInt pCellId, const MInt node=-1)

void	getStrainInterpolationMatrix (MFloatScratchSpace &Be, const MInt pCellId, const MFloat *z)

void	getNodalStiffnessMatrix (const MInt pCellId, const MInt node, MFloatScratchSpace &Ke, MInt nodePos, MFloat z, MFloat determinant, const MFloat alpha, const MInt subCellLevel)

void	getElementMatrix (MFloatScratchSpace &Ke, const MInt pCellId, const MFloat alpha, const MInt subCellLevel, const MFloat *subCellCoord=nullptr)

void	computeAssembledSystemMatrix (MFloatScratchSpace &Ke, const MInt pCellId)

void	computeAssembledBndryMatrix (MFloatScratchSpace &Bndry, const MInt pCellId)

void	solveSystemOfEquations ()

void	calculateStiffnessMatrix ()

void	createCompressedMatrix ()

void	resetDisplacements (const MInt mode=-1)

void	updateDisplacements ()

void	resetLoadVector (const MInt mode=-1)

void	assembleFinalMatrix ()

void	updateLoadVector (const MFloat lambda=F1)

void	interpolateGeometryDebug (const MInt pCellId, const MFloat z, MFloat x)

void	getDisplacementInterpolationMatrixDebug (const MInt pCellId, const MFloat *z, MFloatScratchSpace &L_coef_lagrange)

void	getJacobiMatrixDebug (const MInt pCellId, const MFloat *z, MFloatScratchSpace &jacobi_lagrange)

void	getStrainInterpolationMatrixDebug (const MInt pCellId, const MFloat *z, MFloatScratchSpace &strain_lagrange)

void	fillDisplacementVectorWithCoords ()

void	lagrangianPointsJacobi (const MInt pCellId, const MFloat *z, MFloatScratchSpace &x)

void	solveMatrixIteratively (MFloat A_coeff, MInt *pos, const MInt n)

void	solveMatrixIterativelyPreCon (MFloat A_coeff, MInt pos, const MInt n, const MInt m, MFloat b, MFloat *x)

MFloat	time () const override
	Return number of variables. More...

constexpr const Geom &	geometry () const
	Access the solver's geometry. More...

void	rhs ()

void	rhsBnd ()

void	lhsBnd ()

void	initSolver () override

void	finalizeInitSolver () override

void	preTimeStep () override

MBool	solutionStep () override

void	lhs ()

void	saveSolverSolution (MBool forceOutput, const MBool finalTimeStep) override

MBool	prepareRestart (MBool writeRestart, MBool &writeGridRestart) override
	Prepare the solvers for a grid-restart. More...

void	reIntAfterRestart (MBool doneRestart)

void	writeRestartFile (const MBool writeRestart, const MBool writeBackup, const MString gridFileName, MInt *recalcIdTree) override

void	saveRestartStrainsOnly (const MChar fileName, const MChar gridInputFileName, MInt *recalcIdTree=nullptr)

void	setCellWeights (MFloat *solverCellWeight) override
	Set cell weights. More...

void	resetExternalSources ()

void	exchangeExternalSources ()

virtual void	cleanUp ()

void	postTimeStep () override

MInt	a_noCells () const

Public Member Functions inherited from maia::CartesianSolver< nDim_, FcSolver< nDim_ > >
	CartesianSolver (const MInt solverId, GridProxy &gridProxy_, const MPI_Comm comm, const MBool checkActive=false)

MInt	minLevel () const
	Read-only accessors for grid data. More...

MInt	maxLevel () const

MInt	maxNoGridCells () const

MInt	maxRefinementLevel () const

MInt	maxUniformRefinementLevel () const

MInt	noNeighborDomains () const

MInt	neighborDomain (const MInt id) const

MLong	domainOffset (const MInt id) const

MInt	noHaloLayers () const

MInt	noHaloCells (const MInt domainId) const

MInt	haloCellId (const MInt domainId, const MInt cellId) const

MInt	noWindowCells (const MInt domainId) const

MInt	windowCellId (const MInt domainId, const MInt cellId) const

MString	gridInputFileName () const

MFloat	reductionFactor () const

MFloat	centerOfGravity (const MInt dir) const

MInt	neighborList (const MInt cellId, const MInt dir) const

const MLong &	localPartitionCellGlobalIds (const MInt cellId) const

MLong	localPartitionCellOffsets (const MInt index) const

MInt	noMinCells () const

MInt	minCell (const MInt id) const

const MInt &	haloCell (const MInt domainId, const MInt cellId) const

const MInt &	windowCell (const MInt domainId, const MInt cellId) const

MBool	isActive () const override

constexpr GridProxy &	grid () const

GridProxy &	grid ()

virtual void	sensorDerivative (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorDivergence (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorTotalPressure (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorEntropyGrad (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorEntropyQuot (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorVorticity (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorInterface (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

void	sensorLimit (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt, std::function< MFloat(MInt)>, const MFloat, const MInt *, const MBool, const MBool allowCoarsening=true)
	simple sensor to apply a limit for a value More...

void	sensorSmooth (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)
	sensor to smooth level jumps NOTE: only refines additional cells to ensure a smooth level transition this requires that all other sensors are frozen i.e. no refine/coarse sensors set! More...

void	sensorBand (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)
	This sensor generates a max refinement band around the cells with max refinement level. In order for it to work, the property addedAdaptationSteps has to be equal to /maxRefinementLevel() - minLevel()/. This sensor also ensures a smooth transition between levels. Do not use together with sensorSmooth. More...

virtual void	sensorMeanStress (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorParticle (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorSpecies (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

virtual void	sensorPatch (std::vector< std::vector< MFloat > > &sensor, std::vector< std::bitset< 64 > > &sensorCellFlag, std::vector< MFloat > &sensorWeight, MInt sensorOffset, MInt sen)

virtual void	sensorCutOff (std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

void	saveSensorData (const std::vector< std::vector< MFloat > > &sensors, const MInt &level, const MString &gridFileName, const MInt *const recalcIds) override
	Saves all sensor values for debug/tunig purposes. More...

void	assertValidGridCellId (const MInt) const

MLong	c_parentId (const MInt cellId) const
	Returns the grid parent id of the cell `cellId`. More...

MLong	c_neighborId (const MInt cellId, const MInt dir) const
	Returns the grid neighbor id of the grid cell `cellId` `dir`. More...

MInt	c_noCells () const

MInt	c_level (const MInt cellId) const

MLong	c_globalGridId (const MInt cellId)

void	exchangeData (T *data, const MInt dataBlockSize=1)
	Exchange memory in 'data' assuming a solver size of 'dataBlockSize' per cell. More...

void	exchangeLeafData (std::function< T &(MInt, MInt)> data, const MInt noDat=1)
	Blocking exchange memory in 'data' assuming a solver size of 'dataBlockSize' per cell NOTE: exchange is only performed on leaf-cells and leaf-NeighborDomains Assumes, that updateLeafCellExchange has been called in the proxy previously! More...

void	exchangeSparseLeafValues (G getData, S setData, const MInt dataSize, M cellMapping)
	Exchange of sparse data structures on max Level. More...

void	exchangeAzimuthalPer (T *data, MInt dataBlockSize=1, MInt firstBlock=0)
	Exchange of sparse data structures on max Level. More...

void	collectVariables (T *variablesIn, ScratchSpace< T > &variablesOut, const std::vector< MString > &variablesNameIn, std::vector< MString > &variablesNameOut, const MInt noVars, const MInt noCells, const MBool reverseOrder=false)
	generalised helper function for writing restart files! This is necessary for example if the minLevel shall be raised at the new restart! More...

void	collectVariables (T **variablesIn, ScratchSpace< T > &variablesOut, const std::vector< MString > &variablesNameIn, std::vector< MString > &variablesNameOut, const MInt noVars, const MInt noCells)
	generalised helper function for writing restart files! This is necessary for example if the minLevel shall be raised at the new restart! More...

void	saveGridFlowVars (const MChar fileName, const MChar gridFileName, const MInt noTotalCells, const MInt noInternal, MFloatScratchSpace &dbVariables, std::vector< MString > &dbVariablesName, MInt noDbVars, MIntScratchSpace &idVariables, std::vector< MString > &idVariablesName, MInt noIdVars, MFloatScratchSpace &dbParameters, std::vector< MString > &dbParametersName, MIntScratchSpace &idParameters, std::vector< MString > &idParametersName, MInt *recalcIds, MFloat time)
	This function writes the parallel Netcdf cartesian grid cell based solution/restart file currently used in PostData, LPT and LS solvers! More...

void	collectParameters (T, ScratchSpace< T > &, const MChar *, std::vector< MString > &)
	This function collects a single parameters for the massivley parallel IO functions. More...

void	calcRecalcCellIdsSolver (const MInt *const recalcIdsTree, MInt &noCells, MInt &noInternalCellIds, std::vector< MInt > &recalcCellIdsSolver, std::vector< MInt > &reorderedCellIds)
	Derive recalc cell ids of the solver and reordered cell ids. More...

Public Member Functions inherited from Solver
MString	getIdentifier (const MBool useSolverId=false, const MString preString="", const MString postString="_")

virtual	~Solver ()=default

virtual MInt	noInternalCells () const =0
	Return the number of internal cells within this solver. More...

virtual MFloat	time () const =0
	Return the time. More...

virtual MInt	noVariables () const
	Return the number of variables. More...

virtual void	getDimensionalizationParams (std::vector< std::pair< MFloat, MString > > &) const
	Return the dimensionalization parameters of this solver. More...

void	updateDomainInfo (const MInt domainId, const MInt noDomains, const MPI_Comm mpiComm, const MString &loc)
	Set new domain information. More...

virtual MFloat &	a_slope (const MInt, MInt const, const MInt)

virtual MBool	a_isBndryCell (const MInt) const

virtual MFloat &	a_FcellVolume (MInt)

virtual MInt	getCurrentTimeStep () const

virtual void	accessSampleVariables (MInt, MFloat *&)

virtual void	getSampleVariableNames (std::vector< MString > &NotUsed(varNames))

virtual MBool	a_isBndryGhostCell (MInt) const

virtual void	saveCoarseSolution ()

virtual void	getSolverSamplingProperties (std::vector< MInt > &NotUsed(samplingVarIds), std::vector< MInt > &NotUsed(noSamplingVars), std::vector< std::vector< MString > > &NotUsed(samplingVarNames), const MString NotUsed(featureName)="")

virtual void	initSolverSamplingVariables (const std::vector< MInt > &NotUsed(varIds), const std::vector< MInt > &NotUsed(noSamplingVars))

virtual void	calcSamplingVariables (const std::vector< MInt > &NotUsed(varIds), const MBool NotUsed(exchange))

virtual void	calcSamplingVarAtPoint (const MFloat NotUsed(point), const MInt NotUsed(id), const MInt NotUsed(sampleVarId), MFloat NotUsed(state), const MBool NotUsed(interpolate)=false)

virtual void	balance (const MInt const NotUsed(noCellsToReceiveByDomain), const MInt const NotUsed(noCellsToSendByDomain), const MInt *const NotUsed(targetDomainsByCell), const MInt NotUsed(oldNoCells))
	Perform load balancing. More...

virtual MBool	hasSplitBalancing () const
	Return if load balancing for solver is split into multiple methods or implemented in balance() More...

virtual void	balancePre ()

virtual void	balancePost ()

virtual void	finalizeBalance ()

virtual void	resetSolver ()
	Reset the solver/solver for load balancing. More...

virtual void	cancelMpiRequests ()
	Cancel open mpi (receive) requests in the solver (e.g. due to interleaved execution) More...

virtual void	setCellWeights (MFloat *)
	Set cell weights. More...

virtual MInt	noLoadTypes () const

virtual void	getDefaultWeights (MFloat *NotUsed(weights), std::vector< MString > &NotUsed(names)) const

virtual void	getLoadQuantities (MInt *const NotUsed(loadQuantities)) const

virtual MFloat	getCellLoad (const MInt NotUsed(cellId), const MFloat *const NotUsed(weights)) const

virtual void	limitWeights (MFloat *NotUsed(weights))

virtual void	localToGlobalIds ()

virtual void	globalToLocalIds ()

virtual MInt	noCellDataDlb () const
	Methods to inquire solver data information. More...

virtual MInt	cellDataTypeDlb (const MInt NotUsed(dataId)) const

virtual MInt	cellDataSizeDlb (const MInt NotUsed(dataId), const MInt NotUsed(cellId))

virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt const NotUsed(bufferIdToCellId), MInt const NotUsed(data))

virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt const NotUsed(bufferIdToCellId), MLong const NotUsed(data))

virtual void	getCellDataDlb (const MInt NotUsed(dataId), const MInt NotUsed(oldNoCells), const MInt const NotUsed(bufferIdToCellId), MFloat const NotUsed(data))

virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MInt *const NotUsed(data))

virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MLong *const NotUsed(data))

virtual void	setCellDataDlb (const MInt NotUsed(dataId), const MFloat *const NotUsed(data))

virtual void	getGlobalSolverVars (std::vector< MFloat > &NotUsed(globalFloatVars), std::vector< MInt > &NotUsed(globalIntVars))

virtual void	setGlobalSolverVars (std::vector< MFloat > &NotUsed(globalFloatVars), std::vector< MInt > &NotUsed(globalIdVars))

void	enableDlbTimers ()

void	reEnableDlbTimers ()

void	disableDlbTimers ()

MBool	dlbTimersEnabled ()

void	startLoadTimer (const MString name)

void	stopLoadTimer (const MString &name)

void	stopIdleTimer (const MString &name)

void	startIdleTimer (const MString &name)

MBool	isLoadTimerRunning ()

virtual MInt	noSolverTimers (const MBool NotUsed(allTimings))

virtual void	getSolverTimings (std::vector< std::pair< MString, MFloat > > &NotUsed(solverTimings), const MBool NotUsed(allTimings))

virtual void	getDomainDecompositionInformation (std::vector< std::pair< MString, MInt > > &NotUsed(domainInfo))

void	setDlbTimer (const MInt timerId)

virtual void	prepareAdaptation (std::vector< std::vector< MFloat > > &, std::vector< MFloat > &, std::vector< std::bitset< 64 > > &, std::vector< MInt > &)

virtual void	reinitAfterAdaptation ()

virtual void	prepareAdaptation ()
	prepare adaptation for split adaptation before the adaptation loop More...

virtual void	setSensors (std::vector< std::vector< MFloat > > &, std::vector< MFloat > &, std::vector< std::bitset< 64 > > &, std::vector< MInt > &)
	set solver sensors for split adaptation within the adaptation loop More...

virtual void	saveSensorData (const std::vector< std::vector< MFloat > > &, const MInt &, const MString &, const MInt *const)

virtual void	postAdaptation ()
	post adaptation for split adaptation within the adaptation loop More...

virtual void	finalizeAdaptation ()
	finalize adaptation for split sadptation after the adaptation loop More...

virtual void	refineCell (const MInt)
	Refine the given cell. More...

virtual void	removeChilds (const MInt)
	Coarsen the given cell. More...

virtual void	removeCell (const MInt)
	Remove the given cell. More...

virtual void	swapCells (const MInt, const MInt)
	Swap the given cells. More...

virtual void	swapProxy (const MInt, const MInt)
	Swap the given cells. More...

virtual MInt	cellOutside (const MFloat *, const MInt, const MInt)
	Check whether cell is outside the fluid domain. More...

virtual void	resizeGridMap ()
	Swap the given cells. More...

virtual MBool	prepareRestart (MBool, MBool &)
	Prepare the solvers for a grid-restart. More...

virtual void	reIntAfterRestart (MBool)

MPI_Comm	mpiComm () const
	Return the MPI communicator used by this solver. More...

virtual MInt	domainId () const
	Return the domainId (rank) More...

virtual MInt	noDomains () const

virtual MBool	isActive () const

void	setSolverStatus (const MBool status)

MBool	getSolverStatus ()
	Get the solver status indicating if the solver is currently active in the execution recipe. More...

MString	testcaseDir () const
	Return the testcase directory. More...

MString	outputDir () const
	Return the directory for output files. More...

MString	restartDir () const
	Return the directory for restart files. More...

MString	solverMethod () const
	Return the solverMethod of this solver. More...

MString	solverType () const
	Return the solverType of this solver. More...

MInt	restartInterval () const
	Return the restart interval of this solver. More...

MInt	restartTimeStep () const
	Return the restart interval of this solver. More...

MInt	solverId () const
	Return the solverId. More...

MBool	restartFile ()

MInt	readSolverSamplingVarNames (std::vector< MString > &varNames, const MString featureName="") const
	Read sampling variables names, store in vector and return the number of sampling variables. More...

virtual MBool	hasRestartTimeStep () const

virtual MBool	forceAdaptation ()

virtual void	preTimeStep ()=0

virtual void	postTimeStep ()=0

virtual void	initSolver ()=0

virtual void	finalizeInitSolver ()=0

virtual void	saveSolverSolution (const MBool NotUsed(forceOutput)=false, const MBool NotUsed(finalTimeStep)=false)=0

virtual void	cleanUp ()=0

virtual MBool	solutionStep ()

virtual void	preSolutionStep (MInt)

virtual MBool	postSolutionStep ()

virtual MBool	solverConverged ()

virtual void	getInterpolatedVariables (MInt, const MFloat , MFloat )

virtual void	loadRestartFile ()

virtual MInt	determineRestartTimeStep () const

virtual void	writeRestartFile (MBool)

virtual void	writeRestartFile (const MBool, const MBool, const MString, MInt *)

virtual void	setTimeStep ()

virtual void	implicitTimeStep ()

virtual void	prepareNextTimeStep ()

Public Attributes
GeometryIntersection< nDim > *	m_geometryIntersection

MBool	m_adaptationSinceLastRestart = false

MBool	m_adaptationSinceLastSolution = false

MBool	m_adaptation = false

MInt	solver

MInt	initSolver

MInt	calcStiffMat

MInt	solutionStep

MInt	subCellInt

MInt	forceBC

MInt	displacementBC

MInt	solving

MInt	exchange

Public Attributes inherited from Solver
std::set< MInt >	m_freeIndices

MBool	m_singleAdaptation = false

MBool	m_splitAdaptation = true

MBool	m_saveSensorData = false

Static Public Attributes
static constexpr MInt	nDim = nDim_

static constexpr const MInt	m_noDirs = 2 * nDim

Protected Member Functions
Geom &	geometry ()
	Access the solver's geometry (non-const version) More...

Protected Member Functions inherited from maia::CartesianSolver< nDim_, FcSolver< nDim_ > >
void	identifyBoundaryCells (MBool *const isInterface, const std::vector< MInt > &bndCndIds=std::vector< MInt >())

void	identifyBoundaryCells ()

MBool	cellIsOnGeometry (MInt cellId, Geometry< nDim > *geom)
	checks whether a cell lies on a certain geometry copied the essential part from identifyBoundaryCells More...

void	setBoundaryDistance (const MBool const interfaceCell, const MFloat const outerBandWidth, MFloatScratchSpace &distance)
	transverses over all neighboring cells for a specified length More...

void	markSurrndCells (MIntScratchSpace &inList, const MInt bandWidth, const MInt level, const MBool refineDiagonals=true)

void	receiveWindowTriangles ()
	Receives triangles from neighbors contained in their window cells and inserts them locally. More...

void	compactCells ()
	Removes all holes in the cell collector and moves halo cells to the back of the collector. More...

MInt	createCellId (const MInt gridCellId)

void	removeCellId (const MInt cellId)

MInt	inCell (const MInt cellId, MFloat *point, MFloat fac=F1)

MInt	setUpInterpolationStencil (const MInt cellId, MInt , const MFloat , std::function< MBool(MInt, MInt)>, MBool allowIncompleteStencil)

MFloat	interpolateFieldData (MInt , MFloat , MInt varId, std::function< MFloat(MInt, MInt)> scalarField, std::function< MFloat(MInt, MInt)> coordinate)

MFloat	leastSquaresInterpolation (MInt , MFloat , MInt varId, std::function< MFloat(MInt, MInt)> scalarField, std::function< MFloat(MInt, MInt)> coordinate)

void	checkNoHaloLayers ()
	check that each solver has the required number of haloLayers for leaf cells!!! TODO labels:toenhance under production, needs to be cleaned up! More...

void	mapInterpolationCells (std::map< MInt, MInt > &cellMap)

void	setHaloCellsOnInactiveRanks ()

void	patchRefinement (std::vector< std::vector< MFloat > > &sensors, std::vector< std::bitset< 64 > > &sensorCellFlag, std::vector< MFloat > &sensorWeight, MInt sensorOffset, MInt sen)

void	reOrderCellIds (std::vector< MInt > &reOrderedCells)
	reOrder cellIds before writing the restart file! This is necessary for example if the minLevel shall be raised at the new restart! More...

void	recomputeGlobalIds (std::vector< MInt > &, std::vector< MLong > &)
	reOrder cellIds before writing the restart file! This is necessary for example if the minLevel shall be raised at the new restart! More...

void	extractPointIdsFromGrid (Collector< PointBasedCell< nDim > > &, Collector< CartesianGridPoint< nDim > > &, const MBool, const std::map< MInt, MInt > &, MInt levelThreshold=999999, MFloat *bBox=nullptr, MBool levelSetMb=false) const
	Creates a list of unique corner points for all cells using a hash map levelThreshold optionally specifies the maximum cell level to be extracted bBox optionally specifies a bounding to box to which the extracted domain shall be truncated. More...

Protected Member Functions inherited from Solver
	Solver (const MInt solverId, const MPI_Comm comm, const MBool isActive=true)

MFloat	returnLoadRecord () const

MFloat	returnIdleRecord () const

Protected Attributes
struct {
MInt solver

MInt initSolver

MInt calcStiffMat

MInt solutionStep

MInt subCellInt

MInt forceBC

MInt displacementBC

MInt solving

MInt exchange

}	m_t

MBool	m_nonBlockingComm = false

Geometry< nDim > *	m_geometry

FcBndryCnd< nDim > *	m_bndryCnd = nullptr

MFloat	m_time = F0

MFloat *	m_nodalDisplacements = nullptr

MFloat *	m_totalNodalDisplacements = nullptr

MFloat *	m_nodalLoadVector = nullptr

MFloat *	m_externalLoadVector = nullptr

MFloat *	m_internalLoadVector = nullptr

MFloat *	m_reactionForceVector = nullptr

MInt *	m_localToGlobalId = nullptr

MInt *	m_globalToLocalId = nullptr

MInt *	m_globalNodeIdOffsets = nullptr

MFloat *	m_sysMatCompressed = nullptr

MInt **	m_compressionIndexSys = nullptr

MFloat *	m_bndryMatCompressed = nullptr

MInt **	m_compressionIndexBndry = nullptr

MFloat **	m_gaussPoints = nullptr

MFloat **	m_gaussWeights = nullptr

std::map< std::pair< MInt, MInt >, MFloat >	m_globalStiffnessMatrix

std::map< std::pair< MInt, MInt >, MFloat >	m_globalBndryMatrix

std::map< std::pair< MInt, MInt >, MFloat >	m_finalGlobalMatrix

maia::fc::collector::FcCellCollector< nDim >	m_cells
	Collector for Fc cells. More...

MInt *	m_recalcIds = nullptr

Protected Attributes inherited from maia::CartesianSolver< nDim_, FcSolver< nDim_ > >
MInt *	m_rfnBandWidth

MInt	m_noSensors

MInt	m_adaptationInterval

MInt	m_adaptationStep

std::vector< MInt >	m_maxSensorRefinementLevel

std::vector< MFloat >	m_sensorWeight

std::vector< MFloat >	m_sensorDerivativeVariables

MBool	m_adaptation

MBool	m_adapts

MInt	m_noInitialSensors

MBool	m_resTriggeredAdapt

MInt	m_noSmoothingLayers

MInt	m_sensorBandAdditionalLayers

MBool	m_sensorInterface

MBool	m_sensorParticle

std::vector< MString >	m_sensorType

MInt *	m_recalcIds

std::vector< fun >	m_sensorFnPtr

MInt	m_maxNoSets

std::vector< MFloat >	m_azimuthalCartRecCoord

const MInt	m_revDir [6]

const MInt	m_noDirs

Protected Attributes inherited from Solver
MFloat	m_Re {}
	the Reynolds number More...

MFloat	m_Ma {}
	the Mach number More...

MInt	m_solutionInterval
	The number of timesteps before writing the next solution file. More...

MInt	m_solutionOffset {}

std::set< MInt >	m_solutionTimeSteps

MInt	m_restartInterval
	The number of timesteps before writing the next restart file. More...

MInt	m_restartTimeStep

MInt	m_restartOffset

MString	m_solutionOutput

MBool	m_useNonSpecifiedRestartFile = false

MBool	m_initFromRestartFile

MInt	m_residualInterval
	The number of timesteps before writing the next residual. More...

const MInt	m_solverId
	a unique solver identifier More...

MFloat *	m_outerBandWidth = nullptr

MFloat *	m_innerBandWidth = nullptr

MInt *	m_bandWidth = nullptr

MBool	m_restart = false

MBool	m_restartFile = false

Private Attributes
MInt	m_totalNoNodes = 0

MInt	m_totalNoNodesGlobal = 0

MInt	m_noInternalNodes = 0

MInt	m_noHaloNodes = 0

MInt	m_polyDeg = 0

MFloat	m_poissonRatio = 0.3

MBool	m_testRun = false

MFloat	m_analyticSolution = F1

MBool	m_first = true

MFloat	m_volume = 0.0

MFloat	m_E = 100000.0

MBool	m_isThermal = false

MFloat	m_eps = 1e-12

MInt	m_maxNoIterations = 10000

MInt	m_noLoadSteps = 1

MString	m_fcInterpolationMethod = ""

MBool	m_printEigenValues = false

MFloat	m_alpha = 1e-14

MBool	m_addingPenalties = true

MBool	m_solveSoEIteratively = true

MBool	m_useEigen = false

Static Private Attributes
static constexpr MInt	m_noStrains = (nDim == 2) ? (nDim + 1) : (nDim * 2)

Friends
template<MInt nDim>
class	FcBndryCnd

Additional Inherited Members
Protected Types inherited from maia::CartesianSolver< nDim_, FcSolver< nDim_ > >
using	fun = void(CartesianSolver< nDim, FcSolver< nDim_ > >::*)(std::vector< std::vector< MFloat > > &, std::vector< std::bitset< 64 > > &, std::vector< MFloat > &, MInt, MInt)

Detailed Description

template<MInt nDim_>
class FcSolver< nDim_ >

Definition at line 27 of file fcsolver.h.

Member Typedef Documentation

◆ CartesianSolver

template<MInt nDim_>

using FcSolver< nDim_ >::CartesianSolver = typename maia::CartesianSolver<nDim, FcSolver>

Definition at line 37 of file fcsolver.h.

◆ Cell

template<MInt nDim_>

using FcSolver< nDim_ >::Cell = typename maia::grid::tree::Tree<nDim>::Cell

Definition at line 35 of file fcsolver.h.

◆ Fd

template<MInt nDim_>

using FcSolver< nDim_ >::Fd = FcDescriptor<nDim>

Definition at line 76 of file fcsolver.h.

◆ Geom

template<MInt nDim_>

using FcSolver< nDim_ >::Geom = Geometry<nDim>

Definition at line 434 of file fcsolver.h.

◆ Grid

template<MInt nDim_>

using FcSolver< nDim_ >::Grid = typename CartesianSolver::Grid

Definition at line 38 of file fcsolver.h.

◆ GridProxy

template<MInt nDim_>

using FcSolver< nDim_ >::GridProxy = typename CartesianSolver::GridProxy

Definition at line 39 of file fcsolver.h.

◆ SolverCell

template<MInt nDim_>

using FcSolver< nDim_ >::SolverCell = FcCell

Definition at line 36 of file fcsolver.h.

Constructor & Destructor Documentation

◆ FcSolver()

template<MInt nDim_>

FcSolver< nDim_ >::FcSolver	(	MInt	id,
		GridProxy &	gridProxy_,
		Geometry< nDim > &	geometry_,
		const MPI_Comm	comm
	)

◆ ~FcSolver()

template<MInt nDim_>

FcSolver< nDim_ >::~FcSolver ( )

override

Member Function Documentation

◆ a_alpha() [1/2]

template<MInt nDim_>

MFloat & FcSolver< nDim_ >::a_alpha ( const MInt cellId )

inline

Definition at line 97 of file fcsolver.h.

97{ return m_cells.alpha(cellId); }

FcSolver::m_cells

maia::fc::collector::FcCellCollector< nDim > m_cells

Collector for Fc cells.

Definition: fcsolver.h:548

◆ a_alpha() [2/2]

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_alpha ( const MInt cellId ) const

inline

Definition at line 100 of file fcsolver.h.

100{ return m_cells.alpha(cellId); }

◆ a_bndId() [1/2]

template<MInt nDim_>

MInt & FcSolver< nDim_ >::a_bndId ( const MInt cellId )

inline

Definition at line 232 of file fcsolver.h.

232{ return m_cells.bndId(cellId); }

◆ a_bndId() [2/2]

template<MInt nDim_>

MInt FcSolver< nDim_ >::a_bndId ( const MInt cellId ) const

inline

Definition at line 235 of file fcsolver.h.

235{ return m_cells.bndId(cellId); }

◆ a_dGamma() [1/2]

template<MInt nDim_>

MFloat & FcSolver< nDim_ >::a_dGamma	(	const MInt	cellId,
		const MInt	node
	)

inline

Definition at line 121 of file fcsolver.h.

121{ return m_cells.deltaGamma(cellId, node); }

◆ a_dGamma() [2/2]

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_dGamma	(	const MInt	cellId,
		const MInt	node
	)		const

inline

Definition at line 124 of file fcsolver.h.

124{ return m_cells.deltaGamma(cellId, node); }

◆ a_elementDevStrains()

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_elementDevStrains	(	const MInt	cellId,
		const MInt	dir
	)

inline

Definition at line 155 of file fcsolver.h.

                                                                {
    if(dir < nDim) {
      MFloat epsVol = getVolumetricStrains(&a_elementStrains(cellId, 0));
      return m_cells.elementStrains(cellId, dir) - epsVol;
    }
    return m_cells.elementStrains(cellId, dir);
  }

◆ a_elementDevStresses()

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_elementDevStresses	(	const MInt	cellId,
		const MInt	dir
	)

inline

Definition at line 189 of file fcsolver.h.

                                                                 {
    if(dir < nDim) {
      MFloat hsp = getHydrostaticPressure(&a_elementStresses(cellId, 0));
      return m_cells.elementStresses(cellId, dir) - hsp;
    }
    return m_cells.elementStresses(cellId, dir);
  }

◆ a_elementDispl() [1/2]

template<MInt nDim_>

MFloat & FcSolver< nDim_ >::a_elementDispl	(	const MInt	cellId,
		const MInt	dir
	)

inline

Definition at line 133 of file fcsolver.h.

133{ return m_cells.elementDisplacements(cellId, dir); }

◆ a_elementDispl() [2/2]

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_elementDispl	(	const MInt	cellId,
		const MInt	dir
	)		const

inline

Definition at line 136 of file fcsolver.h.

136{ return m_cells.elementDisplacements(cellId, dir); }

◆ a_elementStrains() [1/2]

template<MInt nDim_>

MFloat & FcSolver< nDim_ >::a_elementStrains	(	const MInt	cellId,
		const MInt	dir
	)

inline

Definition at line 139 of file fcsolver.h.

139{ return m_cells.elementStrains(cellId, dir); }

◆ a_elementStrains() [2/2]

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_elementStrains	(	const MInt	cellId,
		const MInt	dir
	)		const

inline

Definition at line 142 of file fcsolver.h.

142{ return m_cells.elementStrains(cellId, dir); }

◆ a_elementStresses() [1/2]

template<MInt nDim_>

MFloat & FcSolver< nDim_ >::a_elementStresses	(	const MInt	cellId,
		const MInt	dir
	)

inline

Definition at line 173 of file fcsolver.h.

173{ return m_cells.elementStresses(cellId, dir); }

◆ a_elementStresses() [2/2]

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_elementStresses	(	const MInt	cellId,
		const MInt	dir
	)		const

inline

Definition at line 176 of file fcsolver.h.

176{ return m_cells.elementStresses(cellId, dir); }

◆ a_epsilonBarP() [1/2]

template<MInt nDim_>

MFloat & FcSolver< nDim_ >::a_epsilonBarP	(	const MInt	cellId,
		const MInt	node
	)

inline

Definition at line 127 of file fcsolver.h.

127{ return m_cells.epsilonBarP(cellId, node); }

◆ a_epsilonBarP() [2/2]

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_epsilonBarP	(	const MInt	cellId,
		const MInt	node
	)		const

inline

Definition at line 130 of file fcsolver.h.

130{ return m_cells.epsilonBarP(cellId, node); }

◆ a_hasNeighbor()

template<MInt nDim_>

MInt FcSolver< nDim_ >::a_hasNeighbor	(	const MInt	cellId,
		const MInt	dir
	)		const

inline

Definition at line 291 of file fcsolver.h.

                                                              {
    // Note: use neighbor list instead of grid().m_tree, also includes diagonal neighbors
    return static_cast<MInt>(grid().neighborList(cellId, dir) > -1);
  }

◆ a_hasProperty() [1/3]

template<MInt nDim_>

MBool FcSolver< nDim_ >::a_hasProperty	(	const MInt	cellId,
		const Cell	p
	)		const

inline

Definition at line 207 of file fcsolver.h.

207{ return grid().tree().hasProperty(cellId, p); }

◆ a_hasProperty() [2/3]

template<MInt nDim_>

maia::fc::cell::BitsetType::reference FcSolver< nDim_ >::a_hasProperty	(	const MInt	cellId,
		const SolverCell	p
	)

inline

Definition at line 210 of file fcsolver.h.

                                                                                     {
    return m_cells.hasProperty(cellId, p);
  }

◆ a_hasProperty() [3/3]

template<MInt nDim_>

MBool FcSolver< nDim_ >::a_hasProperty	(	const MInt	cellId,
		const SolverCell	p
	)		const

inline

Definition at line 215 of file fcsolver.h.

215{ return m_cells.hasProperty(cellId, p); }

◆ a_invJacobian() [1/2]

template<MInt nDim_>

MFloat & FcSolver< nDim_ >::a_invJacobian ( const MInt cellId )

inline

Definition at line 109 of file fcsolver.h.

109{ return m_cells.invJacobian(cellId); }

◆ a_invJacobian() [2/2]

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_invJacobian ( const MInt cellId ) const

inline

Definition at line 112 of file fcsolver.h.

112{ return m_cells.invJacobian(cellId); }

◆ a_isActive() [1/2]

template<MInt nDim_>

maia::fc::cell::BitsetType::reference FcSolver< nDim_ >::a_isActive ( const MInt cellId )

inline

Definition at line 307 of file fcsolver.h.

                                                              {
    return a_hasProperty(cellId, SolverCell::IsActive);
  }

◆ a_isActive() [2/2]

template<MInt nDim_>

MBool FcSolver< nDim_ >::a_isActive ( const MInt cellId ) const

inline

Definition at line 304 of file fcsolver.h.

304{ return a_hasProperty(cellId, SolverCell::IsActive); }

◆ a_isBndryCell() [1/2]

template<MInt nDim_>

maia::fc::cell::BitsetType::reference FcSolver< nDim_ >::a_isBndryCell ( const MInt cellId )

inline

Definition at line 84 of file fcsolver.h.

                                                                 {
    return a_hasProperty(cellId, SolverCell::IsBndryCell);
  }

◆ a_isBndryCell() [2/2]

template<MInt nDim_>

MBool FcSolver< nDim_ >::a_isBndryCell ( const MInt cellId ) const

inlinevirtual

Reimplemented from Solver.

Definition at line 81 of file fcsolver.h.

81{ return a_hasProperty(cellId, SolverCell::IsBndryCell); }

◆ a_isHalo() [1/2]

template<MInt nDim_>

maia::fc::cell::BitsetType::reference FcSolver< nDim_ >::a_isHalo ( const MInt cellId )

inline

Definition at line 298 of file fcsolver.h.

                                                            {
    //    ENSURE_VALID_GCELLID(gCellId);
    return m_cells.hasProperty(cellId, SolverCell::IsHalo);
  }

◆ a_isHalo() [2/2]

template<MInt nDim_>

MBool FcSolver< nDim_ >::a_isHalo ( const MInt cellId ) const

inline

Definition at line 296 of file fcsolver.h.

296{ return m_cells.hasProperty(cellId, SolverCell::IsHalo); }

◆ a_isWindow() [1/2]

template<MInt nDim_>

maia::fc::cell::BitsetType::reference FcSolver< nDim_ >::a_isWindow ( const MInt cellId )

inline

Definition at line 92 of file fcsolver.h.

                                                              {
    return m_cells.hasProperty(cellId, SolverCell::IsWindow);
  }

◆ a_isWindow() [2/2]

template<MInt nDim_>

MBool FcSolver< nDim_ >::a_isWindow ( const MInt cellId ) const

inline

Definition at line 89 of file fcsolver.h.

89{ return m_cells.hasProperty(cellId, SolverCell::IsWindow); }

◆ a_jacobianMatrix()

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_jacobianMatrix ( const MInt cellId ) const

inline

Definition at line 266 of file fcsolver.h.

                                                   {
    MInt level = c_level(cellId);
    level++;
    return grid().cellLengthAtLevel(level);
  }

◆ a_maxSubCellLvl() [1/2]

template<MInt nDim_>

MInt & FcSolver< nDim_ >::a_maxSubCellLvl ( const MInt cellId )

inline

Definition at line 244 of file fcsolver.h.

244{ return m_cells.maxSubCellLvl(cellId); }

◆ a_maxSubCellLvl() [2/2]

template<MInt nDim_>

MInt FcSolver< nDim_ >::a_maxSubCellLvl ( const MInt cellId ) const

inline

Definition at line 247 of file fcsolver.h.

247{ return m_cells.maxSubCellLvl(cellId); }

◆ a_needsSubCells() [1/2]

template<MInt nDim_>

maia::fc::cell::BitsetType::reference FcSolver< nDim_ >::a_needsSubCells ( const MInt cellId )

inline

Definition at line 221 of file fcsolver.h.

                                                                   {
    return a_hasProperty(cellId, SolverCell::NeedsSubCells);
  }

◆ a_needsSubCells() [2/2]

template<MInt nDim_>

MBool FcSolver< nDim_ >::a_needsSubCells ( const MInt cellId ) const

inline

Definition at line 218 of file fcsolver.h.

218{ return a_hasProperty(cellId, SolverCell::NeedsSubCells); }

◆ a_noCells()

template<MInt nDim_>

MInt FcSolver< nDim_ >::a_noCells ( ) const

inline

Definition at line 544 of file fcsolver.h.

544{ return m_cells.size(); }

◆ a_nodalDevStrains()

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_nodalDevStrains	(	const MInt	cellId,
		const MInt	node,
		const MInt	dir
	)

inline

Definition at line 164 of file fcsolver.h.

                                                                               {
    if(dir < nDim) {
      MFloat epsVol = getVolumetricStrains(&a_nodalStrains(cellId, node, 0));
      return m_cells.nodalStrains(cellId, node, dir) - epsVol;
    }
    return m_cells.nodalStrains(cellId, node, dir);
  }

◆ a_nodalDevStresses()

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_nodalDevStresses	(	const MInt	cellId,
		const MInt	node,
		const MInt	dir
	)

inline

Definition at line 198 of file fcsolver.h.

                                                                                {
    if(dir < nDim) {
      MFloat hsp = getHydrostaticPressure(&a_nodalStresses(cellId, node, 0));
      return m_cells.nodalStresses(cellId, node, dir) - hsp;
    }
    return m_cells.nodalStresses(cellId, node, dir);
  }

◆ a_nodalStrains() [1/2]

template<MInt nDim_>

MFloat & FcSolver< nDim_ >::a_nodalStrains	(	const MInt	cellId,
		const MInt	node,
		const MInt	dir
	)

inline

Definition at line 145 of file fcsolver.h.

                                                                             {
    return m_cells.nodalStrains(cellId, node, dir);
  }

◆ a_nodalStrains() [2/2]

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_nodalStrains	(	const MInt	cellId,
		const MInt	node,
		const MInt	dir
	)		const

inline

Definition at line 150 of file fcsolver.h.

                                                                                  {
    return m_cells.nodalStrains(cellId, node, dir);
  }

◆ a_nodalStresses() [1/2]

template<MInt nDim_>

MFloat & FcSolver< nDim_ >::a_nodalStresses	(	const MInt	cellId,
		const MInt	node,
		const MInt	dir
	)

inline

Definition at line 179 of file fcsolver.h.

                                                                              {
    return m_cells.nodalStresses(cellId, node, dir);
  }

◆ a_nodalStresses() [2/2]

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_nodalStresses	(	const MInt	cellId,
		const MInt	node,
		const MInt	dir
	)		const

inline

Definition at line 184 of file fcsolver.h.

                                                                                   {
    return m_cells.nodalStresses(cellId, node, dir);
  }

◆ a_nodeIdsGlobal() [1/2]

template<MInt nDim_>

MInt & FcSolver< nDim_ >::a_nodeIdsGlobal	(	const MInt	cellId,
		const MInt	nodeDir
	)

inline

Definition at line 256 of file fcsolver.h.

256{ return m_cells.nodeIdsGlob(cellId, nodeDir); }

◆ a_nodeIdsGlobal() [2/2]

template<MInt nDim_>

MInt FcSolver< nDim_ >::a_nodeIdsGlobal	(	const MInt	cellId,
		const MInt	nodeDir
	)		const

inline

Definition at line 259 of file fcsolver.h.

259{ return m_cells.nodeIdsGlob(cellId, nodeDir); }

◆ a_nodeIdsLocal() [1/2]

template<MInt nDim_>

MInt & FcSolver< nDim_ >::a_nodeIdsLocal	(	const MInt	cellId,
		const MInt	nodeDir
	)

inline

Definition at line 250 of file fcsolver.h.

250{ return m_cells.nodeIdsLoc(cellId, nodeDir); }

◆ a_nodeIdsLocal() [2/2]

template<MInt nDim_>

MInt FcSolver< nDim_ >::a_nodeIdsLocal	(	const MInt	cellId,
		const MInt	nodeDir
	)		const

inline

Definition at line 253 of file fcsolver.h.

253{ return m_cells.nodeIdsLoc(cellId, nodeDir); }

◆ a_nodePosition() [1/2]

template<MInt nDim_>

MFloat & FcSolver< nDim_ >::a_nodePosition	(	const MInt	cellId,
		const MInt	dir
	)

inline

Definition at line 115 of file fcsolver.h.

115{ return m_cells.nodePosition(cellId, dir); }

◆ a_nodePosition() [2/2]

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_nodePosition	(	const MInt	cellId,
		const MInt	dir
	)		const

inline

Definition at line 118 of file fcsolver.h.

118{ return m_cells.nodePosition(cellId, dir); }

◆ a_noNodes() [1/2]

template<MInt nDim_>

MInt & FcSolver< nDim_ >::a_noNodes ( const MInt cellId )

inline

Definition at line 226 of file fcsolver.h.

226{ return m_cells.noNodesPerCell(cellId); }

◆ a_noNodes() [2/2]

template<MInt nDim_>

MInt FcSolver< nDim_ >::a_noNodes ( const MInt cellId ) const

inline

Definition at line 229 of file fcsolver.h.

229{ return m_cells.noNodesPerCell(cellId); }

◆ a_poissonRatio() [1/2]

template<MInt nDim_>

MFloat & FcSolver< nDim_ >::a_poissonRatio ( const MInt cellId )

inline

Definition at line 103 of file fcsolver.h.

103{ return m_cells.poissonRatio(cellId); }

◆ a_poissonRatio() [2/2]

template<MInt nDim_>

MFloat FcSolver< nDim_ >::a_poissonRatio ( const MInt cellId ) const

inline

Definition at line 106 of file fcsolver.h.

106{ return m_cells.poissonRatio(cellId); }

◆ a_pRfnmnt() [1/2]

template<MInt nDim_>

MInt & FcSolver< nDim_ >::a_pRfnmnt ( const MInt cellId )

inline

Definition at line 238 of file fcsolver.h.

238{ return m_cells.pRfnmnt(cellId); }

◆ a_pRfnmnt() [2/2]

template<MInt nDim_>

MInt FcSolver< nDim_ >::a_pRfnmnt ( const MInt cellId ) const

inline

Definition at line 241 of file fcsolver.h.

241{ return m_cells.pRfnmnt(cellId); }

◆ a_resetPropertiesSolver()

template<MInt nDim_>

void FcSolver< nDim_ >::a_resetPropertiesSolver ( const MInt cellId )

inline

Definition at line 319 of file fcsolver.h.

319{ m_cells.resetProperties(cellId); }

◆ a_wasActive() [1/2]

template<MInt nDim_>

maia::fc::cell::BitsetType::reference FcSolver< nDim_ >::a_wasActive ( const MInt cellId )

inline

Definition at line 315 of file fcsolver.h.

                                                               {
    return a_hasProperty(cellId, SolverCell::WasActive);
  }

◆ a_wasActive() [2/2]

template<MInt nDim_>

MBool FcSolver< nDim_ >::a_wasActive ( const MInt cellId ) const

inline

Definition at line 312 of file fcsolver.h.

312{ return a_hasProperty(cellId, SolverCell::WasActive); }

◆ allocateNodeVectors()

template<MInt nDim_>

void FcSolver< nDim_ >::allocateNodeVectors ( )

◆ assembleFinalMatrix()

template<MInt nDim_>

void FcSolver< nDim_ >::assembleFinalMatrix ( )

◆ averageTimer()

template<MInt nDim_>

void FcSolver< nDim_ >::averageTimer ( )

◆ c_cellLengthAtCell()

template<MInt nDim_>

MFloat FcSolver< nDim_ >::c_cellLengthAtCell ( const MInt cellId ) const

inline

Definition at line 262 of file fcsolver.h.

262{ return grid().cellLengthAtLevel(c_level(cellId)); }

◆ c_cellLengthAtLevel()

template<MInt nDim_>

MFloat FcSolver< nDim_ >::c_cellLengthAtLevel ( const MInt level ) const

inline

Definition at line 264 of file fcsolver.h.

264{ return grid().cellLengthAtLevel(level); }

◆ c_childId()

template<MInt nDim_>

MInt FcSolver< nDim_ >::c_childId	(	const MInt	cellId,
		const MInt	childNumber
	)		const

inline

Definition at line 352 of file fcsolver.h.

352{ return grid().tree().child(cellId, childNumber); }

◆ c_coordinate()

template<MInt nDim_>

const MFloat & FcSolver< nDim_ >::c_coordinate	(	const MInt	gCellId,
		const MInt	dim
	)		const

inline

Definition at line 274 of file fcsolver.h.

                                                                       {
    return grid().tree().coordinate(gCellId, dim);
  }

◆ c_globalId()

template<MInt nDim_>

MInt FcSolver< nDim_ >::c_globalId ( const MInt cellId ) const

inline

Definition at line 321 of file fcsolver.h.

321{ return grid().tree().globalId(cellId); }

◆ c_isLeafCell()

template<MInt nDim_>

MBool FcSolver< nDim_ >::c_isLeafCell ( const MInt cellId ) const

inline

Definition at line 350 of file fcsolver.h.

350{ return grid().tree().isLeafCell(cellId); }

◆ c_level()

template<MInt nDim_>

MInt FcSolver< nDim_ >::c_level ( const MInt cellId ) const

inline

Definition at line 346 of file fcsolver.h.

346{ return grid().tree().level(cellId); }

◆ c_neighborId() [1/2]

template<MInt nDim_>

MInt & FcSolver< nDim_ >::c_neighborId	(	const MInt	cellId,
		const MInt	dir
	)

inline

Definition at line 279 of file fcsolver.h.

                                                        {
    // Note: use neighbor list instead of grid().m_tree, also includes diagonal neighbors
    return grid().neighborList(cellId, dir);
  }

◆ c_neighborId() [2/2]

template<MInt nDim_>

MInt FcSolver< nDim_ >::c_neighborId	(	const MInt	cellId,
		const MInt	dir
	)		const

inline

Definition at line 285 of file fcsolver.h.

                                                             {
    // Note: use neighbor list instead of grid().m_tree, also includes diagonal neighbors
    return grid().neighborList(cellId, dir);
  }

◆ c_noCells()

template<MInt nDim_>

MInt FcSolver< nDim_ >::c_noCells ( ) const

inline

Definition at line 344 of file fcsolver.h.

344{ return grid().tree().size(); }

◆ c_noChildren()

template<MInt nDim_>

MInt FcSolver< nDim_ >::c_noChildren ( const MInt cellId ) const

inline

Definition at line 348 of file fcsolver.h.

348{ return grid().tree().noChildren(cellId); }

◆ c_parentId()

template<MInt nDim_>

MInt FcSolver< nDim_ >::c_parentId ( const MInt cellId ) const

inline

Definition at line 354 of file fcsolver.h.

354{ return grid().tree().parent(cellId); }

◆ calcElementDisplacements()

template<MInt nDim_>

void FcSolver< nDim_ >::calcElementDisplacements ( )

◆ calcElementStrains()

template<MInt nDim_>

void FcSolver< nDim_ >::calcElementStrains ( )

◆ calcElementStresses()

template<MInt nDim_>

void FcSolver< nDim_ >::calcElementStresses ( )

◆ calculateStiffnessMatrix()

template<MInt nDim_>

void FcSolver< nDim_ >::calculateStiffnessMatrix ( )

◆ cleanUp()

template<MInt nDim_>

virtual void FcSolver< nDim_ >::cleanUp ( )

inlinevirtual

Implements Solver.

Definition at line 463 of file fcsolver.h.

463{};

◆ computeAssembledBndryMatrix()

template<MInt nDim_>

void FcSolver< nDim_ >::computeAssembledBndryMatrix	(	MFloatScratchSpace &	Bndry,
		const MInt	pCellId
	)

◆ computeAssembledSystemMatrix()

template<MInt nDim_>

void FcSolver< nDim_ >::computeAssembledSystemMatrix	(	MFloatScratchSpace &	Ke,
		const MInt	pCellId
	)

◆ consistencyCheck()

template<MInt nDim_>

void FcSolver< nDim_ >::consistencyCheck ( )

◆ consistencyCheck2()

template<MInt nDim_>

void FcSolver< nDim_ >::consistencyCheck2 ( )

◆ correctGlobalNodeIds()

template<MInt nDim_>

void FcSolver< nDim_ >::correctGlobalNodeIds ( )

◆ createCompressedMatrix()

template<MInt nDim_>

void FcSolver< nDim_ >::createCompressedMatrix ( )

◆ createElementToNodeMapping()

template<MInt nDim_>

void FcSolver< nDim_ >::createElementToNodeMapping ( )

◆ createElementToNodeMappingGlobal()

template<MInt nDim_>

void FcSolver< nDim_ >::createElementToNodeMappingGlobal ( )

◆ deactivateCells()

template<MInt nDim_>

void FcSolver< nDim_ >::deactivateCells ( )

◆ exchangeExternalSources()

template<MInt nDim_>

void FcSolver< nDim_ >::exchangeExternalSources ( )

inline

Definition at line 459 of file fcsolver.h.

                                 {
    m_log << "Called LsCartesianSolver::exchangeExternalSources without Implementation" << std::endl;
  }

◆ exchangeNodeIds()

template<MInt nDim_>

void FcSolver< nDim_ >::exchangeNodeIds ( MInt currentDomain )

◆ exchangeVector()

template<MInt nDim_>

void FcSolver< nDim_ >::exchangeVector ( MFloat * vector )

◆ fillDisplacementVectorWithCoords()

template<MInt nDim_>

void FcSolver< nDim_ >::fillDisplacementVectorWithCoords ( )

◆ finalizeInitSolver()

template<MInt nDim_>

void FcSolver< nDim_ >::finalizeInitSolver ( )

overridevirtual

Implements Solver.

◆ geometry() [1/2]

template<MInt nDim_>

Geom & FcSolver< nDim_ >::geometry ( )

inlineprotected

Definition at line 483 of file fcsolver.h.

483{ return *m_geometry; }

FcSolver::m_geometry

Geometry< nDim > * m_geometry

Definition: fcsolver.h:484

◆ geometry() [2/2]

template<MInt nDim_>

constexpr const Geom & FcSolver< nDim_ >::geometry ( ) const

inlineconstexpr

Definition at line 437 of file fcsolver.h.

437{ return *m_geometry; }

◆ getCoordinatesOfNode()

template<MInt nDim_>

void FcSolver< nDim_ >::getCoordinatesOfNode	(	MInt	node,
		MInt	cell,
		MFloat *	coordinates
	)

◆ getDerivativeOfDisplacementInterpolationMatrix()

template<MInt nDim_>

void FcSolver< nDim_ >::getDerivativeOfDisplacementInterpolationMatrix	(	const MInt	pCellId,
		const MFloat *	z,
		MFloatScratchSpace &	x
	)

◆ getDisplacementInterpolationMatrix()

template<MInt nDim_>

void FcSolver< nDim_ >::getDisplacementInterpolationMatrix	(	const MInt	pCellId,
		const MFloat *	z,
		MFloatScratchSpace &	x
	)

◆ getDisplacementInterpolationMatrixDebug()

template<MInt nDim_>

void FcSolver< nDim_ >::getDisplacementInterpolationMatrixDebug	(	const MInt	pCellId,
		const MFloat *	z,
		MFloatScratchSpace &	L_coef_lagrange
	)

◆ getDisplacementsAtPoint()

template<MInt nDim_>

void FcSolver< nDim_ >::getDisplacementsAtPoint	(	const MInt	cellId,
		const MFloat *	z,
		const MFloat *	displ,
		MFloat *	result
	)

◆ getElementMatrix()

template<MInt nDim_>

void FcSolver< nDim_ >::getElementMatrix	(	MFloatScratchSpace &	Ke,
		const MInt	pCellId,
		const MFloat	alpha,
		const MInt	subCellLevel,
		const MFloat *	subCellCoord = `nullptr`
	)

◆ getHydrostaticPressure()

template<MInt nDim_>

MFloat FcSolver< nDim_ >::getHydrostaticPressure ( const MFloat * stresses )

inline

Definition at line 335 of file fcsolver.h.

                                                        {
    MFloat hydrostaticPressure = F0;
    for(MInt d = 0; d < nDim; d++) {
      hydrostaticPressure += stresses[d];
    }
    return (hydrostaticPressure * F1B3);
  }

◆ getIdAtPoint()

template<MInt nDim_>

MInt FcSolver< nDim_ >::getIdAtPoint	(	const MFloat *	point,
		MBool	NotUsedglobalUnique=false
	)

inline

Definition at line 323 of file fcsolver.h.

                                                                              {
    return grid().raw().findContainingLeafCell(point, nullptr, solverId());
  }

◆ getInternalLoadsFromStresses()

template<MInt nDim_>

void FcSolver< nDim_ >::getInternalLoadsFromStresses ( )

◆ getJacobiMatrixDebug()

template<MInt nDim_>

void FcSolver< nDim_ >::getJacobiMatrixDebug	(	const MInt	pCellId,
		const MFloat *	z,
		MFloatScratchSpace &	jacobi_lagrange
	)

◆ getMaterialTensor()

template<MInt nDim_>

void FcSolver< nDim_ >::getMaterialTensor	(	MFloatScratchSpace &	C,
		const MInt	pCellId,
		const MInt	node = `-1`
	)

◆ getNodalStiffnessMatrix()

template<MInt nDim_>

void FcSolver< nDim_ >::getNodalStiffnessMatrix	(	const MInt	pCellId,
		const MInt	node,
		MFloatScratchSpace &	Ke,
		MInt *	nodePos,
		MFloat *	z,
		MFloat	determinant,
		const MFloat	alpha,
		const MInt	subCellLevel
	)

◆ getReactionForces()

template<MInt nDim_>

void FcSolver< nDim_ >::getReactionForces ( )

◆ getStrainInterpolationMatrix()

template<MInt nDim_>

void FcSolver< nDim_ >::getStrainInterpolationMatrix	(	MFloatScratchSpace &	Be,
		const MInt	pCellId,
		const MFloat *	z
	)

◆ getStrainInterpolationMatrixDebug()

template<MInt nDim_>

void FcSolver< nDim_ >::getStrainInterpolationMatrixDebug	(	const MInt	pCellId,
		const MFloat *	z,
		MFloatScratchSpace &	strain_lagrange
	)

◆ getStrainsAtPoint()

template<MInt nDim_>

void FcSolver< nDim_ >::getStrainsAtPoint	(	const MInt	cellId,
		const MFloat *	z,
		const MFloat *	displ,
		MFloat *	strains
	)

◆ getStressesAtPoint()

template<MInt nDim_>

void FcSolver< nDim_ >::getStressesAtPoint	(	const MInt	cellId,
		const MFloat *	z,
		const MFloat *	displ,
		MFloat *	stresses
	)

◆ getVolumetricStrains()

template<MInt nDim_>

MFloat FcSolver< nDim_ >::getVolumetricStrains ( const MFloat * strains )

inline

Definition at line 327 of file fcsolver.h.

                                                     {
    MFloat epsV = F0;
    for(MInt d = 0; d < nDim; d++) {
      epsV += strains[d];
    }
    return (epsV * F1B3);
  }

◆ initJacobianMatrix()

template<MInt nDim_>

void FcSolver< nDim_ >::initJacobianMatrix ( )

◆ initSolver()

template<MInt nDim_>

void FcSolver< nDim_ >::initSolver ( )

overridevirtual

Implements Solver.

◆ initTimer()

template<MInt nDim_>

void FcSolver< nDim_ >::initTimer ( )

◆ interpolateGeometry()

template<MInt nDim_>

void FcSolver< nDim_ >::interpolateGeometry	(	const MInt	pCellId,
		const MFloat *	x,
		MFloat *	z
	)

◆ interpolateGeometryDebug()

template<MInt nDim_>

void FcSolver< nDim_ >::interpolateGeometryDebug	(	const MInt	pCellId,
		const MFloat *	z,
		MFloat *	x
	)

◆ interpolateSubCellGeometry()

template<MInt nDim_>

void FcSolver< nDim_ >::interpolateSubCellGeometry	(	const MInt	pCellId,
		const MFloat *	z,
		MFloat *	x,
		const MInt	subCellLevel,
		const MFloat *	subCellCoord
	)

◆ isActive()

template<MInt nDim_>

MBool FcSolver< nDim_ >::isActive ( ) const

inlineoverridevirtual

Return if the solver is active on this rank; needs to be implemented in derived solver since access to gridproxy not possible here

Reimplemented from Solver.

Definition at line 363 of file fcsolver.h.

363{ return grid().isActive(); }

◆ lagrangianPointsJacobi()

template<MInt nDim_>

void FcSolver< nDim_ >::lagrangianPointsJacobi	(	const MInt	pCellId,
		const MFloat *	z,
		MFloatScratchSpace &	x
	)

◆ lhs()

template<MInt nDim_>

void FcSolver< nDim_ >::lhs ( )

◆ lhsBnd()

template<MInt nDim_>

void FcSolver< nDim_ >::lhsBnd ( )

◆ noInternalCells()

template<MInt nDim_>

MInt FcSolver< nDim_ >::noInternalCells ( ) const

inlineoverridevirtual

Implements Solver.

Definition at line 78 of file fcsolver.h.

78{ return grid().noInternalCells(); }

◆ postTimeStep()

template<MInt nDim_>

void FcSolver< nDim_ >::postTimeStep ( )

overridevirtual

Implements Solver.

◆ prepareRestart()

template<MInt nDim_>

MBool FcSolver< nDim_ >::prepareRestart	(	MBool	,
		MBool &
	)

overridevirtual

Reimplemented from Solver.

◆ preTimeStep()

template<MInt nDim_>

void FcSolver< nDim_ >::preTimeStep ( )

overridevirtual

Implements Solver.

◆ reIntAfterRestart()

template<MInt nDim_>

void FcSolver< nDim_ >::reIntAfterRestart ( MBool doneRestart )

virtual

Reimplemented from Solver.

◆ reorderLocalNodeIds()

template<MInt nDim_>

void FcSolver< nDim_ >::reorderLocalNodeIds ( )

◆ resetActiveState()

template<MInt nDim_>

void FcSolver< nDim_ >::resetActiveState ( )

◆ resetDisplacements()

template<MInt nDim_>

void FcSolver< nDim_ >::resetDisplacements ( const MInt mode = -1 )

◆ resetExternalSources()

template<MInt nDim_>

void FcSolver< nDim_ >::resetExternalSources ( )

inline

Definition at line 456 of file fcsolver.h.

                              {
    m_log << "Called LsCartesianSolver::resetExternalSources without Implementation" << std::endl;
  }

◆ resetLoadVector()

template<MInt nDim_>

void FcSolver< nDim_ >::resetLoadVector ( const MInt mode = -1 )

◆ rhs()

template<MInt nDim_>

void FcSolver< nDim_ >::rhs ( )

◆ rhsBnd()

template<MInt nDim_>

void FcSolver< nDim_ >::rhsBnd ( )

◆ saveRestartStrainsOnly()

template<MInt nDim_>

void FcSolver< nDim_ >::saveRestartStrainsOnly	(	const MChar *	fileName,
		const MChar *	gridInputFileName,
		MInt *	recalcIdTree = `nullptr`
	)

◆ saveSolverSolution()

template<MInt nDim_>

void FcSolver< nDim_ >::saveSolverSolution	(	MBool	forceOutput,
		const MBool	finalTimeStep
	)

override

◆ setCellWeights()

template<MInt nDim_>

void FcSolver< nDim_ >::setCellWeights ( MFloat * )

overridevirtual

Reimplemented from Solver.

◆ setGlobalNodeIds()

template<MInt nDim_>

void FcSolver< nDim_ >::setGlobalNodeIds ( )

◆ setIntegrationWeights()

template<MInt nDim_>

void FcSolver< nDim_ >::setIntegrationWeights ( )

◆ solutionStep()

template<MInt nDim_>

MBool FcSolver< nDim_ >::solutionStep ( )

overridevirtual

Reimplemented from Solver.

◆ solveMatrixIteratively()

template<MInt nDim_>

void FcSolver< nDim_ >::solveMatrixIteratively	(	MFloat *	A_coeff,
		MInt **	pos,
		const MInt	n
	)

◆ solveMatrixIterativelyPreCon()

template<MInt nDim_>

void FcSolver< nDim_ >::solveMatrixIterativelyPreCon	(	MFloat *	A_coeff,
		MInt **	pos,
		const MInt	n,
		const MInt	m,
		MFloat *	b,
		MFloat *	x
	)

◆ solveSystemOfEquations()

template<MInt nDim_>

void FcSolver< nDim_ >::solveSystemOfEquations ( )

◆ time()

template<MInt nDim_>

MFloat FcSolver< nDim_ >::time ( ) const

inlineoverridevirtual

Implements Solver.

Definition at line 432 of file fcsolver.h.

432{ return m_time; }

FcSolver::m_time

MFloat m_time

Definition: fcsolver.h:488

◆ transformToLocal()

template<MInt nDim_>

void FcSolver< nDim_ >::transformToLocal	(	const MInt	pCellId,
		const MFloat *	z,
		MFloat *	x
	)

◆ updateCellCollectorFromGrid()

template<MInt nDim_>

void FcSolver< nDim_ >::updateCellCollectorFromGrid ( )

◆ updateDisplacements()

template<MInt nDim_>

void FcSolver< nDim_ >::updateDisplacements ( )

◆ updateLoadVector()

template<MInt nDim_>

void FcSolver< nDim_ >::updateLoadVector ( const MFloat lambda = F1 )

◆ writeRestartFile()

template<MInt nDim_>

void FcSolver< nDim_ >::writeRestartFile	(	const MBool	writeRestart,
		const MBool	writeBackup,
		const MString	gridFileName,
		MInt *	recalcIdTree
	)

overridevirtual

Reimplemented from Solver.

Friends And Related Function Documentation

◆ FcBndryCnd

template<MInt nDim_>

template<MInt nDim>

friend class FcBndryCnd

friend

Definition at line 29 of file fcsolver.h.

Member Data Documentation

◆ calcStiffMat

template<MInt nDim_>

MInt FcSolver< nDim_ >::calcStiffMat

Definition at line 472 of file fcsolver.h.

◆ displacementBC

template<MInt nDim_>

MInt FcSolver< nDim_ >::displacementBC

Definition at line 476 of file fcsolver.h.

◆ exchange

template<MInt nDim_>

MInt FcSolver< nDim_ >::exchange

Definition at line 478 of file fcsolver.h.

◆ forceBC

template<MInt nDim_>

MInt FcSolver< nDim_ >::forceBC

Definition at line 475 of file fcsolver.h.

◆ initSolver

template<MInt nDim_>

MInt FcSolver< nDim_ >::initSolver

Definition at line 471 of file fcsolver.h.

◆ m_adaptation

template<MInt nDim_>

MBool FcSolver< nDim_ >::m_adaptation = false

Definition at line 493 of file fcsolver.h.

◆ m_adaptationSinceLastRestart

template<MInt nDim_>

MBool FcSolver< nDim_ >::m_adaptationSinceLastRestart = false

Definition at line 491 of file fcsolver.h.

◆ m_adaptationSinceLastSolution

template<MInt nDim_>

MBool FcSolver< nDim_ >::m_adaptationSinceLastSolution = false

Definition at line 492 of file fcsolver.h.

◆ m_addingPenalties

template<MInt nDim_>

MBool FcSolver< nDim_ >::m_addingPenalties = true

private

Definition at line 517 of file fcsolver.h.

◆ m_alpha

template<MInt nDim_>

MFloat FcSolver< nDim_ >::m_alpha = 1e-14

private

Definition at line 516 of file fcsolver.h.

◆ m_analyticSolution

template<MInt nDim_>

MFloat FcSolver< nDim_ >::m_analyticSolution = F1

private

Definition at line 506 of file fcsolver.h.

◆ m_bndryCnd

template<MInt nDim_>

FcBndryCnd<nDim>* FcSolver< nDim_ >::m_bndryCnd = nullptr

protected

Definition at line 486 of file fcsolver.h.

◆ m_bndryMatCompressed

template<MInt nDim_>

MFloat* FcSolver< nDim_ >::m_bndryMatCompressed = nullptr

protected

Definition at line 533 of file fcsolver.h.

◆ m_cells

template<MInt nDim_>

maia::fc::collector::FcCellCollector<nDim> FcSolver< nDim_ >::m_cells

protected

Definition at line 548 of file fcsolver.h.

◆ m_compressionIndexBndry

template<MInt nDim_>

MInt** FcSolver< nDim_ >::m_compressionIndexBndry = nullptr

protected

Definition at line 534 of file fcsolver.h.

◆ m_compressionIndexSys

template<MInt nDim_>

MInt** FcSolver< nDim_ >::m_compressionIndexSys = nullptr

protected

Definition at line 532 of file fcsolver.h.

◆ m_E

template<MInt nDim_>

MFloat FcSolver< nDim_ >::m_E = 100000.0

private

Definition at line 509 of file fcsolver.h.

◆ m_eps

template<MInt nDim_>

MFloat FcSolver< nDim_ >::m_eps = 1e-12

private

Definition at line 511 of file fcsolver.h.

◆ m_externalLoadVector

template<MInt nDim_>

MFloat* FcSolver< nDim_ >::m_externalLoadVector = nullptr

protected

Definition at line 525 of file fcsolver.h.

◆ m_fcInterpolationMethod

template<MInt nDim_>

MString FcSolver< nDim_ >::m_fcInterpolationMethod = ""

private

Definition at line 514 of file fcsolver.h.

◆ m_finalGlobalMatrix

template<MInt nDim_>

std::map<std::pair<MInt, MInt>, MFloat> FcSolver< nDim_ >::m_finalGlobalMatrix

protected

Definition at line 541 of file fcsolver.h.

◆ m_first

template<MInt nDim_>

MBool FcSolver< nDim_ >::m_first = true

private

Definition at line 507 of file fcsolver.h.

◆ m_gaussPoints

template<MInt nDim_>

MFloat** FcSolver< nDim_ >::m_gaussPoints = nullptr

protected

Definition at line 536 of file fcsolver.h.

◆ m_gaussWeights

template<MInt nDim_>

MFloat** FcSolver< nDim_ >::m_gaussWeights = nullptr

protected

Definition at line 537 of file fcsolver.h.

◆ m_geometry

template<MInt nDim_>

Geometry<nDim>* FcSolver< nDim_ >::m_geometry

protected

Definition at line 484 of file fcsolver.h.

◆ m_geometryIntersection

template<MInt nDim_>

GeometryIntersection<nDim>* FcSolver< nDim_ >::m_geometryIntersection

Definition at line 439 of file fcsolver.h.

◆ m_globalBndryMatrix

template<MInt nDim_>

std::map<std::pair<MInt, MInt>, MFloat> FcSolver< nDim_ >::m_globalBndryMatrix

protected

Definition at line 540 of file fcsolver.h.

◆ m_globalNodeIdOffsets

template<MInt nDim_>

MInt* FcSolver< nDim_ >::m_globalNodeIdOffsets = nullptr

protected

Definition at line 530 of file fcsolver.h.

◆ m_globalStiffnessMatrix

template<MInt nDim_>

std::map<std::pair<MInt, MInt>, MFloat> FcSolver< nDim_ >::m_globalStiffnessMatrix

protected

Definition at line 539 of file fcsolver.h.

◆ m_globalToLocalId

template<MInt nDim_>

MInt* FcSolver< nDim_ >::m_globalToLocalId = nullptr

protected

Definition at line 529 of file fcsolver.h.

◆ m_internalLoadVector

template<MInt nDim_>

MFloat* FcSolver< nDim_ >::m_internalLoadVector = nullptr

protected

Definition at line 526 of file fcsolver.h.

◆ m_isThermal

template<MInt nDim_>

MBool FcSolver< nDim_ >::m_isThermal = false

private

Definition at line 510 of file fcsolver.h.

◆ m_localToGlobalId

template<MInt nDim_>

MInt* FcSolver< nDim_ >::m_localToGlobalId = nullptr

protected

Definition at line 528 of file fcsolver.h.

◆ m_maxNoIterations

template<MInt nDim_>

MInt FcSolver< nDim_ >::m_maxNoIterations = 10000

private

Definition at line 512 of file fcsolver.h.

◆ m_nodalDisplacements

template<MInt nDim_>

MFloat* FcSolver< nDim_ >::m_nodalDisplacements = nullptr

protected

Definition at line 522 of file fcsolver.h.

◆ m_nodalLoadVector

template<MInt nDim_>

MFloat* FcSolver< nDim_ >::m_nodalLoadVector = nullptr

protected

Definition at line 524 of file fcsolver.h.

◆ m_noDirs

template<MInt nDim_>

constexpr const MInt FcSolver< nDim_ >::m_noDirs = 2 * nDim

staticconstexpr

Definition at line 357 of file fcsolver.h.

◆ m_noHaloNodes

template<MInt nDim_>

MInt FcSolver< nDim_ >::m_noHaloNodes = 0

private

Definition at line 502 of file fcsolver.h.

◆ m_noInternalNodes

template<MInt nDim_>

MInt FcSolver< nDim_ >::m_noInternalNodes = 0

private

Definition at line 501 of file fcsolver.h.

◆ m_noLoadSteps

template<MInt nDim_>

MInt FcSolver< nDim_ >::m_noLoadSteps = 1

private

Definition at line 513 of file fcsolver.h.

◆ m_nonBlockingComm

template<MInt nDim_>

MBool FcSolver< nDim_ >::m_nonBlockingComm = false

protected

Definition at line 481 of file fcsolver.h.

◆ m_noStrains

template<MInt nDim_>

constexpr MInt FcSolver< nDim_ >::m_noStrains = (nDim == 2) ? (nDim + 1) : (nDim * 2)

staticconstexprprivate

Definition at line 497 of file fcsolver.h.

◆ m_poissonRatio

template<MInt nDim_>

MFloat FcSolver< nDim_ >::m_poissonRatio = 0.3

private

Definition at line 504 of file fcsolver.h.

◆ m_polyDeg

template<MInt nDim_>

MInt FcSolver< nDim_ >::m_polyDeg = 0

private

Definition at line 503 of file fcsolver.h.

◆ m_printEigenValues

template<MInt nDim_>

MBool FcSolver< nDim_ >::m_printEigenValues = false

private

Definition at line 515 of file fcsolver.h.

◆ m_reactionForceVector

template<MInt nDim_>

MFloat* FcSolver< nDim_ >::m_reactionForceVector = nullptr

protected

Definition at line 527 of file fcsolver.h.

◆ m_recalcIds

template<MInt nDim_>

MInt* FcSolver< nDim_ >::m_recalcIds = nullptr

protected

Definition at line 551 of file fcsolver.h.

◆ m_solveSoEIteratively

template<MInt nDim_>

MBool FcSolver< nDim_ >::m_solveSoEIteratively = true

private

Definition at line 518 of file fcsolver.h.

◆ m_sysMatCompressed

template<MInt nDim_>

MFloat* FcSolver< nDim_ >::m_sysMatCompressed = nullptr

protected

Definition at line 531 of file fcsolver.h.

◆

struct { ... } FcSolver< nDim_ >::m_t

◆ m_testRun

template<MInt nDim_>

MBool FcSolver< nDim_ >::m_testRun = false

private

Definition at line 505 of file fcsolver.h.

◆ m_time

template<MInt nDim_>

MFloat FcSolver< nDim_ >::m_time = F0

protected

Definition at line 488 of file fcsolver.h.

◆ m_totalNodalDisplacements

template<MInt nDim_>

MFloat* FcSolver< nDim_ >::m_totalNodalDisplacements = nullptr

protected

Definition at line 523 of file fcsolver.h.

◆ m_totalNoNodes

template<MInt nDim_>

MInt FcSolver< nDim_ >::m_totalNoNodes = 0

private

Definition at line 499 of file fcsolver.h.

◆ m_totalNoNodesGlobal

template<MInt nDim_>

MInt FcSolver< nDim_ >::m_totalNoNodesGlobal = 0

private

Definition at line 500 of file fcsolver.h.

◆ m_useEigen

template<MInt nDim_>

MBool FcSolver< nDim_ >::m_useEigen = false

private

Definition at line 519 of file fcsolver.h.

◆ m_volume

template<MInt nDim_>

MFloat FcSolver< nDim_ >::m_volume = 0.0

private

Definition at line 508 of file fcsolver.h.

◆ nDim

template<MInt nDim_>

constexpr MInt FcSolver< nDim_ >::nDim = nDim_

staticconstexpr

Definition at line 32 of file fcsolver.h.

◆ solutionStep

template<MInt nDim_>

MInt FcSolver< nDim_ >::solutionStep

Definition at line 473 of file fcsolver.h.

◆ solver

template<MInt nDim_>

MInt FcSolver< nDim_ >::solver

Definition at line 470 of file fcsolver.h.

◆ solving

template<MInt nDim_>

MInt FcSolver< nDim_ >::solving

Definition at line 477 of file fcsolver.h.

◆ subCellInt

template<MInt nDim_>

MInt FcSolver< nDim_ >::subCellInt

Definition at line 474 of file fcsolver.h.

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

/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/FC/fcbndrycnd.h
/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/FC/fcsolver.h

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Attributes

Static Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ CartesianSolver

◆ Cell

◆ Fd

◆ Geom

◆ Grid

◆ GridProxy

◆ SolverCell

Constructor & Destructor Documentation

◆ FcSolver()

◆ ~FcSolver()

Member Function Documentation

◆ a_alpha() [1/2]

◆ a_alpha() [2/2]

◆ a_bndId() [1/2]

◆ a_bndId() [2/2]

◆ a_dGamma() [1/2]

◆ a_dGamma() [2/2]

◆ a_elementDevStrains()

◆ a_elementDevStresses()

◆ a_elementDispl() [1/2]

◆ a_elementDispl() [2/2]

◆ a_elementStrains() [1/2]

◆ a_elementStrains() [2/2]

◆ a_elementStresses() [1/2]

◆ a_elementStresses() [2/2]

◆ a_epsilonBarP() [1/2]

◆ a_epsilonBarP() [2/2]

◆ a_hasNeighbor()

◆ a_hasProperty() [1/3]

◆ a_hasProperty() [2/3]

◆ a_hasProperty() [3/3]

◆ a_invJacobian() [1/2]

◆ a_invJacobian() [2/2]

◆ a_isActive() [1/2]

◆ a_isActive() [2/2]

◆ a_isBndryCell() [1/2]

◆ a_isBndryCell() [2/2]

◆ a_isHalo() [1/2]

◆ a_isHalo() [2/2]

◆ a_isWindow() [1/2]

◆ a_isWindow() [2/2]

◆ a_jacobianMatrix()

◆ a_maxSubCellLvl() [1/2]

◆ a_maxSubCellLvl() [2/2]

◆ a_needsSubCells() [1/2]

◆ a_needsSubCells() [2/2]

◆ a_noCells()

◆ a_nodalDevStrains()

◆ a_nodalDevStresses()

◆ a_nodalStrains() [1/2]

◆ a_nodalStrains() [2/2]

◆ a_nodalStresses() [1/2]

◆ a_nodalStresses() [2/2]

◆ a_nodeIdsGlobal() [1/2]

◆ a_nodeIdsGlobal() [2/2]

◆ a_nodeIdsLocal() [1/2]

◆ a_nodeIdsLocal() [2/2]

◆ a_nodePosition() [1/2]

◆ a_nodePosition() [2/2]

◆ a_noNodes() [1/2]

◆ a_noNodes() [2/2]

◆ a_poissonRatio() [1/2]

◆ a_poissonRatio() [2/2]

◆ a_pRfnmnt() [1/2]

◆ a_pRfnmnt() [2/2]

◆ a_resetPropertiesSolver()

◆ a_wasActive() [1/2]

◆ a_wasActive() [2/2]