Beispiel #1
0
def line_segment(X0, X1):
    r"""
    Calculate the voxel coordinates of a straight line between the two given
    end points

    Parameters
    ----------
    X0 and X1 : array_like
        The [x, y] or [x, y, z] coordinates of the start and end points of
        the line.

    Returns
    -------
    coords : list of lists
        A list of lists containing the X, Y, and Z coordinates of all voxels
        that should be drawn between the start and end points to create a solid
        line.
    """
    X0 = sp.around(X0).astype(int)
    X1 = sp.around(X1).astype(int)
    if len(X0) == 3:
        L = sp.amax(sp.absolute([[X1[0]-X0[0]], [X1[1]-X0[1]], [X1[2]-X0[2]]])) + 1
        x = sp.rint(sp.linspace(X0[0], X1[0], L)).astype(int)
        y = sp.rint(sp.linspace(X0[1], X1[1], L)).astype(int)
        z = sp.rint(sp.linspace(X0[2], X1[2], L)).astype(int)
        return [x, y, z]
    else:
        L = sp.amax(sp.absolute([[X1[0]-X0[0]], [X1[1]-X0[1]]])) + 1
        x = sp.rint(sp.linspace(X0[0], X1[0], L)).astype(int)
        y = sp.rint(sp.linspace(X0[1], X1[1], L)).astype(int)
        return [x, y]
def test_distance_center():
    shape = sp.array([7, 5, 9])
    spacing = sp.array([2, 1, 0.5])
    pn = OpenPNM.Network.Cubic(shape=shape, spacing=spacing)
    sx, sy, sz = spacing
    center_coord = sp.around(topology.find_centroid(pn['pore.coords']), 7)
    cx, cy, cz = center_coord
    coords = pn['pore.coords']
    x, y, z = coords.T
    coords = sp.concatenate((coords, center_coord.reshape((1, 3))))
    pn['pore.center'] = False
    mask1 = (x <= (cx + sx/2)) * (y <= (cy + sy/2)) * (z <= (cz + sz/2))
    mask2 = (x >= (cx - sx/2)) * (y >= (cy - sy/2)) * (z >= (cz - sz/2))
    center_pores_mask = pn.Ps[mask1 * mask2]
    pn['pore.center'][center_pores_mask] = True
    center = pn.Ps[pn['pore.center']]
    L1 = sp.amax(topology.find_pores_distance(network=pn,
                                              pores1=center,
                                              pores2=pn.Ps))
    L2 = sp.amax(topology.find_pores_distance(network=pn,
                                              pores1=pn.Ps,
                                              pores2=pn.Ps))
    l1 = ((shape[0] - 1) * sx) ** 2
    l2 = ((shape[1] - 1) * sy) ** 2
    l3 = ((shape[2] - 1) * sz) ** 2
    L3 = sp.sqrt(l1 + l2 + l3)
    assert sp.around(L1 * 2, 7) == sp.around(L2, 7)
    assert sp.around(L2, 7) == sp.around(L3, 7)
Beispiel #3
0
def getDirectLight(latitude,
                   longitude,
                   jourJul,
                   startH,
                   stopH,
                   step=30,
                   decalSun=1,
                   decalGMT=0):
    # startH and stopH represent starting and stoping hour for the light, given in hour
    # step are time step, given in minute
    # decalGMT give 'fuseau horaire' express in hour
    seq = sp.Sequence()
    hdeb = seq.heureTSV(jourJul, startH, decalSun, decalGMT, longitude)
    hfin = seq.heureTSV(jourJul, stopH, decalSun, decalGMT, longitude)
    az, el, time = seq.positionSoleil(step, radians(latitude), jourJul, hdeb,
                                      hfin)
    sw = 0
    for h in el:
        sw += 0.7**(1. / sin(h)) * sin(h)
    w = [0.7**(1. / sin(h)) * sin(h) / sw for h in el]
    tot = 0
    for s in w:
        tot += s
    if round(tot, 1) != 1.0:
        print "sum weight : ", tot
    return [(around(degrees(az[i]), 2), around(degrees(el[i]), 2), w[i])
            for i in range(len(az))]
Beispiel #4
0
 def test_domain_dimensions(self):
     face1 = self.net.pores('bottom_boundary')
     face2 = self.net.pores('top_boundary')
     assert sp.around(self.net.domain_length(face1, face2) / self.scale,
                      3) == 1.0
     assert sp.around(self.net.domain_area(face1) / self.scale**2,
                      3) == 1.0
def binary_errors(CS_object, nonzero_bounds=[0.7, 1.3], zero_bound=1. / 25):

    Nn = CS_object.Nn
    mu_dSs = CS_object.mu_dSs
    sparse_idxs = CS_object.idxs[0]

    errors_nonzero = 0
    errors_zero = 0

    for iN in range(Nn):
        if iN in sparse_idxs:
            scaled_estimate = 1. * CS_object.dSs_est[iN] / CS_object.dSs[iN]
            if nonzero_bounds[0] < scaled_estimate < nonzero_bounds[1]:
                errors_nonzero += 1
        else:
            if abs(CS_object.dSs_est[iN]) < abs(mu_dSs * zero_bound):
                errors_zero += 1

    errors = dict()
    errors['errors_nonzero'] = sp.around(1.*errors_nonzero/ \
              len(sparse_idxs)*100., 2)
    errors['errors_zero'] = sp.around(1.*errors_zero/ \
              (Nn - len(sparse_idxs))*100., 2)

    return errors
Beispiel #6
0
 def test_mesh_surface_area(self):
     region = self.regions == self.regions.max()
     mesh = ps.tools.mesh_region(region)
     a = ps.metrics.mesh_surface_area(mesh)
     assert sp.around(a, decimals=2) == 258.3
     b = ps.metrics.mesh_surface_area(verts=mesh.verts, faces=mesh.faces)
     assert sp.around(b, decimals=2) == sp.around(a, decimals=2)
Beispiel #7
0
 def generate(self, **params):
     r'''
     radius: int
         The physical radius of the netowrk.  The number of pores determined
         from this and the lattice_spacing parameter.
     lattice_spacing : float
         The lattice constant for the network, used to scale distance between pores.
     '''
     self._logger.info(sys._getframe().f_code.co_name+": Start of network topology generation")
     #create spherical template, then call normal template procedure
     self._radius = params['radius']
     self._length = params['length']
     Nr = sp.around(self._radius/params['lattice_spacing'])
     Lz = sp.around(self._length/params['lattice_spacing'])
     temp = sp.ones((2*Nr, 2*Nr, Lz))
     temp[Nr, Nr, :] = 0
     temp = spim.distance_transform_edt(temp)
     temp = temp < Nr
     params['template'] = temp
     #Call standard generation protocol
     self._generate_setup(**params)
     self._generate_pores()
     self._generate_throats()
     self._add_boundaries()
     self._add_labels()
     self._logger.debug(sys._getframe().f_code.co_name+": Network generation complete")        
     return self
Beispiel #8
0
def xover(chrom,N,p):
    """Single point crossover with probability N,precision p
    """
    N = round(chrom.shape[0]*N)
    index1 = scipy.arange(chrom.shape[0])
    index2 = scipy.unique(scipy.around(scipy.rand(chrom.shape[0],)*chrom.shape[0]))[0:chrom.shape[0]/2]
    sel1,sel2 = [],[]
    for i in range(len(index1)):
        if index1[i] not in index2:
            sel1.append(index1[i])
        else:
            sel2.append(index1[i])
    select1 = sel1[0:min([int(round(len(sel1)*N)),int(round(len(sel2)*N))])]
    select2 = sel2[0:min([int(round(len(sel1)*N)),int(round(len(sel2)*N))])]       
    
    # set xover points
    xoverpnt = scipy.around(scipy.rand(len(select1),)*(chrom.shape[1]-1))
    
    # perform xover
    nchrom = copy.deepcopy(chrom)
    for i in range(len(select1)):
        try:
            slice1 = chrom[select1[i],0:int(xoverpnt[i])]
            slice2 = chrom[select2[i],0:int(xoverpnt[i])]
            nchrom[select2[i],0:int(xoverpnt[i])] = slice1
            nchrom[select1[i],0:int(xoverpnt[i])] = slice2
        except:
            nchrom = nchrom
    
    return nchrom
Beispiel #9
0
 def test_domain_dimensions(self):
     face1 = self.net.pores('bottom_boundary')
     face2 = self.net.pores('top_boundary')
     assert sp.around(self.net.domain_length(face1, face2) / self.scale,
                      3) == 1.0
     assert sp.around(self.net.domain_area(face1) / self.scale**2,
                      3) == 1.0
