`shesha.util`¶

Utilities functions Must be stand alone, ie. independent of the rest of the shesha package (except shesha_constants)

Utilities function for DM geometry initialization

shesha.util.dm_util.createDoubleHexaPattern(pitch: float, supportSize: int, pupAngleDegree: float)¶

Creates a list of M actuator positions spread over an hexagonal grid. The number M is the number of points of this grid, it cannot be known before the procedure is called. Coordinates are centred around (0,0). The support of the grid is a square [-supportSize/2,vsupportSize/2].

Parameters:

pitch: (float) : distance in pixels between 2 adjacent actus supportSize: (int) : size in pixels of the support over which the coordinate list

should be returned.

pupAngleDegree: (float) : Rotation angle of the DM

Returns:

xy: (np.ndarray(dims=2,dtype=np.float32)) : xy[2,M] list of coodinates

shesha.util.dm_util.createHexaPattern(pitch: float, supportSize: int)¶

Creates a list of M actuator positions spread over an hexagonal grid. The number M is the number of points of this grid, it cannot be known before the procedure is called. Coordinates are centred around (0,0). The support that limits the grid is a square [-supportSize/2, supportSize/2].

Parameters:

pitch: (float) : distance in pixels between 2 adjacent actus

supportSize: (int) : size in pixels of the support over which the coordinate list: should be returned.

Returns:

xy: (np.ndarray(dims=2,dtype=np.float32)) : xy[2,M] list of coordinates

shesha.util.dm_util.createSquarePattern(pitch: float, nxact: int)¶

Creates a list of M=nxact^2 actuator positions spread over an square grid. Coordinates are centred around (0,0).

Parameters:

pitch: (float) : distance in pixels between 2 adjacent actus

nxact: (int) : number of actu across the pupil diameter

Returns:

xy: (np.ndarray(dims=2,dtype=np.float32)) : xy[M,2] list of coodinates

shesha.util.dm_util.dim_dm_patch(pupdiam: int, diam: float, type: bytes, alt: float, xpos_wfs: List[float], ypos_wfs: List[float])¶

compute patchDiam for DM

Parameters:

pupdiam: (int) : pupil diameter

diam: (float) : telescope diameter

type: (bytes) : type of dm

alt: (float) : altitude of dm

xpos_wfs: (list) : list of wfs xpos

ypos_wfs: (list) : list of wfs ypos

shesha.util.dm_util.dim_dm_support(cent: float, extent: int, ssize: int)¶

Compute the DM support dimensions

Parameters:

cent : (float): center of the pupil

extent: (float): size of the DM support

ssize: (int): size of ipupil support

shesha.util.dm_util.filterActuWithPupil(actuPos: numpy.ndarray, pupil: numpy.ndarray, threshold: float) → numpy.ndarray¶

Select actuators based on their distance to the nearest pupil pixel The implementation proposed here is easy but limits it precision to an integer roundoff of the threshold

actuPos: 2 x nActu np.array[float]: actuator position list - pupil pixel units pupil: nPup x nPup np.ndarray[bool]: pupil mask threshold: float: max allowed distance - pupil pixel units

shesha.util.dm_util.make_zernike(nzer: int, size: int, diameter: int, xc=-1.0, yc=-1.0, ext=0)¶

Compute the zernike modes

Parameters:

nzer: (int) : number of modes

size: (int) : size of the screen

diameter: (int) : pupil diameter

xc: (float) : (optional) x-position of the center

yc: (float) : (optional) y-position of the center

ext: (int) : (optional) extension

Returns:

z : (np.ndarray(ndims=3,dtype=np.float64)) : zernikes modes

shesha.util.dm_util.select_actuators(xc: numpy.ndarray, yc: numpy.ndarray, nxact: int, pitch: int, cobs: float, margin_in: float, margin_out: float, N=None)¶

Select the “valid” actuators according to the system geometry

Parameters:

xc: actuators x positions (origine in center of mirror)

yc: actuators y positions (origine in center of mirror)

nxact:

pitch:

cobs:

margin_in:

margin_out:

N:

Returns:

liste_fin: actuator indice selection for xpos/ypos

shesha.util.dm_util.zernumero(zn: int)¶

Returns the radial degree and the azimuthal number of zernike number zn, according to Noll numbering (Noll, JOSA, 1976)

Parameters:	zn: (int) : zernike number
Returns:	rd: (int) : radial degrees an: (int) : azimuthal numbers

Functions for handling the database system Wrapping of some h5py function for quick HDF5 save

