コード例 #1
0
ファイル: GPdc.py プロジェクト: markm541374/GPc
 def infer_diag_post(self,X_ii,D_i):
     
     X_i = dc(X_ii)
     ns = len(D_i)
     
     X_i.resize([ns,self.D])
     [m,V] = self.infer_diag(X_i,D_i)
     if sp.amin(V)<=-0.:
         class MJMError(Exception):
             pass
         print "negative/eq variance"
         print [m,V,X_i,D_i]
         print "_______________"
         #self.printc()
         raise(MJMError)
     if sp.amin(sp.var(m,axis=0))<-0.:
         class MJMError(Exception):
             pass
         print "negativevar of mean"
         print X_i.shape
         print [m,V,sp.var(m,axis=0),X_i,D_i]
         print "_______________"
         #self.printc()
         raise(MJMError)
     
     return [sp.mean(m,axis=0).reshape([1,ns]),(sp.mean(V,axis=0)+sp.var(m,axis=0)).reshape([1,ns])]
コード例 #2
0
ファイル: mplexp.py プロジェクト: kryv/flame_tools
    def loadfile(self, skiprows=2):
        self.d.efld = np.loadtxt(self.efile, skiprows=skiprows)
        self.d.hfld = np.loadtxt(self.hfile, skiprows=skiprows)
        erows, ecols = np.shape(self.d.efld)
        hrows, hcols = np.shape(self.d.hfld)
        if (erows != hrows) or (ecols != hcols):
            raise TypeError('Input file size of E and H is inconsistent.')

        exl = np.unique(self.d.efld[:, cx])
        eyl = np.unique(self.d.efld[:, cy])
        ezl = np.unique(self.d.efld[:, cz])
        hxl = np.unique(self.d.hfld[:, cx])
        hyl = np.unique(self.d.hfld[:, cy])
        hzl = np.unique(self.d.hfld[:, cz])

        if any(exl != hxl) or any(eyl != hyl) or any(eyl != hyl):
            raise TypeError('Input data grid of E and H is inonsisitent.')

        self.d.xmin = np.amin(exl)
        self.d.xmax = np.amax(exl)
        self.d.ymin = np.amin(eyl)
        self.d.ymax = np.amax(eyl)
        self.d.zmin = np.amin(ezl)
        self.d.zmax = np.amax(ezl)

        self.d.dsize = erows
        self.d.xsize = len(exl) - 1
        self.d.ysize = len(eyl) - 1
        self.d.zsize = len(ezl) - 1

        self.d.dx = (self.d.xmax - self.d.xmin) / float(self.d.xsize)
        self.d.dy = (self.d.ymax - self.d.ymin) / float(self.d.ysize)
        self.d.dz = (self.d.zmax - self.d.zmin) / float(self.d.zsize)

        self.zyxsort()
コード例 #3
0
    def add_boundary_pores(self, labels=['top', 'bottom', 'front', 'back',
                                         'left', 'right'], offset=None):
        r"""
        Add boundary pores to the specified faces of the network

        Pores are offset from the faces of the domain.

        Parameters
        ----------
        labels : string or list of strings
            The labels indicating the pores defining each face where boundary
            pores are to be added (e.g. 'left' or ['left', 'right'])

        offset : scalar or array_like
            The spacing of the network (e.g. [1, 1, 1]).  This must be given
            since it can be quite difficult to infer from the network,
            for instance if boundary pores have already added to other faces.

        """
        offset = sp.array(offset)
        if offset.size == 1:
            offset = sp.ones(3)*offset
        for item in labels:
            Ps = self.pores(item)
            coords = sp.absolute(self['pore.coords'][Ps])
            axis = sp.count_nonzero(sp.diff(coords, axis=0), axis=0) == 0
            ax_off = sp.array(axis, dtype=int)*offset
            if sp.amin(coords) == sp.amin(coords[:, sp.where(axis)[0]]):
                ax_off = -1*ax_off
            topotools.add_boundary_pores(network=self, pores=Ps, offset=ax_off,
                                         apply_label=item + '_boundary')
コード例 #4
0
def merged_event_breakpoint_stats(mev):
    bp1d, bp2d = [], []
    bend1 = bend2 = None
    reads = []
    quals = []
    for ev in mev.events:
        bp1d.append(ev.bp1.pos)
        bp2d.append(ev.bp2.pos)
        reads.append(ev.reads)
        quals.append(ev.qual)
        bend1 = ev.bp1.breakend
        bend2 = ev.bp2.breakend
    bp1d = np.array(bp1d)
    bp2d = np.array(bp2d)
    if bend1 == "+":
        bp1limit = scipy.amin(bp1d)
    else:
        bp1limit = scipy.amax(bp1d)
    if bend2 == "+":
        bp2limit = scipy.amin(bp2d)
    else:
        bp2limit = scipy.amax(bp2d)
    reads_median = int(scipy.median(reads))
    qual_median = int(scipy.median(quals))
    return int(bp1limit), int(bp2limit), int(bp2limit - bp1limit), scipy.mean(
        bp1d), scipy.amax(bp1d) - scipy.amin(bp1d), scipy.std(
            bp1d), scipy.mean(bp2d), scipy.amax(bp2d) - scipy.amin(
                bp2d), scipy.std(bp2d), reads_median, qual_median
コード例 #5
0
ファイル: FDTD1D.py プロジェクト: vegaonline/empython-vega
    def plot(self):
        ex = self.ex
        hy = self.hy
        ngridx = self.ngridx
        nSteps = self.numSteps

        x = np.linspace(0, ngridx, ngridx)
        ymin1 = S.amin(ex)
        ymin2 = S.amin(hy)
        ymax1 = S.amax(ex)
        ymax2 = S.amax(hy)
        yminimum = min(ymin1, ymin2)
        ymaximum = max(ymax1, ymax2)

        title1 = 'EX and Hy field in FDTD 1D simulation.'

        fig = plt.figure()

        ax1 = fig.add_subplot(121)
        ax1.set_xlabel('FDTD Cells', fontsize=12)
        ax1.plot(x, ex, 'tab:blue', label='Ex (Normalized)')
        ax1.set_xlim([0, ngridx])
        ax1.legend(loc='best', shadow=True, ncol=2)
        #  ax1.legend(loc = 'upper center', bbox_to_anchor=(0.5, 0.1),  shadow=True, ncol=2)

        ax2 = fig.add_subplot(122)
        ax2.set_xlabel('FDTD Cells', fontsize=12)
        ax2.plot(x, hy, 'tab:red', label='Hy')
        ax2.set_xlim([0, ngridx])
        ax2.legend(loc='best', shadow=True, ncol=2)
        # ax2.legend(loc = 'upper center', bbox_to_anchor=(0.5, 0.1),  shadow=True, ncol=2)

        plt.suptitle(title1, fontsize=20)
        plt.savefig('Figure.png')
        plt.show()
