| ▼NAirGapDeposition | |
| CvelocityField | |
| ▼NDeposition | |
| CvelocityField | |
| ▼NlsInternal | |
| CEnquistOsher | Engquist osher integration scheme based on the upwind integration scheme. Offers high performance but lower accuracy for complex velocity fields |
| CFiniteDifferences | |
| CGraph | |
| CLaxFriedrichs | Lax Friedrichs integration scheme with constant alpha value for dissipation. This alpha value should be fitted based on the results of the advection and passed to the advection Kernel |
| CLocalLaxFriedrichs | Lax Friedrichs integration scheme, which uses a first neighbour stencil to calculate the alpha values for all neighbours. The largest alpha value is then chosen for dissipation. Slower than lsLocalLocalLaxFriedrichs or lsEngquistOsher but more reliable for complex velocity fields |
| CLocalLaxFriedrichsAnalytical | Lax Friedrichs integration scheme, which uses alpha values provided by the user in getDissipationAlphas in lsVelocityField. If it is possible to derive analytical solutions for the velocityField and the alpha values, this integration scheme should be used and never otherwise |
| CLocalLocalLaxFriedrichs | Lax Friedrichs integration scheme, which considers only the current point for alpha calculation. Faster than lsLocalLaxFriedrichs but not as accurate |
| CMarchingCubes | Helper class for lsToSurfaceMesh. Should not be used directly |
| CStencilLocalLaxFriedrichsScalar | Stencil Local Lax Friedrichs Integration Scheme. It uses a stencil of order around active points, in order to evaluate dissipation values for each point, taking into account the mathematical nature of the speed function. see Toifl et al., 2019. ISBN: 978-1-7281-0938-1; DOI: 10.1109/SISPAD.2019.8870443 |
| ▼Nviennals | |
| CAdvect | This class is used to advance level sets over time. Level sets are passed to the constructor in an std::vector, with the last element being the level set to advect, or "top level set", while the others are then adjusted afterwards. In order to ensure that advection works correctly, the "top level set" has to include all lower level sets: LS_top = LS_top U LS_i for i = {0 ... n}, where n is the number of level sets. The velocities used to advect the level set are given in a concrete implementation of the lsVelocityField (check Advection examples for guidance) |
| CBooleanOperation | This class is used to perform boolean operations on two level sets and write the resulting level set into the first passed level set. When the boolean operation is set to CUSTOM, a comparator must be set using setBooleanOperationComparator. This comparator returns one value generated from the level set value supplied by each level set. E.g.: for a union, the comparator will always return the smaller of the two values. The function signature for the comparator is defined in the public ComparatorType |
| CBox | Class describing a square box from one coordinate to another |
| CBoxDistribution | Concrete implementation of GeometricAdvectDistribution for a rectangular box distribution |
| CCalculateCurvatures | |
| CCalculateNormalVectors | This algorithm is used to compute the normal vectors for all points with level set values <= 0.5. The result is saved in the lsPointData of the lsDomain and can be retrieved with lsDomain.getPointData().getVectorData("Normals"). Since neighbors in each cartesian direction are necessary for the calculation, the level set width must be >=3 |
| CCheck | This class is used to find errors in the underlying level set structure, like invalid neighbours of different signs |
| CConvexHull | This algorithm creates a convex hull mesh from a point cloud. This is done using the gift wrapping approach. The points in the point cloud MUST be unique, otherwise this will fail |
| CCylinder | Class describing a square box from one coordinate to another |
| CDetectFeatures | This class detects features of the level set function. This class offers two methods to determine features of the surface: based on the mean curvature, and based on the angle between surface normals. The curvature-based algorithm is the default as it leads to more accurate results and should be preferred in general |
| CDomain | Class containing all information about the level set, including the dimensions of the domain, boundary conditions and all data |
| CExpand | Expands the leveleSet to the specified number of layers. The largest value in the levelset is thus width*0.5 Returns the number of added points |
| CExtrude | Extrudes a 2D Level Set into a 3D domain. The axis in which should be extruded can be set and boundary conditions in the 3D domain must be specified |
| CFromMesh | Import the regular grid, on which the level set values are defined, from an explicit Mesh<>. The Vertices must be defined, as well as a scalar data field "LSValues". If used for custom read-in, make sure all vertices are lexicographically sorted |
| CFromSurfaceMesh | Construct a level set from an explicit mesh |
| CFromVolumeMesh | This class creates a level set from a tetrahedral mesh. If the mesh contains a scalar data array called "Material", one level set for each material will be created and stored in the supplied std::vector<Domain<T,D>> object |
| CGeometricAdvect | This class advects the level set according to a given distribution. This distribution is overlayed at every grid point of the old surface. All cells within this distribution are then filled, with cells at the edge marked with the correct level set values. Therefore, the surface can be shifted long distances in one step. This algorithm is therefore preferable to normal advection if there is growth/reduction by a purely geometric directional distribution |
| CGeometricAdvectDistribution | Base class for distributions used by lsGeometricAdvect. All functions are pure virtual and must be implemented by any advection distribution |
| CMakeGeometry | Create level sets describing basic geometric forms |
| CMarkVoidPoints | This class is used to mark points of the level set which are enclosed in a void |
| CMaterialMap | |
| CMesh | This class holds an explicit mesh, which is always given in 3 dimensions. If it describes a 2D mesh, the third dimension is set to 0. Vertices, Lines, Triangles, Tetras & Hexas are supported as geometric elements |
| CPlane | Class describing a plane via a point in it and the plane normal |
| CPointCloud | Class describing a point cloud, which can be used to create geometries from its convex hull mesh |
| CPointData | This class holds data associated with points in space |
| CPrune | Removes all level set points, which do not have at least one oppositely signed neighbour (Meaning they do not lie directly at the interface). Afterwards the level set will occupy the least memory possible |
| CReader | |
| CReduce | Reduce the level set size to the specified width. This means all level set points with value <= 0.5*width are removed, reducing the memory footprint of the lsDomain |
| CRemoveStrayPoints | This algorithm can be used to remove all LS values which are not part of a so-called top surface. This surface is detected using the MarkVoidPoints algorithm, according to the method chosen by the user. This method is set using setVoidTopSurface, which is equivalent to the corresponding member function of lsMarkVoidPoints |
| CSphere | Class describing a sphere via origin and radius |
| CSphereDistribution | Concrete implementation of GeometricAdvectDistribution for a spherical advection distribution |
| CToDiskMesh | This class creates a mesh from the level set with all grid points with a level set value <= 0.5. These grid points are shifted in space towards the direction of their normal vector by grid delta * LS value. Grid delta and the origin grid point are saved for each point. This allows for a simple setup of disks for ray tracing |
| CToMesh | Extract the regular grid, on which the level set values are defined, to an explicit Mesh<>. The Vertices will contain the level set value stored at its location. (This is very useful for debugging) |
| CToSurfaceMesh | Extract an explicit Mesh<> instance from an lsDomain. The interface is then described by explciit surface elements: Lines in 2D, Triangles in 3D |
| CToVoxelMesh | Creates a mesh, which consists only of quads/hexas for completely filled grid cells in the level set. Interfaces will not be smooth but stepped. (This can be used to create meshes for finite difference algorithms) |
| CTransformMesh | |
| CVelocityField | Abstract class defining the interface for the velocity field used during advection using lsAdvect |
| CVTKReader | Class handling the import of VTK file types |
| CVTKWriter | Class handling the output of an Mesh<> to VTK file types |
| CWriter | |
1.11.0