auf Vlasov-Gleichungen umgeschrieben,

braucht viel zu viel Speicher, da 3D im Impuls

12 files changed, 1030 insertions, 967 deletions

diff --git a/Physikunit.pas b/Physikunit.pas
index 85b6508..491c186 100644
--- a/Physikunit.pas
+++ b/Physikunit.pas
@@ -18,27 +18,25 @@ uses
 type
   tZeitverfahren = (zfEulerVorwaerts,zfRungeKuttaDreiAchtel,zfRungeKuttaVier,zfRungeKuttaZehn,zfRungeKuttaZwoelf,zfRungeKuttaVierzehn);
   tVerteilungsfunktion = function(x: extended): extended;
-  tEMFeldInhalt = (
-    efA,efAX,efAY,efAZ,
+  tEMFeldGroesze = (
+    efAX,efAY,efAZ,
     efDAXDT,efDAYDT,efDAZDT,
-    efDPhiDX
+    efEX,efBY,efBZ
   );
-  tMaterieFeldInhalt = (
-    mfN,mfDPsiDX,       // Teilchendichte, Geschwindigkeitsdichte
-    mfP,mfPX,mfPY,mfPZ, // Impuls
-    mfGamma,mfIGamma    // rel. Gamma-Faktor
+  tEMQuellGroesze = (
+    eqRho,eqJX,eqJY,eqJZ
   );
+  tEMQuellen = array[tEMQuellGroesze] of extended;
 
 const
   erstesEMFMitAbleitung  =  efAX;
   letztesEMFMitAbleitung =  efDAZDT;
-  erstesMatFMitAbleitung  = mfN;
-  letztesMatFMitAbleitung = mfDPsiDX;
 
 type
 
-  tGitter = class;
+  tRaumPunkt = class;
   tFelder = class;
+  tGitter = class;
   tSimulation = class;
 
   { tAusgabeDatei }
@@ -46,9 +44,10 @@ type
   tAusgabeDatei = class
   private
     ableitung:          boolean;
-    emInhalt:           tEMFeldInhalt;
-    matInhalt:          tMaterieFeldInhalt;
-    teilchen,nNum,tCnt: longint; // wenn teilchen < 0, dann EM-Feld
+    emFelder:           tEMFeldGroesze;
+    emQuellen:          tEMQuellGroesze;
+    teilchen,           // -2: EM-Feld; -1: Gesamt-EM-Quelle; sonst: EM-Quelle der entsprechenden Teilchen
+      nNum,tCnt:        longint;
     pre,suf:            string;
     datei:              file;
     pro:                tProtokollant;
@@ -81,50 +80,60 @@ type
     procedure liesDichteFunktion(rest: string; ifile: tMyStringList; kvs: tKnownValues; teilchen: array of tTeilchenSpezies; prot: tProtokollant);
   end;
 
-  { tWertePunkt }
+  { tImpulsPunkt }
 
-  tWertePunkt = class(tObject) // repräsentiert alle Werte eines Punktes im Gitter und deren Zeitableitungen
+  tImpulsPunkt = class(tObject) // Besetzungsdichten verschiedener Teilchenspezies für ein Paar (r;p)
   private
-    besitzer: tFelder;
+    raumpunkt: tRaumPunkt;
+    nachbarn:  array[0..3,boolean] of tImpulsPunkt; // x-, px-, py-, pz-Nachbarn (jeweil in Richtung - und +)
   public
-    matWerte: array of array[tMaterieFeldInhalt,boolean] of extended;
-      // Materiefelder (getrennt für verschiedene Teilchenspezies) und deren Zeitableitungen
-    emWerte:  array[tEMFeldInhalt,boolean] of extended;
-      // EM-Felder und deren Zeitableitungen
-      // A, dPhiDX, p[xyz]? und i?Gamma haben keine sinnvolle Ableitung hier!
-    lN,rN:    tWertePunkt;
+    werte: array of array[boolean] of extended; // Besetzungsdichten und deren Ableitungen für verschiedene Teilchenspezies
+    constructor create(rp: tRaumPunkt; linksRaum,linksImpuls,untenImpuls,vorneImpuls: tImpulsPunkt; anzTeilchen: longint);
+    destructor destroy; override;
+    {$DEFINE LiKotImpulsPunktHeader}
+    {$INCLUDE linearkombinationen.inc}
+    {$UNDEF LiKotImpulsPunktHeader}
+    procedure nichtnegativieren;
+    procedure akkumuliereEMQuellen(var emQuellen: tEMQuellen; vx,vy,vz,dVP: extended);
+    function gibMirWas(var defizit: extended; entfernung, teilchen,richtung: longint; positiv: boolean): boolean; // ich habe jemanden erreicht
+    procedure setzeNull;
+    procedure berechneAbleitungen(pX,pY,pZ,iDX,iDPX,iDPY,iDPZ: extended);
+  end;
+
+  { tRaumPunkt }
 
-    constructor create(linkerNachbar: tWertePunkt; derBesitzer: tFelder);
+  tRaumPunkt = class(tObject) // repräsentiert alle Werte eines Punktes im Raumgitter und deren Zeitableitungen
+  private
+    felder: tFelder;
+  public
+    phasenraum: array of tImpulsPunkt;
+      // Phasenraumbesetzungsdichten
+    emFelder:  array[tEMFeldGroesze,boolean] of extended;
+      // EM-Felder und deren Zeitableitungen
+      // dPhiDX und B[xyz] haben keine sinnvolle Ableitung hier!
+    emQuellen: array[tEMQuellGroesze] of extended;
+      // Quellen für die EM-Felder
+    lN,rN:    tRaumPunkt;
+      // Nachbarpunkte
+    dPX,dPY,dPZ: extended;
+      // Impulsdiskretisierung
+    aPX,aPY,aPZ: longint;
+      // Anzahl der Impulsbins
+
+    constructor create(linkerNachbar: tRaumPunkt; derBesitzer: tFelder; teilchen,_aPX,_aPY,_aPZ: longint; _dPX,_dPY,_dPZ: extended);
     destructor destroy; override;
-    procedure berechneGammaUndP;
-    procedure berechneDPhiDX(dX: extended);
-    procedure berechneNAbleitung(iDX,pDNMax: extended); overload;
-    procedure berechneNAbleitung(iDX,pDNMax: extended; rechts: boolean); overload;
-    procedure berechneAbleitungen(iDX: extended);
-    procedure liKo(in1,in2: tWertePunkt; fak2: extended); overload;                            // Werte werden auf (in1 + \sum_i faki * ini') gesetzt
-    procedure liKo(in1,in2,in3: tWertePunkt; fak2,fak3: extended); overload;
-    procedure liKo(in1,in2,in3,in4: tWertePunkt; fak2,fak3,fak4: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5: tWertePunkt; fak2,fak3,fak4,fak5: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6: tWertePunkt; fak2,fak3,fak4,fak5,fak6: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23,in24,in25,in26,in27,in28,in29,in30,in31: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23,fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23,in24,in25,in26,in27,in28,in29,in30,in31,in32: tWertePunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23,fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31,fak32: extended); overload;
-    function maxDT: extended;
-    function dump(mitNachbarn: boolean): string;
+    procedure berechneEMFelder(dX: extended; rechts: boolean); overload;
+    procedure berechneEMFelder(dX,iDX: extended); overload;
+    procedure berechneEMAbleitungen(iDX: extended);
+    procedure berechnePhasenraumAbleitungen(iDX: extended);
+    {$DEFINE LiKotRaumPunktHeader}
+    {$INCLUDE linearkombinationen.inc}
+    {$UNDEF LiKotRaumPunktHeader}
     procedure nichtnegativieren;
+    function impulsIntegral(teilchen: longint; emQ: tEMQuellGroesze): extended;
+    procedure initialisiereDichte(teilchen: longint; n: extended);
+    procedure reflektiereTeilchen(rechts: boolean);
+    procedure setzeNull;
   end;
 
   { TFelder }
@@ -137,34 +146,16 @@ type
     lichters:     array[boolean] of tMyStringlist;
     procedure setzeRaender(iDX: extended);
   public
-    inhalt: array of tWertePunkt;
-    par:    tGitter;
+    inhalt: array of tRaumPunkt;
+    gitter: tGitter;
 
-    constructor create(groesse: longint; teilchen: array of tTeilchenSpezies; lichter: tMyStringList; parent: tGitter);
+    constructor create(groesse: longint; teilchen: array of tTeilchenSpezies; lichter: tMyStringList; parent: tGitter; aPX,aPY,aPZ: longint; dPX,dPY,dPZ: extended);
     destructor destroy; override;
-    procedure berechneAbleitungen(dX,iDX,pDNMax: extended);
-    procedure liKo(in1,in2: tFelder; fak2: extended); overload;                            // Werte werden auf (in1 + \sum_i faki * ini') gesetzt
-    procedure liKo(in1,in2,in3: tFelder; fak2,fak3: extended); overload;
-    procedure liKo(in1,in2,in3,in4: tFelder; fak2,fak3,fak4: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5: tFelder; fak2,fak3,fak4,fak5: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6: tFelder; fak2,fak3,fak4,fak5,fak6: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7: tFelder; fak2,fak3,fak4,fak5,fak6,fak7: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23,in24,in25,in26,in27,in28,in29,in30,in31: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23,fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31: extended); overload;
-    procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23,in24,in25,in26,in27,in28,in29,in30,in31,in32: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23,fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31,fak32: extended); overload;
-    function maxDT: extended;
+    procedure berechneAbleitungen(dX,iDX: extended);
+    {$DEFINE LiKotFelderHeader}
+    {$INCLUDE linearkombinationen.inc}
+    {$UNDEF LiKotFelderHeader}
+    procedure setzeNull;
   end;
 
   { tGitter }
@@ -174,22 +165,18 @@ type
     besitzer:                     tSimulation;
     prot:                         tProtokollant;
     zeitverfahren:                tZeitverfahren;
-    pDNMaxDynamisch,abbruch:      boolean;
-    dX,iDX,pDNMax,dTMaximum,xl,t: extended;
+    abbruch:                      boolean;
+    dX,iDX,xl,t:                  extended;
     kvs:                          tKnownValues;
-    procedure diffusionsTermAnpassen(pro: tProtokollant);
-    function pruefeMaxDT(aF: longint; var dTMax,dT: extended; dTMin: extended): boolean; // wurde verkleinert?
     procedure abbrechen;
   public
 
     aktuelleFelder: longint;
     felders: array of tFelder; // mehrere komplette Simulationsboxen von Feldern, benötigt um Zwischenschritte für die Zeitentwicklung zu speichern
 
-    constructor create(derBesitzer: tSimulation; size: longint; deltaT,deltaX,pDNMa: extended; bekannteWerte: tKnownValues; teilchen: array of tTeilchenSpezies; lichter: tMyStringlist; zv: tZeitverfahren; protokollant: tProtokollant; name: string);
+    constructor create(derBesitzer: tSimulation; size: longint; deltaX: extended; bekannteWerte: tKnownValues; teilchen: array of tTeilchenSpezies; lichter: tMyStringlist; zv: tZeitverfahren; protokollant: tProtokollant; name: string; aPX,aPY,aPZ: longint; dPX,dPY,dPZ: extended);
     destructor destroy; override;
-    procedure iteriereSchritt(var dT: extended; dTMin: extended);
-    function dumpErhaltungsgroessen: boolean;
-    procedure berechne(was: char; teilchen: longint);
+    procedure iteriereSchritt(dT: extended);
   end;
 
   { tSimulation }
@@ -198,7 +185,7 @@ type
   private
     prot:                      tProtokollant;
     gitter:                    tGitter;
-    dT,tEnde,sT,sDT,sDX,dTMin: extended;
+    dT,tEnde,sT,sDT,sDX:       extended;
     fortschrittsAnzeige:       boolean;
     ausgabeDateien:            array of tAusgabeDatei;
   public
@@ -213,23 +200,23 @@ procedure SignalCapture(signal : longint); cdecl;
 implementation
 
 const
-  emFeldNamen: array[tEMFeldInhalt] of string = (
-    'A','AX','AY','AZ','DAXDT','DAYDT','DAZDT','DPHIDX'
+  emFeldNamen: array[tEMFeldGroesze] of string = (
+    'AX','AY','AZ','DAXDT','DAYDT','DAZDT','EX','BY','BZ'
   );
-  matFeldNamen: array[tMaterieFeldInhalt] of string = (
-    'N','DPSIDX','P','PX','PY','PZ','GAMMA','IGAMMA'
+  emQuellNamen: array[tEMQuellGroesze] of string = (
+    'RHO','JX','JY','JZ'
   );
   minAusgabeBuffer = 1024*1024;
 
 var
   sighupSimulationen: array of tSimulation;
 
-{ tAusgabeDatei }
+// tAusgabeDatei ***************************************************************
 
 constructor tAusgabeDatei.create(feldName,prefix,suffix: string; prot: tProtokollant; nam: string);
 var
-  emF:     tEMFeldInhalt;
-  maF:     tMaterieFeldInhalt;
+  emF:     tEMFeldGroesze;
+  emQ:     tEMQuellGroesze;
   num:     longint;
   abl,gef: boolean;
 begin
@@ -244,10 +231,10 @@ begin
     delete(feldName,num,length(feldName));
   end
   else
-    teilchen:=0;
+    teilchen:=-1;
 
-  emInhalt:=efA;
-  matInhalt:=mfN;
+  emFelder:=efAX;
+  emQuellen:=eqRho;
   feldName:=ansiUpperCase(feldName);
   nNum:=0; // Header 0 wurde also noch nicht geschrieben
   zeitAnz:=-1;
@@ -256,32 +243,37 @@ begin
   gef:=false;
   for abl:=false to true do begin
     if not gef then
-      for emF:=low(tEMFeldInhalt) to high(tEMFeldInhalt) do
+      for emF:=low(tEMFeldGroesze) to high(tEMFeldGroesze) do
         if copy('D',1,byte(abl))+emFeldNamen[emF] = feldName then begin
-          emInhalt:=emF;
-          teilchen:=-1;
-          gef:=true;
-          break;
-        end;
-    if not gef then
-      for maF:=low(tMaterieFeldInhalt) to high(tMaterieFeldInhalt) do
-        if copy('D',1,byte(abl))+matFeldNamen[maF] = feldName then begin
-          matInhalt:=maF;
+          emFelder:=emF;
+          ableitung:=abl;
+          teilchen:=-2;
           gef:=true;
           break;
         end;
   end;
+  if not gef then
+    for emQ:=low(tEMQuellGroesze) to high(tEMQuellGroesze) do
+      if emQuellNamen[emQ] = feldName then begin
+        ableitung:=false;
+        emQuellen:=emQ;
+        gef:=true;
+        break;
+      end;
 
   if not gef then begin
-    pro.schreibe('tAusgabeDatei.create kennt Feld '''+feldName+''' nicht!',true);
+    pro.schreibe('tAusgabeDatei.create kennt Größe '''+feldName+''' nicht!',true);
     pro.destroyAll;
     halt(1);
   end;
 
-  if teilchen>=0 then
-    pre:=matFeldNamen[maF]+inttostr(teilchen+1)
-  else
-    pre:=emFeldNamen[emF];
+  if teilchen=-2 then
+    pre:=emFeldNamen[emF]
+  else begin
+    pre:=emQuellNamen[emQ];
+    if teilchen>=0 then
+      pre:=pre+inttostr(teilchen+1);
+  end;
 
   if ableitung then
     pre:='d'+pre;
@@ -323,10 +315,13 @@ end;
 
 function tAusgabeDatei.dump: string;
 begin
-  if teilchen<0 then
-    result:=emFeldNamen[emInhalt]
-  else
-    result:=matFeldNamen[matInhalt]+inttostr(teilchen);
+  if teilchen=-2 then
+    result:=emFeldNamen[emFelder]
+  else begin
+    result:=emQuellNamen[emQuellen];
+    if teilchen>=0 then
+      result:=result+inttostr(teilchen);
+  end;
   if ableitung then
     result:=result+'''';
   result:=result+' -> '+pre+'-$i'+suf;
@@ -351,18 +346,14 @@ begin
 end;
 
 procedure tAusgabeDatei.speichereWerte(gitter: tGitter; sT, sDX: extended);
-var i,cnt: longint;
-    sX,cX: extended;
+var i,cnt:     longint;
+    sX,cX,val: extended;
 begin
   if (teilchen>=gitter.felders[gitter.aktuelleFelder].matAnz) then begin
     pro.schreibe('Teilchen '+inttostr(teilchen+1)+' gibt es nicht, da kann ich auch nichts speichern!',true);
     pro.destroyall;
     halt(1);
   end;
-  if (teilchen<0) and (emInhalt=efA) then
-    gitter.berechne('A',teilchen);
-  if (teilchen>=0) and (matInhalt=mfP) then
-    gitter.berechne('P',teilchen);
 
   if sT>=nNum+sDT/2 then
     schreibeKopf;
@@ -389,11 +380,22 @@ begin
   inc(bufPos,sizeof(integer));
 
   sX:=cX-Min(gitter.dX,sDX)/2;
-  if teilchen<0 then begin
+  if teilchen=-2 then begin
     for i:=0 to length(gitter.felders[gitter.aktuelleFelder].inhalt)-1 do begin
       while cX>=sX do begin
         dec(cnt);
-        move(gitter.felders[gitter.aktuelleFelder].inhalt[i].emWerte[emInhalt,ableitung],(buf+bufPos)^,sizeof(extended));
+        move(gitter.felders[gitter.aktuelleFelder].inhalt[i].emFelder[emFelder,ableitung],(buf+bufPos)^,sizeof(extended));
+        inc(bufPos,sizeof(extended));
+        sX:=sX+sDX;
+      end;
+      cX:=cX+gitter.dX;
+    end;
+  end
+  else if teilchen=-1 then begin
+    for i:=0 to length(gitter.felders[gitter.aktuelleFelder].inhalt)-1 do begin
+      while cX>=sX do begin
+        dec(cnt);
+        move(gitter.felders[gitter.aktuelleFelder].inhalt[i].emQuellen[emQuellen],(buf+bufPos)^,sizeof(extended));
         inc(bufPos,sizeof(extended));
         sX:=sX+sDX;
       end;
@@ -404,7 +406,8 @@ begin
     for i:=0 to length(gitter.felders[gitter.aktuelleFelder].inhalt)-1 do begin
       while cX>=sX do begin
         dec(cnt);
-        move(gitter.felders[gitter.aktuelleFelder].inhalt[i].matWerte[teilchen,matInhalt,ableitung],(buf+bufPos)^,sizeof(extended));
+        val:=gitter.felders[gitter.aktuelleFelder].inhalt[i].impulsIntegral(teilchen,emQuellen);
+        move(val,(buf+bufPos)^,sizeof(extended));
         inc(bufPos,sizeof(extended));
         sX:=sX+sDX;
       end;
@@ -418,7 +421,7 @@ begin
   end;
 end;
 
-{ tTeilchenSpezies }
+// tTeilchenSpezies ************************************************************
 
 constructor tTeilchenSpezies.create;
 begin
@@ -515,35 +518,209 @@ begin
   end;
 end;
 
-{ tWertePunkt }
+// tImpulsPunkt ****************************************************************
 
-constructor tWertePunkt.create(linkerNachbar: tWertePunkt; derBesitzer: tFelder);
+constructor tImpulsPunkt.create(rp: tRaumPunkt; linksRaum,linksImpuls,untenImpuls,vorneImpuls: tImpulsPunkt; anzTeilchen: longint);
+var
+  i: longint;
+  b: boolean;
+begin
+  inherited create;
+  raumPunkt:=rp;
+  fillchar(werte,sizeof(werte),#0);
+  setlength(werte,anzTeilchen);
+  for i:=0 to length(werte)-1 do
+    for b:=false to true do
+      werte[i,b]:=0;
+  nachbarn[0,false]:=linksRaum;
+  nachbarn[0,true]:=nil;
+  nachbarn[1,false]:=linksImpuls;
+  nachbarn[1,true]:=nil;
+  nachbarn[2,false]:=untenImpuls;
+  nachbarn[2,true]:=nil;
+  nachbarn[3,false]:=vorneImpuls;
+  nachbarn[3,true]:=nil;
+  for i:=0 to 3 do
+    if assigned(nachbarn[i,false]) then
+      nachbarn[i,false].nachbarn[i,true]:=self;
+end;
+
+destructor tImpulsPunkt.destroy;
+var
+  i: longint;
+  b: boolean;
+begin
+  for i:=0 to 3 do
+    for b:=false to true do
+      if assigned(nachbarn[i,b]) then
+        nachbarn[i,b].nachbarn[i,not b]:=nil;
+  setlength(werte,0);
+  inherited destroy;
+end;
+
+procedure tImpulsPunkt.nichtnegativieren; // Dichten nicht negativ machen
+var
+  i,j,entfernung:   longint;
+  defizit:          extended;
+  pro:              tProtokollant;
+  jemandErreicht,b: boolean;
+begin
+  for i:=0 to length(werte)-1 do
+    if werte[i,false]<0 then begin
+      defizit:=-werte[i,false];
+      werte[i,false]:=0;
+      entfernung:=1;
+      jemandErreicht:=true;
+      while (defizit>0) and jemandErreicht do begin
+        jemandErreicht:=false;
+        for j:=0 to 3 do
+          for b:=false to true do
+            if assigned(nachbarn[j,b]) then
+              jemandErreicht:=nachbarn[j,b].gibMirWas(defizit,i,entfernung,j,b) or jemandErreicht;
+
+        inc(entfernung);
+      end;
+      if defizit>0 then begin
+        pro:=tProtokollant.create(raumpunkt.felder.gitter.prot,'WertePunkt.nichtnegativieren');
+        pro.schreibe('Ich konnte ein Teilchendefizit der Sorte '+inttostr(i+1)+' nicht auffüllen!',true);
+        raumpunkt.felder.gitter.abbrechen;
+      end;
+    end;
+end;
+
+procedure tImpulsPunkt.akkumuliereEMQuellen(var emQuellen: tEMQuellen; vx,vy,vz,dVP: extended);
+var
+  i:   longint;
+  tmp: extended;
+begin
+  for i:=0 to length(werte)-1 do begin
+    tmp:=werte[i,false] * raumpunkt.felder.spezLadungen[i] * dVP;
+    emQuellen[eqRho]:=emQuellen[eqRho] + tmp;
+    emQuellen[eqJX]:= emQuellen[eqJX]  + tmp * vx;
+    emQuellen[eqJY]:= emQuellen[eqJY]  + tmp * vy;
+    emQuellen[eqJZ]:= emQuellen[eqJZ]  + tmp * vz;
+  end;
+end;
+
+function tImpulsPunkt.gibMirWas(var defizit: extended; entfernung, teilchen,richtung: longint; positiv: boolean): boolean; // ich habe jemanden erreicht
+var
+  i: longint;
+begin
+  result:=entfernung<=0;
+  if result then begin
+    if (defizit>0) and (werte[teilchen,false]>0) then begin
+      if defizit>werte[teilchen,false] then begin
+        defizit:=defizit-werte[teilchen,false];
+        werte[teilchen,false]:=0;
+      end
+      else begin
+        werte[teilchen,false]:=werte[teilchen,false]-defizit;
+        defizit:=0;;
+      end;
+    end;
+  end
+  else
+    if defizit>0 then begin
+      result:=false;
+      for i:=richtung to 4 do
+        if assigned(nachbarn[i,positiv]) then
+          result:=nachbarn[i,positiv].gibMirWas(defizit,entfernung-1,teilchen,i,positiv) or result;
+    end;
+end;
+
+procedure tImpulsPunkt.setzeNull;
 var
-  emF: tEMFeldInhalt;
-  maF: tMaterieFeldInhalt;
-  abl: boolean;
   i:   longint;
+  abl: boolean;
+begin
+  for i:=0 to length(werte)-1 do
+    for abl:=false to true do
+      werte[i,abl]:=0;
+end;
+
+procedure tImpulsPunkt.berechneAbleitungen(pX,pY,pZ,iDX,iDPX,iDPY,iDPZ: extended);
+var
+  igam: extended;
+  i:    longint;
+begin
+  igam:=1/sqrt(1+sqr(pX)+sqr(pY)+sqr(pZ));
+  pX:=pX*igam;
+  pY:=pY*igam;
+  pZ:=pZ*igam;
+
+  // df/dt = - v Nabla f - q(E + v/c x B) Nabla_p f
+  for i:=0 to length(werte)-1 do
+    werte[i,true]:=
+      - pX * (nachbarn[0,true].werte[i,false] - nachbarn[0,false].werte[i,false]) * iDX/2
+      - raumpunkt.felder.spezLadungen[i] * (
+        (raumpunkt.emFelder[efEX,false] + pY*raumpunkt.emFelder[efBZ,false] - pZ*raumpunkt.emFelder[efBY,false])
+         * (nachbarn[1,true].werte[i,false] - nachbarn[1,false].werte[i,false]) * iDPX/2
+        -pX*raumpunkt.emFelder[efBZ,false]
+         * (nachbarn[2,true].werte[i,false] - nachbarn[2,false].werte[i,false]) * iDPY/2
+        +pX*raumpunkt.emFelder[efBY,false]
+         * (nachbarn[3,true].werte[i,false] - nachbarn[3,false].werte[i,false]) * iDPZ/2
+      );
+end;
+
+// tRaumPunkt ******************************************************************
+
+constructor tRaumPunkt.create(linkerNachbar: tRaumPunkt; derBesitzer: tFelder; teilchen,_aPX,_aPY,_aPZ: longint; _dPX,_dPY,_dPZ: extended);
+var
+  emF:            tEMFeldGroesze;
+  emQ:            tEMQuellGroesze;
+  abl:            boolean;
+  i,j,k:          longint;
+  xN,pxN,pyN,pzN: tImpulsPunkt;
 begin
   inherited create;
-  besitzer:=derBesitzer;
-  fillchar(matWerte,sizeof(matWerte),#0);
-  setlength(matWerte,length(besitzer.spezLadungen));
-  for i:=0 to length(matWerte)-1 do
-    for maF:=low(tMaterieFeldInhalt) to high(tMaterieFeldInhalt) do
-      for abl:=false to true do
-        matWerte[i,maF,abl]:=0;
-  for emF:=low(tEMFeldInhalt) to high(tEMFeldInhalt) do
+  felder:=derBesitzer;
+  for emQ:=low(tEMQuellGroesze) to high(tEMQuellGroesze) do
+    emQuellen[emQ]:=0;
+  for emF:=low(tEMFeldGroesze) to high(tEMFeldGroesze) do
     for abl:=false to true do
-      emWerte[emF,abl]:=0;
+      emFelder[emF,abl]:=0;
   lN:=linkerNachbar;
   rN:=nil;
   if assigned(lN) then
     lN.rN:=self;
+  aPX:=_aPX+byte(not odd(_aPX));
+  aPY:=_aPY+byte(not odd(_aPY));
+  aPZ:=_aPZ+byte(not odd(_aPZ));
+  dPX:=_dPX;
+  dPY:=_dPY;
+  dPZ:=_dPZ;
+  fillchar(phasenraum,sizeof(phasenraum),#0);
+  setlength(phasenraum,aPX*aPY*aPZ);
+  for i:=0 to aPX-1 do
+    for j:=0 to aPY-1 do
+      for k:=0 to aPZ-1 do begin
+        if assigned(linkerNachbar) then
+          xN:=linkerNachbar.phasenraum[i+aPX*(j+k*aPY)]
+        else
+          xN:=nil;
+        if i>0 then
+          pxN:=phasenraum[i-1+aPX*(j+k*aPY)]
+        else
+          pxN:=nil;
+        if j>0 then
+          pyN:=phasenraum[i+aPX*(j-1+k*aPY)]
+        else
+          pyN:=nil;
+        if k>0 then
+          pzN:=phasenraum[i+aPX*(j+(k-1)*aPY)]
+        else
+          pzN:=nil;
+        phasenraum[i+aPX*(j+k*aPY)]:=tImpulsPunkt.create(self,xN,pxN,pyN,pzN,teilchen);
+      end;
 end;
 
-destructor tWertePunkt.destroy;
+destructor tRaumPunkt.destroy;
+var
+  i: longint;
 begin
-  setlength(matWerte,0);
+  for i:=0 to length(phasenraum)-1 do
+    phasenraum[i].free;
+  setlength(phasenraum,0);
   if assigned(lN) then
     lN.rN:=nil;
   if assigned(rN) then
@@ -551,262 +728,187 @@ begin
   inherited destroy;
 end;
 
-procedure tWertePunkt.berechneGammaUndP; // aus aktuellem dPsi/dX und A
-var
-  i: longint;
+procedure tRaumPunkt.berechneEMFelder(dX: extended; rechts: boolean);
 begin
-  for i:=0 to length(matWerte)-1 do begin
-    matWerte[i,mfPX,false]:= besitzer.spezLadungen[i] * emWerte[efAX,false] + matWerte[i,mfDPsiDX,false];
-    matWerte[i,mfPY,false]:= besitzer.spezLadungen[i] * emWerte[efAY,false];
-    matWerte[i,mfPZ,false]:= besitzer.spezLadungen[i] * emWerte[efAZ,false];
-
-    matWerte[i,mfGamma,false]:=
-      sqrt(
-        1 +
-        sqr(matWerte[i,mfPX,false]) +
-        sqr(matWerte[i,mfPY,false]) +
-        sqr(matWerte[i,mfPZ,false])
-      );
-    matWerte[i,mfIGamma,false]:=
-      1/matWerte[i,mfGamma,false];
-  end;
+  // dEX/dx = rho  ... hier muss integriert werden:
+  // EX = EX(x- deltax) + <rho> * deltax
+
+  if rechts then
+    emFelder[efEX,false]:=
+      lN.emFelder[efEX,false] +
+      (lN.emQuellen[eqRho] + emQuellen[eqRho]) * dX/2
+  else
+    emFelder[efEX,false]:=
+      emQuellen[eqRho] * dX;
+
+  // B = rot A
+  emFelder[efBY,false]:=0;  // kann man vllt auch hübscher machen, ich bin aber gerade zu faul dafür
+  emFelder[efBZ,false]:=0;
+end;
+
+procedure tRaumPunkt.berechneEMFelder(dX,iDX: extended);
+begin
+  // dEX/dx = rho  ... hier muss integriert werden:
+  // EX = EX(x- deltax) + <rho> * deltax
+
+  emFelder[efEX,false]:=
+    lN.emFelder[efEX,false] +
+    (lN.emQuellen[eqRho] + emQuellen[eqRho]) * dX/2;
+
+  // B = rot A
+  emFelder[efBY,false]:=
+    (lN.emFelder[efAZ,false]-rN.emFelder[efAZ,false])*iDX/2;
+  emFelder[efBZ,false]:=
+    (rN.emFelder[efAY,false]-lN.emFelder[efAY,false])*iDX/2;
 end;
 
-procedure tWertePunkt.berechneDPhiDX(dX: extended);
+procedure tRaumPunkt.berechneEMAbleitungen(iDX: extended); // Zeitableitungen der EM-Potentiale berechnen
 var
-  i: longint;
+  i,j,k: longint;
+  emQ:   tEMQuellGroesze;
 begin
-  // d2Phi/dx2 = rho  ... hier muss integriert werden:
-  // dPhi/dx = dPhi/dx(x- deltax) + <rho> * deltax
-
-  if assigned(lN) then begin
-    emWerte[efDPhiDX,false]:=lN.emWerte[efDPhiDX,false];
-    for i:=0 to length(matWerte)-1 do
-      emWerte[efDPhiDX,false]:=
-        emWerte[efDPhiDX,false]
-        + besitzer.spezLadungen[i] * (lN.matWerte[i,mfN,false] + matWerte[i,mfN,false]) * dX/2;
-  end
-  else begin
-    emWerte[efDPhiDX,false]:=0;
-    for i:=0 to length(matWerte)-1 do
-      emWerte[efDPhiDX,false]:=
-        emWerte[efDPhiDX,false]
-        + besitzer.spezLadungen[i] * matWerte[i,mfN,false] * dX/2;
-  end;
+  for emQ:=low(tEMQuellGroesze) to high(tEMQuellGroesze) do
+    emQuellen[emQ]:=0;
+  for i:=0 to aPX-1 do
+    for j:=0 to aPY-1 do
+      for k:=0 to aPZ-1 do
+        phasenraum[i+aPX*(j+aPY*k)].akkumuliereEMQuellen(emQuellen,(i-aPX/2)*dPX,(j-aPY/2)*dPY,(k-aPZ/2)*dPZ,dPX*dPY*dPZ);
+
+  // d2A/dt2 = Laplace(A) - j    ( - dE/dt wird auf dA/dt direkt aufgeschlagen !!! )
+  emFelder[efDAXDT,true]:=
+    ( rN.emFelder[efAX,false] - 2*emFelder[efAX,false] + lN.emFelder[efAX,false] )*sqr(iDX)
+    - emQuellen[eqJX];
+  emFelder[efDAYDT,true]:=
+    ( rN.emFelder[efAY,false] - 2*emFelder[efAY,false] + lN.emFelder[efAY,false] )*sqr(iDX)
+    - emQuellen[eqJY];
+  emFelder[efDAZDT,true]:=
+    ( rN.emFelder[efAZ,false] - 2*emFelder[efAZ,false] + lN.emFelder[efAZ,false] )*sqr(iDX)
+    - emQuellen[eqJZ];
+
+  // dA/dt = dA/dt - E
+  emFelder[efAX,true]:=emFelder[efDAXDT,false] - emFelder[efEX,false];
+  emFelder[efAY,true]:=emFelder[efDAYDT,false];
+  emFelder[efAZ,true]:=emFelder[efDAZDT,false];
 end;
 
-procedure tWertePunkt.berechneNAbleitung(iDX,pDNMax: extended); // Zeitableitung von n berechnen
+procedure tRaumPunkt.berechnePhasenraumAbleitungen(iDX: extended);
 var
-  i: longint;
+  i,j,k: longint;
 begin
-(*  // dn/dt = -d(n/Gamma p_x)/dx
-    Groessen[true,fiN]:=
-      -(   rN^.rN^.Groessen[false,fiN]*rN^.rN^.Groessen[false,fiiGamma]*rN^.rN^.Groessen[false,fiPX]
-         + rN^.Groessen[false,fiN]*rN^.Groessen[false,fiiGamma]*rN^.Groessen[false,fiPX]
-         - lN^.Groessen[false,fiN]*lN^.Groessen[false,fiiGamma]*lN^.Groessen[false,fiPX]
-         - lN^.lN^.Groessen[false,fiN]*lN^.lN^.Groessen[false,fiiGamma]*lN^.lN^.Groessen[false,fiPX]
-       )*iDX/6;
-    // es wird über die beiden nächsten linken bzw. rechten Nachbarn gemittelt   *)
-
-  for i:=0 to length(matWerte)-1 do
-    // dn/dt = -d(n/Gamma p_x)/dx + (p_max*dx) * Laplace n
-    matWerte[i,mfN,true]:=
-      ( rN.matWerte[i,mfN,false] * rN.matWerte[i,mfIGamma,false] * (pDNMax - rN.matWerte[i,mfPX,false] * iDX)
-      + lN.matWerte[i,mfN,false] * lN.matWerte[i,mfIGamma,false] * (pDNMax + lN.matWerte[i,mfPX,false] * iDX)
-      -    matWerte[i,mfN,false]  *   matWerte[i,mfIGamma,false] * 2 * pDNMax) / 2;
-    // Der zweite Summand entspricht (in etwa) einer thermischen Verschmierung
-    // und soll die numerische Stabilität bis zu p * d(ln n)/dx von pDNMax gewährleisten.
-    // Es handelt sich um einen Diffusionsterm dn/dt = alpha * Laplace n mit
-    // alpha = pDNMax * dX^2
+  // df/dt = - v Nabla f - q(E + v/c x B) Nabla_p f
+  for i:=1 to aPX-2 do
+    for j:=1 to aPY-2 do
+      for k:=1 to aPZ-2 do
+        phasenraum[i+aPX*(j+aPY*k)].berechneAbleitungen((i-(aPX div 2))*dPX,(j-(aPY div 2))*dPY,(k-(aPZ div 2))*dPZ,iDX,1/dPX,1/dPY,1/dPZ);
 end;
 
-procedure tWertePunkt.berechneNAbleitung(iDX,pDNMax: extended; rechts: boolean);
+procedure tRaumPunkt.nichtnegativieren; // Dichten nicht negativ machen
 var
-  i: longint;
+  i:       longint;
 begin
-  if rechts then begin
-    for i:=0 to length(matWerte)-1 do
-      // rechter Randterm von dn/dt = -d(n/Gamma p_x)/dx + (p_max*dx) * Laplace n
-      matWerte[i,mfN,true]:=
-        ( lN.matWerte[i,mfN,false] * lN.matWerte[i,mfIGamma,false] * (pDNMax + lN.matWerte[i,mfPX,false] * iDX)
-        -    matWerte[i,mfN,false]  *   matWerte[i,mfIGamma,false] * (pDNMax -    matWerte[i,mfPX,false] * iDX)) / 2;
-  end
-  else begin
-    for i:=0 to length(matWerte)-1 do
-      // linker Randterm von dn/dt = -d(n/Gamma p_x)/dx + (p_max*dx) * Laplace n
-      matWerte[i,mfN,true]:=
-        ( rN.matWerte[i,mfN,false] * rN.matWerte[i,mfIGamma,false] * (pDNMax - rN.matWerte[i,mfPX,false] * iDX)
-        -    matWerte[i,mfN,false]  *   matWerte[i,mfIGamma,false] * (pDNMax +    matWerte[i,mfPX,false] * iDX)) / 2;
-  end
+  for i:=0 to length(phasenraum)-1 do
+    phasenraum[i].nichtnegativieren;
 end;
 
-procedure tWertePunkt.berechneAbleitungen(iDX: extended); // Zeitableitungen berechnen
+function tRaumPunkt.impulsIntegral(teilchen: longint; emQ: tEMQuellGroesze): extended;
 var
-  i: longint;
+  i,j,k:    longint;
 begin
-  // d2Psi/dxdt = dPhi/dx - dGamma/dx
-  for i:=0 to length(matWerte)-1 do
-    matWerte[i,mfDPsiDX,true]:=
-      besitzer.spezLadungen[i] * emWerte[efDPhiDX,false]
-        - (rN.matWerte[i,mfGamma,false] - lN.matWerte[i,mfGamma,false]) * iDX/2;
-
-  // d2A/dt2 = Laplace(A) ...    ( - Nabla(dPhi/dt) wird auf dA/dt aufgeschlagen !!! )
-  emWerte[efDAXDT,true]:=
-    ( rN.emWerte[efAX,false] - 2*emWerte[efAX,false] + lN.emWerte[efAX,false] )*sqr(iDX);
-  emWerte[efDAYDT,true]:=
-    ( rN.emWerte[efAY,false] - 2*emWerte[efAY,false] + lN.emWerte[efAY,false] )*sqr(iDX);
-  emWerte[efDAZDT,true]:=
-    ( rN.emWerte[efAZ,false] - 2*emWerte[efAZ,false] + lN.emWerte[efAZ,false] )*sqr(iDX);
-  // ... - Rho/gamma p
-  for i:=0 to length(matWerte)-1 do begin
-    emWerte[efDAXDT,true]:=
-      emWerte[efDAXDT,true]
-      - (besitzer.spezLadungen[i] * matWerte[i,mfN,false] * matWerte[i,mfIGamma,false] * matWerte[i,mfPX,false]);
-    emWerte[efDAYDT,true]:=
-      emWerte[efDAYDT,true]
-      - (besitzer.spezLadungen[i] * matWerte[i,mfN,false] * matWerte[i,mfIGamma,false] * matWerte[i,mfPY,false]);
-    emWerte[efDAZDT,true]:=
-      emWerte[efDAZDT,true]
-      - (besitzer.spezLadungen[i] * matWerte[i,mfN,false] * matWerte[i,mfIGamma,false] * matWerte[i,mfPZ,false]);
+  if teilchen<0 then begin
+    result:=emQuellen[emQ]; // das ist leicht :-)
+    exit;
   end;
 
-  // dA/dt = dA/dt - Nabla(Phi)
-  emWerte[efAX,true]:=emWerte[efDAXDT,false] - emWerte[efDPhiDX,false];// + emWerte[efDAXDT,true]*dT;
-  emWerte[efAY,true]:=emWerte[efDAYDT,false];// + emWerte[efDAYDT,true]*dT;
-  emWerte[efAZ,true]:=emWerte[efDAZDT,false];// + emWerte[efDAZDT,true]*dT;
+  result:=0;
+
+  case emQ of
+    eqRho:
+      for i:=0 to aPX-1 do
+        for j:=0 to aPY-1 do
+          for k:=0 to aPZ-1 do
+            result:=
+              result +
+              phasenraum[i+aPX*(j+aPY*k)].werte[teilchen,false]*dPX*dPY*dPZ;
+    eqJX:
+      for i:=0 to aPX-1 do
+        for j:=0 to aPY-1 do
+          for k:=0 to aPZ-1 do
+            result:=
+              result +
+              phasenraum[i+aPX*(j+aPY*k)].werte[teilchen,false]*dPX*dPY*dPZ * (i-aPX/2)*dPX;
+    eqJY:
+      for i:=0 to aPX-1 do
+        for j:=0 to aPY-1 do
+          for k:=0 to aPZ-1 do
+            result:=
+              result +
+              phasenraum[i+aPX*(j+aPY*k)].werte[teilchen,false]*dPX*dPY*dPZ * (j-aPY/2)*dPY;
+    eqJZ:
+      for i:=0 to aPX-1 do
+        for j:=0 to aPY-1 do
+          for k:=0 to aPZ-1 do
+            result:=
+              result +
+              phasenraum[i+aPX*(j+aPY*k)].werte[teilchen,false]*dPX*dPY*dPZ * (k-aPZ/2)*dPZ;
+  end;
 end;
 
-function tWertePunkt.maxDT: extended;
+procedure tRaumPunkt.initialisiereDichte(teilchen: longint; n: extended);
 var
   i: longint;
 begin
-  result:=infinity;
-  for i:=0 to length(matWerte)-1 do
-    if (matWerte[i,mfN,true]<0) and
-       (matWerte[i,mfN,false]>0) then
-      result:=min(result,-matWerte[i,mfN,false]/matWerte[i,mfN,true]);
+  for i:=0 to length(phasenraum)-1 do
+    if (aPX div 2) + aPX*((aPY div 2) + aPY*(aPZ div 2)) = i then
+      phasenraum[i].werte[teilchen,false]:=n
+    else
+      phasenraum[i].werte[teilchen,false]:=0;
 end;
 
-function tWertePunkt.dump(mitNachbarn: boolean): string;
+procedure tRaumPunkt.reflektiereTeilchen(rechts: boolean);
 var
-  i: longint;
+  i,j,k: longint;
 begin
-  if mitNachbarn and assigned(lN) then result:=lN.dump(false)+' << '
-  else result:='';
-
-  for i:=0 to length(matWerte)-1 do
-    result:=
-      result+
-      'N['+  inttostr(i)+'] = '+floattostr(matWerte[i,mfN,false])+' '+
-      'N''['+inttostr(i)+'] = '+floattostr(matWerte[i,mfN,true])+' ';
-
-  result:=result+'maxDT: '+floattostr(maxDT);
-
-  if mitNachbarn and assigned(rN) then result:=result+' >> '+rN.dump(false);
+  for i:=(aPX div 2 + 1)*byte(rechts) to (aPX div 2)-1 + (apx-(aPX div 2))*byte(rechts) do
+    for j:=0 to aPY*aPZ-1 do
+      for k:=0 to felder.matAnz-1 do
+        if phasenraum[i+aPX*j].werte[k,false]>0 then begin
+          phasenraum[aPX-1-i+aPX*j].werte[k,false]:=phasenraum[i+aPX*j].werte[k,false];
+          phasenraum[i+aPX*j].werte[k,false]:=0;
+        end;
 end;
 
-procedure tWertePunkt.nichtnegativieren; // Dichten nicht negativ machen
+procedure tRaumPunkt.setzeNull;
 var
-  i:       longint;
-  defizit: extended;
-  li,re:   tWertePunkt;
-  pro:     tProtokollant;
+  i:   longint;
+  emF: tEMFeldGroesze;
+  emQ: tEMQuellGroesze;
+  abl: boolean;
 begin
-  for i:=0 to length(matWerte)-1 do
-    if matWerte[i,mfN,false]<0 then begin
-      defizit:=-matWerte[i,mfN,false];
-      matWerte[i,mfN,false]:=0;
-      li:=self.lN;
-      re:=self.rN;
-      repeat
-        if assigned(li) then begin
-          if li.matWerte[i,mfN,false]>0 then begin
-            if defizit>=li.matWerte[i,mfN,false] then begin
-              defizit:=defizit-li.matWerte[i,mfN,false];
-              li.matWerte[i,mfN,false]:=0;
-            end
-            else begin
-              li.matWerte[i,mfN,false]:=li.matWerte[i,mfN,false]-defizit;
-              defizit:=0;;
-            end;
-          end;
-          li:=li.lN;
-        end;
-        if assigned(re) then begin
-          if re.matWerte[i,mfN,false]>0 then begin
-            if defizit>=re.matWerte[i,mfN,false] then begin
-              defizit:=defizit-re.matWerte[i,mfN,false];
-              re.matWerte[i,mfN,false]:=0;
-            end
-            else begin
-              re.matWerte[i,mfN,false]:=re.matWerte[i,mfN,false]-defizit;
-              defizit:=0;;
-            end;
-          end;
-          re:=re.rN;
-        end;
-      until (defizit<=0) or not (assigned(li) or assigned(re));
-      if defizit>0 then begin
-        pro:=tProtokollant.create(besitzer.par.prot,'WertePunkt.nichtnegativieren');
-        pro.schreibe('Ich konnte ein Teilchendefizit nicht auffüllen!',true);
-        besitzer.par.abbrechen;
-      end;
-    end;
+  for i:=0 to length(phasenraum)-1 do
+    phasenraum[i].setzeNull;
+  for emQ:=low(tEMQuellGroesze) to high(tEMQuellGroesze) do
+    emQuellen[emQ]:=0;
+  for emF:=low(tEMFeldGroesze) to high(tEMFeldGroesze) do
+    for abl:=false to true do
+      emFelder[emF,abl]:=0;
 end;
 
-{ linearkombinationsspezifische Methoden von tWertePunkt und tFelder }
-
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA3}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA4}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA5}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA6}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA7}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA8}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA9}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA10}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA11}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA12}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA14}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA15}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA16}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA17}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA18}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA19}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA22}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA23}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA31}
-{$INCLUDE linearkombination.inc}
-{$DEFINE lkA32}
-{$INCLUDE linearkombination.inc}
-
-{ tFelder }
-
-constructor tFelder.create(groesse: longint; teilchen: array of tTeilchenSpezies; lichter: tMyStringList; parent: tGitter);
+// linearkombinationsspezifische Methoden von tImpulsPunkt, tRaumPunkt und tFelder
+
+{$DEFINE LiKoimplementation}
+{$INCLUDE linearkombinationen.inc}
+{$UNDEF LiKoimplementation}
+
+// tFelder *********************************************************************
+
+constructor tFelder.create(groesse: longint; teilchen: array of tTeilchenSpezies; lichter: tMyStringList; parent: tGitter; aPX,aPY,aPZ: longint; dPX,dPY,dPZ: extended);
 var
   i,j:    longint;
   rechts: boolean;
