Esempio n. 1
0
    def __call__(self, u, v, du_dv=None):
        p = self.order

        # make sure that u and v are of type float64 and ordered in
        # fortran fashion
        u = numpy.array(u, dtype="float64", order="fortran")
        v = numpy.array(v, dtype="float64", order="fortran")

        # allocate memory space for the result array
        result = numpy.zeros_like(u)

        # check if du_dv was given
        if du_dv != None:
            # check the size of du_dv, it must be vector of length 2
            try:
                if len(du_dv) != 2:
                    print "du_dy should be a vector of size 2: [du dv]"
                    return
            except TypeError:
                print "du_dv must be a vector of size 2: [du dv]"
                return

            # try to convert both values to int
            try:
                du_dv[0] = int(du_dv[0])
                du_dv[1] = int(du_dv[1])
            except ValueError:
                print "du_dv must be a vector with two integers"
                return

            # check if they are bigger or equal to zero
            if (du_dv[0] < 0) or (du_dv[1] < 0):
                print "du_dv must be a vector with two positive values"

        if (du_dv == None) or (du_dv == [0, 0]):
            result = _math_tools.polyeval_2d(u, v, self.coeffs[0],
                                             self.coeffs[1], result)
            return result
        elif du_dv == [1, 0]:
            result = _math_tools.polyeval_2d(u, v, self.d_coeffs[0],
                                             self.coeffs[1], result)
            return result
        elif du_dv == [0, 1]:
            result = _math_tools.polyeval_2d(u, v, self.coeffs[0],
                                             self.d_coeffs[1], result)
            return result
        else:
            # compute the coefficients of the derivatives
            du_coeffs = scipy.polyder(self.coeffs[0], m=du_dv[0])
            dv_coeffs = scipy.polyder(self.coeffs[1], m=du_dv[1])
            result = _math_tools.polyeval_2d(u, v, du_coeffs, dv_coeffs,
                                             result)
            return result
Esempio n. 2
0
    def LGR(self,figura):
        """
        Função para traçado do Lugar Geométrico das Raízes
        
        kvect: Vetor dos ganhos;
        figura: referência a uma figura do Matplotlib.
        
        O LGR é traçado sempre com ganho K = 1.
        """

        num = self.polyDnum
        den = self.polyDden
        
        # Criando vetor de ganhos (sem os pontos críticos).
        # Kmin, Kmax e numero de pontos são atributos desta classe.
        delta_k = (self.Kmax-self.Kmin) / self.Kpontos
        kvect = numpy.arange(self.Kmin,self.Kmax,delta_k)
        
        # Geracao dos pontos de separacao
        # Fazendo d(-1/G(s))/ds = 0
        deriv = scipy.polyder(den)*num - scipy.polyder(num)*den
        cpss = scipy.roots(deriv) # candidatos a ponto de separacao
        # Verificacao de quais os candidatos pertinentes
        for raiz in cpss:		
            aux = num(raiz)
            if aux != 0:
                Kc = -den(raiz) / num(raiz)
                if (numpy.isreal(Kc)) and (Kc <= self.Kmax) and (Kc >= self.Kmin):
                        kvect = numpy.append(kvect,Kc)
        # Reordena o kvect:
        kvect = numpy.sort(kvect);
        
        # Calculate the roots:
        root_vector = MyRootLocus(num,den,kvect)
        
        # Ploting:
        figura.clf()
        ax = figura.add_subplot(111)
        # Open loop poles:
        poles = numpy.array(den.r)
        ax.plot(numpy.real(poles), numpy.imag(poles), 'x')
        # Open loop zeros:
        zeros = numpy.array(num.r)
        if zeros.any():
            ax.plot(numpy.real(zeros), numpy.imag(zeros), 'o')
        for col in root_vector.T:
            # Ploting the root locus.
            ax.plot(numpy.real(col), numpy.imag(col), '-')
        
        return root_vector
