Astronomische Berechnungen

Hallo zusammen,
hier stelle ich mal das Script vor, mit welchem man eine ganze Menge astronomischer Berechnungen durchführen kann. Alle Formeln sind aus dem Buch „Practical Astronomy“ von Peter Duffett-Smith und Jonathan Zwart, Fourth Edition.

  1. ein neues Script erstellen
  2. Inhalt von hier dort einfügen und abspeichern
  3. noch ein Script erstellen, das erste Script dort „includen“
  4. Variablen mit den entsprechenden function-Aufrufen erstellen (Beispiel siehe Post #2)
  5. Stringvariablen zur Ausgabe im WF anlegen

Hauptscript:

<?

//FormelScript zur Berechnung von Astronomischen Ereignissen
//nach dem Buch "Practical Astronomy with your Calculator or Spreadsheet"
//von Peter Duffet-Smith und Jonathan Zwart
//
//2016-04-28 Bernd Hoffmann
//allerdings sind noch nicht alle Formeln vorhanden...


$day = date("d");
$month = date("m");
$year = date("Y");
$Hour = date("H");
$Minute = date("i");
$Second = date("s");
$summer = date("I");
if ($summer == 0){   //Summertime
	$DS = 0;}         //$DS = Daylight Saving
	else{
	$DS = 1;}
$ZC = 1; // Zone Correction to Geenwich: 1 = UTC+1

//Breiten- und Längengrad hab ich bei mir als Variable abgelegt
$P = getvalue(29795 /*[Scripte\Sonnenauf/untergang\Breitengrad]*/);
$L = getvalue(31634 /*[Scripte\Sonnenauf/untergang\Längengrad]*/);


function dayName($a){
   $b = date("D",($a));
	if     ($b == "Mon"){$c = "Mo";}
 	elseif ($b == "Tue"){$c = "Di";}
  	elseif ($b == "Wed"){$c = "Mi";}
  	elseif ($b == "Thu"){$c = "Do";}
  	elseif ($b == "Fri"){$c = "Fr";}
  	elseif ($b == "Sat"){$c = "Sa";}
  	elseif ($b == "Sun"){$c = "So";}
  	return ($c);}


function direction($r)
	{
	if(($r >= 0)and($r < 22.5)){
		$direction = "N";
		}
	if(($r >= 22.5)and($r < 45)){
   	$direction = "NNE";
		}
	if(($r >= 45)and($r < 67.5)){
   	$direction = "NE";
		}
	if(($r >= 67.5)and($r < 90)){
		$direction = "ENE";
		}
	if(($r >= 90)and($r < 112.5)){
   	$direction = "E";
		}
	if(($r >= 112.5)and($r < 135)){
   	$direction = "ESE";
		}
	if(($r >= 135)and($r < 157.5)){
   	$direction = "SE";
		}
	if(($r >= 157.5)and($r < 180)){
   	$direction = "SSE";
		}
	if(($r >= 180)and($r < 202.5)){
   	$direction = "S";
		}
	if(($r >= 202.5)and($r < 225)){
   	$direction = "SSW";
		}
	if(($r >= 225)and($r < 247.5)){
   	$direction = "SW";
		}
	if(($r >= 247.5)and($r < 270)){
   	$direction = "WSW";
		}
	if(($r >= 270)and($r < 292.5)){
   	$direction = "W";
		}
	if(($r >= 292.5)and($r < 315)){
   	$direction = "WNW";
		}
	if(($r >= 315)and($r < 337.5)){
		$direction = "NW";
		}
	if(($r >= 337.5)and($r <= 360)){
   	$direction = "NNW";
		}
	return ($direction);
	}


// Greenwich calendar date to Julian date conversion
function CDJD($day, $month, $year)
	{
    if ($month < 3){
        $Y = $year - 1;
        $M = $month + 12;}
    else{
        $Y = $year;
        $M = $month;}

    if ($year > 1582){
        $A = variant_fix($Y / 100);
        $B = 2 - $A + variant_fix($A / 4);}
    else{
     if (($year == 1582) And ($month > 10)){
        $A = variant_fix($Y / 100);
        $B = 2 - $A + variant_fix($A / 4);}
     else{
      if (($year == 1582) And ($month == 10) And ($day >= 15)){
        $A = variant_fix($Y / 100);
        $B = 2 - $A + variant_fix($A / 4);}
      else{
        $B = 0;}
			}
			}

    if ($Y < 0){
        $C = variant_fix((365.25 * $Y) - 0.75);}
    else{
        $C = variant_fix(365.25 * $Y);}

    $D = variant_fix(30.6001 * ($M + 1));
    $CDJD = $B + $C + $D + $day + 1720994.5;
    return ($CDJD);
	}

// Julian date to Greenwich calendar date conversion
function JDCDay($JD)
	{
    $I = variant_fix($JD + 0.5);
    $F = $JD + 0.5 - $I;
    $A = variant_fix(($I - 1867216.25) / 36524.25);

    if ($I > 2299160){
        $B = $I + 1 + $A - variant_fix($A / 4);}
    else{
        $B = $I;}

    $C = $B + 1524;
    $D = variant_fix(($C - 122.1) / 365.25);
    $E = variant_fix(365.25 * $D);
    $G = variant_fix(($C - $E) / 30.6001);
    $JDCDay = $C - $E + $F - variant_fix(30.6001 * $G);
    return ($JDCDay);
	}

function JDCMonth($JD)
	{
	$I = variant_fix($JD + 0.5);
	$F = $JD + 0.5 - $I;
	$A = variant_fix(($I - 1867216.25) / 36524.25);

	if ($I > 2299160){
		$B = $I + 1 + $A - variant_fix($A / 4);}
	else{
		$B = $I;}

	$C = $B + 1524;
	$D = variant_fix(($C - 122.1) / 365.25);
	$E = variant_fix(365.25 * $D);
	$G = variant_fix(($C - $E) / 30.6001);

	if ($G < 13.5){
		$JDCMonth = $G - 1;}
	else{
		$JDCMonth = $G - 13;}
	return ($JDCMonth);
	}

function JDCYear($JD)
	{
    $I = variant_fix($JD + 0.5);
    $F = $JD + 0.5 - $I;
    $A = variant_fix(($I - 1867216.25) / 36524.25);

    if ($I > 2299160){
        $B = $I + 1 + $A - variant_fix($A / 4);}
    else{
        $B = $I;}

    $C = $B + 1524;
    $D = variant_fix(($C - 122.1) / 365.25);
    $E = variant_fix(365.25 * $D);
    $G = variant_fix(($C - $E) / 30.6001);

    if ($G < 13.5){
        $H = $G - 1;}
    else{
        $H = $G - 13;}

    if ($H > 2.5){
        $JDCYear = $D - 4716;}
    else{
        $JDCYear = $D - 4715;}
	return ($JDCYear);
    }

// Converting hours, minutes and seconds to decimal hours
function HMSDH($Hour, $Minute, $Second)
	{
	$A = abs($Second) / 60;
	$B = (abs($Minute) + $A) / 60;
	$C = abs($Hour) + $B;

	if (($Hour < 0) or ($Minute < 0) or ($Second < 0)){
		$HMSDH = $C * (-1);}
	else{
		$HMSDH = $C;}
	return ($HMSDH);
	}

//Decimal Hours to Hours
function DHHour($DH)
	{
    $A = abs($DH);
    $B = $A * 3600;
    $C = round($B - 60 * variant_fix($B / 60), 2);

    if ($C == 60){
        $D = 0;
        $E = $B + 60;}
    else{
        $D = $C;
        $E = $B;}

    if ($DH < 0){
        $DHHour = variant_fix($E / 3600) * (-1);}
    else{
        $DHHour = variant_fix($E / 3600);}
	return ($DHHour);
	}

function DHMin($DH)
	{
    $A = abs($DH);
    $B = $A * 3600;
    $C = round($B - 60 * variant_fix($B / 60), 2);

    if ($C == 60){
        $D = 0;
        $E = $B + 60;}
    else{
        $D = $C;
        $E = $B;}
        
    $DHMin = fmod(floor($E / 60), 60);
	return($DHMin);
	}

function DHSec($DH)
	{
    $A = abs($DH);
    $B = $A * 3600;
    $C = round($B - 60 * variant_fix($B / 60), 2);
    if ($C == 60){
        $D = 0;}
    else{
        $D = $C;}

    $DHSec = $D;
	return ($DHSec);
	}

// Conversion of Local Civil Time to UT (Universal Time) --- Achtung: hier wird ein Array ausgegeben !!!
function LctUT($Hour, $Minute, $Second, $DS, $ZC, $day, $month, $year)
	{
	$A = HMSDH($Hour, $Minute, $Second); 	//LCT
	$B = $A - $DS - $ZC;                   //UT
	$C = $day + ($B / 24);                 //G day
	$D = CDJD($C, $month, $year);  //JD
	$E = JDCDay($D);                       //G day
	$F = JDCMonth($D);                    //G month
	$G = JDCYear($D);                      //G year
	$E1 = variant_fix($E);
	$LctUT = 24 * ($E - $E1);
	return array($LctUT,$E1,$F,$G);
	}

// Conversion of UT (Universal Time) to Local Civil Time --- Achtung: hier wird ein Array ausgegeben !!!
function UTLct($UH, $UM, $US, $DS, $ZC, $GD, $GM, $GY)
	{
    $A = HMSDH($UH, $UM, $US);
    $B = $A + $ZC;
    $C = $B + $DS;
    $D = CDJD($GD, $GM, $GY) + ($C / 24);
    $E = JDCDay($D);
    $F = JDCMonth($D);
    $G = JDCYear($D);
    $E1 = variant_fix($E);
    $UTLct = 24 * ($E - $E1);
	return array($UTLct,$E1,$F,$G);
	}

//Conversion of UT to GST (Greenwich Sideral Time)
function UTGST($UH, $UM, $US, $GD, $GM, $GY)
	{
    $A = CDJD($GD, $GM, $GY);
    $B = $A - 2451545;
    $C = $B / 36525;
    $D = 6.697374558 + (2400.051336 * $C) + (0.000025862 * $C * $C);
    $E = $D - (24 * variant_int($D / 24));
    $F = HMSDH($UH, $UM, $US);
    $G = $F * 1.002737909;
    $H = $E + $G;
    $UTGST = $H - (24 * variant_int($H / 24));
    return ($UTGST);
	}

//Conversion of GST to UT --- Achtung: hier wird ein Array ausgegeben !!!
function GSTUT($GSH, $GSM, $GSS, $GD, $GM, $GY)
	{
    $A = CDJD($GD, $GM, $GY);
    $B = $A - 2451545;
    $C = $B / 36525;
    $D = 6.697374558 + (2400.051336 * $C) + (0.000025862 * $C * $C);
    $E = $D - (24 * variant_int($D / 24));
    $F = HMSDH($GSH, $GSM, $GSS);
    $G = $F - $E;
    $H = $G - (24 * variant_int($G / 24));
    $GSTUT = $H * 0.9972695663;
    if ($GSTUT < (4 / 60)){
        $eGSTUT = "Warning";}
    else{
        $eGSTUT = "OK";}
    return array($GSTUT,$eGSTUT);
	}

//Conversion of GST to LST (Local Sideral Time)
function GSTLST($GH, $GM, $GS, $L)
	{
    $A = HMSDH($GH, $GM, $GS);
    $B = $L / 15;
    $C = $A + $B;
    $GSTLST = $C - (24 * variant_int($C / 24));
    return ($GSTLST);
	}

//Conversion of LST to GST (Greenwich Sideral Time)
function LSTGST($LH, $LM, $LS, $L)
	{
    $A = HMSDH($LH, $LM, $LS);
    $B = $L / 15;
    $C = $A - $B;
    $LSTGST = $C - (24 * variant_int($C / 24));
    return ($LSTGST);
	}

function UTDayAdjust($UT, $G1)
	{
        $UTDayAdjust = $UT;

        if (($UT - $G1) < -6){
            $UTDayAdjust = $UT + 24;
        		}

        if (($UT - $G1) > 6){
            $UTDayAdjust = $UT - 24;
        		}
	return ($UTDayAdjust);
	}

//Converting degrees, minutes and seconds to decimal degrees
function DMSDD($D, $M, $S)
	{
    $A = abs($S) / 60;
    $B = (abs($M) + $A) / 60;
    $C = abs($D) + $B;

    if (($D < 0) Or ($M < 0) Or ($S < 0)){
        $DMSDD = $C * (-1);}
    else{
        $DMSDD = $C;}
	return ($DMSDD);
	}

//decimal degrees to degrees
function DDDeg($DD)
	{
    $A = abs($DD);
    $B = $A * 3600;
    $C = round($B - 60 * variant_fix($B / 60), 2);

    if ($C == 60){
        $D = 0;
        $E = $B + 60;}
    else{
        $D = $C;
        $E = $B;}

    if ($DD < 0){
        $DDDeg = variant_fix($E / 3600) * (-1);}
    else{
        $DDDeg = variant_fix($E / 3600);}
	return ($DDDeg);
	}

//decimal degrees to minutes
function DDMin($DD)
	{
    $A = abs($DD);
    $B = $A * 3600;
    $C = round($B - 60 * variant_fix($B / 60), 2);

    if ($C == 60){
        $D = 0;
        $E = $B + 60;}
    else{
        $D = $C;
        $E = $B;}

    $DDMin = fmod(floor($E / 60), 60);
	return ($DDMin);
	}

//decimal degrees to seconds
function DDSec($DD)
	{
    $A = abs($DD);
    $B = $A * 3600;
    $C = round($B - 60 * variant_fix($B / 60), 2);
    if ($C == 60){
        $D = 0;}
    else{
        $D = $C;}

    $DDSec = $D;
	return ($DDSec);
	}

//Decimal Degrees to Decimal Hours
function DDDH($DD)
	{
    $DDDH = $DD / 15;
	return ($DDDH);
	}

//Decimal Hours to Decimal Degrees
function DHDD($DH)
	{
    $DHDD = $DH * 15;
	return ($DHDD);
	}

function LctGDay($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)
	{
    $A = HMSDH($LCH, $LCM, $LCS);
    $B = $A - $DS - $ZC;
    $C = $LD + ($B / 24);
    $D = CDJD($C, $LM, $LY);
    $E = JDCDay($D);
    $LctGDay = variant_fix($E);
	return ($LctGDay);
	}

function LctGMonth($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)
	{
    $A = HMSDH($LCH, $LCM, $LCS);
    $B = $A - $DS - $ZC;
    $C = $LD + ($B / 24);
    $D = CDJD($C, $LM, $LY);
    $LctGMonth = JDCMonth($D);
	return ($LctGMonth);
	}

function LctGYear($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)
	{
    $A = HMSDH($LCH, $LCM, $LCS);
    $B = $A - $DS - $ZC;
    $C = $LD + ($B / 24);
    $D = CDJD($C, $LM, $LY);
    $LctGYear = JDCYear($D);
	return ($LctGYear);
	}

//Conversion of right ascension to hour angle
//RH Right Ascension in HMS, LH Local Civil Time in HMS, DS Daylight saving, ZC Zonecorrection,
//LD Local Calender Date in DMY, L geographical Longitude in Degrees
function RAHA($RH, $RM, $RS, $LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY, $L)
	{
    $A = LctUT($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)[0];
    $B = LctGDay($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
    $C = LctGMonth($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
    $D = LctGYear($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
    $E = UTGST($A, 0, 0, $B, $C, $D);
    $F = GSTLST($E, 0, 0, $L);
    $G = HMSDH($RH, $RM, $RS);
    $H = $F - $G;
    if ($H < 0){
        $RAHA = 24 + $H;}
    else{
        $RAHA = $H;}
	return ($RAHA);
	}

//Conversion of hour angle to right ascension
function HARA($HH, $HM, $HS, $LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY, $L)
	{
    $A = LctUT($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)[0];
    $B = LctGDay($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
    $C = LctGMonth($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
    $D = LctGYear($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
    $E = UTGST($A, 0, 0, $B, $C, $D);
    $F = GSTLST($E, 0, 0, $L);
    $G = HMSDH($HH, $HM, $HS);
    $H = $F - $G;
    if ($H < 0){
        $HARA = 24 + $H;}
    else{
        $HARA = $H;}
	return ($HARA);
	}

function Radians($W)
	{
    $Radians = $W * 0.01745329252;
	return ($Radians);
	}

function Degrees($W)
	{
    $Degrees = $W * 57.29577951;
	return ($Degrees);
	}



//Equatorial to Horizon coordinate conversion (Az)
//HH HourAngle in HMS, DD Declination in DMS, P Latitude in decimal Degrees
function EQAz($HH, $HM, $HS, $DD, $DM, $DS, $P)
	{
    $A = HMSDH($HH, $HM, $HS);
    $B = $A * 15;
    $C = Radians($B);
    $D = DMSDD($DD, $DM, $DS);
    $E = Radians($D);
    $F = Radians($P);
    $G = sin($E) * sin($F) + cos($E) * cos($F) * cos($C);
    $H = -cos($E) * cos($F) * sin($C);
    $I = sin($E) - (sin($F) * $G);
    $J = Degrees(atan2($H, $I));
    $EQAz = $J - 360 * variant_int($J / 360);
	return ($EQAz);
	}

////Equatorial to Horizon coordinate conversion (Alt)
function EQAlt($HH, $HM, $HS, $DD, $DM, $DS, $P)
	{
    $A = HMSDH($HH, $HM, $HS);
    $B = $A * 15;
    $C = Radians($B);
    $D = DMSDD($DD, $DM, $DS);
    $E = Radians($D);
    $F = Radians($P);
    $G = sin($E) * sin($F) + cos($E) * cos($F) * cos($C);
    $EQAlt = Degrees(asin($G));
	return ($EQAlt);
	}

function HORDec($AZD, $AZM, $AZS, $ALD, $ALM, $ALS, $P)
	{
    $A = DMSDD($AZD, $AZM, $AZS);
    $B = DMSDD($ALD, $ALM, $ALS);
    $C = Radians($A);
    $D = Radians($B);
    $E = Radians($P);
    $F = sin($D) * sin($E) + cos($D) * cos($E) * cos($C);
    $HORDec = Degrees(asin($F));
	return ($HORDec);
	}

function HORHa($AZD, $AZM, $AZS, $ALD, $ALM, $ALS, $P)
	{
    $A = DMSDD($AZD, $AZM, $AZS);
    $B = DMSDD($ALD, $ALM, $ALS);
    $C = Radians($A);
    $D = Radians($B);
    $E = Radians($P);
    $F = sin($D) * sin($E) + cos($D) * cos($E) * cos($C);
    $G = -cos($D) * cos($E) * sin($C);
    $H = sin($D) - sin($E) * $F;
    $I = DDDH(Degrees(atan2($G, $H)));
    $HORHa = $I - 24 * variant_int($I / 24);
	return ($HORHa);
	}

function Obliq($GD, $GM, $GY)
	{
    $A = CDJD($GD, $GM, $GY);
    $B = $A - 2415020;
    $C = ($B / 36525) - 1;
    $D = $C * (46.815 + $C * (0.0006 - ($C * 0.00181)));
    $E = $D / 3600;
    $Obliq = 23.43929167 - $E + NutatObl($GD, $GM, $GY);
	return ($Obliq);
	}

function ECDec($ELD, $ELM, $ELS, $BD, $BM, $BS, $GD, $GM, $GY)
	{
    $A = Radians(DMSDD($ELD, $ELM, $ELS));      				//eclon
    $B = Radians(DMSDD($BD, $BM, $BS));         				//eclat
    $C = Radians(Obliq($GD, $GM, $GY));         				//obliq
    $D = sin($B) * cos($C) + cos($B) * sin($C) * sin($A);   //sin Dec
    $ECDec = Degrees(asin($D));                             //Dec Deg
	return ($ECDec);
	}

function ECRA($ELD, $ELM, $ELS, $BD, $BM, $BS, $GD, $GM, $GY)
	{
    $A = Radians(DMSDD($ELD, $ELM, $ELS));   	//eclon
    $B = Radians(DMSDD($BD, $BM, $BS));      	//eclat
    $C = Radians(Obliq($GD, $GM, $GY));      	//obliq
    $D = sin($A) * cos($C) - tan($B) * sin($C); //y
    $E = cos($A);                            	//x
    $F = Degrees(atan2($D, $E));                //RA Deg
    $ECRA = $F - 360 * variant_int($F / 360);   //RA Deg
	return ($ECRA);
	}

function EQElat($RAH, $RAM, $RAS, $DD, $DM, $DS, $GD, $GM, $GY)
	{
    $A = Radians(DHDD(HMSDH($RAH, $RAM, $RAS)));
    $B = Radians(DMSDD($DD, $DM, $DS));
    $C = Radians(Obliq($GD, $GM, $GY));
    $D = sin($B) * cos($C) - cos($B) * sin($C) * sin($A);
    $EQElat = Degrees(asin($D));
	return ($EQElat);
	}

function EQElong($RAH, $RAM, $RAS, $DD, $DM, $DS, $GD, $GM, $GY)
	{
    $A = Radians(DHDD(HMSDH($RAH, $RAM, $RAS)));
    $B = Radians(DMSDD($DD, $DM, $DS));
    $C = Radians(Obliq($GD, $GM, $GY));
    $D = sin($A) * cos($C) + tan($B) * sin($C);
    $E = cos($A);
    $F = Degrees(atan2($D, $E));
    $EQElong = $F - 360 * variant_int($F / 360);
	return ($EQElong);
	}

function EQGlong($RAH, $RAM, $RAS, $DD, $DM, $DS)
	{
    $A = Radians(DHDD(HMSDH($RAH, $RAM, $RAS)));
    $B = Radians(DMSDD($DD, $DM, $DS));
    $C = cos(Radians(27.4));
    $D = sin(Radians(27.4));
    $E = Radians(192.25);
    $F = cos($B) * $C * cos($A - $E) + sin($B) * $D;
    $G = sin($B) - $F * $D;
    $H = cos($B) * sin($A - $E) * $C;
    $I = Degrees(atan2($G, $H)) + 33;
    $EQGlong = $I - 360 * variant_int($I / 360);
	return ($EQGlong);
	}

function EQGlat($RAH, $RAM, $RAS, $DD, $DM, $DS)
	{
    $A = Radians(DHDD(HMSDH($RAH, $RAM, $RAS)));
    $B = Radians(DMSDD($DD, $DM, $DS));
    $C = cos(Radians(27.4));
    $D = sin(Radians(27.4));
    $E = Radians(192.25);
    $F = cos($B) * $C * cos($A - $E) + sin($B) * $D;
    $EQGlat = Degrees(asin($F));
	return ($EQGlat);
	}

function EqOfTime($GD, $GM, $GY)
	{
    $A = SunLong(12, 0, 0, 0, 0, $GD, $GM, $GY);
    $B = DDDH(ECRA($A, 0, 0, 0, 0, 0, $GD, $GM, $GY));
    $C = GSTUT($B, 0, 0, $GD, $GM, $GY)[0];
    $EqOfTime = $C - 12;
	return ($EqOfTime);
	}

function NutatLong($GD, $GM, $GY)
	{
	$DJ = CDJD($GD, $GM, $GY) - 2415020;
	$T = $DJ / 36525;
	$T2 = $T * $T;
	$A = 100.0021358 * $T;
	$B = 360 * ($A - variant_int($A));
	$L1 = 279.6967 + 0.000303 * $T2 + $B;
	$l2 = 2 * Radians($L1);
	$A = 1336.855231 * $T;
	$B = 360 * ($A - variant_int($A));
	$D1 = 270.4342 - 0.001133 * $T2 + $B;
	$D2 = 2 * Radians($D1);
	$A = 99.99736056 * $T;
	$B = 360 * ($A - variant_int($A));
	$M1 = 358.4758 - 0.00015 * $T2 + $B;
	$M1 = Radians($M1);
	$A = 1325.552359 * $T;
	$B = 360 * ($A - variant_int($A));
	$M2 = 296.1046 + 0.009192 * $T2 + $B;
	$M2 = Radians($M2);
	$A = 5.372616667 * $T;
	$B = 360 * ($A - variant_int($A));
	$N1 = 259.1833 + 0.002078 * $T2 - $B;
	$N1 = Radians($N1);
	$N2 = 2 * $N1;

	$DP = (-17.2327 - 0.01737 * $T) * sin($N1);
	$DP = $DP + (-1.2729 - 0.00013 * $T) * sin($l2) + 0.2088 * sin($N2);
	$DP = $DP - 0.2037 * sin($D2) + (0.1261 - 0.00031 * $T) * sin($M1);
	$DP = $DP + 0.0675 * sin($M2) - (0.0497 - 0.00012 * $T) * sin($l2 + $M1);
	$DP = $DP - 0.0342 * sin($D2 - $N1) - 0.0261 * sin($D2 + $M2);
	$DP = $DP + 0.0214 * sin($l2 - $M1) - 0.0149 * sin($l2 - $D2 + $M2);
	$DP = $DP + 0.0124 * sin($l2 - $N1) + 0.0114 * sin($D2 - $M2);

	$NutatLong = $DP / 3600;
	return ($NutatLong);
	}

function NutatObl($GD, $GM, $GY)
	{
   $DJ = CDJD($GD, $GM, $GY) - 2415020;
	$T = $DJ / 36525;
	$T2 = $T * $T;
   $A = 100.0021358 * $T;
	$B = 360 * ($A - variant_int($A));
   $L1 = 279.6967 + 0.000303 * $T2 + $B;
	$l2 = 2 * Radians($L1);
   $A = 1336.855231 * $T;
	$B = 360 * ($A - variant_int($A));
   $D1 = 270.4342 - 0.001133 * $T2 + $B;
	$D2 = 2 * Radians($D1);
   $A = 99.99736056 * $T;
	$B = 360 * ($A - variant_int($A));
   $M1 = 358.4758 - 0.00015 * $T2 + $B;
	$M1 = Radians($M1);
   $A = 1325.552359 * $T;
	$B = 360 * ($A - variant_int($A));
   $M2 = 296.1046 + 0.009192 * $T2 + $B;
	$M2 = Radians($M2);
   $A = 5.372616667 * $T;
	$B = 360 * ($A - variant_int($A));
   $N1 = 259.1833 + 0.002078 * $T2 - $B;
	$N1 = Radians($N1);
   $N2 = 2 * $N1;

   $DDO = (9.21 + 0.00091 * $T) * cos($N1);
   $DDO = $DDO + (0.5522 - 0.00029 * $T) * cos($l2) - 0.0904 * cos($N2);
   $DDO = $DDO + 0.0884 * cos($D2) + 0.0216 * cos($l2 + $M1);
   $DDO = $DDO + 0.0183 * cos($D2 - $N1) + 0.0113 * cos($D2 + $M2);
   $DDO = $DDO - 0.0093 * cos($l2 - $M1) - 0.0066 * cos($l2 - $N1);

   $NutatObl = $DDO / 3600;
   return ($NutatObl);
	}

function MoonDist($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)
	{
        $HP = Radians(MoonHP($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR));
        $R = 6378.14 / sin($HP);
        $MoonDist = $R;
	return ($MoonDist);
	}

function MoonSize($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)
	{
        $HP = Radians(MoonHP($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR));
        $R = 6378.14 / sin($HP);
        $TH = 384401 * 0.5181 / $R;
        $MoonSize = $TH;
	return ($MoonSize);
	}

function sign($number) {
    return ($number > 0) ? 1 : (($number < 0) ? -1 : 0);
}

function IINT($W)
	{
        $IINT = sign($W) * variant_int(abs($W));
	return ($IINT);
	}

function LINT($W)
	{
        $LINT = IINT($W) + IINT(((1 * sign($W)) - 1) / 2);
   return ($LINT);
	}

function FRACT($W)
	{
        $FRACT = $W - LINT($W);
	return ($FRACT);
	}

function FullMoon($DS, $ZC, $DY, $MN, $YR)
	{
        $D0 = LctGDay(12, 0, 0, $DS, $ZC, $DY, $MN, $YR);
        $M0 = LctGMonth(12, 0, 0, $DS, $ZC, $DY, $MN, $YR);
        $Y0 = LctGYear(12, 0, 0, $DS, $ZC, $DY, $MN, $YR);

        if ($Y0 < 0){
            $Y0 = $Y0 + 1;}

        $J0 = CDJD(0, 1, $Y0) - 2415020;
        $DJ = CDJD($D0, $M0, $Y0) - 2415020;
        $K = LINT((($Y0 - 1900 + (($DJ - $J0) / 365)) * 12.3685) + 0.5);
        $TN = $K / 1236.85;
		  $TF = ($K + 0.5) / 1236.85;
        $T = $TN;
		  $T2 = $T * $T;
		  $E = 29.53 * $K;
		  $C = 166.56 + (132.87 - 0.009173 * $T) * $T;
        $C = Radians($C);
		  $B = 0.00058868 * $K + (0.0001178 - 0.000000155 * $T) * $T2;
        $B = $B + 0.00033 * sin($C) + 0.75933;
		  $A = $K / 12.36886;
        $A1 = 359.2242 + 360 * FRACT($A) - (0.0000333 + 0.00000347 * $T) * $T2;
        $A2 = 306.0253 + 360 * FRACT($K / 0.9330851);
        $A2 = $A2 + (0.0107306 + 0.00001236 * $T) * $T2;
		  $A = $K / 0.9214926;
        $F = 21.2964 + 360 * FRACT($A) - (0.0016528 + 0.00000239 * $T) * $T2;
        $A1 = UnwindDeg($A1);
		  $A2 = UnwindDeg($A2);
		  $F = UnwindDeg($F);
        $A1 = Radians($A1);
		  $A2 = Radians($A2);
		  $F = Radians($F);

        $DD = (0.1734 - 0.000393 * $T) * sin($A1) + 0.0021 * sin(2 * $A1);
        $DD = $DD - 0.4068 * sin($A2) + 0.0161 * sin(2 * $A2) - 0.0004 * sin(3 * $A2);
        $DD = $DD + 0.0104 * sin(2 * $F) - 0.0051 * sin($A1 + $A2);
        $DD = $DD - 0.0074 * sin($A1 - $A2) + 0.0004 * sin(2 * $F + $A1);
        $DD = $DD - 0.0004 * sin(2 * $F - $A1) - 0.0006 * sin(2 * $F + $A2) + 0.001 * sin(2 * $F - $A2);
        $DD = $DD + 0.0005 * sin($A1 + 2 * $A2);
		  $E1 = variant_int($E);
		  $B = $B + $DD + ($E - $E1);
        $B1 = variant_int($B);
		  $A = $E1 + $B1;
		  $B = $B - $B1;
		  $NI = $A;
		  $NF = $B;
		  $NB = $F;
        $T = $TF;
		  $K = $K + 0.5;
		  $T2 = $T * $T;
		  $E = 29.53 * $K;
		  $C = 166.56 + (132.87 - 0.009173 * $T) * $T;
        $C = Radians($C);
		  $B = 0.00058868 * $K + (0.0001178 - 0.000000155 * $T) * $T2;
        $B = $B + 0.00033 * sin($C) + 0.75933;
		  $A = $K / 12.36886;
        $A1 = 359.2242 + 360 * FRACT($A) - (0.0000333 + 0.00000347 * $T) * $T2;
        $A2 = 306.0253 + 360 * FRACT($K / 0.9330851);
        $A2 = $A2 + (0.0107306 + 0.00001236 * $T) * $T2;
		  $A = $K / 0.9214926;
        $F = 21.2964 + 360 * FRACT($A) - (0.0016528 + 0.00000239 * $T) * $T2;
        $A1 = UnwindDeg($A1);
		  $A2 = UnwindDeg($A2);
		  $F = UnwindDeg($F);
        $A1 = Radians($A1);
		  $A2 = Radians($A2);
		  $F = Radians($F);

        $DD = (0.1734 - 0.000393 * $T) * sin($A1) + 0.0021 * sin(2 * $A1);
        $DD = $DD - 0.4068 * sin($A2) + 0.0161 * sin(2 * $A2) - 0.0004 * sin(3 * $A2);
        $DD = $DD + 0.0104 * sin(2 * $F) - 0.0051 * sin($A1 + $A2);
        $DD = $DD - 0.0074 * sin($A1 - $A2) + 0.0004 * sin(2 * $F + $A1);
        $DD = $DD - 0.0004 * sin(2 * $F - $A1) - 0.0006 * sin(2 * $F + $A2) + 0.001 * sin(2 * $F - $A2);
        $DD = $DD + 0.0005 * sin($A1 + 2 * $A2);
		  $E1 = variant_int($E);
		  $B = $B + $DD + ($E - $E1);
        $B1 = variant_int($B);
		  $A = $E1 + $B1;
		  $B = $B - $B1;
		  $FI = $A;
		  $FF = $B;
		  $FB = $F;
		  $FullMoon = $FI + 2415020 + $FF;
	return ($FullMoon);
	}

function Fpart($W)
	{
        $Fpart = $W - LINT($W);
	return ($Fpart);
	}

function MoonHP($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)
	{
        $UT = LctUT($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)[0];
        $GD = LctGDay($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GM = LctGMonth($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GY = LctGYear($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $T = ((CDJD($GD, $GM, $GY) - 2415020) / 36525) + ($UT / 876600);
        $T2 = $T * $T;

        $M1 = 27.32158213;
		  $M2 = 365.2596407;
		  $M3 = 27.55455094;
        $M4 = 29.53058868;
		  $M5 = 27.21222039;
		  $M6 = 6798.363307;
        $Q = CDJD($GD, $GM, $GY) - 2415020 + ($UT / 24);
        $M1 = $Q / $M1;
		  $M2 = $Q / $M2;
		  $M3 = $Q / $M3;
        $M4 = $Q / $M4;
		  $M5 = $Q / $M5;
		  $M6 = $Q / $M6;
        $M1 = 360 * ($M1 - variant_int($M1));
		  $M2 = 360 * ($M2 - variant_int($M2));
        $M3 = 360 * ($M3 - variant_int($M3));
		  $M4 = 360 * ($M4 - variant_int($M4));
        $M5 = 360 * ($M5 - variant_int($M5));
		  $M6 = 360 * ($M6 - variant_int($M6));

        $ML = 270.434164 + $M1 - (0.001133 - 0.0000019 * $T) * $T2;
        $MS = 358.475833 + $M2 - (0.00015 + 0.0000033 * $T) * $T2;
        $MD = 296.104608 + $M3 + (0.009192 + 0.0000144 * $T) * $T2;
        $ME1 = 350.737486 + $M4 - (0.001436 - 0.0000019 * $T) * $T2;
        $MF = 11.250889 + $M5 - (0.003211 + 0.0000003 * $T) * $T2;
        $NA = 259.183275 - $M6 + (0.002078 + 0.0000022 * $T) * $T2;
        $A = Radians(51.2 + 20.2 * $T);
		  $S1 = sin($A);
		  $S2 = sin(Radians($NA));
        $B = 346.56 + (132.87 - 0.0091731 * $T) * $T;
        $S3 = 0.003964 * sin(Radians($B));
        $C = Radians($NA + 275.05 - 2.3 * $T);
		  $S4 = sin($C);
        $ML = $ML + 0.000233 * $S1 + $S3 + 0.001964 * $S2;
        $MS = $MS - 0.001778 * $S1;
        $MD = $MD + 0.000817 * $S1 + $S3 + 0.002541 * $S2;
        $MF = $MF + $S3 - 0.024691 * $S2 - 0.004328 * $S4;
        $ME1 = $ME1 + 0.002011 * $S1 + $S3 + 0.001964 * $S2;
        $E = 1 - (0.002495 + 0.00000752 * $T) * $T;
		  $E2 = $E * $E;
        $ML = Radians($ML);
		  $MS = Radians($MS);
		  $NA = Radians($NA);
        $ME1 = Radians($ME1);
		  $MF = Radians($MF);
		  $MD = Radians($MD);

        $PM = 0.950724 + 0.051818 * cos($MD) + 0.009531 * cos(2 * $ME1 - $MD);
        $PM = $PM + 0.007843 * cos(2 * $ME1) + 0.002824 * cos(2 * $MD);
        $PM = $PM + 0.000857 * cos(2 * $ME1 + $MD) + $E * 0.000533 * cos(2 * $ME1 - $MS);
        $PM = $PM + $E * 0.000401 * cos(2 * $ME1 - $MD - $MS);
        $PM = $PM + $E * 0.00032 * cos($MD - $MS) - 0.000271 * cos($ME1);
        $PM = $PM - $E * 0.000264 * cos($MS + $MD) - 0.000198 * cos(2 * $MF - $MD);
        $PM = $PM + 0.000173 * cos(3 * $MD) + 0.000167 * cos(4 * $ME1 - $MD);
        $PM = $PM - $E * 0.000111 * cos($MS) + 0.000103 * cos(4 * $ME1 - 2 * $MD);
        $PM = $PM - 0.000084 * cos(2 * $MD - 2 * $ME1) - $E * 0.000083 * cos(2 * $ME1 + $MS);
        $PM = $PM + 0.000079 * cos(2 * $ME1 + 2 * $MD) + 0.000072 * cos(4 * $ME1);
        $PM = $PM + $E * 0.000064 * cos(2 * $ME1 - $MS + $MD) - $E * 0.000063 * cos(2 * $ME1 + $MS - $MD);
        $PM = $PM + $E * 0.000041 * cos($MS + $ME1) + $E * 0.000035 * cos(2 * $MD - $MS);
        $PM = $PM - 0.000033 * cos(3 * $MD - 2 * $ME1) - 0.00003 * cos($MD + $ME1);
        $PM = $PM - 0.000029 * cos(2 * ($MF - $ME1)) - $E * 0.000029 * cos(2 * $MD + $MS);
        $PM = $PM + $E2 * 0.000026 * cos(2 * ($ME1 - $MS)) - 0.000023 * cos(2 * ($MF - $ME1) + $MD);
        $PM = $PM + $E * 0.000019 * cos(4 * $ME1 - $MS - $MD);

        $MoonHP = $PM;
	return ($MoonHP);
	}

function CRN($GD, $GM, $GY)
	{
    $A = CDJD($GD, $GM, $GY);
    $CRN = 1690 + round(($A - 2444235.34) / 27.2753, 0);
	return ($CRN);
	}

function UnwindDeg($W)
	{
        $UnwindDeg = $W - 360 * variant_int($W / 360);
	return ($UnwindDeg);
	}

function UnwindRad($W)
	{
    $UnwindRad = $W - 6.283185308 * variant_int($W / 6.283185308);
	return ($UnwindRad);
	}

function Unwind($W)
	{
    $Unwind = $W - 6.283185308 * variant_int($W / 6.283185308);
	return ($Unwind);
	}

function MoonMeanAnomaly($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)
	{
        $UT = LctUT($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)[0];
        $GD = LctGDay($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GM = LctGMonth($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GY = LctGYear($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $T = ((CDJD($GD, $GM, $GY) - 2415020) / 36525) + ($UT / 876600);
        $T2 = $T * $T;

        $M1 = 27.32158213;
		  $M2 = 365.2596407;
		  $M3 = 27.55455094;
        $M4 = 29.53058868;
		  $M5 = 27.21222039;
		  $M6 = 6798.363307;
        $Q = CDJD($GD, $GM, $GY) - 2415020 + ($UT / 24);
        $M1 = $Q / $M1;
		  $M2 = $Q / $M2;
		  $M3 = $Q / $M3;
        $M4 = $Q / $M4;
		  $M5 = $Q / $M5;
		  $M6 = $Q / $M6;
        $M1 = 360 * ($M1 - variant_int($M1));
		  $M2 = 360 * ($M2 - variant_int($M2));
        $M3 = 360 * ($M3 - variant_int($M3));
		  $M4 = 360 * ($M4 - variant_int($M4));
        $M5 = 360 * ($M5 - variant_int($M5));
		  $M6 = 360 * ($M6 - variant_int($M6));

        $ML = 270.434164 + $M1 - (0.001133 - 0.0000019 * $T) * $T2;
        $MS = 358.475833 + $M2 - (0.00015 + 0.0000033 * $T) * $T2;
        $MD = 296.104608 + $M3 + (0.009192 + 0.0000144 * $T) * $T2;
        $ME1 = 350.737486 + $M4 - (0.001436 - 0.0000019 * $T) * $T2;
        $MF = 11.250889 + $M5 - (0.003211 + 0.0000003 * $T) * $T2;
        $NA = 259.183275 - $M6 + (0.002078 + 0.0000022 * $T) * $T2;
        $A = Radians(51.2 + 20.2 * $T);
		  $S1 = sin($A);
		  $S2 = sin(Radians($NA));
        $B = 346.56 + (132.87 - 0.0091731 * $T) * $T;
        $S3 = 0.003964 * sin(Radians($B));
        $C = Radians($NA + 275.05 - 2.3 * $T);
		  $S4 = sin($C);
        $ML = $ML + 0.000233 * $S1 + $S3 + 0.001964 * $S2;
        $MS = $MS - 0.001778 * $S1;
        $MD = $MD + 0.000817 * $S1 + $S3 + 0.002541 * $S2;

        $MoonMeanAnomaly = Radians($MD);
	return ($MoonMeanAnomaly);
	}

function MoonPhase($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)
	{
        $CD = cos(Radians(MoonLong($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR) - SunLong($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR))) * cos(Radians(MoonLat($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)));
        $D = acos($CD);
        $SD = sin($D);
        $I = 0.1468 * $SD * (1 - 0.0549 * sin(MoonMeanAnomaly($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)));
        $I = $I / (1 - 0.0167 * sin(SunMeanAnomaly($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)));
        $I = 3.141592654 - $D - Radians($I);
        $K = (1 + cos($I)) / 2;
        $MoonPhase = number_format($K*100,1,',',''); //*100 is %
	return ($MoonPhase);
	}

function MoonPABL($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)
	{
        $GD = LctGDay($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GM = LctGMonth($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GY = LctGYear($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $LLS = SunLong($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $LLM = MoonLong($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $BM = MoonLat($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $RAS = Radians(ECRA($LLS, 0, 0, 0, 0, 0, $GD, $GM, $GY));
        $RAM = Radians(ECRA($LLM, 0, 0, $BM, 0, 0, $GD, $GM, $GY));
        $DDS = Radians(ECDec($LLS, 0, 0, 0, 0, 0, $GD, $GM, $GY));
        $DM = Radians(ECDec($LLM, 0, 0, $BM, 0, 0, $GD, $GM, $GY));
        $Y = cos($DDS) * sin($RAS - $RAM);
        $X = cos($DM) * sin($DDS) - sin($DM) * cos($DDS) * cos($RAS - $RAM);
        $CHI = atan2($Y, $X);

        $MoonPABL = Degrees($CHI);
	return ($MoonPABL);
	}

function MoonLong($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)
	{
        $UT = LctUT($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)[0];
        $GD = LctGDay($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GM = LctGMonth($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GY = LctGYear($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $T = ((CDJD($GD, $GM, $GY) - 2415020) / 36525) + ($UT / 876600);
        $T2 = $T * $T;

        $M1 = 27.32158213;
		  $M2 = 365.2596407;
		  $M3 = 27.55455094;
        $M4 = 29.53058868;
		  $M5 = 27.21222039;
		  $M6 = 6798.363307;
        $Q = CDJD($GD, $GM, $GY) - 2415020 + ($UT / 24);
        $M1 = $Q / $M1;
		  $M2 = $Q / $M2;
		  $M3 = $Q / $M3;
        $M4 = $Q / $M4;
		  $M5 = $Q / $M5;
		  $M6 = $Q / $M6;
        $M1 = 360 * ($M1 - variant_int($M1));
		  $M2 = 360 * ($M2 - variant_int($M2));
        $M3 = 360 * ($M3 - variant_int($M3));
		  $M4 = 360 * ($M4 - variant_int($M4));
        $M5 = 360 * ($M5 - variant_int($M5));
		  $M6 = 360 * ($M6 - variant_int($M6));

        $ML = 270.434164 + $M1 - (0.001133 - 0.0000019 * $T) * $T2;
        $MS = 358.475833 + $M2 - (0.00015 + 0.0000033 * $T) * $T2;
        $MD = 296.104608 + $M3 + (0.009192 + 0.0000144 * $T) * $T2;
        $ME1 = 350.737486 + $M4 - (0.001436 - 0.0000019 * $T) * $T2;
        $MF = 11.250889 + $M5 - (0.003211 + 0.0000003 * $T) * $T2;
        $NA = 259.183275 - $M6 + (0.002078 + 0.0000022 * $T) * $T2;
        $A = Radians(51.2 + 20.2 * $T);
		  $S1 = sin($A);
		  $S2 = sin(Radians($NA));
        $B = 346.56 + (132.87 - 0.0091731 * $T) * $T;
        $S3 = 0.003964 * Sin(Radians($B));
        $C = Radians($NA + 275.05 - 2.3 * $T);
		  $S4 = sin($C);
        $ML = $ML + 0.000233 * $S1 + $S3 + 0.001964 * $S2;
        $MS = $MS - 0.001778 * $S1;
        $MD = $MD + 0.000817 * $S1 + $S3 + 0.002541 * $S2;
        $MF = $MF + $S3 - 0.024691 * $S2 - 0.004328 * $S4;
        $ME1 = $ME1 + 0.002011 * $S1 + $S3 + 0.001964 * $S2;
        $E = 1 - (0.002495 + 0.00000752 * $T) * $T;
		  $E2 = $E * $E;
        $ML = Radians($ML);
		  $MS = Radians($MS);
		  $NA = Radians($NA);
        $ME1 = Radians($ME1);
		  $MF = Radians($MF);
		  $MD = Radians($MD);

        $L = 6.28875 * sin($MD) + 1.274018 * sin(2 * $ME1 - $MD);
        $L = $L + 0.658309 * sin(2 * $ME1) + 0.213616 * sin(2 * $MD);
        $L = $L - $E * 0.185596 * sin($MS) - 0.114336 * sin(2 * $MF);
        $L = $L + 0.058793 * sin(2 * ($ME1 - $MD));
        $L = $L + 0.057212 * $E * sin(2 * $ME1 - $MS - $MD) + 0.05332 * sin(2 * $ME1 + $MD);
        $L = $L + 0.045874 * $E * sin(2 * $ME1 - $MS) + 0.041024 * $E * sin($MD - $MS);
        $L = $L - 0.034718 * sin($ME1) - $E * 0.030465 * sin($MS + $MD);
        $L = $L + 0.015326 * sin(2 * ($ME1 - $MF)) - 0.012528 * sin(2 * $MF + $MD);
        $L = $L - 0.01098 * sin(2 * $MF - $MD) + 0.010674 * sin(4 * $ME1 - $MD);
        $L = $L + 0.010034 * sin(3 * $MD) + 0.008548 * sin(4 * $ME1 - 2 * $MD);
        $L = $L - $E * 0.00791 * sin($MS - $MD + 2 * $ME1) - $E * 0.006783 * sin(2 * $ME1 + $MS);
        $L = $L + 0.005162 * sin($MD - $ME1) + $E * 0.005 * sin($MS + $ME1);
        $L = $L + 0.003862 * sin(4 * $ME1) + $E * 0.004049 * sin($MD - $MS + 2 * $ME1);
        $L = $L + 0.003996 * sin(2 * ($MD + $ME1)) + 0.003665 * sin(2 * $ME1 - 3 * $MD);
        $L = $L + $E * 0.002695 * sin(2 * $MD - $MS) + 0.002602 * sin($MD - 2 * ($MF + $ME1));
        $L = $L + $E * 0.002396 * sin(2 * ($ME1 - $MD) - $MS) - 0.002349 * sin($MD + $ME1);
        $L = $L + $E2 * 0.002249 * sin(2 * ($ME1 - $MS)) - $E * 0.002125 * sin(2 * $MD + $MS);
        $L = $L - $E2 * 0.002079 * sin(2 * $MS) + $E2 * 0.002059 * sin(2 * ($ME1 - $MS) - $MD);
        $L = $L - 0.001773 * sin($MD + 2 * ($ME1 - $MF)) - 0.001595 * sin(2 * ($MF + $ME1));
        $L = $L + $E * 0.00122 * sin(4 * $ME1 - $MS - $MD) - 0.00111 * sin(2 * ($MD + $MF));
        $L = $L + 0.000892 * sin($MD - 3 * $ME1) - $E * 0.000811 * sin($MS + $MD + 2 * $ME1);
        $L = $L + $E * 0.000761 * sin(4 * $ME1 - $MS - 2 * $MD);
        $L = $L + $E2 * 0.000704 * sin($MD - 2 * ($MS + $ME1));
        $L = $L + $E * 0.000693 * sin($MS - 2 * ($MD - $ME1));
        $L = $L + $E * 0.000598 * sin(2 * ($ME1 - $MF) - $MS);
        $L = $L + 0.00055 * sin($MD + 4 * $ME1) + 0.000538 * sin(4 * $MD);
        $L = $L + $E * 0.000521 * sin(4 * $ME1 - $MS) + 0.000486 * sin(2 * $MD - $ME1);
        $L = $L + $E2 * 0.000717 * sin($MD - 2 * $MS);
        $MM = Unwind($ML + Radians($L));

        $MoonLong = Degrees($MM);
	return ($MoonLong);
	}

Function MoonLat($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)
	{
        $UT = LctUT($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)[0];
        $GD = LctGDay($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GM = LctGMonth($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GY = LctGYear($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $T = ((CDJD($GD, $GM, $GY) - 2415020) / 36525) + ($UT / 876600);
        $T2 = $T * $T;

        $M1 = 27.32158213;
		  $M2 = 365.2596407;
		  $M3 = 27.55455094;
        $M4 = 29.53058868;
		  $M5 = 27.21222039;
		  $M6 = 6798.363307;
        $Q = CDJD($GD, $GM, $GY) - 2415020 + ($UT / 24);
        $M1 = $Q / $M1;
		  $M2 = $Q / $M2;
		  $M3 = $Q / $M3;
        $M4 = $Q / $M4;
		  $M5 = $Q / $M5;
		  $M6 = $Q / $M6;
        $M1 = 360 * ($M1 - variant_int($M1));
		  $M2 = 360 * ($M2 - variant_int($M2));
        $M3 = 360 * ($M3 - variant_int($M3));
		  $M4 = 360 * ($M4 - variant_int($M4));
        $M5 = 360 * ($M5 - variant_int($M5));
		  $M6 = 360 * ($M6 - variant_int($M6));

        $ML = 270.434164 + $M1 - (0.001133 - 0.0000019 * $T) * $T2;
        $MS = 358.475833 + $M2 - (0.00015 + 0.0000033 * $T) * $T2;
        $MD = 296.104608 + $M3 + (0.009192 + 0.0000144 * $T) * $T2;
        $ME1 = 350.737486 + $M4 - (0.001436 - 0.0000019 * $T) * $T2;
        $MF = 11.250889 + $M5 - (0.003211 + 0.0000003 * $T) * $T2;
        $NA = 259.183275 - $M6 + (0.002078 + 0.0000022 * $T) * $T2;
        $A = Radians(51.2 + 20.2 * $T);
		  $S1 = sin($A);
		  $S2 = sin(Radians($NA));
        $B = 346.56 + (132.87 - 0.0091731 * $T) * $T;
        $S3 = 0.003964 * sin(Radians($B));
        $C = Radians($NA + 275.05 - 2.3 * $T);
		  $S4 = sin($C);
        $ML = $ML + 0.000233 * $S1 + $S3 + 0.001964 * $S2;
        $MS = $MS - 0.001778 * $S1;
        $MD = $MD + 0.000817 * $S1 + $S3 + 0.002541 * $S2;
        $MF = $MF + $S3 - 0.024691 * $S2 - 0.004328 * $S4;
        $ME1 = $ME1 + 0.002011 * $S1 + $S3 + 0.001964 * $S2;
        $E = 1 - (0.002495 + 0.00000752 * $T) * $T;
		  $E2 = $E * $E;
        $ML = Radians($ML);
		  $MS = Radians($MS);
		  $NA = Radians($NA);
        $ME1 = Radians($ME1);
		  $MF = Radians($MF);
		  $MD = Radians($MD);

        $G = 5.128189 * sin($MF) + 0.280606 * sin($MD + $MF);
        $G = $G + 0.277693 * sin($MD - $MF) + 0.173238 * sin(2 * $ME1 - $MF);
        $G = $G + 0.055413 * sin(2 * $ME1 + $MF - $MD) + 0.046272 * sin(2 * $ME1 - $MF - $MD);
        $G = $G + 0.032573 * sin(2 * $ME1 + $MF) + 0.017198 * sin(2 * $MD + $MF);
        $G = $G + 0.009267 * sin(2 * $ME1 + $MD - $MF) + 0.008823 * sin(2 * $MD - $MF);
        $G = $G + $E * 0.008247 * sin(2 * $ME1 - $MS - $MF) + 0.004323 * sin(2 * ($ME1 - $MD) - $MF);
        $G = $G + 0.0042 * sin(2 * $ME1 + $MF + $MD) + $E * 0.003372 * sin($MF - $MS - 2 * $ME1);
        $G = $G + $E * 0.002472 * sin(2 * $ME1 + $MF - $MS - $MD);
        $G = $G + $E * 0.002222 * sin(2 * $ME1 + $MF - $MS);
        $G = $G + $E * 0.002072 * sin(2 * $ME1 - $MF - $MS - $MD);
        $G = $G + $E * 0.001877 * sin($MF - $MS + $MD) + 0.001828 * sin(4 * $ME1 - $MF - $MD);
        $G = $G - $E * 0.001803 * sin($MF + $MS) - 0.00175 * sin(3 * $MF);
        $G = $G + $E * 0.00157 * sin($MD - $MS - $MF) - 0.001487 * sin($MF + $ME1);
        $G = $G - $E * 0.001481 * sin($MF + $MS + $MD) + $E * 0.001417 * sin($MF - $MS - $MD);
        $G = $G + $E * 0.00135 * sin($MF - $MS) + 0.00133 * sin($MF - $ME1);
        $G = $G + 0.001106 * sin($MF + 3 * $MD) + 0.00102 * sin(4 * $ME1 - $MF);
        $G = $G + 0.000833 * sin($MF + 4 * $ME1 - $MD) + 0.000781 * sin($MD - 3 * $MF);
        $G = $G + 0.00067 * sin($MF + 4 * $ME1 - 2 * $MD) + 0.000606 * sin(2 * $ME1 - 3 * $MF);
        $G = $G + 0.000597 * sin(2 * ($ME1 + $MD) - $MF);
        $G = $G + $E * 0.000492 * sin(2 * $ME1 + $MD - $MS - $MF) + 0.00045 * sin(2 * ($MD - $ME1) - $MF);
        $G = $G + 0.000439 * sin(3 * $MD - $MF) + 0.000423 * sin($MF + 2 * ($ME1 + $MD));
        $G = $G + 0.000422 * sin(2 * $ME1 - $MF - 3 * $MD) - $E * 0.000367 * sin($MS + $MF + 2 * $ME1 - $MD);
        $G = $G - $E * 0.000353 * sin($MS + $MF + 2 * $ME1) + 0.000331 * sin($MF + 4 * $ME1);
        $G = $G + $E * 0.000317 * sin(2 * $ME1 + $MF - $MS + $MD);
        $G = $G + $E2 * 0.000306 * sin(2 * ($ME1 - $MS) - $MF) - 0.000283 * sin($MD + 3 * $MF);
        $W1 = 0.0004664 * cos($NA);
		  $W2 = 0.0000754 * cos($C);
        $BM = Radians($G) * (1 - $W1 - $W2);

        $MoonLat = Degrees($BM);
	return($MoonLat);
	}

function MoonNodeLong($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)
	{
        $UT = LctUT($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR)[0];
        $GD = LctGDay($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GM = LctGMonth($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $GY = LctGYear($LH, $LM, $LS, $DS, $ZC, $DY, $MN, $YR);
        $T = ((CDJD($GD, $GM, $GY) - 2415020) / 36525) + ($UT / 876600);
        $T2 = $T * $T;

        $M1 = 27.32158213;
		  $M2 = 365.2596407;
		  $M3 = 27.55455094;
        $M4 = 29.53058868;
		  $M5 = 27.21222039;
		  $M6 = 6798.363307;
        $Q = CDJD($GD, $GM, $GY) - 2415020 + ($UT / 24);
        $M1 = $Q / $M1;
		  $M2 = $Q / $M2;
		  $M3 = $Q / $M3;
        $M4 = $Q / $M4;
		  $M5 = $Q / $M5;
		  $M6 = $Q / $M6;
        $M1 = 360 * ($M1 - variant_int($M1));
		  $M2 = 360 * ($M2 - variant_int($M2));
        $M3 = 360 * ($M3 - variant_int($M3));
		  $M4 = 360 * ($M4 - variant_int($M4));
        $M5 = 360 * ($M5 - variant_int($M5));
		  $M6 = 360 * ($M6 - variant_int($M6));

        $ML = 270.434164 + $M1 - (0.001133 - 0.0000019 * $T) * $T2;
        $MS = 358.475833 + $M2 - (0.00015 + 0.0000033 * $T) * $T2;
        $MD = 296.104608 + $M3 + (0.009192 + 0.0000144 * $T) * $T2;
        $ME1 = 350.737486 + $M4 - (0.001436 - 0.0000019 * $T) * $T2;
        $MF = 11.250889 + $M5 - (0.003211 + 0.0000003 * $T) * $T2;
        $NA = 259.183275 - $M6 + (0.002078 + 0.0000022 * $T) * $T2;

        $MoonNodeLong = $NA;
	return ($MoonNodeLong);
	}

function NewMoon($DS, $ZC, $DY, $MN, $YR)
	{
        $D0 = LctGDay(12, 0, 0, $DS, $ZC, $DY, $MN, $YR);
        $M0 = LctGMonth(12, 0, 0, $DS, $ZC, $DY, $MN, $YR);
        $Y0 = LctGYear(12, 0, 0, $DS, $ZC, $DY, $MN, $YR);

        if ($Y0 < 0){
            $Y0 = $Y0 + 1;}

        $J0 = CDJD(0, 1, $Y0) - 2415020;
        $DJ = CDJD($D0, $M0, $Y0) - 2415020;
        $K = LINT((($Y0 - 1900 + (($DJ - $J0) / 365)) * 12.3685) + 0.5);
        $TN = $K / 1236.85;
		  $TF = ($K + 0.5) / 1236.85;
        $T = $TN;
		  $T2 = $T * $T;
		  $E = 29.53 * $K;
		  $C = 166.56 + (132.87 - 0.009173 * $T) * $T;
        $C = Radians($C);
		  $B = 0.00058868 * $K + (0.0001178 - 0.000000155 * $T) * $T2;
        $B = $B + 0.00033 * sin($C) + 0.75933;
		  $A = $K / 12.36886;
        $A1 = 359.2242 + 360 * FRACT($A) - (0.0000333 + 0.00000347 * $T) * $T2;
        $A2 = 306.0253 + 360 * FRACT($K / 0.9330851);
        $A2 = $A2 + (0.0107306 + 0.00001236 * $T) * $T2;
		  $A = $K / 0.9214926;
        $F = 21.2964 + 360 * FRACT($A) - (0.0016528 + 0.00000239 * $T) * $T2;
        $A1 = UnwindDeg($A1);
		  $A2 = UnwindDeg($A2);
		  $F = UnwindDeg($F);
        $A1 = Radians($A1);
		  $A2 = Radians($A2);
		  $F = Radians($F);

        $DD = (0.1734 - 0.000393 * $T) * sin($A1) + 0.0021 * sin(2 * $A1);
        $DD = $DD - 0.4068 * sin($A2) + 0.0161 * sin(2 * $A2) - 0.0004 * sin(3 * $A2);
        $DD = $DD + 0.0104 * sin(2 * $F) - 0.0051 * sin($A1 + $A2);
        $DD = $DD - 0.0074 * sin($A1 - $A2) + 0.0004 * sin(2 * $F + $A1);
        $DD = $DD - 0.0004 * sin(2 * $F - $A1) - 0.0006 * sin(2 * $F + $A2) + 0.001 * sin(2 * $F - $A2);
        $DD = $DD + 0.0005 * sin($A1 + 2 * $A2);
		  $E1 = variant_int($E);
		  $B = $B + $DD + ($E - $E1);
        $B1 = variant_int($B);
		  $A = $E1 + $B1;
		  $B = $B - $B1;
		  $NI = $A;
		  $NF = $B;
		  $NB = $F;
        $T = $TF;
		  $K = $K + 0.5;
		  $T2 = $T * $T;
		  $E = 29.53 * $K;
		  $C = 166.56 + (132.87 - 0.009173 * $T) * $T;
        $C = Radians($C);
		  $B = 0.00058868 * $K + (0.0001178 - 0.000000155 * $T) * $T2;
        $B = $B + 0.00033 * sin($C) + 0.75933;
		  $A = $K / 12.36886;
        $A1 = 359.2242 + 360 * FRACT($A) - (0.0000333 + 0.00000347 * $T) * $T2;
        $A2 = 306.0253 + 360 * FRACT($K / 0.9330851);
        $A2 = $A2 + (0.0107306 + 0.00001236 * $T) * $T2;
		  $A = $K / 0.9214926;
        $F = 21.2964 + 360 * FRACT($A) - (0.0016528 + 0.00000239 * $T) * $T2;
        $A1 = UnwindDeg($A1);
		  $A2 = UnwindDeg($A2);
		  $F = UnwindDeg($F);
        $A1 = Radians($A1);
		  $A2 = Radians($A2);
		  $F = Radians($F);

        $DD = (0.1734 - 0.000393 * $T) * sin($A1) + 0.0021 * sin(2 * $A1);
        $DD = $DD - 0.4068 * sin($A2) + 0.0161 * sin(2 * $A2) - 0.0004 * sin(3 * $A2);
        $DD = $DD + 0.0104 * sin(2 * $F) - 0.0051 * sin($A1 + $A2);
        $DD = $DD - 0.0074 * sin($A1 - $A2) + 0.0004 * sin(2 * $F + $A1);
        $DD = $DD - 0.0004 * sin(2 * $F - $A1) - 0.0006 * sin(2 * $F + $A2) + 0.001 * sin(2 * $F - $A2);
        $DD = $DD + 0.0005 * sin($A1 + 2 * $A2);
		  $E1 = variant_int($E);
		  $B = $B + $DD + ($E - $E1);
        $B1 = variant_int($B);
		  $A = $E1 + $B1;
		  $B = $B - $B1;
		  $FI = $A;
		  $FF = $B;
		  $FB = $F;
		  $NewMoon = $NI + 2415020 + $NF;
	return ($NewMoon);
	}

//$Y2 = altitude of the star in degrees, $W = 'true' or all strings without 'true', $PR = Atmospheric Pressure, $TR = Temperature
function Refract($Y2, $SW, $PR, $TR)
	{
        $Y = Radians($Y2);
        if (preg_match("/true/i",$SW) == 1){
            $D = -1;}
        else{
            $D = 1;}

        if ($D == -1){
            $Y3 = $Y;
				$Y1 = $Y;
				$R1 = 0;
		  step1: //3020
				$Y = $Y1 + $R1;
			   $Q = $Y;
				if ($Y < 0.2617994){
            	if ($Y < -0.087){
            		$Q = 0;
            		$RF = 0;
            		goto ends; //3075
            		}

        		$YD = Degrees($Y);
        		$A = ((0.00002 * $YD + 0.0196) * $YD + 0.1594) * $PR;
        		$B = (273 + $TR) * ((0.0845 * $YD + 0.505) * $YD + 1);
        		$RF = Radians(-($A / $B) * $D);
            }
        		else{
            	$RF = -$D * 0.00007888888 * $PR / ((273 + $TR) * tan($Y));
					}
				$R2 = $RF;
            if (($R2 == 0) or (abs($R2 - $R1) < 0.000001)){
                $Q = $Y3;
                goto ends; //3075
                }
            $R1 = $R2;
				goto step1; //3020
				}
        else{
            if ($Y < 0.2617994){
            	if ($Y < -0.087){
            		$Q = 0;
            		$RF = 0;
            		goto ends; //3075
            		}

        			$YD = Degrees($Y);
        			$A = ((0.00002 * $YD + 0.0196) * $YD + 0.1594) * $PR;
        			$B = (273 + $TR) * ((0.0845 * $YD + 0.505) * $YD + 1);
        			$RF = Radians(-($A / $B) * $D);
            	}
        		else{
            	$RF = -$D * 0.00007888888 * $PR / ((273 + $TR) * tan($Y));
					}
            $Q = $Y;
            goto ends; //3075
            }

		  ends: //3075
		  $Refract = Degrees($Q + $RF);
	return ($Refract);
	}

function SunMeanAnomaly($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)
	{
        $AA = LctGDay($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $BB = LctGMonth($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $CC = LctGYear($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $UT = LctUT($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)[0];
        $DJ = CDJD($AA, $BB, $CC) - 2415020;
        $T = ($DJ / 36525) + ($UT / 876600);
		  $T2 = $T * $T;
        $A = 100.0021359 * $T;
		  $B = 360 * ($A - variant_int($A));
        $M1 = 358.47583 - (0.00015 + 0.0000033 * $T) * $T2 + $B;
        $AM = Unwind(Radians($M1));
        $SunMeanAnomaly = $AM;
	return ($SunMeanAnomaly);
	}

function SunLong($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)
	{
        $AA = LctGDay($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $BB = LctGMonth($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $CC = LctGYear($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $UT = LctUT($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)[0];
        $DJ = CDJD($AA, $BB, $CC) - 2415020;
        $T = ($DJ / 36525) + ($UT / 876600);
		  $T2 = $T * $T;
        $A = 100.0021359 * $T;
		  $B = 360 * ($A - variant_int($A));
        $L = 279.69668 + 0.0003025 * $T2 + $B;
        $A = 99.99736042 * $T;
		  $B = 360 * ($A - variant_int($A));
        $M1 = 358.47583 - (0.00015 + 0.0000033 * $T) * $T2 + $B;
        $EC = 0.01675104 - 0.0000418 * $T - 0.000000126 * $T2;

        $AM = Radians($M1);
        $AT = TrueAnomaly($AM, $EC);
		  $AE = EccentricAnomaly($AM, $EC);

        $A = 62.55209472 * $T;
		  $B = 360 * ($A - variant_int($A));
        $A1 = Radians(153.23 + $B);
        $A = 125.1041894 * $T;
		  $B = 360 * ($A - variant_int($A));
        $B1 = Radians(216.57 + $B);
        $A = 91.56766028 * $T;
		  $B = 360 * ($A - variant_int($A));
        $C1 = Radians(312.69 + $B);
        $A = 1236.853095 * $T;
		  $B = 360 * ($A - variant_int($A));
        $D1 = Radians(350.74 - 0.00144 * $T2 + $B);
        $E1 = Radians(231.19 + 20.2 * $T);
        $A = 183.1353208 * $T;
		  $B = 360 * ($A - variant_int($A));
        $H1 = Radians(353.4 + $B);

        $D2 = 0.00134 * cos($A1) + 0.00154 * cos($B1) + 0.002 * cos($C1);
        $D2 = $D2 + 0.00179 * sin($D1) + 0.00178 * sin($E1);
        $D3 = 0.00000543 * sin($A1) + 0.00001575 * sin($B1);
        $D3 = $D3 + 0.00001627 * sin($C1) + 0.00003076 * cos($D1);
        $D3 = $D3 + 0.00000927 * sin($H1);

        $SR = $AT + Radians($L - $M1 + $D2);
		  $TP = 6.283185308;
        $SR = $SR - $TP * variant_int($SR / $TP);
        $SunLong = Degrees($SR);
	return ($SunLong);
	}

function SunDist($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)
	{
        $AA = LctGDay($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $BB = LctGMonth($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $CC = LctGYear($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $UT = LctUT($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)[0];
        $DJ = CDJD($AA, $BB, $CC) - 2415020;
        $T = ($DJ / 36525) + ($UT / 876600);
		  $T2 = $T * $T;
        $A = 100.0021359 * $T;
		  $B = 360 * ($A - variant_int($A));
        $L = 279.69668 + 0.0003025 * $T2 + $B;
        $A = 99.99736042 * $T;
		  $B = 360 * ($A - variant_int($A));
        $M1 = 358.47583 - (0.00015 + 0.0000033 * $T) * $T2 + $B;
        $EC = 0.01675104 - 0.0000418 * $T - 0.000000126 * $T2;

        $AM = Radians($M1);
        $AT = TrueAnomaly($AM, $EC);
		  $AE = EccentricAnomaly($AM, $EC);

        $A = 62.55209472 * $T;
		  $B = 360 * ($A - variant_int($A));
        $A1 = Radians(153.23 + $B);
        $A = 125.1041894 * $T;
		  $B = 360 * ($A - variant_int($A));
        $B1 = Radians(216.57 + $B);
        $A = 91.56766028 * $T;
		  $B = 360 * ($A - variant_int($A));
        $C1 = Radians(312.69 + $B);
        $A = 1236.853095 * $T;
		  $B = 360 * ($A - variant_int($A));
        $D1 = Radians(350.74 - 0.00144 * $T2 + $B);
        $E1 = Radians(231.19 + 20.2 * $T);
        $A = 183.1353208 * $T;
		  $B = 360 * ($A - variant_int($A));
        $H1 = Radians(353.4 + $B);

        $D2 = 0.00134 * cos($A1) + 0.00154 * cos($B1) + 0.002 * cos($C1);
        $D2 = $D2 + 0.00179 * sin($D1) + 0.00178 * sin($E1);
        $D3 = 0.00000543 * sin($A1) + 0.00001575 * sin($B1);
        $D3 = $D3 + 0.00001627 * sin($C1) + 0.00003076 * cos($D1);
        $D3 = $D3 + 0.00000927 * sin($H1);

        $RR = 1.0000002 * (1 - $EC * cos($AE)) + $D3;
        $SunDist = $RR;
	return ($SunDist);
	}

function SunTrueAnomaly($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)
	{
        $AA = LctGDay($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $BB = LctGMonth($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $CC = LctGYear($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY);
        $UT = LctUT($LCH, $LCM, $LCS, $DS, $ZC, $LD, $LM, $LY)[0];
        $DJ = CDJD($AA, $BB, $CC) - 2415020;
        $T = ($DJ / 36525) + ($UT / 876600);
		  $T2 = $T * $T;
        $A = 100.0021359 * $T;
		  $B = 360 * ($A - variant_int($A));
        $L = 279.69668 + 0.0003025 * $T2 + $B;
        $A = 99.99736042 * $T;
		  $B = 360 * ($A - variant_int($A));
        $M1 = 358.47583 - (0.00015 + 0.0000033 * $T) * $T2 + $B;
        $EC = 0.01675104 - 0.0000418 * $T - 0.000000126 * $T2;

        $AM = Radians($M1);
        $SunTrueAnomaly = Degrees(TrueAnomaly($AM, $EC));
	return ($SunTrueAnomaly);
	}

function SunEcc($GD, $GM, $GY)
	{
    $T = (CDJD($GD, $GM, $GY) - 2415020) / 36525;
    $T2 = $T * $T;
    $SunEcc = 0.01675104 - 0.0000418 * $T - 0.000000126 * $T2;
	return ($SunEcc);
	}

function TrueAnomaly($AM, $EC)
	{
        $TP = 6.283185308;
		  $M = $AM - $TP * variant_int($AM / $TP);
		  $AE = $M;
		  step1: //3305
		  $D = $AE - ($EC * sin($AE)) - $M;

        if (abs($D) < 0.000001){
            goto step2; //3320
        		}

        $D = $D / (1 - ($EC * cos($AE)));
		  $AE = $AE - $D;
		  goto step1; //3305

		  step2: //3320
		  $A = sqrt((1 + $EC) / (1 - $EC)) * tan($AE / 2);
        $AT = 2 * atan($A);
        $TrueAnomaly = $AT;
	return ($TrueAnomaly);
	}

function EccentricAnomaly($AM, $EC)
	{
        $TP = 6.283185308;
		  $M = $AM - $TP * variant_int($AM / $TP);
		  $AE = $M;
		  step1: //3305
		  $D = $AE - ($EC * sin($AE)) - $M;

        if (abs($D) < 0.000001){
            goto step2; //3320
        }

        $D = $D / (1 - ($EC * cos($AE)));
		  $AE = $AE - $D;
		  goto step1; //3305

		  step2: //3320
		  $EccentricAnomaly = $AE;
	return ($EccentricAnomaly);
	}




?>

und hier ein Beispielaufruf…

include "12345.ips.php";	// Practical Astronomy Aufruf ---hier eure ID des Hauptscripts eintragen!!!

$HMSDec = HMSDH($Hour, $Minute, $Second); //Local Time HMS in Decimal Hours
$UTDec = LctUT($Hour, $Minute, $Second, $DS, $ZC, $day, $month, $year)[0];
$GD = LctUT($Hour, $Minute, $Second, $DS, $ZC, $day, $month, $year)[1];
$GM = LctUT($Hour, $Minute, $Second, $DS, $ZC, $day, $month, $year)[2];
$GY = LctUT($Hour, $Minute, $Second, $DS, $ZC, $day, $month, $year)[3];
$CDJD = CDJD($GD, $GM, $GY);  //UT Julian Date
$LCH = DHHour($HMSDec);  //LCT Hour --> Local Time
$LCM = DHMin($HMSDec);   //LCT Minute
$LCS = DHSec($HMSDec);   //LCT Second
//Universal Time
$UH = DHHour($UTDec);  	//UT Hour
$UM = DHMin($UTDec);    //UT Minute
$US = DHSec($UTDec);    //UT Second
$UT_value = $UH.":".$UM.":".$US;
$UDate_value = $GD.":".$GM.":".$GY;

//echo $UT_value."
";
//echo $UDate_value."
";


//Calculation Sun---------------------------------------------------------------

//Sun's ecliptic longitude in decimal degrees
$Sunlong = SunLong($LCH, $LCM, $LCS, $DS, $ZC, $day, $month, $year);
//echo $Sunlong."
";
$SunlongDeg = DDDeg($Sunlong);
$SunlongMin = DDMin($Sunlong);
$SunlongSec = DDSec($Sunlong);

//Sun's RA
$SunRAh = DDDH(ECRA($SunlongDeg, $SunlongMin, $SunlongSec, 0, 0, 0, $GD, $GM, $GY));	//returns RA in hours
$SunRAhour = DHHour($SunRAh);
$SunRAm = DHmin($SunRAh);
$SunRAs = DHSec($SunRAh);
$SunRAhms = $SunRAhour.":".$SunRAm.":".$SunRAs;
//echo $SunRAh."
";

$season = "";
$seasonchange = getvalue(47510 /*[Astronomische Daten\Allgemein\Jahreszeit geändert]*/);
if(($SunRAh>=0)and($SunRAh<6)){$season = "Frühling";}		//Frühling
if(($SunRAh>=6)and($SunRAh<12)){$season = "Sommer";}		//Sommer
if(($SunRAh>=12)and($SunRAh<18)){$season = "Herbst";}		//Herbst
if(($SunRAh>=18)and($SunRAh<24)){$season = "Winter";}		//Winter
//echo $season."
";
setvalue(18628 /*[Astronomische Daten\Allgemein\Jahreszeit]*/,$season);

//Sun's Dec
$SunDec = ECDec($SunlongDeg, $SunlongMin, $SunlongSec, 0, 0, 0, $GD, $GM, $GY);			//returns declination in decimal degrees
$SunDecd = DDDeg($SunDec);
$SunDecm = DDmin($SunDec);
$SunDecs = DDSec($SunDec);
$SunDecdms = $SunDecd.":".$SunDecm.":".$SunDecs;
//echo $SunDecdms."
";

//RH Right Ascension in HMS, LH Local Civil Time in HMS, DS Daylight saving, ZC Zonecorrection,
//LD Local Calender Date in DMY, L geographical Longitude in Degrees
$SunH = RAHA($SunRAhour, $SunRAm, $SunRAs, $Hour, $Minute, $Second, $DS, $ZC, $day, $month, $year, $L); //Hour Angle H
$SunHh = DHHour($SunH);
$SunHm = DHMin($SunH);
$SunHs = DHSec($SunH);

//Equatorial to Horizon coordinate conversion (Az)
//HH HourAngle in HMS, DD Declination in DMS, P Latitude in decimal Degrees
$Sun_az = EQAz($SunHh, $SunHm, $SunHs, $SunDecd, $SunDecm, $SunDecs, $P);
$Sun_alt = EQAlt($SunHh, $SunHm, $SunHs, $SunDecd, $SunDecm, $SunDecs, $P);
$SunDazimut = direction($Sun_az);
$Sunaz_value = number_format($Sun_az,2,',','')."°";
$Sunalt_value = number_format($Sun_alt,2,',','')."°";
//echo $Sunaz_value." azimuth"."
";
//echo $Sunalt_value." höhe"."
";

$SunDist = SunDist($Hour, $Minute, $Second, $DS, $ZC, $day, $month, $year);
$SunTA = Radians(SunTrueAnomaly($Hour, $Minute, $Second, $DS, $ZC, $day, $month, $year));
$SunEcc = SunEcc($GD, $GM, $GY);
$fSun = (1 + $SunEcc * cos($SunTA))/(1 - $SunEcc * $SunEcc);
$rSun = round(149598500/$fSun,-2);
$SunDist_value = $rSun." km";
//echo $SunDist_value."
";

SetValue(11512 /*[Astronomische Daten\Sonne\Azimut]*/, number_format(($Sun_az),2,',','')."°");
SetValue(38558 /*[Astronomische Daten\Sonne\Richtung]*/, $SunDazimut);
SetValue(33283 /*[Astronomische Daten\Sonne\Höhe]*/, number_format(($Sun_alt),2,',','')."°");
SetValue(15466 /*[Astronomische Daten\Sonne\Entfernung]*/, $SunDist_value);

//Calculation Moon--------------------------------------------------------------

$MoonLong = MoonLong($LCH, $LCM, $LCS, $DS, $ZC, $day, $month, $year); //Moon ecliptic longitude (degrees)
//echo $MoonLong."
";
$MoonLat = MoonLat($LCH, $LCM, $LCS, $DS, $ZC, $day, $month, $year); //Moon elciptic latitude (degrees)
//echo $MoonLat."
";
$Nutation = NutatLong($GD, $GM, $GY); //nutation in longitude (degrees)
//echo $Nutation."
";
$Moonlongcorr = $MoonLong + $Nutation; //corrected longitude (degrees)
$MoonHP = MoonHP($LCH, $LCM, $LCS, $DS, $ZC, $day, $month, $year);	//Moon's horizontal parallax (degrees)
//echo $MoonHP."
";
$MoonDist = MoonDist($LCH, $LCM, $LCS, $DS, $ZC, $day, $month, $year);   //Moon Distance to Earth
//echo round($MoonDist)."
";
$Moonphase = MoonPhase($LCH, $LCM, $LCS, $DS, $ZC, $day, $month, $year); //Moonphase in %
//echo $Moonphase."
";
$Moonpabl = MoonPABL($LCH, $LCM, $LCS, $DS, $ZC, $day, $month, $year);   //Moon Bright Limb Angle (degrees)

if($Moonpabl<0){$Moonpabl = $Moonpabl+360;}
else{$Moonpabl = $Moonpabl;}
//echo $Moonpabl."
";


$EcLonDeg = DDDeg($Moonlongcorr); // Ecliptic Longitude Moon - geographische Länge (Längengrad)
$EcLonMin = DDMin($Moonlongcorr);
$EcLonSec = DDSec($Moonlongcorr);

$EcLatDeg = DDDeg($MoonLat); // Ecliptic Latitude Moon - geographische Breite (Breitengrad)
$EcLatMin = DDMin($MoonLat);
$EcLatSec = DDSec($MoonLat);

//Ecliptic to Equatorial Coordinate Conversion (Decimal Degrees)
//ELD Ecliptic Longitude in DMS, BD Ecliptic Latitude in DMS, GD Greenwich Calendar Date in DMY
$MoonRA = DDDH(ECRA($EcLonDeg, $EcLonMin, $EcLonSec, $EcLatDeg, $EcLatMin, $EcLatSec, $GD, $GM, $GY));
$MoonDec = ECDec($EcLonDeg, $EcLonMin, $EcLonSec, $EcLatDeg, $EcLatMin, $EcLatSec, $GD, $GM, $GY);
//echo $MoonRA."
";
$MoonRAh = DHHour($MoonRA);	//Right Ascension Hours
$MoonRAm = DHMin($MoonRA);
$MoonRAs = DHSec($MoonRA);
//echo $MoonRAh.":".$MoonRAm.":".$MoonRAs."
";
$MoonDECd = DDDeg($MoonDec);  //Declination Degrees
$MoonDECm = DDMin($MoonDec);
$MoonDECs = DDSec($MoonDec);
//echo $MoonDECd.":".$MoonDECm.":".$MoonDECs."
";

//RH Right Ascension in HMS, LH Local Civil Time in HMS, DS Daylight saving, ZC Zonecorrection,
//LD Local Calender Date in DMY, L geographical Longitude in Degrees
$MoonH = RAHA($MoonRAh, $MoonRAm, $MoonRAs, $Hour, $Minute, $Second, $DS, $ZC, $day, $month, $year, $L); //Hour Angle H
$MoonHh = DHHour($MoonH);
$MoonHm = DHMin($MoonH);
$MoonHs = DHSec($MoonH);

$az = EQAz($MoonHh, $MoonHm, $MoonHs, $MoonDECd, $MoonDECm, $MoonDECs, $P);
$alt = EQAlt($MoonHh, $MoonHm, $MoonHs, $MoonDECd, $MoonDECm, $MoonDECs, $P);

$dazimut = direction($az);
$az_value = number_format($az,2,',','')."°";
$alt_value = number_format($alt,2,',','')."°";
//echo $az_value."
";
//echo $alt_value."
";

setvalue(48142 /*[Astronomische Daten\Mond\Azimut]*/,$az_value);
setvalue(48649 /*[Astronomische Daten\Mond\Höhe]*/,$alt_value);
setvalue(27013 /*[Astronomische Daten\Mond\Richtung]*/,$dazimut);
setvalue(20856 /*[Astronomische Daten\Mond\Entfernung]*/,round($MoonDist)." km");
setvalue(16474 /*[Astronomische Daten\Mond\Sichtbarkeit]*/,$Moonphase." %");
setvalue(39171 /*[Astronomische Daten\Mond\Positionswinkel der beleuchteten Fläche]*/,number_format($Moonpabl,2,',',''));


Hallo Bernd,

Super! Hast Du vielleicht noch ein Beispiel zur Berechnung von Mond und Sonnen Azimut und Elavation?
Deine Darstellung in https://www.symcon.de/forum/threads/31419-In-HTML-Box?p=291039#post291039 finde ich Genial

Hallo Bernd,

Daumen hoch und vielen Dank für die vielen Functions.
Muss eine heidenarbeit gewesen sein.

Ein paar Functions sind noch unkommentiert.

man hat ja sonst nichts zu tun

Könntest Du die irgend wann noch kurz kommentieren?

Werd mal sehen was ich da so rausbekomme.

Grüsse,

Wolfgang

Hallöchen,
war nicht ohne die Umsetzung von vba in php, vor allen Dingen sind da Formeln bei die den „goto“ Befehl verwenden…
ja und ohne das Buch wird es schwierig mit den einzelnen Formeln etwas vernünftiges rauszubekommen

hier geht’s dann mal weiter…
hab alles in Post #2 eingefügt

Hallo Bernd,

ich bekommst einfach nicht hin. Die berechneten Werte passen nicht. Habs mal Online berechnen lassen und mit denen aus Deinem Skript verglichen.
Was mache ich falsch?
Brauche eigentlich (vorrangig) nur Sonne/Mond Azimut und Höhe um Dein anderes Skript nutzen zu können.

Danke für Deine Hilfe.

Hallo Jürgen,
ich hab’s bei mir auch nochmal mit der Onlineberechnung auf http://lexikon.astronomie.info/java/sunmoon/index.html verglichen, da ist kaum ein Unterschied…
Online und im Script genau die gleichen Koordinaten eingetragen ?

Hallo Bernd,

ja habe ich:

Läuft das Hauptscript fehlerfrei durch wenn du da auf ausführen gehst ?

Ja, komplett ohne Fehler. Versteh ich nicht:confused:

Am Betriebssystem wirds wohl nicht liegen? Ich habe Win7 64Bit mit IPS 4 und Du?

Hab’s unter IPS 3.4 auf Win7 64bit laufen…
Hast du mal Zeit/Datum auf deinem System kontrolliert ?

Ja, alles ok.
Mit diesem Skript hier aus dem Forum klappt wenigstens der Sonnenstand genau wie in der Onlineberechnung:

<?
// Quelle: http://www.ip-symcon.de/forum/f52/sonnenstand-berechnen-azimut-elevation-14925/

 //  Coordinates format is the pair of latitude and longitude, with sign minus (-) for the direction south latitude and west longitude separate by comma simbol (,), here some example:
 //    52.5163 , 13.3779
 //    40.7682 , -73.9816
 //    -22.9708 , -43.1830

//function calcSunPos( $iYear, $iMonth, $iDay, $dHours,    $dMinutes, $dSeconds, $dLongitude, $dLatitude)


$long         = getValue(34991 /*[Scripte\Stammdaten\Longitude]*/); // Längengrad
$lat          = getValue(31837 /*[Scripte\Stammdaten\Latitude]*/ ); // Breitengrad


calcSunPos( gmdate("y"), gmdate("m"), gmdate("d"), gmdate("H"), gmdate("i"), 0, $long, $lat); // location Hamburg Öjendorf, Germany


//function calcSunPos( int iYear,int iMonth,int iDay,double dHours,    double dMinutes,double dSeconds,    double dLongitude,    double dLatitude)
function calcSunPos( $iYear, $iMonth, $iDay, $dHours,    $dMinutes, $dSeconds, $dLongitude, $dLatitude)
{

    $pi = 3.14159265358979323846;
    $twopi = (2*$pi);
    $rad = ($pi/180);
    $dEarthMeanRadius = 6371.01;    // In km
    $dAstronomicalUnit = 149597890;    // In km

    // Calculate difference in days between the current Julian Day
    // and JD 2451545.0, which is noon 1 January 2000 Universal Time

    // Calculate time of the day in UT decimal hours
    $dDecimalHours = floatval($dHours) + (floatval($dMinutes) + floatval($dSeconds) / 60.0 ) / 60.0;

    // Calculate current Julian Day

    $iYfrom2000 = $iYear;//expects now as YY ;
    $iA= (14 - ($iMonth)) / 12;
    $iM= ($iMonth) + 12 * $iA -3;
    $liAux3=(153 * $iM + 2)/5;
    $liAux4= 365 * ($iYfrom2000 - $iA);
    $liAux5= ( $iYfrom2000 - $iA)/4;
    $dElapsedJulianDays= floatval(($iDay + $liAux3 + $liAux4 + $liAux5 + 59)+ -0.5 + $dDecimalHours/24.0);

    // Calculate ecliptic coordinates (ecliptic longitude and obliquity of the
    // ecliptic in radians but without limiting the angle to be less than 2*Pi
    // (i.e., the result may be greater than 2*Pi)

    $dOmega= 2.1429 - 0.0010394594 * $dElapsedJulianDays;
    $dMeanLongitude = 4.8950630 + 0.017202791698 * $dElapsedJulianDays; // Radians
    $dMeanAnomaly = 6.2400600 + 0.0172019699 * $dElapsedJulianDays;
    $dEclipticLongitude = $dMeanLongitude + 0.03341607 * sin( $dMeanAnomaly ) + 0.00034894 * sin( 2 * $dMeanAnomaly ) -0.0001134 -0.0000203 * sin($dOmega);
    $dEclipticObliquity = 0.4090928 - 6.2140e-9 * $dElapsedJulianDays +0.0000396 * cos($dOmega);

    // Calculate celestial coordinates ( right ascension and declination ) in radians
    // but without limiting the angle to be less than 2*Pi (i.e., the result may be
    // greater than 2*Pi)

    $dSin_EclipticLongitude = sin( $dEclipticLongitude );
    $dY1 = cos( $dEclipticObliquity ) * $dSin_EclipticLongitude;
    $dX1 = cos( $dEclipticLongitude );
    $dRightAscension = atan2( $dY1,$dX1 );
    if( $dRightAscension < 0.0 ) $dRightAscension = $dRightAscension + $twopi;
    $dDeclination = asin( sin( $dEclipticObliquity )* $dSin_EclipticLongitude );

    // Calculate local coordinates ( azimuth and zenith angle ) in degrees

    $dGreenwichMeanSiderealTime = 6.6974243242 +    0.0657098283 * $dElapsedJulianDays + $dDecimalHours;

    $dLocalMeanSiderealTime = ($dGreenwichMeanSiderealTime*15 + $dLongitude)* $rad;
    $dHourAngle = $dLocalMeanSiderealTime - $dRightAscension;
    $dLatitudeInRadians = $dLatitude * $rad;
    $dCos_Latitude = cos( $dLatitudeInRadians );
    $dSin_Latitude = sin( $dLatitudeInRadians );
    $dCos_HourAngle= cos( $dHourAngle );
    $dZenithAngle = (acos( $dCos_Latitude * $dCos_HourAngle * cos($dDeclination) + sin( $dDeclination )* $dSin_Latitude));
    $dY = -sin( $dHourAngle );
    $dX = tan( $dDeclination )* $dCos_Latitude - $dSin_Latitude * $dCos_HourAngle;
    $dAzimuth = atan2( $dY, $dX );
    if ( $dAzimuth < 0.0 )
        $dAzimuth = $dAzimuth + $twopi;
    $dAzimuth = $dAzimuth / $rad;
    // Parallax Correction
    $dParallax = ($dEarthMeanRadius / $dAstronomicalUnit) * sin( $dZenithAngle);
    $dZenithAngle = ($dZenithAngle + $dParallax) / $rad;
    $dElevation = 90 - $dZenithAngle;


    // IP Symcon -> Create and take your own variables
    // Save Azimuth and Elevation as Float values

        SetValueFloat(39074 /*[Scripte\Wetter_Klima_Umwelt\PositionSonneMond\Sonnenstand\AzimutSun]*/, $dAzimuth);
        SetValueFloat(39597 /*[Scripte\Wetter_Klima_Umwelt\PositionSonneMond\Sonnenstand\ElevationSun]*/ , $dElevation);



}

// Funktion zur Berechnung des Sommerzeit-Startdatums
function dst_start($year) {
 return mktime(2,0,0,3,31 - date('w', mktime(2,0,0,3,31,$year)),$year);
}
// Funktion zur Berechnung des Sommerzeit-Enddatums
function dst_end($year) {
 return mktime(2,0,0,10,31 - date('w', mktime(2,0,0,10,31,$year)),$year);
}





?>

Du hast aber hier

//Breiten- und Längengrad hab ich bei mir als Variable abgelegt
$P = getvalue(29795 /*[Scripte\Sonnenauf/untergang\Breitengrad (x1000000)]*/)/1000000;
$L = getvalue(31634 /*[Scripte\Sonnenauf/untergang\Längengrad (x1000000)]*/)/1000000;

die /1000000 rausgenommen, oder ? Die hast ja bei dir in den Stammdaten direkt mit Komma angegeben…
Ich habe es mal rausgenommen hier in meinem Post :o

Simsalabim, schon geht es. Vielen vielen Dank:)

Supi :wink:
Hab die Angaben bei mir als Integer abgelegt… deswegen der Teiler :banghead: sollte ich bei mir auch mal ändern

Unter W10 und IPS4 ist bei mir das Script mit den Functions auf den Fehler:

Call to undefined function variant_fix()
gelaufen.

Ursache: die php_com_dotnet.dll fehlt.

Hab die dann von der IPS 3.4 rüber kopiert und ein mal ein IPS-Update laufen lassen. Damit wird dann automatisch die richtige Version der DLL installiert.

Danach hats funktioniert.

Anbei die dll.

php_com_dotnet.zip (32.3 KB)

Unter Ubuntu und IPS4 erzeugt das Haupt-Script den Fehler:
Call to undefined function variant_fix()

Wie kann dies korrigiert werden?
Mit freundlichen Grüßen
Matthias

Hallo Bernd,

bevor ich mich jetzt weiter mit den Functions auseinandersetze …

Hast Du eine Lösung, wie ich die Koordinaten und die aktuelle Uhrzeit an das Function-Script übergeben kann?

Das fänd ich universeller.

Dann könnt ich das selbe Script für verschiedene Anwendungen verwenden.

@Wolfgang

versuche mal das hier im Aufrufscript:

$day = date("d");
$month = date("m");
$year = date("Y");
$Hour = date("H");
$Minute = date("i");
$Second = date("s");
$summer = date("I");
if ($summer == 0){   //Summertime
	$DS = 0;}         //$DS = Daylight Saving
	else{
	$DS = 1;}
$ZC = 1; // Zone Correction to Geenwich: 1 = UTC+1
$P = getvalue(29795 /*[Scripte\Sonnenauf/untergang\Breitengrad]*/);
$L = getvalue(31634 /*[Scripte\Sonnenauf/untergang\Längengrad]*/);

include "12345.ips.php"; //Aufruf Hauptscript

... ab hier dann der Rest vom aufrufenden Script

und lösche folgende Zeilen im Hauptscript

$day = date("d");
$month = date("m");
$year = date("Y");
$Hour = date("H");
$Minute = date("i");
$Second = date("s");
$summer = date("I");
if ($summer == 0){   //Summertime
	$DS = 0;}         //$DS = Daylight Saving
	else{
	$DS = 1;}
$ZC = 1; // Zone Correction to Geenwich: 1 = UTC+1
$P = getvalue(29795 /*[Scripte\Sonnenauf/untergang\Breitengrad]*/);
$L = getvalue(31634 /*[Scripte\Sonnenauf/untergang\Längengrad]*/);