[Fudaa-svn-commit] SF.net SVN: fudaa:[4021] branches/Prepro-0.92-SNAPSHOT/dodico/src/org/fudaa /dodico/ef

[<de...@us...>]

Revision: 4021
          http://fudaa.svn.sourceforge.net/fudaa/?rev=4021&view=rev
Author:   deniger
Date:     2008-10-01 21:04:27 +0000 (Wed, 01 Oct 2008)

Log Message:
-----------


Modified Paths:
--------------
    branches/Prepro-0.92-SNAPSHOT/dodico/src/org/fudaa/dodico/ef/EfComputeVolumeSeuil.java
    branches/Prepro-0.92-SNAPSHOT/dodico/src/org/fudaa/dodico/ef/EfDataIntegrale.java

Modified: branches/Prepro-0.92-SNAPSHOT/dodico/src/org/fudaa/dodico/ef/EfComputeVolumeSeuil.java
===================================================================
--- branches/Prepro-0.92-SNAPSHOT/dodico/src/org/fudaa/dodico/ef/EfComputeVolumeSeuil.java	2008-10-01 17:49:28 UTC (rev 4020)
+++ branches/Prepro-0.92-SNAPSHOT/dodico/src/org/fudaa/dodico/ef/EfComputeVolumeSeuil.java	2008-10-01 21:04:27 UTC (rev 4021)
@@ -19,183 +19,172 @@
 
 /**
  * Calcul du volume par rapport a un seuil et non plus 0.
+ * 
  * @author Adrien Hadoux
- *
  */
 public abstract class EfComputeVolumeSeuil implements CtuluActivity {
 
-	public static class ForMeshData extends EfComputeVolumeSeuil {
+  public static class ForMeshData extends EfComputeVolumeSeuil {
 
-		ForMeshData(final EfFilter _filter, final ProgressionInterface _prog, final EfGridData _data,
-				final CtuluVariable _hVar, final int timestep,final double seuil) {
-			super(_filter, _prog, _data, _hVar,timestep,seuil);
-		}
+    ForMeshData(final EfFilter _filter, final ProgressionInterface _prog, final EfGridData _data,
+        final CtuluVariable _hVar, final int timestep, final double seuil) {
+      super(_filter, _prog, _data, _hVar, timestep, seuil);
+    }
 
-		
-		EfDataIntegrale computeVolume(final EfGridInterface _grid, final EfData _h) {
-			EfDataIntegrale resi = new EfDataIntegrale();
-			for (int ielt = 0; ielt < _grid.getEltNb(); ielt++) {
-				if (filter_.isActivatedElt(ielt, _grid, false)) {
+    EfDataIntegrale computeVolume(final EfGridInterface _grid, final EfData _h) {
+      EfDataIntegrale resi = new EfDataIntegrale();
+      for (int ielt = 0; ielt < _grid.getEltNb(); ielt++) {
+        if (filter_.isActivatedElt(ielt, _grid, false)) {
 
-					if(_h.getValue(ielt)<=seuil_)
-						resi.zoneMoins_ += _grid.getAire(ielt) * _h.getValue(ielt);
-					else
-						resi.zonePlus_ += _grid.getAire(ielt) * _h.getValue(ielt);
-				}
-			}
-			return resi;
-		}
-	}
+          double value = _grid.getAire(ielt) * (_h.getValue(ielt) - seuil_);// Todo je pense que c'est la diff
+          if (value >= 0) resi.zonePlus_ += value;
+          else resi.zoneMoins_ -= value;
+        }
+      }
+      return resi;
+    }
+  }
 
-	public static class ForNodeData extends EfComputeVolumeSeuil {
+  public static class ForNodeData extends EfComputeVolumeSeuil {
 
-		ForNodeData(final EfFilter _filter, final ProgressionInterface _prog, final EfGridData _data,
-				final CtuluVariable _hVar, final int timestep,final double seuil) {
-			super(_filter, _prog, _data, _hVar,timestep,seuil);
-		}
+    ForNodeData(final EfFilter _filter, final ProgressionInterface _prog, final EfGridData _data,
+        final CtuluVariable _hVar, final int timestep, final double seuil) {
+      super(_filter, _prog, _data, _hVar, timestep, seuil);
+    }
 
-		EfDataIntegrale computeVolume(final EfGridInterface _grid, final EfData _h) {
-			EfDataIntegrale resi = new EfDataIntegrale();
-			for (int ipt = 0; ipt < _grid.getPtsNb(); ipt++) {
-				// le calcul du volume se fait:
-					// Volume=(surface des elements adjacents)* hauteur au point /3
-					if (filter_.isActivated(ipt)) {
-						// liste des elements adjacents.
-						final TIntArrayList list = (TIntArrayList) idxPtAdjMes_.get(ipt);
-						// la liste est nulle: ne devrait jamais arriv\xE9: un point isol\xE9 que faire ?
-						// pour l'instant on ignore.
-						if (list != null) {
-							// s est la surface des elements adjacents.
-							double s = 0D;
-							for (int k = 0; k < list.size(); k++) {
-								s += _grid.getAire(list.getQuick(k));
-							}
-							// la formule qui tue
-							if(_h.getValue(ipt)<=seuil_)
-							resi.zoneMoins_ += s * _h.getValue(ipt) / 3D;
-							else
-								resi.zonePlus_ += s * _h.getValue(ipt) / 3D;
-						}
-					}
-			}
-			return resi;
-		}
+    EfDataIntegrale computeVolume(final EfGridInterface _grid, final EfData _h) {
+      EfDataIntegrale resi = new EfDataIntegrale();
+      for (int ipt = 0; ipt < _grid.getPtsNb(); ipt++) {
+        // le calcul du volume se fait:
+        // Volume=(surface des elements adjacents)* hauteur au point /3
+        if (filter_.isActivated(ipt)) {
+          // liste des elements adjacents.
+          final TIntArrayList list = (TIntArrayList) idxPtAdjMes_.get(ipt);
+          // la liste est nulle: ne devrait jamais arriv\xE9: un point isol\xE9 que faire ?
+          // pour l'instant on ignore.
+          if (list != null) {
+            // s est la surface des elements adjacents.
+            double s = 0D;
+            for (int k = 0; k < list.size(); k++) {
+              s += _grid.getAire(list.getQuick(k));
+            }
+            double d = s * (_h.getValue(ipt) - seuil_) / 3D;
+            if (d >= 0) resi.zonePlus_ += d;
+            else resi.zoneMoins_ -= d;
+          }
+        }
+      }
+      return resi;
+    }
 
-		public EfDataIntegrale getVolume(int choosenTimestep) {
-			computeNeighborMeshes();
-			return super.getVolume(choosenTimestep);
-		}
-	}
+    public EfDataIntegrale getVolume(int _choosenTimestep) {
+      computeNeighborMeshes();
+      return super.getVolume(_choosenTimestep);
+    }
+  }
 
-	final EfGridData data_;
-	final EfFilter filter_;
-	final CtuluVariable h_;
-	protected final int timeStep_;
-	protected final double seuil_;
+  final EfGridData data_;
+  final EfFilter filter_;
+  final CtuluVariable h_;
+  protected final int timeStep_;
+  protected final double seuil_;
 
-	/**
-	 * Stocke indice du noeuds -> list element adjacent. Pour les noeuds s\xE9lecionn\xE9s uniquement
-	 */
-	TIntObjectHashMap idxPtAdjMes_;
-	ProgressionInterface prog_;
+  /**
+   * Stocke indice du noeuds -> list element adjacent. Pour les noeuds s\xE9lecionn\xE9s uniquement
+   */
+  TIntObjectHashMap idxPtAdjMes_;
+  ProgressionInterface prog_;
 
-	boolean stop_;
+  boolean stop_;
 
-	public static EfComputeVolumeSeuil getVolumeComputer(final EfFilter _filter, final ProgressionInterface _prog,
-			final EfGridData _data, final CtuluVariable _hVar, final int timestep,final double seuil, final CtuluAnalyze _analyze) {
-		if (!_data.isDefined(_hVar)) {
-			_analyze.addFatalError(DodicoLib.getS("La hauteur d'eau n'est pas d\xE9finie"));
-			return null;
-		}
-		if (_data.isElementVar(_hVar)) {
-			return new ForMeshData(_filter, _prog, _data, _hVar,timestep,seuil);
-		}
-		return new ForNodeData(_filter, _prog, _data, _hVar,timestep,seuil);
+  public static EfComputeVolumeSeuil getVolumeComputer(final EfFilter _filter, final ProgressionInterface _prog,
+      final EfGridData _data, final CtuluVariable _hVar, final int timestep, final double seuil,
+      final CtuluAnalyze _analyze) {
+    if (!_data.isDefined(_hVar)) {
+      _analyze.addFatalError(DodicoLib.getS("La variable n'est pas d\xE9finie"));
+      return null;
+    }
+    if (_data.isElementVar(_hVar)) { return new ForMeshData(_filter, _prog, _data, _hVar, timestep, seuil); }
+    return new ForNodeData(_filter, _prog, _data, _hVar, timestep, seuil);
 
-	}
+  }
 
-	EfComputeVolumeSeuil(final EfFilter _filter, final ProgressionInterface _prog, final EfGridData _data,
-			final CtuluVariable _hVar, final int timestep,final double seuil) {
-		super();
-		prog_ = _prog;
-		data_ = _data;
-		h_ = _hVar;
-		timeStep_=timestep;
-		seuil_=seuil;
-		filter_ = _filter == null ? new EfFilterNone() : _filter;
-	}
+  EfComputeVolumeSeuil(final EfFilter _filter, final ProgressionInterface _prog, final EfGridData _data,
+      final CtuluVariable _hVar, final int timestep, final double seuil) {
+    super();
+    prog_ = _prog;
+    data_ = _data;
+    h_ = _hVar;
+    timeStep_ = timestep;
+    seuil_ = seuil;
+    filter_ = _filter == null ? new EfFilterNone() : _filter;
+  }
 
-	abstract EfDataIntegrale computeVolume(final EfGridInterface _grid, EfData _h);
+  abstract EfDataIntegrale computeVolume(final EfGridInterface _grid, EfData _h);
 
-	protected void computeNeighborMeshes() {
-		if (idxPtAdjMes_ != null) {
-			return;
-		}
-		final ProgressionUpdater up = new ProgressionUpdater(prog_);
-		final EfGridInterface grid = data_.getGrid();
-		up.setValue(10, grid.getEltNb());
-		up.majProgessionStateOnly(DodicoLib.getS("Recherche des \xE9l\xE9ments voisins"));
-		idxPtAdjMes_ = new TIntObjectHashMap(grid.getPtsNb());
-		for (int i = 0; i < grid.getEltNb(); i++) {
-			if (stop_) {
-				idxPtAdjMes_ = null;
-				return;
-			}
-			final EfElement elt = grid.getElement(i);
-			for (int j = 0; j < elt.getPtNb(); j++) {
-				final int ptIndex = elt.getPtIndex(j);
-				// si le noeud est s\xE9lectionne
-				if (filter_.isActivated(ptIndex)) {
-					TIntArrayList list = (TIntArrayList) idxPtAdjMes_.get(ptIndex);
-					// ce noeud n'a pas encore \xE9t\xE9 trait\xE9
-					if (list == null) {
-						list = new TIntArrayList(10);
-						idxPtAdjMes_.put(ptIndex, list);
-					}
-					list.add(i);
+  protected void computeNeighborMeshes() {
+    if (idxPtAdjMes_ != null) { return; }
+    final ProgressionUpdater up = new ProgressionUpdater(prog_);
+    final EfGridInterface grid = data_.getGrid();
+    up.setValue(10, grid.getEltNb());
+    up.majProgessionStateOnly(DodicoLib.getS("Recherche des \xE9l\xE9ments voisins"));
+    idxPtAdjMes_ = new TIntObjectHashMap(grid.getPtsNb());
+    for (int i = 0; i < grid.getEltNb(); i++) {
+      if (stop_) {
+        idxPtAdjMes_ = null;
+        return;
+      }
+      final EfElement elt = grid.getElement(i);
+      for (int j = 0; j < elt.getPtNb(); j++) {
+        final int ptIndex = elt.getPtIndex(j);
+        // si le noeud est s\xE9lectionne
+        if (filter_.isActivated(ptIndex)) {
+          TIntArrayList list = (TIntArrayList) idxPtAdjMes_.get(ptIndex);
+          // ce noeud n'a pas encore \xE9t\xE9 trait\xE9
+          if (list == null) {
+            list = new TIntArrayList(10);
+            idxPtAdjMes_.put(ptIndex, list);
+          }
+          list.add(i);
 
-				}
-			}
-			up.majAvancement();
-		}
-	}
+        }
+      }
+      up.majAvancement();
+    }
+  }
 
-	public EfDataIntegrale getVolume(int choosenTimestep) {
-		final ProgressionUpdater up = new ProgressionUpdater(prog_);
-		final EfGridInterface grid = data_.getGrid();
-		up.setValue(10, 100);
-		 EfDataIntegrale res ;
-		up.majProgessionStateOnly(DodicoLib.getS("Calcul du volume"));
-		
-			if (stop_) {
-				return null;
-			}
-			EfData h = null;
-			try {
-				h = data_.getData(h_, timeStep_);
-			} catch (final IOException _evt) {
-				FuLog.error(_evt);
+  public EfDataIntegrale getVolume(int choosenTimestep) {
+    final ProgressionUpdater up = new ProgressionUpdater(prog_);
+    final EfGridInterface grid = data_.getGrid();
+    up.setValue(10, 100);
+    EfDataIntegrale res;
+    up.majProgessionStateOnly(DodicoLib.getS("Calcul du volume"));
 
-			}
-			if (h == null) {
-				return null;
-			}
-			res = computeVolume(grid, h);
-			up.majAvancement();
-		
-		return res;
-	}
+    if (stop_) { return null; }
+    EfData h = null;
+    try {
+      h = data_.getData(h_, timeStep_);
+    } catch (final IOException _evt) {
+      FuLog.error(_evt);
 
-	public ProgressionInterface getProg() {
-		return prog_;
-	}
+    }
+    if (h == null) { return null; }
+    res = computeVolume(grid, h);
+    up.majAvancement();
 
-	public void setProg(final ProgressionInterface _prog) {
-		prog_ = _prog;
-	}
+    return res;
+  }
 
-	public void stop() {
-		stop_ = true;
-	}
+  public ProgressionInterface getProg() {
+    return prog_;
+  }
 
+  public void setProg(final ProgressionInterface _prog) {
+    prog_ = _prog;
+  }
+
+  public void stop() {
+    stop_ = true;
+  }
+
 }

