Inhaltsverzeichnis 1 JAMS Komponenten-API 1.1 JAMS Datentypen 1.2 JAMS Komponenten 1.3 JAMS Kontextkomponenten 1.4 Input/Output von JAMS-Daten 2 Entwicklung von JAMS Komponenten 2.1 Einrichten einer Entwicklungsumgebung 2.2 JAMS/J2000 Quellen aus dem Internet laden 2.3 Projekte in NetBeans anlegen 2.3.1 1. Schritt - Einbinden des Projektes JAMS 2.3.2 2. Schritt - Einbinden des Projektes J2000 2.3.3 3. Schritt - Einbinden des Projektes JAMSComponents 2.3.4 Starten von Prozesskomponenten aus dem NetBeans 2.4 Main Klassen 2.5 Entwicklung neuer Prozesskomponenten in JAVA 2.5.1 Aufbau einer Komponente 2.5.2 Beispiel einer vollständigen Prozesskomponente 2.6 Entwicklung und Implementierung von JAMS-Kontextkomponenten 2.7 Integration neuer Prozesskomponenten in JAMS oder J2000 Bibliotheken 2.8 Integration und Test neuer (Kontext-)Komponenten 2.9 Debugging und Profiling von Modellen in JAMS 2.9.1 Debugging 2.9.2 Profiling im Netbeans

JAMS Komponenten-API

JAMS Datentypen

Die folgenden JAMS-Datentypen stehen zur Verfügung

• Attribute.Boolean
• Attribute.BooleanArray
• Attribute.Calendar
• Attribute.DirName
• Attribute.Document
• Attribute.Double
• Attribute.DoubleArray
• Attribute.Entity
• Attribute.EntityCollection
• Attribute.FileName
• Attribute.Float
• Attribute.FloatArray
• Attribute.Geometry
• Attribute.Interger
• Attribute.IntegerArray
• Attribute.Long
• Attribute.LongArray
• Attribute.Object
• Attribute.String
• Attribute.StringArray
• Attribute.TimeIntervall

JAMS Komponenten

Der wichtigste Baustein eines JAMS-Modells wird Komponente genannt. Eine Komponente ist eine JAVA-Klasse, die drei verschiedene Methoden anwendet (d.h. init, run und cleanup), die in entsprechende Laufzeitphasen ausgelöst werden, durch die ein JAMS-Modell iteriert. Wie ihre Namen sagen, werden diese Methoden am Anfang, während und am Ende der Lebenszeit einer Komponente aufgerufen. Während die init- und clean-Methode nur einmal ausgeführt werden, kann die run-Methode mehrmals aufgerufen werden, abhängig vom Zweck und der Konfiguration der Komponente.

Die Kommunikation mit dem Framework und anderen Komponenten wird durch willkürliche öffentliche Attribute übernommen, die zwei Bedingungen erfüllen: (i) sie bestehen aus einem validen JAMS-Datentyp und (ii) sie sind durch spezielle JAVA-Annotationen gekennzeichnet, d.h. syntaktische Metainformation. Diese Attribut-Annotationen werden gebraucht, um Folgendes zu definieren: ihren I/O-Typ (read, write), ihre Standardwerte, die physikalische Einheit und Grenzen (wenn numerisch) und einen kurzen Text, der den Zweck des Attributs beschreibt. Diese Informationen werden einerseits dafür genutzt, dass das Laufzeitsystem Attribute erstellen und verbinden kann und dass GUIs während des Modelldesigns Hilfe bieten können.

JAMS Kontextkomponenten

Ein JAMS-Kontext ist eine spezielle, aus mehreren Teilen bestehende Komponente, die andere Komponenten und Kontexte ineinanderfügen kann, die dann Kinder genannt werden. Ein Kontext erfüllt zwei Hauptzwecke: (i) er kontrolliert die Ausführung seiner Kinder und (ii) dient als Datenspeicher für seine Kinder, womit flexibler Datenaustausch zwischen ihnen ermöglicht wird. Je nach dem Zweck eines gegebenen Kontextes kann er seine Kinder mehrere Male über mehrere Iterationen aufrufen (Bild links), aber nur einmal, wenn eine vorher festgelegte Bedingung erfüllt ist (Bild Mitte) oder nur einmal in einer Sequenz (Bild rechts). Da Kontexte spezialisierte Komponenten sind, können sie in andere Kontexte integriert sein, was die Herausbildung von komplexen Komponentenhierarchien und Strukturen zur Ausführungskontrolle. Die folgende Abbildung zeigt Kontextbeispiele.

