deblend-sofia-detections 0.0.1__py3-none-any.whl

deblend_sofia_detections/__init__.py

@@ -0,0 +1,61 @@
+# -*- coding: future_fstrings -*-
+
+try:
+    from importlib.metadata import version
+except ImportError:
+    # Try backported to PY<37 `importlib_resources`.
+    # For Py<3.9 files is not available
+    from importlib_metadata import version 
+
+import os
+import subprocess
+
+def report_version():
+    # Distutils standard  way to do version numbering
+    try:
+        __version__ = version("deblend_sofia_detections")
+    except:
+        __version__ = "devel"
+
+    # perhaps we are in a github with tags; in that case return describe
+    path = os.path.dirname(os.path.abspath(__file__))
+    try:
+        # work round possible unavailability of git -C
+        result = subprocess.check_output(
+            'cd %s; git describe --tags' % path, shell=True, stderr=subprocess.STDOUT).rstrip().decode()
+    except subprocess.CalledProcessError:
+        result = None
+    if result != None and 'fatal' not in result:
+        # will succeed if tags exist
+        return result
+    else:
+        # perhaps we are in a github without tags? Cook something up if so
+        try:
+            result = subprocess.check_output(
+                'cd %s; git rev-parse --short HEAD' % path, shell=True, stderr=subprocess.STDOUT).rstrip().decode()
+        except subprocess.CalledProcessError:
+            result = None
+        if result != None and 'fatal' not in result:
+            return __version__+'-'+result
+        else:
+            # we are probably in an installed version
+            return __version__
+
+def report_branch():
+    path = os.path.dirname(os.path.abspath(__file__))
+    result = None
+    try:
+        branches = subprocess.check_output(\
+            'cd %s; git branch' % path, shell=True, stderr=subprocess.STDOUT).rstrip().decode().split()
+        for i,line in enumerate(branches):
+            if line == '*':
+                result=branches[i+1]
+                break
+    except subprocess.CalledProcessError:
+        result= None
+    return result
+
+__version__ = report_version()
+__branch__ = report_branch()
+
+#set_logger_values()

deblend_sofia_detections/catalogue/download.py

