Add doc for components and devices.

Alain Klotz
1 parent 7a80ffac
Showing 9 changed files with 406 additions and 69 deletions Show diff stats
docs/source/device_definition.rst
docs/source/index.rst
docs/source/using_guitastro_classes.rst
src/guitastro/__init__.py
src/guitastro/communications.py
src/guitastro/component.py
src/guitastro/component_mount_pointing.py
src/guitastro/ephemeris.py
src/guitastro/filenames.py
@@ -0,0 +1,78 @@
+***********************************************
+Device management with guitastro Python classes
+***********************************************
+
+This section explains how to use guitastro to drive a device.
+
+1. Context
+**********
+
+A device is a system constituted by:
+
+	* **communication**: Communication means that messages to drive the device are exchanged between guitastro and the device. Messages can be transported by Serial or TCP protocols.
+	* **components**: A component is a part of the device identified to realize an astronomical action. For example a focuser is a component. Some devices are constituted by many compenents. For example a camera équiped by a shutter and a filter wheel is a device constituted by 3 components.
+	
+In Guitastro we define the following **categories** of components:
+
+	* **MountPointing**: It is a mechanical motorized mount able to point a direction in the sky using two axes.
+	* **DetectorFocuser**: It is a mechanical motorized motor placed close the detector to able changing the focus. 
+	
+The communication chanel is the same for all the components.
+The commands are contents to pilot the components. There are two types of commands:
+
+	* **uniform**: From the side of a Guitastro user, the commands are the same for a given component category. For example to slew a mount the command is always "DO RADEC_GOTO".	
+	* **native**: From the side of device controler, the commands are translated by guitastro into the device manufactured grammar. 
+
+A uniform command is constituted by an **action**, an **operation** and optional parameters:
+
+	* **action**: Main actions are GET, SET, DO. GET and SET manage variables and DO manage messages towards the device.
+	* **operation**: It is a word that depends on the action.
+
+2. Commands of a component
+**************************
+
+A command can be generalized as component/action/operation/parameters
+
+When the component/action = MountPointing/SET, the operation is a variable symbol and parameters is the variable value:
+
+.. code-block:: python
+
+	import guitastro
+	comp = ComponentMountPointing()
+	comp.command("SET", "target", "RADEC 12h56m -08d45m")
+	
+When the component/action = MountPointing/GET, the operation is a variable symbol. The result is the variable value:
+
+.. code-block:: python
+
+	import guitastro
+	comp = ComponentMountPointing()
+	comp.command("GET", "target")
+
+When the component/action/operation = MountPointing/DO/RADEC_GOTO, the operation start a slewing to the target defined in the target variable previously defined:
+
+.. code-block:: python
+
+	import guitastro
+	comp = ComponentMountPointing()
+	comp.command("SET", "target", "RADEC 12h56m -08d45m")
+	comp.command("DO", "RADEC_GOTO")
+
+
+A given category of component have a list of operations. For example for a MountPointing:
+
+	* **RADEC_COORD**: Returns the current coordinates in the RA,Dec system
+	* **RADEC_GOTO**: Slew the mount until a target previously defined by a command 
+
+3. Integration of components into devices for Guitastro
+*******************************************************
+
+The device codes a written outside the guitastro module.
+For a given device the code is a module. For example, guitastro_device_meade_mounts.
+The device modules are downloaded in the site of Guitastro.
+To drive a device it is necessary to install guitastro the device module.
+
+4. Simulation and real devices
+******************************
+
+Blabla.
@@ -153,7 +153,15 @@ Describe how to instanciate guitastro classes to use them in a personal Python c
  
    using_guitastro_classes
  
-9. Class and method documentation
+9. Driving devices with guitastro
+*********************************
+
+.. toctree:: 
+   :maxdepth: 3
+
+   device_definition
+
+10. Class and method documentation
 ***********************************
  
 For developers of Python code of GuitAstro:
@@ -62,10 +62,6 @@ We want to compute sum of the angles 2h3m27s and -0d28m12.4s. Display the result
 4. Using the Python module guitastro for dates
 **********************************************
  
-Celme module is located in the folder pyros/src/utils
-Examples: pyros/src/utils/report/dates.py
-help(Date)
-
 4.1. Simple example to convert dates
 ====================================
  
@@ -97,13 +93,6 @@ Date ISO = 2018-10-13T23:13:44.958
 5. Using the Python module guitastro for ephemeris
 **************************************************
  
-| Celme module is located in the folder pyros/src/utils
-| Examples: pyros/src/utils/report/targets.py
-
-.. code-block:: python
-
-	help(Target)
-
 5.1. Simple example to compute Sun coordinates
 ==============================================
  
@@ -120,6 +120,26 @@ guitastro.mount
 .. automodule:: guitastro.mount
    :members:
  
+guitastro.communications
+------------------------
+.. automodule:: guitastro.communications
+   :members:
+
+guitastro.component
+-------------------
+.. automodule:: guitastro.component
+   :members:
+
+guitastro.component_detector_focuser
+------------------------------------
+.. automodule:: guitastro.component_detector_focuser
+   :members:
+
+guitastro.component_mount_pointing
+------------------------------------
+.. automodule:: guitastro.component_mount_pointing
+   :members:
+
 """
 from __future__ import (absolute_import, division, print_function,
                         unicode_literals)
@@ -146,6 +166,10 @@ from .filenames import FileNames
 from .astrotables import AstroTable
 from .splinefit import Splinefit
  
+from .component import Component
+from .component_mount_pointing import ComponentMountPointing
+from .component_detector_focuser import ComponentDetectorFocuser
+
 from .camera import Camera
 from .mount import Mount
  
@@ -48,7 +48,65 @@ class CommunicationException(GuitastroException):
 class Communication():
     """Communication channel manager
  
-    Usage : Communication("SERIAL", port="//./COM1")
+    This class allows to open and close TCP or SERIAL communications.
+    There are methods to put and read messages.
+
+    :Example:
+
+    To get only informations on communication channels SERIAL and TCP:
+    ::
+
+        >>> chan = Communication("INFOS")
+        >>> available_serial_ports = chan.get_available_serial_ports()
+        >>> my_ip_address = chan.get_ip()
+
+    To open a SERIAL port:
+    ::
+
+        >>> chan = Communication("SERIAL", port="//./COM1", baud_rate=9600)
+
+    To open a TCP port:
+    ::
+
+        >>> chan = Communication("TCP", hostname="192.168.0.4", port="8080")
+
+    To close an opened port:
+    ::
+
+        >>> chan.close()
+
+    To send a message through an opened port:
+    ::
+
+        >>> chan.put("Hello")
+
+    To read a message through an opened port:
+    ::
+
+        >>> result = chan.read()
+
+    Very often protocols need to add suffix characters to the messages.
+    The following optional keys can be added to Communication:
+
+        * END_OF_COMMAND_TO_SEND (str): Suffix systematically added at the end of messages sent.
+        * END_OF_COMMAND_TO_RECEIVE (str): Suffix systematically suppressed at the end of messages received.
+        * DELAY_INIT_CHAN (float): Delay (seconds) executed just after the communication opening because some devices cannot be joined before.
+        * DELAY_PUT_READ (float): Delay (seconds) between put and read commands.
+
+    :Example:
+
+    Open a serial port with many parameters, send a message a wait for a response:
+
+    ::
+
+        chan = Communication("SERIAL", port="//./COM1", baud_rate=9600, end_of_command_to_send="\\n", delay_ini_chan=1.8, delay_put_read=0.2)
+        result = chan.putread("Hello")
+
+    It is possible to open a simulation of the communication channel .
+    To do that the following optional keys can be added to Communication:
+
+        * REAL (bool): Default value is True
+
     """
  
     # === Constant for error codes
@@ -178,9 +236,22 @@ class Communication():
             self._hostname_chan = self._channel_params["HOSTNAME"]
         self._real = self._channel_params["REAL"]
  
-    def get_ip(self):
-        """
-        Tool to return the IP of this computer
+    def get_ip(self)->str:
+        """Tool to return the IP of this computer
+
+        Returns:
+
+            The IP addresse of the local machine.
+
+        :Example:
+
+        To get the IP of the computer:
+
+        ::
+
+            >>> chan = Communication("INFOS")
+            >>> my_ip_address = chan.get_ip()
+
         """
         ip = '127.0.0.1'
         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -207,6 +278,20 @@ class Communication():
  
     def get_available_serial_ports(self):
         """Return a list of available serial ports of the local computer
+
+        Returns:
+
+            The list of serial port names of the local machine
+
+        :Example:
+
+        To get the IP of the computer:
+
+        ::
+
+            >>> chan = Communication("INFOS")
+            >>> available_serial_ports = chan.get_available_serial_ports()
+
         """
         # --
         prefix_myserial_ports = ""
