How to use the taichi.atomic_add function in taichi

To help you get started, we’ve selected a few taichi examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github yuanming-hu / taichi / tests / python / test_complex_kernels.py View on Github external
def func(mul: ti.f32):
    for i in range(n):
      ti.atomic_add(total[None], x[i] * mul)
github yuanming-hu / taichi / examples / difftaichi / liquid_render.py View on Github external
def compute_loss(t: ti.i32):
  for i in range(n_grid):
    for j in range(n_grid):
      ti.atomic_add(loss, dx * dx * ti.sqr(target[i, j] - p[t, i, j]))
github taichi-dev / elements / engine / mpm_solver.py View on Github external
def seed_from_voxels(self, material: ti.i32, color: ti.i32,
                         sample_density: ti.i32):
        for i, j, k in self.voxelizer.voxels:
            inside = 1
            for d in ti.static(range(3)):
                inside = inside and self.padding <= i and i < self.res[
                    d] - self.padding
            if inside and self.voxelizer.voxels[i, j, k] > 0:
                for l in range(sample_density):
                    x = ti.Vector(
                        [ti.random() + i,
                         ti.random() + j,
                         ti.random() + k]) * self.dx + self.source_bound[0]
                    p = ti.atomic_add(self.n_particles[None], 1)
                    self.seed_particle(p, x, material, color,
                                       self.source_velocity[None])
github yuanming-hu / taichi / examples / difftaichi / rigid_body.py View on Github external
def apply_impulse(t, i, impulse, location, toi_input):
  # ti.print(toi)
  delta_v = impulse * inverse_mass[i]
  delta_omega = cross(location - x[t, i], impulse) * inverse_inertia[i]

  toi = ti.min(ti.max(0.0, toi_input), dt)

  ti.atomic_add(x_inc[t + 1, i], toi * (-delta_v))
  ti.atomic_add(rotation_inc[t + 1, i], toi * (-delta_omega))

  ti.atomic_add(v_inc[t + 1, i], delta_v)
  ti.atomic_add(omega_inc[t + 1, i], delta_omega)
github yuanming-hu / taichi / examples / difftaichi / rigid_body_discountinuity.py View on Github external
def apply_impulse(t, i, impulse, location):
  ti.atomic_add(v_inc[t + 1, i], impulse * inverse_mass[i])
  ti.atomic_add(omega_inc[t + 1, i],
                cross(location - x[t, i], impulse) * inverse_inertia[i])
github yuanming-hu / taichi / examples / difftaichi / mass_spring_velocity.py View on Github external
def apply_spring_force(t: ti.i32):
  for i in range(n_springs):
    a = spring_anchor_a[i]
    b = spring_anchor_b[i]
    pos_a = x[t, a]
    pos_b = x[t, b]
    dist = pos_a - pos_b
    length = dist.norm() + 1e-4

    target_length = spring_length[i] * (1.0 + spring_actuation[i] * act[t, i])
    impulse = dt * (
        length - target_length) * spring_stiffness[i] / length * dist

    ti.atomic_add(v_inc[t + 1, a], -impulse)
    ti.atomic_add(v_inc[t + 1, b], impulse)
github yuanming-hu / taichi / examples / mpm_lagrangian_forces.py View on Github external
def compute_total_energy():
  for i in range(n_elements):
    currentT = compute_T(i)
    F = currentT @ restT[i].inverse()
    # NeoHookean
    I1 = (F @ ti.Matrix.transposed(F)).trace()
    J = ti.Matrix.determinant(F)
    element_energy = 0.5 * mu * (
        I1 - 2) - mu * ti.log(J) + 0.5 * la * ti.log(J)**2
    ti.atomic_add(total_energy[None], element_energy * 1e-3)