Tagesendstand, Kampf gegen fftw in vollem Gange

13 files changed, 1055 insertions, 1228 deletions

diff --git a/Physikunit.pas b/Physikunit.pas
index 556334d..b49675b 100644
--- a/Physikunit.pas
+++ b/Physikunit.pas
@@ -13,7 +13,7 @@ unit Physikunit;
 interface
 
 uses
-  Classes, SysUtils, Math, protokollunit, matheunit, mystringlistunit, lowlevelunit, baseUnix;
+  Classes, SysUtils, Math, protokollunit, matheunit, mystringlistunit, lowlevelunit, baseUnix, fftw_l;
 
 type
   tZeitverfahren = (zfEulerVorwaerts,zfRungeKuttaDreiAchtel,zfRungeKuttaVier,zfRungeKuttaZehn,zfRungeKuttaZwoelf,zfRungeKuttaVierzehn);
@@ -21,7 +21,7 @@ type
   tEMFeldGroesze = (
     efAX,efAY,
     efDAXDT,efDAYDT,
-    efEX,efBY,efBZ
+    efEX,efBZ
   );
   tEMQuellGroesze = (
     eqRho,eqJX,eqJY
@@ -37,7 +37,6 @@ const
 
 type
 
-  tRaumPunkt = class;
   tFelder = class;
   tGitter = class;
   tSimulation = class;
@@ -87,87 +86,51 @@ type
     procedure liesDichteFunktion(rest: string; ifile: tMyStringList; kvs: tKnownValues; teilchen: array of tTeilchenSpezies; prot: tProtokollant);
   end;
 
-  { tImpulsPunkt }
-
-  tImpulsPunkt = class(tObject) // Besetzungsdichten verschiedener Teilchenspezies für ein Paar (r;p)
-  private
-    raumpunkt:  tRaumPunkt;
-    nachbarn:   array[0..1,boolean] of tImpulsPunkt; // x- und px-Nachbarn (jeweil in Richtung - und +)
-    istNullPkt: boolean;
-  public
-    werte:   array of array[boolean] of extended; // Besetzungsdichten und deren Ableitungen für verschiedene Teilchenspezies
-    iMGamma: array of extended;                   // 1/m/gamma (= v/p)
-    grad:    array of array[0..1] of extended;    // Ableitung der Besetzungsdichte nach x und px
-    constructor create(anzTeilchen: longint); overload; // NullPunkt erstellen
-    constructor create(rp: tRaumPunkt; linksRaum,linksImpuls: tImpulsPunkt; anzTeilchen: longint); overload;
-    destructor destroy; override;
-    {$DEFINE LiKotImpulsPunktHeader}
-    {$INCLUDE linearkombinationen.inc}
-    {$UNDEF LiKotImpulsPunktHeader}
-    function nichtnegativieren: extended; inline;
-    procedure akkumuliereEMQuellen(var emQuellen: tEMQuellen; pX,dVP: extended); inline;
-    function gibMirWas(var defizit: extended; entfernung, teilchen,richtung: longint; positiv: boolean): boolean; inline; // ich habe jemanden erreicht
-    procedure setzeNull; inline;
-    procedure berechneAbleitungen(pX: extended); inline;
-    property istNullPunkt: boolean read istNullPkt;
-  end;
-
-  { tRaumPunkt }
-
-  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
-    matFelder: array of array[tMaterieFeldGroesze,boolean] of extended;   // impulsunabhängige Materiefelder getrennt nach Teilchenspezies
-    lN,rN:    tRaumPunkt;                                                 // Nachbarpunkte
-    dP:       extended;                                                   // Impulsdiskretisierung
-    aP:       longint;                                                    // Anzahl der Impulsbins
-
-    constructor create(linkerNachbar: tRaumPunkt; derBesitzer: tFelder; teilchen,_aP: longint; _dP: extended);
-    destructor destroy; override;
-    procedure berechneEMFelder(dX: extended; rechts: boolean); overload; inline;
-    procedure berechneEMFelder(dX,iDX: extended); overload; inline;
-    procedure berechneEMQuellen;
-    procedure berechneEMAbleitungen(iDX: extended); inline;
-    procedure berechnePhasenraumAbleitungen; inline;
-    {$DEFINE LiKotRaumPunktHeader}
-    {$INCLUDE linearkombinationen.inc}
-    {$UNDEF LiKotRaumPunktHeader}
-    function nichtnegativieren: extended; inline;
-    function impulsIntegral(teilchen: longint; emQ: tEMQuellGroesze): extended; overload; inline;
-    function impulsIntegral(teilchen: longint; maF: tMaterieSpeicherGroesze): extended; overload; inline;
-    procedure initialisiereDichte(teilchen: longint; breite,n: extended); inline;
-    procedure reflektiereTeilchen(rechts: boolean); inline;
-    procedure setzeNull; inline;
-    procedure berechnePY; inline;
-  end;
-
   { TFelder }
+(*
+  procedure berechneAbleitungen(pX: extended); inline;
+  function nichtnegativieren: extended; inline;
+*)
 
   tFelder = class(tObject) // repräsentiert eine Simulationsbox von Feldern inklusive deren Ableitungen
   private
-    teilchen:      array of tTeilchenSpezies;
-    lichters:      array[boolean] of tMyStringlist;
-    massen:        array of extended;               // Gesamtmassen je Teilchenspezies zur Überwachung der Erhaltungsgrößen
-    gesamtDefizit: extended;
-    procedure setzeRaender(iDX: extended);
+
+    // 2d-Arrays (x & px) sind wie folgt indiziert: [iP + iX*aP]
+
+    teilchen:           array of tTeilchenSpezies;
+    lichters:           array[boolean] of tMyStringlist;
+    massen:             array of extended;                         // Gesamtmassen je Teilchenspezies zur Überwachung der Erhaltungsgrößen
+    gesamtDefizit:      extended;
+    impulsRaumGradient: array of array[0..1] of pExtended;         // Ableitung des Impulsraumes nach x und px
+    iMGamma:            array of pExtended;                        // 1/m/gamma (= v/p)
+    _aX,_aP:            longint;
+    _dX,_dP,iDX:        extended;
+    ffts:               array of array[0..1,boolean] of fftw_plan_extended; // fft-Algorithmen
+    fftTmp:             Pcomplex_extended;                         // Zwischenspeicher für ffts
+    procedure initialisiereDichte(ort,tlc: longint; breite,n: extended); inline;
   public
-    inhalt: array of tRaumPunkt;
+    emFelder:  array[tEMFeldGroesze,boolean] of pExtended;         // EM-Felder und deren Zeitableitungen
+                                                                   // dPhiDX und B[xyz] haben keine sinnvolle Ableitung hier!
+    emQuellen: array[tEMQuellGroesze] of pExtended;                // Quellen für die EM-Felder
+    matFelder: array of array[tMaterieFeldGroesze] of pExtended;   // px-unabhängige Felder, nach Teilchenspezies sortiert
+    impulsraum: array of array[boolean] of pExtended;              // px-abhängige Felder, nach Teilchenspezies sortiert, sowie deren Ableitung
+
     gitter: tGitter;
 
-    constructor create(groesse: longint; _teilchen: array of tTeilchenSpezies; lichter: tMyStringList; parent: tGitter; aP: longint; dP: extended);
+    constructor create(anzX,anzP: longint; deltaX,deltaP: extended; _teilchen: array of tTeilchenSpezies; lichter: tMyStringList; parent: tGitter);
     destructor destroy; override;
-    procedure berechneAbleitungen(dX,iDX: extended); inline;
-    procedure berechneGradienten(iDX,iDP: extended);
-    {$DEFINE LiKotFelderHeader}
-    {$INCLUDE linearkombinationen.inc}
-    {$UNDEF LiKotFelderHeader}
+    procedure berechneAbleitungen;
     procedure setzeNull; inline;
     procedure dumpErhaltungsgroeszen(prot: tProtokollant);
+    property aX: longint read _aX;
+    property aP: longint read _aP;
+    property dX: extended read _dX;
+    property dP: extended read _dP;
+    function impulsIntegral(ort,tlc: longint; emQ: tEMQuellGroesze): extended; overload; inline;
+    function impulsIntegral(ort,tlc: longint; maF: tMaterieSpeicherGroesze): extended; overload; inline;
+    {$DEFINE LiKoInterface}
+    {$INCLUDE linearkombinationen.inc}
+    {$UNDEF LiKoInterface}
   end;
 
   { tGitter }
@@ -186,7 +149,7 @@ type
     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; deltaX: extended; bekannteWerte: tKnownValues; teilchen: array of tTeilchenSpezies; lichter: tMyStringlist; zv: tZeitverfahren; protokollant: tProtokollant; name: string; aP: longint; dP: extended);
+    constructor create(derBesitzer: tSimulation; aX,aP: longint; deltaX,deltaP: extended; bekannteWerte: tKnownValues; teilchen: array of tTeilchenSpezies; lichter: tMyStringlist; zv: tZeitverfahren; protokollant: tProtokollant; name: string);
     destructor destroy; override;
     procedure iteriereSchritt(dT: extended);
     procedure dumpErhaltungsgroeszen;