Beispiel #10
0
    def write_extraction_mask(self):
        """ write both the .roi file and the tif pages
        ROI file format specification: each row a ROI,
        first col: kw for roi type
        if circle: label, layer, pos x, pos y, diameter
        if poly: label, layer, pos x_1, pos_y1, ... pos x_n, pos y_n
        """
        outpath = self.SaveFileDialog(
            title='saving ROIs',
            default_dir=self.Main.Options.general['cwd'],
            extension='*.roi')
        outpath = self.append_extension(outpath, '.roi')

        fh = open(outpath, 'w')

        # iterate over ROIs
        for i, ROI in enumerate(self.Main.ROIs.ROI_list):
            label = str(ROI.label)

            if type(ROI) == myCircleROI:
                #                pos = sp.array([ROI.pos().x(),ROI.pos().y()])
                #                pos = self.get_ROI_position(ROI)
                x = str(sp.around(ROI.center[0], decimals=2))
                y = str(sp.around(ROI.center[1], decimals=2))
                d = str(sp.around(ROI.diameter, decimals=2))

                fh.write('\t'.join(['circle', label, x, y, d, '\n']))

            if type(ROI) == myPolyLineROI:
                fh.write('\t'.join(['polygon', label]))
                fh.write('\t')

                handle_pos = [tup[1] for tup in ROI.getSceneHandlePositions()]
                pos_mapped = [ROI.ViewBox.mapToView(pos) for pos in handle_pos]

                for pos in (pos_mapped):

                    x = pos.x()
                    y = pos.y()

                    fh.write('\t'.join([
                        str(sp.around(x, decimals=2)),
                        str(sp.around(y, decimals=2))
                    ]))
                    fh.write('\t')
                fh.write('\n')

        fh.close()

        print("saved ROIs in .roi format to", outpath)
        #        outpath = os.path.splitext(outpath)[0] + '_mask.tif'
        #        outpath = self.MainWindow.SaveFileDialog(title='saving ROIs',defaultdir=self.path,extension='.tif')

        # extraction mask
        self.Main.Processing.calc_extraction_mask()
        io.save_tstack(self.Main.Data.extraction_mask.astype('uint16'),
                       os.path.splitext(outpath)[0] + '_mask.tif')
        print("saved ROIs in .tif format to", outpath)

        pass
Beispiel #11
0
def test_distance_center():
    shape = sp.array([7, 5, 9])
    spacing = sp.array([2, 1, 0.5])
    pn = OpenPNM.Network.Cubic(shape=shape, spacing=spacing)
    sx, sy, sz = spacing
    center_coord = sp.around(topology.find_centroid(pn['pore.coords']), 7)
    cx, cy, cz = center_coord
    coords = pn['pore.coords']
    x, y, z = coords.T
    coords = sp.concatenate((coords, center_coord.reshape((1, 3))))
    pn['pore.center'] = False
    mask1 = (x <= (cx + sx / 2)) * (y <= (cy + sy / 2)) * (z <= (cz + sz / 2))
    mask2 = (x >= (cx - sx / 2)) * (y >= (cy - sy / 2)) * (z >= (cz - sz / 2))
    center_pores_mask = pn.Ps[mask1 * mask2]
    pn['pore.center'][center_pores_mask] = True
    center = pn.Ps[pn['pore.center']]
    L1 = sp.amax(
        topology.find_pores_distance(network=pn, pores1=center, pores2=pn.Ps))
    L2 = sp.amax(
        topology.find_pores_distance(network=pn, pores1=pn.Ps, pores2=pn.Ps))
    l1 = ((shape[0] - 1) * sx)**2
    l2 = ((shape[1] - 1) * sy)**2
    l3 = ((shape[2] - 1) * sz)**2
    L3 = sp.sqrt(l1 + l2 + l3)
    assert sp.around(L1 * 2, 7) == sp.around(L2, 7)
    assert sp.around(L2, 7) == sp.around(L3, 7)
Beispiel #12
0
def print_msg(msg, log=True):
    """prints the msg string with elapsed time and current memory usage.

    Args:
        msg (str): the string to print
        log (bool): write the msg to the log as well

    """
    if os.name == 'posix':
        mem_used = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1e6
        mem_used = sp.around(mem_used, 2)
        memstr = '(' + str(mem_used) + ' GB): '
        timestr = tp.humantime(sp.around(time.time() - t0, 2))
        print(colorama.Fore.CYAN + timestr + '\t' + memstr + '\t' +
              colorama.Fore.GREEN + msg)
        if log:
            with open('log.log', 'a+') as fH:
                log_str = timestr + '\t' + memstr + '\t' + msg
                fH.writelines(log_str)
    else:
        timestr = tp.humantime(sp.around(time.time() - t0, 2))
        print(colorama.Fore.CYAN + timestr + '\t' + colorama.Fore.GREEN + msg)
        if log:
            with open('log.log', 'a+') as fH:
                log_str = timestr + '\t' + '\t' + msg
                fH.writelines(log_str)
    pass
Beispiel #13
0
def do_local(local_graph):
    local_n = local_graph.number_of_nodes()

    local_P = generate_transition_matrix(local_graph, local_n)
    print 'Local probability transition matrix:'
    print sp.around(local_P, 3)
    print 'Done getting local P'

    w, vr = equilibrium_distribution(local_P)
    # Find the index of the eigenvalue 1

    index = sp.where((w > 0.999999999999999) * (w < 1.000000000000001))[0]
    print index
    #if index.size == 0:
    #    if roundoff == 0:
    #        raise ValueError
    #    P = sp.around(P, roundoff-1)
    #    return equilibrium_distribution(P, roundoff-1)

    eigen_index = 0
    while(1):
        try:
            chosen_index = index[eigen_index]
        except IndexError:
            print 'No eigenvalue of 1 exists, or no eigenvector of 1 exists'
            print 'which allows the fundamental matrix to be non-singular'
            raise

        local_eq_pi = vr[:, chosen_index]
        print 'Local eigenvector:'
        print local_eq_pi
        print 'Done getting local pi'
        print 'Finiteness check:',
        try:
            local_eq_pi = sp.asarray_chkfinite(local_eq_pi)
            print 'OK'
        except ValueError:
            eigen_index += 1
            continue

        local_W = equilibrium_transition_matrix(local_eq_pi, local_n)
        print 'Done getting local W'

        try:
            local_Z = fundamental_matrix(local_P, local_W, local_n)
            print 'Done getting local Z'
            break
        except linalg.LinAlgError:
            eigen_index += 1

    local_Ei_Ti, local_Ei_Tj, local_Epi_Ti = hitting_times(local_eq_pi, local_Z,
                                                           local_n)
    print 'Done getting local hitting times'

    return local_Ei_Ti, local_Ei_Tj, local_Epi_Ti
Beispiel #14
0
    def _get_fibre_slice(self, plane=None, index=None):
        r"""
        Plot an image of a slice through the fibre image
        plane contains percentage values of the length of the image in each axis

        Parameters
        ----------
        plane : array_like
        List of 3 values, [x,y,z], 2 must be zero and the other must be between
        zero and one representing the fraction of the domain to slice along
        the non-zero axis

        index : array_like
        similar to plane but instead of the fraction an index of the image is used
        """
        if hasattr(self, '_fibre_image') is False:
            logger.warning(
                'This method only works when a fibre image exists, ' +
                'please run make_fibre_image')
            return None
        if plane is None and index is None:
            logger.warning(
                'Please provide either a plane array or index array')
            return None
        if self._fibre_image is None:
            self.make_fibre_image()

        if plane is not None:
            if 'array' not in plane.__class__.__name__:
                plane = sp.asarray(plane)
            if sp.sum(plane == 0) != 2:
                logger.warning('Plane argument must have two zero valued ' +
                               'elements to produce a planar slice')
                return None
            l = sp.asarray(sp.shape(self._fibre_image))
            s = sp.around(plane * l).astype(int)
        elif index is not None:
            if 'array' not in index.__class__.__name__:
                index = sp.asarray(index)
            if sp.sum(index == 0) != 2:
                logger.warning('Index argument must have two zero valued ' +
                               'elements to produce a planar slice')
                return None
            if 'int' not in str(index.dtype):
                index = sp.around(index).astype(int)
            s = index

        if s[0] != 0:
            slice_image = self._fibre_image[s[0], :, :]
        elif s[1] != 0:
            slice_image = self._fibre_image[:, s[1], :]
        else:
            slice_image = self._fibre_image[:, :, s[2]]

        return slice_image