Input/Output von JAMS-Daten

I/O-Daten in JAMS können auf zwei verschiedenen Wegen bearbeitet werden. Als erste Option kann die Komponente benutzt werden, um Daten aus jeglicher Datenquelle zu lesen und zu schreiben, z.B. Dateien oder Datenbanken. In diesem Fall muss der Entwickler der Komponente darauf achten, alle nötigen Informationen über die Eingabedaten der Komponente zu erhalten (z.B. Dateinamen), Zugriff auf die Datenquelle zu haben und potentielle Ergebnisse (z.B. Daten aus einer Datei lesen) als Ausgabedaten. Ein Vorteil dieses Ansatzes ist eine hohe Flexibilität, um auf externe Daten zuzugreifen. Auf der anderen Seite müssen solche Komponenten normalerweise an bestimmte Modelle und Datenformate angepasst werden, was ihre Wiederverwendbarkeit beschränkt.

Die zweite Option zur Bearbeitung von Datenaustausch in JAMS ist der Einsatz der DataStore Software-Oberfläche. Diese Oberfläche kann genutzt werden, um Daten von/zu einer externen Datenablage zu lesen/schreiben; diese Ablage kann eine Datei, ein Datenbanksystem oder eine Netzwerkressource sein. Es stellt Funktionen zum Lesen und Schreiben von Datensätzen bereit, wovon jede durch eine geordnete Liste von Datenobjekten dargestellt wird. Die Datenobjekte werden durch Metadaten beschrieben, was z.B. ihren Datentyp, Grenzwerte und ihre Bedeutung beinhaltet. Die folgende Abbildung gibt einen Überblick über die Struktur des JAMS DataStore, wobei zwei DataStore-Typen für das Auslesen (InputDataStore) und für das Schreiben (OutputDataStore) von Daten gezeigt werden. Im Falle des InputDataStore können die Methoden genutzt werden, um verfügbare Daten (DataSet) zu erfragen (hasNext) und zu wiederherzustellen (getNext). Dementsprechend stellt OutputDataStore Methoden bereit, um Daten in das zugrundeliegende Speichermedium zu schreiben.

Die unterstützten Datentypen stellen die verfügbaren JAMS-Datentypen dar und beinhalten numerische Daten, String- und Kalendertypen und räumliche Geometrien. Um letztere darzustellen, benutzt JAMS den Standard des Simple Feature Access des Open Geospatial Consortium.

Um auf Daten vom DataStore zuzugreifen, muss seine letzte Datenquelle und Software für deren Zugriff identifiziert und parametrisiert werden. Dies wird durch spezielle XML-Dokumente durchgeführt. Jedes definiert ein DataStore und dient den folgenden Zwecken:

(1) eine I/O-Softwarekomponente identifizieren und parametrisieren, die letztlich auf einen bestimmten Typ von Datenquelle zugreifen kann,

(2) eine oder mehrere Datenquellen definieren, auf die von dieser Komponente zugegriffen wird, und im Falle eines InputDataStore:

(3) definieren, wie wiederhergestellte Daten formatiert und präsentiert werden.

Die I/O-Softwarekomponenten können durch den Nutzer bereitgestellt werden und werden JAMS zur Verfügung gestellt durch einen Plug-in-Mechanismus. Zum Beispiel könnte dies eine JAVA-Klasse sein, die ASCII-formatierte Dateien lesen kann, die Zeitreihendaten beinhalten. Parameter könnte der Dateiname sein und die Größe des Zwischenspeichers.

Entwicklung von JAMS Komponenten

Einrichten einer Entwicklungsumgebung

Unter http://netbeans.org kann die Entwicklungsumgebung NetBeans kostenlos heruntergeladen werden. Die derzeit aktuellste Version ist NetBeans IDE 6.9.1. Wählen Sie als NetBeans IDE Download-Paket entweder Java SE, JavaFX, Java oder All. Weiterhin ist das Java Development Kit (JDK) erforderlich, welches unter http://www.oracle.com/technetwork/java/javase/downloads/index.html heruntergeladen werden kann.

Ihre NetBeans-Entwicklerumgebung sieht nach dem Start folgendermaßen aus:

JAMS/J2000 Quellen aus dem Internet laden

Die Jave-Quellen von JAMS/J2000 und verschiedene Standardkomponenten sowie alle benötigten Bibliotheken können unter http://www.geoinf.uni-jena.de/5580.0.html mithilfe des Links JAMS-2 16-src.tgz heruntergeladen werden.

Folgende Quellordner sind darin enthalten:

Projekte in NetBeans anlegen

Die Projekte sollten in der im Folgenden beschriebenen Reihenfolge eingebunden werden.

1. Schritt - Einbinden des Projektes JAMS

Nun müssen die JAMS/J2000 Quellen ins Netbeans geladen werden. Im ersten Schritt wird das JAMS-Projekt angelegt. Öffnen Sie dazu NetBeans und wählen Sie unter dem Menüpunkt File den Punkt New Project.

Das folgende Fenster wird angezeigt:

Da Sie bestehenden Quellcode einbinden wollen, wählen Sie Java Project with Existing Source. Klicken Sie Next. Im zweiten Schritt muss ein Name sowie ein Projektordner angegeben werden. Nennen sie das Projekt JAMS. Ein Projektordner ist standardmäßig angegeben, kann aber von Ihnen verändert werden. Klicken Sie auf Next.

Laden Sie über den Button Add Folder die folgenden Source-Quellen in das Projekt.

1. JAMSapi
2. JAMScommon
3. JAMSExplorer
4. JAMSMain
5. JAMSRemote
6. JAMSstarter
7. JAMSui

Klicken sie auf Finish.

Im nächsten Schritt müssen im Projekt die erforderlichen Bibliotheken geladen werden. Diese sind im heruntergeladenen Quellordner unter JAMS-2_x-src\ext zu finden. (x steht für die aktuell heruntergeladene Version, die sich jedoch im Laufe der Zeit verändert) Klicken Sie dazu im erzeugten JAMS-Projekt mit der rechten Maustaste auf das Projekt JAMS. Wählen Sie den Punkt Properties.

Wählen Sie im rechten Bereich des Fensters Project Properties - JAMS unter Categories den Punkt Libraries. Mithilfe des Buttons Add JAR/Folder können die benötigten Bibliotheken geladen werden. Laden Sie alle Bibliotheken, die im heruntergeladenen Quellordner JAMS-2_x-src\ext vorhanden sind.

Das JAMS Projekt wurde angelegt.

Möchten Sie das Projekt kompilieren, so klicken Sie mit der rechten Maustaste auf das JAMS Projekt und wählen den Punkt Build and Clean. Das JAMS.jar wird erzeugt. Im unteren linken Fenster Ihrer NetBeans Entwicklerumgebung sehen Sie, ob der Prozess erfolgreich war und wohin die JAMS.jar gespeichert worden ist.

2. Schritt - Einbinden des Projektes J2000

Binden Sie wie im ersten Schritt beschrieben nun das Projekt J2000 als neues Projekt mit existierenden Quellen ein. Die Quellen befinden sich im Verzeichnis ...\JAMS-x-src\J2K\src, welches Sie heruntergeladen haben.

Laden Sie als Bibliothek die im ersten Schritt erzeugte JAMS.jar.

Kompilieren Sie das neue Projekt indem Sie mit der rechten Maustaste auf das Projekt J2000 klicken und den Menüpunkt Build and Clean auswählen. Im unteren rechten Fenster Ihrer NetBeans-Entwicklerumgebung sollte nun BUILD SUCCESSFUL erscheinen.

3. Schritt - Einbinden des Projektes JAMSComponents

Binden Sie wie im ersten Schritt beschrieben nun das Projekt JAMSComponents als neues Projekt mit existierenden Quellen ein. Die Quellen befinden sich im Verzeichnis ...\JAMS-x-src\JAMSComponents\src, welches Sie heruntergeladen haben.

Laden Sie als Bibliothek die im ersten Schritt erzeugte JAMS.jar, sowie alle Bibliotheken (*.jar - Files) aus dem Ordner ...\JAMS-x-src\ext.

Kompilieren Sie das neue Projekt indem Sie mit der rechten Maustaste auf das Projekt J2000 klicken und den Menüpunkt Build and Clean auswählen. Im unteren rechten Fenster Ihrer NetBeans-Entwicklerumgebung sollte nun BUILD SUCCESSFUL erscheinen.