@@ -214,7 +177,7 @@ implementation
 
 const
   emFeldNamen: array[tEMFeldGroesze] of string = (
-    'AX','AY','DAXDT','DAYDT','EX','BY','BZ'
+    'AX','AY','DAXDT','DAYDT','EX','BZ'
   );
   emQuellNamen: array[tEMQuellGroesze] of string = (
     'RHO','JX','JY'
@@ -399,7 +362,7 @@ begin
   if sT>=nNum+sDT/2 then
     schreibeKopf;
 
-  cnt:=floor(((length(gitter.felders[gitter.aktuelleFelder].inhalt)-1)*gitter.dX+Min(gitter.dX,sDX)/2)/sDX+1);
+  cnt:=floor(((gitter.felders[gitter.aktuelleFelder].aX-1)*gitter.dX+Min(gitter.dX,sDX)/2)/sDX+1);
   cX:=gitter.xl;
   sX:=cX+(cnt-1)*sDX;
 
@@ -423,20 +386,20 @@ begin
   sX:=cX-Min(gitter.dX,sDX)/2;
   case wasSpeichern of
     0: // em-Feld speichern
-      for i:=0 to length(gitter.felders[gitter.aktuelleFelder].inhalt)-1 do begin
+      for i:=0 to gitter.felders[gitter.aktuelleFelder].aX-1 do begin
         while cX>=sX do begin
           dec(cnt);
-          move(gitter.felders[gitter.aktuelleFelder].inhalt[i].emFelder[emFeld,ableitung],(buf+bufPos)^,sizeof(extended));
+          move((gitter.felders[gitter.aktuelleFelder].emFelder[emFeld,ableitung]+i)^,(buf+bufPos)^,sizeof(extended));
           inc(bufPos,sizeof(extended));
           sX:=sX+sDX;
         end;
         cX:=cX+gitter.dX;
       end;
     1:  // em-Quelle
-      for i:=0 to length(gitter.felders[gitter.aktuelleFelder].inhalt)-1 do begin
+      for i:=0 to gitter.felders[gitter.aktuelleFelder].aX-1 do begin
         while cX>=sX do begin
           dec(cnt);
-          val:=gitter.felders[gitter.aktuelleFelder].inhalt[i].impulsIntegral(teilchen,emQuelle);
+          val:=gitter.felders[gitter.aktuelleFelder].impulsIntegral(i,teilchen,emQuelle);
           move(val,(buf+bufPos)^,sizeof(extended));
           inc(bufPos,sizeof(extended));
           sX:=sX+sDX;
@@ -444,10 +407,10 @@ begin
         cX:=cX+gitter.dX;
       end;
     2:  // Materiefeld
-      for i:=0 to length(gitter.felders[gitter.aktuelleFelder].inhalt)-1 do begin
+      for i:=0 to gitter.felders[gitter.aktuelleFelder].aX-1 do begin
         while cX>=sX do begin
           dec(cnt);
-          val:=gitter.felders[gitter.aktuelleFelder].inhalt[i].impulsIntegral(teilchen,matFeld);
+          val:=gitter.felders[gitter.aktuelleFelder].impulsIntegral(i,teilchen,matFeld);
           move(val,(buf+bufPos)^,sizeof(extended));
           inc(bufPos,sizeof(extended));
           sX:=sX+sDX;
@@ -583,365 +546,402 @@ begin
   end;
 end;
 
-// tImpulsPunkt ****************************************************************
-
-constructor tImpulsPunkt.create(anzTeilchen: longint);
+(*
+function tRaumPunkt.nichtnegativieren: extended; // Dichten nicht negativ machen
 var
-  i,j: longint;
-  b:   boolean;
+  i: longint;
 begin
-  inherited create;
-  istNullPkt:=true; // als NullPunkt erstellen
-  raumPunkt:=nil;
-  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;
-  fillchar(grad,sizeof(grad),#0);
-  setlength(grad,anzTeilchen);
-  for i:=0 to length(grad)-1 do
-    for j:=0 to 1 do
-      grad[i,j]:=0;
-  fillchar(iMGamma,sizeof(iMGamma),#0);
-  setlength(iMGamma,length(werte));
-  for i:=0 to length(iMGamma)-1 do
-    iMGamma[i]:=1;
-  nachbarn[0,false]:=self;
-  nachbarn[0,true]:=self;
-  nachbarn[1,false]:=self;
-  nachbarn[1,true]:=self;
+  result:=0;
+  for i:=0 to length(phasenraum)-1 do
+    result:=result+phasenraum[i].nichtnegativieren;
 end;
 
-constructor tImpulsPunkt.create(rp: tRaumPunkt; linksRaum,linksImpuls: tImpulsPunkt; anzTeilchen: longint);
-var
-  i,j:  longint;
-  b:    boolean;
-  np:   tImpulsPunkt;
-begin
-  inherited create;
-  istNullPkt:=false;
-  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;
-  fillchar(grad,sizeof(grad),#0);
-  setlength(grad,anzTeilchen);
-  for i:=0 to length(grad)-1 do
-    for j:=0 to 1 do
-      grad[i,j]:=0;
-  fillchar(iMGamma,sizeof(iMGamma),#0);
-  setlength(iMGamma,length(werte));
-  for i:=0 to length(iMGamma)-1 do
-    iMGamma[i]:=0;
-  nachbarn[0,false]:=linksRaum;
-  nachbarn[0,true]:=nil;
-  nachbarn[1,false]:=linksImpuls;
-  nachbarn[1,true]:=nil;
-  np:=nil;
-  for i:=0 to 1 do
-    if assigned(nachbarn[i,false]) then begin
-      if nachbarn[i,false].nachbarn[i,true].istNullPunkt then
-        np:=nachbarn[i,false].nachbarn[i,true];
-      nachbarn[i,false].nachbarn[i,true]:=self;
-    end;
-  if not assigned(np) then
-    np:=tImpulsPunkt.create(anzTeilchen);
-  for i:=0 to 1 do
-    for b:=false to true do
-      if not assigned(nachbarn[i,b]) then
-        nachbarn[i,b]:=np;
-end;
+*)
+// tFelder *********************************************************************
 
-destructor tImpulsPunkt.destroy;
+constructor tFelder.create(anzX,anzP: longint; deltaX,deltaP: extended; _teilchen: array of tTeilchenSpezies; lichter: tMyStringList; parent: tGitter);
 var
-  i: longint;
-  b: boolean;
+  i,j:        longint;
+  rechts,abl: boolean;
+  dens:       extended;
+  emF:        tEMFeldGroesze;
+  emQ:        tEMQuellGroesze;
+  maF:        tMaterieFeldGroesze;
 begin
-  for i:=0 to 1 do
-    for b:=false to true do
-      if assigned(nachbarn[i,b]) and
-         not nachbarn[i,b].istNullPunkt then
-        nachbarn[i,b].nachbarn[i,not b]:=nil;
-  setlength(werte,0);
-  setlength(iMGamma,0);
-  inherited destroy;
-end;
+  inherited create;
+  gitter:=parent;
+  gesamtDefizit:=0;
+  _aX:=anzX;
+  _aP:=anzP;
+  _dX:=deltaX;
+  _dP:=deltaP;
+  iDX:=1/dX;
+  fillchar(teilchen,sizeof(teilchen),#0);
+  setlength(teilchen,length(_teilchen));
+  for i:=0 to length(teilchen)-1 do
+    teilchen[i]:=tTeilchenSpezies.create(_teilchen[i]);
 
-function tImpulsPunkt.nichtnegativieren: extended; // Dichten nicht negativ machen
-var
-  defizit:                   extended;
-  i:                         longint;
-  pro:                       tProtokollant;
-(*  i,richtung,entfernung:     longint;
-  jemandErreicht,vorZurueck: boolean; *)
-begin
-  result:=0;
-  for i:=0 to length(werte)-1 do begin
-    if werte[i,false]<0 then begin
-      defizit:=-werte[i,false];
-      result:=result+defizit;
-      werte[i,false]:=0; (*
-      entfernung:=1;
-      jemandErreicht:=true;
-      while (defizit>0) and jemandErreicht do begin
-        jemandErreicht:=false;
-        for richtung:=0 to 1 do
-          for vorZurueck:=false to true do
-            if assigned(nachbarn[richtung,vorZurueck]) then
-              jemandErreicht:=nachbarn[richtung,vorZurueck].gibMirWas(defizit,entfernung,i,richtung,vorZurueck) 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;  *)
+  fillchar(impulsRaumGradient,sizeof(impulsRaumGradient),#0);
+  setlength(impulsRaumGradient,length(teilchen));
+  for i:=0 to length(impulsRaumGradient)-1 do
+    for j:=0 to length(impulsRaumGradient[i])-1 do begin
+      fftw_getmem(impulsRaumGradient[i,j],aP*aX*sizeof(extended));
+      fillchar(impulsRaumGradient[i,j]^,aP*aX*sizeof(extended),#0);
     end;
-    if werte[i,false]>1E100 then begin
-      pro:=tProtokollant.create(raumpunkt.felder.gitter.prot,'impulsPunkt.nichtnegativieren');
-      pro.schreibe('An einer Stelle im Phasenraum sind bereits mehr als 10^100 Teilchen, ich breche ab (t = '+floattostr(raumpunkt.felder.gitter.t)+' T)!',true);
-      pro.free;
-      raumpunkt.felder.gitter.abbrechen;
+  fillchar(iMGamma,sizeof(iMGamma),#0);
+  setlength(iMGamma,length(teilchen));
+  for i:=0 to length(iMGamma)-1 do begin
+    fftw_getmem(iMGamma[i],aP*aX*sizeof(extended));
+    fillchar(iMGamma[i]^,aP*aX*sizeof(extended),#0);
+  end;
+  for emF:=low(tEMFeldGroesze) to high(tEMFeldGroesze) do begin
+    emFelder[emF,true]:=nil;
+    for abl:=false to not(emF in [efEX,efBZ]) do begin
+      fftw_getmem(emFelder[emF,abl],aX*sizeof(extended));
+      fillchar(emFelder[emF,abl]^,aX*sizeof(extended),#0);
     end;
   end;
-end;
-
-procedure tImpulsPunkt.akkumuliereEMQuellen(var emQuellen: tEMQuellen; pX,dVP: extended);
-var
-  i:   longint;
-  tmp: extended;
-begin
-  for i:=0 to length(werte)-1 do begin
-    iMGamma[i]:=1/(sqrt(1 + (sqr(pX) + sqr(raumpunkt.matFelder[i,mfPY,false]))*raumpunkt.felder.teilchen[i].eigenschaften[tsgIQdrMasse])*raumpunkt.felder.teilchen[i].eigenschaften[tsgMasse]);
-    tmp:=werte[i,false] * raumpunkt.felder.teilchen[i].eigenschaften[tsgLadung] * dVP;
-    emQuellen[eqRho]:=emQuellen[eqRho] + tmp;    // * iGamma[i] ??? TODO ... falls, dann aber ohne M!
-    emQuellen[eqJX]:= emQuellen[eqJX]  + tmp * pX * iMGamma[i];
-    emQuellen[eqJY]:= emQuellen[eqJY]  + tmp * raumpunkt.matFelder[i,mfPY,false] * iMGamma[i];
+  for emQ:=low(tEMQuellGroesze) to high(tEMQuellGroesze) do begin
+    fftw_getmem(emQuellen[emQ],aX*sizeof(extended));
+    fillchar(emQuellen[emQ]^,aX*sizeof(extended),#0);
   end;
-end;
+  fillchar(matFelder,sizeof(matFelder),#0);
+  setlength(matFelder,length(teilchen));
+  for i:=0 to length(matFelder)-1 do
+    for maF:=low(tMaterieFeldGroesze) to high(tMaterieFeldGroesze) do begin
+      fftw_getmem(matFelder[i,maF],aX*sizeof(extended));
+      fillchar(matFelder[i,maF]^,aX*sizeof(extended),#0);
+    end;
+  fillchar(impulsraum,sizeof(impulsraum),#0);
+  setlength(impulsraum,length(teilchen));
+  for i:=0 to length(impulsraum)-1 do
+    for abl:=false to true do begin
+      fftw_getmem(impulsraum[i,abl],aX*aP*sizeof(extended));
+      fillchar(impulsraum[i,abl]^,aX*aP*sizeof(extended),#0);
+    end;
 
-function tImpulsPunkt.gibMirWas(var defizit: extended; entfernung,teilchen,richtung: longint; positiv: boolean): boolean; // ich habe jemanden erreicht
-var
-  i: longint;
-  b: boolean;
-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;
+  fillchar(massen,sizeof(massen),#0);
+  setlength(massen,length(teilchen));
+  for i:=0 to length(massen)-1 do
+    massen[i]:=0;
+  for i:=0 to aX-1 do
+    for j:=0 to length(teilchen)-1 do begin
+      dens:=_teilchen[j].gibDichte(gitter.xl+(i-2)*gitter.dX,parent.kvs);
+      initialisiereDichte(i,j,_teilchen[j].breite,dens);
+      massen[j]:=massen[j]+dens*gitter.dX*teilchen[j].eigenschaften[tsgMasse];
     end;
-  end
-  else
-    if defizit>0 then
-      for i:=richtung to 1 do
-        for b:=false to i>richtung do
-          if assigned(nachbarn[i,positiv xor b]) then
-            result:=nachbarn[i,positiv xor b].gibMirWas(defizit,entfernung-1,teilchen,i,positiv xor b) or result;
+  for rechts:=false to true do begin
+    lichters[rechts]:=tMyStringlist.create(nil,'');
+    lichters[rechts].text:=lichter.text;
+  end;
+  lichters[false].grep('^links .*');
+  lichters[false].subst('^links *','');
+  lichters[true].grep('^rechts .*');
+  lichters[true].subst('^rechts *','');
+
+  fftw_getmem(fftTmp,(aP+1)*(aX+1)*sizeof(complex_extended));
+
+  fillchar(ffts,sizeof(ffts),#0);
+  setlength(ffts,length(teilchen));  write('.');
+  for i:=0 to length(ffts)-1 do begin
+//    ffts[i,0,false]:=  // Planung der Hintransformationen über x
+//      fftw_plan_many_dft_r2c(1,@_aX,aP,impulsraum[i,false],nil,aP,1,fftTmp,nil,aP,1,[fftw_preserve_input,fftw_measure]); write('1');
+    ffts[i,0,true]:=  // Planung der Rücktransformationen über x
+      fftw_plan_many_dft_c2r(1,@_aX,aP,fftTmp,nil,aP,1,impulsRaumGradient[i,0],nil,aP,1,[fftw_measure]);                 write('2');
+
+//    ffts[i,1,false]:=  // Planung der Hintransformationen über p
+//      fftw_plan_many_dft_r2c(1,@_aP,aX,impulsraum[i,false],nil,1,aP,fftTmp,nil,1,aP,[fftw_preserve_input,fftw_measure]); write('3');
+//    ffts[i,1,true]:=  // Planung der Rücktransformationen über p
+//      fftw_plan_many_dft_c2r(1,@_aP,aX,fftTmp,nil,1,aP,impulsRaumGradient[i,1],nil,1,aP,[fftw_measure]);                 write('4');
+  end;                               write('>');
+   (*
+     fftw_plan_many_dft_r2c(int rank, const int *n, int howmany,
+                                      double *in, const int *inembed,
+                                      int istride, int idist,
+                                      fftw_complex *out, const int *onembed,
+                                      int ostride, int odist,
+                                      unsigned flags);
+     fftw_plan fftw_plan_many_dft_c2r(int rank, const int *n, int howmany,
+                                      fftw_complex *in, const int *inembed,
+                                      int istride, int idist,
+                                      double *out, const int *onembed,
+                                      int ostride, int odist,
+                                      unsigned flags);
+   *)
 end;
 
-procedure tImpulsPunkt.setzeNull;
+destructor tFelder.destroy;
 var
-  i:   longint;
+  i,j: longint;
   abl: boolean;
+  emF: tEMFeldGroesze;
+  emQ: tEMQuellGroesze;
+  maF: tMaterieFeldGroesze;
 begin
-  for i:=0 to length(werte)-1 do begin
+  setlength(massen,0);
+  for i:=0 to length(teilchen)-1 do
+    teilchen[i].free;
+  setlength(teilchen,0);
+  for i:=0 to length(impulsRaumGradient)-1 do
+    for j:=0 to length(impulsRaumGradient[i])-1 do
+      fftw_freemem(impulsRaumGradient[i,j]);
+  setlength(iMGamma,0);
+  for i:=0 to length(iMGamma)-1 do
+    fftw_freemem(iMGamma[i]);
+  setlength(iMGamma,0);
+  for emF:=low(tEMFeldGroesze) to high(tEMFeldGroesze) do
+    for abl:=false to not(emF in [efEX,efBZ]) do
+      fftw_freemem(emFelder[emF,abl]);
+  for emQ:=low(tEMQuellGroesze) to high(tEMQuellGroesze) do
+    fftw_freemem(emQuellen[emQ]);
+  for i:=0 to length(matFelder)-1 do
+    for maF:=low(tMaterieFeldGroesze) to high(tMaterieFeldGroesze) do
+      fftw_freemem(matFelder[i,maF]);
+  setlength(matFelder,0);
+  for i:=0 to length(impulsraum)-1 do
     for abl:=false to true do
-      werte[i,abl]:=0;
-    iMGamma[i]:=0;
-  end;
+      fftw_freemem(impulsraum[i,abl]);
+  setlength(impulsraum,0);
+  lichters[false].free;
+  lichters[true].free;
+  for i:=0 to length(ffts)-1 do
+    for j:=0 to 1 do
+      for abl:=false to true do
+        fftw_destroy_plan(ffts[i,j,abl]);
+  setlength(ffts,0);
+  fftw_freemem(fftTmp);
+  inherited destroy;
 end;
 
-procedure tImpulsPunkt.berechneAbleitungen(pX: extended);
+procedure tFelder.initialisiereDichte(ort,tlc: longint; breite,n: extended);
 var
-  i:     longint;
-  tx,tp: extended;
+  i:   longint;
+  ges: extended;
 begin
-  // df/dt = - v Nabla f - q(E + v/c x B) Nabla_p f
-
-  for i:=0 to length(werte)-1 do begin
-    tX:= // der Teil vor "Nabla f"
-      - pX * iMGamma[i];
-    tP:= // der Teil vor "Nabla_p f"
-      - raumpunkt.felder.teilchen[i].eigenschaften[tsgLadung] *
-        (  raumpunkt.emFelder[efEX,false]
-         + raumpunkt.matFelder[i,mfPY,false] * iMGamma[i] * raumpunkt.emFelder[efBZ,false]);
-    werte[i,true]:=
-      grad[i,0]*tX +
-      grad[i,1]*tP;
+  ges:=0;
+  for i:=0 to aP-1 do begin
+    (impulsraum[tlc,false]+i+ort*aP)^:=power(1/2,sqr((i-aP/2)*dP*2/breite));
+    ges:=ges + (impulsraum[tlc,false]+i+ort*aP)^;
   end;
+  ges:=n/ges/dP;
+  for i:=0 to aP-1 do
+    (impulsraum[tlc,false]+i+ort*aP)^:=(impulsraum[tlc,false]+i+ort*aP)^ * ges;
 end;
 
-// tRaumPunkt ******************************************************************
-
-constructor tRaumPunkt.create(linkerNachbar: tRaumPunkt; derBesitzer: tFelder; teilchen,_aP: longint; _dP: extended);
+procedure tFelder.berechneAbleitungen;
 var
-  emF:   tEMFeldGroesze;
-  emQ:   tEMQuellGroesze;
-  maF:   tMaterieFeldGroesze;
-  abl:   boolean;
-  i:     longint;
-  xN,pN: tImpulsPunkt;
+  i,j,k:  longint;
+  emQ:    tEMQuellGroesze;
+  emF:    tEMFeldGroesze;
+  rechts: boolean;
+  tmp,err:extended;
 begin
-  inherited create;
-  felder:=derBesitzer;
+
+  // PX ggf. korrigieren
+  for i:=0 to length(teilchen)-1 do      // linker Rand
+    for j:=0 to (aP div 2)-1 do          // negativer Impuls
+      if (impulsraum[i,false]+j)^>0 then begin
+        (impulsraum[i,false]+aP-j-byte(j=0))^:=(impulsraum[i,false]+aP-j-byte(j=0))^ + (impulsraum[i,false]+j)^;
+        (impulsraum[i,false]+j)^:=0;
+      end;
+
+  for i:=0 to length(teilchen)-1 do      // rechter Rand
+    for j:=(aP div 2)+1 to aP-1 do       // positiver Impuls
+      if (impulsraum[i,false]+j+(aX-1)*aP)^>0 then begin
+        (impulsraum[i,false]+aP-j+(aX-1)*aP)^:=(impulsraum[i,false]+aP-j+(aX-1)*aP)^ + (impulsraum[i,false]+j+(aX-1)*aP)^;
+        (impulsraum[i,false]+j+(aX-1)*aP)^:=0;
+      end;
+
+  // PY und iMGamma berechnen
+  for i:=0 to length(matFelder)-1 do
+    for j:=0 to aX-1 do begin
+      (matFelder[i,mfPY]+j)^:=-teilchen[i].eigenschaften[tsgLadung] * (emFelder[efAY,false]+j)^;
+      for k:=0 to aP-1 do
+        (iMGamma[i]+k+j*aP)^:=
+          1/(sqrt(1 + (sqr((k-(aP div 2))*dP) + sqr((matFelder[i,mfPY]+j)^))*teilchen[i].eigenschaften[tsgIQdrMasse])*teilchen[i].eigenschaften[tsgMasse]);
+        // 1/(m Gamma) = 1/sqrt(1 + (pX/m)^2 + (pY/m)^2)*m
+    end;
+
+  // rho und j berechnen
   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;
-  fillchar(matFelder,sizeof(matFelder),#0);
-  setlength(matFelder,teilchen);
+    for i:=0 to aX-1 do
+      (emQuellen[emQ]+i)^:=0;
   for i:=0 to length(matFelder)-1 do
-    for maF:=low(tMaterieFeldGroesze) to high(tMaterieFeldGroesze) do
-      for abl:=false to true do
-        matFelder[i,maF,abl]:=0;
-  lN:=linkerNachbar;
-  rN:=nil;
-  if assigned(lN) then
-    lN.rN:=self;
-  aP:=_aP;
-  dP:=_dP;
-  fillchar(phasenraum,sizeof(phasenraum),#0);
-  setlength(phasenraum,aP);
-  for i:=0 to aP-1 do begin
-    if assigned(linkerNachbar) then
-      xN:=linkerNachbar.phasenraum[i]
-    else
-      xN:=nil;
-    if i>0 then
-      pN:=phasenraum[i-1]
-    else
-      pN:=nil;
-    phasenraum[i]:=tImpulsPunkt.create(self,xN,pN,teilchen);
-  end;
-end;
+    for j:=0 to aX-1 do
+      for k:=0 to aP-1 do begin
+        tmp:=(impulsraum[i,false]+k+j*aP)^ * teilchen[i].eigenschaften[tsgLadung] * dP;
+        (emQuellen[eqRho]+j)^:=(emQuellen[eqRho]+j)^ + tmp;    // * iGamma[i] ??? TODO ... falls, dann aber ohne M!
+        (emQuellen[eqJX]+j)^:= (emQuellen[eqJX]+j)^  + tmp * (k-(aP div 2))*dP * (iMGamma[i]+k+j*aP)^;
+        (emQuellen[eqJY]+j)^:= (emQuellen[eqJY]+j)^  + tmp * (matFelder[i,mfPY]+j)^ * (iMGamma[i]+k+j*aP)^;
+      end;
 
-destructor tRaumPunkt.destroy;
-var
-  i: longint;
-begin
-  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
-    rN.lN:=nil;
-  inherited destroy;
-end;
+  // E und B aus Rho und A berechnen
 
-procedure tRaumPunkt.berechneEMFelder(dX: extended; rechts: boolean);
-begin
   // 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;
+  emFelder[efEX,false]^:=emQuellen[eqRho]^ * dX; // linker Rand
+  for i:=1 to aX-1 do                            // Rest
+    (emFelder[efEX,false]+i)^:=
+      (emFelder[efEX,false]+i-1)^ +
+      ((emQuellen[eqRho]+i-1)^ + (emQuellen[eqRho]+i)^) * dX/2;
 
   // 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;
+  emFelder[efBZ,false]^:=0;        // linker Rand
+  for i:=1 to aX-2 do              // Mitte
+    (emFelder[efBZ,false]+i)^:=
+      ((emFelder[efAY,false]+i+1)^ - (emFelder[efAY,false]+i-1)^)*iDX/2;
+  (emFelder[efBZ,false]+aX-1)^:=0; // rechter Rand
 
-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;
+  // Randbedingungen für die Ableitungen des A-Felds setzen
+  for emF:=efAX to efAY do begin // Vakuumrandbedingungen für das A-Feld
+    emFelder[emF,true]^:=
+      ((emFelder[emF,false]+1)^ -
+       emFelder[emF,false]^)*iDX;
+    (emFelder[emF,true]+aX-1)^:=
+      ((emFelder[emF,false]+aX-2)^ -
+       (emFelder[emF,false]+aX-1)^)*iDX;
+  end; // (ein bisschen wird noch reflektiert, vmtl. durch numerische Fehler bzw. nicht beachtete numerische Dispersion)
 
-  // B = rot A
-  emFelder[efBZ,false]:=
-    (rN.emFelder[efAY,false]-lN.emFelder[efAY,false])*iDX/2;
-end;
+  for rechts:=false to true do
+    for i:=0 to lichters[rechts].count-1 do
+      (emFelder[efAY,true]+(aX-1)*byte(rechts))^:=
+        (emFelder[efAY,true]+(aX-1)*byte(rechts))^ +
+        exprToFloat(false,lichters[rechts][i],gitter.kvs,nil);
 
-procedure tRaumPunkt.berechneEMQuellen;
-var
-  i:   longint;
-  emQ: tEMQuellGroesze;
-begin
-  for emQ:=low(tEMQuellGroesze) to high(tEMQuellGroesze) do
-    emQuellen[emQ]:=0;
-  for i:=0 to aP-1 do
-    phasenraum[i].akkumuliereEMQuellen(emQuellen,(i-aP/2)*dP,dP);
-end;
+  // sonstige Ableitungen des A-Feldes berechnen
 
-procedure tRaumPunkt.berechneEMAbleitungen(iDX: extended); // Zeitableitungen der EM-Potentiale berechnen
-begin
   // 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];
+  for i:=1 to aX-2 do
+    (emFelder[efDAXDT,true]+i)^:=
+      ( (emFelder[efAX,false]+i+1)^ - 2*(emFelder[efAX,false]+i)^ + (emFelder[efAX,false]+i-1)^ )*sqr(iDX)
+      - (emQuellen[eqJX]+i)^;
+  for i:=1 to aX-2 do
+    (emFelder[efDAYDT,true]+i)^:=
+      ( (emFelder[efAY,false]+i+1)^ - 2*(emFelder[efAY,false]+i)^ + (emFelder[efAY,false]+i-1)^ )*sqr(iDX)
+      - (emQuellen[eqJY]+i)^;
 
   // dA/dt = dA/dt - E
-  emFelder[efAX,true]:=emFelder[efDAXDT,false] - emFelder[efEX,false];
-  emFelder[efAY,true]:=emFelder[efDAYDT,false];
+  for i:=1 to aX-2 do
+    (emFelder[efAX,true]+i)^:=(emFelder[efDAXDT,false]+i)^ - (emFelder[efEX,false]+i)^;
+  move(emFelder[efDAYDT,false]^,emFelder[efAY,true]^,aX*sizeof(extended));
+
+  // Gradienten der Phasenraumbesetzungsdichte berechnen
+
+  for i:=0 to length(ffts)-1 do begin
+//    fftw_execute(ffts[i,0,false]);
+  //    *i*k*2*pi;
+//    fftw_execute(ffts[i,0,true]);
+    write('A');
+    fftw_execute(ffts[i,1,false]);
+    write('B');
+  //    *i*k*2*pi;
+    fftw_execute(ffts[i,1,true]);
+    write('C');
+  end;
+
+  tmp:=0;
+  err:=0;
+  for i:=0 to length(impulsraum)-1 do
+    for j:=0 to aP*aX-1 do begin
+      tmp:=tmp+abs((impulsraum[i,false]+j)^)+abs((impulsRaumGradient[i,1]+j)^);
+      err:=err+abs((impulsraum[i,false]+j)^-(impulsRaumGradient[i,1]+j)^);
+//      tmp:=tmp+abs((impulsraum[i,false]+j)^)+abs((impulsRaumGradient[i,0]+j)^)+abs((impulsRaumGradient[i,1]+j)^);
+//      err:=err+abs((impulsraum[i,false]+j)^-(impulsRaumGradient[i,0]+j)^)
+//              +abs((impulsraum[i,false]+j)^-(impulsRaumGradient[i,1]+j)^);
+    end;
+  writeln(tmp,' ',err);
+  halt;
+
+  // Zeitableitung der Phasenraumbesetzungsdichte berechnen
+
+  for i:=0 to length(teilchen)-1 do
+    for j:=1 to aX-2 do
+      for k:=1 to aP-2 do
+        (impulsraum[i,true]+k+j*aP)^:=                                               // df/dt =
+          - (k-(aP div 2))*dP * (iMGamma[i]+k+j*aP)^                                 //   - v
+            * (impulsRaumGradient[i,0]+k+j*aP)^                                      //   * Nabla f
+          - teilchen[i].eigenschaften[tsgLadung] *                                   //   - q(
+            (  (emFelder[efEX,false]+j)^                                             //        E
+             + (matFelder[i,mfPY]+j)^ * (iMGamma[i]+k+j*aP)^ * (emFelder[efBZ,false]+j)^) // + v/c x B)
+            * (impulsRaumGradient[i,1]+k+j*aP)^;                                     //   * Nabla_p f
 end;
 
-procedure tRaumPunkt.berechnePhasenraumAbleitungen;
+procedure tFelder.setzeNull;
 var
-  i: longint;
+  i,j,k: longint;
+  abl:   boolean;
+  emF:   tEMFeldGroesze;
+  emQ:   tEMQuellGroesze;
+  maF:   tMaterieFeldGroesze;
 begin
-  // df/dt = - v Nabla f - q(E + v/c x B) Nabla_p f
-  for i:=0 to aP-1 do
-    phasenraum[i].berechneAbleitungen((i-(aP div 2))*dP);
+  for i:=0 to length(impulsRaumGradient)-1 do
+    for j:=0 to length(impulsRaumGradient[i])-1 do
+      for k:=0 to aX*aP-1 do
+        (impulsRaumGradient[i,j]+k)^:=0;
+  for i:=0 to length(iMGamma)-1 do
+    for j:=0 to aX*aP-1 do
+      (iMGamma[i]+j)^:=1;
+  for emF:=low(tEMFeldGroesze) to high(tEMFeldGroesze) do
+    for abl:=false to not(emF in [efEX,efBZ]) do
+      for i:=0 to aX-1 do
+        (emFelder[emF,abl]+i)^:=0;
+  for emQ:=low(tEMQuellGroesze) to high(tEMQuellGroesze) do
+    for i:=0 to aX-1 do
+      (emQuellen[emQ]+i)^:=0;
+  for i:=0 to length(matFelder)-1 do
+    for maF:=low(tMaterieFeldGroesze) to high(tMaterieFeldGroesze) do
+      for j:=0 to aX-1 do
+        (matFelder[i,maF]+j)^:=0;
+  for i:=0 to length(impulsraum)-1 do
+    for abl:=false to true do
+      for j:=0 to aX*aP-1 do
+        (impulsraum[i,abl]+j)^:=0;
 end;
 
-function tRaumPunkt.nichtnegativieren: extended; // Dichten nicht negativ machen
+procedure tFelder.dumpErhaltungsgroeszen(prot: tProtokollant);
 var
-  i: longint;
+  i,j:  longint;
+  dens: extended;
 begin
-  result:=0;
-  for i:=0 to length(phasenraum)-1 do
-    result:=result+phasenraum[i].nichtnegativieren;
+  dens:=0;
+  for i:=0 to length(massen)-1 do
+    dens:=dens+massen[i]/teilchen[i].eigenschaften[tsgMasse];
+  prot.schreibe('Gesamtdefizit: '+floattostr(gesamtDefizit)+' (Anteil '+floattostr(gesamtDefizit/dens)+')',true);
+  for i:=0 to length(massen)-1 do begin
+    dens:=0;
+    for j:=0 to aX-1 do
+      dens:=dens+impulsIntegral(j,i,msN);
+    dens:=dens*teilchen[i].eigenschaften[tsgMasse]*gitter.dX;
+    prot.schreibe('n['+inttostr(i+1)+'] = '+floattostr(dens)+' (relative Abweichung: '+floattostr(dens/massen[i]-1)+')',true);
+  end;
 end;
 
-function tRaumPunkt.impulsIntegral(teilchen: longint; emQ: tEMQuellGroesze): extended;
+function tFelder.impulsIntegral(ort,tlc: longint; emQ: tEMQuellGroesze): extended;
 begin
-  if teilchen<0 then begin
-    result:=emQuellen[emQ]; // das ist leicht :-)
+  if tlc<0 then begin
+    result:=(emQuellen[emQ]+ort)^; // das ist leicht :-)
     exit;
   end;
 
   result:=0;
 
   case emQ of
-    eqRho: result:=impulsIntegral(teilchen,msN);
-    eqJX:  result:=impulsIntegral(teilchen,msVX);
-    eqJY:  result:=impulsIntegral(teilchen,msVY);
+    eqRho: result:=impulsIntegral(ort,tlc,msN);
+    eqJX:  result:=impulsIntegral(ort,tlc,msVX);
+    eqJY:  result:=impulsIntegral(ort,tlc,msVY);
   end{of case};
-  result:=result * felder.teilchen[teilchen].eigenschaften[tsgLadung];
+  result:=result * teilchen[tlc].eigenschaften[tsgLadung];
 end;
 
-function tRaumPunkt.impulsIntegral(teilchen: longint; maF: tMaterieSpeicherGroesze): extended;
+function tFelder.impulsIntegral(ort,tlc: longint; maF: tMaterieSpeicherGroesze): extended;
 var
   i: longint;
 begin
-  if teilchen<0 then begin
+  if tlc<0 then begin
     result:=0;
-    for i:=0 to length(felder.teilchen)-1 do
-      result:=result+impulsIntegral(i,maF);
+    for i:=0 to length(teilchen)-1 do
+      result:=result+impulsIntegral(ort,i,maF);
     exit;
   end;
 
@@ -952,308 +952,54 @@ begin
       for i:=0 to aP-1 do
         result:=
           result +
-          phasenraum[i].werte[teilchen,false]*dP;
+          (impulsraum[tlc,false]+i+ort*aP)^ * dP;
     msPX:
       for i:=0 to aP-1 do
         result:=
           result +
-          phasenraum[i].werte[teilchen,false]*dP * (i-aP/2)*dP;
+          (impulsraum[tlc,false]+i+ort*aP)^ * dP * (i-aP/2)*dP;
     msPXSqr:
       for i:=0 to aP-1 do
         result:=
           result +
-          phasenraum[i].werte[teilchen,false]*dP * sqr((i-aP/2)*dP);
+          (impulsraum[tlc,false]+i+ort*aP)^ * dP * sqr((i-aP/2)*dP);
     msPY: begin
       for i:=0 to aP-1 do
         result:=
           result +
-          phasenraum[i].werte[teilchen,false]*dP;
-      result:=result * matFelder[teilchen,mfPY,false];
+          (impulsraum[tlc,false]+i+ort*aP)^ * dP;
+      result:=result * (matFelder[tlc,mfPY]+ort)^;
     end;
     msVX: begin
       for i:=0 to aP-1 do
         result:=
           result +
-          phasenraum[i].werte[teilchen,false]*dP * (i-aP/2)*dP
-          / sqrt(1 + (sqr((i-aP/2)*dP) + sqr(matFelder[teilchen,mfPY,false]))*felder.teilchen[teilchen].eigenschaften[tsgIQdrMasse]);
-      result:=result / felder.teilchen[teilchen].eigenschaften[tsgMasse];
+          (impulsraum[tlc,false]+i+ort*aP)^ * dP * (i-aP/2)*dP
+          / sqrt(1 + (sqr((i-aP/2)*dP) + sqr((matFelder[tlc,mfPY]+ort)^))*teilchen[tlc].eigenschaften[tsgIQdrMasse]);
+      result:=result / teilchen[tlc].eigenschaften[tsgMasse];
     end;
     msVY: begin
       for i:=0 to aP-1 do
         result:=
           result +
-          phasenraum[i].werte[teilchen,false]*dP
-          / sqrt(1 + (sqr((i-aP/2)*dP) + sqr(matFelder[teilchen,mfPY,false]))*felder.teilchen[teilchen].eigenschaften[tsgIQdrMasse]);
-      result:=result * matFelder[teilchen,mfPY,false] / felder.teilchen[teilchen].eigenschaften[tsgMasse];
+          (impulsraum[tlc,false]+i+ort*aP)^ * dP
+          / sqrt(1 + (sqr((i-aP/2)*dP) + sqr((matFelder[tlc,mfPY]+ort)^))*teilchen[tlc].eigenschaften[tsgIQdrMasse]);
+      result:=result * (matFelder[tlc,mfPY]+ort)^ / teilchen[tlc].eigenschaften[tsgMasse];
     end;
     msPXRipple:
       for i:=1 to aP-1 do
         result:=
-          result + abs(phasenraum[i].werte[teilchen,false]-phasenraum[i-1].werte[teilchen,false])*dP;
+          result + abs((impulsraum[tlc,false]+i+ort*aP)^-(impulsraum[tlc,false]+i-1+ort*aP)^)*dP;
   end{of case};
 end;
 
-procedure tRaumPunkt.initialisiereDichte(teilchen: longint; breite,n: extended);
-var
-  i:   longint;
-  ges: extended;
-begin
-  ges:=0;
-  for i:=0 to length(phasenraum)-1 do begin
-    phasenraum[i].werte[teilchen,false]:=power(1/2,sqr((i-aP/2)*dP*2/breite));
-    ges:=ges + phasenraum[i].werte[teilchen,false];
-  end;
-  ges:=n/ges/dP;
-  for i:=0 to length(phasenraum)-1 do
-    phasenraum[i].werte[teilchen,false]:=phasenraum[i].werte[teilchen,false] * ges;
-end;
-
-procedure tRaumPunkt.reflektiereTeilchen(rechts: boolean);
-var
-  i,j: longint;
-begin
-  for i:=(aP div 2 + 1)*byte(rechts) to (aP div 2)-1 + (aP-(aP div 2))*byte(rechts) do
-    for j:=0 to length(felder.teilchen)-1 do
-      if phasenraum[i].werte[j,false]>0 then begin
-        phasenraum[aP-1-i].werte[j,false]:=phasenraum[aP-1-i].werte[j,false]+phasenraum[i].werte[j,false];
-        phasenraum[i].werte[j,false]:=0;
-      end;
-end;
-
-procedure tRaumPunkt.setzeNull;
-var
-  i:   longint;
-  emF: tEMFeldGroesze;
-  emQ: tEMQuellGroesze;
-  maF: tMaterieFeldGroesze;
-  abl: boolean;
-begin
-  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;
-  for i:=0 to length(matFelder)-1 do
-    for maF:=low(tMaterieFeldGroesze) to high(tMaterieFeldGroesze) do
-      for abl:=false to true do
-        matFelder[i,maF,abl]:=0;
-end;
-
-procedure tRaumPunkt.berechnePY;
-var
-  i: longint;
-begin
-  for i:=0 to length(matFelder)-1 do
-    matFelder[i,mfPY,false]:=-felder.teilchen[i].eigenschaften[tsgLadung] * emFelder[efAY,false];
-end;
-
-// linearkombinationsspezifische Methoden von tImpulsPunkt, tRaumPunkt und tFelder
-
-{$DEFINE LiKoimplementation}
+{$DEFINE LiKoImplementation}
 {$INCLUDE linearkombinationen.inc}
-{$UNDEF LiKoimplementation}
-
-// tFelder *********************************************************************
-
-constructor tFelder.create(groesse: longint; _teilchen: array of tTeilchenSpezies; lichter: tMyStringList; parent: tGitter; aP: longint; dP: extended);
-var
-  i,j:    longint;
-  rechts: boolean;
-  dens:   extended;
-begin
-  inherited create;
-  gitter:=parent;
-  gesamtDefizit:=0;
-  fillchar(teilchen,sizeof(teilchen),#0);
-  setlength(teilchen,length(_teilchen));
-  for i:=0 to length(teilchen)-1 do
-    teilchen[i]:=tTeilchenSpezies.create(_teilchen[i]);
-  fillchar(inhalt,sizeof(inhalt),#0);
-  setlength(inhalt,groesse);
-  inhalt[0]:=tRaumPunkt.create(nil,self,length(teilchen),aP,dP);
-  for i:=1 to length(inhalt)-1 do
-    inhalt[i]:=tRaumPunkt.create(inhalt[i-1],self,length(teilchen),aP,dP);
-  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
-      dens:=_teilchen[j].gibDichte(gitter.xl+(i-2)*gitter.dX,parent.kvs);
-      inhalt[i].initialisiereDichte(j,_teilchen[j].breite,dens);
-      massen[j]:=massen[j]+dens*gitter.dX*teilchen[j].eigenschaften[tsgMasse];
-    end;
-  for rechts:=false to true do begin
-    lichters[rechts]:=tMyStringlist.create(nil,'');
-    lichters[rechts].text:=lichter.text;
-  end;
-  lichters[false].grep('^links .*');
-  lichters[false].subst('^links *','');
-  lichters[true].grep('^rechts .*');
-  lichters[true].subst('^rechts *','');
-end;
-
-destructor tFelder.destroy;
-var
-  i: longint;
-begin
-  setlength(massen,0);
-  for i:=0 to length(teilchen)-1 do
-    teilchen[i].free;
-  setlength(teilchen,0);
-  for i:=0 to length(inhalt)-1 do
-    inhalt[i].free;
-  setlength(inhalt,0);
-  lichters[false].free;
-  lichters[true].free;
-  inherited destroy;
-end;
-
-procedure tFelder.setzeRaender(iDX: extended);
-var
-  emF:    tEMFeldGroesze;
-  rechts: boolean;
-  i:      longint;
-begin
-  for emF:=efAX to efAY do begin // Vakuumrandbedingungen für das A-Feld
-    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)].emFelder[efAY,true]:=
-        inhalt[(length(inhalt)-1)*byte(rechts)].emFelder[efAY,true] +
-        exprToFloat(false,lichters[rechts][i],gitter.kvs,nil);
-end;
-
-procedure tFelder.berechneGradienten(iDX,iDP: extended);
-var
-  res,ims:     array of extended;
-  i,j,tlc,len: longint;
-  tmp:         extended;
-begin
-
-  // Ableitungen nach PX
-
-  len:=length(inhalt[0].phasenraum);
-  setlength(res,len);
-  setlength(ims,len);
-  for i:=0 to length(inhalt)-1 do
-    for tlc:=0 to length(teilchen)-1 do begin
-      if len<>length(inhalt[i].phasenraum) then
-        raise exception.create('Unterschiedliche Diskretisierung im Phasenraum an unterschiedlichen Orten!');
-      for j:=0 to length(inhalt[i].phasenraum)-1 do begin
-        res[j]:=inhalt[i].phasenraum[j].werte[tlc,false];
-        ims[j]:=0;
-      end;
-      fft(res,ims,false);
-      for j:=0 to (len div 2)-1 do begin
-        tmp:=res[j];
-        res[j]:=ims[j]*j;
-        ims[j]:=-tmp*j;
-
-        tmp:=res[len-1-j];
-        res[len-1-j]:=ims[len-1-j]*(-j-1);
-        ims[len-1-j]:=-tmp*(-j-1);
-      end;
-      fft(res,ims,true);
-      for j:=0 to length(inhalt[i].phasenraum)-1 do
-        inhalt[i].phasenraum[j].grad[tlc,0]:=res[j]*iDP;
-    end;
-
-  // Ableitungen nach X
-
-  len:=length(inhalt);
-  setlength(res,len);
-  setlength(ims,len);
-  for i:=0 to length(inhalt[0].phasenraum)-1 do
-    for tlc:=0 to length(teilchen)-1 do begin
-      for j:=0 to length(inhalt)-1 do begin
-        res[j]:=inhalt[j].phasenraum[i].werte[tlc,false];
-        ims[j]:=0;
-      end;
-      fft(res,ims,false);
-      for j:=0 to (len div 2)-1 do begin
-        tmp:=res[j];
-        res[j]:=ims[j]*j;
-        ims[j]:=-tmp*j;
-
-        tmp:=res[len-1-j];
-        res[len-1-j]:=ims[len-1-j]*(-j-1);
-        ims[len-1-j]:=-tmp*(-j-1);
-      end;
-      fft(res,ims,true);
-      for j:=0 to length(inhalt)-1 do
-        inhalt[j].phasenraum[i].grad[tlc,1]:=res[j]*iDX;
-    end;
-end;
-
-procedure tFelder.berechneAbleitungen(dX,iDX: extended);
-var
-  i: longint;
-  b: boolean;
-begin
-  for b:=false to true do                          // PX ggf. korrigieren
-    inhalt[(length(inhalt)-1)*byte(b)].reflektiereTeilchen(b);
-
-  for i:=0 to length(inhalt)-1 do                  // PY berechnen
-    inhalt[i].berechnePY;
-
-  for i:=0 to length(inhalt)-1 do                  // rho, j und nebenbei iGamma berechnen
-    inhalt[i].berechneEMQuellen;
-
-  inhalt[0].berechneEMFelder(dX,false);            // E und B aus Rho und A berechnen
-  for i:=1 to length(inhalt)-2 do
-    inhalt[i].berechneEMFelder(dX,iDX);
-  inhalt[length(inhalt)-1].berechneEMFelder(dX,false);
-
-  setzeRaender(iDX);                               // Randbedingungen für die Ableitungen des A-Felds setzen
-
-  for i:=1 to length(inhalt)-2 do                  // sonstige Ableitungen des A-Feldes berechnen
-    inhalt[i].berechneEMAbleitungen(iDX);
-
-  berechneGradienten(iDX,1/inhalt[0].dP);          // Gradienten der Phasenraumbesetzungsdichte berechnen
-
-  for i:=1 to length(inhalt)-2 do                  // Ableitungen der Phasenraumbesetzungsdichten berechnen (Rand wird ausgelassen!)
-    inhalt[i].berechnePhasenraumAbleitungen;
-end;
-
-procedure tFelder.setzeNull;
-var
-  i: longint;
-begin
-  for i:=0 to length(inhalt)-1 do
-    inhalt[i].setzeNull;
-end;
-
-procedure tFelder.dumpErhaltungsgroeszen(prot: tProtokollant);
-var
-  i,j:  longint;
-  dens: extended;
-begin
-  dens:=0;
-  for i:=0 to length(massen)-1 do
-    dens:=dens+massen[i]/teilchen[i].eigenschaften[tsgMasse];
-  prot.schreibe('Gesamtdefizit: '+floattostr(gesamtDefizit)+' (Anteil '+floattostr(gesamtDefizit/dens)+')',true);
-  for i:=0 to length(massen)-1 do begin
-    dens:=0;
-    for j:=0 to length(inhalt)-1 do
-      dens:=dens+inhalt[j].impulsIntegral(i,msN);
-    dens:=dens*teilchen[i].eigenschaften[tsgMasse]*gitter.dX;
-    prot.schreibe('n['+inttostr(i+1)+'] = '+floattostr(dens)+' (relative Abweichung: '+floattostr(dens/massen[i]-1)+')',true);
-  end;
-end;
+{$UNDEF LiKoImplementation}
 
 // tGitter *********************************************************************
 
-constructor tGitter.create(derBesitzer: tSimulation; size: longint; deltaX: extended; bekannteWerte: tKnownValues; teilchen: array of tTeilchenSpezies; lichter: tMyStringlist; zv: tZeitverfahren; protokollant: tProtokollant; name: string; aP: longint; dP: extended);
+constructor tGitter.create(derBesitzer: tSimulation; aX,aP: longint; deltaX,deltaP: extended; bekannteWerte: tKnownValues; teilchen: array of tTeilchenSpezies; lichter: tMyStringlist; zv: tZeitverfahren; protokollant: tProtokollant; name: string);
 var
   i: longint;
 begin
@@ -1261,11 +1007,11 @@ begin
 
   i:=aP;
   aP:=round(power(2,ceil(ln(aP-0.5)/ln(2))));
-  dP:=dP*(i-1)/(aP-1);
+  deltaP:=deltaP*(i-1)/(aP-1);
 
-  i:=size;
-  size:=round(power(2,ceil(ln(size+4-0.5)/ln(2)))); // zwei Felder links und rechts extra für Randbedingungen
-  deltaX:=deltaX*(i-1)/(size-4-1);
+  i:=aX;
+  aX:=round(power(2,ceil(ln(aX+4-0.5)/ln(2)))); // zwei Felder links und rechts extra für Randbedingungen
+  deltaX:=deltaX*(i-1)/(aX-4-1);
 
   abbruch:=false;
   besitzer:=derBesitzer;
@@ -1289,7 +1035,7 @@ begin
   xl:=dX/2;
 
   for i:=0 to length(felders)-1 do
-    felders[i]:=tFelder.create(size,teilchen,lichter,self,aP,dP);
+    felders[i]:=tFelder.create(aX,aP,deltaX,deltaP,teilchen,lichter,self);
 
   aktuelleFelder:=0;
   t:=0;
@@ -1328,7 +1074,7 @@ begin
   kvs.add('t',t);
 
   repeat
-    felders[aktuelleFelder].berechneAbleitungen(dX,iDX); // y' = y'(t,y(t))
+    felders[aktuelleFelder].berechneAbleitungen; // y' = y'(t,y(t))
 
     case zeitverfahren of
       zfEulerVorwaerts: // y(t+dt) = y(t) + y' dt
@@ -1749,7 +1495,7 @@ begin
   setlength(sighupSimulationen,length(sighupSimulationen)+1);
   sighupSimulationen[length(sighupSimulationen)-1]:=self;
 
-  gitter:=tGitter.create(self,round(breite/dX)+1,dX,kvs,teilchen,lichter,zeitverfahren,prot,'gitter',2*round(pMax/dP)+1,dP);
+  gitter:=tGitter.create(self,round(breite/dX)+1,2*round(pMax/dP)+1,dX,dP,kvs,teilchen,lichter,zeitverfahren,prot,'gitter');
   for i:=0 to length(teilchen)-1 do
     teilchen[i].free;
   setlength(teilchen,0);
diff --git a/Plasmapropagation.lpr b/Plasmapropagation.lpr
index 5559f51..d3b8f0a 100644
--- a/Plasmapropagation.lpr
+++ b/Plasmapropagation.lpr
@@ -8,7 +8,7 @@ uses
   {$ENDIF}{$ENDIF}
   Classes, SysUtils, CustApp,
   { you can add units after this }
-  math, Physikunit, protokollunit;
+  math, Physikunit, protokollunit, fftw_l;
 
 type
 
@@ -30,7 +30,46 @@ var
   start,zeitPhysik,zeitDatei: extended;
   prot:                       tProtokollant;
   s,t,u:                      string;
+
+  xlen,ylen,i,j:              longint;
+  ein:                        Pcomplex_extended;
+  aus:                        Pextended;
+  plan:                       fftw_plan_extended;
 begin
+
+  xlen:=4;
+  ylen:=4;
+
+  fftw_getmem(ein,xlen*ylen*sizeof(complex_extended));
+  fftw_getmem(aus,xlen*ylen*sizeof(extended));
+
+  plan:=fftw_plan_many_dft_c2r(1,@xlen,ylen,ein,nil,ylen,1,aus,nil,ylen,1,[fftw_measure]);
+
+  for i:=0 to xlen-1 do
+    for j:=0 to ylen-1 do begin
+      (ein+j+i*ylen)^.re:=j;
+      (ein+j+i*ylen)^.im:=i;
+    end;
+  for i:=0 to xlen-1 do begin
+    for j:=0 to ylen-1 do
+      write((ein+j+i*ylen)^.re,' + ',(ein+j+i*ylen)^.im,' *I ; ');
+    writeln;
+  end;
+
+  fftw_execute(plan);
+
+  for i:=0 to xlen-1 do begin
+    for j:=0 to ylen-1 do
+      write((aus+j+i*ylen)^,' ');
+    writeln;
+  end;
+
+  fftw_destroy_plan(plan);
+  fftw_freemem(ein);
+  fftw_freemem(aus);
+
+  halt;
+
   prot:=tProtokollant.create('error');
 
   if paramcount<>1 then begin
diff --git a/Plasmapropagation.lps b/Plasmapropagation.lps
index c266d7b..eee3207 100644
--- a/Plasmapropagation.lps
+++ b/Plasmapropagation.lps
@@ -3,23 +3,24 @@
   <ProjectSession>
     <Version Value="9"/>
     <BuildModes Active="Default"/>
-    <Units Count="20">
+    <Units Count="19">
       <Unit0>
         <Filename Value="Plasmapropagation.lpr"/>
         <IsPartOfProject Value="True"/>
-        <CursorPos X="34" Y="11"/>
+        <IsVisibleTab Value="True"/>
+        <TopLine Value="17"/>
+        <CursorPos X="49" Y="37"/>
         <UsageCount Value="200"/>
         <Loaded Value="True"/>
       </Unit0>
       <Unit1>
         <Filename Value="Physikunit.pas"/>
         <IsPartOfProject Value="True"/>
-        <IsVisibleTab Value="True"/>
         <EditorIndex Value="1"/>
-        <TopLine Value="329"/>
-        <CursorPos Y="1136"/>
-        <FoldState Value=" T3mG0{F5 pjdmK0G[945jZ0Q3[95d0C4]97jV0C7 piajL0v5]9fkW0E2]9bjE0S[I4ZjY0{1]Jp7rB0G2 T0)fPc071F3119"/>
-        <UsageCount Value="189"/>
+        <TopLine Value="626"/>
+        <CursorPos Y="645"/>
+        <FoldState Value=" T3lM0{F5 pjdmK0G51313]D2uD0f2111 p0sU0G2 T0!2Pc071F311'"/>
+        <UsageCount Value="200"/>
         <Loaded Value="True"/>
       </Unit1>
       <Unit2>
@@ -27,14 +28,14 @@
         <IsPartOfProject Value="True"/>
         <EditorIndex Value="-1"/>
         <CursorPos X="20" Y="8"/>
-        <UsageCount Value="151"/>
+        <UsageCount Value="165"/>
       </Unit2>
       <Unit3>
         <Filename Value="input.plap"/>
         <IsPartOfProject Value="True"/>
-        <EditorIndex Value="3"/>
-        <CursorPos X="20" Y="11"/>
-        <UsageCount Value="150"/>
+        <EditorIndex Value="4"/>
+        <CursorPos X="33" Y="23"/>
+        <UsageCount Value="164"/>
         <Loaded Value="True"/>
         <DefaultSyntaxHighlighter Value="None"/>
       </Unit3>
@@ -42,20 +43,19 @@
         <Filename Value="linearkombination.inc"/>
         <IsPartOfProject Value="True"/>
         <EditorIndex Value="-1"/>
-        <TopLine Value="285"/>
-        <CursorPos X="20" Y="323"/>
-        <UsageCount Value="98"/>
+        <CursorPos X="54" Y="16"/>
+        <UsageCount Value="112"/>
       </Unit4>
       <Unit5>
         <Filename Value="linearkombinationen.inc"/>
         <IsPartOfProject Value="True"/>
         <EditorIndex Value="-1"/>
-        <TopLine Value="64"/>
-        <UsageCount Value="61"/>
+        <CursorPos X="29" Y="16"/>
+        <UsageCount Value="75"/>
       </Unit5>
       <Unit6>
         <Filename Value="input.epost"/>
-        <EditorIndex Value="4"/>
+        <EditorIndex Value="5"/>
         <TopLine Value="22"/>
         <CursorPos X="26" Y="29"/>
         <UsageCount Value="100"/>
@@ -64,10 +64,11 @@
       </Unit6>
       <Unit7>
         <Filename Value="../units/matheunit.pas"/>
-        <EditorIndex Value="2"/>
+        <EditorIndex Value="3"/>
         <TopLine Value="19"/>
         <CursorPos X="66" Y="48"/>
-        <UsageCount Value="15"/>
+        <FoldState Value=" T3iA05B pj0jV034 piaj60U6 plLmM041p"/>
+        <UsageCount Value="22"/>
         <Loaded Value="True"/>
       </Unit7>
       <Unit8>
@@ -75,7 +76,7 @@
         <EditorIndex Value="-1"/>
         <TopLine Value="558"/>
         <CursorPos X="41" Y="567"/>
-        <UsageCount Value="9"/>
+        <UsageCount Value="8"/>
       </Unit8>
       <Unit9>
         <Filename Value="../units/mystringlistunit.pas"/>
@@ -83,193 +84,187 @@
         <TopLine Value="367"/>
         <CursorPos X="17" Y="390"/>
         <FoldState Value=" T3i3075 piZjD0WQ"/>
-        <UsageCount Value="4"/>
+        <UsageCount Value="3"/>
       </Unit9>
       <Unit10>
-        <Filename Value="../epost/werteunit.pas"/>
+        <Filename Value="rk14.inc"/>
         <EditorIndex Value="-1"/>
-        <TopLine Value="950"/>
-        <CursorPos X="30" Y="1054"/>
-        <UsageCount Value="1"/>
+        <UsageCount Value="3"/>
       </Unit10>
       <Unit11>
-        <Filename Value="../epost/typenunit.pas"/>
+        <Filename Value="rk1210.inc"/>
         <EditorIndex Value="-1"/>
-        <TopLine Value="347"/>
-        <CursorPos X="62" Y="358"/>
-        <UsageCount Value="1"/>
+        <TopLine Value="492"/>
+        <CursorPos X="28" Y="565"/>
+        <UsageCount Value="4"/>
       </Unit11>
       <Unit12>
-        <Filename Value="../units/systemunit.pas"/>
+        <Filename Value="rk1412.inc"/>
         <EditorIndex Value="-1"/>
-        <CursorPos X="3" Y="79"/>
-        <UsageCount Value="1"/>
+        <TopLine Value="640"/>
+        <CursorPos X="3" Y="676"/>
+        <UsageCount Value="10"/>
       </Unit12>
       <Unit13>
-        <Filename Value="/usr/lib/fpc/src/rtl/inc/objpash.inc"/>
+        <Filename Value="rk108.inc"/>
         <EditorIndex Value="-1"/>
-        <TopLine Value="232"/>
-        <CursorPos X="23" Y="192"/>
-        <UsageCount Value="1"/>
+        <CursorPos X="28" Y="8"/>
+        <UsageCount Value="4"/>
       </Unit13>
       <Unit14>
-        <Filename Value="rk14.inc"/>
+        <Filename Value="rk3_8.inc"/>
         <EditorIndex Value="-1"/>
-        <UsageCount Value="4"/>
+        <CursorPos X="41" Y="6"/>
+        <UsageCount Value="9"/>
       </Unit14>
       <Unit15>
-        <Filename Value="rk1210.inc"/>
+        <Filename Value="/usr/lib/fpc/src/rtl/objpas/math.pp"/>
         <EditorIndex Value="-1"/>
-        <TopLine Value="492"/>
-        <CursorPos X="28" Y="565"/>
-        <UsageCount Value="5"/>
+        <TopLine Value="559"/>
+        <CursorPos X="14" Y="568"/>
+        <UsageCount Value="8"/>
       </Unit15>
       <Unit16>
-        <Filename Value="rk1412.inc"/>
-        <EditorIndex Value="-1"/>
-        <TopLine Value="39"/>
-        <CursorPos X="3" Y="246"/>
-        <UsageCount Value="10"/>
+        <Filename Value="../units/fftw_l.pas"/>
+        <EditorIndex Value="2"/>
+        <TopLine Value="68"/>
+        <CursorPos X="29" Y="96"/>
+        <UsageCount Value="14"/>
+        <Loaded Value="True"/>
       </Unit16>
       <Unit17>
-        <Filename Value="rk108.inc"/>
+        <Filename Value="../units/fftw_s.pas"/>
         <EditorIndex Value="-1"/>
-        <CursorPos X="28" Y="8"/>
-        <UsageCount Value="5"/>
+        <CursorPos X="38" Y="25"/>
+        <UsageCount Value="9"/>
       </Unit17>
       <Unit18>
-        <Filename Value="rk3_8.inc"/>
+        <Filename Value="../units/fftw.pas"/>
         <EditorIndex Value="-1"/>
+        <TopLine Value="76"/>
         <UsageCount Value="9"/>
       </Unit18>
-      <Unit19>
-        <Filename Value="/usr/lib/fpc/src/rtl/objpas/math.pp"/>
-        <EditorIndex Value="-1"/>
-        <TopLine Value="559"/>
-        <CursorPos X="14" Y="568"/>
-        <UsageCount Value="9"/>
-      </Unit19>
     </Units>
     <JumpHistory Count="30" HistoryIndex="29">
       <Position1>
-        <Filename Value="../units/matheunit.pas"/>
-        <Caret Line="543" Column="19" TopLine="524"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="643" Column="48" TopLine="623"/>
       </Position1>
       <Position2>
-        <Filename Value="../units/matheunit.pas"/>
-        <Caret Line="511" Column="9" TopLine="505"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="108" Column="77" TopLine="94"/>
       </Position2>
       <Position3>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1190" Column="40" TopLine="1159"/>
+        <Caret Line="645" TopLine="622"/>
       </Position3>
       <Position4>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="606" TopLine="507"/>
+        <Caret Line="646" Column="59" TopLine="626"/>
       </Position4>
       <Position5>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="591" Column="8" TopLine="536"/>
+        <Caret Line="824" Column="25" TopLine="798"/>
       </Position5>
       <Position6>
-        <Filename Value="Plasmapropagation.lpr"/>
-        <Caret Line="53" Column="32" TopLine="21"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="843" Column="45" TopLine="818"/>
       </Position6>
       <Position7>
-        <Filename Value="Plasmapropagation.lpr"/>
-        <Caret Line="34" Column="10" TopLine="14"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="845" Column="13" TopLine="819"/>
       </Position7>
       <Position8>
-        <Filename Value="Plasmapropagation.lpr"/>
-        <Caret Line="11" Column="45"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="650" TopLine="632"/>
       </Position8>
       <Position9>
-        <Filename Value="Plasmapropagation.lpr"/>
-        <Caret Line="34" Column="10" TopLine="14"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="640" TopLine="632"/>
       </Position9>
       <Position10>
-        <Filename Value="Plasmapropagation.lpr"/>
-        <Caret Line="11" Column="55"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="642" TopLine="632"/>
       </Position10>
       <Position11>
-        <Filename Value="Plasmapropagation.lpr"/>
-        <Caret Line="35" Column="18" TopLine="33"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="644" TopLine="632"/>
       </Position11>
       <Position12>
-        <Filename Value="Plasmapropagation.lpr"/>
-        <Caret Line="36" Column="19" TopLine="34"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="645" TopLine="632"/>
       </Position12>
       <Position13>
-        <Filename Value="Plasmapropagation.lpr"/>
-        <Caret Line="57" Column="14" TopLine="33"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="646" TopLine="632"/>
       </Position13>
       <Position14>
-        <Filename Value="Plasmapropagation.lpr"/>
-        <Caret Line="34" TopLine="30"/>
+        <Filename Value="Physikunit.pas"/>
+        <Caret Line="648" TopLine="632"/>
       </Position14>
       <Position15>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1154" TopLine="1097"/>
+        <Caret Line="647" TopLine="632"/>
       </Position15>
       <Position16>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1742" Column="122" TopLine="1695"/>
+        <Caret Line="648" TopLine="632"/>
       </Position16>
       <Position17>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1404" Column="13" TopLine="1289"/>
+        <Caret Line="650" TopLine="632"/>
       </Position17>
       <Position18>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1267" Column="24" TopLine="1226"/>
+        <Caret Line="640" TopLine="632"/>
       </Position18>
       <Position19>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="875" TopLine="658"/>
+        <Caret Line="642" TopLine="632"/>
       </Position19>
       <Position20>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="130" Column="17" TopLine="109"/>
+        <Caret Line="644" TopLine="632"/>
       </Position20>
       <Position21>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="466" Column="83" TopLine="231"/>
+        <Caret Line="645" TopLine="632"/>
       </Position21>
       <Position22>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1192" Column="57" TopLine="1159"/>
+        <Caret Line="646" TopLine="632"/>
       </Position22>
       <Position23>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1166" Column="53" TopLine="1146"/>
+        <Caret Line="648" TopLine="632"/>
       </Position23>
       <Position24>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1185" Column="76" TopLine="1166"/>
+        <Caret Line="647" TopLine="632"/>
       </Position24>
       <Position25>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1136" TopLine="1057"/>
+        <Caret Line="648" TopLine="632"/>
       </Position25>
       <Position26>
-        <Filename Value="Physikunit.pas"/>
-        <Caret Line="1152" TopLine="1114"/>
+        <Filename Value="Plasmapropagation.lpr"/>
+        <Caret Line="47" TopLine="14"/>
       </Position26>
       <Position27>
-        <Filename Value="Physikunit.pas"/>
-        <Caret Line="1156" TopLine="1136"/>
+        <Filename Value="Plasmapropagation.lpr"/>
+        <Caret Line="63" Column="32" TopLine="38"/>
       </Position27>
       <Position28>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1157" TopLine="1138"/>
+        <Caret Line="650" Column="47" TopLine="611"/>
       </Position28>
       <Position29>
         <Filename Value="Physikunit.pas"/>
-        <Caret Line="1169" TopLine="1146"/>
+        <Caret Line="81" TopLine="81"/>
       </Position29>
       <Position30>
-        <Filename Value="Physikunit.pas"/>
-        <Caret Line="1192" Column="42" TopLine="1164"/>
+        <Filename Value="Plasmapropagation.lpr"/>
+        <Caret Line="37" Column="40" TopLine="16"/>
       </Position30>
     </JumpHistory>
   </ProjectSession>
diff --git a/genLikoInc b/genLikoInc
new file mode 100755
index 0000000..6db0770
--- /dev/null
+++ b/genLikoInc
@@ -0,0 +1,105 @@
+#!/bin/bash
+
+file="$(dirname "$0")/linearkombinationen.inc"
+maximum=32
+
+echo > ${file}
+echo "// interface *******************************************************************" >> ${file}
+echo >> ${file}
+echo "{\$IFDEF LiKoInterface}" >> ${file}
+echo "// Werte werden auf (in1 + \sum_i faki * ini') gesetzt" >> ${file}
+
+for ((i=2; i<=maximum; i++))
+do
+  echo -ne "procedure liKo(in1" >> ${file}
+  for ((j=2; j<=${i}; j++))
+  do
+    echo -ne ",in${j}" >> ${file}
+  done
+  echo -ne ": tFelder; fak2" >> ${file}
+  for ((j=3; j<=${i}; j++))
+  do
+    echo -ne ",fak${j}" >> ${file}
+  done
+  echo ": extended); overload; inline;" >> ${file}
+done
+
+echo "{\$ENDIF}" >> ${file}
+echo >> ${file}
+echo "// implementation **************************************************************" >> ${file}
+echo >> ${file}
+echo "{\$IFDEF LiKoImplementation}" >> ${file}
+echo >> ${file}
+echo "{\$INCLUDE linearkombination.inc}" >> ${file}
+for ((i=3; i<=maximum; i++))
+do
+  echo "{\$DEFINE lkA${i}}" >> ${file}
+  echo "{\$INCLUDE linearkombination.inc}" >> ${file}
+done
+for ((i=maximum; i>=3; i--))
+do
+  echo "{\$UNDEF lkA${i}}" >> ${file}
+done
+echo "{\$ENDIF}" >> ${file}
+
+# jetzt zur unter-Include ****************************************************************************
+
+file="$(dirname "$0")/linearkombination.inc"
+
+echo > ${file}
+echo "// Werte werden auf (in1 + \\sum_i faki * ini') gesetzt" >> ${file}
+echo >> ${file}
+echo -ne "procedure tFelder.liKo(in1,in2" >> ${file}
+for ((i=3; i<=maximum; i++))
+do
+  echo -ne "\n{\$IFDEF lkA${i}},in${i}{\$ENDIF}" >> ${file}
+done
+echo ": tFelder;" >> ${file}
+echo -ne "fak2" >> ${file}
+for ((i=3; i<=maximum; i++))
+do
+  echo -ne "\n{\$IFDEF lkA${i}},fak${i}{\$ENDIF}" >> ${file}
+done
+echo ": extended);" >> ${file}
+echo "var" >> ${file}
+echo "  i,j: longint;" >> ${file}
+echo "  emF: tEMFeldGroesze;" >> ${file}
+echo "begin" >> ${file}
+echo "  for emF:=low(tEMFeldGroesze) to high(tEMFeldGroesze) do" >> ${file}
+echo "    for i:=0 to aX-1 do" >> ${file}
+echo "      (emFelder[emF,false]+i)^:=" >> ${file}
+echo -ne "        (in1.emFelder[emF,false]+i)^" >> ${file}
+for ((i=2; i<=maximum; i++))
+do
+  if [ ${i} -gt 2 ]
+  then
+    echo -ne "\n        {\$IFDEF lkA${i}}" >> ${file}
+  fi
+  echo -ne "\n        + fak${i}*(in${i}.emFelder[emF,true]+i)^" >> ${file}
+  if [ ${i} -gt 2 ]
+  then
+    echo -ne "\n        {\$ENDIF}" >> ${file}
+  fi
+done
+echo ";" >> ${file}
+echo >> ${file}
+echo "  for i:=0 to length(impulsraum)-1 do" >> ${file}
+echo "    for j:=0 to aX*aP-1 do" >> ${file}
+echo "      (impulsraum[i,false]+j)^:=" >> ${file}
+echo -ne "        (in1.impulsraum[i,false]+j)^" >> ${file}
+for ((i=2; i<=maximum; i++))
+do
+  if [ ${i} -gt 2 ]
+  then
+    echo -ne "\n        {\$IFDEF lkA${i}}" >> ${file}
+  fi
+  echo -ne "\n        + fak${i}*(in${i}.impulsraum[i,true]+j)^" >> ${file}
+  if [ ${i} -gt 2 ]
+  then
+    echo -ne "\n        {\$ENDIF}" >> ${file}
+  fi
+done
+echo ";" >> ${file}
+echo >> ${file}
+echo "end;" >> ${file}
+
diff --git a/input.plap b/input.plap
index 3196fee..e0bcd9d 100644
--- a/input.plap
+++ b/input.plap
@@ -20,7 +20,7 @@ allgemeinEnde
 ausgaben
   prefix         /home_raid/erich/Dokumente/Prograemmchen/Plasmapropagation/Daten/
   suffix         _test.dat
-  felder         AX,AY,dAYDT,EX,BY,BZ,Rho1,Rho2,VX1,PX1,PXSqr1,N1,PXRipple1
+  felder         AX,AY,dAYDT,EX,BZ,Rho1,Rho2,VX1,PX1,PXSqr1,N1,PXRipple1
 ausgabenEnde
 
 !setze $tFwhm:   (2.5 * T)
diff --git a/linearkombination.inc b/linearkombination.inc
index 85ed695..8fca2c0 100644
--- a/linearkombination.inc
+++ b/linearkombination.inc
@@ -1,325 +1,262 @@
-// 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 tRaumPunkt.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}: tRaumPunkt;
+procedure tFelder.liKo(in1,in2
+{$IFDEF lkA3},in3{$ENDIF}
+{$IFDEF lkA4},in4{$ENDIF}
+{$IFDEF lkA5},in5{$ENDIF}
+{$IFDEF lkA6},in6{$ENDIF}
+{$IFDEF lkA7},in7{$ENDIF}
+{$IFDEF lkA8},in8{$ENDIF}
+{$IFDEF lkA9},in9{$ENDIF}
+{$IFDEF lkA10},in10{$ENDIF}
+{$IFDEF lkA11},in11{$ENDIF}
+{$IFDEF lkA12},in12{$ENDIF}
+{$IFDEF lkA13},in13{$ENDIF}
+{$IFDEF lkA14},in14{$ENDIF}
+{$IFDEF lkA15},in15{$ENDIF}
+{$IFDEF lkA16},in16{$ENDIF}
+{$IFDEF lkA17},in17{$ENDIF}
+{$IFDEF lkA18},in18{$ENDIF}
+{$IFDEF lkA19},in19{$ENDIF}
+{$IFDEF lkA20},in20{$ENDIF}
+{$IFDEF lkA21},in21{$ENDIF}
+{$IFDEF lkA22},in22{$ENDIF}
+{$IFDEF lkA23},in23{$ENDIF}
+{$IFDEF lkA24},in24{$ENDIF}
+{$IFDEF lkA25},in25{$ENDIF}
+{$IFDEF lkA26},in26{$ENDIF}
+{$IFDEF lkA27},in27{$ENDIF}
+{$IFDEF lkA28},in28{$ENDIF}
+{$IFDEF lkA29},in29{$ENDIF}
+{$IFDEF lkA30},in30{$ENDIF}
+{$IFDEF lkA31},in31{$ENDIF}
+{$IFDEF lkA32},in32{$ENDIF}: tFelder;
 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);
+{$IFDEF lkA3},fak3{$ENDIF}
+{$IFDEF lkA4},fak4{$ENDIF}
+{$IFDEF lkA5},fak5{$ENDIF}
+{$IFDEF lkA6},fak6{$ENDIF}
+{$IFDEF lkA7},fak7{$ENDIF}
+{$IFDEF lkA8},fak8{$ENDIF}
+{$IFDEF lkA9},fak9{$ENDIF}
+{$IFDEF lkA10},fak10{$ENDIF}
+{$IFDEF lkA11},fak11{$ENDIF}
+{$IFDEF lkA12},fak12{$ENDIF}
+{$IFDEF lkA13},fak13{$ENDIF}
+{$IFDEF lkA14},fak14{$ENDIF}
+{$IFDEF lkA15},fak15{$ENDIF}
+{$IFDEF lkA16},fak16{$ENDIF}
+{$IFDEF lkA17},fak17{$ENDIF}
+{$IFDEF lkA18},fak18{$ENDIF}
+{$IFDEF lkA19},fak19{$ENDIF}
+{$IFDEF lkA20},fak20{$ENDIF}
+{$IFDEF lkA21},fak21{$ENDIF}
+{$IFDEF lkA22},fak22{$ENDIF}
+{$IFDEF lkA23},fak23{$ENDIF}
+{$IFDEF lkA24},fak24{$ENDIF}
+{$IFDEF lkA25},fak25{$ENDIF}
+{$IFDEF lkA26},fak26{$ENDIF}
+{$IFDEF lkA27},fak27{$ENDIF}
+{$IFDEF lkA28},fak28{$ENDIF}
+{$IFDEF lkA29},fak29{$ENDIF}
+{$IFDEF lkA30},fak30{$ENDIF}
+{$IFDEF lkA31},fak31{$ENDIF}
+{$IFDEF lkA32},fak32{$ENDIF}: extended);
 var
+  i,j: longint;
   emF: tEMFeldGroesze;
-  i:   longint;
 begin
-(*  tEMFeldInhalt = (
-      efA,efAX,efAY,efAZ,
-      efDAXDT,efDAYDT,efDAZDT,
-      efDPhiDX
-    ); *)
-  for emF:=erstesEMFMitAbleitung to letztesEMFMitAbleitung do
-    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};
+  for emF:=low(tEMFeldGroesze) to high(tEMFeldGroesze) do
+    for i:=0 to aX-1 do
+      (emFelder[emF,false]+i)^:=
+        (in1.emFelder[emF,false]+i)^
+        + fak2*(in2.emFelder[emF,true]+i)^
+        {$IFDEF lkA3}
+        + fak3*(in3.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA4}
+        + fak4*(in4.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA5}
+        + fak5*(in5.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA6}
+        + fak6*(in6.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA7}
+        + fak7*(in7.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA8}
+        + fak8*(in8.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA9}
+        + fak9*(in9.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA10}
+        + fak10*(in10.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA11}
+        + fak11*(in11.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA12}
+        + fak12*(in12.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA13}
+        + fak13*(in13.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA14}
+        + fak14*(in14.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA15}
+        + fak15*(in15.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA16}
+        + fak16*(in16.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA17}
+        + fak17*(in17.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA18}
+        + fak18*(in18.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA19}
+        + fak19*(in19.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA20}
+        + fak20*(in20.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA21}
+        + fak21*(in21.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA22}
+        + fak22*(in22.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA23}
+        + fak23*(in23.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA24}
+        + fak24*(in24.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA25}
+        + fak25*(in25.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA26}
+        + fak26*(in26.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA27}
+        + fak27*(in27.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA28}
+        + fak28*(in28.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA29}
+        + fak29*(in29.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA30}
+        + fak30*(in30.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA31}
+        + fak31*(in31.emFelder[emF,true]+i)^
+        {$ENDIF}
+        {$IFDEF lkA32}
+        + fak32*(in32.emFelder[emF,true]+i)^
+        {$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
+  for i:=0 to length(impulsraum)-1 do
+    for j:=0 to aX*aP-1 do
+      (impulsraum[i,false]+j)^:=
+        (in1.impulsraum[i,false]+j)^
+        + fak2*(in2.impulsraum[i,true]+j)^
+        {$IFDEF lkA3}
+        + fak3*(in3.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA4}
+        + fak4*(in4.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA5}
+        + fak5*(in5.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA6}
+        + fak6*(in6.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA7}
+        + fak7*(in7.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA8}
+        + fak8*(in8.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA9}
+        + fak9*(in9.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA10}
+        + fak10*(in10.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA11}
+        + fak11*(in11.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA12}
+        + fak12*(in12.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA13}
+        + fak13*(in13.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA14}
+        + fak14*(in14.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA15}
+        + fak15*(in15.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA16}
+        + fak16*(in16.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA17}
+        + fak17*(in17.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA18}
+        + fak18*(in18.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA19}
+        + fak19*(in19.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA20}
+        + fak20*(in20.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA21}
+        + fak21*(in21.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA22}
+        + fak22*(in22.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA23}
+        + fak23*(in23.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA24}
+        + fak24*(in24.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA25}
+        + fak25*(in25.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA26}
+        + fak26*(in26.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA27}
+        + fak27*(in27.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA28}
+        + fak28*(in28.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA29}
+        + fak29*(in29.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA30}
+        + fak30*(in30.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA31}
+        + fak31*(in31.impulsraum[i,true]+j)^
+        {$ENDIF}
+        {$IFDEF lkA32}
+        + fak32*(in32.impulsraum[i,true]+j)^
+        {$ENDIF};
 
-procedure tFelder.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}: tFelder;
-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(inhalt)-1 do
-    inhalt[i].liKo(
-      in1.inhalt[i],in2.inhalt[i]
-      {$IFDEF lkA3},in3.inhalt[i]
-      {$IFDEF lkA4},in4.inhalt[i]
-      {$IFDEF lkA5},in5.inhalt[i]
-      {$IFDEF lkA6},in6.inhalt[i]
-      {$IFDEF lkA7},in7.inhalt[i]
-      {$IFDEF lkA8},in8.inhalt[i]
-      {$IFDEF lkA9},in9.inhalt[i]
-      {$IFDEF lkA10},in10.inhalt[i]
-      {$IFDEF lkA11},in11.inhalt[i]
-      {$IFDEF lkA12},in12.inhalt[i]
-      {$IFDEF lkA14},in13.inhalt[i],in14.inhalt[i]
-      {$IFDEF lkA15},in15.inhalt[i]
-      {$IFDEF lkA16},in16.inhalt[i]
-      {$IFDEF lkA17},in17.inhalt[i]
-      {$IFDEF lkA18},in18.inhalt[i]
-      {$IFDEF lkA19},in19.inhalt[i]
-      {$IFDEF lkA22},in20.inhalt[i],in21.inhalt[i],in22.inhalt[i]
-      {$IFDEF lkA23},in23.inhalt[i]
-      {$IFDEF lkA31},in24.inhalt[i],in25.inhalt[i],in26.inhalt[i],in27.inhalt[i],in28.inhalt[i],in29.inhalt[i],in30.inhalt[i],in31.inhalt[i]
-      {$IFDEF lkA32},in32.inhalt[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});
-  for i:=0 to length(inhalt)-1 do
-    gesamtDefizit:=gesamtDefizit+inhalt[i].nichtnegativieren;
 end;
-
diff --git a/linearkombinationen.inc b/linearkombinationen.inc
index 6717141..5862886 100644
--- a/linearkombinationen.inc
+++ b/linearkombinationen.inc
@@ -1,88 +1,44 @@
 
 // interface *******************************************************************
 
-{$IFDEF LiKotImpulsPunktHeader}
-procedure liKo(in1,in2: tImpulsPunkt; fak2: extended); overload; inline;                           // Werte werden auf (in1 + \sum_i faki * ini') gesetzt
-procedure liKo(in1,in2,in3: tImpulsPunkt; fak2,fak3: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4: tImpulsPunkt; fak2,fak3,fak4: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5: tImpulsPunkt; fak2,fak3,fak4,fak5: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5,in6: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5,in6,in7: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10: tImpulsPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10: extended); overload; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
+{$IFDEF LiKoInterface}
+// Werte werden auf (in1 + \sum_i faki * ini') gesetzt
+procedure liKo(in1,in2: tFelder; fak2: extended); overload; inline;
+procedure liKo(in1,in2,in3: tFelder; fak2,fak3: extended); overload; inline;
+procedure liKo(in1,in2,in3,in4: tFelder; fak2,fak3,fak4: extended); overload; inline;
+procedure liKo(in1,in2,in3,in4,in5: tFelder; fak2,fak3,fak4,fak5: extended); overload; inline;
+procedure liKo(in1,in2,in3,in4,in5,in6: tFelder; fak2,fak3,fak4,fak5,fak6: extended); overload; inline;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7: tFelder; fak2,fak3,fak4,fak5,fak6,fak7: extended); overload; inline;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8: extended); overload; inline;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9: extended); overload; inline;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10: extended); overload; inline;
+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; inline;
+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; inline;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13: extended); overload; inline;
+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; inline;
+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; inline;
+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; inline;
+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; inline;
+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; inline;
+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; inline;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20: extended); overload; inline;
+procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15,in16,in17,in18,in19,in20,in21: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21: extended); overload; inline;
+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; inline;
+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; inline;
+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: tFelder; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10,fak11,fak12,fak13,fak14,fak15,fak16,fak17,fak18,fak19,fak20,fak21,fak22,fak23,fak24: extended); overload; inline;
+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: 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: extended); overload; inline;
+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: 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: extended); overload; inline;
+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: 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: extended); overload; inline;
+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: 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: extended); overload; inline;
+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: 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: extended); overload; inline;
+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: 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: extended); overload; inline;
+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; inline;
+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; inline;
 {$ENDIF}
 
-{$IFDEF LiKotRaumPunktHeader}
-procedure liKo(in1,in2: tRaumPunkt; fak2: extended); overload; inline;                           // Werte werden auf (in1 + \sum_i faki * ini') gesetzt
-procedure liKo(in1,in2,in3: tRaumPunkt; fak2,fak3: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4: tRaumPunkt; fak2,fak3,fak4: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5: tRaumPunkt; fak2,fak3,fak4,fak5: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5,in6: tRaumPunkt; fak2,fak3,fak4,fak5,fak6: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5,in6,in7: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9: extended); overload; inline;
-procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10: tRaumPunkt; fak2,fak3,fak4,fak5,fak6,fak7,fak8,fak9,fak10: extended); overload; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-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; inline;
-{$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}
+{$IFDEF LiKoImplementation}
 
 {$INCLUDE linearkombination.inc}
 {$DEFINE lkA3}
@@ -105,6 +61,8 @@ procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15
 {$INCLUDE linearkombination.inc}
 {$DEFINE lkA12}
 {$INCLUDE linearkombination.inc}
+{$DEFINE lkA13}
+{$INCLUDE linearkombination.inc}
 {$DEFINE lkA14}
 {$INCLUDE linearkombination.inc}
 {$DEFINE lkA15}
@@ -117,13 +75,60 @@ procedure liKo(in1,in2,in3,in4,in5,in6,in7,in8,in9,in10,in11,in12,in13,in14,in15
 {$INCLUDE linearkombination.inc}
 {$DEFINE lkA19}
 {$INCLUDE linearkombination.inc}
+{$DEFINE lkA20}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA21}
+{$INCLUDE linearkombination.inc}
 {$DEFINE lkA22}
 {$INCLUDE linearkombination.inc}
 {$DEFINE lkA23}
 {$INCLUDE linearkombination.inc}
+{$DEFINE lkA24}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA25}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA26}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA27}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA28}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA29}
+{$INCLUDE linearkombination.inc}
+{$DEFINE lkA30}
+{$INCLUDE linearkombination.inc}
 {$DEFINE lkA31}
 {$INCLUDE linearkombination.inc}
 {$DEFINE lkA32}
 {$INCLUDE linearkombination.inc}