Esempio n. 3
0
    def LGR(self,figura):
        """
        Função para traçado do Lugar Geométrico das Raízes
        
        kvect: Vetor dos ganhos;
        figura: referência a uma figura do Matplotlib.
        
        O LGR é traçado sempre com ganho K = 1.
        """

        num = self.polyDnum
        den = self.polyDden
        
        # Criando vetor de ganhos (sem os pontos críticos).
        # Kmin, Kmax e numero de pontos são atributos desta classe.
        delta_k = (self.Kmax-self.Kmin) / self.Kpontos
        kvect = numpy.arange(self.Kmin,self.Kmax,delta_k)
        
        # Geracao dos pontos de separacao
        # Fazendo d(-1/G(s))/ds = 0
        deriv = scipy.polyder(den)*num - scipy.polyder(num)*den
        cpss = scipy.roots(deriv) # candidatos a ponto de separacao
        # Verificacao de quais os candidatos pertinentes
        for raiz in cpss:		
            aux = num(raiz)
            if aux != 0:
                Kc = -den(raiz) / num(raiz)
                if (numpy.isreal(Kc)) and (Kc <= self.Kmax) and (Kc >= self.Kmin):
                        kvect = numpy.append(kvect,Kc)
        # Reordena o kvect:
        kvect = numpy.sort(kvect);
        
        # Calculate the roots:
        root_vector = MyRootLocus(num,den,kvect)
        
        # Ploting:
        figura.clf()
        ax = figura.add_subplot(111)
        # Open loop poles:
        poles = numpy.array(den.r)
        ax.plot(numpy.real(poles), numpy.imag(poles), 'x')
        # Open loop zeros:
        zeros = numpy.array(num.r)
        if zeros.any():
            ax.plot(numpy.real(zeros), numpy.imag(zeros), 'o')
        for col in root_vector.T:
            # Ploting the root locus.
            ax.plot(numpy.real(col), numpy.imag(col), '-')
        
        return root_vector
Esempio n. 4
0
def polyint(lowerLimit, upperLimit, x, y):
	import scipy
	from scipy.optimize import leastsq
	
	y = y[lowerLimit:upperLimit]
	x = x[lowerLimit:upperLimit]
	
	maxY = max(y)
	
	p0 = array([-276025,1051,-1,1,100])
	plsq = leastsq(polyresiduals, p0, args=(y, x), maxfev=2000)
	
	rplsq = []
	i=1
	while i <= len(plsq[0]):
		rplsq.append(plsq[0][-i])
		i = i+1
		
	diff = scipy.polyder(rplsq,1)
	roots = scipy.roots(diff)
	
	peak = 0
	for root in roots:
		if root < x[-1] and root > x[0]:
			peak = root
	
	peakIntensity = polyfunction(peak,plsq[0])
		
	return float(real(peakIntensity))
Esempio n. 5
0
def quadfit(lowerLimit, upperLimit, x,y):
	import scipy
	from scipy.optimize import leastsq
	
	y = y[lowerLimit:upperLimit]
	x = x[lowerLimit:upperLimit]
	
	maxY = max(y)
	
	p0 = array([-276025.,1051.,1.])
	plsq = leastsq(quadresiduals, p0, args=(y, x), maxfev=2000)
	
	rplsq = []
	i=1
	while i <= len(plsq[0]):
		rplsq.append(plsq[0][-i])
		i = i+1
		
	diff = scipy.polyder(rplsq,1)
	roots = scipy.roots(diff)
	
	peak = 0
	for root in roots:
		if root < x[-1] and root > x[0]:
			peak = root
	
	fit = []
	
	for i in  x:
		fit.append((i,quadfunction(i,plsq[0])))
	
	return float(real(peak))
