def calcular(self):
#Q=self.Q
#3tpozo=self.tpozo
#obs=self.obs
#print obs
self.d = self.controlador.obtenerDominio()
#t_obs=self.t_obs
#r_obs=self.r_obs
Tmin = float(self.listaParametros[0].valoresParametro.valor)
Tmax = float(self.listaParametros[1].valoresParametro.valor)
Smin = float(self.listaParametros[2].valoresParametro.valor)
Smax = float(self.listaParametros[3].valoresParametro.valor)
T_Nint = int(self.listaParametros[4].valoresParametro.valor)
S_Nint = int(self.listaParametros[5].valoresParametro.valor)
c_Nint = int(self.listaParametros[6].valoresParametro.valor)
goteo_min = int(self.listaParametros[7].valoresParametro.valor)
goteo_max = int(self.listaParametros[8].valoresParametro.valor)
Test_T = numpy.linspace(Tmin, Tmax, T_Nint)
Test_S = numpy.linspace(Smin, Smax, S_Nint)
Test_c = numpy.linspace(goteo_min, goteo_max, c_Nint)
#[T_T, T_S] = meshgrid(Test_T, Test_S)
#[T_T, T_c] = meshgrid(Test_T, Test_c)
obj = numpy.zeros((T_Nint, S_Nint, c_Nint), float)
minobj = 999999999999999
iToptimo = 0.0
iSoptimo = 0.0
icoptimo = 0.0
metodo = None
n = Hantush(self.d, self.controlador.parametros, None)
for n_T in range(T_Nint):
#acui.T=Test_T(n_T)
for n_S in range(S_Nint):
#acui.S=Test_S(n_S)
for n_c in range(c_Nint):
#acui.c=Test_c(n_c)
n.setearValores([Test_T[n_T], Test_S[n_S], Test_c[n_c]])
#print "paraemtros ", Test_T[n_T], Test_S[n_S], Test_c[n_c]
#Itero por todos los pozos de observacion
for p in self.pozosobs:
#Itero por las observaciones de un pozo
for obs in p.observaciones[0].devolverO():
t = obs.tiempo
descenso = n.funcionObjetivo2(p, t)
obj[n_S, n_T,
n_c] = obj[n_S, n_T, n_c] + numpy.power(
(obs.nivelpiezometrico -
(self.d.calcularH0(p.x, p.y) - descenso)),
2)
#if n_T==0 and n_S==0 and n_c==0:
#print "obj[1,1,1] :",obj[n_S,n_T,n_c],"tiempo :",obs.tiempo,"h :",obs.nivelpiezometrico,"descenso :",descenso
#Luego del for de goteo va la comparacion
if (obj[n_S, n_T, n_c] < minobj):
minobj = obj[n_S, n_T, n_c]
iToptimo = n_T
iSoptimo = n_S
icoptimo = n_c
obj[n_S, n_T, n_c] = np.log(obj[n_S, n_T, n_c])
#acui.T=Test_T(iToptimo)
#acui.S=Test_S(iSoptimo)
#acui.c=Test_c(icoptimo)
self.T = Test_T[iToptimo]
self.S = Test_S[iSoptimo]
self.c = Test_c[icoptimo]
self.obj = obj[:, :, icoptimo]
self.metodo = Hantush(self.d, self.controlador.parametros, None)
self.metodo.setearValores([self.T, self.S, self.c])
self.d.optimizacioneshechas[self.__str__()] = self
retorno = {}
retorno = {'T': self.T, 'S': self.S, 'C': self.c}
return retorno
class CaliHantush(metodooptimizacion.metodooptimizacion):
def __str__(self):
return "CaliHantush"
def __init__(self):
metodooptimizacion.metodooptimizacion.__init__(self)
self.pozosobs = []
self.listaParametros.append(parametros('Tmin', '')) #parametro 0
self.listaParametros.append(parametros('Tmax', '')) #parametro 1
self.listaParametros.append(parametros('Smin', '')) #parametro 2
self.listaParametros.append(parametros('Smax', '')) #parametro 3
self.listaParametros.append(parametros('N_int_T', '')) #parametro 4
self.listaParametros.append(parametros('N_int_S', '')) #parametro 5
self.listaParametros.append(parametros('N_int_C', '')) #parametro 6
self.listaParametros.append(parametros('goteo_min', '')) #parametro 8
self.listaParametros.append(parametros('goteo_max', '')) #parametro 9
##Estos valores hay que tomarlos desde donde ingresa el usuario
self.setearValores([
'900', '1000', '1.0e-4', '1.4e-4', '15', '15', '15', '650', '700'
])
print "se creo CaliHantush"
def setpozos(self, pozos):
for p in pozos:
pozoobs = self.controlador.buscarPozo(p)
self.pozosobs.append(pozoobs)
print "Se cargaron los pozos:" + str(self.pozosobs)
def setcontrolador(self, controlador):
self.controlador = controlador
def calcular(self):
#Q=self.Q
#3tpozo=self.tpozo
#obs=self.obs
#print obs
self.d = self.controlador.obtenerDominio()
#t_obs=self.t_obs
#r_obs=self.r_obs
Tmin = float(self.listaParametros[0].valoresParametro.valor)
Tmax = float(self.listaParametros[1].valoresParametro.valor)
Smin = float(self.listaParametros[2].valoresParametro.valor)
Smax = float(self.listaParametros[3].valoresParametro.valor)
T_Nint = int(self.listaParametros[4].valoresParametro.valor)
S_Nint = int(self.listaParametros[5].valoresParametro.valor)
c_Nint = int(self.listaParametros[6].valoresParametro.valor)
goteo_min = int(self.listaParametros[7].valoresParametro.valor)
goteo_max = int(self.listaParametros[8].valoresParametro.valor)
Test_T = numpy.linspace(Tmin, Tmax, T_Nint)
Test_S = numpy.linspace(Smin, Smax, S_Nint)
Test_c = numpy.linspace(goteo_min, goteo_max, c_Nint)
#[T_T, T_S] = meshgrid(Test_T, Test_S)
#[T_T, T_c] = meshgrid(Test_T, Test_c)
obj = numpy.zeros((T_Nint, S_Nint, c_Nint), float)
minobj = 999999999999999
iToptimo = 0.0
iSoptimo = 0.0
icoptimo = 0.0
metodo = None
n = Hantush(self.d, self.controlador.parametros, None)
for n_T in range(T_Nint):
#acui.T=Test_T(n_T)
for n_S in range(S_Nint):
#acui.S=Test_S(n_S)
for n_c in range(c_Nint):
#acui.c=Test_c(n_c)
n.setearValores([Test_T[n_T], Test_S[n_S], Test_c[n_c]])
#print "paraemtros ", Test_T[n_T], Test_S[n_S], Test_c[n_c]
#Itero por todos los pozos de observacion
for p in self.pozosobs:
#Itero por las observaciones de un pozo
for obs in p.observaciones[0].devolverO():
t = obs.tiempo
descenso = n.funcionObjetivo2(p, t)
obj[n_S, n_T,
n_c] = obj[n_S, n_T, n_c] + numpy.power(
(obs.nivelpiezometrico -
(self.d.calcularH0(p.x, p.y) - descenso)),
2)
#if n_T==0 and n_S==0 and n_c==0:
#print "obj[1,1,1] :",obj[n_S,n_T,n_c],"tiempo :",obs.tiempo,"h :",obs.nivelpiezometrico,"descenso :",descenso
#Luego del for de goteo va la comparacion
if (obj[n_S, n_T, n_c] < minobj):
minobj = obj[n_S, n_T, n_c]
iToptimo = n_T
iSoptimo = n_S
icoptimo = n_c
obj[n_S, n_T, n_c] = np.log(obj[n_S, n_T, n_c])
#acui.T=Test_T(iToptimo)
#acui.S=Test_S(iSoptimo)
#acui.c=Test_c(icoptimo)
self.T = Test_T[iToptimo]
self.S = Test_S[iSoptimo]
self.c = Test_c[icoptimo]
self.obj = obj[:, :, icoptimo]
self.metodo = Hantush(self.d, self.controlador.parametros, None)
self.metodo.setearValores([self.T, self.S, self.c])
self.d.optimizacioneshechas[self.__str__()] = self
retorno = {}
retorno = {'T': self.T, 'S': self.S, 'C': self.c}
return retorno
def calcular(self):
#Q=self.Q
#3tpozo=self.tpozo
#obs=self.obs
#print obs
self.d=self.controlador.obtenerDominio()
#t_obs=self.t_obs
#r_obs=self.r_obs
Tmin=float(self.listaParametros[0].valoresParametro.valor)
Tmax=float(self.listaParametros[1].valoresParametro.valor)
Smin=float(self.listaParametros[2].valoresParametro.valor)
Smax=float(self.listaParametros[3].valoresParametro.valor)
T_Nint=int(self.listaParametros[4].valoresParametro.valor)
S_Nint=int(self.listaParametros[5].valoresParametro.valor)
c_Nint=int(self.listaParametros[6].valoresParametro.valor)
goteo_min=int(self.listaParametros[7].valoresParametro.valor)
goteo_max=int(self.listaParametros[8].valoresParametro.valor)
Test_T=numpy.linspace(Tmin,Tmax,T_Nint)
Test_S=numpy.linspace(Smin,Smax,S_Nint)
Test_c=numpy.linspace(goteo_min,goteo_max,c_Nint)
#[T_T, T_S] = meshgrid(Test_T, Test_S)
#[T_T, T_c] = meshgrid(Test_T, Test_c)
obj=numpy.zeros((T_Nint,S_Nint,c_Nint),float)
minobj=999999999999999
iToptimo=0.0
iSoptimo=0.0
icoptimo=0.0
metodo=None
n=Hantush(self.d, self.controlador.parametros, None)
for n_T in range(T_Nint):
#acui.T=Test_T(n_T)
for n_S in range(S_Nint):
#acui.S=Test_S(n_S)
for n_c in range(c_Nint):
#acui.c=Test_c(n_c)
n.setearValores([Test_T[n_T], Test_S[n_S], Test_c[n_c]])
#print "paraemtros ", Test_T[n_T], Test_S[n_S], Test_c[n_c]
#Itero por todos los pozos de observacion
for p in self.pozosobs:
#Itero por las observaciones de un pozo
for obs in p.observaciones[0].devolverO():
t=obs.tiempo
descenso= n.funcionObjetivo2(p,t)
obj[n_S,n_T,n_c]= obj[n_S,n_T,n_c] + numpy.power((obs.nivelpiezometrico - (self.d.calcularH0( p.x, p.y ) - descenso) ),2)
#if n_T==0 and n_S==0 and n_c==0:
#print "obj[1,1,1] :",obj[n_S,n_T,n_c],"tiempo :",obs.tiempo,"h :",obs.nivelpiezometrico,"descenso :",descenso
#Luego del for de goteo va la comparacion
if (obj[n_S,n_T,n_c]< minobj):
minobj=obj[n_S,n_T,n_c]
iToptimo=n_T
iSoptimo=n_S
icoptimo=n_c
obj[n_S,n_T,n_c]=np.log(obj[n_S,n_T,n_c])
#acui.T=Test_T(iToptimo)
#acui.S=Test_S(iSoptimo)
#acui.c=Test_c(icoptimo)
self.T=Test_T[iToptimo]
self.S=Test_S[iSoptimo]
self.c=Test_c[icoptimo]
self.obj=obj[:,:,icoptimo]
self.metodo=Hantush(self.d, self.controlador.parametros, None)
self.metodo.setearValores([self.T,self.S,self.c])
self.d.optimizacioneshechas[self.__str__()]=self
retorno={}
retorno={'T':self.T,'S':self.S,'C':self.c}
return retorno
def cargar_demobarrera1000hantush(self):
global ContEnsayo
ContEnsayo=controlador.Proyecto()
ContEnsayo.dominio.alto = 1000
ContEnsayo.dominio.ancho = 1000
ContEnsayo.dominio.a=0
ContEnsayo.dominio.b=0
ContEnsayo.dominio.c=10
##Como prueba se elijio el metodo Theis de una, esto ya asocia el metodo al dominio
m=Hantush(ContEnsayo.dominio, ContEnsayo.parametros, True)
#m=Theis(ContEnsayo.dominio, ContEnsayo.parametros, True)
m.setearValores([1000,1.e-4,676.7])
#m.setearValores([700,1.1e-4])
#print "c ",ContEnsayo.metodo.dominio.c
ContEnsayo.metodo=m
#Adherimos la vista del dominio
self.ui = UiForm()
self.ui.setupUi(MainWindow, ContEnsayo, app.desktop().size().width(), app.desktop().size().height())
#b = vistaPozo(QtGui.QPixmap("content/images/blackDotIcon.png"), "pozo", self.ui.caja.scene())
#b.setX(500)
#b.setY(250)
#b.id = elementoDominio.ContEnsayo.agregarPozo(500, 250)
#self.ui.caja.botones.append(b)
b=self.agregarPozo(500, 250)
#pob = vistaPozo(QtGui.QPixmap("content/images/blackDotIcon.png"), "pozo", self.ui.caja.scene())
#pob.setX(600)
#pob.setY(250)
#pob.id = elementoDominio.ContEnsayo.agregarPozo(600, 250)
#self.ui.caja.botones.append(pob)
pob=self.agregarPozo(600, 250)
x0=250
y0=0
x1=500
y1=1000
#r = QtCore.QLineF(x0, y0, x1, y1)
#barrera = vistaBarrera(x0, y0, x1, y1, "barrera", self.ui.caja.scene())
#barrera.id = ContEnsayo.agregarRecta("positivo", x0, y0, x1, y1, ContEnsayo.dominio.alto, ContEnsayo.dominio.ancho)
#self.ui.caja.rectas.append(barrera)
#barrera=self.agregarRecta(x0, y0, x1, y1, "positivo")
noexec=1
self.ventanaImpoObs(noexec, True)
#self.vimp.archivo="ficheros/obsTheiscnbarrera.ods"
self.vimp.archivo="ficheros/obsHantush.ods"
self.vimp.nombre.setText('obs1')
self.vimp.ext="ods"
self.vimp.accionaceptar()
self.vimp.close()
self.ventanaImportarProyecto(noexec, True)
#self.importar.archivo="ficheros/bombeos.txt"
self.importar.archivo="ficheros/haintush.txt"
self.importar.nombre.setText('ens1')
self.importar.ext="txt"
self.importar.accionaceptar()
self.importar.close()
frmasociar=QtGui.QDialog()
asoe=asociarEnsayos.Ui_Dialog()
asoe.setupUi(frmasociar, b.id, ContEnsayo, True)
asoe.oe=ContEnsayo.ensayos[0]
asoe.tipo="e"
asoe.asociar()
asoe.setupUi(frmasociar, pob.id, ContEnsayo, True)
asoe.oe=ContEnsayo.observaciones[0]
asoe.tipo="o"
asoe.asociar()
class CaliHantush(metodooptimizacion.metodooptimizacion):
def __str__( self ):
return "CaliHantush"
def __init__(self):
metodooptimizacion.metodooptimizacion.__init__(self)
self.pozosobs=[]
self.listaParametros.append(parametros('Tmin','')) #parametro 0
self.listaParametros.append(parametros('Tmax','')) #parametro 1
self.listaParametros.append(parametros('Smin','')) #parametro 2
self.listaParametros.append(parametros('Smax','')) #parametro 3
self.listaParametros.append(parametros('N_int_T','')) #parametro 4
self.listaParametros.append(parametros('N_int_S','')) #parametro 5
self.listaParametros.append(parametros('N_int_C','')) #parametro 6
self.listaParametros.append(parametros('goteo_min','')) #parametro 8
self.listaParametros.append(parametros('goteo_max','')) #parametro 9
##Estos valores hay que tomarlos desde donde ingresa el usuario
self.setearValores(['900','1000','1.0e-4','1.4e-4','15','15','15','650','700'])
print "se creo CaliHantush"
def setpozos(self,pozos):
for p in pozos:
pozoobs=self.controlador.buscarPozo(p)
self.pozosobs.append(pozoobs)
print "Se cargaron los pozos:" + str(self.pozosobs)
def setcontrolador(self,controlador):
self.controlador=controlador
def calcular(self):
#Q=self.Q
#3tpozo=self.tpozo
#obs=self.obs
#print obs
self.d=self.controlador.obtenerDominio()
#t_obs=self.t_obs
#r_obs=self.r_obs
Tmin=float(self.listaParametros[0].valoresParametro.valor)
Tmax=float(self.listaParametros[1].valoresParametro.valor)
Smin=float(self.listaParametros[2].valoresParametro.valor)
Smax=float(self.listaParametros[3].valoresParametro.valor)
T_Nint=int(self.listaParametros[4].valoresParametro.valor)
S_Nint=int(self.listaParametros[5].valoresParametro.valor)
c_Nint=int(self.listaParametros[6].valoresParametro.valor)
goteo_min=int(self.listaParametros[7].valoresParametro.valor)
goteo_max=int(self.listaParametros[8].valoresParametro.valor)
Test_T=numpy.linspace(Tmin,Tmax,T_Nint)
Test_S=numpy.linspace(Smin,Smax,S_Nint)
Test_c=numpy.linspace(goteo_min,goteo_max,c_Nint)
#[T_T, T_S] = meshgrid(Test_T, Test_S)
#[T_T, T_c] = meshgrid(Test_T, Test_c)
obj=numpy.zeros((T_Nint,S_Nint,c_Nint),float)
minobj=999999999999999
iToptimo=0.0
iSoptimo=0.0
icoptimo=0.0
metodo=None
n=Hantush(self.d, self.controlador.parametros, None)
for n_T in range(T_Nint):
#acui.T=Test_T(n_T)
for n_S in range(S_Nint):
#acui.S=Test_S(n_S)
for n_c in range(c_Nint):
#acui.c=Test_c(n_c)
n.setearValores([Test_T[n_T], Test_S[n_S], Test_c[n_c]])
#print "paraemtros ", Test_T[n_T], Test_S[n_S], Test_c[n_c]
#Itero por todos los pozos de observacion
for p in self.pozosobs:
#Itero por las observaciones de un pozo
for obs in p.observaciones[0].devolverO():
t=obs.tiempo
descenso= n.funcionObjetivo2(p,t)
obj[n_S,n_T,n_c]= obj[n_S,n_T,n_c] + numpy.power((obs.nivelpiezometrico - (self.d.calcularH0( p.x, p.y ) - descenso) ),2)
#if n_T==0 and n_S==0 and n_c==0:
#print "obj[1,1,1] :",obj[n_S,n_T,n_c],"tiempo :",obs.tiempo,"h :",obs.nivelpiezometrico,"descenso :",descenso
#Luego del for de goteo va la comparacion
if (obj[n_S,n_T,n_c]< minobj):
minobj=obj[n_S,n_T,n_c]
iToptimo=n_T
iSoptimo=n_S
icoptimo=n_c
obj[n_S,n_T,n_c]=np.log(obj[n_S,n_T,n_c])
#acui.T=Test_T(iToptimo)
#acui.S=Test_S(iSoptimo)
#acui.c=Test_c(icoptimo)
self.T=Test_T[iToptimo]
self.S=Test_S[iSoptimo]
self.c=Test_c[icoptimo]
self.obj=obj[:,:,icoptimo]
self.metodo=Hantush(self.d, self.controlador.parametros, None)
self.metodo.setearValores([self.T,self.S,self.c])
self.d.optimizacioneshechas[self.__str__()]=self
retorno={}
retorno={'T':self.T,'S':self.S,'C':self.c}
return retorno
