Fehler bei Berechnungen in JavaScript

Leo Baumann

unread,

Nov 26, 2021, 3:19:55 PM11/26/21

to

Hallo,
das Programm berechnet das Integral (Simpson) der rel. Bestahlungsstärke
einer geneigten Fläche durch die Sonne.

Zwei funtionierende Programme für waagerechte und senkrechte Bestrahlung
sind beigefügt.

Simpsonneig() ist die Integration nach Simpson, function cosen() ist die
Funktion für die rel. Bestrahlungsstärke.

Die zugehörige Eingabe und der Aufruf für Simpsonneig() ist ganz unten.

Für die eingetragenen Parameter kommt ein sinnvolles Ergebnis heraus,
variiert man die Parameter, gibt es Probleme.

Hier die Programme:

<!DOCTYPE HTML>
<html lang="de">
<head>
<script language="JavaScript">

function cose(t,bb,lb,pi,nwk)
{
ls=2*pi/24*t-pi;
bs=Math.sin(2*pi/8760*t-pi/2)*nwk;
e=Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb);
if (e<=0) e=0; // wenn die Sonne unter dem Horizont steht
wird das nicht mit gerechnet
return e
}

function sine(t,bb,lb,pi,nwk)
{
ls=2*pi/24*t-pi;
bs=Math.sin(2*pi/8760*t-pi/2)*nwk;

eh=Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb);
// *****cos(e)
e=Math.sqrt(1-Math.pow(eh,2)); // *****sin(e)
if (eh<0) e=0; // *****wenn die Sonne unter dem Horizont
steht wird das nicht mit gerechnet
return e
}

function cosen(t,bb,lb,pi,nwk,neig,rif)
{
ls=2*pi/24*t-pi; // Länge Sonne
bs=Math.sin(2*pi/8760*t-pi/2)*nwk; // Breite Sonne

cose1=Math.cos(bb)*Math.cos(ls-lb);
h=Math.acos(cose1);
ri=Math.abs(Math.acos(-Math.sin(bb)*cose1/Math.cos(bb)/Math.sin(h)));
// Richtung zur Sonne
vz=Math.sin(ls-lb)/Math.sin(h);
if (vz<0) ri=-ri;

ele=pi/2-Math.acos(Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb));
// Sonnenhöhe
if (ele<=0) {e=0; ele=0;} else
{e=(-Math.cos(ele)*Math.sin(neig)*Math.cos(ri-rif)+Math.sin(ele)*Math.cos(neig))/Math.sin(ele);}
if (e<=0) e=0;
console.log(ri*180/pi);
return e
}

// Simpson() integriert über cose() von t=0 bis t=8760 Stunden,
also ein Jahr (waagerechte Fläche auf der Erde)
function Simpson()
{
var pi=Math.PI;
var lb=0;
var bb=Math.abs(parseFloat(document.eingabe3.gb.value)*pi/180);
var g=0;
var s=0;
var ug=0;
var og=8760;
var min=1023;
var nwk=23.5*pi/180;

var n=1;
var gs=2;
var te=Math.pow(10,-gs);
var sw=(og-ug)/2;
var c=cose(ug,bb,lb,pi,nwk)+cose(og,bb,lb,pi,nwk);
var u=cose(ug+sw,bb,lb,pi,nwk);
var sa=sw/3*(c+4*u);
do
{
sw=sw/2;
n=2*n+1;
g=g+u;
u=0;

for (t=1;t<=n;t=t+2)
{
u=u+cose(u+t*sw,bb,lb,pi,nwk);
}

s=sw/3*(c+2*g+4*u);
if (s==0) s=te;
fe=Math.abs((s-sa)/(15*s));
sa=s;
}while ((fe>te) || (n<min));

document.eingabe3.schritte.value=String(n+1);
document.eingabe3.fehler.value=String(Math.round(fe*1e8)/1e8);
document.eingabe3.erg.value=String(Math.round(sa/8760*1e4)/100);
document.eingabe3.erg1.value=String(Math.round(sa*100)/100);
}

// Simpsonsenk() integriert über sine() von t=0 bis t=8760
Stunden, also ein Jahr (senkrechte Fläche auf der Erde)
function Simpsonsenk()
{
var pi=Math.PI;
var lb=0;
var bb=Math.abs(parseFloat(document.eingabe10.gb.value)*pi/180);
var g=0;
var s=0;
var ug=0;
var og=8760;
var min=1023;
var nwk=23.5*pi/180;

var n=1;
var gs=2;
var te=Math.pow(10,-gs);
var sw=(og-ug)/2;
var c=sine(ug,bb,lb,pi,nwk)+cose(og,bb,lb,pi,nwk);
var u=sine(ug+sw,bb,lb,pi,nwk);
var sa=sw/3*(c+4*u);

if (bb<=nwk) nwk=bb; // *****für den Fall, dass der
Beobachter innerhalb des Wendekreises ist
do
{
sw=sw/2;
n=2*n+1;
g=g+u;
u=0;

for (t=1;t<=n;t=t+2)
{
u=u+sine(u+t*sw,bb,lb,pi,nwk);
}

s=sw/3*(c+2*g+4*u);
if (s==0) s=te;
fe=Math.abs((s-sa)/(15*s));
sa=s;
}while ((fe>te) || (n<min));

document.eingabe10.schritte.value=String(n+1);
document.eingabe10.fehler.value=String(Math.round(fe*1e8)/1e8);
document.eingabe10.erg.value=String(Math.round(sa/8760*1e4)/100);
document.eingabe10.erg1.value=String(Math.round(sa*100)/100);
}

// Simpsonneig() integriert über cose() von t=0 bis t=8760
Stunden, also ein Jahr (geneigte Fläche auf der Erde)
function Simpsonneig()
{
var pi=Math.PI;
var lb=0;
var bb=Math.abs(parseFloat(document.eingabe11.gb.value)*pi/180);
var neig=parseFloat(document.eingabe11.neig.value)*pi/180;
var rif=parseFloat(document.eingabe11.rif.value)*pi/180;
var g=0;
var s=0;
var ug=0;
var og=8760;
var min=1023;
var nwk=23.5*pi/180;

var n=1;
var gs=2;
var te=Math.pow(10,-gs);
var sw=(og-ug)/2;
var c=cosen(ug,bb,lb,pi,nwk,neig,rif)+cosen(og,bb,lb,pi,nwk,neig,rif);
var u=cosen(ug+sw,bb,lb,pi,nwk,neig,rif);
var sa=sw/3*(c+4*u);

if (bb<=nwk) nwk=bb; // *****für den Fall, dass der
Beobachter innerhalb des Wendekreises ist
do
{
sw=sw/2;
n=2*n+1;
g=g+u;
u=0;

for (t=1;t<=n;t=t+2)
{
u=u+cosen(u+t*sw,bb,lb,pi,nwk,neig,rif);
}

s=sw/3*(c+2*g+4*u);
if (s==0) s=te;
fe=Math.abs((s-sa)/(15*s));
sa=s;
}while ((fe>te) || (n<min));

document.eingabe11.schritte.value=String(n+1);
document.eingabe11.fehler.value=String(Math.round(fe*1e8)/1e8);
document.eingabe11.erg.value=String(Math.round(sa/8760*1e4)/100);
document.eingabe11.erg1.value=String(Math.round(sa*100)/100);
}

</script>

</head>

<a name="Start"></a>
<body link="#0000cb" vlink="#00008b" alink="#ff8c00"
background="grid.gif">
<p><center><font face="Eras Bold ITC"><h1 style= "color:
#0000cb"><u>Berechnungsprogramme</u></h1></font></center></p>

