;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; "atmosphere" i/o type (atm_t):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

out_atm_t = $                      ; "atmosphere" output structure
  {         $
  data_type  : info.out_type[0], $ ; data type   (comes from xxx_info.pro routine)
  data_status: !caos_data.valid, $ ; data status (default value is "valid", not "not_valid" nor "wait")

  screen     : fltarr(nx,ny,nl), $ ; 3D cube defining the layers' screens
                                   ; (where: nx=dimension along x, ny=dim. along y, nl=number of layers)
  scale      : scale,            $ ; the x- and y-scale in meter/pixel
  delta_t    : delta_t,          $ ; the time-base in seconds
  alt        : altitudes,        $ ; a vector containing the layers' altitudes [m]
  dir        : directions,       $ ; a vector containing the layer's winds directions [rd]
  correction : correction        $ ; is this a "correction" atmosphere ? [yes=1B, no=0B]
  }


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; "source/object" i/o type (src_t):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

out_src_t = $                       ; "source/object" output structure
   {        $
   data_type  : info.out_type[0], $ ; data type   (comes from xxx_info.pro routine)
   data_status: !caos_data.valid, $ ; data status (default value is "valid", not "not_valid" nor "wait")

   off_axis   : off_axis,         $ ; off-axis angle of source/object observed
   pos_ang    : pos_ang,          $ ; position angle of source/object observed
   dist_z     : dist_z,           $ ; altitude of source/object (infinite for NGS, finite for LGS)
   map        : fltarr(np,np),    $ ; 2D (or 3D) source/object map
                                    ; (where np=dimension in x and y -- could be used or not)
   scale_xy   : scale_xy,         $ ; map x- and y-scale
                                    ; [in radian/pixel -- used if map exists]
   coord      : coordinates,      $ ; 3D coordinates of source/object [used if 3D object]
   scale_z    : scale_z,          $ ; 3D map z-scale [used if 3D map exists]
   n_phot     : n_phot,           $ ; vector containing the number of photons per pre-defined band
                                    ; [in photons/m^2/second]
   background : background,       $ ; vector containing the sky background per pre-defined band
                                    ; [in photons/m^2/second/arcsec^2]
   lambda     : lambda,           $ ; vector containing the central wavelenghts of the pre-defined bands
                                    ; [in m]
   width      : width,            $ ; vector containing the spectral width of the pre-defined bands
                                    ; [in m]
   constant   : constant          $ ; is it a constant source (wrt time) ? [yes=1B, no=0B]
   }


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; "wave-front propagated" i/o type (wfp_t):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

out_wfp_t = $                       ; "wave-front propagated" output structure
   {        $
   data_type  : info.out_type[0], $ ; data type   (comes from xxx_info.pro routine)
   data_status: !caos_data.valid, $ ; data status (default value is "valid", not "not_valid" nor "wait")

   screen     : fltarr(np,np),    $ ; phase screen (where np is the x- and y-dimension in pixels)
   pupil      : pupil,            $ ; the pupil (same dimensions as out_wfp_t.screen)
   eps        : epsilon,          $ ; obscuration ratio
   scale_atm  : scale_atm,        $ ; spatial scale [in m/px]
   delta_t    : delta_t,          $ ; base time     [in s]

   lambda     : lambda,           $ ; vector containing the central wavelenghts of the pre-defined bands
                                    ; [in m]
   width      : width,            $ ; vector containing the spectral width of the pre-defined bands
                                    ; [in m]
   n_phot     : n_phot            $ ; vector containing the number of photons per pre-defined band
                                    ; [in photons/second]
   background : background,       $ ; vector containing the sky background per pre-defined band
                                    ; [in photons/second/arcsec^2]

   map        : map,              $ ; source map [in px,px]
   map_scale  : map_scale,        $ ; map scale [in rd/px]

                                    ; parameters related to the source position
   dist_z     : dist_z,           $ ; source distance [m]
   off_axis   : off_axis,         $ ; source off-axis angle [rd]
   pos_ang    : pos_ang,          $ ; source position angle  [rd]

                                    ; parameters related to the 3D LGS map:
   coord      : coord,              ; source coordinates relative to the
                                    ; point [0,0] ([rd,rd,m,m,m])
   scale_z    : scale_z,          $ ; vertical scale [m]

                                    ; parameters of the telescope:
   dist       : dist,             $ ; telescope distance from [0,0] ([m])
   angle      : angle,            $ ; telescope pos. angle wrt [0,0] ([rd])

   constant   : constant,         $ ; constant (wrt time) source ?
   correction : correction        $ ; does it come from a reconstructed
   }                                ; atmosphere ? (1B=yes, 0B=no)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; "image" i/o type (img_t):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

