<jupyter_start><jupyter_text>jQuery(document).ready(function($) {      $(window).on('load', function(){    $('preloader').fadeOut('slow',function(){$(this).remove();});  });    });  divpreloader { position: fixed;       left: 0;       top: 0;       z-index: 999;       width: 100%;       height: 100%;       overflow: visible;       background: fff url('http://preloaders.net/preloaders/720/Moving%20line.gif') no-repeat center center;   }   function code_toggle() {    if (code_shown){      $('div.input').hide('500');      $('toggleButton1').val('Show Code')    } else {      $('div.input').show('500');      $('toggleButton1').val('Hide Code')    }    code_shown = !code_shown  }  $( document ).ready(function(){    code_shown=false;    $('div.input').hide()  });   function result_toggle() {    if (result_shown){      $('div.output').hide('500');      $('toggleButton2').val('Show Results')    } else {      $('div.output').show('500');      $('toggleButton2').val('Hide Results')    }    result_shown = !result_shown  }  $( document ).ready(function(){    result_shown=false;    $('div.output').hide()  });<jupyter_code>%display latex<jupyter_output><empty_output><jupyter_text>DIN-5034-2-Algorithmus Der DIN-Algorithmus ist für die Berechnung der Sonneneinstrahlung in Innenräume entwickelt worden.<jupyter_code>import datetime as dt

RR.scientific_notation(True)

var('Zeit Stunden') # Zeiteinheit

var('Jahreswinkel J') # Winkel auf der Sonnenumlaufbahn
var('TagDesJahres d')
var('Zeitgleichung ZG')
var('Sonnendeklination delta') # Sonnendeklination
var('LZ UTC WOZ MOZ') # Zeitangaben: Lokalzeit, koordinierte Weltzeit, wahre und mittlere Ortszeit
var('Zeitzone ZZ')
var('Laengengrad')
var('l', latex_name='\lambda')
var('Breitengrad varphi')
var('Stundenwinkel')
var('Sonnenhoehe gamma')
var('Sonnenazimut alpha')
var('Luftmasse LM')

# Faktoren und Konstanten
Grad = pi/180
Minuten = Stunden / 60
ZahlDerTageImJahr = 365<jupyter_output><empty_output><jupyter_text>Der **Jahreswinkel** $J$:<jupyter_code>J_eqn = J == 360 * Grad * TagDesJahres / ZahlDerTageImJahr;
pretty_print(J_eqn(TagDesJahres=d))<jupyter_output><empty_output><jupyter_text>die **Sonnendeklination** $\delta$:<jupyter_code>delta_eqn = delta == (0.3948 
                        - 23.2559 * cos(J + 9.1 * Grad)
                        - 0.3915 * cos(2 * J + 5.4 * Grad)
                        - 0.1764 * cos(3 * J + 26. * Grad)
                     ) * Grad;
pretty_print(delta_eqn.factor())

delta_eqn = solve([delta_eqn, J_eqn], J, delta)[-1][-1].factor()
#pretty_print(delta_eqn(TagDesJahres=d))<jupyter_output><empty_output><jupyter_text>An diesen Gleichungen wird bereits deutlich, dass der Algorithmus nur ungefähre Ergebnisse liefern kann, da das Konzept der Schaltjahre und Schaltsekunden nicht berücksichtigt wird. Die sogenannte **Zeitgleichung** $ZG$ beschreibt die Abweichung der **wahren Ortszeit** $WOZ$ von der **mittleren Ortszeit** $MOZ$.Die mittlere Ortszeit ist relativ zur **koordinierten Weltzeit** $UTC$ definiert und hängt vom **Längengrad** $\lambda$ ab.Mit der Angabe der **Zeitzone** $ZZ$ ist auch die **lokale Zeit** $LZ$ gegeben:<jupyter_code>ZG_def = ZG == WOZ - MOZ;
ZG_eqn = ZG == (0.0066 
                    + 7.3525 * cos(J + 85.9 * Grad)
                    + 9.9359 * cos(2 * J + 108.9 * Grad)
                    + 0.3387 * cos(3 * J + 105.2 * Grad)
               ) * Minuten;
pretty_print(ZG_def)
pretty_print(ZG_eqn.factor())

