def test_mech_SOFT2():
soft = ctrl.DegreeOfFreedom(SOFT, 'pitch')
tf1 = katTF.getMechTF(SOFT, soft, doftype='pitch')
tf2 = katTF.getMechTF(soft, SOFT, doftype='pitch')
ref = data['mech_SOFT']
c1 = close.allclose(tf1, ref)
c2 = close.allclose(tf2, ref)
assert np.all([c1, c2])
def test_freqI(self):
laser = DegreeOfFreedom('Laser', 'freq')
laser2 = DegreeOfFreedom('Laser', probes='REFL_I', doftype='freq')
tf1 = self.katFR.getTF('REFL_I', 'Laser', doftype='freq')
tf2 = self.katFR.getTF('REFL_I', laser)
tf3 = self.katFR.getTF(laser2)
c1 = close.allclose(tf1, data['tfI_freq'])
c2 = close.allclose(tf2, data['tfI_freq'])
c3 = close.allclose(tf3, data['tfI_freq'])
assert np.all([c1, c2])
def test_ampI(self):
am = DegreeOfFreedom('AM', 'drive')
am2 = DegreeOfFreedom('AM', probes='REFL_I', doftype='drive')
tf1 = self.opt.getTF('REFL_I', 'AM', doftype='drive')
tf2 = self.opt.getTF('REFL_I', am)
tf3 = self.opt.getTF(am2)
c1 = close.allclose(tf1, data['tfI_amp'])
c2 = close.allclose(tf2, data['tfI_amp'])
c3 = close.allclose(tf3, data['tfI_amp'])
assert np.all([c1, c2, c3])
def test_phaseI(self):
pm = DegreeOfFreedom('PM', 'drive')
pm2 = DegreeOfFreedom('PM', probes='REFL_I', doftype='drive')
tf1 = self.opt.getTF('REFL_I', 'PM', doftype='drive')
tf2 = self.opt.getTF('REFL_I', pm)
tf3 = self.opt.getTF(pm2)
c1 = close.allclose(tf1, data['tfI_phase'])
c2 = close.allclose(tf2, data['tfI_phase'])
c3 = close.allclose(tf3, data['tfI_phase'])
assert np.all([c1, c2, c3])
def test_tfQ(self):
ex = DegreeOfFreedom(name='EX', drives='EX', doftype='pos')
ex2 = DegreeOfFreedom(name='EX', drives='EX', doftype='pos',
probes='REFL_Q')
tfQ1 = self.opt.getTF('REFL_Q', 'EX')
tfQ2 = self.opt.getTF('REFL_Q', ex)
tfQ3 = self.opt.getTF(ex2)
c1 = close.allclose(tfQ1, data['tfQ'])
c2 = close.allclose(tfQ2, data['tfQ'])
c3 = close.allclose(tfQ3, data['tfQ'])
assert np.all([c1, c2])
def test_REFLI_HARD():
hard = ctrl.DegreeOfFreedom(HARD, 'pitch')
hard2 = ctrl.DegreeOfFreedom(HARD, 'pitch', probes='REFL_I')
tf1 = katTF.getTF('REFL_I', HARD, doftype='pitch')
tf2 = katTF.getTF('REFL_I', hard)
tf3 = katTF.getTF(hard2)
ref = data['tf_REFLI_HARD']
c1 = close.allclose(tf1, ref)
c2 = close.allclose(tf2, ref)
c3 = close.allclose(tf3, ref)
assert np.all([c1, c2, c3])
def test_po(self):
qnoise = self.kat_po.getQuantumNoise('AS_DIFF')
tf = self.kat_po.getTF('AS_DIFF', DARM)
rslt1 = close.allclose(qnoise,
self.chk_data['po']['qnoise_DIFF'],
rtol=1e-2,
atol=1e-2)
rslt2 = close.allclose(tf,
self.chk_data['po']['tf_DIFF'],
rtol=1e-2,
atol=1e-2)
assert all([rslt1, rslt2])
def test_mMech_EX_EX2():
ex = ctrl.DegreeOfFreedom('EX', doftype='pitch')
mMech1 = katTF.getMechMod('EX', ex, doftype='pitch')
mMech2 = katTF.getMechMod(ex, 'EX', doftype='pitch')
mMech3 = katTF.getMechMod(ex, ex, doftype='pitch')
mMech4 = katTF.getMechMod(ex, ex)
ref = data['mMech_EX_EX']
c1 = close.allclose(mMech1, ref)
c2 = close.allclose(mMech2, ref)
c3 = close.allclose(mMech3, ref)
c4 = close.allclose(mMech4, ref)
assert np.all([c1, c2, c3, c4])
def test_tfI(self):
ex = DegreeOfFreedom('EX')
ex2 = DegreeOfFreedom('EX', probes='REFL_I')
ex3 = DegreeOfFreedom('EX', probes='REFL_DC')
tfI1 = self.katFR.getTF('REFL_I', 'EX')
tfI2 = self.katFR.getTF('REFL_I', ex)
tfI3 = self.katFR.getTF(ex2)
tfI4 = self.katFR.getTF('REFL_I', ex3)
c1 = close.allclose(tfI1, data['tfI'])
c2 = close.allclose(tfI2, data['tfI'])
c3 = close.allclose(tfI3, data['tfI'])
c4 = close.allclose(tfI4, data['tfI'])
assert np.all([c1, c2, c3, c4])
def test_drive_open():
rslt = []
for dof_to in dofs:
for drive in cs.drives:
tf = cs.getTF(dof_to, 'err', drive, 'drive', closed=False)
rslt.append(
close.allclose(tf, data['drive_open'][()][dof_to][drive]))
assert all(rslt)
def test_sense_closed():
rslt = []
for dof_to in dofs:
for probe in cs.probes:
tf = cs.getTF(dof_to, 'err', probe, 'sens', closed=True)
rslt.append(
close.allclose(tf, data['sense_closed'][()][dof_to][probe]))
assert all(rslt)
def test_cltfs():
rslt = []
for dof_to in dofs:
for dof_from in dofs:
rslt.append(
close.allclose(cs.getCLTF(dof_to, dof_from, 'err'),
data['cltfs'][()][dof_to][dof_from]))
assert all(rslt)
def test_cal_open():
rslt = []
for dof_to in dofs:
for dof_from in dofs:
tf = cs.getTF(dof_to, 'err', dof_from, 'cal', closed=False)
rslt.append(
close.allclose(tf, data['calTFs_open'][()][dof_to][dof_from]))
assert all(rslt)
def test_2(self):
k2 = self.k2
p2 = self.p2
filt2b = ctrl.Filter(
lambda ss: k2/((ss + 2*np.pi*p2[0])*(ss + 2*np.pi*p2[1])))
data1 = self.filt2a.computeFilter(self.ff)
# data2 = self.filt2b.computeFilter(self.ff)
data2 = filt2b.computeFilter(self.ff)
assert close.allclose(data1, data2)
def assert_power(optic, ePos, powers_ref):
# opt = computeSweep({optic: 180 * 1064e-9/360})
opt = computeSweep(ePos)
_, powers = getSweepPowers(opt, optic)
rslt = [
close.allclose(powers[key]['f0'], powers_ref[key]['f0'])
for key in powers.keys()
]
return rslt
def test_cat3(self):
k2 = self.k2
p2 = self.p2
filt2b = ctrl.Filter(
lambda ss: k2/((ss + 2*np.pi*p2[0])*(ss + 2*np.pi*p2[1])))
filt3d = ctrl.catfilt(self.filt1a, filt2b)
data1 = self.filt3a.computeFilter(self.ff)
# data2 = self.filt3d.computeFilter(self.ff)
data2 = filt3d.computeFilter(self.ff)
assert close.allclose(data1, data2)
def test_sensing_noise():
shotNoise = {probe: opt.getQuantumNoise(probe) for probe in cs.probes}
sensingNoise = {}
calDARM = cs.getTF('DARM', 'err', 'DARM', 'cal', closed=False)
cltfDARM = cs.getCLTF('DARM', 'DARM', 'err')
for probe, sn in shotNoise.items():
tf = cs.getTF('DARM', 'err', probe, 'sens') / cltfDARM
sensingNoise[probe] = np.abs(tf * sn / calDARM)
rslt = [
close.allclose(noise, data['sensingNoise'][()][probe])
for probe, noise in sensingNoise.items()
]
assert all(rslt)
def test_residuals2():
res1 = cs.getTotalNoiseTo('EX.pos', 'pos', 'drive', seismic_noise)
res2 = cs.getTotalNoiseTo(EX_dof, 'pos', 'drive', seismic_noise)
assert close.allclose(res1, res2)
def test_tfQ_IM(self):
tfQ_IM = self.opt.getTF('AS_Q', {'IX': 0.5, 'IY': -0.5})
assert close.allclose(tfQ_IM, data['tfQ_IM'])
def test_tfI_EM(self):
tfI_EM = self.opt.getTF('AS_I', {'EX': 0.5, 'EY': -0.5})
assert close.allclose(tfI_EM, data['tfI_EM'])
def test_load_mech_SOFT():
tf = katTF2.getMechTF(SOFT, SOFT, doftype='pitch')
ref = data['mech_SOFT']
assert close.allclose(tf, ref)
def test_powfl(self):
assert close.allclose(self.powfl, data['powfl'])
def test_powfu(self):
assert close.allclose(self.powfu, data['powfu'])
def test_powf0(self):
assert close.allclose(self.powf0, data['powf0'])
def test_load_mMech_IX_EX():
mMech = katTF2.getMechMod('IX', 'EX', doftype='pitch')
ref = data['mMech_IX_EX']
assert close.allclose(mMech, ref)
def get_results(tst_data, chk_data):
return [
close.allclose(chk_data[key], val) for key, val in tst_data.items()
]
def test_load_bsm_EX_EX():
bsm = katTF2.computeBeamSpotMotion('EX_fr', 'EX', 'pitch')
ref = data['bsm_EX_EX']
assert close.allclose(bsm, ref)
def test_ss3(self):
ss = self.filt3a.get_state_space()
data1 = self.filt3a.computeFilter(self.ff)
_, data2 = sig.freqresp(ss, 2*np.pi*self.ff)
assert close.allclose(data1, data2)
def test_mech_HARD():
tf = katTF.getMechTF(HARD, HARD, doftype='pitch')
ref = data['mech_HARD']
assert close.allclose(tf, ref)
def test_REFLI_SOFT():
tf = katTF.getTF('REFL_I', SOFT, doftype='pitch')
ref = data['tf_REFLI_SOFT']
assert close.allclose(tf, ref)
