test (0b0310c4) · Commits · csst-sims / csst_mci_sim

csst_mci_sim/CTI/CTI.py

+4 −319

Original line number	Original line	Diff line number	Diff line
	@@ -14,14 +14,6 @@ parameters in parallel and serial direction.
	"""		"""
	import numpy as np		import numpy as np

	# try:
	# import cdm03bidir
	# #import cdm03bidirTest as cdm03bidir #for testing purposes only
	# except ImportError:
	# print('import CTI module')
	# #print ('No CDM03bidir module available, please compile it: f2py -c -m cdm03bidir cdm03bidir.f90')



	#CDM03bidir		#CDM03bidir
	class CDM03bidir():		class CDM03bidir():
	@@ -59,7 +51,7 @@ class CDM03bidir():
	self.params.update(self.values)		self.params.update(self.values)

	#read in trap information		#read in trap information
	trapdata = np.loadtxt(self.values['parallelTrapfile'])		trapdata = np.loadtxt(self.values['dir_path']+self.values['paralleltrapfile'])
	if trapdata.ndim > 1:		if trapdata.ndim > 1:
	self.nt_p = trapdata[:, 0]		self.nt_p = trapdata[:, 0]
	self.sigma_p = trapdata[:, 1]		self.sigma_p = trapdata[:, 1]
	@@ -70,7 +62,7 @@ class CDM03bidir():
	self.sigma_p = [trapdata[1],]		self.sigma_p = [trapdata[1],]
	self.taur_p = [trapdata[2],]		self.taur_p = [trapdata[2],]

	trapdata = np.loadtxt(self.values['serialTrapfile'])		trapdata = np.loadtxt(self.values['dir_path']+self.values['serialtrapfile'])
	if trapdata.ndim > 1:		if trapdata.ndim > 1:
	self.nt_s = trapdata[:, 0]		self.nt_s = trapdata[:, 0]
	self.sigma_s = trapdata[:, 1]		self.sigma_s = trapdata[:, 1]
	@@ -95,100 +87,8 @@ class CDM03bidir():
	Set up the logger.		Set up the logger.
	"""		"""
	self.logger = True		self.logger = True
	if self.log is None:		# if self.log is None:
	self.logger = False		# self.logger = False


	def radiateFullCCD(self):
	"""
	This routine allows the whole CCD to be run through a radiation damage mode.
	The routine takes into account the fact that the amplifiers are in the corners
	of the CCD. The routine assumes that the CCD is using four amplifiers.

	There is an excess of .copy() calls, which should probably be cleaned up. However,
	given that I had problem with the Fortran code, I have kept the calls. If memory
	becomes an issue then this should be cleaned.

	:return: radiation damaged image
	:rtype: ndarray
	"""
	ydim, xdim = self.data.shape
	out = np.zeros((xdim, ydim))

	#transpose the data, because Python has different convention than Fortran
	data = self.data.transpose().copy()

	for quad in self.values['quads']:
	if self.logger:
	self.log.info('Adding CTI to Q%i' % quad)

	if quad == 0:
	d = data[0:self.values['xsize'], 0:self.values['ysize']].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[0:self.values['xsize'], 0:self.values['ysize']] = tmp
	elif quad == 1:
	d = data[self.values['xsize']:, :self.values['ysize']].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[self.values['xsize']:, :self.values['ysize']] = tmp
	elif quad == 2:
	d = data[:self.values['xsize'], self.values['ysize']:].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[:self.values['xsize'], self.values['ysize']:] = tmp
	elif quad == 3:
	d = data[self.values['xsize']:, self.values['ysize']:].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[self.values['xsize']:, self.values['ysize']:] = tmp
	else:
	print( 'ERROR -- too many quadrants!!' )
	self.log.error('Too many quadrants! This method allows only four quadrants.')

	return out.transpose()


	def radiateFullCCD2(self):
	"""
	This routine allows the whole CCD to be run through a radiation damage mode.
	The routine takes into account the fact that the amplifiers are in the corners
	of the CCD. The routine assumes that the CCD is using four amplifiers.

	There is an excess of .copy() calls, which should probably be cleaned up. However,
	given that I had problem with the Fortran code, I have kept the calls. If memory
	becomes an issue then this should be cleaned.

	:return: radiation damaged image
	:rtype: ndarray
	"""
	ydim, xdim = self.data.shape
	out = np.empty((ydim, xdim))

	#transpose the data, because Python has different convention than Fortran
	data = self.data.copy()

	for quad in self.values['quads']:
	if self.logger:
	self.log.info('Adding CTI to Q%i' % quad)

	if quad == 0:
	d = data[:self.values['ysize'], :self.values['xsize']].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[:self.values['ysize'], :self.values['xsize']] = tmp
	elif quad == 1:
	d = data[:self.values['ysize'], self.values['xsize']:].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[:self.values['ysize'], self.values['xsize']:] = tmp
	elif quad == 2:
	d = data[self.values['ysize']:, :self.values['xsize']].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[self.values['ysize']:, :self.values['xsize']] = tmp
	elif quad == 3:
	d = data[self.values['ysize']:, self.values['xsize']:].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[self.values['ysize']:, self.values['xsize']:] = tmp
	else:
	print( 'ERROR -- too many quadrants!!')
	self.log.error('Too many quadrants! This method allows only four quadrants.')

	return out


	def applyRadiationDamage(self, data, iquadrant=0):		def applyRadiationDamage(self, data, iquadrant=0):
	@@ -255,7 +155,6 @@ class CDM03bidir():

	#################################################################################		#################################################################################
	###modify		###modify
	import sys
	#sys.path.append('../so')		#sys.path.append('../so')
	from ifs_so import cdm03bidir		from ifs_so import cdm03bidir
	# from ifs_so.cdm03.cpython-38-x86_64-linux-gnu import cdm03bidir		# from ifs_so.cdm03.cpython-38-x86_64-linux-gnu import cdm03bidir
	@@ -275,220 +174,6 @@ class CDM03bidir():



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

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

	:param data: input data to be radiated
	:type data: ndarray
	:param input: input parameters
	:type input: dictionary
	:param log: instance to Python logging
	:type log: logging instance
	"""
	try:
	import cdm03
	except ImportError:
	print( 'No CDM03 module available, please compile it: f2py -c -m cdm03 cdm03.f90')

	self.data = data
	self.values = dict(quads=(0,1,2,3), xsize=2048, ysize=2066, dob=0.0, rdose=8.0e9)
	self.values.update(input)
	self.log = log
	self._setupLogger()


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


	def radiateFullCCD(self):
	"""
	This routine allows the whole CCD to be run through a radiation damage mode.
	The routine takes into account the fact that the amplifiers are in the corners
	of the CCD. The routine assumes that the CCD is using four amplifiers.

	There is an excess of .copy() calls, which should probably be cleaned up. However,
	given that I had problem with the Fortran code, I have kept the calls. If memory
	becomes an issue then this should be cleaned.

	:return: radiation damaged image
	:rtype: ndarray
	"""
	ydim, xdim = self.data.shape
	out = np.zeros((xdim, ydim))

	#transpose the data, because Python has different convention than Fortran
	data = self.data.transpose().copy()

	for quad in self.values['quads']:
	if self.logger:
	self.log.info('Adding CTI to Q%i' % quad)

	if quad == 0:
	d = data[0:self.values['xsize'], 0:self.values['ysize']].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[0:self.values['xsize'], 0:self.values['ysize']] = tmp
	elif quad == 1:
	d = data[self.values['xsize']:, :self.values['ysize']].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[self.values['xsize']:, :self.values['ysize']] = tmp
	elif quad == 2:
	d = data[:self.values['xsize'], self.values['ysize']:].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[:self.values['xsize'], self.values['ysize']:] = tmp
	elif quad == 3:
	d = data[self.values['xsize']:, self.values['ysize']:].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[self.values['xsize']:, self.values['ysize']:] = tmp
	else:
	print ('ERROR -- too many quadrants!!')
	self.log.error('Too many quadrants! This method allows only four quadrants.')

	return out.transpose()


	def radiateFullCCD2(self):
	"""
	This routine allows the whole CCD to be run through a radiation damage mode.
	The routine takes into account the fact that the amplifiers are in the corners
	of the CCD. The routine assumes that the CCD is using four amplifiers.

	There is an excess of .copy() calls, which should probably be cleaned up. However,
	given that I had problem with the Fortran code, I have kept the calls. If memory
	becomes an issue then this should be cleaned.

	:return: radiation damaged image
	:rtype: ndarray
	"""
	ydim, xdim = self.data.shape
	out = np.empty((ydim, xdim))

	#transpose the data, because Python has different convention than Fortran
	data = self.data.copy()

	for quad in self.values['quads']:
	if self.logger:
	self.log.info('Adding CTI to Q%i' % quad)

	if quad == 0:
	d = data[:self.values['ysize'], :self.values['xsize']].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[:self.values['ysize'], :self.values['xsize']] = tmp
	elif quad == 1:
	d = data[:self.values['ysize'], self.values['xsize']:].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[:self.values['ysize'], self.values['xsize']:] = tmp
	elif quad == 2:
	d = data[self.values['ysize']:, :self.values['xsize']].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[self.values['ysize']:, :self.values['xsize']] = tmp
	elif quad == 3:
	d = data[self.values['ysize']:, self.values['xsize']:].copy()
	tmp = self.applyRadiationDamage(d, iquadrant=quad).copy()
	out[self.values['ysize']:, self.values['xsize']:] = tmp
	else:
	print ('ERROR -- too many quadrants!!')
	self.log.error('Too many quadrants! This method allows only four quadrants.')

	return out


	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
	"""
	#read in trap information
	trapdata = np.loadtxt(self.values['trapfile'])
	nt = trapdata[:, 0]
	sigma = trapdata[:, 1]
	taur = trapdata[:, 2]

	iflip = iquadrant / 2
	jflip = iquadrant % 2

	if self.logger:
	self.log.info('nt=' + str(nt))
	self.log.info('sigma= ' + str(sigma))
	self.log.info('taur= ' + str(taur))
	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)


	# #call Fortran routine
	# CTIed = cdm03.cdm03(np.asfortranarray(data),
	# iflip, jflip,
	# self.values['dob'], self.values['rdose'],
	# nt, sigma, taur)
	###modify
	import sys
	sys.path.append('../CTI')
	import cdm03

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

	CTIed = cdm03.cdm03(np.asfortranarray(data),
	jflip, iflip,
	self.values['dob'], self.values['rdose'],
	nt,sigma,taur )


	return np.asanyarray(CTIed)


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

