Source code for dysmalpy.lensing

# -*- coding: utf-8 -*-
# Copyright (c) MPE/IR-Submm Group. See LICENSE.rst for license information. 
"""
    This is a Python code to implement lensing tranformation in DysmalPy.
    This code uses the C++ library `libLensingTransformer.so`.
    
    .. Last updates:
    ..     2021-08-03, finished first version, Daizhong Liu, MPE.
    ..     2021-08-04, added self.image_plane_data_cube and self.image_plane_data_info, set logging, Daizhong Liu, MPE.
    ..     2022-05-24, change to take ObsLensingOptions instance as input vs params dict.
    ..     2022-06-18, change back to simple params dict and do not use ObsLensingOptions here.

"""

__all__=['LensingTransformer']

import os, sys, datetime, timeit, glob
import logging
logger = logging.getLogger(__name__) # here we do not setLevel so that it inherits its caller logging level.
if '__main__' in logging.Logger.manager.loggerDict: # pragma: no cover
    logger.setLevel(logging.getLogger('__main__').level)
import ctypes
from ctypes import cdll, c_void_p, c_char_p, c_double, c_long, c_int, POINTER
import numpy as np
import multiprocessing, threading
from distutils.sysconfig import get_config_var

mylibfile = os.path.abspath(os.path.dirname(__file__))+os.sep+"lensingTransformer"+get_config_var('EXT_SUFFIX')

# ++++++++++++
if not os.path.isfile(mylibfile):
    mylibfile = os.path.abspath(os.path.dirname(__file__))+os.sep+"lensingTransformer*.so"
    mylibfile = glob.glob(mylibfile)[0]
# ++++++++++++
mylib = cdll.LoadLibrary(mylibfile)
cached_lensing_transformer_dict = {'0': None}

