Python - Ayuda con el sig. error "NotImplementedError: invalid type in assignment"

Ayuda con el sig. error "NotImplementedError: invalid type in assignment"

Publicado por Sergio (6 intervenciones) el 30/10/2013 16:38:27

Que tal,

tratando de reescribir un código de Matlab a Python me topé con este error que no me ha dejado avanzar en un rato. El código realiza una corrida de flujos en sistemas eléctricos de potencia, preimero lee datos obtiene información de los datos leidos y depués los utiliza para realizar la corrida de flujos. Sin embargo, ya para la parte final aparece el error "NotImplementedError: invalid type in assignment" qu la verdad no he podido saber a que se deba. El código es el siguiente (aún no muestra resultados al usuario, sólo realiza la corrida de flujos):

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

"""

Created on Tue Oct 01 12:23:13 2013

@author: Serge

"""

from numpy import *

from math import *

from pylab import *

from cvxopt import *

from time import time

from sys import argv

Num_Bus=[];Tip_Bus=[];Vfi_Bus=[]; Afi_Bus=[];

CW_Bus=[];CVAR_Bus=[];GW_Bus=[];GVAR_Bus=[];

P_Rama=[];Q_Rama=[];R_Rama=[];X_Rama=[];

B_Rama=[];ITEMS=[];T_Rama=[];Tap_Tr=[]

tic=time()

#------------------Abriendo el archivo del caso de estudio

archivo=open('ieee14a.cdf','r')

#------------------Leyendo la potencia base del sistema

Pot_base=archivo.readline()[30:37]

Pot_Base=float(Pot_base)

print 'Potencia Base del Sistema:\n', '\t',Pot_base

#------------------Leyendo el número de nodos del sistema

Numero_Nod=archivo.readline()

Numero_nod=Numero_Nod.find('ITEMS')

N_nod=Numero_Nod[Numero_nod-5:Numero_nod]

N_nod=int(N_nod)

print 'Numero de nodos del Sistema:\n','\t',N_nod

#-------------------leyendo datos de buses

for i in xrange(N_nod):

    dato=archivo.readline()

    Num_Bus.append(int(dato[0:4]))#Numero del bus

    Tip_Bus.append(int(dato[24:26]))#Tipo del bus

    Vfi_Bus.append(float(dato[27:33]))#Voltaje final del bus

    Afi_Bus.append(float(dato[33:40]))#Angulo final del bus

    CW_Bus.append(float(dato[40:49]))#Carga en MW del bus

    CVAR_Bus.append(float(dato[49:59]))#Carga en MVAR del bus

    GW_Bus.append(float(dato[59:67]))#Generacion en MW del bus

    GVAR_Bus.append(float(dato[67:75]))#Generacion en MVAR del bus

#---------------------Leyendo numero de ramas

dato2=archivo.readline()

N_ram=archivo.readline()

Numero_ram=N_ram.find('ITEMS')

N_Ram=N_ram[Numero_ram-5:Numero_ram]

N_Ram=int(N_Ram)

print 'Numero de ramas del Sistema:\n','\t',N_Ram

#----------------------Formando arreglos de los datos leidos

Num_Bus=array(Num_Bus);Tip_Bus=array(Tip_Bus);Vfi_Bus=array(Vfi_Bus)

Afi_Bus=array(Afi_Bus);CW_Bus=array(CW_Bus);CVAR_Bus=array(CVAR_Bus)

GW_Bus=array(GW_Bus);GVAR_Bus=array(GVAR_Bus)

#----------------------Obteniendo tipos de buses

    #Bus tipo Carga

Tip_Carga=find(Tip_Bus==0)

    #Tip_Carga=array(Tip_Carga)

print 'Numero de buses tipo carga',Tip_Carga+1

    #Bus tipo PV

Tip_PV= find (Tip_Bus==2)

print 'Numero de buses tipo PV',Tip_PV+1

    #Bus tipo slack

Tip_Sl=find(Tip_Bus==3)

    #Buses con Geneadores

Bus_Gen=find(Tip_Bus==2)

a=len(Bus_Gen)

NewGen=range(0,a)

Ndim=N_nod+len(Tip_Carga)

#------------------------Leyendo datos de ramas