-
+{$UNDEF lkA32}
+{$UNDEF lkA31}
+{$UNDEF lkA30}
+{$UNDEF lkA29}
+{$UNDEF lkA28}
+{$UNDEF lkA27}
+{$UNDEF lkA26}
+{$UNDEF lkA25}
+{$UNDEF lkA24}
+{$UNDEF lkA23}
+{$UNDEF lkA22}
+{$UNDEF lkA21}
+{$UNDEF lkA20}
+{$UNDEF lkA19}
+{$UNDEF lkA18}
+{$UNDEF lkA17}
+{$UNDEF lkA16}
+{$UNDEF lkA15}
+{$UNDEF lkA14}
+{$UNDEF lkA13}
+{$UNDEF lkA12}
+{$UNDEF lkA11}
+{$UNDEF lkA10}
+{$UNDEF lkA9}
+{$UNDEF lkA8}
+{$UNDEF lkA7}
+{$UNDEF lkA6}
+{$UNDEF lkA5}
+{$UNDEF lkA4}
+{$UNDEF lkA3}
 {$ENDIF}
diff --git a/rk108.inc b/rk108.inc
index 9e3a79f..c4a8868 100644
--- a/rk108.inc
+++ b/rk108.inc
@@ -3,7 +3,7 @@
     felders[aktuelleFelder],
     0.1 * dT
   );