Beispiel #15
0
def generate_transition_matrix(graph, n=None):
    """
    Generates the probability transition matrix for a given graph. It is
    assumed that all edges have weights and that the probability of transition
    from one node to a neighbouring node is proportional to the weight of the
    edge connecting the two nodes, normalised over all current outgoing edges.
    
    Parameters
    ----------
    graph : networkx.Graph
        Graph whose transition matrix is to be found. It is assumed that the
        weight of each edge can be found under the attribute name ``weight``.
    n : int (optional)
        Number of nodes in the graph.
    
    Returns
    -------
    P : numpy.ndarray
        Markov probability transition matrix for the given graph
    
    Notes
    -----
    This method works only for an undirected graph. If the adjacency matrix is
    represented as A[i,j], then it is assumed that an edge "goes" from node j
    to node i. The transition matrix is appropriately defined. The equilibrium
    distribution of states would therefore be the right eigenvectors of the
    resulting matrix.
    """
    
    # First, get the adjacency matrix of the graph
    P = sp.array(nx.adjacency_matrix(graph))
    print 'Adjacency matrix:'
    print sp.around(P)
    # We'll also need the number of nodes
    if n is None:
        n = graph.number_of_nodes()
    
    # The probability transition matrix is simply the adjacency matrix itself,
    # but with values along each column scaled so that every column sums up to
    # unity.
    k = sp.dot(sp.ones((1, n)), P)    # Vector of degrees
    print 'Vector of degrees:', k
    # Stack degrees vertically:
    K = sp.multiply(sp.ones((n, 1)), k)
    P /= K
    print 'Left stochastic check:', sp.dot(sp.ones((1, n)), P)
    
    # If any elements of K were zero, the corresponding elements of P would go
    # infinite. But logically, if the degree of a vertex is zero, then there is
    # no way to get to it, or out of it. Therefore, it should just appear as a
    # zero in the probability transition matrix. We explicitly set this.
    z = sp.where(sp.isnan(P))
    P[z] = 0
    
    return sp.asarray_chkfinite(P)
Beispiel #16
0
    def _get_fibre_slice(self, plane=None, index=None):
        r"""
        Plot an image of a slice through the fibre image
        plane contains percentage values of the length of the image in each axis

        Parameters
        ----------
        plane : array_like
        List of 3 values, [x,y,z], 2 must be zero and the other must be between
        zero and one representing the fraction of the domain to slice along
        the non-zero axis

        index : array_like
        similar to plane but instead of the fraction an index of the image is used
        """
        if hasattr(self, '_fibre_image') is False:
            logger.warning('This method only works when a fibre image exists, ' +
                           'please run make_fibre_image')
            return None
        if plane is None and index is None:
            logger.warning('Please provide either a plane array or index array')
            return None
        if self._fibre_image is None:
            self.make_fibre_image()

        if plane is not None:
            if 'array' not in plane.__class__.__name__:
                plane = sp.asarray(plane)
            if sp.sum(plane == 0) != 2:
                logger.warning('Plane argument must have two zero valued ' +
                               'elements to produce a planar slice')
                return None
            l = sp.asarray(sp.shape(self._fibre_image))
            s = sp.around(plane*l).astype(int)
        elif index is not None:
            if 'array' not in index.__class__.__name__:
                index = sp.asarray(index)
            if sp.sum(index == 0) != 2:
                logger.warning('Index argument must have two zero valued ' +
                               'elements to produce a planar slice')
                return None
            if 'int' not in str(index.dtype):
                index = sp.around(index).astype(int)
            s = index

        if s[0] != 0:
            slice_image = self._fibre_image[s[0], :, :]
        elif s[1] != 0:
            slice_image = self._fibre_image[:, s[1], :]
        else:
            slice_image = self._fibre_image[:, :, s[2]]

        return slice_image
Beispiel #17
0
    def write_extraction_mask(self):
        """ write both the .roi file and the tif pages
        ROI file format specification: each row a ROI,
        first col: kw for roi type
        if circle: label, layer, pos x, pos y, diameter
        if poly: label, layer, pos x_1, pos_y1, ... pos x_n, pos y_n
        """
        outpath = self.SaveFileDialog(title='saving ROIs',default_dir = self.Main.Options.general['cwd'], extension='*.roi')
        outpath = self.append_extension(outpath, '.roi')

        fh = open(outpath,'w')

        # iterate over ROIs
        for i,ROI in enumerate(self.Main.ROIs.ROI_list):
            label = str(ROI.label)

            if type(ROI) == myCircleROI:
#                pos = sp.array([ROI.pos().x(),ROI.pos().y()])
#                pos = self.get_ROI_position(ROI)
                x = str(sp.around(ROI.center[0],decimals=2))
                y = str(sp.around(ROI.center[1],decimals=2))
                d = str(sp.around(ROI.diameter,decimals=2))

                fh.write('\t'.join(['circle',label,x,y,d,'\n']))

            if type(ROI) == myPolyLineROI:
                 fh.write('\t'.join(['polygon',label]))
                 fh.write('\t')

                 handle_pos = [tup[1] for tup in ROI.getSceneHandlePositions()]
                 pos_mapped = [ROI.ViewBox.mapToView(pos) for pos in handle_pos]

                 for pos in (pos_mapped):

                     x = pos.x()
                     y = pos.y()

                     fh.write('\t'.join([str(sp.around(x,decimals=2)),str(sp.around(y,decimals=2))]))
                     fh.write('\t')
                 fh.write('\n')

        fh.close()

        print("saved ROIs in .roi format to", outpath)
#        outpath = os.path.splitext(outpath)[0] + '_mask.tif'
#        outpath = self.MainWindow.SaveFileDialog(title='saving ROIs',defaultdir=self.path,extension='.tif')

        # extraction mask
        self.Main.Processing.calc_extraction_mask()
        io.save_tstack(self.Main.Data.extraction_mask.astype('uint16'),os.path.splitext(outpath)[0] + '_mask.tif')
        print("saved ROIs in .tif format to", outpath)

        pass
def get_cb_ticks(values):
    min_tick = sp.nanmin(values)
    max_tick = sp.nanmax(values)
    med_tick = min_tick + (max_tick - min_tick) / 2.0
    if max_tick > 1.0:
        min_tick = sp.ceil(min_tick)
        max_tick = sp.floor(max_tick)
        med_tick = sp.around(med_tick)
    else:
        min_tick = sp.ceil(min_tick * 100.0) / 100.0
        max_tick = sp.floor(max_tick * 100.0) / 100.0
        med_tick = sp.around(med_tick, 2)
    return [min_tick, med_tick, max_tick]
def binary_errors_dual_odor(CS_object, nonzero_bounds=[0.7, 1.3], 
							zero_bound=1./25):
	
	Nn = CS_object.Nn
	mu_dSs = CS_object.mu_dSs
	mu_dSs_2 = CS_object.mu_dSs_2
	sparse_idxs =  CS_object.idxs[0]
	idxs_2 =  CS_object.idxs_2
	
	errors_nonzero = 0
	errors_nonzero_2 = 0
	errors_zero = 0
	errors_zero_2 = 0
	
	for iN in range(Nn):
		if iN in sparse_idxs: 
			if iN in idxs_2:
				scaled_estimate = 1.*CS_object.dSs_est[iN]/CS_object.dSs[iN]
				if nonzero_bounds[0] < scaled_estimate < nonzero_bounds[1]:
					errors_nonzero_2 += 1
			else:
				scaled_estimate = 1.*CS_object.dSs_est[iN]/CS_object.dSs[iN]
				if nonzero_bounds[0] < scaled_estimate < nonzero_bounds[1]:
					errors_nonzero += 1
		else:
			if abs(CS_object.dSs_est[iN]) <  abs(mu_dSs*zero_bound):
				errors_zero += 1
			if CS_object.Kk_split != 0:
				if abs(CS_object.dSs_est[iN]) <  abs(mu_dSs_2*zero_bound):
					errors_zero_2 += 1
			
	errors = dict()
	
	# Save errors; special cases if split is 0 or full
	if set(idxs_2) == set(sparse_idxs):
		errors['errors_nonzero'] = 0
	else:
		errors['errors_nonzero'] = \
			sp.around(1.*errors_nonzero/(len(sparse_idxs) - len(idxs_2))*100, 2)
	if len(idxs_2) == 0:
		errors['errors_nonzero_2'] = 0
	else:
		errors['errors_nonzero_2'] = \
			sp.around(1.*errors_nonzero_2/len(idxs_2)*100., 2)
	errors['errors_zero'] = \
		sp.around(1.*errors_zero/(Nn - len(sparse_idxs))*100., 2)
	errors['errors_zero_2'] = \
		sp.around(1.*errors_zero_2/(Nn - len(sparse_idxs))*100., 2)
										
	return errors