@@ -245,6 +330,8 @@ class Communication():
         return self.NO_ERROR
  
     def open_chan(self):
+        """Open the channel
+        """
         err = self.NO_ERROR
         if self._real == False:
             fid = "simulation"
@@ -315,6 +402,8 @@ class Communication():
         return self.NO_ERROR
  
     def close_chan(self):
+        """Close the channel
+        """
         err = self.NO_ERROR
         fid = self._fid_chan
         if self._fid_chan == None:
@@ -343,6 +432,11 @@ class Communication():
  
     def put_chan(self, cmd: str):
         """ Send a message into the opened channel
+
+        Args:
+
+            cmd: Message to send. Suffix defined by the option key END_OF_COMMAND_TO_SEND is added inside the method.
+
         """
         # --- check the opening of the serial port
         err, fid = self.check_chan()
@@ -361,6 +455,13 @@ class Communication():
         return (err, cmd)
  
     def read_chan(self):
+        """ Receive a message from the opened channel
+
+        Returns:
+
+            The string of the message read.
+
+        """
         # --- check the opening of the serial port
         err, fid = self.check_chan()
         lignes = "" ; # fid.readlines()
@@ -446,16 +547,37 @@ class Communication():
     delay_init_chan  = property(_get_delay_init_chan,  _set_delay_init_chan)
     verbose_chan     = property(_get_verbose_chan,     _set_verbose_chan)
  
-    def putread_chan(self, cmd, index=-1):
-        return self.putread_chan_check(cmd, index)
+    def putread_chan(self, cmd:str, index:int=-1):
+        """ Send and Receive a message from the opened channel
+
+        Args:
  
-    def putread_chan_nocheck(self, cmd, index=-1):
+            cmd: The message to send
+            index: >0 to extract only the word returned at the index position
+
+        Returns:
+
+            A string containing the response received.
         """
-        cmd is the message to send
-        index >0 to extract only the word returned at the index position
+        return self.putread_chan_check(cmd, index)
+
+    def putread_chan_nocheck(self, cmd:str, index:int=-1):
+        """ Send and Receive a message from the opened channel
+
+        No lock version. See comments of the putread_chan_check
+
+        Args:
+
+            cmd: The message to send
+            index: >0 to extract only the word returned at the index position
+
+        Returns:
+
+            A string containing the response received.
         """
         if self.verbose_chan==True:
-            self.log.self.log.print("Putread: "+cmd)
+            #self.log.self.log.print("Putread: "+cmd)
+            pass
         self._lock_putread = True
         self.put_chan(cmd)
         time.sleep(self._delay_put_read)
@@ -474,11 +596,18 @@ class Communication():
  
     #def putread_chan_lock_verify(self, cmd, index=-1):
     def putread_chan_check(self, cmd, index=-1):
