Delete CTI.py (e4607a2e) · Commits · csst-sims / csst_mci_sim

csst_mci_sim/CTI/CTI.py

deleted100644 → 0

+0 −177

Original line number	Diff line number	Diff line
		"""
		Charge Transfer Inefficiency
		============================

		This file contains a simple class to run a CDM03 CTI model developed by Alex Short (ESA).

		This now contains both the official CDM03 and a new version that allows different trap
		parameters in parallel and serial direction.

		:requires: NumPy
		:requires: CDM03 (FORTRAN code, f2py -c -m cdm03bidir cdm03bidir.f90)

		:version: 0.35
		"""
		import numpy as np


		#CDM03bidir
		class CDM03bidir():
		"""
		Class to run CDM03 CTI model, class Fortran routine to perform the actual CDM03 calculations.

		:param settings: input parameters
		:type settings: dict
		:param data: input data to be radiated
		:type data: ndarray
		:param log: instance to Python logging
		:type log: logging instance
		"""
		def __init__(self, settings, data, log=None):
		"""
		Class constructor.

		:param settings: input parameters
		:type settings: dict
		:param data: input data to be radiated
		:type data: ndarray
		:param log: instance to Python logging
		:type log: logging instance
		"""
		self.data = data
		self.values = dict(quads=(0,1,2,3), xsize=2048, ysize=2066, dob=0.0, rdose=8.0e9)
		self.values.update(settings)
		self.log = log
		self._setupLogger()

		#default CDM03 settings
		self.params = dict(beta_p=0.6, beta_s=0.6, fwc=200000., vth=1.168e7, vg=6.e-11, t=20.48e-3,
		sfwc=730000., svg=1.0e-10, st=5.0e-6, parallel=1., serial=0.0)
		#update with inputs
		self.params.update(self.values)

		#read in trap information
		trapdata = np.loadtxt(self.values['dir_path']+self.values['paralleltrapfile'])
		if trapdata.ndim > 1:
		self.nt_p = trapdata[:, 0]
		self.sigma_p = trapdata[:, 1]
		self.taur_p = trapdata[:, 2]
		else:
		#only one trap species
		self.nt_p = [trapdata[0],]
		self.sigma_p = [trapdata[1],]
		self.taur_p = [trapdata[2],]

		trapdata = np.loadtxt(self.values['dir_path']+self.values['serialtrapfile'])
		if trapdata.ndim > 1:
		self.nt_s = trapdata[:, 0]
		self.sigma_s = trapdata[:, 1]
		self.taur_s = trapdata[:, 2]
		else:
		#only one trap species
		self.nt_s = [trapdata[0],]
		self.sigma_s = [trapdata[1],]
		self.taur_s = [trapdata[2],]

		#scale thibaut's values
		if 'thibaut' in self.values['parallelTrapfile']:
		self.nt_p /= 0.576 #thibaut's values traps / pixel
		self.sigma_p = 1.e4 #thibaut's values in m*2
		if 'thibaut' in self.values['serialTrapfile']:
		self.nt_s *= 0.576 #thibaut's values traps / pixel #should be division?
		self.sigma_s = 1.e4 #thibaut's values in m*2


		def _setupLogger(self):
		"""
		Set up the logger.
		"""
		self.logger = True
		# if self.log is None:
		# self.logger = False


		def applyRadiationDamage(self, data, iquadrant=0):
		"""
		Apply radian damage based on FORTRAN CDM03 model. The method assumes that
		input data covers only a single quadrant defined by the iquadrant integer.

		:param data: imaging data to which the CDM03 model will be applied to.
		:type data: ndarray

		:param iquandrant: number of the quadrant to process
		:type iquandrant: int

		cdm03 - Function signature::

		sout = cdm03(sinp,iflip,jflip,dob,rdose,in_nt,in_sigma,in_tr,[xdim,ydim,zdim])
		Required arguments:
		sinp : input rank-2 array('d') with bounds (xdim,ydim)
		iflip : input int
		jflip : input int
		dob : input float
		rdose : input float
		in_nt : input rank-1 array('d') with bounds (zdim)
		in_sigma : input rank-1 array('d') with bounds (zdim)
		in_tr : input rank-1 array('d') with bounds (zdim)
		Optional arguments:
		xdim := shape(sinp,0) input int
		ydim := shape(sinp,1) input int
		zdim := len(in_nt) input int
		Return objects:
		sout : rank-2 array('d') with bounds (xdim,ydim)

		.. Note:: Because Python/NumPy arrays are different row/column based, one needs
		to be extra careful here. NumPy.asfortranarray will be called to get
		an array laid out in Fortran order in memory. Before returning the
		array will be laid out in memory in C-style (row-major order).

		:return: image that has been run through the CDM03 model
		:rtype: ndarray
		"""""
		#return data

		iflip = iquadrant / 2
		jflip = iquadrant % 2

		params = [self.params['beta_p'], self.params['beta_s'], self.params['fwc'], self.params['vth'],
		self.params['vg'], self.params['t'], self.params['sfwc'], self.params['svg'], self.params['st'],
		self.params['parallel'], self.params['serial']]

		if self.logger:
		self.log.info('nt_p=' + str(self.nt_p))
		self.log.info('nt_s=' + str(self.nt_s))
		self.log.info('sigma_p= ' + str(self.sigma_p))
		self.log.info('sigma_s= ' + str(self.sigma_s))
		self.log.info('taur_p= ' + str(self.taur_p))
		self.log.info('taur_s= ' + str(self.taur_s))
		self.log.info('dob=%f' % self.values['dob'])
		self.log.info('rdose=%e' % self.values['rdose'])
		self.log.info('xsize=%i' % data.shape[1])
		self.log.info('ysize=%i' % data.shape[0])
		self.log.info('quadrant=%i' % iquadrant)
		self.log.info('iflip=%i' % iflip)
		self.log.info('jflip=%i' % jflip)

		#################################################################################
		###modify
		#sys.path.append('../so')

		# from ifs_so.cdm03.cpython-38-x86_64-linux-gnu import cdm03bidir
		# import cdm03bidir
		from .mci_so import cdm03bidir

		CTIed = cdm03bidir.cdm03(np.asfortranarray(data),
		jflip, iflip,
		self.values['dob'], self.values['rdose'],
		self.nt_p, self.sigma_p, self.taur_p,
		self.nt_s, self.sigma_s, self.taur_s,
		params,
		[data.shape[0], data.shape[1], len(self.nt_p), len(self.nt_s), len(self.params)])


		return np.asanyarray(CTIed)

		#################################################################################################################
		#################################################################################################################