QuOc

 

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_CubicGridType
_FullGridType
qc::AArray< DataType, dim >
qc::AArray< DataType, qc::QC_2D >
qc::AArray< DataType, qc::QC_3D >
aol::ABlockOp< VectorType, OpType >
mg::AbstractMultigrid< VectorType >
nb::ActionBlockSubGridSparseMatrixEigenvalues< DataType, ConfigType >
qc::ScalarArray< _DataType, qc::QC_2D >::addCopier
aol::AdditionalOutputToFilePrint cout and cerr not only to console (or whereever you have redirected it), but also to a file
qc::AffineDisplacementProjectionEnergy< ConfiguratorType >This class computes via "apply(...)": $ \int_\Omega w(x)(d-Ax-b)^2 dx $ in "Dest", where the domain $ \Omega $, the weight $ w $, and the displacement $ d $ are passed to the constructor, and $ b $ and $ A $ are passed to "apply(...)"
qc::AffineDisplacementProjectionGradient< ConfiguratorType >This class computes via "apply(...)" the gradient of $ \int_\Omega w(x)(d-Ax-b)^2 dx $ wrt $ A $ and $ b $ in "Dest", where the domain $ \Omega $ and the displacement $ d $ are passed to the constructor, and $ b $ and $ A $ are passed to "apply(...)"
tpcfe::AffineFE3D15Row< GridType >
qc::AffineFEBandMatrix< DataTye, dim >
qc::AffineFEBandMatrix< DataType, qc::QC_3D >
aol::AffineTransformation< MatrixType, DomainType, RangeType >
aol::AlignedCube< RealType >
aol::AlignedQuad< RealType >
tpcfe::AllFacePoempelRemover< RealType >
aol::AMultiVector< ComponentType >
qc::AnisoTangentialProjectionStiffOp< ConfiguratorType, IndexMode >
qc::AnisotropicDiffusion2DStiffOp< ConfiguratorType >
qc::AnisotropicDiffusion3DLevelSetStiffOp< ConfiguratorType, LinearSmootherType >
qc::AnisotropicDiffusion3DStiffOp< ConfiguratorType, LinearSmootherType >
qc::Anisotropy3dGraphInterface< RealType, Imp >(Hopefully) efficient graph interface for 3d-anisotropies to be used in the 2d-graph-case
qc::AnisotropyIntegrationOp< ConfiguratorType, AnisoType >
qc::AnisotropyMassIntegrationOp< ConfiguratorType, AnisoType >
qc::AnisotropyStiffOp< ConfiguratorType, AnisoType, IndexMode >
qc::AnisotropyStiffOpPositionDepending< ConfiguratorType, AnisoType, IndexMode >
qc::AnisotropyVisualizer2d< RealType, AnisoType >
qc::AnisotropyVisualizer3d< RealType, AnisoType >
qc::AnisoWillmoreEnergyOp< ConfiguratorType, BoundaryQuadratureType, AnisoType >
qc::AntiCompressionHyperelasticEnergyDensity< ConfiguratorType, HyperelasticEnergyDensityType >This class represents the hyperelastic energy density $ W(I_1,I_2,I_3) + f(I3) $ with respect to the invariants $ I_1=||\nabla\phi||_F^2 $, $ I_2=||cof(\nabla\phi)||_F^2 $, $ I_3=det(\nabla\phi) $ of the deformation gradient $\nabla\phi$, where the hyperelastic energy $W$ has to be passed to the constructor and $ f(x)=-\log(3x)+\frac5{12} $ for $ x<\frac13 $, $ f(x)=-\frac92(\frac92x+1)(x-\frac23)^3 $ for $ \frac13< x <\frac23 $, and $ f(x)=0 $ for $ x>\frac23 $
aol::ArcTanHeavisideFunction< RealType >
aol::ArmijoLineSearchUsingOp< RealType, DomainType, RangeType, DerivativeType >The interface of searching based on Armijo rule
qc::Array< DataType >
qc::ArrayHeader
aol::AssertAtCompileTime< true >
qc::ATAnisoGradSqrOp< ConfiguratorType, AnisotropyType >
qc::ATAnisotropy1Norm< ConfiguratorType >
qc::ATAnisotropy2Norm< ConfiguratorType >
qc::ATAnisotropyDiffOp< ConfiguratorType, AnisotropyType >
qc::ATAnisotropyDiffOpForU< ConfiguratorType, AnisotropyType >
qc::ATAnisotropyOktaeder< ConfiguratorType >
qc::ATAnisotropyStiffOp< ConfiguratorType, AnisotropyType >
qc::ATAnisotropyStiffOpForU< ConfiguratorType, AnisotropyType >
qc::ATDeformationGradient< ConfiguratorType, Dim >
qc::ATEnergyOp< ConfiguratorType >Computes $ \alpha\int (u-u_0)^2 + \beta\int v^2|\nabla u|^2 +... $, where arg[0]=u, arg[1]=v
qc::ATGradSqrOp< ConfiguratorType >
qc::ATMassAnisoU2Op< ConfiguratorType, AnisotropyType >
qc::ATMassGradU2DeformOp< ConfiguratorType >
qc::ATMassGradU2Op< ConfiguratorType >
qc::ATMassV2Op< ConfiguratorType >
qc::ATSegmentation< ConfiguratorType >
qc::ATStiffV2DeformOp< ConfiguratorType >
qc::ATStiffV2Op< ConfiguratorType >
qc::ATWeightedDeformationGradient< ConfiguratorType, Dim >
qc::ATWeightedStiffV2DeformOp< ConfiguratorType >
aol::auto_container< length, T >
qc::AveragingKernel< ConfiguratorType >
qc::Ball
aol::BandMatrix< DataType >
aol::BarCoord< Dim, RealType >
aol::BarCoord< 2, RealType >
aol::BarCoord< 3, RealType >
BaseClass
qc::simplex::BaseFuncSetTFEConstructor< RealType, QuadRuleType, Dim >
qc::simplex::BaseFuncSetTFEConstructor< RealType, QuadRuleType, QC_3D >
qc::simplex::BaseFunctionCollection< RealType, QuadRuleType, Dim >
aol::BaseFunctionSetInterface< RealType, VecType, DomVecType, NumBaseFuncs, QuadRuleType, Imp >
qc::simplex::BaseFunctionSetLin< RealType, Dim, QuadRuleType >
qc::simplex::BaseFunctionSetLin< RealType, QC_2D, QuadRuleType >
qc::simplex::BaseFunctionSetLin< RealType, QC_3D, QuadRuleType >
aol::BaseFunctionSetLinear< RealType, Dim, QuadRuleType >
aol::BaseFunctionSetLinear< RealType, qc::QC_2D, QuadRuleType >Linear base functions for a regular triangulation (cross type: bisection of the rectangle from left bottom to right top)
aol::BaseFunctionSetLinear< RealType, qc::QC_3D, QuadRuleType >The basefunctionset for linear elements in 3d
aol::BaseFunctionSetMultiLin< RealType, Dim, QuadRuleType >
aol::BaseFunctionSetMultiLin< RealType, qc::QC_1D, QuadRuleType >The basefunctionset for bilinear elements in 1d
aol::BaseFunctionSetMultiLin< RealType, qc::QC_2D, QuadRuleType >The basefunctionset for bilinear elements in 2d
aol::BaseFunctionSetMultiLin< RealType, qc::QC_3D, QuadRuleType >The basefunctionset for bilinear elements in 3d
aol::BaseFunctionSetMultiLinBubble< RealType, Dim, QuadRuleType >
aol::BaseFunctionSetMultiLinBubble< RealType, qc::QC_2D, QuadRuleType >The basefunctionset for bilinear elements in 2d
aol::BaseFunctionSetMultiQuad< RealType, Dim, QuadRuleType >
aol::BaseFunctionSetMultiQuad< RealType, qc::QC_2D, QuadRuleType >
qc::simplex::BaseFunctionSetTFE< RealType, Dim, QuadRuleType >
qc::BaseFunctionSetTFE< RealType, QuadRuleType >
qc::BaseFunctionSetTFE_Static< RealType, QuadRuleType >
BaseInfo
qc::BaseRegistrationConfigurator< ConfiguratorType >
qc::Basis2DConst< RealType >
qc::Basis2DX< RealType >
qc::Basis2DXX< RealType >
qc::Basis2DXY< RealType >
qc::Basis2DY< RealType >
qc::Basis2DYY< RealType >
qc::BasisFunction2D< RealType >
aol::QuasiNewtonBFGS< RealType, VectorType, DerivativeType >::BFGSOp
aol::BiCGInverse< VectorType, OpType >BiCG for nonsymmetric matrices
aol::BiOp< VectorType >
aol::BiOpBase< VectorType >
aol::BiOpBase< MultiVector< RealType > >
aol::BiOpBase< Vector< RealType > >
qc::BitArray< qc::QC_2D >
qc::BitArray< qc::QC_3D >
qc::BitArrayTrait< dim >
qc::BitArrayTrait< 1 >
qc::BitArrayTrait< 2 >
qc::BitArrayTrait< 3 >
aol::BitMaskFunctorFalse
aol::BitMaskFunctorIdentity
aol::BitMaskFunctorNegate
aol::BitMaskFunctorTrue
aol::BitVector
aol::BlockDiagonalPreconditioner< RealType, Dim >A class for block-diagonally preconditioning BlockMatrices with diagonal blocks all the same size and all set
aol::BlockGaussSeidelPreconditioner< VectorType, BlockOpType >
mg::BlockGaussSeidelSelectiveSmoother< VectorType, BlockOpType >
aol::BlockGaussSeidelSelectiveSweeper< RealType, BlockOpType >
mg::BlockGaussSeidelSmoother< VectorType, OpType >
aol::BlockGaussSeidelSweeper< RealType, BlockOpType >
aol::BlockMatrix< MatrixType >
aol::BlockOp< RealType, OpType >
aol::BlockOpBase< RealType, OpType >
aol::BlockSSORPreconditioner< RealType, BlockMatrixType, Dim >
mg::BoomerAMGSolver< OpType, RealType >
qc::BoundaryDiffIntegrationInterface< ConfiguratorType, VecType, Dimension, QuadType, Imp >
qc::BoundaryDiffIntegrationInterface< ConfiguratorType, VecType, qc::QC_2D, QuadType, Imp >
qc::BoundaryDiffIntegrationInterface< ConfiguratorType, VecType, qc::QC_3D, QuadType, Imp >
qc::BoundaryFaceElement< RealType, Dim >
qc::BoundaryFaceElement< RealType, qc::QC_2D >
qc::BoundaryFaceElement< RealType, qc::QC_3D >
qc::BoundaryFaceElementBase< RealType >Base class of 2D/3D boundary element. It knows on which face of the boundary it lies and the corresponding normal vector
qc::BoundaryIntegrationInterface< ConfiguratorType, VecType, Dimension, QuadType, Imp >
nb::BoundaryIntegrationInterface< ConfigType, GridType, VecType, Dimension, QuadType, Imp >
nb::BoundaryIntegrationInterface< ConfigType, GridType, VecType, qc::QC_2D, QuadType, Imp >
nb::BoundaryIntegrationInterface< ConfigType, GridType, VecType, qc::QC_3D, QuadType, Imp >
qc::BoundaryIntegrationInterface< ConfiguratorType, VecType, qc::QC_2D, QuadType, Imp >
qc::BoundaryIntegrationInterface< ConfiguratorType, VecType, qc::QC_3D, QuadType, Imp >3d-specification
om::TriMesh< _RealType >::BoundaryNodeIter
qc::BoundaryWeightedMatrixDiffIntegrationInterface< ConfiguratorType, VecType, Dimension, QuadType, Imp >
qc::BoundaryWeightedMatrixDiffIntegrationInterface< ConfiguratorType, VecType, qc::QC_2D, QuadType, Imp >
aol::BusyBar< _screenWidth, _fullLength, _leftBrace, _rightBrace, _empty, _full >
aol::BzipifstreamCan be used like an ifstream, but supports on the fly bzip2 decompression using libbz2
aol::BzipofstreamCan be used like an ofstream, but supports on the fly bzip2 compression using libbz2
qc::CachedBicubicInterpolator< RealType >
aol::CastOp< VecType, DerivedVecType >
aol::CDQEnergyDerivativeOp< DataType, IndexType >
aol::CDQEnergyGradientOp< DataType, IndexType >
om::CenterQuadrature< RealType >
tpcfe::CFEAssembledBlockOp< ConfiguratorType >
tpcfe::CFEBandMatrix< GridType >
tpcfe::CFEBandMatrix< CFEGrid< _DataType, CFE_CD, NodalCoeffType > >
tpcfe::CFEBandMatrix< CFEGrid< _DataType, CFE_LIEHR > >
tpcfe::CFEBandMatrix< CFEGrid< DataType, CFE_TPOS > >
tpcfe::CFEBandMatrix< CFEGrid< DataType, CFE_TPOSELAST, NodalCoeffType > >
tpcfe::CFEBlockMultigrid< CFEBlockOpType, RePrOpType, CMode >
tpcfe::CFEBlockMultigridPreconditioner< CFEBlockOpType, RePrOpType, CMode >
tpcfe::CFEBlockMultigridProjectAvgConstr< CFEBlockOpType, CFEMassOpType, CMode >
tpcfe::CFEConfigurator< _GridType, _MatrixType >
tpcfe::CFECube
tpcfe::CFEElastOp< _ConfiguratorType >
tpcfe::CFEElement< RealType >
tpcfe::CFEFullyAnisotropicElastOp< _ConfiguratorType >
tpcfe::CFEGeomVirtualNode< RealType >
tpcfe::CFEGrid< _RealType, _CT, NodalCoeffType >For template specialization
tpcfe::CFEGrid< _RealType, CFE_CD, _NodalCoeffType >
tpcfe::CFEGrid< _RealType, CFE_CDWI_LIEHR, _RealType >
tpcfe::CFEGrid< _RealType, CFE_CDWI_TPOS, _RealType >
tpcfe::CFEGrid< _RealType, CFE_DOMAIN, _RealType >
tpcfe::CFEGrid< _RealType, CFE_LIEHR, _RealType >
tpcfe::CFEGrid< _RealType, CFE_NONE, _RealType >
tpcfe::CFEGrid< _RealType, CFE_TP, _RealType >
tpcfe::CFEGrid< _RealType, CFE_TPOS, _RealType >
tpcfe::CFEGrid< _RealType, CFE_TPOSELAST, _NodalCoeffType >
tpcfe::CFEGridBase< _RealType, _CT, NodalCoeffType >
tpcfe::CFEGridDefinition
tpcfe::CFEHybridMatrix< GridType >
tpcfe::CFEHybridMatrix< CFEGrid< DataType, CFE_CD, NodalCoeffType > >
tpcfe::CFEHybridMatrix< CFEGrid< DataType, CFE_LIEHR > >
tpcfe::CFEHybridMatrix< CFEGrid< DataType, CFE_TPOS > >
tpcfe::CFEHybridMatrix< CFEGrid< DataType, CFE_TPOSELAST, NodalCoeffType > >
tpcfe::CFEHybridMatrixBase< GridType >
tpcfe::CFEInterfaceTriang< RealType >
tpcfe::CFEInterfaceTriangleIterator< GridType >
tpcfe::CFEInterfaceTriangulationGenerator< GridType, Float_Type >
tpcfe::CFEInterfaceTriangulationWithComponentDataGenerator< GridType >
tpcfe::CFEInterfaceTriangulationWithScalarDataGenerator< GridType >
tpcfe::CFEInterfaceTriangulationWithVonMisesStressGenerator< GridType >Basis class for template specialization
tpcfe::CFEInterfaceTriangulationWithVonMisesStressGenerator< tpcfe::CFEGrid< _RealType, tpcfe::CFE_CD, _RealType > >Complicated domain, microscopic isotropy given by Lame-Navier constants
tpcfe::CFEInterfaceTriangulationWithVonMisesStressGenerator< tpcfe::CFEGrid< _RealType, tpcfe::CFE_TPOSELAST, tpcfe::IsotropicElasticityCoefficient< _RealType > > >Jumping coefficient elasticity,
tpcfe::CFEInterfaceTriangulationWithVonMisesStressGeneratorBase< GridType >
tpcfe::CFEJCElastOp< _ConfiguratorType >
tpcfe::CFEJCEMassOp< _ConfiguratorType >
tpcfe::CFELinOpInterface< T_ConfiguratorType, Imp >
tpcfe::CFELookup< RealType >
tpcfe::CFEMassOp< _ConfiguratorType >
tpcfe::CFEMassOpWI< _ConfiguratorType >
tpcfe::CFEMatrixAssembler< RealType, MatrixType, CT >
tpcfe::CFEMatrixAssembler< RealType, MatrixType, CFE_DOMAIN >
tpcfe::CFEMixedDerivativeOp< ConfiguratorType >
tpcfe::CFEMixedDerivativeOpBase< ConfiguratorType >
tpcfe::CFEMultigrid< CFEOpType, RePrOpType, CMode >
tpcfe::CFEMultigridPreconditioner< CFEOpType, RePrOpType, CMode >
tpcfe::CFEMultigridProjectAvgConstr< CFEOpType, CFEMassOpType, CMode >
tpcfe::CFEOnTheFlyMultiplicator< RealType >
tpcfe::CFEPeriodicHybridMatrix< GridType >
tpcfe::CFEPeriodicHybridMatrix< CFEGrid< DataType, CFE_CD > >
tpcfe::CFEPeriodicHybridMatrix< CFEGrid< DataType, CFE_TPOS > >
tpcfe::CFEPeriodicHybridMatrix< CFEGrid< DataType, CFE_TPOSELAST, NodalCoeffType > >
tpcfe::CFEPeriodicityHandler< CFEGrid< DataType, CFE_CD > >
tpcfe::CFEPeriodicityHandler< CFEGrid< RealType, CFE_TPOS > >
tpcfe::CFEPeriodicityHandler< CFEGrid< RealType, CFE_TPOSELAST, NodalCoeffType > >
tpcfe::CFEPeriodicityHandlerBase< GridType >
tpcfe::CFEPeriodicProlongOp< GridType >
tpcfe::CFEPeriodicRestrictOp< GridType >
tpcfe::CFEProlongOp< GridType >
tpcfe::CFERestrictOp< GridType >
tpcfe::CFEStandardOp< ConfiguratorType, ImpType >
tpcfe::CFEStiffOp< _ConfiguratorType >
tpcfe::CFEStiffOpWI< _ConfiguratorType >
tpcfe::CFEStructure< RealType >
tpcfe::CFEStructureAffine< RealType >
tpcfe::CFEStructureTrilin< RealType >
tpcfe::CFETester
tpcfe::CFETetra< RealType >
tpcfe::CFETetraInElementIterator< RealType >
tpcfe::CFETopoElement
tpcfe::CFETopoLookup
tpcfe::CFETopoTetraBasis class for CFE tetrahedra containing topological data that can usefully be stored in the lookup tables
tpcfe::CFETopoTetraIterator
tpcfe::CFETPOSBandMatrix< GridType >
tpcfe::CFETPOSHybridMatrix< GridType >
tpcfe::CFETPOSPeriodicHybridMatrix< GridType >
tpcfe::CFETPOSPeriodicityHandler< GridType >
tpcfe::CFEType
tpcfe::CFEVirtualNode< RealType, CFE_CD, NodalCoeffType >
tpcfe::CFEVirtualNode< RealType, CFE_CDWI_LIEHR, RealType >
tpcfe::CFEVirtualNode< RealType, CFE_CDWI_TPOS, RealType >
tpcfe::CFEVirtualNode< RealType, CFE_DOMAIN, RealType >
tpcfe::CFEVirtualNode< RealType, CFE_LIEHR, RealType >
tpcfe::CFEVirtualNode< RealType, CFE_NONE, RealType >
tpcfe::CFEVirtualNode< RealType, CFE_TP, RealType >
tpcfe::CFEVirtualNode< RealType, CFE_TPOS, RealType >
tpcfe::CFEVirtualNode< RealType, CFE_TPOSELAST, NodalCoeffType >
tpcfe::CFEVirtualNodeBase< RealType, CT, NodalCoeffType >
tpcfe::CFEVirtualNodeScalar< RealType, CT >
tpcfe::CFEWeightedStandardOp< ConfiguratorType, ImpType >
tpcfe::CFEWeightProvider< RealType, NodalCoeffType >
qc::CGBasedInverseH1Metric< ConfiguratorType >
aol::CGInverse< VectorType, OpType >
aol::CGInverseProjectEqConstr< VectorType, OpType >
aol::ChanVeseEnergyInterface< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions, ParameterDimension, Imp >
aol::ChanVeseEnergyLevelsetDerivativeInterface< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions, Imp >
aol::ChanVeseEnergyLevelsetPart< RealType >
aol::ChanVeseEnergyParameterDerivativeInterface< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions, ParameterDimension, Imp >
qc::ChanVeseGradientDescent< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions >
aol::CholeskyBiBlockInverseOp< ConfiguratorType, MatrixType, NumBlocksPerRowCol >
aol::CholeskyBlockInverseOp< RealType, MatrixType >
aol::ClampedIdentityFunction< RealType >Heaviside function replacement to convert the Chan Vese model to the one of Chan Esedoglu Nikolova
aol::ClassicalChanVeseEnergyMulti< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions >
aol::ClassicalChanVeseEnergyMultiPhiVariation< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions >
qc::ClassicalChanVeseGradientDescent< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions, ImageDimension >
aol::ClassicalChanVeseMeanValueUpdater< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions, ImageDimension >
aol::ClassicalChanVeseVectorEnergyMulti< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions, ImageDimension >
aol::ClassicalChanVeseVectorEnergyMultiPhiVariation< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions, ImageDimension >
morph::Closing< RealType, Dim >
qc::Codim1QuadratureTrait< QuadType, RealType, Dim, Order >
qc::Codim1QuadratureTrait< aol::GaussQuadrature< RealType, Dim, Order >, RealType, Dim, Order >
qc::Codim1QuadratureTrait< qc::simplex::MidpointQuadrature< RealType, Dim >, RealType, Dim, Order >
qc::ColorWheel< RealType >
aol::ComposedDiscreteFunctionInterface< ConfiguratorType, DiscreteFunctionType, Imp >
aol::ComposeWithNormSqrDerivOp< VecType, SecondDerivativeType >
aol::ComposeWithNormSqrOp< VecType >
aol::Composite_differentDim_Op< DomRanType >
aol::CompositeOp< DomRanType >
om::CompTriMesh< RealType, TriMeshWithNormalType >
qc::ComputeFunctionOnLevelSetInterface< RealType, Imp >
aol::ConcatDataTrait< VectorType, DataType >
aol::ConcatDataTrait< aol::MultiVector< DataType >, DataType >
aol::ConcatDataTrait< aol::Vector< DataType >, DataType >
qc::ConcatImage< DataType, RealType >
aol::ConcatJacobiMatrices< RealType >
qc::simplex::ConfiguratorTraitBase< _RealType, _InitType >
qc::simplex::ConfiguratorTraitLinear< RealType, Dim, QuadType, _InitType >
qc::simplex::ConfiguratorTraitLinear< _RealType, QC_2D, _QuadType, _InitType >
qc::simplex::ConfiguratorTraitLinear< _RealType, QC_3D, _QuadType, _InitType >
qc::simplex::ConfiguratorTraitTFE< RealType, Dim, QuadType, InitType >
qc::simplex::ConfiguratorTraitTFE< _RealType, QC_3D, _QuadType, _InitType >
qc::ConnectedComponentsLabeler
qc::ConsistencyEnergyOp< ConfiguratorType >
aol::ConstOp< DomType, RangeType >
aol::ConvergenceEstimator< RealType >Administrates the storage of previous iterations' residuals and computation of convergence coefficents and order estimates
qc::Convolution< Dim, RealType >
qc::ConvolutionBasedInverseH1Metric< ConfiguratorType >
qc::ConvolutionTrait< Dimension, RealType >
qc::ConvolutionTrait< QC_2D, double >
qc::ConvolutionTrait< QC_2D, float >
qc::ConvolutionTrait< QC_2D, long double >
qc::ConvolutionTrait< QC_3D, double >
qc::ConvolutionTrait< QC_3D, float >
qc::ConvolutionTrait< QC_3D, long double >
aol::CovarianceMatrixOp< RealType, SampleType >For a number of samples (e.g. vectors or matrices) with zero mean, this operator computes the covariance matrix. If the mean is nonzero, then the method "applyForNonZeroMean" has to be used, which first subtracts the mean from all input samples. The dot product of the space has to be ptovided
qc::CrossCorrelationForce< ConfiguratorType >$ \left( - \int R(x)\nabla T(\Phi(x))\cdot \Psi_i(x) dx\right)_i $
aol::CSR_Matrix
qc::CubicGrid< Dim >
aol::CubicZeroOneIntervalPenaltyFunction< RealType >
aol::auto_container< length, T >::data_entity
qc::DataGenerator< ConfiguratorType >A class for generating some standard deformations and levelset functions
nb::DecrementDim< Dimension >
nb::DecrementDim< qc::QC_2D >
nb::DecrementDim< qc::QC_3D >
qc::DefaultArraySaver< RealType, Dim >
aol::DeflationEigenvectorOp< MatrixType >Computes the leading eigenvalues and eigenvectors of a matrix
qc::DeformationGradientInvariants< ConfiguratorType >Computes via the method "apply(...)" $\frac1{h^d}(\int_{\Omega}(\|D\phi\|,\|cof(D\phi)\|,det(D\phi))^T\psi_idx)_i$, where the domain $\Omega$ is given by a grid (passed to the constructor), $\psi_i$ denotes the finite element functions, and $D\phi$ denotes the deformation gradient of a deformation $\phi=identity+d$, where the displacement $d$ is passed to "apply(...)". Expressed differently, the three invariants of the deformation gradient are evaluated on the grid
qc::DeformedWeightMassOp< ConfiguratorType, IndexMode >
aol::DeleteFlagPointer< T >This class lets you choose whether it is responsible for destroying the held object or not
aol::DependOp< DomainType, RangeType >
aol::DerivativeValidatorBase< RealType, VecType >
aol::DerivativeWrapper< RealType, WrappedOpType, VecType >
aol::DescentDirValidator< RealType, VecType, DerivativeType >
aol::DiagonalBlockOp< DataType >
aol::DiagonalMatrix< DataType >A diagonal matrix class
aol::DiagonalPreconditioner< aol::MultiVector< RealType > >A class for diagonally preconditioning BlockMatrices
aol::DiagonalPreconditioner< aol::Vector< RealType > >A class for diagonally preconditioning matrices (and matrices only)
aol::DiagonalRow< DataType >
aol::DicomImportException
aol::DifferentialQuotientTest< RealType, DomainType, DerivativeType >
aol::DifferentialQuotientTest< RealType, aol::MultiVector< RealType > >
aol::DifferentialQuotientTest< RealType, aol::Vector< RealType > >
aol::DifferentialQuotientTestBase< RealType, DomainType, DerivativeType >
morph::Dilation< RealType, qc::QC_2D >::Dilate2d
morph::Dilation< RealType, qc::QC_3D >::Dilate3d
morph::Dilation< RealType, Dim >
morph::Dilation< RealType, qc::QC_2D >
morph::Dilation< RealType, qc::QC_3D >
aol::DimensionMismatchException
qc::DirichletRegularizationConfigurator< ConfiguratorType >
aol::DiscreteFunctionDefault< ConfiguratorType >
aol::DiscreteFunctionInterface< ConfiguratorType, Imp >
aol::DiscreteValueInterpolator< DomType, DiscValType, ContValType >
aol::DiscreteVectorFunction< ConfiguratorType, DiscFuncType, DimRange >
aol::DiscreteVectorFunctionDefault< ConfiguratorType, DimRange >
qc::meanZeroShiftAndRotationProjector< ConfiguratorType >::Displacement3DMomentNormSqr
qc::meanZeroShiftAndRotationProjector< ConfiguratorType >::Displacement3DMomentNormSqrGradient
qc::DisplacementLengthEnergy< ConfiguratorType >
qc::DistanceSweeper2d< DataType >
qc::DistanceSweeper3d< DataType, LocalBitArrayType, LocalDistanceArrayType, _GridType >
qc::doCalculateBackwardFDDivergence< RealType, Dim >
qc::doCalculateBackwardFDDivergence< RealType, qc::QC_2D >
qc::doCalculateBackwardFDDivergence< RealType, qc::QC_3D >
qc::doCalculateForwardFDGradient< RealType, Dim >
qc::doCalculateForwardFDGradient< RealType, qc::QC_2D >
qc::doCalculateForwardFDGradient< RealType, qc::QC_3D >
aol::DofMask
tpcfe::CFEGrid< _RealType, CFE_DOMAIN, _RealType >::DomainNodeIterator
qc::doPNGLoadSave< DataType, rangedim, imagedim >
qc::doPNGLoadSave< DataType, 2, 1 >
qc::doPNGLoadSave< DataType, 2, 2 >
qc::doPNGLoadSave< DataType, 2, 3 >
qc::doPNGLoadSave< DataType, 2, 4 >
qc::DoubleCone3d< RealType >Class for the double cone anisotropy in 3d (Frank diagram is a cylinder aligned to the z-axis)
aol::DQEnergyDerivativeOp< DataType, IndexType >
om::TriMesh< _RealType >::Edge
nb::NarrowBandGrid< _FullGridType, qc::QC_2D >::Edge
qc::EdgeNode< RealType >
aol::EigenvectorOp< MatrixType >Parent class of all eigenvector and -value computing operators
eik::Eikonal< RealType >
eik::Eikonal3d
eik::EikonalNA< RealType, GridType >
eik::EikonalNA3D< RealType >
eik::EikonalNA3DWithExtVelocity< RealType >
eik::EikonalNAInt< RealType, EikonalImp, Dimension, GridType >
eik::EikonalNAInt< RealType, EikonalImp, qc::QC_2D, GridType >
eik::EikonalNAInt< RealType, EikonalImp, qc::QC_3D >
eik::EikonalNANarrowBand< RealType, NarrowBandGridType >
eik::EikonalNANarrowBand3D< RealType, NarrowBandGridType >
eik::EikonalNAWithExtensionVelocity< RealType >
aol::ElasticTensor< DataType >Elastic tensor
qc::Element
qc::simplex::Element< CubicElementType >
qc::ElementInfoTrait< dim >
qc::ElementInfoTrait< QC_2D >
qc::ElementInfoTrait< QC_3D >
nb::ElementIterator< _GridType >
aol::ElementMask< GridType, ConfiguratorType, Dim >
aol::ElementMask< GridType, ConfiguratorType, qc::QC_2D >
aol::ElementMask< GridType, ConfiguratorType, qc::QC_3D >
qc::ElementNodeIterator< Dim >Traverses all nodes of a given element
qc::GridDefinition::ElementOnBoundary
qc::EllipseAnisotropy< RealType >
qc::EllipsoidAnisotropy< RealType >
qc::EndElementSome iterators can compare themselves not to each other, but only to an EndElement. This is a dummy class
aol::EnergyDescentPlotter< DescentType >
qc::ENOConvectExample< RealType >
qc::ENOConvectInt< RealType, Dim, Imp >
qc::ENOConvectWithVelocityField< RealType >
qc::ENODerivative< RealType, Dim >
qc::ENODerivative< RealType, qc::QC_2D >
aol::EpsWriter
morph::Erosion< RealType, Dim >
qc::Estimator2d< T >Estimator class 2d
qc::Estimator3d< DataType >
aol::Exception
mg::ExplicitOperatorHierarchyMultigrid< VectorType, OperatorType, SmoothOpType, ReOpType, PrOpType, GridType >
qc::ExtendFromLevelSet< RealType, DiscFuncType >
tpcfe::ExtrapolationWeightTypeTrait< RealType, CT >
tpcfe::ExtrapolationWeightTypeTrait< RealType, CFE_TPOSELAST >
nb::NarrowBandGrid< _FullGridType, qc::QC_2D >::Face
nb::NarrowBandGrid< _FullGridType, qc::QC_3D >::Face
qc::FastAssembleUniformGridMatrix< _DataType, apply_mode >
qc::simplex::FastILexMapper< aol::DT_GRID_INDEX_MODE, _CubicGridType, Dim >
qc::simplex::FastILexMapper< aol::QUOC_GRID_INDEX_MODE, _CubicGridType, Dim >
qc::FastILexMapper< qc::QC_1D >
qc::FastILexMapper< qc::QC_2D >
qc::FastILexMapper< qc::QC_3D >
qc::FastQuadILexMapper< Dim >
qc::FastQuadILexMapper< qc::QC_2D >
qc::FastUniformGridMatrix< _DataType, Dim, BaseClass >
qc::FastUniformGridMatrix< _DataType, qc::QC_2D, BaseClass >
qc::FastUniformGridMatrix< _DataType, qc::QC_3D, BaseClass >
aol::FE_L2Projection< ConfigDomainType, ConfigRangeType >
qc::FEBoundaryOpInterface< ConfiguratorType, Imp, IteratorType >Interface for linear FE operators which only operate on the domain boundary (implemented for a rectangular grid)
qc::FELevelsetOpInterface< ConfiguratorType, Dim, Imp >This class provides an interface for general linear operators on functions that live on levelsets (given as aol::Vector on a grid). It provides assembly routines for the corresponding matrices and apply routines for direct application to a aol::Vector
qc::FELevelsetOpInterface< ConfiguratorType, QC_2D, Imp >This class provides an interface for general linear operators on functions that live on levelsets (given as aol::Vector on a grid). It provides assembly routines for the corresponding matrices and apply routines for direct application to a aol::Vector
qc::FELevelsetOpInterface< ConfiguratorType, QC_3D, Imp >This class provides an interface for general linear operators on functions that live on levelsets (given as aol::Vector on a grid). It provides assembly routines for the corresponding matrices and apply routines for direct application to a aol::Vector
aol::FELinAsymMatrixWeightedStiffInterface< ConfiguratorType, Imp, IndexMode >
qc::FELinBoundaryMassOp< ConfiguratorType, IteratorType >Computes $(\int_{\partial\Omega} \varphi_i(x)\varphi_j(x) dx)_{ij}$,
qc::FELinBoundaryScalarWeightedMassInterface< ConfiguratorType, Imp, IteratorType >Interface to compute $(\int_{\partial\Omega} w(x)\varphi_i(x)\varphi_j(x) dx)_{ij}$,
qc::FELinDeformAsymMatrixWeightedStiffInterface< ConfiguratorType, Imp >Interface to compute $(\int_\Omega A(x,\Phi(x))\nabla(\varphi_j\circ\Phi)\cdot\nabla(\varphi_i\circ\Phi) dx)_{ij}$,
qc::FELinDeformOpInterface< ConfiguratorType, Imp >Interface for linear FE operators with basis functions deformed by a deformation $\Phi$
qc::FELinDeformScalarWeightedMassInterface< ConfiguratorType, Imp >Interface to compute $(\int_\Omega w(x,\Phi(x))(\varphi_i\circ\Phi)(\varphi_j\circ\Phi) dx)_{ij}$,
qc::FELinLevelsetScalarWeightedMassInterface< ConfiguratorType, Dim, Imp >This class implements the operator (expressed in matrix form) $\left(\int_\Gamma w(x)\varphi_i(x)\varphi_j(x) dx\right)_{ij}$, where $\Gamma$ is the zero levelset passed to the constructor, $\varphi_k$ is the $k$th finite element basis function, and the weight $w$ has to be defined in the derived classes as "getCoeff"
qc::FELinLevelsetScalarWeightedMassInterface< ConfiguratorType, QC_2D, Imp >This class implements the operator (expressed in matrix form) $\left(\int_\Gamma w(x)\varphi_i(x)\varphi_j(x) dx\right)_{ij}$, where $\Gamma$ is the zero levelset passed to the constructor, $\varphi_k$ is the $k$th finite element basis function, and the weight $w$ has to be defined in the derived classes as "getCoeff"
qc::FELinLevelsetScalarWeightedMassInterface< ConfiguratorType, QC_3D, Imp >This class implements the operator (expressed in matrix form) $\left(\int_\Gamma w(x)\varphi_i(x)\varphi_j(x) dx\right)_{ij}$, where $\Gamma$ is the zero levelset passed to the constructor, $\varphi_k$ is the $k$th finite element basis function, and the weight $w$ has to be defined in the derived classes as "getCoeff"
aol::FELinMatrixWeightedStiffInterface< ConfiguratorType, Imp, IndexMode >
aol::FELinMatrixWeightedVectorMassInterface< ConfiguratorType, Imp, NumVecCompsArg, NumVecCompsDest >
aol::FELinOpInterface< RealType, ConfiguratorType, Imp, IndexMode >General Interface for efficient Finite Element operators for all types of meshes and basis functions
aol::FELinScalarWeightedMassInterface< ConfiguratorType, Imp, IndexMode >
aol::FELinScalarWeightedMixedDiffInterface< ConfiguratorType, Imp, IndexMode >Provides a Finite-Element operators of the form $ \int_\Omega \partial_s \phi_i \partial_t \phi_j dx $. This class works in 2D and 3D and can be endowed with arbitrary quadrature rules
aol::FELinScalarWeightedSemiDiffInterface< ConfiguratorType, Imp, IndexMode >
aol::FELinScalarWeightedStiffInterface< ConfiguratorType, Imp, IndexMode >
aol::FELinVectorOpInterface< ConfiguratorType, Imp, NumVecCompsArg, NumVecCompsDest >General Interface for efficient Finite Element operators for all types of meshes and vector-valued basis functions
aol::FELinVectorWeightedSemiDiffInterface< ConfiguratorType, Imp, IndexMode >
qc::FENonlinDeformIntegrationVectorInterface< ConfiguratorType, Imp, NumComponents >Interface to compute $\int_\Omega f(\phi,\Phi(x),x)dx$,
qc::FENonlinDeformOpInterface< ConfiguratorType, Imp >Interface to compute $(\int_\Omega f(\phi,\Phi(x),x) \varphi_i\circ\Phi(x) dx)_i$,
qc::FENonlinDeformVectorDiffOpInterface< ConfiguratorType, NumCompArg, NumCompDest, Imp >Interface to compute $(\int_\Omega f(\phi,\Phi(x),x):\nabla(\varphi_i\circ\Phi(x)) dx)_i$,
aol::FENonlinDiffOpInterface< ConfiguratorType, Imp >General Interface
aol::FENonlinEvaluationOpInterface< ConfiguratorType, DimArg, DimDest, Imp >Operator for evaluating a function on each element
aol::FENonlinIntegrationScalarInterface< ConfiguratorType, Imp >Interface to compute $\int_\Omega f(\phi,x) dx$,
aol::FENonlinIntegrationVectorGeneralInterface< ConfiguratorType, Imp >
aol::FENonlinIntegrationVectorInterface< ConfiguratorType, Imp, NumComponents >
qc::FENonlinLevelsetIntegrationVectorInterface< ConfiguratorType, Dim, NumCompArg, Imp >Via "apply" or "applyAdd" this class computes the integral $\int_\Gamma f\left(\vec\phi(x),\nabla\vec\phi(x),x\right) dx$, where $\Gamma$ is the zero levelset passed to the constructor and $f$ has to be defined in the derived classes as "getNonlinearity". $\phi$ is the function passed to the apply-routines
qc::FENonlinLevelsetIntegrationVectorInterface< ConfiguratorType, qc::QC_2D, NumCompArg, Imp >Via "apply" or "applyAdd" this class computes the integral $\int_\Gamma f\left(\vec\phi(x),\nabla\vec\phi(x),x\right) dx$, where $\Gamma$ is the zero levelset passed to the constructor and $f$ has to be defined in the derived classes as "getNonlinearity". $\phi$ is the function passed to the apply-routines
qc::FENonlinLevelsetIntegrationVectorInterface< ConfiguratorType, qc::QC_3D, NumCompArg, Imp >Via "apply" or "applyAdd" this class computes the integral $\int_\Gamma f\left(\vec\phi(x),\nabla\vec\phi(x),x\right) dx$, where $\Gamma$ is the zero levelset passed to the constructor and $f$ has to be defined in the derived classes as "getNonlinearity". $\phi$ is the function passed to the apply-routines
qc::FENonlinLevelsetVectorDiffOpInterface< ConfiguratorType, Dim, NumCompArg, NumCompDest, Imp >Via "apply" or "applyAdd" this class computes the vector $\left(\int_\Gamma\vec{\vec{f}}\left(\vec\phi(x),\nabla\vec\phi(x),x\right):\nabla \vec\varphi_i(x) dx\!\!\right)_i$, where $\Gamma$ is the zero levelset passed to the constructor, $\vec\varphi_i$ is the vector-valued $i$th finite element basis function, and $\vec{\vec{f}}$ has to be defined in the derived classes as "getNonlinearity". $\vec\phi$ is the function passed to the apply-routines
qc::FENonlinLevelsetVectorDiffOpInterface< ConfiguratorType, qc::QC_2D, NumCompArg, NumCompDest, Imp >Via "apply" or "applyAdd" this class computes the vector $\left(\int_\Gamma\vec{\vec{f}}\left(\vec\phi(x),\nabla\vec\phi(x),x\right):\nabla \vec\varphi_i(x) dx\!\!\right)_i$, where $\Gamma$ is the zero levelset passed to the constructor, $\vec\varphi_i$ is the vector-valued $i$th finite element basis function, and $\vec{\vec{f}}$ has to be defined in the derived classes as "getNonlinearity". $\vec\phi$ is the function passed to the apply-routines
qc::FENonlinLevelsetVectorDiffOpInterface< ConfiguratorType, qc::QC_3D, NumCompArg, NumCompDest, Imp >Via "apply" or "applyAdd" this class computes the vector $\left(\int_\Gamma\vec{\vec{f}}\left(\vec\phi(x),\nabla\vec\phi(x),x\right):\nabla \vec\varphi_i(x) dx\!\!\right)_i$, where $\Gamma$ is the zero levelset passed to the constructor, $\vec\varphi_i$ is the vector-valued $i$th finite element basis function, and $\vec{\vec{f}}$ has to be defined in the derived classes as "getNonlinearity". $\vec\phi$ is the function passed to the apply-routines
qc::FENonlinLevelsetVectorOpInterface< ConfiguratorType, Dim, NumCompArg, NumCompDest, Imp >Via "apply" or "applyAdd" this class computes the vector $\left(\int_\Gamma \vec{f}\left(\vec\phi(x),\nabla\vec\phi(x),x\right)\cdot\vec\varphi_i(x) dx\right)_i$, where $\Gamma$ is the zero levelset passed to the constructor, $\vec\varphi_i$ is the vector-valued $i$th finite element basis function, and $\vec f$ has to be defined in the derived classes as "getNonlinearity". $\vec\phi$ is the function passed to the apply-routines
qc::FENonlinLevelsetVectorOpInterface< ConfiguratorType, qc::QC_2D, NumCompArg, NumCompDest, Imp >Via "apply" or "applyAdd" this class computes the vector $\left(\int_\Gamma \vec{f}\left(\vec\phi(x),\nabla\vec\phi(x),x\right)\cdot\vec\varphi_i(x) dx\right)_i$, where $\Gamma$ is the zero levelset passed to the constructor, $\vec\varphi_i$ is the vector-valued $i$th finite element basis function, and $\vec f$ has to be defined in the derived classes as "getNonlinearity". $\vec\phi$ is the function passed to the apply-routines
qc::FENonlinLevelsetVectorOpInterface< ConfiguratorType, qc::QC_3D, NumCompArg, NumCompDest, Imp >Via "apply" or "applyAdd" this class computes the vector $\left(\int_\Gamma \vec{f}\left(\vec\phi(x),\nabla\vec\phi(x),x\right)\cdot\vec\varphi_i(x) dx\right)_i$, where $\Gamma$ is the zero levelset passed to the constructor, $\vec\varphi_i$ is the vector-valued $i$th finite element basis function, and $\vec f$ has to be defined in the derived classes as "getNonlinearity". $\vec\phi$ is the function passed to the apply-routines
aol::FENonlinOpInterface< ConfiguratorType, Imp >
aol::FENonlinOpInterfaceWithMovedTestFunctions< ConfiguratorType, Imp >
aol::FENonlinVectorDiffOpInterface< ConfiguratorType, NumCompArg, NumCompDest, Imp, CompType >General Interface for nonlinear first order FE-operators depending on x, which are locally assembled. only getNonlinearity has to be provided. not for operators depending on derivatives of the function, use FENonlinDiffOpInterface instead. The discrete operator is of the form