Esempio n. 6
0
def poly2deval_fortran(x, y, polyXY, dx_dy=None):
    # make sure that x, y and polyXY are float64 and ordered in fortran mode
    x = numpy.array(x, dtype="float64", order="fortran")
    y = numpy.array(y, dtype="float64", order="fortran")
    polyXY = numpy.array(polyXY, dtype="float64", order="fortran")

    # check if dx_dy was given
    if dx_dy != None:
        # check the size of dx_dy, it must be vector of length 2
        try:
            if len(dx_dy) != 2:
                print "dx_dy should be a vector of size 2: [dx dy]"
                return
        except TypeError:
            print "dx_dy must be a vector of size 2: [dx dy]"
            return

        # try to convert both values to int
        try:
            dx_dv[0] = int(dx_dy[0])
            dx_dy[1] = int(dx_dy[1])
        except ValueError:
            print "dx_dy must be a vector with two integers"
            return

        # check if they are bigger or equal to zero
        if (dx_dy[0] < 0) or (dx_dy[1] < 0):
            print "dx_dy must be a vector with two positive values"

    # allocate memory space for the result array
    result = numpy.zeros_like(x)

    if (dx_dy == None) or (dx_dy == [0, 0]):
        result = _math_tools.polyeval_2d(x, y, polyXY, result)
        return result
    else:
        # compute the coefficients of the derivative polynomial in x
        polyXY[0, :] = scipy.polyder(polyXY[0], m=dx_dy[0])
        # compute the coefficients of the derivative polynomial in y
        polyXY[1, :] = scipy.polyder(polyXY[1], m=dx_dy[1])
        # evaluate the 2d polynomial in x and y
        result = _math_tools.polyeval_2d(x, y, polyXY, result)
        return resultcipy.polyder(polyXY[1], m=dx_dy[1])
        # evaluate the 2d polynomial in x and y
        result = _math_tools.polyeval_2d(x, y, polyXY, result)
        return result
Esempio n. 7
0
def spl3(x, y, x2, s=3):
    polycoeffs = array(scipy.polyfit(x, y, s)).flatten()

    y2 = scipy.polyval(polycoeffs, x2)
    dercoeffs = scipy.polyder(polycoeffs, 1)

    dy2 = scipy.polyval(dercoeffs, x2)
    return y2, dy2
Esempio n. 8
0
def estimate_rate_func(t, T, N, plot_flag=False, method='central diff'):

    t_est_pts = scipy.linspace(t.min(), t.max(), N + 2)
    interp_func = scipy.interpolate.interp1d(t, T, 'linear')
    T_est_pts = interp_func(t_est_pts)

    if plot_flag == True:
        pylab.figure()
        pylab.subplot(211)
        pylab.plot(t_est_pts, T_est_pts, 'or')

    # Estimate slopes
    slope_pts = scipy.zeros((N, ))
    T_slope_pts = scipy.zeros((N, ))

    if method == 'local fit':
        for i in range(1, (N + 1)):
            mask0 = t > 0.5 * (t_est_pts[i - 1] + t_est_pts[i])
            mask1 = t < 0.5 * (t_est_pts[i + 1] + t_est_pts[i])
            mask = scipy.logical_and(mask0, mask1)
            t_slope_est = t[mask]
            T_slope_est = T[mask]
            local_fit = scipy.polyfit(t_slope_est, T_slope_est, 2)
            dlocal_fit = scipy.polyder(local_fit)
            slope_pts[i - 1] = scipy.polyval(dlocal_fit, t_est_pts[i])
            T_slope_pts[i - 1] = scipy.polyval(local_fit, t_est_pts[i])
            if plot_flag == True:
                t_slope_fit = scipy.linspace(t_slope_est[0], t_slope_est[-1],
                                             100)
                T_slope_fit = scipy.polyval(local_fit, t_slope_fit)
                pylab.plot(t_slope_fit, T_slope_fit, 'g')
    elif method == 'central diff':
        dt = t_est_pts[1] - t_est_pts[0]
        slope_pts = (T_est_pts[2:] - T_est_pts[:-2]) / (2.0 * dt)
        T_slope_pts = T_est_pts[1:-1]
    else:
        raise ValueError, 'unkown method %s' % (method, )

    # Fit line to slope estimates
    fit = scipy.polyfit(T_slope_pts, slope_pts, 1)

    if plot_flag == True:
        T_slope_fit = scipy.linspace(T_slope_pts.min(), T_slope_pts.max(), 100)
        slope_fit = scipy.polyval(fit, T_slope_fit)
        pylab.subplot(212)
        pylab.plot(T_slope_fit, slope_fit, 'r')
        pylab.plot(T_slope_pts, slope_pts, 'o')
        pylab.show()

    rate_slope = fit[0]
    rate_offset = fit[1]
    return rate_slope, rate_offset