csst_mci_sim/mci_data/mci_all_9K.config

+8 −6

Original line number	Original line	Diff line number	Diff line
	@@ -14,20 +14,22 @@ prescan = 27
	overscan = 320		overscan = 320

	#charge trap information file		#charge trap information file
	parallelTrapfile=MCI_inputdata/cdm_euclid_parallel.dat		parallelTrapfile=MCI_inputdata/data/cdm_euclid_parallel.dat
	serialTrapfile=MCI_inputdata/cdm_euclid_serial.dat		serialTrapfile=MCI_inputdata/data/cdm_euclid_serial.dat

	#cosmetic defects input file		#cosmetic defects input file
	cosmeticsFile_b =MCI_inputdata/Cosmetics_b.txt		cosmeticsFile_g =MCI_inputdata/data/Cosmetics_g.txt

	cosmeticsFile_r =MCI_inputdata/Cosmetics_r.txt		cosmeticsFile_r =MCI_inputdata/data/Cosmetics_r.txt

			cosmeticsFile_i =MCI_inputdata/data/Cosmetics_i.txt


	###comicray information file		###comicray information file

	cosmicraylengths=MCI_inputdata/cdf_cr_length.dat		cosmicraylengths=MCI_inputdata/data/cdf_cr_length.dat

	cosmicraydistance=MCI_inputdata/cdf_cr_total.dat		cosmicraydistance=MCI_inputdata/data/cdf_cr_total.dat