for i in xrange(N_Ram):

    dato3=archivo.readline()

    P_Rama.append(int(dato3[0:4]))#Bus inicial

    Q_Rama.append(int(dato3[5:9]))#Bus final

    R_Rama.append(float(dato3[19:29]))#Resistencia de la rama

    X_Rama.append(float(dato3[29:40]))#Reactancia de la rama

    B_Rama.append(float(dato3[40:50]))#Susceptancia de la rama

    T_Rama.append(int(dato3[18:19]))#Tipo de rama

    Tap_Tr.append(float(dato3[76:82]))#Tap del transformador

#print B_Rama

archivo.close()

P_Rama=array(P_Rama); Q_Rama=array(Q_Rama);R_Rama=array(R_Rama);

X_Rama=array(X_Rama);B_Rama=array(B_Rama);T_Rama=array(T_Rama);

Tap_Tr=array(Tap_Tr);

#-------------------------Formando Ynodo

#Indices de lados p y q

pl=find(T_Rama!=1)

pt=find(T_Rama==1)

#Nodos p y q

PL=P_Rama[pl]

PT=P_Rama[pt]

QL=Q_Rama[pl]

QT=Q_Rama[pt]

#Admitancia de la rama

Ylin=1/(R_Rama[pl]+X_Rama[pl]*1j)

Ytr=(1/(R_Rama[pt]+X_Rama[pt]*1j))/Tap_Tr[pt]

#Datos para spmatrix

PQ=concatenate((PL,PT,QL,QT))-1; #Indices pq

QP=concatenate((QL,QT,PL,PT))-1; #Indices qp

Y1=concatenate((Ylin,Ytr,Ylin,Ytr)) #Admitancia propia

Y2=-concatenate((Ylin+B_Rama[pl]/2,Ytr/Tap_Tr[pt],\

Ylin+B_Rama[pl]/2,Ytr*Tap_Tr[pt])) #Admitancia mutua

Ynodo=spmatrix(Y1,PQ,PQ,size=(N_nod,N_nod),tc='z')

Ynodo=Ynodo+spmatrix(Y2,PQ,QP,size=(N_nod,N_nod),tc='z')

print Ynodo[2,:]

it=0

Viol=0

KPQ=1

Tolv=0.001

#Definiendo funciones necesarias para el proceso

def scmplx(*arg):

    nargin=len(arg)

    print 'Numero de argumentos de entrada:',nargin,'\n\n'

    Vfasor=arg[1]*(np.cos(arg[2])+np.sin(arg[2])*1j)

    Vfasor=matrix(Vfasor)

    print 'Vfasor es:\n',Vfasor

    if nargin==4:

        scal=Vfasor[arg[3]]*((arg[0][arg[3],:]*Vfasor))

    else:

        scal=Vfasor*(conjugate(arg[0]*Vfasor))

    return scal

def jb(Ynodo,Vfi_Bus,Afi_Bus,Tip_Bus,N_nodo,Ndim,Tip_Sl):

    i=-1

    j=N_nod

    JB=spmatrix(0,range(Ndim),range(Ndim))

    Tip=Tip_Bus==0

k=0

    for k in xrange(N_nod):

        arg=(Ynodo,Vfi_Bus,Afi_Bus,k)

        S=scmplx(Ynodo,Vfi_Bus,Afi_Bus,k)

        i=i+1

        JB[i,0:N_nod]=hlkm(Vfi_Bus[k],Vfi_Bus,Afi_Bus[k],Afi_Bus,Ynodo[k,:])

        JB[i,i]=-imag[S]-imag(Ynodo[k,k])*(Vfi_Bus[k]*Vfi_Bus[k])

        JB[i,N_nod+1:Ndim]=jnkm(Vfi_Bus[k],Vfi_Bus[Tip],\

        Afi_Bus[k],Afi_Bus[Tip],Ynodo[k,Tip])

        if Tip_Bus[k]==0:

            j=j+1

            print k

            JB[i,j]=real[S]+real(Ynodo[k,k])*(Vfi_Bus[k]*Vfi_Bus[k])

            JB[j,0:N_nod]=-jnkm(Vfi_Bus[k],Vfi_Bus,Afi_Bus[k],\

            Afi_Bus,Ynodo[k,:])

            JB[j,i]= real[S]-real(Ynodo[k,k])*(Vfi_Bus[k]*Vfi_Bus[k])

            JB[j,N_nod+1:Ndim]=hklm(Vfi_Bus[k],Vfi_Bus[Tip],\

            Afi_Bus[k],Afi_Bus[Tip],Ynodo[k,Tip])

            JB[j,j]=imag[S]-imag(Ynodo[k,k]*(Vfi_Bus[k]*Vfi_Bus[k]))

    JB[Tip_Sl,:]=[]

    JB[:,Tip_Sl]=[]

