#-*- coding:utf-8 -*-

#-*- coding:cp1252-*-

############### DEFINIMOS LAS VARIABLES ###################################

archivo=open('entrada.in.txt','r')
arch=archivo.readlines()
archivo.close
nt=len(arch) -1 ##Numero de tuber�as
t=str()
tci=[] ##tuberias ciclo i
filas=[]
mfilas=[]
M_repeticiones=[]
rg=[]
fg=[]
c=[]
dq=[]
M_ciclos=[] ##Matriz de matrices que guarda los ciclos
error=input('ingrese el porcentaje de error admisible. \n')

############## PASAMOS LOS DATOS DEL ARCHIVO A UNA MATRIZ ###################

for i in range (1,nt+1): ##desde 1 porque la fila 0 no nos interesa

aux=arch[i] ##guardamos la fila
fil=aux.split('\t') ##la separamos por las tabulaciones
filas.append(fil) ##agregamos la fila

################ DEFINIMOS LAS FUNCIONES A UTILIZAR #########################

def factor_f(M_ciclos): ##funcion para el factor de friccion

from math import log10
for j in range(0,nc): ##recorremos los ciclos
ff=M_ciclos[j]
f=[]
for k in range(0,tci[j]): ##recorremos las tuberias del ciclo i
x=1/((2*log10(3.7*(float(ff[k][1]))/((float(ff[k][5])))))**2)
f.append(x)
fg.append(0)
fg[j]=f[:]

def coef_r(fg,M_ciclos): ##funcion para el coeficiente r

from math import pi
for j in range(0,nc):
fr=M_ciclos[j] ##usamos el ciclo j
f=fg[j]
r=[]
for k in range(0,tci[j]):
x=(f[k]*(float(fr[k][2]))*8)/((pi**2)*9.81*((float(fr[k][1]))**5))
r.append(x)
rg.append(0)
rg[j]=r[:]

def delta_q(rg,Q_inicial):
for i in range(1,nc+1): ##para cada ciclo
suma_rq2=0
suma_2rq=0
matriz=Q_inicial[i-1]
r=rg[i-1]
 cic=[]
for j in range(1,tci[i-1]+1): ##tuberia j ciclo i
rq2=r[j-1]*(((float(matriz[j-1][1]))))*(abs(float(matriz[j-1][1])))
suma_rq2=suma_rq2+rq2

for j in range(1,tci[i-1]+1): ##tuberia j ciclo i

rq=2*r[j-1]*(float(matriz[j-1][1]))
suma_2rq= suma_2rq +abs(rq)
delta=suma_rq2/suma_2rq
cic=cic+[i,delta]
dq.append(0)
dq[i-1]=cic[:]

############## CREAMOS UNA MATRIZ QUE GUARDE TODOS LOS CICLOS ###################
nc=input ("�Cuantos ciclos existen?\n ")
M_ciclos=[]
for k in range(0,nc):
M_ciclos.append(0)

for i in range (1,nc+1): #por cada ciclo

print "�cuantas tuberias conforman el ciclo",i, "?"
mf=filas[:]
tc=input()
tci.append(tc)
clo=[]
M_r=[]
print 'y definir direccion del flujo. \n(+: sentido horario.) \n(-: sentido
antihorario)'
print 'Ejemplo: \n T.1 \n +'
for j in range (1,tc+1): ##preguntamos por cada tuberia
t=raw_input() ##Nombre
d=raw_input() ##direccion
nyc=[t,i] ##guardamos (nombre,ciclo)
M_r.append(0)
M_r[j-1]=nyc[:] ##guardemos la tuberia y el ciclo al que pertenece

for k in range (0,nt): ##recorremos la primera columna en busca

##de un nombre conocido

if str(t)==str(mf[k][0]):
c=mf[k] ## copiamos la fila
s=abs(float(mf[k][4]))
if d=='-':
c[4]=-s
elif d=='+':
c[4]=s
clo.append(0)
clo[j-1]=c[:]

