This optimizer class handles all the modal basis and DM Influence functions related operations. More...

Inheritance diagram for shesha.supervisor.optimizers.modalBasis.ModalBasis:

Collaboration diagram for shesha.supervisor.optimizers.modalBasis.ModalBasis:

Public Member Functions
def	__init__ (self, config, dms, target)

csr_matrix	compute_influ_basis (self, int dm_index)
	Computes and return the influence function phase basis of the specified DM as a sparse matrix. More...

np.ndarray	compute_modes_to_volts_basis (self, str modal_basis_type, *bool merged=False, int nbpairs=None, bool return_delta=False)
	Computes a given modal basis ("KL2V", "Btt", "Btt_petal") and return the 2 transfer matrices. More...

np.ndarray	compute_btt_basis (self, *bool merged=False, int nbpairs=None, bool return_delta=False)
	Computes the so-called Btt modal basis. More...

np.ndarray	compute_merged_influ (self, int dm_index, *int nbpairs=None)
	Used to compute merged IF from each side of the spider for an ELT case (Petalling Effect) More...

np.ndarray	compute_btt_petal (self)
	Computes a Btt modal basis with Pistons filtered. More...

np.ndarray	compute_phase_to_modes (self, np.ndarray modal_basis)
	Return the phase to modes matrix by using the given modal basis. More...

Public Attributes
	config

	dms

	target

	slaved_actus

	selected_actus

	couples_actus

	index_under_spiders

	modal_basis

	projection_matrix
	Instantiate a ModalBasis object. More...

	btt

Detailed Description

This optimizer class handles all the modal basis and DM Influence functions related operations.

Definition at line 50 of file modalBasis.py.

Constructor & Destructor Documentation

◆ init()

def shesha.supervisor.optimizers.modalBasis.ModalBasis.__init__	(	self,
		config,
		dms,
		target
	)