out_img_t = $                       ; "image" output structure
   {        $
   data_type  : info.out_type[0], $ ; data type   (comes from xxx_info.pro routine)
   data_status: !caos_data.valid, $ ; data status (default value is "valid", not "not_valid" nor "wait")

   image      : fltarr(np,np,ni), $ ; 2D image (or cube of 2D images)
                                    ; (where np is defined hereafter and ni is the number of images)
   npixel     : np,               $ ; number of linear pixels in x- and y-dimension
   resolution : pxsize,           $ ; pixel size [arcsec/pix]
   lambda     : lambda,           $ ; mean detection wavelength [m]
   width      : width,            $ ; wavelength band width [m]
   time_integ : time_integ,       $ ; number of iterations to integrate
   time_delay : time_delay,       $ ; number of iterations to delay
   psf        : psf,              $ ; is it a point-spread function ? [yes=1B, no=0B]
   background : 0.,               $ ; sky background value [could be used or not]
   snr        : 0.                $ ; SNR value [could be used or not]
   }


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; "command" i/o type (com_t):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

out_com_t = $                       ; "command" output structure
   {        $
   data_type  : info.out_type[0], $ ; data type   (comes from xxx_info.pro routine)
   data_status: !caos_data.valid, $ ; data status (default value is "valid", not "not_valid" nor "wait")

   command    : command           $ ; command to be send to correcting mirror
   }


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; "multiple image" i/o type (mim_t):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

out_mim_t = $                       ; "multiple image" output structure
   {        $
   data_type  : info.out_type[0], $ ; data type   (comes from xxx_info.pro routine)
   data_status: !caos_data.valid, $ ; data status (default value is "valid", not "not_valid" nor "wait")

   image      : fltarr(np,np),    $ ; image containing the ordered sub-images from a Shack-Hartmann or
                                    ; from a pyramid sensor (np is the total x- and y-dimension)
   npixpersub : npixpersub,       $ ; number of pixels per sub-image
   pxsize     : pixsize,          $ ; pixels size
                                    ; [in rd for the SH sensor and rd for the pyramid sensor]
   nxsub      : nxsub,            $ ; linear number of sub-images 
   nsp        : nsp,              $ ; total of sub-images (more readily "sub-apertures" for SH sensor)
   xspos_CCD  : xspos_CCD,        $ ; x-positions of sub-apertures [SH case -- not used in the PYR case] 
   yspos_CCD  : yspos_CCD,        $ ; y-positions of sub-apertures [SH case -- not used in the PYR case]
   convert    : convert,          $ ; convertion displacement-->tilt [SH case -- not used in the PYR case]

   lambda     : lambda,           $ ; mean detection wavelength [m]
   width      : width,            $ ; wavelength band width [m]
   }


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; "structure function" i/o type (stf_t):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


out_stf_t = $                       ; "structure function" output structure
   {        $
   data_type  : info.out_type[0], $ ; data type   (comes from xxx_info.pro routine)
   data_status: !caos_data.valid, $ ; data status (default value is "valid", not "not_valid" nor "wait")

   struc      : struc_fct,        $ ; computed structure function
   theo       : theo_struc,       $ ; theoretical structure function
   scale      : scale_atm,        $ ; spatial scale [in m/px]
   model      : model,            $ ; theoretical model (Kolmogorov, von Karman)
   r0         : r0,               $ ; Fried parameter [in m]
   L0         : L0,               $ ; wave-front outer scale [in m]
   iter       : n_iter,           $ ; number of screens used
   dim        : dim               $ ; screens' linear dimension [px]
   }


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; "measurement" i/o type (mes_t):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

out_mes_t = $                       ; "structure function" output structure
   {        $
   data_type  : info.out_type[0], $ ; data type   (comes from xxx_info.pro routine)
   data_status: !caos_data.valid, $ ; data status (default value is "valid", not "not_valid" nor "wait")

   npixpersub : npixpersub,       $ ; number of pixels per subaperture
   pxsize     : pxsize,           $ ; pixel size [SH case only]
   nxsub      : nxsub,            $ ; linear number of subapertures
   nsp        : nsp,              $ ; number of active subapertures
   xspos_CCD  : xspos_CCD,        $ ; x-coord. of the subaperture centers [px] [SH case only]
   yspos_CCD  : yspos_CCD,        $ ; y-coord. of the subaperture centers [px] [SH case only]
   convert    : convert,          $ ; convertion displacement->tilt            [SH case only]
   geom       : type,             $ ; WFS geometry type                        [SH case only]

   lambda     : lambda,           $ ; wavelenght [m]
   width      : width,            $ ; bandwidth  [m]

   meas       : measurements,     $ ; vector containing the measurements
   type       : wfs_type          $ ; type of wave-front type [could be used or not]
   }


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; "power spectrum" i/o type (pws_t):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

out_pws_t = $                       ; "power spectrum" output structure
   {        $
   data_type  : info.out_type[0], $ ; data type   (comes from xxx_info.pro routine)
   data_status: !caos_data.valid, $ ; data status (default value is "valid", not "not_valid" nor "wait")

   image      : fltarr(np,np),    $ ; 2D power spectrum
                                    ; (where np is defined hereafter)
   npixel     : np,               $ ; number of linear pixels in x- and y-dimension
   resolution : pxsize,           $ ; pixel size [(1/m)/pix]
   lambda     : lambda,           $ ; mean detection wavelength [m]
   width      : width,            $ ; wavelength band width [m]
   time_integ : time_integ,       $ ; number of iterations to integrate
   time_delay : time_delay        $ ; number of iterations to delay
   }