コード例 #6
0
    def plot_curr(self):
        """Plotet anhand der eingebenen Zeilennummer"""
        ######## plot a 3D Current ########

        
        fig = plt.figure(figsize=plt.figaspect(0.5))
        canvas = FigureCanvasTkAgg(fig, master=page3)
        canvas.get_tk_widget().pack(side='top', fill='both')
        canvas._tkcanvas.pack(side='top', fill='both', expand=15)
        toolbar = NavigationToolbar2TkAgg(canvas, page3)
        canvas.get_tk_widget().grid(row=1,column=1)
        toolbar.grid(row=50,column=1) 
          
        
        
        ax = fig.add_subplot(1, 2, 1, projection='3d')
        
        X = sp.linspace(0,10,10)
        Y = sp.linspace(0,10,10)
        
        X, Y = sp.meshgrid(X, Y)
        X, Y = X.ravel(), Y.ravel()
        
        #R = sp.sqrt(X**2 + Y**2)
        #Z = sp.sin(R)
        
              
        
        width = depth = 1
        bottom=X*0.
        
        
        #plt.ion()
        getrow=int(entryrowplot.get())
        current_floats=sp.float64(self.data_str['current'][getrow].split(";")).reshape(10,10)
        maxcurr= np.max(current_floats)
        #print sp.mean(current_floats)
        top=current_floats.ravel()
        top_scaled=(top-sp.amin(top))/(sp.amax(top)-sp.amin(top))
        mycolors = cm.jet(top_scaled)
        ax.bar3d(X, Y, bottom, width, depth, top,color=mycolors, alpha=float(entryTrans.get()))
        ax.set_title('Partial Currents @ '+self.data_str['sumcurr'][getrow]+' A'+'//   @ '+self.data['voltage'][getrow]+' V')
        
        ax.set_zlim(0,maxcurr)
        ax.set_zlabel('Current in A', linespacing=10.4)
        ax.view_init(elev=int(entryCurrEval.get()), azim=int(entryCurrAngle.get()))
        
        #plt.show()
        fig = plt.figure()

       
        
        #plt.clf()
        plt.show()
        plt.gcf().canvas.draw()
        
              
        currplot = ts.strftime("%Y.%m.%d. %H:%M:%S :")+"Current dargestellt"
        self.displaystate.insert(tk.END, currplot+'\n')  
コード例 #7
0
def centroid_quadratic(curve, ratio):
    num, div = 0, 0
    top = scp.amin(curve) + (scp.amax(curve) - scp.amin(curve)) * ratio
    for i in range(0, len(curve)):
        if (curve[i] <= top):
            num += (top - curve[i]) * (top - curve[i]) * (i + 1)
            div += (top - curve[i]) * (top - curve[i])
    centroid = num / div
    return centroid
コード例 #8
0
ファイル: ciaoplot.py プロジェクト: chenzhikuo1/OCR-Python
 def __init__(self, evaluator, hof1, hof2, **args):
     if 'symmetric' in args:
         M = CiaoPlot.generateData(evaluator, hof1, hof2, symmetric = args['symmetric'])
         del args['symmetric']
     else:
         M = CiaoPlot.generateData(evaluator, hof1, hof2)
     M *= 1/(amin(M) - amax(M))
     M -= amin(M)
     self.relData = M
     ColorMap.__init__(self, M, minvalue = 0, maxvalue = 1, **args)
コード例 #9
0
ファイル: Trace.py プロジェクト: rshelans/GeneRing
    def partition(self, midpoint):
        """
		returns two lists forward and reverse who have length len(self)=len(forward) +len(reverse)
		each index contains the distance of the closest coordinate of the other strand of the molecule as defined by midpoint
		"""
        forward = scipy.amin(self._d[0:midpoint + 1, midpoint + 1:len(self)],
                             axis=1)
        reverse = scipy.amin(self._d[0:midpoint + 1, midpoint + 1:len(self)],
                             axis=0)
        return forward, reverse
コード例 #10
0
 def compute(i, j):
     if i == j:
         return 1.0
     elif trains[i].size <= 0 or trains[j].size <= 0:
         return 0.0
     else:
         diff_matrix = sp.absolute(trains[i] - sp.atleast_2d(trains[j]).T)
         return 0.5 * (
             sp.sum(kernel(sp.amin(diff_matrix, axis=0))) / trains[i].size +
             sp.sum(kernel(sp.amin(diff_matrix, axis=1))) / trains[j].size)
コード例 #11
0
 def compute(i, j):
     if i == j:
         return 1.0
     elif trains[i].size <= 0 or trains[j].size <= 0:
         return 0.0
     else:
         diff_matrix = sp.absolute(trains[i] - sp.atleast_2d(trains[j]).T)
         return 0.5 * (
             sp.sum(kernel(sp.amin(diff_matrix, axis=0))) / trains[i].size +
             sp.sum(kernel(sp.amin(diff_matrix, axis=1))) / trains[j].size)
コード例 #12
0
ファイル: ciaoplot.py プロジェクト: saber233/pybrain
 def __init__(self, evaluator, hof1, hof2, **args):
     if "symmetric" in args:
         M = CiaoPlot.generateData(evaluator, hof1, hof2, symmetric=args["symmetric"])
         del args["symmetric"]
     else:
         M = CiaoPlot.generateData(evaluator, hof1, hof2)
     M *= 1 / (amin(M) - amax(M))
     M -= amin(M)
     self.relData = M
     ColorMap.__init__(self, M, minvalue=0, maxvalue=1, **args)
コード例 #13
0
ファイル: triangulate.py プロジェクト: jdranczewski/Magic2
 def interpolate(self, canvas, status=None):
     # Clear the interpolated canvas
     canvas.interpolated = sp.zeros_like(canvas.fringes_image) - 1024.0
     if status is not None:
         status.set("Performing the interpolation", 70)
     else:
         print("Performing the interpolation")
     # Iterate over all the triangles in the triangulation
     for triangle in self.triangles:
         # Create a shortcut to the triangle's vertices
         co = triangle.vert_coordinates
         # Calculate a few constants for the Barycentric Coordinates
         # More info: https://codeplea.com/triangular-interpolation
         div = (co[1, 0] - co[2, 0]) * (co[0, 1] - co[2, 1]) + (
             co[2, 1] - co[1, 1]) * (co[0, 0] - co[2, 0])
         a0 = (co[1, 0] - co[2, 0])
         a1 = (co[2, 1] - co[1, 1])
         a2 = (co[2, 0] - co[0, 0])
         a3 = (co[0, 1] - co[2, 1])
         # Calculate the bounds of a rectangle that fully encloses
         # the current triangle
         xmin = int(sp.amin(triangle.vert_coordinates[:, 1]))
         xmax = int(sp.amax(triangle.vert_coordinates[:, 1])) + 1
         ymin = int(sp.amin(triangle.vert_coordinates[:, 0]))
         ymax = int(sp.amax(triangle.vert_coordinates[:, 0])) + 1
         # Take out slices of the x and y arrays,
         # containing the points' coordinates
         x_slice = canvas.x[ymin:ymax, xmin:xmax]
         y_slice = canvas.y[ymin:ymax, xmin:xmax]
         # Use Barycentric Coordinates and the magic of numpy (scipy in this
         # case) to perform the calculations with the C backend, instead
         # of iterating on pixels with Python loops.
         # If you have not worked with numpy arrays befor dear reader,
         # the idea is that if x = [[0 1]
         #                          [2 3]],
         # then x*3+1 is a completely valid operation, returning
         # x = [[1 4]
         #      [7 10]]
         # Basically, we can do maths on arrays as if they were variables.
         # Convenient, and really fast!
         w0 = (a0 * (x_slice - co[2, 1]) + a1 * (y_slice - co[2, 0])) / div
         w1 = (a2 * (x_slice - co[2, 1]) + a3 * (y_slice - co[2, 0])) / div
         w2 = sp.round_(1 - w0 - w1, 10)
         # Calculate the values for a rectangle enclosing our triangle
         slice = (self.values[triangle.vertices[0]] * w0 +
                  self.values[triangle.vertices[1]] * w1 +
                  self.values[triangle.vertices[2]] * w2)
         # Make a mask (so that we only touch the points
         # inside of the triangle).
         # In Barycentric Coordinates the points outside of the triangle
         # have at least one of the coefficients negative, so we use that
         mask = sp.logical_and(sp.logical_and(w0 >= 0, w1 >= 0), w2 >= 0)
         # Change the points in the actual canvas
         canvas.interpolated[ymin:ymax, xmin:xmax][mask] = slice[mask]
     canvas.interpolation_done = True