Definition at line 103 of file modalBasis.py.

                                      nbpairs: int = None, return_delta: bool = False) -> np.ndarray:
         """ Computes a given modal basis ("KL2V", "Btt", "Btt_petal") and return the 2 transfer matrices
  
         Parameters:
             modal_basis_type : (str) : modal basis to compute ("KL2V", "Btt", "Btt_petal")
  
             merged : (bool, optional) :
  
             nbpairs : (int, optional) :
  
         Return:

Member Function Documentation

◆ compute_btt_basis()

np.ndarray shesha.supervisor.optimizers.modalBasis.ModalBasis.compute_btt_basis	(		self,
		*bool	merged = `False`,
		int	nbpairs = `None`,
		bool	return_delta = `False`
	)

Computes the so-called Btt modal basis.

The <merged> flag allows merto merge 2x2 the actuators influence functions for actuators on each side of the spider (ELT case)

Parameters: merged (bool, optional) : If True, merge 2x2 the actuators influence functions for actuators on each side of the spider (ELT case). Default is False

: nbpairs (int, optional) : Default is None. TODO : description

: return_delta (bool, optional) : If False (default), the function returns Btt (modes to volts matrix), and P (volts to mode matrix). If True, returns delta = IF.T.dot(IF) / N instead of P

Return: Btt (np.ndarray) : Btt modes to volts matrix

: projection_matrix (np.ndarray) : volts to Btt modes matrix

Definition at line 199 of file modalBasis.py.

  
         if (merged):
             btt2 = np.zeros((len(boolarray) + 2, self.btt.shape[1]))
             btt2[np.r_[~boolarray, True, True], :] = self.btt
             btt2[couples_actus[:, 1], :] = btt2[couples_actus[:, 0], :]
  
             P2 = np.zeros((self.btt.shape[1], len(boolarray) + 2))
             P2[:, np.r_[~boolarray, True, True]] = self.projection_matrix
             P2[:, couples_actus[:, 1]] = P2[:, couples_actus[:, 0]]
             self.btt = btt2
             self.projection_matrix = P2
  
         return self.btt, self.projection_matrix
  
     def compute_merged_influ(self, dm_index : int, *, nbpairs: int = None) -> np.ndarray:
         """ Used to compute merged IF from each side of the spider
         for an ELT case (Petalling Effect)
  
         Parameters:
             dm_index : (int) : DM index
  
             nbpairs : (int, optional) : Default is None. TODO : description
  
         Return:
             pairs : (np.ndarray) : TODO description
  
             discard : (list) : TODO description
         """
         p_geom = self.config.p_geom
  
  
         cent = p_geom.pupdiam / 2. + 0.5
         p_tel = self.config.p_tel
         p_tel.t_spiders = 0.51
         spup = mkP.make_pupil(p_geom.pupdiam, p_geom.pupdiam, p_tel, cent,
                               cent).astype(np.float32).T
  
         p_tel.t_spiders = 0.
         spup2 = mkP.make_pupil(p_geom.pupdiam, p_geom.pupdiam, p_tel, cent,
                                cent).astype(np.float32).T

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compute_btt_petal()

np.ndarray shesha.supervisor.optimizers.modalBasis.ModalBasis.compute_btt_petal ( self )

Computes a Btt modal basis with Pistons filtered.

Return: Btt (np.ndarray) : Btt modes to volts matrix

: P (np.ndarray) : volts to Btt modes matrix

Definition at line 359 of file modalBasis.py.

         for i in range(nbmode):
             self.dms.set_command((modal_basis[:, i]).copy())
             # self.next(see_atmos=False)
             self.target.raytrace(0, dms=self.dms, ncpa=False, reset=True)
             phase = self.target.get_tar_phase(0, pupil=True)
             # Normalisation pour les unites rms en microns !!!
             norm = np.sqrt(np.sum((phase)**2) / S)
             phase_to_modes[i] = phase / norm
         return phase_to_modes

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compute_influ_basis()

csr_matrix shesha.supervisor.optimizers.modalBasis.ModalBasis.compute_influ_basis	(		self,
		int	dm_index
	)

Computes and return the influence function phase basis of the specified DM as a sparse matrix.

Parameters: dm_index (int) : Index of the DM

Return: influ_sparse (csr_matrix) : influence function phases

Definition at line 123 of file modalBasis.py.

                     self.config.p_atmos, self.config.p_tel)
             fnz = util.first_non_zero(self.modal_basis, axis=0)
             # Computing the sign of the first non zero element
             #sig = np.sign(modal_basis[[fnz, np.arange(modal_basis.shape[1])]])
             sig = np.sign(self.modal_basis[tuple([

Here is the caller graph for this function:

◆ compute_merged_influ()

np.ndarray shesha.supervisor.optimizers.modalBasis.ModalBasis.compute_merged_influ	(		self,
		int	dm_index,
		*int	nbpairs = `None`
	)

Used to compute merged IF from each side of the spider for an ELT case (Petalling Effect)

Parameters: dm_index (int) : DM index

: nbpairs (int, optional) : Default is None. TODO : description

Return: pairs (np.ndarray) : TODO description

: discard (list) : TODO description

Definition at line 252 of file modalBasis.py.

         discard = np.zeros(len(dm_posx), dtype=np.bool)
         pairs = []
  
         # For each of the k pieces of the spider
         for k, px_list in enumerate(px_list_spider):
             pts = np.c_[px_list[1],
                         px_list[0]]  # x,y coord of pixels of the spider piece
             # line_eq = [a, b]
             # Which minimizes leqst squares of aa*x + bb*y = 1
             line_eq = np.linalg.pinv(pts).dot(np.ones(pts.shape[0]))
             aa, bb = line_eq[0], line_eq[1]
  
             # Find any point of the fitted line.
             # For simplicity, the intercept with one of the axes x = 0 / y = 0
             if np.abs(bb) < np.abs(aa):  # near vertical
                 one_point = np.array([1 / aa, 0.])
             else:  # otherwise
                 one_point = np.array([0., 1 / bb])
  
             # Rotation that aligns the spider piece to the horizontal
             rotation = np.array([[-bb, aa], [-aa, -bb]]) / (aa**2 + bb**2)**.5
  
             # Rotated the spider mask
             rotated_px = rotation.dot(pts.T - one_point[:, None])
             # Min and max coordinates along the spider length - to filter actuators that are on
             # 'This' side of the pupil and not the other side
             min_u, max_u = rotated_px[0].min() - 5. * pitch, rotated_px[0].max(
             ) + 5. * pitch
  
             # Rotate the actuators
             rotated_actus = rotation.dot(dm_pos_mat - one_point[:, None])
             sel_good_side = (rotated_actus[0] > min_u) & (rotated_actus[0] < max_u)
             threshold = 0.05
             # Actuators below this piece of spider
             sel_discard = (np.abs(rotated_actus[1]) < threshold * pitch) & sel_good_side
             discard |= sel_discard
  
             # Actuator 'near' this piece of spider
             sel_pairable = (np.abs(rotated_actus[1]) > threshold  * pitch) & \
                             (np.abs(rotated_actus[1]) < 1. * pitch) & \
                             sel_good_side
  
             pairable_index = np.where(sel_pairable)[0]  # Indices of these actuators
             u_coord = rotated_actus[
                     0, sel_pairable]  # Their linear coord along the spider major axis
  
             order = np.sort(u_coord)  # Sort by linear coordinate
             order_index = pairable_index[np.argsort(
                     u_coord)]  # And keep track of original indexes
  
             # i = 0
             # while i < len(order) - 1:
             if (nbpairs is None):
                 i = 0
                 ii = len(order) - 1
             else:
                 i = len(order) // 2 - nbpairs
                 ii = len(order) // 2 + nbpairs
             while (i < ii):
                 # Check if next actu in sorted order is very close
                 # Some lonely actuators may be hanging in this list
                 if np.abs(order[i] - order[i + 1]) < .2 * pitch:
                     pairs += [(order_index[i], order_indx[i + 1])]
                     i += 2
                 else:
                     i += 1
         print('To discard: %u actu' % np.sum(discard))
         print('%u pairs to slave' % len(pairs))
         if np.sum(discard) == 0:
             discard = []
         else:
             list(np.where(discard)[0])
         return np.asarray(pairs), list(np.where(discard)[0])
  
     def compute_btt_petal(self) -> np.ndarray:
         """ Computes a Btt modal basis with Pistons filtered
  
         Return:
             Btt : (np.ndarray) : Btt modes to volts matrix
  
             P : (np.ndarray) : volts to Btt modes matrix
         """
         pzt_index = np.where([d.type is scons.DmType.PZT for d in self.config.p_dms])[0][0]
         influ_pzt = self.compute_influ_basis(pzt_index)
         petal_dm_index = np.where([
                 d.influ_type is scons.InfluType.PETAL for d in self.config.p_dms
         ])[0][0]
         influ_petal = self.compute_influ_basis(petal_dm_index)
         tt_index = np.where([d.type is scons.DmType.TT for d in self.config.p_dms])[0][0]
         influ_tt = self.compute_influ_basis(tt_index).toarray()
  
         self.modal_basis, self.projection_matrix = basis.compute_btt(influ_pzt.T, influ_tt.T, influ_petal=influ_petal)
         return self.modal_basis, self.projection_matrix
  
     def compute_phase_to_modes(self, modal_basis: np.ndarray) -> np.ndarray:
         """ Return the phase to modes matrix by using the given modal basis
  
         Parameters:
             modal_basis : (np.ndarray) : Modal basis matrix
  