shesha.util.hdf5_utils.checkControlParams(savepath, config, pdict, matricesToLoad)¶

Compare the current controller parameters to the database. If similar parameters are found, matricesToLoad dictionary is completed. Since all the controller matrices are computed together, we only check the parameters for the imat matrix : if we load imat, we load eigenv and U too.

Parameters:

config : (module) : simulation parameters

matricesToLoad : (dictionary) : matrices that will be load and their path

shesha.util.hdf5_utils.checkDmsParams(savepath, config, pdict, matricesToLoad)¶

Compare the current controller parameters to the database. If similar parameters are found, matricesToLoad dictionary is completed. Since all the dms matrices are computed together, we only check the parameters for the pztok matrix : if we load pztok, we load pztnok too.

Parameters:

config : (module) : simulation parameters

matricesToLoad : (dictionary) : matrices that will be load and their path

shesha.util.hdf5_utils.checkMatricesDataBase(savepath, config, param_dict)¶

Check in the database if the current config have been already run. If so, return a dictionary containing the matrices to load and their path. Matrices which don’t appear in the dictionary will be computed, stored and added to the database during the simulation. If the database doesn’t exist, this function creates it.

Parameters:

savepath : (str) : path to the data repertory

config : (module) : simulation parameters

param_dict : (dictionary) : parameters dictionary

Returns:

matricesToLoad : (dictionary) : matrices that will be load and their path

shesha.util.hdf5_utils.checkTurbuParams(savepath, config, pdict, matricesToLoad)¶

Compare the current turbulence parameters to the database. If similar parameters are found, the matricesToLoad dictionary is completed. Since all the turbulence matrices are computed together, we only check the parameters for the A matrix : if we load A, we load B, istx and isty too.

Parameters:

config : (module) : simulation parameters

matricesToLoad : (dictionary) : matrices that will be load and their path

shesha.util.hdf5_utils.configFromH5(filename, config)¶: TODO: docstring

shesha.util.hdf5_utils.create_file_attributes(filename, config)¶

Create an hdf5 file wtih attributes corresponding to all simulation parameters

Param:

filename : (str) : full path + filename to create

config : () : simulation parameters

shesha.util.hdf5_utils.initDataBase(savepath, param_dict)¶

Initialize and create the database for all the saved matrices. This database will be placed on the top of the savepath and be named matricesDataBase.h5.

Parameters:

savepath : (str) : path to the data repertory

param_dict : (dictionary) : parameters dictionary

shesha.util.hdf5_utils.init_hdf5_files(savepath, param_dict, matricesToLoad)¶: TODO: docstring

shesha.util.hdf5_utils.load_AB_from_dataBase(database, ind)¶

Read and return A, B, istx and isty from the database

Parameters:

database: (dict): dictionary containing paths to matrices to load

ind: (int): layer index

shesha.util.hdf5_utils.load_dm_geom_from_dataBase(database, ndm)¶

Read and return the DM geometry

Parameters:

database: (dict): dictionary containing paths to matrices to load

ndm: (int): dm index

shesha.util.hdf5_utils.load_imat_from_dataBase(database)¶

Read and return the imat

Parameters:	database: (dict): dictionary containing paths to matrices to load

shesha.util.hdf5_utils.params_dictionary(config)¶

Create and returns a dictionary of all the config parameters with the corresponding keys for further creation of database and save files

Return param_dict:
Parameters:	config – (module) : simulation parameters
	(dictionary) : dictionary of parameters

shesha.util.hdf5_utils.readHdf5SingleDataset(filename, datasetName='dataset')¶

Read a single dataset from an hdf5 file

Parameters:

filename: (str) : name of the file to read from

datasetName: (str) : name of the dataset to read (default=”dataset”)

shesha.util.hdf5_utils.save_AB_in_database(k, A, B, istx, isty)¶

Save A, B, istx and isty in the database

Parameters:

ind:

A:

B:

istx:

isty:

shesha.util.hdf5_utils.save_dm_geom_in_dataBase(ndm, influpos, ninflu, influstart, i1, j1, ok)¶

Save the DM geometry in the database

Parameters:

ndm:

influpos:

ninflu:

influstart:

i1:

j1:

shesha.util.hdf5_utils.save_h5(filename, dataname, config, data)¶

save_hdf5(filename, dataname, config, data) Create a hdf5 file and store data in it with full header from config parameters Usefull to backtrace data origins

Param:

filename: (str) : full path to the file