def hlkm(Vk,V,Ak,A,Y):

    HLkm=Vk*(V*((real(Y)).transpose()*(np.sin(Ak-A))-(imag(Y)).transpose()*\

    (np.cos(Ak-A))))

    return HLkm

def jnkm(Vk,V,Ak,A,Y):

    JNkm=Vk*(V*((real(Y)).transpose()*(np.cos(Ak-A))+(imag(Y)).transpose()*\

    (np.sin(Ak-A))))

    return JNkm

#Lazo iterativo de cálculo

while KPQ==1 and it<=60:

    arg=(Ynodo,Vfi_Bus,Afi_Bus)

    S=scmplx(Ynodo,Vfi_Bus,Afi_Bus)

    S=S.flatten()

    DelP=CW_Bus[Tip_PV]-real(S[Tip_PV])

    DelQ=CVAR_Bus-imag(S)

    Delq=DelQ[Tip_Carga]

    Qgen=-DelQ[Tip_PV[NewGen]]*Pot_Base

    Pmismatch=hstack((DelP,Delq))

    if KPQ == 1:

        Delq=DelQ[Tip_PV]

        Pmismatch=vstack((DelP,Delq))

        #Se calcula el Jacobiano

        JB=jb(Ynodo,Vfi_Bus,Vfi_Bus,Tip_Bus,N_nod,Ndim,Tip_Sl)

        #Se resuelven ángulos y voltajes

        DeltaX=solve(JB,Pmismatch)

        #Se actualizan ángulos y voltajes

        Vfi_Bus[Tip_PV]=Vfi_Bus[Tip_PV]+DeltaX[range(N_nodo,Ndim-1)]\

        *Vfi_Bus[Tip_PV]

        Afi_Bus[Tip_Carga]=Afi_Bus[Tip_Carga]+DeltaX[range(0,N_nod-1)]

        it=it+1

toc=time()

print toc-tic

El error aparece en la línea 160 que sería esta:

JB[i,0:N_nod]=hlkm(Vfi_Bus[k],Vfi_Bus,Afi_Bus[k],Afi_Bus,Ynodo[k,:])

La verdad no tengo mucha experiencia en Python, así que pido su ayuda para poder hacer funcionar el código.Saludos y Gracias.

Valora esta pregunta

Me gusta: Está pregunta es útil y esta clara

No me gusta: Está pregunta no esta clara o no es útil

Responder

Pos: 3

Val: 2.239

Ayuda con el sig. error "NotImplementedError: invalid type in assignment"

Publicado por xve (1646 intervenciones) el 30/10/2013 19:00:06

Hola Sergio, no te se decir muy bien, ya que no he probado el código, pero a la función, estas pasando unos valores:

JB[i,0:N_nod]=hlkm(Vfi_Bus[k],Vfi_Bus,Afi_Bus[k],Afi_Bus,Ynodo[k,:])

Me da la sensación, que estas intentado obtener el valor de una lista cuando no tiene valor o no es una lista.

Puedes mostrar los datos por pantalla para ver que son correctos antes de llamar a la función:

print Vfi_Bus[k],Vfi_Bus,Afi_Bus[k],Afi_Bus,Ynodo[k,:]

Si nos puedes mostrar el resultado...

Valora esta respuesta

Me gusta: Está respuesta es útil y esta clara

No me gusta: Está respuesta no esta clara o no es útil

Comentar

Ayuda con el sig. error "NotImplementedError: invalid type in assignment"

Publicado por Sergio (6 intervenciones) el 30/10/2013 21:47:23

Hola xve,

pues los datos que se llaman en la función son arreglos (al menos eso creo, no se si un arreglo sea una lista) de los datos leidos, la [k] toma el valor de una secuencia for, por lo que tampoco creo que eso cause el error. Te dejo una imagen, espero se pueda ver....

Valora esta respuesta

Comentar

Pos: 3

Val: 2.239

Ayuda con el sig. error "NotImplementedError: invalid type in assignment"