ZG_eqn = solve([ZG_eqn, J_eqn], J, ZG)[-1][-1].factor()
#pretty_print(ZG_eqn(TagDesJahres=d))

LZ_eqn = LZ == UTC + ZZ
MOZ_eqn = MOZ == UTC - 4 * Minuten/(1 * Grad) * Laengengrad
MOZ_eqn = solve([MOZ_eqn, LZ_eqn], UTC, MOZ)[-1][-1].expand()
pretty_print(MOZ_eqn(Laengengrad=l))<jupyter_output><empty_output><jupyter_text>Aus der Definition und einer empirischen Zeitgleichung kann die wahre Ortszeit bestimmt werden:<jupyter_code>WOZ_eqn = solve([ZG_def, ZG_eqn], ZG, WOZ)[-1][-1]
WOZ_eqn = solve([WOZ_eqn, MOZ_eqn], MOZ, WOZ)[-1][-1].expand()
pretty_print(WOZ_eqn(TagDesJahres=d, Laengengrad=l))<jupyter_output><empty_output><jupyter_text>Der **Stundenwinkel**:<jupyter_code>Stundenwinkel_eqn = Stundenwinkel == (12 * Stunden - WOZ) * 15 * Grad / Stunden;
pretty_print(Stundenwinkel_eqn.expand())

Stundenwinkel_eqn = solve([Stundenwinkel_eqn, WOZ_eqn], WOZ, Stundenwinkel)[-1][-1].expand()
#pretty_print(Stundenwinkel_eqn(TagDesJahres=d, Laengengrad=l))<jupyter_output><empty_output><jupyter_text>Mit der **geographischen Breite $\varphi$** lassen sich **Sonnenhöhe** $\gamma$ und -**azimut** $\alpha$ berechnen:<jupyter_code>Sonnenhoehe_eqn = Sonnenhoehe == arcsin(
    cos(Stundenwinkel) * cos(Breitengrad) * cos(delta)
    + sin(Breitengrad) * sin(delta)
    );
pretty_print(Sonnenhoehe_eqn(Laengengrad=l, Breitengrad=varphi))

Sonnenhoehe_eqn = solve([Sonnenhoehe_eqn, Stundenwinkel_eqn], Stundenwinkel, Sonnenhoehe)[-1][-1]
Sonnenhoehe_eqn = solve([Sonnenhoehe_eqn, delta_eqn], delta, Sonnenhoehe)[-1][-1]
#pretty_print(Sonnenhoehe_eqn(TagDesJahres=d, Laengengrad=l, Breitengrad=varphi))
Sonnenazimut_eqn = Sonnenazimut == (180 * Grad 
    + sign(WOZ/Stunden - 12)
    * arccos(
        (sin(Sonnenhoehe) * sin(Breitengrad) - sin(delta))
        / (cos(Sonnenhoehe) * cos(Breitengrad))
        )
    );
pretty_print(Sonnenazimut_eqn(Breitengrad=varphi))
Sonnenazimut_eqn = solve([Sonnenazimut_eqn, Sonnenhoehe_eqn], Sonnenhoehe, Sonnenazimut)[-1][-1]
Sonnenazimut_eqn = solve([Sonnenazimut_eqn, WOZ_eqn], WOZ, Sonnenazimut)[-1][-1]
Sonnenazimut_eqn = solve([Sonnenazimut_eqn, delta_eqn], delta, Sonnenazimut)[-1][-1]
#pretty_print(Sonnenazimut_eqn(TagDesJahres=d, Laengengrad=l, Breitengrad=varphi))<jupyter_output><empty_output><jupyter_text>Heutiger Sonnenweg und jetziger Sonnestand Der heutige Sonnenweg am DBI-TZ kann mit den gegebenen Gleichungen bestimmt werden. Ein Vergleich kann mit dem Online-Angebot von [Sonnenverlauf.de](https://www.sonnenverlauf.de//50.93,13.35,17/2018.12.07/09:15/1/0) vorgenommen werden.<jupyter_code>LON = -13.35 * Grad
LAT = 50.93 * Grad

Sonnenhoehe_hier = Sonnenhoehe_eqn(Laengengrad=LON, Breitengrad=LAT).factor()
Sonnenazimut_hier = Sonnenazimut_eqn(Laengengrad=LON, Breitengrad=LAT).factor()
WOZ_hier = WOZ_eqn(Laengengrad=LON)<jupyter_output><empty_output><jupyter_text>Zurzeit gilt die **Mitteleuropäische Normalzeit** $MEZ$:<jupyter_code>MEZ = + 1 * Stunden
MESZ = + 2 * Stunden