コード例 #14
0
 def test_largest_sphere(self):
     net = OpenPNM.Network.Cubic(shape=[5, 5, 5], spacing=[0.1, 0.2, 0.3])
     geo = OpenPNM.Geometry.GenericGeometry(network=net, pores=net.Ps,
                                            throats=net.Ts)
     geo.models.add(propname='pore.diameter',
                    model=mods.largest_sphere,
                    iters=1)
     dmin = sp.amin(geo['pore.diameter'])
     assert dmin <= 0.1
     geo.models['pore.diameter']['iters'] = 5
     geo.regenerate()
     assert dmin < sp.amin(geo['pore.diameter'])
コード例 #15
0
    def plot_temp(self):
        ######## plot 3D Temperature ########

        fig2 = plt.figure(figsize=plt.figaspect(0.5))
        ax2 = fig2.add_subplot(1, 2, 1, projection='3d')

        X2 = sp.linspace(0, 5, 5)
        Y2 = sp.linspace(0, 5, 5)

        X2, Y2 = sp.meshgrid(X2, Y2)
        X2, Y2 = X2.ravel(), Y2.ravel()

        #R = sp.sqrt(X**2 + Y**2)
        #Z = sp.sin(R)

        width = depth = 1
        bottom = X2 * 0

        #plt.ion()

        p = int(entryrowplot.get())
        temp_floats = sp.float64(self.data_str['temp'][p].split(";")).reshape(
            5, 5)
        mintemp = np.min(temp_floats)
        mintempplot = mintemp
        mintemptxt = str(round(mintemp, 1))
        maxtemp = np.max(temp_floats)
        maxtempplot = maxtemp
        maxi = maxtempplot - mintempplot + 0.1
        top2 = temp_floats.ravel() - mintemp
        top_scaled2 = (top2 - sp.amin(top2)) / (sp.amax(top2) - sp.amin(top2))
        mycolors = cm.jet(top_scaled2)
        ax2.bar3d(X2,
                  Y2,
                  bottom,
                  width,
                  depth,
                  top2,
                  color=mycolors,
                  alpha=float(entryTrans.get()))
        ax2.set_title('Temperature' + '\n' + '@ ' +
                      self.data_str['sumcurr'][p] + ' A' + '  //   @ ' +
                      self.data['voltage'][p] + ' V')

        ax2.set_zlim(0, maxi)
        ax2.set_zlabel('Temperature +' + mintemptxt + '°C')
        ax2.view_init(elev=25., azim=60)

        plt.show()

        tempplot = ts.strftime(
            "%Y.%m.%d. %H:%M:%S :") + "Temperature dargestellt"
        self.displaystate.insert(tk.END, tempplot + '\n')
コード例 #16
0
ファイル: MiscTest.py プロジェクト: yulilicau/OpenPNM
 def test_from_neighbor_throats_max(self):
     self.geo.pop('pore.seed', None)
     self.geo.models.pop('pore.seed', None)
     self.geo.models.pop('throat.seed', None)
     self.geo['throat.seed'] = sp.rand(self.net.Nt, )
     self.geo.add_model(model=mods.from_neighbor_throats,
                        propname='pore.seed',
                        throat_prop='throat.seed',
                        mode='max')
     assert sp.all(sp.in1d(self.geo['pore.seed'], self.geo['throat.seed']))
     pmin = sp.amin(self.geo['pore.seed'])
     tmin = sp.amin(self.geo['throat.seed'])
     assert pmin >= tmin
コード例 #17
0
 def test_largest_sphere(self):
     net = OpenPNM.Network.Cubic(shape=[5, 5, 5], spacing=[0.1, 0.2, 0.3])
     geo = OpenPNM.Geometry.GenericGeometry(network=net,
                                            pores=net.Ps,
                                            throats=net.Ts)
     geo.models.add(propname='pore.diameter',
                    model=mods.largest_sphere,
                    iters=1)
     dmin = sp.amin(geo['pore.diameter'])
     assert dmin <= 0.1
     geo.models['pore.diameter']['iters'] = 5
     geo.regenerate()
     assert dmin < sp.amin(geo['pore.diameter'])
コード例 #18
0
ファイル: PoreMiscTest.py プロジェクト: zhang-cugb/OpenPNM
 def test_neighbor_max(self):
     catch = self.geo.pop('pore.seed', None)
     catch = self.geo.models.pop('pore.seed', None)
     catch = self.geo.models.pop('throat.seed', None)
     mod = gm.pore_misc.neighbor
     self.geo['throat.seed'] = sp.rand(self.net.Nt,)
     self.geo.models.add(model=mod,
                         propname='pore.seed',
                         throat_prop='throat.seed',
                         mode='max')
     assert sp.all(sp.in1d(self.geo['pore.seed'], self.geo['throat.seed']))
     pmin = sp.amin(self.geo['pore.seed'])
     tmin = sp.amin(self.geo['throat.seed'])
     assert pmin >= tmin
コード例 #19
0
def representative_elementary_volume(im, npoints=1000):
    r"""
    Calculates the porosity of the image as a function subdomain size.  This
    function extracts a specified number of subdomains of random size, then
    finds their porosity.

    Parameters
    ----------
    im : ND-array
        The image of the porous material

    npoints : int
        The number of randomly located and sized boxes to sample.  The default
        is 1000.

    Returns
    -------
    A tuple containing the ND-arrays: The subdomain *volume* and its
    *porosity*.  Each of these arrays is ``npoints`` long.  They can be
    conveniently plotted by passing the tuple to matplotlib's ``plot`` function
    using the \* notation: ``plt.plot(*the_tuple, 'b.')``.  The resulting plot
    is similar to the sketch given by Bachmat and Bear [1]

    Notes
    -----
    This function is frustratingly slow.  Profiling indicates that all the time
    is spent on scipy's ``sum`` function which is needed to sum the number of
    void voxels (1's) in each subdomain.

    Also, this function is primed for parallelization since the ``npoints`` are
    calculated independenlty.

    References
    ----------
    [1] Bachmat and Bear. On the Concept and Size of a Representative
    Elementary Volume (Rev), Advances in Transport Phenomena in Porous Media
    (1987)

    """
    im_temp = sp.zeros_like(im)
    crds = sp.array(sp.rand(npoints, im.ndim) * im.shape, dtype=int)
    pads = sp.array(sp.rand(npoints) * sp.amin(im.shape) / 2 + 10, dtype=int)
    im_temp[tuple(crds.T)] = True
    labels, N = spim.label(input=im_temp)
    slices = spim.find_objects(input=labels)
    porosity = sp.zeros(shape=(N, ), dtype=float)
    volume = sp.zeros(shape=(N, ), dtype=int)
    for i in tqdm(sp.arange(0, N)):
        s = slices[i]
        p = pads[i]
        new_s = extend_slice(s, shape=im.shape, pad=p)
        temp = im[new_s]
        Vp = sp.sum(temp)
        Vt = sp.size(temp)
        porosity[i] = Vp / Vt
        volume[i] = Vt
    profile = namedtuple('profile', ('volume', 'porosity'))
    profile.volume = volume
    profile.porosity = porosity
    return profile
