docs/hdk/_g_a_s___project_non_divergent_adaptive_8h_source.html

 #ifndef _GAS_ProjectNonDivergentAdaptive_

 #define _GAS_ProjectNonDivergentAdaptive_


 #include "GAS_SubSolver.h"

 #include "GAS_Utils.h"


 #include <SIM/SIM_RawIndexField.h>


 #include <UT/UT_Array.h>

 #include <UT/UT_FaceGradedOctreeLabels.h>

 #include <UT/UT_SparseMatrix.h>


 class SIM_RawField;

 class SIM_ScalarField;

 class SIM_VectorField;


 class GAS_API GAS_ProjectNonDivergentAdaptive : public GAS_SubSolver

 {

     using SparseMatrixRow = UT_SparseMatrixRowT<fpreal32>;

     using SparseMatrix = UT_SparseMatrixT<fpreal32, false>;

     using Vector = UT_VectorT<fpreal32>;


     using OctreeCellLabels = UT_FaceGradedOctreeLabels::OctreeCellLabels;

     using OctreeFaceLabels = UT_FaceGradedOctreeLabels::OctreeFaceLabels;


 public:


     static constexpr int FLUID_CELL = 0;

     static constexpr int UNASSIGNED_CELL = -1;


     static constexpr int INVALID_FACE = 0;

     static constexpr int VALID_FACE = 1;


     GET_DATA_FUNC_F(SIM_NAME_TOLERANCE, Tolerance);

     GET_DATA_FUNC_I("maxiterations", MaxIterations);


     GET_DATA_FUNC_B("usesharpcollisions", UseSharpCollisions);


     GET_DATA_FUNC_I("octreelevels", OctreeLevels);

     GET_DATA_FUNC_I("finebandwidth", FineBandwidth);


     GET_DATA_FUNC_B("generateoctree", GenerateOctree);

     GET_DATA_FUNC_B("onlygenerateoctree", OnlyGenerateOctree);

     GET_DATA_FUNC_I("smootheriterations", SmootherIterations);

     GET_DATA_FUNC_B("usegaussseidelsmoother", UseGaussSeidelSmoother);


     GET_DATA_FUNC_F("extrapolation", Extrapolation);


     GET_DATA_FUNC_B("useoldpressure", UseOldPressure);


     GET_DATA_FUNC_F("waterline", Waterline);

     GET_DATA_FUNC_B("usewaterline", UseWaterline);

     GET_DATA_FUNC_V3("waterlinedirection", WaterlineDirection);


     GET_DATA_FUNC_B(GAS_NAME_USETIMESTEP, UseTimeStep);

     GET_DATA_FUNC_F(GAS_NAME_TIMESCALE, TimeScale);


 protected:

     explicit GAS_ProjectNonDivergentAdaptive(const SIM_DataFactory *factory);

             ~GAS_ProjectNonDivergentAdaptive() override;


     // Used to determine if the field is complicated enough to justify

     // the overhead of multithreading.

     bool shouldMultiThread(const SIM_RawField *field) const

     {

         return field->field()->numTiles() > 1;

     }


     // The overloaded callback that GAS_SubSolver will invoke to

     // perform our actual computation.  We are giving a single object

     // at a time to work on.

     bool solveGasSubclass(SIM_Engine &engine, SIM_Object *obj,

                           SIM_Time time, SIM_Time timestep) override;


 private:

     // We define this to be a DOP_Auto node which means we do not

     // need to implement a DOP_Node derivative for this data.  Instead,

     // this description is used to define the interface.

     static const SIM_DopDescription *getDopDescription();

     /// These macros are necessary to bind our node to the factory and

     /// ensure useful constants like BaseClass are defined.

     DECLARE_STANDARD_GETCASTTOTYPE();

     DECLARE_DATAFACTORY(GAS_ProjectNonDivergentAdaptive, GAS_SubSolver,

                         "GAS Project Non Divergent Adaptive", getDopDescription());


     THREADED_METHOD6_CONST(GAS_ProjectNonDivergentAdaptive,

                             boundary_weights.shouldMultiThread(),

                             enforceVolumeLimitBoundaries,

                             SIM_RawField &, boundary_weights,

                             SIM_RawField &, valid_faces,

                             const SIM_RawField &, velocity,

                             const SIM_RawField &, cutcell_weights,

                             const SIM_BoundaryLine &, index_boundary_line,

                             const int, axis)


     void enforceVolumeLimitBoundariesPartial(SIM_RawField &boundary_weights,

                                                 SIM_RawField &valid_faces,

                                                 const SIM_RawField &velocity,

                                                 const SIM_RawField &cutcell_weights,

                                                 const SIM_BoundaryLine &index_boundary_line,

                                                 const int axis,

                                                 const UT_JobInfo &info) const;


     THREADED_METHOD6_CONST(GAS_ProjectNonDivergentAdaptive,

                             surface.shouldMultiThread(),

                             classifyRegularLiquidCells,

                             SIM_RawIndexField &, regular_liquid_cell_labels,

                             const SIM_RawField &, surface,

                             const SIM_RawField &, collision,

                             const SIM_RawField **, cutcell_weights,

                             const SIM_RawField *, boundary_weights,

                             const fpreal, extrapolation)


     void classifyRegularLiquidCellsPartial(SIM_RawIndexField &regular_liquid_cell_labels,

                                             const SIM_RawField &surface,

                                             const SIM_RawField &collision,

                                             const SIM_RawField **cutcell_weights,

                                             const SIM_RawField *boundary_weights,

                                             const fpreal extrapolation,

                                             const UT_JobInfo &info) const;


     bool

     checkForFineLiquidCells(const SIM_RawIndexField &regular_liquid_cell_labels) const;


     //

     // Helper functions for building octree labels

     //


     THREADED_METHOD4_CONST(GAS_ProjectNonDivergentAdaptive,

                             regular_liquid_cell_labels.shouldMultiThread(),

                             setFineCellMaskInterior,

                             UT_Array<UT_Array<UT_Vector3I>> &, parallel_boundary_cell_list,

                             UT_VoxelArrayF &, fine_cell_mask,

                             const SIM_RawIndexField &, regular_liquid_cell_labels,

                             const SIM_RawField **, cutcell_weights)


     void setFineCellMaskInteriorPartial(UT_Array<UT_Array<UT_Vector3I>> &parallel_boundary_cell_list,

                                         UT_VoxelArrayF &fine_cell_mask,

                                         const SIM_RawIndexField &regular_liquid_cell_labels,

                                         const SIM_RawField **cutcell_weights,

                                         const UT_JobInfo &info) const;


     void findOccupiedFineTiles(UT_Array<bool> &is_tile_occupied_list,

                                 const UT_Array<UT_Vector3I> &fine_cell_list,

                                 const UT_VoxelArrayF &fine_cell_mask) const;


     void uncompressFineTiles(UT_VoxelArrayF &fine_cell_mask,

                                 const UT_Array<bool> &is_tile_occupied_list) const;


     void setFineCells(UT_VoxelArrayF &fine_cell_mask,

                         const UT_Array<UT_Vector3I> &fine_cell_list) const;


     void setCustomFineCells(UT_VoxelArrayF &fine_cell_mask,

                             const SIM_RawField &custom_fine_cells) const;


     THREADED_METHOD4_CONST(GAS_ProjectNonDivergentAdaptive,

                             old_cell_list.size() > 1000,

                             loadNextOutsideFineCellLayer,

                             UT_Array<UT_Array<UT_Vector3I>> &, parallel_next_cell_list,

                             const UT_Array<UT_Vector3I> &, old_cell_list,

                             const UT_VoxelArrayF &, fine_cell_mask,

                             const SIM_RawIndexField &, regular_liquid_cell_labels)


     void loadNextOutsideFineCellLayerPartial(UT_Array<UT_Array<UT_Vector3I>> &parallel_next_cell_list,

                                                 const UT_Array<UT_Vector3I> &old_cell_list,

                                                 const UT_VoxelArrayF &fine_cell_mask,

                                                 const SIM_RawIndexField &regular_liquid_cell_labels,

                                                 const UT_JobInfo &info) const;


     THREADED_METHOD4_CONST(GAS_ProjectNonDivergentAdaptive,

                             old_cell_list.size() > 1000,

                             loadNextInsideFineCellLayer,

                             UT_Array<UT_Array<UT_Vector3I>> &, parallel_next_cell_list,

                             const UT_Array<UT_Vector3I> &, old_cell_list,

                             const UT_VoxelArrayF &, fine_cell_mask,

                             const SIM_RawIndexField &, regular_liquid_cell_labels)


     void loadNextInsideFineCellLayerPartial(UT_Array<UT_Array<UT_Vector3I>> &parallel_next_cell_list,

                                             const UT_Array<UT_Vector3I> &old_cell_list,

                                             const UT_VoxelArrayF &fine_cell_mask,

                                             const SIM_RawIndexField &regular_liquid_cell_labels,

                                             const UT_JobInfo &info) const;


     void buildOctreeCellLabels(UT_FaceGradedOctreeLabels &octree_labels,

                                 const SIM_RawIndexField &regular_liquid_cell_labels,

                                 const SIM_RawField *custom_fine_cells,

                                 const SIM_RawField **cutcell_weights,

                                 const int levels,

                                 const int inside_fine_width,

                                 const int outside_fine_width) const;


     //

     // Build octree cell indices

     //


     THREADED_METHOD4_CONST(GAS_ProjectNonDivergentAdaptive,

                             octree_labels.numTiles() > 100,

                             classifyOctreeLiquidCells,

                             SIM_RawIndexField &,liquid_indices,

                             const UT_VoxelArray<int> &, octree_labels,

                             const SIM_RawIndexField &, regular_liquid_cell_labels,

                             const int, level)


     void classifyOctreeLiquidCellsPartial(SIM_RawIndexField &liquid_indices,

                                             const UT_VoxelArray<int> &octree_labels,

                                             const SIM_RawIndexField &regular_liquid_cell_labels,

                                             const int level,

                                             const UT_JobInfo &info) const;


     exint buildOctreeCellIndices(UT_Array<SIM_RawIndexField> &liquid_indices,

                                     const UT_FaceGradedOctreeLabels &octree_labels,

                                     const SIM_RawIndexField &regular_liquid_cell_labels,

                                     const UT_Vector3 &octree_grid_size) const;


     THREADED_METHOD4_CONST(GAS_ProjectNonDivergentAdaptive,

                             connected_component_field.shouldMultiThread(),

                             findFreeSurfacePerRegion,

                             UT_Array<bool> &, region_has_free_surface,

                             const SIM_RawIndexField &, connected_component_field,

                             const SIM_RawIndexField &, regular_liquid_cell_labels,

                             const SIM_RawField **, cutcell_weights)


     void findFreeSurfacePerRegionPartial(UT_Array<bool> &region_has_free_surface,

                                             const SIM_RawIndexField &connected_component_field,

                                             const SIM_RawIndexField &regular_liquid_cell_labels,

                                             const SIM_RawField **cutcell_weights,

                                             const UT_JobInfo &info) const;


     THREADED_METHOD6_CONST(GAS_ProjectNonDivergentAdaptive,

                             connected_liquid_components.shouldMultiThread(),

                             computeDivergencePerRegion,

                             UT_Array<UT_Array<fpreal>> &, parallel_region_divergence,

                             UT_Array<UT_Array<fpreal>> &, parallel_region_cell_count,

                             const SIM_RawIndexField &, connected_liquid_components,

                             const SIM_RawIndexField &, regular_liquid_cell_labels,

                             const SIM_RawField &, divergence,

                             const UT_Array<bool> &, region_has_free_surface)


     void computeDivergencePerRegionPartial(UT_Array<UT_Array<fpreal>> &parallel_region_divergence,

                                             UT_Array<UT_Array<fpreal>> &parallel_region_cell_count,

                                             const SIM_RawIndexField &connected_liquid_components,

                                             const SIM_RawIndexField &regular_liquid_cell_labels,

                                             const SIM_RawField &divergence,

                                             const UT_Array<bool> &region_has_free_surface,

                                             const UT_JobInfo &info) const;


     THREADED_METHOD5_CONST(GAS_ProjectNonDivergentAdaptive,

                             connected_liquid_components.shouldMultiThread(),

                             removeAverageDivergence,

                             SIM_RawField &, divergence,

                             const SIM_RawIndexField &, connected_liquid_components,

                             const SIM_RawIndexField &, regular_liquid_cell_labels,

                             const UT_Array<fpreal> &, region_divergence,

                             const UT_Array<bool> &, region_has_free_surface)


     void removeAverageDivergencePartial(SIM_RawField &divergence,

                                         const SIM_RawIndexField &connected_liquid_components,

                                         const SIM_RawIndexField &regular_liquid_cell_labels,

                                         const UT_Array<fpreal> &region_divergence,

                                         const UT_Array<bool> &region_has_free_surface,

                                         const UT_JobInfo &info) const;


     THREADED_METHOD4_CONST(GAS_ProjectNonDivergentAdaptive,

                             octree_labels.numTiles() > 100,

                             buildOccupiedOctreeFaceTiles,

                             UT_Array<bool> &, occupied_tile_list,

                             const SIM_RawField &, valid_faces,

                             const UT_VoxelArray<int> &, octree_labels,

                             const int, axis)


     void buildOccupiedOctreeFaceTilesPartial(UT_Array<bool> &occupied_tile_list,

                                                 const SIM_RawField &valid_faces,

                                                 const UT_VoxelArray<int> &octree_labels,

                                                 const int axis,

                                                 const UT_JobInfo &info) const;


     THREADED_METHOD2_CONST(GAS_ProjectNonDivergentAdaptive,

                             occupied_tile_list.entries() > 20,

                             uncompressTiles,

                             SIM_RawField &, grid,

                             const UT_Array<bool> &, occupied_tile_list)


     void uncompressTilesPartial(SIM_RawField &grid,

                                 const UT_Array<bool> &occupied_tile_list,

                                 const UT_JobInfo &info) const;


     THREADED_METHOD7_CONST(GAS_ProjectNonDivergentAdaptive,

                             valid_faces.shouldMultiThread(),

                             classifyValidOctreeFaces,

                             SIM_RawField &, valid_faces,

                             const UT_FaceGradedOctreeLabels &, octree_labels,

                             const SIM_RawField &, surface,

                             const SIM_RawIndexField &, liquid_cell_indices,

                             const SIM_RawField **, cutcell_weights,

                             const int, axis, const int, level)


     void classifyValidOctreeFacesPartial(SIM_RawField &valid_faces,

                                             const UT_FaceGradedOctreeLabels &octree_labels,

                                             const SIM_RawField &surface,

                                             const SIM_RawIndexField &liquid_cell_indices,

                                             const SIM_RawField **cutcell_weights,

                                             const int axis, const int level,

                                             const UT_JobInfo &info) const;


     void buildValidOctreeFaces(UT_Array<UT_Array<SIM_RawField>> &valid_octree_faces,

                                 const UT_Array<SIM_RawIndexField> &liquid_indices,

                                 const UT_FaceGradedOctreeLabels &octree_labels,

                                 const SIM_RawField **cutcell_weights,

                                 const SIM_RawField &surface,

                                 const UT_Vector3 &octree_grid_size) const;


     THREADED_METHOD4_CONST(GAS_ProjectNonDivergentAdaptive,

                             regular_liquid_cell_labels.field()->numTiles() > 100,

                             findOccupiedRegularGridFaceTiles,

                             UT_Array<bool> &, occupied_tile_list,

                             const SIM_RawIndexField &, regular_liquid_cell_labels,

                             const SIM_RawField &, valid_faces,

                             const int, axis)


     void findOccupiedRegularGridFaceTilesPartial(UT_Array<bool> &occupied_tile_list,

                                                 const SIM_RawIndexField &regular_liquid_cell_labels,

                                                 const SIM_RawField &valid_faces,

                                                 const int axis,

                                                 const UT_JobInfo &info) const;


     THREADED_METHOD4_CONST(GAS_ProjectNonDivergentAdaptive,

                             valid_faces.shouldMultiThread(),

                             classifyValidRegularGridFaces,

                             SIM_RawField &, valid_faces,

                             const SIM_RawIndexField &, regular_liquid_cell_labels,

                             const SIM_RawField &, cutcell_weights,

                             const int, axis)


     void classifyValidRegularGridFacesPartial(SIM_RawField &valid_faces,

                                                 const SIM_RawIndexField &regular_liquid_cell_labels,

                                                 const SIM_RawField &cutcell_weights,

                                                 const int axis,

                                                 const UT_JobInfo &info) const;


     void buildValidRegularGridFaces(SIM_VectorField &valid_faces,

                                     const SIM_RawIndexField &regular_liquid_cell_labels,

                                     const SIM_RawField **cutcell_weights) const;


     THREADED_METHOD6_CONST(GAS_ProjectNonDivergentAdaptive,

                             divergence.shouldMultiThread(),

                             buildFineCutCellDivergence,

                             SIM_RawField &, divergence,

                             const SIM_VectorField &, velocity,

                             const SIM_RawField **, cutcell_weights,

                             const SIM_VectorField *, collision_velocity,

                             const SIM_RawIndexField &, regular_liquid_cell_labels,

                             const bool, use_cutcell_boundaries)


     void buildFineCutCellDivergencePartial(SIM_RawField &divergence,

                                             const SIM_VectorField &velocity,

                                             const SIM_RawField **cutcell_weights,

                                             const SIM_VectorField *collision_velocity,

                                             const SIM_RawIndexField &regular_liquid_cell_labels,

                                             const bool use_cutcell_boundaries,

                                             const UT_JobInfo &info) const;


     THREADED_METHOD3_CONST(GAS_ProjectNonDivergentAdaptive,

                             divergence[level].shouldMultiThread(),

                             buildCoarseDivergence,

                             UT_Array<SIM_RawField> &, divergence,

                             const UT_FaceGradedOctreeLabels &, octree_labels,

                             const int, level)


     void buildCoarseDivergencePartial(UT_Array<SIM_RawField> &divergence,

                                         const UT_FaceGradedOctreeLabels &octree_labels,

                                         const int level,

                                         const UT_JobInfo &info) const;


     THREADED_METHOD3_CONST(GAS_ProjectNonDivergentAdaptive,

                             liquid_cell_indices.shouldMultiThread(),

                             buildRHS,

                             Vector &, rhs_vector,

                             const SIM_RawField &, divergence,

                             const SIM_RawIndexField &, liquid_cell_indices)


     void buildRHSPartial(Vector &rhs_vector,

                             const SIM_RawField &divergence,

                             const SIM_RawIndexField &liquid_cell_indices,

                             const UT_JobInfo &info) const;


     THREADED_METHOD9_CONST(GAS_ProjectNonDivergentAdaptive,

                             valid_faces.shouldMultiThread(),

                             integrateSurfacePressure,

                             SIM_RawField &, velocity,

                             const SIM_RawField &, valid_faces,

                             const SIM_RawField &, surface_pressure,

                             const SIM_RawField &, surface,

                             const SIM_RawField &, density,

                             const SIM_RawIndexField &, regular_liquid_cell_labels,

                             const SIM_VectorField *, surface_weights,

                             const fpreal, dt,

                             const int, axis)


     void integrateSurfacePressurePartial(SIM_RawField &velocity,

                                             const SIM_RawField &valid_faces,

                                             const SIM_RawField &surface_pressure,

                                             const SIM_RawField &surface,

                                             const SIM_RawField &density,

                                             const SIM_RawIndexField &regular_liquid_cell_labels,

                                             const SIM_VectorField *surface_weights,

                                             const fpreal dt,

                                             const int axis,

                                             const UT_JobInfo &info) const;


     THREADED_METHOD3_CONST(GAS_ProjectNonDivergentAdaptive,

                             source_pressure.shouldMultiThread(),

                             buildFinePressure,

                             SIM_RawField &, adaptive_pressure,

                             const SIM_RawField &, source_pressure,

                             const SIM_RawIndexField &, regular_liquid_cell_labels)


     void buildFinePressurePartial(SIM_RawField &adaptive_pressure,

                                     const SIM_RawField &source_pressure,

                                     const SIM_RawIndexField &regular_liquid_cell_labels,

                                     const UT_JobInfo &info) const;


     THREADED_METHOD3_CONST(GAS_ProjectNonDivergentAdaptive,

                             pressure_pyramid[level].shouldMultiThread(),

                             buildCoarsePressure,

                             UT_Array<SIM_RawField> &, pressure_pyramid,

                             const UT_FaceGradedOctreeLabels &, octree_labels,

                             const int, level)


     void buildCoarsePressurePartial(UT_Array<SIM_RawField> &pressure_pyramid,

                                     const UT_FaceGradedOctreeLabels &octree_labels,

                                     const int level,

                                     const UT_JobInfo &info) const;


     THREADED_METHOD3_CONST(GAS_ProjectNonDivergentAdaptive,

                             pressure.shouldMultiThread(),

                             applyWarmStart,

                             Vector &, solution_vector,

                             const SIM_RawField &, pressure,

                             const SIM_RawIndexField &, liquid_cell_indices)


     void applyWarmStartPartial(Vector &solution_vector,

                                 const SIM_RawField &pressure,

                                 const SIM_RawIndexField &liquid_cell_indices,

                                 const UT_JobInfo &info) const;


     struct OctreeSystemParms

     {

         OctreeSystemParms(const SIM_RawField **cutcell_weights,

                             const SIM_RawField *boundary_weights,

                             const SIM_RawField &density,

                             const SIM_RawField &surface,

                             const SIM_VectorField *surface_weights)

         : m_cutcell_weights(cutcell_weights)

         , m_boundary_weights(boundary_weights)

         , m_density(density)

         , m_surface(surface)

         , m_surface_weights(surface_weights)

         {}


         const SIM_RawField **m_cutcell_weights;

         const SIM_RawField *m_boundary_weights;

         const SIM_RawField &m_density;

         const SIM_RawField &m_surface;

         const SIM_VectorField *m_surface_weights;

     };


     THREADED_METHOD6_CONST(GAS_ProjectNonDivergentAdaptive,

                             liquid_cell_indices[level].shouldMultiThread(),

                             buildOctreePressureSystem,

                             UT_Array<SparseMatrix> &, parallel_sparse_matrix,

                             const UT_Array<SIM_RawIndexField> &, liquid_cell_indices,

                             const UT_Array<UT_Array<SIM_RawField>> &, valid_octree_faces,

                             const UT_FaceGradedOctreeLabels &, octree_labels,

                             const OctreeSystemParms &, octree_parms,

                             const int, level)


     void buildOctreePressureSystemPartial(UT_Array<SparseMatrix> &parallel_sparse_matrix,

                                             const UT_Array<SIM_RawIndexField> &liquid_cell_indices,

                                             const UT_Array<UT_Array<SIM_RawField>> &valid_octree_faces,

                                             const UT_FaceGradedOctreeLabels &octree_labels,

                                             const OctreeSystemParms &octree_parms,

                                             const int level,

                                             const UT_JobInfo &info) const;


     void applySolutionPressure(SIM_RawField &pressure,

                                 const Vector &solution_vector,

                                 const SIM_RawIndexField &liquid_cell_indices) const;


     void samplePressureFromParent(UT_Array<SIM_RawField> &pressure_pyramid,

                                     const UT_FaceGradedOctreeLabels &octree_labels,

                                     const int level) const;


     THREADED_METHOD4_CONST(GAS_ProjectNonDivergentAdaptive,

                             pressure.shouldMultiThread(),

                             dampedJacobiSmoother,

                             SIM_RawField &, pressure,

                             const SIM_RawField &, temp_pressure,

                             const SIM_RawField &, divergence,

                             const UT_VoxelArray<int> &, octree_labels)


     void dampedJacobiSmootherPartial(SIM_RawField &pressure,

                                         const SIM_RawField &temp_pressure,

                                         const SIM_RawField &divergence,

                                         const UT_VoxelArray<int> &octree_labels,

                                         const UT_JobInfo &info) const;


     void tiledGaussSeidelSmoother(SIM_RawField &pressure,

                                     const SIM_RawField &divergence,

                                     const UT_VoxelArray<int> &octree_labels,

                                     const bool apply_odd_tiles,

                                     const bool apply_forward_iteration) const;


     void applyOutputPressure(SIM_RawField &pressure,

                                 const SIM_RawField &source_pressure,

                                 const SIM_RawIndexField &regular_liquid_cell_labels) const;


     THREADED_METHOD9_CONST(GAS_ProjectNonDivergentAdaptive,

                             valid_faces.shouldMultiThread(),

                             applyRegularGridPressure,

                             SIM_RawField &, velocity,

                             const SIM_RawField &, pressure,

                             const SIM_RawField &, valid_faces,

                             const SIM_RawField &, surface,

                             const SIM_RawField & ,density,

                             const SIM_RawIndexField &, regular_liquid_cell_labels,

                             const SIM_RawField *, boundary_weights,

                             const SIM_VectorField *, surface_weights,

                             const int,  axis)


     void applyRegularGridPressurePartial(SIM_RawField &velocity,

                                             const SIM_RawField &pressure,

                                             const SIM_RawField &valid_faces,

                                             const SIM_RawField &surface,

                                             const SIM_RawField &density,

                                             const SIM_RawIndexField &regular_liquid_cell_labels,

                                             const SIM_RawField *boundary_weights,

                                             const SIM_VectorField *surface_weights,

                                             const int axis,

                                             const UT_JobInfo &info) const;

 };


 #endif