def binary_errors_temporal_run(init_CS_object, dSs, dSs_est, mu_dSs, 
								nonzero_bounds=[0.7, 1.3], zero_bound=1./10, 
								dual=False):
	
	# Last index is the actual stimulus vector; first index is timepoint
	Nn = init_CS_object.Nn
	sparse_idxs =  init_CS_object.idxs[0]
	if dual == True:
		idxs_2 = init_CS_object.idxs_2
		idxs_1 = []
		for idx in sparse_idxs:
			if idx not in idxs_2:
				idxs_1.append(idx)
	
	nT = dSs.shape[0]
	
	# Check dimension of the stimuli
	assert len(dSs.shape) == 2, "Need to pass rank-2 tensor for dSs; first "\
								"index is time, second is Nn"
	assert len(dSs_est.shape) == 2, "Need to pass rank-2 tensor for dSs_est; "\
								"first index is time, second is Nn"
	assert len(mu_dSs.shape) == 1, "Need to pass 1-rank array for mu_dSs"
	assert len(mu_dSs) == nT, "mu_dSs must be length nT=%s" % nT
	
	errors_nonzero = sp.zeros(nT)
	errors_zero = sp.zeros(nT)
	
	for iN in range(Nn):
		if iN in sparse_idxs: 
			if (dual == True) and (iN in idxs_2):
				continue
			scaled_estimate = 1.*dSs_est[:, iN]/dSs[:, iN]
			errors_nonzero += (nonzero_bounds[0] < scaled_estimate)*\
								(scaled_estimate < nonzero_bounds[1])
		else:
			zero_est = (sp.absolute(dSs_est[:, iN]) < abs(mu_dSs*zero_bound))
			errors_zero += zero_est

	errors = dict()
	if dual == True:
		errors['errors_nonzero'] = sp.around(1.*errors_nonzero/ \
								len(idxs_1)*100., 2)
	else:
		errors['errors_nonzero'] = sp.around(1.*errors_nonzero/ \
								len(sparse_idxs)*100., 2)
	errors['errors_zero'] = sp.around(1.*errors_zero/ \
							(Nn - len(sparse_idxs))*100., 2)
										
	return errors
Beispiel #21
0
    def on_shifted_dwp_curves(self, t):
        a = P4Rm()
        if a.AllDataDict['model'] == 0:
            temp_1 = arange(2, len(a.ParamDict['dwp'])+1)
            temp_2 = temp_1 * t / (len(a.ParamDict['dwp']))
            P4Rm.ParamDict['x_dwp'] = t - temp_2
            shifted_dwp = a.ParamDict['dwp'][:-1:]
            temp_3 = in1d(around(a.ParamDict['depth'], decimals=3),
                          around(a.ParamDict['x_dwp'], decimals=3))
            temp_4 = a.ParamDict['DW_i'][temp_3]
            P4Rm.ParamDict['scale_dw'] = shifted_dwp / temp_4
            P4Rm.ParamDict['scale_dw'][a.ParamDict['scale_dw'] == 0] = 1.

            P4Rm.ParamDict['DW_shifted'] = shifted_dwp/a.ParamDict['scale_dw']
            P4Rm.ParamDict['dw_out'] = a.ParamDict['dwp'][-1]

        elif a.AllDataDict['model'] == 1:
            temp_1 = arange(0, len(a.ParamDict['dwp'])+1-3)
            temp_2 = temp_1 * t / (len(a.ParamDict['dwp'])-3)
            P4Rm.ParamDict['x_dwp'] = t - temp_2
            shifted_dwp = a.ParamDict['dwp'][1:-1:]
            temp_3 = in1d(around(a.ParamDict['depth'], decimals=3),
                          around(a.ParamDict['x_dwp'], decimals=3))
            temp_4 = a.ParamDict['DW_i'][temp_3]
            P4Rm.ParamDict['scale_dw'] = shifted_dwp / temp_4
            P4Rm.ParamDict['scale_dw'][a.ParamDict['scale_dw'] == 0] = 1.

            P4Rm.ParamDict['DW_shifted'] = shifted_dwp/a.ParamDict['scale_dw']
            temp_5 = array([a.ParamDict['dwp'][0], a.ParamDict['dwp'][-1]])
            P4Rm.ParamDict['dw_out'] = temp_5

        elif a.AllDataDict['model'] == 2:
            x_dw_temp = []
            x_dw_temp.append(t*(1-a.ParamDict['dwp'][1]))
            x_dw_temp.append(t*(1-a.ParamDict['dwp'][1] +
                             a.ParamDict['dwp'][2]/2))
            x_dw_temp.append(t*(1-a.ParamDict['dwp'][1] -
                             a.ParamDict['dwp'][3]/2))
            x_dw_temp.append(t*0.05)
            P4Rm.ParamDict['x_dwp'] = x_dw_temp

            y_dw_temp = []
            y_dw_temp.append(a.ParamDict['dwp'][0])
            y_dw_temp.append(1. - (1-a.ParamDict['dwp'][0])/2)
            y_dw_temp.append(1. - (1-a.ParamDict['dwp'][0])/2 -
                             (1-a.ParamDict['dwp'][6])/2)
            y_dw_temp.append(a.ParamDict['dwp'][6])
            P4Rm.ParamDict['DW_shifted'] = y_dw_temp
Beispiel #22
0
    def on_shifted_dwp_curves(self, t):
        a = P4Rm()
        if a.AllDataDict['model'] == 0:
            temp_1 = arange(2, len(a.ParamDict['dwp'])+1)
            temp_2 = temp_1 * t / (len(a.ParamDict['dwp']))
            P4Rm.ParamDict['x_dwp'] = t - temp_2
            shifted_dwp = a.ParamDict['dwp'][:-1:]
            temp_3 = in1d(around(a.ParamDict['depth'], decimals=3),
                          around(a.ParamDict['x_dwp'], decimals=3))
            temp_4 = a.ParamDict['DW_i'][temp_3]
            P4Rm.ParamDict['scale_dw'] = shifted_dwp / temp_4
            P4Rm.ParamDict['scale_dw'][a.ParamDict['scale_dw'] == 0] = 1.

            P4Rm.ParamDict['DW_shifted'] = shifted_dwp/a.ParamDict['scale_dw']
            P4Rm.ParamDict['dw_out'] = a.ParamDict['dwp'][-1]

        elif a.AllDataDict['model'] == 1:
            temp_1 = arange(0, len(a.ParamDict['dwp'])+1-3)
            temp_2 = temp_1 * t / (len(a.ParamDict['dwp'])-3)
            P4Rm.ParamDict['x_dwp'] = t - temp_2
            shifted_dwp = a.ParamDict['dwp'][1:-1:]
            temp_3 = in1d(around(a.ParamDict['depth'], decimals=3),
                          around(a.ParamDict['x_dwp'], decimals=3))
            temp_4 = a.ParamDict['DW_i'][temp_3]
            P4Rm.ParamDict['scale_dw'] = shifted_dwp / temp_4
            P4Rm.ParamDict['scale_dw'][a.ParamDict['scale_dw'] == 0] = 1.

            P4Rm.ParamDict['DW_shifted'] = shifted_dwp/a.ParamDict['scale_dw']
            temp_5 = array([a.ParamDict['dwp'][0], a.ParamDict['dwp'][-1]])
            P4Rm.ParamDict['dw_out'] = temp_5

        elif a.AllDataDict['model'] == 2:
            x_dw_temp = []
            x_dw_temp.append(t*(1-a.ParamDict['dwp'][1]))
            x_dw_temp.append(t*(1-a.ParamDict['dwp'][1] +
                             a.ParamDict['dwp'][2]/2))
            x_dw_temp.append(t*(1-a.ParamDict['dwp'][1] -
                             a.ParamDict['dwp'][3]/2))
            x_dw_temp.append(t*0.05)
            P4Rm.ParamDict['x_dwp'] = x_dw_temp

            y_dw_temp = []
            y_dw_temp.append(a.ParamDict['dwp'][0])
            y_dw_temp.append(1. - (1-a.ParamDict['dwp'][0])/2)
            y_dw_temp.append(1. - (1-a.ParamDict['dwp'][0])/2 -
                             (1-a.ParamDict['dwp'][6])/2)
            y_dw_temp.append(a.ParamDict['dwp'][6])
            P4Rm.ParamDict['DW_shifted'] = y_dw_temp