Esempio n. 9
0
def estimate_rate_func(t, T, N, plot_flag=False, method='central diff'):

    t_est_pts = scipy.linspace(t.min(), t.max(), N+2) 
    interp_func = scipy.interpolate.interp1d(t,T,'linear')
    T_est_pts = interp_func(t_est_pts)
 
    if plot_flag == True:
        pylab.figure()
        pylab.subplot(211)
        pylab.plot(t_est_pts, T_est_pts,'or')

    # Estimate slopes
    slope_pts = scipy.zeros((N,)) 
    T_slope_pts = scipy.zeros((N,))  

    if method == 'local fit':
        for i in range(1,(N+1)):
            mask0 = t > 0.5*(t_est_pts[i-1] + t_est_pts[i])
            mask1 = t < 0.5*(t_est_pts[i+1] + t_est_pts[i])
            mask = scipy.logical_and(mask0, mask1)
            t_slope_est = t[mask]
            T_slope_est = T[mask]
            local_fit = scipy.polyfit(t_slope_est,T_slope_est,2)
            dlocal_fit = scipy.polyder(local_fit)
            slope_pts[i-1] = scipy.polyval(dlocal_fit,t_est_pts[i]) 
            T_slope_pts[i-1] = scipy.polyval(local_fit,t_est_pts[i])
            if plot_flag == True:
                t_slope_fit = scipy.linspace(t_slope_est[0], t_slope_est[-1], 100)
                T_slope_fit = scipy.polyval(local_fit,t_slope_fit)
                pylab.plot(t_slope_fit, T_slope_fit,'g')
    elif method == 'central diff':
        dt = t_est_pts[1] - t_est_pts[0]
        slope_pts = (T_est_pts[2:] - T_est_pts[:-2])/(2.0*dt)
        T_slope_pts = T_est_pts[1:-1]
    else:
        raise ValueError, 'unkown method %s'%(method,)
        
    # Fit line to slope estimates
    fit = scipy.polyfit(T_slope_pts, slope_pts,1)

    if plot_flag == True:
        T_slope_fit = scipy.linspace(T_slope_pts.min(), T_slope_pts.max(),100)
        slope_fit = scipy.polyval(fit,T_slope_fit)
        pylab.subplot(212)
        pylab.plot(T_slope_fit, slope_fit,'r')
        pylab.plot(T_slope_pts, slope_pts,'o')
        pylab.show()

    rate_slope = fit[0]
    rate_offset = fit[1]
    return rate_slope, rate_offset 
Esempio n. 10
0
def _BOpntsLoc(sys):
    """Breakout point locater
    
    This returns the location of breakout points on the root locus and 
    the associated gains at those locations.
    
    Parameters
    ----------
    sys: StateSpace or TransferFunction
        Linear system
        
    Returns
    -------
    KatBO:
        list of gains at which a breakout point occurs
    BOpnts:
        list of breakout points
    """
    (nump, denp) = _systopoly1d(sys)
    
    # Breakout points potentially occur where N*D' - N'*D = 0
    numpD = polyder(nump)
    denpD = polyder(denp)
    BOpnts = roots((nump*denpD) - (numpD*denp))
    
    # Selects only the Breakout points on the real line
    BOpnts = BOpnts[imag(BOpnts) == 0] 
    
    # Finds gains from breakout points
    fgain = vectorize(lambda s: polyval(-denp,s)/polyval(nump,s))
    KatBO = fgain(BOpnts)
    
    # Selects only the positive gains at the Breakout points
    KatBO = KatBO[KatBO >= 0]

    return KatBO, BOpnts
    def PontosSeparacao(self):
        """
        Calcula os pontos de separação e retorna só os pertinentes.
        """
        num = self.polyDnum
        den = self.polyDden

        pontos = []        
        ganhos = []
        
        # Geracao dos pontos de separacao
        # Fazendo d(-1/G(s))/ds = 0
        deriv = scipy.polyder(den)*num - scipy.polyder(num)*den
        cpss = scipy.roots(deriv) # candidatos a ponto de separacao
        # Verificacao de quais os candidatos pertinentes
        for raiz in cpss:		
            aux = num(raiz)
            if aux != 0:
                Kc = -den(raiz) / num(raiz)
                if (numpy.isreal(Kc)):# and (Kc <= self.Kmax) and (Kc >= self.Kmin):
                    pontos.append(raiz)
                    ganhos.append(Kc)
        
        return pontos, ganhos