<p><table border=1 bordercolor="0000b0" cellspacing="7" bgcolor="#fffff0">
<tr><th>Art der Berechnung:</th></tr>
<tr><td><img src="pfeilre.gif"><a href="#Sonne">effektive
Sonnenbestrahlung, waagerechte Fläche</a></td></tr>
<tr><td><img src="pfeilre.gif"><a href="#Sonnesenk">effektive
Sonnenbestrahlung, senkrechte Fläche</a></td></tr>
<tr><td><img src="pfeilre.gif"><a href="#Sonneneig">effektive
Sonnenbestrahlung, geneigte Fläche</a></td></tr>
</table></p>

<p><hr noshade color="#000000" size=1></p>

<a name="Sonne"></a>
<p><h4 style="color:#000000"><u><b>Berechnung der effektiven
Bestrahlungsstärke der waagerechten Fläche durch die
Sonne</b></u></h4></p>

<p>Wieviel Prozent der Sonnenstrahlung fällt auf eine waagerechte
Fläche an der angegebenen geografischen Position, weil die Sonne ja
nicht
unbedingt senkrecht über dieser steht und außerdem dem
Tageszeiten- und Jahreszeitenverlauf unterliegt? Die eingetragenen
Koordinaten gehören zu Mainflingen-Offenbach. Die Berechnung ist
schwierig, weil über folgende Großkreisformel
integriert werden mu&szlig, und zwar von 0 bis 365 x 24 Stunden.</p>
<p><center>cos(e) = sin(bf)*sin(bs)+cos(bf)*cos(bs)*cos(ls-lf)</center>
<center>mit ls=2*pi/24*t-pi und bs=nWK*sin(2*pi/365/24*t-pi/2) den
Koordinaten des Subsonnenpunktes</center></p>
<p>Auch in Kugelkoordinaten ist diese Berechnung schwierig. Darum
empfiehlt sich hier die SIMPSON-Formel. Für beliebige Koordinaten auf
der Erdoberfläche ist diese Iteration hier geeignet.</p>

<p><table border=1 bordercolor="#0000b0"cellpadding="10"
cellspacing="7" bgcolor="#fffff0">
<tr><th colspan="2">effektive Sonnenbestrahlung,
Bestrahlungsstärke, waagerechte Fläche</th></tr><tr><td>
<form name="eingabe3">
<input name="gb" type="text" size=12 value="50.1"> geografische Breite
der Fläche in Dezimalgrad (südlich negativ)<br>
<input name="schritte" type="text" readonly size=12> <span
style="color:#ff0000;">Anzahl der Intervalle der Integration</span><br>
<input name="fehler" type="text" readonly size=12> <span
style="color:#0000ff;">Rechenfehler</span><br>
<input name="erg" type="text" readonly size=12> <span
style="color:#ff0000;">% der wirksamen Bestrahlungsstärke durch die
Sonne</span><br>
<input name="erg1" type="text" readonly size=12> <span
style="color:#0000ff;">äquivalente Sonnen-Stunden senkrechter
Einstrahlung</span><br>
<input name="rechnen" type="button" value="Berechnen"
onClick="Simpson()"><center><img src="sunshine.gif"></center>
</form>
</table></p>

<a name="Sonnesenk"></a>
<p><h4 style="color:#000000"><u><b>Berechnung der effektiven
Bestrahlungsstärke der senkrechten Fläche durch die
Sonne</b></u></h4></p>

<p>Wieviel Prozent der Sonnenstrahlung fällt auf eine senkrechte,
nach Süden bzw. Norden zeigende Fläche an der angegebenen
geografischen Position, weil die Sonne ja nicht
unbedingt senkrecht über dieser steht und außerdem dem
Tageszeiten- und Jahreszeitenverlauf unterliegt? Die eingetragenen
Koordinaten gehören zu Mainflingen-Offenbach. Die Berechnung ist
schwierig, weil über folgende Großkreisformel
integriert werden mu&szlig, und zwar von 0 bis 365 x 24 Stunden.</p>
<p><center>sin(e) =
sqrt(1-(sin(bf)*sin(bs)+cos(bf)*cos(bs)*cos(ls-lf))²)</center>
<center>mit ls=2*pi/24*t-pi und bs=nWK*sin(2*pi/365/24*t-pi/2) den
Koordinaten des Subsonnenpunktes</center></p>
<p>Auch in Kugelkoordinaten ist diese Berechnung schwierig. Darum
empfiehlt sich hier die SIMPSON-Formel. Für beliebige Koordinaten auf
der Erdoberfläche ist diese Iteration hier geeignet.</p></p>

<p><table border=1 bordercolor="#0000b0"cellpadding="10"
cellspacing="7" bgcolor="#fffff0">
<tr><th colspan="2">effektive Sonnenbestrahlung,
Bestrahlungsstärke, senkrechte Fläche</th></tr><tr><td>
<form name="eingabe10">
<input name="gb" type="text" size=12 value="50.1"> geografische Breite
der Fläche in Dezimalgrad (südlich negativ)<br>
<input name="schritte" type="text" readonly size=12> <span
style="color:#ff0000;">Anzahl der Intervalle der Integration</span><br>
<input name="fehler" type="text" readonly size=12> <span
style="color:#0000ff;">Rechenfehler</span><br>
<input name="erg" type="text" readonly size=12> <span
style="color:#ff0000;">% der wirksamen Bestrahlungsstärke durch die
Sonne</span><br>
<input name="erg1" type="text" readonly size=12> <span
style="color:#0000ff;">äquivalente Sonnen-Stunden senkrechter
Einstrahlung</span><br>
<input name="rechnen" type="button" value="Berechnen"
onClick="Simpsonsenk()"><center><img src="sunshine.gif"></center>
</form>
</table></p>

<a href="#Start">[Oben]</a><a href="index.htm"
target="_parent">[Anfang]</a>

<p><hr noshade color="#000000" size=1></p>

<a name="Sonneneig"></a>
<p><h4 style="color:#000000"><u><b>Berechnung der effektiven
Bestrahlungsstärke der geneigten Fläche durch die
Sonne</b></u></h4></p>

<p>Wieviel Prozent der Sonnenstrahlung fällt auf eine geneigte,
nach Süden bzw. Norden zeigende Fläche an der angegebenen
geografischen Position, weil die Sonne ja nicht
unbedingt senkrecht über dieser steht und außerdem dem
Tageszeiten- und Jahreszeitenverlauf unterliegt? Die eingetragenen
Koordinaten gehören zu Mainflingen-Offenbach.</p>

<p><table border=1 bordercolor="#0000b0"cellpadding="10"
cellspacing="7" bgcolor="#fffff0">
<tr><th colspan="2">effektive Sonnenbestrahlung,
Bestrahlungsstärke, geneigte Fläche</th></tr><tr><td>
<form name="eingabe11">
<input name="gb" type="text" size=12 value="50.1"> geografische Breite
der Fläche in Dezimalgrad (südlich negativ)<br>
<input name="neig" type="text" size=12 value="45"> Neigung der
Fläche in Grad<br>
<input name="rif" type="text" size=12 value="-180"> Richtung
der Fläche in Grad<br>
<input name="schritte" type="text" readonly size=12> <span
style="color:#ff0000;">Anzahl der Intervalle der Integration</span><br>
<input name="fehler" type="text" readonly size=12> <span
style="color:#0000ff;">Rechenfehler</span><br>
<input name="erg" type="text" readonly size=12> <span
style="color:#ff0000;">% der wirksamen Bestrahlungsstärke durch die
Sonne</span><br>
<input name="erg1" type="text" readonly size=12> <span
style="color:#0000ff;">äquivalente Sonnen-Stunden senkrechter
Einstrahlung</span><br>
<input name="rechnen" type="button" value="Berechnen"
onClick="Simpsonneig()"><center><img src="sunshine.gif"></center>
</form>
</table></p>

<a href="#Start">[Oben]</a><a href="index.htm"
target="_parent">[Anfang]</a>

</body>
</html>

Thomas 'PointedEars' Lahn

unread,