Here is the caller graph for this function:

◆ compute_modes_to_volts_basis()

np.ndarray shesha.supervisor.optimizers.modalBasis.ModalBasis.compute_modes_to_volts_basis	(		self,
		str	modal_basis_type,
		*bool	merged = `False`,
		int	nbpairs = `None`,
		bool	return_delta = `False`
	)

Computes a given modal basis ("KL2V", "Btt", "Btt_petal") and return the 2 transfer matrices.

Parameters: modal_basis_type (str) : modal basis to compute ("KL2V", "Btt", "Btt_petal")

: merged (bool, optional) :

: nbpairs (int, optional) :

Return: modal_basis (np.ndarray) : modes to volts matrix

: projection_matrix (np.ndarray) : volts to modes matrix (None if "KL")

Definition at line 142 of file modalBasis.py.

             ])])  # pour remove le future warning!
             self.modal_basis *= sig[None, :]
         elif (modal_basis_type == "Btt_petal"):
             print("Computing Btt with a Petal basis...")
             self.modal_basis, self.projection_matrix = self.compute_btt_petal()
         else:
             raise ArgumentError("Unsupported modal basis")
  
         return self.modal_basis, self.projection_matrix
  
     def compute_btt_basis(self, *, merged: bool = False, nbpairs: int = None,
                           return_delta: bool = False) -> np.ndarray:
         """ Computes the so-called Btt modal basis. The <merged> flag allows merto merge
         2x2 the actuators influence functions for actuators on each side of the spider (ELT case)
  
         Parameters:
             merged : (bool, optional) : If True, merge 2x2 the actuators influence functions for
                                         actuators on each side of the spider (ELT case). Default
                                         is False
  
             nbpairs : (int, optional) : Default is None. TODO : description
  
             return_delta : (bool, optional) : If False (default), the function returns
                                               Btt (modes to volts matrix),
                                               and P (volts to mode matrix).
                                               If True, returns delta = IF.T.dot(IF) / N
                                               instead of P
  
         Return:
             Btt : (np.ndarray) : Btt modes to volts matrix
  
             projection_matrix : (np.ndarray) : volts to Btt modes matrix
         """
         dms_basis = basis.compute_IFsparse(self.dms.dms, self.config.p_dms, self.config.p_geom)
         influ_basis = dms_basis[:-2,:]
         tt_basis = dms_basis[-2:,:].toarray()