Starten von Prozesskomponenten aus dem NetBeans

Jede Prozesskomponente welche über eine Main-Procedure vefügt, kann aus dem NetBeans direkt gestartet werden. Beispielhaft werden wir in den nächsten Schritten den JAMSLaucher, welcher im Tutorium für Anfänger genauer beschrieben ist, direkt starten.

Main Klassen

Klicken Sie mit der rechten Maustaste auf das Projekt JAMS. Wählen Sie den Menüpunkt Properties. Klicken Sie im linken Teil des Fensters auf run. Das folgende Fenster sollte angezeigt werden:

Tragen Sie als Main Class die Klasse ein, die bei der Projektausführung gestartet werden soll. Mit einem Klick auf den Button Browse... werden alle im Projekt verfügbaren Main Classes angezeigt, das sind alle Komponenten, die über eine Main-Procedure verfügen. Wählen Sie folgende Klassen für die verschiedenen JAMS-Nutzerschnittstellen:

• jamsui.launcher.JAMSui für den JAMS Launcher
• jamsui.juice.JUICE für den JAMS Builder

Wählen Sie die gewünschte Klasse mit Select Main Class aus und klicken Sie auf OK. Starten Sie jetzt das Projekt JAMS, indem Sie mit der rechten Maustaste auf das Projekt klicken und dann den Punkt run auswählen. Die gewählte Nutzerschnittstelle wird gestartet. Auf diese Art und Weise können beliebige Klassen, welche über Main-Proceduren verfügen, gestartet werden.

Entwicklung neuer Prozesskomponenten in JAVA

Aufbau einer Komponente

Eine JAMSProzesskomponente ist immer folgendermaßen aufgebaut:

1. Paketname. Dieser wird von NetBeans automatisch erzeugt.

package org.unijena.j2k.interception;

2. Importieren von Bibliotheken/Klassen die für die Prozesskomponente benötigt werden.

import jams.data.*;
import jams.model.*;
...

3. Start der Prozesskomponente. Jede Prozesskomponente beginnt mit einer Komponentenbeschreibung. Damit können Metainformationen zur Komponente im Quellcode verankert werden. Es sollten Informationen zum Titel der Komponente, zum Autor, zur Version und zum Erstellungsdatum hinterlegt werden. Weiterhin ist eine kurze Beschreibung der Komponente erforderlich.

@JAMSComponentDescription(
       title="...",
       author="...",
       description="...",
       version="...",
       date="..."    
       )

public class NewClass {

4. Variablenblock öffentlicher und privater Variablen. Auf die öffentlichen Variablen kann auch aus anderen Klassen innerhalb eines Modells zugegriffen werden. Zu jeder öffentlichen Variable werden Bemerkungen in Form von Annotations im Quellcode verankert.

Für den Zugriffstype (AccessType) muss zwischen JAMSVarDescription.AccessType.READ (Variablen die nur gelesen werden), JAMSVarDescription.AccessType.WRITE (Variablen die nur geschrieben werden) und JAMSVarDescription.AccessType.READWRITE (Variablen die gelesen als auch geschrieben werden) gewählt werden.

Weiterhin ist eine kurze Beschreibung und, wenn möglich, eine Einheit sowie obere und untere Schranke der Variable erforderlich.

@JAMSVarDescription(
           access =... ,
           description = "...",
           unit = "...",
           lowerBound= ...,
           upperBound =...            
           )
public JAMSDouble  var1;

@JAMSVarDescription(
           access =... ,
           description = "...",
           unit = "...",
           lowerBound= ...,
           upperBound =...            
           )
public JAMSInteger var2;
 
@JAMSVarDescription(
           access =... ,
           description = "...",
           unit = "...",
           lowerBound= ...,
           upperBound =...            
           )
public JAMSString  var3;
...

private JAMSDoublr var4;
...

Jede JAMS- oder J2000-Klasse verfügt über die Prozeduren init(), run() und cleanup().

5. Die init-Prozedur wird zur Modellinitialisierung durchlaufen.

public void init() throws JAMSEntity.NoSuchAttributeException{
...       
}

6. Die run-Prozedur wird während der Modellausführeung durchlaufen.

public void run() throws JAMSEntity.NoSuchAttributeException{
...
}

7. Die cleanup-Prozedur wird am Ende eines Modelllaufs durchlaufen.

public void cleanup() throws JAMSEntity.NoSuchAttributeException{
...
}

8. Private Prozeduren und Funktionen. Diese stehen nur innerhalb der Prozesskomponente zur Verfügung.

private double funktion1(double var){
       ...
       return ...;
   }

9. Ende der Prozesskomponente.

}