コード例 #20
0
ファイル: PoreSeedTest.py プロジェクト: MichaelHoeh/OpenPNM
 def test_spatially_correlated_zero_weights(self):
     f = OpenPNM.Geometry.models.pore_seed.spatially_correlated
     self.geo.models.add(propname='pore.seed',
                         model=f,
                         weights=[0, 0, 0])
     assert sp.amin(self.geo['pore.seed'] > 0)
     assert sp.amax(self.geo['pore.seed'] < 1)
コード例 #21
0
ファイル: multiphase.py プロジェクト: Maggie1988/OpenPNM
def late_pore_filling(physics,
                      phase,
                      network,
                      Pc,
                      Swp_star=0.2,
                      eta=3,
                      wetting_phase=False,
                      pore_occupancy='pore.occupancy',
                      throat_capillary_pressure='throat.capillary_pressure',
                      **kwargs):
    r'''
    Applies a late pore filling model to calculate fractional pore filling as 
    a function of applied capillary pressure.
    
    Parameters
    ----------
    Pc : float
        The capillary pressure in the non-wetting phase (Pc > 0)
    Swp_star : float
        The residual wetting phase in an invaded pore immediately after
        nonwetting phase invasion
    eta : float
        Exponent to control the rate at which wetting phase is displaced
    wetting_phase : boolean
        Indicates whether supplied phase is the wetting or non-wetting phase
    
    
    '''
    pores = phase.pores(physics.name)
    prop = phase[throat_capillary_pressure]
    neighborTs = network.find_neighbor_throats(pores,flatten=False)
    Pc_star = sp.array([sp.amin(prop[row]) for row in neighborTs])
    Swp = Swp_star*(Pc_star/Pc)**eta
    if wetting_phase:
        values = Swp*phase[pore_occupancy]*(Pc_star<Pc)
    else:
        values = (1-Swp)*(1-phase[pore_occupancy])*(Pc_star<Pc)
    return values
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
コード例 #22
0
ファイル: __MatFile__.py プロジェクト: islah/OpenPNM
 def domain_length(self,face_1,face_2):
     r'''
     Calculate the distance between two faces of the network
     
     Parameters
     ----------
     face_1 and face_2 : array_like
         Lists of pores belonging to opposite faces of the network
         
     Returns
     -------
     The length of the domain in the specified direction
     
     Notes
     -----
     - Does not yet check if input faces are perpendicular to each other
     '''
     #Ensure given points are coplanar before proceeding
     if misc.iscoplanar(self['pore.coords'][face_1]) and misc.iscoplanar(self['pore.coords'][face_2]):
         #Find distance between given faces
         x = self['pore.coords'][face_1]
         y = self['pore.coords'][face_2]
         Ds = misc.dist(x,y)
         L = sp.median(sp.amin(Ds,axis=0))
     else:
         self._logger.warning('The supplied pores are not coplanar. Length will be approximate.')
         f1 = self['pore.coords'][face_1]
         f2 = self['pore.coords'][face_2]
         distavg = [0,0,0]
         distavg[0] = sp.absolute(sp.average(f1[:,0]) - sp.average(f2[:,0]))
         distavg[1] = sp.absolute(sp.average(f1[:,1]) - sp.average(f2[:,1]))
         distavg[2] = sp.absolute(sp.average(f1[:,2]) - sp.average(f2[:,2]))
         L = max(distavg)
     return L
コード例 #23
0
ファイル: utils.py プロジェクト: maxlem/AVRCpp
def find_acceleromoeter_scale_bias_priors(measures):
    maxZ = sp.amax(measures)
    minZ = sp.amin(measures)
    bias = minZ + (maxZ - minZ) / 2.0
    scale = 1 / (maxZ - bias)

    return scale, bias
コード例 #24
0
ファイル: throat_seed.py プロジェクト: MichaelHoeh/OpenPNM
def neighbor(geometry, network, pore_prop='pore.seed', mode='min', **kwargs):
    r"""
    Adopt a value based on the values in the neighboring pores

    Parameters
    ----------
    mode : string
        Indicates how to select the values from the neighboring pores.  The
        options are:

        - min : (Default) Uses the minimum of the value found in the neighbors
        - max : Uses the maximum of the values found in the neighbors
        - mean : Uses an average of the neighbor values

    pore_prop : string
        The dictionary key containing the pore property to be used.
    """
    throats = network.throats(geometry.name)
    P12 = network.find_connected_pores(throats)
    pvalues = network[pore_prop][P12]
    if mode == 'min':
        value = _sp.amin(pvalues, axis=1)
    if mode == 'max':
        value = _sp.amax(pvalues, axis=1)
    if mode == 'mean':
        value = _sp.mean(pvalues, axis=1)
    return value
コード例 #25
0
    def scale(self, x, M=None, m=None):  # TODO:  DO IN PLACE SCALING
        """!@brief Function that standardize the data
        
            Input:
                x: the data
                M: the Max vector
                m: the Min vector
            Output:
                x: the standardize data
                M: the Max vector
                m: the Min vector
        """
        [n, d] = x.shape
        if not sp.issubdtype(x.dtype, float):
            x = x.astype('float')

        # Initialization of the output
        xs = sp.empty_like(x)

        # get the parameters of the scaling
        if M is None:
            M, m = sp.amax(x, axis=0), sp.amin(x, axis=0)

        den = M - m
        for i in range(d):
            if den[i] != 0:
                xs[:, i] = 2 * (x[:, i] - m[i]) / den[i] - 1
            else:
                xs[:, i] = x[:, i]

        return xs
コード例 #26
0
    def run(self, N=100):
        r'''
        '''
        im = self.image
        # Create a list of N random points to use as box centers
        pad = [0.1,0.1,0.45]  # Ensure points are near middle
        Cx = sp.random.randint(pad[0]*sp.shape(im)[0],(1-pad[0])*sp.shape(im)[0],N)
        Cy = sp.random.randint(pad[1]*sp.shape(im)[1],(1-pad[1])*sp.shape(im)[1],N)
        Cz = sp.random.randint(pad[2]*sp.shape(im)[2],(1-pad[2])*sp.shape(im)[2],N)
        C = sp.vstack((Cx,Cy,Cz)).T

        # Find maximum radius allowable for each point
        Rmax = sp.array(C>sp.array(sp.shape(im))/2)
        Rlim = sp.zeros(sp.shape(Rmax))
        Rlim[Rmax[:,0],0] = sp.shape(im)[0]
        Rlim[Rmax[:,1],1] = sp.shape(im)[1]
        Rlim[Rmax[:,2],2] = sp.shape(im)[2]
        R = sp.absolute(C-Rlim)
        R = R.astype(sp.int_)
        Rmin = sp.amin(R,axis=1)

        vol = []
        size = []
        porosity = []
        for i in range(0,N):
            for r in sp.arange(Rmin[i],1,-10):
                imtemp = im[C[i,0]-150:C[i,0]+150,C[i,1]-150:C[i,1]+150:,C[i,2]-r:C[i,2]+r]
                vol.append(sp.size(imtemp))
                size.append(2*r)
                porosity.append(sp.sum(imtemp==1)/(sp.size(imtemp)))

        vals = namedtuple('REV', ('porosity', 'size'))
        vals.porosity = porosity
        vals.size = size
        return vals