Publicado por xve (1646 intervenciones) el 31/10/2013 07:12:34

Hola Sergio, si, un array es como una lista...

Lo que tendrías que probar, es a poner el print que te he comentado, de esta forma, verías si en algún momento estas revisando un indice de la lista que no existe.

Si lo pones, tienes que ponerlo antes de la llamada a la función.

Valora esta respuesta

Comentar

Ayuda con el sig. error "NotImplementedError: invalid type in assignment"

Publicado por Sergio (6 intervenciones) el 01/11/2013 20:30:15

Pues sólo para comentar que la función "jb" que presentaba el error se ha modificado (mi asesor lo ha reescrito), ya no aparece más este error. Al parecer era un traslape de métodos de varios paquetes por ejemplo numpy y cvxopt, sin embargo al parecer nunca se sabrá si era esto lo que lo provocaba.

Gracias a todos y espero colaborar con lo que pueda.
Saludos

Valora esta respuesta

Comentar

Pos: 3

Val: 2.239

Ayuda con el sig. error "NotImplementedError: invalid type in assignment"

Publicado por xve (1646 intervenciones) el 01/11/2013 21:35:32

Gracias por comentarlo Sergio...

Nos puedes mostrar el código para ver como ha quedado?

Valora esta respuesta

Comentar

Ayuda con el sig. error "NotImplementedError: invalid type in assignment"

Publicado por Sergio (6 intervenciones) el 02/11/2013 17:27:14

Claro... aunque aun falta corregir algunas cosas.
La función "jb" sería el sig. (el resto del código está igual):

def jb(Ynodo,Vfi_Bus,Afi_Bus,N_nod):

   Afi_Bus=matrix(Afi_Bus)

   Vfi_Bus=matrix(Vfi_Bus)

   #print e(Afi_Bus*1j)

   Vc=Vfi_Bus+(Afi_Bus*1j)

   #print Vc

   #Vc=matrix(Vc)

   Ss=Vc*conjugate(Ynodo*Vc)

#   P=spdiag(Ss)

#   Q=spdiag(imag(Ss))

#   print P

   P=spmatrix(real(Ss),range(len(Ss)),range(len(Ss)),size=(N_nod,N_nod),tc='z')

   Q=spmatrix(imag(Ss),range(len(Ss)),range(len(Ss)),size=(N_nod,N_nod),tc='z')

#   P=spdiags(real(S),0,N_nod,N_nod)

#   Q=spdiags(imag(S),0,N_nod,N_nod)

   print type(Q)

   Sp=spmatrix(Vc,range(len(Ss)),range(len(Ss)),size=(N_nod,N_nod),tc='z')

   Sp=matrix(Sp)

   #sp=sparse(Sp,tc='z')

   YS=Ynodo*Sp

   YS=matrix(YS)

   a1=real(YS)

   a2=-imag(YS)*1j

   YS1=a1+a2

   YS1=matrix(YS1)

   print type(YS1)

   #print (YS1)

   JB2 = Sp*conjugate(YS1)

   #JB2=matrix(JB2)

   #JB2=sparse([JB2])

   print 'Jb2',type(JB2)

   #JB2 = spdiags(Vc,0,Nnod,Nnod)*conj(Ynodo*spdiags(Vc,0,Nnod,Nnod));

   Jac = matrix([[imag(JB2)-Q,real(JB2)+P],[-real(JB2)+P,imag(JB2)+Q]])

   #Jac(Jac)

   print 'Jac',size(JB)

   Jac[:,NumNG+N_nod]=[]

   Jac[NumNG+N_nod,:]=[]

   Jac[Nslack,:] = [];  Jac[:,Nslack]=[];

   #print size(JB)

Ahora el problema que se presenta en esta línea:

Jac = matrix([[imag(JB2)-Q,real(JB2)+P],[-real(JB2)+P,imag(JB2)+Q]])

Al parecer tengo mezclado dos o mas tipos de datos (todos de la libreria cvxopt) por ejemplo spmatrix, sparse o matrix. Esta mezcla es la que presiento que no me deja avanzar, por lo que supongo tendría que homologar los tipos de los datos que uso, a menos que uds. sugieran algo diferente.....
Saludos!!

Valora esta respuesta

Comentar

Se puede llamar el main desde paquete?

Problema con Python