Nov 26, 2021, 8:53:08 PM11/26/21

to

Leo Baumann wrote:

> das Programm berechnet das Integral (Simpson) der rel. Bestahlungsstärke
> einer geneigten Fläche durch die Sonne.
>
> Zwei funtionierende Programme für waagerechte und senkrechte Bestrahlung
> sind beigefügt.

Zunächst mal sind das keine Programme. HTML ist keine Programmiersprache.

> Simpsonneig() ist die Integration nach Simpson, function cosen() ist die
> Funktion für die rel. Bestrahlungsstärke.
>
> Die zugehörige Eingabe und der Aufruf für Simpsonneig() ist ganz unten.
>
> Für die eingetragenen Parameter kommt ein sinnvolles Ergebnis heraus,
> variiert man die Parameter, gibt es Probleme.

„Es gibt Probleme” ist keine Beschreibung.

> Hier die Programme:

Es wäre besser gewesen, den URI zu posten, statt hier mehr als gefühlt
200 Zeilen schlecht formatierten und schlecht dokumentierten Quellcode
abzukippen. (*So* hatte ich das in de.sci.physik sicher rNICHT gemeint.)

> <!DOCTYPE HTML>
> <html lang="de">
> <head>
> <script language="JavaScript">

Anfängerfehler Nr. 1: Kein gültiges HTML.

Lass dringend <http://validator.w3.org/> über diesen Code laufen.

Schreib ausserdem hier

'use strict';

damit die gröbsten Programmierfehler in modernen Web-Browsern (die
ECMAScript Ed. 6 und neuer unterstützen) gleich erkannt werden.
Zum Beispiel:

> function cose(t,bb,lb,pi,nwk)
> {
> ls=2*pi/24*t-pi;
^^
> bs=Math.sin(2*pi/8760*t-pi/2)*nwk;
^^
> e=Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb);
^

Nicht deklarierte Variablen. Da kann alles Mögliche passieren.

> if (e<=0) e=0; // wenn die Sonne unter dem Horizont steht
> wird das nicht mit gerechnet
> return e
> }
>

> […]

| Die Bereitschaft fühlender Wesen, Deinen Code näher anzuschauen, liegt
| wohl selbst auf logarithmischen Skalen unter Null (das geht genau dann,
| wenn der Leidensdruck dieser Wesen beim Anschauen größer wird als die
| mathematische Notwendigkeit für Werte größer Null).
|
| –Dietmar Meier in dcljs

Siehe auch: <https://github.com/airbnb/javascript>

> // Richtung zur Sonne
> vz=Math.sin(ls-lb)/Math.sin(h);

Die Sinusfunktion kann auch den Wert 0 annehmen, dann hat vz den Wert “NaN”
(“not-a-number”), da die Division durch Null in IEEE-754 (so wie auch meist
in der Mathematik) nicht definiert ist.

> if (vz<0) ri=-ri;

Dieser Fall wird davon dann nicht erfasst, denn NaN < 0 === false.

> var bb=Math.abs(parseFloat(document.eingabe3.gb.value)*pi/180);

Sauber:

document.forms['eingabe3'].elements['gb'].value

Das ganze Geraffel andauernd vor “elements” kann man sich aber sparen, wenn
man direkt eine Referenz auf das Formularobjekt übergibt:

function myCalc (f)
{
… f.elements['gb'].value …
}

<form onsubmit='myCalc(this); return false'>
…
<input type='submit' …>
</form>

Für die Umrechnung von Grad in Radians empfehle ich, eine eigene Funktion zu
schreiben und aufzurufen, damit sich nicht durch Wiederholung Fehler
einschleichen. (Der Standard bietet leider keine solche.)

> document.eingabe3.schritte.value=String(n+1);

Die Konvertierung nach String beim Schreiben der value-Eigenschaft ist
unnötig, das erledigt der Setter selbst.

> document.eingabe3.fehler.value=String(Math.round(fe*1e8)/1e8);
> document.eingabe3.erg.value=String(Math.round(sa/8760*1e4)/100);
> document.eingabe3.erg1.value=String(Math.round(sa*100)/100);

Falls das eine Rundung auf Nachkommastellen werden soll, so ist das falsch.
Benutz stattdessen Number.prototype.toFixed().

> </head>
>
> <a name="Start"></a>

Ungültig. Das a-Element muss im body-Element enthalten sein.

> <body link="#0000cb" vlink="#00008b" alink="#ff8c00"
> background="grid.gif">

Diese veralteten Attribute haben in HTML5 nichts zu suchen. Schon in HTML
4.01 Strict (1999) nicht mehr.

> <p><center><font face="Eras Bold ITC"><h1 style= "color:
> #0000cb"><u>Berechnungsprogramme</u></h1></font></center></p>

Autsch. Mit einem Struktureditor erstellt?

> <p><table border=1 bordercolor="0000b0" cellspacing="7" bgcolor="#fffff0">
> <tr><th>Art der Berechnung:</th></tr>
> <tr><td><img src="pfeilre.gif"><a href="#Sonne">effektive
> Sonnenbestrahlung, waagerechte Fläche</a></td></tr>
> <tr><td><img src="pfeilre.gif"><a href="#Sonnesenk">effektive
> Sonnenbestrahlung, senkrechte Fläche</a></td></tr>
> <tr><td><img src="pfeilre.gif"><a href="#Sonneneig">effektive
> Sonnenbestrahlung, geneigte Fläche</a></td></tr>
> </table></p>

table-Elemente sind schon Block-Level-Elemente, und p-Elemente dürfen sie
nicht enthalten (die sind nämlich für Absätze).

> <p><hr noshade color="#000000" size=1></p>

Autsch.

> <a name="Sonne"></a>
> <p><h4 style="color:#000000"><u><b>Berechnung der effektiven
> Bestrahlungsstärke der waagerechten Fläche durch die
> Sonne</b></u></h4></p>

Nein, sondern

<h4 id='Sonne'>Berechnung der effektiven Bestrahlungsstärke der
waagerechten Fläche durch die Sonne</h4>

Alles andere wird durch ein Stylesheet (CSS) erledigt. Das gilt auch für
die übrigen Elemente. Sonst wird/bleibt das ein Wartungsalbtraum.

Wenn Du diese Fehler beseitigt hast, solltest Du den Code oder URI eines auf
das *Minimum* reduzierten Testfall posten. Bei der Erstellung eines solchen
findest Du sogar womöglich den Fehler schon selbst.

--
PointedEars
FAQ: <http://PointedEars.de/faq> | <http://PointedEars.de/es-matrix>
<https://github.com/PointedEars> | <http://PointedEars.de/wsvn/>
Twitter: @PointedEars2 | Please do not cc me./Bitte keine Kopien per E-Mail.

Thomas 'PointedEars' Lahn

unread,

Nov 26, 2021, 8:59:16 PM11/26/21

to

Thomas 'PointedEars' Lahn wrote:

> Leo Baumann wrote:
>> <a name="Sonne"></a>
>> <p><h4 style="color:#000000"><u><b>Berechnung der effektiven
>> Bestrahlungsstärke der waagerechten Fläche durch die
>> Sonne</b></u></h4></p>
>
> Nein, sondern
>
> <h4 id='Sonne'>Berechnung der effektiven Bestrahlungsstärke der
> waagerechten Fläche durch die Sonne</h4>

Und ausserdem kannst Du einfach z. B. Umlaute direkt schreiben, wenn Du es
als ISO-8859-1 oder -15 oder UTF-8 speicherst (ich empfehle Letzteres) und
auch so deklarierst.

Leo Baumann

unread,

Nov 26, 2021, 9:31:14 PM11/26/21

to

Am 27.11.2021 um 02:53 schrieb Thomas 'PointedEars' Lahn:
> „Es gibt Probleme” ist keine Beschreibung.