+  dens:   extended;
 begin
   inherited create;
-  par:=parent;
+  gitter:=parent;
   matAnz:=length(teilchen);
   fillchar(spezLadungen,sizeof(spezLadungen),#0);
   setlength(spezLadungen,matAnz);
@@ -814,18 +916,18 @@ begin
     spezLadungen[i]:=teilchen[i].spezifischeLadung;
   fillchar(inhalt,sizeof(inhalt),#0);
   setlength(inhalt,groesse+4); // zwei Felder links und rechts extra für Randbedingungen
-  inhalt[0]:=tWertePunkt.create(nil,self);
+  inhalt[0]:=tRaumPunkt.create(nil,self,length(teilchen),aPX,aPY,aPZ,dPX,dPY,dPZ);
   for i:=1 to length(inhalt)-1 do
-    inhalt[i]:=tWertePunkt.create(inhalt[i-1],self);
+    inhalt[i]:=tRaumPunkt.create(inhalt[i-1],self,length(teilchen),aPX,aPY,aPZ,dPX,dPY,dPZ);
   fillchar(massen,sizeof(massen),#0);
   setlength(massen,length(teilchen));
   for i:=0 to length(massen)-1 do
     massen[i]:=0;
   for i:=0 to length(inhalt)-1 do
     for j:=0 to length(teilchen)-1 do begin
-      inhalt[i].matWerte[j,mfN,false]:=teilchen[j].gibDichte(par.xl+(i-2)*par.dX,parent.kvs);
-      inhalt[i].matWerte[j,mfDPsiDX,false]:=0;
-      massen[j]:=massen[j]+inhalt[i].matWerte[j,mfN,false]*par.dX;
+      dens:=teilchen[j].gibDichte(gitter.xl+(i-2)*gitter.dX,parent.kvs);
+      inhalt[i].initialisiereDichte(j,dens);
+      massen[j]:=massen[j]+dens*gitter.dX;
     end;
   for rechts:=false to true do begin
     lichters[rechts]:=tMyStringlist.create(nil,'');
@@ -852,65 +954,58 @@ end;
 
 procedure tFelder.setzeRaender(iDX: extended);
 var
-  emF:    tEMFeldInhalt;
+  emF:    tEMFeldGroesze;
   rechts: boolean;
   i:      longint;
 begin
   for emF:=efAX to efAZ do begin // Vakuumrandbedingungen für das A-Feld
-    inhalt[0].emWerte[emF,true]:=
-      (inhalt[1].emWerte[emF,false] -
-       inhalt[0].emWerte[emF,false])*iDX;
-    inhalt[length(inhalt)-1].emWerte[emF,true]:=
-      (inhalt[length(inhalt)-2].emWerte[emF,false] -
-       inhalt[length(inhalt)-1].emWerte[emF,false])*iDX;
+    inhalt[0].emFelder[emF,true]:=
+      (inhalt[1].emFelder[emF,false] -
+       inhalt[0].emFelder[emF,false])*iDX;
+    inhalt[length(inhalt)-1].emFelder[emF,true]:=
+      (inhalt[length(inhalt)-2].emFelder[emF,false] -
+       inhalt[length(inhalt)-1].emFelder[emF,false])*iDX;
   end; // (ein bisschen wird noch reflektiert, vmtl. durch numerische Fehler bzw. nicht beachtete numerische Dispersion)
 
   for rechts:=false to true do
     for i:=0 to lichters[rechts].count-1 do
-      inhalt[(length(inhalt)-1)*byte(rechts)].emWerte[efAY,true]:=
-        inhalt[(length(inhalt)-1)*byte(rechts)].emWerte[efAY,true] +
-        exprToFloat(false,lichters[rechts][i],par.kvs,nil);
+      inhalt[(length(inhalt)-1)*byte(rechts)].emFelder[efAY,true]:=
+        inhalt[(length(inhalt)-1)*byte(rechts)].emFelder[efAY,true] +
+        exprToFloat(false,lichters[rechts][i],gitter.kvs,nil);
 end;
 
-procedure tFelder.berechneAbleitungen(dX,iDX,pDNMax: extended);
+procedure tFelder.berechneAbleitungen(dX,iDX: extended);
 var
   i: longint;
+  b: boolean;
 begin
-  for i:=0 to length(inhalt)-1 do
-    inhalt[i].berechneGammaUndP;
-  for i:=0 to length(inhalt)-1 do
-    inhalt[i].berechneDPhiDX(dX);
-  for i:=0 to matAnz-1 do begin // Teilchen werden reflektiert
-    inhalt[1].matWerte[i,mfPX,false]:=
-       abs(inhalt[1].matWerte[i,mfPX,false]);
-    inhalt[length(inhalt)-2].matWerte[i,mfPX,false]:=
-      -abs(inhalt[length(inhalt)-2].matWerte[i,mfPX,false]);
-  end;
-
-  for i:=2 to length(inhalt)-3 do
-    inhalt[i].berechneNAbleitung(iDX,pDNMax);
+  for b:=false to true do
+    inhalt[(length(inhalt)-1)*byte(b)].reflektiereTeilchen(b);
 
-  inhalt[1].berechneNAbleitung(iDX,pDNMax,false);
-  inhalt[length(inhalt)-2].berechneNAbleitung(iDX,pDNMax,true);
+  inhalt[0].berechneEMFelder(dX,false);
+  for i:=1 to length(inhalt)-2 do
+    inhalt[i].berechneEMFelder(dX,iDX);
+  inhalt[length(inhalt)-1].berechneEMFelder(dX,false);
 
   setzeRaender(iDX);
 
   for i:=1 to length(inhalt)-2 do
-    inhalt[i].berechneAbleitungen(iDX);
+    inhalt[i].berechneEMAbleitungen(iDX);
+  for i:=1 to length(inhalt)-2 do
+    inhalt[i].berechnePhasenraumAbleitungen(iDX);
 end;
 
-function tFelder.maxDT: extended;
+procedure tFelder.setzeNull;
 var
   i: longint;
 begin
-  result:=inhalt[0].maxDT;
-  for i:=1 to length(inhalt)-1 do
-    result:=min(result,inhalt[i].maxDT);
+  for i:=0 to length(inhalt)-1 do
+    inhalt[i].setzeNull;
 end;
 
-{ tGitter }
+// tGitter *********************************************************************
 
-constructor tGitter.create(derBesitzer: tSimulation; size: longint; deltaT,deltaX,pDNMa: extended; bekannteWerte: tKnownValues; teilchen: array of tTeilchenSpezies; lichter: tMyStringlist; zv: tZeitverfahren; protokollant: tProtokollant; name: string);
+constructor tGitter.create(derBesitzer: tSimulation; size: longint; deltaX: extended; bekannteWerte: tKnownValues; teilchen: array of tTeilchenSpezies; lichter: tMyStringlist; zv: tZeitverfahren; protokollant: tProtokollant; name: string; aPX,aPY,aPZ: longint; dPX,dPY,dPZ: extended);
 var
   i: longint;
 begin
@@ -920,14 +1015,8 @@ begin
   zeitverfahren:=zv;
   kvs:=bekannteWerte;
   prot:=tProtokollant.create(protokollant,name);
-  dTMaximum:=deltaT;
   dX:=deltaX;
   iDX:=1/dX;
-  if pDNMa < 0 then begin
-    pDNMax:=0;
-    pDNMaxDynamisch:=true;
-  end
-  else pDNMax:=pDNMa;
   case Zeitverfahren of
     zfEulerVorwaerts:
       Setlength(Felders,2);
@@ -943,7 +1032,7 @@ begin
   xl:=dX/2;
 
   for i:=0 to length(felders)-1 do
-    felders[i]:=tFelder.create(size,teilchen,lichter,self);
+    felders[i]:=tFelder.create(size,teilchen,lichter,self,aPX,aPY,aPZ,dPX,dPY,dPZ);
 
   aktuelleFelder:=0;
   t:=0;
@@ -960,99 +1049,29 @@ begin
   inherited destroy;
 end;
 
-procedure tGitter.diffusionsTermAnpassen(pro: tProtokollant);
-var
-  i,j,k:      longint;
-  curMax,tmp: extended;
-begin
-  curMax:=0;
-  k:=0;
-  for i:=1 to length(felders[aktuelleFelder].inhalt)-2 do
-    for j:=0 to felders[aktuelleFelder].matAnz-1 do begin
-      tmp:=abs(felders[aktuelleFelder].inhalt[i].matWerte[j,mfPx,false]*
-               (felders[aktuelleFelder].inhalt[i+1].matWerte[j,mfN,false] - felders[aktuelleFelder].inhalt[i-1].matWerte[j,mfN,false])/
-               max(felders[aktuelleFelder].inhalt[i+1].matWerte[j,mfN,false] + felders[aktuelleFelder].inhalt[i-1].matWerte[j,mfN,false],1e-100));
-      if tmp>curMax then begin
-        curMax:=tmp;
-        k:=i;
-      end;
-    end;
-  if curMax > pDNMax then begin
-    if pDNMaxDynamisch then begin
-      pDNMax:=2*curMax;
-      pro.schreibe('Neues maximales px * dn/dx / n: '+floattostr(pDNMax)+' (t='+floattostr(t)+')');
-    end
-    else
-    if pDNMax>0 then begin
-      pro.schreibe('Warnung: maximaler Impuls * dn/dx / n von '+floattostr(pDNMax)+' wurde überschritten (t='+floattostr(t)+
-        'T, x='+floattostr(xL+k*dX)+'), die numerische Stabilität ist nicht mehr gewährleistet, Simulation wird abgebrochen!',true);
-      pro.schreibe(' Lösung: größeren Diffusionsterm wählen',true);
-      pro.schreibe(' außerdem empfohlen: Ortsauflösung in gleichem Maße verbessern',true);
-      abbrechen;
-    end;
-  end;
-end;
-
-function tGitter.pruefeMaxDT(aF: longint; var dTMax,dT: extended; dTMin: extended): boolean; // wurde verkleinert?
-begin
-  dTMax:=min(dTMax,felders[aF].maxDT);
-    // das maximale dT, welches bei den momentanen Ableitungen nicht zu
-    // unphysikalischen Effekten (z.B. negativen Dichten) führt
-
-  result:=(dTMax<dT) and (dT>1.1*dTMin);
-  if result then begin // beabsichtigter Zeitschritt ist zu groß,
-    dT:=dTMax/4;       // dann machen wir ihn doch kleiner!
-    if dT<dTMin then
-      dT:=dTMin
-    {$IFDEF Zeitschrittueberwachung}
-    else begin
-      prot.schreibe('pruefeMaxDT: dT -> '+floattostr(dT)+' (t = '+floattostr(t)+')');
-      prot.spuelen;
-    end
-    {$ENDIF};
-  end;
-end;
-
 procedure tGitter.abbrechen;
 var
-  i,j,k: longint;
-  maF:   tMaterieFeldInhalt;
-  emF:   tEMFeldInhalt;
-  abl:   boolean;
+  i: longint;
 begin
   abbruch:=true;
   for i:=0 to length(felders)-1 do
-    for j:=0 to length(felders[i].inhalt)-1 do begin
-      for emF:=low(tEMFeldInhalt) to high(tEMFeldInhalt) do
-        for abl:=false to true do
-          felders[i].inhalt[j].emWerte[emF,false]:=0;
-      for k:=0 to felders[i].matAnz-1 do
-        for maF:=low(tMaterieFeldInhalt) to high(tMaterieFeldInhalt) do
-          for abl:=false to true do
-            felders[i].inhalt[j].matWerte[k,maF,false]:=0;
-    end;
+    felders[i].setzeNull;
 end;
 
-procedure tGitter.iteriereSchritt(var dT: extended; dTMin: extended);
-var {$IFDEF negativeDichteueberwachung}
-    i,j:     longint;
+procedure tGitter.iteriereSchritt(dT: extended);
+    {$IFDEF negativeDichteueberwachung}
+var i,j:     longint;
     pro:     tProtokollant;
     {$ENDIF}
-    dTMax:   extended;
 begin
   if abbruch then begin
     t:=t+dT;
     exit;
   end;
   kvs.add('t',t);
-  diffusionsTermAnpassen(prot);
-  dTMax:=dX*100;
 
   repeat
-    felders[aktuelleFelder].berechneAbleitungen(dX,iDX,pDNMax); // y' = y'(t,y(t))
-
-    if pruefeMaxDT(aktuelleFelder,dTMax,dT,dTMin) then
-      continue;
+    felders[aktuelleFelder].berechneAbleitungen(dX,iDX); // y' = y'(t,y(t))
 
     case zeitverfahren of
       zfEulerVorwaerts: // y(t+dt) = y(t) + y' dt
@@ -1121,85 +1140,22 @@ begin
         end;
   {$ENDIF}
   t:=t+dT;
-  dT:=max(dT,dTMax/100);
-end;
-
-function tGitter.dumpErhaltungsgroessen: boolean;
-var i,j:     integer;
-    ns:      tExtendedArray;
-    pro:     tProtokollant;
-    s:       string;
-begin
-  pro:=tProtokollant.create(prot,'dumpErhaltungsgroessen');
-  setlength(ns,felders[aktuelleFelder].matAnz);
-
-  result:=true;
-
-  s:='';
-  for i:=0 to length(ns)-1 do
-    ns[i]:=0;
-  for i:=0 to length(felders[aktuelleFelder].inhalt)-1 do
-    for j:=0 to length(ns)-1 do
-      ns[j]:=  ns[j]  +  felders[aktuelleFelder].inhalt[i].matWerte[j,mfN,false];
-  for i:=0 to length(ns)-1 do begin
-    ns[i]:=ns[i]*dX;
-    s:=s+ ' n['+inttostr(i)+']='+floattostr(ns[i]);
-    {$IFDEF Dichteueberwachung}
-    if (not abbruch) and (abs(ns[i]-felders[aktuelleFelder].massen[i])>0.5) then begin
-      result:=false;
-      pro.schreibe(' n['+inttostr(i)+'] ('+floattostr(ns[i])+') unterscheidet sich stark vom Anfangswert ('+floattostr(felders[aktuelleFelder].massen[i])+'), es scheinen sehr viele Teilchen entstanden oder verloren gegangen zu sein. Die Simulation wird abgebrochen. (t='+floattostr(t)+')',true);
-    end;
-    {$ENDIF}
-  end;
-  delete(s,1,1);
-  prot.schreibe(s);
-  pro.free;
-end;
-
-procedure tGitter.berechne(was: char; teilchen: longint);
-var
-  i:   longint;
-  tmp: extended;
-  emF: tEMFeldInhalt;
-  maF: tMaterieFeldInhalt;
-begin
-  if was='A' then begin
-    for i:=0 to length(felders[aktuelleFelder].inhalt)-1 do begin
-      tmp:=0;
-      for emF:=efAX to efAZ do
-        tmp:=tmp+sqr(felders[aktuelleFelder].inhalt[i].emWerte[emF,false]);
-      felders[aktuelleFelder].inhalt[i].emWerte[efA,false]:=sqrt(tmp);
-    end;
-    exit;
-  end;
-  if was='P' then begin
-    for i:=0 to length(felders[aktuelleFelder].inhalt)-1 do begin
-      tmp:=0;
-      for maF:=mfPX to mfPZ do
-        tmp:=tmp+sqr(felders[aktuelleFelder].inhalt[i].matWerte[teilchen,maF,false]);
-      felders[aktuelleFelder].inhalt[i].matWerte[teilchen,maF,false]:=sqrt(tmp);
-    end;
-    exit;
-  end;
-  prot.schreibe('Kann '''+was+''' nicht berechnen, weil ich es nicht verstehe!',true);
-  prot.destroyall;
-  halt;
 end;
 
-{ tSimulation }
+// tSimulation *****************************************************************
 
 constructor tSimulation.create(inName: string; protokollant: tProtokollant; name: string);
 var
-  ifile:                                   tMyStringlist;
-  zeitverfahren:                           tZeitverfahren;
-  s,t,aSuffix,aPrefix:                     string;
-  deltaX,breite,pDNMax:                    extended;
-  i:                                       longint;
-  kvs:                                     tKnownValues;
-  teilchen:                                array of tTeilchenSpezies;
-  lichter:                                 tMyStringlist;
-  pro:                                     tProtokollant;
-  na:                                      pSigActionRec;
+  ifile:                                       tMyStringlist;
+  zeitverfahren:                               tZeitverfahren;
+  s,t,aSuffix,aPrefix:                         string;
+  deltaX,breite,dPX,dPY,dPZ,pXMax,pYMax,pZMax: extended;
+  i:                                           longint;
+  kvs:                                         tKnownValues;
+  teilchen:                                    array of tTeilchenSpezies;
+  lichter:                                     tMyStringlist;
+  pro:                                         tProtokollant;
+  na:                                          pSigActionRec;
 begin
   inherited create;
   prot:=tProtokollant.create(protokollant,name);
@@ -1227,20 +1183,24 @@ begin
   sDX:=-1;
   tEnde:=100;
   breite:=10.0;
-  pDNMax:=-1;
   fortschrittsAnzeige:=false;
-  dTMin:=-1;
   gotSighup:=false;
+  dPX:=-1;
+  dPY:=-1;
+  dPZ:=-1;
+  pXMax:=3;
+  pYMax:=3;
+  pZMax:=3;
 
   // Standardeinstellungen Bereich 'ausgaben'
   aPrefix:=extractfilepath(paramstr(0));
   aSuffix:='.dat';
   setlength(ausgabeDateien,0);
 
-  // Standardeinstellungen Breich 'lichtVon...'
+  // Standardeinstellungen Bereich 'lichtVon...'
   lichter:=tMyStringlist.create(prot,'lichter');
 
-  // Standardeinstellungen Breich 'teilchen...'
+  // Standardeinstellungen Bereich 'teilchen...'
   setlength(teilchen,0);
 
   repeat
@@ -1295,12 +1255,40 @@ begin
           kvs.add('dT',dT);
           continue;
         end;
-        if startetMit('minZeitschritt ',s) then begin
-          dTMin:=exprtofloat(false,s,kvs,nil);
+        if startetMit('impulsschritt ',s) then begin
+          if startetMit('x ',s) then begin
+            dPX:=exprtofloat(false,s,kvs,nil);
+            continue;
+          end;
+          if startetMit('y ',s) then begin
+            dPY:=exprtofloat(false,s,kvs,nil);
+            continue;
+          end;
+          if startetMit('z ',s) then begin
+            dPZ:=exprtofloat(false,s,kvs,nil);
+            continue;
+          end;
+          dPX:=exprtofloat(false,s,kvs,nil);
+          dPY:=dPX;
+          dPZ:=dPX;
           continue;
         end;
-        if startetMit('diffusionsterm ',s) then begin
-          pDNMax:=exprtofloat(false,s,kvs,nil);
+        if startetMit('maximalimpuls ',s) then begin
+          if startetMit('x ',s) then begin
+            pXMax:=exprtofloat(false,s,kvs,nil);
+            continue;
+          end;
+          if startetMit('y ',s) then begin
+            pYMax:=exprtofloat(false,s,kvs,nil);
+            continue;
+          end;
+          if startetMit('z ',s) then begin
+            pZMax:=exprtofloat(false,s,kvs,nil);
+            continue;
+          end;
+          pXMax:=exprtofloat(false,s,kvs,nil);
+          pYMax:=pXMax;
+          pZMax:=pXMax;
           continue;
         end;
         if startetMit('zeit ',s) then begin
@@ -1443,8 +1431,13 @@ begin
   sT:=sDT/2;
   if sDX<0 then
     sDX:=deltaX;
-  if dTMin<0 then
-    dTMin:=min(1E-30,dT*1E-5);
+
+  if dPX<0 then
+    dPX:=deltaX;
+  if dPY<0 then
+    dPY:=sqrt(deltaX);
+  if dPZ<0 then
+    dPZ:=sqrt(deltaX);
 
   pro:=tProtokollant.create(prot,'create');
   case zeitverfahren of
@@ -1466,7 +1459,12 @@ begin
   pro.schreibe('dX = '+floattostr(deltaX));
   pro.schreibe('dT = '+floattostr(dT));
   pro.schreibe('breite = '+floattostr(breite)+' (= '+inttostr(round(breite/deltaX)+1)+' Punkte)');
-  pro.schreibe('pDNMax = '+floattostr(pDNMax));
+  pro.schreibe('dPX  =  '+floattostr(dPX));
+  pro.schreibe('pXMax = '+floattostr(pXMax));
+  pro.schreibe('dPY  =  '+floattostr(dPY));
+  pro.schreibe('pYMax = '+floattostr(pYMax));
+  pro.schreibe('dPZ  =  '+floattostr(dPZ));
+  pro.schreibe('pZMax = '+floattostr(pZMax));
   pro.schreibe('bekannte Werte:');
   kvs.dump(pro,'  ');
   if length(teilchen)>0 then begin
@@ -1505,7 +1503,7 @@ begin
   setlength(sighupSimulationen,length(sighupSimulationen)+1);
   sighupSimulationen[length(sighupSimulationen)-1]:=self;
 
-  gitter:=tGitter.create(self,round(breite/deltaX)+1,dT,deltaX,pDNMax,kvs,teilchen,lichter,zeitverfahren,prot,'gitter');
+  gitter:=tGitter.create(self,round(breite/deltaX)+1,deltaX,kvs,teilchen,lichter,zeitverfahren,prot,'gitter',2*round(pXMax/dPX)+1,2*round(pYMax/dPY)+1,2*round(pZMax/dPZ)+1,dPX,dPY,dPZ);
   for i:=0 to length(teilchen)-1 do
     teilchen[i].free;
   setlength(teilchen,0);
@@ -1541,7 +1539,7 @@ begin
 
   zeitPhysik:=zeitPhysik-now;
   if errorCode<2 then
-    gitter.iteriereSchritt(dT,dTMin);
+    gitter.iteriereSchritt(dT);
   zeitPhysik:=zeitPhysik+now;
   zeitDatei:=zeitDatei-now;
   while (gitter.t>=sT) and (sT<tEnde) do begin
@@ -1558,11 +1556,6 @@ begin
     prot.schreibe(timetostr(now-start)+' ('+floattostr(zeitPhysik/max(1e-11,zeitPhysik+zeitDatei))+')',true);
     prot.schreibe('ETA: '+timetostr((now-start)*(tEnde-Gitter.t)/max(Gitter.t,dT)),true);
     prot.schreibe('aktueller Zeitschritt: '+floattostr(dT)+'T',true);
-    if errorCode<2 then
-      if not gitter.dumpErhaltungsgroessen then begin
-        errorCode:=2;
-        exit;
-      end;
   end;
 
   result:=gitter.t<tEnde;
diff --git a/Plasmapropagation.lpi b/Plasmapropagation.lpi
index c722825..fcb19b7 100644
--- a/Plasmapropagation.lpi
+++ b/Plasmapropagation.lpi
@@ -32,7 +32,7 @@
         <LaunchingApplication PathPlusParams="/usr/bin/screen -T 'Lazarus Run Output' -e $(LazarusDir)/tools/runwait.sh $(TargetCmdLine)"/>
       </local>
     </RunParams>
-    <Units Count="5">
+    <Units Count="6">
       <Unit0>
         <Filename Value="Plasmapropagation.lpr"/>
         <IsPartOfProject Value="True"/>
@@ -53,6 +53,10 @@
         <Filename Value="linearkombination.inc"/>
         <IsPartOfProject Value="True"/>
       </Unit4>
+      <Unit5>
+        <Filename Value="linearkombinationen.inc"/>
+        <IsPartOfProject Value="True"/>
+      </Unit5>
     </Units>
   </ProjectOptions>
   <CompilerOptions>
diff --git a/Plasmapropagation.lps b/Plasmapropagation.lps
index 6e683c8..b7f8821 100644
--- a/Plasmapropagation.lps
+++ b/Plasmapropagation.lps
@@ -3,7 +3,7 @@
   <ProjectSession>
     <Version Value="9"/>
     <BuildModes Active="Default"/>
-    <Units Count="18">
+    <Units Count="19">
       <Unit0>
         <Filename Value="Plasmapropagation.lpr"/>
         <IsPartOfProject Value="True"/>
@@ -15,13 +15,14 @@
       <Unit1>
         <Filename Value="Physikunit.pas"/>
         <IsPartOfProject Value="True"/>
+        <IsVisibleTab Value="True"/>
         <EditorIndex Value="1"/>
-        <TopLine Value="620"/>
-        <CursorPos X="32" Y="673"/>
-        <FoldState Value=" T3mD0,5 pjSlM0A[94BjZ0803114 T0\8Q/0F171M"/>
-        <UsageCount Value="142"/>
+        <TopLine Value="1437"/>
+        <CursorPos X="40" Y="1467"/>
+        <FoldState Value=" T3m00/5 pjdlc0A[94Cja0B413 piXlT0E115]BckQ0a211122 p0v70G011 T0!QPc07121N"/>
+        <UsageCount Value="154"/>
         <Bookmarks Count="1">
-          <Item0 Y="1077"/>
+          <Item0 Y="1096"/>
         </Bookmarks>
         <Loaded Value="True"/>
       </Unit1>
@@ -30,34 +31,32 @@
         <IsPartOfProject Value="True"/>
         <EditorIndex Value="-1"/>
         <CursorPos X="15" Y="46"/>
-        <UsageCount Value="104"/>
+        <UsageCount Value="116"/>
       </Unit2>
       <Unit3>
         <Filename Value="input.plap"/>
         <IsPartOfProject Value="True"/>
-        <EditorIndex Value="3"/>
-        <TopLine Value="9"/>
-        <CursorPos Y="29"/>
-        <UsageCount Value="103"/>
+        <EditorIndex Value="4"/>
+        <CursorPos X="44" Y="23"/>
+        <UsageCount Value="115"/>
         <Loaded Value="True"/>
         <DefaultSyntaxHighlighter Value="None"/>
       </Unit3>
       <Unit4>
         <Filename Value="linearkombination.inc"/>
         <IsPartOfProject Value="True"/>
-        <EditorIndex Value="2"/>
-        <TopLine Value="88"/>
-        <CursorPos X="50" Y="100"/>
-        <UsageCount Value="51"/>
+        <EditorIndex Value="3"/>
+        <TopLine Value="51"/>
+        <CursorPos X="62" Y="77"/>
+        <UsageCount Value="63"/>
         <Loaded Value="True"/>
       </Unit4>
       <Unit5>
         <Filename Value="input.epost"/>
-        <IsVisibleTab Value="True"/>
-        <EditorIndex Value="4"/>
-        <TopLine Value="13"/>
-        <CursorPos X="9" Y="27"/>
-        <UsageCount Value="85"/>
+        <EditorIndex Value="5"/>
+        <TopLine Value="22"/>
+        <CursorPos X="36" Y="29"/>
+        <UsageCount Value="91"/>
         <Loaded Value="True"/>
         <DefaultSyntaxHighlighter Value="None"/>
       </Unit5>
@@ -67,14 +66,14 @@
         <TopLine Value="366"/>
         <CursorPos X="27" Y="390"/>
         <FoldState Value=" T3i905B pj0jV034 piaj60U511+"/>
-        <UsageCount Value="16"/>
+        <UsageCount Value="15"/>
       </Unit6>
       <Unit7>
         <Filename Value="../units/lowlevelunit.pas"/>
         <EditorIndex Value="-1"/>
         <TopLine Value="46"/>
         <CursorPos X="3" Y="12"/>
-        <UsageCount Value="9"/>
+        <UsageCount Value="8"/>
       </Unit7>
       <Unit8>
         <Filename Value="../units/mystringlistunit.pas"/>
@@ -82,187 +81,196 @@
         <TopLine Value="367"/>
         <CursorPos X="17" Y="390"/>
         <FoldState Value=" T3i3075 piZjD0WQ"/>
-        <UsageCount Value="7"/>
+        <UsageCount Value="6"/>
       </Unit8>
       <Unit9>
         <Filename Value="../epost/werteunit.pas"/>
         <EditorIndex Value="-1"/>
         <TopLine Value="950"/>
         <CursorPos X="30" Y="1054"/>
-        <UsageCount Value="4"/>
+        <UsageCount Value="3"/>
       </Unit9>
       <Unit10>
         <Filename Value="../epost/typenunit.pas"/>
         <EditorIndex Value="-1"/>
         <TopLine Value="347"/>
         <CursorPos X="62" Y="358"/>
-        <UsageCount Value="4"/>
+        <UsageCount Value="3"/>
       </Unit10>
       <Unit11>
         <Filename Value="../units/systemunit.pas"/>
         <EditorIndex Value="-1"/>
         <CursorPos X="3" Y="79"/>
-        <UsageCount Value="4"/>
+        <UsageCount Value="3"/>
       </Unit11>
       <Unit12>
         <Filename Value="/usr/lib/fpc/src/rtl/inc/objpash.inc"/>
         <EditorIndex Value="-1"/>
         <TopLine Value="232"/>
         <CursorPos X="23" Y="192"/>
-        <UsageCount Value="4"/>
+        <UsageCount Value="3"/>
       </Unit12>
       <Unit13>
         <Filename Value="rk14.inc"/>
         <EditorIndex Value="-1"/>
-        <UsageCount Value="7"/>
+        <UsageCount Value="6"/>
       </Unit13>
       <Unit14>
         <Filename Value="rk1210.inc"/>
         <EditorIndex Value="-1"/>
         <TopLine Value="492"/>
         <CursorPos X="28" Y="565"/>
-        <UsageCount Value="8"/>
+        <UsageCount Value="7"/>
       </Unit14>
       <Unit15>
         <Filename Value="rk1412.inc"/>
         <EditorIndex Value="-1"/>
         <TopLine Value="945"/>
         <CursorPos X="5" Y="985"/>
-        <UsageCount Value="8"/>
+        <UsageCount Value="7"/>
       </Unit15>
       <Unit16>
         <Filename Value="rk108.inc"/>
         <EditorIndex Value="-1"/>
         <CursorPos X="28" Y="8"/>
-        <UsageCount Value="8"/>
+        <UsageCount Value="7"/>
       </Unit16>
       <Unit17>
         <Filename Value="rk3_8.inc"/>
         <EditorIndex Value="-1"/>
-        <CursorPos X="75" Y="23"/>
-        <UsageCount Value="9"/>
+        <CursorPos X="41" Y="6"/>
+        <UsageCount Value="10"/>
       </Unit17>
+      <Unit18>
+        <Filename Value="linearkombinationen.inc"/>
+        <IsPartOfProject Value="True"/>
+        <EditorIndex Value="2"/>
+        <TopLine Value="89"/>
+        <CursorPos X="77" Y="102"/>
+        <UsageCount Value="26"/>
+        <Loaded Value="True"/>
+      </Unit18>
     </Units>
     <JumpHistory Count="30" HistoryIndex="29">
       <Position1>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="126" Column="17" TopLine="93"/>
+        <Caret Line="954" Column="69" TopLine="934"/>
       </Position1>
       <Position2>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="521" Column="50" TopLine="433"/>
+        <Caret Line="1237" Column="13" TopLine="1202"/>
       </Position2>
       <Position3>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="550" Column="51" TopLine="509"/>
+        <Caret Line="1146" Column="30" TopLine="968"/>
       </Position3>
       <Position4>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="551" Column="51" TopLine="510"/>
+        <Caret Line="202" Column="46" TopLine="178"/>
       </Position4>
       <Position5>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="665" Column="28" TopLine="326"/>
+        <Caret Line="125" Column="25" TopLine="98"/>
       </Position5>
       <Position6>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="798" Column="44" TopLine="765"/>
+        <Caret Line="705" Column="38" TopLine="641"/>
       </Position6>
       <Position7>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="799" Column="25" TopLine="766"/>
+        <Caret Line="715" Column="17" TopLine="691"/>
       </Position7>
       <Position8>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="800" Column="34" TopLine="767"/>
+        <Caret Line="742" Column="23" TopLine="724"/>
       </Position8>
       <Position9>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="801" Column="51" TopLine="774"/>
+        <Caret Line="941" Column="26" TopLine="851"/>
       </Position9>
       <Position10>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="67" Column="22" TopLine="47"/>
+        <Caret Line="125" TopLine="114"/>
       </Position10>
       <Position11>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="425" Column="4" TopLine="210"/>
+        <Caret Line="725" Column="41" TopLine="692"/>
       </Position11>
       <Position12>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="438" Column="63" TopLine="216"/>
+        <Caret Line="24" Column="10" TopLine="24"/>
       </Position12>
       <Position13>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="801" Column="51" TopLine="768"/>
+        <Caret Line="203" Column="50" TopLine="183"/>
       </Position13>
       <Position14>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1385" Column="60" TopLine="1232"/>
+        <Caret Line="721" TopLine="692"/>
       </Position14>
       <Position15>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="789" Column="63" TopLine="773"/>
+        <Caret Line="734" TopLine="714"/>
       </Position15>
       <Position16>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="10" Column="28"/>
+        <Caret Line="731" Column="53" TopLine="714"/>
       </Position16>
       <Position17>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1024" Column="31" TopLine="784"/>
+        <Caret Line="724" Column="22" TopLine="692"/>
       </Position17>
       <Position18>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1067" Column="29" TopLine="1056"/>
+        <Caret Line="124" Column="38" TopLine="89"/>
       </Position18>
       <Position19>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1019" TopLine="861"/>
+        <Caret Line="125" Column="38" TopLine="125"/>
       </Position19>
       <Position20>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="11" Column="3"/>
+        <Caret Line="957" Column="38" TopLine="925"/>
       </Position20>
       <Position21>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1023" Column="5" TopLine="1000"/>
+        <Caret Line="641" TopLine="560"/>
       </Position21>
       <Position22>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="9" Column="33"/>
+        <Caret Line="101" TopLine="77"/>
       </Position22>
       <Position23>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="991" Column="36" TopLine="787"/>
+        <Caret Line="100" Column="15" TopLine="80"/>
       </Position23>
       <Position24>
-        <Filename Value="input.epost"/>
-        <Caret Line="27" TopLine="5"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="661" Column="87" TopLine="520"/>
       </Position24>
       <Position25>
-        <Filename Value="input.epost"/>
-        <Caret Line="44" Column="15" TopLine="5"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="641" Column="52" TopLine="521"/>
       </Position25>
       <Position26>
-        <Filename Value="input.epost"/>
-        <Caret Line="56" Column="27" TopLine="19"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="100" Column="62" TopLine="80"/>
       </Position26>
       <Position27>
-        <Filename Value="input.epost"/>
-        <Caret Line="47" TopLine="25"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="802" Column="120" TopLine="765"/>
       </Position27>
       <Position28>
-        <Filename Value="input.epost"/>
-        <Caret Line="57" TopLine="25"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="794" Column="66" TopLine="765"/>
       </Position28>
       <Position29>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="989" Column="35" TopLine="903"/>
+        <Caret Line="128" Column="59" TopLine="110"/>
       </Position29>
       <Position30>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="24" Column="13"/>
+        <Caret Line="995" Column="49" TopLine="1078"/>
       </Position30>
     </JumpHistory>
   </ProjectSession>
diff --git a/input.plap b/input.plap
index 83607cf..8e6fe6c 100644
--- a/input.plap
+++ b/input.plap
@@ -7,11 +7,11 @@ allgemein
   runge-Kutta-3/8
 #  runge-Kutta-4
 #  euler-Vorwärts
-  ortsschritt    2*10^-3 * λ
-  zeitschritt    2*10^-3 * T
-  minZeitschritt 2*10^-3 * T
+  ortsschritt    10^-2 * λ
+  zeitschritt    10^-2 * T
+#  minZeitschritt 10^-2 * T
   zeit           40 * T
-  diffusionsterm 2                # max. p/Lp
+#  diffusionsterm 2                # max. p/Lp
 !setze $breite: (5 * λ)
   breite         $breite
   mit Fortschrittsanzeige
@@ -20,7 +20,7 @@ allgemeinEnde
 ausgaben
   prefix         /home_raid/erich/Dokumente/Prograemmchen/Plasmapropagation/Daten/
   suffix         _test.dat
-  felder         AX,AY,dAYDT,dPhiDX,N1,dPsiDX1,Gamma1,N2,dPsiDX2,Gamma2
+  felder         AX,AY,dAYDT,EX,BY,BZ,Rho1,Rho2
 ausgabenEnde
 
 !setze $tFwhm:   (2.5 * T)
diff --git a/linearkombination.inc b/linearkombination.inc
index 6250006..0f74497 100644
--- a/linearkombination.inc
+++ b/linearkombination.inc
@@ -1,7 +1,93 @@
+// Werte werden auf (in1 + \sum_i faki * ini') gesetzt
+
+procedure tImpulsPunkt.liKo(in1,in2
+{$IFDEF lkA3},in3
+{$IFDEF lkA4},in4
+{$IFDEF lkA5},in5
+{$IFDEF lkA6},in6
+{$IFDEF lkA7},in7
+{$IFDEF lkA8},in8
+{$IFDEF lkA9},in9
+{$IFDEF lkA10},in10
+{$IFDEF lkA11},in11
+{$IFDEF lkA12},in12
+{$IFDEF lkA14},in13,in14
+{$IFDEF lkA15},in15
+{$IFDEF lkA16},in16
+{$IFDEF lkA17},in17
+{$IFDEF lkA18},in18
+{$IFDEF lkA19},in19
+{$IFDEF lkA22},in20,in21,in22
+{$IFDEF lkA23},in23
+{$IFDEF lkA31},in24,in25,in26,in27,in28,in29,in30,in31
+{$IFDEF lkA32},in32
+{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}: tImpulsPunkt;
+fak2
+{$IFDEF lkA3},fak3
+{$IFDEF lkA4},fak4
+{$IFDEF lkA5},fak5
+{$IFDEF lkA6},fak6
+{$IFDEF lkA7},fak7
+{$IFDEF lkA8},fak8
+{$IFDEF lkA9},fak9
+{$IFDEF lkA10},fak10
+{$IFDEF lkA11},fak11
+{$IFDEF lkA12},fak12
+{$IFDEF lkA14},fak13,fak14
+{$IFDEF lkA15},fak15
+{$IFDEF lkA16},fak16
+{$IFDEF lkA17},fak17
+{$IFDEF lkA18},fak18
+{$IFDEF lkA19},fak19
+{$IFDEF lkA22},fak20,fak21,fak22
+{$IFDEF lkA23},fak23
+{$IFDEF lkA31},fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31
+{$IFDEF lkA32},fak32
+{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}: extended);
+var
+  i:   longint;
+begin
+  for i:=0 to length(werte)-1 do
+    werte[i,false]:=
+      in1.werte[i,false]
+      + fak2  * in2.werte[i,true]  {$IFDEF lkA3}
+      + fak3  * in3.werte[i,true]  {$IFDEF lkA4}
+      + fak4  * in4.werte[i,true]  {$IFDEF lkA5}
+      + fak5  * in5.werte[i,true]  {$IFDEF lkA6}
+      + fak6  * in6.werte[i,true]  {$IFDEF lkA7}
+      + fak7  * in7.werte[i,true]  {$IFDEF lkA8}
+      + fak8  * in8.werte[i,true]  {$IFDEF lkA9}
+      + fak9  * in9.werte[i,true]  {$IFDEF lkA10}
+      + fak10 * in10.werte[i,true] {$IFDEF lkA11}
+      + fak11 * in11.werte[i,true] {$IFDEF lkA12}
+      + fak12 * in12.werte[i,true] {$IFDEF lkA14}
+      + fak13 * in13.werte[i,true]
+      + fak14 * in14.werte[i,true] {$IFDEF lkA15}
+      + fak15 * in15.werte[i,true] {$IFDEF lkA16}
+      + fak16 * in16.werte[i,true] {$IFDEF lkA17}
+      + fak17 * in17.werte[i,true] {$IFDEF lkA18}
+      + fak18 * in18.werte[i,true] {$IFDEF lkA19}
+      + fak19 * in19.werte[i,true] {$IFDEF lkA22}
+      + fak20 * in20.werte[i,true]
+      + fak21 * in21.werte[i,true]
+      + fak22 * in22.werte[i,true] {$IFDEF lkA23}
+      + fak23 * in23.werte[i,true] {$IFDEF lkA31}
+      + fak24 * in24.werte[i,true]
+      + fak25 * in25.werte[i,true]
+      + fak26 * in26.werte[i,true]
+      + fak27 * in27.werte[i,true]
+      + fak28 * in28.werte[i,true]
+      + fak29 * in29.werte[i,true]
+      + fak30 * in30.werte[i,true]
+      + fak31 * in31.werte[i,true] {$IFDEF lkA32}
+      + fak32 * in32.werte[i,true]
+      {$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF};
+
+end;
 
 // Werte werden auf (in1 + \sum_i faki * ini') gesetzt
 
-procedure tWertePunkt.liKo(in1,in2
+procedure tRaumPunkt.liKo(in1,in2
 {$IFDEF lkA3},in3
 {$IFDEF lkA4},in4
 {$IFDEF lkA5},in5
@@ -22,7 +108,7 @@ procedure tWertePunkt.liKo(in1,in2
 {$IFDEF lkA23},in23
 {$IFDEF lkA31},in24,in25,in26,in27,in28,in29,in30,in31
 {$IFDEF lkA32},in32
-{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}: tWertePunkt;
+{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}: tRaumPunkt;
 fak2
 {$IFDEF lkA3},fak3
 {$IFDEF lkA4},fak4
@@ -46,8 +132,7 @@ fak2
 {$IFDEF lkA32},fak32
 {$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}: extended);
 var
-  emF: tEMFeldInhalt;
-  maF: tMaterieFeldInhalt;
+  emF: tEMFeldGroesze;
   i:   longint;
 begin
 (*  tEMFeldInhalt = (
@@ -56,82 +141,87 @@ begin
       efDPhiDX
     ); *)
   for emF:=erstesEMFMitAbleitung to letztesEMFMitAbleitung do
-    emWerte[emF,false]:=
-      in1.emWerte[emF,false]
-      + fak2  * in2.emWerte[emF,true]  {$IFDEF lkA3}
-      + fak3  * in3.emWerte[emF,true]  {$IFDEF lkA4}
-      + fak4  * in4.emWerte[emF,true]  {$IFDEF lkA5}
-      + fak5  * in5.emWerte[emF,true]  {$IFDEF lkA6}
-      + fak6  * in6.emWerte[emF,true]  {$IFDEF lkA7}
-      + fak7  * in7.emWerte[emF,true]  {$IFDEF lkA8}
-      + fak8  * in8.emWerte[emF,true]  {$IFDEF lkA9}
-      + fak9  * in9.emWerte[emF,true]  {$IFDEF lkA10}
-      + fak10 * in10.emWerte[emF,true] {$IFDEF lkA11}
-      + fak11 * in11.emWerte[emF,true] {$IFDEF lkA12}
-      + fak12 * in12.emWerte[emF,true] {$IFDEF lkA14}
-      + fak13 * in13.emWerte[emF,true]
-      + fak14 * in14.emWerte[emF,true] {$IFDEF lkA15}
-      + fak15 * in15.emWerte[emF,true] {$IFDEF lkA16}
-      + fak16 * in16.emWerte[emF,true] {$IFDEF lkA17}
-      + fak17 * in17.emWerte[emF,true] {$IFDEF lkA18}
-      + fak18 * in18.emWerte[emF,true] {$IFDEF lkA19}
-      + fak19 * in19.emWerte[emF,true] {$IFDEF lkA22}
-      + fak20 * in20.emWerte[emF,true]
-      + fak21 * in21.emWerte[emF,true]
-      + fak22 * in22.emWerte[emF,true] {$IFDEF lkA23}
-      + fak23 * in23.emWerte[emF,true] {$IFDEF lkA31}
-      + fak24 * in24.emWerte[emF,true]
-      + fak25 * in25.emWerte[emF,true]
-      + fak26 * in26.emWerte[emF,true]
-      + fak27 * in27.emWerte[emF,true]
-      + fak28 * in28.emWerte[emF,true]
-      + fak29 * in29.emWerte[emF,true]
-      + fak30 * in30.emWerte[emF,true]
-      + fak31 * in31.emWerte[emF,true] {$IFDEF lkA32}
-      + fak32 * in32.emWerte[emF,true]
+    emFelder[emF,false]:=
+      in1.emFelder[emF,false]
+      + fak2  * in2.emFelder[emF,true]  {$IFDEF lkA3}
+      + fak3  * in3.emFelder[emF,true]  {$IFDEF lkA4}
+      + fak4  * in4.emFelder[emF,true]  {$IFDEF lkA5}
+      + fak5  * in5.emFelder[emF,true]  {$IFDEF lkA6}
+      + fak6  * in6.emFelder[emF,true]  {$IFDEF lkA7}
+      + fak7  * in7.emFelder[emF,true]  {$IFDEF lkA8}
+      + fak8  * in8.emFelder[emF,true]  {$IFDEF lkA9}
+      + fak9  * in9.emFelder[emF,true]  {$IFDEF lkA10}
+      + fak10 * in10.emFelder[emF,true] {$IFDEF lkA11}
+      + fak11 * in11.emFelder[emF,true] {$IFDEF lkA12}
+      + fak12 * in12.emFelder[emF,true] {$IFDEF lkA14}
+      + fak13 * in13.emFelder[emF,true]
+      + fak14 * in14.emFelder[emF,true] {$IFDEF lkA15}
+      + fak15 * in15.emFelder[emF,true] {$IFDEF lkA16}
+      + fak16 * in16.emFelder[emF,true] {$IFDEF lkA17}
+      + fak17 * in17.emFelder[emF,true] {$IFDEF lkA18}
+      + fak18 * in18.emFelder[emF,true] {$IFDEF lkA19}
+      + fak19 * in19.emFelder[emF,true] {$IFDEF lkA22}
+      + fak20 * in20.emFelder[emF,true]
+      + fak21 * in21.emFelder[emF,true]
+      + fak22 * in22.emFelder[emF,true] {$IFDEF lkA23}
+      + fak23 * in23.emFelder[emF,true] {$IFDEF lkA31}
+      + fak24 * in24.emFelder[emF,true]
+      + fak25 * in25.emFelder[emF,true]
+      + fak26 * in26.emFelder[emF,true]
+      + fak27 * in27.emFelder[emF,true]
+      + fak28 * in28.emFelder[emF,true]
+      + fak29 * in29.emFelder[emF,true]
+      + fak30 * in30.emFelder[emF,true]
+      + fak31 * in31.emFelder[emF,true] {$IFDEF lkA32}
+      + fak32 * in32.emFelder[emF,true]
       {$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF};
 
-(*  tMaterieFeldInhalt = (
-      mfN,mfDPsiDX,
-      mfP,mfPX,mfPY,mfPZ,
-      mfGamma,mfIGamma
-    ); *)
-  for i:=0 to length(matWerte)-1 do // siehe oben
-    for maF:=erstesMatFMitAbleitung to letztesMatFMitAbleitung do
-      matWerte[i,maF,false]:=
-        in1.matWerte[i,maF,false]
-        + fak2  * in2.matWerte[i,maF,true]  {$IFDEF lkA3}
-        + fak3  * in3.matWerte[i,maF,true]  {$IFDEF lkA4}
-        + fak4  * in4.matWerte[i,maF,true]  {$IFDEF lkA5}
-        + fak5  * in5.matWerte[i,maF,true]  {$IFDEF lkA6}
-        + fak6  * in6.matWerte[i,maF,true]  {$IFDEF lkA7}
-        + fak7  * in7.matWerte[i,maF,true]  {$IFDEF lkA8}
-        + fak8  * in8.matWerte[i,maF,true]  {$IFDEF lkA9}
-        + fak9  * in9.matWerte[i,maF,true]  {$IFDEF lkA10}
-        + fak10 * in10.matWerte[i,maF,true] {$IFDEF lkA11}
-        + fak11 * in11.matWerte[i,maF,true] {$IFDEF lkA12}
-        + fak12 * in12.matWerte[i,maF,true] {$IFDEF lkA14}
-        + fak13 * in13.matWerte[i,maF,true]
-        + fak14 * in14.matWerte[i,maF,true] {$IFDEF lkA15}
-        + fak15 * in15.matWerte[i,maF,true] {$IFDEF lkA16}
-        + fak16 * in16.matWerte[i,maF,true] {$IFDEF lkA17}
-        + fak17 * in17.matWerte[i,maF,true] {$IFDEF lkA18}
-        + fak18 * in18.matWerte[i,maF,true] {$IFDEF lkA19}
-        + fak19 * in19.matWerte[i,maF,true] {$IFDEF lkA22}
-        + fak20 * in20.matWerte[i,maF,true]
-        + fak21 * in21.matWerte[i,maF,true]
-        + fak22 * in22.matWerte[i,maF,true] {$IFDEF lkA23}
-        + fak23 * in23.matWerte[i,maF,true] {$IFDEF lkA31}
-        + fak24 * in24.matWerte[i,maF,true]
-        + fak25 * in25.matWerte[i,maF,true]
-        + fak26 * in26.matWerte[i,maF,true]
-        + fak27 * in27.matWerte[i,maF,true]
-        + fak28 * in28.matWerte[i,maF,true]
-        + fak29 * in29.matWerte[i,maF,true]
-        + fak30 * in30.matWerte[i,maF,true]
-        + fak31 * in31.matWerte[i,maF,true] {$IFDEF lkA32}
-        + fak32 * in32.matWerte[i,maF,true]
-        {$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF};
+  for i:=0 to length(phasenraum)-1 do
+    phasenraum[i].liKo(
+      in1.phasenraum[i],in2.phasenraum[i]
+      {$IFDEF lkA3},in3.phasenraum[i]
+      {$IFDEF lkA4},in4.phasenraum[i]
+      {$IFDEF lkA5},in5.phasenraum[i]
+      {$IFDEF lkA6},in6.phasenraum[i]
+      {$IFDEF lkA7},in7.phasenraum[i]
+      {$IFDEF lkA8},in8.phasenraum[i]
+      {$IFDEF lkA9},in9.phasenraum[i]
+      {$IFDEF lkA10},in10.phasenraum[i]
+      {$IFDEF lkA11},in11.phasenraum[i]
+      {$IFDEF lkA12},in12.phasenraum[i]
+      {$IFDEF lkA14},in13.phasenraum[i],in14.phasenraum[i]
+      {$IFDEF lkA15},in15.phasenraum[i]
+      {$IFDEF lkA16},in16.phasenraum[i]
+      {$IFDEF lkA17},in17.phasenraum[i]
+      {$IFDEF lkA18},in18.phasenraum[i]
+      {$IFDEF lkA19},in19.phasenraum[i]
+      {$IFDEF lkA22},in20.phasenraum[i],in21.phasenraum[i],in22.phasenraum[i]
+      {$IFDEF lkA23},in23.phasenraum[i]
+      {$IFDEF lkA31},in24.phasenraum[i],in25.phasenraum[i],in26.phasenraum[i],in27.phasenraum[i],in28.phasenraum[i],in29.phasenraum[i],in30.phasenraum[i],in31.phasenraum[i]
+      {$IFDEF lkA32},in32.phasenraum[i]
+      {$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF},
+      fak2
+      {$IFDEF lkA3},fak3
+      {$IFDEF lkA4},fak4
+      {$IFDEF lkA5},fak5
+      {$IFDEF lkA6},fak6
+      {$IFDEF lkA7},fak7
+      {$IFDEF lkA8},fak8
+      {$IFDEF lkA9},fak9
+      {$IFDEF lkA10},fak10
+      {$IFDEF lkA11},fak11
+      {$IFDEF lkA12},fak12
+      {$IFDEF lkA14},fak13,fak14
+      {$IFDEF lkA15},fak15
+      {$IFDEF lkA16},fak16
+      {$IFDEF lkA17},fak17
+      {$IFDEF lkA18},fak18
+      {$IFDEF lkA19},fak19
+      {$IFDEF lkA22},fak20,fak21,fak22
+      {$IFDEF lkA23},fak23
+      {$IFDEF lkA31},fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31
+      {$IFDEF lkA32},fak32
+      {$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF}{$ENDIF});
 end;
 
 // Werte werden auf (in1 + \sum_i faki * ini') gesetzt
@@ -233,4 +323,3 @@ begin
     inhalt[i].nichtnegativieren;
 end;
 
-
diff --git a/linearkombinationen.inc b/linearkombinationen.inc
new file mode 100644
index 0000000..724c695
--- /dev/null
+++ b/linearkombinationen.inc
@@ -0,0 +1,129 @@
+
+// interface *******************************************************************
+
+{$IFDEF LiKotImpulsPunktHeader}
+procedure liKo(in1,in2: tImpulsPunkt; fak2: extended); overload;                            // Werte werden auf (in1 + \sum_i faki * ini') gesetzt
+procedure liKo(in1,in2,in3: tImpulsPunkt; fak2,fak3: extended); overload;
+procedure liKo(in1,in2,in3,in4: tImpulsPunkt; fak2,fak3,fak4: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5: tImpulsPunkt; fak2,fak3,fak4,fak5: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23,in24,in25,in26,in27,in28,in29,in30,in31: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23,fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23,in24,in25,in26,in27,in28,in29,in30,in31,in32: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23,fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31,fak32: extended); overload;
+{$ENDIF}
+
+{$IFDEF LiKotRaumPunktHeader}
+procedure liKo(in1,in2: tRaumPunkt; fak2: extended); overload;                            // Werte werden auf (in1 + \sum_i faki * ini') gesetzt
+procedure liKo(in1,in2,in3: tRaumPunkt; fak2,fak3: extended); overload;
+procedure liKo(in1,in2,in3,in4: tRaumPunkt; fak2,fak3,fak4: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5: tRaumPunkt; fak2,fak3,fak4,fak5: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6: tRaumPunkt; fak2,fak3,fak4,fak5,fak6: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23,in24,in25,in26,in27,in28,in29,in30,in31: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23,fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23,in24,in25,in26,in27,in28,in29,in30,in31,in32: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23,fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31,fak32: extended); overload;
+{$ENDIF}
+
+{$IFDEF LiKotFelderHeader}
+procedure liKo(in1,in2: tFelder; fak2: extended); overload;                            // Werte werden auf (in1 + \sum_i faki * ini') gesetzt
+procedure liKo(in1,in2,in3: tFelder; fak2,fak3: extended); overload;
+procedure liKo(in1,in2,in3,in4: tFelder; fak2,fak3,fak4: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5: tFelder; fak2,fak3,fak4,fak5: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6: tFelder; fak2,fak3,fak4,fak5,fak6: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7: tFelder; fak2,fak3,fak4,fak5,fak6,fak7: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23,in24,in25,in26,in27,in28,in29,in30,in31: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23,fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31: extended); overload;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21,in22,in23,in24,in25,in26,in27,in28,in29,in30,in31,in32: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23,fak24,fak25,fak26,fak27,fak28,fak29,fak30,fak31,fak32: extended); overload;
+{$ENDIF}
+
+
+
+
+
+
+
+
+// implementation **************************************************************
+
+{$IFDEF LiKoimplementation}
+
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA3}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA4}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA5}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA6}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA7}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA8}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA9}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA10}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA11}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA12}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA14}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA15}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA16}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA17}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA18}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA19}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA22}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA23}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA31}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA32}
+{$INCLUDE linearkombination.inc}
+
+{$ENDIF}
diff --git a/rk108.inc b/rk108.inc
index 0f98175..9e3a79f 100644
--- a/rk108.inc
+++ b/rk108.inc
@@ -3,10 +3,8 @@
     felders[aktuelleFelder],
     0.1 * dT
   );
-  felders[2].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[2].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(2,dTMax,dT,dTMin) then
-    continue;
 
   felders[3].liKo(
     felders[aktuelleFelder],
@@ -15,10 +13,8 @@
     -0.91517656137529144052001501927534215431895138766436972056466 * dT,
     1.45453440217827322805250021715664459117622483736537873607016 * dT
   );
-  felders[3].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[3].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(3,dTMax,dT,dTMin) then
-    continue;
 
   felders[4].liKo(
     felders[aktuelleFelder],
@@ -27,10 +23,8 @@
     0.202259190301118170324681949205488413821477543637878380814562 * dT,
     0.606777570903354510974045847616465241464432630913635142443687 * dT
   );
-  felders[4].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[4].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(4,dTMax,dT,dTMin) then
-    continue;
 
   felders[5].liKo(
     felders[aktuelleFelder],
@@ -41,10 +35,8 @@
     0.197966831227192369068141770510388793370637287463360401555746 * dT,
     -0.0729547847313632629185146671595558023015011608914382961421311 * dT
   );
-  felders[5].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[5].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(5,dTMax,dT,dTMin) then
-    continue;
 
   felders[6].liKo(
     felders[aktuelleFelder],
@@ -55,10 +47,8 @@
     0.410459702520260645318174895920453426088035325902848695210406 * dT,
     0.482713753678866489204726942976896106809132737721421333413261 * dT
   );
-  felders[6].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[6].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(6,dTMax,dT,dTMin) then
-    continue;
 
   felders[7].liKo(
     felders[aktuelleFelder],
@@ -71,10 +61,8 @@
     0.48966295730945019284450701113589820117801547843379009721079 * dT,
     -0.0731856375070850736789057580558988816340355615025188195854775 * dT
   );
-  felders[7].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[7].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(7,dTMax,dT,dTMin) then
-    continue;
 
   felders[8].liKo(
     felders[aktuelleFelder],
@@ -87,10 +75,8 @@
     0.0325402621549091330158899334391231259332716675992700000776101 * dT,
     -0.0595780211817361001560122202563305121444953672762930724538856 * dT
   );
-  felders[8].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[8].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(8,dTMax,dT,dTMin) then
-    continue;
 
   felders[9].liKo(
     felders[aktuelleFelder],
@@ -103,10 +89,8 @@
     0.32176370560177839010089879904987890408140436860307712925111 * dT,
     0.51048572560806303157775901228512341674467213703175235406759 * dT
   );
-  felders[9].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[9].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(9,dTMax,dT,dTMin) then
-    continue;
 
   felders[10].liKo(
     felders[aktuelleFelder],
@@ -121,10 +105,8 @@
     0.499269229556880061353316843969978567860276816592673201240332 * dT,
     0.50950460892968610423609869004538625398664323235298960218506 * dT
   );
-  felders[10].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[10].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(10,dTMax,dT,dTMin) then
-    continue;
 
   felders[11].liKo(
     felders[aktuelleFelder],
@@ -141,10 +123,8 @@
     0.0107558956873607455550609147441477450257136782823280838547024 * dT,
     -0.327769124164018874147061087350233395378262992392394071906457 * dT
   );
-  felders[11].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[11].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(11,dTMax,dT,dTMin) then
-    continue;
 
   felders[12].liKo(
     felders[aktuelleFelder],
@@ -163,10 +143,8 @@
     -0.0782942710351670777553986729725692447252077047239160551335016 * dT,
     -0.114503299361098912184303164290554670970133218405658122674674 * dT
   );
-  felders[12].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[12].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(12,dTMax,dT,dTMin) then
-    continue;
 
   felders[13].liKo(
     felders[aktuelleFelder],
@@ -191,10 +169,8 @@
     -3.25479342483643918654589367587788726747711504674780680269911 * dT,
     -2.16343541686422982353954211300054820889678036420109999154887 * dT
   );
-  felders[13].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[13].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(13,dTMax,dT,dTMin) then
-    continue;
 
   felders[14].liKo(
     felders[aktuelleFelder],
@@ -221,10 +197,8 @@
     -1.71561608285936264922031819751349098912615880827551992973034 * dT,
     -0.0244036405750127452135415444412216875465593598370910566069132 * dT
   );
-  felders[14].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[14].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(14,dTMax,dT,dTMin) then
-    continue;
 
   felders[15].liKo(
     felders[aktuelleFelder],
@@ -241,10 +215,8 @@
     0.0910895662155176069593203555807484200111889091770101799647985 * dT,
     0.777333643644968233538931228575302137803351053629547286334469 * dT
   );
-  felders[15].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[15].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(15,dTMax,dT,dTMin) then
-    continue;
 
   felders[16].liKo(
     felders[aktuelleFelder],
@@ -255,10 +227,8 @@
     -0.157178665799771163367058998273128921867183754126709419409654 * dT,
     0.157178665799771163367058998273128921867183754126709419409654 * dT
   );
-  felders[16].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[16].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(16,dTMax,dT,dTMin) then
-    continue;
 
   felders[17].liKo(
     felders[aktuelleFelder],
@@ -293,10 +263,8 @@
     -0.34275815984718983994222055341385087174233873470395891993726 * dT,
     -0.675 * dT
   );
-  felders[17].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[17].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(17,dTMax,dT,dTMin) then
-    continue;
 
   felders[1-aktuelleFelder].liKo(
     felders[aktuelleFelder],
diff --git a/rk1210.inc b/rk1210.inc
index 67a95ef..12c6881 100644
--- a/rk1210.inc
+++ b/rk1210.inc
@@ -3,10 +3,8 @@
     felders[aktuelleFelder],
     0.2 * dT
   );
-  felders[2].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[2].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(2,dTMax,dT,dTMin) then
-    continue;
 
   felders[3].liKo(
     felders[aktuelleFelder],
@@ -15,10 +13,8 @@
     -0.216049382716049382716049382716049382716049382716049382716049 * dT,
     0.771604938271604938271604938271604938271604938271604938271605 * dT
   );
-  felders[3].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[3].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(3,dTMax,dT,dTMin) then
-    continue;
 
   felders[4].liKo(
     felders[aktuelleFelder],
@@ -27,10 +23,8 @@
     0.208333333333333333333333333333333333333333333333333333333333 * dT,
     0.625 * dT
   );
-  felders[4].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[4].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(4,dTMax,dT,dTMin) then
-    continue;
 
   felders[5].liKo(
     felders[aktuelleFelder],
@@ -41,10 +35,8 @@
     0.22 * dT,
     -0.08 * dT
   );
-  felders[5].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[5].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(5,dTMax,dT,dTMin) then
-    continue;
 
   felders[6].liKo(
     felders[aktuelleFelder],
@@ -55,10 +47,8 @@
     0.4 * dT,
     0.5 * dT
   );
-  felders[6].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[6].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(6,dTMax,dT,dTMin) then
-    continue;
 
   felders[7].liKo(
     felders[aktuelleFelder],
@@ -71,10 +61,8 @@
     0.48317116756103289928883648045196250872410925751728917730238 * dT,
     -0.038753024569476325208568144376762058039573330234136803880429 * dT
   );
-  felders[7].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[7].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(7,dTMax,dT,dTMin) then
-    continue;
 
   felders[8].liKo(
     felders[aktuelleFelder],
@@ -87,10 +75,8 @@
     0.0137455792075966759812907801835048190594443990939408530842918 * dT,
     -0.0661095317267682844455831341498149531672668252085016565917546 * dT
   );
-  felders[8].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[8].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(8,dTMax,dT,dTMin) then
-    continue;
 
   felders[9].liKo(
     felders[aktuelleFelder],
@@ -103,10 +89,8 @@
     0.0680716801688453518578515120895103863112751730758794372203952 * dT,
     0.408394315582641046727306852653894780093303185664924644551239 * dT
   );
-  felders[9].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[9].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(9,dTMax,dT,dTMin) then
-    continue;
 
   felders[10].liKo(
     felders[aktuelleFelder],
@@ -121,10 +105,8 @@
     0.427930210752576611068192608300897981558240730580396406312359 * dT,
     -0.0865117637557827005740277475955029103267246394128995965941585 * dT
   );
-  felders[10].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[10].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(10,dTMax,dT,dTMin) then
-    continue;
 
   felders[11].liKo(
     felders[aktuelleFelder],
@@ -141,10 +123,8 @@
     -0.951294772321088980532340837388859453930924498799228648050949 * dT,
     -0.408276642965631951497484981519757463459627174520978426909934 * dT
   );
-  felders[11].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[11].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(11,dTMax,dT,dTMin) then
-    continue;
 
   felders[12].liKo(
     felders[aktuelleFelder],
@@ -163,10 +143,8 @@
     0.00263265981064536974369934736325334761174975280887405725010964 * dT,
     0.00315472768977025060103545855572111407955208306374459723959783 * dT
   );
-  felders[12].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[12].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(12,dTMax,dT,dTMin) then
-    continue;
 
   felders[13].liKo(
     felders[aktuelleFelder],
@@ -181,10 +159,8 @@
     0.0000176358982260285155407485928953302139937553442829975734148981 * dT,
     0.0653866627415027051009595231385181033549511358787382098351924 * dT
   );
-  felders[13].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[13].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(13,dTMax,dT,dTMin) then
-    continue;
 
   felders[14].liKo(
     felders[aktuelleFelder],
@@ -201,10 +177,8 @@
     -0.861264460105717678161432562258351242030270498966891201799225 * dT,
     0.908651882074050281096239478469262145034957129939256789178785 * dT
   );
-  felders[14].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[14].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(14,dTMax,dT,dTMin) then
-    continue;
 
   felders[15].liKo(
     felders[aktuelleFelder],
@@ -223,10 +197,8 @@
     0.00535364695524996055083260173615567408717110247274021056118319 * dT,
     0.301167864010967916837091303817051676920059229784957479998077 * dT
   );
-  felders[15].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[15].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(15,dTMax,dT,dTMin) then
-    continue;
 
   felders[16].liKo(
     felders[aktuelleFelder],
@@ -247,10 +219,8 @@
     -0.214007467967990254219503540827349569639028092344812795499026 * dT,
     0.958202417754430239892724139109781371059908874605153648768037 * dT
   );
-  felders[16].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[16].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(16,dTMax,dT,dTMin) then
-    continue;
 
   felders[17].liKo(
     felders[aktuelleFelder],
@@ -273,10 +243,8 @@
     -1.10683733362380649395704708016953056176195769617014899442903 * dT,
     -0.929529037579203999778397238291233214220788057511899747507074 * dT
   );
-  felders[17].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[17].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(17,dTMax,dT,dTMin) then
-    continue;
 
   felders[18].liKo(
     felders[aktuelleFelder],
@@ -307,10 +275,8 @@
     -1.94300935242819610883833776782364287728724899124166920477873 * dT,
     -0.128352601849404542018428714319344620742146491335612353559923 * dT
   );
-  felders[18].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[18].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(18,dTMax,dT,dTMin) then
-    continue;
 
   felders[19].liKo(
     felders[aktuelleFelder],
@@ -343,10 +309,8 @@
     -0.00115618834794939500490703608435907610059605754935305582045729 * dT,
     -0.00544057908677007389319819914241631024660726585015012485938593 * dT
   );
-  felders[19].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[19].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(19,dTMax,dT,dTMin) then
-    continue;
 
   felders[20].liKo(
     felders[aktuelleFelder],
@@ -381,10 +345,8 @@
     0.0418603916412360287969841020776788461794119440689356178942252 * dT,
     0.279084255090877355915660874555379649966282167560126269290222 * dT
   );
-  felders[20].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[20].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(20,dTMax,dT,dTMin) then
-    continue;
 
   felders[21].liKo(
     felders[aktuelleFelder],
@@ -409,10 +371,8 @@
     0.218636633721676647685111485017151199362509373698288330593486 * dT,
     0.438313820361122420391059788940960176420682836652600698580091 * dT
   );
-  felders[21].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[21].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(21,dTMax,dT,dTMin) then
-    continue;
 
   felders[22].liKo(
     felders[aktuelleFelder],
@@ -439,10 +399,8 @@
     0.196410889223054653446526504390100417677539095340135532418849 * dT,
     -0.0984256130499315928152900286856048243348202521491288575952143 * dT
   );
-  felders[22].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[22].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(22,dTMax,dT,dTMin) then
-    continue;
 
   felders[23].liKo(
     felders[aktuelleFelder],
@@ -459,10 +417,8 @@
     0.390696469295978451446999802258495981249099665294395945559163 * dT,
     0.666666666666666666666666666666666666666666666666666666666667 * dT
   );
-  felders[23].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[23].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(23,dTMax,dT,dTMin) then
-    continue;
 
   felders[24].liKo(
     felders[aktuelleFelder],
@@ -473,10 +429,8 @@
     -0.164609053497942386831275720164609053497942386831275720164609 * dT,
     0.164609053497942386831275720164609053497942386831275720164609 * dT
   );
-  felders[24].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[24].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(24,dTMax,dT,dTMin) then
-    continue;
 
   felders[25].liKo(
     felders[aktuelleFelder],
@@ -525,10 +479,8 @@
     -0.421296296296296296296296296296296296296296296296296296296296 * dT,
     -0.7875 * dT
   );
-  felders[25].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[25].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(25,dTMax,dT,dTMin) then
-    continue;
 
   felders[1-aktuelleFelder].liKo(
     felders[aktuelleFelder],
diff --git a/rk1412.inc b/rk1412.inc
index b80ff32..fb8cb56 100644
--- a/rk1412.inc
+++ b/rk1412.inc
@@ -3,10 +3,8 @@
     felders[aktuelleFelder],
     0.111111111111111111111111111111111111111111111111111111111111 * dT
   );
-  felders[2].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[2].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(2,dTMax,dT,dTMin) then
-    continue;
 
   felders[3].liKo(
     felders[aktuelleFelder],
@@ -15,10 +13,8 @@
     -0.833333333333333333333333333333333333333333333333333333333333 * dT,
     1.38888888888888888888888888888888888888888888888888888888889 * dT
   );
-  felders[3].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[3].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(3,dTMax,dT,dTMin) then
-    continue;
 
   felders[4].liKo(
     felders[aktuelleFelder],
@@ -27,10 +23,8 @@
     0.208333333333333333333333333333333333333333333333333333333333 * dT,
     0.625 * dT
   );
-  felders[4].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[4].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(4,dTMax,dT,dTMin) then
-    continue;
 
   felders[5].liKo(
     felders[aktuelleFelder],
@@ -41,10 +35,8 @@
     0.22 * dT,
     -0.08 * dT
   );
-  felders[5].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[5].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(5,dTMax,dT,dTMin) then
-    continue;
 
   felders[6].liKo(
     felders[aktuelleFelder],
@@ -55,10 +47,8 @@
     0.4 * dT,
     0.5 * dT
   );
-  felders[6].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[6].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(6,dTMax,dT,dTMin) then
-    continue;
 
   felders[7].liKo(
     felders[aktuelleFelder],
@@ -71,10 +61,8 @@
     0.482574490331246622475134780125688112865919023850168049679402 * dT,
     -0.038140960001560699973088624000562020566411307247841147742197 * dT
   );
-  felders[7].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[7].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(7,dTMax,dT,dTMin) then
-    continue;
 
   felders[8].liKo(
     felders[aktuelleFelder],
@@ -87,10 +75,8 @@
     0.0137885887618080880607695837016477814530969417491493385363543 * dT,
     -0.06722101339966844497493995074143058569500863415253821828562 * dT
   );
-  felders[8].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[8].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(8,dTMax,dT,dTMin) then
-    continue;
 
   felders[9].liKo(
     felders[aktuelleFelder],
@@ -103,10 +89,8 @@
     0.216019825625503063708860097659866573490979433278117320188668 * dT,
     0.423695063515761937337619073960976753205867469544123532683116 * dT
   );
-  felders[9].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[9].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(9,dTMax,dT,dTMin) then
-    continue;
 
   felders[10].liKo(
     felders[aktuelleFelder],
@@ -121,10 +105,8 @@
     0.0978080858367729012259313014081291665503740655476733940756599 * dT,
     0.217590689243420631360008651767860318344168120024782176879989 * dT
   );
-  felders[10].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[10].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(10,dTMax,dT,dTMin) then
-    continue;
 
   felders[11].liKo(
     felders[aktuelleFelder],
@@ -141,10 +123,8 @@
     -0.247656877593994914689992276329810825853958069263947095548189 * dT,
     0.110895029771437682893999851839061714522445173600678718208625 * dT
   );
-  felders[11].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[11].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(11,dTMax,dT,dTMin) then
-    continue;
 
   felders[12].liKo(
     felders[aktuelleFelder],
@@ -163,10 +143,8 @@
     0.204890423831599428189499202098105603312029235081420653574829 * dT,
     -1.56261579627468188307070943950527825211462892236424360892806 * dT
   );
-  felders[12].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[12].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(12,dTMax,dT,dTMin) then
-    continue;
 
   felders[13].liKo(
     felders[aktuelleFelder],
@@ -181,10 +159,8 @@
     -0.00805328367804983036823857162048902911923392887337029314844206 * dT,
     0.0211517528067396521915711903523399601316877825157550573051221 * dT
   );
-  felders[13].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[13].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(13,dTMax,dT,dTMin) then
-    continue;
 
   felders[14].liKo(
     felders[aktuelleFelder],
@@ -201,10 +177,8 @@
     0.00988442549447664668946335414487885256040819982786014648129297 * dT,
     -0.0213010771328887351384307642875927384886634565429572466632092 * dT
   );
-  felders[14].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[14].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(14,dTMax,dT,dTMin) then
-    continue;
 
   felders[15].liKo(
     felders[aktuelleFelder],
@@ -223,10 +197,8 @@
     -0.977235005036766810872264852372525633013107656892839677696022 * dT,
     -0.660026980479294694616225013856327693720573981219974874776419 * dT
   );
-  felders[15].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[15].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(15,dTMax,dT,dTMin) then
-    continue;
 
   felders[16].liKo(
     felders[aktuelleFelder],
@@ -247,10 +219,8 @@
     0.124343093331358243286225595741786448038973408895106741855721 * dT,
     0.00413829693239480694403512496204335960426192908674476033832967 * dT
   );
-  felders[16].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[16].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(16,dTMax,dT,dTMin) then
-    continue;
 
   felders[17].liKo(
     felders[aktuelleFelder],
@@ -273,10 +243,8 @@
     0.251708904586819292210480529948970541404887852931447491219418 * dT,
     0.779906470345586398810756795282334476023540593411550187024263 * dT
   );
-  felders[17].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[17].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(17,dTMax,dT,dTMin) then
-    continue;
 
   felders[18].liKo(
     felders[aktuelleFelder],
@@ -293,10 +261,8 @@
     0.000591726029494171190528755742777717259844340971924321528178248 * dT,
     -4.01614722154557337064691684906375587732264247950093804676867E-7 * dT
   );
-  felders[18].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[18].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(18,dTMax,dT,dTMin) then
-    continue;
 
   felders[19].liKo(
     felders[aktuelleFelder],
@@ -315,10 +281,8 @@
     -2.04486480935804242706707569691004307904442837552677456232848E-6 * dT,
     0.105328578824431893399799402979093997354240904235172843146582 * dT
   );
-  felders[19].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[19].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(19,dTMax,dT,dTMin) then
-    continue;
 
   felders[20].liKo(
     felders[aktuelleFelder],
@@ -339,10 +303,8 @@
     7.64130548038698765563029310880237651185173367813936997648198 * dT,
     3.50602043659751834989896082949744710968212949893375368243588 * dT
   );
-  felders[20].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[20].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(20,dTMax,dT,dTMin) then
-    continue;
 
   felders[21].liKo(
     felders[aktuelleFelder],
@@ -365,10 +327,8 @@
     -3.64411637921569236846406990361350645806721478409266709351203 * dT,
     -0.804503249910509910899030787958579499315694913210787878260459 * dT
   );
-  felders[21].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[21].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(21,dTMax,dT,dTMin) then
-    continue;
 
   felders[22].liKo(
     felders[aktuelleFelder],
@@ -393,10 +353,8 @@
     13.1939710030282333443670964371153238435064159623744975073252 * dT,
     1.25128781283980445450114974148056006317268830077396406361417 * dT
   );
-  felders[22].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[22].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(22,dTMax,dT,dTMin) then
-    continue;
 
   felders[23].liKo(
     felders[aktuelleFelder],
@@ -423,10 +381,8 @@
     0.422422733996325326010225127471388772575086538809603346825334 * dT,
     0.0859131249503067107308438031499859443441115056294154956487671 * dT
   );
-  felders[23].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[23].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(23,dTMax,dT,dTMin) then
-    continue;
 
   felders[24].liKo(
     felders[aktuelleFelder],
@@ -463,10 +419,8 @@
     0.0210134706331264177317735424331396407424412188443757490871603 * dT,
     0.00952196014417121794175101542454575907376360233658356240547761 * dT
   );
-  felders[24].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[24].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(24,dTMax,dT,dTMin) then
-    continue;
 
   felders[25].liKo(
     felders[aktuelleFelder],
@@ -505,10 +459,8 @@
     -0.0870718339841810522431884137957986245724252047388936572215438 * dT,
     -7.39351814158303067567016952195521063999185773249132944724553 * dT
   );
-  felders[25].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[25].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(25,dTMax,dT,dTMin) then
-    continue;
 
   felders[26].liKo(
     felders[aktuelleFelder],
@@ -549,10 +501,8 @@
     4.79282506449930799649797749629840189457296934139359048988332 * dT,
     0.153725464873068577844576387402512082757034273069877432944621 * dT
   );
-  felders[26].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[26].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(26,dTMax,dT,dTMin) then
-    continue;
 
   felders[27].liKo(
     felders[aktuelleFelder],
@@ -599,10 +549,8 @@
     -1.35548714715078654978732186705996404017554501614191325114947 * dT,
     -1.57196275801232751882901735171459249177687219114442583461866 * dT
   );
-  felders[27].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[27].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(27,dTMax,dT,dTMin) then
-    continue;
 
   felders[28].liKo(
     felders[aktuelleFelder],
@@ -651,10 +599,8 @@
     1.6267482744706653746298936492962893398812502928418368027902 * dT,
     0.491719043846229147070666628704194097678081907210673044988866 * dT
   );
-  felders[28].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[28].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(28,dTMax,dT,dTMin) then
-    continue;
 
   felders[29].liKo(
     felders[aktuelleFelder],
@@ -689,10 +635,8 @@
     -0.0439870229715046685058790092341545026046103890294261359042581 * dT,
     -0.13758560676332522486565963219678774664744722297508486597544 * dT
   );
-  felders[29].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[29].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(29,dTMax,dT,dTMin) then
-    continue;
 
   felders[30].liKo(
     felders[aktuelleFelder],
@@ -729,10 +673,8 @@
     1.96337522866858908928262850028093813988180440518267404553576 * dT,
     0.856238975085428354755349769879501772112121597411563802855067 * dT
   );
-  felders[30].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[30].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(30,dTMax,dT,dTMin) then
-    continue;
 
   felders[31].liKo(
     felders[aktuelleFelder],
@@ -769,10 +711,8 @@
     0.711915811585189227887648262043794387578291882406745570495765 * dT,
     0.550499525310802324138388507020508177411414311000037561712836 * dT
   );
-  felders[31].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[31].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(31,dTMax,dT,dTMin) then
-    continue;
 
   felders[32].liKo(
     felders[aktuelleFelder],
@@ -811,10 +751,8 @@
     0.254297048076270161384068506997153122141835626976703920846242 * dT,
     -0.109993425580724703919462404865068340845119058295846426463652 * dT
   );
-  felders[32].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[32].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(32,dTMax,dT,dTMin) then
-    continue;
 
   felders[33].liKo(
     felders[aktuelleFelder],
@@ -831,10 +769,8 @@
     0.492529543718026304422682049114021320200214681580657784719074 * dT,
     0.75 * dT
   );
-  felders[33].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[33].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(33,dTMax,dT,dTMin) then
-    continue;
 
   felders[34].liKo(
     felders[aktuelleFelder],
@@ -845,10 +781,8 @@
     -0.222222222222222222222222222222222222222222222222222222222222 * dT,
     0.222222222222222222222222222222222222222222222222222222222222 * dT
   );
-  felders[34].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[34].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(34,dTMax,dT,dTMin) then
-    continue;
 
   felders[35].liKo(
     felders[aktuelleFelder],
@@ -915,10 +849,8 @@
     -0.21875 * dT,
     -0.291666666666666666666666666666666666666666666666666666666667 * dT
   );
-  felders[35].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[35].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(35,dTMax,dT,dTMin) then
-    continue;
 
   felders[1-aktuelleFelder].liKo(
     felders[aktuelleFelder],
diff --git a/rk3_8.inc b/rk3_8.inc
index 3419dab..20b70f6 100644
--- a/rk3_8.inc
+++ b/rk3_8.inc
@@ -3,10 +3,8 @@
     felders[aktuelleFelder],
     1/3 * dT
   );
-  felders[2].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[2].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(2,dTMax,dT,dTMin) then
-    continue;
 
   felders[3].liKo(
     felders[aktuelleFelder],
@@ -15,10 +13,8 @@
     -1/3 * dT,
     1 * dT
   );
-  felders[3].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[3].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(3,dTMax,dT,dTMin) then
-    continue;
 
   felders[4].liKo(
     felders[aktuelleFelder],
@@ -29,10 +25,8 @@
     -1 * dT,
     1 * dT
   );
-  felders[4].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[4].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(4,dTMax,dT,dTMin) then
-    continue;
 
   felders[1-aktuelleFelder].liKo(
     felders[aktuelleFelder],
diff --git a/rk4.inc b/rk4.inc
index 4b1cc86..3d05cc4 100644
--- a/rk4.inc
+++ b/rk4.inc
@@ -3,30 +3,24 @@
     felders[aktuelleFelder],
     0.5 * dT
   );
-  felders[2].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[2].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(2,dTMax,dT,dTMin) then
-    continue;
 
   felders[3].liKo(
     felders[aktuelleFelder],
     felders[2],
     0.5 * dT
   );
-  felders[3].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[3].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(3,dTMax,dT,dTMin) then
-    continue;
 
   felders[4].liKo(
     felders[aktuelleFelder],
     felders[3],
     1 * dT
   );
-  felders[4].berechneAbleitungen(dX,iDX,pDNMax);
+  felders[4].berechneAbleitungen(dX,iDX);
 
-  if pruefeMaxDT(4,dTMax,dT,dTMin) then
-    continue;
 
   felders[1-aktuelleFelder].liKo(
     felders[aktuelleFelder],
diff --git a/rktopas b/rktopas
index 589f8d3..7198e7f 100755
--- a/rktopas
+++ b/rktopas
@@ -15,10 +15,10 @@ do
     echo -ne "${lines}" | grep "^${i} \+" | sed "s/^[0-9]\+ \+\([0-9]\+\) \+[-0-9.*^/]\+$/,\n    felders[\1]/" | tr "\n" ";" | sed "s/;,/,/g" | sed "s/;$//" | tr ";" "\n" | sed "s/felders\[1\]/felders[aktuelleFelder]/g" >> ${outputFile}
     echo -ne "${lines}" | grep "^${i} \+" | sed "s/^[0-9]\+ \+[0-9]\+ \+\([-0-9.*^/]\+\)$/,\n    \1 * dT/" | tr "\n" ";" | sed "s/,;/,\n/g" | sed "s/;,/,/g" | tr ";" " " | sed "s/ $//" | sed "s/\*10^/E/g" >> ${outputFile}
     echo -e "\n  );" >> ${outputFile}
-    echo "  felders[${i}].berechneAbleitungen(dX,iDX,pDNMax);" >> ${outputFile}
+    echo "  felders[${i}].berechneAbleitungen(dX,iDX);" >> ${outputFile}
     echo >> ${outputFile}
-    echo "  if pruefeMaxDT(${i},dTMax,dT,dTMin) then" >> ${outputFile}
-    echo "    continue;" >> ${outputFile}
+#    echo "  if pruefeMaxDT(${i},dTMax,dT,dTMin) then" >> ${outputFile}
+#    echo "    continue;" >> ${outputFile}
     echo >> ${outputFile}
   done