-  felders[2].berechneAbleitungen(dX,iDX);
+  felders[2].berechneAbleitungen;
 
 
   felders[3].liKo(
@@ -13,7 +13,7 @@
     -0.91517656137529144052001501927534215431895138766436972056466 * dT,
     1.45453440217827322805250021715664459117622483736537873607016 * dT
   );
-  felders[3].berechneAbleitungen(dX,iDX);
+  felders[3].berechneAbleitungen;
 
 
   felders[4].liKo(
@@ -23,7 +23,7 @@
     0.202259190301118170324681949205488413821477543637878380814562 * dT,
     0.606777570903354510974045847616465241464432630913635142443687 * dT
   );
-  felders[4].berechneAbleitungen(dX,iDX);
+  felders[4].berechneAbleitungen;
 
 
   felders[5].liKo(
@@ -35,7 +35,7 @@
     0.197966831227192369068141770510388793370637287463360401555746 * dT,
     -0.0729547847313632629185146671595558023015011608914382961421311 * dT
   );
-  felders[5].berechneAbleitungen(dX,iDX);
+  felders[5].berechneAbleitungen;
 
 
   felders[6].liKo(
@@ -47,7 +47,7 @@
     0.410459702520260645318174895920453426088035325902848695210406 * dT,
     0.482713753678866489204726942976896106809132737721421333413261 * dT
   );