SIM_Engine
Definition: SIM_Engine.h:65

DECLARE_STANDARD_GETCASTTOTYPE
#define DECLARE_STANDARD_GETCASTTOTYPE()
Definition: SIM_DataUtils.h:50

int
typedef int(APIENTRYP RE_PFNGLXSWAPINTERVALSGIPROC)(int)

THREADED_METHOD4_CONST
#define THREADED_METHOD4_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4)
Definition: UT_ThreadedAlgorithm.h:522

SIM_NAME_TOLERANCE
#define SIM_NAME_TOLERANCE
Definition: SIM_Names.h:202

THREADED_METHOD9_CONST
#define THREADED_METHOD9_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7, PARMTYPE8, PARMNAME8, PARMTYPE9, PARMNAME9)
Definition: UT_ThreadedAlgorithm.h:547

GET_DATA_FUNC_V3
#define GET_DATA_FUNC_V3(DataName, FuncName)
Definition: SIM_OptionsUser.h:117

void
void
Definition: png.h:1083

SIM_Time
Definition: SIM_Time.h:19

GT_Names::time
GT_API const UT_StringHolder time

GAS_NAME_USETIMESTEP
#define GAS_NAME_USETIMESTEP
Definition: GAS_Utils.h:39

GAS_API
#define GAS_API
Definition: GAS_API.h:10

