Tutorium Modellentwickler

Aus ILMS-Wiki
(Unterschied zwischen Versionen)
Wechseln zu: Navigation, Suche
(→JAMS Komponenten-API)
(→JAMS Kontextkomponenten)
Zeile 50: Zeile 50:
 
as a data store for its children, allowing for flexible data exchange between them.
 
as a data store for its children, allowing for flexible data exchange between them.
 
Depending on the purpose of a given context, it might
 
Depending on the purpose of a given context, it might
−
invoke its children multiple times over a number of iterations, only once if some predefined condition is satisfied (Fig.~\ref{fig:contexts}
+
invoke its children multiple times over a number of iterations (Figure left), only once if some predefined condition is satisfied (Figure center)or only once in a sequence (Figure right). As contexts are
−
center) or only once in a sequence (Fig.~\ref{fig:contexts} right). As contexts are
+
specialized components, they can be nested in other
−
specialized components (Fig.~\ref{fig:coreelements}), they can be nested in other
+
 
contexts, allowing the creation of complex component hierarchies and execution control
 
contexts, allowing the creation of complex component hierarchies and execution control
 
structures.
 
structures.

Version vom 25. Mai 2011, 11:39 Uhr

Inhaltsverzeichnis

JAMS Komponenten-API

JAMS Datentypen

Die folgenden JAMS-Datentyper 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

The main building block of any JAMS model is named component. A component is a JAVA class that implements three different methods (i.e. init, run and cleanup) that are triggered at according runtime stages that a JAMS model iterates through. As indicated by their name, these methods are invoked at the beginning, during and at the end of a component's lifetime. While the init and clean methods are executed only once, the run method can be invoked several times, depending on the component's purpose and configuration.

Communication with the framework and other components is handled by arbitrary public attributes that fulfil two conditions: (i) they are of a valid JAMS data type and (ii) they are marked by special JAVA annotations, i.e. syntactic meta-information. These attribute annotations are used to define their I/O type (read, write), their default values, physical unit and boundaries (if numeric), and a short text describing the attribute's purpose. This information is used both by the runtime system to setup and interlink attributes and by GUIs that provide support during model design.

JAMS Kontextkomponenten

A JAMS context is a special, compound-type component that can nest other components and contexts, named children. A context serves two main purposes: (i) it controls the execution of its children, and (ii) serves as a data store for its children, allowing for flexible data exchange between them. Depending on the purpose of a given context, it might invoke its children multiple times over a number of iterations (Figure left), only once if some predefined condition is satisfied (Figure center)or only once in a sequence (Figure right). As contexts are specialized components, they can be nested in other contexts, allowing the creation of complex component hierarchies and execution control structures.

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:

Bild1 1.png

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.

Quellen 1.png

Folgende Quellordner sind darin enthalten:

Quellordner.png

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.

Neues Projekt.png

Das folgende Fenster wird angezeigt:

Projekt laden1.png

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.

Projekt laden2 2.png

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

Projekt laden3 1.png

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.

Projekt laden3 2.png

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.

Bibliotheken laden.png

Das JAMS Projekt wurde angelegt.

JAMS Projekt.png

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.

Build Clean.png

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.

J2000 Quellen.png

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

Bibliotheken laden J2000.png

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. Bibliotheken laden JAMSComponents.png

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. 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 beispielhaft jamsui.launcher.JAMSui. Klicken Sie auf Set Main Class. Das folgende Fenster sollte angezeigt werden:

Main classes.png

Klicken Sie auf OK. Starten Sie jetzt das Projekt JAMS, indem Sie mit der linken Maustaste auf das Projekt klicken und dann den Punkt run auswählen. Der JAMSLauncher 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 Punkte 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 bestehede Modelle zu intergrieren oder für neue Modell zu nutzen, steht ihnen das Werkzeug JUICE zum Modelldesign zur Verfügung. Unter den 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.

Haltepunkte setzen.png

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.

Debug aufrufen.png

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.

Debug 1.png

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

  • Finish Debug Session - Beeindet 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

Debug Menue.png

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.

Debug 2.png

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

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.

Profile 1.png

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

Profile 2.png

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

Profile 4.png

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.

Profile 5.png

Von „https://jams.uni-jena.de/ilmswiki/de/index.php/Tutorium_Modellentwickler“
Meine Werkzeuge