Simpsonneig() integriert über die rel. Bestrahlungsstärke einer
geneigten Fläche über ein Jahr. Die zugehörige Funktion über die
integriert wird ist cosen().

ls - Längengrad Sonne als Fkt. der Std. eines Jahres
bs - Breitengrad der Sonne als Fkt. der Std. eines Jahres
t - Zeit in Stunden
bb - Breitengrad des Beobachters (Fläche auf der Erde)
lb - Längengrad des Beobachters (Fläche auf der Erde), hier Konstante 0
nwk- nördlicher Wendekreis 23.5 Grad
neig - Neigung der Fläche, Winkel zur Erde
rif - Richtung der Fläche, Winkel zu Nord oder Süd
ri - Richtung zur Sonne, Winkel zu Nord oder Süd
vz - Vorzeichen der Richtung
ele - Elevation zur Sonne am Ort der Fläche
return e - e ist nicht der Winkel, sondern der Kosinus des Winkels wie
in https://www.lti.kit.edu/rd_download/Solarenergie_20081024_Sonne.pdf
das cos(θ_gen)

danke

Thomas 'PointedEars' Lahn

unread,

Nov 26, 2021, 10:32:50 PM11/26/21

to

Ja, und was genau ist jetzt das *Problem*?

<http://www.catb.org/~esr/faqs/smart-questions.html>

> danke

Bitte. <facepalm/>

Leo Baumann

unread,

Nov 26, 2021, 10:52:05 PM11/26/21

to

Am 27.11.2021 um 04:32 schrieb Thomas 'PointedEars' Lahn:
> Ja, und was genau ist jetzt das*Problem*?

Für die im vorhandenen Script vordefinierten Parameter funktioniert die
Berechnung. Probleme gibt es, wenn Beobachterbreite und Richtung der
Fläche variiert werden.

Abgesehen davon, dass die Konstante gs (Genauigkeit Stellen) in
simpsonneig() bei verschiedenen Werten reduziert werden muss, damit die
Integration überhaupt funktioniert.

Schön wäre natürlich, wenn für Neigung = 0 und 90 Grad die gleichen
Ergebnisse geliefert würden, wie in den beiden anderen ebenfalls
vorhandenen entsprechenden Scripten.

Aktuell kann ich die Orte der Fehler im Script nicht finden, auch wenn
ich mir einzelne Variablen mit console.log() ansehe.

Leo Baumann

unread,

Nov 27, 2021, 12:00:25 AM11/27/21

to

Am 27.11.2021 um 04:51 schrieb Leo Baumann:
> Ja, und was genau ist jetzt das*Problem*?

Lass' 'mal sein. Da sind noch Fehler in den Formeln. Außerdem gibt es
Probleme mit der Integration simpsonneig().

Das muss ich mir nochmal genauer ansehen nach einer Pause.

Leo Baumann

unread,

Nov 27, 2021, 12:28:43 AM11/27/21

to

Am 27.11.2021 um 06:00 schrieb Leo Baumann:
> Lass' 'mal sein. Da sind noch Fehler in den Formeln. Außerdem gibt es
> Probleme mit der Integration simpsonneig().
>
> Das muss ich mir nochmal genauer ansehen nach einer Pause.

In der Zwischenzeit habe ich einige Korrekturen in den Berechnungen
vorgenommen:

<!DOCTYPE HTML>
<html lang="de">
<head>
<script language="JavaScript">

function cose(t,bb,lb,pi,nwk)
{
ls=2*pi/24*t-pi;
bs=Math.sin(2*pi/8760*t-pi/2)*nwk;
e=Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb);

if (e<=0) e=0; // wenn die Sonne unter dem Horizont steht
wird das nicht mit gerechnet
return e
}

function sine(t,bb,lb,pi,nwk)
{
ls=2*pi/24*t-pi;
bs=Math.sin(2*pi/8760*t-pi/2)*nwk;

eh=Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb);
// *****cos(e)
e=Math.sqrt(1-Math.pow(eh,2)); // *****sin(e)

if (eh<0) e=0; // *****wenn die Sonne unter dem Horizont

steht wird das nicht mit gerechnet
return e
}

function cosen(t,bb,lb,pi,nwk,neig,rif)
{
ls=2*pi/24*t-pi; // Länge Sonne
bs=Math.sin(2*pi/8760*t-pi/2)*nwk; // Breite Sonne

cose1=Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb);
// Großkreis zum Subsonnenpunkt
h=Math.acos(cose1); // Winkel des Subsonnenpunktes im EWrmittelpunkt

ri=Math.abs(Math.acos(Math.sin(bs)-Math.sin(bb)*cose1/Math.cos(bb)/Math.sin(h)));
// Richtung zur Sonne
vz=Math.sin(ls-lb)*Math.cos(bs)/Math.sin(h);

if (vz<0) ri=-ri;

ele=pi/2-Math.acos(Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb));
// Sonnenhöhe
if (ele<=0) {e=0; ele=0;} else
{e=(-Math.cos(ele)*Math.sin(neig)*Math.cos(ri-rif)+Math.sin(ele)*Math.cos(neig))/Math.sin(ele);}
if (e<=0) e=0;

//console.log(t);

console.log(u+t*sw);

}

s=sw/3*(c+2*g+4*u);
if (s==0) s=te;
fe=Math.abs((s-sa)/(15*s));
sa=s;
}while ((fe>te) || (n<min));

document.eingabe11.schritte.value=String(n+1);
document.eingabe11.fehler.value=String(Math.round(fe*1e8)/1e8);
document.eingabe11.erg.value=String(Math.round(sa/8760*1e4)/100);
document.eingabe11.erg1.value=String(Math.round(sa*100)/100);
}

</script>

</head>

<a name="Start"></a>

<p><center><font face="Eras Bold ITC"><h1 style= "color:
#0000cb"><u>Berechnungsprogramme</u></h1></font></center></p>

<p><table border=1 bordercolor="0000b0" cellspacing="7" bgcolor="#fffff0">
<tr><th>Art der Berechnung:</th></tr>
<tr><td><img src="pfeilre.gif"><a href="#Sonne">effektive
Sonnenbestrahlung, waagerechte Fläche</a></td></tr>
<tr><td><img src="pfeilre.gif"><a href="#Sonnesenk">effektive
Sonnenbestrahlung, senkrechte Fläche</a></td></tr>
<tr><td><img src="pfeilre.gif"><a href="#Sonneneig">effektive
Sonnenbestrahlung, geneigte Fläche</a></td></tr>
</table></p>

<a name="Sonne"></a>
<p><h4 style="color:#000000"><u><b>Berechnung der effektiven
Bestrahlungsstärke der waagerechten Fläche durch die
Sonne</b></u></h4></p>

<p>Wieviel Prozent der Sonnenstrahlung fällt auf eine waagerechte
Fläche an der angegebenen geografischen Position, weil die Sonne ja
nicht
unbedingt senkrecht über dieser steht und außerdem dem
Tageszeiten- und Jahreszeitenverlauf unterliegt? Die eingetragenen
Koordinaten gehören zu Mainflingen-Offenbach. Die Berechnung ist
schwierig, weil über folgende Großkreisformel
integriert werden mu&szlig, und zwar von 0 bis 365 x 24 Stunden.</p>
<p><center>cos(e) = sin(bf)*sin(bs)+cos(bf)*cos(bs)*cos(ls-lf)</center>
<center>mit ls=2*pi/24*t-pi und bs=nWK*sin(2*pi/365/24*t-pi/2) den
Koordinaten des Subsonnenpunktes</center></p>
<p>Auch in Kugelkoordinaten ist diese Berechnung schwierig. Darum
empfiehlt sich hier die SIMPSON-Formel. Für beliebige Koordinaten auf
der Erdoberfläche ist diese Iteration hier geeignet.</p>

<p><table border=1 bordercolor="#0000b0"cellpadding="10"