dataname : (str) : name of the data (imat, cmat…)

config : (module) : config parameters

data : np.array : data to save

shesha.util.hdf5_utils.save_hdf5(filename, dataname, data)¶

Create a dataset in an existing hdf5 file filename and store data in it

Param:

filename: (str) : full path to the file

dataname : (str) : name of the data (imat, cmat…)

data : np.array : data to save

shesha.util.hdf5_utils.save_imat_in_dataBase(imat)¶

Save the DM geometry in the database

Parameters:	imat: (np.ndarray): imat to save

shesha.util.hdf5_utils.updateDataBase(h5file, savepath, matrix_type)¶

Update the database adding a new row to the matrix_type database.

Parameters:

h5file : (str) : path to the new h5 file to add

savepath : (str) : path to the data directory

matrix_type : (str) : type of matrix to store (“A”,”B”,”istx”,”isty”: “istx”,”eigenv”,”imat”,”U” “pztok” or “pztnok”)

shesha.util.hdf5_utils.updateParamDict(pdict, pClass, prefix)¶: Update parameters dictionnary pdict with all the parameters of pClass. Prefix must be set to define the key value of the new dict entries

shesha.util.hdf5_utils.validDataBase(savepath, matricesToLoad)¶: TODO: docstring

shesha.util.hdf5_utils.validFile(filename)¶: TODO: docstring

shesha.util.hdf5_utils.validInStore(store, savepath, matricetype)¶: TODO: docstring

shesha.util.hdf5_utils.writeHdf5SingleDataset(filename, data, datasetName='dataset')¶

Write a hdf5 file containig a single field

If the file already exists, it will be overwritten

Parametres:

filename: (str) : name of the file to write

data: (np.ndarray) : content of the file

datasetName: (str) : name of the dataset to write (default=”dataset”)

Computation of the influence functions used by the DM

shesha.util.influ_util.besel_orth(m, n, phi, r)¶

TODO: docstring

Parameters:

m:

n:

phi:

r:

Returns:

B:

shesha.util.influ_util.bessel_influence(xx, yy, type_i='square')¶

TODO: docstring

Parameters:

xx:

yy:

type_i: (optional)

Returns:

influ

shesha.util.influ_util.makeBessel(pitch: float, coupling: float, x: numpy.ndarray = None, y: numpy.ndarray = None, patternType: bytes = 'square')¶

Compute Bessel influence function

Parameters:

pitch: (float) : pitch of the DM expressed in pixels

coupling: (float) : coupling of the actuators

x: indices of influence function in relative position x local coordinates (float). 0 = top of the influence function

y: indices of influence function in relative position y local coordinates (float). 0 = top of the influence function

Returns:

influ: (np.ndarray(dims=3,dtype=np.float64)) : cube of the IF for each actuator

shesha.util.influ_util.makeBlacknutt(pitch: float, coupling: float, x=None, y=None)¶

Compute Blacknutt influence function Attention, ici on ne peut pas choisir la valeur de coupling. La variable a ete laissee dans le code juste pour compatibilité avec les autres fonctions, mais elle n’est pas utilisee.

Parameters:

pitch: (float): pitch of the DM expressed in pixels

coupling: (float) : coupling of the actuators

x: indices of influence function in relative position x local coordinates (float). 0 = top of the influence function

y: indices of influence function in relative position y local coordinates (float). 0 = top of the influence function

Returns:

influ: (np.ndarray(dims=3,dtype=np.float64)) : cube of the IF for each actuator

shesha.util.influ_util.makeGaussian(pitch: float, coupling: float, x=None, y=None)¶

Compute Gaussian influence function. Coupling parameter is not taken into account

Parameters:

pitch: (float) : pitch of the DM expressed in pixels

coupling: (float) : coupling of the actuators

x: indices of influence function in relative position x local coordinates (float). 0 = top of the influence function

y: indices of influence function in relative position y local coordinates (float). 0 = top of the influence function

Returns:

influ: (np.ndarray(dims=3,dtype=np.float64)) : cube of the IF for each actuator

shesha.util.influ_util.makeRadialSchwartz(pitch: float, coupling: float, x=None, y=None)¶

Compute radial Schwartz influence function

Parameters:

pitch: (float) : pitch of the DM expressed in pixels

coupling: (float) : coupling of the actuators

x: indices of influence function in relative position x local coordinates (float). 0 = top of the influence function

y: indices of influence function in relative position y local coordinates (float). 0 = top of the influence function

Returns:

influ: (np.ndarray(dims=3,dtype=np.float64)) : cube of the IF for each actuator

shesha.util.influ_util.makeRigaut(pitch: float, coupling: float, x=None, y=None)¶

Compute ‘Rigaut-like’ influence function

Parameters:

pitch: (float) : pitch of the DM expressed in pixels

coupling: (float) : coupling of the actuators

x: indices of influence function in relative position x local coordinates (float). 0 = top of the influence function

y: indices of influence function in relative position y local coordinates (float). 0 = top of the influence function

Returns:

influ: (np.ndarray(dims=3,dtype=np.float64)) : cube of the IF for each actuator

shesha.util.influ_util.makeSquareSchwartz(pitch: float, coupling: float, x=None, y=None)¶

Compute Square Schwartz influence function

Parameters:

pitch: (float) : pitch of the DM expressed in pixels

coupling: (float) : coupling of the actuators

x: indices of influence function in relative position x local coordinates (float). 0 = top of the influence function

y: indices of influence function in relative position y local coordinates (float). 0 = top of the influence function

Returns:

influ: (np.ndarray(dims=3,dtype=np.float64)) : cube of the IF for each actuator

Stencil and matrices computation for the creation of a turbulent screen

shesha.util.iterkolmo.AB(n, L0, deltax, deltay, rank=0)¶

DOCUMENT AB, n, A, B, istencil This function initializes some matrices A, B and a list of stencil indexes istencil for iterative extrusion of a phase screen.

The method used is described by Fried & Clark in JOSA A, vol 25, no 2, p463, Feb 2008. The iteration is : x = A(z-zRef) + B.noise + zRef with z a vector containing “old” phase values from the initial screen, that are listed thanks to the indexes in istencil.

SEE ALSO: extrude createStencil Cxx Cxz Czz

shesha.util.iterkolmo.Cxx(n, Zxn, Zyn, Xx, Xy, L0)¶: Cxx computes the covariance matrix of the new phase vector x (new column for the phase screen).

shesha.util.iterkolmo.Cxz(n, Zx, Zy, Xx, Xy, istencil, L0)¶

Cxz computes the covariance matrix between the new phase vector x (new column for the phase screen), and the already known phase values z.

The known values z are the values of the phase screen that are pointed by the stencil indexes (istencil)

shesha.util.iterkolmo.Czz(n, Zx, Zy, ist, L0)¶

Czz computes the covariance matrix of the already known phase values z.

The known values z are the values of the phase screen that are pointed by the stencil indexes (istencil)

shesha.util.iterkolmo.asymp_macdo(x)¶

Computes a term involved in the computation of the phase struct function with a finite outer scale according to the Von-Karman model. The term involves the MacDonald function (modified bessel function of second kind) K_{5/6}(x), and the algorithm uses the asymptotic form for x ~ infinity.

Warnings :

This function makes a floating point interrupt for x=0 and should not be used in this case.

Works only for x>0.

shesha.util.iterkolmo.create_screen(r0, pupixsize, screen_size, L0, A, B, ist)¶

DOCUMENT create_screen screen = create_screen(r0,pupixsize,screen_size,&A,&B,&ist)

creates a phase screen and fill it with turbulence r0 : total r0 @ 0.5m pupixsize : pupil pixel size (in meters) screen_size : screen size (in pixels) A : A array for future extrude B : B array for future extrude ist : istencil array for future extrude

shesha.util.iterkolmo.create_screen_assist(screen_size, L0, r0)¶: screen_size : screen size (in pixels) L0 : L0 in pixel r0 : total r0 @ 0.5 microns

shesha.util.iterkolmo.create_stencil(n)¶: TODO: docstring

shesha.util.iterkolmo.extrude(p, r0, A, B, istencil)¶

DOCUMENT p1 = extrude(p,r0,A,B,istencil)

Extrudes a phase screen p1 from initial phase screen p. p1 prolongates p by 1 column on the right end. r0 is expressed in pixels

The method used is described by Fried & Clark in JOSA A, vol 25, no 2, p463, Feb 2008. The iteration is : x = A(z-zRef) + B.noise + zRef with z a vector containing “old” phase values from the initial screen, that are listed thanks to the indexes in istencil.

Examples n = 32; AB, n, A, B, istencil; p = array(0.0,n,n); p1 = extrude(p,r0,A,B,istencil); pli, p1

SEE ALSO: AB() createStencil() Cxx() Cxz() Czz()

shesha.util.iterkolmo.macdo_x56(x, k=10)¶

