From 719059ace06e8813b1bea23fe9dce20d8f5fa969 Mon Sep 17 00:00:00 2001 From: Erich Eckner Date: Thu, 23 Jul 2015 14:34:46 +0200 Subject: initialer Commit --- .gitignore | 12 + AXtest | Bin 0 -> 15079072 bytes AYtest | Bin 0 -> 15079072 bytes Gammatest | Bin 0 -> 15079072 bytes Ntest | Bin 0 -> 15079072 bytes Physikunit.pas | 608 ++++++++++++++++++++++++++++++++++++++++++++++++++ Plasmapropagation | Bin 0 -> 1305003 bytes Plasmapropagation.lpi | 98 ++++++++ Plasmapropagation.lpr | 279 +++++++++++++++++++++++ Plasmapropagation.lps | 179 +++++++++++++++ dAYDTtest | Bin 0 -> 15079072 bytes dPhiDXtest | Bin 0 -> 15079072 bytes dPsiDXtest | Bin 0 -> 15079072 bytes error | 521 ++++++++++++++++++++++++++++++++++++++++++ input.epost | 87 ++++++++ 15 files changed, 1784 insertions(+) create mode 100644 .gitignore create mode 100644 AXtest create mode 100644 AYtest create mode 100644 Gammatest create mode 100644 Ntest create mode 100644 Physikunit.pas create mode 100755 Plasmapropagation create mode 100644 Plasmapropagation.lpi create mode 100644 Plasmapropagation.lpr create mode 100644 Plasmapropagation.lps create mode 100644 dAYDTtest create mode 100644 dPhiDXtest create mode 100644 dPsiDXtest create mode 100644 error create mode 100644 input.epost diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1c69bdf --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +*.bmp +*.png +*.bak +*.ppu +*.o +*.zip +*.tar.gz +Ergebnisse +lib +epost +*~ +Log* diff --git a/AXtest b/AXtest new file mode 100644 index 0000000..a67e5fc Binary files /dev/null and b/AXtest differ diff --git a/AYtest b/AYtest new file mode 100644 index 0000000..5c8f0b7 Binary files /dev/null and b/AYtest differ diff --git a/Gammatest b/Gammatest new file mode 100644 index 0000000..eb6cdf5 Binary files /dev/null and b/Gammatest differ diff --git a/Ntest b/Ntest new file mode 100644 index 0000000..534a0a7 Binary files /dev/null and b/Ntest differ diff --git a/Physikunit.pas b/Physikunit.pas new file mode 100644 index 0000000..0aee452 --- /dev/null +++ b/Physikunit.pas @@ -0,0 +1,608 @@ +unit Physikunit; + +{$mode objfpc}{$H+} + +{ $DEFINE Zeitschrittueberwachung} +{ $DEFINE Dichteueberwachung} + +interface + +uses + Classes, SysUtils, Math; + +type + TZeitverfahren = (zfEulerVorwaerts,zfRungeKuttaVier); + TVerteilungsfunktion = function(x: extended): extended; + TFeldInhalt = ( + fiA,fiAX,fiAY,fiAZ, + fidAXDT,fidAYDT,fidAZDT, + fiN,fidPhiDX,fidPsiDX, + fiP,fiPX,fiPY,fiPZ, + fiGamma,fiiGamma); + + TAusgabeDatei = record + Ableitung: Boolean; + Inhalt: TFeldInhalt; + Datei: File; + end; + + TProtokolldatei = record + datei: textfile; + einrueckung: longint; + end; + + { TProtokollant } + + TProtokollant = class(TObject) + private + sDat: ^TProtokolldatei; + Bes: String; + Kinder: array of TProtokollant; + Elter: TProtokollant; + public + constructor create(Dateiname: string); overload; + constructor create(Elter_: TProtokollant; Besitzer: string); overload; + destructor destroy; override; + procedure schreibe(s: string); + procedure schreibe(s: string; tee: boolean); + procedure destroyall; + end; + + { TFeld } + + pTFeld = ^TFeld; + TFeld = class(TObject) + public + Groessen: array[Boolean,TFeldInhalt] of extended; + // A, p[xyz]? und i?Gamma haben keine sinnvolle Ableitung hier! + dX,iDX,x,pDNMax: extended; + lN,rN: pTFeld; + constructor create(deltaX,pDNMa: extended); + procedure berechneGammaUndP; + procedure berechneNAbleitung; + procedure berechneAbleitungen(dT: extended); + end; + + { TGitter } + + TGitter = class(TObject) + private + groesse: longint; + Prot: TProtokollant; + procedure berechneAbleitungen(Felder: longint; dt: extended); overload; + procedure berechneAbleitungen(Felder: longint; dt: extended; out dTMax: extended); overload; + procedure setzeRaender(Felder: longint); + public + aktuelleFelder: longint; + Felders: array of array of TFeld; + dTMaximum,dX,iDX,xl,xr,t,pDNMax: extended; + pDNMaxDynamisch: boolean; + Zeitverfahren: TZeitverfahren; + Al,Ar: TVerteilungsfunktion; + constructor create(size: longint; deltaT,deltaX,pDNMa: extended; n0: TVerteilungsfunktion; ZV: TZeitverfahren; Protokollant: TProtokollant); + destructor destroy; override; + procedure iteriereSchritt(var dT: extended); + procedure macheAusgabe(AD: TAusgabedatei; sDX: extended); + function gibErhaltungsgroessen: string; + end; + +function Nullfunktion(x: extended): extended; +function timetostr(t: extended): string; + +const + OptionNamen: array[TFeldInhalt] of string = ( + 'A','AX','AY','AZ','dAXDT','dAYDT','dAZDT','N','dPhiDX','dPsiDX','P','PX','PY','PZ','Gamma','iGamma'); + AusgabeNamen: array[TFeldInhalt] of string = ( + 'fiA','fiAX','fiAY','fiAZ','fidAXDT','fidAYDT','fidAZDT','fiN','fidPhiDX','fidPsiDX','fiP','fiPX','fiPY','fiPZ','fiGamma','fiiGamma'); + AusgabeHilfe = '--d?A[XYZ]? --d?dA[XYZ]dt --d?N --d?dPhiDX --d?dPsiDX --P[XYZ]? --Gamma --iGamma'; + +implementation + +{ TProtokollant } + +constructor TProtokollant.create(Dateiname: string); +begin + inherited create; + getmem(sDat,sizeof(TProtokolldatei)); + sDat^.einrueckung:=10; + assignfile(sDat^.datei,Dateiname); + rewrite(sDat^.datei); + Bes:=''; + setlength(Kinder,0); + Elter:=nil; +end; + +constructor TProtokollant.create(Elter_: TProtokollant; Besitzer: string); +begin + inherited create; + sDat:=Elter_.sDat; + setlength(Elter_.Kinder,length(Elter_.Kinder)+1); + Elter_.Kinder[length(Elter_.Kinder)-1]:=self; + Elter:=Elter_; + setlength(Kinder,0); + Bes:=Elter.Bes+'.'+Besitzer; + if pos('.',Bes)=1 then delete(Bes,1,1); + if length(Bes)+4 > sDat^.einrueckung then + sDat^.einrueckung:=length(Bes)+4; +end; + +destructor TProtokollant.destroy; +var i: longint; +begin + while length(Kinder)>0 do + Kinder[length(Kinder)-1].free; + if assigned(Elter) then begin + flush(sDat^.datei); + i:=0; + while (iself) do + inc(i); + if i>=length(Elter.Kinder) then + schreibe('destroy fehlgeschlagen, ich kann mich nicht sehen.'); + inc(i); + while i * deltax + Groessen[true,fidPhiDX]:= + lN^.Groessen[true,fidPhiDX] + + (lN^.Groessen[true,fiN] + Groessen[true,fiN])*dX/2; + // d2A/dt2 = - n/gamma p + Laplace(A) ... + for b:=0 to 2 do + Groessen[true,TFeldinhalt(Byte(fidAXDT)+b)]:= + - (Groessen[false,fiN]*Groessen[false,fiiGamma]*Groessen[false,TFeldinhalt(Byte(fiPX)+b)]) + + (rN^.Groessen[false,TFeldinhalt(Byte(fiAX)+b)] + - 2*Groessen[false,TFeldinhalt(Byte(fiAX)+b)] + + lN^.Groessen[false,TFeldinhalt(Byte(fiAX)+b)])*sqr(iDX); + Groessen[true,fidAXDT]:=Groessen[true,fidAXDT] - Groessen[false,fidPhiDX]; // ... - Nabla(phi) + // dA/dt = dA/dt + for b:=0 to 2 do + Groessen[true,TFeldInhalt(Byte(fiAX)+b)]:= + Groessen[false,TFeldInhalt(Byte(fidAXDT)+b)] + + Groessen[true,TFeldInhalt(Byte(fidAXDT)+b)]*dT; +end; + +{ TGitter } + +procedure TGitter.berechneAbleitungen(Felder: longint; dT: extended; out dTMax: extended); +var i: longint; +begin + berechneAbleitungen(Felder,dT); + dTMax:=dTMaximum; + for i:=0 to groesse+3 do + if Felders[Felder,i].Groessen[true,fiN]<0 then begin + dTMax:=min(dTMax,Abs(Felders[Felder,i].Groessen[false,fiN]/Felders[Felder,i].Groessen[true,fiN])); + end; +end; + +procedure TGitter.berechneAbleitungen(Felder: longint; dT: extended); +var i: longint; +begin + for i:=0 to groesse+3 do begin +(* Felders[Felder,i].Groessen[false,fiN]:= + max(Felders[Felder,i].Groessen[false,fiN],0); // n >= 0 *) + Felders[Felder,i].berechneGammaUndP; + end; + Felders[Felder,1].Groessen[false,fiPX]:= // Teilchen werden reflektiert + Abs(Felders[Felder,1].Groessen[false,fiPX]); + Felders[Felder,groesse+2].Groessen[false,fiPX]:= + -Abs(Felders[Felder,groesse+2].Groessen[false,fiPX]); + setzeRaender(Felder); + for i:=1 to groesse+2 do + Felders[Felder,i].berechneNAbleitung; + for i:=1 to groesse+2 do + Felders[Felder,i].berechneAbleitungen(dT); +end; + +procedure TGitter.setzeRaender(Felder: longint); +var FI: TFeldInhalt; +begin + for FI:=fiAX to fiAZ do begin // Vakuumrandbedingungen für das A-Feld + Felders[Felder,0].Groessen[true,FI]:= + (Felders[Felder,1].Groessen[false,FI] - + Felders[Felder,0].Groessen[false,FI])*iDX; + Felders[Felder,groesse+3].Groessen[true,FI]:= + (Felders[Felder,groesse+2].Groessen[false,FI] - + Felders[Felder,groesse+3].Groessen[false,FI])*iDX; + end; // (ein bisschen wird noch reflektiert, vmtl. durch numerische Fehler) + Felders[Felder,0].Groessen[true,fiAy]:= + Felders[Felder,0].Groessen[true,fiAy] + + (Al(t+dTMaximum)-Al(t))/dTMaximum; + Felders[Felder,groesse+3].Groessen[true,fiAy]:= + Felders[Felder,groesse+3].Groessen[true,fiAy] + + (Ar(t+dTMaximum)-Ar(t))/dTMaximum; +end; + +constructor TGitter.create(size: longint; deltaT,deltaX,pDNMa: extended; n0: TVerteilungsfunktion; ZV: TZeitverfahren; Protokollant: TProtokollant); +var i,j: longint; +begin + inherited create; + Ar:=@Nullfunktion; + Al:=@Nullfunktion; + Zeitverfahren:=ZV; + groesse:=size; + Prot:=TProtokollant.create(Protokollant,'TGitter'); + dTMaximum:=deltaT; + dX:=deltaX; + iDX:=1/dX; + if pDNMa < 0 then begin + pDNMax:=0; + pDNMaxDynamisch:=true; + end + else pDNMax:=pDNMa; + case Zeitverfahren of + zfEulerVorwaerts: Setlength(Felders,2); + zfRungeKuttaVier: Setlength(Felders,5); + end{of Case}; + xl:=dX/2; + for i:=0 to length(Felders)-1 do begin + setlength(Felders[i],size+4); // auf jeder Seite je zwei Felder Rand extra + for j:=0 to length(felders[i])-1 do begin + felders[i,j]:=TFeld.create(dX,pDNMax); + felders[i,j].x:=xl+j*dX; + felders[i,j].Groessen[false,fiN]:=n0(felders[i,j].x); + felders[i,j].Groessen[false,fidPsiDX]:=0.0001*Cos(j/(length(felders[i])-1)*pi*15); + end; + felders[i,0].lN:=@felders[i,0]; + for j:=1 to length(felders[i])-1 do begin + felders[i,j].lN:=@felders[i,j-1]; + felders[i,j-1].rN:=@felders[i,j]; + end; + felders[i,length(felders[i])-1].rN:=@felders[i,length(felders[i])-1]; + end; + xr:=xl+dX*(length(Felders[0])-1); + aktuelleFelder:=0; + t:=0; +end; + +destructor TGitter.destroy; +var i,j: longint; +begin + for i:=0 to 1 do + for j:=0 to length(Felders[i])-1 do + Felders[i,j].free; + inherited destroy; +end; + +procedure TGitter.iteriereSchritt(var dT: extended); +var i: longint; + FI: TFeldInhalt; + dTMax: extended; + {$IFDEF Zeitschrittueberwachung} + Pro: TProtokollant; + {$ENDIF} +const zeitObergrenze = 1/4; + zeitSollwert = 1/8; + zeitUntergrenze = 1/16; +begin + berechneAbleitungen(aktuelleFelder,dT,dTMax); // y' = y'(t,y(t)) + {$IFDEF Zeitschrittueberwachung} + Pro:=TProtokollant.create(Prot,'iteriereSchritt'); + {$ENDIF} + while dT>=dTMax*zeitObergrenze do begin + dT:=dTMax*zeitSollwert; + berechneAbleitungen(aktuelleFelder,dT,dTMax); // y' = y'(t,y(t)) + {$IFDEF Zeitschrittueberwachung} + Pro.schreibe('+ neues dT: '+floattostr(dT)+' (t='+floattostr(t)+')'); + {$ENDIF} + end; + {$IFDEF Zeitschrittueberwachung} + if dT<1e-30 then begin + for i:=1 to groesse+2 do + if (Felders[aktuelleFelder,i].Groessen[true,fiN]<0) and + (Abs(Felders[aktuelleFelder,i].Groessen[false,fiN]/ + Felders[aktuelleFelder,i].Groessen[true,fiN])<1e-15) then + Prot.schreibe( + floattostr(t)+' '+ + inttostr(i)+' '+ + floattostr(Felders[aktuelleFelder,i-1].Groessen[false,fidPsiDX]* + Felders[aktuelleFelder,i-1].Groessen[false,fiiGamma])+' '+ + floattostr(Felders[aktuelleFelder,i-1].Groessen[false,fiN])+' '+ + floattostr(Felders[aktuelleFelder,i-1].Groessen[true,fiN])+' '+ + floattostr(Felders[aktuelleFelder,i].Groessen[false,fidPsiDX]* + Felders[aktuelleFelder,i].Groessen[false,fiiGamma])+' '+ + floattostr(Felders[aktuelleFelder,i].Groessen[false,fiN])+' '+ + floattostr(Felders[aktuelleFelder,i].Groessen[true,fiN])+' '+ + floattostr(Felders[aktuelleFelder,i+1].Groessen[false,fidPsiDX]* + Felders[aktuelleFelder,i+1].Groessen[false,fiiGamma])+' '+ + floattostr(Felders[aktuelleFelder,i+1].Groessen[false,fiN])+' '+ + floattostr(Felders[aktuelleFelder,i+1].Groessen[true,fiN]), + true); + Pro.destroyall; + halt(1); + end; + {$ENDIF} + + case Zeitverfahren of + zfEulerVorwaerts: + begin // y(t+dt) = y(t) + y' dt + for i:=0 to groesse+3 do + for FI:=low(TFeldinhalt) to fidPsiDX do + Felders[1-aktuelleFelder,i].Groessen[false,FI]:= + Felders[aktuelleFelder,i].Groessen[false,FI] + + Felders[aktuelleFelder,i].Groessen[true,FI]*dT; + end; + zfRungeKuttaVier: + begin + for i:=0 to groesse+3 do // ya = y(t) + y' dt/2 + for FI:=low(TFeldinhalt) to fidPsiDX do + Felders[2,i].Groessen[false,FI]:= + Felders[aktuelleFelder,i].Groessen[false,FI] + + Felders[aktuelleFelder,i].Groessen[true,FI]*dT/2; + berechneAbleitungen(2,dT/2,dTMax); // ya' = y'(t+dt/2,ya) + if dT/2>dTMax*zeitObergrenze then begin + {$IFDEF Zeitschrittueberwachung} + Pro.schreibe('1. '+floattostr(dT/2)+'>'+floattostr(dTMax*zeitObergrenze)+' (t='+floattostr(t)+')',true); + Pro.free; + {$ENDIF} + dT:=dTMax*zeitSollwert; + exit; + end; + for i:=0 to groesse+3 do // yb = y(t) + ya' dt/2 + for FI:=low(TFeldinhalt) to fidPsiDX do + Felders[3,i].Groessen[false,FI]:= + Felders[aktuelleFelder,i].Groessen[false,FI] + + Felders[2,i].Groessen[true,FI]*dT/2; + berechneAbleitungen(3,dT/2,dTMax); // yb' = y'(t+dt/2,yb) + if dT/2>dTMax*zeitObergrenze then begin + {$IFDEF Zeitschrittueberwachung} + Pro.schreibe('2. '+floattostr(dT/2)+'>'+floattostr(dTMax*zeitObergrenze)+' (t='+floattostr(t)+')',true); + Pro.free; + {$ENDIF} + dT:=dTMax*zeitSollwert; + exit; + end; + for i:=0 to groesse+3 do // yc = y(t) + yb' dt + for FI:=low(TFeldinhalt) to fidPsiDX do + Felders[4,i].Groessen[false,FI]:= + Felders[aktuelleFelder,i].Groessen[false,FI] + + Felders[3,i].Groessen[true,FI]*dT; + berechneAbleitungen(4,dT/2,dTMax); // yc' = y'(t+dt,yc) + if dT/2>dTMax*zeitObergrenze then begin + {$IFDEF Zeitschrittueberwachung} + Pro.schreibe('3. '+floattostr(dT/2)+'>'+floattostr(dTMax*zeitObergrenze)+' (t='+floattostr(t)+')',true); + Pro.free; + {$ENDIF} + dT:=dTMax*zeitSollwert; + exit; + end; + for i:=0 to groesse+3 do // y(t+dt) = y(t) + (y' + 2(ya' + yb') + yc') dt/6 + for FI:=low(TFeldinhalt) to fidPsiDX do + Felders[1-aktuelleFelder,i].Groessen[false,FI]:= + Felders[aktuelleFelder,i].Groessen[false,FI] + + (Felders[aktuelleFelder,i].Groessen[true,FI] + + 2*(Felders[2,i].Groessen[true,FI] + + Felders[3,i].Groessen[true,FI]) + + Felders[4,i].Groessen[true,FI])*dT/6; + end; + end{of case}; + + t:=t+dT; + aktuelleFelder:=1-aktuelleFelder; + if dT=sX do begin + BlockWrite(AD.Datei,Felders[aktuelleFelder,i].Groessen[AD.Ableitung,AD.Inhalt],sizeof(extended)); + sX:=sX+sDX; + end; +end; + +function TGitter.gibErhaltungsgroessen: string; +var i,j,k: integer; + n: extended; + Pro: TProtokollant; +begin + Pro:=TProtokollant.create(Prot,'gibErhaltungsgroessen'); + n:=0; + for i:=0 to groesse+3 do + n:=n+Felders[aktuelleFelder,i].Groessen[false,fiN]; + for i:=1 to groesse+2 do + if abs(Felders[aktuelleFelder,i].Groessen[false,fiPx]* + (Felders[aktuelleFelder,i+1].Groessen[false,fiN]-Felders[aktuelleFelder,i-1].Groessen[false,fiN])/ + Max(Felders[aktuelleFelder,i+1].Groessen[false,fiN]+Felders[aktuelleFelder,i-1].Groessen[false,fiN],1e-10)) + > pDNMax then begin + if pDNMaxDynamisch then begin + pDNMax:= + 2* + abs(Felders[aktuelleFelder,i].Groessen[false,fiPx]* + (Felders[aktuelleFelder,i+1].Groessen[false,fiN]-Felders[aktuelleFelder,i-1].Groessen[false,fiN])/ + Max(Felders[aktuelleFelder,i+1].Groessen[false,fiN]+Felders[aktuelleFelder,i-1].Groessen[false,fiN],1e-10)); + for j:=0 to length(felders)-1 do + for k:=0 to length(felders[j])-1 do + felders[j,k].pDNMax:=pDNMax; + Pro.schreibe('Neues maximales px * dn/dx / n: '+floattostr(pDNMax)+' (t='+floattostr(t)+')'); + end + else + if pDNMax>0 then begin + Pro.schreibe('Warnung: maximaler Impuls * dn/dx / n von '+floattostr(pDNMax)+' wurde überschritten (t='+floattostr(t)+ + 'T), die numerische Stabilität ist nicht mehr gewährleistet!',true); + Pro.schreibe(' Lösung: größeren Diffusionsterm wählen (-D)',true); + Pro.schreibe(' außerdem empfohlen: Ortsauflösung in gleichem Maße verbessern (-x)',true); + pDNMax:=-1; + end; + end; + result:='n='+floattostr(n); + {$IFDEF Dichteueberwachung} + if n>1000 then begin + errorCode:=2; + Pro.schreibe(' n > 1000, es scheinen sehr viele neue Teilchen entstanden zu sein. Die Simulation wird abgebrochen. (t='+floattostr(t)+')'); + end; + {$ENDIF} + Pro.free; +end; + +function Nullfunktion(x: extended): extended; +begin + result:=0*x; +end; + +function timetostr(t: extended): string; +var b: boolean; +begin + result:=''; + b:=t>=1; + if b then begin + result:=result+inttostr(floor(t))+' Tage '; + t:=t-floor(t); + end; + t:=t*24; + b:=b or (t>=1); + if b then begin + result:=result+inttostr(floor(t))+'h '; + t:=t-floor(t); + end; + t:=t*60; + b:=b or (t>=1); + if b then begin + result:=result+inttostr(floor(t))+'min '; + t:=t-floor(t); + end; + t:=t*60; + result:=result+inttostr(round(t))+'s'; +end; + +end. + diff --git a/Plasmapropagation b/Plasmapropagation new file mode 100755 index 0000000..c461c9f Binary files /dev/null and b/Plasmapropagation differ diff --git a/Plasmapropagation.lpi b/Plasmapropagation.lpi new file mode 100644 index 0000000..40504f6 --- /dev/null +++ b/Plasmapropagation.lpi @@ -0,0 +1,98 @@ + + + + + + + + + + + + <UseAppBundle Value="False"/> + <ResourceType Value="res"/> + </General> + <i18n> + <EnableI18N LFM="False"/> + </i18n> + <VersionInfo> + <StringTable ProductVersion=""/> + </VersionInfo> + <BuildModes Count="1"> + <Item1 Name="Default" Default="True"/> + </BuildModes> + <PublishOptions> + <Version Value="2"/> + <IncludeFileFilter Value="*.(pas|pp|inc|lfm|lpr|lrs|lpi|lpk|sh|xml)"/> + <ExcludeFileFilter Value="*.(bak|ppu|o|so);*~;backup"/> + </PublishOptions> + <RunParams> + <local> + <FormatVersion Value="1"/> + <LaunchingApplication PathPlusParams="/usr/bin/screen -T 'Lazarus Run Output' -e $(LazarusDir)/tools/runwait.sh $(TargetCmdLine)"/> + </local> + </RunParams> + <Units Count="2"> + <Unit0> + <Filename Value="Plasmapropagation.lpr"/> + <IsPartOfProject Value="True"/> + <UnitName Value="Plasmapropagation"/> + </Unit0> + <Unit1> + <Filename Value="Physikunit.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="Physikunit"/> + </Unit1> + </Units> + </ProjectOptions> + <CompilerOptions> + <Version Value="11"/> + <Target> + <Filename Value="Plasmapropagation"/> + </Target> + <SearchPaths> + <IncludeFiles Value="$(ProjOutDir)"/> + <UnitOutputDirectory Value="lib/$(TargetCPU)-$(TargetOS)"/> + </SearchPaths> + <CodeGeneration> + <Checks> + <IOChecks Value="True"/> + <RangeChecks Value="True"/> + <OverflowChecks Value="True"/> + <StackChecks Value="True"/> + </Checks> + <VerifyObjMethodCallValidity Value="True"/> + </CodeGeneration> + <Linking> + <Options> + <Win32> + <GraphicApplication Value="True"/> + </Win32> + </Options> + </Linking> + <Other> + <Verbosity> + <ShoLineNum Value="True"/> + <ShowAllProcsOnError Value="True"/> + <ShowDebugInfo Value="True"/> + </Verbosity> + <CompilerMessages> + <MsgFileName Value=""/> + </CompilerMessages> + <CompilerPath Value="$(CompPath)"/> + </Other> + </CompilerOptions> + <Debugging> + <Exceptions Count="3"> + <Item1> + <Name Value="EAbort"/> + </Item1> + <Item2> + <Name Value="ECodetoolError"/> + </Item2> + <Item3> + <Name Value="EFOpenError"/> + </Item3> + </Exceptions> + </Debugging> +</CONFIG> diff --git a/Plasmapropagation.lpr b/Plasmapropagation.lpr new file mode 100644 index 0000000..52e1926 --- /dev/null +++ b/Plasmapropagation.lpr @@ -0,0 +1,279 @@ +program Plasmapropagation; + +{$mode objfpc}{$H+} + +uses + {$IFDEF UNIX}{$IFDEF UseCThreads} + cthreads, + {$ENDIF}{$ENDIF} + Classes, SysUtils, CustApp, + { you can add units after this } + math, Physikunit, crt; + +var ErrorCode: longint; + +type + + { TPlasmapropagation } + + TPlasmapropagation = class(TCustomApplication) + protected + procedure DoRun; override; + public + constructor Create(TheOwner: TComponent); override; + destructor Destroy; override; + procedure WriteHelp; virtual; + end; + +function InputFeld(t: extended): extended; +const a0 = 1; + omega = 2*pi*100; + tfwhm = 10 * 2*pi/omega; + tMitte = 3*tfwhm; +begin +(* result:= + a0 * Exp(-2*Ln(2)*sqr((t-tMitte)/tfwhm)) * + (omega*Cos(t*omega) + 4*Ln(2)*(tMitte - t)*Sin(t*omega)/sqr(tfwhm)); *) + + result:= + a0 * Exp(-2*Ln(2)*sqr((t-tMitte)/tfwhm)) * + Sin(t*omega) +end; + +function Anfangsdichte(x: extended): extended; +const Profilbreite = 0.5; + Randbreite = 0.1; + offset = 0.0001; + Mitte = 0.75; +begin + x:=abs(x-Mitte); + result:=1+offset; + if x<=Profilbreite then exit; + result:=0+offset; + if x>=Profilbreite+Randbreite then exit; + result:=sqr(sin((Profilbreite+Randbreite-x)*0.5*pi/Randbreite))+offset; +end; + +{ TPlasmapropagation } + +procedure TPlasmapropagation.DoRun; +var + ErrorMsg,s,t,u: String; + Breite,i,j: longint; + Gitter: TGitter; + deltaT,deltaX,start, + sT,sDT,sDX,Endzeit, + zeitDatei,zeitPhysik, + pDNMax: extended; + AusgabeDateien: array of TAusgabeDatei; + FI: TFeldInhalt; + Zeitverfahren: TZeitverfahren; + Abl: Boolean; + Prot: TProtokollant; + c: char; +begin + // quick check parameters + start:=now; + s:=''; + for Abl:=False to True do + for FI:=low(TFeldInhalt) to high(TFeldInhalt) do + if not (Abl and (FI in [fiP,fiPX,fiPY,fiPZ,fiGamma,fiiGamma])) then + s:=s+' '+Copy('d',1,Byte(Abl))+OptionNamen[FI]+':'; + ErrorMsg:=CheckOptions('HB:Z:x:t:FEX:T:D:','Hilfe Breite: Zeit: Ortsschritt: Zeitschritt: Fortschrittsanzeige Euler Ortsspeicherschritt: Zeitspeicherschritt: Diffusionsterm:'+s); + if (ErrorMsg='') then begin + setlength(Ausgabedateien,0); + for Abl:=False to True do + for FI:=low(TFeldInhalt) to high(TFeldInhalt) do + if not (Abl and (FI in [fiGamma,fiP])) then + if HasOption(Copy('d',1,Byte(Abl))+OptionNamen[FI]) then begin + setlength(Ausgabedateien,length(Ausgabedateien)+1); + Ausgabedateien[length(Ausgabedateien)-1].Inhalt:=FI; + Ausgabedateien[length(Ausgabedateien)-1].Ableitung:=Abl; + AssignFile(Ausgabedateien[length(Ausgabedateien)-1].Datei,GetOptionValue(Copy('d',1,Byte(Abl))+OptionNamen[FI])); + end; + if length(Ausgabedateien)=0 then + ErrorMsg:='Du solltest irgendetwas abspeichern lassen! ('+AusgabeHilfe+')'; + end; + if ErrorMsg<>'' then begin + ShowException(Exception.Create(ErrorMsg)); + Terminate; + Exit; + end; + + // parse parameters + if HasOption('H','Hilfe') then begin + WriteHelp; + Terminate; + Exit; + end; + if HasOption('Z','Zeit') then Endzeit:=strtofloat(GetOptionValue('Z','Zeit')) + else Endzeit:=100; + if HasOption('x','Ortsschritt') then deltaX:=strtofloat(GetOptionValue('x','Ortsschritt')) + else deltaX:=1e-2; + if HasOption('B','Breite') then Breite:=round(strtofloat(GetOptionValue('B','Breite'))/deltaX) + else Breite:=1000; + if HasOption('t','Zeitschritt') then deltaT:=strtofloat(GetOptionValue('t','Zeitschritt')) + else deltaT:=deltaX/10; + if HasOption('X','Ortsspeicherschritt') then begin + s:=GetOptionValue('X','Ortsspeicherschritt'); + if pos('#',s)=0 then sDX:=strtofloat(s) + else sDX:=Breite*deltaX/strtofloat(rightstr(s,length(s)-1)); + end + else sDX:=deltaX; + if HasOption('T','Zeitspeicherschritt') then begin + s:=GetOptionValue('T','Zeitspeicherschritt'); + if pos('#',s)=0 then sDT:=strtofloat(s) + else sDT:=Endzeit/strtofloat(rightstr(s,length(s)-1)); + end + else sDT:=sDX; + if HasOption('D','Diffusionsterm') then pDNMax:=strtofloat(GetOptionValue('D','Diffusionsterm')) + else pDNMax:=-1; + if HasOption('E','Euler') then Zeitverfahren:=zfEulerVorwaerts + else Zeitverfahren:=zfRungeKuttaVier; + + { add your program here } + + Prot:=TProtokollant.create('error'); + + Prot.schreibe('Simulationsbox'); + Prot.schreibe(' '+inttostr(breite)+' Felder breit ('+floattostr(breite*deltaX)+' lambda)'); + Prot.schreibe(' '+floattostr(Endzeit)+' T lang (etwa '+inttostr(round(Endzeit/deltaT))+' Schritte)'); + Prot.schreibe(' '+floattostr(deltaT)+' Zeitschritt und '+floattostr(deltaX)+' Ortsschritt'); + for i:=0 to length(Ausgabedateien)-1 do begin + Prot.schreibe('Mache Ausgabe '+Copy('d',1,Byte(Ausgabedateien[i].Ableitung))+Ausgabenamen[Ausgabedateien[i].Inhalt]+'.'); + Rewrite(Ausgabedateien[i].Datei,1); + j:=0; + BlockWrite(Ausgabedateien[i].Datei,j,sizeof(longint)); + j:=floor(Endzeit/sDT+1); + BlockWrite(Ausgabedateien[i].Datei,j,sizeof(longint)); + end; + if pDNMax<0 then Prot.schreibe('Maximales px * dn/dx / n wird automatisch ermittelt.') + else Prot.schreibe('Maximales px * dn/dx / n: '+floattostr(pDNMax/deltaX)+'mc/dx'); + s:='Iterationsverfahren: '; + case Zeitverfahren of + zfEulerVorwaerts: s:=s+'Euler-Vorwärts'; + zfRungeKuttaVier: s:=s+'Runge-Kutta'; + else s:=s+'unbekannt!?'; + end{of case}; + Prot.schreibe(s); + + zeitDatei:=0; + zeitPhysik:=0; + sT:=-Min(deltaT,sDT)/2; + Gitter:=TGitter.create(Breite,deltaT,deltaX,pDNMax,@Anfangsdichte,Zeitverfahren,Prot); +// Gitter.Al:=@InputFeld; + while Gitter.t<Endzeit do begin + if HasOption('F','Fortschrittsanzeige') then begin + if errorCode<2 then + s:=Gitter.gibErhaltungsgroessen; + if (floor(100*Gitter.t/Endzeit) < floor(100*(Gitter.t+deltaT)/Endzeit)) or keypressed then begin + if keypressed then c:=readkey + else c:=#0; + case c of + #27,'q': begin + errorCode:=3; + break; + end; + ' ': begin + writeln(' ... Pause (beliebige Taste drücken um fortzufahren) ...'); + readkey; + writeln(' ... weiter geht''s ...'); + end; + else begin + Prot.schreibe(inttostr(round(100*Gitter.t/Endzeit))+'% (t='+floattostr(Gitter.t)+'T)',true); + Prot.schreibe(timetostr(now-start)+' ('+floattostr(zeitPhysik/max(1e-11,zeitPhysik+zeitDatei))+')',true); + Prot.schreibe('ETA: '+timetostr((now-start)*(Endzeit-Gitter.t)/max(Gitter.t,deltaT)),true); + Prot.schreibe('aktueller Zeitschritt: '+floattostr(deltaT)+'T',true); + Prot.schreibe(s); + end; + end{of case}; + end; + end; + + zeitPhysik:=zeitPhysik-now; + if errorCode<2 then + Gitter.iteriereSchritt(deltaT); + zeitPhysik:=zeitPhysik+now; + zeitDatei:=zeitDatei-now; + while Gitter.t>=sT do begin + sT:=sT+sDT; + for j:=0 to length(Ausgabedateien)-1 do + Gitter.macheAusgabe(Ausgabedateien[j],sDX); + end; + zeitDatei:=zeitDatei+now; + end; + + case errorCode of + 2: Prot.schreibe('Simulation wurde auf halbem Wege abgebrochen wegen Überlaufs.',true); + 3: Prot.schreibe('Simulation wurde auf halbem Wege abgebrochen wegen Benutzereingriffs.',true); + end{of case}; + + for i:=0 to length(Ausgabedateien)-1 do + CloseFile(Ausgabedateien[i].Datei); + + Prot.schreibe('fertig!',true); + s:=timetostr(now-start); + t:=timetostr(zeitDatei); + u:=timetostr(zeitPhysik); + while length(s)<max(length(t),length(u)) do s:=' '+s; + while length(t)<max(length(s),length(u)) do t:=' '+t; + while length(u)<max(length(s),length(t)) do u:=' '+u; + Prot.schreibe('Das hat '+s+' gedauert,',true); + Prot.schreibe(' davon '+t+' für Dateizugriffe',true); + Prot.schreibe('und nur '+u+' für die eigentliche Physik!',true); + + Gitter.Free; + Prot.Free; + // stop program loop + Terminate; + if errorCode=1 then errorCode:=0; +end; + +constructor TPlasmapropagation.Create(TheOwner: TComponent); +begin + inherited Create(TheOwner); + errorCode:=1; + StopOnException:=True; +end; + +destructor TPlasmapropagation.Destroy; +begin + inherited Destroy; +end; + +procedure TPlasmapropagation.WriteHelp; +begin + { add your help code here } + writeln('Verwendung:'); + writeln(ExeName,' -HBZxtFEP '+AusgabeHilfe); + writeln(' -H/--Hilfe Hilfe anzeigen'); + writeln(' -B/--Breite=x'); + writeln(' Breite der Simulationsbox in Plasmawellenlängen'); + writeln(' -Z/Zeit=x'); + writeln(' Länge der Simulationsbox in Plasmaoszillationsperioden'); + writeln(' -x/Ortsschritt=x'); + writeln(' Ortsdiskretisierung in Plasmaoszillationsvakuumwellenlängen'); + writeln(' -t/Zeitschritt=x'); + writeln(' Zeitdiskretisierung in Plasmaoszillationsperioden'); + writeln(' -X/Ortsspeicherschritt=x'); + writeln(' Ortsdiskretisierung der gespeicherten Werte in Plasmaoszillationsvakuumwellenlängen'); + writeln(' -T/Zeitspeicherschritt=x'); + writeln(' Zeitdiskretisierung der gespeicherten Werte in Plasmaoszillationsperioden'); + writeln(' -F/Fortschrittsanzeige'); + writeln(' -E/Euler'); + writeln(' verwende Eulerverfahren statt Runge-Kutta Stufe 4'); + writeln(' -D/Diffusionsterm=x'); + writeln(' p_x * dn/dx / n, bis zu dem numerische Stabilität gewähleistet ist.'); + writeln(' Ein hoher Wert bringt in Verbindung mit einer schlechten Ortsauflösung unphysikalische Ergebnisse!'); + writeln(' Ein negativer Wert sowie keine Angabe aktivieren die automatische Bestimmung. Das garantiert numerische Stabilität, führt jedoch möglicherweise unbemerkt zu unphysikalischen Ergebnissen.'); +end; + +var + Application: TPlasmapropagation; +begin + Application:=TPlasmapropagation.Create(nil); + Application.Run; + Application.Free; + Halt(errorCode); +end. + diff --git a/Plasmapropagation.lps b/Plasmapropagation.lps new file mode 100644 index 0000000..6dd806f --- /dev/null +++ b/Plasmapropagation.lps @@ -0,0 +1,179 @@ +<?xml version="1.0"?> +<CONFIG> + <ProjectSession> + <Version Value="9"/> + <BuildModes Active="Default"/> + <Units Count="4"> + <Unit0> + <Filename Value="Plasmapropagation.lpr"/> + <IsPartOfProject Value="True"/> + <UnitName Value="Plasmapropagation"/> + <EditorIndex Value="0"/> + <WindowIndex Value="0"/> + <TopLine Value="76"/> + <CursorPos X="29" Y="82"/> + <UsageCount Value="117"/> + <Loaded Value="True"/> + </Unit0> + <Unit1> + <Filename Value="Physikunit.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="Physikunit"/> + <IsVisibleTab Value="True"/> + <EditorIndex Value="1"/> + <WindowIndex Value="0"/> + <TopLine Value="67"/> + <CursorPos X="26" Y="86"/> + <UsageCount Value="58"/> + <Bookmarks Count="1"> + <Item0 X="1" Y="384" ID="0"/> + </Bookmarks> + <Loaded Value="True"/> + </Unit1> + <Unit2> + <Filename Value="../epost/epostunit.pas"/> + <UnitName Value="epostunit"/> + <WindowIndex Value="0"/> + <TopLine Value="575"/> + <CursorPos X="1" Y="1"/> + <FoldState Value=" T3jg0C2 pk4kM0{A1O"/> + <UsageCount Value="1"/> + </Unit2> + <Unit3> + <Filename Value="input.epost"/> + <EditorIndex Value="2"/> + <WindowIndex Value="0"/> + <TopLine Value="45"/> + <CursorPos X="1" Y="69"/> + <UsageCount Value="57"/> + <Loaded Value="True"/> + <DefaultSyntaxHighlighter Value="None"/> + </Unit3> + </Units> + <General> + <ActiveWindowIndexAtStart Value="0"/> + </General> + <JumpHistory Count="30" HistoryIndex="29"> + <Position1> + <Filename Value="Physikunit.pas"/> + <Caret Line="426" Column="66" TopLine="392"/> + </Position1> + <Position2> + <Filename Value="Physikunit.pas"/> + <Caret Line="440" Column="91" TopLine="406"/> + </Position2> + <Position3> + <Filename Value="Physikunit.pas"/> + <Caret Line="454" Column="91" TopLine="420"/> + </Position3> + <Position4> + <Filename Value="Physikunit.pas"/> + <Caret Line="476" Column="19" TopLine="451"/> + </Position4> + <Position5> + <Filename Value="Physikunit.pas"/> + <Caret Line="546" Column="100" TopLine="511"/> + </Position5> + <Position6> + <Filename Value="Physikunit.pas"/> + <Caret Line="550" Column="21" TopLine="515"/> + </Position6> + <Position7> + <Filename Value="Physikunit.pas"/> + <Caret Line="552" Column="21" TopLine="517"/> + </Position7> + <Position8> + <Filename Value="Physikunit.pas"/> + <Caret Line="553" Column="21" TopLine="518"/> + </Position8> + <Position9> + <Filename Value="Plasmapropagation.lpr"/> + <Caret Line="169" Column="24" TopLine="147"/> + </Position9> + <Position10> + <Filename Value="Plasmapropagation.lpr"/> + <Caret Line="165" Column="93" TopLine="144"/> + </Position10> + <Position11> + <Filename Value="Plasmapropagation.lpr"/> + <Caret Line="11" Column="24" TopLine="1"/> + </Position11> + <Position12> + <Filename Value="Plasmapropagation.lpr"/> + <Caret Line="167" Column="12" TopLine="146"/> + </Position12> + <Position13> + <Filename Value="Physikunit.pas"/> + <Caret Line="308" Column="34" TopLine="285"/> + </Position13> + <Position14> + <Filename Value="Physikunit.pas"/> + <Caret Line="305" Column="19" TopLine="284"/> + </Position14> + <Position15> + <Filename Value="Physikunit.pas"/> + <Caret Line="43" Column="1" TopLine="43"/> + </Position15> + <Position16> + <Filename Value="Physikunit.pas"/> + <Caret Line="305" Column="47" TopLine="284"/> + </Position16> + <Position17> + <Filename Value="Physikunit.pas"/> + <Caret Line="308" Column="26" TopLine="287"/> + </Position17> + <Position18> + <Filename Value="Physikunit.pas"/> + <Caret Line="305" Column="14" TopLine="278"/> + </Position18> + <Position19> + <Filename Value="Physikunit.pas"/> + <Caret Line="81" Column="10" TopLine="63"/> + </Position19> + <Position20> + <Filename Value="Physikunit.pas"/> + <Caret Line="305" Column="27" TopLine="284"/> + </Position20> + <Position21> + <Filename Value="Physikunit.pas"/> + <Caret Line="308" Column="27" TopLine="287"/> + </Position21> + <Position22> + <Filename Value="Plasmapropagation.lpr"/> + <Caret Line="40" Column="11" TopLine="16"/> + </Position22> + <Position23> + <Filename Value="Physikunit.pas"/> + <Caret Line="373" Column="1" TopLine="357"/> + </Position23> + <Position24> + <Filename Value="Physikunit.pas"/> + <Caret Line="472" Column="60" TopLine="449"/> + </Position24> + <Position25> + <Filename Value="Physikunit.pas"/> + <Caret Line="78" Column="9" TopLine="52"/> + </Position25> + <Position26> + <Filename Value="Physikunit.pas"/> + <Caret Line="266" Column="19" TopLine="231"/> + </Position26> + <Position27> + <Filename Value="Physikunit.pas"/> + <Caret Line="305" Column="41" TopLine="270"/> + </Position27> + <Position28> + <Filename Value="Physikunit.pas"/> + <Caret Line="308" Column="41" TopLine="273"/> + </Position28> + <Position29> + <Filename Value="Plasmapropagation.lpr"/> + <Caret Line="183" Column="26" TopLine="153"/> + </Position29> + <Position30> + <Filename Value="Physikunit.pas"/> + <Caret Line="393" Column="86" TopLine="378"/> + </Position30> + </JumpHistory> + </ProjectSession> +</CONFIG> diff --git a/dAYDTtest b/dAYDTtest new file mode 100644 index 0000000..5c8f0b7 Binary files /dev/null and b/dAYDTtest differ diff --git a/dPhiDXtest b/dPhiDXtest new file mode 100644 index 0000000..a37f979 Binary files /dev/null and b/dPhiDXtest differ diff --git a/dPsiDXtest b/dPsiDXtest new file mode 100644 index 0000000..7ba5d78 Binary files /dev/null and b/dPsiDXtest differ diff --git a/error b/error new file mode 100644 index 0000000..166a407 --- /dev/null +++ b/error @@ -0,0 +1,521 @@ + Simulationsbox + 1500 Felder breit (1.5 lambda) + 1 T lang (etwa 10000 Schritte) + 0.0001 Zeitschritt und 0.001 Ortsschritt + Mache Ausgabe fiAX. + Mache Ausgabe fiAY. + Mache Ausgabe fidAYDT. + Mache Ausgabe fiN. + Mache Ausgabe fidPhiDX. + Mache Ausgabe fidPsiDX. + Mache Ausgabe fiGamma. + Maximales px * dn/dx / n wird automatisch ermittelt. + Iterationsverfahren: Runge-Kutta +TGitter.gibErhaltungsgroessen Neues maximales px * dn/dx / n: 4.90867701035798E-13 (t=0.000025) +TGitter.gibErhaltungsgroessen Neues maximales px * dn/dx / n: 1.9210083367696E-6 (t=0.000025) +TGitter.gibErhaltungsgroessen Neues maximales px * dn/dx / n: 6.95677493143965E-6 (t=0.000025) +TGitter.gibErhaltungsgroessen Neues maximales px * dn/dx / n: 0.00001391665818 (t=0.000025) + 1% (t=0.0099875T) + 4s (0.93572594126268) + ETA: 6min 12s + aktueller Zeitschritt: 0.0000125T + n=1100.1504001997 + 2% (t=0.0199875T) + 7s (0.93845056986265) + ETA: 6min 4s + aktueller Zeitschritt: 0.0000125T + n=1100.15040039965 + 3% (t=0.0299875T) + 11s (0.9396443307214) + ETA: 5min 59s + aktueller Zeitschritt: 0.0000125T + n=1100.1504005996 + 4% (t=0.04T) + 15s (0.93995505725415) + ETA: 5min 55s + aktueller Zeitschritt: 0.0000125T + n=1100.1504007998 + 5% (t=0.05T) + 18s (0.94021909059327) + ETA: 5min 51s + aktueller Zeitschritt: 0.0000125T + n=1100.15040099976 + 6% (t=0.06T) + 22s (0.94028101686857) + ETA: 5min 47s + aktueller Zeitschritt: 0.0000125T + n=1100.15040119971 + 7% (t=0.07T) + 26s (0.94036230559588) + ETA: 5min 43s + aktueller Zeitschritt: 0.0000125T + n=1100.15040139966 + 8% (t=0.08T) + 30s (0.94045357808056) + ETA: 5min 39s + aktueller Zeitschritt: 0.0000125T + n=1100.15040159961 + 9% (t=0.09T) + 33s (0.94041907955508) + ETA: 5min 36s + aktueller Zeitschritt: 0.0000125T + n=1100.15040179956 + 10% (t=0.1T) + 37s (0.93998029343796) + ETA: 5min 32s + aktueller Zeitschritt: 0.0000125T + n=1100.15040199952 + 11% (t=0.11T) + 41s (0.9391274466381) + ETA: 5min 29s + aktueller Zeitschritt: 0.0000125T + n=1100.15040219947 + 12% (t=0.12T) + 44s (0.93928366492497) + ETA: 5min 25s + aktueller Zeitschritt: 0.0000125T + n=1100.15040239942 + 13% (t=0.13T) + 48s (0.93936119390127) + ETA: 5min 21s + aktueller Zeitschritt: 0.0000125T + n=1100.15040259938 + 14% (t=0.14T) + 52s (0.93947196769724) + ETA: 5min 17s + aktueller Zeitschritt: 0.0000125T + n=1100.15040279933 + 15% (t=0.1499875T) + 55s (0.93947754328833) + ETA: 5min 14s + aktueller Zeitschritt: 0.0000125T + n=1100.15040299903 + 16% (t=0.1599875T) + 59s (0.93955884945007) + ETA: 5min 10s + aktueller Zeitschritt: 0.0000125T + n=1100.15040319899 + 17% (t=0.1699875T) + 1min 3s (0.93965263560525) + ETA: 5min 6s + aktueller Zeitschritt: 0.0000125T + n=1100.15040339894 + 18% (t=0.1799875T) + 1min 6s (0.9397448828285) + ETA: 5min 2s + aktueller Zeitschritt: 0.0000125T + n=1100.15040359889 + 19% (t=0.1899875T) + 1min 10s (0.93915432836246) + ETA: 4min 59s + aktueller Zeitschritt: 0.0000125T + n=1100.15040379885 + 20% (t=0.1999875T) + 1min 14s (0.93900073347529) + ETA: 4min 55s + aktueller Zeitschritt: 0.0000125T + n=1100.15040399879 + 21% (t=0.2099875T) + 1min 17s (0.93909659887595) + ETA: 4min 51s + aktueller Zeitschritt: 0.0000125T + n=1100.15040419873 + 22% (t=0.2199875T) + 1min 21s (0.93917337012531) + ETA: 4min 48s + aktueller Zeitschritt: 0.0000125T + n=1100.15040439866 + 23% (t=0.2299875T) + 1min 25s (0.93758208132779) + ETA: 4min 44s + aktueller Zeitschritt: 0.0000125T + n=1100.15040459857 + 24% (t=0.2399875T) + 1min 29s (0.93768875699546) + ETA: 4min 41s + aktueller Zeitschritt: 0.0000125T + n=1100.15040479846 + 25% (t=0.2499875T) + 1min 32s (0.9378121327816) + ETA: 4min 37s + aktueller Zeitschritt: 0.0000125T + n=1100.15040499831 + 26% (t=0.2599875T) + 1min 36s (0.93788794049542) + ETA: 4min 33s + aktueller Zeitschritt: 0.0000125T + n=1100.15040519814 + 27% (t=0.2699875T) + 1min 39s (0.93470907399499) + ETA: 4min 29s + aktueller Zeitschritt: 0.0000125T + n=1100.15040539794 + 28% (t=0.2799875T) + 1min 43s (0.93392779228268) + ETA: 4min 24s + aktueller Zeitschritt: 0.0000125T + n=1100.15040559772 + 29% (t=0.2899875T) + 1min 46s (0.9341559070417) + ETA: 4min 21s + aktueller Zeitschritt: 0.0000125T + n=1100.15040579748 + 30% (t=0.2999875T) + 1min 50s (0.93429738634912) + ETA: 4min 17s + aktueller Zeitschritt: 0.0000125T + n=1100.15040599723 + 31% (t=0.3099875T) + 1min 54s (0.93446650346284) + ETA: 4min 13s + aktueller Zeitschritt: 0.0000125T + n=1100.15040619699 + 32% (t=0.3199875T) + 1min 57s (0.93465115233278) + ETA: 4min 10s + aktueller Zeitschritt: 0.0000125T + n=1100.15040639676 + 33% (t=0.3299875T) + 2min 1s (0.93480925657284) + ETA: 4min 6s + aktueller Zeitschritt: 0.0000125T + n=1100.15040659655 + 34% (t=0.3399875T) + 2min 5s (0.93496938818957) + ETA: 4min 2s + aktueller Zeitschritt: 0.0000125T + n=1100.15040679637 + 35% (t=0.3499875T) + 2min 8s (0.93499199359356) + ETA: 3min 59s + aktueller Zeitschritt: 0.0000125T + n=1100.15040699623 + 36% (t=0.3599875T) + 2min 12s (0.93513974146828) + ETA: 3min 55s + aktueller Zeitschritt: 0.0000125T + n=1100.15040719612 + 37% (t=0.3699875T) + 2min 16s (0.93462522712332) + ETA: 3min 51s + aktueller Zeitschritt: 0.0000125T + n=1100.15040739603 + 38% (t=0.3799875T) + 2min 20s (0.93477500648) + ETA: 3min 48s + aktueller Zeitschritt: 0.0000125T + n=1100.15040759598 + 39% (t=0.3899875T) + 2min 23s (0.93418072020113) + ETA: 3min 43s + aktueller Zeitschritt: 0.0000125T + n=1100.15040779595 + 40% (t=0.3999875T) + 2min 26s (0.93434368089496) + ETA: 3min 39s + aktueller Zeitschritt: 0.0000125T + n=1100.15040799592 + 41% (t=0.4099875T) + 2min 29s (0.93438719449992) + ETA: 3min 35s + aktueller Zeitschritt: 0.0000125T + n=1100.1504081959 + 42% (t=0.4199875T) + 2min 33s (0.93448808312355) + ETA: 3min 31s + aktueller Zeitschritt: 0.0000125T + n=1100.15040839587 + 43% (t=0.4299875T) + 2min 37s (0.93459425789043) + ETA: 3min 28s + aktueller Zeitschritt: 0.0000125T + n=1100.15040859582 + 44% (t=0.4399875T) + 2min 40s (0.93472965099255) + ETA: 3min 24s + aktueller Zeitschritt: 0.0000125T + n=1100.15040879575 + 45% (t=0.4499875T) + 2min 44s (0.93483912389575) + ETA: 3min 20s + aktueller Zeitschritt: 0.0000125T + n=1100.15040899565 + 46% (t=0.4599875T) + 2min 48s (0.93495962549421) + ETA: 3min 17s + aktueller Zeitschritt: 0.0000125T + n=1100.15040919551 + 47% (t=0.4699875T) + 2min 51s (0.93495055947613) + ETA: 3min 13s + aktueller Zeitschritt: 0.0000125T + n=1100.15040939535 + 48% (t=0.4799875T) + 2min 55s (0.93509540698992) + ETA: 3min 10s + aktueller Zeitschritt: 0.0000125T + n=1100.15040959517 + 49% (t=0.4899875T) + 2min 59s (0.93522625662536) + ETA: 3min 6s + aktueller Zeitschritt: 0.0000125T + n=1100.15040979497 + 50% (t=0.4999875T) + 3min 2s (0.93534449434932) + ETA: 3min 2s + aktueller Zeitschritt: 0.0000125T + n=1100.15040999477 + 51% (t=0.5099875T) + 3min 6s (0.93508263291742) + ETA: 2min 59s + aktueller Zeitschritt: 0.0000125T + n=1100.15041019456 + 52% (t=0.5199875T) + 3min 10s (0.93509288526884) + ETA: 2min 55s + aktueller Zeitschritt: 0.0000125T + n=1100.15041039437 + 53% (t=0.5299875T) + 3min 13s (0.93488834098026) + ETA: 2min 52s + aktueller Zeitschritt: 0.0000125T + n=1100.1504105942 + 54% (t=0.5399875T) + 3min 17s (0.93499188128487) + ETA: 2min 48s + aktueller Zeitschritt: 0.0000125T + n=1100.15041079406 + 55% (t=0.5499875T) + 3min 21s (0.93480126139187) + ETA: 2min 44s + aktueller Zeitschritt: 0.0000125T + n=1100.15041099395 + 56% (t=0.5599875T) + 3min 25s (0.93490491597985) + ETA: 2min 41s + aktueller Zeitschritt: 0.0000125T + n=1100.15041119387 + 57% (t=0.5699875T) + 3min 28s (0.93500136747388) + ETA: 2min 37s + aktueller Zeitschritt: 0.0000125T + n=1100.15041139383 + 58% (t=0.5799875T) + 3min 32s (0.93465203973783) + ETA: 2min 34s + aktueller Zeitschritt: 0.0000125T + n=1100.15041159381 + 59% (t=0.5899875T) + 3min 36s (0.93472936944875) + ETA: 2min 30s + aktueller Zeitschritt: 0.0000125T + n=1100.15041179381 + 60% (t=0.6T) + 3min 39s (0.9348087023095) + ETA: 2min 26s + aktueller Zeitschritt: 0.0000125T + n=1100.15041199407 + 61% (t=0.61T) + 3min 43s (0.93491070711469) + ETA: 2min 23s + aktueller Zeitschritt: 0.0000125T + n=1100.15041219408 + 62% (t=0.62T) + 3min 46s (0.93462517792379) + ETA: 2min 19s + aktueller Zeitschritt: 0.0000125T + n=1100.15041239408 + 63% (t=0.63T) + 3min 50s (0.93465224645404) + ETA: 2min 15s + aktueller Zeitschritt: 0.0000125T + n=1100.15041259406 + 64% (t=0.64T) + 3min 53s (0.93472351649562) + ETA: 2min 11s + aktueller Zeitschritt: 0.0000125T + n=1100.15041279402 + 65% (t=0.65T) + 3min 56s (0.9346948061847) + ETA: 2min 7s + aktueller Zeitschritt: 0.0000125T + n=1100.15041299395 + 66% (t=0.66T) + 3min 59s (0.93474317500594) + ETA: 2min 3s + aktueller Zeitschritt: 0.0000125T + n=1100.15041319385 + 67% (t=0.67T) + 4min 2s (0.93478852332337) + ETA: 1min 59s + aktueller Zeitschritt: 0.0000125T + n=1100.15041339372 + 68% (t=0.68T) + 4min 5s (0.93477508176243) + ETA: 1min 55s + aktueller Zeitschritt: 0.0000125T + n=1100.15041359357 + 69% (t=0.69T) + 4min 9s (0.93486059208118) + ETA: 1min 52s + aktueller Zeitschritt: 0.0000125T + n=1100.1504137934 + 70% (t=0.7T) + 4min 13s (0.93484459753493) + ETA: 1min 48s + aktueller Zeitschritt: 0.0000125T + n=1100.15041399322 + 71% (t=0.71T) + 4min 16s (0.93492848469232) + ETA: 1min 45s + aktueller Zeitschritt: 0.0000125T + n=1100.15041419304 + 72% (t=0.72T) + 4min 20s (0.93471191856157) + ETA: 1min 41s + aktueller Zeitschritt: 0.0000125T + n=1100.15041439287 + 73% (t=0.73T) + 4min 24s (0.9348012495454) + ETA: 1min 38s + aktueller Zeitschritt: 0.0000125T + n=1100.15041459273 + 74% (t=0.74T) + 4min 27s (0.9348810582785) + ETA: 1min 34s + aktueller Zeitschritt: 0.0000125T + n=1100.15041479261 + 75% (t=0.75T) + 4min 31s (0.93466154687072) + ETA: 1min 30s + aktueller Zeitschritt: 0.0000125T + n=1100.15041499252 + 76% (t=0.76T) + 4min 35s (0.93474800649981) + ETA: 1min 27s + aktueller Zeitschritt: 0.0000125T + n=1100.15041519246 + 77% (t=0.77T) + 4min 39s (0.93464517725866) + ETA: 1min 23s + aktueller Zeitschritt: 0.0000125T + n=1100.15041539244 + 78% (t=0.78T) + 4min 42s (0.93471589587541) + ETA: 1min 20s + aktueller Zeitschritt: 0.0000125T + n=1100.15041559244 + 79% (t=0.79T) + 4min 46s (0.93479319538545) + ETA: 1min 16s + aktueller Zeitschritt: 0.0000125T + n=1100.15041579245 + 80% (t=0.8T) + 4min 50s (0.93487046513783) + ETA: 1min 12s + aktueller Zeitschritt: 0.0000125T + n=1100.15041599248 + 81% (t=0.81T) + 4min 53s (0.93494272921598) + ETA: 1min 9s + aktueller Zeitschritt: 0.0000125T + n=1100.15041619251 + 82% (t=0.82T) + 4min 57s (0.93502453059895) + ETA: 1min 5s + aktueller Zeitschritt: 0.0000125T + n=1100.15041639253 + 83% (t=0.83T) + 5min 1s (0.93509745330369) + ETA: 1min 2s + aktueller Zeitschritt: 0.0000125T + n=1100.15041659253 + 84% (t=0.84T) + 5min 4s (0.93517156164012) + ETA: 58s + aktueller Zeitschritt: 0.0000125T + n=1100.1504167925 + 85% (t=0.85T) + 5min 8s (0.9352390216625) + ETA: 54s + aktueller Zeitschritt: 0.0000125T + n=1100.15041699245 + 86% (t=0.86T) + 5min 12s (0.9352517564134) + ETA: 51s + aktueller Zeitschritt: 0.0000125T + n=1100.15041719236 + 87% (t=0.87T) + 5min 16s (0.9351394704682) + ETA: 47s + aktueller Zeitschritt: 0.0000125T + n=1100.15041739224 + 88% (t=0.88T) + 5min 19s (0.93520735055799) + ETA: 44s + aktueller Zeitschritt: 0.0000125T + n=1100.1504175921 + 89% (t=0.89T) + 5min 23s (0.93512915953451) + ETA: 40s + aktueller Zeitschritt: 0.0000125T + n=1100.15041779194 + 90% (t=0.9T) + 5min 27s (0.93519826581303) + ETA: 36s + aktueller Zeitschritt: 0.0000125T + n=1100.15041799177 + 91% (t=0.91T) + 5min 31s (0.93483492969017) + ETA: 33s + aktueller Zeitschritt: 0.0000125T + n=1100.1504181916 + 92% (t=0.92T) + 5min 34s (0.93490573860459) + ETA: 29s + aktueller Zeitschritt: 0.0000125T + n=1100.15041839144 + 93% (t=0.93T) + 5min 38s (0.93496816016958) + ETA: 25s + aktueller Zeitschritt: 0.0000125T + n=1100.1504185913 + 94% (t=0.94T) + 5min 42s (0.9348235620777) + ETA: 22s + aktueller Zeitschritt: 0.0000125T + n=1100.15041879118 + 95% (t=0.95T) + 5min 45s (0.93488922414053) + ETA: 18s + aktueller Zeitschritt: 0.0000125T + n=1100.1504189911 + 96% (t=0.96T) + 5min 49s (0.93492794655297) + ETA: 15s + aktueller Zeitschritt: 0.0000125T + n=1100.15041919104 + 97% (t=0.97T) + 5min 53s (0.93495188615352) + ETA: 11s + aktueller Zeitschritt: 0.0000125T + n=1100.15041939102 + 98% (t=0.98T) + 5min 56s (0.93481669414105) + ETA: 7s + aktueller Zeitschritt: 0.0000125T + n=1100.15041959102 + 99% (t=0.99T) + 6min 0s (0.93488083192356) + ETA: 4s + aktueller Zeitschritt: 0.0000125T + n=1100.15041979103 + 100% (t=1T) + 6min 4s (0.93494126481698) + ETA: 0s + aktueller Zeitschritt: 0.0000125T + n=1100.15041999106 + fertig! + Das hat 6min 4s gedauert, + davon 23s für Dateizugriffe + und nur 5min 29s für die eigentliche Physik! diff --git a/input.epost b/input.epost new file mode 100644 index 0000000..f1906d1 --- /dev/null +++ b/input.epost @@ -0,0 +1,87 @@ +# Beispielinputfile um epost zu steuern +# +# Führende und folgende Leerzeichen werden ignoriert. +# Leere oder mit # beginnende Zeilen werden ignoriert. + +Palette + Name: erweiterter Regenbogen + ffffff + ff0000 + ffff00 + 00ff00 + 00ffff + 0000ff + ff00ff + 000000 + Ende + +Threadanzahl: 10 + +Dateien einlesen + Genauigkeit: extended + Ntest + Ende + +lineares Bild + Palette: erweiterter Regenbogen + maximale und minimale Dichten bestimmen + Datei: N.bmp + Ende + + Dateien einlesen + Genauigkeit: extended + Gammatest + Ende + +lineares Bild + Palette: erweiterter Regenbogen + maximale und minimale Dichten bestimmen + Datei: Gamma.bmp + Ende + +Dateien einlesen + Genauigkeit: extended + dPhiDXtest + Ende + +lineares Bild + Palette: erweiterter Regenbogen + maximale und minimale Dichten bestimmen + Datei: dPhiDX.bmp + Ende + +Dateien einlesen + Genauigkeit: extended + dPsiDXtest + Ende + +lineares Bild + Palette: erweiterter Regenbogen + maximale und minimale Dichten bestimmen + Datei: dPsiDX.bmp + Ende + +Dateien einlesen + Genauigkeit: extended + AYtest + Ende + +Dateiende + +lineares Bild + Palette: erweiterter Regenbogen + maximale und minimale Dichten bestimmen + Datei: AY.bmp + Ende + +Dateien einlesen + Genauigkeit: extended + dAYDTtest + Ende + +lineares Bild + Palette: erweiterter Regenbogen + maximale und minimale Dichten bestimmen + Datei: dAYDT.bmp + Ende + -- cgit v1.2.3-70-g09d2