Esempio n. 12
0
    def PontosSeparacao(self):
        """
        Calcula os pontos de separação e retorna só os pertinentes.
        """
        num = self.polyDnum
        den = self.polyDden

        pontos = []        
        ganhos = []
        
        # Geracao dos pontos de separacao
        # Fazendo d(-1/G(s))/ds = 0
        deriv = scipy.polyder(den)*num - scipy.polyder(num)*den
        cpss = scipy.roots(deriv) # candidatos a ponto de separacao
        # Verificacao de quais os candidatos pertinentes
        for raiz in cpss:		
            aux = num(raiz)
            if aux != 0:
                Kc = -den(raiz) / num(raiz)
                if (numpy.isreal(Kc)):# and (Kc <= self.Kmax) and (Kc >= self.Kmin):
                    pontos.append(raiz)
                    ganhos.append(Kc)
        
        return pontos, ganhos
Esempio n. 13
0
    def _offbid(self, markups, withholds):
        """ Converts arrays of percentage price markups and capacity withholds
        into offers/bids and submits them to the marketplace.
        """
        for i, g in enumerate(self.generators):
            ratedPMin = self._g0[g]["p_min"]
            ratedPMax = self._g0[g]["p_max"]
            margPCost = self._g0[g]["p_cost"]
            margPCostModel = self._g0[g]["pcost_model"]

            # Index of the first markup in 'markups' for generator 'i'.
            k = i * (len(markups) / len(self.generators))
            # Index of the first withhold in 'withholds' for generator 'i'.
            kk = i * (len(withholds) / len(self.generators))

            # Determine the cost at zero output.
            if margPCostModel == POLYNOMIAL:
                costNoLoad = margPCost[-1]
            else:
                costNoLoad = 0.0

            # Divide available capacity equally among the offers/bids.
            if g.is_load:
                qty = ratedPMin / self.numOffbids
            else:
                qty = ratedPMax / self.numOffbids

            # Track the total quantity offered/bid for by the generator.
            totQty = 0.0

#            p0 = 0.0
#            c0 = costNoLoad
            for j in range(self.numOffbids):
                wh = withholds[kk+j]
                qty = qty * ((100.0 - wh) / 100.0)

                totQty += qty

                # The markups are cumulative to ensure cost function convexity.
                mk = sum(markups[k:k + j + 1])

                # Marginal cost (cost function gradient).
                if margPCostModel == POLYNOMIAL:
                    cmarg = polyval(polyder(margPCost), totQty)
                elif margPCostModel == PW_LINEAR:
                    n_segments = len(margPCost) - 1
                    for i in range(n_segments):
                        x1, y1 = margPCost[i]
                        x2, y2 = margPCost[i + 1]
                        if x1 <= totQty <= x2:
                            cmarg = (y2 - y1) / (x2 - x1)
                    else:
                        raise ValueError, "Invalid bid quantity [%f]." % totQty
                else:
                    raise ValueError

                # Markup the marginal cost of the generator.
                if not g.is_load:
                    prc = cmarg * ((100.0 + mk) / 100.0)
                else:
                    prc = cmarg * ((100.0 + mk) / 100.0)

                if not g.is_load:
                    offer = Offer(g, qty, prc, costNoLoad)
                    self.market.offers.append(offer)

                    self._lastAction.append(offer)

                    logger.info(
                        "%.2fMW offered at %.2f$/MWh for %s (%.1f%%, %.1f%%)."
                        % (qty, prc, g.name, mk, wh))
                else:
                    bid = Bid(g, -qty, prc, costNoLoad)
                    self.market.bids.append(bid)

                    self._lastAction.append(bid)

                    logger.info(
                        "%.2f$/MWh bid for %.2fMW for %s (%.1f%%, %.1f%%)."
                        % (prc, -qty, g.name, mk, wh))

        return self._lastAction
