numpy.npint

Here are the examples of the python api numpy.npint taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

8 Examples 7

Example 1

Project: fracture-cuda Source File: fracture.py
  def update_zone_map(self):
    self.zone_num[:] = 0
    self.cuda_agg(
        npint(self.nz),
        npint(self.zone_leap),
        npint(self.num),
        drv.In(self.xy[:self.num, :]),
        drv.InOut(self.zone_num),
        drv.Out(self.zone_node),
        block=(self.threads,1,1),
        grid=(int(self.num//self.threads + 1), 1) # this cant be a numpy int for some reason
        )

    if not self.itt%100:
      m = self.zone_num.max()
      assert self.zone_leap-100 > m, 'bad zone leap size'
      print('zone leap ok {:d}>{:d}'.format(self.zone_leap, m))

Example 2

Project: differential-lattice Source File: differentialLattice.py
  def step(self):

    import pycuda.driver as drv

    self.itt += 1

    num = self.num
    xy = self.xy
    dxy = self.dxy
    blocks = num//self.threads + 1

    self.zone_num[:] = 0

    self.cuda_agg(
        npint(num),
        npint(self.nz),
        npint(self.zone_leap),
        drv.In(xy[:num,:]),
        drv.InOut(self.zone_num),
        drv.InOut(self.zone_node),
        block=(self.threads,1,1),
        grid=(blocks,1)
        )

    self.cuda_step(
        npint(num),
        npint(self.nz),
        npint(self.zone_leap),
        drv.In(xy[:num,:]),
        drv.Out(dxy[:num,:]),
        drv.Out(self.tmp[:num,:]),
        drv.Out(self.links[:num*10,:]),
        drv.Out(self.link_counts[:num,:]),
        drv.In(self.zone_num),
        drv.In(self.zone_node),
        npfloat(self.stp),
        npfloat(self.reject_stp),
        npfloat(self.spring_stp),
        npfloat(self.cohesion_stp),
        npfloat(self.spring_reject_rad),
        npfloat(self.spring_attract_rad),
        npint(self.max_capacity),
        npfloat(self.outer_influence_rad),
        npfloat(self.link_ignore_rad),
        block=(self.threads,1,1),
        grid=(blocks,1)
        )

    xy[:num,:] += dxy[:num,:]

Example 3

Project: fracture-cuda Source File: fracture.py
  def frac(self, factor, angle, max_active, dbg=False):
    num = self.num
    fnum = self.fnum
    anum = self.anum

    if anum>max_active:
      return 0

    f_inds = (random(fnum)<factor).nonzero()[0]

    n = len(f_inds)
    if n<1:
      return 0

    visited = self.visited[:num]
    cand_ii = self.fid_node[f_inds, 1]

    xy = self.xy[:num, :]
    new = arange(fnum, fnum+n)
    orig_dxy = self.dxy[f_inds, :]

    diff_theta = (-1)**randint(2, size=n)*HPI + (0.5-random(n)) * angle
    theta = arctan2(orig_dxy[:, 1], orig_dxy[:, 0]) + diff_theta

    fid_node = column_stack((
        new,
        cand_ii
        ))
    cand_dxy = column_stack((
        cos(theta),
        sin(theta)
        ))

    nactive = arange(n)

    tmp_dxy = self.tmp_dxy[:n, :]

    self.update_zone_map()

    self.cuda_calc_stp(
        npint(self.nz),
        npint(self.zone_leap),
        npint(num),
        npint(n),
        npint(n),
        npfloat(self.frac_dot),
        npfloat(self.frac_dst),
        npfloat(self.frac_stp),
        npint(self.ignore_fracture_sources),
        drv.In(visited),
        drv.In(fid_node),
        drv.In(nactive),
        drv.Out(self.tmp[:n, :]),
        drv.In(xy),
        drv.In(cand_dxy),
        drv.Out(tmp_dxy),
        drv.In(self.zone_num),
        drv.In(self.zone_node),
        block=(self.threads,1,1),
        grid=(int(n//self.threads + 1), 1) # this cant be a numpy int for some reason
        )

    mask = tmp_dxy[:, 0] >= -1.0
    n = mask.sum()

    if n<1:
      return 0

    nodes = cand_ii[mask]
    self._add_fracs(cand_dxy[mask, :], nodes)

    if dbg:
      self.print_debug(num, fnum, anum, meta='new: {:d}'.format(n))
    return n

Example 4

Project: fracture-cuda Source File: fracture.py
  def frac_front(self, factor, angle, dbg=False):
    inds = (random(self.anum)<factor).nonzero()[0]

    n = len(inds)
    if n<1:
      return 0

    cand_aa = self.active[inds, 0]
    cand_ii = self.fid_node[cand_aa, 1]

    num = self.num
    fnum = self.fnum
    anum = self.anum

    xy = self.xy[:num, :]
    visited = self.visited[:num, 0]
    new = arange(fnum, fnum+n)
    orig_dxy = self.dxy[cand_aa, :]

    diff_theta = (-1)**randint(2, size=n)*HPI + (0.5-random(n)) * angle
    theta = arctan2(orig_dxy[:, 1], orig_dxy[:, 0]) + diff_theta

    fid_node = column_stack((
        new,
        cand_ii
        ))
    cand_dxy = column_stack((
        cos(theta),
        sin(theta)
        ))

    nactive = arange(n)

    tmp_dxy = self.tmp_dxy[:n, :]

    self.update_zone_map()

    self.cuda_calc_stp(
        npint(self.nz),
        npint(self.zone_leap),
        npint(num),
        npint(n),
        npint(n),
        npfloat(self.frac_dot),
        npfloat(self.frac_dst),
        npfloat(self.frac_stp),
        npint(self.ignore_fracture_sources),
        drv.In(visited),
        drv.In(fid_node),
        drv.In(nactive),
        drv.Out(self.tmp[:n, :]),
        drv.In(xy),
        drv.In(cand_dxy),
        drv.Out(tmp_dxy),
        drv.In(self.zone_num),
        drv.In(self.zone_node),
        block=(self.threads,1,1),
        grid=(int(n//self.threads + 1), 1) # this cant be a numpy int for some reason
        )

    mask = tmp_dxy[:, 0] >= -1.0
    n = mask.sum()

    if n<1:
      return 0

    nodes = cand_ii[mask]
    self._add_fracs(cand_dxy[mask, :], nodes)

    if dbg:
      self.print_debug(num, fnum, anum, meta='new: {:d}'.format(n))
    return n

Example 5

Project: fracture-cuda Source File: fracture.py
  def step(self):
    self.itt += 1

    num = self.num
    fnum = self.fnum
    anum = self.anum

    xy = self.xy[:num, :]
    visited = self.visited[:num, 0]
    active = self.active[:anum]
    fid_node = self.fid_node[:fnum]
    dxy = self.dxy[:fnum, :]
    new_dxy = self.new_dxy[:anum, :] # currently active fractures?

    self.update_zone_map()

    tmp = self.tmp[:anum, :]
    tmp[:,:] = -1
    new_dxy[:,:] = -10
    self.cuda_calc_stp(
        npint(self.nz),
        npint(self.zone_leap),
        npint(num),
        npint(fnum),
        npint(anum),
        npfloat(self.frac_dot),
        npfloat(self.frac_dst),
        npfloat(self.frac_stp),
        npint(self.ignore_fracture_sources),
        drv.In(visited),
        drv.In(fid_node),
        drv.In(active),
        drv.InOut(tmp),
        drv.In(xy),
        drv.In(dxy),
        drv.Out(new_dxy),
        drv.In(self.zone_num),
        drv.In(self.zone_node),
        block=(self.threads,1,1),
        grid=(int(anum//self.threads + 1), 1) # this cant be a numpy int for some reason
        )

    res = self._do_steps(active, new_dxy)

    return res

Example 6

Project: leaf-cuda Source File: leaf.py
  def __make_zonemap(self):

    from pycuda.driver import In
    from pycuda.driver import Out
    from pycuda.driver import InOut

    vxy = self.vxy
    vnum = self.vnum

    zone_num = self.zone_num
    zone = self.zone

    zone_num[:] = 0

    self.cuda_agg_count(
      npint(vnum),
      npint(self.nz),
      In(vxy[:vnum,:]),
      InOut(zone_num),
      block=(self.threads,1,1),
      grid=(vnum//self.threads + 1,1)
    )

    zone_leap = zone_num[:].max()
    zone_map_size = self.nz2*zone_leap

    if zone_map_size>len(self.zone_node):
      print('resize, new zone leap: ', zone_map_size*2./self.nz2)
      self.zone_node = zeros(zone_map_size*2, npint)

    self.zone_node[:] = 0
    zone_num[:] = 0

    self.cuda_agg(
      npint(vnum),
      npint(self.nz),
      npint(zone_leap),
      In(vxy[:vnum,:]),
      InOut(zone_num),
      InOut(self.zone_node),
      Out(zone[:vnum]),
      block=(self.threads,1,1),
      grid=(vnum//self.threads + 1,1)
    )

    return zone_leap, self.zone_node, zone_num

Example 7

Project: leaf-cuda Source File: leaf.py
  def __rnn_query(self, zone_leap, zone_node, zone_num):

    from pycuda.driver import In
    from pycuda.driver import InOut

    snum = self.snum
    vnum = self.vnum

    sv_size = self.sv_size

    sv = self.sv[:sv_size]
    sv_num = self.sv_num[:sv_size]
    dst = self.dst[:sv_size]

    sv_num[:] = 0
    sv[:] = -5
    dst[:] = -10.0

    self.cuda_rnn(
      npint(self.nz),
      npfloat(self.area_rad),
      npfloat(self.kill_rad),
      npint(zone_leap),
      npint(self.sv_leap),
      In(zone_num),
      In(zone_node),
      npint(snum),
      npint(vnum),
      In(self.smask),
      In(self.sxy),
      In(self.vxy[:vnum,:]),
      InOut(sv_num),
      InOut(sv),
      InOut(dst),
      block=(self.threads,1,1),
      grid=(snum//self.threads + 1,1)
    )

    return sv_num, sv, dst

Example 8

Project: leaf-cuda Source File: leaf.py
  def __growth(
    self,
    zone_leap,
    zone_num,
    zone_node,
    vs_map,
    vs_ind,
    vs_counts
  ):

    from pycuda.driver import In
    from pycuda.driver import InOut

    vnum = self.vnum
    enum = self.enum
    has_descendants = self.has_descendants
    gen = self.gen

    vec = self.vec[:vnum,:]

    stp = self.stp
    kill_rad = self.kill_rad

    edges = self.edges
    parent = self.parent
    sxy = self.sxy
    vxy = self.vxy

    vec[:,:] = -99.0

    self.cuda_growth(
      npint(self.nz),
      npfloat(kill_rad),
      npfloat(stp),
      npint(zone_leap),
      In(zone_num),
      In(zone_node),
      In(vs_map),
      In(vs_ind),
      In(vs_counts),
      In(sxy),
      In(vxy[:vnum,:]),
      npint(vnum),
      InOut(vec),
      block=(self.threads,1,1),
      grid=(vnum//self.threads + 1,1)
    )

    abort = True
    for i in range(vnum):
      gv = vec[i,:]
      if gv[0]<-3.0:
        continue

      if has_descendants[i]:
        gen[vnum] = gen[i]+1
      else:
        gen[vnum] = gen[i]
      has_descendants[i] = True
      edges[enum, :] = [i,vnum]
      parent[vnum] = i
      vxy[vnum,:] = gv
      abort = False
      enum += 1
      vnum += 1

    self.enum = enum
    self.vnum = vnum

    return abort