Computation of the function

f(x) = x^(5/6)*K_{5/6}(x) using a series for the esimation of K_{5/6}, taken from Rod Conan thesis : K_a(x)=1/2 sum_{n=0}^infty

rac{(-1)^n}{n!}

left(Gamma(-n-a) (x/2)^{2n+a} + Gamma(-n+a) (x/2)^{2n-a}

ight) ,

with a = 5/6.

Setting x22 = (x/2)^2, setting uda = (1/2)^a, and multiplying by x^a, this becomes : x^a * Ka(x) = 0.5 $ -1^n / n! [ G(-n-a).uda x22^(n+a) + G(-n+a)/uda x22^n ] Then we use the following recurrence formulae on the following quantities : G(-(n+1)-a) = G(-n-a) / -a-n-1 G(-(n+1)+a) = G(-n+a) / a-n-1 (n+1)! = n! * (n+1) x22^(n+1) = x22^n * x22 and at each iteration on n, one will use the values already computed at step (n-1). The values of G(a) and G(-a) are hardcoded instead of being computed.

The first term of the series has also been skipped, as it vanishes with another term in the expression of Dphi.

shesha.util.iterkolmo.phase_struct(r, L0=None)¶: TODO: docstring

shesha.util.iterkolmo.rodconan(r, L0)¶

The phase structure function is computed from the expression Dphi(r) = k1 * L0^(5./3) * (k2 - (2.pi.r/L0)^5/6 K_{5/6}(2.pi.r/L0))

For small r, the expression is computed from a development of K_5/6 near 0. The value of k2 is not used, as this same value appears in the series and cancels with k2. For large r, the expression is taken from an asymptotic form.

shesha.util.iterkolmo.stencil_size(n)¶: TODO: docstring

shesha.util.iterkolmo.stencil_size_array(size)¶

Compute_size2(np.ndarray[ndim=1, dtype=np.int64_t] size)

Compute the size of a stencil, given the screen size

Parameters:	size: (np.ndarray[ndim=1,dtype=np.int64_t]) :screen size

Functions for DM KL initialization

shesha.util.kl_util.gkl_fcom(kers: numpy.ndarray, cobs: float, nf: int)¶

This routine does the work : finding the eigenvalues and corresponding eigenvectors. Sort them and select the right one. It returns the KL modes : in polar coordinates : rabas as well as the associated variance : evals. It also returns a bunch of indices used to recover the modes in cartesian coordinates (nord, npo and ordd).

Parameters:

kerns : (np.ndarray[ndim= ,dtype=np.float32]) :

cobs : (float) : central obstruction

nf : (int) :

shesha.util.kl_util.make_azimuth(nord: int, npp: int) → numpy.ndarray¶

TODO: docstring

Parameters:

nord:

npp:

Returns:

azbas:

shesha.util.kl_util.make_kernels(cobs: float, nr: int, radp: numpy.ndarray, kl_type: bytes, outscl: float = 3.0) → numpy.ndarray¶

This routine generates the kernel used to find the KL modes. The kernel constructed here should be simply a discretization of the continuous kernel. It needs rescaling before it is treated as a matrix for finding the eigen-values. The outer scale should be in units of the diameter of the telescope.

TODO:

Parameters:

cobs : (float): central obstruction

nr : (int) :

radp : (float) :

kl_type : (bytes) : “kolmo” or “karman”

outscl : (float) : outter scale for Von Karman spectrum

Returns:

kers :

shesha.util.kl_util.make_radii(cobs: float, nr: int) → float¶

TODO: docstring

Parameters:

cobs: (float) : central obstruction

nr : (int) :

shesha.util.kl_util.pcgeom(nr, npp, cobs, ncp, ncmar)¶

This routine builds a geom_struct. px and py are the x and y coordinates of points in the polar arrays. cr and cp are the r and phi coordinates of points in the cartesian grids. ncmar allows the possibility that there is a margin of ncmar points in the cartesian arrays outside the region of interest

TODO:

parameters:
nr:

npp:

cobs: (float) : central obstruction

ncp:

ncmar:

returns:
ncp:

ncmar:

px:

py:

cr:

cp:

pincx:

pincy:

pincw:

ap:

shesha.util.kl_util.piston_orth(nr: int) → numpy.ndarray¶

TODO: docstring

Parameters:	nr:
Returns:	s:

shesha.util.kl_util.polang(r: numpy.ndarray) → numpy.ndarray¶