Beispiel #23
0
 def __init__(self, shape, num_points=None, **kwargs):
     # Generate Delaunay tessellation from super class, then trim
     super().__init__(shape=shape, num_points=num_points, **kwargs)
     points = self['pore.coords']
     conns = self['throat.conns']
     # Find centroid of each pair of nodes
     c = points[conns]
     m = (c[:, 0, :] + c[:, 1, :])/2
     # Find radius of circle connecting each pair of nodes
     r = sp.sqrt(sp.sum((c[:, 0, :] - c[:, 1, :])**2, axis=1))/2
     # Use KD-Tree to find distance to nearest neighbors
     tree = sptl.cKDTree(points)
     n = tree.query(x=m, k=1)[0]
     # Identify throats whose centroid is not near an unconnected node
     g = sp.around(n, decimals=5) == sp.around(r, decimals=5)
     trim(self, throats=~g)
Beispiel #24
0
    def test_transient_advection_diffusion(self):
        sf = op.algorithms.StokesFlow(network=self.net, phase=self.phase)
        sf.setup(quantity='pore.pressure',
                 conductance='throat.hydraulic_conductance')
        sf.set_value_BC(pores=self.net.pores('back'), values=1)
        sf.set_value_BC(pores=self.net.pores('front'), values=0)
        sf.run()
        self.phase[sf.settings['quantity']] = sf[sf.settings['quantity']]

        ad = op.algorithms.TransientAdvectionDiffusion(network=self.net,
                                                       phase=self.phase)
        ad.setup(quantity='pore.concentration',
                 diffusive_conductance='throat.diffusive_conductance',
                 hydraulic_conductance='throat.hydraulic_conductance',
                 pressure='pore.pressure',
                 t_initial=0,
                 t_final=100,
                 t_step=1,
                 t_output=50,
                 t_tolerance=1e-20,
                 s_scheme='powerlaw',
                 t_scheme='implicit')
        ad.set_IC(0)
        ad.set_value_BC(pores=self.net.pores('back'), values=2)
        ad.set_value_BC(pores=self.net.pores('front'), values=0)
        ad.run()

        x = [
            0., 0., 0., 0.89653, 0.89653, 0.89653, 1.53924, 1.53924, 1.53924,
            2., 2., 2.
        ]
        y = sp.around(ad[ad.settings['quantity']], decimals=5)
        assert sp.all(x == y)
Beispiel #25
0
def voronoi_edges(shape: List[int],
                  radius: int,
                  ncells: int,
                  flat_faces: bool = True):
    r"""
    Create an image of the edges in a Voronoi tessellation

    Parameters
    ----------
    shape : array_like
        The size of the image to generate in [Nx, Ny, Nz] where Ni is the
        number of voxels in each direction.

    radius : scalar
        The radius to which Voronoi edges should be dilated in the final image.

    ncells : scalar
        The number of Voronoi cells to include in the tesselation.

    flat_faces : Boolean
        Whether the Voronoi edges should lie on the boundary of the
        image (True), or if edges outside the image should be removed (False).

    Returns
    -------
    image : ND-array
        A boolean array with ``True`` values denoting the pore space

    """
    print(78 * '―')
    print('voronoi_edges: Generating', ncells, ' cells')
    shape = sp.array(shape)
    if sp.size(shape) == 1:
        shape = sp.full((3, ), int(shape))
    im = sp.zeros(shape, dtype=bool)
    base_pts = sp.rand(ncells, 3) * shape
    if flat_faces:
        # Reflect base points
        Nx, Ny, Nz = shape
        orig_pts = base_pts
        base_pts = sp.vstack(
            (base_pts, [-1, 1, 1] * orig_pts + [2.0 * Nx, 0, 0]))
        base_pts = sp.vstack(
            (base_pts, [1, -1, 1] * orig_pts + [0, 2.0 * Ny, 0]))
        base_pts = sp.vstack(
            (base_pts, [1, 1, -1] * orig_pts + [0, 0, 2.0 * Nz]))
        base_pts = sp.vstack((base_pts, [-1, 1, 1] * orig_pts))
        base_pts = sp.vstack((base_pts, [1, -1, 1] * orig_pts))
        base_pts = sp.vstack((base_pts, [1, 1, -1] * orig_pts))
    vor = sptl.Voronoi(points=base_pts)
    vor.vertices = sp.around(vor.vertices)
    vor.vertices *= (sp.array(im.shape) - 1) / sp.array(im.shape)
    vor.edges = _get_Voronoi_edges(vor)
    for row in vor.edges:
        pts = vor.vertices[row].astype(int)
        if sp.all(pts >= 0) and sp.all(pts < im.shape):
            line_pts = line_segment(pts[0], pts[1])
            im[line_pts] = True
    im = spim.distance_transform_edt(~im) > radius
    return im
Beispiel #26
0
 def test_compress_geom(self):
     b1 = self.net.pores('bottom_boundary')
     b2 = self.net.pores('top_boundary')
     height1 = self.net.domain_length(b1, b2)
     self.geo_vox.compress_geometry(factor=[1, 1, 0.5])
     height2 = self.net.domain_length(b1, b2)
     assert sp.around(height1 / height2, 5) == 2.0
Beispiel #27
0
def convert2int(move):
    """
    Converts continuous move to indices
    """
    debug_print('convert2int')
    move_index = scipy.around(move)
    return move_index.astype(scipy.integer)
Beispiel #28
0
def genPhenoCube(sim,
                 Xr,
                 vTotR=4e-3,
                 nCausalR=10,
                 pCommonR=0.8,
                 vTotBg=0.4,
                 pHidd=0.6,
                 pCommon=0.8):
    # region
    nCommonR = int(SP.around(nCausalR * pCommonR))
    # background
    vCommonBg = pCommon * vTotBg
    # noise
    vTotH = pHidd * (1 - vTotR - vTotBg)
    vTotN = (1 - pHidd) * (1 - vTotR - vTotBg)
    vCommonH = pCommon * vTotH
    all_settings = {
        'vTotR': vTotR,
        'nCommonR': nCommonR,
        'nCausalR': nCausalR,
        'vTotBg': vTotBg,
        'vCommonBg': vCommonBg,
        'pCausalBg': 1.,
        'use_XX': True,
        'vTotH': vTotH,
        'vCommonH': vCommonH,
        'nHidden': 10,
        'vTotN': vTotN,
        'vCommonN': 0.
    }

    Y, info = sim.genPheno(Xr, **all_settings)
    return Y, info
Beispiel #29
0
def display_data(X, width=None, save=False):
  m, n = X.shape
  width = sp.int_(width or sp.around(sp.sqrt(n)))
  height = sp.int_(n / width)
  display_rows = sp.int_(sp.floor(sp.sqrt(m)))
  display_cols = sp.int_(sp.ceil(m / display_rows))

  def rightward(acc, curr):
    return sp.hstack([acc, curr])

  def downward(acc, curr):
    return sp.vstack([acc, curr])

  def merge(func, init):
    return lambda arr: reduce(func, arr, init)

  init_rightward = sp.matrix([]).reshape([height, 0])
  init_downward = sp.matrix([]).reshape([0, width * display_cols])

  img_list = [X[i].reshape([height, width]).T for i in range(0, m)]
  img_list_split = [img_list[i:i+display_cols] for i in range(0, len(img_list), display_cols)]
  img = merge(downward, init_downward)(map(merge(rightward, init_rightward), img_list_split))

  plt.figure(1)
  plt.imshow(img, cmap='gray')
  plt.tick_params(labelbottom='off', labelleft='off')
  if save:
    plt.savefig('1.png')
  else:
    plt.show()

  return None
def plot_median_errors(RefinementLevels):
        for i in RefinementLevels[0].cases:
            x =[];
            y =[];
            print "Analyzing median error on: ", i ;
            for r in RefinementLevels:                
                x.append(r.LUT.D_dim*r.LUT.P_dim)
                r.get_REL_ERR_SU2(i)
                y.append(r.SU2[i].median_ERR*100)
            
            x = sp.array(x)
            y = sp.array(y)            
            y = y[sp.argsort(x)]
            x = x[sp.argsort(x)]
                                    
            LHM = sp.ones((len(x),2))
            RHS = sp.ones((len(x),1))            
            LHM[:,1] = sp.log10(x)
            RHS[:,0] = sp.log10(y)

            sols = sp.linalg.lstsq(LHM,RHS)
            b = -sols[0][1]
            plt.loglog(x,y, label='%s, %s'%(i,r'$O(\frac{1}{N})^{%s}$'%str(sp.around(b,2))), basex=10, basey=10, \
                       subsy=sp.linspace(10**(-5), 10**(-2),20),\
                       subsx=sp.linspace(10**(2), 10**(5),50))
            
            #for r in RefinementLevels:                
               # x.append(r.LUT.D_dim*r.LUT.P_dim)
              #  r.get_REL_ERR_SciPy(i)
             #   y.append(r.SciPy[i].median_ERR*100)
            #plt.plot(x,y, label='SciPy: %s'%i)
        plt.grid(which='both')
        plt.xlabel('Grid Nodes (N)')
        plt.ylabel('Median relative error [%]')
        return;
