Example #1
0
    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
Example #2
0
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
Example #3
0
	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             
Example #4
0
    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()
Example #5
0
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