-  felders[6].berechneAbleitungen(dX,iDX);
+  felders[6].berechneAbleitungen;
 
 
   felders[7].liKo(
@@ -61,7 +61,7 @@
     0.48966295730945019284450701113589820117801547843379009721079 * dT,
     -0.0731856375070850736789057580558988816340355615025188195854775 * dT
   );
-  felders[7].berechneAbleitungen(dX,iDX);
+  felders[7].berechneAbleitungen;
 
 
   felders[8].liKo(
@@ -75,7 +75,7 @@
     0.0325402621549091330158899334391231259332716675992700000776101 * dT,
     -0.0595780211817361001560122202563305121444953672762930724538856 * dT
   );
-  felders[8].berechneAbleitungen(dX,iDX);
+  felders[8].berechneAbleitungen;
 
 
   felders[9].liKo(
@@ -89,7 +89,7 @@
     0.32176370560177839010089879904987890408140436860307712925111 * dT,
     0.51048572560806303157775901228512341674467213703175235406759 * dT
   );
-  felders[9].berechneAbleitungen(dX,iDX);
+  felders[9].berechneAbleitungen;
 
 
   felders[10].liKo(
@@ -105,7 +105,7 @@
     0.499269229556880061353316843969978567860276816592673201240332 * dT,
     0.50950460892968610423609869004538625398664323235298960218506 * dT
   );
