targetCompass.py

 
from shesha.init.target_init import target_init
from shesha.supervisor.components.sourceCompass import SourceCompass
import numpy as np
 
class TargetCompass(SourceCompass):
    """ Target handler for compass simulation
 
    Attributes:
        target : (sutraWrap.Target) : Sutra target instance
 
        context : (carmaContext) : CarmaContext instance
 
        config : (config module) : Parameters configuration structure module
 
        sources : (List) : List of SutraSource instances used for raytracing
    """
    def __init__(self, context, config, tel):
        """ Initialize a TargetCompass component for target related supervision
 
        Parameters:
            context : (carmaContext) : CarmaContext instance
 
            config : (config module) : Parameters configuration structure module
 
            tel : (TelescopeCompass) : A TelescopeCompass instance
        """
        self.context = context
        self.config = config # Parameters configuration coming from supervisor init
        print("->target init")
        self.target = target_init(self.context, tel.tel, self.config.p_targets,
                                   self.config.p_atmos, self.config.p_tel,
                                   self.config.p_geom, self.config.p_dms, brahma=False)
        self.sources = self.target.d_targets
 
    def get_tar_image(self, tar_index : int, *, expo_type: str = "se") -> np.ndarray:
        """ Get the PSF in the direction of the given target
 
        Parameters:
            tar_index : (int) : Index of target
 
            expo_type : (str, optional) : "se" for short exposure (default)
                                          "le" for long exposure
 
        Return:
            psf : (np.ndarray) : PSF
        """
        if (expo_type == "se"):
            return np.fft.fftshift(
                    np.array(self.target.d_targets[tar_index].d_image_se))
        elif (expo_type == "le"):
            return np.fft.fftshift(
                    np.array(self.target.d_targets[tar_index].d_image_le)
            ) / self.target.d_targets[tar_index].strehl_counter
        else:
            raise ValueError("Unknown exposure type")
 
    def set_tar_phase(self, tar_index : int, phase : np.ndarray) -> None:
        """ Set the phase screen seen by the tar
 
        Parameters:
            tar_index : (int) : target index
 
            phase : (np.ndarray) : phase screen to set
        """
        self.target.d_targets[tar_index].set_phase(phase)
 
    def get_tar_phase(self, tar_index: int, *, pupil: bool = False) -> np.ndarray:
        """ Returns the target phase screen of target number tar_index
 
        Parameters:
            tar_index : (int) : Target index
 
            pupil : (bool, optional) : If True, applies the pupil on top of the phase screen
                                       Default is False
 
        Return:
            tar_phase : (np.ndarray) : Target phase screen
        """
        tar_phase = np.array(self.target.d_targets[tar_index].d_phase)
        if pupil:
            pup = self.config.p_geom._spupil
            tar_phase *= pup
        return tar_phase
 
    def reset_strehl(self, tar_index: int) -> None:
        """ Reset the Strehl Ratio of the target tar_index
 
        Parameters:
            tar_index : (int) : Target index
        """
        self.target.d_targets[tar_index].reset_strehlmeter()
 
    def reset_tar_phase(self, tar_index: int) -> None:
        """ Reset the phase screen of the target tar_index
 
        Parameters:
            tar_index : (int) : Target index
        """
        self.target.d_targets[tar_index].d_phase.reset()
 
    def get_strehl(self, tar_index: int, *, do_fit: bool = True) -> np.ndarray:
        """ Return the Strehl Ratio of target number tar_index.
        This fuction will return an array of 4 values as
        [SR SE, SR LE, phase variance SE [µm²], phase variance LE [µm²]]
 
        Parameters:
            tar_index : (int) : Target index
 
            do_fit : (bool, optional) : If True (default), fit the PSF
                                        with a sinc before computing SR
 
        Return:
            strehl : (np.ndarray) : Strehl ratios and phase variances
        """
        src = self.target.d_targets[tar_index]
        src.comp_strehl(do_fit)
        avg_var = 0
        if (src.phase_var_count > 0):
            avg_var = src.phase_var_avg / src.phase_var_count
        return [src.strehl_se, src.strehl_le, src.phase_var, avg_var]
 
    def get_ncpa_tar(self, tar_index : int) -> np.ndarray:
        """ Return the current NCPA phase screen of the target path
 
        Parameters:
            tar_index : (int) : Index of the target
 
        Return:
            ncpa : (np.ndarray) : NCPA phase screen
        """
        return np.array(self.target.d_targets[tar_index].d_ncpa_phase)
 
    def set_ncpa_tar(self, tar_index: int, ncpa: np.ndarray) -> None:
        """ Set the additional fixed NCPA phase in the target path.
        ncpa must be of the same size of the spupil support
 
        Parameters:
            tar_index : (int) : WFS index
 
            ncpa : (ndarray) : NCPA phase screen to set [µm]
        """
        self.target.d_targets[tar_index].set_ncpa(ncpa)
 
    def comp_tar_image(self, tarNum: int, *, puponly: int = 0, compLE: bool = True) -> None:
        """ Computes the PSF
 
        Parameters :
            tarNum: (int): target index
 
            puponly: (int, optionnal) : if set to 1, computes Airy (default=0)
 
            compLE: (bool, optionnal) : if True, the computed image is taken into account in long exposure image (default=True)
        """
        self.target.d_targets[tarNum].comp_image(puponly, compLE)
 
    def comp_strehl(self, tarNum: int, *, do_fit: bool = True) -> None:
        """ Computes the Strehl ratio
 
        Parameters :
            tarNum: (int): target index
        """
        self.target.d_targets[tarNum].comp_strehl(do_fit)