-        """
-        Version with a lock to avoid multiple calls to the controller.
+        """ Send and Receive a message from the opened channel
+
+        Same as putread_chan but a lock is added to avoid multiple calls to the controller.
+
+        Args:
+
+            cmd: The message to send
+            index: >0 to extract only the word returned at the index position
+
+        Returns:
  
-        cmd is the message to send
-        index >0 to extract only the word returned at the index position
+            A string containing the response received.
         """
         if self.verbose_chan==True:
             # self.log.self.log.print("Putread: "+cmd)
@@ -494,7 +623,7 @@ class Communication():
                 time.sleep(0.05)
                 dt = time.time() - t0
                 if dt>2.0:
-                    self.log.print("Serial port locked timeout for {}".format(cmd))
+                    #self.log.print("Serial port locked timeout for {}".format(cmd))
                     break
         # --- verify the lock state
         if self._lock_putread == False:
@@ -56,8 +56,9 @@ class Component(ComponentException):
  
     A command of a component is constituted by:
  
-        * Action : A string word as GET, SET, DO
-        * Parameters : List or/and dict depending the action
+        * Action: A string word as GET, SET, DO
+        * Operation: A string word that dependis on the action
+        * Parameters: List or/and dict depending the action/operation
  
     A command is sent to the component using the method command:
  
@@ -99,7 +100,7 @@ class Component(ComponentException):
     Note that the parameters of an operation should be assigned by the Action SET
     before calling DO.
  
-   :Example:
+    :Example:
  
     ::
  
@@ -222,8 +223,11 @@ class Component(ComponentException):
         return res
  
     def parameters(self, action="", operation=""):
-        """Get the list of operations for a given action
-        or get the description of a given operation.
+        """Get the list of operations for a given action or get the description of a given operation.
+
+        Args:
+
+            action: If not given, returns the list of Actions
         """
         actions = self.actions
         if action=="":
@@ -244,7 +248,19 @@ class Component(ComponentException):
     def command(self, action:str, *args, **kwargs):
         """General method to send command.
  
-        Action must be a str amongst elements of the list returned by the method prop
+        Args:
+
+            action: A str amongst elements of the list returned by the method prop
+            *args: args[0] should be an operation
+            **kwargs: Dictionary of options associated to the operation
+
+        Returns:
+
+            The result of the command.
+
+        Use the method parameters(action) to get the available operations for a given action.
+        The kwargs are defined for each operation.
+
         """
         result = None
         action = action.upper()