UT_FaceGradedOctreeLabels.h

SIM_RawIndexField.h

exint
int64 exint
Definition: SYS_Types.h:125

level
GLint level
Definition: glcorearb.h:108

GAS_SubSolver::solveGasSubclass
virtual bool solveGasSubclass(SIM_Engine &engine, SIM_Object *obj, SIM_Time time, SIM_Time timestep)=0

UT_Array.h

UT_Vector3T< float >

UT_Array
Definition: BV_KDOPTree.h:18

THREADED_METHOD5_CONST
#define THREADED_METHOD5_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5)
Definition: UT_ThreadedAlgorithm.h:527

UT_FaceGradedOctreeLabels::OctreeCellLabels
OctreeCellLabels
Definition: UT_FaceGradedOctreeLabels.h:39

DECLARE_DATAFACTORY
#define DECLARE_DATAFACTORY(DataClass, SuperClass, Description, DopParms)
Definition: SIM_DataUtils.h:63

GET_DATA_FUNC_I
#define GET_DATA_FUNC_I(DataName, FuncName)
Definition: SIM_OptionsUser.h:48

UT_VectorT
Definition: GA_NUBBasis.h:29

UT_VoxelArray::numTiles
int numTiles() const
Definition: UT_VoxelArray.h:1357

THREADED_METHOD7_CONST
#define THREADED_METHOD7_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7)
Definition: UT_ThreadedAlgorithm.h:537