-  felders[10].berechneAbleitungen(dX,iDX);
+  felders[10].berechneAbleitungen;
 
 
   felders[11].liKo(
@@ -123,7 +123,7 @@
     0.0107558956873607455550609147441477450257136782823280838547024 * dT,
     -0.327769124164018874147061087350233395378262992392394071906457 * dT
   );
-  felders[11].berechneAbleitungen(dX,iDX);
+  felders[11].berechneAbleitungen;
 
 
   felders[12].liKo(
@@ -143,7 +143,7 @@
     -0.0782942710351670777553986729725692447252077047239160551335016 * dT,
     -0.114503299361098912184303164290554670970133218405658122674674 * dT
   );
-  felders[12].berechneAbleitungen(dX,iDX);
+  felders[12].berechneAbleitungen;
 
 
   felders[13].liKo(
@@ -169,7 +169,7 @@
     -3.25479342483643918654589367587788726747711504674780680269911 * dT,
     -2.16343541686422982353954211300054820889678036420109999154887 * dT
   );
-  felders[13].berechneAbleitungen(dX,iDX);
+  felders[13].berechneAbleitungen;
 
 
   felders[14].liKo(
@@ -197,7 +197,7 @@
     -1.71561608285936264922031819751349098912615880827551992973034 * dT,
     -0.0244036405750127452135415444412216875465593598370910566069132 * dT
   );