@@ -0,0 +1,98 @@
+# -*- coding: future_fstrings -*-
+#Functions that look for optical image
+
+from deblend_sofia_detections.deblending.image_manipulation import cut_optical
+from deblend_sofia_detections.support.errors import DownloadError
+from astropy import units as u
+from astropy.io import fits
+from astroquery.skyview import SkyView
+from astropy.coordinates import SkyCoord
+from astropy.wcs import WCS
+
+import os
+import warnings
+import numpy as np
+
+
+
+def download_full_FOV_optical(cfg):
+    SkyView.URL = 'https://skyview.gsfc.nasa.gov/current/cgi/basicform.pl'
+    if cfg.general.verbose:
+        print(f'Quering the Sky Survey')
+    if not os.path.isdir(f'{cfg.internal.ancillary_directory}/'):
+        os.system(f'mkdir {cfg.internal.ancillary_directory}/')
+    #First we open the moment header 0 to get the extend of the field 
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")     
+        mom0_header = fits.getheader(f'{cfg.internal.sofia_directory}/{cfg.internal.sofia_basename}_mom0.fits')
+        mom0_wcs = WCS(mom0_header).celestial
+    #set the size of the image
+    size = np.nanmax([abs(mom0_header['NAXIS1']*mom0_header['CDELT1'])*60.,
+                      abs(mom0_header['NAXIS2']*mom0_header['CDELT2'])*60.,])
+    size_quantity= u.Quantity(size,u.arcmin)
+    #get_image_list seems to guess at the pixel size let's fix it to 3 arcsec 
+    beam = mom0_header['BMAJ'] * u.deg
+    optical_pixel_scale = beam.to(u.arcsec).value/cfg.general.optical_pixel_scale * u.arcsec
+    #If the resolution of our optical images is greater than 5 the deblending becomes hairy 
+    if optical_pixel_scale > 4.*u.arcsec:
+        optical_pixel_scale = 4. * u.arcsec
+    size_pixels = (size_quantity.to(u.arcsec).value/optical_pixel_scale.value).astype(int)
+    #obtain the central coordinates
+    ra,dec = mom0_wcs.wcs_pix2world(mom0_header['NAXIS1']/2., mom0_header['NAXIS2']/2.,1.)
+    obj_coords = SkyCoord(ra= ra* u.degree, dec= dec * u.degree, frame='fk5')
+
+  
+    if not cfg.input.manual_optical_image[0] is None:
+        if cfg.general.verbose:
+            print(f'Checking manual input')
+        for identifier in cfg.general.manual_optical_image:
+            if os.path.isfile(identifier):
+                print(f'Found manual optical image: {identifier}')
+            manual_path,manual_file = os.path.split(identifier)
+            if manual_path == '':
+                manual_path = './'
+            cutout = cut_optical(mom0_header,mom0_wcs,\
+                manual_path,
+                manual_file)
+
+            cutout_hdr = cutout.wcs.to_header()
+            cutout_hdr['COMMENT'] =  f'The original file was  {identifier}'
+            fits.writeto(f'{cfg.internal.ancillary_directory}/moment0_full_DSS.fits',cutout.data,cutout_hdr,overwrite=True)
+
+            return
+
+
+    if cfg.general.verbose:
+        print(f'''Obtaining the actual image list with the following parameters:
+object coordinates: {obj_coords.to_string('hmsdms')},
+radius: {size_quantity},
+pixels: {size_pixels},''')
+    #SkyView.clear_cache()
+    sky_view_list = SkyView.get_image_list(position=obj_coords,
+                                   radius = size_quantity,
+                                   coordinates = "J2000",
+                                   pixels = size_pixels,
+                                   cache=True,
+                                   #survey=['WISE 3.4'])
+                                   #survey=['2MASS-K'])
+                                   survey=['DSS2 Red'])
+
+    if cfg.general.verbose:
+        print(f'''Obtained {len(sky_view_list)} images from SkyView
+{sky_view_list}
+              ''')
+    for path in sky_view_list:
+        if cfg.general.verbose:
+            print(f'''Starting the download for {cfg.internal.data_cube}.
+This can take a while.''')
+        filename = path.split("/")[-1]
+        os.system('wget '+path)
+        if os.path.isfile(filename):
+            print("Successfully downloaded the image")
+            os.system(f'mv {filename} {cfg.internal.ancillary_directory}/moment0_full_DSS.fits')
+        else:
+            print("Failed to obtain the image from SkyView")
+            raise DownloadError(f'''Failed to download the image from SkyView: {path}
+Check your internet connection and the SkyView service status.
+Note that redownloading the exact same image may fail if it has recently been removed from the SkyView archive.
+''')

deblend_sofia_detections/catalogue/search.py

