aopera 0.1.0__py3-none-any.whl

aopera/photometry.py

@@ -0,0 +1,219 @@
+"""
+Photometric budget
+"""
+
+import numpy as np
+from aopera.readconfig import set_attribute, read_config_file, read_config_tiptop
+from aopera.utils import rad2arcsec
+import logging
+
+CONSTANT = {'h':6.626e-34, 'c':2.998e8, 'kb':1.381e-23}
+
+def black_body(wvl, temp):
+    """
+    Black body spectrum [W/m2/sr/m]
+    
+    Parameters
+    ----------
+    wvl : float, np.array
+        Wavelengths [m] at which to compute the spectrum.
+    temp : float
+        Temperature [K] of the black body.
+    """
+    return 2*CONSTANT['h']*CONSTANT['c']**2/((np.exp(CONSTANT['h']*CONSTANT['c']/(wvl*CONSTANT['kb']*temp))-1.0)*wvl**5)
+
+
+def black_body_sun(wvl):
+    """
+    Sun black body spectrum [W/m2/m] as seen from Earth distance.
+    
+    Parameters
+    ----------
+    wvl : float, np.array
+        Wavelengths [m] at which to compute the spectrum.
+    """
+    temp = 5780 # surface temperature [Kelvin]
+    solid_angle = 6.8*1e-5 # Sun disk seen from Earth [steradian]
+    return black_body(wvl, temp) * solid_angle
+
+
+def atmospheric_transmission(zenith_rad, t_zenith=0.8):
+    """Atmospheric transmission"""
+    return t_zenith ** (1/np.cos(zenith_rad))
+
+
+def satellite_flux(wvl_min, wvl_max, phase_angle=65, albedo=0.15):
+    """
+    Number of photons per second per steradian per m² of satellite surface.
+    The received number of photons on a detector will be:
+        N = satellite_flux(...) * T_exposure * S_satellite * S_telescope / distance² * throughput
+    """
+    incidence = 2/(3*np.pi) * (np.sin(np.deg2rad(phase_angle)) + (np.pi - np.deg2rad(phase_angle)) * np.cos(np.deg2rad(phase_angle)))
+    wvl = np.linspace(wvl_min, wvl_max, 2000)
+    spectrum = black_body_sun(wvl) * wvl/(CONSTANT['h']*CONSTANT['c'])  # [photon/s/wvl]
+    nb_ph_sun = np.trapezoid(spectrum, wvl)
+    sun_size_idl_correction_factor = 3.1
+    return nb_ph_sun * albedo * incidence / sun_size_idl_correction_factor
+
+
+class Band:
+    # These values come from OOMAO [Conan and Correia]
+    # [central wvl, bandwidth, zeropoint]
+    BANDS = {
+        "V": [ 550e-9,  90e-9, 3.3e12],
+        "R": [ 640e-9, 150e-9,   4e12],
+        "I": [ 790e-9, 150e-9, 2.7e12],
+        "J": [1215e-9, 260e-9, 1.9e12],
+        "H": [1654e-9, 290e-9, 1.1e12]
+        }
+    
+    def __init__(self, band):
+        self.band = band
+      
+    @property
+    def band(self):
+        return self._band
+        
+    @band.setter
+    def band(self, band):
+        if band not in Band.BANDS.keys():
+            raise KeyError('The required photometric band [%s] has not been implemented'%band)
+        self._band = band
+        
+    @property
+    def wavelength(self):
+        """Central wavelength of the band [m]"""
+        return Band.BANDS[self.band][0]
+        
+    @property
+    def bandwidth(self):
+        """Bandwidth [m]"""
+        return Band.BANDS[self.band][1]
+    
+    @property
+    def zeropoint(self):
+        """Photon per m2 per second at magnitude 0"""
+        return Band.BANDS[self.band][2]/368.0 # This factor comes from OOMAO [Conan and Correia]
+    
+    def photon2mag(self, nphot):
+        """Convert number of photons per m2 per second in magnitude"""
+        return -2.5*np.log10(nphot/self.zeropoint)
+    
+    def mag2photon(self, mag):
+        """Convert magnitude to number of photons per m2 per second"""
+        return self.zeropoint * 10**(-mag/2.5)
+    
+    
+class SourceScience:
+    def __init__(self, dictionary):
+        set_attribute(self, dictionary, 'source_science')
+            
+    def __repr__(self):
+        s  = 'aopera.SOURCE_SCIENCE\n'
+        s += '----------------------\n'
+        s += 'wvl    : %u nm\n'%self.wvl_nm
+        s += 'zenith : %u deg\n'%self.zenith_deg
+        return s
+        
+    @staticmethod
+    def from_file(filepath, category='source_science'):
+        return SourceScience(read_config_file(filepath, category))
+    
+    @staticmethod
+    def from_file_tiptop(filepath):
+        return SourceScience(read_config_tiptop(filepath)[4])
+    
+    @staticmethod
+    def from_oopao(src):
+        return SourceScience({'wvl_nm':src.wavelength*1e9,'zenith_deg':0})
+    
+    @property
+    def wvl(self):
+        return self.wvl_nm * 1e-9
+    
+    @wvl.setter
+    def wvl(self, value):
+        self.wvl_nm = value * 1e9
+        
+    @property
+    def zenith_rad(self):
+        return self.zenith_deg * np.pi/180
+    
+    @zenith_rad.setter
+    def zenith_rad(self, value):
+        self.zenith_deg = value * 180/np.pi
+        
+    @property
+    def elevation_rad(self):
+        return np.pi/2 - self.zenith_rad
+    
+    @property
+    def elevation_deg(self):
+        return 90 - self.zenith_deg
+    
+    
+    
+class SourceWFS:
+    def __init__(self, dictionary):
+        self.square = False
+        set_attribute(self, dictionary, 'source_wfs')
+            
+    def __repr__(self):
+        s  = 'aopera.SOURCE_WFS\n'
+        s += '------------------\n'
+        s += 'wvl       : %u nm\n'%self.wvl_nm
+        s += 'flux      : %.2g ph/m²/s\n'%self.flux
+        s += 'separation: %.3f arcsec\n'%self.separation
+        s += 'size      : %.2f arcsec\n'%self.size
+        return s
+        
+    @staticmethod
+    def from_file(filepath, category='source_wfs'):
+        return SourceWFS(read_config_file(filepath, category))
+    
+    @staticmethod
+    def from_file_tiptop(filepath):
+        return SourceWFS(read_config_tiptop(filepath)[5])
+    
+    @staticmethod
+    def from_oopao(src_wfs, src_sci):
+        r_wfs, a_wfs = src_wfs.coordinates
+        x_wfs = r_wfs * np.cos(a_wfs*np.pi/180)
+        y_wfs = r_wfs * np.sin(a_wfs*np.pi/180)
+        r_sci, a_sci = src_sci.coordinates
+        x_sci = r_sci * np.cos(a_sci*np.pi/180)
+        y_sci = r_sci * np.sin(a_sci*np.pi/180)
+        logging.warning('Conversion from OOPAO to aopera assumes a point-like WFS source.')
+        return SourceWFS({'wvl_nm':src_wfs.wavelength*1e9,
+                          'flux':src_wfs.nPhoton,
+                          'separation':np.sqrt((x_sci-x_wfs)**2+(y_sci-y_wfs)**2),
+                          'angle':np.arctan2(y_wfs-y_sci, x_wfs-x_sci)*180/np.pi,
+                          'size':0})
+    
+    @property
+    def wvl(self):
+        return self.wvl_nm * 1e-9
+    
+    @wvl.setter
+    def wvl(self, value):
+        self.wvl_nm = value * 1e9
+        
+    @property
+    def separation_x(self):
+        return self.separation * np.cos(self.angle*np.pi/180)
+    
+    @property
+    def separation_y(self):
+        return self.separation * np.sin(self.angle*np.pi/180)
+    
+    def image(self, nx, tel_diameter, samp):
+        xx,yy = np.mgrid[0:nx,0:nx] - nx//2
+        pix_size_arcsec = rad2arcsec((self.wvl/tel_diameter) / samp)
+        Robj_pix = (self.size/2) / pix_size_arcsec
+        if self.square:
+            obj = (np.abs(xx)<=Robj_pix)*(np.abs(yy)<=Robj_pix)
+        else:
+            rr = np.sqrt(xx**2+yy**2)
+            obj = (rr <= Robj_pix)
+        return obj / np.sum(obj)
+        

