queso-cluster 0.0.0__py3-none-any.whl

queso_cluster/addon/aia.py

@@ -0,0 +1,103 @@
+#> file:  ./QuESO/addon/aia
+#> lang:  python
+#> synopsis: 
+#> author:   <>
+
+from scipy.io import readsav
+import numpy as np
+
+from .logg import loggTimer
+
+
+@loggTimer
+def delayAIA(fname, epochDev):
+#> detail: 
+#> param type fname:
+#> param type epochDev:
+#> return (type): 
+#> test-method:
+	
+	eD = epochDev
+	print(eD.shape)
+	print(fname)
+	jq_delayCube = readsav(fname)
+
+	#jq_delayCube['arr'][0] --> background of pixel
+	#jq_delayCube['arr'][1] --> background noise of pixel (standard deviation)
+	#jq_delayCube['arr'][2] --> AIA brightness at ViSP slit time
+	#jq_delayCube['arr'][3] --> time of the ViSP slit
+	#jq_delayCube['arr'][4] --> xpos
+	#jq_delayCube['arr'][5] --> ypos
+	#jq_delayCube['arr'][6] --> brightness of peak (before ViSP time)
+	#jq_delayCube['arr'][7] --> time of peak before ViSP time
+	#jq_delayCube['arr'][8] --> brightness of peak (after ViSP time)
+	#jq_delayCube['arr'][9] --> time of peak after ViSP time
+
+
+	jq_AIAFrame = np.zeros((514, 295)) + np.nan
+	#momentFrame = np.zeros(len(jq_delayCube['arr'][:, 4])) + np.nan
+
+	#moment_compare = eD.dataSquare[:, eD.spectralWindow[0]:eD.spectralWindow[1]].mean(axis=-1).reshape(eD.shape[0], eD.shape[1])
+
+	#aia_correct =  lambda x: x.reshape((295, 514)).T.reshape(514*295)
+	correct = lambda x: x.reshape(eD.shape[1], eD.shape[0]).T.reshape(eD.shape[0]*eD.shape[1])
+
+	jq_AIAMask 	= np.zeros(jq_AIAFrame.shape) + np.nan
+	jq_indxMap 	= np.zeros(jq_AIAFrame.shape) + np.nan
+	jq_AIABright = np.zeros(jq_AIAFrame.shape) + np.nan
+
+	#print([0.01937, eD.deltas['pxlAlongSlit']])
+	#print([0.21420, eD.deltas['pxlSlitWidth']])
+
+	dy = 0.01937
+	dx = 0.214167
+
+
+	for i in range(len(jq_delayCube['arr'][:, 4])):
+		xx = int(np.floor(jq_delayCube['arr'][int(i), 4]*dx*6))
+		yy = int(np.floor(jq_delayCube['arr'][int(i), 5]*dy*6))
+
+		if jq_delayCube['arr'][i, 7] > 0:
+			jq_AIAFrame[xx, yy] = jq_delayCube['arr'][i, 3] - jq_delayCube['arr'][i, 7] 
+			jq_AIAMask[xx, yy] = 1
+
+			jq_AIABright[xx, yy] = jq_delayCube['arr'][i, 2]
+		if jq_delayCube['arr'][i, 9] > 0:
+			jq_AIAFrame[xx, yy] = jq_delayCube['arr'][i, 3] - jq_delayCube['arr'][i, 9]
+			jq_AIAMask[xx, yy] = 1
+
+			jq_AIABright[xx, yy] = jq_delayCube['arr'][i, 2]
+
+		jq_indxMap[xx, yy] = i
+
+
+	visp_jqDelayFrame 	= np.zeros(eD.dataSquare.shape[0]) + np.nan
+	visp_jqMaskFrame 	= np.zeros(eD.dataSquare.shape[0]) + np.nan
+	visp_aiaIndx 		= np.zeros(eD.dataSquare.shape[0]) + np.nan
+	visp_aiaBright 		= np.zeros(eD.dataSquare.shape[0]) + np.nan
+	for i in range(eD.dataSquare.shape[0]):
+		yy = int(np.floor((i / eD.shape[0])*dy*6))
+		xx = int(np.floor(np.mod(i, eD.shape[0])*dx*6))
+
+		if ~(np.isnan(jq_AIAMask[xx, yy])):
+			visp_jqMaskFrame[i] 	= jq_AIAMask[xx, yy]
+			visp_aiaIndx[i] 		= jq_indxMap[xx, yy]
+			visp_aiaBright[i] 		= jq_AIABright[xx, yy]
+			visp_jqDelayFrame[i] 	= jq_AIAFrame[xx, yy]
+
+	delayCube 	= correct(visp_jqDelayFrame)/60.#)/60.
+	aiaATvisp  	= correct(visp_aiaBright)
+	aiaIndxMap 	= correct(visp_aiaIndx)
+
+	mask_map = np.zeros(delayCube.shape)
+	mask_map[np.where(~np.isnan(delayCube))] = 1
+
+	import matplotlib.pyplot as plt
+	fig = plt.figure(layout='constrained', figsize=(10, 5), dpi=300)
+	ax = fig.add_subplot(111)
+
+	ax.imshow(mask_map.reshape(eD.shape[0], eD.shape[1]).T, cmap='Greys_r', origin='lower', extent=[0, eD.shape[0]*dx, 0, eD.shape[1]*dy])
+	fig.savefig("./maskTest.png")
+	plt.close()
+
+	return(delayCube, aiaATvisp, aiaIndxMap, mask_map.astype(bool))