@@ -0,0 +1,304 @@
+from deblend_sofia_detections.support.errors import InputError
+from deblend_sofia_detections.support.table_functions import check_table_length,\
+    read_manual_table, combine_tables, copy_table_header
+from deblend_sofia_detections.support.support_functions import convertRADEC,\
+    isquantity, get_nan_for_dtype,calculate_projected_distance
+
+from astropy.coordinates import SkyCoord
+from astropy.io import fits
+from astropy.table import QTable, Column
+
+from astroquery.ipac.ned import Ned
+
+import astropy.units as u
+import copy
+import numpy as np
+import time
+
+Ned.TIMEOUT = 3600
+
+def find_NED_counterpart(cfg,source,header_info, sysrange = None,\
+        weights = [1.,1.,1.],weight_min_area = False ):
+    requested_columns=['Object Name','RA','DEC','Velocity','Type',\
+        'Magnitude and Filter','Distance']
+  
+    coordinates = [source['ra'].unmasked,source['dec'].unmasked]
+    #coordinates, radius
+    #[source['ra'],source['dec'],source['v_sofia']],\
+    #            beam_size[0]/2.
+    
+    co = SkyCoord(ra=coordinates[0], dec=coordinates[1], frame='fk5')
+
+    # Setup a search table in ned
+    vsys, radius = set_search_radius(cfg,source,header_info,sysrange,
+        counterpart_region=cfg.general.counterpart_region)
+    if cfg.general.verbose:
+        print("Querying NED")
+        print(f'Search a radius {radius.to(u.arcmin)} around {", ".join(convertRADEC(*[x.value for x in coordinates[:2]]))}')
+    # get the NED table
+    try:
+        internet_table = Ned.query_region(co, radius=radius, equinox='J2000.0')
+    except:
+        time.sleep(10)
+        try:
+            internet_table = Ned.query_region(co, radius=radius, equinox='J2000.0')
+        except Exception as e:
+            raise InputError(f'Could not query NED, error {e}')
+    # as astropy is the dumbest project ever they can not be consistant so 
+    # we have to correct the units for RA and DEg
+    internet_table['RA'].unit=u.deg
+    internet_table['DEC'].unit=u.deg
+    # Astropy is so stupid that it does not provide a QTable from the query
+    # so we have to do this as well. 
+    result_table = QTable()
+    for x in requested_columns:
+        if x in internet_table.colnames:
+            tmp_column= internet_table[x]
+            tmp_column[tmp_column.mask] = float('NaN')
+           
+            result_table[x] = Column(tmp_column,\
+                                unit=internet_table[x].unit)
+        else:
+            result_table[x] = Column([None for x in range(check_table_length(internet_table))])
+           
+  
+    #select out the galaxies
+    objects_to_select = ['G','GPAIR','GTRPL']
+    rows = [True if x.upper() in objects_to_select else False for x in result_table['Type']]
+    search_table = result_table[rows]
+   
+    # if we have set a range of velocities we mask all that that are outside the range
+    if not sysrange is None:
+        rows =  [True if vsys-sysrange < x < vsys+sysrange else False for x in search_table['Velocity']]
+        search_table = search_table[rows]
+    else:
+        # if we do not have a velocity range we have to make sure that we take the None as float
+        search_table['Velocity'] = [float('NaN') if x is None else x for x in search_table['Velocity']]
+       
+    if check_table_length(search_table) > 0:
+        if not isquantity(search_table['Velocity']):
+            search_table['Velocity'].unit = u.km/u.s
+        else:
+            if search_table['Velocity'].unit != u.km/u.s:
+                try:
+                    search_table['Velocity'] = [x.to(u.km/u.s).value for x in search_table['Velocity']]
+                    search_table['Velocity'].unit = u.km/u.s
+                except:
+                    raise InputError(f'the NED counterpart for {source["Name"]} has a weird unit {search_table["Velocity"].unit}')
+   
+    # first sort on distance, we always do this cause else we do not get the Spatial and combined columns
+    search_table = sort_on_distance(search_table, coordinates,vsys)
+    if len(search_table) > 1:
+        # then pick NGC/UGC/ESO/M matches
+        search_table = sort_by_name(search_table)
+
+    if check_table_length(search_table) > 0:
+        name = search_table['Object Name'][0]
+        if ':' in name:
+            search_table['Object Name'][0] = name.split(':')[0]
+    if search_table['Velocity Diff'].unit != u.km/u.s:
+        print(search_table)
+        print(f'Velocity Diff unit is {search_table["Velocity Diff"].unit}')
+   
+    return search_table
+
+
+def find_manual_counterpart(cfg,source,header_info, sysrange=None):
+    if cfg.input.manual_input_tables[0] is None:
+        return  QTable()
+    manual_table = read_manual_table(cfg)
+    coordinates = [source['sofia_ra'][0],source['sofia_dec'][0]]
+    vsys, radius = set_search_radius(cfg,source,header_info,sysrange,
+        counterpart_region=cfg.general.counterpart_region)
+    search_table = sort_on_distance(manual_table, coordinates,vsys)
+    if cfg.general.verbose:
+        print(f'Searching for manual counterpart for {source["sofia_id"][0]}')
+        print(f'Search a radius {radius.to(u.arcsec)} around {", ".join(convertRADEC(coordinates[0].value,coordinates[1].value))}')
+        print(f' The nearest target is {search_table["Name"][0]} at a distance of {search_table["Spatial Diff"][0].to(u.arcsec)}')
+        print(f'And the velocity difference is {search_table["Velocity Diff"][0].to(u.km/u.s)} to vsys {vsys.to(u.km/u.s)}')
+   
+    # if we have set a range of velocities we mask all that that are outside the range
+    if search_table['Spatial Diff'][0] > 2.*radius.to(u.arcsec) or\
+       search_table['Velocity Diff'][0] > sysrange:
+       search_table = QTable()
+    return search_table
+   
+
+
+
+def search_counter_part(cfg,source,sofia_directory= './',
+        basename=None,query ='NED',insource=None):
+    '''Look for the optical counterpart of the source'''
+    try:
+        inid = source['id']
+    except:
+        inid = source['sofia_id'][0]
+    if cfg.general.verbose:
+        print(f'Searching in {query} to find a counterpart for {basename} with id {inid}')
+   
+    input_dir = f'{sofia_directory}/{basename}_cubelets'
+    cube = fits.open(f'{input_dir}/{basename}_{inid}_cube.fits',\
+        output_verify='warn')
+    header_info= {'BMAJ':float(cube[0].header['BMAJ'])*u.deg,
+                  'pixelsize': float(np.mean([abs(cube[0].header['CDELT1']),\
+                                              abs(cube[0].header['CDELT1'])]))\
+                                              *u.deg\
+                                                 }
+   
+    # first try a spectroscopic match
+    if query.upper() == 'NED':
+        spectroscopic_table = find_NED_counterpart(cfg,source, header_info,\
+            sysrange=150.*u.km/u.s)
+        search_id = 'NED'
+        pref =''
+    elif query.upper() == 'MANUAL':
+        spectroscopic_table = find_manual_counterpart(cfg,source, header_info,
+            sysrange=150.*u.km/u.s)  
+        search_id = 'Manual'
+        pref = 'sofia_'
+    confirmed = True
+   
+    if check_table_length(spectroscopic_table) > 0:
+        new_table = spectroscopic_table   
+    else:
+        if cfg.general.verbose:
+            print(f'We found no match within the velocity range, picking the closest object without velocity')
+        if query.upper() == 'NED':
+            possible_table = find_NED_counterpart(cfg,source, header_info)
+        if query.upper() == 'MANUAL':
+            possible_table = QTable()
+        new_table = possible_table
+        confirmed = False
+    #We don't need the searching rows
+    #false_table = True
+    #if query.upper() == 'NED':
+    #    false_table = False
+    if check_table_length(new_table) > 0: # and false_table:
+        new_table=new_table[0:1]
+        final_row = combine_tables(new_table,source,column_indicators=[search_id,insource])
+        final_row[f'{search_id}_spectroscopic'] = confirmed
+    else:
+        if cfg.general.verbose:
+            print(f'We found no {search_id} counterpart for {source[pref+"id"]}')
+        if query.upper() == 'NED':
+            requested_columns = ['Object Name','RA','DEC','Velocity','Type',\
+                'Magnitude and Filter','Distance','Spatial Diff','Velocity Diff',\
+                'Combined Diff']
+            requested_dtypes = ['U30',float,float,float,object,object,object,float,float,float]
+            requested_units = [None,u.deg,u.deg,u.km/u.s,None,None,None,u.deg,u.km/u.s,None]
+        elif query.upper() == 'MANUAL':
+            manual_table = read_manual_table(cfg,need_velocity=False)
+            # Add the difference columns 
+            add_units = [u.deg, u.km/u.s, u.dimensionless_unscaled]
+            for i,col in enumerate(['Spatial Diff','Velocity Diff','Combined Diff']):
+                if col not in manual_table.colnames:
+                    manual_table.add_column(np.nan,name=col)
+                    manual_table[col].unit = add_units[i]
+            requested_columns = []
+            requested_dtypes = []
+            requested_units = []
+            for col in manual_table.colnames:
+                requested_columns.append(col)
+                requested_dtypes.append(manual_table[col].dtype)
+                requested_units.append(manual_table[col].unit)
+        requested_values = []
+        for dt in requested_dtypes:
+            requested_values.append(get_nan_for_dtype(dt))    
+        dummy_table = QTable(names=requested_columns \
+            ,dtype=requested_dtypes,units = requested_units)
+        dummy_table.add_row(requested_values)
+        final_row = combine_tables(dummy_table,source,column_indicators=[search_id,insource])
+        final_row[f'{search_id}_spectroscopic'] = False
+       
+    return final_row
+
+
+def set_search_radius(cfg,source,header_info,sysrange=None,
+        counterpart_region = 'Beam'):
+    vsys = None
+    pref = ''
+    for col in source.colnames:
+            if 'sofia_' in col.lower():
+                pref = 'sofia_'
+    if not sysrange is None:
+        vsys = source[pref+'v_sofia'].to(u.km/u.s) #systemic in km/s
+            
+    if counterpart_region.lower() in ['beam']:
+        radius = header_info['BMAJ']/2.
+    elif counterpart_region.lower() in ['3beam']:
+        radius = header_info['BMAJ']*3./2.
+    elif counterpart_region.lower() in ['box']:
+        radius = np.max([source[pref+'x'].value-source[pref+'x_min'].value,\
+                         source[pref+'x_max'].value-source[pref+'x'].value,
+                         source[pref+'y'].value-source[pref+'y_min'].value,
+                         source[pref+'y_max'].value-source[pref+'y'].value
+                         ])*header_info['pixelsize']
+    else:
+        raise InputError(f'We dont know what to do with {counterpart_region} for counterpart_region')
+    return vsys, radius
+
+
+
+''' Sort our table based on catalogue name'''
+def sort_by_name(table):
+    #print(table)
+    # The order we prefer things in 
+    preferred_order = [['NGC'], ['UGC','ESO'], ['M']]
+    new_table = copy_table_header(  table,)
+   
+    # add the rows to our table  based on the preferred order
+    for names in preferred_order:
+        for row in table:
+            row_name = row['Object Name']
+            for identifier in names:
+                if row_name[:len(identifier)].upper() == identifier:
+                    if len(identifier) == 1:
+                        if not row_name[len(identifier):].isdigit():
+                            continue
+                    new_table.add_row(row)
+    #Attach all final objects that did not have a preffered order
+    selected_objects = [x['Object Name'] for x in new_table]
+    for row in table:
+        if row['Object Name'] not in selected_objects:
+            new_table.add_row(row)
+
+    return new_table            
+
+'''Sort the table by distance'''
+def sort_on_distance(table_in,coordinates,vsys,weights = [1.,1.],print_in=False):
+    # this stupid table is not ordered so get names, types ra and dec and sort on distance
+    for x in table_in.colnames:
+        if x.lower() in ['spatial_diff','velocity_diff', 'combined_diff']:
+            raise InputError(f'Column {x} is not allowed in the table, please rename it')     
+    if print_in:
+        print(f'Before sorting: {table_in}')    
+        print(f'This the table type {type(table_in)}')
+    table = copy.deepcopy(table_in)
+    table['Spatial Diff'] = [calculate_projected_distance([x,\
+        y],coordinates,no_PA = True).value for x,y in zip(\
+        table['RA'],table['DEC'])]* u.deg
+    if not vsys is None:
+        velocities = table['Velocity'].to(u.km/u.s)
+        if isquantity(velocities):
+            velocities = velocities.value
+        if isquantity(vsys):
+            vsys = vsys.to(u.km/u.s).value
+        table['Velocity Diff'] = [float(abs(vsys-z)/weights[1])\
+            for z in velocities] * u.km/u.s
+        table['Combined Diff']= [float(np.sqrt(x.value**2+y.to(u.arcsec).value**2)) for x,y in\
+            zip(table['Velocity Diff'],table['Spatial Diff'])] * u.dimensionless_unscaled
+             
+        table.sort('Combined Diff')
+       
+    else:
+      
+        table['Velocity Diff'] = [float('NaN') for x in table['Spatial Diff']]\
+            * u.km/u.s
+        table['Combined Diff'] = [float('NaN') for x in table['Spatial Diff']]\
+            * u.dimensionless_unscaled
+        table.sort('Spatial Diff')
+    if print_in:
+        print(f'After sorting: {table}')
+        
+    return table
+           

