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
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,:]
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
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
def map_angle(ang, range=None, units=None): period = cnst.period_for_unit(units) ang = np.atleast_1d(npfloat(ang)) # if we have a specified angular range, use it if range is not None: angRange = np.atleast_1d(npfloat(args[0])) # divide of multiples of period ang = ang - npint(ang / period) * period lb = angRange.min() ub = angRange.max() if abs(ub - lb) != period: raise RuntimeError('range is incomplete!') lbi = ang < lb while lbi.sum() > 0: ang[lbi] = ang[lbi] + period lbi = ang < lb pass ubi = ang > ub while ubi.sum() > 0: ang[ubi] = ang[ubi] - period ubi = ang > ub pass retval = ang # shouldn't all this be equivalent to: # retval = np.mod(ang - lb, period) + lb ???? # note the particular case below for range (-0.5*period, +0.5*period) # where lb would be -0.5*period. else: retval = np.mod(ang + 0.5*period, period) - 0.5*period return retval
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, :]
def inside(*args, **kwargs): res = f(*args, **kwargs) self = args[0] if self.noise is not None: rad = npfloat(self.noise) ng = res.shape[0] xy = zeros((ng, 2), npfloat) mid = zeros((1, 2), npfloat) _cuda_sample_circle(npint(ng), RGEN.gen_uniform((ng, 3), npfloat), cuda.Out(xy), rad, cuda.In(mid), npint(ng), block=(THREADS, 1, 1), grid=(int(ng//THREADS + 1), 1)) return res + xy return res
def float(self): """ convert inner-type to 'float' usage: >>> int1 = interval(-1, 1) >>> interval.float(int1) or >>> int1.float() """ from numpy import float as npfloat if isinstance(self, interval): self.inf = self.inf * 1.0 self.sup = self.sup * 1.0 else: return npfloat(self) return interval(self.inf, self.sup)
def sample(self, imsize, verbose=False): if not self._cinit: self.__cuda_init() grains = self._get_n(imsize) ng = self.num*grains shape = (ng, 3) xy = zeros((ng, 2), npfloat) _cuda_sample_circle(npint(ng), RGEN.gen_uniform(shape, npfloat), cuda.Out(xy), npfloat(self.rad), self._mid, npint(grains), block=(THREADS, 1, 1), grid=(int(ng//THREADS + 1), 1)) return xy
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
def step(self, t=None): import pycuda.driver as drv self.itt += 1 num = self.num xy = self.xy dxy = self.dxy tmp = self.tmp link_len = self.link_len link_curv = self.link_curv blocks = num//self.threads + 1 self.zone_num[:] = 0 self.cuda_agg_count( npint(num), npint(self.nz), drv.In(xy[:num,:]), drv.InOut(self.zone_num), block=(self.threads,1,1), grid=(blocks,1) ) zone_leap = self.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_num[:] = 0 self.cuda_agg( npint(num), npint(self.nz), npint(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(zone_leap), drv.In(xy[:num,:]), drv.Out(dxy[:num,:]), drv.Out(tmp[:num,:]), drv.Out(link_len[:num,:]), drv.Out(link_curv[:num,:]), drv.In(self.links[:num,:]), drv.In(self.zone_num), drv.In(self.zone_node), npfloat(self.stp), npfloat(self.reject_stp), npfloat(self.spring_stp), npfloat(self.near_rad), npfloat(self.far_rad), block=(self.threads,1,1), grid=(blocks,1) ) xy[:num,:] += dxy[:num,:]
def step(self, t=None): import pycuda.driver as drv self.itt += 1 num = self.num xy = self.xy dxy = self.dxy tmp = self.tmp link_len = self.link_len link_curv = self.link_curv blocks = num // self.threads + 1 self.zone_num[:] = 0 self.cuda_agg_count(npint(num), npint(self.nz), drv.In(xy[:num, :]), drv.InOut(self.zone_num), block=(self.threads, 1, 1), grid=(blocks, 1)) zone_leap = self.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_num[:] = 0 self.cuda_agg(npint(num), npint(self.nz), npint(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(zone_leap), drv.In(xy[:num, :]), drv.Out(dxy[:num, :]), drv.Out(tmp[:num, :]), drv.Out(link_len[:num, :]), drv.Out(link_curv[:num, :]), drv.In(self.links[:num, :]), drv.In(self.zone_num), drv.In(self.zone_node), npfloat(self.stp), npfloat(self.reject_stp), npfloat(self.spring_stp), npfloat(self.near_rad), npfloat(self.far_rad), block=(self.threads, 1, 1), grid=(blocks, 1)) xy[:num, :] += dxy[:num, :]
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 xrange(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
def setValues(self, data): self.identity() self.m[12] = npfloat(data[0]) self.m[13] = npfloat(data[1]) self.m[0] = npfloat(data[2])
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