def main(): print(""" -------------------------------------------------------------- Example file for using PyKat to automate Finesse simulations Finesse: http://www.gwoptics.org/finesse PyKat: http://www.gwoptics.org/pykat The file runs through the various Finesse simulations to generate the Finesse results reported in the document: `Comparing Finesse simulations, analytical solutions and OSCAR simulations of Fabry-Perot alignment signals', LIGO-T1300345, freely available online: http://arxiv.org/abs/1401.5727 Run this file after master2.py to create data which can be plotted using master3_plot.py. Results are saved after each step and plots can be created at any time. Andreas Freise 16.01.2014 -------------------------------------------------------------- """) # shall we clear the workspace? # %reset -f # making these global during testing and debugging #global kat, out kat = finesse.kat(tempdir=".", tempname="test") kat.verbose = False tmpresultfile = 'myshelf2.dat' # loading data saved by master.py kat.loadKatFile('asc_base3.kat') try: with open(tmpresultfile, 'rb') as handle: result = pickle.load(handle) except: raise Exception( "Could not open temprary results file {0}".format(tmpresultfile)) kat.PDrefl_q.enabled = False kat.WFS1_Q.enabled = False kat.WFS2_Q.enabled = False print("--------------------------------------------------------") print(" 9. ASC signals for large misalignments (ITM)") asc_large(kat, 'ITM') print("--------------------------------------------------------") print(" 10. ASC signals for large misalignments (ETM)") asc_large(kat, 'ETM')
def test_string(_str): kat = finesse.kat() # create a fresh cat object _str = _str.strip() kat.parse(_str) # remove extra kat info produced by pykat katfile = ''.join(kat.generateKatScript()[1:-1]).strip() try: assert katfile == _str except AssertionError as e: print('Input string {} does not match output string {}'.format( _str, katfile)) raise e
def simulation_and_save(filename): kat = finesse.kat() # create a fresh cat object kat.verbose = verbose kat.parse(""" l laser 1 0 n0 s s_in 0.1 n0 n1 m m_in 0.99 0.01 0 n1 n2 s s_1 1 n2 n3 m m_c 0.5 0.5 0 n3 n4 s s_2 1 n4 n5 m m_out 0.99 0.01 0 n5 n6 pd trans n6 xaxis m_in phi lin 0 180 360 x2axis m_out phi lin 0 180 360 """) out = kat.run() out.saveKatRun(filename + '.katrun')
def main(): print(""" -------------------------------------------------------------- Template file for using PyKat to automate Finesse simulations Finesse: http://www.gwoptics.org/finesse PyKat: http://www.gwoptics.org/pykat Andreas Freise 19.05.2015 -------------------------------------------------------------- """) # for debugging we might need to see the temporay file: global kat kat = finesse.kat(tempdir=".", tempname="test") kat.verbose = False code1 = """ l l1 1 0 0 n1 s s1 1 n1 n2 pd power n2 xaxis l1 P lin 1 2 4 """ kat.parseKatCode(code1) out = kat.run() print("result = {}".format(out.y))
s cav1 $test n2 n3 m m2 0.99 0.01 -0.1 n3 n4 attr m2 m 1 # mech sus1 const test 1200 ad up_refl 0 n1 ad low_refl 0 n1 qd refl_A 0 0 n1 qd refl_Q 0 90 n1 qd tran_A 0 0 n4 qd tran_Q 0 90 n4 put up_refl f $x1 put low_refl f $mx1 yaxis log re:im fsig noise 1 """ kat = finesse.kat(kat_code=code) kat.signals.apply(kat.l1.P, 1, 0) kat.signals.apply(kat.m1.phi, 1, 90) kat.add(xaxis('log', [1, 1000], kat.signals.f, 100)) out = kat.run(printout=0, printerr=0)
def make_kat(katfile=None, verbose=False, debug=False, keepComments=False, preserveConstants=False): """ Returns a kat object and fills in the kat.IFO property for storing the associated interferometer data. keepComments: If true it will keep the original comments from the file preserveComments: If true it will keep the const commands in the kat """ names = ['design'] if debug: kat = finesse.kat(tempdir=".", tempname="test") else: kat = finesse.kat() kat.verbose = verbose # Create empty object to just store whatever DOFs, port, variables in # that will be used by processing functions kat.IFO = APLUS_IFO( kat, # Define which keys are used for a tuning description ["maxtem", "phase"], # Define which mirrors create the tuning description ["PRM", "ITMX", "ETMX", "ITMY", "ETMY", "BS", "SRM"]) kat.IFO._data_path = pkg_resources.resource_filename( 'pykat.ifo', os.path.join('aplus', 'files')) kat.IFO.rawBlocks = BlockedKatFile() if katfile: kat.load(katfile, keepComments=keepComments, preserveConstants=preserveConstants) kat.IFO.rawBlocks.read(katfile) else: katkile = os.path.join(kat.IFO._data_path, "design.kat") kat.load(katkile, keepComments=keepComments, preserveConstants=preserveConstants) kat.IFO.rawBlocks.read(katkile) # ---------------------------------------------------------------------- # get and derive parameters from the kat file # get main frequencies if "f1" in kat.constants.keys(): kat.IFO.f1 = float(kat.constants["f1"].value) else: kat.IFO.f1 = 9099471.0 if "f2" in kat.constants.keys(): kat.IFO.f2 = float(kat.constants["f2"].value) else: kat.IFO.f2 = 5.0 * kat.IFO.f1 # TODO add else here! # check modultion frequencies if (5 * kat.IFO.f1 != kat.IFO.f2): print(" ** Warning: modulation frequencies do not match: 5*f1!=f2") # defining a dicotionary for the main mirror positions (tunings), # keys should include maxtem, phase and all main optics names #kat.IFO.tunings = get_tunings(dict.fromkeys(["maxtem", "phase", "PRM", "ITMX", "ETMX", "ITMY", "ETMY", "BS", "SRM"])) kat.IFO.compute_derived_lengths() # ---------------------------------------------------------------------- # define ports and signals # useful ports kat.IFO.POP_f1 = Output(kat.IFO, "POP_f1", "nPOP", "f1", phase=101) kat.IFO.POP_f2 = Output(kat.IFO, "POP_f2", "nPOP", "f2", phase=13) kat.IFO.REFL_f1 = Output(kat.IFO, "REFL_f1", "nREFL", "f1", phase=101) kat.IFO.REFL_f2 = Output(kat.IFO, "REFL_f2", "nREFL", "f2", phase=14) kat.IFO.AS_DC = Output(kat.IFO, "AS_DC", "nAS") kat.IFO.AS_f1 = Output(kat.IFO, "AS_f1", "nAS", "f1", phase=101) kat.IFO.AS_f2 = Output(kat.IFO, "AS_f2", "nAS", "f2", phase=14) kat.IFO.AS_f36 = Output(kat.IFO, "AS_f36", "nAS", "f36M", phase=14) kat.IFO.BHD = Output(kat.IFO, "BHD", ["nBHD1", "nBHD2"]) kat.IFO.POW_BS = Output(kat.IFO, "PowBS", "nPRBS*") kat.IFO.POW_X = Output(kat.IFO, "PowX", "nITMX2") kat.IFO.POW_Y = Output(kat.IFO, "PowY", "nITMY2") kat.IFO.TRX = Output(kat.IFO, "TRX", "nETMX2") kat.IFO.TRY = Output(kat.IFO, "TRY", "nETMY2") # pretune LSC DOF kat.IFO.preARMX = DOF(kat.IFO, "ARMX", kat.IFO.POW_X, "", "ETMX", 1, 1.0, sigtype="z") kat.IFO.preARMY = DOF(kat.IFO, "ARMY", kat.IFO.POW_Y, "", "ETMY", 1, 1.0, sigtype="z") kat.IFO.preMICH = DOF(kat.IFO, "AS", kat.IFO.AS_DC, "", ["ITMX", "ETMX", "ITMY", "ETMY"], [1, 1, -1, -1], 6.0, sigtype="z") kat.IFO.prePRCL = DOF(kat.IFO, "PRCL", kat.IFO.POW_BS, "", "PRM", 1, 10.0, sigtype="z") kat.IFO.preSRCL = DOF(kat.IFO, "SRCL", kat.IFO.AS_DC, "", "SRM", 1, 10.0, sigtype="z") # Used by new pretuning scripts DOFs - based on lock aquisition stuff in martynov thesis kat.IFO._preMICH = DOF(kat.IFO, "preMICH", kat.IFO.AS_f2, "Q", ["ITMX", "ETMX", "ITMY", "ETMY"], [1, 1, -1, -1], 1.0, sigtype="z") kat.IFO._preSRCL = DOF(kat.IFO, "preSRCL", kat.IFO.AS_f2, "I", "SRM", 1, 1.0, sigtype="z") kat.IFO._prePRCL = DOF(kat.IFO, "prePRCL", kat.IFO.REFL_f1, "I", "PRM", 1, 1.0, sigtype="z") kat.IFO._preALSX = DOF(kat.IFO, "ALSX", kat.IFO.POW_X, "", "ETMX", 1, 1.0, sigtype="z") kat.IFO._preALSY = DOF(kat.IFO, "ALSY", kat.IFO.POW_Y, "", "ETMY", 1, 1.0, sigtype="z") # control scheme as in [1] Table C.1. Due to Finesse # conventions, the overall factor for all but PRCL are multiplied by -1 # compared to the LIGO defintion, to match the same defintion. kat.IFO.PRCL = DOF(kat.IFO, "PRCL", kat.IFO.POP_f1, "I", "PRM", 1, 100.0, sigtype="z") kat.IFO.MICH = DOF(kat.IFO, "MICH", kat.IFO.POP_f2, "Q", ["ITMX", "ETMX", "ITMY", "ETMY"], [-0.5, -0.5, 0.5, 0.5], 100.0, sigtype="z") kat.IFO.CARM = DOF(kat.IFO, "CARM", kat.IFO.REFL_f1, "I", ["ETMX", "ETMY"], [-1, -1], 1.5, sigtype="z") kat.IFO.DARM = DOF(kat.IFO, "DARM", kat.IFO.AS_f2, "Q", ["ETMX", "ETMY"], [-1, 1], 1.0, sigtype="z") kat.IFO.SRCL = DOF(kat.IFO, "SRCL", kat.IFO.REFL_f2, "I", "SRM", -1, 1e2, sigtype="z") kat.IFO.DARM_h = DOF(kat.IFO, "DARM_h", kat.IFO.BHD, "", ["LY", "LX"], [-1, 1], 1.0, sigtype="phase") kat.IFO.LSC_DOFs = (kat.IFO.PRCL, kat.IFO.MICH, kat.IFO.CARM, kat.IFO.DARM, kat.IFO.SRCL) kat.IFO.CAV_POWs = (kat.IFO.POW_X, kat.IFO.POW_Y, kat.IFO.POW_BS) # Ignore angular stuff for now # # Pitch DOfs # # There is a difference in the way LIGO and Finesse define positive and negative # # rotations of the cavity mirrors. For LIGO the rotational DOFs assume ITM + rotation # # is clockwise and ETM + rotation is anticlockwise. # # I'll be explict here for future reference. # cav_mirrors = ["ETMX", "ETMXAR", "ETMY", "ETMYAR", "ITMX", "ITMXAR", "ITMY", "ITMYAR"] # # # LIGO definitions # # Based on figure 7 in T0900511-v4 # CHARD_factors = np.array([ 1, 1, 1, 1,-1,-1,-1,-1]) # DHARD_factors = np.array([ 1, 1,-1,-1,-1,-1, 1, 1]) # CSOFT_factors = np.array([-1,-1,-1,-1,-1,-1,-1,-1]) # # DSOFT_factors = np.array([-1,-1, 1, 1, 1, 1,-1,-1]) # Wrong! # DSOFT_factors = np.array([-1,-1, 1, 1,-1,-1, 1, 1]) # # # Finesse definitions # # negative for ITM rotations # ITMS = np.in1d(cav_mirrors, np.array(["ITMX", "ITMXAR", "ITMY", "ITMYAR"])) # CHARD_factors[ITMS] *= -1 # DHARD_factors[ITMS] *= -1 # CSOFT_factors[ITMS] *= -1 # DSOFT_factors[ITMS] *= -1 # # kat.IFO.CHARD_P = DOF(kat.IFO, "CHARD_P", None , None, cav_mirrors, CHARD_factors, 1, sigtype="pitch") # kat.IFO.DHARD_P = DOF(kat.IFO, "DHARD_P", None , None, cav_mirrors, DHARD_factors, 1, sigtype="pitch") # kat.IFO.CSOFT_P = DOF(kat.IFO, "CSOFT_P", None , None, cav_mirrors, CSOFT_factors, 1, sigtype="pitch") # kat.IFO.DSOFT_P = DOF(kat.IFO, "DSOFT_P", None , None, cav_mirrors, DSOFT_factors, 1, sigtype="pitch") # kat.IFO.PRM_P = DOF(kat.IFO, "PRM_P" , None , None, ["PRM", "PRMAR"], [1,1], 1, sigtype="pitch") # kat.IFO.PRC2_P = DOF(kat.IFO, "PRC2_P" , None , None, ["PR2"], [1], 1, sigtype="pitch") # kat.IFO.PRC3_P = DOF(kat.IFO, "PRC3_P" , None , None, ["PR3"], [1], 1, sigtype="pitch") # kat.IFO.SRM_P = DOF(kat.IFO, "SRM_P" , None , None, ["SRM", "SRMAR"], [1,1], 1, sigtype="pitch") # kat.IFO.SRC2_P = DOF(kat.IFO, "SRC2_P" , None , None, ["SR2"], [1], 1, sigtype="pitch") # kat.IFO.SRC3_P = DOF(kat.IFO, "SRC3_P" , None , None, ["SR3"], [1], 1, sigtype="pitch") # kat.IFO.MICH_P = DOF(kat.IFO, "MICH_P" , None , None, ["BS", "BSAR1", "BSAR2"], [1,1,1], 1, sigtype="pitch") # # kat.IFO.ASC_P_DOFs = (kat.IFO.CHARD_P, kat.IFO.DHARD_P, # kat.IFO.CSOFT_P, kat.IFO.DSOFT_P, # kat.IFO.PRM_P, kat.IFO.PRC2_P, # kat.IFO.PRC3_P, kat.IFO.SRM_P, # kat.IFO.SRC2_P, kat.IFO.SRC3_P, # kat.IFO.MICH_P) kat.IFO.update() kat.IFO.lockNames = None kat.noxaxis = True return kat
def main(): print(""" -------------------------------------------------------------- Example file for using PyKat to automate Finesse simulations Finesse: http://www.gwoptics.org/finesse PyKat: http://www.gwoptics.org/pykat The file runs through the various Finesse simulations to generate the Finesse results reported in the document: `Comparing Finesse simulations, analytical solutions and OSCAR simulations of Fabry-Perot alignment signals', LIGO-T1300345, freely available online: http://arxiv.org/abs/1401.5727 This file is part of a collection; it outputs the results shown the document's sections 3 and 4 and saves temporary data and a new Finesse input file to be read by master2.py. Andreas Freise 16.01.2014 -------------------------------------------------------------- """) # for debugging we might need to see the temporay file: global kat kat = finesse.kat(tempdir=".", tempname="test") kat.verbose = False kat.loadKatFile('asc_base.kat') kat.maxtem = 3 Lambda = 1064.0e-9 result = {} # defining variables as global for debugging #global kat, out, result print("--------------------------------------------------------") print(" 1. tunes ETM position to find resonance") kat.ETM.phi = resonance(kat) print("--------------------------------------------------------") print(" 2. print sideband and carrier powers/amplitudes") powers(kat) print("--------------------------------------------------------") print(" 3. determine the optimal phase for the PDH signal") (result['p_phase'], result['q_phase']) = pd_phase(kat) # setting demodulation phase code_det = """ pd1 PDrefl_p 9M 0 nWFS1 scale 2 PDrefl_p pd1 PDrefl_q 9M 90 nWFS1 scale 2 PDrefl_q """ kat.parseKatCode(code_det) kat.PDrefl_p.phase1 = result['p_phase'] kat.PDrefl_q.phase1 = result['q_phase'] print("--------------------------------------------------------") print(" 4. adding a 0.1nm offset to ETM and compute PDH signal") result['phi_tuned'] = float(kat.ETM.phi) result['phi_detuned'] = result['phi_tuned'] + 0.1 * 360.0 / 1064.0 kat.ETM.phi = result['phi_detuned'] print(" new ETM phi tuning = %g " % kat.ETM.phi) (result['pd_p'], result['pd_q']) = pd_signal(kat) print(" PDH inphase = %e " % result['pd_p']) print(" PDH quadrtature = %e " % result['pd_q']) print("--------------------------------------------------------") print(" Saving results in temp. files to be read by master2.py") tmpkatfile = "asc_base2.kat" tmpresultfile = "myshelf1.dat" print(" kat object saved in: {0}".format(tmpkatfile)) print(" current results saved in: {0}".format(tmpresultfile)) # first the current kat file kat.saveScript(tmpkatfile) with open(tmpresultfile, 'wb') as handle: pickle.dump(result, handle)
def model_DRFPMI(): # # usage: base = utils_DRFPMI.model_DRFPMI() # output is the finesse structure with the DRFPMI configuration # # base = finesse.kat() base.verbose=False base.parse(""" # ======== Constants ======================== const f1 16.881M const f2 45.0159M const mf1 -16.881M const mf2 -45.0159M const a 0.686 const pi 3.1415 # ======== Input optics ===================== l i1 1 0 n0 s s_eo0 0 n0 n_eo1 mod eom1 $f1 0.3 1 pm n_eo1 n_eo2 s s_eo1 0 n_eo2 n_eo3 mod eom2 $f2 0.3 1 pm n_eo3 n_eo4 s s_eo2 0 n_eo4 nREFL ## ======= PRC each mirror loss 45ppm ======= # PRC m1 PRM 0.1 45e-6 0 nREFL npr1 s sLpr1 14.7615 npr1 npr2 bs1 PR2 500e-6 45e-6 0 $a npr3 npr2 nPOP nPOP2 s sLpr2 11.0661 npr3 npr4 bs1 PR3 50e-6 45e-6 0 $a dump dump npr4 npr5 s sLpr3 15.7638 npr5 npr6 # Michelson bs bs1 0.5 0.5 0 45 npr6 n2 n3 n4 s lx 26.6649 n3 nx1 s ly 23.3351 n2 ny1 # X arm m ITMX 0.996 0.004 0 nx1 nx2 s sx1 3000 nx2 nx3 m ETMX 0.999995 5e-06 0 nx3 nTMSX # Y arm m ITMY 0.996 0.004 90 ny1 ny2 s sy1 3000 ny2 ny3 m ETMY 0.999995 5e-06 90 ny3 nTMSY # ========= SRC each mirror loss 45ppm ======= s sLsr3 15.7386 n4 nsr5 bs1 SR3 50e-6 45e-6 0 $a nsr5 nsr4 dump dump s sLsr2 11.1115 nsr4 nsr3 bs1 SR2 500e-6 45e-6 0 $a nsr2 nsr3 nPOS dump s sLsr1 14.7412 nsr2 nsr1 m1 SRM 0.3 0e-6 0 nsr1 nAS ## ===== amplitude detectors ===== ad CR_REFL 0 nREFL ad SB1p_REFL $f1 nREFL ad SB1m_REFL $mf1 nREFL ad SB2p_REFL $f2 nREFL ad SB2m_REFL $mf2 nREFL ad CR_POP 0 nPOP ad SB1p_POP $f1 nPOP ad SB1m_POP $mf1 nPOP ad SB2p_POP $f2 nPOP ad SB2m_POP $mf2 nPOP ad CR_TMSX 0 nTMSX ad SB1p_TMSX $f1 nTMSX ad SB1m_TMSX $mf1 nTMSX ad SB2p_TMSX $f2 nTMSX ad SB2m_TMSX $mf2 nTMSX ad CR_TMSY 0 nTMSY ad SB1p_TMSY $f1 nTMSY ad SB1m_TMSY $mf1 nTMSY ad SB2p_TMSY $f2 nTMSY ad SB2m_TMSY $mf2 nTMSY ad CR_POS 0 nPOS ad SB1p_POS $f1 nPOS ad SB1m_POS $mf1 nPOS ad SB2p_POS $f2 nPOS ad SB2m_POS $mf2 nPOS ad CR_AS 0 nAS ad SB1p_AS $f1 nAS ad SB1m_AS $mf1 nAS ad SB2p_AS $f2 nAS ad SB2m_AS $mf2 nAS """) return base
def model_HOM_DRFPMI(): # # usage: base = utils_DRFPMI.model_DRFPMI() # output is the finesse structure with the DRFPMI configuration # # base = finesse.kat() base.verbose=False base.parse(""" # ======== Constants ======================== const f1 16.881M const f2 45.0159M const mf1 -16.881M const mf2 -45.0159M const a 0.686 const phi_PRM 90 const pi 3.1415 const phi_SRM 90 # ======== Input optics ===================== l i1 1 0 n0 s s_eo0 0 n0 n_eo1 mod eom1 $f1 0.3 1 pm n_eo1 n_eo2 s s_eo1 0 n_eo2 n_eo3 mod eom2 $f2 0.3 1 pm n_eo3 n_eo4 s s_eo2 0 n_eo4 nREFL # ======= PRC each mirror loss 45ppm ======= # PRC m1 PRM 0.1 45e-6 $phi_PRM nREFL npr1 s sLpr1 14.7615 npr1 npr2 bs1 PR2 500e-6 45e-6 0 $a npr3 npr2 nPOP nPOP2 s sLpr2 11.0661 npr3 npr4 bs1 PR3 50e-6 45e-6 0 $a dump dump npr4 npr5 s sLpr3 15.7638 npr5 npr6 # ======= Michelson ======================== bs bs1 0.5 0.5 0 45 npr6 n2 n3 n4 s lx 26.4018 n3 nx1 #26.6649-thickness*1.754 s ly 23.072 n2 ny1 #23.3351-thickness*1.754 # ======== Thick ITMs ====================== m IXAR 0 1 0 nx1 nx2 s thick_IX 0.15 1.754 nx2 nx3 m ITMX 0.996 0.004 0 nx3 nx4 m IYAR 0 1 0 ny1 ny2 s thick_IY 0.15 1.754 ny2 ny3 m ITMY 0.996 0.004 90 ny3 ny4 # ========== Arm ======================= s sx1 3000 nx4 nx5 m ETMX 0.999995 5e-06 0 nx5 nTMSX s sy1 3000 ny4 ny5 m ETMY 0.999995 5e-06 90 ny5 nTMSY # ========= SRC each mirror loss 45ppm ======= s sLsr3 15.7386 n4 nsr5 bs1 SR3 50e-6 45e-6 0 $a nsr5 nsr4 dump dump s sLsr2 11.1115 nsr4 nsr3 bs1 SR2 500e-6 45e-6 0 $a nsr2 nsr3 nPOS dump s sLsr1 14.7412 nsr2 nsr1 m1 SRM 0.3 0e-6 $phi_SRM nsr1 nAS # ========= HOM Expansion ======= attr PRM Rc -458.1285 attr PR2 Rc -3.0764 attr PR3 Rc -24.9165 attr bs1 Rc 0 attr ITMX Rc -1900. # measured -1904.6 attr ETMX Rc 1900. # measured 1908.24 attr ITMY Rc -1900 # measured -1904.4 attr ETMY Rc 1900. # measured 1905.55 attr SRM Rc 458.1285 attr SR2 Rc -2.9872 attr SR3 Rc 24.9165 attr IXAR Rc 0 attr IYAR Rc 0 cav XARM ITMX nx4 ETMX nx5 cav YARM ITMY ny4 ETMY ny5 cav PRX PRM npr1 ITMX nx3 cav PRY PRM npr1 ITMY ny3 cav SRX SRM nsr1 ITMX nx3 cav SRY SRM nsr1 ITMY ny3 # ===== amplitude detectors ===== ad CR_REFL 0 nREFL ad SB1p_REFL $f1 nREFL ad SB1m_REFL $mf1 nREFL ad SB2p_REFL $f2 nREFL ad SB2m_REFL $mf2 nREFL ad CR_POP 0 nPOP ad SB1p_POP $f1 nPOP ad SB1m_POP $mf1 nPOP ad SB2p_POP $f2 nPOP ad SB2m_POP $mf2 nPOP ad CR_TMSX 0 nTMSX ad SB1p_TMSX $f1 nTMSX ad SB1m_TMSX $mf1 nTMSX ad SB2p_TMSX $f2 nTMSX ad SB2m_TMSX $mf2 nTMSX ad CR_TMSY 0 nTMSY ad SB1p_TMSY $f1 nTMSY ad SB1m_TMSY $mf1 nTMSY ad SB2p_TMSY $f2 nTMSY ad SB2m_TMSY $mf2 nTMSY ad CR_POS 0 nPOS ad SB1p_POS $f1 nPOS ad SB1m_POS $mf1 nPOS ad SB2p_POS $f2 nPOS ad SB2m_POS $mf2 nPOS ad CR_AS 0 nAS ad SB1p_AS $f1 nAS ad SB1m_AS $mf1 nAS ad SB2p_AS $f2 nAS ad SB2m_AS $mf2 nAS """) return base
from pykat.commands import xaxis import pylab as pl import numpy as np import math code = """ l l1 1 0 0 n1 s s1 10 1 n1 n2 m m1 1 0 0 n2 n3 pd refl n2 xaxis m1 r_ap lin 0.1e-3 2e-3 10 """ kat = finesse.kat() kat.parseCommands(code) maxtem = np.arange(0, 4) kat.m1.n2.q = gauss_param(w0=1e-3, z=0) kat.verbose = False for tem in maxtem: print "Calculating maxtem ", tem, "..." kat.maxtem = tem r = kat.run() pl.plot(r.x/1e-3, r.y, label="maxtem={0}".format(tem))
def main(): print(""" -------------------------------------------------------------- Example file for using PyKat to automate Finesse simulations Finesse: http://www.gwoptics.org/finesse PyKat: https://pypi.python.org/pypi/PyKat/ The file runs through the various pykat files which are used to generate the Finesse results reported in the document: `Comparing Finesse simulations, analytical solutions and OSCAR simulations of Fabry-Perot alignment signals', LIGO-T1300345 This file is part of a collection. Run this after master2.py Andreas Freise 06.12.2013 -------------------------------------------------------------- """) # shall we clear the workspace? # %reset -f # making these global during testing and debugging global kat global out kat = finesse.kat(tempdir=".", tempname="test") kat.verbose = False tmpresultfile = 'myshelf2.dat' # loading data saved by master.py kat.loadKatFile('asc_base3.kat') try: tmpfile = shelve.open(tmpresultfile) result = tmpfile[str('result')] tmpfile.close() except: raise Exception( "Could not open temprary results file {0}".format(tmpresultfile)) # overwriting some variables kat.maxtem = 3 Lambda = 1064.0e-9 # this does not work yet due to the scale command kat.PDrefl_p.enabled = False kat.PDrefl_q.enabled = False kat.WFS1_I.enabled = False kat.WFS1_Q.enabled = False kat.WFS2_I.enabled = False kat.WFS2_Q.enabled = False kat.ETM.phi = result['phi_tuned'] (beam1, beam2, beam3) = get_qs(kat) """ print " Measured beam parameter:" print " - At front of ITM (no thermal lens) q={0}".format(beam1.q) print " (eqals w0={0}, z={1})".format(beam1.w0, beam1.z) print " - At pick of mirror 'po' (50k lens) q={0}".format(beam2.q) print " (eqals w0={0}, z={1})".format(beam2.w0, beam2.z) print " - At pick of mirror 'po' (5k lens) q={0}".format(beam3.q) print " (eqals w0={0}, z={1})".format(beam3.w0, beam3.z) #print " Setting these now view Gauss command and adding thermal lens" """ kat.ITM.nITM1.node.setGauss(kat.ITM, beam1) print("--------------------------------------------------------") print(" 11. computing beam sizes with thermal lens") #beam_size(kat, beam2, beam3) kat.ITM_TL.f = 50e3 kat.maxtem = 8 print("--------------------------------------------------------") print(" 11. computing beam tilt with thermal lens (f={0}, maxtem={1})". format(kat.ITM_TL.f, kat.maxtem)) #gravity_tilt(kat) kat.ITM_TL.f = 5e3 kat.maxtem = 23 print("--------------------------------------------------------") print(" 12. computing beam tilt with thermal lens (f={0}, maxtem={1})". format(kat.ITM_TL.f, kat.maxtem)) #gravity_tilt(kat) print("--------------------------------------------------------") print(" 12. compute beam center with thermal lens") print("--------------------------------------------------------") print(" Saving results in temp. files to be read by master6.py") tmpkatfile = "asc_base4.kat" tmpresultfile = "myshelf3.dat" print(" kat object saved in: {0}".format(tmpkatfile)) print(" current results saved in: {0}".format(tmpresultfile)) # first the current kat file kat.saveScript(tmpkatfile) # now the result variables: tmpfile = shelve.open(tmpresultfile) tmpfile[str('result')] = result tmpfile.close()
def make_kat(name="voyager_BSAR_LO", katfile=None, verbose=False, debug=False, keepComments=False, preserveConstants=False): """ Returns a kat object and fills in the kat.IFO property for storing the associated interferometer data. name: Model to load - "voyager" base voyager model with IFO, OMC, LMC keepComments: If true it will keep the original comments from the file preserveComments: If true it will keep the const commands in the kat """ names = ['voyager_BSAR_LO', 'voyager_POP_LO'] if debug: kat = finesse.kat(tempdir=".", tempname="test") else: kat = finesse.kat() kat.verbose = verbose # Create empty object to just store whatever DOFs, port, variables in # that will be used by processing functions kat.IFO = VOYAGER_IFO( kat, # Define which keys are used for a tuning description ["maxtem", "phase"], # Define which mirrors create the tuning description ["PRM", "ITMX", "ETMX", "ITMY", "ETMY", "BS", "SRM"]) kat.IFO._data_path = pkg_resources.resource_filename( 'pykat.ifo', os.path.join('voyager', 'files')) kat.IFO.rawBlocks = BlockedKatFile() if katfile: kat.load(katfile, keepComments=keepComments, preserveConstants=preserveConstants) kat.IFO.rawBlocks.read(katfile) else: if name not in names: pkex.printWarning( "aLIGO name `{}' not recognised, options are {}, using default 'design'" .format(name, names)) katkile = os.path.join(kat.IFO._data_path, name + ".kat") kat.load(katkile, keepComments=keepComments, preserveConstants=preserveConstants) kat.IFO.rawBlocks.read(katkile) # ---------------------------------------------------------------------- # get and derive parameters from the kat file # get main frequencies if "f1" in kat.constants.keys(): kat.IFO.f1 = float(kat.constants["f1"].value) else: kat.IFO.f1 = 9099471.0 if "f2" in kat.constants.keys(): kat.IFO.f2 = float(kat.constants["f2"].value) else: kat.IFO.f2 = 5.0 * kat.IFO.f1 if "f3" in kat.constants.keys(): kat.IFO.f3 = float(kat.constants["f3"].value) kat.IFO.f36M = kat.IFO.f2 - kat.IFO.f1 # TODO add else here! # check modultion frequencies if (5 * kat.IFO.f1 != kat.IFO.f2): print(" ** Warning: modulation frequencies do not match: 5*f1!=f2") # defining a dicotionary for the main mirror positions (tunings), # keys should include maxtem, phase and all main optics names #kat.IFO.tunings = get_tunings(dict.fromkeys(["maxtem", "phase", "PRM", "ITMX", "ETMX", "ITMY", "ETMY", "BS", "SRM"])) kat.IFO.compute_derived_lengths() # ---------------------------------------------------------------------- # define ports and signals # useful ports kat.IFO.POP_f1 = Output(kat.IFO, "POP_f1", "nPOP", "f1", phase=101) kat.IFO.POP_f2 = Output(kat.IFO, "POP_f2", "nPOP", "f2", phase=13) kat.IFO.REFL_f1 = Output(kat.IFO, "REFL_f1", "nREFL", "f1", phase=101) kat.IFO.REFL_f2 = Output(kat.IFO, "REFL_f2", "nREFL", "f2", phase=14) kat.IFO.AS_f1 = Output(kat.IFO, "AS_f1", "nSRM2", "f1", phase=101) kat.IFO.AS_f2 = Output(kat.IFO, "AS_f2", "nSRM2", "f2", phase=14) kat.IFO.AS_f36 = Output(kat.IFO, "AS_f36", "nSRM2", "f36M", phase=14) # AS_DC refers to what is coming out of the OMC now kat.IFO.AS_DC = Output(kat.IFO, "AS_DC", "nOMC_OCc") kat.IFO.POW_BS = Output(kat.IFO, "PowBS", "nPRBS*") kat.IFO.POW_X = Output(kat.IFO, "PowX", "nITMX2") kat.IFO.POW_Y = Output(kat.IFO, "PowY", "nITMY2") kat.IFO.POW_SRC = Output(kat.IFO, "PowSRC", "nSRM1") kat.IFO.POW_PRC = Output(kat.IFO, "PowPRC", "nPRM2") # pretune LSC DOF kat.IFO.preARMX = DOF(kat.IFO, "ARMX", kat.IFO.POW_X, "", "ETMX", 1, 1.0, sigtype="z") kat.IFO.preARMY = DOF(kat.IFO, "ARMY", kat.IFO.POW_Y, "", "ETMY", 1, 1.0, sigtype="z") kat.IFO.preMICH = DOF(kat.IFO, "AS", kat.IFO.AS_DC, "", ["ITMX", "ETMX", "ITMY", "ETMY"], [1, 1, -1, -1], 6.0, sigtype="z") kat.IFO.prePRCL = DOF(kat.IFO, "PRCL", kat.IFO.POW_BS, "", "PRM", 1, 10.0, sigtype="z") kat.IFO.preSRCL = DOF(kat.IFO, "SRCL", kat.IFO.AS_DC, "", "SRM", 1, 10.0, sigtype="z") # control scheme as in [1] Table C.1. Due to Finesse # conventions, the overall factor for all but PRCL are multiplied by -1 # compared to the LIGO defintion, to match the same defintion. kat.IFO.PRCL = DOF(kat.IFO, "PRCL", kat.IFO.POP_f1, "I", "PRM", 1, 100.0, sigtype="z") kat.IFO.MICH = DOF(kat.IFO, "MICH", kat.IFO.POP_f2, "Q", ["ITMX", "ETMX", "ITMY", "ETMY"], [-0.5, -0.5, 0.5, 0.5], 100.0, sigtype="z") kat.IFO.CARM = DOF(kat.IFO, "CARM", kat.IFO.REFL_f1, "I", ["ETMX", "ETMY"], [-1, -1], 1.5, sigtype="z") kat.IFO.DARM = DOF(kat.IFO, "DARM", kat.IFO.AS_f2, "Q", ["ETMX", "ETMY"], [-1, 1], 1.0, sigtype="z") kat.IFO.SRCL = DOF(kat.IFO, "SRCL", kat.IFO.REFL_f2, "I", "SRM", -1, 1e2, sigtype="z") kat.IFO.DARM_h = DOF(kat.IFO, "DARM_h", None, "", ["LY", "LX"], [-1, 1], 1.0, sigtype="phase") kat.IFO.LSC_DOFs = (kat.IFO.PRCL, kat.IFO.MICH, kat.IFO.CARM, kat.IFO.DARM, kat.IFO.SRCL) kat.IFO.CAV_POWs = (kat.IFO.POW_X, kat.IFO.POW_Y, kat.IFO.POW_BS) # Pitch DOfs # There is a difference in the way LIGO and Finesse define positive and negative # rotations of the cavity mirrors. For LIGO the rotational DOFs assume ITM + rotation # is clockwise and ETM + rotation is anticlockwise. # I'll be explict here for future reference. cav_mirrors = [ "ETMX", "ETMXAR", "ETMY", "ETMYAR", "ITMX", "ITMXAR", "ITMY", "ITMYAR" ] # LIGO definitions # Based on figure 7 in T0900511-v4 CHARD_factors = np.array([1, 1, 1, 1, -1, -1, -1, -1]) DHARD_factors = np.array([1, 1, -1, -1, -1, -1, 1, 1]) CSOFT_factors = np.array([-1, -1, -1, -1, -1, -1, -1, -1]) # DSOFT_factors = np.array([-1,-1, 1, 1, 1, 1,-1,-1]) # Wrong! DSOFT_factors = np.array([-1, -1, 1, 1, -1, -1, 1, 1]) # Finesse definitions # negative for ITM rotations ITMS = np.in1d(cav_mirrors, np.array(["ITMX", "ITMXAR", "ITMY", "ITMYAR"])) CHARD_factors[ITMS] *= -1 DHARD_factors[ITMS] *= -1 CSOFT_factors[ITMS] *= -1 DSOFT_factors[ITMS] *= -1 kat.IFO.CHARD_P = DOF(kat.IFO, "CHARD_P", None, None, cav_mirrors, CHARD_factors, 1, sigtype="pitch") kat.IFO.DHARD_P = DOF(kat.IFO, "DHARD_P", None, None, cav_mirrors, DHARD_factors, 1, sigtype="pitch") kat.IFO.CSOFT_P = DOF(kat.IFO, "CSOFT_P", None, None, cav_mirrors, CSOFT_factors, 1, sigtype="pitch") kat.IFO.DSOFT_P = DOF(kat.IFO, "DSOFT_P", None, None, cav_mirrors, DSOFT_factors, 1, sigtype="pitch") kat.IFO.PRM_P = DOF(kat.IFO, "PRM_P", None, None, ["PRM", "PRMAR"], [1, 1], 1, sigtype="pitch") kat.IFO.PRC2_P = DOF(kat.IFO, "PRC2_P", None, None, ["PR2"], [1], 1, sigtype="pitch") kat.IFO.PRC3_P = DOF(kat.IFO, "PRC3_P", None, None, ["PR3"], [1], 1, sigtype="pitch") kat.IFO.SRM_P = DOF(kat.IFO, "SRM_P", None, None, ["SRM", "SRMAR"], [1, 1], 1, sigtype="pitch") kat.IFO.SRC2_P = DOF(kat.IFO, "SRC2_P", None, None, ["SR2"], [1], 1, sigtype="pitch") kat.IFO.SRC3_P = DOF(kat.IFO, "SRC3_P", None, None, ["SR3"], [1], 1, sigtype="pitch") kat.IFO.MICH_P = DOF(kat.IFO, "MICH_P", None, None, ["BS", "BSAR1", "BSAR2"], [1, 1, 1], 1, sigtype="pitch") kat.IFO.ASC_P_DOFs = (kat.IFO.CHARD_P, kat.IFO.DHARD_P, kat.IFO.CSOFT_P, kat.IFO.DSOFT_P, kat.IFO.PRM_P, kat.IFO.PRC2_P, kat.IFO.PRC3_P, kat.IFO.SRM_P, kat.IFO.SRC2_P, kat.IFO.SRC3_P, kat.IFO.MICH_P) kat.IFO.update() kat.IFO.lockNames = None return kat
def main(): print(""" -------------------------------------------------------------- Example file for using PyKat to automate Finesse simulations Finesse: http://www.gwoptics.org/finesse PyKat: https://pypi.python.org/pypi/PyKat/ The file runs through the various Finesse simulations to generate the Finesse results reported in the document: `Comparing Finesse simulations, analytical solutions and OSCAR simulations of Fabry-Perot alignment signals', LIGO-T1300345, freely available online: http://arxiv.org/abs/1401.5727 Run this file after master2.py to create data which can be plotted using master4_plot.py. Results are saved after each step and plots can be created at any time. Andreas Freise 16.01.2014 -------------------------------------------------------------- """) # shall we clear the workspace? # %reset -f # making these global during testing and debugging #global kat, out kat = finesse.kat(tempdir=".",tempname="test") kat.verbose = False tmpresultfile = 'myshelf2.dat' # loading data saved by master.py kat.loadKatFile('asc_base3.kat') try: with open(tmpresultfile, 'rb') as handle: result = pickle.load(handle) except: raise Exception("Could not open temprary results file {0}".format(tmpresultfile)) # this does not work yet due to the scale command kat.PDrefl_p.enabled = False kat.PDrefl_q.enabled = False kat.WFS1_I.enabled = False kat.WFS1_Q.enabled = False kat.WFS2_I.enabled = False kat.WFS2_Q.enabled = False kat.ETM.phi=result['phi_tuned'] print("--------------------------------------------------------") print(" 11. Do beam tracing to measure beam parameters") # get beam parameters at nodes: "npsl", "nITM1", "nWFS1", "nWFS2", "npo2" global beam1, beam2, beam3 beam1 = get_qs(kat,1e13) beam2 = get_qs(kat,50e3) beam3 = get_qs(kat,5e3) # starting with cold beam at npsl kat.psl.npsl.node.setGauss(kat.psl, beam1[0]) kat.parseKatCode("startnode npsl") # if we use bs-based cavity we try to set good beam # parameter for reflected beam, first by # computing 'average' beam from cold and hot beams x1=0.70 x2=0.30 if "ITM_TL_r" in kat._kat__components: beam50 = beam_param(z=(x1*beam1[1].z+x2*beam2[1].z), w0=(x1*beam1[1].w0+x2*beam2[1].w0)) beam5 = beam_param(z=(x1*beam1[1].z+x2*beam3[1].z), w0=(x1*beam1[1].w0+x2*beam3[1].w0)) node_text = "at ITM->nITM1r" t_comp=kat.ITM t_node=kat.ITM.nITM1r else: beam50 = beam_param(z=(x1*beam1[4].z+x2*beam2[4].z), w0=(x1*beam1[4].w0+x2*beam2[4].w0)) beam5 = beam_param(z=(x1*beam1[4].z+x2*beam3[4].z), w0=(x1*beam1[4].w0+x2*beam3[4].w0)) node_text = "at s2->npo2" t_comp=kat.s2 t_node=kat.s2.npo2 kat = set_thermal_lens(kat,50.0e3) print("--------------------------------------------------------") print(" 12. computing beam tilt with thermal lens (f={0})".format(kat.ITM_TL.f)) print(" Setting compromise beam parameter {0}:\n w0={1}, z={2}".format(node_text, beam50.w0, beam50.z)) t_node.node.setGauss(t_comp, beam50) kat.maxtem=8 print(" Calculating maxtem = %d " % kat.maxtem) tmp = gravity_tilt(kat) kat = set_thermal_lens(kat,5e3) print("--------------------------------------------------------") print(" 13. computing beam tilt with thermal lens (f={0})".format(kat.ITM_TL.f)) print(" Setting compromise beam parameter {0}:\n w0={1}, z={2}".format(node_text, beam5.w0, beam5.z)) t_node.node.setGauss(t_comp, beam5) #maxtems = [1, 3, 5, 9, 11, 13, 15, 19, 23, 25, 27, 29] #maxtems = [1, 3, 5, 9, 11, 13, 15] maxtems = [1, 3, 5, 7] converge_tilt(kat, maxtems) kat.PDrefl_p.enabled = True kat.WFS1_I.enabled = True kat.WFS2_I.enabled = True kat = set_thermal_lens(kat,50e3) print("--------------------------------------------------------") print(" 12. computing alignment signal with thermal lens (f={0})".format(kat.ITM_TL.f)) t_node.node.setGauss(t_comp, beam50) #maxtems = [1, 3, 5, 9, 11, 13, 15, 17, 19] #maxtems = [1, 3, 5, 9, 11, 13, 15] maxtems = [1, 3, 5, 7] converge_asc(kat, maxtems, 'asc_signals_50.txt') kat = set_thermal_lens(kat,5e3) print("--------------------------------------------------------") print(" 13. computing alignment signal with thermal lens (f={0})".format(kat.ITM_TL.f)) t_node.node.setGauss(t_comp, beam5) #maxtems = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31] #maxtems = [1, 3, 5, 9, 11, 13, 15] maxtems = [1, 3, 5, 7] converge_asc(kat, maxtems, 'asc_signals_5.txt')
# -*- coding: utf-8 -*- import pykat from pykat import finesse result = [] # prepare for the result kat = finesse.kat() # create a fresh cat object kat.verbose = False kat.load("LHO_IFO_maxtem2.kat") # load the conf ############################################## ## set excitationas, sensors, and some settings ############################################## kat.parse("fsig sig1 ETMXHR 10 180") kat.parse("fsig sig1 ETMYHR 10 0") kat.parse("pd1 myomc 10 nOMC_HROC_trans") kat.parse("xaxis sig1 f log 10 1k 10") kat.parse("put myomc f1 $x1") # to follow kat.parse("yaxis abs:deg") kat.verbose = True out = kat.run() # do the computation result.append(out['myomc']) # append the result print("PASSED")
def main(): print(""" -------------------------------------------------------------- Example file for using PyKat to automate Finesse simulations Finesse: http://www.gwoptics.org/finesse PyKat: http://www.gwoptics.org/pykat The file runs through the various Finesse simulations to generate the Finesse results reported in the document: `Comparing Finesse simulations, analytical solutions and OSCAR simulations of Fabry-Perot alignment signals', LIGO-T1300345, freely available online: http://arxiv.org/abs/1401.5727 This file is part of a collection; it outputs the results shown the document's sections 5 and 6 and saves temporary data and a new Finesse input file to be read by master3.py, and master4.py. Andreas Freise 16.01.2014 -------------------------------------------------------------- """) # shall we clear the workspace? # %reset -f # making these global during testing and debugging #global kat, out kat = finesse.kat(tempdir=".", tempname="test") kat.verbose = False tmpresultfile = "myshelf1.dat" # loading data saved by master.py kat.loadKatFile('asc_base2.kat') try: with open(tmpresultfile, 'rb') as handle: result = pickle.load(handle) except: raise Exception( "Could not open temprary results file {0}".format(tmpresultfile)) # overwriting some variables kat.maxtem = 3 Lambda = 1064.0e-9 # disable PDH photo diode as we won't need it for most of this kat.PDrefl_p.enabled = False kat.PDrefl_q.enabled = False # simulating a tuned cavity kat.ETM.phi = result['phi_tuned'] print("--------------------------------------------------------") print(" 5. checking wavefronts for ITM/ETM tilt of 0.1nrad") tilt(kat) print("--------------------------------------------------------") print(" 6. compute beam tilt from beam propogation") gravity_tilt(kat) print("--------------------------------------------------------") print(" 7. compute optimal demodulation phase of WFS1 and WFS2") # adding wave front sensors to global kat object, will need them later # on as well. code_WFS1 = """ pd1 WFS1_I 9M 0 nWFS1 pdtype WFS1_I y-split pd1 WFS1_Q 9M 90 nWFS1 pdtype WFS1_Q y-split scale 2 WFS1_I % compensate the 0.5 gain of the demodulation scale 2 WFS1_Q % compensate the 0.5 gain of the demodulation """ code_WFS2 = """ pd1 WFS2_I 9M 0 nWFS2 pdtype WFS2_I y-split pd1 WFS2_Q 9M 90 nWFS2 pdtype WFS2_Q y-split scale 2 WFS2_I % compensate the 0.5 gain of the demodulation scale 2 WFS2_Q % compensate the 0.5 gain of the demodulation """ kat.parseKatCode(code_WFS1) kat.parseKatCode(code_WFS2) (WFS1_phase, WFS2_phase) = asc_phases(kat) kat.WFS1_I.phase1 = WFS1_phase kat.WFS1_Q.phase1 = WFS1_phase + 90.0 kat.WFS2_I.phase1 = WFS2_phase kat.WFS2_Q.phase1 = WFS2_phase + 90.0 result['WFS1_phase'] = WFS1_phase result['WFS2_phase'] = WFS2_phase print("--------------------------------------------------------") print(" 8. compute ASC signal matrix at WFS1 and WFS2") signal = asc_signal(kat) print("--------------------------------------------------------") print(" Saving results in temp. files to be read by master3.py") # re-enable PDH photo diode for saving of kat file for next script kat.PDrefl_p.enabled = True kat.PDrefl_q.enabled = True tmpkatfile = "asc_base3.kat" tmpresultfile = "myshelf2.dat" print(" kat object saved in: {0}".format(tmpkatfile)) print(" current results saved in: {0}".format(tmpresultfile)) kat.saveScript(tmpkatfile) with open(tmpresultfile, 'wb') as handle: pickle.dump(result, handle)
def main(): print(""" -------------------------------------------------------------- Example file for using PyKat to automate Finesse simulations Finesse: http://www.gwoptics.org/finesse PyKat: http://www.gwoptics.org/pykat The file runs through some Finesse simulations for the Glasgow speedmeter experiment, using the file: sagnac_base.kat Andreas Freise 30.10.2014 -------------------------------------------------------------- """) # defining variables as global for debugging global kat global out global result global legend # for debugging we might need to see the temporay file: kat = finesse.kat(tempdir=".", tempname="test") kat.verbose = False kat.loadKatFile('sagnac_base.kat') extra = kat._kat__blocks['NO_BLOCK'] # adding homodyne detector #kat.addLine('qhdS sens 180 nout1 nout2') extra.contents.append('qhdS sens 180 nout1 nout2') extra.contents.append('scale meter sens') kat.maxtem = 'off' Lambda = 1064.0e-9 result = OrderedDict() legend = {} # getting mass of the light mirror of cavity a global m m = kat.M1a.mass.value AoI2 = float(kat.constants['AoI2'].value) / 180. * np.pi global f f = namedtuple('f', ('start', 'stop', 'points', 'data')) f.start = 100 f.stop = 2e4 f.points = 100 kat.parseKatCode('xaxis sig1 f log {0} {1} {2}'.format( f.start, f.stop, f.points - 1)) # Reading Haixing Miao's reference data: datah1 = np.loadtxt('QN_Sagnac_lossless.dat') datah2 = np.loadtxt('QN_Sagnac_25ppm_loss.dat') # Reading Stefan D. example data: data = np.loadtxt('Stefan_data.txt') print("--------------------------------------------------------") print(" Run default file (no loss)") out = kat.run() #f.data = np.logspace(np.log10(f.start), np.log10(f.stop), f.points) f.data = out.x # getting frequency vector from Finesse instead print("--------------------------------------------------------") print(" Computing SQL") hbar = 6.62606957E-34 / (2.0 * np.pi) SQL_x = np.sqrt(4 * hbar / (m * f.data**2 * 4 * np.pi * np.pi)) legend['SQL'] = mylegend('SQL', 'k') result['SQL'] = SQL_x result['H1'] = datah1[:, 1] legend['H1'] = mylegend('Haixing, no loss', 'g') legend['H1'].lt = '--.' legend['H1'].lw = 2 result['default'] = out.y * np.cos(AoI2) legend['default'] = mylegend('no loss', 'm') print("--------------------------------------------------------") L = 0 T = 12.5e-6 R = 1 - T - L kat.M2a.R = R kat.M3a.R = R kat.M2b.R = R kat.M3b.R = R kat.M2a.T = T kat.M3a.T = T kat.M2b.T = T kat.M3b.T = T kat.M2a.L = L kat.M3a.L = L kat.M2b.L = L kat.M3b.L = L out = kat.run() result['H2'] = datah2[:, 1] legend['H2'] = mylegend('Haixing, 25ppm loss', 'g') legend['H2'].lt = '-.' legend['H2'].lw = 5 result['loss'] = out.y * np.cos(AoI2) legend['loss'] = mylegend('25ppm loss', 'b') #result['S_sym']=data[:,1] #legend['S_sym']=mylegend('Stefan D, balanced','k') #legend['S_sym'].lt='-.' print("--------------------------------------------------------") print(" 3. Imbalanced BS") #result['bs']=imbalanced_bs(kat)*np.cos(AoI2) #legend['bs']=mylegend('Imbalanced BS 49:51','r') #result['S_imb']=data[:,2] #legend['S_imb']=mylegend('Stefan D, imbalanced','k') #legend['S_imb'].lt='--.' print("--------------------------------------------------------") print(" 3. Mass asymmetry") #result['mass']=mass(kat) #legend['mass']=mylegend('Mass asymmetry 10%','c') print("--------------------------------------------------------") print(" Plotting results") plot_results(f, result, legend)