deblend_sofia_detections/config/config.py

@@ -0,0 +1,51 @@
+# OmegaConf setups
+
+from dataclasses import dataclass, field
+from omegaconf import OmegaConf,MISSING
+from typing import List, Optional
+
+import os
+import psutil
+
+
+@dataclass
+class Input:
+    sofia_parameters: str = 'sofia_input.par' #Give full pathe else expected in the run directory
+    manual_input_tables:  List = field(default_factory=lambda: [None])
+      # If True we will update the manual input table with the information found online
+    manual_optical_image: List = field(default_factory=lambda: [None])
+
+@dataclass
+class General:
+    verbose: bool = True
+    try:
+        ncpu: int = len(psutil.Process().cpu_affinity())
+    except AttributeError:
+        ncpu: int = psutil.cpu_count()
+    multiprocessing: bool = True
+    optical_pixel_scale: float = 5. # Amount of optical pixels that should cover a beam
+    counterpart_region: str = 'Beam' 
+
+
+@dataclass
+class Internal:
+    ancillary_directory: str = MISSING
+    data_cube: str = MISSING
+    data_directory: str = MISSING
+    run_directory: str = MISSING
+    sofia_catalogue: str = MISSING
+    sofia_directory: str = MISSING
+    sofia_parameter_file: str = MISSING
+    sofia_basename: str = MISSING
+  
+    #font_file: str = "/usr/share/fonts/truetype/msttcorefonts/Times_New_Roman.ttf"
+
+@dataclass
+class defaults:
+    print_examples: bool = False
+    configuration_file: Optional[str] = None
+    input: Input = field(default_factory = Input)
+    general: General = field(default_factory = General)
+    internal: Internal = field(default_factory = Internal)
+
+