This routine generates an array with the same dimensions as r, but containing the azimuthal values for a polar coordinate system.

TODO:

parameters: r:

return: p:

shesha.util.kl_util.radii(nr: int, npp: int, cobs: float) → numpy.ndarray¶

This routine generates an nr x npp array with npp copies of the radial coordinate array. Radial coordinate span the range from r=cobs to r=1 with successive annuli having equal areas (ie, the area between cobs and 1 is divided into nr equal rings, and the points are positioned at the half-area mark on each ring). There are no points on the border.

TODO:

parameters:
nr:

npp:

cobs: (float) : central obstruction

return:
r

shesha.util.kl_util.set_pctr(dim: int, nr, npp, nkl: int, cobs: float, nord, ncmar=None, ncp=None)¶

This routine calls pcgeom to build a geom_struct with the right initializations. bas is a gkl_basis_struct built with the gkl_bas routine. TODO:

Parameters:

dim:

nr:

npp:

nkl:

cobs:

nord:

ncmar: (optional)

ncp: (optional)

Returns:

ncp

ncmar

px

py

cr

cp

pincx

pincy

pincw

ap

shesha.util.kl_util.setpincs(ax: numpy.ndarray, ay: numpy.ndarray, px: numpy.ndarray, py: numpy.ndarray, cobs: float) → Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]¶

This routine determines a set of squares for interpolating from cartesian to polar coordinates, using only those points with cobs < r < 1 SEE ALSO : pcgeom

TODO:

parameters:
ax:

ay:

px:

py:

cobs: (float) : central obstruction

return:
pincx:

pincy:

pincw

make_apodizer function

shesha.util.make_apodizer.make_apodizer(dim, pupd, filename, angle)¶

TODO doc

Parameters:

(int) : im:

(int) : pupd:

(str) : filename:

(float) : angle:

Pupil creation functions

shesha.util.make_pupil.centrePourVidal(N, i0, j0, centerMark)¶: Renvoie une image de boolens (False) de taille (N,N) avec un point ou une croix (True) centree sur (i0, j0). :param int N: taille de l’image de sortie :param float i0, j0: position du marqueur de sortie :param int centerMark: 0 (pour rien), 1 (option point) ou 2 (option croix)

shesha.util.make_pupil.compute1Spider(nspider, N, dspider, i0, j0, scale, rot)¶: Fonction de fab pour creer le slaving. La fonction cree un tableau de booleens avec une seule spider. Utilisee par la fonction compute6Segments()

shesha.util.make_pupil.compute6Segments(pupNoSpiders, N, pixscale, dspider, i0, j0, rot=0)¶

N = p_geom.pupdiam i0 = j0 = N / 2. - 0.5 D = p_tel.diam pixscale = D/N dspider = 0.51

Utilisee dans compass/shesha/shesha/supervisor/canapassSupervisor.py pour le slaving des actus.

shesha.util.make_pupil.createHexaPattern(pitch, supportSize)¶

Cree une liste de coordonnees qui decrit un maillage hexagonal. Retourne un tuple (x,y).

Le maillage est centre sur 0, l’un des points est (0,0). Une des pointes de l’hexagone est dirigee selon l’axe Y, au sens ou le tuple de sortie est (x,y).

Parameters:	pitch (float) – distance between 2 neighbour points supportSize (int) – size of the support that need to be populated

shesha.util.make_pupil.fillPolygon(x, y, i0, j0, scale, gap, N, index=0)¶

From a list of points defined by their 2 coordinates list x and y, creates a filled polygon with sides joining the points. The polygon is created in an image of size (N, N). The origin (x,y)=(0,0) is mapped at pixel i0, j0 (both can be floating-point values). Arrays x and y are supposed to be in unit U, and scale is the pixel size in U units.

Returns:	filled polygon (N, N), boolean
Parameters:	x, y (float) – list of points defining the polygon i0, j0 (float) – index of pixels where the pupil should be centred. Can be floating-point indexes. scale (float) – size of a pixel of the image, in same unit as x and y. N (float) – size of output image.
Example:

x = np.array([1,-1,-1.5,0,1.1]) y = np.array([1,1.5,-0.2,-2,0]) N = 200 i0 = N/2 j0 = N/2 gap = 0. scale = 0.03 pol = fillPolygon(x, y, i0, j0, scale, gap, N, index=2)

shesha.util.make_pupil.fillSpider(N, nspider, dspider, i0, j0, scale, rot)¶