Beispiel einer vollständigen Prozesskomponente

1. Paketname.

package org.unijena.j2k.potET;

2. Importierte Bibliotheken

import java.io.*;
import jams.data.*;
import jams.model.*;

3. Start der Prozesskomponente. Jede Prozesskomponente beginnt mit eine Komponentenbeschreibung. Damit können Metainformationen zur Komponente im Quellcode verankert werden. Es sollten Informationen zum Titel der Komponente, zum Autor, zur Version und zum Erstellungsdatum hinterlegt werden. Weiterhin ist eine kurze Beschreibung der Komponente erforderlich.

@JAMSComponentDescription(
       title=""CalcDailyETP_PenmanMonteith"",
       author="Peter Krause",
       description="Calculates potential ETP according Penman-Monteith",
       version="1.0_0",
       date="2011-04-11"    
       )

public class Penman extends JAMSComponent {

4. Variablenblock öffentlicher und privater Variablen. Auf die öffentlichen Variablen kann auch aus anderen Klassen innerhalb eines Modells zugegriffen werden. Zu jeder öffentlichen Variable werden Bemerkungen in Form von Annotations im Quellcode verankert.

Für den Zugriffstype (AccessType) muss zwischen JAMSVarDescription.AccessType.READ (Variablen die nur gelesen werden), JAMSVarDescription.AccessType.WRITE (Variablen die nur geschrieben werden) und JAMSVarDescription.AccessType.READWRITE (Variablen die gelesen als auch geschrieben werden) gewählt werden.

Weiterhin ist eine kurze Beschreibung und, wenn möglich, eine Einheit sowie obere und untere Schranke der Variable erforderlich.

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.READ,
   description = "Current time")
   public JAMSCalendar time;

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.READ,
   description = "temporal resolution [d | h | m]")
   public JAMSString tempRes;

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.READ,
   description = "state variable wind")
   public JAMSDouble wind;

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.READ,
   description = "state variable mean temperature")
   public JAMSDouble tmean;

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.READ,
   description = "state variable relative humidity")
   public JAMSDouble rhum;

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.READ,
   description = "state variable net radiation")
   public JAMSDouble netRad;

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.READ,
   description = "attribute elevation")
   public JAMSDouble elevation;

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.READ,
   description = "attribute area")
   public JAMSDouble area;

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.WRITE,
   description = "potential ET [mm/ timeUnit]")
   public JAMSDouble potET;

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.WRITE,
   description = "actual ET [mm/ timeUnit]")
   public JAMSDouble actET;

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.READ,
   description = "et calibration parameter")
   public JAMSDouble et_cal;

   @JAMSVarDescription(access = JAMSVarDescription.AccessType.READ,
   defaultValue = "0")
   public JAMSInteger dataCaching;

   private File cacheFile;
   transient private ObjectOutputStream writer;
   transient private ObjectInputStream reader;
   public final double CP = 1.031E-3;   //konstanter Parameter  
   public final double RSS = 150;       //konstanter Parameter 

5. Die init-Prozedur wird zur Modellinitialisierung durchlaufen.

   public void init() throws JAMSEntity.NoSuchAttributeException, IOException {
       cacheFile = new File(getModel().getWorkspace().getTempDirectory(), this.getInstanceName() + ".cache");
       if (!cacheFile.exists() && (dataCaching.getValue() == 1)) {
           getModel().getRuntime().sendHalt(this.getInstanceName() + ": dataCaching is true but no cache file available!");
       }

       if (dataCaching.getValue() == 1) {
           reader = new ObjectInputStream(new BufferedInputStream(new FileInputStream(cacheFile)));//new FileInputStream(cacheFile));
       } else if (dataCaching.getValue() == 0) {
           writer = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(cacheFile)));
       }
   }