Jetzt = dt.datetime.utcnow() + dt.timedelta(hours = int(MEZ / Stunden));
Heute = (Jetzt.date() - dt.date(Jetzt.year,1,1)).days + 1;

LokaleZeit = (Jetzt.hour + Jetzt.minute/60) * Stunden;
WOZ_jetzt = (WOZ_hier(TagDesJahres=Heute, LZ=LokaleZeit, ZZ=MEZ)/Stunden).expand()<jupyter_output><empty_output><jupyter_text>Mit dem **Tag des Jahres** ergibt sich:<jupyter_code>J_heute = J_eqn(TagDesJahres=Heute).rhs()
delta_heute = delta_eqn(TagDesJahres=Heute).rhs()
ZG_heute = ZG_eqn(TagDesJahres=Heute).rhs()
pretty_print(   'Seit Beginn des Tages sind {:.1f} Stunden vergangen.\n'
                'Heute haben wir den {}. Tag des Jahres.\n'
                'Die Erde hat seit Begin des Jahres {:.1f} Grad auf der Sonnenumlaufbahn zurückgelegt.\n'
                'Die Abweichung des Sonnenstandes ist heute etwa {:.1f} Grad.\n'
                'Die Sonnenzeit weicht heute {:.1f} Minuten von der lokalen Zeit ab.'.format(
                    float(LokaleZeit/Stunden),
                    Heute,
                    float(J_heute/Grad),
                    float(delta_heute/Grad),
                    float(ZG_heute/Minuten))
            )<jupyter_output><empty_output><jupyter_text>Über das Jahr gesehen hat die **Abweichung** folgenden Verlauf.<jupyter_code>Deltadiagram = plot(delta_eqn.rhs()/Grad, 0, 365)
Deltadiagram.axes_labels(['Tag des\n Jahres',u'Sonnendeklination\n in °'])
Deltadiagram<jupyter_output><empty_output><jupyter_text>Über das Jahr gesehen hat die **Zeitgleichung** folgenden Verlauf.<jupyter_code>Zgldiagramm = plot(ZG_eqn.rhs()/Minuten, 0, 365)
Zgldiagramm.axes_labels(['Tag des\n Jahres','Abweichung von der\n Sonnenzeit in Minuten'])
Zgldiagramm<jupyter_output><empty_output><jupyter_text>Für **heute**:<jupyter_code>SH = (Sonnenhoehe_hier(TagDesJahres=Heute, ZZ=MEZ, LZ=LZ*Stunden).rhs()/Grad).function(LZ)
Hoehe = SH(LokaleZeit/Stunden).n()
pretty_print('Zur Zeit steht die Sonne in einem Winkel von etwa {:.1f} Grad ueber dem DBI-TZ.'.format(float(Hoehe)))<jupyter_output><empty_output><jupyter_text>Natürlich können wir mit unseren Gleichungen auch den Zeitpunkt des Sonnenauf- und -untergangs berechnen, indem wir die Nulldurchgänge der Sonnenhöhe am Vormittag und Nachmittag bestimmen.<jupyter_code>Sonnenaufgang = find_root(SH,0,12)
Sonnenuntergang = find_root(SH,12,24)

pretty_print('Sonnenaufgang war etwa um {:%H:%M} und Sonnenuntergang wird etwa um {:%H:%M} sein.'.format(
                dt.datetime.utcfromtimestamp(float(Sonnenaufgang*3600))
                ,dt.datetime.utcfromtimestamp(float(Sonnenuntergang*3600))
                )
            )<jupyter_output><empty_output><jupyter_text>Wir können auch den Sonnenhöchststand ermitteln, indem wir die folgende Extremwertaufgabe lösen.<jupyter_code>Mittag = find_root(SH.diff(LZ),Sonnenaufgang,Sonnenuntergang)
pretty_print('Der Sonnenhöchststand ist heute um {:%H:%M}.'.format(
                dt.datetime.utcfromtimestamp(float(Mittag*3600))
                )
            )