コード例 #27
0
def overf_power_spectrum(amp, index, f0, dt, n, cut_off=0):
    """Calculates the theoretical f**`index` power spectrum.
    """
    
    if cut_off < 0:
        raise ValueError("Low frequency cut off must not be negative.")
    # Sometimes the fitting routines do something weird that causes
    # an overflow from a ridiculous index.  Limit the index.
    index = max(index, -20)
    # Get the frequencies represented in the FFT.
    df = 1.0/dt/n
    freq = sp.arange(n, dtype=float)
    freq[n//2+1:] -= freq[-1] + 1
    freq = abs(freq)*df
    # 0th (mean) mode is meaningless has IR divergence.  Deal with it later (in
    # the cut off.
    freq[0] = 1
    # Make the power spectrum.
    power = (freq/f0)**index
    power *= amp
    # Restore frequency of mean mode.
    freq[0] = 0
    # Find the power just above the cut off frequency.
    p_cut = power[sp.amin(sp.where(freq > cut_off)[0])]
    # Flatten off the power spectrum.
    power[freq <= cut_off] = p_cut
    return power
コード例 #28
0
ファイル: OPTutils.py プロジェクト: markm541374/GPc
 def compX(self,xtrue):
     n = self.X.shape[0]
     R = sp.empty([2,n])
     for i in xrange(n):
         R[0,i] = spl.norm(self.X[i,:]-xtrue)
         R[1,i] = sp.amin(R[0,:i+1])
     return R
コード例 #29
0
ファイル: __MatFile__.py プロジェクト: Maggie1988/OpenPNM
    def domain_length(self,face_1,face_2):
        r'''
        Calculate the distance between two faces of the network

        Parameters
        ----------
        face_1 and face_2 : array_like
            Lists of pores belonging to opposite faces of the network

        Returns
        -------
        The length of the domain in the specified direction

        Notes
        -----
        - Does not yet check if input faces are perpendicular to each other
        '''
        #Ensure given points are coplanar before proceeding
        if misc.iscoplanar(self['pore.coords'][face_1]) and misc.iscoplanar(self['pore.coords'][face_2]):
            #Find distance between given faces
            x = self['pore.coords'][face_1]
            y = self['pore.coords'][face_2]
            Ds = misc.dist(x,y)
            L = sp.median(sp.amin(Ds,axis=0))
        else:
            logger.warning('The supplied pores are not coplanar. Length will be approximate.')
            f1 = self['pore.coords'][face_1]
            f2 = self['pore.coords'][face_2]
            distavg = [0,0,0]
            distavg[0] = sp.absolute(sp.average(f1[:,0]) - sp.average(f2[:,0]))
            distavg[1] = sp.absolute(sp.average(f1[:,1]) - sp.average(f2[:,1]))
            distavg[2] = sp.absolute(sp.average(f1[:,2]) - sp.average(f2[:,2]))
            L = max(distavg)
        return L
コード例 #30
0
def plot_pairwise_velocities_r(case,color,all_radial_distances,all_radial_velocities):
    dr = 0.3 # Mpc/h
    rmin, rmax = sp.amin(all_radial_distances), sp.amax(all_radial_distances) 
    rrange = rmax-rmin 
    N = int(sp.ceil(rrange/dr))
    rs = sp.linspace(rmin,rmax,N)
    v12_of_r = [[] for index in range(N)]
    
    for r,v12 in zip(all_radial_distances,all_pairwise_velocities):
    
        index = int(sp.floor((r-rmin)/dr))
        v12_of_r[index].append(v12)
            
    
    sigma_12s = sp.zeros(N)
    v12_means = sp.zeros(N)
    for index in range(len(sigma_12s)):
        v12_of_r_index = sp.array(v12_of_r[index])
        print "number of counts in the", index,"th bin:", len(v12_of_r_index)
        sigma_12 = sp.sqrt(sp.mean(v12_of_r_index**2))
        v12_mean = -sp.mean(v12_of_r_index)
        sigma_12s[index] = sigma_12
        v12_means[index] = v12_mean
    
    
    plt.plot(rs,sigma_12s,color=color,label='$\sigma_{12}$')
    plt.plot(rs,v12_means,color=color,label='$|v_{12}|$')
    plt.xlabel('r [Mpc/h]')
    plt.ylabel('[km/s]')
    plt.xscale('log')
    plt.axis([0.5,100,0,600])
コード例 #31
0
ファイル: fiologparser.py プロジェクト: huyanhua/fio
def print_all_stats(ctx, series):
    ftime = get_ftime(series)
    start = 0 
    end = ctx.interval
    print('start-time, samples, min, avg, median, 90%, 95%, 99%, max')
    while (start < ftime):  # for each time interval
        end = ftime if ftime < end else end
        sample_arrays = [ s.get_samples(start, end) for s in series ]
        samplevalue_arrays = []
        for sample_array in sample_arrays:
            samplevalue_arrays.append( 
                [ sample.value for sample in sample_array ] )
        #print('samplevalue_arrays len: %d' % len(samplevalue_arrays))
        #print('samplevalue_arrays elements len: ' + \
               #str(map( lambda l: len(l), samplevalue_arrays)))
        # collapse list of lists of sample values into list of sample values
        samplevalues = reduce( array_collapser, samplevalue_arrays, [] )
        #print('samplevalues: ' + str(sorted(samplevalues)))
        # compute all stats and print them
        myarray = scipy.fromiter(samplevalues, float)
        mymin = scipy.amin(myarray)
        myavg = scipy.average(myarray)
        mymedian = scipy.median(myarray)
        my90th = scipy.percentile(myarray, 90)
        my95th = scipy.percentile(myarray, 95)
        my99th = scipy.percentile(myarray, 99)
        mymax = scipy.amax(myarray)
        print( '%f, %d, %f, %f, %f, %f, %f, %f, %f' % (
            start, len(samplevalues), 
            mymin, myavg, mymedian, my90th, my95th, my99th, mymax))

        # advance to next interval
        start += ctx.interval
        end += ctx.interval
コード例 #32
0
ファイル: ThroatSeedTest.py プロジェクト: MichaelHoeh/OpenPNM
 def test_random(self):
     self.geo.models.add(propname='throat.seed',
                         model=OpenPNM.Geometry.models.throat_seed.random,
                         seed=0,
                         num_range=[0.1, 2])
     assert sp.amax(self.geo['throat.seed']) > 1.9
     assert sp.amin(self.geo['throat.seed']) > 0.1
コード例 #33
0
ファイル: ThroatMiscTest.py プロジェクト: MichaelHoeh/OpenPNM
 def test_random_with_range(self):
     mod = gm.throat_misc.random
     self.geo.models.add(model=mod,
                         propname='throat.seed',
                         num_range=[0.1, 0.9])
     assert sp.amax(self.geo['throat.seed']) <= 0.9
     assert sp.amin(self.geo['throat.seed']) >= 0.1
コード例 #34
0
ファイル: vmc.py プロジェクト: EPFL-LQM/gpvmc
def GetStat(filename,Nsamp=1):
    hfile=[]
    if type(filename)==list:
        for i,f in enumerate(filename):
            hfile.append(h5py.File(f,'r'))
    elif type(filename)==str:
        hfile.append(h5py.File(filename,'r'))
        filename=[filename]
    stats=[]
    datapath=[]
    for ih,h in enumerate(hfile):
        for r in h:
            for d in h[r]:
                try:
                    stats.append(int(h[r][d].attrs['statistics'][0]))
                except KeyError as err:
                    stats.append(1)
                datapath.append((filename[ih],"/{0}/{1}".format(r,d)))
    bunches,args=vln.bunch(stats,Nsamp,indices=True)
    addstat=sc.array([sum(bunches[i]) for i in range(Nsamp)])
    print("Average statistics of {0} (min: {1}, max: {2})"\
            .format(sc.mean(addstat),sc.amin(addstat),sc.amax(addstat)))
    for f in hfile:
        f.close()
    return datapath,args
コード例 #35
0
 def _do_one_outer_iteration(self, **kwargs):
     r"""
     One iteration of an outer iteration loop for an algorithm
     (e.g. time or parametric study)
     """
     # Checking for the necessary values in Picard algorithm
     nan_tol = sp.isnan(self['pore.source_tol'])
     nan_max = sp.isnan(self['pore.source_maxiter'])
     self._tol_for_all = sp.amin(self['pore.source_tol'][~nan_tol])
     self._maxiter_for_all = sp.amax(self['pore.source_maxiter'][~nan_max])
     if self._guess is None:
         self._guess = sp.zeros(self._coeff_dimension)
     t = 1
     step = 0
     # The main Picard loop
     while t > self._tol_for_all and step <= self._maxiter_for_all:
         X, t, A, b = self._do_inner_iteration_stage(guess=self._guess,
                                                     **kwargs)
         logger.info('tol for Picard source_algorithm in step ' +
                     str(step) + ' : ' + str(t))
         self._guess = X
         step += 1
     # Check for divergence
     self._steps = step
     if t >= self._tol_for_all and step > self._maxiter_for_all:
         raise Exception('Iterative algorithm for the source term reached '
                         'to the maxiter: ' + str(self._maxiter_for_all) +
                         ' without achieving tol: ' +
                         str(self._tol_for_all))
     logger.info('Picard algorithm for source term converged!')
     self.A = A
     self.b = b
     self._tol_reached = t
     return X
コード例 #36
0
ファイル: colormaps.py プロジェクト: chenyuyou/pybrain2
    def __init__(self, mat, cmap=None, pixelspervalue=20, minvalue=None, maxvalue=None):
        """ Make a colormap image of a matrix or sequence of Matrix/Connection objects

        :key mat: the matrix to be used for the colormap.
        """
        if isinstance(mat, (ParameterContainer, Connection)):
            mat = reshape(mat.params, (mat.outdim, mat.indim))

        if not isinstance(mat, ndarray):
            raise ValueError("Don't know how to display a ColorMap for a matrix of type {}".format(type(mat)))
        if minvalue == None:
            minvalue = amin(mat)
        if maxvalue == None:
            maxvalue = amax(mat)
        if isinstance(cmap, basestring) and cmap.strip():
            cmap = getattr(cm, cmap.lower().strip())
        if not cmap:
            cmap = cm.hot

        figsize = (array(mat.shape) / 100. * pixelspervalue)[::-1]
        self.fig = figure(figsize=figsize)
        axes([0, 0, 1, 1]) # Make the plot occupy the whole canvas
        axis('off')
        self.fig.set_size_inches(figsize)
        imshow(mat, cmap=cmap, clim=(minvalue, maxvalue), interpolation='nearest')
コード例 #37
0
ファイル: throat_misc.py プロジェクト: MichaelHoeh/OpenPNM
def neighbor(geometry, pore_prop='pore.seed', mode='min', **kwargs):
    r"""
    Adopt a value based on the values in neighboring pores

    Parameters
    ----------
    geometry : OpenPNM Geometry Object
        The object containing the ``pore_prop`` to be used.

    pore_prop : string
        The dictionary key to the array containing the pore property to be
        used in the calculation.  Default is 'pore.seed'.

    mode : string
        Controls how the throat property is calculated.  Options are 'min',
        'max' and 'mean'.

    """
    network = geometry._net
    throats = network.throats(geometry.name)
    P12 = network.find_connected_pores(throats)
    pvalues = network[pore_prop][P12]
    if mode == 'min':
        value = _sp.amin(pvalues, axis=1)
    if mode == 'max':
        value = _sp.amax(pvalues, axis=1)
    if mode == 'mean':
        value = _sp.mean(pvalues, axis=1)
    return value
コード例 #38
0
    def plotDigit(self, adigit, nvals=False):
        """Plots an image specified by adigit. If nvals is true, 
		then it uses a colormap to distinguish negative and 
		positive values, as opposed to plotting a monochrome image."""

        # Set max/min of scale equal to +/- of largest value found in adigit
        scale = max(abs(scipy.amax(adigit)), abs(scipy.amin(adigit)))

        # Reshape adigit to square image
        dims = int(math.sqrt(len(adigit)))
        adigit = adigit.reshape(dims, dims)

        # Plot using interpolation
        if nvals:
            plt.imshow(
                adigit,
                cmap='RdBu_r',
                vmin=-scale,
                vmax=scale,
                interpolation='nearest')  # show image in red-blue colorscale

        # Plot grey if nvals is false
        else:
            plt.imshow(adigit, cmap='Greys_r')  # show image in greyscale

        # Add colorbar and show plot
        plt.colorbar()
        plt.show()
コード例 #39
0
    def test_generic(self):
        import OpenPNM.Geometry.models.pore_diameter as mods

        func = spst.gamma(a=2, loc=0.001, scale=0.0001)
        self.geo.models.add(propname="throat.diameter", model=mods.generic, func=func, seeds="throat.seed")
        assert sp.amin(self.geo["throat.diameter"]) > 0.001
        del self.geo["throat.diameter"]
コード例 #40
0
def averageLogDistribution(values, log_step=0.2, first_point=None, last_point=None):
    """
    calculates the <values> vs. xVariable in log scale

    Parameters:
    ---------------
    values : dict
    A dictionary where the keys are the xValues
    and each element contains an array-like sequence of data
    Example:
    [1: array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),
     2: array([1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2]),
     
    values : ndarray
    Two columns array of xValues and yValues,
    to be rearranged as above
     
    Returns:
    center point of the bin, average value within the bin

    """
    # Check the list of Values
    if not checkIfVoid(values):
        print("Error")
    if isinstance(values, dict):
        xValues = np.asarray(values.keys())
        yValues = np.asarray(values.values())
    elif isinstance(values, np.ndarray):
        xValues = np.unique(values[:, 0])
        yValues = []
        for xVal in xValues:
            index = values[:, 0] == xVal
            yValues.append(values[index, 1])
        yValues = scipy.array(yValues)
    else:
        print("Values shape not recognized")
        return
    if not first_point:
        first_point = scipy.amin(xValues) * 0.99
    if not last_point:
        last_point = scipy.amax(xValues) * 1.01

    xbins, bins = getLogBins(first_point, last_point, log_step)
    yAverage = []
    for i, j in zip(bins[:-1], bins[1:]):
        q1, q2 = np.greater_equal(xValues, i), np.less(xValues, j)
        q = np.logical_and(q1, q2)
        if sum(q) == 0:
            averageValue = np.NaN
        else:
            allElements = [val for val in itertools.chain(*yValues[q])]
            averageValue = sum(allElements) / float(len(allElements))
            # print averageValue, allElements
        yAverage.append(averageValue)
    yAverage = np.asanyarray(yAverage)
    # Check if there are NaN values
    iNan = np.isnan(yAverage)
    x = xbins[~iNan]
    y = yAverage[~iNan]
    return x, y
コード例 #41
0
ファイル: pgpda.py プロジェクト: lennepkade/PGPDA
def scale(x, M=None, m=None, REVERSE=None):
    """ Function that standardize the data
        Input:
            x: the data
            M: the Max vector
            m: the Min vector
        Output:
            x: the standardize data
            M: the Max vector
            m: the Min vector
    """
    if not sp.issubdtype(x.dtype, float):
        do_convert = 1
    else:
        do_convert = 0
    if REVERSE is None:
        if M is None:
            M = sp.amax(x, axis=0)
            m = sp.amin(x, axis=0)
            if do_convert:
                xs = 2 * (x.astype("float") - m) / (M - m) - 1
            else:
                xs = 2 * (x - m) / (M - m) - 1
            return xs, M, m
        else:
            if do_convert:
                xs = 2 * (x.astype("float") - m) / (M - m) - 1
            else:
                xs = 2 * (x - m) / (M - m) - 1
            return xs
    else:
        return (1 + x) / 2 * (M - m) + m
コード例 #42
0
def test_late_pore_and_throat_filling():
    phys.models.add(propname='pore.fractional_filling',
                    model=OpenPNM.Physics.models.multiphase.late_pore_filling,
                    Pc=0,
                    Swp_star=0.2,
                    eta=1)
    mod = OpenPNM.Physics.models.multiphase.late_throat_filling
    phys.models.add(propname='throat.fractional_filling',
                    model=mod,
                    Pc=0,
                    Swp_star=0.2,
                    eta=1)
    phys.regenerate()
    drainage.setup(invading_phase=water, defending_phase=air,
                   pore_filling='pore.fractional_filling',
                   throat_filling='throat.fractional_filling')
    drainage.set_inlets(pores=pn.pores('boundary_top'))
    drainage.run()
    data = drainage.get_drainage_data()
    assert sp.amin(data['invading_phase_saturation']) == 0.0
    assert sp.amax(data['invading_phase_saturation']) < 1.0

    drainage.return_results(Pc=5000)
    assert 'pore.occupancy' in water.keys()
    assert 'throat.occupancy' in water.keys()
    assert 'pore.partial_occupancy' in water.keys()
    assert 'throat.partial_occupancy' in water.keys()
コード例 #43
0
ファイル: __Template__.py プロジェクト: AgustinPerez/OpenPNM
 def _add_labels(self):
     pind = self.get_pore_indices('all')
     Tn = self.find_neighbor_throats(pnums=pind, flatten=False)
     Tmax = sp.amax(self.num_neighbors(pnums=pind, flatten=False))
     for i in sp.arange(0, sp.shape(Tn)[0]):
         if sp.shape(Tn[i])[0] < Tmax:
             self.set_pore_info(label='surface', locations=i)
         else:
             self.set_pore_info(label='internal', locations=i)
     coords = self.get_pore_data(prop='coords')
     self.set_pore_info(label='left',locations=coords[:,0]<=(sp.amin(coords[:,0])))
     self.set_pore_info(label='right',locations=coords[:,0]>=(sp.amax(coords[:,0])))
     self.set_pore_info(label='front',locations=coords[:,1]<=(sp.amin(coords[:,1])))
     self.set_pore_info(label='back',locations=coords[:,1]>=(sp.amax(coords[:,1])))
     self.set_pore_info(label='bottom',locations=coords[:,2]<=(sp.amin(coords[:,2])))
     self.set_pore_info(label='top',locations=coords[:,2]>=(sp.amax(coords[:,2])))
コード例 #44
0
def test_residual_and_lpf():
    phys.models.add(propname='pore.fractional_filling',
                    model=OpenPNM.Physics.models.multiphase.late_pore_filling,
                    Pc=0,
                    Swp_star=0.2,
                    eta=1)
    phys.models.add(propname='throat.fractional_filling',
                    model=OpenPNM.Physics.models.multiphase.late_throat_filling,
                    Pc=0,
                    Swp_star=0.2,
                    eta=1)
    phys.regenerate()
    drainage.setup(invading_phase=water, defending_phase=air,
                   pore_filling='pore.fractional_filling',
                   throat_filling='throat.fractional_filling')
    drainage.set_inlets(pores=pn.pores('boundary_top'))
    resPs = pn.pores('internal')[sp.random.random(len(pn.pores('internal')))<0.1]
    resTs = pn.throats('internal')[sp.random.random(len(pn.throats('internal')))<0.1]
    drainage.set_residual(pores=resPs, throats=resTs)
    drainage.run()
    drainage.return_results(Pc=5000)
    data = drainage.get_drainage_data()
    assert sp.all(water["pore.partial_occupancy"][resPs] == 1.0)
    assert sp.all(water["throat.partial_occupancy"][resTs] == 1.0)
    assert sp.amin(data['invading_phase_saturation']) > 0.0
    assert sp.amax(data['invading_phase_saturation']) < 1.0
    assert sp.all(water["pore.occupancy"]+air["pore.occupancy"] == 1.0)
    total_pp = water["pore.partial_occupancy"]+air["pore.partial_occupancy"]
    assert sp.all(total_pp == 1.0)
    assert sp.all(water["throat.occupancy"]+air["throat.occupancy"] == 1.0)
    total_pt = water["throat.partial_occupancy"]+air["throat.partial_occupancy"] 
    assert sp.all(total_pt == 1.0)
コード例 #45
0
def main(database):

    #Commits per committer limited to the 30 first with the highest accumulated activity
    query = "select count(*) from scmlog group by committer_id order by count(*) desc limit 40"

    #Connecting to the data base and retrieving data
    connector = connect(database)
    results = int(connector.execute(query))
    if results > 0:
        results_aux = connector.fetchall()
    else:
        print("Error when retrieving data")
        return

    #Moving data to a list
    commits = []
    for commit in results_aux[5:]:
        #   for commits in results_aux:
        commits.append(int(commit[0]))

    #Calculating basic statistics
    print "max: " + str(sp.amax(commits))
    print "min: " + str(sp.amin(commits))
    print "mean: " + str(sp.mean(commits))
    print "median: " + str(sp.median(commits))
    print "std: " + str(sp.std(commits))
    print ".25 quartile: " + str(sp.percentile(commits, 25))
    print ".50 quartile: " + str(sp.percentile(commits, 50))
    print ".75 quartile: " + str(sp.percentile(commits, 75))
コード例 #46
0
def main(database):

    # Commits per committer limited to the 30 first with the highest accumulated activity
    query = "select count(*) from scmlog group by committer_id order by count(*) desc limit 40"

    # Connecting to the data base and retrieving data
    connector = connect(database)
    results = int(connector.execute(query))
    if results > 0:
        results_aux = connector.fetchall()
    else:
        print ("Error when retrieving data")
        return

    # Moving data to a list
    commits = []
    for commit in results_aux[5:]:
        #   for commits in results_aux:
        commits.append(int(commit[0]))

    # Calculating basic statistics
    print "max: " + str(sp.amax(commits))
    print "min: " + str(sp.amin(commits))
    print "mean: " + str(sp.mean(commits))
    print "median: " + str(sp.median(commits))
    print "std: " + str(sp.std(commits))
    print ".25 quartile: " + str(sp.percentile(commits, 25))
    print ".50 quartile: " + str(sp.percentile(commits, 50))
    print ".75 quartile: " + str(sp.percentile(commits, 75))
コード例 #47
0
    def run(self, npts=25, inv_points=None, access_limited=True, **kwargs):
        r"""
        Parameters
        ----------
        npts : int (default = 25)
            The number of pressure points to apply.  The list of pressures
            is logarithmically spaced between the lowest and highest throat
            entry pressures in the network.

        inv_points : array_like, optional
            A list of specific pressure point(s) to apply.

        """
        if 'inlets' in kwargs.keys():
            logger.info('Inlets recieved, passing to set_inlets')
            self.set_inlets(pores=kwargs['inlets'])
        if 'outlets' in kwargs.keys():
            logger.info('Outlets recieved, passing to set_outlets')
            self.set_outlets(pores=kwargs['outlets'])
        self._AL = access_limited
        if inv_points is None:
            logger.info('Generating list of invasion pressures')
            min_p = sp.amin(self['throat.entry_pressure']) * 0.98  # nudge down
            max_p = sp.amax(self['throat.entry_pressure']) * 1.02  # bump up
            inv_points = sp.logspace(sp.log10(min_p), sp.log10(max_p), npts)

        self._npts = sp.size(inv_points)
        # Execute calculation
        self._do_outer_iteration_stage(inv_points)
コード例 #48
0
 def test_calculates_frequencies(self) :
     self.Data.calc_freq()
     self.assertTrue(hasattr(self.Data, 'freq'))
     self.assertEqual(len(self.Data.freq), self.nfreq)
     self.assertAlmostEqual(self.Data.field['BANDWID'], 
                            sp.amax(self.Data.freq) -
                            sp.amin(self.Data.freq), -5)
コード例 #49
0
 def test_random(self):
     self.geo.models.add(propname='throat.seed',
                         model=OpenPNM.Geometry.models.throat_seed.random,
                         seed=0,
                         num_range=[0.1, 2])
     assert sp.amax(self.geo['throat.seed']) > 1.9
     assert sp.amin(self.geo['throat.seed']) > 0.1
コード例 #50
0
 def _do_one_outer_iteration(self, **kwargs):
     r"""
     One iteration of an outer iteration loop for an algorithm
     (e.g. time or parametric study)
     """
     # Checking for the necessary values in Picard algorithm
     nan_tol = sp.isnan(self['pore.source_tol'])
     nan_max = sp.isnan(self['pore.source_maxiter'])
     self._tol_for_all = sp.amin(self['pore.source_tol'][~nan_tol])
     self._maxiter_for_all = sp.amax(self['pore.source_maxiter'][~nan_max])
     if self._guess is None:
         self._guess = sp.zeros(self._coeff_dimension)
     t = 1
     step = 0
     # The main Picard loop
     while t > self._tol_for_all and step <= self._maxiter_for_all:
         X, t, A, b = self._do_inner_iteration_stage(guess=self._guess,
                                                     **kwargs)
         logger.info('tol for Picard source_algorithm in step ' +
                     str(step) + ' : ' + str(t))
         self._guess = X
         step += 1
     # Check for divergence
     self._steps = step
     if t >= self._tol_for_all and step > self._maxiter_for_all:
         raise Exception('Iterative algorithm for the source term reached '
                         'to the maxiter: ' + str(self._maxiter_for_all) +
                         ' without achieving tol: ' +
                         str(self._tol_for_all))
     logger.info('Picard algorithm for source term converged!')
     self.A = A
     self.b = b
     self._tol_reached = t
     return X
コード例 #51
0
    def run(self, npts=25, inv_points=None, access_limited=True, **kwargs):
        r"""
        Parameters
        ----------
        npts : int (default = 25)
            The number of pressure points to apply.  The list of pressures
            is logarithmically spaced between the lowest and highest throat
            entry pressures in the network.

        inv_points : array_like, optional
            A list of specific pressure point(s) to apply.

        """
        if 'inlets' in kwargs.keys():
            logger.info('Inlets recieved, passing to set_inlets')
            self.set_inlets(pores=kwargs['inlets'])
        if 'outlets' in kwargs.keys():
            logger.info('Outlets recieved, passing to set_outlets')
            self.set_outlets(pores=kwargs['outlets'])
        self._AL = access_limited
        if inv_points is None:
            logger.info('Generating list of invasion pressures')
            min_p = sp.amin(self['throat.entry_pressure']) * 0.98  # nudge down
            max_p = sp.amax(self['throat.entry_pressure']) * 1.02  # bump up
            inv_points = sp.logspace(sp.log10(min_p),
                                     sp.log10(max_p),
                                     npts)

        self._npts = sp.size(inv_points)
        # Execute calculation
        self._do_outer_iteration_stage(inv_points)
コード例 #52
0
ファイル: pore_misc.py プロジェクト: zhang-cugb/OpenPNM
def neighbor(geometry, throat_prop='throat.seed', mode='min', **kwargs):
    r"""
    Adopt a value from the values found in neighboring throats

    Parameters
    ----------
    geometry : OpenPNM Geometry Object
        The object containing the ``throat_prop`` to be used.

    throat_prop : string
        The dictionary key of the array containing the throat property to be
        used in the calculation.  The default is 'throat.seed'.

    mode : string
        Controls how the pore property is calculated.  Options are 'min',
        'max' and 'mean'.
    """
    network = geometry._net
    Ps = geometry.pores()
    data = geometry[throat_prop]
    neighborTs = network.find_neighbor_throats(pores=Ps,
                                               flatten=False,
                                               mode='intersection')
    values = _sp.ones((_sp.shape(Ps)[0], )) * _sp.nan
    if mode == 'min':
        for pore in Ps:
            values[pore] = _sp.amin(data[neighborTs[pore]])
    if mode == 'max':
        for pore in Ps:
            values[pore] = _sp.amax(data[neighborTs[pore]])
    if mode == 'mean':
        for pore in Ps:
            values[pore] = _sp.mean(data[neighborTs[pore]])
    return values
コード例 #53
0
def neighbor(geometry, network, pore_prop='pore.seed', mode='min', **kwargs):
    r"""
    Adopt a value based on the values in the neighboring pores

    Parameters
    ----------
    mode : string
        Indicates how to select the values from the neighboring pores.  The
        options are:

        - min : (Default) Uses the minimum of the value found in the neighbors
        - max : Uses the maximum of the values found in the neighbors
        - mean : Uses an average of the neighbor values

    pore_prop : string
        The dictionary key containing the pore property to be used.
    """
    throats = network.throats(geometry.name)
    P12 = network.find_connected_pores(throats)
    pvalues = network[pore_prop][P12]
    if mode == 'min':
        value = _sp.amin(pvalues, axis=1)
    if mode == 'max':
        value = _sp.amax(pvalues, axis=1)
    if mode == 'mean':
        value = _sp.mean(pvalues, axis=1)
    return value
コード例 #54
0
    def __init__(self,
                 mat,
                 cmap=None,
                 pixelspervalue=20,
                 minvalue=None,
                 maxvalue=None):
        """ Make a colormap image of a matrix

        :key mat: the matrix to be used for the colormap.
        """
        if minvalue == None:
            minvalue = amin(mat)
        if maxvalue == None:
            maxvalue = amax(mat)
        if not cmap:
            cmap = cm.hot

        figsize = (array(mat.shape) / 100. * pixelspervalue)[::-1]
        self.fig = figure(figsize=figsize)
        axes([0, 0, 1, 1])  # Make the plot occupy the whole canvas
        axis('off')
        self.fig.set_size_inches(figsize)
        imshow(mat,
               cmap=cmap,
               clim=(minvalue, maxvalue),
               interpolation='nearest')