| CAccumulated | Storage for accumulating derivatives |
| CAffineMatrix | |
| CAlignedStorage< Type > | Simple block of memory on stack with size and alignment given by template type |
| CAlignedStorage< T > | |
| CAlignedStorage< Type & > | Specialization for l-value references, a simple wrapper of ReferenceWrapper with same interface to allow generic usage of AlignedStorage for both values and references |
| CAlignedUnion< TArgs > | Stores value of type std::aligned_union, having size and alignment equal to maximum of sizes and alignments of template types |
| CAlignedUnion< TArgs... > | |
| CAllTrue< Values > | |
| CAllTrue< First, Second, Others... > | |
| CAllTrue< Value > | |
| CAntisymmetricTensor | |
| CAny | Type-safe object that can store value of any type, similar to std::any |
| CAnyTrue< Values > | Static logical or |
| CAnyTrue< First, Second, Others... > | |
| CAnyTrue< Value > | |
| CApprox< Type > | This is more or less stolen from Catch unit-testing framework |
| CArcBall | Helper object providing rotation matrix based on mouse drag |
| CArgDesc | Descriptor of a command-line argument |
| CArgParser | Provides functions for parsing command-line arguments |
| CArrayRef< T > | |
| CArrayRef< const BasicVector > | |
| CArrayRef< const Float > | |
| CArrayRef< const Size > | |
| CArrayRef< const TracelessTensor > | |
| CArrayRef< const Type > | |
| CArrayStats< Type > | |
| CArrayView< T, TCounter > | Object providing safe access to continuous memory of data |
| CArrayView< BasicVector > | |
| CArrayView< const AutoPtr< IDiagnostic > > | |
| CArrayView< const BasicVector > | |
| CArrayView< const Float > | |
| CArrayView< const SharedPtr< JobNode > > | |
| CArrayView< const Size > | |
| CArrayView< const SymmetricTensor > | |
| CArrayView< const TracelessTensor > | |
| CArrayView< const Type > | |
| CArrayView< Float > | |
| CArrayView< Size > | |
| CArrayView< SymmetricTensor > | |
| CArrayView< Tensor > | |
| CArrayView< TracelessTensor > | |
| CArrayView< typename Traits::Type > | |
| CAssert | |
| CVariantHelpers::Assign< TArgs > | Assigns a value type of which can be stored in variant |
| CAtomic< Type > | Atomic value implemented using compare-exchange |
| ►CAutoPtr< T > | Wrapper of pointer that deletes the resource from destructor |
| CSafePtr< T > | |
| CAutoPtr< AbstractHolder > | |
| CAutoPtr< Controller > | |
| CAutoPtr< Detail::Cloner > | |
| CAutoPtr< IBasicFinder > | |
| CAutoPtr< IBoundaryCondition > | |
| CAutoPtr< IBrdf > | |
| CAutoPtr< ICamera > | |
| CAutoPtr< ICollisionHandler > | |
| CAutoPtr< IColorizer > | |
| CAutoPtr< IColorMap > | |
| CAutoPtr< IDistribution > | |
| CAutoPtr< IDomain > | |
| CAutoPtr< IEnergyPartitioner > | |
| CAutoPtr< IEos > | |
| CAutoPtr< IExtraEntry > | |
| CAutoPtr< IFractureModel > | |
| CAutoPtr< IGravity > | |
| CAutoPtr< IJob > | |
| CAutoPtr< ILogger > | |
| CAutoPtr< ILogWriter > | |
| CAutoPtr< IMaterial > | |
| CAutoPtr< IOutput > | |
| CAutoPtr< IOverlapHandler > | |
| CAutoPtr< IRenderContext > | |
| CAutoPtr< IRenderer > | |
| CAutoPtr< IRenderPreview > | |
| CAutoPtr< IRheology > | |
| CAutoPtr< IRng > | |
| CAutoPtr< ISolver > | |
| CAutoPtr< ISymmetricFinder > | |
| CAutoPtr< ITimeStepCriterion > | |
| CAutoPtr< ITimeStepping > | |
| CAutoPtr< ITracker > | |
| CAutoPtr< IUvMapping > | |
| CAutoPtr< Session > | |
| CAutoPtr< Settings > | |
| CAutoPtr< Statistics > | |
| CAutoPtr< std::ofstream > | |
| CAutoPtr< TextInput > | |
| CAutoPtr< TextOutput > | |
| CAutoPtr< Timer > | |
| CAutoPtr< TimerThread > | |
| CAutoPtr< wxAuiManager > | |
| CAutoPtr< wxBitmap > | |
| CBackInserter< TContainer > | Output iterator that inserts the written values to the given iterator using push function |
| CBadge< T > | Helper class used to allow calling a function only from within T |
| CBaseline | |
| CBasicOutcome< TError > | Expected-like class that does not contain any value |
| CBasicOutcome< std::string > | |
| CBasicPoint< T, TDerived > | |
| ►CBasicPoint< float, Coords > | |
| CCoords | |
| ►CBasicPoint< int, Pixel > | |
| CPixel | |
| CBasicVector< T > | |
| CBasicVector< double > | Specialization for doubles or units of double precision |
| CBasicVector< float > | 3-dimensional vector, float precision |
| CBasicVector< Float > | |
| CBatchManager | |
| CBatchValueVisitor | |
| CBenzAsphaugForceDiscr | Discretization of pressure term in code SPH5 |
| CInitialConditions::BodySetup | Holds data needed to create a single body in addHeterogeneousBody function |
| CBodyView | Non-owning view of particles belonging to the same body |
| CBox | Helper object defining three-dimensional interval (box) |
| CBusyCursor | |
| CBvhBuildEntry | |
| ►CBvhPrimitive | |
| CBvhBox | Trait for finding intersections with a axis-aligned box |
| CBvhSphere | Trait for finding intersections with a sphere |
| CBvhTriangle | Trait for finding intersections with a triangle |
| CBvhTraversal | |
| CDetail::Callable< TSignature > | |
| CCallbackSet< void(TArgs...)>::Callback | |
| CCallbackSet< TSignature > | |
| CCallbackSet< Function > | |
| ►CCallbackSet< void(TArgs...)> | |
| CCallbackSet< Function< void(TArgs...)> > | Convenience specialization for Function |
| CCameraData | |
| CCameraParams | |
| CCameraRay | Ray given by origin and target point |
| CGalaxyCallbacks::Cancelled | |
| CVirtualSettings::Category | |
| CCell | Single cell used in mesh generation |
| CHashMapFinder::Cell | |
| CCenterDensityDiscr | Discretization using the density of the center particle |
| CCircularArray< T > | |
| CClonePtr< T > | |
| CCohesionKernel | Helper kernel used to simulate Lennard-Jones forces |
| CCollisionMC | |
| CCollisionRecord | |
| CCollisionSet | |
| CCollisionStats | |
| ►CCompareEnums | |
| CFlatMap< Optional, FlatMap, CompareEnums > | |
| CComponentGetter | |
| CComponentIterator< TIterator > | |
| CPost::HistogramParams::ComponentParams | Parameters used by histogram of components |
| CCompressedVector | |
| CComputeTrace< M > | |
| CComputeTrace< 1 > | |
| CComputeTrace< 2 > | |
| CConcurrentQueue< Type > | |
| CConfig | Provides functionality for reading and writing configuration files |
| CConfigNode | Represents a single node in the hierarchy written into config file |
| CConsole | |
| CConstexprArray< T, N > | Container similar to StaticArray, but with constexpr constructors and getters |
| CConstStorageElement | |
| CConstStorageIterator | Helper class for iterating over quantities stored in Storage, const version |
| CConstStorageSequence | Helper class, provides functions begin and end, returning const iterators to the first and last quantity in Storage, respectively |
| CContext | Accessible from benchmarks |
| CMomentOperators::Contraction< TValue > | |
| CPkdgravParams::Conversion | Conversion factors for pkdgrav |
| CConvertToSizeType< T, TEnabler > | Converts all signed integral types and enums into Size, does not change other types |
| CConvertToSizeType< T, std::enable_if_t< std::is_enum< std::decay_t< T > >::value > > | |
| CCopyableArray< T, TAllocator, TCounter > | |
| CVariantHelpers::CopyMoveAssign< TArgs > | Creates a variant by copying/moving value currently stored in other variant |
| CVariantHelpers::CopyMoveCreate< TArgs > | Creates a variant by copying/moving value currently stored in other variant |
| CCpuUsage | |
| CCrashPad | |
| CCurve | Represents a user-defined function, defined by a set of points interpolated by either piecewise linear curve or cubic spline |
| CCurvePoint | |
| CDateFormat | Helper class for transforming Julian date to calendar date |
| CVariantHelpers::DefaultCreate< TArgs > | Creates a variant using default constructor |
| CVariantHelpers::Delete< TArgs > | Destroys the object currently stored in variant |
| CMomentOperators::Delta< Order > | |
| CMomentOperators::Delta< 2 > | |
| CDiagnosticsError | Object containing a reported error message |
| CDiehlParams | Parameters of DiehlDistribution |
| CDiehlReporter | |
| CMomentOperators::Difference< TValue1, TValue2 > | |
| CFileSystem::DirectoryIterator | Iterator allowing to enumerate files and subdirectories in given directory |
| CDivergenceTraits | |
| CDumpAllVisitor | |
| CDynamic | Convenient object for storing a single value of different types |
| CEigen | |
| CFlatMap< TKey, TValue, TLess >::Element | Element of the container |
| CUnorderedMap< TKey, TValue >::Element | Element of the container |
| CKepler::Elements | Object holding Keplerian orbital elements of a body |
| CElementWithIndex< TValue > | |
| CEmptyArray | |
| CEmptyFlags | |
| CEmptySettingsTag | Tag for initialization of empty settings object |
| CEndingCondition | |
| CEnumInputValue< TEnum > | |
| CEnumMap | |
| CEnumValue | |
| CEnumWrapper | Wrapper of an enum |
| CEps< T > | Small value (compared with 1) for given precision |
| CEps< double > | |
| CEps< float > | |
| CEquationHolder | Container holding equation terms |
| CEquilibriumEnergySolver | Solver for equilibrium internal energy |
| CEquilibriumStressSolver | Solves for total stress tensor sigma |
| CEuclideanMetric | |
| ►Cstd::exception | |
| CAssert::Exception | |
| ►CException | Generic exception |
| CArgError | Exception thrown if the arguments are invalid |
| CHelpException | Exception thrown when used passes -h or –help parameter |
| CInvalidSettingsAccess | Exception thrown on invalid access to entries of a Settings object |
| CInvalidSetup | Thrown when components of the run are mutually incompatible |
| CInvalidStorageAccess | Exception thrown when accessing missing quantities, casting to different types, etc |
| CIoError | Exception thrown when file cannot be read, it has invalid format, etc |
| CMissingQuantityException | |
| CPathError | |
| CProcessException | |
| CSafePtrException | |
| CSerializerException | Exception thrown by Deserializer on failure |
| CExpected< Type, Error > | Wrapper of type that either contains a value of given type, or an error message |
| CExtendedEnum< TBase > | Helper type allowing to "derive" from enum class |
| CExtendedEnum< HistogramId > | |
| CExtendedEnum< JobType > | |
| CExtraEntry | Copyable wrapper of a IExtraEntry |
| CMesh::Face | |
| CFailTag | |
| CFamilyAsteroid | |
| CIVirtualEntry::FileFormat | |
| CFileSystem::FileLock | Locks a file |
| CFilmicMapping | Using http://filmicworlds.com/blog/filmic-tonemapping-with-piecewise-power-curves/ |
| CFinally< TFunctor > | |
| CFlags< TEnum > | Wrapper of an integral value providing functions for reading and modifying individual bits |
| CFlags< CheckFunction > | |
| CFlags< ColorizerFlag > | |
| CFlags< DerivativeFlag > | |
| CFlags< Flag > | |
| CFlags< Options > | |
| CFlags< OutputQuantityFlag > | |
| CFlags< Post::ComponentFlag > | |
| CFlags< TextAlign > | |
| CFlags< TimerFlags > | |
| CFlagsTraits< T > | |
| CFlagsTraits< Flags< T > > | |
| CDetail::ForEachIfVisitor< TFunctor, TTuple, TTrait > | |
| CDetail::ForEachVisitor< TFunctor, TTuple > | |
| CDetail::ForValue< N, T0, TArgs > | |
| CDetail::ForValue< N, NothingType, TArgs... > | |
| CDetail::ForValue< N, T0 > | |
| CFunction< T > | |
| CFunction< bool()> | |
| CFunction< bool(const Value &newValue)> | |
| CFunction< bool(double)> | |
| CFunction< bool(Float progress)> | |
| CFunction< bool(Float)> | |
| CFunction< bool(Size index)> | |
| CFunction< bool(Size iter, ArrayView< const BasicVector > r)> | |
| CFunction< Dynamic(const Storage &storage)> | |
| CFunction< Float(const BasicVector &)> | |
| CFunction< Float(const Vector &position)> | |
| CFunction< TReturn(TArgs...)> | Wrapper of callable objects |
| CFunction< void()> | |
| CFunction< void(const Curve &)> | |
| CFunction< void(GuiSettingsId id)> | |
| CFunction< void(Palette)> | |
| CFunction< void(TArgs...)> | |
| CFunction< wxPGEditorDialogAdapter *()> | |
| CFunctionChecker | |
| CFunctionSignature< TSignature > | Function traits |
| CFunctionTraits< TFunction > | |
| CFunctionTraits< TReturn(*)(TArgs...)> | |
| CFunctionTraits< TReturn(TClass::*)(TArgs...) const > | |
| CFunctionTraits< TReturn(TClass::*)(TArgs...)> | |
| CDetail::FunctorInitTag | |
| CGeneralizedMean< Power > | Generalized mean with fixed (compile-time) power |
| CGeneralizedMean< 0 > | Geometric mean has to be specialized |
| CGeneralizedMean< 1 > | |
| CGetTypeFromEnum< Type > | Convert ValueType enum to type |
| CGetTypeFromEnum< ValueEnum::INDEX > | |
| CGetTypeFromEnum< ValueEnum::SCALAR > | |
| CGetTypeFromEnum< ValueEnum::SYMMETRIC_TENSOR > | |
| CGetTypeFromEnum< ValueEnum::TENSOR > | |
| CGetTypeFromEnum< ValueEnum::TRACELESS_TENSOR > | |
| CGetTypeFromEnum< ValueEnum::VECTOR > | |
| CGetValueEnum< T > | Convert type to ValueType enum |
| CGetValueEnum< Float > | |
| CGetValueEnum< Size > | |
| CGetValueEnum< SymmetricTensor > | |
| CGetValueEnum< Tensor > | |
| CGetValueEnum< TracelessTensor > | |
| CGetValueEnum< Vector > | |
| CGhost | |
| CGradH | Object evaluating grad-h terms |
| CGradientTraits | |
| CGravityKernel< TKernel > | Gravity smoothing kernels associated with standard SPH kernels |
| ►CGravityKernelTag | |
| CSolidSphereKernel | Gravity kernel of a solid sphere |
| CGravityLutKernel | Gravitational kernel approximated by LUT for close particles |
| CGrid< T > | |
| CGroup | |
| CPointCloud::Handle | Identifies a point in the point cloud |
| CHandoffParams | |
| CHapkeParams | |
| CHarrisAsteroid | |
| Cstd::hash< Sph::Indices > | |
| CHasStreamOperator< T, TStream, typename > | |
| CHasStreamOperator< T, TStream, VoidType< decltype(std::declval< TStream & >()<< std::declval< T >())> > | |
| COctreeNode< T >::Hint | |
| CPost::HistogramParams | Parameters of the histogram |
| CPost::HistPoint | Point in the histogram |
| CDetail::Holder< TValue > | |
| CHsv | |
| CIcProgressCallback | |
| CIgnore | Placeholder for unused variables in tieToTuple |
| ►CImmovable | Object with deleted copy and move constructor and copy and move operator |
| CStackAllocator< TSize, TAlign > | Allocator used pre-allocated fixed-size buffer on stack |
| CImpactCone | |
| CIndexAdapter< TContainer > | |
| ►CIndexIterator | |
| CLeafIndexIterator | Index iterator with given mapping (index permutation) |
| ►CIndexSequence | |
| CLeafIndexSequence | Helper index sequence to iterate over particle indices of a leaf node |
| CIndices | Helper object for storing three (possibly four) int or bool values |
| CIndicesEqual | |
| ►CINeighbourFinder | |
| CAdaptiveGridFinder | Finder projecting a non-uniform grid on particles |
| CBinaryInput::Info | |
| CCompressedInput::Info | |
| CMomentOperators::InnerProduct< N, O1, TValue1, TValue2 > | |
| CMomentOperators::InnerProduct< 1, 1, TValue1, TValue2 > | |
| CMomentOperators::InnerProduct< 1, 2, TValue1, TValue2 > | |
| CMomentOperators::InnerProduct< 2, 2, TValue1, TValue2 > | |
| CMomentOperators::InnerProduct< 3, 3, TValue1, TValue2 > | |
| CIntersectionInfo | Holds intormation about intersection |
| CInterval | Object representing a 1D interval of real numbers |
| CIsCallable< TCallable, TArgs > | |
| CIsCallableImpl< TCallable, TEnabler, TArgs > | |
| CIsCallableImpl< TCallable, VoidType< decltype(std::declval< TCallable >()(std::declval< TArgs >()...))>, TArgs... > | |
| CIsEnumClass< T > | |
| CIsExtended< TDerived, TBase > | |
| CIsExtendedEnum< T > | |
| CIsExtendedEnum< ExtendedEnum< TEnum > > | |
| CIsGravityKernel< T, typename > | |
| CIsGravityKernel< GravityKernel< T > > | |
| CIsGravityKernel< T, std::enable_if_t< std::is_base_of< GravityKernelTag, std::decay_t< T > >::value > > | |
| CIsKernel< T, typename > | |
| CIsKernel< T, VoidType< decltype(std::declval< T >().radius())> > | |
| CIsShareFromThis< T, TEnabler > | |
| CIsShareFromThis< T, typename T::SHARE_FROM_THIS_TAG > | |
| CIsTuple< T > | Useful type trait, checking whether given type is a Tuple |
| CIsTuple< const Tuple< TArgs... > & > | |
| CIsTuple< Tuple< TArgs... > & > | |
| CIsTuple< Tuple< TArgs... > && > | |
| CIsVectorType< T > | Helper type trait to determine if the type is a vector of some kind |
| CIsVectorType< BasicVector< T > > | |
| ►CIterator< T > | Simple (forward) iterator over continuous array of objects of type T |
| CThreadLocal< Type >::LocalIterator< T > | |
| CIterator< const FlatMap< BodySettingsId, Dynamic >::Element > | |
| CIterator< const FlatMap< QuantityId, InternalQuantityData >::Element > | |
| CIterator< const FlatMap< QuantityId, Quantity >::Element > | |
| CIterator< const TValue > | |
| CIterator< const typename FlatMap< TEnum, typename Settings< TEnum >::Entry >::Element > | |
| CIterator< FlatMap< QuantityId, Quantity >::Element > | |
| CSettingsIterator< TEnum >::IteratorValue | |
| CIteratorWithIndex< TIterator > | Wrapper of iterator keeping also an index of current element |
| CJobRegistrar | Helper class, allowing to register job into the global list of jobs |
| CPost::KsResult | |
| CIRenderOutput::Label | |
| CHandoffParams::LargestRemnant | |
| ►CLess | |
| CFlatSet< AutoPtr< IDerivative >, Less > | |
| ►Cstd::less | |
| CFlatMap< wxPGProperty *, IVirtualEntry * > | |
| CFlatMap< std::string, Variant > | |
| CFlatMap< TEnum, Entry > | |
| CFlatMap< BodySettingsId, Dynamic > | |
| CFlatMap< GuiSettingsId, Entry > | |
| CFlatMap< QuantityId, Particle::InternalQuantityData > | |
| CFlatMap< QuantityId, Quantity > | |
| CFlatMap< CollisionGeometrySettingsId, Entry > | |
| CFlatMap< RunSettingsId, Entry > | |
| CFlatMap< StatisticsId, Variant > | |
| CFlatMap< QuantityId, Interval > | |
| CFlatMap< GalaxySettingsId, Entry > | |
| CFlatMap< NBodySettingsId, Entry > | |
| CFlatMap< PanelId, wxAuiPaneInfo * > | |
| CFlatMap< wxCheckBox *, PlotEnum > | |
| CFlatMap< QuantityId, InternalQuantityData > | |
| CFlatMap< std::string, Palette > | |
| CFlatMap< RunPage *, RunData > | |
| CFlatMap< QuantityId, Float > | |
| CFlatMap< Size, SharedPtr< TemporalPlot > > | |
| CFlatMap< BodySettingsId, Entry > | |
| CFlatSet< Size > | |
| CFlatSet< RawPtr< IAcceleration > > | |
| CFlatMap< TKey, TValue, TLess > | Container of key-value pairs |
| CFlatSet< T, TLess > | |
| CPost::LinearFunction | Class representing an ordinary 1D linear function |
| CListIterator< T > | |
| CListNode< T > | |
| ►CLocal | Object intended to only be constructed on stack |
| CStackAllocator< TSize, TAlign > | Allocator used pre-allocated fixed-size buffer on stack |
| CLocking< T, TMutex > | Wraps given object together with a mutex, locking it every time the object is accessed |
| CLocking< Array< Function > > | |
| CLockingPtr< T > | |
| CLockingPtr< IPlot > | |
| CLockingPtr< SelectedParticlePlot > | |
| CLutIterator< TValue, TScalar > | |
| CMakeMultipole< N > | Creates multipole by evaluating given object for each independent component |
| CMakeMultipole< 0 > | |
| CMakeMultipole< 1 > | |
| CMakeMultipole< 2 > | |
| CMakeMultipole< 3 > | |
| CMakeMultipole< 4 > | |
| CMakeTracelessMultipole< N > | Creates multipole by evaluating given object for each independent component |
| CMakeTracelessMultipole< 0 > | |
| CMakeTracelessMultipole< 1 > | |
| CMakeTracelessMultipole< 2 > | |
| CMakeTracelessMultipole< 3 > | |
| CMakeTracelessMultipole< 4 > | |
| CMakeVoid< Ts > | |
| ►CMallocator | Default allocator, simply wrapping _mm_malloc and _mm_free calls |
| CArray< Callback > | |
| CArray< BasicVector > | |
| CArray< PlotPoint > | |
| CArray< InnerNode< TNode > > | |
| CArray< Post::HistPoint > | |
| CArray< Array< Size > > | |
| CArray< BinaryInput::Info::QuantityInfo > | |
| CArray< Size > | |
| CArray< AutoPtr< ITextColumn > > | |
| CArray< SharedPtr< Texture > > | |
| CArray< Mesh::Face > | |
| CArray< SharedPtr< JobNode > > | |
| CArray< Float > | |
| CArray< Aggregate > | |
| CArray< SharedPtr< IColorizer > > | |
| CArray< Palette::Point > | |
| CArray< Rgba > | |
| CArray< std::string > | |
| CArray< AutoPtr< std::thread > > | |
| CArray< IntersectionInfo > | |
| CArray< AutoPtr< ITimeStepCriterion > > | |
| CArray< AffineMatrix > | |
| CArray< float > | |
| CArray< CompressedVector > | |
| CArray< std::remove_const_t< T > > | |
| CArray< BvhTriangle > | |
| CArray< TValue > | |
| CArray< UnorderedMap::Element > | |
| CArray< WeakPtr< JobNode > > | |
| CArray< QuantityRecord > | |
| CArray< Element > | |
| CArray< Array< std::string > > | |
| CArray< MatRange > | |
| CArray< T, Mallocator, uint64_t > | |
| CArray< IVirtualEntry::FileFormat > | |
| CArray< ArgDesc > | |
| CArray< Sphere > | |
| CArray< Array > | |
| CArray< InnerNode< BarnesHutNode > > | |
| CArray< RawPtr< Aggregate > > | |
| CArray< TimerEntry > | |
| CArray< std::pair< CurvePoint, bool > > | |
| CArray< BodyMetadata > | |
| CArray< Type > | |
| CArray< Col > | |
| CArray< WeakPtr< Storage > > | |
| CArray< ExtendedEnum > | |
| CArray< Ghost > | |
| CArray< Function > | |
| CArray< AutoPtr< IColorizer > > | |
| CArray< AutoPtr< IDiagnostic > > | |
| CArray< char > | |
| CArray< Local > | |
| CArray< Triangle > | |
| CArray< BvhSphere > | |
| CArray< SharedPtr< Unit > > | |
| CArray< TBvhObject > | |
| CArray< FlatMap::Element > | |
| CArray< AutoPtr< IAsymmetricDerivative > > | |
| CArray< Group > | |
| CArray< LockingPtr< IPlot > > | |
| CArray< AutoPtr< IPlot > > | |
| CArray< AutoPtr< ILogger > > | |
| CArray< Array< BasicVector > > | |
| CArray< BvhNode > | |
| CArray< NeighbourRecord > | |
| CArray< IRenderOutput::Label > | |
| CArray< CollisionRecord > | |
| CArray< SharedPtr< IEquationTerm > > | |
| CArray< T, TAllocator, TCounter > | Generic dynamically allocated resizable storage |
| CMarchingCubes | Marching cubes algorithm for generation of mesh from iso-surface of given scalar field |
| CMaterialInitialContext | Shared data used when creating all bodies in the simulation |
| ►CMaterialProvider | |
| CMaterialJob | |
| ►CMonolithicBodyIc | Creates a single monolithic body |
| CImpactorIc | |
| CMaterialView | Non-owning wrapper of a material and particles with this material |
| CMatrix4 | |
| CMcConfig | |
| CMeanStepTls< T > | |
| CMemoryBlock | |
| CMemoryResourceAllocator< TResource > | Allocator that obtains memory blocks from given memory resource |
| CMesh | |
| CMeshParams | |
| CMinimalStepTls< T > | Helper class storing a minimal value of time step and corresponding statistics |
| CMinMaxMean | Helper class for statistics, accumulating minimal, maximal and mean value of a set of numbers |
| CMomentOperators::MultiplyByScalar< TValue > | |
| CMomentOperators::MultiplyTwo< O1, TValue1, TValue2 > | |
| CMomentOperators::MultiplyTwo< 1, TValue1, TValue2 > | |
| CMomentOperators::MultiplyTwo< 2, TValue1, TValue2 > | |
| CMomentOperators::MultiplyTwo< 4, TValue1, TValue2 > | |
| CMultipole< Order > | |
| CExperimental::MultipoleBase< N > | |
| CMultipoleExpansion< N > | |
| CMultipoleExpansion< 0 > | |
| CMultipoleExpansion< 3 > | |
| CDetail::MultipoleMapping< Idxs > | |
| CDetail::MultipoleMapping< I > | |
| CDetail::MultipoleMapping<> | |
| CDetail::MultipoleMappingImpl< Idxs > | |
| CDetail::MultipoleMappingImpl< I > | |
| CDetail::MultipoleMappingImpl< X, Second, Idxs... > | |
| CDetail::MultipoleMappingImpl< Y, Second, Idxs... > | |
| CDetail::MultipoleMappingImpl< Z, Second, Idxs... > | |
| CNeighbourDensityDiscr | Discretization using the densities of summed particles |
| CNeighbourRecord | Holds information about a neighbour particles |
| CNodeManager | |
| CNodeSlot | |
| ►CNoncopyable | Object with deleted copy constructor and copy operator |
| CArray< Callback > | |
| CArray< BasicVector > | |
| CArray< PlotPoint > | |
| CArray< InnerNode< TNode > > | |
| CArray< Post::HistPoint > | |
| CArray< Array< Size > > | |
| CArray< BinaryInput::Info::QuantityInfo > | |
| CArray< Size > | |
| CArray< AutoPtr< ITextColumn > > | |
| CArray< SharedPtr< Texture > > | |
| CArray< Mesh::Face > | |
| CArray< SharedPtr< JobNode > > | |
| CArray< Float > | |
| CArray< Aggregate > | |
| CArray< SharedPtr< IColorizer > > | |
| CArray< Palette::Point > | |
| CArray< Rgba > | |
| CArray< std::string > | |
| CArray< AutoPtr< std::thread > > | |
| CArray< IntersectionInfo > | |
| CArray< AutoPtr< ITimeStepCriterion > > | |
| CArray< AffineMatrix > | |
| CArray< float > | |
| CArray< CompressedVector > | |
| CArray< std::remove_const_t< T > > | |
| CArray< BvhTriangle > | |
| CArray< TValue > | |
| CArray< UnorderedMap::Element > | |
| CArray< WeakPtr< JobNode > > | |
| CArray< T, TAllocator, TCounter > | |
| CArray< QuantityRecord > | |
| CArray< Element > | |
| CArray< Array< std::string > > | |
| CArray< MatRange > | |
| CArray< T, Mallocator, uint64_t > | |
| CArray< IVirtualEntry::FileFormat > | |
| CArray< ArgDesc > | |
| CArray< Sphere > | |
| CArray< Array > | |
| CArray< InnerNode< BarnesHutNode > > | |
| CArray< RawPtr< Aggregate > > | |
| CArray< TimerEntry > | |
| CArray< std::pair< CurvePoint, bool > > | |
| CArray< BodyMetadata > | |
| CArray< Type > | |
| CArray< Col > | |
| CArray< WeakPtr< Storage > > | |
| CArray< ExtendedEnum > | |
| CArray< Ghost > | |
| CArray< Function > | |
| CArray< AutoPtr< IColorizer > > | |
| CArray< AutoPtr< IDiagnostic > > | |
| CArray< char > | |
| CArray< Local > | |
| CArray< Triangle > | |
| CArray< BvhSphere > | |
| CArray< SharedPtr< Unit > > | |
| CArray< TBvhObject > | |
| CArray< FlatMap::Element > | |
| CArray< AutoPtr< IAsymmetricDerivative > > | |
| CArray< Group > | |
| CArray< LockingPtr< IPlot > > | |
| CArray< AutoPtr< IPlot > > | |
| CArray< AutoPtr< ILogger > > | |
| CArray< Array< BasicVector > > | |
| CArray< BvhNode > | |
| CArray< NeighbourRecord > | |
| CArray< IRenderOutput::Label > | |
| CArray< CollisionRecord > | |
| CArray< SharedPtr< IEquationTerm > > | |
| CBitmap< std::string > | |
| CBitmap< Rgba > | |
| CBvh< BvhTriangle > | |
| CBvh< BvhSphere > | |
| CFlatMap< wxPGProperty *, IVirtualEntry * > | |
| CFlatMap< std::string, Variant > | |
| CFlatMap< TEnum, Entry > | |
| CFlatMap< BodySettingsId, Dynamic > | |
| CFlatMap< GuiSettingsId, Entry > | |
| CFlatMap< QuantityId, Particle::InternalQuantityData > | |
| CFlatMap< QuantityId, Quantity > | |
| CFlatMap< CollisionGeometrySettingsId, Entry > | |
| CFlatMap< RunSettingsId, Entry > | |
| CFlatMap< StatisticsId, Variant > | |
| CFlatMap< QuantityId, Interval > | |
| CFlatMap< GalaxySettingsId, Entry > | |
| CFlatMap< NBodySettingsId, Entry > | |
| CFlatMap< PanelId, wxAuiPaneInfo * > | |
| CFlatMap< wxCheckBox *, PlotEnum > | |
| CFlatMap< Optional, FlatMap, CompareEnums > | |
| CFlatMap< QuantityId, InternalQuantityData > | |
| CFlatMap< std::string, Palette > | |
| CFlatMap< RunPage *, RunData > | |
| CFlatMap< QuantityId, Float > | |
| CFlatMap< Size, SharedPtr< TemporalPlot > > | |
| CFlatMap< BodySettingsId, Entry > | |
| CFlatSet< Size > | |
| CFlatSet< AutoPtr< IDerivative >, Less > | |
| CFlatSet< RawPtr< IAcceleration > > | |
| ►CKernel< CubicSpline< D >, D > | |
| CCubicSpline< D > | Cubic spline (M4) kernel |
| ►CKernel< LutKernel< D >, D > | |
| CLutKernel< Dim > | |
| CLutKernel< 2 > | |
| CLutKernel< DIMENSIONS > | |
| CLutKernel< 3 > | |
| CLutKernel< D > | A look-up table approximation of the kernel |
| ►CKernel< SolidSphereKernel, 3 > | |
| CSolidSphereKernel | Gravity kernel of a solid sphere |
| ►CKernel< WendlandC6, 3 > | |
| CWendlandC6 | |
| ►CKernel< ScalingKernel< D, TKernel >, D > | |
| CScalingKernel< D, TKernel > | Helper kernel wrapper that modifies the support of another kernel |
| ►CKernel< FourthOrderSpline< D >, D > | |
| CFourthOrderSpline< D > | Fourth-order spline (M5) kernel |
| ►CKernel< Gaussian< D >, D > | |
| CGaussian< D > | Gaussian kernel |
| ►CKernel< CoreTriangle, 3 > | |
| CCoreTriangle | Kernel proposed by Read et al. (2010) with improved stability |
| ►CKernel< WendlandC2, 3 > | |
| CWendlandC2 | |
| ►CKernel< WendlandC4, 3 > | |
| CWendlandC4 | |
| ►CKernel< ThomasCouchmanKernel< D >, D > | |
| CThomasCouchmanKernel< D > | Kernel introduced by Thomas & Couchman (1992) |
| ►CKernel< GravityKernel< CubicSpline< 3 > >, 3 > | |
| ►CGravityKernel< CubicSpline< 3 > > | |
| CGravityKernel< ThomasCouchmanKernel< 3 > > | ThomasCouchmanKernel differs from CubicSpline only in the gradient, so the GravityKernel is the same |
| ►CKernel< TriangleKernel< D >, D > | |
| CTriangleKernel< D > | Triangular (piecewise linear) kernel |
| CList< Size > | |
| CList< AutoPtr< ITrigger > > | |
| CLut< Float > | |
| CQueue< PlotPoint > | |
| CUnorderedMap< std::string, SharedPtr< ConfigNode > > | |
| CUnorderedMap< std::string, SharedPtr< JobNode > > | |
| CUnorderedMap< std::string, AutoPtr< IVirtualEntry > > | |
| CUnorderedMap< SharedPtr< JobNode >, VisNode > | |
| CUnorderedMap< std::string, JobContext > | |
| CUnorderedMap< std::string, VirtualSettings::Category > | |
| CUnorderedMap< std::string, std::string > | |
| CAggregate | Aggregate of particles, moving as a rigid body according to Euler's equations |
| CAggregateHolder | Holds a set of aggregates |
| CArray< T, TAllocator, TCounter > | Generic dynamically allocated resizable storage |
| CBarnesHut::NodeTask | |
| CBenzAsphaugRng | Random number generator used in code SPH5 of Benz & Asphaug (1994) |
| CBitmap< Type > | |
| CBvh< TBvhObject > | Simple bounding volume hierarchy |
| CCompressedStorage | Reduced information |
| CDeserializer< Precise > | Object for reading serialized primitives from input stream |
| CFileSystem::DirectoryAdapter | Object providing begin and end directory iterator for given directory path |
| CFlatMap< TKey, TValue, TLess > | Container of key-value pairs |
| CFlatSet< T, TLess > | |
| CFrameBuffer | |
| CHaltonQrng | Quasi-random number generator |
| ►CIInterpolant< Type > | Interface for computing quantity at any point in space |
| ►CSphInterpolant< Type > | Object for computing interpolated values of quantities |
| CCorrectedSphInterpolant< Type > | Computes corrected interpolated value |
| ►CILogger | Interface providing generic (text, human readable) output of the program |
| CFileLogger | File output logger |
| CMultiLogger | Class holding multiple loggers and writing messages to all of them |
| CNullLogger | Helper logger that does not write anything |
| CStdOutLogger | Standard output logger |
| CStringLogger | Logger writing messages to string stream |
| CInitialConditions | Object for adding one or more bodies with given material into a Storage |
| CIntegrator< TRng, TInternal > | Object for integrating a generic three-dimensional scalar function |
| ►CKdNode | Base class for nodes of K-d tree |
| CBarnesHutNode | |
| CKernel< TDerived, D > | Base class for all SPH kernels |
| CList< T, TAllocator > | Doubly-linked list |
| CLookupMap | |
| CLut< TValue, TScalar > | Callable representing a generic R->T function, approximated using look-up table |
| CMovie | Object managing periodic rendering of images and saving them to given paths |
| COrder | Permutation, i.e. (discrete) invertible function int->int |
| CPointCloud | Container of points with optimized search queries |
| CQuantity | Generic container for storing scalar, vector or tensor quantity and its derivatives |
| CQueue< T, TCounter > | Container allowing to add and remove elements from both ends |
| CRandomPathManager | Generates random file names |
| CSerializer< Precise > | Object providing serialization of primitives into a stream |
| CSph::MemoryPool< T, ChunkSize > | |
| CStorage | Container storing all quantities used within the simulations |
| CSubRange< TIterator > | |
| CTexture | |
| CTimerThread | |
| CUniformRng | Random number generator with uniform distribution |
| CUniquePathManager | Object generating unique paths |
| CUnorderedMap< TKey, TValue > | |
| CVectorPdfRng< TScalarRng > | Generic generator of random vectors using sampling with given PDF |
| CVectorRng< TScalarRng > | Wrapper for generating random vectors |
| CVerboseLogGuard | RAII guard writing called functions and their durations to a special verbose logger |
| CNothingType | |
| CNullInserter | Helper output iterator that simply ignores the written values |
| CNumericLimits< TValue > | Helper class, used to avoid including large header limits.h |
| CNumericLimits< uint32_t > | |
| CNumericLimits< uint64_t > | |
| COctreeNode< T > | |
| COperatorTemplate< TDerived > | Class defining additional operators from existing ones |
| ►COperatorTemplate< AffineMatrix2 > | |
| CAffineMatrix2 | 2D affine matrix |
| ►COperatorTemplate< PlotPoint > | |
| ►CPlotPoint | Point in 2D plot |
| CErrorPlotPoint | Point with error bars |
| COptional< Type > | Wrapper of type value of which may or may not be present |
| COptional< BodyData > | |
| COptional< float > | |
| COptional< Float > | |
| COptional< HandoffParams::LargestRemnant > | |
| COptional< int > | |
| COptional< Interval > | |
| COptional< NodeSlot > | |
| COptional< Palette > | |
| COptional< Particle > | |
| COptional< PathType > | |
| COptional< Pixel > | |
| COptional< RadiiHashMap > | |
| COptional< RenderParams > | |
| COptional< RunTypeEnum > | |
| COptional< Size > | |
| COptional< std::string > | |
| COptional< std::type_index > | |
| COptional< TError > | |
| COptional< TicsParams > | |
| COutcomeTraits< TError > | Utility functions used within BasicOutcome |
| COutcomeTraits< std::string > | |
| CMomentOperators::OuterProduct< Order > | |
| COutputFile | Helper file generating file names for output files |
| COverPixelOp | |
| COverridePixelOp | |
| CParticlePairingDiagnostic::Pair | |
| CPalette | Represents a color palette, used for mapping arbitrary number to a color |
| CPaletteDesc | |
| CParticle::ParamData | Stored info about a material parameter |
| CParticle::ParamIterator | |
| CFixedParticles::Params | |
| CTemporalPlot::Params | Parameters of the plot |
| CParticle::ParamSequence | Helper for enumerating all stored parameters |
| CDetail::ParamTraits< TArgs > | |
| CDetail::ParamTraits< TArg > | |
| CParticle | Object holding information about single particle |
| CParticleData | |
| CParticleVisitor | |
| CPath | Object representing a path on a filesystem |
| CPerElementWrapper< TContainer > | |
| CMomentOperators::Permutations< N1, N2, Value1, Value2 > | |
| CMomentOperators::Permutations< 0, N, Value1, Value2 > | |
| CMomentOperators::Permutations< 1, 2, Value1, Value2 > | |
| CMomentOperators::Permutations< 2, 1, Value1, Value2 > | |
| CMomentOperators::Permutations< 2, 2, Value1, Value2 > | |
| CMomentOperators::Permutations< 3, 1, Value1, Value2 > | |
| CMomentOperators::Permutations< N, 0, Value1, Value2 > | |
| CPkdgravParams | |
| CPlotData | |
| CPalette::Point | |
| ►CPolymorphic | Base class for all polymorphic objects |
| ►CIIntegral< MinMaxMean > | |
| CQuantityMeans | Returns means of given scalar quantity |
| ►CIIntegral< Float > | |
| CIntegralWrapper | Helper integral wrapping another integral and converting the returned value to scalar |
| CQuantityValue | Returns the quantity value of given particle |
| CRelativeEnergyChange | |
| CSelectedParticleIntegral | |
| CTotalEnergy | Returns the total energy of all particles |
| CTotalInternalEnergy | Returns the total internal energy of all particles |
| CTotalKineticEnergy | Returns the total kinetic energy of all particles |
| CTotalMass | Computes the total mass of all SPH particles |
| ►CIIntegral< Vector > | |
| CCenterOfMass | Computes the center of mass of particles |
| CTotalAngularMomentum | Computes total angular momentum of all SPH particles with a respect to the reference frame |
| CTotalMomentum | Computes total momentum of all SPH particles with a respect to the reference frame |
| CComponentChecker | |
| ►CDerivativeHolder | Container holding derivatives and the storage they accumulate to |
| CAccelerationSeparatingHolder | Derivative holder, splitting the registered derivatives into accelerations and the rest |
| CDetail::Callable< TReturn(TArgs...)> | |
| ►CDetail::Cloner | |
| CDetail::TypedCloner< T > | |
| ►CDetail::ControlBlockHolder | |
| ►CDetail::ControlBlock< T > | |
| CDetail::LockingControlBlock< IPlot > | |
| CDetail::LockingControlBlock< SelectedParticlePlot > | |
| CDetail::LockingControlBlock< T, TMutex > | |
| CDetail::TokenBlock | |
| ►CGalaxy::IProgressCallbacks | |
| CGalaxy::NullProgressCallbacks | |
| CGalaxyCallbacks | |
| CIAsymmetricTerm | |
| ►CIBasicFinder | Interface of objects finding neighbouring particles |
| ►CISymmetricFinder | Extension of IBasicFinder, allowing to search only particles with lower rank in smoothing length |
| ►CFinderTemplate< UniformGridFinder > | |
| CUniformGridFinder | Finder projecting a uniform grid on the particles |
| ►CFinderTemplate< KdTree< TNode, EuclideanMetric > > | |
| CKdTree< TNode, TMetric > | K-d tree, used for hierarchical clustering of particles and accelerated Kn queries |
| ►CFinderTemplate< BruteForceFinder > | |
| CBruteForceFinder | Searches for neighbours by 'brute force', comparing every pair of vectors |
| ►CFinderTemplate< HashMapFinder > | |
| CHashMapFinder | |
| ►CFinderTemplate< KdTree< BarnesHutNode, EuclideanMetric > > | |
| CKdTree< BarnesHutNode > | |
| CFinderTemplate< TDerived > | Helper template, allowing to define all three functions with a single function |
| CPeriodicFinder | Finder wrapper respecting periodic domain |
| ►CIBoundaryCondition | Base object for boundary conditions |
| CFixedParticles | Places immovable particles along boundary |
| ►CFrozenParticles | Boundary condition that nulls all highest derivates of selected particles |
| CWindTunnel | Boundary conditions creating particles with given velocity at the boundary of the domain |
| CGhostParticles | Adds ghost particles symmetrically for each SPH particle close to boundary |
| CKillEscapersBoundary | Boundary condition that removes particles outside the domain |
| CNullBoundaryCondition | |
| CPeriodicBoundary | Boundary condition moving all particles passed through the domain to the other side of the domain |
| CProjection1D | Helper tool for 1D tests, projects all particles onto a 1D line |
| CSodBc | |
| CSymmetricBoundary | Boundary duplicating particles along z=0 plane |
| ►CIBrdf | |
| CHapkeBrdf | |
| CLambertBrdf | |
| CPhongBrdf | |
| ►CICamera | Interface defining a camera or view, used by a renderer |
| COrthoCamera | Orthographic camera |
| ►CPanoCameraBase | Common base for panoramic cameras |
| CFisheyeCamera | Fisheye camera |
| CSphericalCamera | Spherical camera |
| CPerspectiveCamera | Perspective camera |
| ►CICollisionHandler | Abstraction of collision outcome |
| CAggregateCollisionHandler | |
| CElasticBounceHandler | Handler for bounce on collision |
| CFallbackHandler< TPrimary, TFallback > | Composite handler, choosing another collision handler if the primary handler rejects the collision by returning CollisionResult::NONE |
| CFragmentationHandler | |
| CMergingCollisionHandler | Handler merging particles into a single, larger particles |
| CNullCollisionHandler | Helper handler always returning CollisionResult::NONE |
| ►CIColorMap | |
| CFilmicColorMap | |
| CLogarithmicColorMap | |
| ►CIColorizer | Interface for objects assigning colors to particles |
| ►CIdColorizerTemplate< AggregateIdColorizer > | |
| CAggregateIdColorizer | |
| ►CIdColorizerTemplate< IndexColorizer > | |
| ►CIndexColorizer | |
| CMaterialColorizer | |
| ►CIdColorizerTemplate< ParticleIdColorizer > | |
| CParticleIdColorizer | |
| ►CIdColorizerTemplate< ComponentIdColorizer > | |
| CComponentIdColorizer | |
| ►CTypedColorizer< Float > | |
| CGravityColorizer | |
| CTemperatureColorizer | |
| CYieldReductionColorizer | |
| ►CTypedColorizer< Vector > | |
| CAccelerationColorizer | Displays the magnitudes of accelerations |
| CRadiusColorizer | |
| CVelocityColorizer | Displays the magnitudes of particle velocities |
| CBeautyColorizer | |
| CBoundaryColorizer | Shows boundary of bodies in the simulation |
| CCorotatingVelocityColorizer | Shows particle velocities with subtracted corotating component |
| CDamageActivationColorizer | |
| CDensityPerturbationColorizer | |
| CDirectionColorizer | Shows direction of particle movement in color |
| CEnergyColorizer | |
| CIdColorizerTemplate< TDerived > | |
| CStressColorizer | |
| CSummedDensityColorizer | |
| CTypedColorizer< Type > | Default colorizer simply converting quantity value to color using defined palette |
| CUvwColorizer | |
| ►CIConfigValue | Interface for value written to the config file |
| CConfigValue< Type > | Generic implementation of IConfigValue, using std::stringstream for the (de)serialization |
| CConfigValue< Interval > | |
| CConfigValue< Path > | |
| CConfigValue< Vector > | |
| CConfigValue< std::string > | |
| ►CIDerivative | Derivative accumulated by summing up neighbouring particles |
| CCorrectionTensor | |
| ►CIAsymmetricDerivative | Special derivative evaluated by GradHSolver |
| CAsymmetricPressureGradient | |
| ►CISymmetricDerivative | Extension of derivative, allowing a symmetrized evaluation |
| ►CDerivativeTemplate< Derivative > | |
| CArtificialConductivity::Derivative | |
| ►CDerivativeTemplate< ColorFieldDerivative > | |
| CColorFieldDerivative | Computes the color field of the fluid |
| ►CDerivativeTemplate< EnergyLaplacian > | |
| CEnergyLaplacian | |
| ►CDerivativeTemplate< VelocityTemplate< Id, Discr, Traits > > | |
| CVelocityTemplate< Id, Discr, Traits > | |
| ►CDerivativeTemplate< DisplacementGradient > | |
| CDisplacementGradient | Derivative computing components of stress tensor from known displacement vectors |
| ►CDerivativeTemplate< DensityIndependentPressureGradient > | |
| CDensityIndependentPressureGradient | |
| ►CDerivativeTemplate< RenormalizedDensityGradient > | |
| CDeltaSph::RenormalizedDensityGradient | |
| CDerivativeTemplate< TDerived > | Helper template for derivatives that define both the symmetrized and asymmetric variant |
| ►CIAcceleration | Extension of derivative allowing to compute pair-wise acceleration for each neighbour |
| ►CAccelerationTemplate< Derivative< Discr > > | |
| CStressAV::Derivative< Discr > | |
| ►CAccelerationTemplate< CohesionDerivative > | |
| CCohesionDerivative | |
| ►CAccelerationTemplate< Derivative > | |
| CMorrisMonaghanAV::Derivative | |
| CRiemannAV::Derivative | |
| CStandardAV::Derivative | |
| ►CAccelerationTemplate< StressDivergence< Discr > > | |
| CStressDivergence< Discr > | |
| ►CAccelerationTemplate< PressureGradient< Discr > > | |
| CPressureGradient< Discr > | |
| CAccelerationTemplate< TDerived > | Helper template specifically used to implement forces |
| ►CIDiagnostic | Base class of diagnostics of the run |
| CCourantInstabilityDiagnostic | Checks for excessively large magnitudes of acceleration, indicating a numerical instability |
| COvercoolingDiagnostic | Checks for clamping of excesivelly low values of internal energy |
| CParticlePairingDiagnostic | Checks for particle pairs, indicating a pairing instability |
| CSmoothingDiscontinuityDiagnostic | Checks for large differences of smoothing length between neighbouring particles |
| ►CIDistribution | Base class for generating vertices with specific distribution |
| CCubicPacking | Cubic close packing |
| CDiehlDistribution | Distribution with given particle density |
| CDistribution | |
| CHexagonalPacking | Hexagonal close packing |
| CKelvinHelmholtzDistribution | |
| CLinearDistribution | Generates particles uniformly on a line in x direction, for testing purposes |
| CParametrizedSpiralingDistribution | Parametrized spiraling scheme by Saff & Kuijlaars (1997) |
| CPlanarDistribution | |
| CRandomDistribution | Generating random positions withing the domain |
| CStratifiedDistribution | Generates random positions using stratified sampling |
| ►CIDomain | Base class for computational domains |
| CBlockDomain | Block aligned with coordinate axes, defined by its center and length of each side |
| CBooleanDomain | |
| CCylindricalDomain | Cylinder aligned with z-axis, optionally including bases (can be either open or close cylinder) |
| CElasticBands::SubtractDomain | |
| CEllipsoidalDomain | Axis aligned ellipsoidal domain, defined by the center of sphere and lengths of three axes |
| CGaussianRandomSphere | See Muinonen 1998 |
| CHalfSpaceDomain | Domain representing a half-space, given by z>0 |
| CHexagonalDomain | Similar to cylindrical domain, but bases are hexagons instead of circles |
| CInvertDomain | |
| CMeshDomain | Domain represented by triangular mesh |
| CSphDomain | Domain represented by SPH particles |
| CSpheresDomain | |
| CSphericalDomain | Spherical domain, defined by the center of sphere and its radius |
| CSubtractDomain | |
| CTransformedDomain | Transform another domain by given transformation matrix |
| ►CIDrawPath | |
| CGraphicsPath | |
| CSvgPath | |
| CTextContext::TextPath | |
| ►CIDrawingContext | Abstraction of a drawing context |
| CGraphicsContext | Drawing context using wxWidgets implementation of Cairo backend |
| CSvgContext | |
| CTextContext | |
| ►CIEnergyPartitioner | Abstraction of the |
| CBlendingPartitioner< TPrimary, TSecondary > | |
| CEquipartitioner | |
| CMonotonicDiminishingPartitioner | |
| CSmoothlyDiminishingPartitioner | |
| ►CIEos | Base class for equations of state |
| CAneos | ANEOS equation defined by a look-up table |
| CIdealGasEos | Equation of state for ideal gas |
| CMieGruneisenEos | Mie-Gruneisen equation of state |
| CMurnaghanEos | Murnaghan equation of state |
| CSimplifiedTillotsonEos | Simplified Tillotsons equation of state, valid for small pressures and energies |
| CTaitEos | Tait equation of state |
| CTillotsonEos | Tillotson equation of state [15] |
| CVanDerWaalsEos | |
| ►CIEquationTerm | Represents a term or terms appearing in evolutionary equations |
| CAdaptiveSmoothingLength | Evolutionary equation for the (scalar) smoothing length |
| CArtificialConductivity | Artificial thermal conductivity |
| CBalsaraSwitch< AV > | Implementation of the Balsara switch [2], designed to reduce artificial viscosity in shear flows and avoid numerical issues, such as unphysical transport of angular momentum |
| CChaiScriptTerm | |
| CCohesionTerm | |
| CConstSmoothingLength | Helper term to keep smoothing length constant during the simulation |
| CContinuityEquation | Equation for evolution of density |
| CDeltaSph::DensityDiffusion | Numerical diffusion of density |
| CDeltaSph::VelocityDiffusion | Numerical diffusion of velocity |
| CDensityIndependentPressureForce | |
| CDisplacementTerm | |
| CExternalForce< TFunctor > | Generic external force given by lambda function |
| CHeatDiffusionEquation | |
| CInertialForce | Centrifugal and Coriolis force |
| CMorrisMonaghanAV | Time-dependent artificial viscosity with non-homogeneous oefficients alpha and beta |
| CNaiveViscosity | |
| CNavierStokesForce | Navier-Stokes equation of motion |
| CNeighbourCountTerm | Helper term counting the number of neighbours of each particle |
| CPressureForce | Equation of motion due to pressure gradient |
| CRadiativeCooling | |
| CRiemannAV | Artificial viscosity based on Riemann solver |
| CSimpleDamping | |
| CSolidStressForce | Equation of motion for solid body and constitutive equation for the stress tensor (Hooke's law) |
| CSphericalGravityEquation | Implements IEquationTerm interface using SphericalGravity |
| CStandardAV | Standard artificial viscosity Monaghan & Gingold [9] |
| CStressAV | Artificial stress for simulations including stress tensor |
| CSurfaceNormal | Term computing normals of free surface |
| CTests::SingleDerivativeMaker< TDerivative > | |
| CViscousStress | Flebbe et al. (1994) |
| CXSph | XSPH correction that (partially) averages the velocities over neighbouring particles |
| CYorpSpinup | |
| ►CIExtraEntry | Provides an interface for implementing new types of entries |
| CCurveEntry | Special entry allowing to access and (de)serialize a curve |
| ►CIFractureModel | Interface representing a fragmentation model |
| CNullFracture | |
| CScalarGradyKippModel | Scalar damage describing fragmentation of the body according to Grady-Kipp model (Grady and Kipp, 1980) |
| CTensorGradyKippModel | |
| ►CIGravity | Interface for computing gravitational interactions of particles |
| CBarnesHut | Multipole approximation of distance particle |
| CBruteForceGravity | Computes gravitational acceleration by summing up forces from all particle pairs |
| CCachedGravity | Wrapper of other IGravity implementation that approximates the gravity using cached values |
| CSphericalGravity | Spherically symmetrized gravitational force |
| CSymmetricGravity | |
| ►CIInput | Interface for loading quantities of SPH particles from a file |
| CBinaryInput | Input for the binary file, generated by BinaryOutput |
| CCompressedInput | |
| CHdf5Input | Reader of HDF5 files generated by the code miluphcuda |
| CMpcorpInput | Reads data from Minor Planet Center Orbit Database exports |
| CPkdgravInput | Input for pkdgrav output files (ss.xxxxx.bt) |
| CTabInput | Simple text input file, having particle masses, positions and velocities on separate lines |
| CTextInput | Input for the text file, generated by TextOutput or conforming to the same format |
| CIIntegral< Type > | Interface for classes computing integral quantities from storage |
| ►CIJob | Base class for all object performing an operation in a simulation hierarchy |
| ►CICameraJob | |
| CFisheyeCameraJob | |
| COrthoCameraJob | |
| CPerspectiveCameraJob | |
| ►CIGeometryJob | Base class for jobs providing a geometric shape |
| CBlockJob | |
| CBooleanGeometryJob | |
| CCylinderJob | |
| CEllipsoidJob | |
| CGaussianSphereJob | |
| CHalfSpaceJob | |
| CInvertGeometryJob | |
| CMaclaurinSpheroidJob | |
| CMeshGeometryJob | |
| CParticleGeometryJob | |
| CSphereJob | |
| CSpheresGeometryJob | |
| CTransformGeometryJob | |
| ►CIMaterialJob | Base class for jobs providing a material |
| CDisableDerivativeCriterionJob | |
| CMaterialJob | |
| ►CINullJob | Base class for jobs providing no data |
| CAnimationJob | |
| CVdbJob | |
| ►CIParticleJob | Base class for all jobs providing particle data |
| CBatchJob | |
| CCenterParticlesJob | |
| CChangeMaterialJob | |
| CCollisionGeometrySetup | |
| CCompareJob | |
| CDifferentiatedBodyIc | Creates a single differentiated body |
| CEmplaceComponentsAsFlagsJob | |
| CEquilibriumIc | |
| CExtractComponentJob | |
| CExtractParticlesInDomainJob | |
| CFileSequenceJob | |
| CGalaxyIc | |
| ►CIRunJob | Base class for jobs running a simulation |
| CNBodyJob | |
| ►CSphJob | |
| CSphStabilizationJob | |
| CIsothermalSphereIc | |
| CJoinParticlesJob | |
| CLoadFileJob | |
| CMergeComponentsJob | |
| CModifyQuantityIc | |
| CMonolithicBodyIc | Creates a single monolithic body |
| CMultiJoinParticlesJob | |
| CNBodyIc | |
| CNoiseQuantityIc | |
| COrbitParticlesJob | |
| CPolytropicStarIc | |
| CRemoveParticlesJob | |
| CSaveFileJob | |
| CSaveMeshJob | |
| CSingleParticleIc | |
| CSmoothedToSolidHandoff | |
| CSubsampleJob | |
| CTransformParticlesJob | |
| ►CIJobData | |
| CJobData< TValue > | |
| CIJobDesc | Provides a descriptor of a job that allows to create new instances |
| CILogger | Interface providing generic (text, human readable) output of the program |
| ►CIMaterial | Material settings and functions specific for one material |
| ►CEosMaterial | Material holding equation of state |
| CSolidMaterial | Generalization of material with equation of state |
| ►CNullMaterial | Material that does not require any initialization or finalization |
| CCustomMaterial | |
| ►CIMeshFile | Interface for mesh exporters |
| CObjFile | Text format containing mesh vertices (prefixed by 'v') and triangle indices (prefixed by 'f') |
| CPlyFile | Exports meshes into a Polygon File Format (.ply file) |
| CTabFile | Simple text format containing mesh vertices and triangle indices |
| ►CINode | Provides an interface for running a simulation |
| CJobNode | Building block of a simulation hierarchy |
| ►CINodeManagerCallbacks | |
| CNodeManagerCallbacks | |
| ►CIOutput | Interface for saving quantities of SPH particles to a file |
| CBinaryOutput | Output saving data to binary data without loss of precision |
| CCompressedOutput | |
| CNullOutput | |
| CPkdgravOutput | Dumps data into a file that can be used as an input for pkdgrav code by Richardson et al |
| CSodOutput | |
| ►CTextOutput | Output saving data to text (human readable) file |
| CGnuplotOutput | Extension of text output that runs given gnuplot script on dumped text data |
| CVtkOutput | XML-based output format used by Visualization ToolKit (VTK) |
| ►CIOutputTime | |
| CCustomOutputTime | |
| CLinearOutputTime | |
| CLogarithmicOutputTime | |
| ►CIOverlapHandler | Handles overlaps of particles |
| CAggregateOverlapHandler | |
| CInternalBounceHandler | Overlap handler performing a bounce of particles |
| CMergeBoundHandler | Handler merging overlapping particles if their relative velocity is lower than the escape velocity |
| CMergeOverlapHandler | Handler unconditionally merging the overlapping particles |
| CNullOverlapHandler | Handler simply ignoring overlaps |
| CRepelHandler< TFollowupHandler > | Handler displacing the overlapping particles so that they just touch |
| ►CIPlot | Interface for constructing generic plots from quantities stored in storage |
| ►CSpatialPlot< RadialDistributionPlot > | |
| CRadialDistributionPlot | Plots a dependence of given quantity on the distance from the origin |
| ►CSpatialPlot< AxialDistributionPlot > | |
| CAxialDistributionPlot | Plots a dependence of given quantity on the distance from given axis |
| CAngularHistogramPlot | Differential histogram of angular distribution |
| CDataPlot | Plots given array of points |
| CHistogramPlot | Differential histogram of quantities |
| CMultiPlot | Helper object used for drawing multiple plots into the same device |
| CSelectedParticlePlot | Temporal plot of currently selected particle |
| CSfdPlot | |
| CSpatialPlot< TDerived > | Base class for plots showing a dependence of given quantity on a spatial coordinate |
| CTemporalPlot | Plot of temporal dependence of a scalar quantity |
| ►CIRenderContext | Abstraction of a device used for rendering |
| ►CPreviewRenderContext< OverPixelOp > | |
| ►CAntiAliasedRenderContext | |
| CSmoothedRenderContext | |
| CFlippedRenderContext | |
| CPreviewRenderContext< PixelOp > | |
| CWxRenderContext | Render context drawing directly into wxDC |
| ►CIRenderOutput | |
| CBitmapOutput | |
| CMovieRenderOutput | |
| ►CIRenderPreview | |
| CRenderPreview | |
| ►CIRenderer | Interface used to implement renderers |
| CContourRenderer | |
| ►CIRaytracer | Base class for renderers based on raytracing |
| CRayMarcher | |
| CVolumeRenderer | |
| CMeshRenderer | |
| CParticleRenderer | |
| ►CIRheology | Base class of rheological models |
| CDruckerPragerRheology | Pressure dependent failure modes [5] |
| CElasticRheology | Perfectly elastic material, no yielding nor fragmentation |
| CVonMisesRheology | Introduces plastic behavior for stress tensor, using von Mises yield criterion [16] |
| ►CIRng | Polymorphic holder allowing to store any RNG (type erasure) |
| CRngWrapper< TRng > | |
| ►CIRun | Defines the interface for a run |
| CBoundaryRun | |
| CCliffCollapse | |
| CCollision | |
| CCollision | |
| CDeathStar | |
| CElasticBands | |
| CFragmentation | |
| CGalaxyRun | |
| CHde | |
| CHelloAsteroid | |
| CKelvinHelmholtz | |
| CNBodyRun | |
| CReaccumulation | |
| CRotatingRod | |
| CSedov | |
| CSimpleRun | |
| CSod | |
| ►CSphRun | |
| CSphStabilizationRun | |
| CVanDerWallsSimulation | |
| ►CIRunCallbacks | Callbacks executed by the simulation to provide feedback to the user |
| ►CIJobCallbacks | Interface used during job evaluation |
| CController | Main GUI class connection the simulation with UI controls |
| ►CNullJobCallbacks | |
| CUpdateCameraCallbacks | |
| CNullRunCallbacks | |
| CIScalarField | Inferface for a generic scalar field, returning a float for given position.:w |
| ►CIScheduler | Interface that allows unified implementation of sequential and parallelized versions of algorithms |
| COmpScheduler | Scheduler encapsulating OpenMP directives |
| CSequentialScheduler | Dummy scheduler that simply executes the submitted tasks sequentially on calling thread |
| CTbb | Scheduler encapsulating Intel Thread Building Blocks (TBB) |
| CThreadPool | Thread pool capable of executing tasks concurrently |
| ►CISolver | Base class for all solvers |
| CSymmetricSolver< DIMENSIONS > | |
| CDensityIndependentSolver | Density-independent SPH solver |
| CElasticDeformationSolver | |
| ►CHardSphereSolver | Solver computing gravitational interactions of hard-sphere particles |
| CAggregateSolver | |
| CHdeSolver | |
| ►CIAsymmetricSolver | Base class for asymmetric SPH solvers |
| ►CAsymmetricSolver | Generic SPH solver, evaluating equations for each particle separately |
| CGradHSolver | |
| CEnergyConservingSolver | See Owen 2009: A compatibly differenced total energy conserving form of SPH |
| CSimpleSolver | Minimalistic SPH solver, mainly used for benchmarking and educational purposes |
| CSoftSphereSolver | Solver computing gravitational interactions and repulsive forces between particles |
| CStabilizationSolver | Helper solver used to converge into stable initial conditions |
| ►CSymmetricSolver< Dim > | Basic solver for integration of SPH equations |
| CSummationSolver< Dim > | SPH solver using density and specific energy as independent variables |
| ►CIStorageUserData | Base class for arbitrary data stored in the storage alongside particles |
| CGhostParticlesData | Provides a way to access ghost particle data outside the solver |
| ►CIAggregateObserver | Holds aggregate data stored in the storage and used by the solver |
| CAggregateHolder | Holds a set of aggregates |
| ►CITask | Handle used to control tasks submitted into the scheduler |
| CSequentialTaskHandle | |
| CTask | Task to be executed by one of available threads |
| ►CITextColumn | Base class for conversion of quantities into the output data |
| CDamageColumn< TValue > | Prints actual values of scalar damage |
| CDerivativeColumn< TValue > | Returns first derivatives of given quantity as stored in storage |
| CParticleNumberColumn | Helper column printing particle numbers |
| CSecondDerivativeColumn< TValue > | Returns second derivatives of given quantity as stored in storage |
| CSmoothingLengthColumn | Returns smoothing lengths of particles |
| CTimeColumn | Helper column printing current run time. This value is the same for every particle |
| CValueColumn< TValue > | Returns values of given quantity as stored in storage |
| ►CITimeLineCallbacks | |
| CTimeLineCallbacks | |
| ►CITimeStepCriterion | Base class for timestep setters |
| CAccelerationCriterion | Criterion setting time step based on computed acceleration of particles |
| CCourantCriterion | Time step based on CFL criterion |
| CDerivativeCriterion | Criterion setting time step based on value-to-derivative ratio for time-dependent quantities |
| CDivergenceCriterion | Criterion computing time step from velocity divergence |
| CMultiCriterion | Helper criterion, wrapping multiple criteria under ITimeStepCriterion interface |
| ►CITimeStepping | Base object providing integration in time for all quantities |
| CBulirschStoer | |
| CEulerExplicit | Simple Euler first-order timestepping |
| CLeapFrog | Leapfrog timestepping |
| CModifiedMidpointMethod | |
| CPredictorCorrector | Predictor-corrector second-order timestepping |
| CRungeKutta | |
| ►CITracker | |
| CMedianTracker | |
| CParticleTracker | |
| ►CITrigger | Interface for triggering generic actions during the run |
| ►CPeriodicTrigger | Trigger executing given action every period |
| CAngularMomentumLog | |
| CDiagnosticsTrigger | |
| ►CILogWriter | Base class for objects logging run statistics |
| CBriefLogWriter | Writer logging only basic run information |
| CEnergyLogWriter | |
| CIntegralsLogWriter | Writer logging selected integrals of motion |
| CLogWriter | Custom writer of simulation log |
| CNullLogWriter | Helper writer that does not write any logs |
| ►CStandardLogWriter | Writer logging useful statistics (current run time, relative progress, time step, ...) |
| CVerboseLogWriter | Extension of StandardLogWriter, printing additional information abount quantities |
| CProgressLog | |
| CProgressLogger | |
| CIUserQuantity | Interface for auxilirary user-defined scalar quantities |
| ►CIUvMapping | |
| CPlanarUvMapping | |
| CSphericalUvMapping | |
| ►CIVirtualEntry | Represents a virtual entry in the settings |
| ►CEntryControl | Helper object, allowing to add units, tooltips and additional properties into the entry created with VirtualSettings::Category::connect |
| CDetail::SettingsEntry< TValue, TEnum, TEnabler > | |
| CDetail::SettingsEntry< Path, TEnum > | Partial specialization for Path |
| CDetail::SettingsEntry< TValue, TEnum, std::enable_if_t< FlagsTraits< TValue >::isFlags > > | Partial specialization for Flags |
| CDetail::ValueEntry< TValue, typename > | |
| CDetail::ValueEntry< TValue, std::enable_if_t< FlagsTraits< TValue >::isFlags > > | |
| CIntervalEntry< TEnum > | Entry connecting to either lower or upper bound of an interval stored in settings |
| CJobContext | Data exchanged by jobs |
| ►CVirtualSettings::IEntryProc | Interface allowing to enumerate all entries in the settings |
| CAddParamProc | |
| CAddParamsProc | |
| CCopyEntriesProc | |
| CLoadProc | |
| CLoadProc | |
| CSaveProc | |
| CSetAccessorsProc | |
| ►CPositiveMean | Generalized mean with positive (runtime) power |
| CNegativeMean | Generalized mean with negative (runtime) power |
| CPowerLawSfd | Holds the information about a power-law size-frequency distributions |
| CPrinter | |
| CProcess | Holds a handle to a created process |
| CProcessedNode | Object used during traversal |
| CProject | |
| CProjectedPoint | Represents a particle projected onto image plane |
| CPropagateConst< TPtr > | Const-propagating wrapper for object with point semantics |
| CPropagateConst< AutoPtr< Impl > > | |
| CPropagateConst< AutoPtr< TbbData > > | |
| CPropertyGrid | |
| CLocking< T, TMutex >::Proxy | |
| CLockingPtr< T >::Proxy | |
| CLockingPtr< T >::ProxyRef | |
| CPseudoVectorTag | |
| CPost::QuadraticFunction | |
| CParticle::QuantityData | Stored info about a quantity |
| CBinaryInput::Info::QuantityInfo | Information about stored quantities |
| CParticle::QuantityIterator | Iterator used to enumerate all stored quantities |
| CQuantityMetadata | Auxiliary information about quantity that aren't stored directly in Quantity |
| CParticle::QuantitySequence | Helper for enumerating all stored quantities |
| CQuat | Quaternion representing an axis of rotation and a (half of) rotation angle |
| CRadiiHashMap | Helper structure storing search radii for particles as hash map |
| CRawPtr< T > | Non-owning wrapper of pointer |
| CRawPtr< AggregateHolder > | |
| CRawPtr< AnimationJob > | |
| CRawPtr< const IJob > | |
| CRawPtr< const Storage > | |
| CRawPtr< const VisNode > | |
| CRawPtr< Controller > | |
| CRawPtr< IGraphicsPane > | |
| CRawPtr< IMaterial > | |
| CRawPtr< IRunCallbacks > | |
| CRawPtr< JobNode > | |
| CRawPtr< ListNode > | |
| CRawPtr< ListNode< T > > | |
| CRawPtr< ParticleProbe > | |
| CRawPtr< RunPage > | |
| CRawPtr< Storage > | |
| CRay | |
| CReferenceWrapper< T > | Helper class for storing l-value references. Has a default constructor for convenient usage in containers |
| CReferenceWrapper< Type > | |
| CRegister | |
| CRegisterEnum< TEnum > | Helper class for adding individual enums to the enum map |
| CRenderParams | Parameters of the rendered image |
| CResult | |
| CReverseAdapter< TContainer > | |
| CReverseIterator< TIterator > | Generic reverse iterator over continuous array of objects of type T |
| CRgba | |
| CRotationTraits | |
| CRunFactory | |
| CRunParams | |
| CAssert::ScopedAssertExceptionEnabler | |
| CScopedConsole | |
| CScopedTimer | Timer that reports the measured duration when being destroyed |
| CFileSystem::ScopedWorkingDirectory | |
| CDetail::SelectNthType< I, N > | |
| CDetail::SelectNthType< N, N > | |
| CDetail::SerializedType< Precise, T, TEnabler > | Type trait for serialization/deserialization of types |
| CDetail::SerializedType< Precise, char[N]> | |
| CDetail::SerializedType< Precise, T, std::enable_if_t< std::is_floating_point< T >::value > > | |
| CDetail::SerializedType< Precise, T, std::enable_if_t< std::is_integral< T >::value||std::is_enum< T >::value > > | |
| CSession | |
| CSettings< TEnum > | Generic object containing various settings and parameters of the run |
| CSettings< BodySettingsId > | |
| CSettings< CollisionGeometrySettingsId > | |
| CSettings< GalaxySettingsId > | |
| ►CSettings< GuiSettingsId > | |
| CGuiSettings | |
| CSettings< NBodySettingsId > | |
| CSettings< RunSettingsId > | |
| CSettingsIterator< TEnum > | Iterator useful for iterating over all entries in the settings |
| CSharedPtr< T > | |
| CSharedPtr< AggregateHolder > | |
| CSharedPtr< Array< PlotData > > | |
| CSharedPtr< CameraData > | |
| CSharedPtr< Detail::Callable< TReturn(TArgs...)> > | |
| CSharedPtr< IColorizer > | |
| CSharedPtr< IDomain > | |
| CSharedPtr< IJobData > | |
| CSharedPtr< ILogger > | |
| CSharedPtr< IMaterial > | |
| CSharedPtr< INode > | |
| CSharedPtr< INodeManagerCallbacks > | |
| CSharedPtr< InteractiveRenderer > | |
| CSharedPtr< IPlot > | |
| CSharedPtr< IScalarField > | |
| CSharedPtr< IScheduler > | |
| CSharedPtr< IStorageUserData > | |
| CSharedPtr< ITimeLineCallbacks > | |
| CSharedPtr< JobNode > | |
| CSharedPtr< NodeManager > | |
| CSharedPtr< OmpScheduler > | |
| CSharedPtr< ParticleData > | |
| CSharedPtr< SelectedParticlePlot > | |
| CSharedPtr< Storage > | |
| CSharedPtr< Task > | |
| CSharedPtr< Tbb > | |
| CSharedPtr< TemporalPlot > | |
| CSharedPtr< ThreadPool > | |
| CSharedPtr< TValue > | |
| CSharedPtr< wxGraphicsContext > | |
| ►CSharedToken | |
| CNBodyJob | |
| CSphJob | |
| CShareFromThis< T > | |
| ►CShareFromThis< InteractiveRenderer > | |
| CInteractiveRenderer | |
| ►CShareFromThis< JobNode > | |
| CJobNode | Building block of a simulation hierarchy |
| ►CShareFromThis< Task > | |
| CTask | Task to be executed by one of available threads |
| CSlotData | |
| CSodConfig | |
| ►CSolverBase | |
| CEntropySolver | |
| CSparseGrid< T > | |
| CSparseMatrix | Sparse representation of matrix of arbitrary dimension |
| CSphere | |
| CSphericalCoords | |
| CStandardForceDiscr | Discretization of pressure term in standard SPH formulation |
| CStellar::Star | |
| CStaticArray< T, N, TCounter > | Array with fixed number of allocated elements |
| CStaticArray< BasicVector, 3 > | |
| CStaticArray< BasicVector, 8 > | |
| CStaticArray< ComponentProperty *, 2 > | |
| CStaticArray< ComponentProperty *, 3 > | |
| CStaticArray< float, 3 > | |
| CStaticArray< Float, 8 > | |
| CStaticArray< Float, DIMENSION_CNT > | |
| CStaticArray< int, dimension > | |
| CStaticArray< int, DIMENSION_CNT > | |
| CStaticArray< int, ntab > | |
| CStaticArray< Size, 3 > | |
| CDetail::StaticForType< N1, N2 > | |
| CDetail::StaticForType< N, N > | |
| CAnalytic::StaticSphere | Properties of a homogeneous sphere in rest (no temporal derivatives) |
| CStatistics | Object holding various statistics about current run |
| CStats | |
| CStorageBuilder | |
| CStorageElement | |
| CStorageIterator | Helper class for iterating over quantities stored in Storage |
| CStoragePairVisitor< TVisitorType > | |
| CStoragePairVisitor< VisitorEnum::ALL_BUFFERS > | |
| CStoragePairVisitor< VisitorEnum::ALL_VALUES > | |
| CStoragePairVisitor< VisitorEnum::FIRST_ORDER > | |
| CStoragePairVisitor< VisitorEnum::HIGHEST_DERIVATIVES > | |
| CStoragePairVisitor< VisitorEnum::SECOND_ORDER > | |
| CStoragePairVisitor< VisitorEnum::ZERO_ORDER > | |
| CStorageSequence | Helper class, provides functions begin and end, returning iterators to the first and last quantity in Storage, respectively |
| CStorageVisitor< TVisitorType > | |
| CStorageVisitor< VisitorEnum::ALL_BUFFERS > | Iterator over all buffers |
| CStorageVisitor< VisitorEnum::ALL_VALUES > | Iterator over all quantities, executes given functor with buffer of quantity values |
| CStorageVisitor< VisitorEnum::FIRST_ORDER > | Iterator over all first-order quantities |
| CStorageVisitor< VisitorEnum::HIGHEST_DERIVATIVES > | Iterator over all highest-order derivatives of quantities |
| CStorageVisitor< VisitorEnum::SECOND_ORDER > | |
| CStorageVisitor< VisitorEnum::ZERO_ORDER > | Iterator over all zero-order quantities |
| CStorageVisitorWithPositions | |
| CString | |
| CSubsetAdapter< TContainer, TCondition > | Non-owning view to access and iterate over subset of container |
| CSubsetIterator< TIterator, TCondition > | Allows to iterate over a given subset of a container, given by condition functor |
| CSuccessTag | |
| CMomentOperators::Sum< TValue1, TValue2 > | |
| CSvd | |
| CVariantHelpers::Swap< TArgs > | Swaps content of two variants |
| CSymmetricTensor | Symmetric tensor of 2nd order |
| CSymmetrizeSmoothingLengths< TKernel > | |
| CSymmetrizeSmoothingLengths< LutKernel< 3 > > | |
| CSymmetrizeSmoothingLengths< LutKernel< DIMENSIONS > > | |
| CSymmetrizeValues< TKernel > | |
| CTable | |
| ►CTAllocator | |
| CArray< T, TAllocator, TCounter > | |
| CList< Size > | |
| CList< AutoPtr< ITrigger > > | |
| CList< T, TAllocator > | Doubly-linked list |
| CMonotonicMemoryResource< TAllocator > | Simple memory resource with pre-allocated contiguous memory buffer |
| CTrackingAllocator< TAllocator > | Helper allocator that keeps track on allocated memory |
| CTarget | |
| ►CTBase | |
| CInnerNode< TBase > | Inner node of K-d tree |
| CLeafNode< TBase > | Leaf (bucket) node of K-d tree |
| CTensor | Generic 2nd-order tensor with 9 independent components |
| CMomentOperators::Term2 | |
| CMomentOperators::Term30 | |
| CMomentOperators::Term31 | |
| CMomentOperators::Term32 | |
| ►CTFallback | |
| CFallbackAllocator< TPrimary, TFallback > | Allocator that attemps to allocate using given primary allocator, and if the allocation fails, it allocates using a second fallback allocator |
| CThreadContext | |
| CAsymmetricSolver::ThreadData | |
| CIRaytracer::ThreadData | |
| CSymmetricSolver< Dim >::ThreadData | |
| CThreadLocal< Type > | Template for storing a copy of a value for every thread in given scheduler |
| CThreadLocal< Array< NeighbourRecord > > | |
| CThreadLocal< AsymmetricSolver::ThreadData > | |
| CThreadLocal< IRaytracer::ThreadData > | |
| CThreadLocal< SecondThreadData > | |
| CThreadLocal< SymmetricSolver::ThreadData > | |
| CThreadLocal< ThreadData > | |
| CTicsParams | |
| ►CTimer | Basic time-measuring tool. Starts automatically when constructed |
| CStoppableTimer | Simple extension of Timer allowing to pause and continue timer |
| CTimeStep | |
| ►CTLarge | |
| CSegregator< TLimit, TSmall, TLarge > | Compositor that uses one allocator for small allocations and another allocator for large allocations |
| ►CTPrimary | |
| CFallbackAllocator< TPrimary, TFallback > | Allocator that attemps to allocate using given primary allocator, and if the allocation fails, it allocates using a second fallback allocator |
| CTracelessMultipole< Order > | |
| CTracelessMultipole< 0 > | |
| CTracelessMultipole< 1 > | |
| CTracelessMultipole< 2 > | |
| CTracelessMultipole< 3 > | |
| CTracelessMultipole< N > | |
| CTracelessMultipoleComponent< Idxs > | |
| CTracelessMultipoleComponentImpl< Idxs > | |
| CTracelessMultipoleComponentImpl< I, J, Z, Z > | |
| CTracelessMultipoleComponentImpl< I, Z, Z > | |
| CTracelessMultipoleComponentImpl< Z, Z > | |
| CDetail::TracelessMultipoleMapping< Idxs > | |
| CDetail::TracelessMultipoleMapping< I > | |
| CDetail::TracelessMultipoleMappingImpl< Idxs > | |
| CDetail::TracelessMultipoleMappingImpl< I > | |
| CDetail::TracelessMultipoleMappingImpl< X, Second, Idxs... > | |
| CDetail::TracelessMultipoleMappingImpl< Y, Second, Idxs... > | |
| CTracelessTensor | Symmetric traceless 2nd order tensor |
| CBarnesHut::TreeWalkResult | |
| CBarnesHut::TreeWalkState | Data passed into each node during treewalk |
| CTriangle | Triangle.h |
| ►CTSmall | |
| CSegregator< TLimit, TSmall, TLarge > | Compositor that uses one allocator for small allocations and another allocator for large allocations |
| ►CTSphSolver | |
| CGravitySolver< TSphSolver > | Extension of a generic SPH solver, including gravitational interactions of particles |
| CPost::Tumbler | |
| CTupleAdapter< TElement, TContainers > | |
| CTupleContains< TTuple, Type > | |
| CTupleContains< Tuple< TArgs... >, Type > | |
| CTupleElementType< TTuple, TIndex > | Gets type of tuple element given its index |
| CTupleElementType< const Tuple< TArgs... > &, TIndex > | |
| CTupleElementType< Tuple< TArgs... > &&, TIndex > | |
| CTupleElementType< Tuple< TArgs... > &, TIndex > | |
| CTupleElementType< Tuple< TArgs... >, TIndex > | |
| CDetail::TupleImpl< TSequence, TArgs > | |
| ►CDetail::TupleImpl< std::index_sequence_for< TArgs... >, TArgs... > | |
| CTuple< TIterator... > | |
| CTuple< TContainers... > | |
| CTuple< TArgs > | Heterogeneous container capable of storing a fixed number of values |
| CTupleIterator< TElement, TIterator > | Holds multiple iterators, advancing all of them at the same time |
| CDetail::TupleValue< TIndex, TValue > | |
| ►CDetail::TupleValue< TIndices, TArgs > | |
| CDetail::TupleImpl< std::index_sequence< TIndices... >, TArgs... > | |
| CTypeIndex< T0, n, T1, TArgs > | Returns the index of type T0 in type list. If the type is not in the list, returns -1 |
| CTypeIndex< T0, n, T1 > | |
| CTypeSelector< n, TArgs > | Gets n-th type |
| CTypeSelector< 0, T0, TArgs... > | |
| ►CTypeSelector< n - 1, TArgs... > | |
| CTypeSelector< n, T0, TArgs... > | |
| CUndecayType< T, TOther > | Adds const or reference to the type, based on const-ness and reference-ness of given type |
| CUndecayType< T, const TOther & > | |
| CUndecayType< T, const TOther > | |
| CUndecayType< T, TOther & > | |
| CUnexpectedTag | |
| CUniqueNameManager | |
| CUnit | Single benchmark unit |
| CDetail::UnitAdapter< T, typename > | |
| CDetail::UnitAdapter< T, std::enable_if_t< std::is_same< T, Float >::value||std::is_same< T, Vector >::value > > | |
| CUnitDesc | |
| CUnitDimensions | |
| CUnitSystem | |
| CUnwrapReferenceType< T > | Type trait for "extracting" stored references from reference_wrappers. Other types keeps unchanged |
| CUnwrapReferenceType< ReferenceWrapper< T > > | |
| CFilmicMapping::UserParams | |
| CLutIterator< TValue, TScalar >::Value | |
| CDetail::ValueInitTag | |
| CVariant< TArgs > | Variant, an implementation of type-safe union, similar to std::variant or boost::variant |
| CVariant< bool, int, Float, Interval, std::string, Vector, SymmetricTensor, TracelessTensor, EnumWrapper > | |
| CVariant< Float, Vector, Tensor, SymmetricTensor, TracelessTensor, Size > | |
| CVariant< NothingType, Size, Float, Vector, Tensor, SymmetricTensor, TracelessTensor, MinMaxMean, std::string > | |
| CVariant< NothingType, Type, UnexpectedWrapper > | |
| CVariant< QuantityId, AutoPtr< IUserQuantity > > | |
| CVariant< Size, Float, Vector, TracelessTensor, SymmetricTensor > | |
| CVariant< StaticArray, T > | |
| CVariantIterator< T0, TArgs > | Iterates through types of variant until idx-th type is found, and executes given TVisitor, passing arguments to its method visit |
| CVariantIterator< T0 > | Specialization for last type |
| CVdbParams | |
| CVector4 | |
| CVectorComponentAdapter< TBuffer > | Wraps a vector container, providing means to iterate over given component of vector elements |
| CVerboseLogThreadContext | |
| CVirtualSettings | Holds a map of virtual entries, associated with a unique name |
| CVisNode | |
| CVolume< TValue > | |
| CVolume< char > | |
| CWeakPtr< T > | |
| CWeakPtr< JobNode > | |
| CWeakPtr< Timer > | |
| CWeakToken | |
| CWrapReferenceType< T > | Type trait wrapping references. Other types keeps unchanged |
| CWrapReferenceType< T & > | |
| ►CwxApp | |
| CApp | |
| CSsfToPngApp | |
| ►CwxComboBox | |
| CComboBox | |
| ►CwxCommandEvent | |
| CMainLoopEvent | Custom event holding a callback |
| ►CwxDialog | |
| CBatchDialog | |
| CGuiSettingsDialog | |
| CParamSelectDialog | |
| CRunSelectDialog | |
| CSessionDialog | |
| CWaitDialog | |
| ►CwxFileProperty | |
| CFileProperty | |
| ►CwxFrame | |
| CCurveDialog | |
| CMainWindow | |
| CPaletteDialog | |
| ►CwxPanel | |
| CCurvePanel | |
| CGridPage | |
| ►CIGraphicsPane | |
| COrthoPane | |
| CNodeEditor | |
| CNodeWindow | |
| CPaletteCanvas | |
| CParticleProbe | |
| CPlotPage | |
| CPlotView | |
| CProgressPanel | |
| CRenderPane | |
| CRunPage | Main frame of the application |
| CTimeLine | |
| CTimeLinePanel | |
| ►CwxPGEditor | |
| CCurveEditor | |
| ►CwxPGEditorDialogAdapter | |
| CDirDialogAdapter | |
| COpenFileDialogAdapter | |
| CSaveFileDialogAdapter | |
| ►CwxStringProperty | |
| CCurveProperty | |
| CIntervalProperty | |
| CVectorProperty | |
| ►CwxTextCtrl | |
| CFloatTextCtrl | |
| ►CwxTimer | |
| CDelayedCallback | |
| CXyz | |