@@ -83,7 +83,7 @@ class ComponentMountPointing(ComponentMountPointingException, Component, Guitast
                 # --- call the real
                 kwargs = {}
                 kwargs['computed'] = (ra, dec, equinox, epoch, dra, ddec)
-                self._my_do(*args, **kwargs)
+                result = self._my_do(*args, **kwargs)
                 # --- update the motion
                 self._set("motion", "slewing")
             else:
@@ -96,10 +96,12 @@ class ComponentMountPointing(ComponentMountPointingException, Component, Guitast
             # TODO
             # --- update the motion
             self._set("motion", "stoped")
+            result = self._my_do(*args, **kwargs)
         elif operation == "RADEC_COORD":
             # --- make the simulation
             # TODO
             self.log = f"start simulation of {operation}"
+            result = self._my_do(*args, **kwargs)
             result = "12h00m45.78s -06d55m23.2s"
         return self._fresult(result)
  
@@ -443,21 +443,33 @@ class Ephemeris(EphemerisException, GuitastroTools):
         return sra, sdec, equinox, t0
  
     def radec(self, target: str, **kwargs)-> tuple:
-        """Return ra, dec, euqinox, epoch of a target.
+        """Return ra, dec, equinox, epoch of a target.
  
-        target is a string that starts with a keyword:
+        Args:
  
-            * RADEC: to indicate an equatorial Right Ascension, Declination position.
-            * CELESTRACK: to indicate a satellite name in the Celestrack TLE files.
-            * DATERADECS: to indicate a list of equatorial Right Ascension, Declination positions.
-            * TLE: to indicate a satellite defined by its TLE (Two Line Elements).
+            target: A string that starts with a keyword:
  
-        kwargs keys can be:
+                * 'RADEC': Followed by an equatorial Right Ascension, Declination position.
+                * 'RADECDRIFT': Followed by an equatorial Right Ascension, Declination position and the drift.
+                * 'CELESTRACK' or 'TLEFILES': Followed by a satellite name in the Celestrack TLE files.
+                * 'DATERADECS': Followed by a list of equatorial Right Ascension, Declination positions.
+                * 'TLE': Followed by a satellite defined by its TLE (Two Line Elements).
+                * 'GCNC': Followed by a number which is a GRB name (e.g. GCNC 990123) to search information in GCN circulars.
+                * 'MPC': Followed by a name which is a Solar System Body.
  
-            * date: To compute ephemeris for a given date ("now" for now).
-            * unit_ra: To indicate the output format (see Angle)
-            * unit_dec: To indicate the output format (see Angle)
-            * target_type:  To indicate the input format if the keyword is not indicated in the target string.
+            **kwargs: A dictionary of options, keys can be:
+
+                * 'date': To compute ephemeris for a given date ("now" for now).
+                * 'unit_ra': To indicate the output format (see Angle)
+                * 'unit_dec': To indicate the output format (see Angle)
+                * 'target_type':  To indicate the input format if the keyword is not indicated in the target string.
+
+        Returns:
+
+            ra: Target Right Ascention position at the given date for a given equinox
+            dec: Target Declination at the given date for a given equinox
+            equinox: Equinox of the position
+            epoch: Date of the position when the object is moving
  
         """
         equinox = "J2000"
@@ -724,6 +736,21 @@ class Ephemeris(EphemerisException, GuitastroTools):
  
     def radec_speed(self, target, **kwargs):
         """Return ra, dec J2000 of a target as method radec and add the speed (deg/s)
+
+        Args:
+
+            target: See radec for explanations
+            **kwargs: See radec for explanations
+
+        Returns:
+
+            ra: Target Right Ascention position at the given date for a given equinox
+            dec: Target Declination at the given date for a given equinox
+            equinox: Equinox of the position
+            epoch: Date of the position when the object is moving
+            dra: Velocity on Right Ascension axis (deg/s)
+            ddec: Velocity on Declination axis (deg/s)
+
         """
         ra, dec, equinox, epoch = self.radec(target, **kwargs)
         target = str(target)
@@ -762,6 +789,16 @@ class Ephemeris(EphemerisException, GuitastroTools):
  
     def altitude2tp(self, alti:float, p0m:float=101325):
         """Compute the theoretical pressure and temperature in the Earth atmosphere given an altitude
+
+        Args:
+
+            alti: The altitude of the observation site in meters
+            p0m: The pressure at the sea level. Default is 101325 Pascal.
+
+        Returns:
+
+            pressure: The pressure in Pascal
+            temperature: The temperature in Kelvin
         """
         tk0m=273.15+15
         if alti<11000:
@@ -832,6 +869,52 @@ class Ephemeris(EphemerisException, GuitastroTools):
  
     def target2night(self, target, night:str, ephem_sun:dict=None, ephem_moon:dict=None, **kwargs)->dict:
         """Compute the ephemeris at every second of local coodinates for a night
+
+        Two computations are importants:
+
+            * 'observability': An integer defining why the target is visible or not.
+            * 'observability': A float value from 0 (not observable) to 100 (best conditions to observe)
+
+        Args:
+
+            target: A target in the formalism of the method radec
+            night: A night symbol (e.g. 20230330)
+            ephem_sun: A dictionary result of the method called target2night("sun", night)
+            ephem_moon: A dictionary result of the method called target2night("moon", night)
+            kwargs: A dictionary of options:
+
+                * horizon: An object of the class Horizon of Guitastro that defines the horizon line.
+                * preference: A string "bestelev" or "immediate" to compute the observability
+                * duskelev: A float, the elevation of the Sun defining the start and end of the night.
+
+        Returns:
+
+            A dictionary:
+
+                * 'night': String of the night
+                * 'home': String of the GPS position
+                * 'target': String of the input target
+                * 'ndate': Number of dates used to compute amers before interpolations
+                * 'jd': Numpy array of Julian days
+                * 'alt': Numpy array of the elevation (deg)
+                * 'az': Numpy array of the azimut (deg)
+                * 'ha': Numpy array of the apparent hour angle (deg)
+                * 'dec': Numpy array of the apparent declination (deg)
+                * 'ra_equinox': Numpy array of the Right Ascension at the input equinox (deg)
+                * 'dec_equinox': Numpy array of the Declination at the input equinox (deg)
+                * 'cosphi': Numpy array of cos(ra_equinox)
+                * 'sinphi': Numpy array of sin(ra_equinox)
+                * 'costheta': Numpy array of cos(dec_equinox)
+                * 'sintheta': Numpy array of sin(dec_equinox)
+                * 'distsun': Numpy array of the distance from the Sun (deg)
+                * 'distmoon': Numpy array of the distance from the Moon (deg)
+                * 'visibility': Numpy array of the visibility
+                * 'observability': Numpy array of the observability (>0 means observable)
+                * 'horizon': Numpy array of horizon elevations (deg)
+
+        The Numpy arrays are 1D of 86400 elements.
+        if ephem_sun==None or ephem_moon==None, the distances between the target and the Sun and Moon will not be calculated.
+
         """
         nsec = 86400
         if ephem_sun==None or ephem_moon==None:
@@ -845,7 +928,7 @@ class Ephemeris(EphemerisException, GuitastroTools):
             hor_az = np.arange(0, 361)
             hor_elev = np.zeros(len(hor_az))
         if 'preference' in kwargs.keys():
-            preference = kwargs['preference']
+            preference = kwargs['preference'].lower()
         else:
             preference="bestelev"
         if 'duskelev' in kwargs.keys():
@@ -961,41 +1044,42 @@ class Ephemeris(EphemerisException, GuitastroTools):
         sinthetas = aangles[9]
         distsuns = aangles[10]
         distmoons = aangles[11]
-        # --- visibility
-        disponibilitys = np.zeros(nsec)
+        # --- observability and visibility
         visibilitys = np.zeros(nsec)
+        observabilitys = np.zeros(nsec)
         horizons = np.zeros(nsec)
         if sunmoon==True:
+            # --- visibility
             kk = 0
             for alt, az in zip(alts, azs):
                 k = int(np.floor(az))%360
                 altmini = hor_elev[k]
                 horizons[kk] = altmini
                 if alt < altmini:
-                    disponibilitys[kk] += 1
+                    visibilitys[kk] += 1
                 if ephem_sun['alt'][kk] > duskelev:
-                    disponibilitys[kk] += 2
+                    visibilitys[kk] += 2
                 kk += 1
-            disponibilitys = np.where(distsuns > 30, disponibilitys, disponibilitys+4)
-            disponibilitys = np.where(distmoons > 30, disponibilitys, disponibilitys+8)
-            # --- visibility
+            visibilitys = np.where(distsuns > 30, visibilitys, visibilitys+4)
+            visibilitys = np.where(distmoons > 30, visibilitys, visibilitys+8)
+            # --- observability
             nvis = 0
             altmaxi = 0
             for kk in range(nsec):
-                if disponibilitys[kk] == 0:
+                if visibilitys[kk] == 0:
                     nvis += 1
                     if alts[kk] > altmaxi:
                         altmaxi = alts[kk]
             if preference=="immediate":
                 kvis = nvis
                 for kk in range(nsec):
-                    if disponibilitys[kk] == 0:
-                        visibilitys[kk] = kvis/nvis*100
+                    if visibilitys[kk] == 0:
+                        observabilitys[kk] = kvis/nvis*100
                         kvis -= 1
             if preference=="bestelev":
                 for kk in range(nsec):
-                    if disponibilitys[kk] == 0:
-                        visibilitys[kk] = alts[kk]/altmaxi*100
+                    if visibilitys[kk] == 0:
+                        observabilitys[kk] = alts[kk]/altmaxi*100
          # --- dictionary
         eph = {}
         eph['night'] = night
@@ -1015,8 +1099,8 @@ class Ephemeris(EphemerisException, GuitastroTools):
         eph['sintheta'] = sinthetas
         eph['distsun'] = distsuns
         eph['distmoon'] = distmoons
-        eph['disponibility'] = disponibilitys
         eph['visibility'] = visibilitys
+        eph['observability'] = observabilitys
         eph['horizon'] = horizons
         return eph
  
@@ -1156,6 +1240,14 @@ if __name__ == &quot;__main__&quot;:
         Compute the ephemeris of a target along all a night
         """
         import matplotlib.pyplot as plt
+        def compute_hours(ephem):
+            jd0 = ephem['jd'][0]
+            frac = jd0 - np.floor(jd0)
+            offset = frac - 0.5
+            hours = (ephem['jd'] - jd0 + offset)*24
+            date = Date(jd0).iso(0)
+            return hours, date
+        # ---
         eph = Ephemeris()
         eph.set_home("guitalens")
         night = "20230320"
@@ -1173,7 +1265,6 @@ if __name__ == &quot;__main__&quot;:
         ephem_sun = eph.target2night(target, night)
         dt = time.time()-t0
         print(f"SUN dt={dt}")
-        plt.plot(ephem_sun['jd'], ephem_sun['alt'], "y-")
         # --- moon
         target = "moon"
         t0 = time.time()
@@ -1186,12 +1277,12 @@ if __name__ == &quot;__main__&quot;:
         ephem = eph.target2night(target, night, ephem_sun, ephem_moon, horizon=hor, preference=preference, duskelev=duskelev)
         dt = time.time()-t0
         print(f"TARGET dt={dt}")
-        #plt.plot(ephem['jd'], ephem['ha'], "r:")
-        #plt.plot(ephem['jd'], ephem['dec'], "r-")
-        plt.plot(ephem['jd'], ephem['alt'], "b-")
-        #plt.plot(ephem['jd'], ephem['az'], ":-")
-        plt.plot(ephem['jd'], ephem['disponibility'], "k:")
-        plt.plot(ephem['jd'], ephem['visibility'], "k-")
-        plt.plot(ephem['jd'], ephem['horizon'], "g-")
+        hours, date = compute_hours(ephem)
+        plt.plot(hours, ephem_sun['alt'], "y-")
+        plt.plot(hours, ephem['alt'], "b-")
+        plt.plot(hours, ephem['horizon'], "g-")
+        plt.plot(hours, ephem['visibility'], "k:")
+        plt.plot(hours, ephem['observability'], "k-")
         plt.grid()
-
+        plt.ylabel('Degrees')
+        plt.xlabel(f'Hours since {date}')
@@ -1128,7 +1128,7 @@ class FileNames(FileNamesException, GuitastroTools):
             fn = FileNames()
             fn.naming_date("2023-01-03T12:43:27.876983")
  
-        The result should be {'iso': '2023-01-03T12:43:27.876983', 'iso_': '2023_01_03_12_43_27_876983', 'yyyy': '2023', 'mm': '43', 'dd': '03', 'hh': '12', 'ss': '27', 'yyyymmdd': '20230103', 'hhmmss': '124327', 'hhmmssssssss': '124327876983'}
+        The result should be {'iso': '2023-01-03T12:43:27.876983', 'iso\_': '2023_01_03_12_43_27_876983', 'yyyy': '2023', 'mm': '43', 'dd': '03', 'hh': '12', 'ss': '27', 'yyyymmdd': '20230103', 'hhmmss': '124327', 'hhmmssssssss': '124327876983'}
         """
         date = Date(date);
         digits = date.digits(6)