aopera/readconfig.py

@@ -0,0 +1,267 @@
+"""
+Load data from a .INI configuration file
+"""
+
+import os
+from configparser import ConfigParser
+import logging
+import numpy as np
+# from aopera.turbulence import WVL_REF_SEEING
+from aopera.utils import arcsec2rad
+
+WVL_REF_SEEING = 500e-9 # TODO: solve circular import issue
+
+def np_array(x):
+    try:
+        return np.array(eval(x))
+    except:
+        return np.array(x)
+
+def make_bool(x):
+    if type(x) is bool:
+        return x
+    else:
+        return x.lower()=='true'
+
+def float_or_none(x):
+    if (x is None) or (x == 'None'):
+        return None
+    else:
+        return float(x)
+
+# INFO have following structure:
+#   key : (string to type converter, mandatory boolean, default value if optional)
+
+INFO_ATMO_ABSTRACT = {'lext':(float,True,None), # [m]
+                      'altitude':(np_array,True,None), # [m]
+                      'wind_speed':(np_array,True,None), # [m/s]
+                      'wind_direction':(np_array,True,None)} # [deg]
+
+INFO_ATMO_SEEING = dict(INFO_ATMO_ABSTRACT)
+INFO_ATMO_SEEING.update({'seeing':(float,True,None), # [arcsec]
+                         'cn2dh_ratio':(np_array,True,None)}) # [no unit]
+
+INFO_ATMO_CN2DH = dict(INFO_ATMO_ABSTRACT)
+INFO_ATMO_CN2DH.update({'cn2dh':(np_array,True,None)}) # [m^(-1/3)]
+
+INFO_SOURCE_SCIENCE = {'wvl_nm':(float,True,None), # [nm]
+                       'zenith_deg':(float,True,None)} # [deg]
+
+INFO_SOURCE_WFS = {'wvl_nm':(float,True,None), # [nm]
+                   'flux':(float,True,None),  # [ph/m²/s]
+                   'separation':(float,True,None), # [arcsec]
+                   'angle':(float,True,None), # [deg]
+                   'size':(float,True,None)} # [arcsec]
+
+INFO_PUPIL = {'diameter':(float,True,None), # [m]
+              'occultation':(float,True,None), # [no unit]
+              'nact':(int,True,None), # [no unit]
+              'ncpa':(float,False,0), # [nm RMS]
+              'nmode_ratio':(float,False,1.0)}
+
+INFO_RTC = {'freq':(float,True,None), # [Hz]
+            'delay':(float,True,None), # [ms]
+            'ki':(float,True,None)} # [no unit]
+
+INFO_WFS_ABSTRACT = {'lenslet':(int,True,None), # [no unit]
+                     'ron':(float,True,None), # [e-/pixel]
+                     'emccd':(make_bool,True,None)} # [no unit]
+
+INFO_PWFS = dict(INFO_WFS_ABSTRACT)
+INFO_PWFS.update({'modulation':(float,True,None),
+                  'og_compensation':(bool,False,False)}) # [lambda/D]
+
+INFO_SHWFS = dict(INFO_WFS_ABSTRACT)
+INFO_SHWFS.update({'samp':(float,True,None), # [no unit]
+                   'npix_cog':(int,True,None),
+                   'weight':(float_or_none,False,None)}) # [no unit]
+
+
+INFO = {'atmosphere_seeing':INFO_ATMO_SEEING,
+        'atmosphere_cn2dh':INFO_ATMO_CN2DH,
+        'source_science':INFO_SOURCE_SCIENCE,
+        'source_wfs':INFO_SOURCE_WFS,
+        'pupil':INFO_PUPIL,
+        'rtc':INFO_RTC,
+        'pwfs':INFO_PWFS,
+        'shwfs':INFO_SHWFS}
+
+
+def read_config_file(filepath, category):
+    """Generic function to read a specific category of a INI file"""
+    cfg = ConfigParser()
+    cfg.optionxform = str
+    out = cfg.read(filepath)
+    if len(out)==0:
+        # Try in the 'data' folder
+        filepath_data = os.path.dirname(os.path.abspath(__file__)) + os.path.sep + 'data' + os.path.sep + filepath
+        out = cfg.read(filepath_data)
+        if len(out)==0:
+            raise FileNotFoundError("The configuration file has not been found")
+        else:
+            logging.info('File <%s> has been found in <aopera/data/>'%filepath)
+    if not category in cfg.keys():
+        raise ValueError("The category [%s] does not appear in the configuration file"%category)
+    return cfg[category]
+
+
+def read_config_tiptop(filepath):
+    """
+    Read a TIPTOP INI file to generate aopera compatible dictionaries
+    """
+    cfg = ConfigParser()
+    cfg.optionxform = str
+    out = cfg.read(filepath)
+    if len(out)==0:
+        raise FileNotFoundError("The configuration file has not been found")
+    
+    cfg_tel = cfg['telescope']
+    cfg_atm = cfg['atmosphere']
+    dm_act = eval(cfg['DM']['NumberActuators'])
+    
+    if len(dm_act)>1: #TODO: SCAO only
+        raise ValueError('TIPTOP file has more than one DM, this is not compatible with aopera')
+    
+    if float(cfg_atm['Wavelength']) != WVL_REF_SEEING:
+        raise ValueError('TIPTOP file must define seeing at %u nm'%(WVL_REF_SEEING*1e9))
+    
+    if 'SensorFrameRate_LO' in cfg['RTC'].keys():
+        raise ValueError('Cannot use a Low Order split with aopera')
+    
+    area_shape = cfg['DM']['AoArea'].replace('\'','')
+    if area_shape == 'circle':
+        nmode_ratio = np.pi/4
+    elif area_shape == 'square':
+        nmode_ratio = 1
+    else:
+        raise ValueError('Error when reading Tiptop file, the DM AoArea must be `circle` or `square`')
+    
+    pupil = {'diameter':float(cfg_tel['TelescopeDiameter']),
+             'occultation':float(cfg_tel['ObscurationRatio']),
+             'nact':dm_act[0],
+             'nmode_ratio':nmode_ratio}
+    
+    atmosphere = {'seeing':float(cfg_atm['Seeing']),
+                  'cn2dh_ratio':np_array(cfg_atm['Cn2Weights']),
+                  'lext':float(cfg_atm['L0']),
+                  'altitude':np_array(cfg_atm['Cn2Heights']),
+                  'wind_speed':np_array(cfg_atm['WindSpeed']),
+                  'wind_direction':90 - np_array(cfg_atm['WindDirection'])}
+    
+    nb_frame_delay = float(cfg['RTC']['LoopDelaySteps_HO']) - 1 # TIPTOP counts WFS integration as frame delay
+    freq = float(cfg['RTC']['SensorFrameRate_HO'])
+    
+    rtc = {'freq':freq,
+           'delay':nb_frame_delay/freq*1e3,
+           'ki':float(cfg['RTC']['LoopGain_HO'])}
+    
+    if eval(cfg['sources_science']['Zenith'])[0] != 0:
+        raise ValueError('aopera evaluates performance at center of array, source science zenith angle should be null.')
+    
+    src_sci_wvl = eval(cfg['sources_science']['Wavelength'])
+    if len(src_sci_wvl) > 1:
+        raise NotImplementedError('No compatibility between TIPTOP and aopera for multiple science wavelengths.')
+    src_sci = {'wvl_nm':src_sci_wvl[0]*1e9,
+               'zenith_deg':float(cfg_tel['ZenithAngle'])}
+    
+    cfg_src_wfs = cfg['sources_HO']
+    cfg_wfs = cfg['sensor_HO']
+    
+    wfs_type = cfg_wfs['WfsType']
+    if int(cfg_wfs['ExcessNoiseFactor']) == 1:
+        emccd = False
+    elif int(cfg_wfs['ExcessNoiseFactor']) == 2:
+        emccd = True
+    else:
+        raise ValueError('Can only process ExcessNoiseFactor with value 1 or 2')
+    
+    wfs_nb_lenslet = eval(cfg_wfs['NumberLenslets'])
+    if len(wfs_nb_lenslet) > 1:
+        raise ValueError('TIPTOP file has more than one WFS, this is not compatible with aopera')
+    
+    wfs = {'lenslet':wfs_nb_lenslet[0],
+           'ron':float(cfg_wfs['SigmaRON']),
+           'emccd':emccd}
+    
+    nb_phot_wfs = eval(cfg_wfs['NumberPhotons'])[0] # nb photon/subap/frame
+    wfs_flux = nb_phot_wfs * rtc['freq'] * wfs['lenslet']**2 / pupil['diameter']**2
+    
+    
+    src_wfs = {'wvl_nm':float(cfg_src_wfs['Wavelength'])*1e9,
+               'flux':wfs_flux,
+               'separation':eval(cfg_src_wfs['Zenith'])[0],
+               'angle':eval(cfg_src_wfs['Azimuth'])[0],
+               'size':0}
+    
+    if 'Pyramid' in wfs_type:
+        wfs['modulation'] = float(cfg_wfs['Modulation'])
+    elif 'Shack-Hartmann' in wfs_type:
+        logging.warning('TIPTOP and aopera definitions for SH spot CoG algorithm have to be checked.')
+        pix_rad = arcsec2rad(float(cfg_wfs['PixelScale'])*1e-3)
+        lmbd_dpup = src_wfs['wvl_nm'] * 1e-9 / (pupil['diameter']/wfs['lenslet'])
+        wfs['samp'] = lmbd_dpup / pix_rad
+        wfs['npix_cog'] = 10
+    else:
+        raise ValueError('Unknown TIPTOP WFS type')
+    
+    return pupil, atmosphere, wfs, rtc, src_sci, src_wfs
+    
+
+def read_config_tiptop_samp(filepath):
+    """Read a TIPTOP INI file and compute PSF sampling at WFS wavelength"""
+    cfg = ConfigParser()
+    cfg.optionxform = str
+    out = cfg.read(filepath)
+    if len(out)==0:
+        raise FileNotFoundError("The configuration file has not been found")
+    diameter = float(cfg['telescope']['TelescopeDiameter'])
+    wvl_wfs = float(cfg['sources_HO']['Wavelength'])
+    pix_mas = float(cfg['sensor_science']['PixelScale'])
+    return (wvl_wfs/diameter) / arcsec2rad(pix_mas*1e-3)
+
+
+def read_config_tiptop_nx(filepath):
+    """Read a TIPTOP INI file and compute PSF sampling at WFS wavelength"""
+    cfg = ConfigParser()
+    cfg.optionxform = str
+    out = cfg.read(filepath)
+    if len(out)==0:
+        raise FileNotFoundError("The configuration file has not been found")  
+    return int(cfg['sensor_science']['FieldOfView'])
+    
+
+def check_dictionary(dictionary, category_name):
+    """
+    Check keywords.
+    Return a dictionary with optional keywords filled with default value.
+    """
+    for k in INFO[category_name].keys():
+        if not k in dictionary.keys():
+            if INFO[category_name][k][1]: # Keyword is mandatory
+                logging.error('The keyword \'%s\' is mandatory in the category \'%s\''%(k,category_name))
+            else:
+                # logging.warning('The keyword \'%s\' has not been defined in the category \'%s\', it is set to default value \'%s\''%(k,category_name,INFO[category_name][k][2]))
+                logging.warning('Undefined keyword set to default value \'%s.%s=%s\''%(category_name,k,INFO[category_name][k][2]))
+                try:
+                    dictionary[k] = INFO[category_name][k][2]
+                except: # config parser requires strings
+                    dictionary[k] = str(INFO[category_name][k][2])
+        else:
+            try:
+                INFO[category_name][k][0](dictionary[k]) # try type conversion
+            except:
+                logging.error('The keyword \'%s\' in the category \'%s\' does not have the correct type'%(k,category_name))
+    for k in dictionary.keys():
+        if not k in INFO[category_name].keys():
+            logging.warning('The keyword \'%s\' is ignored by the category \'%s\''%(k,category_name))
+    return dictionary
+
+
+def set_attribute(slf, dictionary, category_name):
+    """
+    Set a disctionary as attribute of the Python object `slf`
+    """
+    dictionary = check_dictionary(dictionary, category_name)
+    for k in INFO[category_name].keys():
+        setattr(slf, k, INFO[category_name][k][0](dictionary[k]))
+