(mpm_solver, dir_name, frame, save_to_ply=True, save_to_h5=False)

(position_tensor, filename)

(self)

(self, n_particles, n_grid=100, grid_lim=1.0, device="cuda:0")

(self, step, dt, device="cuda:0")

(self, kwargs={}, device="cuda:0")

( self, point, normal, surface="sticky", friction=0.0, start_t

(cov_tensor, rotation_matrix)

(position_tensor, rotation_matrices)

( model: MPMModelStruct, w: wp.mat33, dw: wp.mat33, i: int, j: int, k: int )

( self, point, size, velocity, start_time, end_time, device="cuda:0" )

(self, device="cuda:0")

( azimuth, elevation, radius, view_center, observant_coordinates )

(upper_mat)

(mat)

(self, tensor_x, clone=True, device="cuda:0")

( F: wp.mat33, U: wp.mat33, V: wp.mat33, sig: wp.vec3, mu: float, lam: float )

( self, tensor_x, tensor_volume, tensor_cov=None, n_grid=100,

(t, copy=False, dtype=warp.types.float32, dvc="cuda:0")

(t, copy=False, dtype=warp.types.float32, dvc="cuda:0")

(input, rotation_matrices, scale_origin, original_mean_pos)

(position_tensor)

(position_tensor, scale, original_mean_pos)

(self, start_time=0.0, end_time=999.0)

( self, force, dt, point=[1, 1, 1], size=[1, 1, 1], num_dt=1,

(upper_cov_tensor, rotation_matrices)

(upper_cov_tensor, rotation_matrices)

(position_tensor, rotation_matrix)

(position_tensor, rotation_matrix)

(position_tensor, rotation_matrices)

(pos: ti.template(), grid: ti.template(), grid_dx: float)

( grid: ti.template(), grid_density: ti.template(), index, dir_type, size, threshold )

( grid: ti.template(), grid_density: ti.template(), index, dir_type, size, threshold )

(index, pos, opacity, cov, grid_dx)

( pos: ti.template(), grid: ti.template(), particle_vol: ti.template(), grid_dx: float )

( shs_view, viewpoint_camera, pc: GaussianModel, position: torch.tensor, rotation: torch.t

(json_file)

( init_particles: ti.template(), opacity: ti.template(), cov_upper: ti.template(), grid: ti.te

( self, point, normal, half_height_and_radius, rotation_scale,

(self, device="cuda:0")

(self, device="cuda:0")

( grid: ti.template(), grid_density: ti.template(), grid_dx: float, density_thres: float,

( pos, opacity, cov, grid_n: int, max_samples: int, grid_dx: float, density_thres=

(camera_to_object, object_vertical_downward)

(vertical_vector)

(degrees, axises)

(degree, axis)

( ti_pos: ti.template(), ti_shs: ti.template(), ti_opacity: ti.template(), ti_cov: ti.template

( mpm_space_viewpoint_center, mpm_space_vertical_upward_axis, rotation_matrices, scale_origin,

( camera_position, view_center, observesant_coordinates )

(pos, grid_n: int, grid_dx: float, unifrom: bool = False)

(azimuth, elevation, radius, center, observant_coordinates)

(pos, shs, cov, opacity, new_pos)

( viewpoint_camera, pc: GaussianModel, pipe, bg_color: torch.Tensor, scaling_modifier=1.0,

( grid: ti.template(), grid_density: ti.template(), grid_dx: float, new_particles: ti.template

( F: wp.mat33, U: wp.mat33, V: wp.mat33, J: float, mu: float, lam: float )

( F: wp.mat33, U: wp.mat33, V: wp.mat33, sig: wp.vec3, mu: float, lam: float )

(model_path, sh_degree=3, iteration=-1)

( self, sampling_h5, n_grid=100, grid_lim=1.0, device="cuda:0" )

( pc: GaussianModel, pipe, scaling_modifier=1.0, override_color=None )

(mpm_solver, filename)

( self, normal, start_position, end_position, num_layers, start_time, end_time )

( F_trial: wp.mat33, state: MPMStateStruct, model: MPMModelStruct, p: int )

( mpm_solver: MPM_Simulator_WARP, bc_params: dict, time_params: dict )

( self, point, size, velocity, start_time=0.0, end_time=999.0,

(position_tensor)

(t, copy=False, dtype=warp.types.float32, dvc="cuda:0")

(position_tensor, scale = 1.0)

(state: MPMStateStruct, p: int, grad_v: wp.mat33, dt: float)

( F_trial: wp.mat33, model: MPMModelStruct, p: int, dt: float )

(F_trial: wp.mat33, model: MPMModelStruct, p: int)

( F_trial: wp.mat33, model: MPMModelStruct, p: int )

(self)

(self, n_particles, n_grid=100, grid_lim=1.0, device="cuda:0")

(state: MPMStateStruct, scale: float)

(target_array: wp.array(dtype=wp.mat33))

( first_array: wp.array(dtype=wp.vec3), second_array: wp.array(dtype=wp.vec3) )

( state: MPMStateStruct, model: MPMModelStruct, params_modifier: MaterialParamsModifier, )

( time: float, dt: float, state: MPMStateStruct, param: Impulse_modifier )

( time: float, dt: float, state: MPMStateStruct, model: MPMMod

(state: MPMStateStruct, model: MPMModelStruct)

(state: MPMStateStruct, model: MPMModelStruct)

(state: MPMStateStruct, model: MPMModelStruct)

( state: MPMStateStruct, model: MPMModelStruct, dt: float )

(self)

(self)

(self)

(state: MPMStateStruct, model: MPMModelStruct, dt: float)

( arrayA: wp.array(dtype=float), arrayB: wp.array(dtype=float), arrayC: wp.array(dtype=float), )

( state: MPMStateStruct, model: MPMModelStruct, dt: float )

(self, tensor_C, clone=True, device="cuda:0")

(self, tensor_F, clone=True, device="cuda:0")

(self, tensor_v, clone=True, device="cuda:0")

( F: wp.mat33, U: wp.mat33, V: wp.mat33, J: float, sig: wp.vec3, mu: float, lam: float )

(time, dt, param: Dirichlet_collider)

( time: float, state: MPMStateStruct, velocity_modifier_params: ParticleVe

(state: MPMStateStruct, model: MPMModelStruct, dt: float)

(self)

( self, all_particle_densities, device="cuda:0" )