cellspacing="7" bgcolor="#fffff0">

<tr><th colspan="2">effektive Sonnenbestrahlung,
Bestrahlungsstärke, waagerechte Fläche</th></tr><tr><td>
<form name="eingabe3">
<input name="gb" type="text" size=12 value="50.1"> geografische Breite
der Fläche in Dezimalgrad (südlich negativ)<br>
<input name="schritte" type="text" readonly size=12> <span
style="color:#ff0000;">Anzahl der Intervalle der Integration</span><br>
<input name="fehler" type="text" readonly size=12> <span
style="color:#0000ff;">Rechenfehler</span><br>
<input name="erg" type="text" readonly size=12> <span
style="color:#ff0000;">% der wirksamen Bestrahlungsstärke durch die
Sonne</span><br>
<input name="erg1" type="text" readonly size=12> <span
style="color:#0000ff;">äquivalente Sonnen-Stunden senkrechter
Einstrahlung</span><br>
<input name="rechnen" type="button" value="Berechnen"
onClick="Simpson()"><center><img src="sunshine.gif"></center>
</form>
</table></p>

<p><h4 style="color:#000000"><u><b>Berechnung der effektiven

Bestrahlungsstärke der senkrechten Fläche durch die

Sonne</b></u></h4></p>

<p>Wieviel Prozent der Sonnenstrahlung fällt auf eine senkrechte,
nach Süden bzw. Norden zeigende Fläche an der angegebenen
geografischen Position, weil die Sonne ja nicht
unbedingt senkrecht über dieser steht und außerdem dem
Tageszeiten- und Jahreszeitenverlauf unterliegt? Die eingetragenen
Koordinaten gehören zu Mainflingen-Offenbach. Die Berechnung ist
schwierig, weil über folgende Großkreisformel
integriert werden mu&szlig, und zwar von 0 bis 365 x 24 Stunden.</p>
<p><center>sin(e) =
sqrt(1-(sin(bf)*sin(bs)+cos(bf)*cos(bs)*cos(ls-lf))²)</center>
<center>mit ls=2*pi/24*t-pi und bs=nWK*sin(2*pi/365/24*t-pi/2) den
Koordinaten des Subsonnenpunktes</center></p>
<p>Auch in Kugelkoordinaten ist diese Berechnung schwierig. Darum
empfiehlt sich hier die SIMPSON-Formel. Für beliebige Koordinaten auf
der Erdoberfläche ist diese Iteration hier geeignet.</p></p>

<p><table border=1 bordercolor="#0000b0"cellpadding="10"

cellspacing="7" bgcolor="#fffff0">

<tr><th colspan="2">effektive Sonnenbestrahlung,
Bestrahlungsstärke, senkrechte Fläche</th></tr><tr><td>
<form name="eingabe10">
<input name="gb" type="text" size=12 value="50.1"> geografische Breite
der Fläche in Dezimalgrad (südlich negativ)<br>
<input name="schritte" type="text" readonly size=12> <span
style="color:#ff0000;">Anzahl der Intervalle der Integration</span><br>
<input name="fehler" type="text" readonly size=12> <span
style="color:#0000ff;">Rechenfehler</span><br>
<input name="erg" type="text" readonly size=12> <span
style="color:#ff0000;">% der wirksamen Bestrahlungsstärke durch die
Sonne</span><br>
<input name="erg1" type="text" readonly size=12> <span
style="color:#0000ff;">äquivalente Sonnen-Stunden senkrechter
Einstrahlung</span><br>
<input name="rechnen" type="button" value="Berechnen"
onClick="Simpsonsenk()"><center><img src="sunshine.gif"></center>
</form>
</table></p>

<a href="#Start">[Oben]</a><a href="index.htm"
target="_parent">[Anfang]</a>

<p><h4 style="color:#000000"><u><b>Berechnung der effektiven

Bestrahlungsstärke der geneigten Fläche durch die

Sonne</b></u></h4></p>

<p>Wieviel Prozent der Sonnenstrahlung fällt auf eine geneigte,
nach Süden bzw. Norden zeigende Fläche an der angegebenen
geografischen Position, weil die Sonne ja nicht
unbedingt senkrecht über dieser steht und außerdem dem
Tageszeiten- und Jahreszeitenverlauf unterliegt? Die eingetragenen
Koordinaten gehören zu Mainflingen-Offenbach.</p>

<p><table border=1 bordercolor="#0000b0"cellpadding="10"

cellspacing="7" bgcolor="#fffff0">

Thomas 'PointedEars' Lahn

unread,

Nov 27, 2021, 12:50:34 AM11/27/21

to

Leo Baumann wrote:

> Am 27.11.2021 um 04:32 schrieb Thomas 'PointedEars' Lahn:
>> Ja, und was genau ist jetzt das*Problem*?
>
> Für die im vorhandenen Script vordefinierten Parameter funktioniert die
> Berechnung. Probleme gibt es, wenn Beobachterbreite und Richtung der
> Fläche variiert werden.

Soifz. [psf 10.1]

Deine vagen Beschreibungen sind für einen Aussenstehenden komplett nutzlos.
Verstehst Du das nicht?

> Abgesehen davon, dass die Konstante gs (Genauigkeit Stellen) in
> simpsonneig() bei verschiedenen Werten reduziert werden muss, damit die
> Integration überhaupt funktioniert.

Das liegt möglicherweise an Rundungsfehlern, die durch eine Reduktion von
Dezimalstellen reduziert werden. Bei der Addition von Gleitkommazahlen muss
die begrenzte Genauigkeit beachtet und um eine “catastrophic cancellation”
zu vermeiden stattdessen eine geeignete Strategie gewählt werden, zum
Beispiel Kahan–Neumaier-Summation.

> Schön wäre natürlich, wenn für Neigung = 0 und 90 Grad die gleichen
> Ergebnisse geliefert würden, wie in den beiden anderen ebenfalls
> vorhandenen entsprechenden Scripten.

Diese beiden Situationen sind aber keineswegs identisch: einerseits ist die
Fläche parallel und andererseits senkrecht zum Boden.

> Aktuell kann ich die Orte der Fehler im Script nicht finden, auch wenn
> ich mir einzelne Variablen mit console.log() ansehe.

Debugging wäre natürlich eine Lösung.

Stefan Reuther

unread,

Nov 27, 2021, 5:12:53 AM11/27/21

to

Am 27.11.2021 um 04:51 schrieb Leo Baumann:

> Am 27.11.2021 um 04:32 schrieb Thomas 'PointedEars' Lahn:
>> Ja, und was genau ist jetzt das*Problem*?
>
> Für die im vorhandenen Script vordefinierten Parameter funktioniert die
> Berechnung. Probleme gibt es, wenn Beobachterbreite und Richtung der
> Fläche variiert werden.

Das ist keine Fehlerbeschreibung.

Eine Fehlerbeschreibung sagt: "ich habe <Umgebung>, ich führe <Aktion>
aus, ich bekomme <Ergebnis>, ich erwarte aber <erwartetes Ergebnis>".
Und das ist unabhängig davon, ob man ein Problem mit der Klospülung,
einem Plätzchenrezept, einem Auto oder einem Javascript-Programm hat.

Bonuspunkte gibt's, wenn die Umgebung schon von "200 Zeilen wildes
Javascript" auf etwas kleineres eingedampft wurde.

> Aktuell kann ich die Orte der Fehler im Script nicht finden, auch wenn
> ich mir einzelne Variablen mit console.log() ansehe.

Dann schaust du nicht die richtigen Variablen an.

Den Tipp mit den undeklarierten Variablen hast du schon bekommen. Um
sowas zu finden, empfiehlt es sich, eine Entwicklungsumgebung zu
benutzen, die was von Javascript versteht. Bei mir ist das ganz einfach
Emacs mit js2-mode, der unterkringelt mir undeklarierte Variablen und
fehlende Semikola automatisch. Außerdem gibt es Online-Tools wie
<https://www.jslint.com/>.