queso_cluster/addon/logg.py

@@ -0,0 +1,66 @@
+#> file:  ./QuESO/addon/logg
+#> lang:  python
+#> synopsis: 
+#> author:   <>
+import logging
+import timeit 
+
+logger = logging.getLogger("queso_cluster")
+logger.addHandler(logging.NullHandler())
+
+def loggTimer(func):
+#> detail: 
+#> param type func:
+#> return (type): 
+#> test-method:
+	def wrapper(*args, **kwargs):
+		__log__ = logg("start", val="{}".format(func.__name__))
+		value = func(*args, **kwargs)
+		logg("stop", _log=__log__)
+		return(value)
+	return(wrapper)
+
+
+def logg(tag, val=None, _time=None, _log=None):
+#> detail: 
+#> param type tag:
+#> param type [None] val:
+#> param type [None] _time:
+#> param type [None] _log:
+#> return (type): 
+#> test-method:
+	ptag = '[' + tag.upper() + '\t]'
+	if _log is not None:
+		val, _time = _log
+	if _time is not None:
+		dur = timeit.default_timer() - _time
+	match tag:
+		case 'aloha': 
+			if _log is not None:
+				log_str = ptag + '[' + duration_string(dur) + ']'
+			else:
+				#print(ptag + 'DURATION\tMESSAGES\tRUNNERS')
+				logger.info(ptag)
+				return(None, timeit.default_timer())
+		case 'start': 
+			log_str = ptag + '\t\t' + val.upper()
+			logger.info(log_str)
+			return(val.upper(), timeit.default_timer())
+		case 'stop': 
+			log_str = ptag + '[' + duration_string(dur) + ']\t' + val.upper()
+		case 'msg': 
+			log_str = ptag + '\t\t' + val.upper()
+		case 'warn':
+			logger.warning(val.upper())
+			return None
+		case 'error':
+			logger.error(val.upper())
+			return None
+	logger.info(log_str)
+
+def duration_string(dur):
+#> detail: 
+#> param type dur:
+#> return (type): 
+#> test-method:
+	return("{:02d}h {:02d}m {:02d}s".format(int(dur/3600), int(int(dur/60) % 60), int(dur % 60))) 

queso_cluster/addon/multiline.py

@@ -0,0 +1,5 @@
+#> file:  ./QuESO/addon/multiline
+#> lang:  python
+#> synopsis: 
+#> author:   <>
+

queso_cluster/addon/prep.py