Creates a boolean spider mask on a map of dimensions (N,N) The spider is centred at floating-point coords (i0,j0).

Returns:	spider image (boolean)
Parameters:	N (int) – size of output image nspider (int) – number of spiders dspider (float) – width of spiders i0 (float) – coord of spiders symmetry centre j0 (float) – coord of spiders symmetry centre scale (float) – size of a pixel in same unit as dspider rot (float) – rotation angle in radians

shesha.util.make_pupil.gendron()¶

La fonction est appelee quand l’utilisateur a demande une pupille ELT, et renseigne un diametre de telescope different de 40 metres.

Faut vraiment que je commente ou t’as compris ??

shesha.util.make_pupil.generateCoordSegments(D, rot)¶

Computes the coordinates of the corners of all the hexagonal segments of M1. Result is a tuple of arrays(6, 798).

Parameters:	D (float) – D is the pupil diameter in meters, it must be set to 40.0 m

for the nominal EELT. :param float rot: pupil rotation angle in radians

shesha.util.make_pupil.generateEeltPupilMask(npt, dspider, i0, j0, pixscale, gap, rotdegree, D=40.0, centerMark=0, halfSpider=0)¶

Generates a boolean pupil mask of the binary EELT pupil on a map of size (npt, npt).

Returns:	pupil image (npt, npt), boolean
Parameters:	npt (int) – size of the output array dspider (float) – width of spiders in meters i0, j0 (float) – index of pixels where the pupil should be centred = p_geom.pupdiam / 2. - 0.5 Can be floating-point indexes. pixscale (float) – size of a pixel of the image, in meters = ptel.diam/(p_geom.pupdiam / 2. - 0.5) gap (float) – gap between 2 segments in metres rotdegree (float) – rotation angle of the pupil, in degrees. D (float) – diameter of the pupil. For the nominal EELT, D shall be set to 40.0 centerMark (int) – when centerMark!=0, a pixel is added at the centre of symmetry of the pupil in order to debug things using compass. centerMark==1 draws a point centerMark==2 draws 2 lines halfSpider (int) – created by F Vidal.
Example:

npt = p_geom.pupdiam D = p_tel.diam i0 = npt / 2. - 0.5 j0 = npt / 2. - 0.5 rotdegree = 0. pixscale = D/(npt / 2. - 0.5) dspider = 0.51 gap = 0.0 pup = generateEeltPupilMask(npt, dspider, i0, j0, pixscale, gap, rotdegree)

shesha.util.make_pupil.generateSegmentProperties(attribute, hx, hy, i0, j0, scale, gap, N, D, softGap=0)¶

Builds a 2D image of the pupil with some attributes for each of the segments. Those segments are described from arguments hx and hy, that are produced by the function generateCoordSegments(D, rot).

When attribute is a phase, then it must be a float array of dimension [3, 798] with the dimension 3 being piston, tip, and tilt. Units of phase is xxx rms, and the output of the procedure will be in units of xxx.

Returns:

pupil image (N, N), with the same type of input argument attribute

Parameters:

attribute (float/int/bool) – scalar value or 1D-array of the reflectivity of the segments or 2D array of phase If attribute is scalar, the value will be replicated for all segments. If attribute is a 1D array, then it shall contain the reflectivities of all segments. If attribute is a 2D array then it shall contain the piston, tip and tilt of the segments. The array shall be of dimension [3, 798] that contains [piston, tip, tilt] On output, the data type of the pupil map will be the same as attribute.
hx, hy (float) – arrays [6,:] describing the segment shapes. They are generated using generateCoordSegments()
dspider (float) – width of spiders in meters
i0, j0 (float) – index of pixels where the pupil should be centred. Can be floating-point indexes.
scale (float) – size of a pixel of the image, in meters.
gap (float) – half-space between segments in meters
N (int) – size of the output array (N,N)
D (float) – diameter of the pupil. For the nominal EELT, D shall be set to 40.0
softGap (bool) – if False, the gap between segments is binary 0/1 depending if the pixel is within the gap or not. If True, the gap is a smooth region of a fwhm of 2 pixels with a depth related to the gap width.

attribute = np.ones(798)+np.random.randn(798)/20. N = 800 i0 = N/2 j0 = N/2 rotdegree = 0.0 scale = 41./N gap = 0.03

shesha.util.make_pupil.getdatatype(truc)¶: Returns the data type of a numpy variable, either scalar value or array

shesha.util.make_pupil.make_EELT(dim, pupd, tel, N_seg=-1)¶

Initialize the EELT pupil