SA = Sonnenazimut_hier(TagDesJahres=Heute, ZZ=MEZ, LZ=LZ*Stunden).rhs()/Grad
SA = SA(Stunden=1).function(LZ) # Die sign-Funktion lässt sich sonst nicht gut vereinfachen.

Azimut = SA(LZ=LokaleZeit/Stunden).n()
pretty_print('Zur Zeit steht die Sonne im Azimut von {:.1f} Grad.'.format(float(Azimut)))
aspectratio = 3
durchmesser = 10
StundenListe = srange(12-6, 12+10, 2)

# Sonnenweg
Sonnenwegdiagram = parametric_plot( (SA(Zeit), SH(Zeit)), (Zeit, Sonnenaufgang, Sonnenuntergang ) )
# Punkte für Stunden
SonnenwegdiagramStunden = point( [(SA(Zeit), SH(Zeit)) for Zeit in StundenListe] )
# Symbol für die Sonne
Sonne = ellipse((Azimut,Hoehe),durchmesser,durchmesser / aspectratio,rgbcolor='yellow', fill=True, legend_label='Die Sonne')

# Grafikobjekt
G = Graphics()
G += Sonnenwegdiagram
G += SonnenwegdiagramStunden
# Beschriftung für Stunden
for Zeit in StundenListe:
    if SH(Zeit) > -5:
        da = 3
        if Zeit < 12: da = -3
        G += text('{}'.format(Zeit),(SA(Zeit) + da, SH(Zeit) + 6 / aspectratio))
G += Sonne