6. Die run-Prozedur wird während der Modellausführeung durchlaufen.

   public void run() throws JAMSEntity.NoSuchAttributeException, IOException {

       if (dataCaching.getValue() == 1) {
           this.potET.setValue(reader.readDouble());
           this.actET.setValue(0.0);
       } else {
           double netRad = this.netRad.getValue();
           double temperature = this.tmean.getValue();
           double rhum = this.rhum.getValue();
           double wind = this.wind.getValue();
           double elevation = this.elevation.getValue();
           double area = this.area.getValue();

           double abs_temp = org.unijena.j2k.physicalCalculations.ClimatologicalVariables.calc_absTemp(temperature, "degC");
           double delta_s = org.unijena.j2k.physicalCalculations.ClimatologicalVariables.calc_slopeOfSaturationPressureCurve(temperature);
           double pz = org.unijena.j2k.physicalCalculations.ClimatologicalVariables.calc_atmosphericPressure(elevation, abs_temp);
           double est = org.unijena.j2k.physicalCalculations.ClimatologicalVariables.calc_saturationVapourPressure(temperature);
           double ea = org.unijena.j2k.physicalCalculations.ClimatologicalVariables.calc_vapourPressure(rhum, est);

           double latH = org.unijena.j2k.physicalCalculations.ClimatologicalVariables.calc_latentHeatOfVaporization(temperature);
           double psy = org.unijena.j2k.physicalCalculations.ClimatologicalVariables.calc_psyConst(pz, latH);

           double G = this.calc_groundHeatFlux(netRad);
           double vT = org.unijena.j2k.physicalCalculations.ClimatologicalVariables.calc_VirtualTemperature(abs_temp, pz, ea);
           double pa = org.unijena.j2k.physicalCalculations.ClimatologicalVariables.calc_AirDensityAtConstantPressure(vT, pz);

           double tempFactor = 0;
           double pET = 0;
           double aET = 0;


           if (this.tempRes.getValue().equals("d")) {
               tempFactor = 86400;
           } else if (this.tempRes.getValue().equals("h")) {
               tempFactor = 3600;
           } else if (this.tempRes.getValue().equals("m")) {
               tempFactor = 86400;
           }
           double Letp = 0;
           Letp = this.calcPM(delta_s, netRad, G, pa, CP, est, ea, psy, tempFactor, wind);

           pET = Letp / latH;
           aET = 0;

           //converting mm to litres
           pET = pET * area;

           //aggregation to monthly values
           if (this.time != null) {
               if (this.tempRes.getValue().equals("m")) {
                   int daysInMonth = this.time.getActualMaximum(time.DATE);
                   pET = pET * daysInMonth;
               }
           }
           //avoiding negative potETPs
           if (pET < 0) {
               pET = 0;
           }

           this.potET.setValue(pET*et_cal.getValue());
           this.actET.setValue(aET);
           
           if (dataCaching.getValue() == 0) {
               writer.writeDouble(pET*et_cal.getValue());
           }
       }
   }

7. Die cleanup-Prozedur wird am Ende eines Modelllaufs durchlaufen.

   public void cleanup() throws IOException {
       if (dataCaching.getValue() == 0) {
           writer.flush();
           writer.close();
       } else if (dataCaching.getValue() == 1) {
           reader.close();
       }
   }

8. Private Prozeduren und Funktionen. Diese stehen nur innerhalb der Prozesskomponente zur Verfügung.

private double calcPM(double ds, double netRad, double G, double pa, double CP, double est, double ea, double psy, double tempFactor, double  wind){
       double fu = (0.27 + 0.2333 * wind);
       double Letp = (ds * (netRad - G) + (pa * CP * (est - ea) * fu)) / (ds + psy);
       return Letp;
   }
   
private double calc_groundHeatFlux(double netRad) {
       double g = 0.1 * netRad;
       return g;
   }

9. Ende der Prozesskomponente.

}

Entwicklung und Implementierung von JAMS-Kontextkomponenten

Integration neuer Prozesskomponenten in JAMS oder J2000 Bibliotheken

Um Ihre entwickelte Prozesskomponente den bestehenden JAMS oder J2000 Komponenten hinzuzufügen, erstellen sie ein neues *.jar des Projektes, indem die Komponente liegt. Klicken Sie dazu mit der rechten Maustaste auf das Projekt und wählen Sie den Punkt Build and Clean. Binden Sie dieses *.jar nun als Bibliothek ein, so enthält diese Ihre neue Komponente.

Integration und Test neuer (Kontext-)Komponenten

