def test_saveloadScrn(self):
# test the saving and loading phase screens
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH,"sh_8x8.yaml"))
config.atmos.wholeScrnSize = 512
config.atmos.infinite = False
atmos = atmosphere.atmos(config)
# Make a directory to save the screens in
if os.path.exists('testscrns'):
shutil.rmtree('testscrns')
os.makedirs('testscrns')
atmos.saveScrns('testscrns')
try:
# change config to load scrns
config.atmos.scrnNames = []
for i in range(config.atmos.scrnNo):
config.atmos.scrnNames.append('testscrns/scrn{}.fits'.format(i))
atmos2 = atmosphere.atmos(config)
# Check that all scrns are identical
for i in range(config.atmos.scrnNo):
assert numpy.allclose(atmos.wholeScrns[i], atmos2.wholeScrns[i])
# delete that dir
shutil.rmtree('testscrns')
except:
# always delete that dir - even in case of failure
shutil.rmtree('testscrns')
raise
def testd_LegacySHWfsFrame(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
wfs = WFS.ShackHartmannLegacy(config, mask=mask)
wfs.frame(numpy.zeros((config.atmos.scrnNo, config.sim.simSize, config.sim.simSize)))
def testc_initLegacySHWfs(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
wfs = WFS.ShackHartmannLegacy(config, mask=mask)
def testa_initWfs(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize/2., config.sim.simSize)
wfs = WFS.WFS(config, mask=mask)
def test_Piezo_valid_actuators():
"""
Tests that when you set the "valid actuators", the DM doesn't use actuators marked 'invalid'
"""
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
wfs = WFS.ShackHartmann(config, mask=mask)
dm = DM.FastPiezo(config, n_dm=1, wfss=[wfs], mask=mask)
act_coord1 = dm.valid_act_coords[0]
act_coord_last = dm.valid_act_coords[-1]
act_coord2 = dm.valid_act_coords[1]
valid_actuators = numpy.ones(dm.n_acts, dtype=int)
valid_actuators[0] = valid_actuators[-1] = 0
dm.valid_actuators = valid_actuators
assert dm.n_valid_actuators == (dm.n_acts - 2)
assert not numpy.array_equal(dm.valid_act_coords[0], act_coord1)
assert not numpy.array_equal(dm.valid_act_coords[-1], act_coord_last)
assert numpy.array_equal(dm.valid_act_coords[0], act_coord2)
def testg_initCustomShape():
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH,
"sh_8x8.yaml"))
config.sim.pupilSize = 64
config.sim.simSize = 66
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
wfs = WFS.ShackHartmann(config, mask=mask)
dm = DM.KarhunenLoeve(config, n_dm=1, wfss=[wfs], mask=mask)
customShape = dm.iMatShapes
# saving temporary shapes
fname = os.path.dirname(
os.path.abspath(__file__)) + '/tmp_CustomDmShapes.fits'
fits.writeto(fname, customShape, overwrite=True)
# change size to ensure it tests interpolation
config.sim.pupilSize = 100
config.sim.simSize = 104
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
wfs = WFS.ShackHartmann(config, mask=mask)
config.dms[1].dmShapesFilename = fname
dm = DM.CustomShapes(config, n_dm=1, wfss=[wfs], mask=mask)
# remove temporary shapes
os.remove(fname)
def testa_initLgs(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8_lgs-uplink.yaml"))
mask = aotools.circle(config.sim.pupilSize/2., config.sim.simSize)
lgs = LGS.LGS(config.wfss[1], config)
def testd_initPhysLgs(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8_lgs-uplink.yaml"))
config.wfss[1].lgs.propagationMode = "Physical"
mask = aotools.circle(config.sim.pupilSize/2., config.sim.simSize)
lgs = LGS.LGS_Physical(config.wfss[1], config)
def testc_initGradWfs(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
config.sim.pupilSize = 10*config.wfss[0].nxSubaps
mask = aotools.circle(config.sim.pupilSize/2., config.sim.simSize)
wfs = WFS.Gradient(config, mask=mask)
def testa_initLgs(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8_lgs-uplink.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
lgs = LGS.LGS(config.wfss[1], config)
def testc_geoLgsPsf(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8_lgs-uplink.yaml"))
mask = aotools.circle(config.sim.pupilSize/2., config.sim.simSize)
config.wfss[1].lgs.propagationMode = "Geometric"
lgs = LGS.LGS_Geometric(config.wfss[1], config)
psf = lgs.getLgsPsf(
numpy.zeros((config.atmos.scrnNo, config.sim.simSize, config.sim.simSize)))
def testc_initGradWfs(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
config.sim.pupilSize = 10 * config.wfss[0].nxSubaps
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
wfs = WFS.Gradient(config, mask=mask)
def testd_initPhysLgs(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8_lgs-uplink.yaml"))
config.wfss[1].lgs.propagationMode = "Physical"
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
lgs = LGS.LGS_Physical(config.wfss[1], config)
def testd_SHWfsFrame(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
wfs = WFS.ShackHartmann(config, mask=mask)
wfs.frame(numpy.zeros((config.sim.simSize, config.sim.simSize)))
def testb_wfsFrame(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize/2., config.sim.simSize)
wfs = WFS.WFS(config, mask=mask)
wfs.frame(numpy.zeros((config.sim.simSize, config.sim.simSize)))
def test_fibreInit(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
sci = SCI.singleModeFibre(config, 0, mask)
def test_sciInit(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
sci = scienceinstrument.PSFCamera(config, 0, mask)
def testa_initDM():
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize/2., config.sim.simSize)
wfs = WFS.ShackHartmann(config, mask=mask)
dm = DM.DM(config, wfss=[wfs], mask=mask)
def testa_initWfs(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
wfs = WFS.WFS(config, mask=mask)
def teste_physLgsPsf(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8_lgs-uplink.yaml"))
config.wfss[1].lgs.propagationMode = "Physical"
mask = aotools.circle(config.sim.pupilSize/2., config.sim.simSize)
lgs = LGS.LGS_Physical(config.wfss[1], config, nOutPxls=10)
psf = lgs.getLgsPsf(
numpy.zeros((config.atmos.scrnNo, config.sim.simSize, config.sim.simSize)))
def test_runLOS(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
los = lineofsight.LineOfSight(config.wfss[0], config)
testPhase = numpy.arange(config.sim.simSize**2).reshape(
(config.sim.simSize,)*2)
phs = los.frame(testPhase)
def testd_GradWfsFrame(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
config.sim.pupilSize = 10*config.wfss[0].nxSubaps
mask = aotools.circle(config.sim.pupilSize/2., config.sim.simSize)
wfs = WFS.Gradient(config, mask=mask)
wfs.frame(numpy.zeros((config.sim.simSize, config.sim.simSize)))
def test_PhysWfs(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
config.wfss[0].propagationMode = "Physical"
mask = aotools.circle(config.sim.pupilSize/2., config.sim.simSize)
wfs = WFS.WFS(config, mask=mask)
wfs.frame(numpy.zeros((config.atmos.scrnNo, config.sim.scrnSize, config.sim.scrnSize)))
def testc_geoLgsPsf(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8_lgs-uplink.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
config.wfss[1].lgs.propagationMode = "Geometric"
lgs = LGS.LGS_Geometric(config.wfss[1], config)
psf = lgs.getLgsPsf(
numpy.zeros(
(config.atmos.scrnNo, config.sim.simSize, config.sim.simSize)))
def test_runLOS(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
los = lineofsight.LineOfSight(config.wfss[0], config)
testPhase = numpy.arange(config.sim.simSize**2).reshape(
(config.sim.simSize, ) * 2)
phs = los.frame(testPhase)
def test_fibreFrame(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
sci = SCI.singleModeFibre(config, 0, mask)
sci.frame(
numpy.ones((config.atmos.scrnNo, config.sim.scrnSize,
config.sim.scrnSize)))
def testd_GradWfsFrame(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
config.sim.pupilSize = 10 * config.wfss[0].nxSubaps
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
wfs = WFS.Gradient(config, mask=mask)
wfs.frame(numpy.zeros((config.sim.simSize, config.sim.simSize)))
def teste_physLgsPsf(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8_lgs-uplink.yaml"))
config.wfss[1].lgs.propagationMode = "Physical"
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
lgs = LGS.LGS_Physical(config.wfss[1], config, nOutPxls=10)
psf = lgs.getLgsPsf(
numpy.zeros(
(config.atmos.scrnNo, config.sim.simSize, config.sim.simSize)))
def test_sciFrame(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
sci = scienceinstrument.PSFCamera(config, 0, mask)
sci.frame(
numpy.ones((config.atmos.scrnNo, config.sim.scrnSize,
config.sim.scrnSize)))
def test_PhysWfs(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
config.wfss[0].propagationMode = "Physical"
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
wfs = WFS.WFS(config, mask=mask)
wfs.frame(
numpy.zeros((config.atmos.scrnNo, config.sim.scrnSize,
config.sim.scrnSize)))
def test_sciStrehl(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
sci = SCI.PSF(config, 0, mask)
sci.frame(
numpy.ones((config.atmos.scrnNo, config.sim.scrnSize,
config.sim.scrnSize)))
self.assertTrue(numpy.allclose(sci.instStrehl, 1.))
def loadConfig(self):
"""
Load the Soapy config file
"""
self.config = confParse.loadSoapyConfig(self.configfile)
self.nIters = self.config.sim.nIters
self.mask = circle.circle(
self.config.sim.pupilSize/2., self.config.sim.simSize)
self.wfsPixelScale = self.config.wfss[0].subapFOV/self.config.wfss[0].pxlsPerSubap
# Initialise the WFS (can use same one for all tests)
self.wfs = wfs.ShackHartmann(self.config, mask=self.mask)
def loadConfig(self):
"""
Load the Soapy config file
"""
self.config = confParse.loadSoapyConfig(self.configfile)
self.nIters = self.config.sim.nIters
self.mask = circle.circle(self.config.sim.pupilSize / 2.,
self.config.sim.simSize)
self.wfsPixelScale = self.config.wfss[0].subapFOV / self.config.wfss[
0].pxlsPerSubap
# Initialise the WFS (can use same one for all tests)
self.wfs = wfs.Gradient(self.config, mask=self.mask)
def test_set_valid_actuators():
"""
Tests that when you set the "valid actuators", the DM computes how many valid actuators there are correctly
"""
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize/2., config.sim.simSize)
wfs = WFS.ShackHartmann(config, mask=mask)
dm = DM.DM(config, n_dm=1, wfss=[wfs], mask=mask)
valid_actuators = numpy.ones(dm.n_acts, dtype=int)
valid_actuators[0] = valid_actuators[-1] = 0
dm.valid_actuators = valid_actuators
assert dm.n_valid_actuators == (dm.n_acts - 2)
import numpy as np
import matplotlib.pyplot as pl
from soapy import confParse, SCI, atmosphere
# load a sim config that defines lots of science cameras across the field
config = confParse.loadSoapyConfig('sh_8x8.py')
# Init a science camera
sci_camera = SCI.PSF(config, mask=np.ones((154,154)))
# init some atmosphere
atmos = atmosphere.atmos(config)
# Now loop over lots of difference turbulence
for i in range(100):
print(i)
# Get phase for this time step
phase_scrns = atmos.moveScrns()
# Calculate all the PSF for this turbulence
psf = sci_camera.frame(phase_scrns)
# You can also get the phase if you’d like from each science detector with
# phase = sci_camera.los.phase
pl.imshow(psf)
pl.show()
def test_loadSh8x8_yaml(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
def test_initLOS(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
los = lineofsight.LineOfSight(config.wfss[0], config)
def testa_loadSh8x8_lgsUplink_yaml(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8_lgs-uplink.yaml"))
def test_loadSh8x8_py(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "py_config/sh_8x8.py"))
def testa_loadSh8x8_lgsElong_py(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "py_config/sh_8x8_lgs-elongation.py"))
o_zernike.append(i)
# Generate randomly Zernike coefficient. By dividing the value
# by its radial order we produce a distribution following
# the expected 1/f^-2 law.
c_zernike = 2 * np.random.random((n_psfs, n_zernike)) - 1
for j in range(n_psfs):
for i in range(n_zernike):
c_zernike[j, i] = c_zernike[j, i] / o_zernike[i]
c_zernike = np.array([
c_zernike[k, :] / np.abs(c_zernike[k, :]).sum() * wavelength * (10**9)
for k in range(n_psfs)
])
# Update scientific camera parameters
config = confParse.loadSoapyConfig(SOAPY_CONF)
config.scis[0].pxlScale = pixelScale
config.tel.telDiam = diameter
config.calcParams()
mask = aotools.circle(config.sim.pupilSize / 2.,
config.sim.simSize).astype(np.float64)
zernike_basis = aotools.zernikeArray(n_zernike + 1,
config.sim.pupilSize,
norm='rms')
psfObj = SCI.PSF(config, nSci=0, mask=mask)
psfs_in = np.zeros(
(n_psfs, psfObj.detector.shape[0], psfObj.detector.shape[1]))
psfs_out = np.zeros(
def testa_loadSh8x8_lgsElong_yaml(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8_lgs-elongation.yaml"))
def testa_loadSh8x8_lgsUplink_py(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "py_config/sh_8x8_lgs-uplink.py"))
def loadConfig(self):
self.config = confParse.loadSoapyConfig(self.configfile)
def testa_loadSh8x8_lgsUplink_yaml(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8_lgs-uplink.yaml"))
def test_loadSh8x8_py(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "py_config/sh_8x8.py"))
def test_randomAtmos(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH,"sh_8x8.yaml"))
atmos = atmosphere.atmos(config)
atmos.randomScrns()
def test_loadSh8x8_yaml(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
def test_initLOS(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
los = lineofsight.LineOfSight(config.wfss[0], config)
def testa_loadSh8x8_lgsElong_py(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "py_config/sh_8x8_lgs-elongation.py"))
def testa_loadSh8x8_lgsElong_yaml(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "sh_8x8_lgs-elongation.yaml"))
def testa_loadSh8x8_lgsUplink_py(self):
config = confParse.loadSoapyConfig(
os.path.join(CONFIG_PATH, "py_config/sh_8x8_lgs-uplink.py"))
def generate_training(n_patches, n_patches_validation, n_stars, n_frames):
# Size of final images
nx = 256
ny = 256
n_zernike = 40
# GREGOR
telescope_radius = 1.44 * 1.440 * u.meter
secondary_radius = 0.404 * 0.404 * u.meter
pixSize = (6.0/512.0) * u.arcsec / u.pixel
lambda0 = 850.0 * u.nm
fov = 3.0 * u.arcsec
border = 100
f_images = h5py.File('database.h5', 'w')
f_images_validation = h5py.File('database_validation.h5', 'w')
database_images = f_images.create_dataset('intensity', (n_patches, n_frames+1, nx, ny, 1), 'f')
database_images_validation = f_images_validation.create_dataset('intensity', (n_patches_validation, n_frames+1, nx, ny, 1), 'f')
loop = 0
loop_val = 0
# load a sim config that defines lots of science cameras across the field
config = confParse.loadSoapyConfig('sh_8x8.py')
# Init a science camera
sci_camera = SCI.PSF(config, mask=np.ones((154,154)))
# init some atmosphere
atmos = atmosphere.atmos(config)
##############
# Training set
##############
for i in range(n_patches):
progressbar(i, n_patches, text='Progress (traininig set)')
star_field = np.zeros((nx, ny))
indx = np.random.randint(border, nx-border)
indy = np.random.randint(border, ny-border)
star_field[indx, indy] = 1.0
# Save original image in file
database_images[i,0,:,:,0] = star_field
star_field_fft = pyfftw.interfaces.numpy_fft.fft2(star_field)
for j in range(n_frames):
# Get phase for this time step
phase_scrns = atmos.moveScrns()
# Calculate all the PSF for this turbulence
psf = sci_camera.frame(phase_scrns)
nx_psf, ny_psf = psf.shape
psf_roll = np.roll(psf.data, int(nx_psf/2), axis=0)
psf_roll = np.roll(psf_roll, int(ny_psf/2), axis=1)
psf_fft = pyfftw.interfaces.numpy_fft.fft2(psf_roll)
image_final = np.real(pyfftw.interfaces.numpy_fft.ifft2(psf_fft * star_field_fft))
database_images[i,j+1,:,:,0] = image_final
for j in range(50):
phase_scrns = atmos.moveScrns()
##############
# Validation set
##############
for i in range(n_patches_validation):
progressbar(i, n_patches_validation, text='Progress (validation set)')
star_field = np.zeros((nx, ny))
indx = np.random.randint(border, nx-border)
indy = np.random.randint(border, ny-border)
star_field[indx, indy] = 1.0
# Save original image in file
database_images_validation[i,0,:,:,0] = star_field
star_field_fft = pyfftw.interfaces.numpy_fft.fft2(star_field)
for j in range(n_frames):
# Get phase for this time step
phase_scrns = atmos.moveScrns()
# Calculate all the PSF for this turbulence
psf = sci_camera.frame(phase_scrns)
nx_psf, ny_psf = psf.shape
psf_roll = np.roll(psf.data, int(nx_psf/2), axis=0)
psf_roll = np.roll(psf_roll, int(ny_psf/2), axis=1)
psf_fft = pyfftw.interfaces.numpy_fft.fft2(psf_roll)
image_final = np.real(pyfftw.interfaces.numpy_fft.ifft2(psf_fft * star_field_fft))
database_images_validation[i,j+1,:,:,0] = image_final
for j in range(50):
phase_scrns = atmos.moveScrns()
f_images.close()
f_images_validation.close()
def testc_initLegacySHWfs(self):
config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml"))
mask = aotools.circle(config.sim.pupilSize / 2., config.sim.simSize)
wfs = WFS.ShackHartmannLegacy(config, mask=mask)