Beispiel #31
0
    def test_hybrid_advection_diffusion_diffusion(self):
        sf = op.algorithms.StokesFlow(network=self.net, phase=self.phase)
        sf.setup(quantity='pore.pressure',
                 conductance='throat.hydraulic_conductance')
        sf.set_value_BC(pores=self.net.pores('back'), values=1)
        sf.set_value_BC(pores=self.net.pores('front'), values=0)
        sf.run()
        self.phase[sf.settings['quantity']] = sf[sf.settings['quantity']]

        ad = op.algorithms.AdvectionDiffusion(network=self.net,
                                              phase=self.phase)
        ad.setup(quantity='pore.concentration',
                 diffusive_conductance='throat.diffusive_conductance',
                 hydraulic_conductance='throat.hydraulic_conductance',
                 pressure='pore.pressure', s_scheme='hybrid')
        ad.set_value_BC(pores=self.net.pores('back'), values=2)
        ad.set_value_BC(pores=self.net.pores('front'), values=0)
        ad.run()

        x = [0., 0., 0.,
             0.89908, 0.89908, 0.89908,
             1.54128, 1.54128, 1.54128,
             2., 2., 2.]
        y = sp.around(ad[ad.settings['quantity']], decimals=5)
        assert sp.all(x == y)
Beispiel #32
0
def local_thickness(im):
    r"""
    For each voxel, this functions calculates the radius of the largest sphere
    that both engulfs the voxel and fits entirely within the foreground. This
    is not the same as a simple distance transform, which finds the largest
    sphere that could be *centered* on each voxel.

    Parameters
    ----------
    im : array_like
        A binary image with the phase of interest set to True

    Returns
    -------
    An image with the pore size values in each voxel

    Notes
    -----
    The term *foreground* is used since this function can be applied to both
    pore space or the solid, whichever is set to True.

    """
    from skimage.morphology import cube
    if im.ndim == 2:
        from skimage.morphology import square as cube
    dt = spim.distance_transform_edt(im)
    sizes = sp.unique(sp.around(dt, decimals=0))
    im_new = sp.zeros_like(im, dtype=float)
    for r in tqdm(sizes):
        im_temp = dt >= r
        im_temp = spim.distance_transform_edt(~im_temp) <= r
        im_new[im_temp] = r
    # Trim outer edge of features to remove noise
    im_new = spim.binary_erosion(input=im, structure=cube(1))*im_new
    return im_new
Beispiel #33
0
 def test_compress_geom(self):
     b1 = self.net.pores('bottom_boundary')
     b2 = self.net.pores('top_boundary')
     height1 = self.net.domain_length(b1, b2)
     self.geo_vox.compress_geometry(factor=[1, 1, 0.5])
     height2 = self.net.domain_length(b1, b2)
     assert sp.around(height1/height2, 5) == 2.0
Beispiel #34
0
    def rekernel(self):
        dcontrol = self.control[ord('d')]
        econtrol = self.control[ord('e')]
        rcontrol = self.control[ord('r')]
        radius = rcontrol.val
        dvalue = dcontrol.val
        evalue = econtrol.val
        rmax   = rcontrol.limit[2]
        if self.rlast != radius:
            inner, outer = float(radius-1), float(radius)
            shape      = (self.edge, self.edge)
            self.radii = list(product(arange(-rmax,rmax+1,1.0), repeat=2))
            self.radii = array([sqrt(x*x+y*y) for x,y in self.radii]).reshape(shape)

            if True:
                self.negative = -exp(-dvalue*(self.radii-outer)**2)
                self.positive = +exp(-dvalue*(self.radii-inner)**2)
            else:
                self.radii = around(self.radii)
                self.negative = zeros((self.edge,self.edge),dtype=float)
                self.negative[self.radii == outer] = -1.0
                self.positive = zeros(shape,dtype=float)
                self.positive[self.radii == inner] = +1.0

            self.negative /= fabs(self.negative.sum())
            self.positive /= fabs(self.positive.sum())

            self.kernel = self.negative + self.positive
            self.rlast = radius
        if self.elast != evalue:
            self.gauss = exp(-evalue * self.radii**2)
            self.gauss /= self.gauss.sum()
            self.elast = evalue
Beispiel #35
0
def crtpop(ni,nv,prec):
    """Create a random population array of size
    ni by nv in the range 0:preci-1.  Use prec = 2
    to create binary string
    """
    pop = scipy.around(scipy.rand(ni,nv)*(prec-1))
    
    return pop
Beispiel #36
0
 def wheelEvent(self, evt):  # reimplementation
     d = sp.around(evt.angleDelta().y() /
                   120.0)  # check this on different machines how much it is
     updated_frame = self.Main.Data_Display.Frame_Visualizer.frame - d
     if 0 <= updated_frame < self.Main.Data.nFrames:
         self.Main.Data_Display.Frame_Visualizer.frame -= d
         self.update_vline(self.Main.Data_Display.Frame_Visualizer.frame)
         self.Main.Data_Display.Frame_Visualizer.update_frame()
Beispiel #37
0
def do_global(graph):
    n = graph.number_of_nodes()
    print n

    P = generate_transition_matrix(graph, n)
    print 'Probability transition marix:'
    print sp.where(P < 0.001, sp.zeros((n, n)), sp.around(P, 3))
    print 'Done getting P'

    w, vr = equilibrium_distribution(P)
    # Find the index of the eigenvalue 1

    index = sp.where((w > 0.999999999999999) * (w < 1.000000000000001))[0]
    print index
    #if index.size == 0:
    #    if roundoff == 0:
    #        raise ValueError
    #    P = sp.around(P, roundoff-1)
    #    return equilibrium_distribution(P, roundoff-1)

    # Instead of randomly choosing the first eigenvalue, choose the first
    # eigen value which yields a non-singular fundamental matrix
    eigen_index = 0
    while(1):
        try:
            chosen_index = index[eigen_index]
            print 'Trying with index', chosen_index
        except IndexError:
            print 'No eigenvalue of 1 exists, or no eigenvector of 1 exists',
            print 'which allows the fundamental matrix to be non-singular'
            raise

        eq_pi = vr[:, chosen_index]
        print 'Eigenvector: '
        print eq_pi
        print 'Done getting pi'
        print 'Finiteness check:',
        try:
            eq_pi = sp.asarray_chkfinite(eq_pi)
            print 'OK'
        except ValueError:
            eigen_index += 1
            continue

        W = equilibrium_transition_matrix(eq_pi, n)
        print 'Done getting W'

        try:
            Z = fundamental_matrix(P, W, n)
            print 'Done getting Z'
            break
        except linalg.LinAlgError:
            eigen_index += 1

    Ei_Ti, Ei_Tj, Epi_Ti = hitting_times(eq_pi, Z, n)
    print 'Done getting hitting times'

    return Ei_Ti, Ei_Tj, Epi_Ti
Beispiel #38
0
    def add_shape(self,
                  shape,
                  outline_color=[0, 0, 0],
                  fill_color=[255, 255, 255]):
        """To add a matplotlib shape:
        ``line2D``, ``circle``, ``ellipse``, ``rectangle`` or ``polygon``

        Parameters
        ----------

        shape: matplotlib shape
            line2D, circle, ellipse, rectangle or polygon
        outline_color: list
            rgb color
        fill_color: list
            rgb color
        """
        self.__shapes.append(shape)
        self.__outline_color_shapes.append(outline_color)
        self.__fill_color_shapes.append(fill_color)
        if (isinstance(shape, Circle) or isinstance(shape, Ellipse)
                or isinstance(shape, Rectangle) or isinstance(shape, Polygon)):
            xy = shape.get_verts() / self.pixel_size
            xy[:, 1] = self.height - xy[:, 1]
            self.draw.polygon(
                sp.around(xy.flatten()).tolist(),
                outline="rgb(" + str(outline_color[0]) + "," +
                str(outline_color[1]) + "," + str(outline_color[2]) + ")",
                fill="rgb(" + str(fill_color[0]) + "," + str(fill_color[1]) +
                "," + str(fill_color[2]) + ")")
            linewidth = shape.get_linewidth()
            self.draw.line(sp.around(xy.flatten()).tolist(),
                           width=int(linewidth),
                           fill="rgb(" + str(outline_color[0]) + "," +
                           str(outline_color[1]) + "," +
                           str(outline_color[2]) + ")")
        elif isinstance(shape, Line2D):
            linewidth = shape.get_linewidth()
            xy = shape.get_xydata() / self.pixel_size
            xy[:, 1] = self.height - xy[:, 1]
            self.draw.line(sp.around(xy.flatten()).tolist(),
                           width=int(linewidth),
                           fill="rgb(" + str(outline_color[0]) + "," +
                           str(outline_color[1]) + "," +
                           str(outline_color[2]) + ")")