Um neue (Kontext-)komponenten in bestehende Modelle zu intergrieren oder für neue Modelle zu nutzen, steht Ihnen das Werkzeug JUICE zum Modelldesign zur Verfügung. Unter dem Punkt 1.2 Anwenden von JUICE für Modelldesign und -konfiguration im Tutorium für fortgeschittene Anwender sind alle Arbeitsschritte zur Integration von Komponenten erläutert. Mithilfe des JUICE kann das Modell gestartet und damit die neue Komponente getestet werden.

Debugging und Profiling von Modellen in JAMS

Debugging

Um die Arbeitsweise der entwickelten und bestehenden (JAMS-/J2000-) Komponenten nachzuvollziehen oder die Fehlersuche bei der Entwicklung zu erleichtern, steht Ihnen die Möglichkeit des Debuggings zur Verfügung. Hier könnten Sie die Stellen im Quellcode mit Haltepunkten markieren, an denen der Compiler die Modellausführung anhalten soll. Es ist dann möglich, zu diesem Zeitpunt die Werte der deklarieten Variablen einzusehen. Weiterhin kann nun Zeile für Zeile die Arbeitsweise der entwickelten bzw. bestehenden Komponente nachvollzogen werden.

Bevor Sie Ihr Modell im Debug-Modus starten, müssen Sie Haltepunkte an den für Sie interessanten Stellen setzen. Klicken sie dazu auf den roten Punkt in der Menüleiste und anschließend auf die Stelle im Quellcode. Im folgenden Bild wurden zwei Haltepunkte gesetzt.

Verfügt Ihre Komponente über eine Main-Procedure, können Sie diese direkt debuggen. Ist Ihre Komponente Bestandteil eines komplexen Modells, so muss das komplette Modell debuggt werden. Klicken Sie dazu mit der rechten Maustaste auf das zu startende Projekt (das Projekt indem die Komponente enthalten ist) und wälhen Sie debug.

Der Modelllauf wird an dem von Ihnen markierten Punkt angehalten. In unteren Fenster sehen Sie die aktuelle Belegung der Modellvariablen. Im linken oberen Fenster die Position im Quellcode.

Nun können Sie die Arbeitsweise des Quellcodes schrittweise nachvollziehen. Dazu stehen Ihnen die folgenden Optionen, welche in der Netbeans-Menüleiste unter dem Punkt Debug oder teilweise direkt in der Menüleiste zu finden sind, zur Verfügung:

• Finish Debug Session - Beendet den Debug-Modus
• Continue - Springt zum nächsten Haltepunkt
• Step Over - Geht zur nächsten Anweisung
• Step Into - Geht falls möglich in die Anweisung. Anderenfall zur nächsten Anweisung
• Step Out

Mit den Funktionen Step Over und Step Into können Sie schrittweise die Arbeitsweise des Quellcodes verfolgen. Die grün hinterlegte Zeile ist die aktuelle Position, welche ausgewertet wird.

Durch Betätigung des Buttons Continue können Sie zum nächsten gesetzten Haltepunkt (rot hinterlegte Zeile) springen.

Profiling im Netbeans

Netbeans bietet die Möglichkeit, die Modelllaufzeiten, d.h. welcher Teil des Modells wieviel Zeit beansprucht, nachzuvollziehen. Damit können zeitintensive Implementierungen identifiziert werden.

Klicken Sie dazu mit der rechten Maustaste auf das Projekt, welches analysiert werden soll. Wählen Sie unter Eigenschaften (Properties) im Punkt Run die Main-Klasse, auf der das Profiling durchgeführt werden soll.

Wählen Sie nun den Punkt Profiling.

Das folgende Fenster wird geöffnet. Nun können Sie zwischen der Analyse des komletten Quellcodes oder von Quellcodeabschnitte wählen. Folgende Optionen stehen Ihnen zum Filtern zur Verfügung:

• Profile all classes
• Profile only project classes
• Exclude Java core classes
• Quick Filter

Klicken Sie auf run

Die Laufzeitanalyse wird durchgeführt. Das folgende Fenster wird angezeigt.

Das Ergebnis der Analyse wird Ihnen im Netbeans angezeigt. Im linken Fenster sind allgemeine Informationen zu Ihren Profiling angezeigt. Im rechten oberen Fenster sind die Laufzeiten der einzelne Funktionen innerhalb Ihrer gewählten Main-Klasse angezeigt.