G.axes_range(0,360,0,60)
G.axes_labels(['Azimut',u'Höhe'])
G.set_aspect_ratio(aspectratio)
G.show()<jupyter_output><empty_output><jupyter_text>SonnenstundenDie Definition der Luftmasse in der Vorlesung $LM = \frac{1}{\sin{\gamma_S}}$ gilt nur für große Winkel $\gamma_S > 30\, °$.Diese Bedingung ist in unseren Breitengraden selten der Fall.Deshalb verwenden wir hier eine [Formel](http://www.pveducation.org/pvcdrom/2-properties-sunlight/air-mass),die die Krümmung der Erdoberfläche berücksichtigt.<jupyter_code># Formel aus der Vorlesung
LM_eqn = Luftmasse == (1/sin(Sonnenhoehe))
pretty_print(LM_eqn(Sonnenhoehe=gamma))

# Alternative Formel
LM_alt = Luftmasse == (1/(cos(90 * Grad - Sonnenhoehe) + 0.50572 * (6.07995 + Sonnenhoehe/Grad)**(-1.6364))).factor()
pretty_print(LM_alt(Sonnenhoehe=gamma))
SH = Sonnenhoehe_hier(ZZ=MEZ, LZ=LZ*Stunden).rhs()
LM_hier = LM_alt.subs(Sonnenhoehe=SH).rhs()<jupyter_output><empty_output><jupyter_text>Anhand des Sonnenweges können die Sonnenstunden eines Jahres und die mittlere Luftmasse ermittelt werden.<jupyter_code>ErsterTag = 1
Sonnenstunden = 0
LM_sum = 0
Delta = 0.01

for Heute in srange(ErsterTag, ErsterTag + ZahlDerTageImJahr, 1):
    SH_heute = SH(TagDesJahres=Heute).factor()
    LM_heute = LM_hier(TagDesJahres=Heute).factor()
    Sonnenaufgang = find_root(SH_heute, 0, 12)
    Sonnenuntergang = find_root(SH_heute, 12, 24)
    Sonnenstunden += float(Sonnenuntergang - Sonnenaufgang - 2 * Delta)
    LM_sum += numerical_integral(
                    LM_heute, 
                    Sonnenaufgang + Delta, 
                    Sonnenuntergang - Delta
                )[0]/float(Sonnenuntergang - Sonnenaufgang - 2 * Delta)
pretty_print(   'An diesem Ort gibt es {:.0f} Stunden Tageslicht im Jahr.\n'
                'Die mittlere tägliche Sonnenscheindauer beträgt {:.2f} Stunden.\n'
                'Die mittlere Luftmasse beträgt {:.2f}.'.format(
                    Sonnenstunden,
                    Sonnenstunden/ZahlDerTageImJahr,
                    LM_sum/ZahlDerTageImJahr) 
            )<jupyter_output><empty_output><jupyter_text>In Deutschland wird von einer Sonnenscheindauer von $1000$ Stunden pro Jahr ausgegangen.Um auf die Sonnenscheindauer zu kommen, wird die gleiche Auswertung für die Mittagsstunden wiederholt.<jupyter_code>ErsterTag = 1
Sonnenstunden = 0
LM_sum = 0
Delta = 0.01
for Heute in srange(ErsterTag, ErsterTag + ZahlDerTageImJahr, 1):
    SH_heute = SH(TagDesJahres=Heute).factor()
    LM_heute = LM_hier(TagDesJahres=Heute).factor()
    Sonnenaufgang = find_root(SH_heute, 0, 12)
    Sonnenuntergang = find_root(SH_heute, 12, 24)
    Mittag = find_root(SH_heute.diff(LZ), Sonnenaufgang, Sonnenuntergang)
    Mittagsstunden = (Sonnenuntergang - Sonnenaufgang)/4
    Anfangszeit = Mittag - Mittagsstunden/2
    Endzeit = Mittag + Mittagsstunden/2
    Sonnenstunden += float(Mittagsstunden)
    LM_sum += numerical_integral(
                    LM_heute, 
                    Sonnenaufgang + Delta, 
                    Sonnenuntergang - Delta
                )[0]/float(Mittagsstunden)
pretty_print(   'An diesem Ort gibt es {:.0f} Stunden Sonnenschein im Jahr.\n'
                'Die mittlere tägliche Sonnenscheindauer beträgt {:.2f} Stunden.\n'
                'Die mittlere Luftmasse beträgt {:.2f}.'.format(
                    Sonnenstunden,
                    Sonnenstunden/ZahlDerTageImJahr,
                    LM_sum/ZahlDerTageImJahr) 
            )<jupyter_output><empty_output><jupyter_text>Für einen bestimmten Tag des Jahres ergibt sich folgender Verlauf der Luftmasse und der Sonnenhöhe.<jupyter_code>Heute = 1 #364/2

SH_heute = SH(TagDesJahres=Heute).factor()
LM_heute = LM_hier(TagDesJahres=Heute).factor()

Sonnenaufgang = find_root(SH_heute, 0, 12)
Sonnenuntergang = find_root(SH_heute, 12, 24)
Mittag = find_root(SH_heute.diff(LZ), Sonnenaufgang, Sonnenuntergang)

print '----------------------'
print 'Zeit\t LM\t SH'
print 'in h\t -\t in °'
print '---------------------'
for Zeit in srange(Sonnenaufgang+0.1,Sonnenuntergang):
    print '{:4.1f}\t{:4.1f}\t{:4.1f}'.format(float(Zeit), float(LM_heute(LZ=Zeit)), float(SH_heute(LZ=Zeit)))
print '---------------------'<jupyter_output>----------------------
Zeit	 LM	 SH
in h	 -	 in °
---------------------
 8.4	28.8	 0.0
 9.4	 7.4	 0.1
10.4	 4.6	 0.2
11.4	 3.7	 0.3
12.4	 3.6	 0.3
13.4	 4.0	 0.2
14.4	 5.3	 0.2
15.4	10.7	 0.1
---------------------<jupyter_text>----<jupyter_code><script>
  $(document).ready(function(){
    $('div.prompt').hide();
    $('div.back-to-top').hide();
    <!-- $('nav#menubar').hide(); -->
    $('.breadcrumb').hide();
    $('.hidden-print').hide();
  });
</script>

<footer id="attribution" style="float:right; color:#999; background:#fff;">
Created with Jupyter, delivered by Fastly, rendered by Rackspace.
</footer><jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14470742932281394, 'fraction_numerical': 0.025575279421433266, 'mean_word_length': 4.072024008002668, 'pattern_counts': {'":': 0, '<': 90, '<?xml version=': 0, '>': 91, 'https://': 1, 'lorem ipsum': 0, 'www.': 2, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '21', 'dir': 'jupyter-structured-clean-dedup', 'id': '239557', 'license': 'MIT', 'n_tokens_mistral': 6257, 'n_tokens_neox': 5848, 'n_words': 1077, 'path': 'DIN-5034-2.ipynb', 'repo_name': 'bassenj/RegEn', 'size': '15210'}