[docs] class LensingTransformer(object): """docstring for LensingTransformer Args: `mesh_file`: String. The "mesh.dat" file from the lensing modeling using Glafic software. `verbose`: Boolean. The verbose level for this Python class. `c_verbose`: Integer. The verbose level for the C program. """ def __init__( self, mesh_file, mesh_ra, mesh_dec, source_plane_data_cube = None, source_plane_nx = None, source_plane_ny = None, source_plane_nchan = None, source_plane_cenra = None, source_plane_cendec = None, source_plane_pixsc = None, source_plane_cenx = None, source_plane_ceny = None, image_plane_cenra = None, image_plane_cendec = None, image_plane_pixsc = None, image_plane_sizex = None, image_plane_sizey = None, image_plane_cenx = None, image_plane_ceny = None, verbose = True, c_verbose = 0, ): # self.logger = logging.getLogger('LensingTransformer') self.logger.setLevel(logging.getLevelName(logging.getLogger(__name__).level)) # self.logger.setLevel(logging.INFO) if verbose: self.printLibInfo() global mylib self.mylib = mylib self.myobj = None self.mesh_file = mesh_file self.mesh_ra = mesh_ra self.mesh_dec = mesh_dec self.source_plane_data_cube = None self.source_plane_data_info = None self.source_plane_nx = None self.source_plane_ny = None self.source_plane_nchan = None self.source_plane_cenra = None self.source_plane_cendec = None self.source_plane_pixsc = None self.source_plane_cenx = None self.source_plane_ceny = None self.image_plane_cenra = None self.image_plane_cendec = None self.image_plane_pixsc = None self.image_plane_sizex = None self.image_plane_sizey = None self.image_plane_cenx = None self.image_plane_ceny = None self.image_plane_data_cube = None self.image_plane_data_info = None if source_plane_nx is not None: self.source_plane_nx = source_plane_nx if source_plane_ny is not None: self.source_plane_ny = source_plane_ny if source_plane_nchan is not None: self.source_plane_nchan = source_plane_nchan if source_plane_cenra is not None: self.source_plane_cenra = source_plane_cenra if source_plane_cendec is not None: self.source_plane_cendec = source_plane_cendec if source_plane_pixsc is not None: self.source_plane_pixsc = source_plane_pixsc if source_plane_cenx is not None: self.source_plane_cenx = source_plane_cenx if source_plane_ceny is not None: self.source_plane_ceny = source_plane_ceny if image_plane_cenra is not None: self.image_plane_cenra = image_plane_cenra if image_plane_cendec is not None: self.image_plane_cendec = image_plane_cendec if image_plane_pixsc is not None: self.image_plane_pixsc = image_plane_pixsc if image_plane_sizex is not None: self.image_plane_sizex = image_plane_sizex if image_plane_sizey is not None: self.image_plane_sizey = image_plane_sizey if image_plane_cenx is not None: self.image_plane_cenx = image_plane_cenx if image_plane_ceny is not None: self.image_plane_ceny = image_plane_ceny if source_plane_data_cube is not None: if np.any([t is None for t in [\ source_plane_cenra, source_plane_cendec, source_plane_pixsc]]): raise Exception('Error! source_plane_data_cube is not None but one of source_plane_cenra/cendec/pixsc is None! Please input all of them.') # self.source_plane_nx = source_plane_data_cube.shape[2] self.source_plane_ny = source_plane_data_cube.shape[1] self.source_plane_nchan = source_plane_data_cube.shape[0] self.setSourcePlaneDataCube(\ source_plane_data_cube, source_plane_cenra, source_plane_cendec, source_plane_pixsc, source_plane_cenx, source_plane_ceny, verbose, ) if self.myobj is None: # pragma: no cover raise Exception('Error! Could not set source plane data cube!') def __del__(self): if self.myobj is not None and self.mylib is not None: self.mylib.destroyLensingTransformer(self.myobj)
[docs] def logMessage(self, text): """Print message with logger.info() or logger.debug() depending on current logging level. """ if self.logger.level == logging.DEBUG: # pragma: no cover self.logger.debug(text) else: self.logger.info(text)
[docs] def printLibInfo(self): self.logMessage('mylibfile %r'%(mylibfile)) self.logMessage('mylib %s'%(mylib))
[docs] def setDebugLevel(self, level=1): if self.myobj is not None and self.mylib is not None: self.mylib.setLensingTransformerDebugLevel(self.myobj, level)
[docs] def setSourcePlaneDataCube( self, source_plane_data_cube, source_plane_cenra = None, source_plane_cendec = None, source_plane_pixsc = None, source_plane_cenx = None, source_plane_ceny = None, verbose = True, c_verbose = 0, ): # self.source_plane_data_cube = source_plane_data_cube if len(self.source_plane_data_cube.shape) != 3: raise Exception('Error! The input data cube should have 3 dimensions!') # self.source_plane_nx = source_plane_data_cube.shape[2] self.source_plane_ny = source_plane_data_cube.shape[1] self.source_plane_nchan = source_plane_data_cube.shape[0] # if source_plane_cenra is None: source_plane_cenra = self.source_plane_cenra if source_plane_cendec is None: source_plane_cendec = self.source_plane_cendec if source_plane_pixsc is None: source_plane_pixsc = self.source_plane_pixsc if source_plane_cenx is None: if self.source_plane_cenx is not None: source_plane_cenx = self.source_plane_cenx if source_plane_ceny is None: if self.source_plane_ceny is not None: source_plane_ceny = self.source_plane_ceny # data = source_plane_data_cube nx = source_plane_data_cube.shape[2] ny = source_plane_data_cube.shape[1] nchan = source_plane_data_cube.shape[0] cenra = source_plane_cenra cendec = source_plane_cendec pixsc = source_plane_pixsc if source_plane_cenx is None: cenx = (nx+1.0)/2.0 else: cenx = float(source_plane_cenx) if source_plane_ceny is None: ceny = (ny+1.0)/2.0 else: ceny = float(source_plane_ceny) self.source_plane_data_info = {'NAXIS':3, 'NAXIS1':nx, 'NAXIS2':ny, 'NAXIS3':nchan, 'RADESYS':'ICRS', 'SPECSYS':'TOPOCENT', 'EQUINOX':2000.0, 'CTYPE1':'RA---TAN', 'CTYPE2':'DEC--TAN', 'CTYPE3':'CHANNEL', 'CUNIT1':'deg', 'CUNIT2':'deg', 'CUNIT3':'', 'CRPIX1':cenx, 'CRPIX2':ceny, 'CRPIX3':1.0, 'CRVAL1':cenra, 'CRVAL2':cendec, 'CRVAL3':1.0, 'CDELT1':-pixsc/3600.0, 'CDELT2':pixsc/3600.0, 'CDELT3':1.0, } # if sys.byteorder == 'little': data = data.astype('<f8') else: # pragma: no cover data = data.astype('>f8') # createLensingTransformer if verbose: self.logMessage('mylib.createLensingTransformer %s is called'%(mylib.createLensingTransformer)) cdata = data.ctypes.data_as(POINTER(c_double)) # args : mesh_file, mesh_ra, mesh_dec, # source_plane_data_cube, # source_plane_data_nx, source_plane_data_ny, source_plane_data_nchan, # source_plane_ra, source_plane_dec, source_plane_pixelsize, # source_plane_cenx=nan, source_plane_ceny=nan, verbose=1 mylib.createLensingTransformer.argtypes = [c_char_p, c_double, c_double, POINTER(c_double), c_long, c_long, c_long, c_double, c_double, c_double, c_double, c_double, c_int] mylib.createLensingTransformer.restype = c_void_p self.myobj = c_void_p(mylib.createLensingTransformer(\ c_char_p(self.mesh_file.encode('utf-8')), self.mesh_ra, self.mesh_dec, cdata, nx, ny, nchan, cenra, cendec, pixsc, cenx, ceny, c_verbose)) if verbose: self.logMessage('mylib.createLensingTransformer %s finished'%(mylib.createLensingTransformer))
[docs] def updateSourcePlaneDataCube( self, source_plane_data_cube, verbose = True, c_verbose = 0, ): # if source_plane_data_cube.shape != self.source_plane_data_cube.shape: raise Exception('Error! Wrong input data dimension! Must input a data cube with the same shape as before.') # data = source_plane_data_cube # if sys.byteorder == 'little': data = data.astype('<f8') else: # pragma: no cover data = data.astype('>f8') # updateSourcePlaneDataCube if verbose: self.logMessage('mylib.updateSourcePlaneDataCube %s is called'%(mylib.updateSourcePlaneDataCube)) cdata = data.ctypes.data_as(POINTER(c_double)) # args : ptr, # source_plane_data_cube, # verbose=1 mylib.updateSourcePlaneDataCube.argtypes = [c_void_p, POINTER(c_double), c_int] mylib.updateSourcePlaneDataCube(self.myobj, cdata, c_verbose) if verbose: self.logMessage('mylib.updateSourcePlaneDataCube %s finished'%(mylib.updateSourcePlaneDataCube))
[docs] def performLensingTransformation( self, imcenra = None, imcendec = None, impixsc = None, imsizex = None, imsizey = None, imcenx = None, imceny = None, verbose = True, c_verbose = 0, ): # if imcenra is None: if self.image_plane_cenra is not None: imcenra = self.image_plane_cenra if imcendec is None: if self.image_plane_cendec is not None: imcendec = self.image_plane_cendec if impixsc is None: if self.image_plane_pixsc is not None: impixsc = self.image_plane_pixsc if imsizex is None: if self.image_plane_sizex is not None: imsizex = self.image_plane_sizex if imsizey is None: if self.image_plane_sizey is not None: imsizey = self.image_plane_sizey if imcenx is None: if self.image_plane_cenx is not None: imcenx = self.image_plane_cenx if imceny is None: if self.image_plane_ceny is not None: imceny = self.image_plane_ceny # if np.any([t is None for t in [imcenra, imcendec, impixsc, imsizex, imsizey]]): # pragma: no cover self.logger.error('Error! Incorrect input to performLensingTransformation.' + 'Please check imcenra, imcendec, impixsc, imsizex, imsizey.' + 'Retunning None.') return None # nchan = self.source_plane_data_cube.shape[0] if imcenx is None: imcenx = (imsizex+1.0)/2.0 else: imcenx = float(imcenx) if imceny is None: imceny = (imsizey+1.0)/2.0 else: imceny = float(imceny) # performLensingTransformation if verbose: self.logMessage('mylib.performLensingTransformation %s is called'%(mylib.performLensingTransformation)) self.logMessage('running lensing transformation at '+str(datetime.datetime.now())) time_begin = timeit.default_timer() # args : ptr, # image_plane_ra, image_plane_dec, image_plane_pixelsize, # image_plane_sizex, image_plane_sizey, # image_plane_cenx=nan, image_plane_ceny=nan, verbose=1 if verbose and logger.level == logging.DEBUG: self.setDebugLevel(2) #DBEUGGING# 20211221 mylib.setGlobalDebugLevel(2) mylib.performLensingTransformation.argtypes = [c_void_p, c_double, c_double, c_double, c_long, c_long, c_double, c_double, c_int] mylib.performLensingTransformation.restype = ctypes.POINTER(ctypes.c_double * imsizex * imsizey * nchan) outcdata = mylib.performLensingTransformation(self.myobj, imcenra, imcendec, impixsc, imsizex, imsizey, imcenx, imceny, c_verbose) outdata = np.ctypeslib.as_array(\ (ctypes.c_double * imsizex * imsizey * nchan).from_address(ctypes.addressof(outcdata.contents))\ ) self.image_plane_data_cube = outdata self.image_plane_data_info = {'NAXIS':3, 'NAXIS1':imsizex, 'NAXIS2':imsizey, 'NAXIS3':nchan, 'RADESYS':'ICRS', 'SPECSYS':'TOPOCENT', 'EQUINOX':2000.0, 'CTYPE1':'RA---TAN', 'CTYPE2':'DEC--TAN', 'CTYPE3':'CHANNEL', 'CUNIT1':'deg', 'CUNIT2':'deg', 'CUNIT3':'', 'CRPIX1':imcenx, 'CRPIX2':imceny, 'CRPIX3':1.0, 'CRVAL1':imcenra, 'CRVAL2':imcendec, 'CRVAL3':1.0, 'CDELT1':-impixsc/3600.0, 'CDELT2':impixsc/3600.0, 'CDELT3':1.0, } if verbose: time_finish = timeit.default_timer() self.logMessage('finished lensing transformation at '+str(datetime.datetime.now())) self.logMessage('elapsed %s seconds'%(time_finish - time_begin)) self.logMessage('mylib.performLensingTransformation %s finished'%(mylib.performLensingTransformation)) return outdata
def has_lensing_transform_keys_in_params( params, ): """Check if the input dict has lensing* keys """ for key in params: if key.startswith('lensing'): return True return False # pragma: no cover def setup_lensing_transformer_from_params( params = None, mesh_dir = None, mesh_file = None, mesh_ra = None, mesh_dec = None, source_plane_nx = None, source_plane_ny = None, source_plane_nchan = None, source_plane_cenra = None, source_plane_cendec = None, source_plane_pixsc = None, image_plane_cenra = None, image_plane_cendec = None, image_plane_pixsc = None, image_plane_sizex = None, image_plane_sizey = None, reuse_lensing_transformer = None, cache_lensing_transformer = True, reuse_cached_lensing_transformer = True, verbose = True, **kwargs, ): """A utility function to return a LensingTransformer instance from the input parameters. One can either provide a params dict with following madatory keys: - `lensing_ra` - `lensing_dec` - `lensing_ssizex` - `lensing_ssizey` - `lensing_sra` - `lensing_sdec` - `lensing_spixsc` - `lensing_imra` - `lensing_imdec` - `pixscale` - `fov_npix` - `nspec` or individual parameters as arguments. Note that the individual parameter inputs overrides the use of the keys in the params dict. If one inputs a `reuse_lensing_transformer`, then we will assume it is a LensingTransformer object and try to reuse it if all parameters are matched. """ if mesh_dir is None: if params is not None: if 'lensing_datadir' in params: mesh_dir = params['lensing_datadir'] elif 'datadir' in params: mesh_dir = params['datadir'] if mesh_file is None: if params is not None: if 'lensing_mesh' in params: mesh_file = params['lensing_mesh'] if mesh_ra is None: if params is not None: if 'lensing_ra' in params: mesh_ra = params['lensing_ra'] if mesh_dec is None: if params is not None: if 'lensing_dec' in params: mesh_dec = params['lensing_dec'] if source_plane_nx is None: if params is not None: if 'lensing_ssizex' in params: source_plane_nx = params['lensing_ssizex'] if source_plane_ny is None: if params is not None: if 'lensing_ssizey' in params: source_plane_ny = params['lensing_ssizey'] if source_plane_nchan is None: if params is not None: if 'nspec' in params: source_plane_nchan = params['nspec'] if source_plane_cenra is None: if params is not None: if 'lensing_sra' in params: source_plane_cenra = params['lensing_sra'] if source_plane_cendec is None: if params is not None: if 'lensing_sdec' in params: source_plane_cendec = params['lensing_sdec'] if source_plane_pixsc is None: if params is not None: if 'lensing_spixsc' in params: source_plane_pixsc = params['lensing_spixsc'] if image_plane_cenra is None: if params is not None: if 'lensing_imra' in params: image_plane_cenra = params['lensing_imra'] if image_plane_cendec is None: if params is not None: if 'lensing_imdec' in params: image_plane_cendec = params['lensing_imdec'] if image_plane_pixsc is None: if params is not None: if 'pixscale' in params: image_plane_pixsc = params['pixscale'] if image_plane_sizex is None: if params is not None: if 'nx_sky' in params: image_plane_sizex = params['nx_sky'] elif 'fov_npix' in params: image_plane_sizex = params['fov_npix'] if image_plane_sizey is None: if params is not None: if 'ny_sky' in params: image_plane_sizey = params['ny_sky'] elif 'fov_npix' in params: image_plane_sizey = params['fov_npix'] # return None if everything is None # this means that the input params dict does not contain a lensing model if params is not None and \ mesh_file is None and \ mesh_ra is None and \ mesh_dec is None: # pragma: no cover return None # check error if the input params dict does not contain all mandatory lensing transformation keys has_error = False if mesh_file is None: has_error = True logger.error('Error! The input mesh_file is invalid or key \'lensing_mesh\' is not in the input params dict!') if mesh_ra is None: has_error = True logger.error('Error! The input mesh_ra is invalid or key \'lensing_ra\' is not in the input params dict!') if mesh_dec is None: has_error = True logger.error('Error! The input mesh_dec is invalid or key \'lensing_dec\' is not in the input params dict!') if source_plane_nx is None: has_error = True logger.error('Error! The input source_plane_nx is invalid or key \'lensing_ssizex\' is not in the input params dict!') if source_plane_ny is None: has_error = True logger.error('Error! The input source_plane_ny is invalid or key \'lensing_ssizey\' is not in the input params dict!') if source_plane_nchan is None: has_error = True logger.error('Error! The input source_plane_nchan is invalid or key \'nspec\' is not in the input params dict!') if source_plane_cenra is None: has_error = True logger.error('Error! The input source_plane_cenra is invalid or key \'lensing_sra\' is not in the input params dict!') if source_plane_cendec is None: has_error = True logger.error('Error! The input source_plane_cendec is invalid or key \'lensing_sdec\' is not in the input params dict!') if source_plane_pixsc is None: has_error = True logger.error('Error! The input source_plane_pixsc is invalid or key \'lensing_spixsc\' is not in the input params dict!') if image_plane_cenra is None: has_error = True logger.error('Error! The input image_plane_cenra is invalid or key \'lensing_imra\' is not in the input params dict!') if image_plane_cendec is None: has_error = True logger.error('Error! The input image_plane_cendec is invalid or key \'lensing_imdec\' is not in the input params dict!') if image_plane_pixsc is None: has_error = True logger.error('Error! The input image_plane_pixsc is invalid or key \'pixscale\' is not in the input params dict!') if image_plane_sizex is None: has_error = True logger.error('Error! The input image_plane_sizex is invalid or key \'fov_npix\' is not in the input params dict!') if image_plane_sizey is None: has_error = True logger.error('Error! The input image_plane_sizey is invalid or key \'fov_npix\' is not in the input params dict!') # raise exception for the error if has_error: raise Exception('Error occurred! Please check error messages above.') # return None # prepend lensing_datadir path to the mesh file if mesh_dir is not None and mesh_dir != '': mesh_file = os.path.join(mesh_dir, mesh_file) # unzip if mesh_file.endswith('.gz'): import gzip import shutil unzip_mesh_file = mesh_file.rstrip('.gz') with gzip.open(mesh_file, 'rb') as f_in: with open(unzip_mesh_file, 'wb') as f_out: shutil.copyfileobj(f_in, f_out) mesh_file = unzip_mesh_file # define logMessage function if logger.level == logging.DEBUG: # pragma: no cover logMessage = logger.debug else: logMessage = logger.info # try to reuse a LensingTransformer from cache global cached_lensing_transformer_dict if reuse_lensing_transformer is None: if reuse_cached_lensing_transformer: if cached_lensing_transformer_dict['0'] is not None: reuse_lensing_transformer = cached_lensing_transformer_dict['0'] # try to reuse a LensingTransformer if one has an input # <TODO> note that we have some tolerance for reusing a lensing transfomer # e.g., 0.01 arcsec in RA Dec, 0.001 arcsec in pixsize if reuse_lensing_transformer is not None: reuse_check_ok = True if reuse_lensing_transformer.mesh_file != mesh_file: reuse_check_ok = False logger.debug('reusing lensing transformer check failed for mesh_file') elif not np.isclose(reuse_lensing_transformer.mesh_ra, mesh_ra, rtol=1e-6, atol=0.01/3600.): reuse_check_ok = False logger.debug('reusing lensing transformer check failed for mesh_ra') elif not np.isclose(reuse_lensing_transformer.mesh_dec, mesh_dec, rtol=1e-6, atol=0.01/3600.): reuse_check_ok = False logger.debug('reusing lensing transformer check failed for mesh_dec') elif reuse_lensing_transformer.source_plane_nx != source_plane_nx: reuse_check_ok = False logger.debug('reusing lensing transformer check failed for source_plane_nx') elif reuse_lensing_transformer.source_plane_ny != source_plane_ny: reuse_check_ok = False logger.debug('reusing lensing transformer check failed for source_plane_ny') elif reuse_lensing_transformer.source_plane_nchan != source_plane_nchan: reuse_check_ok = False logger.debug('reusing lensing transformer check failed for source_plane_nchan') elif not np.isclose(reuse_lensing_transformer.source_plane_cenra, source_plane_cenra, rtol=1e-7, atol=0.01/3600.): reuse_check_ok = False logger.debug('reusing lensing transformer check failed for source_plane_cenra') elif not np.isclose(reuse_lensing_transformer.source_plane_cendec, source_plane_cendec, rtol=1e-7, atol=0.01/3600.): reuse_check_ok = False logger.debug('reusing lensing transformer check failed for source_plane_cendec') elif not np.isclose(reuse_lensing_transformer.source_plane_pixsc, source_plane_pixsc, rtol=1e-4, atol=0.001): reuse_check_ok = False logger.debug('reusing lensing transformer check failed for source_plane_pixsc') elif not np.isclose(reuse_lensing_transformer.image_plane_cenra, image_plane_cenra, rtol=1e-7, atol=0.01/3600.): reuse_check_ok = False logger.debug('reusing lensing transformer check failed for image_plane_cenra') elif not np.isclose(reuse_lensing_transformer.image_plane_cendec, image_plane_cendec, rtol=1e-7, atol=0.01/3600.): reuse_check_ok = False logger.debug('reusing lensing transformer check failed for image_plane_cendec') elif not np.isclose(reuse_lensing_transformer.image_plane_pixsc, image_plane_pixsc, rtol=1e-4, atol=0.001): reuse_check_ok = False logger.debug('reusing lensing transformer check failed for image_plane_pixsc') elif reuse_lensing_transformer.image_plane_sizex != image_plane_sizex: reuse_check_ok = False logger.debug('reusing lensing transformer check failed for image_plane_sizex') elif reuse_lensing_transformer.image_plane_sizey != image_plane_sizey: reuse_check_ok = False logger.debug('reusing lensing transformer check failed for image_plane_sizey') # if reuse_check_ok: if verbose or (logger.level == logging.DEBUG): logMessage('reusing lensing transformer '+str(hex(id(reuse_lensing_transformer)))+ ' in thread '+str(multiprocessing.current_process().pid)+' '+str(hex(threading.currentThread().ident)) ) return reuse_lensing_transformer else: del reuse_lensing_transformer reuse_lensing_transformer = None # create LensingTransformer if ((cache_lensing_transformer and cached_lensing_transformer_dict['0'] is None)) or \ (logger.level == logging.DEBUG) or \ (verbose == True): # print message when # this is the first time creating this object and the cache is empty # debug mode # or verbose logMessage('creating lensing transformer with:\n'+ ' mesh_file = %r, \n'%(mesh_file)+ ' mesh_ra = %s, \n'%(mesh_ra)+ ' mesh_dec = %s, \n'%(mesh_dec)+ ' source_plane_nx = %s, \n'%(source_plane_nx)+ ' source_plane_ny = %s, \n'%(source_plane_ny)+ ' source_plane_nchan = %s, \n'%(source_plane_nchan)+ ' source_plane_cenra = %s, \n'%(source_plane_cenra)+ ' source_plane_cendec = %s, \n'%(source_plane_cendec)+ ' source_plane_pixsc = %s, \n'%(source_plane_pixsc)+ ' image_plane_cenra = %s, \n'%(image_plane_cenra)+ ' image_plane_cendec = %s, \n'%(image_plane_cendec)+ ' image_plane_pixsc = %s, \n'%(image_plane_pixsc)+ ' image_plane_sizex = %s, \n'%(image_plane_sizex)+ ' image_plane_sizey = %s\n'%(image_plane_sizey)+ ' in thread '+str(multiprocessing.current_process().pid)+' '+str(hex(threading.currentThread().ident)) ) lensing_transformer = LensingTransformer(\ mesh_file = mesh_file, mesh_ra = mesh_ra, mesh_dec = mesh_dec, source_plane_nx = source_plane_nx, source_plane_ny = source_plane_ny, source_plane_nchan = source_plane_nchan, source_plane_cenra = source_plane_cenra, source_plane_cendec = source_plane_cendec, source_plane_pixsc = source_plane_pixsc, image_plane_cenra = image_plane_cenra, image_plane_cendec = image_plane_cendec, image_plane_pixsc = image_plane_pixsc, image_plane_sizex = image_plane_sizex, image_plane_sizey = image_plane_sizey, verbose = verbose, ) if verbose: logMessage('created lensing transformer '+str(hex(id(lensing_transformer)))+ ' in thread '+str(multiprocessing.current_process().pid)+' '+str(hex(threading.currentThread().ident)) ) # global cached_lensing_transformer_dict if cache_lensing_transformer: cached_lensing_transformer_dict['0'] = lensing_transformer else: cached_lensing_transformer_dict['0'] = None # return return lensing_transformer def _get_cached_lensing_transformer(): global cached_lensing_transformer_dict return cached_lensing_transformer_dict['0']