public void ejecutarEvapotranspiracion(ref DataSet dataSetSimulador) { dataSetSimulador.evaporacionEP = new RasterDatos(dataSetSimulador.anchoEjeX, dataSetSimulador.altoEjeY); for (int x = 0; x < dataSetSimulador.anchoEjeX; x++) { for (int y = 0; y < dataSetSimulador.altoEjeY; y++) { //Si hay agua superficial if (dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] > 0.0) { //La evaporacion en ese punto se correspondera con el coeficiente de evaporacion. //evaporacionEP.setValue(EP,x,y); dataSetSimulador.evaporacionEP.matrizDEM_[y, x] = dataSetSimulador.coefEvaporacion; } //Si no hay agua superficial y la profundidad del suelo en ese punto no es nula else if (dataSetSimulador.profundidadSuelos.matrizDEM_[y, x] > 0.0) { //La evaporacion en ese punto se traduce en: dataSetSimulador.evaporacionEP.matrizDEM_[y, x] = dataSetSimulador.coefEvaporacion * (dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x] / dataSetSimulador.profundidadSuelos.matrizDEM_[y, x]); //Que se corresponde con la formula extraida del doc referente a Wolski y Overton. //Si no hay agua en la capa 1 la evaporacion queda en 0. } } } }
public ControlEjecucionProc(ConfParameters parametrosSimulacion, GUIModelEjecForm formEjec) { formPadre = formEjec; parametrosSimulador = parametrosSimulacion; dataSetSimulador = new DataSet(parametrosSimulacion); arrayOfMatrizFlowsEnX = new int[parametrosSimulador.escSupPasosNts + 1][,]; arrayOfMatrizFlowsEnY = new int[parametrosSimulador.escSupPasosNts + 1][,]; infiltradorVertical = new InfiltracionVertical(); escurridorSuperficial = new EscurrimientoSuperficial(); clusterizadorPlanchador = new ClusteringPlanchado(); evaporador = new Evapotranspiracion(); infiltradorHorizontal = new InfiltracionHorizontal(); }
public void ejecutarEscurrimientoSuperficial(ref DataSet dataSetSimulador, float dts) { float tempValue; //Se hace una copia de los datos que seran leidos para procesar. Ya que no acepta valores por referencia. DataSet copyDataSetSimulador = dataSetSimulador; //Se generan datos RasterDatos tempFlujoEnX = new RasterDatos(dataSetSimulador.anchoEjeX, dataSetSimulador.altoEjeY); RasterDatos tempFlujoEnY = new RasterDatos(dataSetSimulador.anchoEjeX, dataSetSimulador.altoEjeY); int anchoEjeX = dataSetSimulador.anchoEjeX; int altoEjeY = dataSetSimulador.altoEjeY; Parallel.Invoke( () => { tempFlujoEnX = escurrimientoSuperficialEnX(copyDataSetSimulador, dts, 0, anchoEjeX, 0, altoEjeY); }, // close first Action () => { tempFlujoEnY = escurrimientoSuperficialEnY(copyDataSetSimulador, dts, 0, anchoEjeX, 0, altoEjeY); } //close second Action ); //close parallel.invoke dataSetSimulador.flujoEnXSuperficie = tempFlujoEnX; dataSetSimulador.flujoEnYSuperficie = tempFlujoEnY; /* dataSetSimulador.flujoEnXSuperficie = escurrimientoSuperficialEnX(dataSetSimulador, dts); dataSetSimulador.flujoEnYSuperficie = escurrimientoSuperficialEnY(dataSetSimulador, dts);*/ dataSetSimulador.flujoResultanteSuperficie = new RasterDatos(dataSetSimulador.anchoEjeX, dataSetSimulador.altoEjeY); for (int x = 1; x < dataSetSimulador.anchoEjeX - 1; x++) { for (int y = 1; y < dataSetSimulador.altoEjeY - 1; y++) { tempValue = (float)((dataSetSimulador.flujoEnXSuperficie.matrizDEM_[y, x - 1] - dataSetSimulador.flujoEnXSuperficie.matrizDEM_[y, x] + dataSetSimulador.flujoEnYSuperficie.matrizDEM_[y - 1, x] - dataSetSimulador.flujoEnYSuperficie.matrizDEM_[y, x]) / Math.Pow(dataSetSimulador.dimensionCelda, 2.0)); dataSetSimulador.flujoResultanteSuperficie.matrizDEM_[y, x] = tempValue; } } }
public void ejecutarInfiltracionHorizontal(ref DataSet dataSetSimulador) { float tempValue; dataSetSimulador.flujoResultanteCapaPerm = new RasterDatos(dataSetSimulador.anchoEjeX, dataSetSimulador.altoEjeY); infiltracionHorizontalEnX(ref dataSetSimulador); infiltracionHorizontalEnY(ref dataSetSimulador); for (int x = 1; x < dataSetSimulador.anchoEjeX - 1; x++) { for (int y = 1; y < dataSetSimulador.altoEjeY - 1; y++) { tempValue = (float)(dataSetSimulador.flujoResultanteCapaPerm.matrizDEM_[y, x] + (dataSetSimulador.flujoEnXCapaPermeable.matrizDEM_[y, x - 1] - dataSetSimulador.flujoEnXCapaPermeable.matrizDEM_[y, x] + dataSetSimulador.flujoEnYCapaPermeable.matrizDEM_[y - 1, x] - dataSetSimulador.flujoEnYCapaPermeable.matrizDEM_[y, x]) / Math.Pow(dataSetSimulador.dimensionCelda, 2.0)); dataSetSimulador.flujoResultanteCapaPerm.matrizDEM_[y, x] = tempValue; } } }
private void infiltracionHorizontalEnY(ref DataSet dataSetSimulador) { float tempValue; dataSetSimulador.flujoEnYCapaPermeable = new RasterDatos(dataSetSimulador.anchoEjeX, dataSetSimulador.altoEjeY); for (int x = 0; x < dataSetSimulador.anchoEjeX; x++) { for (int y = 0; y < dataSetSimulador.altoEjeY - 1; y++) { //Si hay agua en el punto (x,y) o en el punto (x+1,y) y la capacidad de almacenamiento del suelo //es mayor que cero en ambos puntos if ((dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x] > 0.0 || dataSetSimulador.aguaCapaPermeable.matrizDEM_[y + 1, x] > 0.0) && dataSetSimulador.capacidadAlmacenSuelo.matrizDEM_[y, x] > 0.0 && dataSetSimulador.capacidadAlmacenSuelo.matrizDEM_[y + 1, x] > 0.0) { //No coincide con la formula??? O como se explica esto??? Grafica en papel. tempValue = (dataSetSimulador.kConductividadHSuelo.matrizDEM_[y, x] + dataSetSimulador.kConductividadHSuelo.matrizDEM_[y + 1, x]) / 2.0f * ((dataSetSimulador.aguaCapaPermeable.matrizDEM_[y + 1, x] - dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x]) + (dataSetSimulador.alturaSueloPermeable.matrizDEM_[y + 1, x] - dataSetSimulador.alturaSueloPermeable.matrizDEM_[y, x])) * (dataSetSimulador.aguaCapaPermeable.matrizDEM_[y + 1, x] + dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x]) / 2.0f; dataSetSimulador.flujoEnYCapaPermeable.matrizDEM_[y, x] = tempValue; } } } }
private void infiltracionHorizontalEnX(ref DataSet dataSetSimulador) { float tempValue; dataSetSimulador.flujoEnXCapaPermeable = new RasterDatos(dataSetSimulador.anchoEjeX, dataSetSimulador.altoEjeY); for (int x = 0; x < dataSetSimulador.anchoEjeX - 1; x++) { for (int y = 0; y < dataSetSimulador.altoEjeY; y++) { //Si hay agua en el punto (x,y) o en el punto (x+1,y) y la capacidad de almacenamiento del suelo //es mayor que cero en ambos puntos if ((dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x] > 0.0 || dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x + 1] > 0.0) && dataSetSimulador.capacidadAlmacenSuelo.matrizDEM_[y, x] > 0.0 && dataSetSimulador.capacidadAlmacenSuelo.matrizDEM_[y, x + 1] > 0.0) { tempValue = (float)((dataSetSimulador.kConductividadHSuelo.matrizDEM_[y, x] + dataSetSimulador.kConductividadHSuelo.matrizDEM_[y, x + 1]) / 2.0 * ((dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x + 1] - dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x]) + (dataSetSimulador.alturaSueloPermeable.matrizDEM_[y, x + 1] - dataSetSimulador.alturaSueloPermeable.matrizDEM_[y, x])) * (dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x + 1] + dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x]) / 2.0); dataSetSimulador.flujoEnXCapaPermeable.matrizDEM_[y, x] = tempValue; } } } }
void clustering(ref DataSet dataSetSimulador) { int numberClusterCreated = 0; dataSetSimulador.matrizClusters = new RasterDatos(dataSetSimulador.anchoEjeX, dataSetSimulador.altoEjeY); List<Tuple<int, int>> tempCluster = new List<Tuple<int, int>>(); listOfClusters.Add(tempCluster); float numberClusterAssignedNew = 0; Tuple<int, int> tempParPixel; //recorrer toda la matriz de cantidad de variaciones for (int j = 0; j < dataSetSimulador.altoEjeY; j++) { for (int i = 0; i < dataSetSimulador.anchoEjeX; i++) { numberClusterAssignedNew = 0; //si el pixel tiene valor de cantidad de variaciones mayor que el definido //debo determinar un valor de cluster al cual pertenece if (dataSetSimulador.matrizCantVariaciones.matrizDEM_[j, i] > variacionesMax) { //si ES un pixel del borde izquierdo superior, o sea que no tiene vecinos a los que se le haya podido asignar //un cluster previamente if (i == 0 && j == 0) { numberClusterCreated++; //Cuando se crea un nuevo indice de nuevo cluster se crea la nueva lista que almacenara //los pares tempCluster = new List<Tuple<int, int>>(); listOfClusters.Add(tempCluster); numberClusterAssignedNew = numberClusterCreated; } else { if (i != 0) { //si la matriz de asignacion de clusters tiene un cluster asignado para el vecino i-1, j if (dataSetSimulador.matrizClusters.matrizDEM_[j, i - 1] != 0.0) { //asignar ese cluster al nuevo pixel numberClusterAssignedNew = dataSetSimulador.matrizClusters.matrizDEM_[j, i - 1]; } //si no tiene un cluster asignado para el vecino i-1, j else { if (j != 0) { if (dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i - 1] != 0.0) { //asignar ese cluster al nuevo pixel numberClusterAssignedNew = dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i - 1]; } } } } if (j != 0 && numberClusterAssignedNew == 0.0) { if (dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i] != 0.0) { //asignar ese cluster al nuevo pixel numberClusterAssignedNew = dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i]; } //si no tiene un cluster asignado para el vecino i + 1, j - 1 else { if (dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i + 1] != 0.0) { //asignar ese cluster al nuevo pixel numberClusterAssignedNew = dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i + 1]; } } } } //Si es el pixel superior izquierdo o no salio del ciclo por haber encontrado un vecino con cluster asignado if (numberClusterAssignedNew == 0.0) { numberClusterCreated++; tempCluster = new List<Tuple<int, int>>(); listOfClusters.Add(tempCluster); numberClusterAssignedNew = numberClusterCreated; } //Cuando esta por asignar el nuevo cluster al cual pertenece el pixel tengo que ver si alguno de los //otros vecinos tiene asignado un cluster diferente bool different = false; float differentValue = 0; if (i != 0) { if (dataSetSimulador.matrizClusters.matrizDEM_[j, i - 1] != 0.0 && numberClusterAssignedNew != dataSetSimulador.matrizClusters.matrizDEM_[j, i - 1]) { different = true; differentValue = dataSetSimulador.matrizClusters.matrizDEM_[j, i - 1]; } if (j != 0) { if (dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i - 1] != 0.0 && numberClusterAssignedNew != dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i - 1]) { different = true; differentValue = dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i - 1]; } } } if (j != 0) { if (dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i] != 0.0 && numberClusterAssignedNew != dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i]) { different = true; differentValue = dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i]; } else if (i != dataSetSimulador.anchoEjeX - 1) { if (dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i + 1] != 0.0 && numberClusterAssignedNew != dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i + 1]) { different = true; differentValue = dataSetSimulador.matrizClusters.matrizDEM_[j - 1, i + 1]; } } } if (different) { //Seteo en la matriz de clusters los valores correspondiente for (int n = 0; n < listOfClusters[(int)differentValue].Count; n++) { dataSetSimulador.matrizClusters.matrizDEM_[listOfClusters[(int)differentValue][n].Item1, listOfClusters[(int)differentValue][n].Item2] = numberClusterAssignedNew; } //Cambio los elementos de Cluster int elementos = listOfClusters[(int)differentValue].Count; for (int m = 0; m < elementos; m++) { listOfClusters[(int)numberClusterAssignedNew].Add(listOfClusters[(int)differentValue][m]); } listOfClusters[(int)differentValue].Clear(); } different = false; //Primero deberias crear el arreglo de clusters tempParPixel = new Tuple<int, int>(j, i); listOfClusters[(int)numberClusterAssignedNew].Add(tempParPixel); //Estos es para poder visualizar el cluster, para desarrollo, puede ser omitido tal vez dataSetSimulador.matrizClusters.matrizDEM_[j, i] = numberClusterAssignedNew; } } } }
void planchado(ref DataSet dataSetSimulador) { Tuple<int, int> tempParPixel; List<Tuple<int, int>> tempCluster; List<Tuple<double, Tuple<int, int>>> listAlturasDem = new List<Tuple<double, Tuple<int, int>>>(); Tuple<double, Tuple<int, int>> tempAltura; double alturaDemTemp = 0.0f; //Altura media calculada en la que tiene que quedar el agua double media = 0.0; //agua total double aguaTotal = 0.0; //DEM total double DEMTotal = 0.0; //temporario de agua pixel double tempAguaPixel = 0.0; double tempDemPixel = 0.0; //Cantidad de pixeles en los que se divide el agua int pixelesN; List<float> verificacion = new List<float>(); for (int g = 1; g < listOfClusters.Count; g++) { if (listOfClusters[g].Count != 0) { tempCluster = listOfClusters[g]; pixelesN = tempCluster.Count; //Se obtienen el agua for (int h = 0; h < pixelesN; h++) { tempParPixel = tempCluster[h]; //Agua del pixel en cuestion tempAguaPixel = dataSetSimulador.aguaSuperficie.matrizDEM_[tempParPixel.Item1, tempParPixel.Item2]; //Altura del pixel en cuestion tempDemPixel = dataSetSimulador.DEM.matrizDEM_[tempParPixel.Item1, tempParPixel.Item2]; //AGUA TOTAL: Sumo el agua que corresponde al pixel total al total de agua aguaTotal += tempAguaPixel; //DEM TOTAL DEMTotal += tempDemPixel; //Se crea el nuevo elemento que contiene (altura de dem, pixeles) tempAltura = new Tuple<double, Tuple<int, int>>(tempDemPixel, tempParPixel); //Agrego listAlturasDem.Add(tempAltura); } listAlturasDem.Sort((a, b) => a.Item1.CompareTo(b.Item1)); listAlturasDem.Reverse(); //obtener la media media = (aguaTotal + DEMTotal) / pixelesN; //Sacar el elemento mas grande alturaDemTemp = listAlturasDem[0].Item1; //Elimino de la lista los elementos del dem que dieron por encima de la media while (media < alturaDemTemp) { DEMTotal = DEMTotal - alturaDemTemp; pixelesN = pixelesN - 1; media = (aguaTotal + DEMTotal) / pixelesN; //Sacarle el agua a los pixeles cuya altura del DEM supere tempParPixel = listAlturasDem[0].Item2; dataSetSimulador.aguaSuperficie.matrizDEM_[tempParPixel.Item1, tempParPixel.Item2] = 0.0f; //Se lo saca de la lista y se toma el siguiente elemento listAlturasDem.RemoveAt(0); alturaDemTemp = listAlturasDem[0].Item1; } //Acá distribuir el agua en los pixeles los cuales el DEM dio por debajo de la media. for (int i = 0; i < listAlturasDem.Count; i++) { tempAltura = listAlturasDem[i]; tempParPixel = tempAltura.Item2; dataSetSimulador.aguaSuperficie.matrizDEM_[tempParPixel.Item1, tempParPixel.Item2] = (float)(media - tempAltura.Item1); aguaTotal = aguaTotal - (media - tempAltura.Item1); } listAlturasDem.Clear(); aguaTotal = 0.0f; DEMTotal = 0.0f; } } listOfClusters.Clear(); }
public void ejecutarClusteringPlanchado(ref DataSet dataSetSimulador) { variacionesMax = dataSetSimulador.maxCantidadVariaciones; clustering(ref dataSetSimulador); planchado(ref dataSetSimulador); }
public void ejecutarInfiltracionVertical(ref DataSet dataSetSimulador) { //Para cada punto de la cuadricula for (int x = 0; x < dataSetSimulador.anchoEjeX; x++) { for (int y = 0; y < dataSetSimulador.altoEjeY; y++) { float alturaEquivCapa1 = 0.0f; float alturaLibreCapa1 = 0.0f; float aguaCabeCapa1 = 0.0f; float maxFluxSupCapa1 = 0.0f; float auxiliar2 = 0.0f; //Si hay agua en la superficie y hay lugar para agua en la capa 1 if (dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] > 0 && dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x] < dataSetSimulador.profundidadSuelos.matrizDEM_[y, x]) { //Calculo la maxima agua que puede pasar de la superficia a la capa 1 maxFluxSupCapa1 = 2 * dataSetSimulador.kConductividadHSuelo.matrizDEM_[y, x]; //Guardo la altura libre de agua que hay en la capa 1 alturaLibreCapa1 = dataSetSimulador.profundidadSuelos.matrizDEM_[y, x] - dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x]; auxiliar2 = alturaLibreCapa1; aguaCabeCapa1 = alturaLibreCapa1 * dataSetSimulador.capacidadAlmacenSuelo.matrizDEM_[y, x] / dataSetSimulador.profundidadSuelos.matrizDEM_[y, x]; if (dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] <= maxFluxSupCapa1) { //Si el agua en superficie es menor que el maximo que se le puede sacar y ese maximo es menor que la que cantidad que cabe en la capa 1 if (dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] < aguaCabeCapa1) { //Altura equivalente en capa 1 alturaEquivCapa1 = dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] * dataSetSimulador.profundidadSuelos.matrizDEM_[y, x] / dataSetSimulador.capacidadAlmacenSuelo.matrizDEM_[y, x]; auxiliar2 = alturaEquivCapa1; //Agua en superficie aguaCabeCapa1 = dataSetSimulador.aguaSuperficie.matrizDEM_[y, x]; } //El agua en superficie se actualiza con lo que sale dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] = dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] - aguaCabeCapa1; ; //El agua en la capa 1 se actualiza con lo que le entra dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x] = dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x] + auxiliar2; } else { if (maxFluxSupCapa1 < aguaCabeCapa1) { //Altura equivalente en capa 1 alturaEquivCapa1 = maxFluxSupCapa1 * dataSetSimulador.profundidadSuelos.matrizDEM_[y, x] / dataSetSimulador.capacidadAlmacenSuelo.matrizDEM_[y, x]; auxiliar2 = alturaEquivCapa1; //Agua en superficie aguaCabeCapa1 = maxFluxSupCapa1; } //El agua en superficie se actualiza con lo que sale dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] = dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] - aguaCabeCapa1; ; //El agua en la capa 1 se actualiza con lo que le entra dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x] = dataSetSimulador.aguaCapaPermeable.matrizDEM_[y, x] + auxiliar2; } } } } }
public void ejecutarEscurrimientoSuperficial(ref DataSet dataSetSimulador, float dts) { float tempValue; //Se hace una copia de los datos que seran leidos para procesar. Ya que no acepta valores por referencia. DataSet copyDataSetSimulador = dataSetSimulador; int anchoEjeX = dataSetSimulador.anchoEjeX; int altoEjeY = dataSetSimulador.altoEjeY; //Se deben generar los raster tanto para X como para Y /*RasterDatos[] rastersFlujoX = new RasterDatos[divXFlujoEnX * divYFlujoEnX]; RasterDatos[] rastersFlujoY = new RasterDatos[divXFlujoEnY * divYFlujoEnY];*/ RasterDatos[] rastersFlujoX = desarmarRaster(anchoEjeX, altoEjeY, 2, 2); RasterDatos[] rastersFlujoY = desarmarRaster(anchoEjeX, altoEjeY, 2, 2); //Se generan datos RasterDatos tempFlujoEnX = new RasterDatos(anchoEjeX, altoEjeY); RasterDatos tempFlujoEnY = new RasterDatos(anchoEjeX, altoEjeY); Parallel.Invoke( () => { rastersFlujoX[0] = escurrimientoSuperficialEnX(copyDataSetSimulador, dts, 0, anchoEjeX/2, 0, altoEjeY/2); }, () => { rastersFlujoX[1] = escurrimientoSuperficialEnX(copyDataSetSimulador, dts, anchoEjeX/2, anchoEjeX, 0, altoEjeY/2); }, () => { rastersFlujoX[2] = escurrimientoSuperficialEnX(copyDataSetSimulador, dts, 0, anchoEjeX/2, altoEjeY/2, altoEjeY); }, () => { rastersFlujoX[3] = escurrimientoSuperficialEnX(copyDataSetSimulador, dts, anchoEjeX/2, anchoEjeX, altoEjeY/2, altoEjeY); }, () => { rastersFlujoY[0] = escurrimientoSuperficialEnY(copyDataSetSimulador, dts, 0, anchoEjeX/2, 0, altoEjeY/2); }, () => { rastersFlujoY[1] = escurrimientoSuperficialEnY(copyDataSetSimulador, dts, anchoEjeX/2, anchoEjeX, 0, altoEjeY/2); }, () => { rastersFlujoY[2] = escurrimientoSuperficialEnY(copyDataSetSimulador, dts, 0, anchoEjeX/2, altoEjeY/2, altoEjeY); }, () => { rastersFlujoY[3] = escurrimientoSuperficialEnY(copyDataSetSimulador, dts, anchoEjeX/2, anchoEjeX, altoEjeY/2, altoEjeY); } ); //close parallel.invoke /* Parallel.Invoke( () => { tempFlujoEnX = escurrimientoSuperficialEnX(copyDataSetSimulador, dts, 0, anchoEjeX, 0, altoEjeY); }, // close first Action () => { tempFlujoEnY = escurrimientoSuperficialEnY(copyDataSetSimulador, dts,0, anchoEjeX, 0, altoEjeY); } //close second Action ); //close parallel.invoke */ dataSetSimulador.flujoEnXSuperficie = armarRaster(rastersFlujoX, anchoEjeX, altoEjeY, 2, 2); dataSetSimulador.flujoEnYSuperficie = armarRaster(rastersFlujoY, anchoEjeX, altoEjeY, 2, 2); //dataSetSimulador.flujoEnXSuperficie = tempFlujoEnX; //dataSetSimulador.flujoEnYSuperficie = tempFlujoEnY; /* dataSetSimulador.flujoEnXSuperficie = escurrimientoSuperficialEnX(dataSetSimulador, dts); dataSetSimulador.flujoEnYSuperficie = escurrimientoSuperficialEnY(dataSetSimulador, dts);*/ dataSetSimulador.flujoResultanteSuperficie = new RasterDatos(dataSetSimulador.anchoEjeX, dataSetSimulador.altoEjeY); for (int x = 1; x < dataSetSimulador.anchoEjeX - 1; x++) { for (int y = 1; y < dataSetSimulador.altoEjeY - 1; y++) { tempValue = (float)((dataSetSimulador.flujoEnXSuperficie.matrizDEM_[y, x - 1] - dataSetSimulador.flujoEnXSuperficie.matrizDEM_[y, x] + dataSetSimulador.flujoEnYSuperficie.matrizDEM_[y - 1, x] - dataSetSimulador.flujoEnYSuperficie.matrizDEM_[y, x]) / Math.Pow(dataSetSimulador.dimensionCelda, 2.0)); dataSetSimulador.flujoResultanteSuperficie.matrizDEM_[y, x] = tempValue; } } }
private RasterDatos escurrimientoSuperficialEnY(DataSet dataSetSimulador, float dts, int startEjeX, int endEjeX, int startEjeY, int endEjeY) { float Slope = 0.0f; float auxiliar1 = 0.0f; float CSArea = 0.0f; float RadiusHydraulic = 0.0f; float tempValue; //Se calculan los anchos y altos de las matrices. int anchoEjeX = endEjeX - startEjeX; int altoEjeY = endEjeY - startEjeY; dataSetSimulador.flujoEnYSuperficie = new RasterDatos(anchoEjeX, altoEjeY); //Llevar la cuenta de las posiciones para los rasters chiquitos. int f = 0; int g = 0; //Condicion para el borde. if (endEjeY == dataSetSimulador.altoEjeY) { endEjeY = endEjeY - 1; } for (int x = startEjeX; x < endEjeX; x++) { for (int y = startEjeY; y < endEjeY; y++) { //Se va a armar una matriz de flujo de agua en X dataSetSimulador.flujoEnYSuperficie.matrizDEM_[g, f] = 0.0f; //Si hay agua superficial en alguna de las dos celdas, y o y+1 if (dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] > 0.0 || dataSetSimulador.aguaSuperficie.matrizDEM_[y + 1, x] > 0.0) { //Diferencias de las altura del DEM del x + agua superficial - lo mismo de x + 1 Slope = ((dataSetSimulador.DEM.matrizDEM_[y, x] + dataSetSimulador.aguaSuperficie.matrizDEM_[y, x]) - (dataSetSimulador.DEM.matrizDEM_[y + 1, x] + dataSetSimulador.aguaSuperficie.matrizDEM_[y + 1, x])) / dataSetSimulador.dimensionCelda; //Esto es, si la diferenca de agua entre las capaz es significativa if (Math.Abs(Slope) >= cotaInferior) { //MUCHAS DUDAS DE CORRESPONDENCIA CON LA FORMULA TEORICA auxiliar1 = (dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] + dataSetSimulador.aguaSuperficie.matrizDEM_[y + 1, x]) / 2; CSArea = auxiliar1 * dataSetSimulador.dimensionCelda; RadiusHydraulic = dataSetSimulador.dimensionCelda + 2 * auxiliar1; //Algo se entiende de la formula, porque hacerla de esta forma complicada lo del Slope? tempValue = (float)(Math.Pow(CSArea, 5.0f / 3.0f) * Math.Pow(Math.Abs(Slope), 1.5f) / Slope / Math.Pow(RadiusHydraulic, 2.0f / 3.0f) / dataSetSimulador.coefManning); //flujoEnY.setValue(tempValue,x,y); if (tempValue > 0.0) { //NO ENTIENDO QUE HACE ACA - DE QUE FORMULA SALE? Segun lo que haga aca se crea una matriz inicial con todo esto //Para no recalcular para los dos flujos //Supongo que <= seria casi igual que < varia mas abajo //Esta condicion no se va a cumplir nunca pues si el flujo de agua es positivo significa que el agua inicial //en X es mayor que el agua inicial en X+1 por lo que no puede haber entrado al ciclo pasando las dos condiciones //sobre la cota inferior, el cambio se ve en Modificacion 2. if (dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] > cotaInferior) { auxiliar1 = (float)(dataSetSimulador.aguaSuperficie.matrizDEM_[y, x] / dts * Math.Pow(dataSetSimulador.dimensionCelda, 2.0f) / 4.0f); if (tempValue > auxiliar1) { dataSetSimulador.flujoEnYSuperficie.matrizDEM_[g, f] = auxiliar1; } else { dataSetSimulador.flujoEnYSuperficie.matrizDEM_[g, f] = tempValue; } } } if (tempValue < 0.0) { if (dataSetSimulador.aguaSuperficie.matrizDEM_[y + 1, x] > cotaInferior) { auxiliar1 = (float)(dataSetSimulador.aguaSuperficie.matrizDEM_[y + 1, x] / dts * Math.Pow(dataSetSimulador.dimensionCelda, 2.0f) / 4.0f); if (-tempValue > auxiliar1) { dataSetSimulador.flujoEnYSuperficie.matrizDEM_[g, f] = -auxiliar1; } else { dataSetSimulador.flujoEnYSuperficie.matrizDEM_[g, f] = tempValue; } } } } } g++; } g=0; f++; } return dataSetSimulador.flujoEnYSuperficie; }
private RasterDatos escurrimientoSuperficialEnX(DataSet dataSetSimulador, float dts, int startEjeX, int endEjeX, int startEjeY, int endEjeY) { float Slope = 0.0f; float auxiliar1 = 0.0f; float CSArea = 0.0f; float WettedPerimeter = 0.0f; float aguaSupxy = 0.0f; float aguaSupx1y = 0.0f; float tempValue; //Se calculan los anchos y altos de las matrices. int anchoEjeX = endEjeX - startEjeX; int altoEjeY = endEjeY - startEjeY; //Se crea el Raster del tamaño adecuado. dataSetSimulador.flujoEnXSuperficie = new RasterDatos(anchoEjeX, altoEjeY); //Llevar la cuenta de las posiciones para los rasters chiquitos. int f = 0; int g = 0; //Condicion para el borde. if (endEjeX == dataSetSimulador.anchoEjeX) { endEjeX = endEjeX - 1; } for (int x = startEjeX; x < endEjeX; x++) { for (int y = startEjeY; y < endEjeY; y++) { //Seteo el valor 0 a la casilla [x,y] dataSetSimulador.flujoEnXSuperficie.matrizDEM_[g, f] = 0.0f; aguaSupxy = dataSetSimulador.aguaSuperficie.matrizDEM_[y, x]; aguaSupx1y = dataSetSimulador.aguaSuperficie.matrizDEM_[y, x + 1]; //Si hay agua superficial en alguna de las dos celdas, x o x+1 if (aguaSupxy > 0.0 || aguaSupx1y > 0.0) { //(Altura suelo + agua en x - (menos) Altura suelo + agua en x+1) dividido el otro cateto y obtengo la hipotenusa // o pendiente o slope. Slope = ((dataSetSimulador.DEM.matrizDEM_[y, x] + aguaSupxy) - (dataSetSimulador.DEM.matrizDEM_[y, x + 1] + aguaSupx1y)) / dataSetSimulador.dimensionCelda; //Esto es, si la diferenca de agua entre las capaz es significativa. //Se le pone el valor absoluto ya que no me importa que sentido sea la diferencia. if (Math.Abs(Slope) >= cotaInferior) { //Se toma el promedio de las dos alturas. auxiliar1 = (aguaSupxy + aguaSupx1y) / 2; CSArea = auxiliar1 * dataSetSimulador.dimensionCelda; WettedPerimeter = dataSetSimulador.dimensionCelda + 2 * auxiliar1; //Calculo del flujo tempValue = (float)(Math.Pow(CSArea, 5.0f / 3.0f) * Math.Pow(Math.Abs(Slope), 1.5f) / Slope / Math.Pow(WettedPerimeter, 2.0f / 3.0f) / dataSetSimulador.coefManning); //Si el flujo es mayor que 0. if (tempValue > 0.0) { if (aguaSupxy > cotaInferior) { auxiliar1 = (float)(aguaSupxy / dts * Math.Pow(dataSetSimulador.dimensionCelda, 2.0f) / 4.0f); if (tempValue > auxiliar1) { dataSetSimulador.flujoEnXSuperficie.matrizDEM_[g, f] = auxiliar1; } else { dataSetSimulador.flujoEnXSuperficie.matrizDEM_[g, f] = tempValue; } } } if (tempValue < 0.0) { //En esta parte implementar las mismas modificaciones que para el caso anterior if (aguaSupx1y > cotaInferior) { auxiliar1 = (float)(aguaSupx1y / dts * Math.Pow(dataSetSimulador.dimensionCelda, 2.0f) / 4.0f); if (-tempValue > auxiliar1) { dataSetSimulador.flujoEnXSuperficie.matrizDEM_[g, f] = -auxiliar1; } else { dataSetSimulador.flujoEnXSuperficie.matrizDEM_[g, f] = tempValue; } } } } } g++; } g = 0; f++; } return dataSetSimulador.flujoEnXSuperficie; }