BlueM - User contributions [en]

BlueM.Sim compilation

2011-09-21T21:01:05Z

Reussner: Compiler settings - deleting and parallelisation

{{BlueM.Sim nav}}
<div style="float:right; margin:0 0 10px 10px;">__TOC__</div>

==Compilation==
BlueM.Sim is written in FORTRAN. Additional components such as [[BlueM.DLLAdapter]] and [[Wave]] are written in C# and VB.NET.

Requirements for compiling BlueM.Sim:
* [http://www.microsoft.com/visualstudio/en-us/products/professional/default.mspx Microsoft Visual Studio 2008 Professional] (the Standard Edition may be enough, but has not been tested)
* [http://www.intel.com/cd/software/products/asmo-na/eng/compilers/278834.htm Intel Fortran Compiler] v11
* [http://www.steema.com/products/teechart/net/overview.html TeeChart for .NET (v4) developer license] (only required for compiling [[Wave]])

==Compiler settings==
[[Bild:RECLinBytes.jpg|thumb|Use Bytes as RECL]]
Compiler-Einstellungen (''Flags''), die zur erfolgreichen Kompilierung erforderlich sind.
* <code>/assume:byterecl</code>
: Damit Intel Fortran bei unformatierten Dateien (wie den Zeitreihen im BIN-Format) die Record-Länge als bytes und nicht als 4-byte Einheiten (longwords) interpretiert, muss folgender Flag gesetzt werden: "'''Use Bytes as RECL unit for unformatted files: Yes'''" (siehe Bild)

==Build configurations==
The following build configurations for BlueM.Sim are defined in the project file:
* '''Debug''': Debug version, no optimizations
* '''Release''': Full optimization, requires processor supporting Intel<sup>®</sup> Streaming SIMD Extensions 2 (Intel<sup>®</sup> SSE2). Auto parallelisation (with threshold 90) ON
* '''Release_AllProcessors''': Full optimization, for generic IA-32 architectures (older processors) (Bug 442). Auto parallelisation OFF

==Compilation in Eclipse==
[[Bild:Eclipse.gif|thumb|Eclipse screenshot]]
Bisher ist es noch nicht gelungen, BlueM.Sim erfolgreich in [http://www.eclipse.org Eclipse] zu kompilieren. Hier eine vorläufige (inkomplette) Anleitung:

<u>Installation:</u>
* Eclipse SDK 3.2.1: http://www.eclipse.org/downloads/
* Eclipse C/C++ Development Toolkit (CDT): http://www.eclipse.org/cdt/ (''In Eclipse über Menü '''Help - Software Updates''' installieren'')
* Photran Feature 3.1 Beta: http://www.eclipse.org/photran/ (''Inhalt der ZIP-Datei einfach in entsprechende Ordner im Eclipse Installationsverzeichnis kopieren'')
* Cygwin mit gdb (GNU Debugger): http://www.cygwin.com/ (''gdb bei der Installation unter '''Devel''' auswählen'')
* make für Windows: http://www.steve.org.uk/Software/make/ (''make muss auf den PATH'')
* g95 compiler: http://www.g95.org/ (''g95 muss auf den PATH'')

<u>Eclipse Einstellungen:</u>
* Project Properties: Binary Parser: '''PE Windows Parser''' (''für Syntaxfehlererkennung'')
* Debug As...: C/C++ Local Application: Debugger: '''Cygwin gdb Debugger''' und Pfad zu gdb.exe angeben

Es ist (theoretisch) auch möglich, den Intel Fortran Compiler/Debugger in Eclipse einzubinden.

[[Kategorie:BlueM.Sim Development]]

BlueM.Sim input files

2010-07-16T08:37:12Z

Reussner: Alphabetisch geordnet

{{Eingabedateien}}
''Sample records can be downloaded from [http://130.83.196.220/bluem/forum/ Forum].''

'''List of input files for BlueM.Sim'''<br/>
<u>General:</u>
*'''[[ALL-File]]:''' General Simulation Options
*'''[[SYS-File]]:''' System Plan
<u>Functions:</u>
*'''[[FKT-File]]:''' Functions
*'''[[KTR-File]]:''' Control functions
<u>Time series</u>
*'''[[EXT-File]]:''' time series management (see also [[ZRE-Format]])
*'''[[JGG-File]]:''' Annual series
*'''[[TGG-File]]:''' Day series
*'''[[WGG-File]]:''' Week series
<u>Elements</u>
*'''[[BEK-File]]:''' Rain overflow basin
*'''[[EIN-File]]:''' Individual discharges
*'''[[EZG-File]]:''' Natural catchments
*'''[[FKA-File]]:''' Urban catchment
*'''[[HYA-File]]:''' Hydraulic Elements
*'''[[RUE-File]]:''' About Rain Barrels
*'''[[TAL-File]]:''' Dams
*'''[[TRS-File]]:''' Transport routes
*'''[[URB-File]]:''' Consumers
*'''[[VER-File]]:''' Branching
<u>Soil moisture calculation</u>
*'''[[BOA-File]]:''' Soil types
*'''[[BOD-File]]:''' Soil types
*'''[[EFL-File]]:''' Elementary surfaces
*'''[[LNZ-File]]:''' Land
<u>Diffuse sources</u>
*'''[[DIF-File]]:''' Diffuse sources
** See also '''[[ALL-File]]:''' General Simulation Options
** See also '''[[EFL-File]]:''' Elementary surfaces

[[Kategorie:BlueM Eingabedateien|*]]

TRS-File

2010-01-26T08:38:34Z

Reussner: Verrohrung Rechteck deaktiviert

{{Eingabedateien}}

<big>Transportstrecken</big>

''siehe auch [[Transportstrecken|Theorie:Transportstrecken]]''

==Datei==
<bluem>
*Transportelemente (*.TRS)
*=========================
*
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|------------------------|
*| Bez | Kng | |Kng =1| Kng = 2,5 | Kng 3 = offenes Gerinne | Kng = 4 | MQ | Temperatur |
*| | |Laenge|Trans-| Rohrleitung |Vorland --Links--- --Rechts--- | Kennlinie | | |
*| | | |lation|P B/D Aquer Js kb | v Hoehe Breite Kst Breite Kst Js | Hoehe A-quer Qab | |Kng Tem JGG TGG Datei |
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|------------------------|
*| - | 1-5 | m | min | m m^2 °/oo mm | m m m^.3/s m m^.3/s °/oo | m m^2 m^3/s | m^3/s |1/2 °C - - Nummer |
*|-<-->-|-<->-|<---->|<---->|+<---><---><---><--->-|-+-<----><----><--->-<----><--->-<--->-|-<----><----><---->-|-<---->-|-+-<-->-<->-<->-<------>|
*| A | B | C | D |S E F G H | I J K L M N | O P Q | R | S T V W X |
| S100 | 3 | 1| | | 0 0.009 38.2 1.813 26 2 | | 1 | 2 20 1 |
| | | | | | 0.5 0.009 38.2 2 38.2 | | | |
| | | | | | 0.981 0.446 26 2.211 34 | | | |
| | | | | | 0.994 0.452 26 2.313 34 | | | |
| | | | | | 1.133 1.443 34 3.403 34 | | | |
| | | | | | 1.152 1.578 34 4.983 34 | | | |
| | | | | | v 1.253 3.195 34 13.394 34 | | | |
| SEND | 1 | 1| 1440| | | | 1 | 2 20 1 |
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|------------------------|

</bluem>

==Erläuterung==
'''Allgemein'''
*'''A''': Bezeichnung
*'''B''': Kennung
*'''C''': Länge
'''Kennung 1: Translation'''
*'''D''': Translationszeit [min]
:Die Translationszeit wird immer auf ein Vielfaches des Simulationszeitschritts '''ab'''gerundet!
:Wenn die Translationszeit kürzer als der Simulationszeitschritt ist, findet '''keine''' Translation statt!
'''Kennung 2: Rohrleitung nach Kalinin-Miljukov''' /<br/>
'''Kennung 5: Rohrleitung über nicht-linearen Speicher'''
*'''S''': Profilart [1-4]:
*: 1: Kreis
*: 2: Ei (Norm-Ei H/B = 1,5)
*: 3: Maul (Norm-Maul H/B = 0,75)
*: (implementiert aber mit Fehlern 4: Rechteck )
*'''E''': Durchmesser (beziehungsweise Breite)
*'''F''': Querschnittfläche
*'''G''': Sohlgefälle [&permil;]
*'''H''': Rauheit
'''Kennung 3: offenes Gerinne'''
*'''I''': Höhe
*'''J''': Breite linke Uferseite
*'''K''': k<sub>st</sub> linke Uferseite
*'''L''': Breite rechte Uferseite
*'''M''': k<sub>st</sub> rechte Uferseite
*'''N''': Sohlgefälle [&permil;]
'''Kennung 4: Kennlinie'''
*'''O''': Höhe
*'''P''': Querschnittsfläche
*'''Q''': Abfluss Q<sub>ab</sub>
'''MQ'''
*'''R''': Anfangswert für den Abfluss
:wird zusätzlich mit der Kenngröße <code>Gerinneabfluss [% von MQ]</code> aus der [[ALL-Datei]] skaliert!

<u>Temperatur:</u>
*'''S''': Berechnungsart für die Temperatur (1 = Mittelwert mit optionalem [[TSIM.JGG | Jahres]]/[[TSIM.WGG | Wochen]]/[[TSIM.TGG | Tagesgang]]; 2 = Temperatur aus Zeitreihe/Datei)
*'''T''': Mittlere Temperatur [°C]
*'''V''', '''W''': Nummer des zu verwendenden [[TSIM.JGG | Jahres]]/[[TSIM.TGG | Tagesgangs]]
*'''X''': Dateinummer der zu verwendenden Temperaturzeitreihe (siehe [[TSIM.EXT | *.EXT-Datei]])

==Notes==
The maximum number of lines that can be entered per transport element is '''26'''! (<code>TRS_MAXSTZ</code>)

[[Kategorie:BlueM Eingabedateien]]

EIN-File

2009-12-01T12:03:27Z

Reussner: /* Erläuterung */ Skalierungsfaktor

{{Eingabedateien}}

<big>Einzeleinleitungen</big>

''siehe auch [[Einleitungen|Theorie:Einleitungen]]''

==Datei==
<bluem>
*Einzeleinleitungen (*.EIN)
*==========================
*
*|------|-----|----------------------|----------------|
*| Bez. | Kng | konst. Ganglinie | Datei Faktor|
*| | | QMITTEL JGG WGG TGG | Nr. |
*|------|-----|----------------------|----------------|
*| - | 1/2 | m3/s - - - | % |
*|-<-->-|-<->-|-<------>-<->-<->-<->-|-<------>-<--->-|
| A | B | C D E F | G H |
*|------|-----|----------------------|----------------|
</bluem>

erweitert, um Fläche und Spende (nur zur Info, es wird weiterhin nur Qmittel oder Datei eingelesen)

<bluem>
*Einzeleinleitungen (*.EIN)
*==========================
*
*|------|-----|----------------------|----------------|--------|--------|
*| Bez. | Kng | konst. Ganglinie | Datei Faktor| Spende | Fläche |
*| | | QMITTEL JGG WGG TGG | Nr. | | |
*|------|-----|----------------------|----------------|--------|--------|
*| - | 1/2 | m3/s - - - | % |m3/s km2| km2 |
*|-<-->-|-<->-|-<------>-<->-<->-<->-|-<------>-<--->-|-<---->-|-<---->-|
| A | B | C D E F | G H | Spende | Fläche |
*|------|-----|----------------------|----------------|--------|--------|
</bluem>

==Erläuterung==
*A: Bezeichnung des Elements
*B: Berechnungsart (1/2)
'''Berechnungsart 1: mittlere Abgabe mit optionalem [[TSIM.JGG | Jahres]]/[[TSIM.WGG | Wochen]]/[[TSIM.TGG | Tagesgang]]''':
*C: Mittelwert
*D, E, F: Nummer des zu verwendenden [[TSIM.JGG | Jahres]]/[[TSIM.WGG | Wochen]]/[[TSIM.TGG | Tagesgangs]]
'''Berechnungsart 2: Zeitreihe/Datei mit Skalierungsfaktor'''
*G: Nummer der zu verwendenden Datei (siehe [[TSIM.EXT | *.EXT-Datei]])
*H: Skalierungsfaktor [%] (Dezimalzahl)

; Achtung: der Skalierungsfaktor ist ab Version 0.9.6.3 allgemeingültig für alle Berechnungsoptionen !!!

[[Kategorie:BlueM Eingabedateien]]

BlueM References

2009-10-05T08:04:55Z

Reussner:

<div style="float:right; margin:0 0 10px 10px;">__TOC__</div>
==Publications==
The following publications refer to BlueM:

===Presentations===
* {{:Literatur:Bach et al. 2009|[[BlueM - Ein Softwarepaket zur integrierten Flussgebietsbewirtschaftung]]}} (2009)
* {{:Literature:Muschalla et al. 2009|[[BlueM.Opt - a generic framework for simulation based optimization]]}} (2009)
* {{:Literature:Froehlich & Hübner 2009|[[Kopplung von Simulation und Optimierung - Eine Vorstellung von BlueM.Opt]]}} (2009)

===Papers===
* {{:Literature:Reußner et al. 2009|[http://dx.doi.org/10.2166/wst.2009.471 Basin-wide integrated modelling via OpenMI considering multiple urban catchments.]}} (2009)
''under construction''

===Theses===
* {{:Literature:Muschalla 2006|Muschalla (2006): Evolutionäre multikriterielle Optimierung komplexer wasserwirtschaftlicher Systeme}}

==Projects==
BlueM has been used in the following projects:

===RIMAX33===
[[Bild:RIMAX logo.png|thumb|RIMAX]]
Im Rahmen der BMBF-Fördermaßnahme [http://www.rimax-hochwasser.de RIMAX] (Risikomanagement extremer Hochwasserereignisse) wurde am [http://www.ihwb.tu-darmstadt.de ihwb] und am [http://www.iwd.tu-dresden.de Institut für Wasserbau und Technische Hydromechanik der TU Dresden] gemeinschaftlich das Projekt '''"Erhöhung der Bauwerkssicherheit und Reduktion des Hochwasserrisikos im Unterlauf durch optimierte Speicher- und Poldersteuerung unter Berücksichtigung ökologischer Belange" (RIMAX33)''' bearbeitet.

Hierbei wurde [[BlueM.Sim]] für die Niederschlags-Abfluss-Modellierung und die Talsperrensimulation verwendet, [[BlueM.Opt]] kam für die Optimierung von Betriebsregeln zum Einsatz.

[http://www.ihwb.tu-darmstadt.de/rimax33/ Projekt-Homepage]<br clear="all"/>

===Immissions-Leitfaden===
Goal of the project is the development of a simulation based method for the analysis and planning of immission oriented verification. Building on developments of the Hessian waste water discharge model SMUSI 5.0 the verification is extended to rural catchment and water body elements (Extended waste water discharge model). Because this extended model considers outflow and storage processes of urban system elements in detail, using this model enables a better qualified identification of impacts in the water bodies and allows for comparative planning of measures. In this process there is no need for further data collection compared to the existing guideline.

[http://www.ihwb.tu-darmstadt.de/research/current_research/aktuelleforschung.en.jsp#leitfaden Guideline]<br clear="all"/>

==Literature==
<references/>

[[Category:Publications|*]]

Literature:Reußner et al. 2009

2009-10-05T08:01:04Z

Reussner: Created page with '{{{1|Reußner et al.(2009)}}}<ref name="reussner_2009">'''Reußner, F., Alex J., Bach M., Schütze M., Muschalla D.''' (2009): Basin-wide integrated modelling via OpenMI consider…'

{{{1|Reußner et al.(2009)}}}<ref name="reussner_2009">'''Reußner, F., Alex J., Bach M., Schütze M., Muschalla D.''' (2009): Basin-wide integrated modelling via OpenMI considering multiple urban catchments. DOI: 10.2166/wst.2009.471</ref><noinclude>
==Vorschau==
<references/>
</noinclude>

[[Category:BlueM.Opt]]
[[Category:Publications]]

BlueM References

2009-10-05T07:56:42Z

Reussner: Literatur Reußner -und Projekt AG Leitfaden

<div style="float:right; margin:0 0 10px 10px;">__TOC__</div>
==Publications==
The following publications refer to BlueM:

===Presentations===
* {{:Literatur:Bach et al. 2009|[[BlueM - Ein Softwarepaket zur integrierten Flussgebietsbewirtschaftung]]}} (2009)
* {{:Literature:Muschalla et al. 2009|[[BlueM.Opt - a generic framework for simulation based optimization]]}} (2009)
* {{:Literature:Froehlich & Hübner 2009|[[Kopplung von Simulation und Optimierung - Eine Vorstellung von BlueM.Opt]]}} (2009)

===Papers===
* {{:Literature:Reußner et al. 2009|[[Basin-wide integrated modelling via OpenMI considering multiple urban catchments.]]}} (2009)
''under construction''

===Theses===
* {{:Literature:Muschalla 2006|Muschalla (2006): Evolutionäre multikriterielle Optimierung komplexer wasserwirtschaftlicher Systeme}}

==Projects==
BlueM has been used in the following projects:

===RIMAX33===
[[Bild:RIMAX logo.png|thumb|RIMAX]]
Im Rahmen der BMBF-Fördermaßnahme [http://www.rimax-hochwasser.de RIMAX] (Risikomanagement extremer Hochwasserereignisse) wurde am [http://www.ihwb.tu-darmstadt.de ihwb] und am [http://www.iwd.tu-dresden.de Institut für Wasserbau und Technische Hydromechanik der TU Dresden] gemeinschaftlich das Projekt '''"Erhöhung der Bauwerkssicherheit und Reduktion des Hochwasserrisikos im Unterlauf durch optimierte Speicher- und Poldersteuerung unter Berücksichtigung ökologischer Belange" (RIMAX33)''' bearbeitet.

Hierbei wurde [[BlueM.Sim]] für die Niederschlags-Abfluss-Modellierung und die Talsperrensimulation verwendet, [[BlueM.Opt]] kam für die Optimierung von Betriebsregeln zum Einsatz.

[http://www.ihwb.tu-darmstadt.de/rimax33/ Projekt-Homepage]<br clear="all"/>

===Immissions-Leitfaden===
Goal of the project is the development of a simulation based method for the analysis and planning of immission oriented verification. Building on developments of the Hessian waste water discharge model SMUSI 5.0 the verification is extended to rural catchment and water body elements (Extended waste water discharge model). Because this extended model considers outflow and storage processes of urban system elements in detail, using this model enables a better qualified identification of impacts in the water bodies and allows for comparative planning of measures. In this process there is no need for further data collection compared to the existing guideline.

[http://www.ihwb.tu-darmstadt.de/research/current_research/aktuelleforschung.en.jsp#leitfaden Guideline]<br clear="all"/>

==Literature==
<references/>

[[Category:Publications|*]]

BlueM.Sim application

2009-09-16T15:36:47Z

Reussner:

__NOTOC__
{{BlueM_nav}}
This page is an aid to the application of BlueM.

==Dataset==
* A BlueM.Sim dataset consists of several text files. The minimum requirements are an [[ALL-File]] - (general options) and a [[SYS-File]] - (System Plan). Furthermore, files for describing the different types of system elements must be included. All files must have the same filename (which is also the name of the dataset), only the file extensions differ. <small>(The name of the dataset should not be longer than 32 characters! ''See Bug 13'')</small>
* It is possible to create a dataset using [[TALSIM]], which can then be exported and used for BlueM.Sim. Minor modifications to the export files need to be carried out (see [[TALSIM Export]]).
''See also [[BlueM Eingabedateien|Input files]]''

==OpenMI==

Omifile:
<XML>
<LinkableComponent Type="IHWB.BlueM.OpenMIAdapter.BlueM_LinkableComponent" Assembly="D:\PRGLeitfaden\BIN\BlueMSWQM4\IHWB.BlueM.OpenMIAdapter.dll">
<Arguments>
<Argument Key="FilePath" ReadOnly="true" Value="D:\PRGLeitfaden\Fallbeispiele\Test\TestGueteQ\TestGuete" />
<Argument Key="AnzahlInterneZeitschritte" ReadOnly="true" Value="5" />
<Argument Key="Guetemodell" ReadOnly="true" Value="false" />
<Argument Key="Guetemodell_Abbauprozess" ReadOnly="true" Value="true" />
<Argument Key="Guetemodell_Dispersion" ReadOnly="true" Value="false" />
<Argument Key="Guetemodell_Merge" ReadOnly="true" Value="false" />
<Argument Key="Simulationsanfang" ReadOnly="true" Value="28.12.1967 00:00" />
</Arguments>
</LinkableComponent>


</XML>
==Simulation==
[[File:BlueMWin_screenshot.png|thumb|BlueM.Win Screenshot]]
===Releases starting from 0.9.1===
For individual simulations, it is easiest to use the '''[[BlueM.Win]]''' package.
* [[BlueM Downloads|Download]] the precompiled package <code>BlueM.Win.zip</code> and unzip.
* Start the program <code>BlueM.Win.exe</code>
* Select a dataset
* Start the simulation
* After successful simulation, view the simulation result in [[Wave]].

The computational core (<code>bluem.dll</code>) can be controlled from another application using the [[BlueM.DLLAdapter]].<br clear="all"/>

===Release 0.9===
[[File:BlueMExe_screenshot.png|thumb|BlueM.exe Screenshot]]
* In the simplest case the compiled EXE file ([[BlueM Downloads|BlueM.exe]]) is in the same directory as the dataset to be simulated. In this case, simply launch the EXE and then enter the dataset name.
* You can specify the name of the dataset directly as a parameter to pass to BlueM.exe
:<dos>C:\WorkingDir>"Path\to\BlueM.exe" datasetname</dos>
* To prevent the window from closing immediately when the simulation is finished or an error has occurred, a shortcut to BlueM.exe can be created. In the properties of the shortcut enter the following "target" :
:<pre>cmd.exe /K "path\to\BlueM.exe"</pre>
:Under "Start in" the working directory must be specified, i.e., the directory in which the dataset is located.

==Results==
* Depending on the settings, BlueM.Sim creates different result files. By default, the main results are written to a [[WEL-File]].
''See also [[BlueM Ausgabedateien|output files]]''

===Errors / warnings===
* Errors cause the simulation to stop and must be remedied. All errors are logged to an [[ERR-File|*.ERR file]] in the dataset directory. The *.ERR file contains the date and time of the simulation in the filename and is preserved until deleted by the user. The error messages sometimes contain [[ERROR-Konstanten | error constants]].
* Warnings that occur during the simulation are also logged to a file ([[$WARN.TMP]]), which is deleted each time a new simulation is started.

[[Kategorie: BlueM.Sim Anwendung|A]]

BlueM.Sim output files

2009-07-30T10:59:28Z

Reussner: Änderung der Fehlerdatei

Some of the output files generated by BlueM can be controlled by the output options in the [[ALL-File]].For the output of outflow values and outflow balances the corresponding objects marked in the [[SYS-File]] must be added.

<u>Outputs:</u>
* '''[[MAX-File]]:''' Output of the maximum values for each object in the system .
* '''[[WEL-Format]]:''' Output of the runoff volume and volume time series for all objects marked in the [[SYS-File]] system.
* '''[[KWL-Format]]:''' Output of the runoff volume and volume time series for all control functions.
* '''[[BLZ-Format]]:''' Output of the runoff volume and volume balances for all objects marked in the [[SYS-File]] system.
* '''[[PRB-Format]]:''' Output of the probability distributions.

<u>Extended edition:</u>
* '''[[EFL.WEL-Format]]:''' Detailed wave output of each elementary soil processes and surface layer (only when [[soil moisture calculation]])
* '''[[EFL.TXT-Format]]:''' Output of the simulation parameters used for soil characteristics per elementary area (only when [[soil moisture calculation]])

<u>Errors and Warnings:</u>
* '''[[Err_YYMMDDhhmmss.ERR]]:''' Output errors z.B. '''Err_090730125812.ERR:'''(ehemals '''[[$FEHL.tmp]]:''')
* '''[[$WARN.TMP]]:''' Warnings

[[Kategorie:BlueM.Sim Ausgabedateien|*]]

EIN-File

2009-06-18T14:28:13Z

Reussner: Abflussspenden und Flächen

TRS-File

2009-06-18T12:18:10Z

Reussner: /* Erläuterung */

{{Eingabedateien}}

<big>Transportstrecken</big>

''siehe auch [[Transportstrecken|Theorie:Transportstrecken]]''

==Datei==
<bluem>
*Transportelemente (*.TRS)
*=========================
*
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|
*| Bez | Kng | |Kng =1| Kng = 2,5 | Kng 3 = offenes Gerinne | Kng = 4 | MQ |
*| | |Laenge|Trans-| Rohrleitung |Vorland --Links--- --Rechts--- | Kennlinie | |
*| | | |lation|P B/D Aquer Js kb | v Hoehe Breite Kst Breite Kst Js | Hoehe A-quer Qab | |
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|
*| - | 1-4 | m | min | m m^2 °/oo mm | m m m^.3/s m m^.3/s °/oo | m m^2 m^3/s | m^3/s |
*|-<-->-|-<->-|<---->|<---->|+<---><---><---><--->-|-+-<----><----><--->-<----><--->-<--->-|-<----><----><---->-|-<---->-|
*| A | B | C | D |S E F G H | I J K L M N | O P Q | R |
*|-<-->-|-<->-|<---->|<---->|-<---><---><---><--->-|-+-<----><----><--->-<----><--->-<--->-|-<----><----><---->-|-<---->-|
| S100 | 3 | 1| | | 0 0.009 38.2 1.813 26 2 | | 1 |
| | | | | | 0.5 0.009 38.2 2 38.2 | | |
| | | | | | 0.981 0.446 26 2.211 34 | | |
| | | | | | 0.994 0.452 26 2.313 34 | | |
| | | | | | 1.133 1.443 34 3.403 34 | | |
| | | | | | 1.152 1.578 34 4.983 34 | | |
| | | | | | v 1.253 3.195 34 13.394 34 | | |
| SEND | 1 | 1| 1440| | | | 1 |
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|
</bluem>

==Erläuterung==
'''Allgemein'''
*'''A''': Bezeichnung
*'''B''': Kennung
*'''C''': Länge
'''Kennung 1: Translation'''
*'''D''': Translationszeit [min]
:Die Translationszeit wird immer auf ein Vielfaches des Simulationszeitschritts '''ab'''gerundet!
:Wenn die Translationszeit kürzer als der Simulationszeitschritt ist, findet '''keine''' Translation statt!
'''Kennung 2 und 5: Rohrleitung nach Kalinin-Miljukov (Kng 2) oder über nicht-linearen Speicher (Kng 5)'''
*'''S''': Profilart [1-4]:
*: 1: Kreis
*: 2: Ei (Norm-Ei H/B = 1,5)
*: 3: Maul (Norm-Maul H/B = 0,75)
*: 4: Rechteck
*'''E''': Durchmesser (beziehungsweise Breite)
*'''F''': Querschnittfläche
*'''G''': Sohlgefälle [&permil;]
*'''H''': Rauheit
'''Kennung 3: offenes Gerinne'''
*'''I''': Höhe
*'''J''': Breite linke Uferseite
*'''K''': kst linke Uferseite
*'''L''': Breite rechte Uferseite
*'''M''': kst rechte Uferseite
*'''N''': Sohlgefälle [&permil;]
'''Kennung 4: Kennlinie'''
*'''O''': Höhe
*'''P''': Querschnittsfläche
*'''Q''': Abfluss Qab
'''MQ'''
*'''R''': Anfangswert für den Abfluss
:wird zusätzlich mit der Kenngröße <code>Gerinneabfluss [% von MQ]</code> aus der [[ALL-Datei]] skaliert!

[[Kategorie:BlueM Eingabedateien]]

TRS-File

2009-06-18T12:17:42Z

Reussner: Typen für Rohre

{{Eingabedateien}}

<big>Transportstrecken</big>

''siehe auch [[Transportstrecken|Theorie:Transportstrecken]]''

==Datei==
<bluem>
*Transportelemente (*.TRS)
*=========================
*
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|
*| Bez | Kng | |Kng =1| Kng = 2,5 | Kng 3 = offenes Gerinne | Kng = 4 | MQ |
*| | |Laenge|Trans-| Rohrleitung |Vorland --Links--- --Rechts--- | Kennlinie | |
*| | | |lation|P B/D Aquer Js kb | v Hoehe Breite Kst Breite Kst Js | Hoehe A-quer Qab | |
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|
*| - | 1-4 | m | min | m m^2 °/oo mm | m m m^.3/s m m^.3/s °/oo | m m^2 m^3/s | m^3/s |
*|-<-->-|-<->-|<---->|<---->|+<---><---><---><--->-|-+-<----><----><--->-<----><--->-<--->-|-<----><----><---->-|-<---->-|
*| A | B | C | D |S E F G H | I J K L M N | O P Q | R |
*|-<-->-|-<->-|<---->|<---->|-<---><---><---><--->-|-+-<----><----><--->-<----><--->-<--->-|-<----><----><---->-|-<---->-|
| S100 | 3 | 1| | | 0 0.009 38.2 1.813 26 2 | | 1 |
| | | | | | 0.5 0.009 38.2 2 38.2 | | |
| | | | | | 0.981 0.446 26 2.211 34 | | |
| | | | | | 0.994 0.452 26 2.313 34 | | |
| | | | | | 1.133 1.443 34 3.403 34 | | |
| | | | | | 1.152 1.578 34 4.983 34 | | |
| | | | | | v 1.253 3.195 34 13.394 34 | | |
| SEND | 1 | 1| 1440| | | | 1 |
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|
</bluem>

==Erläuterung==
'''Allgemein'''
*'''A''': Bezeichnung
*'''B''': Kennung
*'''C''': Länge
'''Kennung 1: Translation'''
*'''D''': Translationszeit [min]
:Die Translationszeit wird immer auf ein Vielfaches des Simulationszeitschritts '''ab'''gerundet!
:Wenn die Translationszeit kürzer als der Simulationszeitschritt ist, findet '''keine''' Translation statt!
'''Kennung 2 und 5: Rohrleitung nach Kalinin-Miljukov (Kng 2) oder über nicht-linearen Speicher (Kng 5)'''
*'''S''': Profilart [1-4]:
*: 1: Kreis
*: 2: Ei (Norm-Ei H/B = 1,5)
*: 3: Maul (Norm-Maul H/B = 0,75)
*: 4: Rechteck
*'''E''': Durchmesser
*'''F''': Querschnittfläche
*'''G''': Sohlgefälle [&permil;]
*'''H''': Rauheit
'''Kennung 3: offenes Gerinne'''
*'''I''': Höhe
*'''J''': Breite linke Uferseite
*'''K''': kst linke Uferseite
*'''L''': Breite rechte Uferseite
*'''M''': kst rechte Uferseite
*'''N''': Sohlgefälle [&permil;]
'''Kennung 4: Kennlinie'''
*'''O''': Höhe
*'''P''': Querschnittsfläche
*'''Q''': Abfluss Qab
'''MQ'''
*'''R''': Anfangswert für den Abfluss
:wird zusätzlich mit der Kenngröße <code>Gerinneabfluss [% von MQ]</code> aus der [[ALL-Datei]] skaliert!

[[Kategorie:BlueM Eingabedateien]]

TRS-File

2009-06-05T11:09:19Z

Reussner: /* Erläuterung */

{{Eingabedateien}}

<big>Transportstrecken</big>

''siehe auch [[Transportstrecken|Theorie:Transportstrecken]]''

==Datei==
<bluem>
*Transportelemente (*.TRS)
*=========================
*
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|
*| Bez | Kng | |Kng =1| Kng = 2,5 | Kng 3 = offenes Gerinne | Kng = 4 | MQ |
*| | |Laenge|Trans-| Rohrleitung |Vorland --Links--- --Rechts--- | Kennlinie | |
*| | | |lation|P B/D Aquer Js kb | v Hoehe Breite Kst Breite Kst Js | Hoehe A-quer Qab | |
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|
*| - | 1-4 | m | min | m m^2 °/oo mm | m m m^.3/s m m^.3/s °/oo | m m^2 m^3/s | m^3/s |
*|-<-->-|-<->-|<---->|<---->|+<---><---><---><--->-|-+-<----><----><--->-<----><--->-<--->-|-<----><----><---->-|-<---->-|
*| A | B | C | D |S E F G H | I J K L M N | O P Q | R |
*|-<-->-|-<->-|<---->|<---->|-<---><---><---><--->-|-+-<----><----><--->-<----><--->-<--->-|-<----><----><---->-|-<---->-|
| S100 | 3 | 1| | | 0 0.009 38.2 1.813 26 2 | | 1 |
| | | | | | 0.5 0.009 38.2 2 38.2 | | |
| | | | | | 0.981 0.446 26 2.211 34 | | |
| | | | | | 0.994 0.452 26 2.313 34 | | |
| | | | | | 1.133 1.443 34 3.403 34 | | |
| | | | | | 1.152 1.578 34 4.983 34 | | |
| | | | | | v 1.253 3.195 34 13.394 34 | | |
| SEND | 1 | 1| 1440| | | | 1 |
*|------|-----|------|------|----------------------|---------------------------------------|--------------------|--------|
</bluem>

==Erläuterung==
'''Allgemein'''
*'''A''': Bezeichnung
*'''B''': Kennung
*'''C''': Länge
'''Kennung 1: Translation'''
*'''D''': Translationszeit [min]
:Die Translationszeit wird immer auf ein Vielfaches des Simulationszeitschritts '''ab'''gerundet!
:Wenn die Translationszeit kürzer als der Simulationszeitschritt ist, findet '''keine''' Translation statt!
'''Kennung 2 und 5: Rohrleitung nach Kalinin-Miljukov (Kng 2) oder über nicht-linearen Speicher (Kng 5)'''
*'''S''': Profilart [1-4]:
*: 1: Kreis
*: 2: Ei
*: 3: Maul
*: 4: Rechteck
*'''E''': Durchmesser
*'''F''': Querschnittfläche
*'''G''': Sohlgefälle [&permil;]
*'''H''': Rauheit
'''Kennung 3: offenes Gerinne'''
*'''I''': Höhe
*'''J''': Breite linke Uferseite
*'''K''': kst linke Uferseite
*'''L''': Breite rechte Uferseite
*'''M''': kst rechte Uferseite
*'''N''': Sohlgefälle [&permil;]
'''Kennung 4: Kennlinie'''
*'''O''': Höhe
*'''P''': Querschnittsfläche
*'''Q''': Abfluss Qab
'''MQ'''
*'''R''': Anfangswert für den Abfluss
:wird zusätzlich mit der Kenngröße <code>Gerinneabfluss [% von MQ]</code> aus der [[ALL-Datei]] skaliert!

[[Kategorie:BlueM Eingabedateien]]

EIN-File

2009-05-28T08:42:17Z

Reussner: /* Erläuterung */

ZRE-Format

2009-04-21T09:08:35Z

Reussner:

Formatbeschreibung für das Zeitreihenformat ZRE.

<u>Beispiel:</u>
<pre>
*ZRE
Beschreibung mm
1 1. 1. 1.
19900116 00:00 19900101 04:15
19900116 00:00 0.00000
19900116 00:15 4.55000
19900116 00:30 4.55000
19900116 00:45 4.55000
19900116 01:00 4.55000
19900116 01:15 4.55000
19900116 01:30 4.55000
19900116 01:45 4.55000
19900116 02:00 4.55000
19900116 02:15 4.55000
19900116 02:30 4.55000
19900116 02:45 4.55000
19900116 03:00 4.55000
19900116 03:15 4.55000
19900116 03:30 4.55000
19900116 03:45 4.55000
19900116 04:00 4.55000
19900116 04:15 4.55000
</pre>

'''1. Zeile:''' "<code>*ZRE</code>"

'''2. Zeile:''' Beschreibung (15 Zeichen) und Einheit (ab Spalte 16)

'''3. Zeile:''' belanglose(?) Parameter

'''4. Zeile:''' Start- und Enddatum der Zeitreihe

'''ab Zeile 5:''' Zeitstempel und Wert

Alle Datumsangaben müssen im Format <code>JJJJMMTT hh:mm</code> sein.

;Hinweis:
:ZRE-Dateien können auch mit [[Wave]] erstellt werden

[[Kategorie:BlueM Eingabedateien]]

WEL-Format (BlueM)

2009-01-27T09:59:12Z

Reussner: Gütedaten in WEL

BlueM schreibt die Simulationsergebnisse in eine WEL-Datei. In der [[SYS-Datei]] wird festgelegt, für welche Systemelemente die Simulationsergebnisse in diese Datei geschrieben werden.

== Ganglinien ==
Die Interpretation der ausgegeben Ganglinien variiert mit dem ausgegebenen Wert. So gilt z.B. für Temperatur und Abfluss die Interpretation "Block rechts", für Niederschlag und Verdunstung aber "Summenlinie pro Zeitschritt". Im Beispiel unten liegt wurde also zwischen 4:00 und 5:00 Uhr 0,005 mm verdunstet, während die Temperatur zwischen 4:00 und 5.00 Uhr konstant bei 10°C lag. Grundsätzlich sieht eine WEL-Datei wie im folgenden Beispiel aus:
<pre>
*WEL 15.06.2007 15:47
Datum_Zeit A001_TEM A001_ETP A001_ETA A001_SCH
- °C mm mm mm
01.01.1990 00:00 10.000 0.004 0.004 0.000
01.01.1990 01:00 10.000 0.004 0.004 0.000
01.01.1990 02:00 10.000 0.004 0.004 0.000
01.01.1990 03:00 10.000 0.004 0.004 0.000
01.01.1990 04:00 10.000 0.005 0.005 0.000
01.01.1990 05:00 10.000 0.007 0.007 0.000
01.01.1990 06:00 10.000 0.010 0.010 0.000
01.01.1990 07:00 10.000 0.011 0.011 0.000
01.01.1990 08:00 10.000 0.013 0.013 0.000
01.01.1990 09:00 10.000 0.017 0.017 0.000
01.01.1990 10:00 10.000 0.026 0.026 0.000
01.01.1990 11:00 10.000 0.031 0.031 0.000
01.01.1990 12:00 10.000 0.034 0.034 0.000
</pre>

Wenn in der [[ALL-Datei]] die Option "CSV-Format" aktiviert wird, werden die Spalten in der WEL-Datei noch mit Semikola getrennt, wie im folgenden Beispiel gezeigt:
<pre>
*WEL;24.07.2007 17:20
; Datum_Zeit; TOLF_VOL; TOLF_WSP; TOLF_1ZU; TOLF_QA2
; -; Tsd.m3; mNN; m3/s; m3/s
;01.04.1984 00:00; 6937.487; 449.130; 2.820; 0.000
;02.04.1984 00:00; 7012.276; 449.288; 2.430; 0.000
;03.04.1984 00:00; 7074.796; 449.419; 2.045; 0.000
;04.04.1984 00:00; 7122.398; 449.520; 1.565; 0.000
;05.04.1984 00:00; 7161.622; 449.603; 1.295; 0.000
;06.04.1984 00:00; 7197.977; 449.679; 1.205; 0.000
;07.04.1984 00:00; 7232.840; 449.753; 1.160; 0.000
;08.04.1984 00:00; 7268.167; 449.827; 1.180; 0.000
;09.04.1984 00:00; 7305.434; 449.906; 1.250; 0.000
;10.04.1984 00:00; 7349.340; 449.999; 1.480; 0.000
;11.04.1984 00:00; 7403.884; 450.090; 1.850; 0.000
;12.04.1984 00:00; 7469.293; 450.199; 2.235; 0.000
;13.04.1984 00:00; 7541.710; 450.320; 2.495; 0.000
;14.04.1984 00:00; 7619.098; 450.448; 2.690; 0.000
;15.04.1984 00:00; 7706.950; 450.595; 3.085; 0.000
;16.04.1984 00:00; 7797.539; 450.746; 3.215; 0.000
;17.04.1984 00:00; 7876.266; 450.877; 2.820; 0.000
;18.04.1984 00:00; 7939.994; 450.983; 2.300; 0.000
</pre>

Die in WEL-Dateien enthaltenen Ganglinien können mit '''[[Wave]]''' geöffnet und angezeigt werden.

== Spaltennamen ==

=== normale TODO ===

=== Güteausgabe ===
Wenn mit Gütemodell simuliert wird, dann werden für die ausgewählten Elemente auch die Gütevariablen ausgegeben.

;Anmerkung: Momentan nur für TRS implementiert ([[Benutzer:Reussner|Reussner]] 09:59, 27. Jan. 2009 (UTC)) !

<pre>
S100_ca1 S100_cc1 S100_cM1 S100_cm1 S100_cx1 S100_ca2 S100_cc2 S100_cM2 S100_cm2 S100_cx2 S100_ca3 S100_cc3 S100_cM3 S100_cm3 S100_cx3 S100_ca4 S100_cc4 S100_cM4 S100_cm4 S100_cx4 S100_ca5 S100_cc5 S100_cM5 S100_cm5 S100_cx5
</pre>

ca1 := AbflussKonzentrationen(1,konzloop)
cc1 := Konzentrationen(konzloop)

cM1 := Statistik_MinKonzentrationen(konzloop)
cm1 := Statistik_MaxKonzentrationen(konzloop)

cx1 := externKonzentrationen(konzloop)

1 steht für die erste Konzentration:

Reihenfolge Konzentrationen SWQM:
SO = 1
SNH = 2
SI = 3
SS = 4
P = 5

[[Kategorie:BlueM Ausgabedateien]]

FORTRAN

2008-12-04T11:36:49Z

Reussner: /* Fixed Form und Free Form */

<div style="float:right; margin-left:10px;">__TOC__</div>
== Real Werte und Vergleiche ==
Ein wichtiger Punkt bei der Programmierung mit Fortran ist die Behandlung der Real Werte. Insbesondere der vergleich, ob zwei Real Werte gleich sind, ist in FORTRAN nur durch eine erweiterte Syntax möglich.

=== Zuweisen von Werten ===
<fortran>
real*4 a
real*8 b

a = 0.123e0 !das e0 kennzeichnet den Wert als real*4
b = 0.123d0 !das d0 kennzeichnet den Wert als real*8</fortran>

=== Vergleich von Realzahlen ===
:''siehe Bug 367''
Früher wurde im Rechenkern mit unterschiedlichen Vergleichen gerechnet (<code>GLOBAL_NULL</code>, <code>GLOBAL_FASTNULL</code> etc.)

'''Momentan verwendet:'''
<fortran>
R8_EPSILON = 2 * Epsilon(1.2345d0)
R4_EPSILON = 2 * Epsilon(1.2654E0) ! entspricht 2**-23</fortran>

'''Diskussion:'''
<fortran>
real*4 a
real*4 b
logical isNull

isNull = (a == b) !wird so gut wie nie erfüllt

isNull = (ABS(a - b) < 1E-15) !früher im Projekt verwendet (GLOBAL_NULL)

!Alternativen (zur Diskussion)
isNull = (ABS(a - b) < Epsilon(a)) !nach Rechenoperationen erwies sich Epsilon als zu ungenau bzw. genau
isNull = (ABS(a / b - 1.0E0) < eps) !Relativvergleich - führte bei Tests aber zu Fehlern
isNull = (ABS(a - b) < SPACING(0.0E0))</fortran>

====Anmerkung====
Im Code von BlueM sind ein paar nicht korrekte Anweisungen enthalten:
<fortran>
! FALSCH
MAX(dumdidum, R8_EPSILON)
MAX(dumdidum, R4_EPSILON)</fortran>
Korrekt ist aber:
<fortran>
! RICHTIG
MAX(dumdidum, 0.0D0)
MAX(dumdidum, 0.0E0)</fortran>

==== Links ====
* [http://hodgson.pi.tu-berlin.de/Lehre/EDV1/skripte/f95_skript/node56.html Vergleich von Realwerten]
* [http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231255.aspx Aus dem Intel-Forum]
* Guter Artikel über Problematik: [http://www.lahey.com/float.htm The Perils of Floating Point]

== Übergabe von Arrays ==
In Fortran ist es möglich Teile von Arrays an Funktionen zu übergeben.

Dabei wird der Subroutine (oder function) einfach der "Anfangswert" übergeben - z.B. <code>func_array(Huba(1,2,1))</code>.Von diesem Startpunkt wird, dann in der Subroutine ein entsprechendes Array gebildet. Erwartet beispielsweise die Subroutine einen Vektor, dann werden vom jenem Startpunkt an alle Werte der ersten Dimension übernommen. Analog verhält es sich bei mehrdimiensionalen Arrays.
;Anmerkung: Das Array der Subroutine sollte natürlich kleiner sein, als das Übergebene (vom Startpunkt gezählt) !

Das Beispiel verdeutlicht dies:
<fortran>
!---------------------------------------------------------------
subroutine TestArrayFortranFortran()
integer arr(3,4)
integer i
integer j

do i = 1, ubound(arr,1)
do j = 1, ubound(arr,2)
arr(i,j) = i + (j-1)*3
write(*,'("Matrix (", I4,",",I4,") = ",I4)') i,j,arr(i,j)
end do
end do

write(*,'("Aufruf mit arr(1,1) ")')
call TestArrayFortranFortran_SUB(arr(1,1))
write(*,'("Aufruf mit arr(2,1) ")')
call TestArrayFortranFortran_SUB(arr(2,1))
write(*,'("Aufruf mit arr(1,2) ")')
call TestArrayFortranFortran_SUB(arr(1,2))
write(*,'("Aufruf mit arr(2,2) ")')
call TestArrayFortranFortran_SUB(arr(2,2))

end subroutine
!---------------------------------------------------------------

!---------------------------------------------------------------
subroutine TestArrayFortranFortran_SUB(arr)
integer arr(2)
integer i

do i = 1, ubound(arr,1)
write(*,'("Vektor ", I4)') arr(i)
end do

end subroutine
!---------------------------------------------------------------
</fortran>

Ausgabe:
[[Bild:ConsolenAusgabe TestArray.png]]

== Fixed Form und Free Form ==
Die Free Form ist der Fixed Form der übersichtlichkeitshalber vorzuziehen. Ausserdem können bei der Fixed Form Fehler entstehen, die der compiler nicht abfängt (z. B. Formeln die über den Rand gehen - in SMUSI war beispielsweise eine Stelle, wo statt mit 300 nur mit 3 multipliziert wurde.

Für die Umstellung gibts hier eine regular Expression, die alle Zeilen anzeigt die länger als 72 Zeichen sind:

Identifizieren von Problemstellen
<pre>
^[^cC!][^!]^72
</pre>
Visualisierung unter [http://strfriend.com/vis?re=^%5b^cC!%5d%5b^!%5d^72%0D%0A]

Bereinigen von Leerzeichen am Ende
<pre>
(:b+)$
</pre>
Visualisierung unter [http://strfriend.com/vis?re=(%3Ab%2B)%24%0D%0A]

[[Kategorie: Fortran]]

FORTRAN

2008-12-04T10:37:47Z

Reussner: /* Fixed Form und Free Form */ Visualisierung

<div style="float:right; margin-left:10px;">__TOC__</div>
== Real Werte und Vergleiche ==
Ein wichtiger Punkt bei der Programmierung mit Fortran ist die Behandlung der Real Werte. Insbesondere der vergleich, ob zwei Real Werte gleich sind, ist in FORTRAN nur durch eine erweiterte Syntax möglich.

=== Zuweisen von Werten ===
<fortran>
real*4 a
real*8 b

a = 0.123e0 !das e0 kennzeichnet den Wert als real*4
b = 0.123d0 !das d0 kennzeichnet den Wert als real*8</fortran>

=== Vergleich von Realzahlen ===
:''siehe Bug 367''
Früher wurde im Rechenkern mit unterschiedlichen Vergleichen gerechnet (<code>GLOBAL_NULL</code>, <code>GLOBAL_FASTNULL</code> etc.)

'''Momentan verwendet:'''
<fortran>
R8_EPSILON = 2 * Epsilon(1.2345d0)
R4_EPSILON = 2 * Epsilon(1.2654E0) ! entspricht 2**-23</fortran>

'''Diskussion:'''
<fortran>
real*4 a
real*4 b
logical isNull

isNull = (a == b) !wird so gut wie nie erfüllt

isNull = (ABS(a - b) < 1E-15) !früher im Projekt verwendet (GLOBAL_NULL)

!Alternativen (zur Diskussion)
isNull = (ABS(a - b) < Epsilon(a)) !nach Rechenoperationen erwies sich Epsilon als zu ungenau bzw. genau
isNull = (ABS(a / b - 1.0E0) < eps) !Relativvergleich - führte bei Tests aber zu Fehlern
isNull = (ABS(a - b) < SPACING(0.0E0))</fortran>

====Anmerkung====
Im Code von BlueM sind ein paar nicht korrekte Anweisungen enthalten:
<fortran>
! FALSCH
MAX(dumdidum, R8_EPSILON)
MAX(dumdidum, R4_EPSILON)</fortran>
Korrekt ist aber:
<fortran>
! RICHTIG
MAX(dumdidum, 0.0D0)
MAX(dumdidum, 0.0E0)</fortran>

==== Links ====
* [http://hodgson.pi.tu-berlin.de/Lehre/EDV1/skripte/f95_skript/node56.html Vergleich von Realwerten]
* [http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231255.aspx Aus dem Intel-Forum]
* Guter Artikel über Problematik: [http://www.lahey.com/float.htm The Perils of Floating Point]

== Übergabe von Arrays ==
In Fortran ist es möglich Teile von Arrays an Funktionen zu übergeben.

Dabei wird der Subroutine (oder function) einfach der "Anfangswert" übergeben - z.B. <code>func_array(Huba(1,2,1))</code>.Von diesem Startpunkt wird, dann in der Subroutine ein entsprechendes Array gebildet. Erwartet beispielsweise die Subroutine einen Vektor, dann werden vom jenem Startpunkt an alle Werte der ersten Dimension übernommen. Analog verhält es sich bei mehrdimiensionalen Arrays.
;Anmerkung: Das Array der Subroutine sollte natürlich kleiner sein, als das Übergebene (vom Startpunkt gezählt) !

Das Beispiel verdeutlicht dies:
<fortran>
!---------------------------------------------------------------
subroutine TestArrayFortranFortran()
integer arr(3,4)
integer i
integer j

do i = 1, ubound(arr,1)
do j = 1, ubound(arr,2)
arr(i,j) = i + (j-1)*3
write(*,'("Matrix (", I4,",",I4,") = ",I4)') i,j,arr(i,j)
end do
end do

write(*,'("Aufruf mit arr(1,1) ")')
call TestArrayFortranFortran_SUB(arr(1,1))
write(*,'("Aufruf mit arr(2,1) ")')
call TestArrayFortranFortran_SUB(arr(2,1))
write(*,'("Aufruf mit arr(1,2) ")')
call TestArrayFortranFortran_SUB(arr(1,2))
write(*,'("Aufruf mit arr(2,2) ")')
call TestArrayFortranFortran_SUB(arr(2,2))

end subroutine
!---------------------------------------------------------------

!---------------------------------------------------------------
subroutine TestArrayFortranFortran_SUB(arr)
integer arr(2)
integer i

do i = 1, ubound(arr,1)
write(*,'("Vektor ", I4)') arr(i)
end do

end subroutine
!---------------------------------------------------------------
</fortran>

Ausgabe:
[[Bild:ConsolenAusgabe TestArray.png]]

== Fixed Form und Free Form ==
Die Free Form ist der Fixed Form der übersichtlichkeitshalber vorzuziehen. Ausserdem können bei der Fixed Form Fehler entstehen, die der compiler nicht abfängt (z. B. Formeln die über den Rand gehen - in SMUSI war beispielsweise eine Stelle, wo statt mit 300 nur mit 3 multipliziert wurde.

Für die Umstellung gibts hier eine regular Expression, die alle Zeilen anzeigt die länger als 72 Zeichen sind:

Identifizieren von Problemstellen
<pre>
^[^cC!][^!]^72
</pre>
Visualisierung unter [http://strfriend.com/vis?re=^[^cC!][^!]^72%0D%0A]

Bereinigen von Leerzeichen am Ende
<pre>
(:b+)$
</pre>
Visualisierung unter [http://strfriend.com/vis?re=(%3Ab%2B)%24%0D%0A]

[[Kategorie: Fortran]]

Fraktionierung innerhalb von BlueM.Sim

2008-11-19T11:37:48Z

Reussner:

[[Bild:BlueMDevMettingGuete_Einleitung.jpg|800px]]
[[Bild:BlueMDevMettingGuete_Ablaufdiagramm.jpg|800px]]
[[Bild:BlueMDevMettingGuete_Informationsspeicherung.jpg|800px]]
[[Bild:BlueMDevMettingGuete_1erMilestone.jpg|800px]]

File:BlueMDevMettingGuete 1erMilestone.jpg

2008-11-19T11:35:48Z

Reussner:

File:BlueMDevMettingGuete Informationsspeicherung.jpg

2008-11-19T11:35:26Z

Reussner:

File:BlueMDevMettingGuete Ablaufdiagramm.jpg

2008-11-19T11:35:07Z

Reussner:

File:BlueMDevMettingGuete Einleitung.jpg

2008-11-19T11:34:31Z

Reussner:

Fraktionierung innerhalb von BlueM.Sim

2008-11-19T11:33:56Z

Reussner: Die Seite wurde neu angelegt: Bild:BlueMDevMettingGuete_Einleitung.jpg Bild:BlueMDevMettingGuete_Ablaufdiagramm.jpg Bild:BlueMDevMettingGuete_Informationsspeicherung.jpg [[Bild:BlueMDevM...

[[Bild:BlueMDevMettingGuete_Einleitung.jpg]]
[[Bild:BlueMDevMettingGuete_Ablaufdiagramm.jpg]]
[[Bild:BlueMDevMettingGuete_Informationsspeicherung.jpg]]
[[Bild:BlueMDevMettingGuete_1erMilestone.jpg]]

Gütemodell

2008-11-19T09:57:03Z

Reussner: /* Gütemodell */

== Gütemodell ==
Alles was das Gütemodell angeht ...

* [[Fraktionierung innerhalb von BlueM.Sim]]
* LaPipe
** [[Weitergabe Stoffe]]

[[Category:Gütemodell]]

FORTRAN

2008-10-29T12:39:31Z

Reussner: /* Übergabe von Arrays */

<div style="float:right; margin-left:10px;">__TOC__</div>
== Real Werte und Vergleiche ==
Ein wichtiger Punkt bei der Programmierung mit Fortran ist die Behandlung der Real Werte. Insbesondere der vergleich, ob zwei Real Werte gleich sind, ist in FORTRAN nur durch eine erweiterte Syntax möglich.

=== Zuweisen von Werten ===
<fortran>
real*4 a
real*8 b

a = 0.123e0 !das e0 kennzeichnet den Wert als real*4
b = 0.123d0 !das d0 kennzeichnet den Wert als real*8</fortran>

=== Vergleich von Realzahlen ===
:''siehe Bug 367''
Früher wurde im Rechenkern mit unterschiedlichen Vergleichen gerechnet (<code>GLOBAL_NULL</code>, <code>GLOBAL_FASTNULL</code> etc.)

'''Momentan verwendet:'''
<fortran>
R8_EPSILON = 2 * Epsilon(1.2345d0)
R4_EPSILON = 2 * Epsilon(1.2654E0) ! entspricht 2**-23</fortran>

'''Diskussion:'''
<fortran>
real*4 a
real*4 b
logical isNull

isNull = (a == b) !wird so gut wie nie erfüllt

isNull = (ABS(a - b) < 1E-15) !früher im Projekt verwendet (GLOBAL_NULL)

!Alternativen (zur Diskussion)
isNull = (ABS(a - b) < Epsilon(a)) !nach Rechenoperationen erwies sich Epsilon als zu ungenau bzw. genau
isNull = (ABS(a / b - 1.0E0) < eps) !Relativvergleich - führte bei Tests aber zu Fehlern
isNull = (ABS(a - b) < SPACING(0.0E0))</fortran>

====Anmerkung====
Im Code von BlueM sind ein paar nicht korrekte Anweisungen enthalten:
<fortran>
! FALSCH
MAX(dumdidum, R8_EPSILON)
MAX(dumdidum, R4_EPSILON)</fortran>
Korrekt ist aber:
<fortran>
! RICHTIG
MAX(dumdidum, 0.0D0)
MAX(dumdidum, 0.0E0)</fortran>

==== Links ====
* [http://hodgson.pi.tu-berlin.de/Lehre/EDV1/skripte/f95_skript/node56.html Vergleich von Realwerten]
* [http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231255.aspx Aus dem Intel-Forum]
* Guter Artikel über Problematik: [http://www.lahey.com/float.htm The Perils of Floating Point]

== Übergabe von Arrays ==
In Fortran ist es möglich Teile von Arrays an Funktionen zu übergeben.

Dabei wird der Subroutine (oder function) einfach der "Anfangswert" übergeben - z.B. <code>func_array(Huba(1,2,1))</code>.Von diesem Startpunkt wird, dann in der Subroutine ein entsprechendes Array gebildet. Erwartet beispielsweise die Subroutine einen Vektor, dann werden vom jenem Startpunkt an alle Werte der ersten Dimension übernommen. Analog verhält es sich bei mehrdimiensionalen Arrays.
;Anmerkung: Das Array der Subroutine sollte natürlich kleiner sein, als das Übergebene (vom Startpunkt gezählt) !

Das Beispiel verdeutlicht dies:
<fortran>
!---------------------------------------------------------------
subroutine TestArrayFortranFortran()
integer arr(3,4)
integer i
integer j

do i = 1, ubound(arr,1)
do j = 1, ubound(arr,2)
arr(i,j) = i + (j-1)*3
write(*,'("Matrix (", I4,",",I4,") = ",I4)') i,j,arr(i,j)
end do
end do

write(*,'("Aufruf mit arr(1,1) ")')
call TestArrayFortranFortran_SUB(arr(1,1))
write(*,'("Aufruf mit arr(2,1) ")')
call TestArrayFortranFortran_SUB(arr(2,1))
write(*,'("Aufruf mit arr(1,2) ")')
call TestArrayFortranFortran_SUB(arr(1,2))
write(*,'("Aufruf mit arr(2,2) ")')
call TestArrayFortranFortran_SUB(arr(2,2))

end subroutine
!---------------------------------------------------------------

!---------------------------------------------------------------
subroutine TestArrayFortranFortran_SUB(arr)
integer arr(2)
integer i

do i = 1, ubound(arr,1)
write(*,'("Vektor ", I4)') arr(i)
end do

end subroutine
!---------------------------------------------------------------
</fortran>

Ausgabe:
[[Bild:ConsolenAusgabe TestArray.png]]

== Fixed Form und Free Form ==
Die Free Form ist der Fixed Form der übersichtlichkeitshalber vorzuziehen. Ausserdem können bei der Fixed Form Fehler entstehen, die der compiler nicht abfängt (z. B. Formeln die über den Rand gehen - in SMUSI war beispielsweise eine Stelle, wo statt mit 300 nur mit 3 multipliziert wurde.

Für die Umstellung gibts hier eine regular Expression, die alle Zeilen anzeigt die länger als 72 Zeichen sind:

Identifizieren von Problemstellen
<pre>
^[^cC!][^!]^72
</pre>

Bereinigen von Leerzeichen am Ende
<pre>
(:b+)$
</pre>

[[Kategorie: Fortran]]

FORTRAN

2008-10-29T10:14:34Z

Reussner: /* Übergabe von Arrays */

<div style="float:right; margin-left:10px;">__TOC__</div>
== Real Werte und Vergleiche ==
Ein wichtiger Punkt bei der Programmierung mit Fortran ist die Behandlung der Real Werte. Insbesondere der vergleich, ob zwei Real Werte gleich sind, ist in FORTRAN nur durch eine erweiterte Syntax möglich.

=== Zuweisen von Werten ===
<fortran>
real*4 a
real*8 b

a = 0.123e0 !das e0 kennzeichnet den Wert als real*4
b = 0.123d0 !das d0 kennzeichnet den Wert als real*8</fortran>

=== Vergleich von Realzahlen ===
:''siehe Bug 367''
Früher wurde im Rechenkern mit unterschiedlichen Vergleichen gerechnet (<code>GLOBAL_NULL</code>, <code>GLOBAL_FASTNULL</code> etc.)

'''Momentan verwendet:'''
<fortran>
R8_EPSILON = 2 * Epsilon(1.2345d0)
R4_EPSILON = 2 * Epsilon(1.2654E0) ! entspricht 2**-23</fortran>

'''Diskussion:'''
<fortran>
real*4 a
real*4 b
logical isNull

isNull = (a == b) !wird so gut wie nie erfüllt

isNull = (ABS(a - b) < 1E-15) !früher im Projekt verwendet (GLOBAL_NULL)

!Alternativen (zur Diskussion)
isNull = (ABS(a - b) < Epsilon(a)) !nach Rechenoperationen erwies sich Epsilon als zu ungenau bzw. genau
isNull = (ABS(a / b - 1.0E0) < eps) !Relativvergleich - führte bei Tests aber zu Fehlern
isNull = (ABS(a - b) < SPACING(0.0E0))</fortran>

====Anmerkung====
Im Code von BlueM sind ein paar nicht korrekte Anweisungen enthalten:
<fortran>
! FALSCH
MAX(dumdidum, R8_EPSILON)
MAX(dumdidum, R4_EPSILON)</fortran>
Korrekt ist aber:
<fortran>
! RICHTIG
MAX(dumdidum, 0.0D0)
MAX(dumdidum, 0.0E0)</fortran>

==== Links ====
* [http://hodgson.pi.tu-berlin.de/Lehre/EDV1/skripte/f95_skript/node56.html Vergleich von Realwerten]
* [http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231255.aspx Aus dem Intel-Forum]
* Guter Artikel über Problematik: [http://www.lahey.com/float.htm The Perils of Floating Point]

== Übergabe von Arrays ==
In Fortran ist es möglich Teile von Arrays an Funktionen zu übergeben. Wie genau das funktioniert, sollte hier erläutert werden:

Das Beispiel zeigt was genau übergeben wird:
<fortran>
!---------------------------------------------------------------
subroutine TestArrayFortranFortran()
integer arr(3,4)
integer i
integer j

do i = 1, ubound(arr,1)
do j = 1, ubound(arr,2)
arr(i,j) = i + (j-1)*3
write(*,'("Matrix (", I4,",",I4,") = ",I4)') i,j,arr(i,j)
end do
end do

write(*,'("Aufruf mit arr(1,1) ")')
call TestArrayFortranFortran_SUB(arr(1,1))
write(*,'("Aufruf mit arr(2,1) ")')
call TestArrayFortranFortran_SUB(arr(2,1))
write(*,'("Aufruf mit arr(1,2) ")')
call TestArrayFortranFortran_SUB(arr(1,2))
write(*,'("Aufruf mit arr(2,2) ")')
call TestArrayFortranFortran_SUB(arr(2,2))

end subroutine
!---------------------------------------------------------------

!---------------------------------------------------------------
subroutine TestArrayFortranFortran_SUB(arr)
integer arr(2)
integer i

do i = 1, ubound(arr,1)
write(*,'("Vektor ", I4)') arr(i)
end do

end subroutine
!---------------------------------------------------------------
</fortran>

Ausgabe:
[[Bild:ConsolenAusgabe TestArray.png]]

== Fixed Form und Free Form ==
Die Free Form ist der Fixed Form der übersichtlichkeitshalber vorzuziehen. Ausserdem können bei der Fixed Form Fehler entstehen, die der compiler nicht abfängt (z. B. Formeln die über den Rand gehen - in SMUSI war beispielsweise eine Stelle, wo statt mit 300 nur mit 3 multipliziert wurde.

Für die Umstellung gibts hier eine regular Expression, die alle Zeilen anzeigt die länger als 72 Zeichen sind:

Identifizieren von Problemstellen
<pre>
^[^cC!][^!]^72
</pre>

Bereinigen von Leerzeichen am Ende
<pre>
(:b+)$
</pre>

[[Kategorie: Fortran]]

File:ConsolenAusgabe TestArray.png

2008-10-29T10:13:45Z

Reussner:

FORTRAN

2008-10-29T10:11:51Z

Reussner: /* Übergabe von Arrays */

<div style="float:right; margin-left:10px;">__TOC__</div>
== Real Werte und Vergleiche ==
Ein wichtiger Punkt bei der Programmierung mit Fortran ist die Behandlung der Real Werte. Insbesondere der vergleich, ob zwei Real Werte gleich sind, ist in FORTRAN nur durch eine erweiterte Syntax möglich.

=== Zuweisen von Werten ===
<fortran>
real*4 a
real*8 b

a = 0.123e0 !das e0 kennzeichnet den Wert als real*4
b = 0.123d0 !das d0 kennzeichnet den Wert als real*8</fortran>

=== Vergleich von Realzahlen ===
:''siehe Bug 367''
Früher wurde im Rechenkern mit unterschiedlichen Vergleichen gerechnet (<code>GLOBAL_NULL</code>, <code>GLOBAL_FASTNULL</code> etc.)

'''Momentan verwendet:'''
<fortran>
R8_EPSILON = 2 * Epsilon(1.2345d0)
R4_EPSILON = 2 * Epsilon(1.2654E0) ! entspricht 2**-23</fortran>

'''Diskussion:'''
<fortran>
real*4 a
real*4 b
logical isNull

isNull = (a == b) !wird so gut wie nie erfüllt

isNull = (ABS(a - b) < 1E-15) !früher im Projekt verwendet (GLOBAL_NULL)

!Alternativen (zur Diskussion)
isNull = (ABS(a - b) < Epsilon(a)) !nach Rechenoperationen erwies sich Epsilon als zu ungenau bzw. genau
isNull = (ABS(a / b - 1.0E0) < eps) !Relativvergleich - führte bei Tests aber zu Fehlern
isNull = (ABS(a - b) < SPACING(0.0E0))</fortran>

====Anmerkung====
Im Code von BlueM sind ein paar nicht korrekte Anweisungen enthalten:
<fortran>
! FALSCH
MAX(dumdidum, R8_EPSILON)
MAX(dumdidum, R4_EPSILON)</fortran>
Korrekt ist aber:
<fortran>
! RICHTIG
MAX(dumdidum, 0.0D0)
MAX(dumdidum, 0.0E0)</fortran>

==== Links ====
* [http://hodgson.pi.tu-berlin.de/Lehre/EDV1/skripte/f95_skript/node56.html Vergleich von Realwerten]
* [http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231255.aspx Aus dem Intel-Forum]
* Guter Artikel über Problematik: [http://www.lahey.com/float.htm The Perils of Floating Point]

== Übergabe von Arrays ==
In Fortran ist es möglich Teile von Arrays an Funktionen zu übergeben. Wie genau das funktioniert, sollte hier erläutert werden:

Das Beispiel zeigt was genau übergeben wird:
<fortran>
!---------------------------------------------------------------
subroutine TestArrayFortranFortran()
integer arr(3,4)
integer i
integer j

do i = 1, ubound(arr,1)
do j = 1, ubound(arr,2)
arr(i,j) = i + (j-1)*3
write(*,'("Matrix (", I4,",",I4,") = ",I4)') i,j,arr(i,j)
end do
end do

write(*,'("Aufruf mit arr(1,1) ")')
call TestArrayFortranFortran_SUB(arr(1,1))
write(*,'("Aufruf mit arr(2,1) ")')
call TestArrayFortranFortran_SUB(arr(2,1))
write(*,'("Aufruf mit arr(1,2) ")')
call TestArrayFortranFortran_SUB(arr(1,2))
write(*,'("Aufruf mit arr(2,2) ")')
call TestArrayFortranFortran_SUB(arr(2,2))

end subroutine
!---------------------------------------------------------------

!---------------------------------------------------------------
subroutine TestArrayFortranFortran_SUB(arr)
integer arr(2)
integer i

do i = 1, ubound(arr,1)
write(*,'("Vektor ", I4)') arr(i)
end do

end subroutine
!---------------------------------------------------------------
</fortran>

Ausgabe:
[[Bild:ConsolenAusgabe TestArray.jpg]]

== Fixed Form und Free Form ==
Die Free Form ist der Fixed Form der übersichtlichkeitshalber vorzuziehen. Ausserdem können bei der Fixed Form Fehler entstehen, die der compiler nicht abfängt (z. B. Formeln die über den Rand gehen - in SMUSI war beispielsweise eine Stelle, wo statt mit 300 nur mit 3 multipliziert wurde.

Für die Umstellung gibts hier eine regular Expression, die alle Zeilen anzeigt die länger als 72 Zeichen sind:

Identifizieren von Problemstellen
<pre>
^[^cC!][^!]^72
</pre>

Bereinigen von Leerzeichen am Ende
<pre>
(:b+)$
</pre>

[[Kategorie: Fortran]]

FORTRAN

2008-10-29T09:08:28Z

Reussner: /* Anmerkung */

FORTRAN

2008-08-12T07:50:34Z

Reussner: /* Fixed Form und Free Form */

== Fixed Form und Free Form ==
Die Free Form ist der Fixed Form der übersichtlichkeitshalber vorzuziehen. Ausserdem können bei der Fixed Form Fehler entstehen, die der compiler nicht abfängt (z. B. Formeln die über den Rand gehen - in SMUSI war beispielsweise eine Stelle, wo statt mit 300 nur mit 3 multipliziert wurde.

Für die Umstellung gibts hier eine regular Expression, die alle Zeilen anzeigt die länger als 72 Zeichen sind:

Identizieren von Problemstellen
<pre>
^[^cC!][^!]^72
</pre>

Bereinigen von Leerzeichen am Ende
<pre>
(:b+)$
</pre>

== Real Werte und Vergleiche ==
Ein wichtiger Punkt bei der Programmierung mit Fortran ist die Behandlung der Real Werte. Insbesondere der vergleich, ob zwei Real Werte gelich sind, ist in FORTRAN nur durch eine erweiterte Syntax möglich.

=== Zuweisen von Werten: ===

<fortran>
real*4 a
real*8 b

a = 0.123e0 !das e0 kennzeichnet den Wert als real*4

b = 0.123d0 ! das d0 kennzeichnet den Wert als real*8
</fortran>

=== Vergleich von Realzahlen ===
Momentan wird im Rechenkern mit unterschiedlichen Vergelichen gerechnet (global_fastnull etc.)

Momentaner Favorit ist: FortranEpsilonfürNull = 2 * Epsilon(...)

;Anmerkung: Im Code von BlueM sind ein paar nicht korrekte Anweisungen enthalten: MAX(dumdidum,global_FastNull). Korrekt ist MAX(dumdidum,0.0E0)

<fortran>
real*4 a
real*4 b
logical isNull

isNull =(a == b) !wird sogut wie nie erfüllt

isNull = (a - b < global_fastnull) !aktuell im Projekt verwendet

!Alternativen (zur Diskussion)

!isnull = (abs(a - b) < Epsilon(a)) ! nach Rechenoperationen erwies sich Epsilon als zu ungenau bzw. genau
!isnull = (abs(a/b-1.0E0) < eps) !Relativvergleich - führte bei Tests aber zu Fehlern

isNull = (abs(a-b) < SPACING(0.0E0))
</fortran>

==== Links: ====
Vergleich von Realwerten [http://hodgson.pi.tu-berlin.de/Lehre/EDV1/skripte/f95_skript/node56.html]
[http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231255.aspx|Aus dem intelforum]
Guter Artikel über Problemetik: [http://www.lahey.com/float.htm|The Perils of Floating Point]

[[Kategorie: Fortran]]]

FORTRAN

2008-08-12T07:41:12Z

Reussner: /* Fixed Form und Free Form */ reg. Expr.

== Fixed Form und Free Form ==
Die Free Form ist der Fixed Form der übersichtlichkeitshalber vorzuziehen. Ausserdem können bei der Fixed Form Fehler entstehen, die der compiler nicht abfängt (z. B. Formeln die über den Rand gehen - in SMUSI war beispielsweise eine Stelle, wo statt mit 300 nur mit 3 multipliziert wurde.

Für die Umstellung gibts hier eine regular Expression, die alle Zeilen anzeigt die länger als 72 Zeichen sind:

<pre>
^[^cC!][^!]^72
</pre>

== Real Werte und Vergleiche ==
Ein wichtiger Punkt bei der Programmierung mit Fortran ist die Behandlung der Real Werte. Insbesondere der vergleich, ob zwei Real Werte gelich sind, ist in FORTRAN nur durch eine erweiterte Syntax möglich.

=== Zuweisen von Werten: ===

<fortran>
real*4 a
real*8 b

a = 0.123e0 !das e0 kennzeichnet den Wert als real*4

b = 0.123d0 ! das d0 kennzeichnet den Wert als real*8
</fortran>

=== Vergleich von Realzahlen ===
Momentan wird im Rechenkern mit unterschiedlichen Vergelichen gerechnet (global_fastnull etc.)

Momentaner Favorit ist: FortranEpsilonfürNull = 2 * Epsilon(...)

;Anmerkung: Im Code von BlueM sind ein paar nicht korrekte Anweisungen enthalten: MAX(dumdidum,global_FastNull). Korrekt ist MAX(dumdidum,0.0E0)

<fortran>
real*4 a
real*4 b
logical isNull

isNull =(a == b) !wird sogut wie nie erfüllt

isNull = (a - b < global_fastnull) !aktuell im Projekt verwendet

!Alternativen (zur Diskussion)

!isnull = (abs(a - b) < Epsilon(a)) ! nach Rechenoperationen erwies sich Epsilon als zu ungenau bzw. genau
!isnull = (abs(a/b-1.0E0) < eps) !Relativvergleich - führte bei Tests aber zu Fehlern

isNull = (abs(a-b) < SPACING(0.0E0))
</fortran>

==== Links: ====
Vergleich von Realwerten [http://hodgson.pi.tu-berlin.de/Lehre/EDV1/skripte/f95_skript/node56.html]
[http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231255.aspx|Aus dem intelforum]
Guter Artikel über Problemetik: [http://www.lahey.com/float.htm|The Perils of Floating Point]

[[Kategorie: Fortran]]]

Steuern und Regeln

2008-07-30T13:52:10Z

Reussner: /* Status quo in BlueM */

[[Bild:Steuerung_Regelung.png|thumb|Steuerung vs. Regelung]]
Ein paar Dokumente für die gleiche Diskussionsgrundlage:
* http://de.wikipedia.org/wiki/Regelung_(Regelungstechnik)
* http://de.wikipedia.org/wiki/Steuern_(Systemtheorie)

==Status quo in BlueM==
[[Bild:KTR-Berechnung.png|thumb|left|Berechnungsablauf Kontrollfunktionen]]

* Momentan (r484) wird immer 2 Mal iteriert
* Die Systemzustände können im ersten Durchlauf auch zeitlich gemischt sein (aktueller zeitschritt und vorheriger).
So werden beim ersten Durchgang für Kontrollfunktionen, die zum Zeitpunkt der Berechnung des jeweiligen Elements
noch nicht berechnet werden können (bspw. weil von unterstrom gelegenen Systemzuständen abhängig),
als Schätzung die Kontrollfunktionswerte des vorherigen Zeitschritts verwendet.
* Es gibt keine Unterscheidung zwischen Reglung und Steuerung

Siehe auch Bug 341.

Steuern und Regeln

2008-07-29T13:56:31Z

Reussner: Die Seite wurde neu angelegt: Ein paar Dokumente für die gleiche Diskussionsgrundlage: http://de.wikipedia.org/wiki/Regelung_(Regelungstechnik) [[http://de.wikipedia.org/wiki/Steuern_(Systemth...

Ein paar Dokumente für die gleiche Diskussionsgrundlage:
[[http://de.wikipedia.org/wiki/Regelung_(Regelungstechnik)]]
[[http://de.wikipedia.org/wiki/Steuern_(Systemtheorie)]]

BlueM.DLLAdapter

2008-07-10T13:27:12Z

Reussner: /* Basismethoden */

'''BlueM.DLLAdapter''' ist ein .NET Wrapper zum Ansprechen des [[BlueM]] Rechenkerns in DLL-Form.

==Schnittstellendefinitionen==
[[Bild:BlueM DLL Wrapper.png|thumb|Klassendiagramm]]
Nachfolgend werden die Schnittstellen-Methoden zur Kommunikation mit der BlueM DLL mit den zugehörigen Übergabe- bzw. Rückgabeparametern aufgelistet.

Falls ein Fehler auftritt wird die Methode <code>CreateAndThrowException</code> aufgerufen (schmeisst einen Fehler).
===Basismethoden===
'''Initialize'''
<csharp>public void Initialize(string filePath)</csharp>
:<code>filePath</code> ist der Absolute Pfad mit dem Projektnamen ohne die Dateiendung <code>.ALL</code> (Bsp.: <code>"D:\Simulation\TSIM"</code>).
:Das System wird initialisiert und alle zugehörigen Daten aus den Simulationsdateien geladen.

'''PerformTimeStep'''
<csharp>public void PerformTimeStep()</csharp>
:Berechnet den nächsten Zeitschritt.

'''Finish / Dispose'''
<csharp>
public void Finish()
public void Dispose()
</csharp>
:Schliessen aller Dateien und Freigabe des Speichers

'''Datumsangaben'''
<csharp>
public DateTime GetCurrentTime()
public DateTime GetSimulationStartDate()
public DateTime GetSimulationEndDate()
</csharp>
:Was sind die Simulationszeiten (Anfang und Ende). Wo befinden wir uns gerade (GetCurrentTime) - wird nach jedem PerformTimeStep wietergeschoben.

==Anwendungsbeispiel==
Beispiel zur Nutzung des Bluem.DLLAdapters zur Simulation mittels BlueM.dll in VB.NET (Anwendung nur mit einer Simulation - ''SingleDLL''):
<vbnet>
'Einmal zu Beginn instanzieren
bluem_dll = New BlueM_EngineDotNetAccess("Pfad-zu-BlueM.dll")

...

Try

Call bluem_dll.Initialize("Pfad-zu-Datensatz")

Dim SimEnde As DateTime = BlueM_EngineDotNetAccess.DateTime(bluem_dll.GetSimulationEndDate())

'Schleife über Simulationszeitraum
Do While (BlueM_EngineDotNetAccess.DateTime(bluem_dll.GetCurrentTime) <= SimEnde)
Call bluem_dll.PerformTimeStep()
Loop

'Simulation abschliessen
Call bluem_dll.Finish()

'Simulation abgeschlossen
MsgBox("Simulation erfolgreich!", MsgBoxStyle.Information, "BlueM")

simOK = True

Catch ex As Exception

'Simulationsfehler aufgetreten
MsgBox(ex.Message, MsgBoxStyle.Exclamation, "BlueM")

'Simulation abschliessen
Call bluem_dll.Finish()

simOK = False

Finally

'Ressourcen deallokieren
Call bluem_dll.Dispose()

End Try
</vbnet>

[[Kategorie:BlueM Code]]

BlueM.DLLAdapter

2008-07-10T13:22:11Z

Reussner: /* Anwendungsbeispiel */ SingleDLL

'''BlueM.DLLAdapter''' ist ein .NET Wrapper zum Ansprechen des [[BlueM]] Rechenkerns in DLL-Form.

==Schnittstellendefinitionen==
[[Bild:BlueM DLL Wrapper.png|thumb|Klassendiagramm]]
Nachfolgend werden die Schnittstellen-Methoden zur Kommunikation mit der BlueM DLL mit den zugehörigen Übergabe- bzw. Rückgabeparametern aufgelistet.

Falls ein Fehler auftritt wird die Methode <code>CreateAndThrowException</code> aufgerufen (schmeisst einen Fehler).
===Basismethoden===
'''Initialize'''
<csharp>public void Initialize(string filePath)</csharp>
:<code>filePath</code> ist der Absolute Pfad mit dem Projektnamen ohne die Dateiendung <code>.ALL</code> (Bsp.: <code>"D:\Simulation\TSIM"</code>).
:Das System wird initialisiert und alle zugehörigen Daten aus den Simulationsdateien geladen.

'''PerformTimeStep'''
<csharp>public void PerformTimeStep()</csharp>
:Berechnet den nächsten Zeitschritt.

'''Finish / Dispose'''
<csharp>
public void Finish()
public void Dispose()
</csharp>
:Schliessen aller Dateien und Freigabe des Speichers

==Anwendungsbeispiel==
Beispiel zur Nutzung des Bluem.DLLAdapters zur Simulation mittels BlueM.dll in VB.NET (Anwendung nur mit einer Simulation - ''SingleDLL''):
<vbnet>
'Einmal zu Beginn instanzieren
bluem_dll = New BlueM_EngineDotNetAccess("Pfad-zu-BlueM.dll")

...

Try

Call bluem_dll.Initialize("Pfad-zu-Datensatz")

Dim SimEnde As DateTime = BlueM_EngineDotNetAccess.DateTime(bluem_dll.GetSimulationEndDate())

'Schleife über Simulationszeitraum
Do While (BlueM_EngineDotNetAccess.DateTime(bluem_dll.GetCurrentTime) <= SimEnde)
Call bluem_dll.PerformTimeStep()
Loop

'Simulation abschliessen
Call bluem_dll.Finish()

'Simulation abgeschlossen
MsgBox("Simulation erfolgreich!", MsgBoxStyle.Information, "BlueM")

simOK = True

Catch ex As Exception

'Simulationsfehler aufgetreten
MsgBox(ex.Message, MsgBoxStyle.Exclamation, "BlueM")

'Simulation abschliessen
Call bluem_dll.Finish()

simOK = False

Finally

'Ressourcen deallokieren
Call bluem_dll.Dispose()

End Try
</vbnet>

[[Kategorie:BlueM Code]]

FORTRAN

2008-06-25T13:02:50Z

Reussner: /* Vergleich von Realzahlen */

== Real Werte und Vergleiche ==
Ein wichtiger Punkt bei der Programmierung mit Fortran ist die Behandlung der Real Werte. Insbesondere der vergleich, ob zwei Real Werte gelich sind, ist in FORTRAN nur durch eine erweiterte Syntax möglich.

=== Zuweisen von Werten: ===

<fortran>
real*4 a
real*8 b

a = 0.123e0 !das e0 kennzeichnet den Wert als real*4

b = 0.123d0 ! das d0 kennzeichnet den Wert als real*8
</fortran>

=== Vergleich von Realzahlen ===
Momentan wird im Rechenkern mit unterschiedlichen Vergelichen gerechnet (global_fastnull etc.)

Momentaner Favorit ist: FortranEpsilonfürNull = 2 * Epsilon(...)

;Anmerkung: Im Code von BlueM sind ein paar nicht korrekte Anweisungen enthalten: MAX(dumdidum,global_FastNull). Korrekt ist MAX(dumdidum,0.0E0)

<fortran>
real*4 a
real*4 b
logical isNull

isNull =(a == b) !wird sogut wie nie erfüllt

isNull = (a - b < global_fastnull) !aktuell im Projekt verwendet

!Alternativen (zur Diskussion)

!isnull = (abs(a - b) < Epsilon(a)) ! nach Rechenoperationen erwies sich Epsilon als zu ungenau bzw. genau
!isnull = (abs(a/b-1.0E0) < eps) !Relativvergleich - führte bei Tests aber zu Fehlern

isNull = (abs(a-b) < SPACING(0.0E0))
</fortran>

==== Links: ====
Vergleich von Realwerten [http://hodgson.pi.tu-berlin.de/Lehre/EDV1/skripte/f95_skript/node56.html]
[http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231255.aspx|Aus dem intelforum]
Guter Artikel über Problemetik: [http://www.lahey.com/float.htm|The Perils of Floating Point]

[[Kategorie: Fortran]]]

FORTRAN

2008-06-25T12:01:57Z

Reussner: /* Real Werte und Vergleiche */

== Real Werte und Vergleiche ==
Ein wichtiger Punkt bei der Programmierung mit Fortran ist die Behandlung der Real Werte. Insbesondere der vergleich, ob zwei Real Werte gelich sind, ist in FORTRAN nur durch eine erweiterte Syntax möglich.

=== Zuweisen von Werten: ===

<fortran>
real*4 a
real*8 b

a = 0.123e0 !das e0 kennzeichnet den Wert als real*4

b = 0.123d0 ! das d0 kennzeichnet den Wert als real*8
</fortran>

=== Vergleich von Realzahlen ===
Momentan wird im Rechenkern mit unterschiedlichen Vergelichen gerechnet (global_fastnull etc.)

Mit Epsilon() kommt man wohl nicht zum ZIEL, da sich Epsilon laut Dr. Fortran an der 1.0 orientiert [http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231255.aspx|siehe hier].
Dr. Fortran schlägt Spacing() vor! Allerdings sollten wir dann überprüfen ob wir gegen Null checken wollen oder zwei Werte vergleichen. Bei letzterem können wir auch das Spacing() zurückgreifen.

<fortran>
real*4 a
real*4 b
logical isNull

isNull =(a == b) !wird sogut wie nie erfüllt

isNull = (a - b < global_fastnull) !aktuell im Projekt verwendet

!Alternativen (zur Diskussion)

!isnull = (abs(a - b) < Epsilon(a)) ! nach Rechenoperationen erwies sich Epsilon als zu ungenau bzw. genau
!isnull = (abs(a/b-1.0E0) < eps) !Relativvergleich - führte bei Tests aber zu Fehlern

isNull = (abs(a-b) < SPACING(0.0E0))
</fortran>

==== Links: ====
Vergleich von Realwerten [http://hodgson.pi.tu-berlin.de/Lehre/EDV1/skripte/f95_skript/node56.html]
[http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231255.aspx|Aus dem intelforum]
Guter Artikel über Problemetik: [http://www.lahey.com/float.htm|The Perils of Floating Point]

[[Kategorie: Fortran]]]

FORTRAN

2008-06-25T11:49:18Z

Reussner: /* Vergleich von Realzahlen */ +++ no Epsilon +++ now Spacing +++

== Real Werte und Vergleiche ==
Ein wichtiger Punkt bei der Programmierung mit Fortran ist die Behandlung der Real Werte. Insbesondere der vergleich, ob zwei Real Werte gelich sind, ist in FORTRAN nur durch eine erweiterte Syntax möglich.

=== Zuweisen von Werten: ===

<fortran>
real*4 a
real*8 b

a = 0.123e0 !das e0 kennzeichnet den Wert als real*4

b = 0.123d0 ! das d0 kennzeichnet den Wert als real*8
</fortran>

=== Vergleich von Realzahlen ===
Momentan wird im Rechenkern mit unterschiedlichen Vergelichen gerechnet (global_fastnull etc.)

Mit Epsilon() kommt man wohl nicht zum ZIEL, da sich Epsilon laut dr. Fortran an der 1.0 orientiert [http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231255.aspx].
Dr. Fortran schlägt Spacing() vor! Allerdings sollten wir dann überprüfen ob wir gegen Null checken wollen oder zwei Werte vergleichen. Bei letzterem können wir auch das Spacing() zurückgreifen.

<fortran>
real*4 a
real*4 b
logical isNull

isNull =(a == b) !wird sogut wie nie erfüllt

isNull = (a - b < global_fastnull) !aktuell im Projekt verwendet

!Alternativen (zur Diskussion)

!isnull = (abs(a - b) < Epsilon(a)) ! nach Rechenoperationen erwies sich Epsilon als zu ungenau bzw. genau
!isnull = (abs(a/b-1.0E0) < eps) !Relativvergleich - führte bei Tests aber zu Fehlern

isNull = (abs(a-b) < SPACING(0.0E0))
</fortran>

=== Links: ===
Vergleich von Realwerten [http://hodgson.pi.tu-berlin.de/Lehre/EDV1/skripte/f95_skript/node56.html]

[[Kategorie: Fortran]]]

FORTRAN

2008-06-24T14:18:26Z

Reussner: /* Vergleich von Realzahlen */ Epsilon-Methode

FORTRAN

2008-06-24T14:08:03Z

Reussner: /* Vergleich von Realzahlen */

FORTRAN

2008-06-24T10:39:54Z

Reussner: /* Vergleich von Realzahlen */

FORTRAN

2008-06-24T09:44:16Z

Reussner: Besonderheiten von Realwerten in Fortran

DLL-Methoden hinzufügen (.NET 2 FORTRAN)

2008-06-24T09:42:15Z

Reussner: /* Hinzufügen der neuen Methode in der BlueM Fortran-DLL */

<div style="float:left; margin-right:10px">__TOC__</div>
<big> Anleitung für das Hinzufügen neuer Methoden in eine Modell-DLL (am Beispiel von [[BlueM]]) </big><br clear="all"/>

== Hinzufügen der neuen Methode in der BlueM Fortran-DLL ==

<fortran>
logical function GetModelDescription(Description)
!DEC$ ATTRIBUTES DLLEXPORT :: GETMODELDESCRIPTION
character(*) Description
...
end function
</fortran>
* Funktionsname und DLLEXPORT-Name müssen gleich sein !
* Übergabeparameter müssen definiert sein (und die Typen sollten so einfach wie möglich sein) !

; Tip : Kontrollieren, ob der Export funktioniert hat, kann man mit dem DependencyWalker des Visual Studios <br/><code>C:\Programme\Microsoft Visual Studio 8\Common7\Tools\Bin\Depends.Exe</code>. <br/>Dort werden alle exportierte Methoden aufgelistet.

[[Kategorie:Fortran]]

== Erweiterung des [[BlueM.DLLAdapter|DLL-Wrappers]] (C#) ==
Die Methoden der DLL werden aus der Klasse <code>DLLMethoden</code> aufgerufen.

# Hinzufügen des Delegats in DLLMethoden
# Hinzufügen der Schnittstellenmethode
# Hinzufügen einer Testmethode [[UnitTest]]

<csharp>
public class DLLMethoden
{
...
delegate bool GetModelDescriptionDelegate([MarshalAs(UnmanagedType.LPStr)] StringBuilder description, uint length);
...
public bool GetModelDescription(StringBuilder description, uint length)
{
if (myDll == IntPtr.Zero)
InitializeMyDll(pathToDll);
IntPtr pProc = DllImportDynamic.GetProcAddress(myDll, "OPENMI_mp_GETMODELDESCRIPTION");
GetModelDescriptionDelegate cpv = (GetModelDescriptionDelegate)Marshal.GetDelegateForFunctionPointer(pProc, typeof(GetModelDescriptionDelegate));
return cpv(description, (uint)description.Length);
}
...
}
</csharp>

==== Delegate ====
Eine Delegatmethode ist eine Art "Platzhalter". in diesem Beispiel fungiert sie als Platzhalter für die Fortran-DLL. Sie hat die selben Übergabeparameter wie in der Fortran-DLL beschrieben - Ausnahme sind Zeichenketten (Siehe [[#Marshaling|Marshaling]]).

==== Marshaling ====
* Um Typensicherheit zu gewährleiseten, gibt es in .NET die Attributsklasse <code>MarshalAs</code>. Über diese Klasse können Typen aus unmanaged Code und dem .NET Code ausgetauscht werden - z.B. <code>r8</code> und <code>double</code> oder wie bei <code>GetModelDescriptionDelegate</code> eine Zeichenkette (<code>LPStr</code>/<code>StringBuilder</code>):
<csharp> [MarshalAs(UnmanagedType.LPStr)] StringBuilder description </csharp>
* Um eine Zeichenkette mit der Fortran-DLL auszutauschen, muss zu dem inhalt immer auch die Länge des Strings angegeben werden:
<csharp> uint length </csharp>

==== Aufruf der DLL-Methode ====
<csharp>IntPtr pProc = DllImportDynamic.GetProcAddress(myDll, "OPENMI_mp_GETMODELDESCRIPTION");</csharp>
Holt sich die Einsprungadresse der DLL_Methode.
<csharp>GetModelDescriptionDelegate cpv = (GetModelDescriptionDelegate)Marshal.GetDelegateForFunctionPointer(pProc, typeof(GetModelDescriptionDelegate));</csharp>
Die Einsprungadresse und der "Platzhalter" werden miteinander verknüpft. Nun kann man einfach die Delegatmethode mit den entsprechenden Parametern aufrufen:
<csharp>cpv(description, (uint)description.Length);</csharp>

[[Kategorie:OpenMI]]
[[Kategorie:Hilfe]]
[[Kategorie:BlueM Code]]
[[Kategorie:BlueM Entwicklung]]

Fortran: Lahey LF90

2008-06-24T09:41:44Z

Reussner: /* Fortran Compiler Lahey LF90 */

== Fortran Compiler Lahey LF90 ==

=== DLL erstellen ===
Automake-Datei:

<fortran>
QUITONERROR
DEBUG
FILES=*.for
COMPILE=@lf90 -ap -chk -g -co -f90 -lst -pca -sav -stchk -trace -w -wo -xref -c %fi -DLL -WIN -ML WINAPI

LINK=@lf90 @%rf -dll -out %ex -ml winapi -fullwarn -g
TARGET=Target.dll
</fortran>

;TIP: Es können mit LF90 keine Proceduren eines Moduls exportiert werden ! Deshalb eigene Subroutine/Funktion mit Modulproceduraufruf implementieren.
Gültige Schnittstellendefinitionen mit LF90
<fortran>
subroutine TEST_MODULE()
USE MOD_BLABLA
DLL_EXPORT TEST_MODULE
call BLABLA_Procedure()
end subroutine

subroutine TEST_dlL()
DLL_EXPORT TEST_dll
end subroutine

function TEST_FUNCT()
LOGICAL :: TEST_FUNCT
DLL_EXPORT TEST_FUNCT
end function

LOGICAL function TEST_FUNCT2()
DLL_EXPORT TEST_FUNCT2
TEST_FUNCT2 = .true.
end function

LOGICAL function TEST_UEBERGABE_Z(Zahl)
USE MOD_SCHNITTSTELLE
DLL_EXPORT TEST_UEBERGABE_Z
INTEGER Zahl
TEST_UEBERGABE_Z = .true.
end function

LOGICAL function TEST_UEBERGABE_C(str)
USE MOD_SCHNITTSTELLE
DLL_EXPORT TEST_UEBERGABE_C
CHARACTER(1024) str
TEST_UEBERGABE_C = .true.
end function

LOGICAL function TEST_UEBERGABE_C2(str)
USE MOD_SCHNITTSTELLE
DLL_EXPORT TEST_UEBERGABE_C2
CHARACTER(*) str
TEST_UEBERGABE_C2 = .true.
end function
</fortran>

;TIP: Aufpassen manchmal sind die exportierten Methdoden "case sensitive" !!!

[[Kategorie:OpenMI]]
[[Kategorie:Hilfe]]
[[Kategorie:DLL]]
[[Kategorie:SMUSI]]
[[Kategorie:Fortran]]

Weitergabe Stoffe

2008-06-16T08:31:07Z

Reussner: /* Zuflüsse und Aktionen - Gütemodell */

==Stoffweitergabe von Element zu Element ==
* Angeschlossenes Gütemodell ist laPipe.dll
* Ein Gütemodell mit vielen Wasserschleifen ist generiert
=== Prozess zur Weitergabe der Informationen/Konzentrationen ===
==== Weitergabe Optionen ====
* Verfügbare Optionen in laPipe
** Add : hinzufügen neuer Volumen (mit Konzentration)
** Remove : entfernen von Volumen
** moveNode : von Wasserschlange zu Wasserschlange (1:1)
** moveLink : von Wasserschlange zu Wasserschlange (n:m)
* fehlende Option
** '''Add und moveNode/moveLink als Kombination'''
==== Weitergabeprozess ====
Siehe auch [[#Zuflüsse und Aktionen - Gütemodell|Zuflüsse und Aktionen - Gütemodell]]

* Anwendungsfälle
{| border="1"
|+ Anwendungsfälle Stoffweitergabe von Knoten zu Knoten
! Von KnotenArt!! Zu KnotenArt !! Aktion des ZU-Knotens
|-
|X
|TRS
|Add
|-
|TRS
|TRS
|moveNode
|-
|(n) TRS
|X
|removeVol
|-
|n TRS
|TRS
|moveLink
|-
|n TRS + X
|TRS
|moveLink + ADD ??? (Dies wird wohl der Standardfall bei einer Einleitung aus SMUSI sein)
|}
** X : irgendein nicht im Gütemodell enthaltener Knoten (z.B. EZG, Becken, Zielpegel etc.)
** TRS : Knoten der mit dem Gütemodell als Wasserschlange modelliert wird
** n TRS : Mehrere Knoten des Typs TRS

* von wo aus wird der Prozess angeschmissen ?
** vom oberen Element aus
*** [[Bild:Stoffweitergabe vonoben.jpg|thumb|none|500px]]
*** Nachteil: Es müssen mitunter Zwei Aktionen ausgeführt werden (z. B. add/moveNode)
** vom unteren Element aus
*** [[Bild:Stoffweitergabe vonUnten.jpg|thumb|none|500px]]
* offene Punkte
** Zufluss und Abfluss im selben Zeitschritt verwenden ?

== Zuflüsse und Aktionen - Gütemodell ==

S : Sonstiges Element
T : Transportelement (alle als Wasserschlange abgebildeten Elemente)
Beispiel ST = Sonstiges in Transportelement

{| border="1"
|+ EINFACHE KOMBINATIONEN
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||SS || -
|-
|2. ||- ||-
|-
|3. || - ||-
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||ST ||ADD
|-
|2. || - ||-
|-
|3. || - || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||TS ||REMOVE
|-
|2. || - || -
|-
|3. || - || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||TT ||MoveNode
|-
|2. || - || -
|-
|3. || - || -
|}

{| border="1"
|+ METAKOMBINATIONEN EINFACH
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||TT ||MoveLink
|-
|2. ||TT || -
|-
|3. ||TT ||-
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||TS ||REMOVE ||Wäre Schön wenn man das auch als MEGAREMOVE hat
|-
|2. ||TS ||REMOVE
|-
|3. ||TS ||REMOVE
|}

{| border="1"
|+ METAKOMBINATIONEN noch nicht in Gütemodell
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||ST ||MEGAADD
|-
|2. ||ST || -
|-
|3. ||ST || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||TT ||MOVENODEplusMEGAADD
|-
|2. ||ST || -
|-
|3. ||ST || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||TT ||MOVELINKplusADD
|-
|2. ||TT || -
|-
|3. ||ST ||-
|}

;Anmerkung: Nach Diskussion mit IFAK: Übergabe bei MegaADD MoveNodeplusMegaAdd etc. wird erstmal ein Mechanismus REMOVE&ADD getestet. Sollte die auftretende numerische Dispersion zu stark ins Gewicht fallen, muss DANN ein neuer Mechanismus entwickelt werden.

[[Category:Gütemodell]]

Weitergabe Stoffe

2008-06-16T08:28:58Z

Reussner: /* Weitergabeprozess */ verlinkung

==Stoffweitergabe von Element zu Element ==
* Angeschlossenes Gütemodell ist laPipe.dll
* Ein Gütemodell mit vielen Wasserschleifen ist generiert
=== Prozess zur Weitergabe der Informationen/Konzentrationen ===
==== Weitergabe Optionen ====
* Verfügbare Optionen in laPipe
** Add : hinzufügen neuer Volumen (mit Konzentration)
** Remove : entfernen von Volumen
** moveNode : von Wasserschlange zu Wasserschlange (1:1)
** moveLink : von Wasserschlange zu Wasserschlange (n:m)
* fehlende Option
** '''Add und moveNode/moveLink als Kombination'''
==== Weitergabeprozess ====
Siehe auch [[#Zuflüsse und Aktionen - Gütemodell|Zuflüsse und Aktionen - Gütemodell]]

* Anwendungsfälle
{| border="1"
|+ Anwendungsfälle Stoffweitergabe von Knoten zu Knoten
! Von KnotenArt!! Zu KnotenArt !! Aktion des ZU-Knotens
|-
|X
|TRS
|Add
|-
|TRS
|TRS
|moveNode
|-
|(n) TRS
|X
|removeVol
|-
|n TRS
|TRS
|moveLink
|-
|n TRS + X
|TRS
|moveLink + ADD ??? (Dies wird wohl der Standardfall bei einer Einleitung aus SMUSI sein)
|}
** X : irgendein nicht im Gütemodell enthaltener Knoten (z.B. EZG, Becken, Zielpegel etc.)
** TRS : Knoten der mit dem Gütemodell als Wasserschlange modelliert wird
** n TRS : Mehrere Knoten des Typs TRS

* von wo aus wird der Prozess angeschmissen ?
** vom oberen Element aus
*** [[Bild:Stoffweitergabe vonoben.jpg|thumb|none|500px]]
*** Nachteil: Es müssen mitunter Zwei Aktionen ausgeführt werden (z. B. add/moveNode)
** vom unteren Element aus
*** [[Bild:Stoffweitergabe vonUnten.jpg|thumb|none|500px]]
* offene Punkte
** Zufluss und Abfluss im selben Zeitschritt verwenden ?

== Zuflüsse und Aktionen - Gütemodell ==

S : Sonstiges Element
T : Transportelement (alle als Wasserschlange abgebildeten Elemente)
Beispiel ST = Sonstiges in Transportelement

{| border="1"
|+ EINFACHE KOMBINATIONEN
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||SS || -
|-
|2. ||- ||-
|-
|3. || - ||-
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||ST ||ADD
|-
|2. || - ||-
|-
|3. || - || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TS ||REMOVE
|-
|2. || - || -
|-
|3. || - || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TT ||MoveNode
|-
|2. || - || -
|-
|3. || - || -
|}

{| border="1"
|+ METAKOMBINATIONEN EINFACH
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TT ||MoveLink
|-
|2. ||TT || -
|-
|3. ||TT ||-
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TS ||REMOVE ||Wäre Schön wenn man das auch als MEGAREMOVE hat
|-
|2. ||TS ||REMOVE
|-
|3. ||TS ||REMOVE
|}

{| border="1"
|+ METAKOMBINATIONEN noch nicht in Gütemodell
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||ST ||MEGAADD
|-
|2. ||ST || -
|-
|3. ||ST || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TT ||MOVENODEplusMEGAADD
|-
|2. ||ST || -
|-
|3. ||ST || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||TT ||MOVELINKplusADD
|-
|2. ||TT || -
|-
|3. ||ST ||-
|}

;Anmerkung: Nach Diskussion mit IFAK: Übergabe bei MegaADD MoveNodeplusMegaAdd etc. wird erstmal ein Mechanismus REMOVE&ADD getestet. Sollte die auftretende numerische Dispersion zu stark ins Gewicht fallen, muss DANN ein neuer Mechanismus entwickelt werden.

[[Category:Gütemodell]]

Weitergabe Stoffe

2008-06-16T08:26:44Z

Reussner: /* Zuflüsse und Aktionen - Gütemodell */ Verbesserung Tabelle + Anmerkungen zu Metakombinationen

==Stoffweitergabe von Element zu Element ==
* Angeschlossenes Gütemodell ist laPipe.dll
* Ein Gütemodell mit vielen Wasserschleifen ist generiert
=== Prozess zur Weitergabe der Informationen/Konzentrationen ===
==== Weitergabe Optionen ====
* Verfügbare Optionen in laPipe
** Add : hinzufügen neuer Volumen (mit Konzentration)
** Remove : entfernen von Volumen
** moveNode : von Wasserschlange zu Wasserschlange (1:1)
** moveLink : von Wasserschlange zu Wasserschlange (n:m)
* fehlende Option
** '''Add und moveNode/moveLink als Kombination'''
==== Weitergabeprozess ====
* Anwendungsfälle
{| border="1"
|+ Anwendungsfälle Stoffweitergabe von Knoten zu Knoten
! Von KnotenArt!! Zu KnotenArt !! Aktion des ZU-Knotens
|-
|X
|TRS
|Add
|-
|TRS
|TRS
|moveNode
|-
|(n) TRS
|X
|removeVol
|-
|n TRS
|TRS
|moveLink
|-
|n TRS + X
|TRS
|moveLink + ADD ??? (Dies wird wohl der Standardfall bei einer Einleitung aus SMUSI sein)
|}
** X : irgendein nicht im Gütemodell enthaltener Knoten (z.B. EZG, Becken, Zielpegel etc.)
** TRS : Knoten der mit dem Gütemodell als Wasserschlange modelliert wird
** n TRS : Mehrere Knoten des Typs TRS

* von wo aus wird der Prozess angeschmissen ?
** vom oberen Element aus
*** [[Bild:Stoffweitergabe vonoben.jpg|thumb|none|500px]]
*** Nachteil: Es müssen mitunter Zwei Aktionen ausgeführt werden (z. B. add/moveNode)
** vom unteren Element aus
*** [[Bild:Stoffweitergabe vonUnten.jpg|thumb|none|500px]]
* offene Punkte
** Zufluss und Abfluss im selben Zeitschritt verwenden ?

== Zuflüsse und Aktionen - Gütemodell ==

S : Sonstiges Element
T : Transportelement (alle als Wasserschlange abgebildeten Elemente)
Beispiel ST = Sonstiges in Transportelement

{| border="1"
|+ EINFACHE KOMBINATIONEN
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||SS || -
|-
|2. ||- ||-
|-
|3. || - ||-
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||ST ||ADD
|-
|2. || - ||-
|-
|3. || - || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TS ||REMOVE
|-
|2. || - || -
|-
|3. || - || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TT ||MoveNode
|-
|2. || - || -
|-
|3. || - || -
|}

{| border="1"
|+ METAKOMBINATIONEN EINFACH
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TT ||MoveLink
|-
|2. ||TT || -
|-
|3. ||TT ||-
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TS ||REMOVE ||Wäre Schön wenn man das auch als MEGAREMOVE hat
|-
|2. ||TS ||REMOVE
|-
|3. ||TS ||REMOVE
|}

{| border="1"
|+ METAKOMBINATIONEN noch nicht in Gütemodell
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||ST ||MEGAADD
|-
|2. ||ST || -
|-
|3. ||ST || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TT ||MOVENODEplusMEGAADD
|-
|2. ||ST || -
|-
|3. ||ST || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||TT ||MOVELINKplusADD
|-
|2. ||TT || -
|-
|3. ||ST ||-
|}

;Anmerkung: Nach Diskussion mit IFAK: Übergabe bei MegaADD MoveNodeplusMegaAdd etc. wird erstmal ein Mechanismus REMOVE&ADD getestet. Sollte die auftretende numerische Dispersion zu stark ins Gewicht fallen, muss DANN ein neuer Mechanismus entwickelt werden.

[[Category:Gütemodell]]

Weitergabe Stoffe

2008-06-12T14:13:08Z

Reussner: /* Weitergabeprozess */

==Stoffweitergabe von Element zu Element ==
* Angeschlossenes Gütemodell ist laPipe.dll
* Ein Gütemodell mit vielen Wasserschleifen ist generiert
=== Prozess zur Weitergabe der Informationen/Konzentrationen ===
==== Weitergabe Optionen ====
* Verfügbare Optionen in laPipe
** Add : hinzufügen neuer Volumen (mit Konzentration)
** Remove : entfernen von Volumen
** moveNode : von Wasserschlange zu Wasserschlange (1:1)
** moveLink : von Wasserschlange zu Wasserschlange (n:m)
* fehlende Option
** '''Add und moveNode/moveLink als Kombination'''
==== Weitergabeprozess ====
* Anwendungsfälle
{| border="1"
|+ Anwendungsfälle Stoffweitergabe von Knoten zu Knoten
! Von KnotenArt!! Zu KnotenArt !! Aktion des ZU-Knotens
|-
|X
|TRS
|Add
|-
|TRS
|TRS
|moveNode
|-
|(n) TRS
|X
|removeVol
|-
|n TRS
|TRS
|moveLink
|-
|n TRS + X
|TRS
|moveLink + ADD ??? (Dies wird wohl der Standardfall bei einer Einleitung aus SMUSI sein)
|}
** X : irgendein nicht im Gütemodell enthaltener Knoten (z.B. EZG, Becken, Zielpegel etc.)
** TRS : Knoten der mit dem Gütemodell als Wasserschlange modelliert wird
** n TRS : Mehrere Knoten des Typs TRS

* von wo aus wird der Prozess angeschmissen ?
** vom oberen Element aus
*** [[Bild:Stoffweitergabe vonoben.jpg|thumb|none|500px]]
*** Nachteil: Es müssen mitunter Zwei Aktionen ausgeführt werden (z. B. add/moveNode)
** vom unteren Element aus
*** [[Bild:Stoffweitergabe vonUnten.jpg|thumb|none|500px]]
* offene Punkte
** Zufluss und Abfluss im selben Zeitschritt verwenden ?

== Zuflüsse und Aktionen - Gütemodell ==

S : Sonstiges Element
T : Transportelement (alle als Wasserschlange abgebildeten Elemente)
Beispiel ST = Sonstiges in Transportelement

{| border="1"
|+ EINFACHE KOMBINATIONEN
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||SS || -
|-
|2. ||- ||-
|-
|3. || - ||-
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||ST ||ADD
|-
|2. || - ||-
|-
|3. || - || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TS ||REMOVE
|-
|2. || - || -
|-
|3. || - || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TT ||MoveNode
|-
|2. || - || -
|-
|3. || - || -
|}

{| border="1"
|+ METAKOMBINATIONEN EINFACH
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TT ||MoveLink
|-
|2. ||TT || -
|-
|3. ||TT ||-
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TS ||REMOVE ||Wäre Schön wenn man das auch als MEGAREMOVE hat
|-
|2. ||TS ||REMOVE
|-
|3. ||TS ||REMOVE
|}

{| border="1"
|+ METAKOMBINATIONEN noch nicht in Gütemodell
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||ST ||MEGAADD
|-
|2. ||ST || -
|-
|3. ||ST || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion

|-
|1. ||TT ||MOVENODEplusMEGAADD
|-
|2. ||TS || -
|-
|3. ||TS || -
|}

{| border="1"
|+
! elementindex!! Zuflusskombi !! Aktion
|-
|1. ||TT ||MOVELINKplusADD
|-
|2. ||TT || -
|-
|3. ||TS ||-
|}

[[Category:Gütemodell]]

Weitergabe Stoffe

2008-06-12T09:53:23Z

Reussner: /* Weitergabeprozess */