solarsystem 0.1.6__py3-none-any.whl

solarsystem/__init__.py

@@ -0,0 +1,26 @@
+"""
+===========
+SolarSystem
+===========
+
+* Planets positions around Sun.
+* Planets positions around Earth.
+* Moon positions around Earth.
+* Sunrise/Sunset.
+* Moonrise/Moonset, Moon Phase.
+* Convert between different coordinate systems.
+
+"""
+
+__version__='0.1.6'
+
+from .heliocentric import Heliocentric
+from .geocentric import Geocentric
+from .sunriseset import Sunriseset
+from .moon import Moon
+
+from .functions import normalize
+from .functions import demical2clock, demical2arcs, demical2hms
+from .functions import spherical2rectangular, rectangular2spherical
+from .functions import ecliptic2equatorial, equatorial2ecliptic
+from .functions import spherical_ecliptic2equatorial, spherical_equatorial2ecliptic

solarsystem/functions.py

@@ -0,0 +1,312 @@
+# -*- coding: utf-8 -*-
+import math
+
+    
+#degree_sign= u'\N{DEGREE SIGN}'
+
+def normalize(degrees):  
+    """
+    set degrees always between 0 - 360
+    
+    Args:
+        degrees (float): degrees to be adjusted
+        
+    Returns:
+        float: degrees between 0-360
+        
+    """
+    return degrees % 360
+
+    
+
+def spherical2rectangular(RA, Decl, r):
+    """Transform spherical to rectangular projection.
+    
+    From spherical (RA,Decl) coordinates system to rectangular(x,y,z) or 
+    by replacing RA with longitude and Decl with latitude we can tranform 
+    ecliptic coordinates to horizontal (azimuth,altitude).
+    
+    Args:
+        RA: Right Ascension.
+        Decl: Declination.
+        r: Distance in astronomical units.
+   
+    Returns:
+        tuple: x, y, z rectangular coordinate system. 
+        
+    """
+    
+    RA = math.radians(RA)
+    Decl = math.radians(Decl)
+    x = r * math.cos(RA) * math.cos(Decl)
+    y = r * math.sin(RA) * math.cos(Decl)
+    z = r * math.sin(Decl)
+    
+    return (x, y, z)
+
+
+def rectangular2spherical(x, y, z):
+    """Transform rectangular to spherical projection.
+    
+    From rectangular(x,y,z) coordinates system to spherical (RA,Decl, r) or 
+    by replacing x with azimuth and y with altitude we can tranform 
+    horizontal coordinates to ecliptic (longitude, latitude).
+    
+    Args:
+        x: value on x axis of a rectangular projection.
+        y: value on y axis of a rectangular projection.
+        z: value on z axis of a rectangular projection.
+   
+    Returns:
+        tuple: RA, Decl, r spherical coordinate system. 
+        
+    """
+    
+    r    = math.sqrt( x*x + y*y + z*z )
+    RA   = math.atan2( y, x )
+#    Decl = math.asin( z / r ) 
+    Decl = math.atan2( z, math.sqrt( x*x + y*y ) )
+    
+    RA = normalize(math.degrees(RA))
+    Decl = (math.degrees(Decl))
+    return (RA, Decl, r)
+    
+
+
+def ecliptic2equatorial(xeclip, yeclip, zeclip, oblecl):
+    """Transform ecliptic to equatorial projection.
+    
+    Args:
+        xeclip: value on x axis of ecliptic plane.
+        yeclip: value on y axis of ecliptic plane.
+        zeclip: value on z axis of ecliptic plane.
+        oblecl: obliquity of the ecliptic, approximately 23.4 degrees for earth
+   
+    Returns:
+        tuple: x, y, z equatorial projection 
+        
+    """
+#    oblecl = math.radians(oblecl)
+    
+    xequat = xeclip
+    yequat = yeclip * math.cos(oblecl) - zeclip * math.sin(oblecl)
+    zequat = yeclip * math.sin(oblecl) + zeclip * math.cos(oblecl)
+    
+    return (xequat, yequat, zequat)
+
+
+
+def equatorial2ecliptic(xequat, yequat, zequat, oblecl):
+    """Transform equatorial to ecliptic projection.
+    
+    Args:
+        xequat: value on x axis of equatorial plane
+        yequat: value on y axis of equatorial plane
+        zequat: value on z axis of equatorial plane
+        oblecl: obliquity of the ecliptic, approximately 23.4 degrees for earth
+   
+    Returns:
+        tuple: x, y, z ecliptic projection 
+        
+    """
+    
+#    oblecl = math.radians(oblecl)
+    xeclip = xequat
+    yeclip = yequat * math.cos(-oblecl) - zequat * math.sin(-oblecl)
+    zeclip = yequat * math.sin(-oblecl) + zequat * math.cos(-oblecl)
+    return (xeclip, yeclip, zeclip)
+    
+
+
+def spherical_ecliptic2equatorial(long, lat, distance, oblecl):
+    """Transform eclipitc to spherical projection for given obliquity.
+    
+    From spherical (RA, Decl, distance) coordinates system to 
+    eclipitc(long, lat, distance).
+    
+    Args:
+        long: Longitude.
+        last: Latitude.
+        distance: Distance in astronomical units.
+        oblecl: obliquity (axial tilt).
+            
+    Returns:
+        tuple: RA, Decl, distance spherical coordinate system. 
+        
+    """
+    
+    b = spherical2rectangular(long,lat,distance)
+    c = ecliptic2equatorial(b[0],b[1],b[2], oblecl)
+    return rectangular2spherical(c[0],c[1],c[2])
+
+
+def spherical_equatorial2ecliptic(RA, Decl, distance, oblecl):
+    """Transform spherical to eclipitc projection for given obliquity.
+    
+    From spherical (RA, Decl, distance) coordinates system to 
+    eclipitc(long, lat, distance).
+    
+    Args:
+        RA: Right Ascension.
+        Decl: Declination.
+        distance: Distance in astronomical units.
+        oblecl: obliquity (axial tilt).
+            
+    Returns:
+        tuple: long, lat, distance eclipitc coordinate system. 
+        
+    """
+    
+    b = spherical2rectangular(RA, Decl,distance)
+    c = equatorial2ecliptic(b[0],b[1],b[2], oblecl)
+    return rectangular2spherical(c[0],c[1],c[2])
+
+
+def demical2clock(demicaltime):
+    """
+    Convert demical time view to Hours, Minutes and Seconds.
+    
+    Args:
+        demicaltime (float): time to be converted.
+        
+    Returns:
+        str: one string representation in hours, minutes format.
+        
+    """ 
+    h = int(demicaltime)
+    m = int((demicaltime - h) * 60)
+    s = int(((demicaltime-h)*60 - m ) * 60)
+    h=str(h)
+    m=str(m)
+    s=str(s)
+    if len(h)==1: h = '0' + h
+    if len(m)==1: m = '0' + m
+    if len(s)==1: s = '0' + s
+    res = h + ':'+ m + ':'+ s
+    return res
+
+
+def demical2arcs(num):
+    """
+    Convert Demical view to Degrees and minutes.
+    
+    Args:
+        num (float): degrees to be converted.
+        
+    Returns:
+        str: one string representation in degrees and minutes format.
+        
+    """
+#    return(str(int(num))+u"\u00b0 "+str(round(abs(num - int(num))*60,2))+"'")
+    return(str(int(num))+"° "+str(round(abs(num - int(num))*60,2))+"'")
+
+#def degrees2hours(degrees):
+#    """
+#    Convert degrees to string representation of hours, minutes and seconds.
+#    
+#    Args:
+#        degrees (float): degrees to be converted.
+#        
+#    Returns:
+#        str: one string representation in hours, minutes and seconds format.
+#        
+#    """    
+#    h=degrees//15
+#    r=(degrees%15)*4
+#    m=int(r)
+#    s=int((r-m)*60)
+#    return (str(h)+'h '+str(m)+'m '+str(s)+'s')
+
+def demical2hms(degrees):
+    """
+    Convert degrees to string representation of hours, minutes and seconds.
+    
+    Args:
+        degrees (float): degrees to be converted.
+        
+    Returns:
+        str: one string representation in hours, minutes and seconds format.
+        
+    """   
+    
+    h = int(degrees/15)
+    m = int((degrees/15 - h) * 60)
+    s = int(((degrees/15-h)*60 - m ) * 60)
+    h=str(h)
+    m=str(m)
+    s=str(s)
+    if len(h)==1: h =  h
+    if len(m)==1: m =  m
+    if len(s)==1: s =  s
+    res = h + 'h '+ m + 'm '+ s +'s'
+    return res
+
+
+def Planet_Sun(M, e, a, N, w, i):
+    """
+    Helper Function. From planet's trajectory elements to position around sun
+        
+    Returns:
+        tuple: position elements
+        
+    """
+    M2=math.radians(M)
+    E0=M + (180/math.pi)*e*math.sin(M2)*(1+e*math.cos(M2))
+    E0=normalize(E0) 
+    E02=math.radians(E0)
+    E1=E0 - (E0 - (180/math.pi)*e*math.sin(E02)-M)/(1-e*math.cos(E02))
+    E1=normalize(E1) 
+    E=math.radians(E1)
+    x=a*(math.cos(E)-e)
+    y=a*(math.sqrt(1 - e*e))*math.sin(E)
+
+    r=math.sqrt(x*x+y*y)
+    v=math.atan2(y, x)
+    v=normalize(math.degrees(v))
+
+    xeclip=r*(math.cos(math.radians(N))*math.cos(math.radians(v+w)) - math.sin(math.radians(N))*math.sin(math.radians(v+w))*math.cos(math.radians(i)))
+    yeclip=r*(math.sin(math.radians(N))*math.cos(math.radians(v+w)) + math.cos(math.radians(N))*math.sin(math.radians(v+w))*math.cos(math.radians(i)))
+    zeclip=r*math.sin(math.radians(v+w))*math.sin(math.radians(i)) 
+    long2 = math.atan2( yeclip, xeclip )
+    long2=normalize(math.degrees(long2))
+    lat2 = math.atan2( zeclip, math.sqrt( xeclip*xeclip +yeclip*yeclip ) )
+    lat2=math.degrees(lat2)
+    return (xeclip,yeclip,zeclip, long2, lat2, r)
+
+
+def sun2planet(xeclip, yeclip, zeclip, x, y, z):
+    """
+    Helper Function. From Hliocentric to Geocentric position
+        
+    Returns:
+        tuple: geocentric view of object.
+        
+    """
+    x_geoc=(x+xeclip)
+    y_geoc=(y+yeclip)
+    z_geoc=(z+zeclip)
+
+    return rectangular2spherical(x_geoc, y_geoc, z_geoc)
+#    t = ecliptic2equatorial(x_geoc, y_geoc, z_geoc, 23.4)
+#    return rectangular2spherical(t[0],t[1],t[2])
+
+def precession_longitude_correction(jd):
+    """
+    Helper Function. From Hliocentric to Geocentric position
+        
+    Args:
+        jd (float): julian date
+        
+    Returns:
+        p_arcsec (float): degrees of latitude correction
+        
+    """
+
+    T = (jd - 2451543.5) / 36525.0
+
+    # general precession in longitude (arcsec)
+    p_arcsec = 5028.796195 * T
+
+    # convert to degrees
+    return p_arcsec / 3600.0
+    

