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
3
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))
0
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,:]
0
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
0
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
0
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
0
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
0
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
0
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