Esempio n. 14
0
from numpy.polynomial.polynomial import polyfit
from scipy.optimize import fmin
import numpy as np
import scipy
import numpy
import pylab
import scipy.optimize as optimize

c, stats = polyfit(range(1, len(data) + 1), data, 120, full=True)
x, stats = polyfit(range(1, len(show_data) + 1), show_data, 120, full=True)

l = c.tolist()
g = x.tolist()

f = scipy.poly1d(l[::-1])
f1 = scipy.poly1d(scipy.polyder(f))
f2 = scipy.poly1d(scipy.polyder(f1))
f3 = scipy.poly1d(scipy.polyder(f2))

g = scipy.poly1d(g[::-1])
g1 = scipy.poly1d(scipy.polyder(g))
g2 = scipy.poly1d(scipy.polyder(g1))
g3 = scipy.poly1d(scipy.polyder(g2))

t = numpy.arange(0.0, 40, 0.01)

#s = map(f,t)
#s1 = map(f1,t)
#s2 = map(f2,t)
#s3 = map(f3,t)
#pylab.plot(t, s,'#000000')
Esempio n. 15
0
    def _offbid(self, markups, withholds):
        """ Converts arrays of percentage price markups and capacity withholds
        into offers/bids and submits them to the marketplace.
        """
        for i, g in enumerate(self.generators):
            ratedPMin = self._g0[g]["p_min"]
            ratedPMax = self._g0[g]["p_max"]
            margPCost = self._g0[g]["p_cost"]
            margPCostModel = self._g0[g]["pcost_model"]

            # Index of the first markup in 'markups' for generator 'i'.
            k = i * (len(markups) / len(self.generators))
            # Index of the first withhold in 'withholds' for generator 'i'.
            kk = i * (len(withholds) / len(self.generators))

            # Determine the cost at zero output.
            if margPCostModel == POLYNOMIAL:
                costNoLoad = margPCost[-1]
            else:
                costNoLoad = 0.0

            # Divide available capacity equally among the offers/bids.
            if g.is_load:
                qty = ratedPMin / self.numOffbids
            else:
                qty = ratedPMax / self.numOffbids

            # Track the total quantity offered/bid for by the generator.
            totQty = 0.0

            #            p0 = 0.0
            #            c0 = costNoLoad
            for j in range(self.numOffbids):
                wh = withholds[kk + j]
                qty = qty * ((100.0 - wh) / 100.0)

                totQty += qty

                # The markups are cumulative to ensure cost function convexity.
                mk = sum(markups[k:k + j + 1])

                # Marginal cost (cost function gradient).
                if margPCostModel == POLYNOMIAL:
                    cmarg = polyval(polyder(margPCost), totQty)
                elif margPCostModel == PW_LINEAR:
                    n_segments = len(margPCost) - 1
                    for i in range(n_segments):
                        x1, y1 = margPCost[i]
                        x2, y2 = margPCost[i + 1]
                        if x1 <= totQty <= x2:
                            cmarg = (y2 - y1) / (x2 - x1)
                    else:
                        raise ValueError, "Invalid bid quantity [%f]." % totQty
                else:
                    raise ValueError

                # Markup the marginal cost of the generator.
                if not g.is_load:
                    prc = cmarg * ((100.0 + mk) / 100.0)
                else:
                    prc = cmarg * ((100.0 + mk) / 100.0)

                if not g.is_load:
                    offer = Offer(g, qty, prc, costNoLoad)
                    self.market.offers.append(offer)

                    self._lastAction.append(offer)

                    logger.info(
                        "%.2fMW offered at %.2f$/MWh for %s (%.1f%%, %.1f%%)."
                        % (qty, prc, g.name, mk, wh))
                else:
                    bid = Bid(g, -qty, prc, costNoLoad)
                    self.market.bids.append(bid)

                    self._lastAction.append(bid)

                    logger.info(
                        "%.2f$/MWh bid for %.2fMW for %s (%.1f%%, %.1f%%)." %
                        (prc, -qty, g.name, mk, wh))

        return self._lastAction