\[ [F(\Phi)]_i = \int_\Omega tr\left( f( x, \nabla \phi )^T \cdot \nabla \psi_i \right) dx \]

where $ \psi_i $ corresponds to the i-th basis function, $f:R^d\times R^{d,d} \to R^{d,d} $, which has to be implemented in getNonlinearity

aol::FENonlinVectorOpInterface< ConfiguratorType, NumCompArg, NumCompDest, Imp >
aol::FEOpInterface< ConfiguratorType, _DomainType, _RangeType >
aol::FEOpMixedDerivative< ConfiguratorType >
aol::FileDoesNotExistException
aol::FileException
aol::FileFormatException
qc::FindMinMaxNormOfGradientOp< ConfiguratorType >
aol::FirstDerivativeTester< VecType, DerivativeType >
aol::FirstDerivativeValidator< VecType, DerivativeType, RealType >
aol::FirstPartOfFullVariationOfHeavisideLevelsetLengthEnergy< ConfiguratorType, HeavisideFunctionType >
qc::ScalarArray< _DataType, qc::QC_3D >::flipCopier
aol::Format
qc::RectangularGrid< Dim >::FullBoundaryNodeIterator
qc::FullColorWheel< RealType >
qc::RectangularGrid< Dim >::FullElementIterator
nb::FullGridConfiguratorHull< _FullGridConfType, _InitType >
nb::FullGridConfiguratorHullWithFullGridMatrix< _FullGridConfType, _InitType >
aol::FullMatrix< _DataType >
om::TriMesh< _RealType >::FullNodeIter
qc::RectangularGrid< Dim >::FullNodeIterator
qc::GridDefinition::FullNodeNeighborIterator< Dim >Traverses all elements adjacent to an element
qc::simplex::FullSimplexIterator< CubicElIterator, _CubicGridType, Dim >
aol::FullVariationOfHeavisideLevelsetLengthEnergy< ConfiguratorType, HeavisideFunctionType, numberOfLevelsetFunctions >
aol::FullVariationOfOneMinusHeavisideIntegrateFEFunction< ConfiguratorType, HeavisideFunctionType >
functionComponents
functionComponentsMV
aol::FunctorFromOp< RealType >
qc::GammaIntegrationOp< ConfiguratorType, AnisoType >Operator for computing $ \int_{\Omega} \gamma(\nabla u) \, dx. $
qc::GaussDiffKernel2d< RealType >A 2D Gaussian Differentiation Filter Kernel
qc::GaussDiffKernel3d< T_RealType >Kernel for Derivatives on Gaussian smoothed data
qc::GaussKernel2d< RealType >A 2D Gaussian Filter Kernel
qc::GaussKernel3d< T_RealType >A Gaussian filtering kernel
aol::GaussQuadrature< _RealType, _Dim, _Order >
aol::GaussQuadrature1D< _RealType, _Order >
aol::GaussQuadrature< _RealType, qc::QC_1D, 1 >
aol::GaussQuadrature< _RealType, qc::QC_1D, 11 >
aol::GaussQuadrature< _RealType, qc::QC_1D, 13 >
aol::GaussQuadrature< _RealType, qc::QC_1D, 15 >
aol::GaussQuadrature< _RealType, qc::QC_1D, 17 >
aol::GaussQuadrature< _RealType, qc::QC_1D, 19 >
aol::GaussQuadrature< _RealType, qc::QC_1D, 21 >
aol::GaussQuadrature< _RealType, qc::QC_1D, 23 >
aol::GaussQuadrature< _RealType, qc::QC_1D, 3 >
aol::GaussQuadrature< _RealType, qc::QC_1D, 5 >
aol::GaussQuadrature< _RealType, qc::QC_1D, 7 >
aol::GaussQuadrature< _RealType, qc::QC_1D, 9 >
aol::GaussQuadrature< _RealType, qc::QC_2D, _Order >
aol::GaussQuadrature< _RealType, qc::QC_3D, _Order >
aol::GaussSeidelInverse< VectorType, OpType >
aol::GaussSeidelPreconditioner< VectorType, MatrixType >
mg::GaussSeidelSelectiveSmoother< VectorType, OpType >
aol::GaussSeidelSelectiveSweeper< RealType, VectorType, OpType >
mg::GaussSeidelSmoother< VectorType, OpType >
aol::GaussSeidelSweeper< RealType, VectorType, OpType >
aol::GenBandMatrix< _DataType >
aol::GenEnergyOp< DomainType, RealType >
qc::GeneralAnisotropyIntegrationOp< ConfiguratorType, AnisoType >
qc::GeneralLinearSmoothOp< ConfiguratorType >
qc::GeneralWillmoreStiffImpOp< ConfiguratorType, AnisotropyType >
aol::GenSparseMatrix< DataType >
aol::GenSparseOp< RealType >
aol::GeometricScalingPreconditioner< aol::MultiVector< RealType > >A class for preconditioning block matrices using geometric scaling (division by l2 norm of unblocked rows)
aol::GeometricScalingPreconditioner< aol::Vector< RealType > >A class for preconditioning matrices using geometric scaling (division by l2 norm of rows, cf. Gordon & Gordon, arXiv:0812.2769v2 [cs.MS])
aol::GivensRotation< DataType >One single Givens rotation
aol::GivensRotations< DataType >
aol::GMRESInverse< VectorType, OpType >Computes the inverse by GMRES(m) algorithm. works on non-symmetric matrices, but is slower
qc::GradDivergenceOp< ConfiguratorType, Dim >
aol::GradientDescent< ConfiguratorType, VectorType >
aol::GradientDescent< ConfiguratorType, aol::MultiVector< typename ConfiguratorType::RealType > >
aol::GradientDescent< ConfiguratorType, aol::Vector< typename ConfiguratorType::RealType > >
aol::GradientDescentBase< RealType, VectorType, DerivativeType >The class of implementing the gradient descent searching
aol::GradientDescentComponentWiseTimestepControlled< ConfiguratorType, GradientDescentType >
GradientDescentType
aol::GradientDescentWithAutomaticFilterWidth< ConfiguratorType, VectorType, GradientDescentType >
aol::GradientDescentWithAutomaticFilterWidth< ConfiguratorType, aol::MultiVector< typename ConfiguratorType::RealType >, GradientDescentType >
aol::GradientDescentWithAutomaticFilterWidth< ConfiguratorType, aol::Vector< typename ConfiguratorType::RealType >, GradientDescentType >
qc::GradPhiTestFctOp< ConfiguratorType >
qcsm::GraphToTriangMesh< RealType >
qc::GridDefinition
aol::GridlessGradientDescent< RealType, VectorType, DerivativeType >
qc::GridSize< _Dim >
qc::GridStructure
qc::simplex::GridStructure< _CubicGridType, Dim >
qc::simplex::GridStructureBase< _CubicGridType >
qc::GrowWulffshapeEO3D< RealType, AnisoType >Operator for overloading the velocity function of the Enquist-Osher scheme
aol::H1GradientDescent< ConfiguratorType, VectorType, InverseH1MetricType >
__gnu_cxx::hash< qc::Element >
__gnu_cxx::hash< qc::simplex::Element< qc::Element > >
hash_set
aol::HashSet< qc::Element >
aol::HashSet< qc::simplex::Element< qc::Element > >
qc::Heap< T >
qc::HeapBase< T, T_leaftype >
aol::HeapsortOp< RealType >Ordering operator using heapsort
aol::HeavisideAndOneMinusHFENonlinDiffOpInterface< ConfiguratorType, HeavisideFunctionType, TargetOpType >
aol::HeavisideAndOneMinusHFENonlinIntegrationVectorInterface< ConfiguratorType, HeavisideFunctionType, TargetOpType >
aol::HeavisideFENonlinIntegrationVectorInterface< ConfiguratorType, HeavisideFunctionType, TargetOpType >
aol::HeavisideFunctionLumpedMassOp< ConfiguratorType, HeavisideFunctionType >
aol::HeavisideFunctionMassOp< ConfiguratorType, HeavisideFunctionType >
aol::HeavisideFunctionProduct< ConfiguratorType, HeavisideFunctionType >A helper class for Chan Vese with multiple levelset functions
aol::HeavisideLevelsetLengthEnergy< ConfiguratorType, HeavisideFunctionType, numberOfLevelsetFunctions >
aol::HeavisideProductFENonlinIntegrationVectorInterface< ConfiguratorType, HeavisideFunctionType, TargetOpType >Given n levelset functions and 2^n ops, this class calculates the sum over these ops, where the integrands of the ops are multiplied with the proper combination of heaviside functions of the levelset functions as needed in the Chan Vese model for more than two segments. The ops have to be derived from FENonlinIntegrationVectorInterface
aol::HeavySideOneMinusHFENonlinOpInterface< ConfiguratorType, HeavisideFunctionType, TargetOpType >
qc::Hexagon2d< RealType >Class for a hexagon in 2d
qc::ScalarArray< _DataType, qc::QC_3D >::Hexahedron
qc::HopfLax< RealType >
qc::HyperelasticDeformEnergy< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" a hyperelastic energy $ \int_\Omega W(I_1,I_2,I_3,x) dx $, where the hyperelastic invariants are given by $ I_1=||\nabla\phi\nabla\Phi||_F^2 $, $ I_2=||cof(\nabla\phi\nabla\Phi)||_F^2 $, $ I_1=det(\nabla\phi\nabla\Phi) $ and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). $ \Phi $ is a deformation passed to the constructor. In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ in the different Cartesian directions; the deformation $ \phi $ is then automatically computed via $ \phi=d+$ identity
qc::HyperelasticDeformGradient< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" a hyperelastic energy gradient with respect to the displacement, i.e. $ (<\frac{\partial \int_\Omega W(I_1,I_2,I_3,x) dx}{\partial \phi},\psi_i>)_i $, where the $ \psi_i $ are the FE basis functions, the hyperelastic invariants are given by $ I_1=||\nabla\phi\nabla\Phi||_F^2 $, $ I_2=||cof(\nabla\phi\nabla\Phi)||_F^2 $, $ I_3=det(\nabla\phi\nabla\Phi)$ and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). $ \Phi $ is some prestressing deformation. In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ in the different Cartesian directions; the deformation $ \phi $ is then automatically computed via $ \phi=d+$ identity
qc::HyperelasticDeformHessian< ConfiguratorType, HyperelasticEnergyDensityType, SubMatrixType >This class computes via "apply(...)" or "applyAdd(...)" a hyperelastic energy Hessian with respect to the displacement, where the material is prestressed by a deformation $ \Phi $, i.e. $ (<\frac{\partial^2 \int_\Omega W(I_1,I_2,I_3,x) dx}{\partial \phi^2},\psi_i\circ\Phi,\psi_j\circ\Phi>)_{i,j} $, where the $ \psi_i $ and $ \psi_j $ are the vector-valued FE basis functions, the hyperelastic invariants are given by $ I_1=||\nabla\phi\nabla\Phi||_F^2 $, $ I_2=||cof(\nabla\phi\nabla\Phi)||_F^2 $, $ I_3=det(\nabla\phi\nabla\Phi)$, and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ in the different Cartesian directions; the deformation $ \phi $ is then automatically computed via $ \phi=d+$ identity
qc::HyperelasticDeformSubHessian< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" parts of a hyperelastic energy Hessian with respect to the displacement, where the material is prestressed by a deformation $ \Phi $, i.e. $ (<\frac{\partial^2 \int_\Omega W(I_1,I_2,I_3,x) dx}{\partial\phi^2},\psi_i\circ\Phi,\psi_j\circ\Phi>)_{i,j} $, where the $ \psi_i $ and $ \psi_j $ are those vector-valued FE basis functions that are only nonzero in the kth and lth component, the hyperelastic invariants are given by $ I_1=||\nabla\phi\nabla\Phi||_F^2 $, $ I_2=||cof(\nabla\phi\nabla\Phi)||_F^2 $, $ I_3=det(\nabla\phi\nabla\Phi)$, and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ in the different Cartesian directions; the deformation $ \phi $ is then automatically computed via $ \phi=d+$ identity
qc::HyperelasticEnergy< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" a hyperelastic energy $ \int_\Omega W(I_1,I_2,I_3,x) dx $, where the hyperelastic invariants are given by $ I_1=||\nabla\phi||_F^2 $, $ I_2=||cof(\nabla\phi)||_F^2 $, $ I_1=det(\nabla\phi) $ and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ in the different Cartesian directions; the deformation $ \phi $ is then automatically computed via $ \phi=d+$ identity
qc::HyperelasticEnergyDensity2DLinear< ConfiguratorType >Implements the 2D linear energy density $ W(I_1,I_2,I_3)=\alpha(I_1+2-2\sqrt{I_1+2\det I_3})=\alpha dist(\nabla\phi,SO(2))^2 $ with $ I_1=||\nabla\phi||_F^2 $, $ I_2=||cof(\nabla\phi)||_F^2 $, $ I_3=det(\nabla\phi) $
qc::HyperelasticEnergyDensityDefault< ConfiguratorType >This class represents a standard implementation of the hyperelastic energy density $ W(I_1,I_2,I_3) $ with respect to the invariants $ I_1=||\nabla\phi||_F^2 $, $ I_2=||cof(\nabla\phi)||_F^2 $, $ I_3=det(\nabla\phi) $ of the deformation gradient $\nabla\phi$. In addition to $I_1,I_2,I_3$, the methods "evaluate(...)" and "evaluateDerivative(...)" have to be passed a spatial position, since in principle the energy density may be space dependent
qc::HyperelasticEnergyDensityGeneralizedMooneyRivlin< ConfiguratorType >Implements a generalized Mooney-Rivlin energy density $ W(I_1,I_2,I_3)=aI_1^{\frac{p}2}+bI_2^{\frac{q}2}+c\Gamma(I_3)-ad^{\frac{p}2}-bd^{\frac{q}2} $ with $ I_1=||\nabla\phi||_F^2 $, $ I_2=||cof(\nabla\phi)||_F^2 $, $ I_3=det(\nabla\phi) $, $ \Gamma(I_3)=\frac1{I_3^s}+\frac{s}rI_3^r-1-\frac{s}r $, and the deformation gradient $\nabla\phi$
qc::HyperelasticEnergyDensityStVenantKirchhoff< ConfiguratorType >Implements the St Venant-Kirchhoff energy density $ W(I_1,I_2,I_3)=\frac\lambda2(I_1-d)^2+\frac\mu4((I_1-1)^2+d-1-2\zeta)+\nu\Gamma(I_3) $ with $ I_1=||\nabla\phi||_F^2 $, $ I_2=||cof(\nabla\phi)||_F^2 $, $ I_3=det(\nabla\phi) $, $ \zeta=I_3^2 $ in 2D and $ \zeta=I_2 $ in 3D, $ \Gamma(I_3)=\frac1{I_3^2}+I_3^2-2 $, and the deformation gradient $\nabla\phi$, where $ \Gamma $ in fact does not belong to the law and only prohibits complete compression
qc::HyperelasticGradient< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" a hyperelastic energy gradient with respect to the displacement, i.e. $ (<\frac{\partial \int_\Omega W(I_1,I_2,I_3,x) dx}{\partial \phi},\psi_i>)_i $, where the $ \psi_i $ are the FE basis functions, the hyperelastic invariants are given by $ I_1=||\nabla\phi||_F^2 $, $ I_2=||cof(\nabla\phi)||_F^2 $, $ I_3=det(\nabla\phi)$ and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ in the different Cartesian directions; the deformation $ \phi $ is then automatically computed via $ \phi=d+$ identity
qc::HyperelasticHessian< ConfiguratorType, HyperelasticEnergyDensityType, SubMatrixType >This class computes via "apply(...)" or "applyAdd(...)" a hyperelastic energy Hessian with respect to the displacement, i.e. $ (<\frac{\partial^2 \int_\Omega W(I_1,I_2,I_3,x) dx}{\partial \phi^2},\psi_i,\psi_j>)_{i,j} $, where the $ \psi_i $ are the FE basis functions, the hyperelastic invariants are given by $ I_1=||\nabla\phi||_F^2 $, $ I_2=||cof(\nabla\phi)||_F^2 $, $ I_3=det(\nabla\phi)$ and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ in the different Cartesian directions; the deformation $ \phi $ is then automatically computed via $ \phi=d+$ identity
qc::HyperelasticPrePostDeformEnergy< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" a hyperelastic energy $ \int_\Omega W(I_1,I_2,I_3,x)det(\nabla\phi_r) dx $, where the hyperelastic invariants are given by $ I_1=||\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}||_F^2 $, $ I_2=||cof(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1})||_F^2 $, $ I_1=det(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}) $ and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). $ \phi $ is a deformation passed to the constructor. In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ of $ \phi_l $ and $ \phi_r $ in the different Cartesian directions
qc::HyperelasticPrePostDeformGradientPostComp< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" a hyperelastic energy gradient with respect to one of two displacements, i.e. $ (<\frac{\partial \int_\Omega W(I_1,I_2,I_3,x)det(\nabla\phi_r) dx}{\partial \phi_l},\psi_i>)_i $, where the $ \psi_i $ are the vector-valued FE basis functions, the hyperelastic invariants are given by $ I_1=||\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}||_F^2 $, $ I_2=||cof(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1})||_F^2 $, $ I_1=det(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}) $ and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). $ \phi $ is some prestressing deformation. In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ of $ \phi_l $ and $ \phi_r $ in the different Cartesian directions
qc::HyperelasticPrePostDeformGradientPreComp< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" a hyperelastic energy gradient with respect to one of two displacements, i.e. $ (<\frac{\partial \int_\Omega W(I_1,I_2,I_3,x)det(\nabla\phi_r) dx}{\partial \phi_r},\psi_i>)_i $, where the $ \psi_i $ are the vector-valued FE basis functions, the hyperelastic invariants are given by $ I_1=||\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}||_F^2 $, $ I_2=||cof(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1})||_F^2 $, $ I_1=det(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}) $ and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). $ \phi $ is some prestressing deformation. In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ of $ \phi_l $ and $ \phi_r $ in the different Cartesian directions
qc::HyperelasticPrePostDeformSubHessianMixedPart< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" part of the hyperelastic energy Hessian with respect to two displacements, i.e. $ (<\frac{\partial^2\int_\Omega W(I_1,I_2,I_3,x)det(\nabla\phi_r) dx}{\partial\phi_l\partial\phi_r},\psi_i,\psi_j>)_{ij} $, where the $ \psi_i $ are the vector-valued FE basis functions, the hyperelastic invariants are given by $ I_1=||\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}||_F^2 $, $ I_2=||cof(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1})||_F^2 $, $ I_1=det(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}) $ and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). $ \phi $ is some prestressing deformation. In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ of $ \phi_l $ and $ \phi_r $ in the different Cartesian directions. If ``PhiRVariationFromRight''=true, then the resulting matrix is the Hessian with respect to a variation of the ``L''th component of $ \phi_r $ from the right and a vatiation of the ``K''th component of $ \phi_l $ from the left; else $ \phi_l $ and $ \phi_r $ are exchanged
qc::HyperelasticPrePostDeformSubHessianPostComp< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" part of the hyperelastic energy Hessian with respect to one of two displacements, i.e. $ (<\frac{\partial^2\int_\Omega W(I_1,I_2,I_3,x)det(\nabla\phi_r) dx}{\partial \phi_l^2},\psi_i,\psi_j>)_{ij} $, where the $ \psi_i $ are the vector-valued FE basis functions, the hyperelastic invariants are given by $ I_1=||\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}||_F^2 $, $ I_2=||cof(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1})||_F^2 $, $ I_1=det(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}) $ and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). $ \phi $ is some prestressing deformation. In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ of $ \phi_l $ and $ \phi_r $ in the different Cartesian directions
qc::HyperelasticPrePostDeformSubHessianPreComp< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" part of the hyperelastic energy Hessian with respect to one of two displacements, i.e. $ (<\frac{\partial^2\int_\Omega W(I_1,I_2,I_3,x)det(\nabla\phi_r) dx}{\partial \phi_r^2},\psi_i,\psi_j>)_{ij} $, where the $ \psi_i $ are the vector-valued FE basis functions, the hyperelastic invariants are given by $ I_1=||\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}||_F^2 $, $ I_2=||cof(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1})||_F^2 $, $ I_1=det(\nabla\phi_l\nabla\phi\nabla\phi_r^{-1}) $ and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). $ \phi $ is some prestressing deformation. In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ of $ \phi_l $ and $ \phi_r $ in the different Cartesian directions
qc::HyperelasticSubHessian< ConfiguratorType, HyperelasticEnergyDensityType >This class computes via "apply(...)" or "applyAdd(...)" parts of a hyperelastic energy Hessian with respect to the displacement, i.e. $ (<\frac{\partial^2 \int_\Omega W(I_1,I_2,I_3,x) dx}{\partial \phi^2},\psi_i,\psi_j>)_{i,j} $, where the $ \psi_i $ and $ \psi_i $ are those vector-valued FE basis functions that are only nonzero in the kth and lth component, the hyperelastic invariants are given by $ I_1=||\nabla\phi||_F^2 $, $ I_2=||cof(\nabla\phi)||_F^2 $, $ I_3=det(\nabla\phi)$, and the function $ W(I_1,I_2,I_3,x) $ is passed to the constructor (e.g. HyerelasticEnergyDensityDefault). In its first argument, "apply" and "applyAdd" expect a Multivector which represents the displacements $ d_i $ in the different Cartesian directions; the deformation $ \phi $ is then automatically computed via $ \phi=d+$ identity
mg::BoomerAMGSolver< OpType, RealType >::HypreParCSRMatrixUnionUnion allowing to access same object as void** and HYPRE_ParCSRMatrix without warning about breaking strict aliasing rules
mg::BoomerAMGSolver< OpType, RealType >::HypreParVectorUnion
aol::IdentityFunction< RealType, _ScalingFunctionType >Heaviside function replacement to convert the Chan Vese model to the one of Chan Esedoglu Nikolova with exact penalty
aol::IdentityOp< DomRanType >
aol::ILU0BlockPreconditioner< RealType, BlockMatrixType >
aol::ILU0Preconditioner< RealType, MatrixType >
aol::ImageGradientSemiDiffOp< ConfiguratorType >
aol::ImageNormalSemiDiffOp< ConfiguratorType >
qc::BasisFunction2D< RealType >::IncompBasisEx
aol::InconsistentDataException
qc::IndexedHeap< T >
aol::IndexTranslationMatrix< MatrixType >Wrapper for Matrices that are intended to work only on a small set of vector components. In contrast to the behaviour of TransparentIndexTranslationMatrix, the underlying small matrix ist not visible
qc::InfinitesimalElastOp< ConfiguratorType, Dim, SparseType >
qc::InfinitesimalElastOp< ConfiguratorType, qc::QC_2D, SparseType >
nb::InitNarrowBand< RealType, NarrowBandGridType, Dim >
nb::InitNarrowBand< RealType, NarrowBandGridType, qc::QC_2D >
nb::InitNarrowBand< RealType, NarrowBandGridType, qc::QC_3D >
nb::IntegrateAnisotropyOverBoundary< RealType, ConfigType, SubGridType, AnisoType, Dim >
aol::IntegrateFEFunction< ConfiguratorType >
qc::IntegrateFunctionOverLevelSet< RealType, Dim >
qc::IntegrateFunctionOverLevelSet< RealType, qc::QC_2D >
qc::IntegrateFunctionOverLevelSet< RealType, qc::QC_3D >
qc::IntegrateFunctionOverLevelSetBase3d< RealType, Imp >
qc::IntegrateFunctionSqrOverLevelSet< RealType, Dim >
qc::IntegrateFunctionSqrOverLevelSet< RealType, qc::QC_3D >
qc::IntegrateGammaZOverBoundary< ConfiguratorType, BoundaryQuadratureType, AnisoType >
qc::IntegrateGammaZZWOverBoundary< ConfiguratorType, BoundaryQuadratureType, AnisoType >
qc::IntegrateGradUOverBoundary< ConfiguratorType, BoundaryQuadratureType >
nb::IntegrateIdOverBoundary< ConfiguratorType, BoundaryQuadratureType, SubGridType >
nb::IntegrateMCMGradUOverBoundary< ConfiguratorType, BoundaryQuadratureType, SubGridType >
qc::IntegrateProjectionUOverBoundary< ConfiguratorType, BoundaryQuadratureType >
nb::IntegrateProjectionUOverBoundary< ConfiguratorType, BoundaryQuadratureType, SubGridType >
qc::IntegrateTangentGradientOfFunctionSqrOverLevelSet< RealType, Dim >
qc::IntegrateTangentGradientOfFunctionSqrOverLevelSet< RealType, qc::QC_3D >
qc::IntegrateUDiffBasisFunctionOverBoundary< ConfiguratorType, BoundaryQuadratureType >
qc::InterpolateFunctionOp< ConfType >
aol::InterruptableIterativeInfo< BaseInfo >Decorator for any IterativeInfo subclass that enables catching Ctrl-C pressures
aol::Intersector< PRIMITIVE_A, PRIMITIVE_B >
aol::Intersector< AlignedCube< RealType >, LineSegment< RealType, qc::QC_3D > >
aol::Intersector< AlignedCube< RealType >, Triangle< RealType > >
aol::Intersector< AlignedQuad< RealType >, LineSegment< RealType, qc::QC_2D > >
aol::Intersector< LineSegment< RealType, qc::QC_2D >, LineSegment< RealType, qc::QC_2D > >
aol::Intersector< LineSegment< RealType, qc::QC_3D >, LineSegment< RealType, qc::QC_3D > >
aol::Intersector< Plane< RealType >, Triangle< RealType > >
qc::InvDeformedWeightMassOp< ConfiguratorType, IndexMode >
aol::InverseOp< VectorType >
aol::IOException
aol::ipfstream
aol::IsoEnergyOp< ConfiguratorType >Computes $ \int | \nabla u |_{2,\delta} $, where arg=u
qc::IsoFragmentInf< RealType, d >
qc::IsoLineIterator2d< ConfiguratorType >
qc::IsoLineManager2d< ConfiguratorType >
tpcfe::IsotropicElasticityCoefficient< RealType >
aol::IsotropicEnergy< ConfiguratorType, MatrixType >Computes the whole energy-functional
aol::IsotropicMatrixStiffOp< ConfiguratorType >
qc::Isotropy< RealType >
qc::Isotropy3d< RealType >
aol::IterativeInfo< _RealType >Base class for SolverInfo and NewtonInfo
aol::IterativeInverseOp< VectorType, OpType >
qc::simplex::Iterator< IteratedType, _CubicGridType, Imp >
aol::DofMask::iterator
qc::Ball::iteratorBall
aol::ConcatJacobiMatrices< RealType >::jacobi_rot_mat
aol::JacobiEigenvectorOp< MatrixType >Computes all eigenvalues, and all eigenvectors, of a symmetrix matrix. The template matrix class has to support set to every possible entry, thus full matrix classes are prefereable
aol::JacobiInverse< VectorType, OpType >
mg::JacobiSmoother< VectorType, OpType >
qc::JointHistogram< RealType >
qc::Kernel2d< RealType >Abstract class for the implementation of an arbitrary 2d filtering kernel
qc::Kernel3d< T_RealType >Abstract class for an arbitrary convolution kernel
qc::KernelTrait< RealType, dim >
qc::KernelTrait< RealType, 2 >
qc::KernelTrait< RealType, 3 >
KernelType
qc::L1Norm2d< RealType >Class for the simple L1-norm-anisotropy in 2d
qc::L1Norm3d< RealType >Class for the simple L1-norm-anisotropy in 3d (Wulff shape is a cube)
aol::L2GradientDescentDirichletBCs< ConfiguratorType, VectorType >
qc::L2Projector< RealType >
qc::LaplaceBeltramiOp< ConfiguratorType, IndexMode >
qc::LengthEnergy< ConfiguratorType, Dim >
qc::LengthGradient< ConfiguratorType, Dim >
qc::LevelSet2d< RealType, Velocity >
qc::LevelSet2dInt< RealType, Imp >
qc::LevelSet2dWithSpeedField< RealType >
qc::LevelSet3dInt< RealType, Imp >
qc::LevelSet3dWithSpeedField< RealType >
qc::LevelSetDrawer< ConfiguratorType >
qc::LevelsetMassOp< ConfiguratorType >This class implements the operator (expressed in matrix form) $\left(\int_\Gamma \varphi_i(x)\varphi_j(x) dx\right)_{ij}$, where $\Gamma$ is the zero levelset passed to the constructor and $\varphi_k$ is the $k$th finite element basis function
qcsm::LevelsetToTriangMesh< RealType >
qc::LevelsetVectorMassOp< ConfiguratorType, NumComp >Via "apply" or "applyAdd" this class computes the vector $\left(\int_\Gamma\vec\phi(x)\cdot\vec\varphi_idx\right)_i$, where $\Gamma$ is the zero levelset passed to the constructor and $\vec\varphi_i$ is the $i$th finite element basis function. $\phi$ is the function passed to the apply-routines
qc::LevelsetVectorStiffOp< ConfiguratorType, NumCompArg, NumCompDest >Via "apply" or "applyAdd" this class computes the vector $\left(\int_\Gamma\nabla\vec\phi(x):\nabla\vec\varphi_idx\right)_i$, where $\Gamma$ is the zero levelset passed to the constructor and $\vec\varphi_i$ is the $i$th finite element basis function. $\phi$ is the function passed to the apply-routines
qc::LevelSetVolume< RealType >
aol::LinCombOp< DomainType, RangeType >
qc::LinearBlended3dAnisotropy< ConfiguratorType, AnisoType1, AnisoType2 >
qc::LinearBlendedAnisotropy2dGraph< ConfiguratorType, AnisoType1, AnisoType2 >
qc::LinearConvolution< RealType >
qc::LinearConvolutionSmoothGradientOp< RealType, Dim >
qc::LinearConvolutionSmoothGradientOp< RealType, qc::QC_2D >
qc::LinearConvolutionSmoothOp< RealType, Dim >
qc::LinearConvolutionSmoothOp< RealType, qc::QC_2D >
qc::LinearizedElasticEnergy< ConfiguratorType >
qc::LinearSmoothOp< RealType >
qc::LinearTransformedAnisotropy2d< RealType, AnisoType >General class, that applies a linear transformation (2x2-matrix) to a given anisotropy
qc::LineSegment< RealType >
aol::LineSegment< RealType, EmbedDim >
aol::LineSegment< RealType, qc::QC_2D >
aol::LineSegment< RealType, qc::QC_3D >
qc::LInfNorm2d< RealType >Class for the simple L1-norm-anisotropy in 2d
qc::LInfNorm3d< RealType >
qc::LocalLInfBoxBoundaryIterator< qc::QC_3D >
qc::LocalLInfBoxIterator< qc::QC_3D >
qc::LocalOnesidedLInfBoxIterator< qc::QC_3D >
qc::LocalRotatedAnisotropyIntegrationOp< ConfiguratorType, AnisoType >
qc::LocalRotatedAnisotropyStiffOp< ConfiguratorType, AnisoType, IndexMode >
aol::LogicException
qc::simplex::Lookup< RealType, Dim >
qc::simplex::Lookup< RealType, QC_2D >
qc::simplex::Lookup< RealType, QC_3D >
qc::LpAnisotropy< RealType >
qc::LpAnisotropy3d< RealType >
aol::LQuadBandMatrix< DataType >
aol::LUInverse< DataType >
aol::LumpedFELinOpInterface< RealType, ConfiguratorType, Imp >
aol::LumpedMassOp< ConfiguratorType >
aol::LumpedMassOpInterface< ConfiguratorType, Imp >Easy interface to lumped mass matrices. Attention: works only for nodal basis Finite Elements!
aol::MaskedOp< OpType >
aol::MaskedVector< DataType >
aol::MassOp< ConfiguratorType, IndexMode >
aol::Mat< numRows, numCols, _DataType >
aol::MatDimTrait< RealType, Dim >
aol::MatDimTrait< RealType, 2 >
aol::MatDimTrait< RealType, 3 >
aol::Matrix< _DataType >Abstract Matrix class
aol::Matrix22< _DataType >
aol::Matrix33< _DataType >
aol::Matrix33Symm< _DataType >
aol::Matrix44< _DataType >
aol::MatrixAbstractBase< RealType >
qc::MCMDirichletSmoothOp< ConfType, IndexMode >
qc::MCMLumpedMassOp< ConfiguratorType >
qc::MCMMassOp< ConfiguratorType, IndexMode >
qc::MCMSmoothOp< ConfType, IndexMode >
qc::MCMStiffOp< ConfiguratorType, IndexMode >
qc::MCMWeightedMassOp< ConfiguratorType, IndexMode >
qc::MCMWeightedStiffOp< ConfiguratorType, IndexMode >
aol::MeanOp< SampleType >For a number of samples (e.g. vectors or matrices), this operator computes the arithmetic mean and (if desired) the input samples with the mean subtracted
qc::meanZeroShiftAndRotationProjector< ConfiguratorType >
MESH_INFO
aol::MeshWithData< MeshType >
eik::MetaEstimator
eik::MetaEstimatorStruct
tpcfe::MGStandardWeightProvider< GridType >
tpcfe::MGWeightProvider< GridType >
tpcfe::MGWeightProvider< CFEGrid< RealType, CFE_CD, NodalCoeffType > >
tpcfe::MGWeightProvider< CFEGrid< RealType, CFE_LIEHR > >
tpcfe::MGWeightProvider< CFEGrid< RealType, CFE_TPOS > >
tpcfe::MGWeightProvider< CFEGrid< RealType, CFE_TPOSELAST, IsotropicElasticityCoefficient< RealType > > >
tpcfe::MGWeightProvider< CFEGrid< RealType, CFE_TPOSELAST, VoigtElasticityCoefficient< RealType > > >
tpcfe::MGWeightProviderJumpCoeff< GridType >
qc::simplex::MidpointQuadrature< RealType, Dim >
qc::MidpointQuadrature< RealType, Dim >
qc::simplex::MidpointQuadrature< _RealType, qc::QC_3D >
qc::simplex::MidpointQuadrature< RealType, qc::QC_2D >
qc::MidpointQuadrature< RealType, qc::QC_3D >
qc::MIForce< ConfiguratorType >
qc::MIRegistrationConfigurator< ConfiguratorType >
qc::MIRegistrationEnergyWithRegardToPhi< ConfiguratorType, ConfiguratorTypeFeatureDomain >
qc::MixedAnisotropy< RealType >
aol::MixedFormat
qc::MultiArray< DataType, rangedim, imagedim >
aol::MultiDerivedVector< DerivedType >
qc::MultiDimMultilevelArray< DataType, ArrayType, ProlongOpType, RestrictOpType >
qc::MultilevelArray< DataType, ArrayType, ProlongOpType, RestrictOpType >
qc::MultilevelDescentInterface< ConfiguratorType >
aol::MultiLevelsetVolumes< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions >
aol::MultiLevelsetWeightedVolumes< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions, ImageDimension >
qc::MultilinFEBandMatrix< DataTye, dim >
qc::MultilinFEBandMatrix< DataType, qc::QC_2D >
qc::MultilinFEBandMatrix< DataType, qc::QC_3D >
aol::MultiRestrOp< DataType >
aol::MultiStreambufOutput stream buffer that sends its content to multiple other stream buffers
aol::MultiVector< _DataType >
aol::MultiVectorWithConcatData< _DataType >
nb::NarrowBandBoundaryMeshExport< Dim >
nb::NarrowBandBoundaryMeshExport< qc::QC_3D >
nb::NarrowBandConfiguratorTraitMultiLin< _RealType, Dim, _QuadType, _InitType >
nb::NarrowBandConfiguratorTraitMultiQuad< _RealType, Dim, _QuadType, _InitType >
nb::NarrowBandConfiguratorTraitTFE< _RealType, Dim, _QuadType, _InitType >
nb::NarrowBandGrid< _FullGridType, Dim >
nb::NarrowBandGrid< _FullGridType, qc::QC_2D >
nb::NarrowBandGrid< _FullGridType, qc::QC_3D >
nb::NarrowBandGridBase< _FullGridType >
nb::NarrowBandMaskedGrid< RealType, Dim >
nb::NarrowBandMaskedGrid< _RealType, qc::QC_3D >
qc::NCCRegistrationConfigurator< ConfiguratorType >
aol::NewtonInfo< RealType >Collects all administrative infos about a Newton method
aol::NewtonIteration< ConfiguratorType, VectorType, SecondDerivativeType >
aol::NewtonIteration< ConfiguratorType, aol::Vector< typename ConfiguratorType::RealType >, SecondDerivativeType >
aol::NewtonIterationBase< RealType, VectorType, DerivativeType, SecondDerivativeType >
aol::NewtonIterationSparseBlockMatrix< MatrixType, SolverType, NumComponents >
aol::NewtonMinimizationBase< RealType, VectorType, DerivativeType, SecondDerivativeType >
qc::PeriodicFastILexMapper< QC_2D >::nmap_T
qc::FastQuadILexMapper< qc::QC_2D >::nmap_T
qc::PeriodicFastILexMapper< QC_3D >::nmap_T
nb::NodeIterator< _FullGridConfType, _InitType >
qc::GridDefinition::NodeNeighborHoodIterator2D
qc::NodeOffsetsStruct
aol::NoiseOperator< RealType >
aol::NonlinearCombinedDiffVectorOpInterface< ConfiguratorType, NumCompArg, NumCompDest, Imp >General Interface for nonlinear first order FE-operators depending on x, which are locally assembled. only getNonlinearity has to be provided. not for operators depending on derivatives of the function, use FENonlinDiffOpInterface instead. The discrete operator is of the form