Beispiel #39
0
def mutate(chrom,N,p):
    """Mutation with probability N and precision p
    """
    index = []
    for x in range(int(scipy.around(chrom.shape[0]*chrom.shape[1]*N))):
        index.append((int(scipy.around(scipy.rand(1,)[0]*(chrom.shape[0]-1))),
        int(scipy.around(scipy.rand(1,)[0]*(chrom.shape[1]-1)))))

    for x in index:
        if p == 1:
            if chrom[x] == 1:
                chrom[x] = 0
            else:
                chrom[x] = 1
        else:
            chrom[x] = int(scipy.around(scipy.rand(1,)[0]*(p-1)))
    
    return chrom
 def test_hybrid_advection_diffusion_diffusion(self):
     self.ad.setup(s_scheme='hybrid')
     self.ad.run()
     x = [
         0., 0., 0., 0.89908, 0.89908, 0.89908, 1.54128, 1.54128, 1.54128,
         2., 2., 2.
     ]
     y = sp.around(self.ad['pore.concentration'], decimals=5)
     assert_allclose(actual=y, desired=x)
Beispiel #41
0
def toRanks(A):
    """
    converts the columns of A to ranks
    """
    AA=sp.zeros_like(A)
    for i in range(A.shape[1]):
        AA[:,i] = st.rankdata(A[:,i])
    AA=sp.array(sp.around(AA),dtype="int")-1
    return AA
Beispiel #42
0
def toRanks(A):
    """
    converts the columns of A to ranks
    """
    AA = sp.zeros_like(A)
    for i in range(A.shape[1]):
        AA[:, i] = st.rankdata(A[:, i])
    AA = sp.array(sp.around(AA), dtype="int") - 1
    return AA
 def test_powerlaw_advection_diffusion_diffusion(self):
     self.ad.setup(s_scheme='powerlaw')
     self.ad.run()
     x = [
         0., 0., 0., 0.89653, 0.89653, 0.89653, 1.53924, 1.53924, 1.53924,
         2., 2., 2.
     ]
     y = sp.around(self.ad['pore.concentration'], decimals=5)
     assert_allclose(actual=y, desired=x)
 def test_upwind_advection_diffusion_diffusion(self):
     self.ad.setup(s_scheme='upwind')
     self.ad.run()
     x = [
         0., 0., 0., 0.86486, 0.86486, 0.86486, 1.51351, 1.51351, 1.51351,
         2., 2., 2.
     ]
     y = sp.around(self.ad['pore.concentration'], decimals=5)
     assert_allclose(actual=y, desired=x)
Beispiel #45
0
 def is_near_constant(self, pid, min_num_diff=10):
     vals = sp.array(self.phen_dict[pid]["values"])
     if sp.std(vals) > 0:
         vals = 50 * (vals - sp.mean(vals)) / sp.std(vals)
         vals = vals - vals.min() + 0.1
         b_counts = sp.bincount(sp.array(sp.around(vals), dtype="int"))
         b = b_counts.max() > len(vals) - min_num_diff
         return b
     else:
         return True
Beispiel #46
0
 def test_general_toroidal(self):
     phys = self.phys
     r_tor = 1e-6
     phys.add_model(propname='throat.purcell_pressure',
                    model=pm.capillary_pressure.purcell,
                    r_toroid=r_tor)
     phys['throat.scale_a'] = r_tor
     phys['throat.scale_b'] = r_tor
     phys.add_model(propname='throat.general_pressure',
                    model=pm.meniscus.general_toroidal,
                    mode='max',
                    num_points=1000)
     a = sp.around(phys['throat.purcell_pressure'], 10)
     b = sp.around(phys['throat.general_pressure'], 10)
     assert sp.allclose(a, b)
     h = phys.check_data_health()
     for check in h.values():
         if len(check) > 0:
             assert 1 == 2
Beispiel #47
0
 def is_near_constant(self, min_num_diff=10):
     vals = sp.array(self.values)
     if sp.std(vals) > 0:
         vals = 50 * (vals - sp.mean(vals)) / sp.std(vals)
         vals = vals - vals.min() + 0.1
         b_counts = sp.bincount(sp.array(sp.around(vals), dtype='int'))
         b = b_counts.max() > len(vals) - min_num_diff
         return b
     else:
         return True
Beispiel #48
0
 def NormLog(self,X,Y,parameterValues, independentValues):
     """
     This kind of normalization is correct
     if the data are uniform in log scale,
     as prepared by our code toBinDistributions.py
     """
     lgX = scipy.log10(X)
     D = scipy.around(lgX[1] - lgX[0],2)
     bins = 10**(lgX+D/2.) - 10**(lgX-D/2.)
     return Y/sum(Y*bins)
Beispiel #49
0
def _assert_files_equal_testing(e, a):

    da = sp.loadtxt(a, dtype='str', delimiter='\t')
    de = sp.loadtxt(e, dtype='str', delimiter='\t')

    ### check header
    assert sp.all(da[0, :] == de[0, :])
    da = da[1:, ]
    de = de[1:, ]

    ### check text cols
    assert sp.all(da[:, [0, 1]] == de[:, [0, 1]])
    da = da[:, 2:]
    de = de[:, 2:]

    ### check p-values (up to certain precision)
    da = sp.around(da.astype('float'), decimals=6)
    de = sp.around(de.astype('float'), decimals=6)
    assert sp.all(da == de)
Beispiel #50
0
 def test_one_value_one_rate(self):
     alg = op.algorithms.GenericTransport(network=self.net,
                                          phase=self.phase)
     alg.settings['conductance'] = 'throat.diffusive_conductance'
     alg.settings['quantity'] = 'pore.mole_fraction'
     alg.set_rate_BC(pores=self.net.pores('bottom'), values=1)
     alg.set_value_BC(pores=self.net.pores('top'), values=0)
     alg.run()
     x = [0., 1., 2., 3., 4., 5., 6., 7., 8.]
     y = sp.unique(sp.around(alg['pore.mole_fraction'], decimals=3))
     assert sp.all(x == y)
Beispiel #51
0
 def test_two_value_conditions(self):
     alg = op.algorithms.GenericTransport(network=self.net,
                                          phase=self.phase)
     alg.settings['conductance'] = 'throat.diffusive_conductance'
     alg.settings['quantity'] = 'pore.mole_fraction'
     alg.set_value_BC(pores=self.net.pores('top'), values=1)
     alg.set_value_BC(pores=self.net.pores('bottom'), values=0)
     alg.run()
     x = [0.0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0]
     y = sp.unique(sp.around(alg['pore.mole_fraction'], decimals=3))
     assert sp.all(x == y)
Beispiel #52
0
def readSMO(filename="sample_image.smo"):
	imageList = []
	tempList = []
	with open(filename,'rb') as inFile:
		stringArray = inFile.read().split(",")
	
	#import pdb; pdb.set_trace()

	for elem in stringArray:
		if elem[0] == '[':	
			tempList = [int(sp.around(float(elem[1:])))]
		elif elem[-1] == ']':
			imageList.append(tempList)
		elif elem == '\n':
			pass
		else:
			tempList.append(int(sp.around(float(elem))))

	imageList = sp.array(imageList)
	misc.imsave("final_converted.jpg",imageList)