-  felders[14].berechneAbleitungen(dX,iDX);
+  felders[14].berechneAbleitungen;
 
 
   felders[15].liKo(
@@ -215,7 +215,7 @@
     0.0910895662155176069593203555807484200111889091770101799647985 * dT,
     0.777333643644968233538931228575302137803351053629547286334469 * dT
   );
-  felders[15].berechneAbleitungen(dX,iDX);
+  felders[15].berechneAbleitungen;
 
 
   felders[16].liKo(
@@ -227,7 +227,7 @@
     -0.157178665799771163367058998273128921867183754126709419409654 * dT,
     0.157178665799771163367058998273128921867183754126709419409654 * dT
   );
-  felders[16].berechneAbleitungen(dX,iDX);
+  felders[16].berechneAbleitungen;
 
 
   felders[17].liKo(
@@ -263,7 +263,7 @@
     -0.34275815984718983994222055341385087174233873470395891993726 * dT,
     -0.675 * dT
   );
-  felders[17].berechneAbleitungen(dX,iDX);
+  felders[17].berechneAbleitungen;
 
 
   felders[1-aktuelleFelder].liKo(
diff --git a/rk1210.inc b/rk1210.inc
index 12c6881..71cf35f 100644
--- a/rk1210.inc
+++ b/rk1210.inc
@@ -3,7 +3,7 @@
     felders[aktuelleFelder],
     0.2 * dT
   );
-  felders[2].berechneAbleitungen(dX,iDX);
+  felders[2].berechneAbleitungen;
 
 
   felders[3].liKo(
@@ -13,7 +13,7 @@
     -0.216049382716049382716049382716049382716049382716049382716049 * dT,
     0.771604938271604938271604938271604938271604938271604938271605 * dT
   );
-  felders[3].berechneAbleitungen(dX,iDX);
+  felders[3].berechneAbleitungen;
 
 
   felders[4].liKo(
@@ -23,7 +23,7 @@
     0.208333333333333333333333333333333333333333333333333333333333 * dT,
     0.625 * dT
   );
-  felders[4].berechneAbleitungen(dX,iDX);
+  felders[4].berechneAbleitungen;
 
 
   felders[5].liKo(
@@ -35,7 +35,7 @@
     0.22 * dT,
     -0.08 * dT
   );
-  felders[5].berechneAbleitungen(dX,iDX);
+  felders[5].berechneAbleitungen;
 
 
   felders[6].liKo(
@@ -47,7 +47,7 @@
     0.4 * dT,
     0.5 * dT
   );
-  felders[6].berechneAbleitungen(dX,iDX);
+  felders[6].berechneAbleitungen;
 
 
   felders[7].liKo(
@@ -61,7 +61,7 @@
     0.48317116756103289928883648045196250872410925751728917730238 * dT,
     -0.038753024569476325208568144376762058039573330234136803880429 * dT
   );
-  felders[7].berechneAbleitungen(dX,iDX);
+  felders[7].berechneAbleitungen;
 
 
   felders[8].liKo(
@@ -75,7 +75,7 @@
     0.0137455792075966759812907801835048190594443990939408530842918 * dT,
     -0.0661095317267682844455831341498149531672668252085016565917546 * dT
   );
-  felders[8].berechneAbleitungen(dX,iDX);
+  felders[8].berechneAbleitungen;
 
 
   felders[9].liKo(
@@ -89,7 +89,7 @@
     0.0680716801688453518578515120895103863112751730758794372203952 * dT,
     0.408394315582641046727306852653894780093303185664924644551239 * dT
   );
-  felders[9].berechneAbleitungen(dX,iDX);
+  felders[9].berechneAbleitungen;
 
 
   felders[10].liKo(
@@ -105,7 +105,7 @@
     0.427930210752576611068192608300897981558240730580396406312359 * dT,
     -0.0865117637557827005740277475955029103267246394128995965941585 * dT
   );
-  felders[10].berechneAbleitungen(dX,iDX);
+  felders[10].berechneAbleitungen;
 
 
   felders[11].liKo(
@@ -123,7 +123,7 @@
     -0.951294772321088980532340837388859453930924498799228648050949 * dT,
     -0.408276642965631951497484981519757463459627174520978426909934 * dT
   );
-  felders[11].berechneAbleitungen(dX,iDX);
+  felders[11].berechneAbleitungen;
 
 
   felders[12].liKo(
@@ -143,7 +143,7 @@
     0.00263265981064536974369934736325334761174975280887405725010964 * dT,
     0.00315472768977025060103545855572111407955208306374459723959783 * dT
   );
-  felders[12].berechneAbleitungen(dX,iDX);
+  felders[12].berechneAbleitungen;
 
 
   felders[13].liKo(
@@ -159,7 +159,7 @@
     0.0000176358982260285155407485928953302139937553442829975734148981 * dT,
     0.0653866627415027051009595231385181033549511358787382098351924 * dT
   );
-  felders[13].berechneAbleitungen(dX,iDX);
+  felders[13].berechneAbleitungen;
 
 
   felders[14].liKo(
@@ -177,7 +177,7 @@
     -0.861264460105717678161432562258351242030270498966891201799225 * dT,
     0.908651882074050281096239478469262145034957129939256789178785 * dT
   );
-  felders[14].berechneAbleitungen(dX,iDX);
+  felders[14].berechneAbleitungen;
 
 
   felders[15].liKo(
@@ -197,7 +197,7 @@
     0.00535364695524996055083260173615567408717110247274021056118319 * dT,
     0.301167864010967916837091303817051676920059229784957479998077 * dT
   );
-  felders[15].berechneAbleitungen(dX,iDX);
+  felders[15].berechneAbleitungen;
 
 
   felders[16].liKo(
@@ -219,7 +219,7 @@
     -0.214007467967990254219503540827349569639028092344812795499026 * dT,
     0.958202417754430239892724139109781371059908874605153648768037 * dT
   );
-  felders[16].berechneAbleitungen(dX,iDX);
+  felders[16].berechneAbleitungen;
 
 
   felders[17].liKo(
@@ -243,7 +243,7 @@
     -1.10683733362380649395704708016953056176195769617014899442903 * dT,
     -0.929529037579203999778397238291233214220788057511899747507074 * dT
   );
-  felders[17].berechneAbleitungen(dX,iDX);
+  felders[17].berechneAbleitungen;
 
 
   felders[18].liKo(
@@ -275,7 +275,7 @@
     -1.94300935242819610883833776782364287728724899124166920477873 * dT,
     -0.128352601849404542018428714319344620742146491335612353559923 * dT
   );
-  felders[18].berechneAbleitungen(dX,iDX);
+  felders[18].berechneAbleitungen;
 
 
   felders[19].liKo(
@@ -309,7 +309,7 @@
     -0.00115618834794939500490703608435907610059605754935305582045729 * dT,
     -0.00544057908677007389319819914241631024660726585015012485938593 * dT
   );