Für beides empfiehlt es sich, Javascript in eine separate Datei
abzulegen und nicht direkt im HTML. Das vereinfacht die Arbeit.

Stefan

Message has been deleted

Thomas 'PointedEars' Lahn

unread,

Nov 27, 2021, 10:28:53 AM11/27/21

to

Stefan Reuther wrote:

> Am 27.11.2021 um 04:51 schrieb Leo Baumann:
>> Aktuell kann ich die Orte der Fehler im Script nicht finden, auch wenn
>> ich mir einzelne Variablen mit console.log() ansehe.
>
> Dann schaust du nicht die richtigen Variablen an.

Das ist möglich.

> Den Tipp mit den undeklarierten Variablen hast du schon bekommen. Um
> sowas zu finden, empfiehlt es sich, eine Entwicklungsumgebung zu
> benutzen, die was von Javascript versteht.

Zunächst wäre es hilfreich, selbst etwas von "_JavaScript_" zu verstehen,
und dass es sich dabei eben nicht um *eine* Programmiersprache, sondern um
*mehrere*, handelt; sie sind nur alle *ähnlich*, weil sie alle auf demselben
Standard – ECMAScript – basieren:

<http://PointedEars.de/es-matrix>

Weiss man dies, dann kann man auch wissen, wie schon erwähnt, dass speziell
dieses Problem und einige andere bereits mit Aktivierung des ECMAScript 5+
Strict Mode entdeckt werden; dazu schreibe man einfach

'use strict';

am Anfang des Programms oder einer Funktion/Methode (welche String-Begrenzer
man verwendet, ist fast egal) und benutze eine Browserversion, die jünger
als 10 Jahre ist, und folglich ECMAScript Ed. 5 oder neuer unterstützt.
(Der Code läuft dann auch noch in älteren Umgebungen, weil dies eine dort
syntaktisch korrekte Anweisung ist, die dort nichts bewirkt.)

> Bei mir ist das ganz einfach Emacs mit js2-mode, der unterkringelt mir
> undeklarierte Variablen und fehlende Semikola automatisch. Außerdem gibt
> es Online-Tools wie <https://www.jslint.com/>.

Dieses Tool kann ich gerade für Anfänger nicht empfehlen und auch von
anderen Profis wird davon abgeraten: es spiegelt zu sehr die persönliche
Meinung von Douglas Crockford und zuwenig die rational begründete,
empfohlene Praxis wider. Stattdessen kann ich aus eigener Praxis ESLint
sehr empfehlen.

Dazu kann ich Atom zusammen mit den Add-ons ide-typescript und linter-eslint
empfehlen. Eine gute und anpassbare Basiskonfiguration für ESLint basierend
auf dem Airbnb JavaScript Style Guide ist ebenda verfügbar (URI in meiner
anderen Antwort).

<http://eslint.org/>
<http://atom.io/>

> Für beides empfiehlt es sich, Javascript in eine separate Datei

Nochmals: _JavaScript_, und selbst das ist noch unpräzise.

> abzulegen und nicht direkt im HTML. Das vereinfacht die Arbeit.

Ja, und gleiches gilt für CSS.

Thomas 'PointedEars' Lahn

unread,

Nov 27, 2021, 1:41:09 PM11/27/21

to

Thomas 'PointedEars' Lahn wrote:

> Leo Baumann wrote:

>> Aktuell kann ich die Orte der Fehler im Script nicht finden, auch wenn
>> ich mir einzelne Variablen mit console.log() ansehe.
>
> Debugging wäre natürlich eine Lösung.

<http://devtoolsecrets.com/>

Arno Welzel

unread,

Nov 27, 2021, 6:53:57 PM11/27/21

to

Leo Baumann:

> Am 27.11.2021 um 04:32 schrieb Thomas 'PointedEars' Lahn:
>> Ja, und was genau ist jetzt das*Problem*?
>
> Für die im vorhandenen Script vordefinierten Parameter funktioniert die
> Berechnung. Probleme gibt es, wenn Beobachterbreite und Richtung der
> Fläche variiert werden.

*Welche* Probleme?

Was erwartest Du als Ergebnis und was erhältst Du statt dessen?

--
Arno Welzel
https://arnowelzel.de

Leo Baumann

unread,

Nov 27, 2021, 11:47:27 PM11/27/21

to

Am 28.11.2021 um 00:53 schrieb Arno Welzel:
> *Welche* Probleme?
>
> Was erwartest Du als Ergebnis und was erhältst Du statt dessen?