def centre_of_mass(geometry, vertices='throat.offset_vertices', **kwargs):
    r"""
    Calculate the centre of mass of the throat from the voronoi vertices.
    """
    Nt = geometry.num_throats()
    outer_verts = geometry['throat.vertices']
    offset_verts = geometry[vertices]
    normal = geometry['throat.normal']
    z_axis = [0, 0, 1]
    value = _sp.ndarray([Nt, 3])
    for i in range(Nt):
        if len(offset_verts[i]) > 2:
            verts = offset_verts[i]
        elif len(outer_verts[i]) > 2:
            verts = outer_verts[i]
        else:
            verts = []
        if len(verts) > 0:
            # For boundaries some facets will already be aligned with the axis -
            # if this is the case a rotation is unnecessary and could also cause
            # problems
            angle = tr.angle_between_vectors(normal[i], z_axis)
            if angle == 0.0 or angle == _sp.pi:
                "We are already aligned"
                rotate_input = False
                facet = verts
            else:
                rotate_input = True
                M = tr.rotation_matrix(tr.angle_between_vectors(normal[i], z_axis),
                                       tr.vector_product(normal[i], z_axis))
                facet = _sp.dot(verts, M[:3, :3].T)
            # Now we have a rotated facet aligned with the z axis - make 2D
            facet_2D = _sp.column_stack((facet[:, 0], facet[:, 1]))
            z = _sp.unique(_sp.around(facet[:, 2], 10))
            if len(z) == 1:
                # We need the vertices arranged in order so perform a convex hull
                hull = ConvexHull(facet_2D)
                ordered_facet_2D = facet_2D[hull.vertices]
                # Call the routine to calculate an area wighted centroid from the
                # 2D polygon
                COM_2D = vo.PolyWeightedCentroid2D(ordered_facet_2D)
                COM_3D = _sp.hstack((COM_2D, z))
                # If we performed a rotation we need to rotate back
                if (rotate_input):
                    MI = tr.inverse_matrix(M)
                    # Unrotate the offset coordinates using the inverse of the
                    # original rotation matrix
                    value[i] = _sp.dot(COM_3D, MI[:3, :3].T)
                else:
                    value[i] = COM_3D
            else:
                print('Rotation Failed: ' + str(_sp.unique(facet[:, 2])))

    return value
Beispiel #54
0
def plotBias(vals, fn_plot, myidx, logScale = False, refname = 'TCGA'):

    iqr    = ( (sp.percentile(vals[~myidx],75) - sp.percentile(vals[~myidx],25) ) * 1.5)
    iqr2    = ( (sp.percentile(vals[myidx],75) - sp.percentile(vals[myidx],25) ) * 1.5)

    sidx   = sp.argsort(vals)
    vals   = vals[sidx]
    myidx = myidx[sidx]

    fig  = plt.figure(figsize=(12,10))
    ax   = fig.add_subplot(111)
    ax_c = ax.twinx()
    ax.vlines(sp.array(sp.arange(sp.sum(vals.shape[0])))[myidx],[0], vals[myidx], label = '%s Reference'%refname)
    ax.vlines(sp.array(sp.arange(sp.sum(vals.shape[0])))[~myidx],[0], vals[~myidx], color = 'r', label = 'Your Samples')

    ax.plot([0,vals.shape[0]],[3,3], '--', color = 'green')
    ax.plot([0,vals.shape[0]],[5,5] , '--',color = 'green')
    ax.plot([0,vals.shape[0]],[iqr + sp.percentile(vals[~myidx], 75),iqr + sp.percentile(vals[~myidx], 75)], '--',color = 'green')
    ax.plot([0,vals.shape[0]],[iqr2 + sp.percentile(vals[myidx], 75),iqr2 + sp.percentile(vals[myidx], 75)], '--',color = 'green')

#    ax.plot([0,vals.shape[0]],[6.25,6.25],'--', color = 'green')
    ax.plot([0,vals.shape[0]],[10,10] , '--',color = 'green')
    ax.set_ylabel('Median 3\'/5\' Bias')
    ax.set_xlim(0,vals.shape[0])
    if logScale:
        ax.set_yscale('log')
        ax_c.set_yscale('log')
    ax_c.set_ylim(ax.get_ylim())

    ### add right side ticks
    if logScale:       
        tick_thresholds = sp.array([3,5,iqr+sp.percentile(vals[~myidx],75),iqr2 + sp.percentile(vals[myidx], 75), 10])#sp.array(sp.log([3,5,iqr+sp.percentile(vals,75), 10, 50]))
    else:
        tick_thresholds = sp.array([3,5,iqr+sp.percentile(vals[~myidx],75),iqr2 + sp.percentile(vals[myidx], 75), 10])
    tick_idx        = sp.argsort(tick_thresholds)
    tick_thresholds = tick_thresholds[tick_idx]
    tick_thresholds = sp.around(tick_thresholds, decimals = 2)
    ax_c.set_yticks(tick_thresholds)

    tick_thresholds                = tick_thresholds.astype('|S4')
    tick_thresholds                = tick_thresholds.astype('|S50')
    tick_thresholds[tick_idx == 2] = tick_thresholds[tick_idx == 2][0] + ' (Your Filter)'
#    tick_thresholds[tick_idx == 3] = tick_thresholds[tick_idx == 3][0] + ' (PRAD Filter)'
    tick_thresholds[tick_idx == 3] = tick_thresholds[tick_idx == 3][0] + ' (%s Filter)'%(refname)

    ax_c.set_yticklabels(tick_thresholds)


    ax.grid()
    ax.legend(loc=2)
    plt.tight_layout()
    plt.savefig(fn_plot, dpi = 300)
    plt.clf()
Beispiel #55
0
 def _label_faces(self):
     r'''
     Label the pores sitting on the faces of the domain in accordance with
     the conventions used for cubic etc.
     '''
     coords = sp.around(self['pore.coords'], decimals=10)
     min_labels = ['front', 'left', 'bottom']
     max_labels = ['back', 'right', 'top']
     min_coords = sp.amin(coords, axis=0)
     max_coords = sp.amax(coords, axis=0)
     for ax in range(3):
         self['pore.' + min_labels[ax]] = coords[:, ax] == min_coords[ax]
         self['pore.' + max_labels[ax]] = coords[:, ax] == max_coords[ax]
Beispiel #56
0
def mcUnitConvergeEst(func,dims,minPoints,maxPoints,numTestPoints,testRuns):
	#Couldn't get this to work, spits out an answer near 0
	testPoints=sp.around(sp.linspace(minPoints,maxPoints,numTestPoints))
	error = sp.zeros(sp.size(testPoints))
	area = sp.zeros(testRuns)

	for i in range(0,numTestPoints):
		for k in range(0,testRuns):
			area[k]=mcUnit(func,testPoints[i],dims)
		error[i] = sp.mean(sp.absolute(area-sp.pi))

	estimate = la.lstsq(sp.vstack((sp.log(testPoints),sp.ones(sp.size(testPoints)))).T,sp.log(error))
	return estimate
Beispiel #57
0
 def test_upwind_advection_diffusion(self):
     mod = op.models.physics.ad_dif_conductance.ad_dif
     self.phys.add_model(propname='throat.ad_dif_conductance_upwind',
                         model=mod, s_scheme='upwind')
     self.phys.regenerate_models()
     self.ad.setup(conductance='throat.ad_dif_conductance_upwind')
     self.ad.run()
     x = [0., 0., 0.,
          0.86486, 0.86486, 0.86486,
          1.51351, 1.51351, 1.51351,
          2., 2., 2.]
     y = sp.around(self.ad['pore.concentration'], decimals=5)
     assert_allclose(actual=y, desired=x)
Beispiel #58
0
 def test_upwind_NernstPlanck(self):
     mod = op.models.physics.ad_dif_mig_conductance.ad_dif_mig
     self.phys.add_model(propname='throat.ad_dif_mig_conductance_upwind',
                         model=mod, s_scheme='upwind', ion='ionX')
     self.phys.regenerate_models()
     self.adm.setup(conductance='throat.ad_dif_mig_conductance_upwind')
     self.adm.run()
     x = [0.,      0.,      0.,
          0.86486, 0.86486, 0.86486,
          1.51351, 1.51351, 1.51351,
          2.,      2.,      2.]
     y = sp.around(self.adm['pore.concentration.ionX'], decimals=5)
     assert_allclose(actual=y, desired=x)
Beispiel #59
0
 def test_one_value_one_source(self):
     rt = op.algorithms.ReactiveTransport(network=self.net,
                                          phase=self.phase)
     rt.setup(rxn_tolerance=1e-05, max_iter=5000,
              relaxation_source=1, relaxation_quantity=1)
     rt.settings.update({'conductance': 'throat.diffusive_conductance',
                         'quantity': 'pore.concentration'})
     rt.set_source(pores=self.net.pores('bottom'), propname='pore.reaction')
     rt.set_value_BC(pores=self.net.pores('top'), values=1.0)
     rt.run()
     x = [0.0011, 0.1260, 0.2508, 0.3757,
          0.5006, 0.6254, 0.7503, 0.8751, 1.0]
     y = sp.unique(sp.around(rt['pore.concentration'], decimals=4))
     assert sp.all(x == y)