UT_VoxelArray< fpreal32 >

UT_FaceGradedOctreeLabels
Definition: UT_FaceGradedOctreeLabels.h:24

UT_SparseMatrixRowT
Definition: UT_SparseMatrix.h:391

GAS_Utils.h

SIM_DopDescription
Definition: SIM_DopDescription.h:23

SparseMatrix
Definition: GAS_Viscosity.h:24

SIM_DataFactory
Definition: SIM_DataFactory.h:33

levels
GLsizei levels
Definition: glcorearb.h:2224

UT_SparseMatrixT
Definition: UT_SparseMatrix.h:38

THREADED_METHOD2_CONST
#define THREADED_METHOD2_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2)
Definition: UT_ThreadedAlgorithm.h:512

SIM_BoundaryLine
Definition: SIM_RawField.h:81

fpreal
fpreal64 fpreal
Definition: SYS_Types.h:277

SIM_RawIndexField
Definition: SIM_RawIndexField.h:41

GET_DATA_FUNC_B
#define GET_DATA_FUNC_B(DataName, FuncName)
Definition: SIM_OptionsUser.h:64

GAS_SubSolver.h

GAS_SubSolver::THREADED_METHOD6_CONST
THREADED_METHOD6_CONST(GAS_SubSolver, gdp->getNumPoints() > 2048, applyForces, GU_Detail *, gdp, const GA_PointGroup *, ptgrp, SIM_Time, timestep, bool, densityscale, bool, doorient, bool, updatepos) void applyForcesPartial(GU_Detail *gdp

SIM_Object
Definition: SIM_Object.h:33

GET_DATA_FUNC_F
#define GET_DATA_FUNC_F(DataName, FuncName)
Definition: SIM_OptionsUser.h:71

SIM_ScalarField
This class holds a three dimensional scalar field.
Definition: SIM_ScalarField.h:30

GAS_NAME_TIMESCALE
#define GAS_NAME_TIMESCALE
Definition: GAS_Utils.h:40

GAS_ProjectNonDivergentAdaptive
Definition: GAS_ProjectNonDivergentAdaptive.h:17

GAS_SubSolver
Definition: GAS_SubSolver.h:70

openvdb::OPENVDB_VERSION_NAME::tools::divergence
VectorToScalarConverter< GridType >::Type::Ptr divergence(const GridType &grid, bool threaded, InterruptT *interrupt)
Compute the divergence of the given vector-valued grid.
Definition: GridOperators.h:984

UT_JobInfo
Definition: UT_ThreadedAlgorithm.h:92

UT_SparseMatrix.h

const
#define const
Definition: zconf.h:214

THREADED_METHOD3_CONST
#define THREADED_METHOD3_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3)
Definition: UT_ThreadedAlgorithm.h:517

SIM_VectorField
This class holds a three dimensional vector field.
Definition: SIM_VectorField.h:34

GAS_ProjectNonDivergentAdaptive::shouldMultiThread
bool shouldMultiThread(const SIM_RawField *field) const
Definition: GAS_ProjectNonDivergentAdaptive.h:64

SIM_RawField
Definition: SIM_RawField.h:108

SIM_RawField::field
UT_VoxelArrayF UT_VoxelArrayF & field
Definition: SIM_RawField.h:1402

UT_FaceGradedOctreeLabels::OctreeFaceLabels
OctreeFaceLabels
Definition: UT_FaceGradedOctreeLabels.h:57