\[ [F(\Phi)]_i = \int_\Omega tr\left( f( x, \nabla \phi )^T \cdot \nabla \psi_i \right) dx \]

where $ \psi_i $ corresponds to the i-th basis function, $ :R^d\times R^{d,d} \to R^{d,d} $, which has to be implemented in getNonlinearity

qc::NormalizedCrossCorrelationEnergy< ConfiguratorType >$ - \int \frac{(T\circ\Phi-\textrm{mean}(T\circ\Phi))(x)(R(x)-\textrm{mean}(R))}{\textrm{var}(T\circ\Phi)\textrm{var}(R)} dx $
om::NormalProjection< ConfType >
om::NormalProjMassOp< ConfType >
aol::NullOp< DomType, RangeType >
aol::NumberTrait< T >
aol::Obj
qc::OcGridField
qc::OcTree
qc::ScalarArray< _DataType, qc::QC_2D >::offsetCopier
qc::ScalarArray< _DataType, qc::QC_3D >::offsetCopier
qc::GridDefinition::OldAllElementIterator
qc::RectangularGrid< Dim >::OldAllElementIterator
qc::GridStructure::OldAllNodeIterator
qc::GridDefinition::OldBoundaryHyperfaceIterator2DIterator traverses the boundary elements of a 2d-grid (i.e. the four sides of the unit-square)
qc::GridDefinition::OldFullBoundaryNodeIterator
qc::GridDefinition::OldFullElementIteratorIterator over all elements in a quoc grid
qc::GridDefinition::OldFullNodeIterator
nb::NarrowBandGrid< _FullGridType, qc::QC_3D >::OldFullNodeIterator
nb::NarrowBandGrid< _FullGridType, qc::QC_2D >::OldFullNodeIterator
qc::GridDefinition::OldFullPeriodicElementIteratorFor a grid with periodic boundary condition
qc::GridDefinition::OldLShapeElementIteratorIterator for L-shape
qc::GridDefinition::OldXPeriodicElementIteratorPeriodic boundary condition in x-direction
aol::OneMinusArcTanHeavisideFunction< RealType >
aol::OneMinusHeavisideFENonlinIntegrationVectorInterface< ConfiguratorType, HeavisideFunctionType, TargetOpType >
aol::OneMinusHeavisideFENonlinOpInterface< ConfiguratorType, HeavisideFunctionType, TargetOpType >
aol::OneMinusHeavisideFENonlinVectorDiffOpInterface< ConfiguratorType, NumCompArg, NumCompDest, HeavisideFunctionType, TargetOpType >
aol::OneMinusHeavisideIntegrateFEFunction< ConfiguratorType, HeavisideFunctionType >
aol::Op< _DomainType, _RangeType >
morph::Opening< RealType, Dim >
om::OpenMeshConfigurator< _RealType, OpenMeshType, _QuadType >
aol::OperationNotPermittedException
mg::OperatorHierarchyMultigrid< VectorType, OpType, SmoothOpType, ReOpType, PrOpType >
aol::opfstream
OpType
aol::OrderOp< RealType >Base class for ordering operators
qc::OTFILexMapper< qc::QC_2D >
qc::OTFILexMapper< qc::QC_3D >
aol::OutOfBoundsException
aol::OutOfMemoryException
aol::OverflowTrait< T >
qc::Parallelogram2d< RealType >Class for the simple parallelogram-anisotropy in 2d
aol::ParameterException
aol::ParameterParserA class for reading parameters from configuration files
aol::ParameterRangeException
tpcfe::ParentTetraIdentifier
tpcfe::ParentTetraList
aol::PBiCGInverse< VectorType, OpType, iOpType >Preconditioned BiCG
aol::PBiCGStabInverse< VectorType, OpType, iOpType >BiCG-stab solver with preconditioning
aol::PCAOp< RealType, SampleType >Class for performing a principal component analysis on data of the type "aol::Vector" or "aol::MultiVector" (or any type providing the same class methods and fitting into a "aol::RandomAccessContainer"). The dot product used for the covariance matrix can be freely chosen
aol::PCGInverse< VectorType, OpType, iOpType >Preconditioned Conjugate Gradient solver
aol::PCGInverseProjectEqConstr< VectorType, OpType, iOpType >
qc::Pedestal2d< RealType >Class for a pedestal-like Wulffshape in 2D
qc::Pedestal3d< RealType >Class for a pedestal-like Wulffshape
qc::Pentagon2d< RealType >Class for a pentagon-like Wulffshape in 2D
qc::Pentagon3d< RealType >Class for a rotated pentagon-like Wulffshape in 3D
qc::PeriodicFastILexMapper< Dim >
qc::PeriodicFastILexMapper< QC_2D >
qc::PeriodicFastILexMapper< QC_3D >
qc::PeriodicityHandlerBase< GridType, DataType, Dim >
aol::PermutationMatrix< ArgDataType >
qc::PeronaMalikLevelSetStiffOp< ConfiguratorType >
qc::PeronaMalikStiffOp< ConfiguratorType >
qc::PeronaMalikWeightingFunction< RealType >
qc::PiecewiseConstantTwoPhaseMSSegmentor< ConfiguratorType, ImageDimension, BaseClass >
aol::PipeException
aol::Plane< RealType >
aol::PlotDataFileHandler< RealType >
aol::Plotter< RealType >
qc::PNGLoadInterface
qc::PNGSaveInterface
tpcfe::PoempelRemoverBase< RealType >
aol::PointwiseConstraintPenaltyEnergy< ConfiguratorType, PenaltyFunctionType >
aol::PointwiseConstraintPenaltyEnergyMulti< ConfiguratorType, PenaltyFunctionType, numberOfFunctions >
aol::Polynom< T >
aol::PolynomialHeavisideFunction< RealType >
aol::PowerSetIteratorIterates over all possible vectors of length NumberOfComponents with component values of zero or one
qc::PPMImage< REAL >
aol::ProgressBar< _showPercentage, _showBar, TYPE, _screenWidth, _leftBrace, _rightBrace, _empty, _full >
aol::ProjectEqConstrSolver< VectorType >
aol::ProjectingMetricDescent< DataType, IndexType >
qc::ProlongOp< RealType >
qc::simplex::ProlongOp< RealType, Dim >Class for prolongation of data on a simplicial grid consistent with qc::simplex::TopologyLookup
aol::provideVirtualGetCoeffClass< ConfiguratorType >
aol::provideVirtualGetCoeffMatrixClass< ConfiguratorType >
aol::QLTridiagEigenvectorOp< BandMatrixType, OrthogonalMatrixType >QL algorith with implicit shift. Determines eigenvalues (and eigenvectors, if desired) of a real symmetric tridiagonal matrix
aol::QRDecomposeGivensBase< RealType >
aol::QRDecomposeHouseholderMatrix< RealType >
aol::QRDecomposeModifiedGramSchmidt< RealType >
aol::QREigenvectorOp< MatrixType >Composition of QRGivensTridiag and QLTridiagEigenvectorOp. Computes eigenvalues by first producing tridiagonal form and then finding eigenvalues of this tridiagonal matrix
aol::QRGivensTridiag< MatrixType >QR tridiagonalization of a matrix via Givens rotations Constructed with a symmetric full matrix A, it computes an orthogonal matrix Q such that Q^T A Q is tridiagonal
aol::QRInverse< DataType >
aol::QRInversePivot< DataType >
qc::QuadGridField
aol::QuadraticCEMEnergyMixedSecondLevelsetDerivativeInterface< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions, Imp >
aol::QuadraticCEMEnergySecondLevelsetDerivativeInterface< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions, Imp >
aol::QuadraticFormOp< VecType >
aol::QuadraticZeroOneIntervalPenaltyFunction< RealType >
qc::QuadTree
aol::QuasiNewtonBFGS< RealType, VectorType, DerivativeType >
aol::QuasiNewtonIteration< RealType, VectorType, DerivativeType >
aol::QuasiNewtonIterationComponentWiseTimestepControlled< RealType >
qc::QuocConfiguratorTraitBase< RealType, Dim >This serves as a basic default configuration for qc::Ops
qc::QuocConfiguratorTraitMultiLin< RealType, Dim, QuadType, _MatrixType >
qc::QuocConfiguratorTraitMultiLin< _RealType, qc::QC_1D, _QuadType, _MatrixType >
qc::QuocConfiguratorTraitMultiLin< _RealType, qc::QC_2D, _QuadType, _MatrixType >
qc::QuocConfiguratorTraitMultiLin< _RealType, qc::QC_3D, _QuadType, _MatrixType >
qc::QuocConfiguratorTraitMultiQuad< RealType, Dim, QuadType, _MatrixType >
qc::QuocConfiguratorTraitMultiQuad< _RealType, qc::QC_2D, _QuadType, _MatrixType >
nb::QuocConfiguratorTraitTFE< RealType, Dim, QuadType, InitType >
nb::QuocConfiguratorTraitTFE< _RealType, qc::QC_3D, _QuadType, _InitType >
aol::QuocGradientDescent< ConfiguratorType, VectorType >
mg::QuocMultigrid< RealType, MatrixType, CMode >
qc::QuocOneDirectionPeriodicityHandler< GridType, DataType, Dim >
qc::QuocPeriodicityHandler< GridType, DataType, Dim >
qc::QuocTimestepSaver< ConfiguratorType >
aol::RandomAccessContainer< _DataType >
aol::RandomGenerator
aol::RateIndependentDescent< DataType, IndexType >
aol::RealTrait< T >
aol::RealTrait< double >
aol::RealTrait< long double >
aol::RecordedGradientDescent< ConfiguratorType >
qc::RectangularBoundaryFaceElementIterator< ConfiguratorType >
qc::RectangularBoundaryIterator< Dim, IteratedType >
qc::RectangularContainer< DataType, ArrayType, dim >
qc::RectangularContainer< DataType, ArrayType, qc::QC_3D >
qc::RectangularGrid< Dim >
qc::RectangularGridConfigurator< _RealType, Dimension, _QuadType >
qc::RectangularGridConfigurator2D< _RealType, _QuadType >
qc::RectangularGridConfigurator3D< _RealType, _QuadType >
qc::RectangularGridConfigurator< _RealType, qc::QC_2D, _QuadType >
qc::RectangularGridConfigurator< _RealType, qc::QC_3D, _QuadType >
qc::RectangularGridConfiguratorBase< _RealType, Dim >
qc::RectangularIterator< Dim, IteratedType >
qc::RectangularIteratorBase< Dim, IteratedType >Basis class for RectangularIterator and RectangularBoundaryIterator in 2D, do not use directly
qc::RegistrationInterface< ConfiguratorType >
qc::RegistrationMultilevelDescentInterface< ConfiguratorType >
qc::RegistrationStepSaver< ConfiguratorType >
qc::RegMaxAnisotropy< RealType >
qc::RegularizedLinCombDescentDirOp< RealType, VecType >
qc::RegularizedLinCombDescentDirOp< RealType, aol::MultiVector< RealType > >
qc::RegularSimplexConfigurator< _RealType, Dimension, _QuadType, _InitType >
qc::RegularSimplexConfigurator< _RealType, qc::QC_2D, _QuadType, _InitType >
qc::RegularSimplexConfigurator< _RealType, qc::QC_3D, _QuadType, _InitType >
qc::RegularSimplexConfiguratorBase< _RealType, Dim, _InitType >
tpcfe::SlopeInterface< CFEGrid< RealType, CFE_TPOS > >::RelevantEdgeIdentifier
qc::ScalarArray< _DataType, qc::QC_2D >::resampleCopier
qc::ScalarArray< _DataType, qc::QC_3D >::resampleCopier
qc::RestrictOp< RealType, RestrType >
qc::RestrictValuesFromVectorOp< RealType, VecType >
qc::RestrictValuesOpDef< RealType >
qc::RestrictValuesOpInterface< RealType, Imp, VecType >
aol::RestrOp< DataType >
aol::RGBColorMap< RealType >
qc::RigidDisplacementProjectionEnergy< ConfiguratorType >This class computes via "apply(...)": $ \int_\Omega w(x)(\phi-R(\alpha_i)(x-x_0)-b-x_0)^2 dx $ in "Dest", where the domain $ \Omega $, the weight $ w $, and the displacement $ \phi-id $ are passed to the constructor, and $ b $ and the angles $ \alpha_i $ for the rotation matrix $ R(\alpha_i) $ are passed to "apply(...)". If the offset $ x_0 $ was not passed to the constructor it is taken to be zero
qc::RigidDisplacementProjectionGradient< ConfiguratorType >This class computes via "apply(...)" the gradient of $ \int_\Omega w(x)(\phi-R(\alpha_i)(x-x_0)-b-x_0)^2 dx $ wrt $ b $ and the $ \alpha_i $ in "Dest", where the domain $ \Omega $, the weight $ w $, and the displacement $ \phi-id $ are passed to the constructor, and $ b $ and the angles $ \alpha_i $ for the rotation matrix $ R(\alpha_i) $ are passed to "apply(...)". If the offset $ x_0 $ was not passed to the constructor it is taken to be zero
aol::RingBuffer< T >Container that can overwrite its oldest item when inserting a new one
aol::RingBufferFrontInsertCapped< T >Ring buffer that inserts in front, start with size zero and grows up to its initially given maximal size
qc::ROFRegularizationConfigurator< ConfiguratorType >
qc::Rotated3dAnisotropy< RealType, AnisoType >
qc::RotatedEllipsoidAnisotropy< RealType >
qc::RotatedHexagon3d< RealType >Class for an rotated hexagon in 3d
qc::RotatedLpAnisotropy3d< RealType >
aol::Row< DataType >
aol::Row< DataType >::RowEntry
aol::Row< DataType >::RowEntryComp
aol::RowEntryOp< RealType, SparseOpType >
aol::RQuadBandMatrix< DataType >
qc::SaveTypeTrait< DataType >
aol::Scalar< _DataType >This class is needed when you use operators with DestType = a scalar value
ScalarArray
qc::ScalarArray< _DataType, qc::QC_1D >
qc::ScalarArray< _DataType, qc::QC_2D >
qc::ScalarArray< _DataType, qc::QC_3D >
qc::ScalarArrayTrait< _DataType, dim >
qc::ScalarArrayTrait< _DataType, 1 >
qc::ScalarArrayTrait< _DataType, 2 >
qc::ScalarArrayTrait< _DataType, 3 >
aol::MeshWithData< MeshType >::ScalarData
aol::ScalarVecToScalarMVecOp< RealType >
aol::SecondDerivativeTester< VecType, SecondDerivativeType >
aol::SecondDerivativeValidator< VecType, SecondDerivativeType >
qc::simplex::SecondOrderQuadrature< RealType, Dim >
qc::simplex::SecondOrderQuadrature< RealType, qc::QC_3D >
aol::SecondPartOfFullVariationOfHeavisideLevelsetLengthEnergy< ConfiguratorType, HeavisideFunctionType >
aol::SecondVariationOfEsedogluSegmentationModelWithPenalty< ConfiguratorType, PenaltyFunctionType, MatrixType >
aol::SecondVariationOfEsedogluSegmentationModelWithPenaltyMulti< ConfiguratorType, PenaltyFunctionType, numberOfFunctions, MatrixType >
aol::SecondVariationOfIsotropicROF< ConfiguratorType, MatrixType >
aol::SecondVariationOfPointwiseConstraintPenaltyEnergy< ConfiguratorType, PenaltyFunctionType >
eik::SegEstimator3d
eik::MetaEstimator::SegEstItem
eik::Segment3d
aol::SemiimplicitFixpointInverse< VectorType, InverseType >Fixpoint iteration, untested
aol::SemiImplicitGradientDescent< ConfiguratorType, VectorType, MatrixType >
aol::SemiImplicitGradientDescent< ConfiguratorType, aol::MultiVector< typename ConfiguratorType::RealType >, MatrixType >
aol::SemiImplicitGradientDescentBase< RealType, VectorType, MatrixType, DerivativeType >
aol::SemiImplicitGradientDescentHelper< VectorType, MatrixType >
qc::SetValuesOp< RealType, IteratorType, GridType >
qc::ShapeLevelsetGenerator< DataType >
qc::SigmaTauOpBase< RealType >
qc::SignedDistanceBase< ConfiguratorType, EikonalType >
qc::SignedDistanceBase3D< RealType, EikonalType >
qc::SignedDistanceOp< ConfiguratorType >
qc::SignedDistanceOp3D< RealType >
qc::SignedDistanceOp3DWithExtVel< RealType >
qc::SignedDistanceOpTrait< ConfiguratorType, Dim >
qc::SignedDistanceOpTrait< ConfiguratorType, qc::QC_2D >
qc::SignedDistanceOpTrait< ConfiguratorType, qc::QC_3D >
qc::SignedDistanceSweepingOp3D< RealType >
qc::SignedDistAndExtVelocityOp< ConfiguratorType >
aol::SimpleDescent< DataType, IndexType >
aol::SimpleFormat
aol::SimpleGradientDescent< ConfiguratorType, VectorType >
aol::SimpleGradientDescent< ConfiguratorType, aol::MultiVector< typename ConfiguratorType::RealType > >
aol::SimpleGradientDescent< ConfiguratorType, aol::Vector< typename ConfiguratorType::RealType > >
qc::simplex::SimplexBoundaryFaceElement< CubicElementType, RealType, Dim >Simplicial face element
qc::simplex::SimplexBoundaryFaceElement< CubicElementType, RealType, qc::QC_3D >Simplicial face element implementation for 3D
qc::simplex::SimplexBoundaryFaceElementIterator< CubicBoundaryFaceElementIterator, _GridType, _SimplexConfType, Dim >
qc::simplex::SimplexInCubeIterator< CubicElIterator, _CubicGridType, Dim >
qc::simplex::SimplexInFaceIterator< CubicBoundaryFaceElementIterator, _GridType, Dim, RealType >Iterates over all simplices of a cubic boundary face
aol::SimultaneouslyAssembledLinCombOp< ConfiguratorType, IndexMode >
qc::SinePolygonRotated3d< RealType >
qc::SkewSymmetricMean< ConfiguratorType >Computes $ \frac{1}{2}\int (\partial_iu_j-\partial_ju_i $, where marg=u
qc::SliceExtractor< ConfiguratorType >
tpcfe::SlopeInterface< CFEGrid< RealType, CFE_CD, NodalCoeffType > >Compatibility slope interface for CFE_CD
tpcfe::SlopeInterface< CFEGrid< RealType, CFE_LIEHR > >
tpcfe::SlopeInterface< CFEGrid< RealType, CFE_TPOS > >
tpcfe::SlopeInterface< CFEGrid< RealType, CFE_TPOSELAST, IsotropicElasticityCoefficient< RealType > > >Compatibility slope interface for CFE_TPOSELAST
tpcfe::SlopeInterface< CFEGrid< RealType, CFE_TPOSELAST, VoigtElasticityCoefficient< RealType > > >
tpcfe::SlopeInterfaceBase< GridType >
tpcfe::SmallComponentsPoempelRemover< RealType >
mg::Smoother< VectorType, OpType >
aol::SolutionStepSaver< SolverType, VectorType >
aol::SolverInfo< RealType >Collects all administrative infos about an iterative linear solver
aol::SparseBlockMatrix< MatrixType >
aol::SparseMatrix< DataType >
aol::SparseRow< DataType >
aol::SphericalVec< RealType >3d-vector in spherical coordinates
qc::SquaredDeformedWeightMassOp< ConfiguratorType, IndexMode >
aol::SquaredDiffWeightMassOp< ConfiguratorType, IndexMode >
qc::SquaredInvDeformedWeightMassOp< ConfiguratorType, IndexMode >
qc::SquaredWeightDeformMassOp< ConfiguratorType >Class to compute $(\int_\Omega w(x)^2(\varphi_i\circ\Phi)(\varphi_j\circ\Phi) dx)_{ij}$,
aol::SquaredWeightMassOp< ConfiguratorType, IndexMode >
aol::SquaredWeightStiffOp< ConfiguratorType, IndexMode >
aol::SquareFunction< RealType >
qc::SSDEnergy< ConfiguratorType >$ \frac{1}{2}\int ((T\circ\Phi)(x)-R(x))^2 dx $
qc::SSDForce< ConfiguratorType >$ \left( \int ((T\circ\Phi)(x)-R(x))\nabla T(x)\cdot \Psi_i(x) dx\right)_i $
qc::SSDRegistrationConfigurator< ConfiguratorType >
aol::SSORPreconditioner< aol::MultiVector< RealType >, MatrixType >SSOR preconditioner for block matrices. Represents for a given matrix $A$ and its decomposition $A=L+D+U$ into the lower triangular, diagonal, and upper triangular part the operator $\left(\frac{D}\omega+L\right)\frac\omega{2-\omega}D^{-1}\left(\frac{D}\omega+U\right)$, which is equivalent to computing one single SSOR iterate starting with the initial vector 0. Note, the SOR-iteration to solve the system $Ax=b$ is given by $\left(\frac{D}\omega+L\right)x^{m+1}=\frac{2-\omega}\omega Dx^m-\left(\frac{D}\omega+U\right)x^m+b$, the backward SOR-iteration by $\left(\frac{D}\omega+U\right)x^{m+1}=\frac{2-\omega}\omega Dx^m-\left(\frac{D}\omega+L\right)x^m+b$, and the SSOR-iteration by alternatingly applying the SOR-iteration first and then the backward SOR-iteration
aol::SSORPreconditioner< aol::Vector< RealType >, MatrixType >A class for preconditioning sparse matrices by SSOR. Represents for a given matrix $A$ and its decomposition $A=L+D+U$ into the lower triangular, diagonal, and upper triangular part the operator $\left(\frac{D}\omega+L\right)\frac\omega{2-\omega}D^{-1}\left(\frac{D}\omega+U\right)$, which is equivalent to computing one single SSOR iterate starting with the initial vector 0. Note, the SOR-iteration to solve the system $Ax=b$ is given by $\left(\frac{D}\omega+L\right)x^{m+1}=\frac{2-\omega}\omega Dx^m-\left(\frac{D}\omega+U\right)x^m+b$, the backward SOR-iteration by $\left(\frac{D}\omega+U\right)x^{m+1}=\frac{2-\omega}\omega Dx^m-\left(\frac{D}\omega+L\right)x^m+b$, and the SSOR-iteration by alternatingly applying the SOR-iteration first and then the backward SOR-iteration
qc::StandardRegistration< ConfiguratorType, RegistrationConfiguratorType, RegularizationConfiguratorType, GradientDescentType >
qc::StandardRegistrationMultilevelDescent< ConfiguratorType, RegistrationConfiguratorType, RegularizationConfiguratorType >
tpcfe::StandardSlopeInterface< GridType >Basis class for slope interface (compatibility only) classes for standard coarsening
qc::ScalarArray< _DataType, qc::QC_3D >::standartCopier
qc::ScalarArray< _DataType, qc::QC_2D >::standartCopier
aol::StepSaverBase< RealType, SaveInputType >
aol::StiffOp< ConfiguratorType, IndexMode >
aol::StopWatch
streambuf
stringstream
nb::SubGridSparseMatrix< DataType, ConfigType >
qc::SymmetricLengthEnergy< ConfiguratorType >Computes $ \frac{1}{2}\int |Du+Du^T|^2 $, where marg=u
aol::SymmetricMatrix< DataType >A class for symmetric matrices
qc::BaseFunctionSetTFE_Static< RealType, QuadRuleType >::tableCache
aol::Tensor< VecType, dim >Tensor of order n+1 if VecType is of order n
aol::Tensor222< DataType >
aol::Tensor2222< DataType >
aol::TensorOp< RealType, VectorType >
aol::TensorStiffOp< ConfiguratorType >Operator for stiffness matrices of the form

\[ \int_\Omega w_1 \times w_2 \nabla u \cdot \nabla w dx \]

qc::TiledSpace< ArrayType, MatrixType, VectorType >
aol::TimestepSaver< RealType >
tpcfe::TopBottomPoempelRemover< RealType >
qc::simplex::TopologyLookup< Dim >
qc::simplex::TopologyLookup< QC_2D >
qc::simplex::TopologyLookup< QC_3D >
qc::TransformFunction< _RealType, Dim >
qc::TransformFunction< RealType, qc::QC_2D >
qc::TransformFunction< RealType, qc::QC_3D >
aol::TransparentIndexTranslationMatrix< MatrixType, LargeDomainType, LargeRangeType >Wrapper for Matrices that are intended to work only on a small set of vector components. Small matrix is visible through the wrapper
eik::Traversable
eik::Eikonal< RealType >::TrialNode
eik::TrialNode< T >
eik::EikonalNAInt< RealType, EikonalImp, qc::QC_3D >::TrialNode
eik::EikonalNAInt< RealType, EikonalImp, qc::QC_2D, GridType >::TrialNode
aol::Triangle< DataType >
om::TriMesh< _RealType >::TriangleSee description of base class above
om::TriangleBase< RealType, MeshType >
aol::TriangleIntegration< RealType, Dim, order >
aol::TriangleIntegration< RealType, qc::QC_2D, 1 >Integration over a triangle: area * value at the center of gravity
aol::TriangleIntegration< RealType, qc::QC_2D, 2 >Integration over a triangle: area * (sum of weighted values at side middle points)
aol::TriangleIntegration< RealType, qc::QC_3D, 0 >Integration over a tetrahedron: test
aol::TriangleIntegration< RealType, qc::QC_3D, 1 >Center of mass integration over the six tetrahedra which are decomposition of a unit cube
om::TriMesh< _RealType >::TriangleIter
aol::TriangMesh< DataType >::TriangleIterator
aol::TriangMesh< DataType >
aol::TriBandMatrix< DataType >
om::TriMesh< _RealType >
TriMesh_ArrayKernelT
om::TriMeshBaseFunctionSet< RealType, QuadRuleType, TriangleType >
om::TriMeshWithEdgeNormals< RealType >
om::TriMeshWithGeomProps< RealType, Imp >
TriMeshWithNormalType
om::TriMeshWithVertexNormals< RealType >
om::TriQuadrature< RealType >
aol::TrustRegionMethod< _RealType, _VectorType, _SecondDerivativeType, _PrecondType, SubMatrixType >Newton trust region method
qc::TVAlgorithmBase< ConfiguratorType >
qc::TVStiffOp< ConfiguratorType >
qc::TwoPhaseMSSegmentor< ConfiguratorType >Abstract base class for two phase Mumford Shah segmentation
aol::TypeException
qc::UGBMatrix< columns, localDimension, blocksize, _DataType, InitType >
qc::UniformGridSparseMatrix< DataType >
qc::UniformGridSparseRow< DataType >
qc::UniGridCSR_Matrix< Dim >
qc::UniGridCSR_Matrix< QC_2D >
qc::UniGridCSR_Matrix< QC_3D >
aol::UnimplementedCodeException
aol::Variable
aol::VariableField
qc::simplex::VariableNumberOfQuadPointsBaseFunctionSet< RealType, VecType, DomVecType, NumBaseFuncs, Imp >
aol::VariationOfHeavisideLevelsetLengthEnergy< ConfiguratorType, numberOfLevelsetFunctions >
aol::VariationOfIsoEnergyOp< ConfiguratorType >
aol::VariationOfIsotropicROF< ConfiguratorType, MatrixType >
qc::VariationOfLinearizedElasticEnergy< ConfiguratorType >
qc::VariationOfMIRegistrationEnergyWithRegardToPhi< ConfiguratorType >
qc::VariationOfNormalizedCrossCorrelationEnergy< ConfiguratorType >
aol::VariationOfPointwiseConstraintPenaltyEnergy< ConfiguratorType, PenaltyFunctionType >
aol::VariationOfPointwiseConstraintPenaltyEnergyMulti< ConfiguratorType, PenaltyFunctionType, numberOfFunctions >
qc::VariationOfSymmetricLengthEnergy< ConfiguratorType >Computes the first variation of SymmetricLengthEnergy, e.q. $ 2 int (Du+Du^T):D\zeta $, where marg=u
om::VariationOpInterface< TriMeshConfType, Imp >Special class for variations of TriMeshes Similar to aol::FENonlinVectorDiffOpInterface< ConfType, 3, 3, Imp > but - in order to reduce unnecessary conversions - the DomainType is TriMeshType (instead of MV)
aol::Vec< dimension, _DataType >
aol::Vec2< _DataType >
aol::Vec3< _DataType >
aol::MultiVector< _DataType >::vec_entry
aol::AMultiVector< ComponentType >::vec_entry
aol::VecDimTrait< DataType, Dim >
aol::VecDimTrait< DataType, 2 >
aol::VecDimTrait< DataType, 3 >
aol::VecToMVecOp< RealType >
aol::Vector< _DataType >A vector class
vector
aol::VectorContainer< DataType >
aol::MeshWithData< MeshType >::VectorData
aol::VectorFENonlinIntegrationVectorInterface< ConfiguratorType, Imp, NumComponents, NumberOfIntegrandComponents >
Velocity
aol::TriangMesh< DataType >::VertexIterator
tpcfe::VoigtElasticityCoefficient< RealType >
qc::VolumeEnergy< ConfiguratorType, Dim >
qc::VolumeGradient< ConfiguratorType, Dim >
qc::WeightedAdditionalFEFctMassOp< ConfiguratorType, IndexMode >
qc::WeightedHyperelasticEnergyDensity< ConfiguratorType, HyperelasticEnergyDensityType >This class represents a spatially weighted hyperelastic energy density $ w(x)W(I_1,I_2,I_3) $ with respect to the invariants $ I_1=||\nabla\phi||_F^2 $, $ I_2=||cof(\nabla\phi)||_F^2 $, $ I_3=det(\nabla\phi) $ of the deformation gradient $\nabla\phi$, where the hyperelastic energy $W$ and the weight $w$ have to be passed to the constructor. $W$ can e.g. be "HyperelasticEnergyDensityDefault"
aol::WeightedMassOp< ConfiguratorType, IndexMode >
qc::WeightedMassOp< ConfiguratorType, IndexMode >
aol::WeightedSemiDiffOp< ConfiguratorType >
aol::WeightedStiffOp< ConfiguratorType, IndexMode >
qc::WeightedTwoPhaseMSSegmentor< ConfiguratorType >
qc::WillmoreProjectionStiffOp< ConfiguratorType >
qc::WillmoreStiffAnisoOp< ConfiguratorType, AnisotropyType >Operator from willmore flow with p-regularization
qc::WillmoreStiffExpOp< ConfiguratorType, AnisotropyType >Operator from willmore flow with p-regularization
qc::WillmoreStiffImpOp< ConfiguratorType, AnisotropyType >
qc::WillmoreStiffWOp< ConfiguratorType >
aol::ZeroOneIntervalPenaltyFunction< RealType >
aol::ZOTrait< T >
aol::ZTrait< T >

Generated on Fri Sep 9 2011 21:08:47 for QuocMesh by doxygen 1.7.1