deblend_sofia_detections/config/functions.py

@@ -0,0 +1,110 @@
+from deblend_sofia_detections.config.config import defaults
+from deblend_sofia_detections.support.errors import InputError
+from deblend_sofia_detections.support.system_functions import create_directory
+from deblend_sofia_detections.deblending.sofia_functions import load_sofia_input_file
+from omegaconf import OmegaConf
+
+import os
+import psutil
+import sys
+import deblend_sofia_detections
+try:
+    from importlib.resources import files as import_pack_files
+except ImportError:
+    # Try backported to PY<37 `importlib_resources`.
+    # For Py<3.9 files is not available
+    from importlib_resources import files as import_pack_files
+    
+
+def setup_config(argv):
+    if '-v' in argv or '--version' in argv:
+        print(f"This is version {deblend_sofia_detections.__version__} of the program.")
+        sys.exit()
+
+    if '-h' in argv or '--help' in argv:
+        print('''
+Use package_name in this way:
+
+All config parameters can be set directly from the command line by setting the correct parameters, e.g:
+create_package_name def_file=cube.fits error_generator=tirshaker 
+''')
+        sys.exit()
+
+
+    cfg = OmegaConf.structured(defaults)
+    if cfg.general.ncpu == psutil.cpu_count():
+        cfg.general.ncpu -= 1
+    inputconf = OmegaConf.from_cli(argv)
+    cfg_input = OmegaConf.merge(cfg,inputconf)
+    
+    if cfg_input.print_examples:
+        default_name = f'{__name__.split(".")[0]}_default.yml' 
+        masked_copy = OmegaConf.masked_copy(cfg,\
+                    ['input','general'])
+           
+        with open(default_name,'w') as default_write:
+            default_write.write(OmegaConf.to_yaml(masked_copy))
+        print(f'''We have printed the file {default_name} in {os.getcwd()}.
+Exiting {__name__.split(".")[0]}.''')
+        my_resources = import_pack_files('deblend_sofia_detections.template')
+        data = (my_resources / 'sofia_template.par').read_bytes()
+        with open('sofia_template.par','w+b') as default_write:
+            default_write.write(data)
+        print(f'''We have printed the file  sofia_template.par in {os.getcwd()}.
+''')
+        sys.exit()
+        
+
+    if cfg_input.configuration_file:
+        succes = False
+        while not succes:
+            try:
+                yaml_config = OmegaConf.load(cfg_input.configuration_file)
+        #merge yml file with defaults
+                cfg = OmegaConf.merge(cfg,yaml_config)
+                succes = True
+            except FileNotFoundError:
+                cfg_input.configuration_file = input(f'''
+You have provided a config file ({cfg_input.configuration_file}) but it can't be found.
+If you want to provide a config file please give the correct name.
+Else press CTRL-C to abort.
+configuration_file = ''')
+    cfg = OmegaConf.merge(cfg,inputconf) 
+
+    #open the input parameter file to obtain the data cube and output locations
+    cfg = read_parameter_input(cfg)
+
+    cfg = directory_check(cfg)    
+    return cfg
+
+
+def directory_check(cfg):
+
+    for test_dir in [cfg.internal.data_directory, cfg.internal.sofia_directory, cfg.internal.run_directory]:
+        if not os.path.isdir(test_dir):
+            raise InputError(f'''The directory {test_dir} does not exist.''')
+    return cfg
+
+
+def read_parameter_input(cfg):
+    cfg.internal.run_directory = os.getcwd()
+    parameters = load_sofia_input_file(cfg.input.sofia_parameters)
+    input_pathname,parameter_file = os.path.split(cfg.input.sofia_parameters)
+    cfg.internal.sofia_parameter_file = parameter_file
+    if input_pathname == '' or input_pathname[0] != '/':
+        input_pathname = os.path.join(os.getcwd(),input_pathname)
+    data_path,data_file = os.path.split(parameters['input.data'])
+    if data_path == '' or data_path[0] != '/':
+        cfg.internal.data_directory = f'{input_pathname}{data_path}'
+    else:
+        cfg.internal.data_directory = data_path
+    cfg.internal.ancillary_directory = f'{cfg.internal.data_directory}/ancillary_data'
+    cfg.internal.data_cube = data_file
+    cfg.internal.sofia_basename = parameters['output.filename']
+    if cfg.internal.sofia_basename == '':
+        cfg.internal.sofia_basename = os.path.splitext(data_file)[0]
+    cfg.internal.sofia_directory = parameters['output.directory']
+    if cfg.internal.sofia_directory == '' or cfg.internal.sofia_directory[0] != '/':
+        cfg.internal.sofia_directory = os.path.join(input_pathname,cfg.internal.sofia_directory)
+    
+    return cfg