M_ciclos[i-1]=clo[:]
M_repeticiones.append(0)
M_repeticiones[i-1]=M_r[:]

###################### CREAMOS UN VECTOR PARA LOS CAUDALES EN CADA CICLO

####################
Q_inicial=[]
for j in range(0,nc):
 fq=M_ciclos[:]
Q_inicial.append(0)
Q=[]
for i in range(0,tci[j]):
m=M_ciclos[j]
q=[m[i][0],m[i][4]]
Q.append(q)
Q_inicial[j]=Q[:]

##################### REVISAMOS QU� TUBERIAS PERTENECEN A MAS DE UN CICLO######

tub_compartida=[]
n=0 ####Contador de tuberias repetidas
for j in range(0,nc): ##para cada tuberia del ciclo j
m1=M_repeticiones[j]

for i in range(0,tci[j]): ##voy a revisar tci veces (cantidad de tuberias en

el ciclo j)
for k in range(0,nc):
m2=M_repeticiones[k] ##ciclo k
if j!=k:
for w in range(0,tci[k]): ##tuberia w del ciclo k
if str(m1[i][0])==str(m2[w][0]):
n=n+1
tub_compartida.append(0)
tc=[m1[i][0],m1[i][1],m2[w][1]] ##nombre t.repetida, se
repite en ciclo i y w
tub_compartida[n-1]=tc[:]

####################### CORREMOS LAS FUNCIONES QUE NECESITAMOS

################################

factor_f(M_ciclos)
coef_r(fg,M_ciclos)

################################ ITEREMOS ####################################

cont=0
E=1 ##variable condicional que detendra el ciclo cuando sea igual a cero
while E!=0 & cont!=200:
cont=cont+1
Q_ciclo=[]
m=n
dq=[]
Q_prima=Q_inicial[:]
delta_q(rg,Q_inicial)
E=0
tub_comp=tub_compartida[:]

for j in range(0,nc): ##entramos al ciclo j

q=Q_inicial[j]
q2=q[:]
Q_ciclo=q[:] ##caudales del ciclo j
qq=q[:]
for i in range(0,tci[j]): ##para cada tuberia del ciclo j revisamos
p=0
for k in range(0,m):
while p==0:
if Q_ciclo[i][0]==tub_comp[k][0]: ##si es que esta dentro de
las "n" tuberias repetidas
b=int(tub_comp[k][2])-1 ###tuberia analizada
v=int(tub_comp[k][1])-1 ###tuberia comparada
Q_ciclo[i][1]=float(Q_ciclo[i][1])-float(dq[v][1])
+float(dq[b][1]) #si esta repetida le restamos el dq del ciclo j
tub_comp.pop(k)
m=m-1 ##y sumamos el dq del ciclo
k donde se repite
if Q_ciclo[i][0]==filas[len(filas)-1][0]:
print 'entro'
if Q_ciclo[i][0]!=tub_compartida[k][0]:
Q_ciclo[i][1]=float(Q_ciclo[i][1])-float(dq[j][1])
##sino, solo restamos dq del ciclo al que pertenece
if Q_ciclo[i][0]==filas[len(filas)-1][0]:
print 'entro'
p=1

Q_prima[j]=Q_ciclo[:] ##guardamos los nuevos caudales en una misma

matriz

for k in range(0,tci[j]):
porcentaje=abs(float(dq[j][1])/float(q2[k][1]))*100
if (porcentaje>error):
E=E+1
Q_inicial=Q_prima[:] #################### Creemos un archivo de salida con
los caudales finales #######

################## creemos una matriz con los nombres de las tuberias

##############
nombres=[]
caudales=[]

for i in range(0,nt):
nombres.append(0)
nombres[i]=filas[i][0]

for j in range(0,nc):
caudales=caudales+Q_inicial[j]