def __init__(
self,
res,
quant=False,
use_voxelizer=True,
size=1,
max_num_particles=2**30,
# Max 1 G particles
padding=3,
unbounded=False,
dt_scale=1,
E_scale=1,
voxelizer_super_sample=2,
use_g2p2g=False, # Ref: A massively parallel and scalable multi-GPU material point method
v_clamp_g2p2g=True,
use_bls=True,
g2p2g_allowed_cfl=0.9, # 0.0 for no CFL limit
water_density=1.0,
support_plasticity=True, # Support snow and sand materials
use_adaptive_dt=False,
use_ggui=False,
use_emitter_id=False):
self.dim = len(res)
self.quant = quant
self.use_g2p2g = use_g2p2g
self.v_clamp_g2p2g = v_clamp_g2p2g
self.use_bls = use_bls
self.g2p2g_allowed_cfl = g2p2g_allowed_cfl
self.water_density = water_density
self.grid_size = 4096
assert self.dim in (
2, 3), "MPM solver supports only 2D and 3D simulations."
self.t = 0.0
self.res = res
self.n_particles = ti.field(ti.i32, shape=())
self.dx = size / res[0]
self.inv_dx = 1.0 / self.dx
self.default_dt = 2e-2 * self.dx / size * dt_scale
self.p_vol = self.dx**self.dim
self.p_rho = 1000
self.p_mass = self.p_vol * self.p_rho
self.max_num_particles = max_num_particles
self.gravity = ti.Vector.field(self.dim, dtype=ti.f32, shape=())
self.source_bound = ti.Vector.field(self.dim, dtype=ti.f32, shape=2)
self.source_velocity = ti.Vector.field(self.dim,
dtype=ti.f32,
shape=())
self.input_grid = 0
self.all_time_max_velocity = 0
self.support_plasticity = support_plasticity
self.use_adaptive_dt = use_adaptive_dt
self.use_ggui = use_ggui
self.F_bound = 4.0
# Affine velocity field
if not self.use_g2p2g:
self.C = ti.Matrix.field(self.dim, self.dim, dtype=ti.f32)
# Deformation gradient
if quant:
ci21 = ti.type_factory.custom_int(21, True)
cft = ti.type_factory.custom_float(significand_type=ci21,
scale=1 / (2**19))
self.x = ti.Vector.field(self.dim, dtype=cft)
cu6 = ti.type_factory.custom_int(7, False)
ci19 = ti.type_factory.custom_int(19, True)
cft = ti.type_factory.custom_float(significand_type=ci19,
exponent_type=cu6)
self.v = ti.Vector.field(self.dim, dtype=cft)
ci16 = ti.type_factory.custom_int(16, True)
cft = ti.type_factory.custom_float(significand_type=ci16,
scale=(self.F_bound + 0.1) /
(2**15))
self.F = ti.Matrix.field(self.dim, self.dim, dtype=cft)
else:
self.v = ti.Vector.field(self.dim, dtype=ti.f32)
self.x = ti.Vector.field(self.dim, dtype=ti.f32)
self.F = ti.Matrix.field(self.dim, self.dim, dtype=ti.f32)
self.use_emitter_id = use_emitter_id
if self.use_emitter_id:
self.emitter_ids = ti.field(dtype=ti.i32)
self.last_time_final_particles = ti.field(dtype=ti.i32, shape=())
# Material id
if quant and self.dim == 3:
self.material = ti.field(dtype=ti.quant.int(16, False))
else:
self.material = ti.field(dtype=ti.i32)
# Particle color
self.color = ti.field(dtype=ti.i32)
if self.use_ggui:
self.color_with_alpha = ti.Vector.field(4, dtype=ti.f32)
# Plastic deformation volume ratio
if self.support_plasticity:
self.Jp = ti.field(dtype=ti.f32)
if self.dim == 2:
indices = ti.ij
else:
indices = ti.ijk
if unbounded:
# The maximum grid size must be larger than twice of
# simulation resolution in an unbounded simulation,
# Otherwise the top and right sides will be bounded by grid size
while self.grid_size <= 2 * max(self.res):
self.grid_size *= 2 # keep it power of two
offset = tuple(-self.grid_size // 2 for _ in range(self.dim))
self.offset = offset
self.num_grids = 2 if self.use_g2p2g else 1
grid_block_size = 128
if self.dim == 2:
self.leaf_block_size = 16
else:
# TODO: use 8?
self.leaf_block_size = 4
self.grid = []
self.grid_v = []
self.grid_m = []
self.pid = []
for g in range(self.num_grids):
# Grid node momentum/velocity
grid_v = ti.Vector.field(self.dim, dtype=ti.f32)
grid_m = ti.field(dtype=ti.f32)
pid = ti.field(ti.i32)
self.grid_v.append(grid_v)
# Grid node mass
self.grid_m.append(grid_m)
grid = ti.root.pointer(indices, self.grid_size // grid_block_size)
block = grid.pointer(indices,
grid_block_size // self.leaf_block_size)
self.block = block
self.grid.append(grid)
def block_component(c):
block.dense(indices, self.leaf_block_size).place(c,
offset=offset)
block_component(grid_m)
for d in range(self.dim):
block_component(grid_v.get_scalar_field(d))
self.pid.append(pid)
block_offset = tuple(o // self.leaf_block_size
for o in self.offset)
self.block_offset = block_offset
block.dynamic(ti.axes(self.dim),
1024 * 1024,
chunk_size=self.leaf_block_size**self.dim * 8).place(
pid, offset=block_offset + (0, ))
self.padding = padding
# Young's modulus and Poisson's ratio
self.E, self.nu = 1e6 * size * E_scale, 0.2
# Lame parameters
self.mu_0, self.lambda_0 = self.E / (
2 * (1 + self.nu)), self.E * self.nu / ((1 + self.nu) *
(1 - 2 * self.nu))
# Sand parameters
friction_angle = math.radians(45)
sin_phi = math.sin(friction_angle)
self.alpha = math.sqrt(2 / 3) * 2 * sin_phi / (3 - sin_phi)
# An empirically optimal chunk size is 1/10 of the expected particle number
chunk_size = 2**20 if self.dim == 2 else 2**23
self.particle = ti.root.dynamic(ti.i, max_num_particles, chunk_size)
if self.quant:
if not self.use_g2p2g:
self.particle.place(self.C)
if self.support_plasticity:
self.particle.place(self.Jp)
self.particle.bit_struct(num_bits=64).place(self.x)
self.particle.bit_struct(num_bits=64).place(self.v,
shared_exponent=True)
if self.dim == 3:
self.particle.bit_struct(num_bits=32).place(
self.F.get_scalar_field(0, 0),
self.F.get_scalar_field(0, 1))
self.particle.bit_struct(num_bits=32).place(
self.F.get_scalar_field(0, 2),
self.F.get_scalar_field(1, 0))
self.particle.bit_struct(num_bits=32).place(
self.F.get_scalar_field(1, 1),
self.F.get_scalar_field(1, 2))
self.particle.bit_struct(num_bits=32).place(
self.F.get_scalar_field(2, 0),
self.F.get_scalar_field(2, 1))
self.particle.bit_struct(num_bits=32).place(
self.F.get_scalar_field(2, 2), self.material)
else:
assert self.dim == 2
self.particle.bit_struct(num_bits=32).place(
self.F.get_scalar_field(0, 0),
self.F.get_scalar_field(0, 1))
self.particle.bit_struct(num_bits=32).place(
self.F.get_scalar_field(1, 0),
self.F.get_scalar_field(1, 1))
# No quantization on particle material in 2D
self.particle.place(self.material)
self.particle.place(self.color)
if self.use_emitter_id:
self.particle.place(self.emitter_ids)
else:
if self.use_emitter_id:
self.particle.place(self.x, self.v, self.F, self.material,
self.color, self.emitter_ids)
else:
self.particle.place(self.x, self.v, self.F, self.material,
self.color)
if self.support_plasticity:
self.particle.place(self.Jp)
if not self.use_g2p2g:
self.particle.place(self.C)
if self.use_ggui:
self.particle.place(self.color_with_alpha)
self.total_substeps = 0
self.unbounded = unbounded
if self.dim == 2:
self.voxelizer = None
self.set_gravity((0, -9.8))
else:
if use_voxelizer:
if USE_IN_BLENDER:
from .voxelizer import Voxelizer
else:
from engine.voxelizer import Voxelizer
self.voxelizer = Voxelizer(res=self.res,
dx=self.dx,
padding=self.padding,
super_sample=voxelizer_super_sample)
else:
self.voxelizer = None
self.set_gravity((0, -9.8, 0))
self.voxelizer_super_sample = voxelizer_super_sample
self.grid_postprocess = []
self.add_bounding_box(self.unbounded)
self.writers = []
if not self.use_g2p2g:
self.grid = self.grid[0]
self.grid_v = self.grid_v[0]
self.grid_m = self.grid_m[0]
self.pid = self.pid[0]
def __init__(
self,
res,
size=1,
max_num_particles=2**27,
# Max 128 MB particles
padding=3,
unbounded=False,
dt_scale=1,
E_scale=1,
voxelizer_super_sample=2):
self.dim = len(res)
assert self.dim in (
2, 3), "MPM solver supports only 2D and 3D simulations."
self.res = res
self.n_particles = ti.field(ti.i32, shape=())
self.dx = size / res[0]
self.inv_dx = 1.0 / self.dx
self.default_dt = 2e-2 * self.dx / size * dt_scale
self.p_vol = self.dx**self.dim
self.p_rho = 1000
self.p_mass = self.p_vol * self.p_rho
self.max_num_particles = max_num_particles
self.gravity = ti.Vector.field(self.dim, dtype=ti.f32, shape=())
self.source_bound = ti.Vector.field(self.dim, dtype=ti.f32, shape=2)
self.source_velocity = ti.Vector.field(self.dim,
dtype=ti.f32,
shape=())
self.pid = ti.field(ti.i32)
# position
self.x = ti.Vector.field(self.dim, dtype=ti.f32)
# velocity
self.v = ti.Vector.field(self.dim, dtype=ti.f32)
# affine velocity field
self.C = ti.Matrix.field(self.dim, self.dim, dtype=ti.f32)
# deformation gradient
self.F = ti.Matrix.field(self.dim, self.dim, dtype=ti.f32)
# material id
self.material = ti.field(dtype=ti.i32)
self.color = ti.field(dtype=ti.i32)
# plastic deformation volume ratio
self.Jp = ti.field(dtype=ti.f32)
if self.dim == 2:
indices = ti.ij
else:
indices = ti.ijk
offset = tuple(-self.grid_size // 2 for _ in range(self.dim))
self.offset = offset
# grid node momentum/velocity
self.grid_v = ti.Vector.field(self.dim, dtype=ti.f32)
# grid node mass
self.grid_m = ti.field(dtype=ti.f32)
grid_block_size = 128
self.grid = ti.root.pointer(indices, self.grid_size // grid_block_size)
if self.dim == 2:
self.leaf_block_size = 16
else:
self.leaf_block_size = 8
block = self.grid.pointer(indices,
grid_block_size // self.leaf_block_size)
def block_component(c):
block.dense(indices, self.leaf_block_size).place(c, offset=offset)
block_component(self.grid_m)
for v in self.grid_v.entries:
block_component(v)
block.dynamic(ti.indices(self.dim),
1024 * 1024,
chunk_size=self.leaf_block_size**self.dim * 8).place(
self.pid, offset=offset + (0, ))
self.padding = padding
# Young's modulus and Poisson's ratio
self.E, self.nu = 1e6 * size * E_scale, 0.2
# Lame parameters
self.mu_0, self.lambda_0 = self.E / (
2 * (1 + self.nu)), self.E * self.nu / ((1 + self.nu) *
(1 - 2 * self.nu))
# Sand parameters
friction_angle = math.radians(45)
sin_phi = math.sin(friction_angle)
self.alpha = math.sqrt(2 / 3) * 2 * sin_phi / (3 - sin_phi)
self.particle = ti.root.dynamic(ti.i, max_num_particles, 2**20)
self.particle.place(self.x, self.v, self.C, self.F, self.material,
self.color, self.Jp)
self.total_substeps = 0
self.unbounded = unbounded
if self.dim == 2:
self.voxelizer = None
self.set_gravity((0, -9.8))
else:
if USE_IN_BLENDER:
from .voxelizer import Voxelizer
else:
from engine.voxelizer import Voxelizer
self.voxelizer = Voxelizer(res=self.res,
dx=self.dx,
padding=self.padding,
super_sample=voxelizer_super_sample)
self.set_gravity((0, -9.8, 0))
self.voxelizer_super_sample = voxelizer_super_sample
self.grid_postprocess = []
self.add_bounding_box(self.unbounded)
self.writers = []
def __init__(self,
res,
size=1,
max_num_particles=2**20,
padding=3,
unbounded=False):
self.dim = len(res)
assert self.dim in (
2, 3), "MPM solver supports only 2D and 3D simulations."
self.res = res
self.n_particles = ti.var(ti.i32, shape=())
self.dx = size / res[0]
self.inv_dx = 1.0 / self.dx
self.default_dt = 2e-2 * self.dx / size
self.p_vol = self.dx**self.dim
self.p_rho = 1000
self.p_mass = self.p_vol * self.p_rho
self.max_num_particles = max_num_particles
self.gravity = ti.Vector(self.dim, dt=ti.f32, shape=())
self.source_bound = ti.Vector(self.dim, dt=ti.f32, shape=2)
self.source_velocity = ti.Vector(self.dim, dt=ti.f32, shape=())
# position
self.x = ti.Vector(self.dim, dt=ti.f32)
# velocity
self.v = ti.Vector(self.dim, dt=ti.f32)
# affine velocity field
self.C = ti.Matrix(self.dim, self.dim, dt=ti.f32)
# deformation gradient
self.F = ti.Matrix(self.dim, self.dim, dt=ti.f32)
# material id
self.material = ti.var(dt=ti.i32)
self.color = ti.var(dt=ti.i32)
# plastic deformation
self.Jp = ti.var(dt=ti.f32)
# grid node momentum/velocity
self.grid_v = ti.Vector(self.dim, dt=ti.f32)
# grid node mass
self.grid_m = ti.var(dt=ti.f32)
if self.dim == 2:
self.grid = ti.root.pointer(ti.ij, 128)
self.grid.pointer(ti.ij, 8).dense(ti.ij,
8).place(self.grid_m,
self.grid_v,
offset=(-4096, -4096))
else:
self.grid = ti.root.pointer(ti.ijk, 128)
self.grid.pointer(ti.ijk,
16).dense(ti.ijk,
4).place(self.grid_m,
self.grid_v,
offset=(-4096, -4096, -4096))
self.padding = padding
# Young's modulus and Poisson's ratio
self.E, self.nu = 1e6 * size, 0.2
# Lame parameters
self.mu_0, self.lambda_0 = self.E / (
2 * (1 + self.nu)), self.E * self.nu / ((1 + self.nu) *
(1 - 2 * self.nu))
# Sand parameters
friction_angle = math.radians(45)
sin_phi = math.sin(friction_angle)
self.alpha = math.sqrt(2 / 3) * 2 * sin_phi / (3 - sin_phi)
ti.root.dynamic(ti.i, max_num_particles,
8192).place(self.x, self.v, self.C, self.F,
self.material, self.color, self.Jp)
self.unbounded = unbounded
if self.dim == 2:
self.voxelizer = None
self.set_gravity((0, -9.8))
else:
if USE_IN_BLENDER:
from .voxelizer import Voxelizer
else:
from engine.voxelizer import Voxelizer
self.voxelizer = Voxelizer(res=self.res,
dx=self.dx,
padding=self.padding)
self.set_gravity((0, -9.8, 0))
self.grid_postprocess = []