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 test_randomAtmos(self): config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH,"sh_8x8.yaml")) atmos = atmosphere.atmos(config) atmos.randomScrns()
def test_initLOS(self): config = confParse.loadSoapyConfig(os.path.join(CONFIG_PATH, "sh_8x8.yaml")) los = lineofsight.LineOfSight(config.wfss[0], config)
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)