Parameters:

dim: (long) : linear size of ???

pupd: (long) : linear size of total pupil

tel: (Param_tel) : Telescope structure

N_seg: (int)

TODO: complete TODO : add force rescal pup elt

shesha.util.make_pupil.make_VLT(dim, pupd, tel)¶

Initialize the VLT pupil

Parameters:

dim: (long) : linear size of ???

pupd: (long) : linear size of total pupil

tel: (Param_tel) : Telescope structure

shesha.util.make_pupil.make_phase_ab(dim, pupd, tel, pup)¶

Compute the EELT M1 phase aberration

Parameters:

dim: (long) : linear size of ???

pupd: (long) : linear size of total pupil

tel: (Param_tel) : Telescope structure

pup: (?)

TODO: complete

shesha.util.make_pupil.make_pupil(dim, pupd, tel, xc=-1, yc=-1, real=0, halfSpider=0)¶

Initialize the system pupil

Parameters:

dim: (long) : = p_geom.pupdiam

pupd: (long) : linear size of total pupil = p_geom.pupdiam

tel: (Param_tel) : Telescope structure

xc: (int) = p_geom.pupdiam / 2. - 0.5

yc: (int) = p_geom.pupdiam / 2. - 0.5

real: (int)

cobs: (float) : central obstruction ratio.

TODO: complete

shesha.util.make_pupil.make_pupil_generic(dim, pupd, t_spiders=0.01, spiders_type='six', xc=0, yc=0, real=0, cobs=0)¶

Initialize the system pupil

Parameters:

dim: (long) : linear size of ???

pupd: (long) : linear size of total pupil

t_spiders: (float) : secondary supports ratio.

spiders_type: (str) : secondary supports type: “four” or “six”.

xc: (int)

yc: (int)

real: (int)

cobs: (float) : central obstruction ratio.

TODO: complete

shesha.util.make_pupil.reorganizeSegmentsOrderESO(x, y)¶

Reorganisation des segments facon ESO. Voir ESO-193058 Standard Coordinate System and Basic Conventions

Return tuple (x,y):
Parameters:	x (float) – tableau des centres X des segments y (float) – idem Y
	meme tuple que les arguments d’entree, mais tries.

Some utilities functions for RTC

shesha.util.rtc_util.centroid_gain(E, F)¶

Returns the mean centroid gain

Parameters:

E : (np.array(dtype=np.float32)) : measurements from WFS

F : (np.array(dtype=np.float32)) : geometric measurements

Returns:

cgain : (float) : mean centroid gain between the sets of WFS measurements and geometric ones

shesha.util.rtc_util.create_interp_mat(dimx: int, dimy: int)¶

TODO doc

Parameters:

dimx: (int) :

dimy: (int) :

Basic utilities function

shesha.util.utilities.bin2d(data_in, binfact)¶

Returns the input 2D array “array”, binned with the binning factor “binfact”. The input array X and/or Y dimensions needs not to be a multiple of “binfact”; The final/edge pixels are in effect replicated if needed. This routine prepares the parameters and calls the C routine _bin2d. The input array can be of type int, float or double. Last modified: Dec 15, 2003. Author: F.Rigaut SEE ALSO: _bin2d

Parmeters:

data_in: (np.ndarray) : data to binned

binfact: (int) : binning factor

shesha.util.utilities.dist(dim, xc=-1, yc=-1)¶: TODO: docstring

shesha.util.utilities.fft_goodsize(s)¶

find best size for a fft from size s

Parameters:	s: (int) size

shesha.util.utilities.load_config_from_file(sim_class, filename_path: str) → None¶

Load the parameters from the parameters file

Parameters:	filename_path: (str): path to the parameters file

shesha.util.utilities.load_config_from_module(sim_class, filepath: str) → None¶

Load the parameters from the parameters module

Parameters:	filepath: (str): path to the parameters module

shesha.util.utilities.makegaussian(size, fwhm, xc=-1, yc=-1, norm=0)¶

Returns a centered gaussian of specified size and fwhm. norm returns normalized 2d gaussian

Parameters:	size – (int) : fwhm – (float) : xc – (float) : (optional) center position on x axis yc – (float) : (optional) center position on y axis norm – (int) : (optional) normalization

shesha.util.utilities.pad_array(A, N)¶: TODO: docstring

shesha.util.utilities.rebin(a, shape)¶: TODO: docstring

`shesha.util`¶

Previous topic

This Page

shesha.util¶

`shesha.util`¶