solarsystem/geocentric.py

@@ -0,0 +1,93 @@
+from .functions import sun2planet, spherical2rectangular, ecliptic2equatorial
+from .functions import rectangular2spherical  
+from .heliocentric import Heliocentric
+
+class Geocentric():
+    """Import date data outputs planets positions around Earth.
+    
+    Args:
+        year (int): Year (4 digits) ex. 2020
+        month (int): Month (1-12)
+        day (int): Day (1-31)
+        hour (int): Hour (0-23)
+        minute (int): Minute (0-60)
+        UT: Time Zone (deviation from UT, -12:+14), ex. for Greece (GMT + 2) 
+            enter UT = 2
+        dst (int): daylight saving time (0 or 1). Wheather dst is applied at 
+                   given time and place
+        plane: desired output format. Should be one of: ecliptic, equatorial.
+               Default: ecliptic
+        precession (boolean): True or False. Apply corrections to object's 
+                              Longitude due to Earth's axis rotation.
+                              Default: True
+            
+    """
+    
+    def __init__(self, year, month, day, hour, minute, UT=0, dst=0, 
+                 plane='ecliptic', precession=True):
+        self.plane=plane
+        self.planetoncenter = 'Earth'
+        objectlist = [ "Mercury","Venus","Earth","Mars","Jupiter","Saturn"
+                           ,"Uranus","Neptune","Pluto","Ceres","Chiron","Eris"]
+        h = Heliocentric(year=year, month=month, day=day, hour=hour, 
+                         minute=minute, UT=UT, dst=dst, view='rectangular', precession=precession )
+        hplanets = h.planets()
+        planets=[]
+        for key in objectlist:
+            if key != "Earth":
+               planets.append(hplanets[key])
+            else:
+                planets.append((h.x2, h.y2, h.z2))
+        self.objectlist = objectlist
+        self.planets = planets
+        self.oblecl = h.oblecl
+        self.precession=precession
+
+        
+    def position(self):
+        """Main method which returns a dictionary of geocentric positions.
+        
+        Returns:
+            dictionary: Planet positions around earth: Each row represents a 
+                        planet and each column the position of that planet.
+                        
+        """        
+        c = self.planets[2]
+        RA, Decl, r = rectangular2spherical(c[0],c[1],c[2])
+        planetccentric_pos={'Sun':(RA, Decl, r)}
+
+        for i in range(len(self.planets)):
+            if i != 2:
+                planetccentric_pos[self.objectlist[i]] = sun2planet(self.planets[i][0],
+                                  self.planets[i][1], self.planets[i][2],
+                               self.planets[2][0], self.planets[2][1], 
+                               self.planets[2][2])
+                
+        if self.plane=='equatorial':
+            v1,v2,v3=planetccentric_pos['Sun']
+            vv1,vv2,vv3 = spherical2rectangular(v1,v2,v3)
+            vvv1,vvv2,vvv3 = ecliptic2equatorial(vv1,vv2,vv3, self.oblecl)
+            vvvv1,vvvv2,vvvv3 = rectangular2spherical(vvv1,vvv2,vvv3)
+            planetccentric_pos['Sun'] = (vvvv1,vvvv2,vvvv3)
+            
+            for i in range(len(self.objectlist)):
+                if i != 2:
+                    v1,v2,v3=planetccentric_pos[self.objectlist[i]]
+                    vv1,vv2,vv3 = spherical2rectangular(v1,v2,v3)
+                    vvv1,vvv2,vvv3 = ecliptic2equatorial(vv1,vv2,vv3, 
+                                                         self.oblecl)
+                    vvvv1,vvvv2,vvvv3 = rectangular2spherical(vvv1,vvv2,vvv3)
+                    planetccentric_pos[self.objectlist[i]] =(vvvv1,vvvv2,vvvv3)
+                
+        return planetccentric_pos
+     
+    def objectnames(self):
+        """Names of solar system objects used. 
+        
+        Returns:
+            list: A list of solar system objects
+            
+        """               
+        orderedobjects= ["Sun", "Mercury","Venus","Mars","Jupiter","Saturn","Uranus",
+                "Neptune","Pluto","Ceres","Chiron","Eris"]
+        return( orderedobjects )