Here is the call graph for this function:

◆ compute_phase_to_modes()

np.ndarray shesha.supervisor.optimizers.modalBasis.ModalBasis.compute_phase_to_modes	(		self,
		np.ndarray	modal_basis
	)

Return the phase to modes matrix by using the given modal basis.

Parameters: modal_basis (np.ndarray) : Modal basis matrix

Return: phase_to_modes (np.ndarray) : phase to modes matrix

Definition at line 380 of file modalBasis.py.

Member Data Documentation

◆ btt

shesha.supervisor.optimizers.modalBasis.ModalBasis.btt

Definition at line 233 of file modalBasis.py.

◆ config

shesha.supervisor.optimizers.modalBasis.ModalBasis.config

(config) : Configuration parameters module

Definition at line 104 of file modalBasis.py.

◆ couples_actus

shesha.supervisor.optimizers.modalBasis.ModalBasis.couples_actus

TODO : docstring

Definition at line 109 of file modalBasis.py.

◆ dms

shesha.supervisor.optimizers.modalBasis.ModalBasis.dms

(DmCompass) : DmCompass instance

Definition at line 105 of file modalBasis.py.

◆ index_under_spiders

shesha.supervisor.optimizers.modalBasis.ModalBasis.index_under_spiders

TODO : docstring

Definition at line 110 of file modalBasis.py.

◆ modal_basis

shesha.supervisor.optimizers.modalBasis.ModalBasis.modal_basis

(np.ndarray) : Last modal basis computed

Definition at line 111 of file modalBasis.py.

◆ projection_matrix

shesha.supervisor.optimizers.modalBasis.ModalBasis.projection_matrix

Instantiate a ModalBasis object.

(np.ndarray) : Last projection_matrix computed

Parameters: config (config) : Configuration parameters module

: dms (DmCompass) : DmCompass instance

: target (TargetCompass) : TargetCompass instance

Definition at line 112 of file modalBasis.py.

◆ selected_actus

shesha.supervisor.optimizers.modalBasis.ModalBasis.selected_actus

TODO : docstring

Definition at line 108 of file modalBasis.py.

◆ slaved_actus

shesha.supervisor.optimizers.modalBasis.ModalBasis.slaved_actus

TODO : docstring

Definition at line 107 of file modalBasis.py.

◆ target

shesha.supervisor.optimizers.modalBasis.ModalBasis.target

(TargetCompass) : TargetCompass instance

Definition at line 106 of file modalBasis.py.

The documentation for this class was generated from the following file:

modalBasis.py

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ compute_btt_basis()

◆ compute_btt_petal()

◆ compute_influ_basis()

◆ compute_merged_influ()

◆ compute_modes_to_volts_basis()

◆ compute_phase_to_modes()

Member Data Documentation

◆ btt

◆ config

◆ couples_actus

◆ dms

◆ index_under_spiders

◆ modal_basis

◆ projection_matrix

◆ selected_actus

◆ slaved_actus

◆ target

◆ init()