From 0176355cca7ce2b06b21c3037c3a55b00740862f Mon Sep 17 00:00:00 2001 From: linarphy Date: Thu, 27 Mar 2025 14:38:54 +0100 Subject: [PATCH] Update jupyter notebook --- finesse-virgo-sensitivity.npy | Bin 0 -> 16144 bytes generate_from_finesse-virgo.ipynb | 101 +++ main.ipynb | 1226 ++++++++++++++++++++++++++++- pyproject.toml | 9 + uv.lock | 161 ++++ 5 files changed, 1460 insertions(+), 37 deletions(-) create mode 100644 finesse-virgo-sensitivity.npy create mode 100644 generate_from_finesse-virgo.ipynb diff --git a/finesse-virgo-sensitivity.npy b/finesse-virgo-sensitivity.npy new file mode 100644 index 0000000000000000000000000000000000000000..66916a65bfabd0b2ecd5ec2616720287bd0a4c0e GIT binary patch literal 16144 zcmbVT_dnL}_m_&SqTKgw@4fdr#<6#{$R?YtC_+Y*y+YZ0MTM4`LQ3I{h7?j7(ohtk z`re;^;d}k^e4O)oy{`K@=XK7x&N2>YWm-2~hirHS6$&-w zCgIfhS3Mge5=ziM|5zJF!fxk-a~h>2%rWn(hq~+7dEt?ycVUC$%YNz zZ$`WJu;C*{E5i6EHoV{bY%Y(D9bF?D{8~)dQCVKZjO8>tN?#b~es!50fB$2N{q>3+ z|DG<~^4-sYg=udTWsw7uY1$uJhjZW}-+k+`Iu3M@{BykeIR`$hFz%b6KP(k^x1;cOn1N@wE}ZskE8Gkc1@hdfwg zaKiQ62Oiv2Uw$cdFE19qtvb-d&x>c)e{c!v@FKJCHKAd5Ui8hYNG(0Xi?@0tDw`^J zk@|4trQ#Q*-j6=t!}#ga#juT09&|bK%1(v#KjR z@qFmlP8IyUf)B5nl=|%4;lr-K9h5qYeAvu*wD}$-KQ4IN4aN)bwhN+;0)idG`B_pJjQxtFV$lK|FSB8C*L?`5Q&25O?xRW5d_Kd z3_O+c5Jb1uIvVbCf+)BDV~%y3AlA3+di`)(5Z8CBho@`_;u)q}cT#wT@I<%2&Lbls zw6Wojv=0@+*PL0?!WV_`=Ogi1tpOn%-Qz)3`B4akz63qfXA(xij*y26YQoq<40H?f z5=MqSdaPeEg)y09=+v#7!q{q6O7Zx$FusiSP!OjR!Je(+i%%6ru*3Lr$0K(UBwSwK zw?9(^jYoR;%5RC_l&#A7=(i&1c(34I?Ez8Ddi%+VLtPZnpdp-}5?2GLkC4C>2?7r88kIy-;tPS1*A z#<5H?sATe`{hy=^ zQd72e-Y}8DlNI}$Dtu+|lSkZg_gNYA-JzJKt&u^~Cf$MTJ2JR#l+R!|Cxc!Yb0mdr z8GN;`N8O%P7IOoAX4{ly(YElO1=!1?&4Z&me^1Eb%%m6oE|5i0<-S<4PFXy2?8m`^ zDOseO2XFZwvd9{d@Qm)D9J)o=k8;S#VaWSE^*+{eXgGZK(Q>#P9#TrGZ77gK?opS5 z^6PR)(=SOm@l+1k)$bgE4LO{xD&Bd+B9FiB{&c*rCXXJ<(=XmR%j4CCcki{&$m0}a z)#ur2dF16&IMO~OkF9453Wh((;|GPX11xk3*gd18+AO7j+blW>(bftm_b1pkElL4j z7-tH-C{aMlMKM4BI|_J4usTC+Ndbf0nf92|D59)rfPS@YwCHzm?|3dey5;D=J^cn3|#?4}c9ik1F%LmlSOxnf+j)0etDrZ%hPrs13R&*1mC7a+Bz4f; z_IRR#O;2gW!YEX6a#!4=aS2s)eaI(#+EEqFzF&C|m8yyrf@A9UI#uy#J0FwlqAH$H zwR~c7Kn=%Z)(B}DYIuaM*@rbq4ehx0JM5IG;Z4(fv2vqon0wUUulKha&g^fyS|SQ) zx25@U%n`8Da<<7n9q?7ZewtzrV70y-U*KoJE2Pg1o1E%+C+6?_R~G6h(OO{4mZXla z9*j&~yRMEkx5s#@Kd9ph$M>lfHVvH7xtNxBSOY(@7`)F<(m)20vW(T68mN)$%z1f5 z1C#az;UJGDw!E1xQMK2^tb;?-`!h9hN~N$s_nsztwvQ&yY-(a^J+sBQv=-jvwXPQQ z)j|g80^x-UEeu&@%iVsah4&X_hWn@yCpt3TN(&%vWF3rsf`|uKk9@rBf~aehm2@)( z@zBAu_3Oom{@<^(`rJTF`j2m&ej4%Pzv7t>tB4^EfwwmHYomZ$Vr0}KMaW{QtM!(t2hO- zuntz=(l9VF)Ir(;&l_F7I{4uDzE02cI(YfMRlR;Q`MM2p&2v--9nF_^_pIn3>B=rV z%%F>Xr-B(drFBtm*W$del`j5Onk0lokm(;GJZpuzcuA)%;QDP{G`Xwd(fLvrvzC&= zR{!cE(Y~K1h))kMnl4@xGSI{E#fEI206lyko$GWoTMrMjeh7Wip@$ofdNJp@9@5i% z)yUYW|-JNdwF^bGa^TXMp9ofzKYq8le6uqUp6d13Ww;oHPH}0Q1@ncx-!dNRigC-w{WC_^mV5q{k|wxjbR+JNvk9(# z28!8q6FjY3p1jsY#ti;a_hl2j>%sMsm(>*4a+hY5jZHCe>8V(4v?=cX=j?Z^#T2vT zzl+AcG{sAvEHo?hW_V!Muc}?s44)ssWV4=N#sadAI8le$F`?+59871gE{A; z4`Y^9XGq!A!+7DemjUDZ!)QGo*tf)Cfg&8b32e3&$a6XuIx;Nqm%C(n>!1Z@-xIc_ z-Lb$ycF%o2Y?j!@h&sQOEYV_xM)r=4CI08vEpj*BfaX88)dO|-@LAs^Wc8*EXosj+Tl)D|=Msw+%>v&FzG)Eb-2cKH6h zs=SAq9SSv!XVAObA@N#4?^cQ(E;tIQOSIbIMXU-k2LZ5c-}x2`lU^2QM~)+LReTR4IO8yWpeG!EEEII)na;DGfsiX91V z4ye7((>IXrfQPJ3oio2l#`3^R!fza~n1VCbV!tE)+pg{!R&&Hg(%!jrUq`GhG7PW0 z;D{X(UQ~PTIpWuwrovs{9Pz)6Rj)goN0HYa%}8cPQLa)b>~73aoPU&etiSmv?t2*C zwg1IYq}9E%yK|otW}S$bxvb)Z8k+@Uzx|wWe}!~R`6VaJ*7b-g9(BU@t5!}Qx1I1p znCf7zq%*#|=V_eh=8TcS;_09AoYC?+6@U4VGyc>%)6u-)j4Jz8XBfp@Fw%QXVcOLN z9Ur9!e9w2mw|}?TgGO9X_Lut?-5nRKTi8jCmUYE3A%#>1UsueDEhwcZcSU&nUy#kT zD<0|}tEHlK!}g_%D{R_s*w+=hntRF(yYz?M{I9v8iJjWVx{q#nXY2__4Wl~_2j)`> zNV=o(ztizE#_rg0-R{#JA9tLhOs<+ucE{#n>K&14cU(J~=5V>+9bXPu9Q1tUjzKpK zQq8yAQG5O`({UCLWO#e!(2$Y`+Egffvas{ORV4moI^lsUamg2G3p`N%mc6K2hX-Di zAQGx4J+MaNXP4G@4;(an8bf6A#Do;X9zj`8d|#Ti5Nzd%UqwpIzJ+OTH({ z9&o-`+3ATTmZ$Y5o_M0Wlll|YU!J%~!F_FkiJJBphNLRX7E2z(QzyUYd0QPrACc(T zh{$6Y?V0Uy_tG)k*wxix(SHmD9ZlYFy*-9+3thdW_jzNy=zMdcq&I5FpAjS4c%$8y z`$xZ=^2S6Cx_0VHZ~T%NQRhAEjqfbBTd6;LBTsd>?$?7p==0;uBCDDYvQ$>@%JA?( zd3R}Uoirch9Cx~@)$W7KONx4DU-)2BMvDO>r7s3>rm8QA`Qp)y$a)G}Uv#6QrSysO z#XU!FPBS<9B2(9sGKNWCG*xYQZMp4>gD-6P7XpIsxf7%a&*tglO z8vT$`QnH9~+7DU3d~WCb=ZB`;JDaD({jq+F@fV+iKWe^wuE3GvkK7yU+TI=hNJXT& z{CB}0JwGu} z%~YfmixYydUL@&&cxMoL?tj0jAy^I*JTpRG)p7>vu4uL&+U zf|0m(^(FJCU_93GTvCktILa3|bd=j3N0-ZvjG^hr@phZoYW2Wz%-Pi6mftvzMUB?4 zgrq{StyxIxw08&|oPF@0Yg2I@P+S zTM?L{d+AR7Yy?_<3;O>0PXwyIe%*MK_XN85zq2}|e*(R`rQPWKPv8%AK;5hpi0dXk zJ?$qjcp*Ud#IqB4&^65D`1T2mDW>?=%oB+mOXuo^4I*(&RsZdWz(_n=V!*YMN2bpP zj>+DRL~4H@zux&s6y@so&Da}-;Z75Jl@d|-Qhq#o(CMhTIU*c#5=(EsT$Pta-pFQ*$GK$6tfo8Xw$Y`|Gi2gNE6O9biNw>}ai^g#dDg}p3rmZ^*onca^S5I#$=^X??L!RCzWKD$PCAV-Y@^P@hNp4= z8*@&nQ>W4J$;{B_rqg&pYIbGU>}hnnJRyFZE*8an4Y}nsVsWZ}(c^GPEHha_+j&pNDp-!W*#F>X+j)+=6$fl84`yl&KU1@tc^pxy4C+ypT{9vj^dAZ z^zj(Ra-CjPCmz!`B}YD;jK`<{Wj@?)i$_t_rQV>Wc(na5!c>#}4CY%l^MqNS!3T|e z%X`z$Aj_d^)_?Aj`I`3h4qInXO+myfgEaw_^k`T)l@d^>PcU)OIsxO0B7V+^?Xu8)c;P&oBR9e+)UFJ>1Ma$kqOH4$L zs!zsWTodsOUFxxcxI}zjwI(}SmWXFh>mH)(O+>17*?{DiiP$wMa!GzW5yRqfHwSwX z#;9x4Yd{j_xYn^0J0+n+Qel=@Y!Z$Pd+@0`$99n zT>p9&g_oB8yf~DCF#Xpj|Hunlsk?n{I>$AR8lvPmqBlA8L zDN`fkruU!2@jsNT{mSQXbo7bEclUFMV)tr-)6ZerR%(I#^>bKhIb5eZe-1ktsgG9d zJC7x4ca-(y&*RI3=7Wl^=kZC~R#HUTd2DIk_4m*9^QdEz(fjoEd3+nzVYp47hKCNP zh=!=9p*}VB7g?V)yb>YHrB{%K(~o}{Hw>gBz5m5$FGy$Or#khn zQ15Ky2qpb+FU`jDp}mXOCbRJ?)gC#IeL1MSxt0~Km4hBi1x;t)yHW+T15=Se1*f zZqM(G^yMPSRE|IHWiHMoe4_CEor{iC1#2m!JS3fSahz4m!^kImdB<$?&}RR!ErEzU zY#%fI$)2BwNmf_i7`Nx4W7`3NtN-O;&{he%*=inUr%OukGUj6lr%jiXOg=s!83{*P z=HuJmt=aX^d{hpgSG$szk48_YTBv!o+kwzFPNiRr#5Zl_cM=SHuFGb1PHo zRVl!2;Z@Si(E=n5(I?2n6=1=H5Y9CuxkCf za*D(S+;Z3Lu(G^>Z=YeO%ZUrvC*XUz`QimMbrm~`~Mm4esclu{hOR*qAo-x z@{a5&QHWaoKPuO)3UT^W$oRvPg?Q(S1NWQqLbS^Kk4AHd%olyMcm7i$o;!6g^Bz+X z#w8jMKdThs9M1xmlY0^FoR#EdJYR$_uDV>JyHalJX1u@%RFB{rzpmJowt{p zMT^OGOV#^9>tej&$j>AkTa29?FIuPTi*c!pS$%Y(7@zz;phLG+jBGMrb&3TpV&cu- z!Q&PeQH3kgBtPaN*4_B)LfLQ;ZKY&V?@V6AA^l0y(LWbaKCDcIU+fafWa9Ht`%8E% z-Lvy<@+DM~sC3-dehF)CW*(`WzeM)4UN}czf-D7ng#&6Oc&DD@m#KdVYB&0R6}?!3 zdNoo^P9r5qdt>j9g%8+!*Qjz&g89KFmbgyqOLt4c#!`!7ZRC%J3_LNkPHzyN@ zBTdV(c#BvOcBUNXiZgCJ>@3I4fSjxGAIq_%?Was0X9b!PZZ7PysX*n~ubz|VEAac> z_ns7YDzI4cKw8ev3VbC_m2gI)51PpftIQY zJ>x%=MDtald_ub@yH*u4e0!Su&8Z4`nq%oVPF3OBxnP1^Q58DIGX1IQtU~?P2yVT} zD(uMDdBOgz3Y~Z-&xtTpW785TEkL{)lSFUA8{=v;5nTJ5<5!J0xbMiFI9H9YE3PZ& zG*qKkA#2Fua5Y}Yf2|hyt{QKxH~*2?TZ3_&!)(HWHJH^T`^!fL)`z`ou<>!^ z>A=()lzi}D)ugcot$lrZjy@7E_NV+ZyxKA-`NQD}`Pi zrV9mW{_?HEeJ!2x5}9?lx4$T$=2{(+?AYxbpVnc^EhZnUtvdYtiNKV>U5^25d81VN z_2hGk9_rzMdVJths(C-R9@8V}-qYTy$A5S$vS6+r?`w1WxbJB|hrUZP;o=SGWNK^i z(7FL1S=nj$#57=IN?eq2O#_A;Pdgbg+JKCo5B4wpXuy#>`47t38!?~cNvzas#7vG} z;pN~)97?_u7hBv&?qi3RINoi<4@tKv5?2}#69X022u*0Tq~CoFo6z9zH&SI<;QGzb^I058qtDcQ@XC zD`vflKgBAak62#C!^uHyj_0o;9`pv7@NPX_%HI{35`~I12RJ?}C zMZ4#ATVKQ7&AT7`K7I`|Mj1)`nb(jM=Pa1ed<~Bfx(_prT*DtPD!)Bjx`vkoM7$>{ z+tDcHAj2-+cC`60r0=8Ej&--qj_-19#{-Al-%rK1W8w$b{Vz+~F+$wdkgca3-S%z# z$enFRcZSvot*v&P@Jy8uV(UO|3gbk5wGNzl>-((yXb0Xmr^%B(-GS2ERHW_F4)pW> zHcrvkfeDnQf_EqW``Gcg=mnC$tEX@$d67jLdTf5YHf4Tn}iUl{ED`FfKfJ`6M&V#Y(Y z!r(>Pq~+~hVZiRv$+b8X3Pm!xOCQdM!pl2a&JWE);eFRQ6c@y zFLgrT_fGM;!t`-i>8TMG@IDU51HNR{ZU)1?Ds7XttYFai+EWAq!H_pgE*pA-z~=l@ zwF$c*P-huD`EWH5F6nmcm&*zSuFu&`yTt<`^Sae;)zJW``C9+|aXeaJc5O&haqPa#%E+vpT#Wa7ps> ztspOuImL2%PS^{ywR^+1-g<)Afh+^MYEKyRJsn5y<_UYu`x>`6J)tl9qSw@%2WSUL zI_Fk+z=VOWv8=lXI5aYUYv=O-=2%Xy1Ml4-{K9gFev3O;N-h;zhq%KPC6OLEMR%ZO zuhqN1;RXwn<*j#9-5@~2f7XiR25-Z87{i)fLGWC3J*$Q*P^X4a8%()?w8qz4t9~w^ z$a}_|d6x?ajc$ZrE^&tAS4BTuQ*?$sz6G(|Q%>N_a)|Xuh!dP}D!IXbzzOc-TbHX> zkHWteA(>pOqrkKF|KxM{WnY^%)t zd!Xz9uAg!^Pro?=CZu;0F4;$byXnY85FCN~zx0=Cm+j$6)YbQYFWSTDw0P3rW(OX>=p_?9>_B0$ILn4;2Zo#PgybIE0vPQmvnJbuo^cn$Ua*CQ zrAo>lYc`+|Qyc%P%?7H=)_)E7*+6aQ_?J=v8=&(s_~E~34QC&-R0&sFL#6NO%1IY% z*z@&s-7!vUcr`#3HaBMl-vliFQ>nCq0HiOC@UVilJER-w0#=};*~xJFqa}#wxm0Sm zS;9DTW5~;JOPJeDm!q$02~JsqEO8W;(En54`){rVtj9fP&F8a#ux{(2t2YjV{KlcL zRwjobZg-eM#A|b)Y&veV|CBk1TAcjK$z%>!t{wbacG(O99#?pz8k#}aJsRTEB~xf# z$rL-AYzmh*{06f5O@W=dmUeZ>1Y~FLnb-Q7fE9KALM@#M)G@vi`f|+}QZ7oD#vCyQ zv8bvc!+%C_us5qS5PI)s+E+FMD4Vy;u^iWjrkhp#!%6zE>F1Sfq@oY++o^s( z`>F?jK196=YS4qai(m4o-1H!Ib0E8lMGunpDOe~^>%v}dL-&zvU1%RqKWc8O3+Ik~ zdo#RG7tB&hS|mqwAl#|zcw(v!xYF2d_8I8FTDCC9Yib?flMm}&dZ-P~rQ`h%GPU7w z>;axMOKr$mVR+3)(1v;GRJwv$gloFrx}H@bM2*=ntoS1A>lK$9lSYug6V$)Hss+;0 zEiDVlT41|ttly4B3+Qe2>a4D4!s+^D(zw1RIH-3o56^3WVOidee6$8EeO=N&M9?7L zcV^7BLmiIlXtgm}sY8DA6Gq|h09K>~#gcr0j9XLwK8gS*)Iu1}y-@oF%w zvUZ|VPz|WmOigc&se;;|-Hq)iRd5VAdF%|YDiFT)vTBT}fL331y-bV>*r+}KU?-vi zB@gH)nw~3zQ^IWr!Sl-C-t{_nL{%AF4!zII_^bpAo`=r{S1AD-Z*GOZof7;in-_?s zQv&6_Uw+m16oK*N=Z8;Y6yg5k%}#=XB3Q&5Rk?gsfP?smxusbF;?j24ZFnmH=gzaw zI{XT7%igWz{GvQ;ed_TVu9An8D{tw3xy!?J*GUf&pF9M46=@1B$-%+@uAJv?lmo{f zwlWlfa^NOIlpU6q1AUXjd4WG=;nw>dkJTPo;EONqw@j9W#anBS(@bSS41e`rWR`_j z6!{Ng=4IgElMH#uW*OL@Yj4_iLI#5JR(v*52Hs@WzNgzS1Am9O{YGy|!*+gC@@_k6 zNN?Un>R*!rt4A|pKMSOwZkg*vt)di+g!h{b&q%`YQ0u$4agv}YF`s14F9|7kQogi| zN`Rk&VX$9>1Z*C^9+$`|0k^KSHGh8~4#jUcGOkC8L+APS(P4gZ$P6my=A9M;y*Vq3 zd&y#OZ9qe^UQrD0*kzUse-s7#vr8%5<)Uz$T6E=#wJ0>{sZNK`h{8x;hmGr95m@!? z%#Ml?fyWtT9oH2^ps4!UZ{}5Dkg62kE#$C6VT(=p+|(HEYKA6mtRfNc!FrZd{OaPUY=k5iWRkV)q5ZADmFxxWCe| zj}r!c<_Z(iIKi{PocXprCs-#I3~UQ7yyKRZy(ePp!N zVF!JOK=pU*>|oBHa>M)=8~iKKxSlr21}oy~rwiNI;Mw=dBf;rxkoJ$VhQW^wG#};k zh8wT}^@+dCmju~hu(OswZZ8{TW?l|tf6odHg}kRjM_A$N#O9|{&8)Dte9%oclNACt z4N{9jSi$p@FI&A0EBx1B_}Wp06-KBA8rwNpK~kv0w0SoxSccJcXnbM;Dj0bbILQK6 zd%s0*IO)(YmdY8F_}|Lq)}&H}?H6f>41Sb$F`dt}9h1%3+X>qi-}fcvXbom6=i zSjZaN$I8tD^gpRTi_@{dZCWqW-VG91R6WlfSt7y1Q3YAkDG~^!GPmjtkbwTsL`M4+ z60lnad*_ssU<6BMUS^U&!MPykLM#dNcC%>R3L*g`wL^op3kl*i7qev#lc0@1^YK|N z5`22-tD!1Of>Zr<56$>VFlu?mtB*i}A3Gw{Y5Pc^CE4EHwoQa)g)dp6--wXeFCJ_SNa{7dmi7;O`fBthc5%l#asnj$nA({*xJ1~zO6z8r#;+e?`4Ug0pCrj#fcEXHhjrN zfCybaD*HZi5@GD;R%ktm2sGi>u3umx!cpI;?(1|!aFfpu+e1YJKi{6QBnl#2g`!cZ zZ30NMj`~yoBEW0`cG7((z{=@;H`G28;Ht7}a=`}zFnc^xCcGs8;cDlP{&@nJb34As znI%Af(g)(XX9Q4F{PVJQiU15IrLOPB32^W??X1Zo0-OyT%$^=0z_S^Pd+|dAxJIjV z$Mh}%=0xV6sP+>eZ{x%fqaFfW_L!@Tx=nxp-)y>}8w5CYI$=k;lK?Hegcn`c$j=|3 zp!c{!0RA$WJ%X(SP)YAm*xNz?b-Q8aT}|Zmv;}dqG!THQ;KsCZ9Rco@oVZ?CLxA!w zHKXk+0$g;_W{s&N0BO_y22%wAC|*8lyIV#8o|A6HX{7`hqLQNZFCoBoYDKl%CGxy% zRy#o#32@{NLvL;|0p3P+ri>O5U|+fLE;cg46a5$Qg#@T)|F38B0s*#;xH+C9<8NMD zZ!t2m?s`zTSU>>X_wlu@WVE1pVVpt6nFGTHab&!c(Q!11jN1>+8kLaI_eaXpAu>8g z9DTTp{Cr>Q`WH(w-la}E&_PCbOxh73|DMM0$dqO>o~~w%(;}~FasI$?I)e^uzdiI`CJptYv4iSDr*0a^aNZ}B& z-lYVYud|Zhg8}W@o$1R2C>dAMDsLk|)ShVJsH+6{u5>TNwVeRD!^w>HodihS&fD!m ze!tFETzV0=2%tFKK7O%_0B+ZWtH;Q8FtM+xn~7`}?PE3U-U9^KKQcNza*u3}&lr1E zhspAqR#Ntm?TP6Aw8C_h0QM_7#Vd~qAV8{HE14jGiQ8PSBiRm@5;t~)pAx{epZ(6> z83L>lau2ML?KNStbNkyIS^ihsc{{Jk_FVjJk!6Vh7h(i=^vHJp{t*61_(XuUx1XLp z{zBG!=JP%gvOgrg@9w#q6u>qAwF@M)vEEJOwm2rHSCs=awm}K!n~!QILJk2r}Q? z7RiknC{8gBdTKz9FY%(Kt)@hf)qGP_WJ&gKTIsX`J0djft1YWNN`#X_O*{9=amGP1 z{^_4%L|ExowKWPLLVv_yLqiA=uJ3=o%@RqDXO}3GD`SXcd#?{tOCZ8M|JCK?6e4iA zzLmI=L4+sThyBjw5g{XIVj{AbEZ6dMadbHmJfaJK=GPM8yf-`dy=EdzTdJB;Un9r2 z(d>55n?yMGGBy24FL|EwBL`dtiR8Y-u9%&NWZY-DxAQ+Dj7vWMoIsAVbt*rDeCCNT zXE=G!>m7L>c_)eJ&qUZGXZo>Wjl8ZhUZpQvM3~AIvNxk7!J9V!v>_T2{Cskk$)1S> zar2L5cd?Q{&gq-PeI62s+uIt}i;&BJ#>@=-P!K~+dWBeqD?#^Fpvb)HNSXuPLROcL}*Acjs(GFt_=pM zBv4MLCPwCvfZ~yv$K8u0Xei)(E?z@|gQ*fD*DsTR+4@_e^9>TX)m1p~-yuQJ3&nDp zha{ML5MFa&ngn&FPkR*S$nzvrX~cdY!A9uw*tg$F@NW-J1n!Vvjo%}KK+OU+50dsR zGO>{3Qd`A12MY`aU2d2cW&z&ly)jJW{q(^3y%D~eEHF!bl8t78eu3X{9w{t9S7KX!D~|=J>&{HbSFk`RXH?{~78W?u zw7Ob(ivB;tj-O@)86)lsSJGKwaIUeQy@VB(_;jLglJk`Br|RR*bg{xlod(~@hpb>_FZR6r z1uIOqYci}avqHgL3Z7g= zHZ0hHxYMT9=)nf7D}2||BG_QhMUUH+DQxi3ga5zfVm8=vo(S=4VFNvy7)FjhHgIoT z65snD8}vMjRTp^62G{AG`=ZJD*b!DkF)CViINaIx?;$5UI8nBA56iN{FdxN>-}>yp zbCvUj&rx=e^I=tE2w{hW`i|3IlG&ky(TZ!|C3Y|&?x}UT!Va31Nf}=U*`dBs>}bym zb`X3?kw5f}9iok{-K3@BfUCRG&9XT-fO7QgjD;a~_e7km?zet1fT3&iRV{di=?1@7VHJpTS%p!qoQqh%@= z?E1qtpIplY`Oo}{DDQGX)-T4!v3V|#0k?*CJ6!Ns-9X%wog0n~xQ+c)<%W~8Uj%kJ za)Z0p%&7G#ZnzZE>9AhR4G-^h`@O%#4Qvii3PoqQ;hRX_>HbY_xbTYja*Cb@j>Q;% z58>p2mPqjlB`F>tzL_5s*5ZL?qd6{JOCFdP*pyE5;DJOhN5idf9{4+#e52?r4}AV) z^T@S`2iiXVdtu$g10|Cz@)6xUaOYvV$iQPB$Q~=FS6ko#C9Pkwi{!e5P*b>aV-GKU zS9zIvo5Tx6ch34Ri}8XY_tmFHn!MmA_FV9}6))8K%wDc%;Tqdp6 zd)$1mt7S+hP>~NzR+6&}O!$m_aNF{bh}y*uOAow-C0O}kzvbW+7Fm9X>doO%H|B@= zcSl|pdGG^GEU%_$3_nOY2Q{tb^TXHs@-e?I^MhN}w?lHn{P29L@L9t=KQ!i+^4o3l zgJRn+XN`jbAhFH$&P_r9)aws$_Zg7sLZjn$9s&T*CX_^D1%OB^Kc`YG0GfU0@1N}u z02-Qb2ZnJ0uzAJ)dumw#j^^TlXL|)9#!Zxx#3u;1KV4NV(iDXK16o|RPJ*!T;W>-d zDM3&Pq%X)S6omK{>J6GsL0E^ZtM~sC1lP4q;i0dB(7>eon36#V60<32lEsC<_mH=# zzKIa@mg(&>@fU(l65&$bc_FyQxthq)Bm|!-E{Ly;2*Hg~KdQeUgy8mKOtRfRVQ{>1 zmiY&{9_PO15*{YBt-cR;2vG@naiMPY1t*yN_XC`bwM47_m=g%?f1y3X;Uupm`p!(S%~mdtLUDx;!sSXZB| zY*iG@*czt}lf=L-vxD7AQw-j(2b`+)7J~uF%RvTNVlba89H(|e43xiwNGHsR!Fus` z8Wt*XU`qI1Kq)N_e*8D>&_NtZuBpyUCW^y#>e%{Qm&GA*(b?$7Q*m&gsy9obkbply z^jd!65^&E!p{>qd0yHDr1yz#B^bU;*{}l<)&c1!ZXI281Vx)p8sU@NI!PCwSc}a+k zJoL)ILlUAd8po_=OG1493;v(Ik|2vhA$BX05G-4?#>6HCeY1te;>J?oKYxj~=9Cni zk>j0=YLbHQUbj?QW~4xB?bn<-jWoOq&v2DilZN__@{UP?(qOS~I9RD%8Xl*LYnV+) zLyO`qg*Oy3;L|!YYQZK0B~k41-{fT={G9B-fVm8)*0~N3`N{xaVRX@Uq73NTeL3e{ zCId~_{gv{T4Cou38 z-=nhd`~9bNhLf`35znV%Qy>dhBL_GpuFAr_S91%Ak7Z%FRp~?EvMikcBbJjzB?kiz z0}3Db<>1I>jbgO69856@uj;zVfgHQZpkbUGr14$fpHeCZK@44TJ6&=R{LL}9ZAK2p zT@2DLZODN{_uQEQqC5nq$vo#%l83qJU26k&@(>^JK)Ezh9v)a;qwOe^2LnRcO$S3nKa5E(_z`^BBKlg%tl2gk0`_akFU*V)zN!FUl5Expiz*Dh{3H>is|o{2=2zT~t3oW_$%{3YRN+ilOoZaF zD*1lT2Q1%J$$cPMUUN=0FbjIOZ`xQ5w(U;QU5-+N+0-{Tp4O^?q%KF1&7>L#U*HD8 ze`=sl`lMhg34pWl%=euD^29#|7NrCDM5&JVb^-il$(vAJ1~_WPws$|PI(#^EV6U1n zxu5*I%cnnD9e6lS-79TT2S!p)`_xNyc=CaE!izxz_&!kIw9wKZpEm{VE)LUx0b52p zwK@%OTKZtD_FMxFt?x@JrqzU2?aLL`nws!tSxhG=Toc5-Xc^x%Xu@R9dTZZHP1u?0 z@BhW91wWYrKj#`~!P#}u`OH`?2%dJ8H^M#o8<%&UAw2Fnb5m>`;m!`* zP!^Lm6f3vO2uW*$W$7Wubu(@7(CI1J4A6$ckWm}?G;PpmV|ZKFs14UC{xq83*9JeX zK1!)~+8|ucV{5QS2b6@H{}hqG;id0B@4=(10}-<|Z{B$7z=w&frTHWs==@gjh`Ck= zZjN5xIXkEW{K*Y-(o5uTes@2ALfESd_LjlM%0jy2`qQNLf}t*)I74qL<*y5oG4w5a zGIW9Kke3)sn=YKz`l#eTp$odp3b6TI7ko_XYKNKiKwj5wZcDS{uKY?-(rSPm;F|((8dsU_i>z$jx~g= z*ZYq()*HeC>!KF-gdu1<*Oo7C8bULhCB-*BBZyiUTQM{@g5`g!OP@~~!86^su=yGz zu+0@_;T$)D?2Evt&HK2V5FO1yfGx|^ksi(F^1w7=a{Kx zjG^t8ReZ=^6DX@MIw~e_0)kT0D#{)v@G>Q}xhTg3F6t?08uy#PUk#r$i!bE!s$*BU zS~yI>q^2p~(aaRoTXtexV@)CGi`((8R#TvfFWwV4X9|Z`qn}0WH-jjL?{QDG%%DN| zPhnP=8K}!$@2;#h1BD8MG`eSIz_s$Pa&n(JocU-}@dL~uZm?M(B*Yw^{Co7ou+|*@ E58K_1_y7O^ literal 0 HcmV?d00001 diff --git a/generate_from_finesse-virgo.ipynb b/generate_from_finesse-virgo.ipynb new file mode 100644 index 0000000..4bb4e3c --- /dev/null +++ b/generate_from_finesse-virgo.ipynb @@ -0,0 +1,101 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 22, + "id": "8382eebe-ea67-402e-b4da-64d9f616f0c1", + "metadata": {}, + "outputs": [], + "source": [ + "from finesse.virgo import Virgo\n", + "from rich.console import Console\n", + "from matplotlib.pyplot import figure, show\n", + "from numpy import save, array" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "77a9edfb-d910-4264-a29c-1674a4841c8d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adjusting recycling cavity lengths...\n", + "Pretuning...\n", + "Optimizing demodulation phases...\n", + "Optimizing lock gains...\n", + "Running RF locks...\n", + "Switching to DARM DC lock...\n", + "Done.\n" + ] + } + ], + "source": [ + "console = Console()\n", + "\n", + "virgo = Virgo()\n", + "virgo.make()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "2d780140-9125-4a81-927e-daf298504add", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result = virgo.get_QNLS([5, 5000, 1000])\n", + "\n", + "Figure = figure()\n", + "_ = Figure.gca().loglog(result.x0, abs(result[\"NSR_with_RP\"]))\n", + "Figure.gca().grid(True, \"both\", \"both\")\n", + "show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8261c88c-8104-4ef9-9a0f-c186891c8b27", + "metadata": {}, + "outputs": [], + "source": [ + "save(\"finesse-virgo-sensitivity.npy\", array([result.x0, abs(result[\"NSR_with_RP\"])]))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/main.ipynb b/main.ipynb index ec9eef8..8b5266f 100644 --- a/main.ipynb +++ b/main.ipynb @@ -1,51 +1,487 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "a6ba3eb0-8f27-4ebd-b407-3f25f449c6bf", + "metadata": {}, + "source": [ + "# Imports" + ] + }, { "cell_type": "code", - "execution_count": 4, - "id": "b597604e-003e-4326-ac50-1570958a6d7f", + "execution_count": 11, + "id": "bd9299aa-a531-468c-b04b-798b06315f41", "metadata": {}, "outputs": [], "source": [ - "from finesse_virgo.virgo import Virgo" + "# pyright: reportUnknownArgumentType=false, reportCallIssue=false, reportAttributeAccessIssue=false, reportOptionalSubscript=false, reportArgumentType=false\n", + "from rich.console import Console\n", + "from rich.table import Table\n", + "from rich.theme import Theme\n", + "\n", + "from finesse.model import Model\n", + "from finesse.analysis.actions.axes import Noxaxis, Xaxis\n", + "from finesse.solutions import SeriesSolution\n", + "from finesse.analysis.actions import (\n", + " TemporaryParameters,\n", + " Change,\n", + " Maximize,\n", + " Minimize,\n", + " Series,\n", + " FrequencyResponse,\n", + ")\n", + "from finesse.components import Mirror, SignalGenerator\n", + "from finesse.detectors import QuantumNoiseDetector\n", + "\n", + "from pathlib import Path\n", + "from typing import NamedTuple\n", + "import re\n", + "\n", + "from matplotlib.axes import Axes\n", + "from matplotlib.pyplot import figure, show\n", + "\n", + "\n", + "from numpy import linspace, geomspace, pi, angle, where, diff, mean, loadtxt, load\n", + "from scipy.io.matlab import loadmat\n", + "\n", + "from science_signal import Signal" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4c038d40-1d01-49cb-9182-a9a0e94d0d40", + "metadata": {}, + "outputs": [], + "source": [ + "from gettext import install\n", + "from logging import getLogger" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5d4f2612-c5ea-4b21-a326-7074022966bc", + "metadata": {}, + "outputs": [], + "source": [ + "install(__name__)\n", + "logger = getLogger(__name__)\n", + "theme = Theme(\n", + " {\n", + " \"strong\": \"cyan underline\",\n", + " \"result\": \"red bold\",\n", + " }\n", + ")\n", + "console = Console(theme=theme)" + ] + }, + { + "cell_type": "markdown", + "id": "eb7d2340-c817-4309-9599-6d58070ff4ab", + "metadata": {}, + "source": [ + "## Paramètres généraux" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8fc23eea-145e-4641-93e9-6f8989edca96", + "metadata": {}, + "outputs": [], + "source": [ + "C_POWER = 25 # en Whatt\n", + "C_DARK_FRINGE = 8e-3 # en Whatt" + ] + }, + { + "cell_type": "markdown", + "id": "3052aa2b-350e-4eb3-b31c-a4204ab84dac", + "metadata": {}, + "source": [ + "## Modèle simplifié de Virgo" ] }, { "cell_type": "code", "execution_count": 5, - "id": "62096a5f-410c-4f6d-84d4-eead2bab3e0b", + "id": "d32480d0-8525-478a-9af5-b1a1c8b30f1d", "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Adjusting recycling cavity lengths...\n", - "Pretuning...\n", - "Optimizing demodulation phases...\n", - "Optimizing lock gains...\n", - "Running RF locks...\n", - "Switching to DARM DC lock...\n", - "Done.\n" + "/home/demagny/codes/python/finesse/finesse-simulation-04/.venv/lib/python3.13/site-packages/pygraphviz/agraph.py:1403: RuntimeWarning: Warning: Illegal value sgd for attribute \"mode\" in graph - ignored\n", + "\n", + " warnings.warn(b\"\".join(errors).decode(self.encoding), RuntimeWarning)\n" ] + }, + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "laser\n", + "\n", + "laser\n", + "\n", + "\n", + "\n", + "eom1\n", + "\n", + "eom1\n", + "\n", + "\n", + "\n", + "laser--eom1\n", + "\n", + "\n", + "\n", + "\n", + "eom2\n", + "\n", + "eom2\n", + "\n", + "\n", + "\n", + "eom1--eom2\n", + "\n", + "\n", + "\n", + "\n", + "eom3\n", + "\n", + "eom3\n", + "\n", + "\n", + "\n", + "eom2--eom3\n", + "\n", + "\n", + "\n", + "\n", + "eom4\n", + "\n", + "eom4\n", + "\n", + "\n", + "\n", + "eom3--eom4\n", + "\n", + "\n", + "\n", + "\n", + "PR_AR\n", + "\n", + "PR_AR\n", + "\n", + "\n", + "\n", + "eom4--PR_AR\n", + "\n", + "\n", + "\n", + "\n", + "PR\n", + "\n", + "PR\n", + "\n", + "\n", + "\n", + "PR--PR_AR\n", + "\n", + "\n", + "\n", + "\n", + "BS\n", + "\n", + "BS\n", + "\n", + "\n", + "\n", + "PR--BS\n", + "\n", + "\n", + "\n", + "\n", + "NI_AR\n", + "\n", + "NI_AR\n", + "\n", + "\n", + "\n", + "BS--NI_AR\n", + "\n", + "\n", + "\n", + "\n", + "WI_AR\n", + "\n", + "WI_AR\n", + "\n", + "\n", + "\n", + "BS--WI_AR\n", + "\n", + "\n", + "\n", + "\n", + "SR\n", + "\n", + "SR\n", + "\n", + "\n", + "\n", + "BS--SR\n", + "\n", + "\n", + "\n", + "\n", + "SR_AR\n", + "\n", + "SR_AR\n", + "\n", + "\n", + "\n", + "SR--SR_AR\n", + "\n", + "\n", + "\n", + "\n", + "NI\n", + "\n", + "NI\n", + "\n", + "\n", + "\n", + "NI--NI_AR\n", + "\n", + "\n", + "\n", + "\n", + "NE\n", + "\n", + "NE\n", + "\n", + "\n", + "\n", + "NI--NE\n", + "\n", + "\n", + "\n", + "\n", + "NE_AR\n", + "\n", + "NE_AR\n", + "\n", + "\n", + "\n", + "NE--NE_AR\n", + "\n", + "\n", + "\n", + "\n", + "SNEB\n", + "\n", + "SNEB\n", + "\n", + "\n", + "\n", + "NE_AR--SNEB\n", + "\n", + "\n", + "\n", + "\n", + "WI\n", + "\n", + "WI\n", + "\n", + "\n", + "\n", + "WI--WI_AR\n", + "\n", + "\n", + "\n", + "\n", + "WE\n", + "\n", + "WE\n", + "\n", + "\n", + "\n", + "WI--WE\n", + "\n", + "\n", + "\n", + "\n", + "WE_AR\n", + "\n", + "WE_AR\n", + "\n", + "\n", + "\n", + "WE--WE_AR\n", + "\n", + "\n", + "\n", + "\n", + "SWEB\n", + "\n", + "SWEB\n", + "\n", + "\n", + "\n", + "WE_AR--SWEB\n", + "\n", + "\n", + "\n", + "\n", + "SDB1\n", + "\n", + "SDB1\n", + "\n", + "\n", + "\n", + "SR_AR--SDB1\n", + "\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "virgo = Virgo()\n", - "virgo.make()" + "%matplotlib ipympl\n", + "model_file = Path(\"model.kat\")\n", + "model = Model()\n", + "model.phase_config(zero_k00=False, zero_tem00_gouy=True)\n", + "model.modes(modes=\"off\") # pyright: ignore[reportUnusedCallResult]\n", + "model.parse(model_file.read_text())\n", + "model.lambda0 = model.get(\"wavelength\")\n", + "model.laser.P = C_POWER\n", + "model.plot_graph() # pyright: ignore[reportUnusedCallResult]\n", + "show()" ] }, { "cell_type": "code", - "execution_count": 18, - "id": "3b268a67-aaa3-4677-b9ee-3df785bd7265", + "execution_count": 6, + "id": "b742cd14-2149-437b-9194-249cf40849b1", + "metadata": {}, + "outputs": [], + "source": [ + "result = model.run(\n", + " TemporaryParameters(\n", + " Series(\n", + " Change(\n", + " {\n", + " \"SR.misaligned\": True,\n", + " \"PR.misaligned\": True,\n", + " \"eom1.midx\": 0,\n", + " \"eom2.midx\": 0,\n", + " \"eom3.midx\": 0,\n", + " \"eom4.midx\": 0,\n", + " }\n", + " ),\n", + " Maximize(\n", + " model.get(\"NE_p1\"),\n", + " model.get(\"NORTH_ARM.DC\"),\n", + " bounds=[-180, 180],\n", + " tol=1e-14,\n", + " ),\n", + " Maximize(\n", + " model.get(\"WE_p1\"),\n", + " model.get(\"WEST_ARM.DC\"),\n", + " bounds=[-180, 180],\n", + " tol=1e-14,\n", + " ),\n", + " Minimize(\n", + " model.get(\"SR_p2\"), model.get(\"MICH.DC\"), bounds=[-180, 180], tol=1e-14\n", + " ),\n", + " Change(\n", + " {\n", + " \"PR.misaligned\": False,\n", + " }\n", + " ),\n", + " Maximize(\n", + " model.get(\"PR_p2\"), model.get(\"PRCL.DC\"), bounds=[-180, 180], tol=1e-14\n", + " ),\n", + " Change(\n", + " {\n", + " \"SR.misaligned\": False,\n", + " }\n", + " ),\n", + " Maximize(\n", + " model.get(\"B1_DC\"), model.get(\"SRCL.DC\"), bounds=[-180, 180], tol=1e-14\n", + " ),\n", + " Change(\n", + " {\n", + " \"SRCL.DC\": -90,\n", + " },\n", + " relative=True,\n", + " ),\n", + " ),\n", + " exclude=[\n", + " \"NE.phi\",\n", + " \"NI.phi\",\n", + " \"WE.phi\",\n", + " \"WI.phi\",\n", + " \"SR.phi\",\n", + " \"PR.phi\",\n", + " \"NORTH_ARM.DC\",\n", + " \"WEST_ARM.DC\",\n", + " \"DARM.DC\",\n", + " \"MICH.DC\",\n", + " \"PRCL.DC\",\n", + " \"SRCL.DC\",\n", + " \"SR.misaligned\",\n", + " \"eom1.midx\",\n", + " \"eom2.midx\",\n", + " \"eom3.midx\",\n", + " \"eom4.midx\",\n", + " ],\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fbc0d68f-9b01-4d52-866c-18d49aedff32", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "ec208db4b3a044e58f2fbe5c28a1dacd", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -53,9 +489,12 @@ }, { "data": { - "image/png": "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", + "text/html": [ + "
Degré de liberté 0.00164794921875 trouvé en 14 pas pour avoir une puissance de 0.007916437680880756 W sur B1\n",
+       "
\n" + ], "text/plain": [ - "
" + "Degré de liberté \u001b[1;31m0.00164794921875\u001b[0m trouvé en \u001b[1;4;36m14\u001b[0m\u001b[4;36m pas\u001b[0m pour avoir une puissance de \u001b[1;31m0.007916437680880756\u001b[0m\u001b[1;31m W\u001b[0m sur B1\n" ] }, "metadata": {}, @@ -63,41 +502,754 @@ } ], "source": [ - "axes = virgo.plot_QNLS()\n", - "axes = virgo.plot_DARM()[0]" + "def compute_solutions(\n", + " model: Model, DOF: str, padding: float, nb: int = 10000\n", + ") -> SeriesSolution:\n", + " return model.run(\n", + " Xaxis(\n", + " model.get(DOF).DC,\n", + " \"lin\",\n", + " model.get(DOF).DC - padding,\n", + " model.get(DOF).DC + padding,\n", + " nb,\n", + " )\n", + " )\n", + "\n", + "\n", + "def display_ax(\n", + " ax: Axes,\n", + " solution: SeriesSolution,\n", + " model: Model,\n", + " DOF: str,\n", + " padding: float,\n", + " nb: int = 10000,\n", + ") -> Axes:\n", + " x = linspace(model.get(DOF).DC - padding, model.get(DOF).DC + padding, nb + 1)\n", + " _ = ax.semilogy(x, solution[\"SR_p2\"], label=\"dark fringe\")\n", + " _ = ax.semilogy(x, solution[\"NE_p1\"], label=\"north cavity\")\n", + " _ = ax.semilogy(x, solution[\"WE_p1\"], label=\"west cavity\")\n", + " _ = ax.vlines(\n", + " [model.get(DOF).DC],\n", + " min(solution[\"SR_p2\"]),\n", + " max(solution[\"NE_p1\"]),\n", + " colors=\"red\",\n", + " )\n", + " _ = ax.set_ylabel(\"power (W)\")\n", + " ax.grid()\n", + " _ = ax.legend()\n", + " return ax\n", + "\n", + "\n", + "class DisplayData(NamedTuple):\n", + " DOF: str\n", + " padding: float\n", + "\n", + "\n", + "data: list[DisplayData] = [\n", + " DisplayData(\"NORTH_ARM\", 10),\n", + " DisplayData(\"WEST_ARM\", 10),\n", + " DisplayData(\"PRCL\", 10),\n", + " DisplayData(\"MICH\", 10),\n", + " DisplayData(\"DARM\", 10),\n", + " DisplayData(\"CARM\", 10),\n", + "]\n", + "\n", + "Figure = figure(figsize=(13, 10))\n", + "nb = int(1e4)\n", + "\n", + "for i in range(len(data)):\n", + " element: DisplayData = data[i]\n", + " ax = Figure.add_subplot(3, 2, i + 1)\n", + " solution = compute_solutions(model, element.DOF, element.padding, nb)\n", + " _ = display_ax(ax, solution, model, element.DOF, element.padding, nb).set_xlabel(\n", + " \"{} value\".format(element.DOF)\n", + " )\n", + "show()\n", + "\n", + "solution = model.run(Noxaxis())\n", + "result = solution[\"B1_DC\"]\n", + "start, stop, nb = 0, 1, 0\n", + "while (abs(result - C_DARK_FRINGE) > 1e-4) and (nb < 100):\n", + " nb += 1\n", + " temp = start + (stop - start) / 2\n", + "\n", + " model.DARM.DC = temp\n", + " solution = model.run(Noxaxis())\n", + " result = solution[\"B1_DC\"]\n", + " if result > C_DARK_FRINGE:\n", + " stop = temp\n", + " else:\n", + " start = temp\n", + "console.print(\n", + " \"Degré de liberté [result]{dof}[/result] trouvé en [strong]{nb} pas[/strong] pour avoir une puissance de [result]{result} W[/result] sur B1\".format(\n", + " nb=nb, dof=model.DARM.DC, result=result\n", + " )\n", + ")" ] }, { "cell_type": "code", - "execution_count": 19, - "id": "3841fe37-a868-4b38-a1bd-b20dff03dadf", + "execution_count": 8, + "id": "66c9be03-cedc-4d07-acbd-3269f3143cd4", "metadata": {}, "outputs": [ { - "name": "stdout", + "data": { + "text/html": [ + "
             Puissances dans l'interferomètre              \n",
+       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ position                         ┃ puissance (W)        ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ Injection                        │ 25.0                 │\n",
+       "│ PR                               │ 3.521405604227854    │\n",
+       "│ cavité de recyclage de puissance │ 964.8062576854608    │\n",
+       "│ cavité ouest                     │ 135195.25653088812   │\n",
+       "│ cavité nord                      │ 133095.29409492214   │\n",
+       "│ frange noire                     │ 0.007917561973564627 │\n",
+       "│ SNEB                             │ 0.5857983720708054   │\n",
+       "│ SWEB                             │ 0.5811406164494011   │\n",
+       "│ SDB1                             │ 0.007916445597326354 │\n",
+       "└──────────────────────────────────┴──────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[3m Puissances dans l'interferomètre \u001b[0m\n", + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mposition \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mpuissance (W) \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[37m \u001b[0m\u001b[37mInjection \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m25.0 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mPR \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m3.521405604227854 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mcavité de recyclage de puissance\u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m964.8062576854608 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mcavité ouest \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m135195.25653088812 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mcavité nord \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m133095.29409492214 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mfrange noire \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m0.007917561973564627\u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mSNEB \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m0.5857983720708054 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mSWEB \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m0.5811406164494011 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mSDB1 \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m0.007916445597326354\u001b[0m\u001b[36m \u001b[0m│\n", + "└──────────────────────────────────┴──────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
       DOF dans l'interferomètre        \n",
+       "┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ nom        ┃ valeur                  ┃\n",
+       "┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ Bras nord  │ 3.7574470043182375e-06  │\n",
+       "│ Bras ouest │ -5.5315203862846825e-05 │\n",
+       "│ PR         │ -44.946605361949466     │\n",
+       "│ SR         │ -135.08366870105175     │\n",
+       "│ MICH       │ -89.79186967953954      │\n",
+       "└────────────┴─────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[3m DOF dans l'interferomètre \u001b[0m\n", + "┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mnom \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mvaleur \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[37m \u001b[0m\u001b[37mBras nord \u001b[0m\u001b[37m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m3.7574470043182375e-06 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mBras ouest\u001b[0m\u001b[37m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m-5.5315203862846825e-05\u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mPR \u001b[0m\u001b[37m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m-44.946605361949466 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mSR \u001b[0m\u001b[37m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m-135.08366870105175 \u001b[0m\u001b[35m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mMICH \u001b[0m\u001b[37m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m-89.79186967953954 \u001b[0m\u001b[35m \u001b[0m│\n", + "└────────────┴─────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ nom                   ┃ valeur                          ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ FSR                   │ 49968.74091606107               │\n",
+       "│ Loss                  │ 0.013848722846499961            │\n",
+       "│ Finesse               │ 450.5516190359727               │\n",
+       "│ FWHM                  │ 110.90569605093683              │\n",
+       "│ Storage time          │ 0.0028700950223295757           │\n",
+       "│ Pole                  │ 55.45284802546841               │\n",
+       "│ Round trip length     │ 5999.6                          │\n",
+       "│ Waist size            │ [0.00968668 0.00968668]         │\n",
+       "│ Waist position        │ [-1363.71492094 -1363.71492094] │\n",
+       "│ Stability (m-factor)  │ [0.7409226 0.7409226]           │\n",
+       "│ Stability (g-factor)  │ [0.8704613 0.8704613]           │\n",
+       "│ Round trip gouy phase │ [317.81006617 317.81006617]     │\n",
+       "│ Mode separation       │ [5856.04964666 5856.04964666]   │\n",
+       "│ Resolution            │ [52.80206387 52.80206387]       │\n",
+       "│ Stable                │ True                            │\n",
+       "│ Critically stable     │ False                           │\n",
+       "└───────────────────────┴─────────────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mnom \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mvaleur \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[37m \u001b[0m\u001b[37mFSR \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m49968.74091606107 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mLoss \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m0.013848722846499961 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mFinesse \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m450.5516190359727 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mFWHM \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m110.90569605093683 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mStorage time \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m0.0028700950223295757 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mPole \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m55.45284802546841 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mRound trip length \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m5999.6 \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mWaist size \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m[0.00968668 0.00968668] \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mWaist position \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m[-1363.71492094 -1363.71492094]\u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mStability (m-factor) \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m[0.7409226 0.7409226] \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mStability (g-factor) \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m[0.8704613 0.8704613] \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mRound trip gouy phase\u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m[317.81006617 317.81006617] \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mMode separation \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m[5856.04964666 5856.04964666] \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mResolution \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36m[52.80206387 52.80206387] \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mStable \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36mTrue \u001b[0m\u001b[36m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mCritically stable \u001b[0m\u001b[37m \u001b[0m│\u001b[36m \u001b[0m\u001b[36mFalse \u001b[0m\u001b[36m \u001b[0m│\n", + "└───────────────────────┴─────────────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "solution = model.run(Noxaxis())\n", + "console = Console()\n", + "table = Table(title=\"Puissances dans l'interferomètre\")\n", + "table.add_column(\"position\", justify=\"left\", style=\"white\")\n", + "table.add_column(\"puissance (W)\", justify=\"left\", style=\"cyan\")\n", + "\n", + "table.add_row(\"Injection\", str(model.get(\"laser\").P.eval()))\n", + "table.add_row(\"PR\", str(solution[\"PR_p1\"]))\n", + "table.add_row(\"cavité de recyclage de puissance\", str(solution[\"PR_p2\"]))\n", + "table.add_row(\"cavité ouest\", str(solution[\"WE_p1\"]))\n", + "table.add_row(\"cavité nord\", str(solution[\"NE_p1\"]))\n", + "table.add_row(\"frange noire\", str(solution[\"SR_p2\"]))\n", + "table.add_row(\"SNEB\", str(solution[\"SNEB_DC\"]))\n", + "table.add_row(\"SWEB\", str(solution[\"SWEB_DC\"]))\n", + "table.add_row(\"SDB1\", str(solution[\"SDB1_DC\"]))\n", + "\n", + "console.print(table)\n", + "\n", + "table = Table(title=\"DOF dans l'interferomètre\")\n", + "table.add_column(\"nom\", justify=\"left\", style=\"white\")\n", + "table.add_column(\"valeur\", justify=\"left\", style=\"magenta\")\n", + "\n", + "table.add_row(\"Bras nord\", str(model.get(\"NORTH_ARM.DC\")))\n", + "table.add_row(\"Bras ouest\", str(model.get(\"WEST_ARM.DC\")))\n", + "table.add_row(\"PR\", str(model.get(\"PRCL.DC\")))\n", + "table.add_row(\"SR\", str(model.get(\"SRCL.DC\")))\n", + "table.add_row(\"MICH\", str(model.get(\"MICH.DC\")))\n", + "\n", + "console.print(table)\n", + "\n", + "console = Console(theme=theme)\n", + "table = Table(title=\"\")\n", + "table.add_column(\"nom\", justify=\"left\", style=\"white\")\n", + "table.add_column(\"valeur\", justify=\"left\", style=\"cyan\")\n", + "for i in range(1, model.west_arm.info_parameter_table().table.shape[0]):\n", + " table.add_row(\n", + " str(model.west_arm.info_parameter_table().table[i, 0]),\n", + " str(model.west_arm.info_parameter_table().table[i, 1]),\n", + " )\n", + "console.print(table)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7fde067a-52b7-4798-8bd6-0890e27f33e2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f9c247ee23cd41e697912012b06e3348", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", "output_type": "stream", "text": [ - "┌──────────────╥───────────┬────────────┐\n", - "│ Detector ║ Power [W] │ Pow. ratio │\n", - "╞══════════════╬═══════════╪════════════╡\n", - "│ CAR_AMP_PRin ║ 40 │ 1 │\n", - "│ CAR_AMP_N ║ 2.484e+05 │ 6209 │\n", - "│ CAR_AMP_W ║ 2.466e+05 │ 6164 │\n", - "│ CAR_AMP_BS ║ 1752 │ 43.81 │\n", - "│ CAR_AMP_AS ║ 0.005335 │ 0.0001334 │\n", - "└──────────────╨───────────┴────────────┘\n", - "\n" + "/home/demagny/codes/python/finesse/finesse-simulation-04/.venv/lib/python3.13/site-packages/finesse/analysis/actions/base.py:157: UserWarning: Signal frequency (fsig) was set to None but simulation needs it. Setting default value of 1 Hz\n", + " self.__sim.__enter__()\n" + ] + }, + { + "data": { + "text/html": [ + "
Le pôle de la fonction de transfert DARM est à 445.2 Hz\n",
+       "
\n" + ], + "text/plain": [ + "Le \u001b[4;36mpôle\u001b[0m de la fonction de transfert \u001b[4;36mDARM\u001b[0m est à \u001b[1;31m445.2\u001b[0m Hz\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
             Position des différents miroirs              \n",
+       "┏━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ miroir ┃ offset (°)          ┃ offset (m)              ┃\n",
+       "┡━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ NE     │ 44.8951146226074    │ 2.6538001088030154e-07  │\n",
+       "│ NE_AR  │ 44.8951146226074    │ 2.6538001088030154e-07  │\n",
+       "│ NI     │ 44.89593483976977   │ 2.6538485927508354e-07  │\n",
+       "│ NI_AR  │ 44.89593483976977   │ 2.6538485927508354e-07  │\n",
+       "│ WE     │ -44.895166180364264 │ -2.65380315643931e-07   │\n",
+       "│ WE_AR  │ -44.895166180364264 │ -2.65380315643931e-07   │\n",
+       "│ WI     │ -44.89593483976977  │ -2.6538485927508354e-07 │\n",
+       "│ WI_AR  │ -44.89593483976977  │ -2.6538485927508354e-07 │\n",
+       "│ PR     │ -44.946605361949466 │ -2.6568437836174573e-07 │\n",
+       "│ PR_AR  │ -44.946605361949466 │ -2.6568437836174573e-07 │\n",
+       "│ SR     │ -135.08366870105175 │ -7.984945749884392e-07  │\n",
+       "│ SR_AR  │ -135.08366870105175 │ -7.984945749884392e-07  │\n",
+       "└────────┴─────────────────────┴─────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[3m Position des différents miroirs \u001b[0m\n", + "┏━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mmiroir\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1moffset (°) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1moffset (m) \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│\u001b[37m \u001b[0m\u001b[37mNE \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m44.8951146226074 \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m2.6538001088030154e-07 \u001b[0m\u001b[37m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mNE_AR \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m44.8951146226074 \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m2.6538001088030154e-07 \u001b[0m\u001b[37m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mNI \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m44.89593483976977 \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m2.6538485927508354e-07 \u001b[0m\u001b[37m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mNI_AR \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m44.89593483976977 \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m2.6538485927508354e-07 \u001b[0m\u001b[37m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mWE \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-44.895166180364264\u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-2.65380315643931e-07 \u001b[0m\u001b[37m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mWE_AR \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-44.895166180364264\u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-2.65380315643931e-07 \u001b[0m\u001b[37m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mWI \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-44.89593483976977 \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-2.6538485927508354e-07\u001b[0m\u001b[37m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mWI_AR \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-44.89593483976977 \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-2.6538485927508354e-07\u001b[0m\u001b[37m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mPR \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-44.946605361949466\u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-2.6568437836174573e-07\u001b[0m\u001b[37m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mPR_AR \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-44.946605361949466\u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-2.6568437836174573e-07\u001b[0m\u001b[37m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mSR \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-135.08366870105175\u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-7.984945749884392e-07 \u001b[0m\u001b[37m \u001b[0m│\n", + "│\u001b[37m \u001b[0m\u001b[37mSR_AR \u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-135.08366870105175\u001b[0m\u001b[37m \u001b[0m│\u001b[37m \u001b[0m\u001b[37m-7.984945749884392e-07 \u001b[0m\u001b[37m \u001b[0m│\n", + "└────────┴─────────────────────┴─────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def get_QNLS(\n", + " model: Model, start: int = 5, stop: int = 1000, nb: int = 100\n", + ") -> SeriesSolution:\n", + " new_model = model.deepcopy()\n", + " new_model.fsig.f = 1\n", + " new_model.add(SignalGenerator(\"darmx\", new_model.space_NI_NE.h, 1, 0))\n", + " new_model.add(SignalGenerator(\"darmy\", new_model.space_WI_WE.h, 1, 180))\n", + " new_model.add(QuantumNoiseDetector(\"NSR_with_RP\", new_model.SR.p2.o, True))\n", + " return new_model.run(Xaxis(new_model.get(\"fsig.f\"), \"log\", start, stop, nb))\n", + "\n", + "\n", + "model._settings.phase_config.zero_k00 = False\n", + "\n", + "solution = get_QNLS(model, 5, 5000, 10000)\n", + "\n", + "\n", + "def dumb_parse(value: str = \"\"):\n", + " regex = re.compile(\"\\\\((\\\\d+\\\\.\\\\d+e[+-]\\\\d{2})([+-]\\\\d+\\\\.\\\\d+e[+-]\\\\d{2})j\\\\)\")\n", + " result = re.search(regex, value)\n", + " if result:\n", + " return float(result.groups()[0]) + 1j * float(result.groups()[1])\n", + " raise Exception(value)\n", + "\n", + "\n", + "QNLS = load(\"finesse-virgo-sensitivity.npy\")\n", + "\n", + "current_O4_sensitivity_ASD = loadtxt(\n", + " \"/home/demagny/data/sensitivity/O4/nominal_reference.txt\"\n", + ")\n", + "high_O5_sensitivity_PSD = loadtxt(\n", + " \"/home/demagny/data/sensitivity/O5/23721_O5HighSensPSD.txt\"\n", + ")\n", + "\n", + "\n", + "Figure = figure()\n", + "_ = Figure.gca().loglog(\n", + " solution.x1, abs(solution[\"NSR_with_RP\"]), label=\"this lock process\"\n", + ")\n", + "_ = Figure.gca().loglog(\n", + " QNLS[0],\n", + " QNLS[1],\n", + " label=\"packaged lock process\",\n", + ")\n", + "_ = Figure.gca().loglog(\n", + " current_O4_sensitivity_ASD[0],\n", + " abs(current_O4_sensitivity_ASD[1]),\n", + " label=\"current nominal sensitivity during O4\",\n", + ")\n", + "# _ = Figure.gca().loglog(high_O5_sensitivity_PSD[:,0], high_O5_sensitivity_PSD[:,1], label = \"high sensitivity projection for O5\")\n", + "_ = Figure.gca().legend()\n", + "Figure.gca().grid(True, \"both\", \"both\")\n", + "show()\n", + "\n", + "solution = model.run(FrequencyResponse(geomspace(5, 10000, 1000), [\"DARM\"], [\"B1.I\"]))\n", + "maximum_amplitude_step: float = max(abs(diff(angle(solution[\"B1.I\", \"DARM\"]))))\n", + "pole_index = round(\n", + " mean(\n", + " where(\n", + " abs(angle(solution[\"B1.I\", \"DARM\"]) + pi / 4) < maximum_amplitude_step * 2\n", + " )\n", + " )\n", + ") # find the index where the curve is the closest to -45°\n", + "console.print(\n", + " \"Le [strong]pôle[/strong] de la fonction de transfert [strong]DARM[/strong] est à [result]{:.1f}[/result] Hz\".format(\n", + " solution.f[pole_index]\n", + " )\n", + ")\n", + "\n", + "table = Table(title=\"Position des différents miroirs\")\n", + "table.add_column(\"miroir\", justify=\"left\", style=\"white\")\n", + "table.add_column(\"offset (°)\", justify=\"left\", style=\"white\")\n", + "table.add_column(\"offset (m)\", justify=\"left\", style=\"white\")\n", + "\n", + "for name in [\n", + " \"NE\",\n", + " \"NE_AR\",\n", + " \"NI\",\n", + " \"NI_AR\",\n", + " \"WE\",\n", + " \"WE_AR\",\n", + " \"WI\",\n", + " \"WI_AR\",\n", + " \"PR\",\n", + " \"PR_AR\",\n", + " \"SR\",\n", + " \"SR_AR\",\n", + "]:\n", + " element: Mirror = model.get(name)\n", + " table.add_row(\n", + " str(element.name),\n", + " str(element.phi.eval()),\n", + " str(element.phi.eval() * model.lambda0 / 180),\n", + " )\n", + "\n", + "console.print(table)" + ] + }, + { + "cell_type": "markdown", + "id": "fd5ff122-8d97-43f2-982a-084ee984b827", + "metadata": {}, + "source": [ + "## Comparaison avec Optickle" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fd3b1078-0fd6-4e1b-9e55-b231d9464bdf", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'loadmat' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[10], line 37\u001b[0m\n\u001b[1;32m 30\u001b[0m in_tf[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDARM\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mrun(\n\u001b[1;32m 31\u001b[0m FrequencyResponse(geomspace(\u001b[38;5;241m5\u001b[39m, \u001b[38;5;241m10000\u001b[39m, \u001b[38;5;241m1000\u001b[39m), [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDARM\u001b[39m\u001b[38;5;124m\"\u001b[39m], [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mB1.I\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[1;32m 32\u001b[0m )\n\u001b[1;32m 34\u001b[0m modelisation_file \u001b[38;5;241m=\u001b[39m Path(\n\u001b[1;32m 35\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/home/demagny/data/simulation/optickle/transfer_function/scatterCoupling_25_8.mat\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 36\u001b[0m )\n\u001b[0;32m---> 37\u001b[0m modelisation_data \u001b[38;5;241m=\u001b[39m \u001b[43mloadmat\u001b[49m(modelisation_file)\n\u001b[1;32m 38\u001b[0m coupling_data: \u001b[38;5;28mdict\u001b[39m[\u001b[38;5;28mstr\u001b[39m, \u001b[38;5;28mlist\u001b[39m[Signal]] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mdict\u001b[39m()\n\u001b[1;32m 39\u001b[0m old_couplings \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSNEB\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSWEB\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSDB1\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n", + "\u001b[0;31mNameError\u001b[0m: name 'loadmat' is not defined" ] } ], "source": [ - "virgo.print_powers()" + "model.SNEB.phi = -45\n", + "model.SWEB.phi = -45\n", + "model.SDB1.phi = 0\n", + "\n", + "quad_tf: dict[str, SeriesSolution] = dict()\n", + "in_tf: dict[str, SeriesSolution] = dict()\n", + "\n", + "for bench_name in [\"SNEB\", \"SWEB\", \"SDB1\"]:\n", + " quad_tf[bench_name] = model.run(\n", + " FrequencyResponse(\n", + " geomspace(5, 10000, 1000), [\"{}_z\".format(bench_name)], [\"B1.I\"]\n", + " )\n", + " )\n", + "\n", + "quad_tf[\"DARM\"] = model.run(\n", + " FrequencyResponse(geomspace(5, 10000, 1000), [\"DARM\"], [\"B1.I\"])\n", + ")\n", + "\n", + "model.SNEB.phi = 0\n", + "model.SWEB.phi = 0\n", + "model.SDB1.phi = 20\n", + "\n", + "for bench_name in [\"SNEB\", \"SWEB\", \"SDB1\"]:\n", + " in_tf[bench_name] = model.run(\n", + " FrequencyResponse(\n", + " geomspace(5, 10000, 1000), [\"{}_z\".format(bench_name)], [\"B1.I\"]\n", + " )\n", + " )\n", + "\n", + "in_tf[\"DARM\"] = model.run(\n", + " FrequencyResponse(geomspace(5, 10000, 1000), [\"DARM\"], [\"B1.I\"])\n", + ")\n", + "\n", + "modelisation_file = Path(\n", + " \"/home/demagny/data/simulation/optickle/transfer_function/scatterCoupling_25_8.mat\"\n", + ")\n", + "modelisation_data = loadmat(modelisation_file)\n", + "coupling_data: dict[str, list[Signal]] = dict()\n", + "old_couplings = [\"SNEB\", \"SWEB\", \"SDB1\"]\n", + "for coupling in old_couplings:\n", + " coupling_data[coupling] = [\n", + " Signal(\n", + " modelisation_data[\"freq\"][0],\n", + " abs(values),\n", + " )\n", + " for values in modelisation_data[\"{}coupling\".format(coupling)]\n", + " ]\n", + "DARMcoupling = Signal(\n", + " modelisation_data[\"freq\"][0],\n", + " modelisation_data[\"DARMmat\"][0],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "be43f8b2-eddf-4dfc-a342-a54017b571f6", + "metadata": {}, + "source": [ + "### En fonction de la phase" ] }, { "cell_type": "code", "execution_count": null, - "id": "2b008181-6475-4c62-a896-9600963db694", + "id": "61c3d4e0-b8bc-48e0-83cd-5675c62feba1", + "metadata": {}, + "outputs": [], + "source": [ + "Figure = figure(figsize=(14, 5))\n", + "_ = Figure.suptitle(\"Comparaison des fonctions de transfert pour DARM\")\n", + "ax = Figure.add_subplot(1, 2, 1)\n", + "_ = ax.loglog(quad_tf[\"DARM\"].f, abs(quad_tf[\"DARM\"][\"B1.I\", \"DARM\"]), label=\"Finesse\")\n", + "_ = ax.loglog(DARMcoupling.x, abs(DARMcoupling.y), label=\"Optickle\")\n", + "_ = ax.set_title(\"En quadrature de phase\")\n", + "_ = ax.legend()\n", + "ax.grid(True, \"both\", \"both\")\n", + "ax = Figure.add_subplot(1, 2, 2)\n", + "_ = ax.loglog(in_tf[\"DARM\"].f, abs(in_tf[\"DARM\"][\"B1.I\", \"DARM\"]), label=\"Finesse\")\n", + "_ = ax.loglog(DARMcoupling.x, abs(DARMcoupling.y), label=\"Optickle\")\n", + "_ = ax.set_title(\"En phase\")\n", + "_ = ax.legend()\n", + "ax.grid(True, \"both\", \"both\")\n", + "\n", + "for bench_name in [\"SNEB\", \"SWEB\", \"SDB1\"]:\n", + " in_index = 0\n", + " if bench_name == \"SDB1\":\n", + " in_index = 1\n", + " quad_index = (1 + in_index) % 2\n", + " Figure = figure(figsize=(14, 5))\n", + " _ = Figure.suptitle(\n", + " \"Comparaison des fonctions de transfert pour {}\".format(bench_name)\n", + " )\n", + " ax = Figure.add_subplot(1, 2, 1)\n", + " _ = ax.loglog(\n", + " quad_tf[bench_name].f,\n", + " abs(quad_tf[bench_name][\"B1.I\", \"{}_z\".format(bench_name)])\n", + " / abs(quad_tf[\"DARM\"][\"B1.I\", \"DARM\"])\n", + " / model.space_NI_NE.L.eval(),\n", + " label=\"Finesse\",\n", + " )\n", + " _ = ax.loglog(\n", + " coupling_data[bench_name][quad_index].x,\n", + " abs(coupling_data[bench_name][quad_index].y),\n", + " label=\"Optickle\",\n", + " )\n", + " _ = ax.set_title(\"En Quadrature de phase\")\n", + " _ = ax.legend()\n", + " ax.grid(True, \"both\", \"both\")\n", + " ax = Figure.add_subplot(1, 2, 2)\n", + " _ = ax.loglog(\n", + " in_tf[bench_name].f,\n", + " abs(in_tf[bench_name][\"B1.I\", \"{}_z\".format(bench_name)])\n", + " / abs(in_tf[\"DARM\"][\"B1.I\", \"DARM\"])\n", + " / model.space_NI_NE.L.eval(),\n", + " label=\"Finesse\",\n", + " )\n", + " _ = ax.loglog(\n", + " coupling_data[bench_name][in_index].x,\n", + " abs(coupling_data[bench_name][in_index].y),\n", + " label=\"Optickle\",\n", + " )\n", + " _ = ax.set_title(\"En phase\")\n", + " _ = ax.legend()\n", + " ax.grid(True, \"both\", \"both\")\n", + " console.print()" + ] + }, + { + "cell_type": "markdown", + "id": "11606546-2606-404c-a75e-6e434d19084b", + "metadata": {}, + "source": [ + "### En fonction de la simulation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88002141-6a42-4ae0-a614-4c2b8dd336ac", + "metadata": {}, + "outputs": [], + "source": [ + "for bench_name in [\"SNEB\", \"SWEB\", \"SDB1\"]:\n", + " in_index = 0\n", + " if bench_name == \"SDB1\":\n", + " in_index = 1\n", + " quad_index = (1 + in_index) % 2\n", + " Figure = figure(figsize=(14, 5))\n", + " _ = Figure.suptitle(\n", + " \"Comparaison des fonctions de transfert pour {}\".format(bench_name)\n", + " )\n", + " ax = Figure.add_subplot(1, 2, 1)\n", + " _ = ax.loglog(\n", + " quad_tf[bench_name].f,\n", + " abs(quad_tf[bench_name][\"B1.I\", \"{}_z\".format(bench_name)])\n", + " / abs(quad_tf[\"DARM\"][\"B1.I\", \"DARM\"])\n", + " / model.space_NI_NE.L.eval(),\n", + " label=\"Quadrature de phase\",\n", + " )\n", + " _ = ax.loglog(\n", + " in_tf[bench_name].f,\n", + " abs(in_tf[bench_name][\"B1.I\", \"{}_z\".format(bench_name)])\n", + " / abs(in_tf[\"DARM\"][\"B1.I\", \"DARM\"])\n", + " / model.space_NI_NE.L.eval(),\n", + " label=\"En phase\",\n", + " )\n", + " _ = ax.set_title(\"Finesse\")\n", + " _ = ax.legend()\n", + " ax.grid(True, \"both\", \"both\")\n", + " ax = Figure.add_subplot(1, 2, 2)\n", + " _ = ax.loglog(\n", + " coupling_data[bench_name][quad_index].x,\n", + " abs(coupling_data[bench_name][quad_index].y),\n", + " label=\"Quadrature de phase\",\n", + " )\n", + " _ = ax.loglog(\n", + " coupling_data[bench_name][in_index].x,\n", + " abs(coupling_data[bench_name][in_index].y),\n", + " label=\"En phase\",\n", + " )\n", + " _ = ax.set_title(\"Optickle\")\n", + " _ = ax.legend()\n", + " ax.grid(True, \"both\", \"both\")\n", + " show()" + ] + }, + { + "cell_type": "markdown", + "id": "0c70d12b-b5ae-44b7-b0d3-6f054b697300", + "metadata": {}, + "source": [ + "### En fonction du module/phase" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb1fd40c-83bb-4dc3-b259-7dd3a08d3b6b", + "metadata": {}, + "outputs": [], + "source": [ + "for bench_name in [\"SNEB\", \"SWEB\", \"SDB1\"]:\n", + " Figure = figure(figsize=(14, 5))\n", + " _ = Figure.suptitle(\n", + " \"Comparaison des fonctions de transfert pour {}\".format(bench_name)\n", + " )\n", + " ax = Figure.add_subplot(1, 2, 1)\n", + " _ = ax.loglog(\n", + " quad_tf[bench_name].f,\n", + " abs(quad_tf[bench_name][\"B1.I\", \"{}_z\".format(bench_name)])\n", + " / abs(quad_tf[\"DARM\"][\"B1.I\", \"DARM\"])\n", + " / model.space_NI_NE.L.eval(),\n", + " label=\"Quadrature de phase\",\n", + " )\n", + " _ = ax.loglog(\n", + " in_tf[bench_name].f,\n", + " abs(in_tf[bench_name][\"B1.I\", \"{}_z\".format(bench_name)])\n", + " / abs(in_tf[\"DARM\"][\"B1.I\", \"DARM\"])\n", + " / model.space_NI_NE.L.eval(),\n", + " label=\"En phase\",\n", + " )\n", + " _ = ax.set_title(\"Module\")\n", + " _ = ax.legend()\n", + " ax.grid(True, \"both\", \"both\")\n", + " ax = Figure.add_subplot(1, 2, 2)\n", + " _ = ax.semilogx(\n", + " quad_tf[bench_name].f,\n", + " angle(quad_tf[bench_name][\"B1.I\", \"{}_z\".format(bench_name)]) * 180 / pi,\n", + " label=\"Quadrature de phase\",\n", + " )\n", + " _ = ax.semilogx(\n", + " in_tf[bench_name].f,\n", + " angle(in_tf[bench_name][\"B1.I\", \"{}_z\".format(bench_name)]) * 180 / pi,\n", + " label=\"En phase\",\n", + " )\n", + " _ = ax.set_title(\"Finesse\")\n", + " _ = ax.legend()\n", + " ax.grid(True, \"both\", \"both\")\n", + " show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4bec97a5-ed7b-4976-a98e-846b9988d8a1", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bbaef9fa-e9f5-45af-af5e-8e695fa5a77f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35322249-57ac-47a4-8fe4-30df71759897", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0eb465dd-cff8-4c12-856b-2612d374dd06", "metadata": {}, "outputs": [], "source": [] diff --git a/pyproject.toml b/pyproject.toml index 6e8ecc8..bba0522 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,12 +6,21 @@ authors = [{ name = "linarphy", email = "augustin.demagny@ligo.org" }] readme = "README.md" requires-python = ">=3.13" dependencies = [ + "astropy>=7.0.1", "basedpyright>=1.27.1", "finesse>=3.0a31", "finesse-virgo>=1.0.9", + "ipympl>=0.9.7", + "ipywidgets>=8.1.5", "jupyter-lsp>=2.2.5", "jupyterlab>=4.3.5", "jupyterlab-code-formatter>=3.0.2", "jupyterlab-lsp>=5.1.0", + "pygraphviz>=1.14", + "rich>=13.9.4", "ruff>=0.9.6", + "science-signal", ] + +[tool.uv.sources] +science-signal = { git = "https://git.linarphy.net/linarphy/science_signal.git" } diff --git a/uv.lock b/uv.lock index 533f924..52b0265 100644 --- a/uv.lock +++ b/uv.lock @@ -70,6 +70,37 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f8/ed/e97229a566617f2ae958a6b13e7cc0f585470eac730a73e9e82c32a3cdd2/arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80", size = 66419 }, ] +[[package]] +name = "astropy" +version = "7.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "astropy-iers-data" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pyerfa" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/45/12/a1c582b3f9df5e2680eae0ed82c8057ae06d6130a1f7a5c0770fa899737e/astropy-7.0.1.tar.gz", hash = "sha256:392feeb443b2437cd4c2e0641a65e0f15ba791e148e9b1e5ed7de7dfcb38e460", size = 7139539 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/f0/b4a484970e6227ea94cacea93d7dbd38bbef9c368e60ef3a6e00fe21d7b8/astropy-7.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:012e4331535dae6f43ddf86295b05e711e1ff6dec7af9d77a887ef08e6cef60d", size = 6574160 }, + { url = "https://files.pythonhosted.org/packages/10/87/cb34793d62e33f97f61f2cec9e4651e8f14786e1810a78fae6e7209b6232/astropy-7.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0785533096b5682148ab79b077ab0e17f254be17c9fa12cb7789b8109044fe95", size = 6497653 }, + { url = "https://files.pythonhosted.org/packages/b0/0c/4e8552bcfc4d12f9e2953f39336c554527261361277968aeada918208285/astropy-7.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5949792533238a601597574ac85599f0fab2db2480e0121c58121d808626698f", size = 10208169 }, + { url = "https://files.pythonhosted.org/packages/9b/a3/33546e62bb936d8dcceb24e7ef7540005c1dfbbe341715b217d2867e7cc2/astropy-7.0.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a367d334b789934b975565be470eb1043b3419508bd8e15a882775925e30d2ce", size = 10295439 }, + { url = "https://files.pythonhosted.org/packages/1b/a8/17246827967f6b4b6f5fa69ae1bb4a6e26370e3eb0d64185da2c3fa3911a/astropy-7.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:43c6dac6454e1056649268e79c3f595ecf079ad762936c6ce5c738ee1cff53de", size = 10319045 }, + { url = "https://files.pythonhosted.org/packages/48/6c/31730227b985744c7a58f7ebad1768f9501b4f1f4923ccd58e6f13fa6308/astropy-7.0.1-cp313-cp313-win32.whl", hash = "sha256:b458e4ac2466cb8bfeb0a9ed1fa7e96a9955d03902c1e5ce4ec8881bdfefaf4a", size = 6362116 }, + { url = "https://files.pythonhosted.org/packages/53/ef/eeeb9eb42cf5a83abf704043fafe04417849997321a20fcd465f32ed4b19/astropy-7.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:8ffb20105eeec84f6bd8bbde4a86686a8f78424c3c46b6021fbf816e40dd8960", size = 6486463 }, +] + +[[package]] +name = "astropy-iers-data" +version = "0.2025.3.24.0.35.32" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/29/f76a6e3704d927a41a88b9c7d428b99ea5106b4c9db0bf529f629913e359/astropy_iers_data-0.2025.3.24.0.35.32.tar.gz", hash = "sha256:4c01603b92800b5a89a2a7418b3f84d66fef3334e8e5af2ec726510db6e1b384", size = 1896659 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/34/f6d78f23d55bf61cc0d45a91dea496bf312c7d83cb8926dc0dc8b0f4c2f9/astropy_iers_data-0.2025.3.24.0.35.32-py3-none-any.whl", hash = "sha256:a9eb0c46a19d055dac53fdb99d91d0117ec5ccfd0033ff0ffcfcac4d4a44a677", size = 1949603 }, +] + [[package]] name = "asttokens" version = "3.0.0" @@ -393,26 +424,38 @@ name = "finesse-simulation-04" version = "0.1.0" source = { virtual = "." } dependencies = [ + { name = "astropy" }, { name = "basedpyright" }, { name = "finesse" }, { name = "finesse-virgo" }, + { name = "ipympl" }, + { name = "ipywidgets" }, { name = "jupyter-lsp" }, { name = "jupyterlab" }, { name = "jupyterlab-code-formatter" }, { name = "jupyterlab-lsp" }, + { name = "pygraphviz" }, + { name = "rich" }, { name = "ruff" }, + { name = "science-signal" }, ] [package.metadata] requires-dist = [ + { name = "astropy", specifier = ">=7.0.1" }, { name = "basedpyright", specifier = ">=1.27.1" }, { name = "finesse", specifier = ">=3.0a31" }, { name = "finesse-virgo", specifier = ">=1.0.9" }, + { name = "ipympl", specifier = ">=0.9.7" }, + { name = "ipywidgets", specifier = ">=8.1.5" }, { name = "jupyter-lsp", specifier = ">=2.2.5" }, { name = "jupyterlab", specifier = ">=4.3.5" }, { name = "jupyterlab-code-formatter", specifier = ">=3.0.2" }, { name = "jupyterlab-lsp", specifier = ">=5.1.0" }, + { name = "pygraphviz", specifier = ">=1.14" }, + { name = "rich", specifier = ">=13.9.4" }, { name = "ruff", specifier = ">=0.9.6" }, + { name = "science-signal", git = "https://git.linarphy.net/linarphy/science_signal.git" }, ] [[package]] @@ -544,6 +587,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/94/5c/368ae6c01c7628438358e6d337c19b05425727fbb221d2a3c4303c372f42/ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5", size = 117173 }, ] +[[package]] +name = "ipympl" +version = "0.9.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipython" }, + { name = "ipywidgets" }, + { name = "matplotlib" }, + { name = "numpy" }, + { name = "pillow" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/39/1b/acd3d481869d614a7acbb831bd9304411eae47b05d7607db989613028788/ipympl-0.9.7.tar.gz", hash = "sha256:3e505a56b6e9a7bfc4d40c1a861a0547adb16820eb67ec79131335dd0a5084f0", size = 58547447 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/6b/21c62f1b2b5e18c6553f7364487dfdf7eb7952b1000a1b7863c1f97819e9/ipympl-0.9.7-py3-none-any.whl", hash = "sha256:3698ee7eaa0b047a7603517d7aa1b71b32118a5f51754cab45ec5d994f67208f", size = 515702 }, +] + [[package]] name = "ipython" version = "8.32.0" @@ -564,6 +624,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e7/e1/f4474a7ecdb7745a820f6f6039dc43c66add40f1bcc66485607d93571af6/ipython-8.32.0-py3-none-any.whl", hash = "sha256:cae85b0c61eff1fc48b0a8002de5958b6528fa9c8defb1894da63f42613708aa", size = 825524 }, ] +[[package]] +name = "ipywidgets" +version = "8.1.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "comm" }, + { name = "ipython" }, + { name = "jupyterlab-widgets" }, + { name = "traitlets" }, + { name = "widgetsnbextension" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c7/4c/dab2a281b07596a5fc220d49827fe6c794c66f1493d7a74f1df0640f2cc5/ipywidgets-8.1.5.tar.gz", hash = "sha256:870e43b1a35656a80c18c9503bbf2d16802db1cb487eec6fab27d683381dde17", size = 116723 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/2d/9c0b76f2f9cc0ebede1b9371b6f317243028ed60b90705863d493bae622e/ipywidgets-8.1.5-py3-none-any.whl", hash = "sha256:3290f526f87ae6e77655555baba4f36681c555b8bdbbff430b70e52c34c86245", size = 139767 }, +] + [[package]] name = "isoduration" version = "20.11.0" @@ -838,6 +914,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/54/09/2032e7d15c544a0e3cd831c51d77a8ca57f7555b2e1b2922142eddb02a84/jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4", size = 59700 }, ] +[[package]] +name = "jupyterlab-widgets" +version = "3.0.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/59/73/fa26bbb747a9ea4fca6b01453aa22990d52ab62dd61384f1ac0dc9d4e7ba/jupyterlab_widgets-3.0.13.tar.gz", hash = "sha256:a2966d385328c1942b683a8cd96b89b8dd82c8b8f81dda902bb2bc06d46f5bed", size = 203556 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/93/858e87edc634d628e5d752ba944c2833133a28fa87bb093e6832ced36a3e/jupyterlab_widgets-3.0.13-py3-none-any.whl", hash = "sha256:e3cda2c233ce144192f1e29914ad522b2f4c40e77214b0cc97377ca3d323db54", size = 214392 }, +] + [[package]] name = "kiwisolver" version = "1.4.8" @@ -874,6 +959,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/4c/fa/be89a49c640930180657482a74970cdcf6f7072c8d2471e1babe17a222dc/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:be4816dc51c8a471749d664161b434912eee82f2ea66bd7628bd14583a833e85", size = 2349213 }, ] +[[package]] +name = "markdown-it-py" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 }, +] + [[package]] name = "markupsafe" version = "3.0.2" @@ -945,6 +1042,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899 }, ] +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 }, +] + [[package]] name = "mistune" version = "3.1.2" @@ -1248,6 +1354,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 }, ] +[[package]] +name = "pyerfa" +version = "2.0.1.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/39/63cc8291b0cf324ae710df41527faf7d331bce573899199d926b3e492260/pyerfa-2.0.1.5.tar.gz", hash = "sha256:17d6b24fe4846c65d5e7d8c362dcb08199dc63b30a236aedd73875cc83e1f6c0", size = 818430 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/d9/3448a57cb5bd19950de6d6ab08bd8fbb3df60baa71726de91d73d76c481b/pyerfa-2.0.1.5-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b282d7c60c4c47cf629c484c17ac504fcb04abd7b3f4dfcf53ee042afc3a5944", size = 341818 }, + { url = "https://files.pythonhosted.org/packages/11/4a/31a363370478b63c6289a34743f2ba2d3ae1bd8223e004d18ab28fb92385/pyerfa-2.0.1.5-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:be1aeb70390dd03a34faf96749d5cabc58437410b4aab7213c512323932427df", size = 329370 }, + { url = "https://files.pythonhosted.org/packages/cb/96/b6210fc624123c8ae13e1eecb68fb75e3f3adff216d95eee1c7b05843e3e/pyerfa-2.0.1.5-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0603e8e1b839327d586c8a627cdc634b795e18b007d84f0cda5500a0908254e", size = 692794 }, + { url = "https://files.pythonhosted.org/packages/e5/e0/050018d855d26d3c0b4a7d1b2ed692be758ce276d8289e2a2b44ba1014a5/pyerfa-2.0.1.5-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e43c7194e3242083f2350b46c09fd4bf8ba1bcc0ebd1460b98fc47fe2389906", size = 738711 }, + { url = "https://files.pythonhosted.org/packages/b9/f5/ff91ee77308793ae32fa1e1de95e9edd4551456dd888b4e87c5938657ca5/pyerfa-2.0.1.5-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:07b80cd70701f5d066b1ac8cce406682cfcd667a1186ec7d7ade597239a6021d", size = 722966 }, + { url = "https://files.pythonhosted.org/packages/2c/56/b22b35c8551d2228ff8d445e63787112927ca13f6dc9e2c04f69d742c95b/pyerfa-2.0.1.5-cp39-abi3-win32.whl", hash = "sha256:d30b9b0df588ed5467e529d851ea324a67239096dd44703125072fd11b351ea2", size = 339955 }, + { url = "https://files.pythonhosted.org/packages/b4/11/97233cf23ad5411ac6f13b1d6ee3888f90ace4f974d9bf9db887aa428912/pyerfa-2.0.1.5-cp39-abi3-win_amd64.whl", hash = "sha256:66292d437dcf75925b694977aa06eb697126e7b86553e620371ed3e48b5e0ad0", size = 349410 }, +] + [[package]] name = "pygments" version = "2.19.1" @@ -1257,6 +1381,12 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 }, ] +[[package]] +name = "pygraphviz" +version = "1.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/ca/823d5c74a73d6b8b08e1f5aea12468ef334f0732c65cbb18df2a7f285c87/pygraphviz-1.14.tar.gz", hash = "sha256:c10df02377f4e39b00ae17c862f4ee7e5767317f1c6b2dfd04cea6acc7fc2bea", size = 106003 } + [[package]] name = "pyparsing" version = "3.2.1" @@ -1423,6 +1553,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242 }, ] +[[package]] +name = "rich" +version = "13.9.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424 }, +] + [[package]] name = "rpds-py" version = "0.22.3" @@ -1482,6 +1625,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e8/a8/d71f44b93e3aa86ae232af1f2126ca7b95c0f515ec135462b3e1f351441c/ruff-0.9.6-py3-none-win_arm64.whl", hash = "sha256:0e2bb706a2be7ddfea4a4af918562fdc1bcb16df255e5fa595bbd800ce322a5a", size = 10177499 }, ] +[[package]] +name = "science-signal" +version = "1.0.0" +source = { git = "https://git.linarphy.net/linarphy/science_signal.git#232494365313d7f1617a1c0ee85a4d491e090fd9" } +dependencies = [ + { name = "numpy" }, + { name = "scipy" }, +] + [[package]] name = "scipy" version = "1.15.2" @@ -1728,6 +1880,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5a/84/44687a29792a70e111c5c477230a72c4b957d88d16141199bf9acb7537a3/websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526", size = 58826 }, ] +[[package]] +name = "widgetsnbextension" +version = "4.0.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/56/fc/238c424fd7f4ebb25f8b1da9a934a3ad7c848286732ae04263661eb0fc03/widgetsnbextension-4.0.13.tar.gz", hash = "sha256:ffcb67bc9febd10234a362795f643927f4e0c05d9342c727b65d2384f8feacb6", size = 1164730 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/02/88b65cc394961a60c43c70517066b6b679738caf78506a5da7b88ffcb643/widgetsnbextension-4.0.13-py3-none-any.whl", hash = "sha256:74b2692e8500525cc38c2b877236ba51d34541e6385eeed5aec15a70f88a6c71", size = 2335872 }, +] + [[package]] name = "wrapt" version = "1.17.2"