-  felders[19].berechneAbleitungen(dX,iDX);
+  felders[19].berechneAbleitungen;
 
 
   felders[20].liKo(
@@ -345,7 +345,7 @@
     0.0418603916412360287969841020776788461794119440689356178942252 * dT,
     0.279084255090877355915660874555379649966282167560126269290222 * dT
   );
-  felders[20].berechneAbleitungen(dX,iDX);
+  felders[20].berechneAbleitungen;
 
 
   felders[21].liKo(
@@ -371,7 +371,7 @@
     0.218636633721676647685111485017151199362509373698288330593486 * dT,
     0.438313820361122420391059788940960176420682836652600698580091 * dT
   );
-  felders[21].berechneAbleitungen(dX,iDX);
+  felders[21].berechneAbleitungen;
 
 
   felders[22].liKo(
@@ -399,7 +399,7 @@
     0.196410889223054653446526504390100417677539095340135532418849 * dT,
     -0.0984256130499315928152900286856048243348202521491288575952143 * dT
   );
-  felders[22].berechneAbleitungen(dX,iDX);
+  felders[22].berechneAbleitungen;
 
 
   felders[23].liKo(
@@ -417,7 +417,7 @@
     0.390696469295978451446999802258495981249099665294395945559163 * dT,
     0.666666666666666666666666666666666666666666666666666666666667 * dT
   );
-  felders[23].berechneAbleitungen(dX,iDX);
+  felders[23].berechneAbleitungen;
 
 
   felders[24].liKo(
@@ -429,7 +429,7 @@
     -0.164609053497942386831275720164609053497942386831275720164609 * dT,
     0.164609053497942386831275720164609053497942386831275720164609 * dT
   );
-  felders[24].berechneAbleitungen(dX,iDX);
+  felders[24].berechneAbleitungen;
 
 
   felders[25].liKo(
@@ -479,7 +479,7 @@
     -0.421296296296296296296296296296296296296296296296296296296296 * dT,
     -0.7875 * dT
   );
-  felders[25].berechneAbleitungen(dX,iDX);
+  felders[25].berechneAbleitungen;
 
 
   felders[1-aktuelleFelder].liKo(
diff --git a/rk1412.inc b/rk1412.inc
index fb8cb56..aa51d64 100644
--- a/rk1412.inc
+++ b/rk1412.inc
@@ -3,7 +3,7 @@
     felders[aktuelleFelder],
     0.111111111111111111111111111111111111111111111111111111111111 * dT
   );
-  felders[2].berechneAbleitungen(dX,iDX);
+  felders[2].berechneAbleitungen;
 
 
   felders[3].liKo(
@@ -13,7 +13,7 @@
     -0.833333333333333333333333333333333333333333333333333333333333 * dT,
     1.38888888888888888888888888888888888888888888888888888888889 * dT
   );
-  felders[3].berechneAbleitungen(dX,iDX);
+  felders[3].berechneAbleitungen;
 
 
   felders[4].liKo(
@@ -23,7 +23,7 @@
     0.208333333333333333333333333333333333333333333333333333333333 * dT,
     0.625 * dT
   );
-  felders[4].berechneAbleitungen(dX,iDX);
+  felders[4].berechneAbleitungen;
 
 
   felders[5].liKo(
@@ -35,7 +35,7 @@
     0.22 * dT,
     -0.08 * dT
   );
-  felders[5].berechneAbleitungen(dX,iDX);
+  felders[5].berechneAbleitungen;
 
 
   felders[6].liKo(
@@ -47,7 +47,7 @@
     0.4 * dT,
     0.5 * dT
   );
-  felders[6].berechneAbleitungen(dX,iDX);
+  felders[6].berechneAbleitungen;
 
 
   felders[7].liKo(
@@ -61,7 +61,7 @@
     0.482574490331246622475134780125688112865919023850168049679402 * dT,
     -0.038140960001560699973088624000562020566411307247841147742197 * dT
   );
-  felders[7].berechneAbleitungen(dX,iDX);
+  felders[7].berechneAbleitungen;
 
 
   felders[8].liKo(
@@ -75,7 +75,7 @@
     0.0137885887618080880607695837016477814530969417491493385363543 * dT,
     -0.06722101339966844497493995074143058569500863415253821828562 * dT
   );
-  felders[8].berechneAbleitungen(dX,iDX);
+  felders[8].berechneAbleitungen;
 
 
   felders[9].liKo(
@@ -89,7 +89,7 @@
     0.216019825625503063708860097659866573490979433278117320188668 * dT,
     0.423695063515761937337619073960976753205867469544123532683116 * dT
   );
-  felders[9].berechneAbleitungen(dX,iDX);
+  felders[9].berechneAbleitungen;
 
 
   felders[10].liKo(
@@ -105,7 +105,7 @@
     0.0978080858367729012259313014081291665503740655476733940756599 * dT,
     0.217590689243420631360008651767860318344168120024782176879989 * dT
   );
-  felders[10].berechneAbleitungen(dX,iDX);
+  felders[10].berechneAbleitungen;
 
 
   felders[11].liKo(
@@ -123,7 +123,7 @@
     -0.247656877593994914689992276329810825853958069263947095548189 * dT,
     0.110895029771437682893999851839061714522445173600678718208625 * dT
   );
-  felders[11].berechneAbleitungen(dX,iDX);
+  felders[11].berechneAbleitungen;
 
 
   felders[12].liKo(
@@ -143,7 +143,7 @@
     0.204890423831599428189499202098105603312029235081420653574829 * dT,
     -1.56261579627468188307070943950527825211462892236424360892806 * dT
   );
-  felders[12].berechneAbleitungen(dX,iDX);
+  felders[12].berechneAbleitungen;
 
 
   felders[13].liKo(
@@ -159,7 +159,7 @@
     -0.00805328367804983036823857162048902911923392887337029314844206 * dT,
     0.0211517528067396521915711903523399601316877825157550573051221 * dT
   );
-  felders[13].berechneAbleitungen(dX,iDX);
+  felders[13].berechneAbleitungen;
 
 
   felders[14].liKo(
@@ -177,7 +177,7 @@
     0.00988442549447664668946335414487885256040819982786014648129297 * dT,
     -0.0213010771328887351384307642875927384886634565429572466632092 * dT
   );
-  felders[14].berechneAbleitungen(dX,iDX);
+  felders[14].berechneAbleitungen;
 
 
   felders[15].liKo(
@@ -197,7 +197,7 @@
     -0.977235005036766810872264852372525633013107656892839677696022 * dT,
     -0.660026980479294694616225013856327693720573981219974874776419 * dT
   );
-  felders[15].berechneAbleitungen(dX,iDX);
+  felders[15].berechneAbleitungen;
 
 
   felders[16].liKo(
@@ -219,7 +219,7 @@
     0.124343093331358243286225595741786448038973408895106741855721 * dT,
     0.00413829693239480694403512496204335960426192908674476033832967 * dT
   );
-  felders[16].berechneAbleitungen(dX,iDX);
+  felders[16].berechneAbleitungen;
 
 
   felders[17].liKo(
@@ -243,7 +243,7 @@
     0.251708904586819292210480529948970541404887852931447491219418 * dT,
     0.779906470345586398810756795282334476023540593411550187024263 * dT
   );
-  felders[17].berechneAbleitungen(dX,iDX);
+  felders[17].berechneAbleitungen;
 
 
   felders[18].liKo(
@@ -261,7 +261,7 @@
     0.000591726029494171190528755742777717259844340971924321528178248 * dT,
     -4.01614722154557337064691684906375587732264247950093804676867E-7 * dT
   );
-  felders[18].berechneAbleitungen(dX,iDX);
+  felders[18].berechneAbleitungen;
 
 
   felders[19].liKo(
@@ -281,7 +281,7 @@
     -2.04486480935804242706707569691004307904442837552677456232848E-6 * dT,
     0.105328578824431893399799402979093997354240904235172843146582 * dT
   );
-  felders[19].berechneAbleitungen(dX,iDX);
+  felders[19].berechneAbleitungen;
 
 
   felders[20].liKo(
@@ -303,7 +303,7 @@
     7.64130548038698765563029310880237651185173367813936997648198 * dT,
     3.50602043659751834989896082949744710968212949893375368243588 * dT
   );
-  felders[20].berechneAbleitungen(dX,iDX);
+  felders[20].berechneAbleitungen;
 
 
   felders[21].liKo(
@@ -327,7 +327,7 @@
     -3.64411637921569236846406990361350645806721478409266709351203 * dT,
     -0.804503249910509910899030787958579499315694913210787878260459 * dT
   );
-  felders[21].berechneAbleitungen(dX,iDX);
+  felders[21].berechneAbleitungen;
 
 
   felders[22].liKo(
@@ -353,7 +353,7 @@
     13.1939710030282333443670964371153238435064159623744975073252 * dT,
     1.25128781283980445450114974148056006317268830077396406361417 * dT
   );
-  felders[22].berechneAbleitungen(dX,iDX);
+  felders[22].berechneAbleitungen;
 
 
   felders[23].liKo(
@@ -381,7 +381,7 @@
     0.422422733996325326010225127471388772575086538809603346825334 * dT,
     0.0859131249503067107308438031499859443441115056294154956487671 * dT
   );
-  felders[23].berechneAbleitungen(dX,iDX);
+  felders[23].berechneAbleitungen;
 
 
   felders[24].liKo(
@@ -419,7 +419,7 @@
     0.0210134706331264177317735424331396407424412188443757490871603 * dT,
     0.00952196014417121794175101542454575907376360233658356240547761 * dT
   );
-  felders[24].berechneAbleitungen(dX,iDX);
+  felders[24].berechneAbleitungen;
 
 
   felders[25].liKo(
@@ -459,7 +459,7 @@
     -0.0870718339841810522431884137957986245724252047388936572215438 * dT,
     -7.39351814158303067567016952195521063999185773249132944724553 * dT
   );
-  felders[25].berechneAbleitungen(dX,iDX);
+  felders[25].berechneAbleitungen;
 
 
   felders[26].liKo(
@@ -501,7 +501,7 @@
     4.79282506449930799649797749629840189457296934139359048988332 * dT,
     0.153725464873068577844576387402512082757034273069877432944621 * dT
   );
-  felders[26].berechneAbleitungen(dX,iDX);
+  felders[26].berechneAbleitungen;
 
 
   felders[27].liKo(
@@ -549,7 +549,7 @@
     -1.35548714715078654978732186705996404017554501614191325114947 * dT,
     -1.57196275801232751882901735171459249177687219114442583461866 * dT
   );
-  felders[27].berechneAbleitungen(dX,iDX);
+  felders[27].berechneAbleitungen;
 
 
   felders[28].liKo(
@@ -599,7 +599,7 @@
     1.6267482744706653746298936492962893398812502928418368027902 * dT,
     0.491719043846229147070666628704194097678081907210673044988866 * dT
   );
-  felders[28].berechneAbleitungen(dX,iDX);
+  felders[28].berechneAbleitungen;
 
 
   felders[29].liKo(
@@ -635,7 +635,7 @@
     -0.0439870229715046685058790092341545026046103890294261359042581 * dT,
     -0.13758560676332522486565963219678774664744722297508486597544 * dT
   );
-  felders[29].berechneAbleitungen(dX,iDX);
+  felders[29].berechneAbleitungen;
 
 
   felders[30].liKo(
@@ -673,7 +673,7 @@
     1.96337522866858908928262850028093813988180440518267404553576 * dT,
     0.856238975085428354755349769879501772112121597411563802855067 * dT
   );
-  felders[30].berechneAbleitungen(dX,iDX);
+  felders[30].berechneAbleitungen;
 
 
   felders[31].liKo(
@@ -711,7 +711,7 @@
     0.711915811585189227887648262043794387578291882406745570495765 * dT,
     0.550499525310802324138388507020508177411414311000037561712836 * dT
   );
-  felders[31].berechneAbleitungen(dX,iDX);
+  felders[31].berechneAbleitungen;
 
 
   felders[32].liKo(
@@ -751,7 +751,7 @@
     0.254297048076270161384068506997153122141835626976703920846242 * dT,
     -0.109993425580724703919462404865068340845119058295846426463652 * dT
   );
-  felders[32].berechneAbleitungen(dX,iDX);
+  felders[32].berechneAbleitungen;
 
 
   felders[33].liKo(
@@ -769,7 +769,7 @@
     0.492529543718026304422682049114021320200214681580657784719074 * dT,
     0.75 * dT
   );
-  felders[33].berechneAbleitungen(dX,iDX);
+  felders[33].berechneAbleitungen;
 
 
   felders[34].liKo(
@@ -781,7 +781,7 @@
     -0.222222222222222222222222222222222222222222222222222222222222 * dT,
     0.222222222222222222222222222222222222222222222222222222222222 * dT
   );
-  felders[34].berechneAbleitungen(dX,iDX);
+  felders[34].berechneAbleitungen;
 
 
   felders[35].liKo(
@@ -849,7 +849,7 @@
     -0.21875 * dT,
     -0.291666666666666666666666666666666666666666666666666666666667 * dT
   );
-  felders[35].berechneAbleitungen(dX,iDX);
+  felders[35].berechneAbleitungen;
 
 
   felders[1-aktuelleFelder].liKo(
diff --git a/rk3_8.inc b/rk3_8.inc
index 20b70f6..4c93d40 100644
--- a/rk3_8.inc
+++ b/rk3_8.inc
@@ -3,7 +3,7 @@
     felders[aktuelleFelder],
     1/3 * dT
   );
-  felders[2].berechneAbleitungen(dX,iDX);
+  felders[2].berechneAbleitungen;
 
 
   felders[3].liKo(
@@ -13,7 +13,7 @@
     -1/3 * dT,
     1 * dT
   );
-  felders[3].berechneAbleitungen(dX,iDX);
+  felders[3].berechneAbleitungen;
 
 
   felders[4].liKo(
@@ -25,7 +25,7 @@
     -1 * dT,
     1 * dT
   );
-  felders[4].berechneAbleitungen(dX,iDX);
+  felders[4].berechneAbleitungen;
 
 
   felders[1-aktuelleFelder].liKo(
diff --git a/rk4.inc b/rk4.inc
index 3d05cc4..4cf18ce 100644
--- a/rk4.inc
+++ b/rk4.inc
@@ -3,7 +3,7 @@
     felders[aktuelleFelder],
     0.5 * dT
   );
-  felders[2].berechneAbleitungen(dX,iDX);
+  felders[2].berechneAbleitungen;
 
 
   felders[3].liKo(
@@ -11,7 +11,7 @@
     felders[2],
     0.5 * dT
   );
-  felders[3].berechneAbleitungen(dX,iDX);
+  felders[3].berechneAbleitungen;
 
 
   felders[4].liKo(
@@ -19,7 +19,7 @@
     felders[3],
     1 * dT
   );
-  felders[4].berechneAbleitungen(dX,iDX);
+  felders[4].berechneAbleitungen;
 
 
   felders[1-aktuelleFelder].liKo(
diff --git a/rktopas b/rktopas
index 7198e7f..cfcbb4b 100755
--- a/rktopas
+++ b/rktopas
@@ -15,7 +15,7 @@ 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);" >> ${outputFile}
+    echo "  felders[${i}].berechneAbleitungen;" >> ${outputFile}
     echo >> ${outputFile}
 #    echo "  if pruefeMaxDT(${i},dTMax,dT,dTMin) then" >> ${outputFile}
 #    echo "    continue;" >> ${outputFile}