@@ -0,0 +1,36 @@
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import numpy as np
+
+from . import style as sty
+def figureBackup01(analysisObj, dataSquare=None):
+    ii, jj = analysisObj.spectralWindow
+    if dataSquare is None:
+        dataSquare = analysisObj.dataSquare
+    
+    moment0_integrated = dataSquare[:, ii:jj+1].mean(axis=-1).compute()
+    print(moment0_integrated.shape)
+    moment0_continuum = dataSquare[:, analysisObj.continuum].compute()
+    print(moment0_continuum.shape)
+
+    i0_layerCount = len(analysisObj.clusterConfig['intrinsic'])
+
+    fig = plt.figure(layout='constrained', figsize=(5*i0_layerCount, 5), dpi=300)
+
+    moment0 = {'window': moment0_integrated, 'continuum': moment0_continuum}
+    binWidth = {'window': 0.01, 'continuum': 0.01}
+
+    for i in range(i0_layerCount):
+        label = analysisObj.config.clusterConfig['intrinsic'][i]['label']
+        bins  = analysisObj.config.clusterConfig['intrinsic'][i]['layerConfig']['bins']
+
+        ax = fig.add_subplot(1, i0_layerCount, i+1)
+        histBins = np.arange(0, np.ceil(np.nanmax(moment0[label])*10)/10, step=binWidth[label])
+        ax.hist(moment0[label], bins=histBins, range=histBins, rwidth=1, fill=False, histtype='step', color='black')
+        _, color_pallet =  sty._genColorPallet(len(np.diff(bins)))
+
+        for j in range(len(bins)-2):
+            ax.axvline(x = bins[j+1] , color=mpl.colors.rgb2hex(color_pallet[j+1]))
+
+
+    return(fig)

queso_cluster/addon/products.py