Zunächst habe ich Fehler in den Berechnungsformeln beseitigt.-
Aktuell habe ich das Problem, dass das e, unten in cosen() zu NaN wird,
und ich das nicht durchschaue. :(

Thomas 'PointedEars' Lahn

unread,

Nov 28, 2021, 6:51:28 PM11/28/21

to

Nochmals: *Benutz* *einen* *Debugger*.

Der entsprechende Code lesbar geschrieben und grobe Fehler (nicht
deklarierte Variablen) korrigiert (einige Debugger können ersteres bis zu
eineem gewissen Grad):

function cosen (t, bb, lb, pi, nwk, neig, rif)
{
/* Längengrad Sonne */
let ls = 2*pi/24 * t - pi;

/* Breitengrad Sonne */
let bs = Math.sin(2*pi/8760 * t - pi/2) * nwk;
let cose1 = Math.cos(bb) * Math.cos(ls - lb);
let h = Math.acos(cose1);
let ri = Math.abs(
Math.acos(-Math.sin(bb) * cose1 / Math.cos(bb) / Math.sin(h))
);

/* Richtung zur Sonne */
let vz = Math.sin(ls - lb)/Math.sin(h);
if (vz < 0) ri = -ri;

let ele = pi/2
- Math.acos(
Math.sin(bb) * Math.sin(bs)
+ Math.cos(bb) * Math.cos(bs) * Math.cos(ls - lb)
);

/* Sonnenhöhe */
let e;
if (ele <= 0)
{
e = 0;
ele = 0;
}
else
{
e = (-Math.cos(ele) * Math.sin(neig) * Math.cos(ri - rif)
+ Math.sin(ele) * Math.cos(neig))
/ Math.sin(ele);
}

if (e <= 0) e = 0;

/* DEBUG */
console.log(ri * 180/pi);

return e;
}

(Das nächste Mal bitte selbst machen.)

Mit diesem nun lesbareren Code sollte spätestens jetzt klar sein, dass e nur
genau dann NaN sein kann, wenn einer der Faktoren im Zähler oder der Nenner
NaN ist [ist hingegen Math.sin(ele) === 0, dann ist e === Infinity]. Das
ist genau dann der Fall, wenn mindestens eines der Argumente der Methoden
NaN ist – also ele, neig, oder ri - rif. Letzteres kann dann NaN sein, wenn
ri oder rif NaN sind. Und so weiter.

Und Deine nachträgliche Korrektur

if (e <= 0) e = 0;

trifft AISB auf Number.isNaN(e) NICHT zu, da (NaN <= 0) === false.

Deswegen kann e bei der return-Anweisung NaN sein.

Ich würde übrigens π (und allgemein echte Konstanten, die nicht als
Platzhalter dienen) NICHT als Argument (hier: pi) übergeben; schon allein
weil die Parameterwerte in einer Funktion versehentlich modifiziert werden
könnten (dagegen hilft auch der Strict Mode nicht). Ausserdem bläht es die
Funktionssignatur unnötig auf und widerspricht dem Gesetz von Demeter
(“Black box”-Prinzip).

Wenn Du nicht ständig Math.PI schreiben willst, dann deklarier Dir eine
globale Konstante oder (besser) eine Modulkonstante:

let myMod = (function () {
/* Module constants */

const PI = Math.PI;

/* Private functions */

function _privateFunctionName (…)
{
… PI …
}

/* Public properties */

return {
publicMethodName: function (…) {
… _privateFunctionName(…) …
}
};
}());

Irnkwo im HTML-Code:

… myMod.publicMethodName(…); …

Die Bezeichner sind geeignet zu ändern.

Auch ist “e” ein schlechter (weil mehrdeutiger) Variablenbezeichner.

Leo Baumann

unread,

Nov 29, 2021, 9:41:37 AM11/29/21

to

Am 29.11.2021 um 00:51 schrieb Thomas 'PointedEars' Lahn:
> Nochmals:*Benutz* *einen* *Debugger*.

Nachdem ich mich mit dem Debugger vertraut gemacht habe und einen
Breakpoint gesetzt habe, konnte ich herausfinden wo die NaNs entstehen:

In dem Befehl

if (h!=0)
{ris=Math.abs(Math.acos(Math.sin(bs)-Math.sin(bb)*cose1/Math.cos(bb)/Math.sin(h)));}

wird ris zu NaN obwohl alle bestimmenden Parameter im grünen Bereich
sind, also bs,bb,cose1,cos(bb) und sin(h)

Das treibt mich jetzt aber wirklich zur Verzweifelung :(

Arno Welzel

unread,

Nov 29, 2021, 10:12:44 AM11/29/21

to

Leo Baumann:

> Am 29.11.2021 um 00:51 schrieb Thomas 'PointedEars' Lahn:
>> Nochmals:*Benutz* *einen* *Debugger*.
>
> Nachdem ich mich mit dem Debugger vertraut gemacht habe und einen
> Breakpoint gesetzt habe, konnte ich herausfinden wo die NaNs entstehen:
>
> In dem Befehl
>
> if (h!=0)
> {ris=Math.abs(Math.acos(Math.sin(bs)-Math.sin(bb)*cose1/Math.cos(bb)/Math.sin(h)));}
>
>
> wird ris zu NaN obwohl alle bestimmenden Parameter im grünen Bereich
> sind, also bs,bb,cose1,cos(bb) und sin(h)

Was ist "grüner Bereich"? Relevant ist, ob folgendes erfüllt ist:

Math.cos(bb) != 0
Math.sin(h) != 0

Leo Baumann

unread,

Nov 29, 2021, 10:23:25 AM11/29/21

to

Am 29.11.2021 um 16:12 schrieb Arno Welzel:
> Was ist "grüner Bereich"? Relevant ist, ob folgendes erfüllt ist:
>
> Math.cos(bb) != 0
> Math.sin(h) != 0

Natürlich ist beides erfüllt, 10 x kontrolliert. :(

Leo Baumann

unread,

Nov 29, 2021, 10:30:44 AM11/29/21

to

So, nochmals kontrolliert - beides im grünen Bereich!!!

V E R Z W E I F E L U N G :(

Arno Welzel

unread,

Nov 29, 2021, 10:56:27 AM11/29/21

to

Leo Baumann:

Also:

Du sagst, dass hier würde NaN ergeben:

Math.abs(
Math.acos(
Math.sin(bs) -

Math.sin(bb) * cose1 / Math.cos(bb) / Math.sin(h)
)
)

Und bs, bb, cose1 und h sind gültige numerische Werte und Math.cos(bb)
sowie Math.sin(h) sind ungleich 0.

Das ist aus meiner Sicht unmöglich.

Leo Baumann

unread,

Nov 29, 2021, 11:00:17 AM11/29/21

to

Am 29.11.2021 um 16:56 schrieb Arno Welzel:
>> Natürlich ist beides erfüllt, 10 x kontrolliert.:(
> Also:
>
> Du sagst, dass hier würde NaN ergeben:
>
> Math.abs(
> Math.acos(
> Math.sin(bs) -
> Math.sin(bb) * cose1 / Math.cos(bb) / Math.sin(h)
> )
> )
>
> Und bs, bb, cose1 und h sind gültige numerische Werte und Math.cos(bb)
> sowie Math.sin(h) sind ungleich 0.
>
> Das ist aus meiner Sicht unmöglich.

Darum bin ich aktuell auch verzweifelt und konfus. Definitiv sind
cos(bb) sowie sin(h) ungleich Null und alle anderen sind gültige Werte.

Arno Welzel

unread,

Nov 29, 2021, 11:02:05 AM11/29/21

to

Arno Welzel:

I stand corrected.

Math.acos(x) will für x einen Wert von -1 bis 1 haben. Alle Werte unter
-1 oder über 1 liefern NaN.

Siehe auch:

<https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Math/acos>

Arno Welzel

unread,

Nov 29, 2021, 11:02:59 AM11/29/21

to

Leo Baumann:

Ja - aber Math.acos(x) will für x einen Wert von -1 bis 1 haben. Das ist
für den Ausdruck

Math.sin(bs) - Math.sin(bb) * cose1 / Math.cos(bb) / Math.sin(h)

nicht garantiert.

Leo Baumann

unread,

Nov 29, 2021, 11:06:47 AM11/29/21

to

Am 29.11.2021 um 17:02 schrieb Arno Welzel:
> I stand corrected.
>
> Math.acos(x) will für x einen Wert von -1 bis 1 haben. Alle Werte unter
> -1 oder über 1 liefern NaN.
>
> Siehe auch:
>
> <https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Math/acos>

ah - ok - danke - Ich werde prüfen.

Leo Baumann

unread,

Nov 29, 2021, 11:10:47 AM11/29/21

to

Am 29.11.2021 um 17:02 schrieb Arno Welzel:

> I stand corrected.
>
> Math.acos(x) will für x einen Wert von -1 bis 1 haben. Alle Werte unter
> -1 oder über 1 liefern NaN.
>
> Siehe auch:
>
> <https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Math/acos>

x wird -1.9896

danke - damit komme ich weiter :)

Leo Baumann

unread,

Nov 29, 2021, 5:46:49 PM11/29/21

to

Jetzt läuft die Integration durch. Ergebnisse aber zu groß.
Ich suche weiter ...

Leo Baumann

unread,

Nov 29, 2021, 10:12:50 PM11/29/21

to

Am 29.11.2021 um 23:46 schrieb Leo Baumann:
> Jetzt läuft die Integration durch. Ergebnisse aber zu groß.
> Ich suche weiter ...

Hier nochmal die Winkel:
https://www.lti.kit.edu/rd_download/Solarenergie_20081024_Sonne.pdf

Aufsummiert wird cos(θ_gen/sin(γ_s)).-

Ausschließen muss ich γ_s<0 weil die Sonne unter dem Horizont ist.

Ausschließen muss ich auch Sonnenbestrahlung hinter die Fläche. Sieht
jemand in der Zeichung im pdf welcher Winkel das ist?

Die Zeichnung macht meine Augen wild ...

Leo Baumann

unread,

Dec 1, 2021, 8:29:48 AM12/1/21

to

Am 26.11.2021 um 21:19 schrieb Leo Baumann:
> Hallo,
> das Programm berechnet das Integral (Simpson) der rel. Bestahlungsstärke
> einer geneigten Fläche durch die Sonne.
>
> Zwei funtionierende Programme für waagerechte und senkrechte Bestrahlung
> sind beigefügt.
>
> Simpsonneig() ist die Integration nach Simpson, function cosen() ist die
> Funktion für die rel. Bestrahlungsstärke.
>
> Die zugehörige Eingabe und der Aufruf für Simpsonneig() ist ganz unten.
>
> Für die eingetragenen Parameter kommt ein sinnvolles Ergebnis heraus,
> variiert man die Parameter, gibt es Probleme.

Das Script funktioniert jetzt für die meisten Parameter, aber wie sich
durch Vergleich mit dem anderen, zweiten Script zeigt, liefert die
Berechnungsgleichung für senkrechte Flächen falsche Ergebnisse. Die
Berechnungsgleichung aus dem Internet

https://www.lti.kit.edu/rd_download/Solarenergie_20081024_Sonne.pdf

e=(-Math.cos(ele)*Math.sin(neig)*Math.cos(ris-rif)+Math.sin(ele)*Math.cos(neig));

ist wohl falsch.

>
> Hier die Programme:

<!DOCTYPE HTML>
<html lang="de">
<head>
<script language="JavaScript">

function cose(t,bb,lb,pi,nwk)
{
ls=2*pi/24*t-pi;
bs=Math.sin(2*pi/8760*t-pi/2)*nwk;
e=Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb);
if (e<=0) e=0; // wenn die Sonne unter dem Horizont steht
wird das nicht mit gerechnet
return e
}

function sine(t,bb,lb,pi,nwk)
{
ls=2*pi/24*t-pi;
bs=Math.sin(2*pi/8760*t-pi/2)*nwk;

eh=Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb);
// *****cos(e)
e=Math.sqrt(1-Math.pow(eh,2)); // *****sin(e)
if (eh<0) e=0; // *****wenn die Sonne unter dem Horizont
steht wird das nicht mit gerechnet
return e
}

function cosen(t,bb,lb,pi,nwk,neig,rif)
{
ls=2*pi/24*t-pi; // Länge Sonne
bs=Math.sin(2*pi/8760*t-pi/2)*nwk; // Breite Sonne

cose1=Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb);

// cos des Winkels zum Subsonnenpunkt
h=Math.acos(cose1); // Winkel des Subsonnenpunktes im Ermittelpunkt

if (h!=0)
{rish=Math.sin(bb)-Math.sin(bs)*cose1/Math.cos(bs)/Math.sin(h);
ris=Math.abs(Math.acos(rish))} else if (h==0) {ris=0;} // Richtung zur Sonne
if (h!=0) {vz=Math.sin(ls-lb)*Math.cos(bs)/Math.sin(h);} else if
(h>=0) {vz=1;};
if (vz<0) {ris=-ris;}

ele=pi/2-Math.acos(Math.sin(bb)*Math.sin(bs)+Math.cos(bb)*Math.cos(bs)*Math.cos(ls-lb));
// Sonnenhöhe
if ((ele<=0)||(ele>=pi-neig)) {e=0;} else
{e=(-Math.cos(ele)*Math.sin(neig)*Math.cos(ris-rif)+Math.sin(ele)*Math.cos(neig));}
// /Math.sin(ele);}
//console.log(e);

<input name="rif" type="text" size=12 value="180"> Richtung der

Thomas 'PointedEars' Lahn

unread,

Dec 1, 2021, 7:27:42 PM12/1/21

to

Leo Baumann wrote:

> Das Script funktioniert jetzt für die meisten Parameter, aber wie sich
> durch Vergleich mit dem anderen, zweiten Script zeigt, liefert die
> Berechnungsgleichung für senkrechte Flächen falsche Ergebnisse. Die
> Berechnungsgleichung aus dem Internet
>
> https://www.lti.kit.edu/rd_download/Solarenergie_20081024_Sonne.pdf
>
> e=(-Math.cos(ele)*Math.sin(neig)*Math.cos(ris-
rif)+Math.sin(ele)*Math.cos(neig));
>
> ist wohl falsch.

Wahrscheinlicher ist, dass Du sie falsch implementiert hast, aufgrund Deiner
unstrukturierten Vorgehensweise. GIGO.

>> Hier die Programme:

Trotz ausführlicher Hinweise und Erklärungen immer noch derselbe Müll :-(

Leo Baumann

unread,

Dec 1, 2021, 8:20:47 PM12/1/21

to

Am 02.12.2021 um 01:27 schrieb Thomas 'PointedEars' Lahn:
> Wahrscheinlicher ist, dass Du sie falsch implementiert hast, aufgrund Deiner
> unstrukturierten Vorgehensweise. GIGO.

Nein, das ist geprutscht, liefert aber für waagerechte Flächen das
richtige Ergebnis - für senkrechte nicht.

Thomas 'PointedEars' Lahn

unread,

Dec 1, 2021, 10:00:39 PM12/1/21

to

Leo Baumann wrote:

> Am 02.12.2021 um 01:27 schrieb Thomas 'PointedEars' Lahn:
>> Wahrscheinlicher ist, dass Du sie falsch implementiert hast, aufgrund
>> Deiner unstrukturierten Vorgehensweise. GIGO.
>
> Nein, das ist geprutscht,

^^^^^^^^^^
Wie bitte?

> liefert aber für waagerechte Flächen das richtige Ergebnis - für
> senkrechte nicht.

cos(90°) = 0, insofern ist das kein Wunder.

Leo Baumann

unread,

Dec 2, 2021, 1:11:41 AM12/2/21

to

Am 02.12.2021 um 04:00 schrieb Thomas 'PointedEars' Lahn:
>> liefert aber für waagerechte Flächen das richtige Ergebnis - für
>> senkrechte nicht.
> cos(90°) = 0, insofern ist das kein Wunder.

Nun, das Integral über

sin(e) = sqrt(1-(sin(bf)*sin(bs)+cos(bf)*cos(bs)*cos(ls-lf))²)

mit ls=2*pi/24*t-pi und bs=nWK*sin(2*pi/365/24*t-pi/2) den Koordinaten
des Subsonnenpunktes

liefert das richtige Ergebnis, also ist das Integral

cos(e)=(-Math.cos(ele)*Math.sin(neig)*Math.cos(ris-rif)+Math.sin(ele)*Math.cos(neig))

für einen Neigungswinkel von 90 Grad nicht geeignet.

Ersteres habe ich selber hergeleitet, zweiteres ist Zweifelhaftes aus
dem Internet von:

https://www.lti.kit.edu/rd_download/Solarenergie_20081024_Sonne.pdf

Thomas 'PointedEars' Lahn

unread,

Dec 2, 2021, 9:51:28 PM12/2/21

to

Leo Baumann wrote:

> Am 02.12.2021 um 04:00 schrieb Thomas 'PointedEars' Lahn:
>>> liefert aber für waagerechte Flächen das richtige Ergebnis - für
>>> senkrechte nicht.
>> cos(90°) = 0, insofern ist das kein Wunder.
>
> Nun, das Integral über
>
> sin(e) = sqrt(1-(sin(bf)*sin(bs)+cos(bf)*cos(bs)*cos(ls-lf))²)
>
> mit ls=2*pi/24*t-pi und bs=nWK*sin(2*pi/365/24*t-pi/2) den Koordinaten
> des Subsonnenpunktes
>
> liefert das richtige Ergebnis,

Na dann ist ja alles gut. Und was heisst nun „geprutscht“?

Leo Baumann

unread,

Dec 2, 2021, 10:57:39 PM12/2/21

to

Am 03.12.2021 um 03:51 schrieb Thomas 'PointedEars' Lahn:
> Und was heisst nun „geprutscht“?

"Geprutscht" heisst zusammengestrickt, gemogelt, unsauber programmiert.

Leo Baumann

unread,

Dec 2, 2021, 11:18:41 PM12/2/21

to

Am 03.12.2021 um 03:51 schrieb Thomas 'PointedEars' Lahn:

> Na dann ist ja alles gut

Nun, nein - nicht alles ist gut. Ich wollte gerne die äquivalenten
Sonnenstunden senkrechter Einstrahlung für geneigte Flächen berechnen.
Und natürlich so, dass die Ergebnisse nicht nur für waagerechte Flächen,
sondern auch für senkrechte Flächen mit den beiden ersten Skripten
übereinstimmt.

So bin ich noch nicht weiter ...

Thomas 'PointedEars' Lahn

unread,

Dec 2, 2021, 11:33:21 PM12/2/21

to

Ahja.