Modified: branches/Prepro-0.92-SNAPSHOT/dodico/src/org/fudaa/dodico/ef/EfDataIntegrale.java
===================================================================
--- branches/Prepro-0.92-SNAPSHOT/dodico/src/org/fudaa/dodico/ef/EfDataIntegrale.java	2008-10-01 17:49:28 UTC (rev 4020)
+++ branches/Prepro-0.92-SNAPSHOT/dodico/src/org/fudaa/dodico/ef/EfDataIntegrale.java	2008-10-01 21:04:27 UTC (rev 4021)
@@ -143,17 +143,17 @@
       } else {
         // cas particulier : intersection, on calcule l'intersection entre les
         // points
-        double yIntersect = 0;
+        final double yIntersect = seuil;
         double xIntersect = 0;
         // on prend la droite form\xE9e par les 2 points et on calcule son
         // intersection avec la droite affine
         if (x2 - x != 0) {
-          // droite non parrallele a l axe des abscisses
+          // droite non parrallele a l axe des ordonn\xE9e !
         double coefDirecteur = (y2 - y) / (x2 - x);
         double ordoOrigine = y2 - coefDirecteur * x2;
         
         // intersection de droites avec le seuil
-          yIntersect = seuil;
+//          yIntersect = seuil;
          
           
           if(coefDirecteur!=0)
@@ -168,7 +168,7 @@
           // x2=x droite perpendiculaire au seuil, le point d'intersection est
           // donc (x,seuil)
           xIntersect = x;
-          yIntersect = seuil;
+//          yIntersect = seuil;
         }
         
         //maintenant que l on a le point d'intersection, on test si on ajoute en positif ou negatif
@@ -194,7 +194,6 @@
    * (x2,y4)
    */
   public static double calculAireTrapeze(double x, double y, double x2, double y2, double y3, double y4) {
-    double aire = 0;
     // 1: calcul de la hauteur
     double h = Math.abs(x2 - x);
     // 2 base 1: coordonnees cartesiennes entre le point x,y et x,y3
@@ -202,8 +201,7 @@
     // 3 base 2: coordonnees cartesiennes entre le point x2,y2 et x2,y4
     double base2 = Math.abs(y4 - y2);
     // 4 calcul de l'aire
-    aire = h * (base1 + base2) / 2;
-    return aire;
+    return h * (base1 + base2) / 2;
 }
   
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.