@@ -0,0 +1,403 @@
+#> file:  ./QuESO/addon/products
+#> lang:  python
+#> synopsis: 
+#> author:   <>
+#from ..atoms import base as baseAtom
+
+from . import style as sty
+from .logg import loggTimer
+from ..atoms import aux as auxAtom
+from ..atoms import scores as scoresAtom
+from  ..runners import base as baseRun
+
+import numpy as np
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+from matplotlib.gridspec import GridSpec
+from matplotlib.colors import LinearSegmentedColormap
+
+from ..addon.logg import logger
+
+class Products:
+
+	def __init__(self, quesoOut, optLabels):
+#> detail: 
+#> param type self:
+#> param type quesoOut:
+#> param type optLabels:
+#> return (type): 
+#> test-method:
+		self.quesoOut = quesoOut
+		self.config 			= self.quesoOut.config
+		self.keepI0 = self.config.runners.config['keepI0']
+		self.ii, self.jj = self.quesoOut.spectralWindow
+		self.lineCenter = self.quesoOut.lineCenter
+		self.continuum = self.quesoOut.continuum
+		
+
+		#self.waveFit 	= self.quesoOut.waveFit 
+		self.optLabels 	= optLabels
+		self.optLabels[self.optLabels == 0] = np.nan
+		self.vindx 	= np.where(~np.isnan(self.optLabels))#[0]
+		#print(np.where(~np.isnan(self.optLabels)))
+
+		self.mapMake = sty.mapMaker(self.quesoOut.spaceInfo, self.quesoOut.deltas)
+
+	@loggTimer
+	def clusterMapSequence(self, orientation='vertical'):
+		ncols = self.optLabels.shape[0]
+		#> Error?: Maximum number of clients reached		
+		fig = plt.figure(layout='compressed', figsize=(ncols, 2*ncols), dpi=300)
+		
+		if orientation == 'vertical':
+			nrows = ncols
+			ncols = 2
+			height_ratios = [1 for x in range(nrows)]
+			width_ratios = [1, 0.025]
+		else:
+			nrows = 2
+			height_ratios=[0.025, 1]
+			width_ratios = [1 for x in range(ncols)]
+		gs = GridSpec(nrows, ncols, figure=fig, 
+				height_ratios=height_ratios, width_ratios=width_ratios, hspace=0, wspace=0)
+
+		#xx = (self.vindx % self.quesoOut.rasterSize)#, self.quesoOut.alongSlitSize])
+		#yy = (self.vindx // self.quesoOut.rasterSize)#, self.quesoOut.alongSlitSize])
+
+		#inset_bbox = [xx0, xx1, yy0, yy1]
+
+		xlim = np.array([self.vindx[1].min(), 
+		  		self.vindx[1].max()]) 
+		ylim = np.array([self.vindx[2].min(), 
+		  		self.vindx[2].max()]) 
+
+
+		labelLst = np.unique(self.optLabels[self.vindx]).astype(int)#.astype(str)
+		print(labelLst)
+		print(labelLst[~np.isnan(labelLst)])
+		# tLabels = np.unique(self.optLabels)
+		actual_bounds, bound_ticks, color_pallet = sty.cbar_bounds(list(labelLst[~np.isnan(labelLst)]))
+		cmap = mpl.colors.ListedColormap(color_pallet)
+		norm = mpl.colors.BoundaryNorm(actual_bounds, cmap.N+1)
+
+		compoundLabels = np.zeros(self.optLabels.shape[1:], dtype=str)
+
+		recountedLabels = np.zeros(self.optLabels.shape) + np.nan
+		for l in range(labelLst.size):
+			#for t in range(self.optLabels.shape[0]):
+			lindx = np.where(self.optLabels == labelLst[l])
+			recountedLabels[lindx] = l+1
+
+		for t in range(self.optLabels.shape[0]):
+			print(np.unique(self.optLabels[t, ...]))
+			kwargsDict = {'cmap': cmap, 'norm': norm}
+			ax, im  = self.mapMake._mapGen(fig, gs[t, 0], 
+												recountedLabels[t, ...],
+												timeAxis=True, 
+												#flareContour=self.mask_map, 
+												**kwargsDict)
+			ax.set_xlim(xlim* self.quesoOut.deltas['pxlSlitWidth'].magnitude)
+			ax.set_ylim(ylim* self.quesoOut.deltas['pxlAlongSlit'].magnitude)
+
+			ax.set_aspect("equal")
+
+			if not gs[t, 0].is_last_row():
+				ax.set_xticklabels([])
+
+			#cbar = fig.colorbar(im, cax=cax, ticks=bounds_ticks)#, label='Binned Intensity')
+				#
+			# cbar.ax.set_yticklabels(["{}XX".format(int(x)) for x in recountLst])
+			compoundLabels = np.char.add(compoundLabels, np.char.zfill(recountedLabels[t, ...].astype(np.uint).astype(str), 2))
+		
+		cax = fig.add_subplot(gs[:, 1])
+		cbar = fig.colorbar(im, spacing='uniform',
+									ticks=bound_ticks, orientation=orientation,
+									cax=cax)
+		cbar.ax.set_yticklabels(["{}".format(int(x)) for x in np.unique(labelLst)])
+		
+
+
+		print(np.unique(compoundLabels))
+		compoundLabels[~np.char.isalnum(compoundLabels)] = np.nan
+
+		recountedCompoundLabels = np.zeros(compoundLabels.shape) + np.nan
+		labelLst = np.unique(compoundLabels[:-1])
+		for l in range(labelLst.size):
+			#for t in range(self.optLabels.shape[0]):
+			lindx = np.where(compoundLabels == labelLst[l])
+			recountedCompoundLabels[lindx] = l+1
+		print(labelLst)
+		print(np.unique(recountedCompoundLabels))
+		fig2 = plt.figure(layout='compressed', figsize=(10, 7), dpi=300)
+		gs2 = GridSpec(1, 2, figure=fig2,  width_ratios=[1, 0.025], hspace=0, wspace=0)		
+		_, color_pallet = sty._genColorPallet(len(np.unique(labelLst)))
+		cmap = mpl.colors.ListedColormap(color_pallet)
+		#cmap = mpl.cm.get_cmap('rainbow_r', len(labelLst))
+		cmap.set_bad("#FFFFFF")
+		kwargsDict = {'cmap': cmap}
+		ax, im  = self.mapMake._mapGen(fig2, gs2[0, 0], 
+												recountedCompoundLabels.astype(int),
+												timeAxis=True, 
+												#flareContour=self.mask_map, 
+												**kwargsDict)
+		ax.set_xlim(xlim*self.quesoOut.deltas['pxlSlitWidth'].magnitude)
+		ax.set_ylim(ylim*self.quesoOut.deltas['pxlAlongSlit'].magnitude)
+		ax.set_aspect("equal")
+
+		cax = fig2.add_subplot(gs2[0, 1])
+		cbar = fig2.colorbar(im, spacing='uniform', orientation=orientation,
+									cax=cax)
+		return(fig, fig2)
+
+	@loggTimer
+	def figure03(self):
+#> detail: 
+#> param type self:
+#> return (type): 
+#> test-method:
+
+		width = [2, 0.025]
+		types = ['intensity', 'labels']
+		for t in range(len(types)):
+
+			fig = plt.figure(layout='compressed', figsize=(2*4, 3.25*4), dpi=300)
+
+			gs = GridSpec(3,2, figure=fig, width_ratios=width, height_ratios=[1, 1, 1], hspace=0, wspace=0)
+
+
+			intrinsicConfig = self.config.srcLst.clusterConfig['intrinsic']
+			for i in range(len(intrinsicConfig)):
+				match intrinsicConfig[i]['label']:
+					case 'window':
+						moment0 = self.quesoOut.instrumentObj.dataSquare[:, self.ii:self.jj+1].mean(axis=-1).compute()
+						bins = intrinsicConfig[i]['layerConfig']['bins']
+						cbar_label = "Mean Window Intensity"
+					case 'continuum':
+						moment0 = self.quesoOut.instrumentObj.dataSquare[:, self.quesoOut.continuum].compute()
+						bins = intrinsicConfig[i]['layerConfig']['bins']
+						cbar_label = "Continuum Intensity"
+
+				intrinsicLayerMap = baseRun.runIntrinsic(len(np.diff(bins)), np.floor(moment0*100)/100., 
+											  edgeOverride=np.array(bins).astype(float))
+				_, color_pallet = sty._genColorPallet(len(np.unique(intrinsicLayerMap)))
+
+				match types[t]:
+					case 'intensity':
+						present = moment0
+						cmap = 'Greys_r'
+					case 'labels':
+						present = intrinsicLayerMap
+						cmap = mpl.colors.ListedColormap(color_pallet)
+						norm = mpl.colors.BoundaryNorm(np.array(bins).astype(float), cmap.N)
+
+				kwargsDict = {'cmap': cmap}
+				# if i > np.inf:
+				# 	ax, im, tax = self.mapMake._mapGen(fig, gs[i, 0], 
+				# 									present,
+				# 									timeAxis=True,
+				# 									#flareContour=self.mask_map, 
+				# 									**kwargsDict)
+
+				# 	ax.set_xlabel("Raster Direction [arcseconds]")
+				# 	tax.set_xlabel('Time  [hours after 20:02:42 UTC]')	
+				# else:
+				ax, im = self.mapMake._mapGen(fig, gs[i, 0], 
+												present,
+												#flareContour=self.mask_map, 
+												**kwargsDict)
+
+				ax.set_xticklabels([])
+				ax.set_aspect("equal")
+				ax.set_ylabel("Along Slit Direction [arcseconds]")
+
+				#ax.text(20, 2250, " ({})".format(self.alphaLst[i]), va="center", ha="center", bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.25', alpha=0.3), font='monospace')
+				# ax.annotate('({})'.format(self.alphaLst[i]),
+            	# 	xy=(0.035, 1-0.05), xycoords='axes fraction',
+				# 	xytext=(0.035, 1-0.05), textcoords='axes fraction', fontfamily='sans-serif',
+            	# 	va='center', ha='center', bbox=dict(boxstyle='square', facecolor='white', edgecolor='black', alpha=0.4))
+				
+				cax = fig.add_subplot(gs[i, 1])
+				match types[t]:
+					case 'intensity':
+						im_cbar = im
+					case 'labels':
+						im_cbar = mpl.cm.ScalarMappable(norm=norm, cmap=cmap)
+				cbar = fig.colorbar(im_cbar, cax=cax, spacing='uniform', label=cbar_label)
+
+			intrinsicLayerMap_oldCount = auxAtom.pick_jth_label(self.optLabels[self.vindx], 0).astype(float)
+			intrinsicLayerMap = np.zeros(self.optLabels.shape) + np.nan
+			recountLst = np.unique(intrinsicLayerMap_oldCount)
+			for rc in range(recountLst.size):
+				lindx = np.where(intrinsicLayerMap_oldCount == recountLst[rc])[0]
+				intrinsicLayerMap[self.vindx[lindx]] = rc+1
+
+			actual_bounds, bound_ticks, color_pallet = sty.cbar_bounds(list(np.unique(intrinsicLayerMap[self.vindx])))
+			cmap = mpl.colors.ListedColormap(color_pallet)
+			norm = mpl.colors.BoundaryNorm(actual_bounds, cmap.N+1)
+
+			kwargsDict = {'cmap': cmap}
+			ax, im, tax = self.mapMake._mapGen(fig, gs[-1, 0], 
+												intrinsicLayerMap,
+												timeAxis=True, 
+												#flareContour=self.mask_map, 
+												**kwargsDict)
+			cax = fig.add_subplot(gs[-1, 1])
+			ax.set_aspect("equal")
+
+			#cbar = fig.colorbar(im, cax=cax, ticks=bounds_ticks)#, label='Binned Intensity')
+			cbar = fig.colorbar(mpl.cm.ScalarMappable(norm=norm, cmap=cmap), spacing='proportional',
+									ticks=bound_ticks,
+									cax=cax, label='Intrinsic bins')
+			cbar.ax.set_yticklabels(["{}XX".format(int(x)) for x in recountLst])
+
+			ax.set_xlabel("Raster Direction [arcseconds]")
+			tax.set_xlabel('Time  [hours after 20:02:42 UTC]')
+			ax.set_ylabel("Along Slit Direction [arcseconds]")
+
+			#ax.text(20, 2250, " ({})".format(self.alphaLst[2]), va="center", ha="center", bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.25', alpha=0.3))
+			# ax.annotate('({})'.format(self.alphaLst[2]),
+            # 		xy=(0.035, 1-0.05), xycoords='axes fraction',
+			# 		xytext=(0.035, 1-0.05), textcoords='axes fraction', fontfamily='sans-serif',
+            # 		va='center', ha='center', bbox=dict(boxstyle='square', facecolor='white', edgecolor='black', alpha=0.4))
+
+			#print(self.figDir + 'figure03_{}.pdf'.format(types[t]))
+			fig.savefig('./figure03_{}.png'.format(types[t]))
+			#fig.savefig(self.figDir + 'figure03_{}.pdf'.format(types[t]))
+
+
+	@loggTimer
+	def clusterProfiles(self, dev=False):
+		#> detail: 
+		#> param type self:
+		#> return (type): 
+		#> test-method:
+		
+		ii, jj = [self.ii, self.jj]
+		
+		wavelambda  = self.quesoOut.waveFit
+		validLabels = self.optLabels[self.vindx]
+		i0Arr = auxAtom.pick_jth_label(validLabels, 0)
+
+		i0o1Arr = auxAtom.pick_jth_label(validLabels, 0)*10 + auxAtom.pick_jth_label(validLabels, 1)
+
+		i0o1Lst = np.unique(i0o1Arr)
+
+		nrows = len(i0o1Lst)
+		ncols = 1 + auxAtom.pick_jth_label(validLabels, 2).max()
+
+		fig = plt.figure(layout='constrained', figsize=((ncols + 0.2)*3, nrows*3), dpi=300)
+		
+		gs  = GridSpec(nrows, ncols + 1, 
+					left=0, right=1, top=1, bottom=0, 
+					width_ratios=[1 for x in range(ncols)] + [0.2],
+					height_ratios=[1 for x in range(nrows)],
+					figure=fig)			
+
+		raw_max = (np.ceil(self.quesoOut.prepSquare[:, ii:jj+1].max()*10)/10.).compute()
+		raw_min = (np.floor(self.quesoOut.prepSquare[:, ii:jj+1].min()*10)/10.).compute()	
+		extent  	= (wavelambda[ii]-wavelambda[self.lineCenter]).magnitude, (wavelambda[jj]-wavelambda[self.lineCenter]).magnitude, raw_min, raw_max
+
+		color = "black"
+		panel_bounds = []
+		bounds_ticker = int(str(i0o1Lst[0])[0])
+		for j in range(len(i0o1Lst)):
+			i0_indx = np.where(i0o1Arr == i0o1Lst[j])[0]
+
+			ax0      = plt.subplot(gs[j, 0])
+			ax0 = self.spectralEntry(ax0, i0_indx, color, wavelambda.magnitude, extent)
+			if gs[j,0].is_last_row():
+				#ax0.set_xlabel(r"$\lambda-\lambda_{0}$ [$\mathrm{\AA}$]")
+				ax0.set_xlabel(r"$\lambda-\lambda_{0}$" +  " [{}]".format(wavelambda.units))
+			ax0.tick_params(labelleft=True)
+			#axR0.tick_params(labelright=False)
+			if not gs[j, 0].is_last_row():
+				ax0.tick_params(labelbottom=False)
+		
+			if bounds_ticker != int(str(i0o1Lst[j])[0]):
+				trans = mpl.transforms.blended_transform_factory(ax0.transData, fig.transFigure)
+				panel_bounds.append([-extent[0], ax0.get_position().bounds[2], j, trans])
+
+			bounds_ticker = int(str(i0o1Lst[j])[0])
+
+			o2Arr = auxAtom.pick_jth_label(validLabels[i0_indx], 2).astype(int)					
+			o2Lst = np.unique(o2Arr).astype(int)
+			for k in range(len(o2Lst)):
+				ax      	= plt.subplot(gs[j, k+1])
+				o2_indx 	= i0_indx[np.where(o2Arr == o2Lst[k])[0]]
+
+				sArr = auxAtom.pick_jth_label(validLabels[o2_indx], 0)
+				sindx = np.where(i0Arr == sArr[0])[0]
+
+				score = 0#scoresAtom.calcSingleSilhouetteScore(self.quesoOut.prepSquare[sindx.astype(np.uint32), ii:jj+1].compute(), validLabels[sindx.astype(np.uint32)], validLabels[o2_indx[0]])
+			
+				ax = self.spectralEntry(ax, o2_indx, color, wavelambda.magnitude, extent, scores=score)
+				if gs[j,k+1].is_last_row():
+					ax.set_xlabel(r"$\lambda-\lambda_{0}$" +  " [{}]".format(wavelambda.units))	
+				else:
+					ax.tick_params(labelbottom=False)				
+										
+				ax.tick_params(labelleft=False)
+				# if dev and not gs[j, k+1].is_last_col():
+				# 	axR.tick_params(labelright=False)
+
+
+
+		return(fig)
+
+	def spectralEntry(self, ax, indx, color, wavelambda, extent, scores=None, dev=False):
+		#> detail: 
+		#> param type self:
+		#> param type ax:
+		#> param type indx:
+		#> param type color:
+		#> param type wavelambda:
+		#> param type extent:
+		#> param type [None] scores:
+		#> return (type): 
+		#> test-method:
+		ii, jj = [self.ii, self.jj]
+		raw_dat = self.quesoOut.prepSquare[indx.astype(np.uint32), ii:jj+1].compute()
+		centroid_i = raw_dat.sum(axis=0)/raw_dat.shape[0]	
+
+
+		if dev:
+			resolvingIndex = scoresAtom.calcSingleResolvingIndex(raw_dat)
+			centroid_min, centroid_max = np.quantile(raw_dat, [0.25, 0.75], axis=0)			
+			axR = ax.twinx()
+			axR.set_ylim([-1, 1])
+			axR.plot(wavelambda[ii:jj+1]-wavelambda[self.lineCenter], resolvingIndex, color='red', linestyle='dashed', linewidth=0.75)
+			ax.plot(wavelambda[ii:jj+1]-wavelambda[self.lineCenter], centroid_min, color='blue', linewidth=0.75)
+			ax.plot(wavelambda[ii:jj+1]-wavelambda[self.lineCenter], centroid_max, color='blue', linewidth=0.75)
+			logger.debug("Resolving Index: {}".format(np.mean(np.abs(resolvingIndex))))
+
+		ax.plot(wavelambda[ii:jj+1]-wavelambda[self.lineCenter], centroid_i, color='black', linewidth=0.75)
+		
+		# im = ax.hist2d(raw_dat, bins=[0.01, wavelambda[ii:jj+1]-wavelambda[self.lineCenter]])
+
+		temp_im 	= auxAtom.density_hist2d(raw_dat, 0.01, extent[3], extent[2])
+
+		ww, insty = np.meshgrid((wavelambda[ii:jj+1+1]-wavelambda[self.lineCenter]), np.arange(extent[2], extent[3], 0.01))
+		im = ax.pcolormesh(ww, insty, temp_im.T, cmap=LinearSegmentedColormap.from_list('', ['white', color]))
+
+		ax.axvline(x = 0, linestyle='dashed', color='black')
+
+		tindx = self.vindx[0][indx]
+		xindx = self.vindx[1][indx]
+		yindx = self.vindx[2][indx]
+		labelLst = np.unique(self.optLabels[tindx, xindx, yindx]).astype(int).astype(str)
+		commonLabel = [labelLst[0][j] for j in range(len(labelLst[0])) if np.unique([a[j] for a in [list(x) for x in labelLst]]).size == 1]
+		#print(commonLabel)
+		label = "{}{}".format(int("".join(commonLabel)), "X"*(len(labelLst[0]) - len(commonLabel)))
+
+		if scores == None:
+			ax.text(0.9*(wavelambda[ii]-wavelambda[self.lineCenter]), 0.8*extent[3],
+						"{}\nN={}\n".format(label, len(indx)))
+#						fontname='Times New Roman')
+		else:
+			ax.text(0.9*(wavelambda[ii]-wavelambda[self.lineCenter]), 0.8*extent[3],
+					"{}\nN={}\nS={:.3f}\n".format(label, len(indx), float(scores)))
+#					fontname='Times New Roman')
+			
+		ax.xaxis.set_minor_locator(mpl.ticker.MultipleLocator(base=0.2))
+
+		return(ax)