Mercurial > public > atmospheric_lidar_ghk / changeset
changeset
2nd order polynomial fits to
Wed, 07 Jul 2021 15:59:31 +0200
- author
- Volker Freudenthaler
- date
- Wed, 07 Jul 2021 15:59:31 +0200
- changeset 51
- 10fb0fc3d79f
- parent 49
- 7c14c9a085ba
- child 52
- 6eb017aeb6fe
2nd order polynomial fits to
- K(LDRCal) and
- LDR-uncertainty max. and min depending on LDRtrue
| GHK_0.9.8e5_Py3.7.py | file | annotate | diff | comparison | revisions | |
| GHK_0.9.8f_Py3.7.py | file | annotate | diff | comparison | revisions | |
| README_2_05.06.2020_141855.md | file | annotate | diff | comparison | revisions | |
| system_settings/optic_input_0.9.8h-PollyXT_Cyprus_532_210429_vf_4.py | file | annotate | diff | comparison | revisions | |
| system_settings/output_optic_input_0.9.8h-PollyXT_Cyprus_532_210429_vf_4_GHK_0.9.8h_Py3.7.dat | file | annotate | diff | comparison | revisions |
--- a/GHK_0.9.8e5_Py3.7.py Wed Jul 07 15:42:30 2021 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,2885 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Copyright 2016, 2019 Volker Freudenthaler - -Licensed under the EUPL, Version 1.1 only (the "Licence"). - -You may not use this work except in compliance with the Licence. -A copy of the licence is distributed with the code. Alternatively, you may obtain -a copy of the Licence at: - -https://joinup.ec.europa.eu/community/eupl/og_page/eupl - -Unless required by applicable law or agreed to in writing, software distributed -under the Licence is distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS -OF ANY KIND, either express or implied. See the Licence for the specific language governing -permissions and limitations under the Licence. - -Equation reference: http://www.atmos-meas-tech-discuss.net/amt-2015-338/amt-2015-338.pdf -With equations code from Appendix C -Python 3.7, seaborn 0.9.0 - -Code description: - -From measured lidar signals we cannot directly determine the desired backscatter coefficient (F11) and the linear depolarization ratio (LDR) -because of the cross talk between the channles and systematic errors of a lidar system. -http://www.atmos-meas-tech-discuss.net/amt-2015-338/amt-2015-338.pdf provides an analytical model for the description of these errors, -with which the measured signals can be corrected. -This code simulates the lidar measurements with "assumed true" model parameters from an input file, and calculates the correction parameters (G,H, and K). -The "assumed true" system parameters are the ones we think are the right ones, but in reality these parameters probably deviate from the assumed truth due to -uncertainties. The uncertainties of the "assumed true" parameters can be described in the input file. Then this code calculates the lidar signals and the -gain ratio eta* with all possible combinations of "errors", which represents the distribution of "possibly real" signals, and "corrects" them with the "assumed true" -GHK parameters (GT0, GR0, HT0, HR0, and K0) to derive finally the distributions of "possibly real" linear depolarization ratios (LDRCorr), -which are plotted for five different input linear depolarization ratios (LDRtrue). The red bars in the plots represent the input values of LDRtrue. -A complication arises from the fact that the correction parameter K = eta*/eta (Eq. 83) can depend on the LDR during the calibration measurement, i.e. LDRcal or aCal -in the code (see e.g. Eqs. (103), (115), and (141); mind the mistake in Eq. (116)). Therefor values of K for LDRcal = 0.004, 0.2, and 0.45 are calculated for -"assumed true" system parameters and printed in the output file behind the GH parameters. The full impact of the LDRcal dependent K can be considered in the error -calculation by specifying a range of possible LDRcal values in the input file. For the real calibration measurements a calibration range with low or no aerosol -content should be chosen, and the default in the input file is a range of LDRcal between 0.004 and 0.014 (i.e. 0.009 +-0.005). - -Tip: In case you run the code with Spyder, all output text and plots can be displayed together in an IPython console, which can be saved as an html file. - -Ver. 0.9.7: includes the random error (signal noise) of the calibration and standard measurements -Changes: - Line 1687 Eta = (TaR * TiR) / (TaT * TiT) - Line 1691 K = Etax / Eta # K of the real system; but correction in Line 1721 with K0 / Etax - should work with nTCalT = nTCalR = 0 -Ver. 0.9.7b: - ToDo: include error due to TCalT und TCalR => determination of NCalT and NCalR etc. in error calculation line 1741ff - combined error loops iNI and INCal for signals -Ver. 0.9.7c: individual error loops for each of the six signals -Ver. 0.9.7c2: different calculation of the signal noise errors -Ver. 0.9.7c3: n.a.different calculation of the signal noise errors -Ver. 0.9.7c4: test to speed up the loops for error calculation by moving them just before the actual calculation: still some code errors -Ver. 0.9.8: - - correct calculation of Eta for cleaned anaylsers considering the combined transmission Eta = (TaT* TiT)(1 + cos2RotaT * DaT * DiT) and (TaR * TiR)(1 + cos2RotaR * DaR * DiR) according to the papers supplement Eqs. (S.10.10.1) ff - - calculation of the PLDR from LDR and BSR, BSR, and LDRm - - ND-filters can be added for the calibration measurements in the transmitted (TCalT) and the reflected path (TCalR) in order to include their uncertainties in the error calculation. -Ver. 0.9.8b: change from "TTa = TiT * TaT" to "TTa = TiT * TaT * ATPT" etc. (compare ver 0.9.8 with 0.9.8b) removes - - the strong Tp dependence of the errors - - the factor 2 in the GH parameters - - see c:\technik\Optik\Polarizers\DepCal\ApplOpt\GH-parameters-190114.odt -Ver. 0.9.8c: includes error of Etax -Ver. 0.9.8d: Eta0, K0 etc in error loop replaced by Eta0y, K0y etc. Changes in signal noise calculations -Ver. 0.9.8e: ambiguous laser spec. DOLP (no discrimination between left and right circular polarisation) replaced by Stokes parameters Qin, Uin -Ver. 0.9.8e2: Added plot of LDRsim, Etax, Etapx, Etamx; LDRCorr and aLDRcorr consistently named -Ver. 0.9.8e3: Change of OutputFile name; Change of Ir and It noise if (CalcFrom0deg) = False; (Different calculation of error contributions tested but not implemented) -Ver. 0.9.8e4: text changed for y=+-1 (see line 274 ff and line 1044 ff -Ver. 0.9.8e5: changed: LDRunCorr = LDRsim / Etax - - ======================================================== -simulation: LDRsim = Ir / It with variable parameters (possible truths) - G,H,Eta,Etax,K - It = TaT * TiT * ATP1 * TiO * TiE * (GT + atrue * HT) - LDRsim = Ir / It -consistency test: is forward simulation and correction consistent? - LDRCorr = (LDRsim / Eta * (GT + HT) - (GR + HR)) / ((GR - HR) - LDRsim / Eta * (GT - HT)) => atrue? -assumed true: G0,H0,Eta0,Etax0,K0 => actual retrievals of LDRCorr - => correct possible truths with assumed true G0,H0,Eta0 - measure: It, Ir, EtaX - LDRunCorr = LDRsim / Etax - correct it with G0,H0,K0: - LDRCorr = (LDRsim / (Etax / K0) * (GT0 + HT0) - (GR0 + HR0)) / ((GR0 - HR0) - LDRsim0 / (Etax / K0) * (GT0 - HT0)) -""" -# Comment: The code might works with Python 2.7 with the help of following line, which enables Python2 to correctly interpret the Python 3 print statements. -from __future__ import print_function -# !/usr/bin/env python3 - -import os -import sys - -from scipy.stats import kurtosis -from scipy.stats import skew -# use: kurtosis(data, fisher=True,bias=False) => 0; skew(data,bias=False) => 0 -# Comment: the seaborn library makes nicer plots, but the code works also without it. -import numpy as np -import matplotlib.pyplot as plt - -try: - import seaborn as sns - - sns_loaded = True -except ImportError: - sns_loaded = False - -# from time import clock # python 2 -from timeit import default_timer as clock - -# from matplotlib.backends.backend_pdf import PdfPages -# pdffile = '{}.pdf'.format('path') -# pp = PdfPages(pdffile) -## pp.savefig can be called multiple times to save to multiple pages -# pp.savefig() -# pp.close() - -from contextlib import contextmanager - -@contextmanager -def redirect_stdout(new_target): - old_target, sys.stdout = sys.stdout, new_target # replace sys.stdout - try: - yield new_target # run some code with the replaced stdout - finally: - sys.stdout.flush() - sys.stdout = old_target # restore to the previous value - -''' -real_raw_input = vars(__builtins__).get('raw_input',input) -''' -try: - import __builtin__ - - input = getattr(__builtin__, 'raw_input') -except (ImportError, AttributeError): - pass - -from distutils.util import strtobool - - -def user_yes_no_query(question): - sys.stdout.write('%s [y/n]\n' % question) - while True: - try: - return strtobool(input().lower()) - except ValueError: - sys.stdout.write('Please respond with \'y\' or \'n\'.\n') - - -# if user_yes_no_query('want to exit?') == 1: sys.exit() - -abspath = os.path.abspath(__file__) -dname = os.path.dirname(abspath) -fname = os.path.basename(abspath) -os.chdir(dname) - -# PrintToOutputFile = True - -sqr05 = 0.5 ** 0.5 - -# ---- Initial definition of variables; the actual values will be read in with exec(open('./optic_input.py').read()) below -# Do you want to calculate the errors? If not, just the GHK-parameters are determined. -Error_Calc = True -LID = "internal" -EID = "internal" -# --- IL Laser IL and +-Uncertainty -Qin, dQin, nQin = 1., 0.0, 0 # second Stokes vector parameter; default 1 => linear polarization -Vin, dVin, nVin = 0., 0.0, 0 # fourth Stokes vector parameter -RotL, dRotL, nRotL = 0.0, 0.0, 1 # alpha; rotation of laser polarization in degrees; default 0 -# IL = 1e5 #photons in the laser beam, including detection efficiency of the telescope, atmodspheric and r^2 attenuation -# --- ME Emitter and +-Uncertainty -DiE, dDiE, nDiE = 0., 0.00, 1 # Diattenuation -TiE = 1. # Unpolarized transmittance -RetE, dRetE, nRetE = 0., 180.0, 0 # Retardance in degrees -RotE, dRotE, nRotE = 0., 0.0, 0 # beta: Rotation of optical element in degrees -# --- MO Receiver Optics including telescope -DiO, dDiO, nDiO = -0.055, 0.003, 1 -TiO = 0.9 -RetO, dRetO, nRetO = 0., 180.0, 2 -RotO, dRotO, nRotO = 0., 0.1, 1 # gamma -# --- PBS MT transmitting path defined with (TS,TP); and +-Uncertainty -TP, dTP, nTP = 0.98, 0.02, 1 -TS, dTS, nTS = 0.001, 0.001, 1 -TiT = 0.5 * (TP + TS) -DiT = (TP - TS) / (TP + TS) -# PolFilter -RetT, dRetT, nRetT = 0., 180., 0 -ERaT, dERaT, nERaT = 0.001, 0.001, 1 -RotaT, dRotaT, nRotaT = 0., 3., 1 -DaT = (1 - ERaT) / (1 + ERaT) -TaT = 0.5 * (1 + ERaT) -# --- PBS MR reflecting path defined with (RS,RP); and +-Uncertainty -RS_RP_depend_on_TS_TP = False -if (RS_RP_depend_on_TS_TP): - RP, dRP, nRP = 1 - TP, 0.0, 0 - RS, dRS, nRS = 1 - TS, 0.0, 0 -else: - RP, dRP, nRP = 0.05, 0.01, 1 - RS, dRS, nRS = 0.98, 0.01, 1 -TiR = 0.5 * (RP + RS) -DiR = (RP - RS) / (RP + RS) -# PolFilter -RetR, dRetR, nRetR = 0., 180., 0 -ERaR, dERaR, nERaR = 0.001, 0.001, 1 -RotaR, dRotaR, nRotaR = 90., 3., 1 -DaR = (1 - ERaR) / (1 + ERaR) -TaR = 0.5 * (1 + ERaR) - -# +++ Orientation of the PBS with respect to the reference plane (see Polarisation-orientation.png and Polarisation-orientation-2.png in /system_settings) -# Y = +1: PBS incidence plane is parallel to reference plane and polarisation in reference plane is finally transmitted. -# Y = -1: PBS incidence plane is perpendicular to reference plane and polarisation in reference plane is finally reflected. -Y = 1. - -# Calibrator = type defined by matrix values -LocC = 4 # location of calibrator: behind laser = 1; behind emitter = 2; before receiver = 3; before PBS = 4 - -# --- Additional attenuation (transmission of the ND-filter) during the calibration -TCalT, dTCalT, nTCalT = 1, 0., 0 # transmitting path; error calc not working yet -TCalR, dTCalR, nTCalR = 1, 0., 0 # reflecting path; error calc not working yet - -# *** signal noise error calculation -# --- number of photon counts in the signal summed up in the calibration range during the calibration measurements -NCalT = 1e6 # default 1e6, assumed the same in +45° and -45° signals -NCalR = 1e6 # default 1e6, assumed the same in +45° and -45° signals -NILfac = 1.0 # duration of standard (0°) measurement relative to calibration measurements -nNCal = 0 # error nNCal: one-sigma in steps to left and right for calibration signals -nNI = 0 # error nNI: one-sigma in steps to left and right for 0° signals -NI = 50000 #number of photon counts in the parallel 0°-signal -eFacT = 1.0 # rel. amplification of transmitted channel, approximate values are sufficient; def. = 1 -eFacR = 10.0 -IoutTp0, IoutTp, dIoutTp0 = 0.5, 0.5, 0.0 -IoutTm0, IoutTm, dIoutTm0 = 0.5, 0.5, 0.0 -IoutRp0, IoutRp, dIoutRp0 = 0.5, 0.5, 0.0 -IoutRm0, IoutRm, dIoutRm0 = 0.5, 0.5, 0.0 -It0, It, dIt0 = 1 , 1, 0 -Ir0, Ir, dTr0 = 1 , 1, 0 -CalcFrom0deg = True - -TypeC = 3 # linear polarizer calibrator -# example with extinction ratio 0.001 -DiC, dDiC, nDiC = 1.0, 0., 0 # ideal 1.0 -TiC = 0.5 # ideal 0.5 -RetC, dRetC, nRetC = 0.0, 0.0, 0 -RotC, dRotC, nRotC = 0.0, 0.1, 0 # constant calibrator offset epsilon -RotationErrorEpsilonForNormalMeasurements = False # is in general False for TypeC == 3 calibrator - -# Rotation error without calibrator: if False, then epsilon = 0 for normal measurements -RotationErrorEpsilonForNormalMeasurements = True -# BSR backscatter ratio -# BSR, dBSR, nBSR = 10, 0.05, 1 -BSR = np.zeros(5) -BSR = [1.1, 2, 5, 10., 50.] -# theoretical molecular LDR LDRm -LDRm, dLDRm, nLDRm = 0.004, 0.001, 1 -# LDRCal assumed atmospheric linear depolarization ratio during the calibration measurements (first guess) -LDRCal0, dLDRCal, nLDRCal = 0.25, 0.04, 1 -LDRCal = LDRCal0 -# measured LDRm will be corrected with calculated parameters -LDRmeas = 0.015 -# LDRtrue for simulation of measurement => LDRsim -LDRtrue = 0.004 -LDRtrue2 = 0.004 -LDRunCorr = 1. -# Initialize other values to 0 -ER, nER, dER = 0.001, 0, 0.001 -K = 0. -Km = 0. -Kp = 0. -LDRCorr = 0. -Eta = 0. -Ir = 0. -It = 0. -h = 1. - -Loc = ['', 'behind laser', 'behind emitter', 'before receiver', 'before PBS'] -Type = ['', 'mechanical rotator', 'hwp rotator', 'linear polarizer', 'qwp rotator', 'circular polarizer', - 'real HWP +-22.5°'] - -bPlotEtax = False - -# end of initial definition of variables -# ******************************************************************************************************************************* -# --- Read actual lidar system parameters from optic_input.py (must be in the programs sub-directory 'system_settings') -# ******************************************************************************************************************************* - -# InputFile = 'optic_input_0.9.8e4-PollyXT_Lacros.py' -InputFile = 'optic_input_example_lidar_ver0.9.8e.py' - -# ******************************************************************************************************************************* - -''' -print("From ", dname) -print("Running ", fname) -print("Reading input file ", InputFile, " for") -''' -input_path = os.path.join('.', 'system_settings', InputFile) -# this works with Python 2 and 3! -exec(open(input_path).read(), globals()) -# end of read actual system parameters - - -# --- Manual Parameter Change --- -# (use for quick parameter changes without changing the input file ) -# DiO = 0. -# LDRtrue = 0.45 -# LDRtrue2 = 0.004 -# Y = -1 -# LocC = 4 #location of calibrator: 1 = behind laser; 2 = behind emitter; 3 = before receiver; 4 = before PBS -# #TypeC = 6 Don't change the TypeC here -# RotationErrorEpsilonForNormalMeasurements = True -# LDRCal = 0.25 -# # --- Errors -Qin0, dQin, nQin = Qin, dQin, nQin -Vin0, dVin, nVin = Vin, dVin, nVin -RotL0, dRotL, nRotL = RotL, dRotL, nRotL - -DiE0, dDiE, nDiE = DiE, dDiE, nDiE -RetE0, dRetE, nRetE = RetE, dRetE, nRetE -RotE0, dRotE, nRotE = RotE, dRotE, nRotE - -DiO0, dDiO, nDiO = DiO, dDiO, nDiO -RetO0, dRetO, nRetO = RetO, dRetO, nRetO -RotO0, dRotO, nRotO = RotO, dRotO, nRotO - -DiC0, dDiC, nDiC = DiC, dDiC, nDiC -RetC0, dRetC, nRetC = RetC, dRetC, nRetC -RotC0, dRotC, nRotC = RotC, dRotC, nRotC - -TP0, dTP, nTP = TP, dTP, nTP -TS0, dTS, nTS = TS, dTS, nTS -RetT0, dRetT, nRetT = RetT, dRetT, nRetT - -ERaT0, dERaT, nERaT = ERaT, dERaT, nERaT -RotaT0, dRotaT, nRotaT = RotaT, dRotaT, nRotaT - -RP0, dRP, nRP = RP, dRP, nRP -RS0, dRS, nRS = RS, dRS, nRS -RetR0, dRetR, nRetR = RetR, dRetR, nRetR - -ERaR0, dERaR, nERaR = ERaR, dERaR, nERaR -RotaR0, dRotaR, nRotaR = RotaR, dRotaR, nRotaR - -LDRCal0, dLDRCal, nLDRCal = LDRCal, dLDRCal, nLDRCal - -# BSR0, dBSR, nBSR = BSR, dBSR, nBSR -LDRm0, dLDRm, nLDRm = LDRm, dLDRm, nLDRm -# ---------- End of manual parameter change - -RotL, RotE, RetE, DiE, RotO, RetO, DiO, RotC, RetC, DiC = RotL0, RotE0, RetE0, DiE0, RotO0, RetO0, DiO0, RotC0, RetC0, DiC0 -TP, TS, RP, RS, ERaT, RotaT, RetT, ERaR, RotaR, RetR = TP0, TS0, RP0, RS0, ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0 -LDRCal = LDRCal0 -DTa0, TTa0, DRa0, TRa0, LDRsimx, LDRCorr = 0., 0., 0., 0., 0., 0. -TCalT0, TCalR0 = TCalT, TCalR - -TiT = 0.5 * (TP + TS) -DiT = (TP - TS) / (TP + TS) -ZiT = (1. - DiT ** 2) ** 0.5 -TiR = 0.5 * (RP + RS) -DiR = (RP - RS) / (RP + RS) -ZiR = (1. - DiR ** 2) ** 0.5 - -C2aT = np.cos(np.deg2rad(2. * RotaT)) -C2aR = np.cos(np.deg2rad(2. * RotaR)) -ATPT = float(1. + C2aT * DaT * DiT) -ARPT = float(1. + C2aR * DaR * DiR) -TTa = TiT * TaT * ATPT # unpolarized transmission -TRa = TiR * TaR * ARPT # unpolarized transmission -Eta0 = TRa / TTa - -# --- alternative texts for output -dY = ['perpendicular', '', 'parallel'] -dY2 = ['reflected', '', 'transmitted'] -if ((abs(RotL) < 45 and Y == 1) or (abs(RotL) >= 45 and Y == -1)): - dY3 = "the parallel laser polarisation is detected in the transmitted channel." -else: - dY3 = "the parallel laser polarisation is detected in the reflected channel." - -# --- check input errors -if ((Qin ** 2 + Vin ** 2) ** 0.5) > 1: - print("Error: degree of polarisation of laser > 1. Check Qin and Vin! ") - sys.exit() - -# --- this subroutine is for the calculation of the PLDR from LDR, BSR, and LDRm ------------------- -def CalcPLDR(LDR, BSR, LDRm): - PLDR = (BSR * (1. + LDRm) * LDR - LDRm * (1. + LDR)) / (BSR * (1. + LDRm) - (1. + LDR)) - return (PLDR) -# --- this subroutine is for the calculation with certain fixed parameters ------------------------ -def Calc(TCalT, TCalR, NCalT, NCalR, Qin, Vin, RotL, RotE, RetE, DiE, RotO, RetO, DiO, - RotC, RetC, DiC, TP, TS, RP, RS, - ERaT, RotaT, RetT, ERaR, RotaR, RetR, LDRCal): - # ---- Do the calculations of bra-ket vectors - h = -1. if TypeC == 2 else 1 - # from input file: assumed LDRCal for calibration measurements - aCal = (1. - LDRCal) / (1. + LDRCal) - atrue = (1. - LDRtrue) / (1. + LDRtrue) - - # angles of emitter and laser and calibrator and receiver optics - # RotL = alpha, RotE = beta, RotO = gamma, RotC = epsilon - S2a = np.sin(2 * np.deg2rad(RotL)) - C2a = np.cos(2 * np.deg2rad(RotL)) - S2b = np.sin(2 * np.deg2rad(RotE)) - C2b = np.cos(2 * np.deg2rad(RotE)) - S2ab = np.sin(np.deg2rad(2 * RotL - 2 * RotE)) - C2ab = np.cos(np.deg2rad(2 * RotL - 2 * RotE)) - S2g = np.sin(np.deg2rad(2 * RotO)) - C2g = np.cos(np.deg2rad(2 * RotO)) - - # Laser with Degree of linear polarization DOLP - IinL = 1. - QinL = Qin - UinL = 0. - VinL = Vin - # VinL = (1. - DOLP ** 2) ** 0.5 - - # Stokes Input Vector rotation Eq. E.4 - A = C2a * QinL - S2a * UinL - B = S2a * QinL + C2a * UinL - # Stokes Input Vector rotation Eq. E.9 - C = C2ab * QinL - S2ab * UinL - D = S2ab * QinL + C2ab * UinL - - # emitter optics - CosE = np.cos(np.deg2rad(RetE)) - SinE = np.sin(np.deg2rad(RetE)) - ZiE = (1. - DiE ** 2) ** 0.5 - WiE = (1. - ZiE * CosE) - - # Stokes Input Vector after emitter optics equivalent to Eq. E.9 with already rotated input vector from Eq. E.4 - # b = beta - IinE = (IinL + DiE * C) - QinE = (C2b * DiE * IinL + A + S2b * (WiE * D - ZiE * SinE * VinL)) - UinE = (S2b * DiE * IinL + B - C2b * (WiE * D - ZiE * SinE * VinL)) - VinE = (-ZiE * SinE * D + ZiE * CosE * VinL) - - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - IinF = IinE - QinF = aCal * QinE - UinF = -aCal * UinE - VinF = (1. - 2. * aCal) * VinE - - # receiver optics - CosO = np.cos(np.deg2rad(RetO)) - SinO = np.sin(np.deg2rad(RetO)) - ZiO = (1. - DiO ** 2) ** 0.5 - WiO = (1. - ZiO * CosO) - - # calibrator - CosC = np.cos(np.deg2rad(RetC)) - SinC = np.sin(np.deg2rad(RetC)) - ZiC = (1. - DiC ** 2) ** 0.5 - WiC = (1. - ZiC * CosC) - - # Stokes Input Vector before the polarising beam splitter Eq. E.31 - A = C2g * QinE - S2g * UinE - B = S2g * QinE + C2g * UinE - - IinP = (IinE + DiO * aCal * A) - QinP = (C2g * DiO * IinE + aCal * QinE - S2g * (WiO * aCal * B + ZiO * SinO * (1. - 2. * aCal) * VinE)) - UinP = (S2g * DiO * IinE - aCal * UinE + C2g * (WiO * aCal * B + ZiO * SinO * (1. - 2. * aCal) * VinE)) - VinP = (ZiO * SinO * aCal * B + ZiO * CosO * (1. - 2. * aCal) * VinE) - - # ------------------------- - # F11 assuemd to be = 1 => measured: F11m = IinP / IinE with atrue - # F11sim = TiO*(IinE + DiO*atrue*A)/IinE - # ------------------------- - - # analyser - if (RS_RP_depend_on_TS_TP): - RS = 1. - TS - RP = 1. - TP - - TiT = 0.5 * (TP + TS) - DiT = (TP - TS) / (TP + TS) - ZiT = (1. - DiT ** 2) ** 0.5 - TiR = 0.5 * (RP + RS) - DiR = (RP - RS) / (RP + RS) - ZiR = (1. - DiR ** 2) ** 0.5 - CosT = np.cos(np.deg2rad(RetT)) - SinT = np.sin(np.deg2rad(RetT)) - CosR = np.cos(np.deg2rad(RetR)) - SinR = np.sin(np.deg2rad(RetR)) - - DaT = (1. - ERaT) / (1. + ERaT) - DaR = (1. - ERaR) / (1. + ERaR) - TaT = 0.5 * (1. + ERaT) - TaR = 0.5 * (1. + ERaR) - - S2aT = np.sin(np.deg2rad(h * 2 * RotaT)) - C2aT = np.cos(np.deg2rad(2 * RotaT)) - S2aR = np.sin(np.deg2rad(h * 2 * RotaR)) - C2aR = np.cos(np.deg2rad(2 * RotaR)) - - # Analyzer As before the PBS Eq. D.5; combined PBS and cleaning pol-filter - ATPT = (1. + C2aT * DaT * DiT) # unpolarized transmission correction - TTa = TiT * TaT * ATPT # unpolarized transmission - ATP1 = 1. - ATP2 = Y * (DiT + C2aT * DaT) / ATPT - ATP3 = Y * S2aT * DaT * ZiT * CosT / ATPT - ATP4 = S2aT * DaT * ZiT * SinT / ATPT - ATP = np.array([ATP1, ATP2, ATP3, ATP4]) - DTa = ATP2 * Y - - ARPT = (1 + C2aR * DaR * DiR) # unpolarized transmission correction - TRa = TiR * TaR * ARPT # unpolarized transmission - ARP1 = 1 - ARP2 = Y * (DiR + C2aR * DaR) / ARPT - ARP3 = Y * S2aR * DaR * ZiR * CosR / ARPT - ARP4 = S2aR * DaR * ZiR * SinR / ARPT - ARP = np.array([ARP1, ARP2, ARP3, ARP4]) - DRa = ARP2 * Y - - - # ---- Calculate signals and correction parameters for diffeent locations and calibrators - if LocC == 4: # Calibrator before the PBS - # print("Calibrator location not implemented yet") - - # S2ge = np.sin(np.deg2rad(2*RotO + h*2*RotC)) - # C2ge = np.cos(np.deg2rad(2*RotO + h*2*RotC)) - S2e = np.sin(np.deg2rad(h * 2 * RotC)) - C2e = np.cos(np.deg2rad(2 * RotC)) - # rotated AinP by epsilon Eq. C.3 - ATP2e = C2e * ATP2 + S2e * ATP3 - ATP3e = C2e * ATP3 - S2e * ATP2 - ARP2e = C2e * ARP2 + S2e * ARP3 - ARP3e = C2e * ARP3 - S2e * ARP2 - ATPe = np.array([ATP1, ATP2e, ATP3e, ATP4]) - ARPe = np.array([ARP1, ARP2e, ARP3e, ARP4]) - # Stokes Input Vector before the polarising beam splitter Eq. E.31 - A = C2g * QinE - S2g * UinE - B = S2g * QinE + C2g * UinE - # C = (WiO*aCal*B + ZiO*SinO*(1-2*aCal)*VinE) - Co = ZiO * SinO * VinE - Ca = (WiO * B - 2 * ZiO * SinO * VinE) - # C = Co + aCal*Ca - # IinP = (IinE + DiO*aCal*A) - # QinP = (C2g*DiO*IinE + aCal*QinE - S2g*C) - # UinP = (S2g*DiO*IinE - aCal*UinE + C2g*C) - # VinP = (ZiO*SinO*aCal*B + ZiO*CosO*(1-2*aCal)*VinE) - IinPo = IinE - QinPo = (C2g * DiO * IinE - S2g * Co) - UinPo = (S2g * DiO * IinE + C2g * Co) - VinPo = ZiO * CosO * VinE - - IinPa = DiO * A - QinPa = QinE - S2g * Ca - UinPa = -UinE + C2g * Ca - VinPa = ZiO * (SinO * B - 2 * CosO * VinE) - - IinP = IinPo + aCal * IinPa - QinP = QinPo + aCal * QinPa - UinP = UinPo + aCal * UinPa - VinP = VinPo + aCal * VinPa - # Stokes Input Vector before the polarising beam splitter rotated by epsilon Eq. C.3 - # QinPe = C2e*QinP + S2e*UinP - # UinPe = C2e*UinP - S2e*QinP - QinPoe = C2e * QinPo + S2e * UinPo - UinPoe = C2e * UinPo - S2e * QinPo - QinPae = C2e * QinPa + S2e * UinPa - UinPae = C2e * UinPa - S2e * QinPa - QinPe = C2e * QinP + S2e * UinP - UinPe = C2e * UinP - S2e * QinP - - # Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # rotator calibration Eq. C.4 - # parameters for calibration with aCal - AT = ATP1 * IinP + h * ATP4 * VinP - BT = ATP3e * QinP - h * ATP2e * UinP - AR = ARP1 * IinP + h * ARP4 * VinP - BR = ARP3e * QinP - h * ARP2e * UinP - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATPe, IS1) - GR = np.dot(ARPe, IS1) - HT = np.dot(ATPe, IS2) - HR = np.dot(ARPe, IS2) - elif (TypeC == 3) or (TypeC == 4): # linear polariser calibration Eq. C.5 - # parameters for calibration with aCal - AT = ATP1 * IinP + ATP3e * UinPe + ZiC * CosC * (ATP2e * QinPe + ATP4 * VinP) - BT = DiC * (ATP1 * UinPe + ATP3e * IinP) - ZiC * SinC * (ATP2e * VinP - ATP4 * QinPe) - AR = ARP1 * IinP + ARP3e * UinPe + ZiC * CosC * (ARP2e * QinPe + ARP4 * VinP) - BR = DiC * (ARP1 * UinPe + ARP3e * IinP) - ZiC * SinC * (ARP2e * VinP - ARP4 * QinPe) - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1e = np.array([IinPo + DiC * QinPoe, DiC * IinPo + QinPoe, ZiC * (CosC * UinPoe + SinC * VinPo), - -ZiC * (SinC * UinPoe - CosC * VinPo)]) - IS2e = np.array([IinPa + DiC * QinPae, DiC * IinPa + QinPae, ZiC * (CosC * UinPae + SinC * VinPa), - -ZiC * (SinC * UinPae - CosC * VinPa)]) - GT = np.dot(ATPe, IS1e) - GR = np.dot(ARPe, IS1e) - HT = np.dot(ATPe, IS2e) - HR = np.dot(ARPe, IS2e) - elif (TypeC == 6): # diattenuator calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # parameters for calibration with aCal - AT = ATP1 * IinP + sqr05 * DiC * (ATP1 * QinPe + ATP2e * IinP) + (1. - 0.5 * WiC) * ( - ATP2e * QinPe + ATP3e * UinPe) + ZiC * (sqr05 * SinC * (ATP3e * VinP - ATP4 * UinPe) + ATP4 * CosC * VinP) - BT = sqr05 * DiC * (ATP1 * UinPe + ATP3e * IinP) + 0.5 * WiC * ( - ATP2e * UinPe + ATP3e * QinPe) - sqr05 * ZiC * SinC * (ATP2e * VinP - ATP4 * QinPe) - AR = ARP1 * IinP + sqr05 * DiC * (ARP1 * QinPe + ARP2e * IinP) + (1. - 0.5 * WiC) * ( - ARP2e * QinPe + ARP3e * UinPe) + ZiC * (sqr05 * SinC * (ARP3e * VinP - ARP4 * UinPe) + ARP4 * CosC * VinP) - BR = sqr05 * DiC * (ARP1 * UinPe + ARP3e * IinP) + 0.5 * WiC * ( - ARP2e * UinPe + ARP3e * QinPe) - sqr05 * ZiC * SinC * (ARP2e * VinP - ARP4 * QinPe) - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1e = np.array([IinPo + DiC * QinPoe, DiC * IinPo + QinPoe, ZiC * (CosC * UinPoe + SinC * VinPo), - -ZiC * (SinC * UinPoe - CosC * VinPo)]) - IS2e = np.array([IinPa + DiC * QinPae, DiC * IinPa + QinPae, ZiC * (CosC * UinPae + SinC * VinPa), - -ZiC * (SinC * UinPae - CosC * VinPa)]) - GT = np.dot(ATPe, IS1e) - GR = np.dot(ARPe, IS1e) - HT = np.dot(ATPe, IS2e) - HR = np.dot(ARPe, IS2e) - else: - print("Calibrator not implemented yet") - sys.exit() - - elif LocC == 3: # C before receiver optics Eq.57 - - # S2ge = np.sin(np.deg2rad(2*RotO - 2*RotC)) - # C2ge = np.cos(np.deg2rad(2*RotO - 2*RotC)) - S2e = np.sin(np.deg2rad(2. * RotC)) - C2e = np.cos(np.deg2rad(2. * RotC)) - - # As with C before the receiver optics (rotated_diattenuator_X22x5deg.odt) - AF1 = np.array([1., C2g * DiO, S2g * DiO, 0.]) - AF2 = np.array([C2g * DiO, 1. - S2g ** 2 * WiO, S2g * C2g * WiO, -S2g * ZiO * SinO]) - AF3 = np.array([S2g * DiO, S2g * C2g * WiO, 1. - C2g ** 2 * WiO, C2g * ZiO * SinO]) - AF4 = np.array([0., S2g * SinO, -C2g * SinO, CosO]) - - ATF = (ATP1 * AF1 + ATP2 * AF2 + ATP3 * AF3 + ATP4 * AF4) - ARF = (ARP1 * AF1 + ARP2 * AF2 + ARP3 * AF3 + ARP4 * AF4) - ATF2 = ATF[1] - ATF3 = ATF[2] - ARF2 = ARF[1] - ARF3 = ARF[2] - - # rotated AinF by epsilon - ATF1 = ATF[0] - ATF4 = ATF[3] - ATF2e = C2e * ATF[1] + S2e * ATF[2] - ATF3e = C2e * ATF[2] - S2e * ATF[1] - ARF1 = ARF[0] - ARF4 = ARF[3] - ARF2e = C2e * ARF[1] + S2e * ARF[2] - ARF3e = C2e * ARF[2] - S2e * ARF[1] - - ATFe = np.array([ATF1, ATF2e, ATF3e, ATF4]) - ARFe = np.array([ARF1, ARF2e, ARF3e, ARF4]) - - QinEe = C2e * QinE + S2e * UinE - UinEe = C2e * UinE - S2e * QinE - - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - IinF = IinE - QinF = aCal * QinE - UinF = -aCal * UinE - VinF = (1. - 2. * aCal) * VinE - - IinFo = IinE - QinFo = 0. - UinFo = 0. - VinFo = VinE - - IinFa = 0. - QinFa = QinE - UinFa = -UinE - VinFa = -2. * VinE - - # Stokes Input Vector before receiver optics rotated by epsilon Eq. C.3 - QinFe = C2e * QinF + S2e * UinF - UinFe = C2e * UinF - S2e * QinF - QinFoe = C2e * QinFo + S2e * UinFo - UinFoe = C2e * UinFo - S2e * QinFo - QinFae = C2e * QinFa + S2e * UinFa - UinFae = C2e * UinFa - S2e * QinFa - - # Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # rotator calibration Eq. C.4 - # parameters for calibration with aCal - AT = ATF1 * IinF + ATF4 * h * VinF - BT = ATF3e * QinF - ATF2e * h * UinF - AR = ARF1 * IinF + ARF4 * h * VinF - BR = ARF3e * QinF - ARF2e * h * UinF - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - GT = ATF1 * IinE + ATF4 * VinE - GR = ARF1 * IinE + ARF4 * VinE - HT = ATF2 * QinE - ATF3 * UinE - ATF4 * 2 * VinE - HR = ARF2 * QinE - ARF3 * UinE - ARF4 * 2 * VinE - else: - GT = ATF1 * IinE + ATF4 * h * VinE - GR = ARF1 * IinE + ARF4 * h * VinE - HT = ATF2e * QinE - ATF3e * h * UinE - ATF4 * h * 2 * VinE - HR = ARF2e * QinE - ARF3e * h * UinE - ARF4 * h * 2 * VinE - elif (TypeC == 3) or (TypeC == 4): # linear polariser calibration Eq. C.5 - # p = +45°, m = -45° - IF1e = np.array([IinF, ZiC * CosC * QinFe, UinFe, ZiC * CosC * VinF]) - IF2e = np.array([DiC * UinFe, -ZiC * SinC * VinF, DiC * IinF, ZiC * SinC * QinFe]) - AT = np.dot(ATFe, IF1e) - AR = np.dot(ARFe, IF1e) - BT = np.dot(ATFe, IF2e) - BR = np.dot(ARFe, IF2e) - - # Correction parameters for normal measurements; they are independent of LDR --- the same as for TypeC = 6 - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinE, 0., 0., VinE]) - IS2 = np.array([0., QinE, -UinE, -2. * VinE]) - GT = np.dot(ATF, IS1) - GR = np.dot(ARF, IS1) - HT = np.dot(ATF, IS2) - HR = np.dot(ARF, IS2) - else: - IS1e = np.array([IinFo + DiC * QinFoe, DiC * IinFo + QinFoe, ZiC * (CosC * UinFoe + SinC * VinFo), - -ZiC * (SinC * UinFoe - CosC * VinFo)]) - IS2e = np.array([IinFa + DiC * QinFae, DiC * IinFa + QinFae, ZiC * (CosC * UinFae + SinC * VinFa), - -ZiC * (SinC * UinFae - CosC * VinFa)]) - GT = np.dot(ATFe, IS1e) - GR = np.dot(ARFe, IS1e) - HT = np.dot(ATFe, IS2e) - HR = np.dot(ARFe, IS2e) - - elif (TypeC == 6): # diattenuator calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # parameters for calibration with aCal - IF1e = np.array([IinF + sqr05 * DiC * QinFe, sqr05 * DiC * IinF + (1. - 0.5 * WiC) * QinFe, - (1. - 0.5 * WiC) * UinFe + sqr05 * ZiC * SinC * VinF, - -sqr05 * ZiC * SinC * UinFe + ZiC * CosC * VinF]) - IF2e = np.array([sqr05 * DiC * UinFe, 0.5 * WiC * UinFe - sqr05 * ZiC * SinC * VinF, - sqr05 * DiC * IinF + 0.5 * WiC * QinFe, sqr05 * ZiC * SinC * QinFe]) - AT = np.dot(ATFe, IF1e) - AR = np.dot(ARFe, IF1e) - BT = np.dot(ATFe, IF2e) - BR = np.dot(ARFe, IF2e) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - # IS1 = np.array([IinE,0,0,VinE]) - # IS2 = np.array([0,QinE,-UinE,-2*VinE]) - IS1 = np.array([IinFo, 0., 0., VinFo]) - IS2 = np.array([0., QinFa, UinFa, VinFa]) - GT = np.dot(ATF, IS1) - GR = np.dot(ARF, IS1) - HT = np.dot(ATF, IS2) - HR = np.dot(ARF, IS2) - else: - IS1e = np.array([IinFo + DiC * QinFoe, DiC * IinFo + QinFoe, ZiC * (CosC * UinFoe + SinC * VinFo), - -ZiC * (SinC * UinFoe - CosC * VinFo)]) - IS2e = np.array([IinFa + DiC * QinFae, DiC * IinFa + QinFae, ZiC * (CosC * UinFae + SinC * VinFa), - -ZiC * (SinC * UinFae - CosC * VinFa)]) - # IS1e = np.array([IinFo,0,0,VinFo]) - # IS2e = np.array([0,QinFae,UinFae,VinFa]) - GT = np.dot(ATFe, IS1e) - GR = np.dot(ARFe, IS1e) - HT = np.dot(ATFe, IS2e) - HR = np.dot(ARFe, IS2e) - - else: - print('Calibrator not implemented yet') - sys.exit() - - elif LocC == 2: # C behind emitter optics Eq.57 ------------------------------------------------------- - # print("Calibrator location not implemented yet") - S2e = np.sin(np.deg2rad(2. * RotC)) - C2e = np.cos(np.deg2rad(2. * RotC)) - - # AS with C before the receiver optics (see document rotated_diattenuator_X22x5deg.odt) - AF1 = np.array([1, C2g * DiO, S2g * DiO, 0.]) - AF2 = np.array([C2g * DiO, 1. - S2g ** 2 * WiO, S2g * C2g * WiO, -S2g * ZiO * SinO]) - AF3 = np.array([S2g * DiO, S2g * C2g * WiO, 1. - C2g ** 2 * WiO, C2g * ZiO * SinO]) - AF4 = np.array([0., S2g * SinO, -C2g * SinO, CosO]) - - ATF = (ATP1 * AF1 + ATP2 * AF2 + ATP3 * AF3 + ATP4 * AF4) - ARF = (ARP1 * AF1 + ARP2 * AF2 + ARP3 * AF3 + ARP4 * AF4) - ATF1 = ATF[0] - ATF2 = ATF[1] - ATF3 = ATF[2] - ATF4 = ATF[3] - ARF1 = ARF[0] - ARF2 = ARF[1] - ARF3 = ARF[2] - ARF4 = ARF[3] - - # AS with C behind the emitter - # terms without aCal - ATE1o, ARE1o = ATF1, ARF1 - ATE2o, ARE2o = 0., 0. - ATE3o, ARE3o = 0., 0. - ATE4o, ARE4o = ATF4, ARF4 - # terms with aCal - ATE1a, ARE1a = 0., 0. - ATE2a, ARE2a = ATF2, ARF2 - ATE3a, ARE3a = -ATF3, -ARF3 - ATE4a, ARE4a = -2. * ATF4, -2. * ARF4 - # rotated AinEa by epsilon - ATE2ae = C2e * ATF2 + S2e * ATF3 - ATE3ae = -S2e * ATF2 - C2e * ATF3 - ARE2ae = C2e * ARF2 + S2e * ARF3 - ARE3ae = -S2e * ARF2 - C2e * ARF3 - - ATE1 = ATE1o - ATE2e = aCal * ATE2ae - ATE3e = aCal * ATE3ae - ATE4 = (1 - 2 * aCal) * ATF4 - ARE1 = ARE1o - ARE2e = aCal * ARE2ae - ARE3e = aCal * ARE3ae - ARE4 = (1 - 2 * aCal) * ARF4 - - # rotated IinE - QinEe = C2e * QinE + S2e * UinE - UinEe = C2e * UinE - S2e * QinE - - # Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # +++++++++ rotator calibration Eq. C.4 - AT = ATE1o * IinE + (ATE4o + aCal * ATE4a) * h * VinE - BT = aCal * (ATE3ae * QinEe - ATE2ae * h * UinEe) - AR = ARE1o * IinE + (ARE4o + aCal * ARE4a) * h * VinE - BR = aCal * (ARE3ae * QinEe - ARE2ae * h * UinEe) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - GT = ATE1o * IinE + ATE4o * h * VinE - GR = ARE1o * IinE + ARE4o * h * VinE - HT = ATE2a * QinE + ATE3a * h * UinEe + ATE4a * h * VinE - HR = ARE2a * QinE + ARE3a * h * UinEe + ARE4a * h * VinE - else: - GT = ATE1o * IinE + ATE4o * h * VinE - GR = ARE1o * IinE + ARE4o * h * VinE - HT = ATE2ae * QinE + ATE3ae * h * UinEe + ATE4a * h * VinE - HR = ARE2ae * QinE + ARE3ae * h * UinEe + ARE4a * h * VinE - - elif (TypeC == 3) or (TypeC == 4): # +++++++++ linear polariser calibration Eq. C.5 - # p = +45°, m = -45° - AT = ATE1 * IinE + ZiC * CosC * (ATE2e * QinEe + ATE4 * VinE) + ATE3e * UinEe - BT = DiC * (ATE1 * UinEe + ATE3e * IinE) + ZiC * SinC * (ATE4 * QinEe - ATE2e * VinE) - AR = ARE1 * IinE + ZiC * CosC * (ARE2e * QinEe + ARE4 * VinE) + ARE3e * UinEe - BR = DiC * (ARE1 * UinEe + ARE3e * IinE) + ZiC * SinC * (ARE4 * QinEe - ARE2e * VinE) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - GT = ATE1o * IinE + ATE4o * VinE - GR = ARE1o * IinE + ARE4o * VinE - HT = ATE2a * QinE + ATE3a * UinE + ATE4a * VinE - HR = ARE2a * QinE + ARE3a * UinE + ARE4a * VinE - else: - D = IinE + DiC * QinEe - A = DiC * IinE + QinEe - B = ZiC * (CosC * UinEe + SinC * VinE) - C = -ZiC * (SinC * UinEe - CosC * VinE) - GT = ATE1o * D + ATE4o * C - GR = ARE1o * D + ARE4o * C - HT = ATE2a * A + ATE3a * B + ATE4a * C - HR = ARE2a * A + ARE3a * B + ARE4a * C - - elif (TypeC == 6): # real HWP calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # p = +22.5°, m = -22.5° - IE1e = np.array([IinE + sqr05 * DiC * QinEe, sqr05 * DiC * IinE + (1 - 0.5 * WiC) * QinEe, - (1 - 0.5 * WiC) * UinEe + sqr05 * ZiC * SinC * VinE, - -sqr05 * ZiC * SinC * UinEe + ZiC * CosC * VinE]) - IE2e = np.array([sqr05 * DiC * UinEe, 0.5 * WiC * UinEe - sqr05 * ZiC * SinC * VinE, - sqr05 * DiC * IinE + 0.5 * WiC * QinEe, sqr05 * ZiC * SinC * QinEe]) - ATEe = np.array([ATE1, ATE2e, ATE3e, ATE4]) - AREe = np.array([ARE1, ARE2e, ARE3e, ARE4]) - AT = np.dot(ATEe, IE1e) - AR = np.dot(AREe, IE1e) - BT = np.dot(ATEe, IE2e) - BR = np.dot(AREe, IE2e) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - GT = ATE1o * IinE + ATE4o * VinE - GR = ARE1o * IinE + ARE4o * VinE - HT = ATE2a * QinE + ATE3a * UinE + ATE4a * VinE - HR = ARE2a * QinE + ARE3a * UinE + ARE4a * VinE - else: - D = IinE + DiC * QinEe - A = DiC * IinE + QinEe - B = ZiC * (CosC * UinEe + SinC * VinE) - C = -ZiC * (SinC * UinEe - CosC * VinE) - GT = ATE1o * D + ATE4o * C - GR = ARE1o * D + ARE4o * C - HT = ATE2a * A + ATE3a * B + ATE4a * C - HR = ARE2a * A + ARE3a * B + ARE4a * C - - else: - print('Calibrator not implemented yet') - sys.exit() - - else: - print("Calibrator location not implemented yet") - sys.exit() - - # Determination of the correction K of the calibration factor. - IoutTp = TTa * TiC * TiO * TiE * (AT + BT) - IoutTm = TTa * TiC * TiO * TiE * (AT - BT) - IoutRp = TRa * TiC * TiO * TiE * (AR + BR) - IoutRm = TRa * TiC * TiO * TiE * (AR - BR) - # --- Results and Corrections; electronic etaR and etaT are assumed to be 1 - Etapx = IoutRp / IoutTp - Etamx = IoutRm / IoutTm - Etax = (Etapx * Etamx) ** 0.5 - - Eta = (TRa / TTa) # = TRa / TTa; Eta = Eta*/K Eq. 84 => K = Eta* / Eta; equation corrected according to the papers supplement Eqs. (S.10.10.1) ff - K = Etax / Eta - - # For comparison with Volkers Libreoffice Müller Matrix spreadsheet - # Eta_test_p = (IoutRp/IoutTp) - # Eta_test_m = (IoutRm/IoutTm) - # Eta_test = (Eta_test_p*Eta_test_m)**0.5 - - # ----- random error calculation ---------- - # noise must be calculated with the photon counts of measured signals; - # relative standard deviation of calibration signals with LDRcal; assumed to be statisitcally independent - # normalised noise errors - if (CalcFrom0deg): - dIoutTp = (NCalT * IoutTp) ** -0.5 - dIoutTm = (NCalT * IoutTm) ** -0.5 - dIoutRp = (NCalR * IoutRp) ** -0.5 - dIoutRm = (NCalR * IoutRm) ** -0.5 - else: - dIoutTp = (NCalT ** -0.5) - dIoutTm = (NCalT ** -0.5) - dIoutRp = (NCalR ** -0.5) - dIoutRm = (NCalR ** -0.5) - # Forward simulated 0°-signals with LDRCal with atrue; from input file - - It = TTa * TiO * TiE * (GT + atrue * HT) - Ir = TRa * TiO * TiE * (GR + atrue * HR) - # relative standard deviation of standard signals with LDRmeas; assumed to be statisitcally independent - if (CalcFrom0deg): # this works! - dIt = ((It * NI * eFacT) ** -0.5) - dIr = ((Ir * NI * eFacR) ** -0.5) - ''' - dIt = ((NCalT * It / IoutTp * NILfac / TCalT) ** -0.5) - dIr = ((NCalR * Ir / IoutRp * NILfac / TCalR) ** -0.5) - ''' - else: # does this work? Why not as above? - dIt = ((NCalT * 2 * NILfac / TCalT ) ** -0.5) - dIr = ((NCalR * 2 * NILfac / TCalR) ** -0.5) - - # ----- Forward simulated LDRsim = 1/Eta*Ir/It # simulated LDR* with Y from input file - LDRsim = Ir / It # simulated uncorrected LDR with Y from input file - # Corrected LDRsimCorr from forward simulated LDRsim (atrue) - # LDRsimCorr = (1./Eta*LDRsim*(GT+HT)-(GR+HR))/((GR-HR)-1./Eta*LDRsim*(GT-HT)) - ''' - if ((Y == -1.) and (abs(RotL0) < 45)) or ((Y == +1.) and (abs(RotL0) > 45)): - LDRsimx = 1. / LDRsim / Etax - else: - LDRsimx = LDRsim / Etax - ''' - LDRsimx = LDRsim - - # The following is correct without doubt - # LDRCorr = (LDRsim/(Etax/K)*(GT+HT)-(GR+HR))/((GR-HR)-LDRsim/(Etax/K)*(GT-HT)) - - # The following is a test whether the equations for calibration Etax and normal signal (GHK, LDRsim) are consistent - LDRCorr = (LDRsim / (Etax / K) * (GT + HT) - (GR + HR)) / ((GR - HR) - LDRsim / (Etax / K) * (GT - HT)) - # here we could also use Eta instead of Etax / K => how to test whether Etax is correct? => comparison with MüllerMatrix simulation! - # Without any correction: only measured It, Ir, EtaX are used - LDRunCorr = LDRsim / Etax - # LDRunCorr = (LDRsim / Etax * (GT / abs(GT) + HT / abs(HT)) - (GR / abs(GR) + HR / abs(HR))) / ((GR / abs(GR) - HR / abs(HR)) - LDRsim / Etax * (GT / abs(GT) - HT / abs(HT))) - - #LDRCorr = LDRsimx # for test only - - F11sim = 1 / (TiO * TiE) * ((HR * Eta * It - HT * Ir) / (HR * GT - HT * GR)) # IL = 1, Etat = Etar = 1 ; AMT Eq.64; what is Etax/K? => see about 20 lines above: = Eta - - return (IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr, - GT, HT, GR, HR, K, Eta, LDRsimx, LDRCorr, DTa, DRa, TTa, TRa, F11sim, LDRunCorr) - - - -# ******************************************************************************************************************************* - -# --- CALC with assumed true parameters from the input file -LDRtrue = LDRtrue2 -IoutTp0, IoutTm0, IoutRp0, IoutRm0, It0, Ir0, dIoutTp0, dIoutTm0, dIoutRp0, dIoutRm0, dIt0, dIr0, \ -GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ -Calc(TCalT, TCalR, NCalT, NCalR, Qin0, Vin0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal0) -Etax0 = K0 * Eta0 -Etapx0 = IoutRp0 / IoutTp0 -Etamx0 = IoutRm0 / IoutTm0 -# --- Print parameters to console and output file -OutputFile = 'output_' + InputFile[0:-3] + '_' + fname[0:-3] +'.dat' -with open('output_files\\' + OutputFile, 'w') as f: - with redirect_stdout(f): - print("From ", dname) - print("Running ", fname) - print("Reading input file ", InputFile) # , " for Lidar system :", EID, ", ", LID) - print("for Lidar system: ", EID, ", ", LID) - # --- Print iput information********************************* - print(" --- Input parameters: value ±error / ±steps ----------------------") - print("{0:7}{1:17} {2:6.4f}±{3:7.4f}/{4:2d}".format("Laser: ", "Qin =", Qin0, dQin, nQin)) - print("{0:7}{1:17} {2:6.4f}±{3:7.4f}/{4:2d}".format("", "Vin =", Vin0, dVin, nVin)) - print("{0:7}{1:17} {2:6.4f}±{3:7.4f}/{4:2d}".format("", "Rotation alpha = ", RotL0, dRotL, nRotL)) - print("{0:7}{1:15} {2:8.4f} {3:17}".format("", "=> DOP", ((Qin ** 2 + Vin ** 2) ** 0.5), " (degree of polarisation)")) - - print("Optic: Diatt., Tunpol, Retard., Rotation (deg)") - print("{0:12} {1:7.4f} ±{2:7.4f} /{8:2d}, {3:7.4f}, {4:3.0f}±{5:3.0f}/{9:2d}, {6:7.4f}±{7:7.4f}/{10:2d}".format( - "Emitter ", DiE0, dDiE, TiE, RetE0, dRetE, RotE0, dRotE, nDiE, nRetE, nRotE)) - print("{0:12} {1:7.4f} ±{2:7.4f} /{8:2d}, {3:7.4f}, {4:3.0f}±{5:3.0f}/{9:2d}, {6:7.4f}±{7:7.4f}/{10:2d}".format( - "Receiver ", DiO0, dDiO, TiO, RetO0, dRetO, RotO0, dRotO, nDiO, nRetO, nRotO)) - print("{0:12} {1:9.6f}±{2:9.6f}/{8:2d}, {3:7.4f}, {4:3.0f}±{5:3.0f}/{9:2d}, {6:7.4f}±{7:7.4f}/{10:2d}".format( - "Calibrator ", DiC0, dDiC, TiC, RetC0, dRetC, RotC0, dRotC, nDiC, nRetC, nRotC)) - print("{0:12}".format(" Pol.-filter ------ ")) - print("{0:12}{1:7.4f}±{2:7.4f}/{3:2d}, {4:7.4f}±{5:7.4f}/{6:2d}".format( - "ERT, RotT :", ERaT0, dERaT, nERaT, RotaT0, dRotaT, nRotaT)) - print("{0:12}{1:7.4f}±{2:7.4f}/{3:2d}, {4:7.4f}±{5:7.4f}/{6:2d}".format( - "ERR, RotR :", ERaR0, dERaR, nERaR, RotaR0, dRotaR, nRotaR)) - print("{0:12}".format(" PBS ------ ")) - print("{0:12}{1:7.4f}±{2:7.4f}/{3:2d}, {4:7.4f}±{5:7.4f}/{6:2d}".format( - "TP,TS :", TP0, dTP, nTP, TS0, dTS, nTS)) - print("{0:12}{1:7.4f}±{2:7.4f}/{3:2d}, {4:7.4f}±{5:7.4f}/{6:2d}".format( - "RP,RS :", RP0, dRP, nRP, RS0, dRS, nRS)) - print("{0:12}{1:7.4f},{2:7.4f}, {3:7.4f},{4:7.4f}, {5:1.0f}".format( - "DT,TT,DR,TR,Y :", DiT, TiT, DiR, TiR, Y)) - print("{0:12}".format(" Combined PBS + Pol.-filter ------ ")) - print("{0:12}{1:7.4f},{2:7.4f}, {3:7.4f},{4:7.4f}".format( - "DT,TT,DR,TR :", DTa0, TTa0, DRa0, TRa0)) - print("{0:26}: {1:6.3f}± {2:5.3f}/{3:2d}".format( - "LDRCal during calibration in calibration range", LDRCal0, dLDRCal, nLDRCal)) - print("{0:12}".format(" --- Additional ND filter attenuation (transmission) during the calibration ---")) - print("{0:12}{1:7.4f}±{2:7.4f}/{3:2d}, {4:7.4f}±{5:7.4f}/{6:2d}".format( - "TCalT,TCalR :", TCalT0, dTCalT, nTCalT, TCalR0, dTCalR, nTCalR)) - print() - print(Type[TypeC],"calibrator is located", Loc[LocC]) - print("Rotation error epsilon is considered also for normal measurements = ", RotationErrorEpsilonForNormalMeasurements) - print("The PBS incidence plane is ", dY[int(Y + 1)], "to the reference plane" ) - print("The laser polarisation in the reference plane is finally", dY2[int(Y + 1)], "=>", dY3) - print("RS_RP_depend_on_TS_TP = ", RS_RP_depend_on_TS_TP) - # end of print actual system parameters - # ****************************************************************************** - - - print() - - K0List = np.zeros(7) - LDRsimxList = np.zeros(7) - LDRCalList = 0.0, 0.004, 0.02, 0.1, 0.2, 0.3, 0.45 - # The loop over LDRCalList is ony for checking whether and how much the LDR depends on the LDRCal during calibration and whether the corrections work. - # Still with assumed true parameters in input file - - ''' - facIt = NCalT / TCalT0 * NILfac - facIr = NCalR / TCalR0 * NILfac - ''' - facIt = NI * eFacT - facIr = NI * eFacR - if (bPlotEtax): - # check error signals - # dIs are relative stdevs - print("LDRCal, IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp,dIoutTm,dIoutRp,dIoutRm,dIt, dIr") - - for i, LDRCal in enumerate(LDRCalList): - IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr, \ - GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ - Calc(TCalT0, TCalR0, NCalT, NCalR, Qin0, Vin0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal) - K0List[i] = K0 - LDRsimxList[i] = LDRsimx - - if (bPlotEtax): - # check error signals - print( "{:0.2f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}".format(LDRCal, IoutTp * NCalT, IoutTm * NCalT, IoutRp * NCalR, IoutRm * NCalR, It * facIt, Ir * facIr, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr)) - #print( "{:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}".format(IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr)) - # end check error signals - print('===========================================================================================================') - print("{0:8},{1:8},{2:8},{3:8},{4:9},{5:8},{6:9},{7:9},{8:9},{9:9},{10:9}".format( - " GR", " GT", " HR", " HT", " K(0.000)", " K(0.004)", " K(0.02)", " K(0.1)", " K(0.2)", " K(0.3)", " K(0.45)")) - print("{0:8.5f},{1:8.5f},{2:8.5f},{3:8.5f},{4:9.5f},{5:9.5f},{6:9.5f},{7:9.5f},{8:9.5f},{9:9.5f},{10:9.5f}".format( - GR0, GT0, HR0, HT0, K0List[0], K0List[1], K0List[2], K0List[3], K0List[4], K0List[5], K0List[6])) - print('===========================================================================================================') - print() - print("Errors from neglecting GHK corrections and/or calibration:") - print("{0:>10},{1:>10},{2:>10},{3:>10},{4:>10},{5:>10}".format( - "LDRtrue", "LDRunCorr", "1/LDRunCorr", "LDRsimx", "1/LDRsimx", "LDRCorr")) - - aF11sim0 = np.zeros(5) - LDRrange = np.zeros(5) - LDRsim0 = np.zeros(5) - LDRrange = [0.004, 0.02, 0.1, 0.3, 0.45] # list - LDRrange[0] = LDRtrue2 # value in the input file; default 0.004 - - # The loop over LDRtrueList is only for checking how much the uncorrected LDRsimx deviates from LDRtrue ... and whether the corrections work. - # LDRsimx = LDRsim = Ir / It or 1/LDRsim - # Still with assumed true parameters in input file - for i, LDRtrue in enumerate(LDRrange): - #for LDRtrue in LDRrange: - IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr, \ - GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ - Calc(TCalT0, TCalR0, NCalT, NCalR, Qin0, Vin0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal0) - print("{0:10.5f},{1:10.5f},{2:10.5f},{3:10.5f},{4:10.5f},{5:10.5f}".format(LDRtrue, LDRunCorr, 1/LDRunCorr, LDRsimx, 1/LDRsimx, LDRCorr)) - aF11sim0[i] = F11sim0 - LDRsim0[i] = Ir / It - # the assumed true aF11sim0 results will be used below to calc the deviation from the real signals - print("LDRsimx = LDR of the nominal system directly from measured signals without calibration and GHK-corrections") - print("LDRunCorr = LDR of the nominal system directly from measured signals with calibration but without GHK-corrections; electronic amplifications = 1 assumed") - print("LDRCorr = LDR calibrated and GHK-corrected") - print() - print("Errors from signal noise:") - print("Signal counts: NI, NCalT, NCalR, NILfac, nNCal, nNI, stdev(NI)/NI = {0:10.0f},{1:10.0f},{2:10.0f},{3:3.0f},{4:2.0f},{5:2.0f},{6:8.5f}".format( - NI, NCalT, NCalR, NILfac, nNCal, nNI, 1.0 / NI ** 0.5)) - print() - print() - '''# das muß wieder weg - print("IoutTp, IoutTm, IoutRp, IoutRm, It , Ir , dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr") - LDRCal = 0.01 - for i, LDRtrue in enumerate(LDRrange): - IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr, \ - GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ - Calc(TCalT0, TCalR0, NCalT, NCalR, DOLP0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal0) - print( "{:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}".format( - IoutTp * NCalT, IoutTm * NCalT, IoutRp * NCalR, IoutRm * NCalR, It * facIt, Ir * facIr, - dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr)) - aF11sim0[i] = F11sim0 - # the assumed true aF11sim0 results will be used below to calc the deviation from the real signals - # bis hierher weg - ''' - -file = open('output_files\\' + OutputFile, 'r') -print(file.read()) -file.close() - -# --- CALC again assumed truth with LDRCal0 and with assumed true parameters in input file to reset all 0-values -LDRtrue = LDRtrue2 -IoutTp0, IoutTm0, IoutRp0, IoutRm0, It0, Ir0, dIoutTp0, dIoutTm0, dIoutRp0, dIoutRm0, dIt0, dIr0, \ -GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ -Calc(TCalT0, TCalR0, NCalT, NCalR, Qin0, Vin0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal0) -Etax0 = K0 * Eta0 -Etapx0 = IoutRp0 / IoutTp0 -Etamx0 = IoutRm0 / IoutTm0 -''' -if(PrintToOutputFile): - f = open('output_ver7.dat', 'w') - old_target = sys.stdout - sys.stdout = f - - print("something") - -if(PrintToOutputFile): - sys.stdout.flush() - f.close - sys.stdout = old_target -''' -if (Error_Calc): - # --- CALC again assumed truth with LDRCal0 and with assumed true parameters in input file to reset all 0-values - LDRtrue = LDRtrue2 - IoutTp0, IoutTm0, IoutRp0, IoutRm0, It0, Ir0, dIoutTp0, dIoutTm0, dIoutRp0, dIoutRm0, dIt0, dIr0, \ - GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ - Calc(TCalT0, TCalR0, NCalT, NCalR, Qin0, Vin0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal0) - Etax0 = K0 * Eta0 - Etapx0 = IoutRp0 / IoutTp0 - Etamx0 = IoutRm0 / IoutTm0 - - # --- Start Error calculation with variable parameters ------------------------------------------------------------------ - # error nNCal: one-sigma in steps to left and right for calibration signals - # error nNI: one-sigma in steps to left and right for 0° signals - - iN = -1 - N = ((nTCalT * 2 + 1) * (nTCalR * 2 + 1) * - (nNCal * 2 + 1) ** 4 * (nNI * 2 + 1) ** 2 * - (nQin * 2 + 1) * (nVin * 2 + 1) * (nRotL * 2 + 1) * - (nRotE * 2 + 1) * (nRetE * 2 + 1) * (nDiE * 2 + 1) * - (nRotO * 2 + 1) * (nRetO * 2 + 1) * (nDiO * 2 + 1) * - (nRotC * 2 + 1) * (nRetC * 2 + 1) * (nDiC * 2 + 1) * - (nTP * 2 + 1) * (nTS * 2 + 1) * (nRP * 2 + 1) * (nRS * 2 + 1) * (nERaT * 2 + 1) * (nERaR * 2 + 1) * - (nRotaT * 2 + 1) * (nRotaR * 2 + 1) * (nRetT * 2 + 1) * (nRetR * 2 + 1) * (nLDRCal * 2 + 1)) - print("number of system variations N = ", N, " ", end="") - - if N > 1e6: - if user_yes_no_query('Warning: processing ' + str( - N) + ' samples will take very long. Do you want to proceed?') == 0: sys.exit() - if N > 5e6: - if user_yes_no_query('Warning: the memory required for ' + str(N) + ' samples might be ' + '{0:5.1f}'.format( - N / 4e6) + ' GB. Do you anyway want to proceed?') == 0: sys.exit() - - # if user_yes_no_query('Warning: processing' + str(N) + ' samples will take very long. Do you want to proceed?') == 0: sys.exit() - - # --- Arrays for plotting ------ - LDRmin = np.zeros(5) - LDRmax = np.zeros(5) - LDRstd = np.zeros(5) - LDRmean = np.zeros(5) - LDRmedian = np.zeros(5) - LDRskew = np.zeros(5) - LDRkurt = np.zeros(5) - LDRsimmin = np.zeros(5) - LDRsimmax = np.zeros(5) - LDRsimmean = np.zeros(5) - - F11min = np.zeros(5) - F11max = np.zeros(5) - Etaxmin = np.zeros(5) - Etaxmax = np.zeros(5) - - aQin = np.zeros(N) - aVin = np.zeros(N) - aERaT = np.zeros(N) - aERaR = np.zeros(N) - aRotaT = np.zeros(N) - aRotaR = np.zeros(N) - aRetT = np.zeros(N) - aRetR = np.zeros(N) - aTP = np.zeros(N) - aTS = np.zeros(N) - aRP = np.zeros(N) - aRS = np.zeros(N) - aDiE = np.zeros(N) - aDiO = np.zeros(N) - aDiC = np.zeros(N) - aRotC = np.zeros(N) - aRetC = np.zeros(N) - aRotL = np.zeros(N) - aRetE = np.zeros(N) - aRotE = np.zeros(N) - aRetO = np.zeros(N) - aRotO = np.zeros(N) - aLDRCal = np.zeros(N) - aNCalTp = np.zeros(N) - aNCalTm = np.zeros(N) - aNCalRp = np.zeros(N) - aNCalRm = np.zeros(N) - aNIt = np.zeros(N) - aNIr = np.zeros(N) - aTCalT = np.zeros(N) - aTCalR = np.zeros(N) - - # each np.zeros((LDRrange, N)) array has the same N-dependency - aLDRcorr = np.zeros((5, N)) - aLDRsim = np.zeros((5, N)) - aF11corr = np.zeros((5, N)) - aPLDR = np.zeros((5, N)) - aEtax = np.zeros((5, N)) - aEtapx = np.zeros((5, N)) - aEtamx = np.zeros((5, N)) - - # np.zeros((GHKs, N)) - aGHK = np.zeros((5, N)) - - atime = clock() - dtime = clock() - - # --- Calc Error signals - # ---- Do the calculations of bra-ket vectors - h = -1. if TypeC == 2 else 1 - - for iLDRCal in range(-nLDRCal, nLDRCal + 1): - # from input file: LDRCal for calibration measurements - LDRCal = LDRCal0 - if nLDRCal > 0: - LDRCal = LDRCal0 + iLDRCal * dLDRCal / nLDRCal - # provides the intensities of the calibration measurements at various LDRCal for signal noise errors - # IoutTp, IoutTm, IoutRp, IoutRm, dIoutTp, dIoutTm, dIoutRp, dIoutRm - - aCal = (1. - LDRCal) / (1. + LDRCal) - for iQin, iVin, iRotL, iRotE, iRetE, iDiE \ - in [(iQin, iVin, iRotL, iRotE, iRetE, iDiE) - for iQin in range(-nQin, nQin + 1) - for iVin in range(-nVin, nVin + 1) - for iRotL in range(-nRotL, nRotL + 1) - for iRotE in range(-nRotE, nRotE + 1) - for iRetE in range(-nRetE, nRetE + 1) - for iDiE in range(-nDiE, nDiE + 1)]: - - if nQin > 0: Qin = Qin0 + iQin * dQin / nQin - if nVin > 0: Vin = Vin0 + iVin * dVin / nVin - if nRotL > 0: RotL = RotL0 + iRotL * dRotL / nRotL - if nRotE > 0: RotE = RotE0 + iRotE * dRotE / nRotE - if nRetE > 0: RetE = RetE0 + iRetE * dRetE / nRetE - if nDiE > 0: DiE = DiE0 + iDiE * dDiE / nDiE - - if ((Qin ** 2 + Vin ** 2) ** 0.5) > 1.0: - print("Error: degree of polarisation of laser > 1. Check Qin and Vin! ") - sys.exit() - # angles of emitter and laser and calibrator and receiver optics - # RotL = alpha, RotE = beta, RotO = gamma, RotC = epsilon - S2a = np.sin(2 * np.deg2rad(RotL)) - C2a = np.cos(2 * np.deg2rad(RotL)) - S2b = np.sin(2 * np.deg2rad(RotE)) - C2b = np.cos(2 * np.deg2rad(RotE)) - S2ab = np.sin(np.deg2rad(2 * RotL - 2 * RotE)) - C2ab = np.cos(np.deg2rad(2 * RotL - 2 * RotE)) - - # Laser with Degree of linear polarization DOLP - IinL = 1. - QinL = Qin - UinL = 0. - VinL = Vin - # VinL = (1. - DOLP ** 2) ** 0.5 - - # Stokes Input Vector rotation Eq. E.4 - A = C2a * QinL - S2a * UinL - B = S2a * QinL + C2a * UinL - # Stokes Input Vector rotation Eq. E.9 - C = C2ab * QinL - S2ab * UinL - D = S2ab * QinL + C2ab * UinL - - # emitter optics - CosE = np.cos(np.deg2rad(RetE)) - SinE = np.sin(np.deg2rad(RetE)) - ZiE = (1. - DiE ** 2) ** 0.5 - WiE = (1. - ZiE * CosE) - - # Stokes Input Vector after emitter optics equivalent to Eq. E.9 with already rotated input vector from Eq. E.4 - # b = beta - IinE = (IinL + DiE * C) - QinE = (C2b * DiE * IinL + A + S2b * (WiE * D - ZiE * SinE * VinL)) - UinE = (S2b * DiE * IinL + B - C2b * (WiE * D - ZiE * SinE * VinL)) - VinE = (-ZiE * SinE * D + ZiE * CosE * VinL) - - # ------------------------- - # F11 assuemd to be = 1 => measured: F11m = IinP / IinE with atrue - # F11sim = (IinE + DiO*atrue*(C2g*QinE - S2g*UinE))/IinE - # ------------------------- - - for iRotO, iRetO, iDiO, iRotC, iRetC, iDiC, iTP, iTS, iRP, iRS, iERaT, iRotaT, iRetT, iERaR, iRotaR, iRetR \ - in [ - (iRotO, iRetO, iDiO, iRotC, iRetC, iDiC, iTP, iTS, iRP, iRS, iERaT, iRotaT, iRetT, iERaR, iRotaR, iRetR) - for iRotO in range(-nRotO, nRotO + 1) - for iRetO in range(-nRetO, nRetO + 1) - for iDiO in range(-nDiO, nDiO + 1) - for iRotC in range(-nRotC, nRotC + 1) - for iRetC in range(-nRetC, nRetC + 1) - for iDiC in range(-nDiC, nDiC + 1) - for iTP in range(-nTP, nTP + 1) - for iTS in range(-nTS, nTS + 1) - for iRP in range(-nRP, nRP + 1) - for iRS in range(-nRS, nRS + 1) - for iERaT in range(-nERaT, nERaT + 1) - for iRotaT in range(-nRotaT, nRotaT + 1) - for iRetT in range(-nRetT, nRetT + 1) - for iERaR in range(-nERaR, nERaR + 1) - for iRotaR in range(-nRotaR, nRotaR + 1) - for iRetR in range(-nRetR, nRetR + 1)]: - - if nRotO > 0: RotO = RotO0 + iRotO * dRotO / nRotO - if nRetO > 0: RetO = RetO0 + iRetO * dRetO / nRetO - if nDiO > 0: DiO = DiO0 + iDiO * dDiO / nDiO - if nRotC > 0: RotC = RotC0 + iRotC * dRotC / nRotC - if nRetC > 0: RetC = RetC0 + iRetC * dRetC / nRetC - if nDiC > 0: DiC = DiC0 + iDiC * dDiC / nDiC - if nTP > 0: TP = TP0 + iTP * dTP / nTP - if nTS > 0: TS = TS0 + iTS * dTS / nTS - if nRP > 0: RP = RP0 + iRP * dRP / nRP - if nRS > 0: RS = RS0 + iRS * dRS / nRS - if nERaT > 0: ERaT = ERaT0 + iERaT * dERaT / nERaT - if nRotaT > 0: RotaT = RotaT0 + iRotaT * dRotaT / nRotaT - if nRetT > 0: RetT = RetT0 + iRetT * dRetT / nRetT - if nERaR > 0: ERaR = ERaR0 + iERaR * dERaR / nERaR - if nRotaR > 0: RotaR = RotaR0 + iRotaR * dRotaR / nRotaR - if nRetR > 0: RetR = RetR0 + iRetR * dRetR / nRetR - - # print("{0:5.2f}, {1:5.2f}, {2:5.2f}, {3:10d}".format(RotL, RotE, RotO, iN)) - - # receiver optics - CosO = np.cos(np.deg2rad(RetO)) - SinO = np.sin(np.deg2rad(RetO)) - ZiO = (1. - DiO ** 2) ** 0.5 - WiO = (1. - ZiO * CosO) - S2g = np.sin(np.deg2rad(2 * RotO)) - C2g = np.cos(np.deg2rad(2 * RotO)) - # calibrator - CosC = np.cos(np.deg2rad(RetC)) - SinC = np.sin(np.deg2rad(RetC)) - ZiC = (1. - DiC ** 2) ** 0.5 - WiC = (1. - ZiC * CosC) - - # analyser - # For POLLY_XTs - if (RS_RP_depend_on_TS_TP): - RS = 1.0 - TS - RP = 1.0 - TP - TiT = 0.5 * (TP + TS) - DiT = (TP - TS) / (TP + TS) - ZiT = (1. - DiT ** 2.) ** 0.5 - TiR = 0.5 * (RP + RS) - DiR = (RP - RS) / (RP + RS) - ZiR = (1. - DiR ** 2.) ** 0.5 - CosT = np.cos(np.deg2rad(RetT)) - SinT = np.sin(np.deg2rad(RetT)) - CosR = np.cos(np.deg2rad(RetR)) - SinR = np.sin(np.deg2rad(RetR)) - - # cleaning pol-filter - DaT = (1.0 - ERaT) / (1.0 + ERaT) - DaR = (1.0 - ERaR) / (1.0 + ERaR) - TaT = 0.5 * (1.0 + ERaT) - TaR = 0.5 * (1.0 + ERaR) - - S2aT = np.sin(np.deg2rad(h * 2.0 * RotaT)) - C2aT = np.cos(np.deg2rad(2.0 * RotaT)) - S2aR = np.sin(np.deg2rad(h * 2.0 * RotaR)) - C2aR = np.cos(np.deg2rad(2.0 * RotaR)) - - # Analyzer As before the PBS Eq. D.5; combined PBS and cleaning pol-filter - ATPT = (1 + C2aT * DaT * DiT) # unpolarized transmission correction - TTa = TiT * TaT * ATPT # unpolarized transmission - ATP1 = 1.0 - ATP2 = Y * (DiT + C2aT * DaT) / ATPT - ATP3 = Y * S2aT * DaT * ZiT * CosT / ATPT - ATP4 = S2aT * DaT * ZiT * SinT / ATPT - ATP = np.array([ATP1, ATP2, ATP3, ATP4]) - DTa = ATP2 * Y - - ARPT = (1 + C2aR * DaR * DiR) # unpolarized transmission correction - TRa = TiR * TaR * ARPT # unpolarized transmission - ARP1 = 1 - ARP2 = Y * (DiR + C2aR * DaR) / ARPT - ARP3 = Y * S2aR * DaR * ZiR * CosR / ARPT - ARP4 = S2aR * DaR * ZiR * SinR / ARPT - ARP = np.array([ARP1, ARP2, ARP3, ARP4]) - DRa = ARP2 * Y - - # ---- Calculate signals and correction parameters for diffeent locations and calibrators - if LocC == 4: # Calibrator before the PBS - # print("Calibrator location not implemented yet") - - # S2ge = np.sin(np.deg2rad(2*RotO + h*2*RotC)) - # C2ge = np.cos(np.deg2rad(2*RotO + h*2*RotC)) - S2e = np.sin(np.deg2rad(h * 2 * RotC)) - C2e = np.cos(np.deg2rad(2 * RotC)) - # rotated AinP by epsilon Eq. C.3 - ATP2e = C2e * ATP2 + S2e * ATP3 - ATP3e = C2e * ATP3 - S2e * ATP2 - ARP2e = C2e * ARP2 + S2e * ARP3 - ARP3e = C2e * ARP3 - S2e * ARP2 - ATPe = np.array([ATP1, ATP2e, ATP3e, ATP4]) - ARPe = np.array([ARP1, ARP2e, ARP3e, ARP4]) - # Stokes Input Vector before the polarising beam splitter Eq. E.31 - A = C2g * QinE - S2g * UinE - B = S2g * QinE + C2g * UinE - # C = (WiO*aCal*B + ZiO*SinO*(1-2*aCal)*VinE) - Co = ZiO * SinO * VinE - Ca = (WiO * B - 2 * ZiO * SinO * VinE) - # C = Co + aCal*Ca - # IinP = (IinE + DiO*aCal*A) - # QinP = (C2g*DiO*IinE + aCal*QinE - S2g*C) - # UinP = (S2g*DiO*IinE - aCal*UinE + C2g*C) - # VinP = (ZiO*SinO*aCal*B + ZiO*CosO*(1-2*aCal)*VinE) - IinPo = IinE - QinPo = (C2g * DiO * IinE - S2g * Co) - UinPo = (S2g * DiO * IinE + C2g * Co) - VinPo = ZiO * CosO * VinE - - IinPa = DiO * A - QinPa = QinE - S2g * Ca - UinPa = -UinE + C2g * Ca - VinPa = ZiO * (SinO * B - 2 * CosO * VinE) - - IinP = IinPo + aCal * IinPa - QinP = QinPo + aCal * QinPa - UinP = UinPo + aCal * UinPa - VinP = VinPo + aCal * VinPa - # Stokes Input Vector before the polarising beam splitter rotated by epsilon Eq. C.3 - # QinPe = C2e*QinP + S2e*UinP - # UinPe = C2e*UinP - S2e*QinP - QinPoe = C2e * QinPo + S2e * UinPo - UinPoe = C2e * UinPo - S2e * QinPo - QinPae = C2e * QinPa + S2e * UinPa - UinPae = C2e * UinPa - S2e * QinPa - QinPe = C2e * QinP + S2e * UinP - UinPe = C2e * UinP - S2e * QinP - - # Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # rotator calibration Eq. C.4 - # parameters for calibration with aCal - AT = ATP1 * IinP + h * ATP4 * VinP - BT = ATP3e * QinP - h * ATP2e * UinP - AR = ARP1 * IinP + h * ARP4 * VinP - BR = ARP3e * QinP - h * ARP2e * UinP - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATPe, IS1) - GR = np.dot(ARPe, IS1) - HT = np.dot(ATPe, IS2) - HR = np.dot(ARPe, IS2) - elif (TypeC == 3) or (TypeC == 4): # linear polariser calibration Eq. C.5 - # parameters for calibration with aCal - AT = ATP1 * IinP + ATP3e * UinPe + ZiC * CosC * (ATP2e * QinPe + ATP4 * VinP) - BT = DiC * (ATP1 * UinPe + ATP3e * IinP) - ZiC * SinC * (ATP2e * VinP - ATP4 * QinPe) - AR = ARP1 * IinP + ARP3e * UinPe + ZiC * CosC * (ARP2e * QinPe + ARP4 * VinP) - BR = DiC * (ARP1 * UinPe + ARP3e * IinP) - ZiC * SinC * (ARP2e * VinP - ARP4 * QinPe) - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1e = np.array( - [IinPo + DiC * QinPoe, DiC * IinPo + QinPoe, ZiC * (CosC * UinPoe + SinC * VinPo), - -ZiC * (SinC * UinPoe - CosC * VinPo)]) - IS2e = np.array( - [IinPa + DiC * QinPae, DiC * IinPa + QinPae, ZiC * (CosC * UinPae + SinC * VinPa), - -ZiC * (SinC * UinPae - CosC * VinPa)]) - GT = np.dot(ATPe, IS1e) - GR = np.dot(ARPe, IS1e) - HT = np.dot(ATPe, IS2e) - HR = np.dot(ARPe, IS2e) - elif (TypeC == 6): # diattenuator calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # parameters for calibration with aCal - AT = ATP1 * IinP + sqr05 * DiC * (ATP1 * QinPe + ATP2e * IinP) + (1 - 0.5 * WiC) * ( - ATP2e * QinPe + ATP3e * UinPe) + ZiC * ( - sqr05 * SinC * (ATP3e * VinP - ATP4 * UinPe) + ATP4 * CosC * VinP) - BT = sqr05 * DiC * (ATP1 * UinPe + ATP3e * IinP) + 0.5 * WiC * ( - ATP2e * UinPe + ATP3e * QinPe) - sqr05 * ZiC * SinC * (ATP2e * VinP - ATP4 * QinPe) - AR = ARP1 * IinP + sqr05 * DiC * (ARP1 * QinPe + ARP2e * IinP) + (1 - 0.5 * WiC) * ( - ARP2e * QinPe + ARP3e * UinPe) + ZiC * ( - sqr05 * SinC * (ARP3e * VinP - ARP4 * UinPe) + ARP4 * CosC * VinP) - BR = sqr05 * DiC * (ARP1 * UinPe + ARP3e * IinP) + 0.5 * WiC * ( - ARP2e * UinPe + ARP3e * QinPe) - sqr05 * ZiC * SinC * (ARP2e * VinP - ARP4 * QinPe) - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1e = np.array( - [IinPo + DiC * QinPoe, DiC * IinPo + QinPoe, ZiC * (CosC * UinPoe + SinC * VinPo), - -ZiC * (SinC * UinPoe - CosC * VinPo)]) - IS2e = np.array( - [IinPa + DiC * QinPae, DiC * IinPa + QinPae, ZiC * (CosC * UinPae + SinC * VinPa), - -ZiC * (SinC * UinPae - CosC * VinPa)]) - GT = np.dot(ATPe, IS1e) - GR = np.dot(ARPe, IS1e) - HT = np.dot(ATPe, IS2e) - HR = np.dot(ARPe, IS2e) - else: - print("Calibrator not implemented yet") - sys.exit() - - elif LocC == 3: # C before receiver optics Eq.57 - - # S2ge = np.sin(np.deg2rad(2*RotO - 2*RotC)) - # C2ge = np.cos(np.deg2rad(2*RotO - 2*RotC)) - S2e = np.sin(np.deg2rad(2 * RotC)) - C2e = np.cos(np.deg2rad(2 * RotC)) - - # AS with C before the receiver optics (see document rotated_diattenuator_X22x5deg.odt) - AF1 = np.array([1, C2g * DiO, S2g * DiO, 0]) - AF2 = np.array([C2g * DiO, 1 - S2g ** 2 * WiO, S2g * C2g * WiO, -S2g * ZiO * SinO]) - AF3 = np.array([S2g * DiO, S2g * C2g * WiO, 1 - C2g ** 2 * WiO, C2g * ZiO * SinO]) - AF4 = np.array([0, S2g * SinO, -C2g * SinO, CosO]) - - ATF = (ATP1 * AF1 + ATP2 * AF2 + ATP3 * AF3 + ATP4 * AF4) - ARF = (ARP1 * AF1 + ARP2 * AF2 + ARP3 * AF3 + ARP4 * AF4) - ATF1 = ATF[0] - ATF2 = ATF[1] - ATF3 = ATF[2] - ATF4 = ATF[3] - ARF1 = ARF[0] - ARF2 = ARF[1] - ARF3 = ARF[2] - ARF4 = ARF[3] - - # rotated AinF by epsilon - ATF2e = C2e * ATF[1] + S2e * ATF[2] - ATF3e = C2e * ATF[2] - S2e * ATF[1] - ARF2e = C2e * ARF[1] + S2e * ARF[2] - ARF3e = C2e * ARF[2] - S2e * ARF[1] - - ATFe = np.array([ATF1, ATF2e, ATF3e, ATF4]) - ARFe = np.array([ARF1, ARF2e, ARF3e, ARF4]) - - QinEe = C2e * QinE + S2e * UinE - UinEe = C2e * UinE - S2e * QinE - - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - IinF = IinE - QinF = aCal * QinE - UinF = -aCal * UinE - VinF = (1. - 2. * aCal) * VinE - - IinFo = IinE - QinFo = 0. - UinFo = 0. - VinFo = VinE - - IinFa = 0. - QinFa = QinE - UinFa = -UinE - VinFa = -2. * VinE - - # Stokes Input Vector before receiver optics rotated by epsilon Eq. C.3 - QinFe = C2e * QinF + S2e * UinF - UinFe = C2e * UinF - S2e * QinF - QinFoe = C2e * QinFo + S2e * UinFo - UinFoe = C2e * UinFo - S2e * QinFo - QinFae = C2e * QinFa + S2e * UinFa - UinFae = C2e * UinFa - S2e * QinFa - - # Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # rotator calibration Eq. C.4 - AT = ATF1 * IinF + ATF4 * h * VinF - BT = ATF3e * QinF - ATF2e * h * UinF - AR = ARF1 * IinF + ARF4 * h * VinF - BR = ARF3e * QinF - ARF2e * h * UinF - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - GT = ATF1 * IinE + ATF4 * VinE - GR = ARF1 * IinE + ARF4 * VinE - HT = ATF2 * QinE - ATF3 * UinE - ATF4 * 2 * VinE - HR = ARF2 * QinE - ARF3 * UinE - ARF4 * 2 * VinE - else: - GT = ATF1 * IinE + ATF4 * h * VinE - GR = ARF1 * IinE + ARF4 * h * VinE - HT = ATF2e * QinE - ATF3e * h * UinE - ATF4 * h * 2 * VinE - HR = ARF2e * QinE - ARF3e * h * UinE - ARF4 * h * 2 * VinE - - elif (TypeC == 3) or (TypeC == 4): # linear polariser calibration Eq. C.5 - # p = +45°, m = -45° - IF1e = np.array([IinF, ZiC * CosC * QinFe, UinFe, ZiC * CosC * VinF]) - IF2e = np.array([DiC * UinFe, -ZiC * SinC * VinF, DiC * IinF, ZiC * SinC * QinFe]) - - AT = np.dot(ATFe, IF1e) - AR = np.dot(ARFe, IF1e) - BT = np.dot(ATFe, IF2e) - BR = np.dot(ARFe, IF2e) - - # Correction parameters for normal measurements; they are independent of LDR --- the same as for TypeC = 6 - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinE, 0, 0, VinE]) - IS2 = np.array([0, QinE, -UinE, -2 * VinE]) - - GT = np.dot(ATF, IS1) - GR = np.dot(ARF, IS1) - HT = np.dot(ATF, IS2) - HR = np.dot(ARF, IS2) - else: - IS1e = np.array( - [IinFo + DiC * QinFoe, DiC * IinFo + QinFoe, ZiC * (CosC * UinFoe + SinC * VinFo), - -ZiC * (SinC * UinFoe - CosC * VinFo)]) - IS2e = np.array( - [IinFa + DiC * QinFae, DiC * IinFa + QinFae, ZiC * (CosC * UinFae + SinC * VinFa), - -ZiC * (SinC * UinFae - CosC * VinFa)]) - GT = np.dot(ATFe, IS1e) - GR = np.dot(ARFe, IS1e) - HT = np.dot(ATFe, IS2e) - HR = np.dot(ARFe, IS2e) - - elif (TypeC == 6): # diattenuator calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # p = +22.5°, m = -22.5° - IF1e = np.array([IinF + sqr05 * DiC * QinFe, sqr05 * DiC * IinF + (1 - 0.5 * WiC) * QinFe, - (1 - 0.5 * WiC) * UinFe + sqr05 * ZiC * SinC * VinF, - -sqr05 * ZiC * SinC * UinFe + ZiC * CosC * VinF]) - IF2e = np.array([sqr05 * DiC * UinFe, 0.5 * WiC * UinFe - sqr05 * ZiC * SinC * VinF, - sqr05 * DiC * IinF + 0.5 * WiC * QinFe, sqr05 * ZiC * SinC * QinFe]) - - AT = np.dot(ATFe, IF1e) - AR = np.dot(ARFe, IF1e) - BT = np.dot(ATFe, IF2e) - BR = np.dot(ARFe, IF2e) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - # IS1 = np.array([IinE,0,0,VinE]) - # IS2 = np.array([0,QinE,-UinE,-2*VinE]) - IS1 = np.array([IinFo, 0, 0, VinFo]) - IS2 = np.array([0, QinFa, UinFa, VinFa]) - GT = np.dot(ATF, IS1) - GR = np.dot(ARF, IS1) - HT = np.dot(ATF, IS2) - HR = np.dot(ARF, IS2) - else: - # IS1e = np.array([IinE,DiC*IinE,ZiC*SinC*VinE,ZiC*CosC*VinE]) - # IS2e = np.array([DiC*QinEe,QinEe,-ZiC*(CosC*UinEe+2*SinC*VinE),ZiC*(SinC*UinEe-2*CosC*VinE)]) - IS1e = np.array( - [IinFo + DiC * QinFoe, DiC * IinFo + QinFoe, ZiC * (CosC * UinFoe + SinC * VinFo), - -ZiC * (SinC * UinFoe - CosC * VinFo)]) - IS2e = np.array( - [IinFa + DiC * QinFae, DiC * IinFa + QinFae, ZiC * (CosC * UinFae + SinC * VinFa), - -ZiC * (SinC * UinFae - CosC * VinFa)]) - GT = np.dot(ATFe, IS1e) - GR = np.dot(ARFe, IS1e) - HT = np.dot(ATFe, IS2e) - HR = np.dot(ARFe, IS2e) - - - else: - print('Calibrator not implemented yet') - sys.exit() - - elif LocC == 2: # C behind emitter optics Eq.57 - # print("Calibrator location not implemented yet") - S2e = np.sin(np.deg2rad(2 * RotC)) - C2e = np.cos(np.deg2rad(2 * RotC)) - - # AS with C before the receiver optics (see document rotated_diattenuator_X22x5deg.odt) - AF1 = np.array([1, C2g * DiO, S2g * DiO, 0]) - AF2 = np.array([C2g * DiO, 1 - S2g ** 2 * WiO, S2g * C2g * WiO, -S2g * ZiO * SinO]) - AF3 = np.array([S2g * DiO, S2g * C2g * WiO, 1 - C2g ** 2 * WiO, C2g * ZiO * SinO]) - AF4 = np.array([0, S2g * SinO, -C2g * SinO, CosO]) - - ATF = (ATP1 * AF1 + ATP2 * AF2 + ATP3 * AF3 + ATP4 * AF4) - ARF = (ARP1 * AF1 + ARP2 * AF2 + ARP3 * AF3 + ARP4 * AF4) - ATF1 = ATF[0] - ATF2 = ATF[1] - ATF3 = ATF[2] - ATF4 = ATF[3] - ARF1 = ARF[0] - ARF2 = ARF[1] - ARF3 = ARF[2] - ARF4 = ARF[3] - - # AS with C behind the emitter -------------------------------------------- - # terms without aCal - ATE1o, ARE1o = ATF1, ARF1 - ATE2o, ARE2o = 0., 0. - ATE3o, ARE3o = 0., 0. - ATE4o, ARE4o = ATF4, ARF4 - # terms with aCal - ATE1a, ARE1a = 0., 0. - ATE2a, ARE2a = ATF2, ARF2 - ATE3a, ARE3a = -ATF3, -ARF3 - ATE4a, ARE4a = -2 * ATF4, -2 * ARF4 - # rotated AinEa by epsilon - ATE2ae = C2e * ATF2 + S2e * ATF3 - ATE3ae = -S2e * ATF2 - C2e * ATF3 - ARE2ae = C2e * ARF2 + S2e * ARF3 - ARE3ae = -S2e * ARF2 - C2e * ARF3 - - ATE1 = ATE1o - ATE2e = aCal * ATE2ae - ATE3e = aCal * ATE3ae - ATE4 = (1 - 2 * aCal) * ATF4 - ARE1 = ARE1o - ARE2e = aCal * ARE2ae - ARE3e = aCal * ARE3ae - ARE4 = (1. - 2. * aCal) * ARF4 - - # rotated IinE - QinEe = C2e * QinE + S2e * UinE - UinEe = C2e * UinE - S2e * QinE - - # --- Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # +++++++++ rotator calibration Eq. C.4 - AT = ATE1o * IinE + (ATE4o + aCal * ATE4a) * h * VinE - BT = aCal * (ATE3ae * QinEe - ATE2ae * h * UinEe) - AR = ARE1o * IinE + (ARE4o + aCal * ARE4a) * h * VinE - BR = aCal * (ARE3ae * QinEe - ARE2ae * h * UinEe) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - GT = ATE1o * IinE + ATE4o * h * VinE - GR = ARE1o * IinE + ARE4o * h * VinE - HT = ATE2a * QinE + ATE3a * h * UinEe + ATE4a * h * VinE - HR = ARE2a * QinE + ARE3a * h * UinEe + ARE4a * h * VinE - else: - GT = ATE1o * IinE + ATE4o * h * VinE - GR = ARE1o * IinE + ARE4o * h * VinE - HT = ATE2ae * QinE + ATE3ae * h * UinEe + ATE4a * h * VinE - HR = ARE2ae * QinE + ARE3ae * h * UinEe + ARE4a * h * VinE - - elif (TypeC == 3) or (TypeC == 4): # +++++++++ linear polariser calibration Eq. C.5 - # p = +45°, m = -45° - AT = ATE1 * IinE + ZiC * CosC * (ATE2e * QinEe + ATE4 * VinE) + ATE3e * UinEe - BT = DiC * (ATE1 * UinEe + ATE3e * IinE) + ZiC * SinC * (ATE4 * QinEe - ATE2e * VinE) - AR = ARE1 * IinE + ZiC * CosC * (ARE2e * QinEe + ARE4 * VinE) + ARE3e * UinEe - BR = DiC * (ARE1 * UinEe + ARE3e * IinE) + ZiC * SinC * (ARE4 * QinEe - ARE2e * VinE) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - GT = ATE1o * IinE + ATE4o * VinE - GR = ARE1o * IinE + ARE4o * VinE - HT = ATE2a * QinE + ATE3a * UinE + ATE4a * VinE - HR = ARE2a * QinE + ARE3a * UinE + ARE4a * VinE - else: - D = IinE + DiC * QinEe - A = DiC * IinE + QinEe - B = ZiC * (CosC * UinEe + SinC * VinE) - C = -ZiC * (SinC * UinEe - CosC * VinE) - GT = ATE1o * D + ATE4o * C - GR = ARE1o * D + ARE4o * C - HT = ATE2a * A + ATE3a * B + ATE4a * C - HR = ARE2a * A + ARE3a * B + ARE4a * C - - elif (TypeC == 6): # real HWP calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # p = +22.5°, m = -22.5° - IE1e = np.array([IinE + sqr05 * DiC * QinEe, sqr05 * DiC * IinE + (1 - 0.5 * WiC) * QinEe, - (1. - 0.5 * WiC) * UinEe + sqr05 * ZiC * SinC * VinE, - -sqr05 * ZiC * SinC * UinEe + ZiC * CosC * VinE]) - IE2e = np.array([sqr05 * DiC * UinEe, 0.5 * WiC * UinEe - sqr05 * ZiC * SinC * VinE, - sqr05 * DiC * IinE + 0.5 * WiC * QinEe, sqr05 * ZiC * SinC * QinEe]) - ATEe = np.array([ATE1, ATE2e, ATE3e, ATE4]) - AREe = np.array([ARE1, ARE2e, ARE3e, ARE4]) - AT = np.dot(ATEe, IE1e) - AR = np.dot(AREe, IE1e) - BT = np.dot(ATEe, IE2e) - BR = np.dot(AREe, IE2e) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - GT = ATE1o * IinE + ATE4o * VinE - GR = ARE1o * IinE + ARE4o * VinE - HT = ATE2a * QinE + ATE3a * UinE + ATE4a * VinE - HR = ARE2a * QinE + ARE3a * UinE + ARE4a * VinE - else: - D = IinE + DiC * QinEe - A = DiC * IinE + QinEe - B = ZiC * (CosC * UinEe + SinC * VinE) - C = -ZiC * (SinC * UinEe - CosC * VinE) - GT = ATE1o * D + ATE4o * C - GR = ARE1o * D + ARE4o * C - HT = ATE2a * A + ATE3a * B + ATE4a * C - HR = ARE2a * A + ARE3a * B + ARE4a * C - else: - print('Calibrator not implemented yet') - sys.exit() - - for iTCalT, iTCalR, iNCalTp, iNCalTm, iNCalRp, iNCalRm, iNIt, iNIr \ - in [ - (iTCalT, iTCalR, iNCalTp, iNCalTm, iNCalRp, iNCalRm, iNIt, iNIr) - for iTCalT in range(-nTCalT, nTCalT + 1) # Etax - for iTCalR in range(-nTCalR, nTCalR + 1) # Etax - for iNCalTp in range(-nNCal, nNCal + 1) # noise error of calibration signals => Etax - for iNCalTm in range(-nNCal, nNCal + 1) # noise error of calibration signals => Etax - for iNCalRp in range(-nNCal, nNCal + 1) # noise error of calibration signals => Etax - for iNCalRm in range(-nNCal, nNCal + 1) # noise error of calibration signals => Etax - for iNIt in range(-nNI, nNI + 1) - for iNIr in range(-nNI, nNI + 1)]: - - # Calibration signals with aCal => Determination of the correction K of the real calibration factor - IoutTp = TTa * TiC * TiO * TiE * (AT + BT) - IoutTm = TTa * TiC * TiO * TiE * (AT - BT) - IoutRp = TRa * TiC * TiO * TiE * (AR + BR) - IoutRm = TRa * TiC * TiO * TiE * (AR - BR) - - if nTCalT > 0: TCalT = TCalT0 + iTCalT * dTCalT / nTCalT - if nTCalR > 0: TCalR = TCalR0 + iTCalR * dTCalR / nTCalR - # signal noise errors - # ----- random error calculation ---------- - # noise must be calculated from/with the actually measured signals; influence of TCalT, TCalR errors on noise are not considered ? - # actually measured signal counts are in input file and don't change - # relative standard deviation of calibration signals with LDRcal; assumed to be statisitcally independent - # error nNCal: one-sigma in steps to left and right for calibration signals - if nNCal > 0: - if (CalcFrom0deg): - dIoutTp = (NCalT * IoutTp) ** -0.5 - dIoutTm = (NCalT * IoutTm) ** -0.5 - dIoutRp = (NCalR * IoutRp) ** -0.5 - dIoutRm = (NCalR * IoutRm) ** -0.5 - else: - dIoutTp = dIoutTp0 * (IoutTp / IoutTp0) - dIoutTm = dIoutTm0 * (IoutTm / IoutTm0) - dIoutRp = dIoutRp0 * (IoutRp / IoutRp0) - dIoutRm = dIoutRm0 * (IoutRm / IoutRm0) - # print(iTCalT, iTCalR, iNCalTp, iNCalTm, iNCalRp, iNCalRm, iNIt, iNIr, IoutTp, dIoutTp) - IoutTp = IoutTp * (1. + iNCalTp * dIoutTp / nNCal) - IoutTm = IoutTm * (1. + iNCalTm * dIoutTm / nNCal) - IoutRp = IoutRp * (1. + iNCalRp * dIoutRp / nNCal) - IoutRm = IoutRm * (1. + iNCalRm * dIoutRm / nNCal) - - IoutTp = IoutTp * TCalT / TCalT0 - IoutTm = IoutTm * TCalT / TCalT0 - IoutRp = IoutRp * TCalR / TCalR0 - IoutRm = IoutRm * TCalR / TCalR0 - # --- Results and Corrections; electronic etaR and etaT are assumed to be 1 for true and assumed true systems - # calibration factor - Eta = (TRa / TTa) # = TRa / TTa; Eta = Eta*/K Eq. 84; corrected according to the papers supplement Eqs. (S.10.10.1) ff - # possibly real calibration factor - Etapx = IoutRp / IoutTp - Etamx = IoutRm / IoutTm - Etax = (Etapx * Etamx) ** 0.5 - K = Etax / Eta - # print("{0:6.3f},{1:6.3f},{2:6.3f},{3:6.3f},{4:6.3f},{5:6.3f},{6:6.3f},{7:6.3f},{8:6.3f},{9:6.3f},{10:6.3f}".format(AT, BT, AR, BR, DiC, ZiC, RetO, TP, TS, Kp, Km)) - # print("{0:6.3f},{1:6.3f},{2:6.3f},{3:6.3f}".format(DiC, ZiC, Kp, Km)) - - # For comparison with Volkers Libreoffice Müller Matrix spreadsheet - # Eta_test_p = (IoutRp/IoutTp) - # Eta_test_m = (IoutRm/IoutTm) - # Eta_test = (Eta_test_p*Eta_test_m)**0.5 - ''' - for iIt, iIr \ - in [(iIt, iIr) - for iIt in range(-nNI, nNI + 1) - for iIr in range(-nNI, nNI + 1)]: - ''' - - iN = iN + 1 - if (iN == 10001): - ctime = clock() - print(" estimated time ", "{0:4.2f}".format(N / 10000 * (ctime - atime)), "sec ") # , end="") - print("\r elapsed time ", "{0:5.0f}".format((ctime - atime)), "sec ", end="\r") - ctime = clock() - if ((ctime - dtime) > 10): - print("\r elapsed time ", "{0:5.0f}".format((ctime - atime)), "sec ", end="\r") - dtime = ctime - - # *** loop for different real LDRs ********************************************************************** - iLDR = -1 - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - atrue = (1. - LDRTrue) / (1. + LDRTrue) - # ----- Forward simulated signals and LDRsim with atrue; from input file; not considering TiC. - It = TTa * TiO * TiE * (GT + atrue * HT) # TaT*TiT*TiC*TiO*IinL*(GT+atrue*HT) - Ir = TRa * TiO * TiE * (GR + atrue * HR) # TaR*TiR*TiC*TiO*IinL*(GR+atrue*HR) - # # signal noise errors; standard deviation of signals; assumed to be statisitcally independent - # because the signals depend on LDRtrue, the errors dIt and dIr must be calculated for each LDRtrue - if (CalcFrom0deg): - ''' - dIt = ((NCalT * It / IoutTp * NILfac / TCalT) ** -0.5) - dIr = ((NCalR * Ir / IoutRp * NILfac / TCalR) ** -0.5) - ''' - dIt = ((It * NI * eFacT) ** -0.5) - dIr = ((Ir * NI * eFacR) ** -0.5) - else: - dIt = ((It * NI * eFacT) ** -0.5) - dIr = ((Ir * NI * eFacR) ** -0.5) - ''' - # does this work? Why not as above? - dIt = ((NCalT * 2. * NILfac / TCalT ) ** -0.5) - dIr = ((NCalR * 2. * NILfac / TCalR) ** -0.5) - ''' - # error nNI: one-sigma in steps to left and right for 0° signals - if nNI > 0: - It = It * (1. + iNIt * dIt / nNI) - Ir = Ir * (1. + iNIr * dIr / nNI) - - # LDRsim = 1/Eta*Ir/It # simulated LDR* with Y from input file - LDRsim = Ir / It # simulated uncorrected LDR with Y from input file - - # ----- Backward correction - # Corrected LDRCorr with assumed true G0,H0,K0,Eta0 from forward simulated (real) LDRsim(atrue) - LDRCorr = (LDRsim / (Etax / K0) * (GT0 + HT0) - (GR0 + HR0)) / ((GR0 - HR0) - LDRsim / (Etax / K0) * (GT0 - HT0)) - - # The following is a test whether the equations for calibration Etax and normal signal (GHK, LDRsim) are consistent - # LDRCorr = (LDRsim / Eta * (GT + HT) - (GR + HR)) / ((GR - HR) - LDRsim / Eta * (GT - HT)) - # Without any correction - LDRunCorr = LDRsim / Etax - # LDRunCorr = (LDRsim / Etax * (GT / abs(GT) + HT / abs(HT)) - (GR / abs(GR) + HR / abs(HR))) / ((GR / abs(GR) - HR / abs(HR)) - LDRsim / Etax * (GT / abs(GT) - HT / abs(HT))) - - - ''' - # -- F11corr from It and Ir and calibration EtaX - Text1 = "!!! EXPERIMENTAL !!! F11corr from It and Ir with calibration EtaX: x-axis: F11corr(LDRtrue) / F11corr(LDRtrue = 0.004) - 1" - F11corr = 1 / (TiO * TiE) * ( - (HR0 * Etax / K0 * It / TTa - HT0 * Ir / TRa) / (HR0 * GT0 - HT0 * GR0)) # IL = 1 Eq.(64); Etax/K0 = Eta0. - ''' - # Corrected F11corr with assumed true G0,H0,K0 from forward simulated (real) It and Ir (atrue) - Text1 = "!!! EXPERIMENTAL !!! F11corr from real It and Ir with real calibration EtaX: x-axis: F11corr(LDRtrue) / aF11sim0(LDRtrue) - 1" - F11corr = 1 / (TiO * TiE) * ( - (HR0 * Etax / K0 * It / TTa - HT0 * Ir / TRa) / (HR0 * GT0 - HT0 * GR0)) # IL = 1 Eq.(64); Etax/K0 = Eta0. - - # Text1 = "F11corr from It and Ir without corrections but with calibration EtaX: x-axis: F11corr(LDRtrue) devided by F11corr(LDRtrue = 0.004)" - # F11corr = 0.5/(TiO*TiE)*(Etax*It/TTa+Ir/TRa) # IL = 1 Eq.(64) - - # -- It from It only with atrue without corrections - for BERTHA (and PollyXTs) - # Text1 = " x-axis: IT(LDRtrue) / IT(LDRtrue = 0.004) - 1" - # F11corr = It/(TaT*TiT*TiO*TiE) #/(TaT*TiT*TiO*TiE*(GT0+atrue*HT0)) - # ! see below line 1673ff - - aF11corr[iLDR, iN] = F11corr - aLDRcorr[iLDR, iN] = LDRCorr # LDRCorr # LDRsim # for test only - aLDRsim[iLDR, iN] = LDRsim # LDRCorr # LDRsim # for test only - # aPLDR[iLDR, iN] = CalcPLDR(LDRCorr, BSR[iLDR], LDRm0) - aEtax[iLDR, iN] = Etax - aEtapx[iLDR, iN] = Etapx - aEtamx[iLDR, iN] = Etamx - - aGHK[0, iN] = GR - aGHK[1, iN] = GT - aGHK[2, iN] = HR - aGHK[3, iN] = HT - aGHK[4, iN] = K - - aLDRCal[iN] = iLDRCal - aQin[iN] = iQin - aVin[iN] = iVin - aERaT[iN] = iERaT - aERaR[iN] = iERaR - aRotaT[iN] = iRotaT - aRotaR[iN] = iRotaR - aRetT[iN] = iRetT - aRetR[iN] = iRetR - - aRotL[iN] = iRotL - aRotE[iN] = iRotE - aRetE[iN] = iRetE - aRotO[iN] = iRotO - aRetO[iN] = iRetO - aRotC[iN] = iRotC - aRetC[iN] = iRetC - aDiO[iN] = iDiO - aDiE[iN] = iDiE - aDiC[iN] = iDiC - aTP[iN] = iTP - aTS[iN] = iTS - aRP[iN] = iRP - aRS[iN] = iRS - aTCalT[iN] = iTCalT - aTCalR[iN] = iTCalR - - aNCalTp[iN] = iNCalTp # IoutTp, IoutTm, IoutRp, IoutRm => Etax - aNCalTm[iN] = iNCalTm # IoutTp, IoutTm, IoutRp, IoutRm => Etax - aNCalRp[iN] = iNCalRp # IoutTp, IoutTm, IoutRp, IoutRm => Etax - aNCalRm[iN] = iNCalRm # IoutTp, IoutTm, IoutRp, IoutRm => Etax - aNIt[iN] = iNIt # It, Tr - aNIr[iN] = iNIr # It, Tr - - # --- END loop - btime = clock() - # print("\r done in ", "{0:5.0f}".format(btime - atime), "sec. => producing plots now .... some more seconds ..."), # , end="\r"); - print(" done in ", "{0:5.0f}".format(btime - atime), "sec. => producing plots now .... some more seconds ...") - # --- Plot ----------------------------------------------------------------- - print("Errors from GHK correction uncertainties:") - if (sns_loaded): - sns.set_style("whitegrid") - sns.set_palette("bright6", 6) - # for older seaborn versions use: - # sns.set_palette("bright", 6) - - ''' - fig2 = plt.figure() - plt.plot(aLDRcorr[2,:],'b.') - plt.plot(aLDRcorr[3,:],'r.') - plt.plot(aLDRcorr[4,:],'g.') - #plt.plot(aLDRcorr[6,:],'c.') - plt.show - ''' - - # Plot LDR - def PlotSubHist(aVar, aX, X0, daX, iaX, naX): - # aVar is the name of the parameter and aX is the subset of aLDRcorr which is coloured in the plot - # example: PlotSubHist("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP) - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - LDRmin[iLDR] = np.amin(aLDRcorr[iLDR, :]) - LDRmax[iLDR] = np.amax(aLDRcorr[iLDR, :]) - if (LDRmax[iLDR] > 10): LDRmax[iLDR] = 10 - if (LDRmin[iLDR] < -10): LDRmin[iLDR] = -10 - Rmin = LDRmin[iLDR] * 0.995 # np.min(aLDRcorr[iLDR,:]) * 0.995 - Rmax = LDRmax[iLDR] * 1.005 # np.max(aLDRcorr[iLDR,:]) * 1.005 - - # Determine mean distance of all aXmean from each other for each iLDR - meanDist = 0.0 - for iaX in range(-naX, naX + 1): - # mean LDRCorr value for certain error (iaX) of parameter aVar - aXmean[iaX + naX] = np.mean(aLDRcorr[iLDR, aX == iaX]) - # relative to absolute spread of LDRCorrs - meanDist = (np.max(aXmean) - np.min(aXmean)) / (LDRmax[iLDR] - LDRmin[iLDR]) * 100 - - plt.subplot(1, 5, iLDR + 1) - (n, bins, patches) = plt.hist(aLDRcorr[iLDR, :], - bins=100, log=False, - range=[Rmin, Rmax], - alpha=0.5, density=False, color='0.5', histtype='stepfilled') - - for iaX in range(-naX, naX + 1): - # mean LDRCorr value for certain error (iaX) of parameter aVar - plt.hist(aLDRcorr[iLDR, aX == iaX], - range=[Rmin, Rmax], - bins=100, log=False, alpha=0.3, density=False, histtype='stepfilled', - label=str(round(X0 + iaX * daX / naX, 5))) - - if (iLDR == 2): - leg = plt.legend() - leg.get_frame().set_alpha(0.1) - - plt.tick_params(axis='both', labelsize=10) - plt.plot([LDRTrue, LDRTrue], [0, np.max(n)], 'r-', lw=2) - plt.gca().set_title("{0:3.0f}%".format(meanDist)) - plt.gca().set_xlabel('LDRtrue', color="red") - - # plt.ylabel('frequency', fontsize=10) - # plt.xlabel('LDRCorr', fontsize=10) - # fig.tight_layout() - fig.suptitle(LID + ' with ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar + ' error contribution', fontsize=14, y=1.10) - # plt.show() - # fig.savefig(LID + '_' + aVar + '.png', dpi=150, bbox_inches='tight', pad_inches=0) - # plt.close - return - - def PlotLDRsim(aVar, aX, X0, daX, iaX, naX): - # aVar is the name of the parameter and aX is the subset of aLDRsim which is coloured in the plot - # example: PlotSubHist("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP) - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - LDRsimmin[iLDR] = np.amin(aLDRsim[iLDR, :]) - LDRsimmax[iLDR] = np.amax(aLDRsim[iLDR, :]) - # print("LDRsimmin[iLDR], LDRsimmax[iLDR] = ", LDRsimmin[iLDR], LDRsimmax[iLDR]) - # if (LDRsimmax[iLDR] > 10): LDRsimmax[iLDR] = 10 - # if (LDRsimmin[iLDR] < -10): LDRsimmin[iLDR] = -10 - Rmin = LDRsimmin[iLDR] * 0.995 # np.min(aLDRsim[iLDR,:]) * 0.995 - Rmax = LDRsimmax[iLDR] * 1.005 # np.max(aLDRsim[iLDR,:]) * 1.005 - # print("Rmin, Rmax = ", Rmin, Rmax) - - # Determine mean distance of all aXmean from each other for each iLDR - meanDist = 0.0 - for iaX in range(-naX, naX + 1): - # mean LDRCorr value for certain error (iaX) of parameter aVar - aXmean[iaX + naX] = np.mean(aLDRsim[iLDR, aX == iaX]) - # relative to absolute spread of LDRCorrs - meanDist = (np.max(aXmean) - np.min(aXmean)) / (LDRsimmax[iLDR] - LDRsimmin[iLDR]) * 100 - - plt.subplot(1, 5, iLDR + 1) - (n, bins, patches) = plt.hist(aLDRsim[iLDR, :], - bins=100, log=False, - range=[Rmin, Rmax], - alpha=0.5, density=False, color='0.5', histtype='stepfilled') - - for iaX in range(-naX, naX + 1): - # mean LDRCorr value for certain error (iaX) of parameter aVar - plt.hist(aLDRsim[iLDR, aX == iaX], - range=[Rmin, Rmax], - bins=100, log=False, alpha=0.3, density=False, histtype='stepfilled', - label=str(round(X0 + iaX * daX / naX, 5))) - - if (iLDR == 2): - leg = plt.legend() - leg.get_frame().set_alpha(0.1) - - plt.tick_params(axis='both', labelsize=10) - plt.plot([LDRsim0[iLDR], LDRsim0[iLDR]], [0, np.max(n)], 'r-', lw=2) - plt.gca().set_title("{0:3.0f}%".format(meanDist)) - plt.gca().set_xlabel('LDRsim0', color="red") - - fig.suptitle('LDRsim - ' +LID + ' with ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar + ' error contribution', fontsize=14, y=1.10) - return - - - # Plot Etax - def PlotEtax(aVar, aX, X0, daX, iaX, naX): - # aVar is the name of the parameter and aX is the subset of aLDRcorr which is coloured in the plot - # example: PlotSubHist("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP) - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - Etaxmin = np.amin(aEtax[iLDR, :]) - Etaxmax = np.amax(aEtax[iLDR, :]) - Rmin = Etaxmin * 0.995 # np.min(aLDRcorr[iLDR,:]) * 0.995 - Rmax = Etaxmax * 1.005 # np.max(aLDRcorr[iLDR,:]) * 1.005 - - # Determine mean distance of all aXmean from each other for each iLDR - meanDist = 0.0 - for iaX in range(-naX, naX + 1): - # mean Etax value for certain error (iaX) of parameter aVar - aXmean[iaX + naX] = np.mean(aEtax[iLDR, aX == iaX]) - # relative to absolute spread of Etax - meanDist = (np.max(aXmean) - np.min(aXmean)) / (Etaxmax - Etaxmin) * 100 - - plt.subplot(1, 5, iLDR + 1) - (n, bins, patches) = plt.hist(aEtax[iLDR, :], - bins=50, log=False, - range=[Rmin, Rmax], - alpha=0.5, density=False, color='0.5', histtype='stepfilled') - for iaX in range(-naX, naX + 1): - plt.hist(aEtax[iLDR, aX == iaX], - range=[Rmin, Rmax], - bins=50, log=False, alpha=0.3, density=False, histtype='stepfilled', - label=str(round(X0 + iaX * daX / naX, 5))) - if (iLDR == 2): - leg = plt.legend() - leg.get_frame().set_alpha(0.1) - plt.tick_params(axis='both', labelsize=10) - plt.plot([Etax0, Etax0], [0, np.max(n)], 'r-', lw=2) - plt.gca().set_title("{0:3.0f}%".format(meanDist)) - plt.gca().set_xlabel('Etax0', color="red") - fig.suptitle('Etax - ' + LID + ' with ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar + ' error contribution', fontsize=14, y=1.10) - return - - def PlotEtapx(aVar, aX, X0, daX, iaX, naX): - # aVar is the name of the parameter and aX is the subset of aLDRcorr which is coloured in the plot - # example: PlotSubHist("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP) - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - Etapxmin = np.amin(aEtapx[iLDR, :]) - Etapxmax = np.amax(aEtapx[iLDR, :]) - Rmin = Etapxmin * 0.995 # np.min(aLDRcorr[iLDR,:]) * 0.995 - Rmax = Etapxmax * 1.005 # np.max(aLDRcorr[iLDR,:]) * 1.005 - - # Determine mean distance of all aXmean from each other for each iLDR - meanDist = 0.0 - for iaX in range(-naX, naX + 1): - # mean Etapx value for certain error (iaX) of parameter aVar - aXmean[iaX + naX] = np.mean(aEtapx[iLDR, aX == iaX]) - # relative to absolute spread of Etapx - meanDist = (np.max(aXmean) - np.min(aXmean)) / (Etapxmax - Etapxmin) * 100 - - plt.subplot(1, 5, iLDR + 1) - (n, bins, patches) = plt.hist(aEtapx[iLDR, :], - bins=50, log=False, - range=[Rmin, Rmax], - alpha=0.5, density=False, color='0.5', histtype='stepfilled') - for iaX in range(-naX, naX + 1): - plt.hist(aEtapx[iLDR, aX == iaX], - range=[Rmin, Rmax], - bins=50, log=False, alpha=0.3, density=False, histtype='stepfilled', - label=str(round(X0 + iaX * daX / naX, 5))) - if (iLDR == 2): - leg = plt.legend() - leg.get_frame().set_alpha(0.1) - plt.tick_params(axis='both', labelsize=10) - plt.plot([Etapx0, Etapx0], [0, np.max(n)], 'r-', lw=2) - plt.gca().set_title("{0:3.0f}%".format(meanDist)) - plt.gca().set_xlabel('Etapx0', color="red") - fig.suptitle('Etapx - ' + LID + ' with ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar + ' error contribution', fontsize=14, y=1.10) - return - - def PlotEtamx(aVar, aX, X0, daX, iaX, naX): - # aVar is the name of the parameter and aX is the subset of aLDRcorr which is coloured in the plot - # example: PlotSubHist("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP) - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - Etamxmin = np.amin(aEtamx[iLDR, :]) - Etamxmax = np.amax(aEtamx[iLDR, :]) - Rmin = Etamxmin * 0.995 # np.min(aLDRcorr[iLDR,:]) * 0.995 - Rmax = Etamxmax * 1.005 # np.max(aLDRcorr[iLDR,:]) * 1.005 - - # Determine mean distance of all aXmean from each other for each iLDR - meanDist = 0.0 - for iaX in range(-naX, naX + 1): - # mean Etamx value for certain error (iaX) of parameter aVar - aXmean[iaX + naX] = np.mean(aEtamx[iLDR, aX == iaX]) - # relative to absolute spread of Etamx - meanDist = (np.max(aXmean) - np.min(aXmean)) / (Etamxmax - Etamxmin) * 100 - - plt.subplot(1, 5, iLDR + 1) - (n, bins, patches) = plt.hist(aEtamx[iLDR, :], - bins=50, log=False, - range=[Rmin, Rmax], - alpha=0.5, density=False, color='0.5', histtype='stepfilled') - for iaX in range(-naX, naX + 1): - plt.hist(aEtamx[iLDR, aX == iaX], - range=[Rmin, Rmax], - bins=50, log=False, alpha=0.3, density=False, histtype='stepfilled', - label=str(round(X0 + iaX * daX / naX, 5))) - if (iLDR == 2): - leg = plt.legend() - leg.get_frame().set_alpha(0.1) - plt.tick_params(axis='both', labelsize=10) - plt.plot([Etamx0, Etamx0], [0, np.max(n)], 'r-', lw=2) - plt.gca().set_title("{0:3.0f}%".format(meanDist)) - plt.gca().set_xlabel('Etamx0', color="red") - fig.suptitle('Etamx - ' + LID + ' with ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar + ' error contribution', fontsize=14, y=1.10) - return - - # calc contribution of the error of aVar = aX to aY for each LDRtrue - def Contribution(aVar, aX, X0, daX, iaX, naX, aY, Ysum, widthSum): - # aVar is the name of the parameter and aX is the subset of aY which is coloured in the plot - # example: Contribution("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP, aLDRcorr, DOLPcontr) - iLDR = -1 - # Ysum, widthSum = np.zeros(5) - meanDist = np.zeros(5) # iLDR - widthDist = np.zeros(5) # iLDR - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - aXwidth = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - # total width of distribution - aYmin = np.amin(aY[iLDR, :]) - aYmax = np.amax(aY[iLDR, :]) - aYwidth = aYmax - aYmin - # Determine mean distance of all aXmean from each other for each iLDR - for iaX in range(-naX, naX + 1): - # mean LDRCorr value for all errors iaX of parameter aVar - aXmean[iaX + naX] = np.mean(aY[iLDR, aX == iaX]) - aXwidth[iaX + naX] = np.max(aY[iLDR, aX == iaX]) - np.min(aY[iLDR, aX == iaX]) - # relative to absolute spread of LDRCorrs - meanDist[iLDR] = (np.max(aXmean) - np.min(aXmean)) / aYwidth * 1000 - # meanDist[iLDR] = (aYwidth - aXwidth[naX]) / aYwidth * 1000 - widthDist[iLDR] = (np.max(aXwidth) - aXwidth[naX]) / aYwidth * 1000 - - print("{:12}{:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f}"\ - .format(aVar,meanDist[0],meanDist[1],meanDist[2],meanDist[3],meanDist[4],widthDist[0],widthDist[1],widthDist[2],widthDist[3],widthDist[4])) - Ysum = Ysum + meanDist - widthSum = widthSum + widthDist - return(Ysum, widthSum) - - # print(.format(LDRrangeA[iLDR],)) - - # error contributions to a certain output aY; loop over all variables - def Contribution_aY(aYvar, aY): - Ysum = np.zeros(5) - widthSum = np.zeros(5) - # meanDist = np.zeros(5) # iLDR - LDRrangeA = np.array(LDRrange) - print() - print(aYvar + ": contribution to the total error (per mill)") - print(" of individual parameter errors of combined parameter errors") - print(" at LDRtrue {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f}"\ - .format(LDRrangeA[0],LDRrangeA[1],LDRrangeA[2],LDRrangeA[3],LDRrangeA[4],LDRrangeA[0],LDRrangeA[1],LDRrangeA[2],LDRrangeA[3],LDRrangeA[4])) - print() - if (nQin > 0): Ysum, widthSum = Contribution("Qin", aQin, Qin0, dQin, iQin, nQin, aY, Ysum, widthSum) - if (nVin > 0): Ysum, widthSum = Contribution("Vin", aVin, Vin0, dVin, iVin, nVin, aY, Ysum, widthSum) - if (nRotL > 0): Ysum, widthSum = Contribution("RotL", aRotL, RotL0, dRotL, iRotL, nRotL, aY, Ysum, widthSum) - if (nRetE > 0): Ysum, widthSum = Contribution("RetE", aRetE, RetE0, dRetE, iRetE, nRetE, aY, Ysum, widthSum) - if (nRotE > 0): Ysum, widthSum = Contribution("RotE", aRotE, RotE0, dRotE, iRotE, nRotE, aY, Ysum, widthSum) - if (nDiE > 0): Ysum, widthSum = Contribution("DiE", aDiE, DiE0, dDiE, iDiE, nDiE, aY, Ysum, widthSum) - if (nRetO > 0): Ysum, widthSum = Contribution("RetO", aRetO, RetO0, dRetO, iRetO, nRetO, aY, Ysum, widthSum) - if (nRotO > 0): Ysum, widthSum = Contribution("RotO", aRotO, RotO0, dRotO, iRotO, nRotO, aY, Ysum, widthSum) - if (nDiO > 0): Ysum, widthSum = Contribution("DiO", aDiO, DiO0, dDiO, iDiO, nDiO, aY, Ysum, widthSum) - if (nDiC > 0): Ysum, widthSum = Contribution("DiC", aDiC, DiC0, dDiC, iDiC, nDiC, aY, Ysum, widthSum) - if (nRotC > 0): Ysum, widthSum = Contribution("RotC", aRotC, RotC0, dRotC, iRotC, nRotC, aY, Ysum, widthSum) - if (nRetC > 0): Ysum, widthSum = Contribution("RetC", aRetC, RetC0, dRetC, iRetC, nRetC, aY, Ysum, widthSum) - if (nTP > 0): Ysum, widthSum = Contribution("TP", aTP, TP0, dTP, iTP, nTP, aY, Ysum, widthSum) - if (nTS > 0): Ysum, widthSum = Contribution("TS", aTS, TS0, dTS, iTS, nTS, aY, Ysum, widthSum) - if (nRP > 0): Ysum, widthSum = Contribution("RP", aRP, RP0, dRP, iRP, nRP, aY, Ysum, widthSum) - if (nRS > 0): Ysum, widthSum = Contribution("RS", aRS, RS0, dRS, iRS, nRS, aY, Ysum, widthSum) - if (nRetT > 0): Ysum, widthSum = Contribution("RetT", aRetT, RetT0, dRetT, iRetT, nRetT, aY, Ysum, widthSum) - if (nRetR > 0): Ysum, widthSum = Contribution("RetR", aRetR, RetR0, dRetR, iRetR, nRetR, aY, Ysum, widthSum) - if (nERaT > 0): Ysum, widthSum = Contribution("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT, aY, Ysum, widthSum) - if (nERaR > 0): Ysum, widthSum = Contribution("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR, aY, Ysum, widthSum) - if (nRotaT > 0): Ysum, widthSum = Contribution("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT, aY, Ysum, widthSum) - if (nRotaR > 0): Ysum, widthSum = Contribution("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR, aY, Ysum, widthSum) - if (nLDRCal > 0): Ysum, widthSum = Contribution("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal, aY, Ysum, widthSum) - if (nTCalT > 0): Ysum, widthSum = Contribution("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT, aY, Ysum, widthSum) - if (nTCalR > 0): Ysum, widthSum = Contribution("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR, aY, Ysum, widthSum) - if (nNCal > 0): Ysum, widthSum = Contribution("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal, aY, Ysum, widthSum) - if (nNCal > 0): Ysum, widthSum = Contribution("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal, aY, Ysum, widthSum) - if (nNCal > 0): Ysum, widthSum = Contribution("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal, aY, Ysum, widthSum) - if (nNCal > 0): Ysum, widthSum = Contribution("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal, aY, Ysum, widthSum) - if (nNI > 0): Ysum, widthSum = Contribution("SigNoiseIt", aNIt, 0, 1, iNIt, nNI, aY, Ysum, widthSum) - if (nNI > 0): Ysum, widthSum = Contribution("SigNoiseIr", aNIr, 0, 1, iNIr, nNI, aY, Ysum, widthSum) - print("{:12}{:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f}"\ - .format("Sum ",Ysum[0],Ysum[1],Ysum[2],Ysum[3],Ysum[4],widthSum[0],widthSum[1],widthSum[2],widthSum[3],widthSum[4])) - - - # Plot LDR histograms - if (nQin > 0): PlotSubHist("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotSubHist("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotSubHist("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotSubHist("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotSubHist("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotSubHist("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotSubHist("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotSubHist("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotSubHist("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotSubHist("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotSubHist("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotSubHist("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotSubHist("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotSubHist("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotSubHist("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotSubHist("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotSubHist("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotSubHist("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotSubHist("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotSubHist("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotSubHist("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotSubHist("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotSubHist("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotSubHist("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotSubHist("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotSubHist("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal) - if (nNCal > 0): PlotSubHist("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal) - if (nNCal > 0): PlotSubHist("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal) - if (nNCal > 0): PlotSubHist("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal) - if (nNI > 0): PlotSubHist("SigNoiseIt", aNIt, 0, 1, iNIt, nNI) - if (nNI > 0): PlotSubHist("SigNoiseIr", aNIr, 0, 1, iNIr, nNI) - plt.show() - plt.close - - - - # --- Plot LDRmin, LDRmax - iLDR = -1 - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - LDRmin[iLDR] = np.amin(aLDRcorr[iLDR, :]) - LDRmax[iLDR] = np.amax(aLDRcorr[iLDR, :]) - LDRstd[iLDR] = np.std(aLDRcorr[iLDR, :]) - LDRmean[iLDR] = np.mean(aLDRcorr[iLDR, :]) - LDRmedian[iLDR] = np.median(aLDRcorr[iLDR, :]) - LDRskew[iLDR] = skew(aLDRcorr[iLDR, :],bias=False) - LDRkurt[iLDR] = kurtosis(aLDRcorr[iLDR, :],fisher=True,bias=False) - - fig2 = plt.figure() - LDRrangeA = np.array(LDRrange) - if((np.amax(LDRmax - LDRrangeA)-np.amin(LDRmin - LDRrangeA)) < 0.001): - plt.ylim(-0.001,0.001) - plt.plot(LDRrangeA, LDRmax - LDRrangeA, linewidth=2.0, color='b') - plt.plot(LDRrangeA, LDRmin - LDRrangeA, linewidth=2.0, color='g') - - plt.xlabel('LDRtrue', fontsize=18) - plt.ylabel('LDRTrue-LDRmin, LDRTrue-LDRmax', fontsize=14) - plt.title(LID + ' ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]), fontsize=18) - # plt.ylimit(-0.07, 0.07) - plt.show() - plt.close - - # --- Save LDRmin, LDRmax to file - # http://stackoverflow.com/questions/4675728/redirect-stdout-to-a-file-in-python - with open('output_files\\' + OutputFile, 'a') as f: - # with open('output_files\\' + LID + '-' + InputFile[0:-3] + '-LDR_min_max.dat', 'w') as f: - with redirect_stdout(f): - print("Lidar ID: " + LID) - print() - print("minimum and maximum values of the distributions of possibly measured LDR for different LDRtrue") - print("LDRtrue , LDRmin, LDRmax") - for i in range(len(LDRrangeA)): - print("{0:7.4f},{1:7.4f},{2:7.4f}".format(LDRrangeA[i], LDRmin[i], LDRmax[i])) - print() - # Print LDR statistics - print("LDRtrue , mean , median, max-mean, min-mean, std, excess_kurtosis, skewness") - iLDR = -1 - LDRrangeA = np.array(LDRrange) - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - print("{0:8.5f},{1:8.5f},{2:8.5f}, {3:8.5f},{4:8.5f},{5:8.5f}, {6:8.5f},{7:8.5f}"\ - .format(LDRrangeA[iLDR], LDRmean[iLDR], LDRmedian[iLDR], LDRmax[iLDR]-LDRrangeA[iLDR], \ - LDRmin[iLDR]-LDRrangeA[iLDR], LDRstd[iLDR], LDRkurt[iLDR], LDRskew[iLDR])) - print() - # Calculate and print statistics for calibration factors - print("minimum and maximum values of the distributions of signal ratios and calibration factors for different LDRtrue") - iLDR = -1 - LDRrangeA = np.array(LDRrange) - print("LDRtrue , LDRsim, (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - LDRsimmin[iLDR] = np.amin(aLDRsim[iLDR, :]) - LDRsimmax[iLDR] = np.amax(aLDRsim[iLDR, :]) - # LDRsimstd = np.std(aLDRsim[iLDR, :]) - LDRsimmean[iLDR] = np.mean(aLDRsim[iLDR, :]) - # LDRsimmedian = np.median(aLDRsim[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR],LDRsimmean[iLDR],(LDRsimmax[iLDR]-LDRsimmin[iLDR])/2,(LDRsimmax[iLDR]-LDRsimmin[iLDR])/2/LDRsimmean[iLDR])) - iLDR = -1 - print("LDRtrue , Etax , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etaxmin = np.amin(aEtax[iLDR, :]) - Etaxmax = np.amax(aEtax[iLDR, :]) - # Etaxstd = np.std(aEtax[iLDR, :]) - Etaxmean = np.mean(aEtax[iLDR, :]) - # Etaxmedian = np.median(aEtax[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etaxmean, (Etaxmax-Etaxmin)/2, (Etaxmax-Etaxmin)/2/Etaxmean)) - iLDR = -1 - print("LDRtrue , Etapx , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etapxmin = np.amin(aEtapx[iLDR, :]) - Etapxmax = np.amax(aEtapx[iLDR, :]) - # Etapxstd = np.std(aEtapx[iLDR, :]) - Etapxmean = np.mean(aEtapx[iLDR, :]) - # Etapxmedian = np.median(aEtapx[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etapxmean, (Etapxmax-Etapxmin)/2, (Etapxmax-Etapxmin)/2/Etapxmean)) - iLDR = -1 - print("LDRtrue , Etamx , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etamxmin = np.amin(aEtamx[iLDR, :]) - Etamxmax = np.amax(aEtamx[iLDR, :]) - # Etamxstd = np.std(aEtamx[iLDR, :]) - Etamxmean = np.mean(aEtamx[iLDR, :]) - # Etamxmedian = np.median(aEtamx[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etamxmean, (Etamxmax-Etamxmin)/2, (Etamxmax-Etamxmin)/2/Etamxmean)) - - # Print LDR statistics - print("LDRtrue , mean , median, max-mean, min-mean, std, excess_kurtosis, skewness") - iLDR = -1 - LDRrangeA = np.array(LDRrange) - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - print("{0:8.5f},{1:8.5f},{2:8.5f}, {3:8.5f},{4:8.5f},{5:8.5f}, {6:8.5f},{7:8.5f}".format(LDRrangeA[iLDR], LDRmean[iLDR], LDRmedian[iLDR], LDRmax[iLDR]-LDRrangeA[iLDR], LDRmin[iLDR]-LDRrangeA[iLDR], LDRstd[iLDR],LDRkurt[iLDR],LDRskew[iLDR])) - - - with open('output_files\\' + OutputFile, 'a') as f: - # with open('output_files\\' + LID + '-' + InputFile[0:-3] + '-LDR_min_max.dat', 'a') as f: - with redirect_stdout(f): - Contribution_aY("LDRCorr", aLDRcorr) - Contribution_aY("LDRsim", aLDRsim) - Contribution_aY("EtaX, D90", aEtax) - Contribution_aY("Etapx, +45°", aEtapx) - Contribution_aY("Etamx -45°", aEtamx) - - - # Plot other histograms - if (bPlotEtax): - - if (nQin > 0): PlotLDRsim("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotLDRsim("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotLDRsim("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotLDRsim("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotLDRsim("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotLDRsim("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotLDRsim("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotLDRsim("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotLDRsim("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotLDRsim("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotLDRsim("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotLDRsim("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotLDRsim("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotLDRsim("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotLDRsim("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotLDRsim("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotLDRsim("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotLDRsim("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotLDRsim("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotLDRsim("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotLDRsim("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotLDRsim("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotLDRsim("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotLDRsim("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotLDRsim("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotLDRsim("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal) - if (nNCal > 0): PlotLDRsim("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal) - if (nNCal > 0): PlotLDRsim("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal) - if (nNCal > 0): PlotLDRsim("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal) - if (nNI > 0): PlotLDRsim("SigNoiseIt", aNIt, 0, 1, iNIt, nNI) - if (nNI > 0): PlotLDRsim("SigNoiseIr", aNIr, 0, 1, iNIr, nNI) - plt.show() - plt.close - print("---------------------------------------...producing more plots...------------------------------------------------------------------") - - if (nQin > 0): PlotEtax("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotEtax("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotEtax("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotEtax("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotEtax("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotEtax("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotEtax("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotEtax("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotEtax("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotEtax("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotEtax("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotEtax("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotEtax("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotEtax("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotEtax("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotEtax("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotEtax("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotEtax("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotEtax("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotEtax("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotEtax("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotEtax("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotEtax("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotEtax("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotEtax("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotEtax("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal) - if (nNCal > 0): PlotEtax("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal) - if (nNCal > 0): PlotEtax("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal) - if (nNCal > 0): PlotEtax("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal) - if (nNI > 0): PlotEtax("SigNoiseIt", aNIt, 0, 1, iNIt, nNI) - if (nNI > 0): PlotEtax("SigNoiseIr", aNIr, 0, 1, iNIr, nNI) - plt.show() - plt.close - print("---------------------------------------...producing more plots...------------------------------------------------------------------") - - if (nQin > 0): PlotEtapx("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotEtapx("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotEtapx("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotEtapx("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotEtapx("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotEtapx("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotEtapx("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotEtapx("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotEtapx("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotEtapx("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotEtapx("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotEtapx("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotEtapx("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotEtapx("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotEtapx("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotEtapx("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotEtapx("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotEtapx("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotEtapx("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotEtapx("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotEtapx("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotEtapx("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotEtapx("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotEtapx("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotEtapx("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotEtapx("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal) - if (nNCal > 0): PlotEtapx("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal) - if (nNCal > 0): PlotEtapx("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal) - if (nNCal > 0): PlotEtapx("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal) - if (nNI > 0): PlotEtapx("SigNoiseIt", aNIt, 0, 1, iNIt, nNI) - if (nNI > 0): PlotEtapx("SigNoiseIr", aNIr, 0, 1, iNIr, nNI) - plt.show() - plt.close - print("---------------------------------------...producing more plots...------------------------------------------------------------------") - - if (nQin > 0): PlotEtamx("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotEtamx("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotEtamx("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotEtamx("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotEtamx("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotEtamx("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotEtamx("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotEtamx("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotEtamx("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotEtamx("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotEtamx("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotEtamx("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotEtamx("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotEtamx("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotEtamx("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotEtamx("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotEtamx("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotEtamx("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotEtamx("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotEtamx("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotEtamx("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotEtamx("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotEtamx("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotEtamx("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotEtamx("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotEtamx("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal) - if (nNCal > 0): PlotEtamx("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal) - if (nNCal > 0): PlotEtamx("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal) - if (nNCal > 0): PlotEtamx("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal) - if (nNI > 0): PlotEtamx("SigNoiseIt", aNIt, 0, 1, iNIt, nNI) - if (nNI > 0): PlotEtamx("SigNoiseIr", aNIr, 0, 1, iNIr, nNI) - plt.show() - plt.close - - # Print Etax statistics - Etaxmin = np.amin(aEtax[1, :]) - Etaxmax = np.amax(aEtax[1, :]) - Etaxstd = np.std(aEtax[1, :]) - Etaxmean = np.mean(aEtax[1, :]) - Etaxmedian = np.median(aEtax[1, :]) - print("Etax , max-mean, min-mean, median, mean ± std, eta") - print("{0:8.5f} ±({1:8.5f},{2:8.5f}),{3:8.5f},{4:8.5f}±{5:8.5f},{6:8.5f}".format(Etax0, Etaxmax-Etax0, Etaxmin-Etax0, Etaxmedian, Etaxmean, Etaxstd, Etax0 / K0)) - print() - - # Calculate and print statistics for calibration factors - iLDR = -1 - LDRrangeA = np.array(LDRrange) - print("LDR...., LDRsim, (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - LDRsimmin[iLDR] = np.amin(aLDRsim[iLDR, :]) - LDRsimmax[iLDR] = np.amax(aLDRsim[iLDR, :]) - # LDRsimstd = np.std(aLDRsim[iLDR, :]) - LDRsimmean[iLDR] = np.mean(aLDRsim[iLDR, :]) - # LDRsimmedian = np.median(aLDRsim[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], LDRsimmean[iLDR], (LDRsimmax[iLDR]-LDRsimmin[iLDR])/2, (LDRsimmax[iLDR]-LDRsimmin[iLDR])/2/LDRsimmean[iLDR])) - iLDR = -1 - print("LDR...., Etax , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etaxmin = np.amin(aEtax[iLDR, :]) - Etaxmax = np.amax(aEtax[iLDR, :]) - # Etaxstd = np.std(aEtax[iLDR, :]) - Etaxmean = np.mean(aEtax[iLDR, :]) - # Etaxmedian = np.median(aEtax[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etaxmean, (Etaxmax-Etaxmin)/2, (Etaxmax-Etaxmin)/2/Etaxmean)) - iLDR = -1 - print("LDR...., Etapx , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etapxmin = np.amin(aEtapx[iLDR, :]) - Etapxmax = np.amax(aEtapx[iLDR, :]) - # Etapxstd = np.std(aEtapx[iLDR, :]) - Etapxmean = np.mean(aEtapx[iLDR, :]) - # Etapxmedian = np.median(aEtapx[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etapxmean, (Etapxmax-Etapxmin)/2, (Etapxmax-Etapxmin)/2/Etapxmean)) - iLDR = -1 - print("LDR...., Etamx , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etamxmin = np.amin(aEtamx[iLDR, :]) - Etamxmax = np.amax(aEtamx[iLDR, :]) - # Etamxstd = np.std(aEtamx[iLDR, :]) - Etamxmean = np.mean(aEtamx[iLDR, :]) - # Etamxmedian = np.median(aEtamx[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etamxmean, (Etamxmax-Etamxmin)/2, (Etamxmax-Etamxmin)/2/Etamxmean)) - - f.close() - - -''' - # --- Plot F11 histograms - print() - print(" ############################################################################## ") - print(Text1) - print() - - iLDR = 5 - for LDRTrue in LDRrange: - iLDR = iLDR - 1 - #aF11corr[iLDR,:] = aF11corr[iLDR,:] / aF11corr[0,:] - 1.0 - aF11corr[iLDR,:] = aF11corr[iLDR,:] / aF11sim0[iLDR] - 1.0 - # Plot F11 - def PlotSubHistF11(aVar, aX, X0, daX, iaX, naX): - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - - #F11min[iLDR] = np.min(aF11corr[iLDR,:]) - #F11max[iLDR] = np.max(aF11corr[iLDR,:]) - #Rmin = F11min[iLDR] * 0.995 # np.min(aLDRcorr[iLDR,:]) * 0.995 - #Rmax = F11max[iLDR] * 1.005 # np.max(aLDRcorr[iLDR,:]) * 1.005 - - #Rmin = 0.8 - #Rmax = 1.2 - - #plt.subplot(5,2,iLDR+1) - plt.subplot(1,5,iLDR+1) - (n, bins, patches) = plt.hist(aF11corr[iLDR,:], - bins=100, log=False, - alpha=0.5, density=False, color = '0.5', histtype='stepfilled') - - for iaX in range(-naX,naX+1): - plt.hist(aF11corr[iLDR,aX == iaX], - bins=100, log=False, alpha=0.3, density=False, histtype='stepfilled', label = str(round(X0 + iaX*daX/naX,5))) - - if (iLDR == 2): plt.legend() - - plt.tick_params(axis='both', labelsize=9) - #plt.plot([LDRTrue, LDRTrue], [0, np.max(n)], 'r-', lw=2) - - #plt.title(LID + ' ' + aVar, fontsize=18) - #plt.ylabel('frequency', fontsize=10) - #plt.xlabel('LDRCorr', fontsize=10) - #fig.tight_layout() - fig.suptitle(LID + ' ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar, fontsize=14, y=1.05) - #plt.show() - #fig.savefig(LID + '_' + aVar + '.png', dpi=150, bbox_inches='tight', pad_inches=0) - #plt.close - return - - if (nQin > 0): PlotSubHistF11("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotSubHistF11("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotSubHistF11("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotSubHistF11("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotSubHistF11("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotSubHistF11("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotSubHistF11("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotSubHistF11("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotSubHistF11("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotSubHistF11("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotSubHistF11("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotSubHistF11("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotSubHistF11("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotSubHistF11("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotSubHistF11("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotSubHistF11("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotSubHistF11("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotSubHistF11("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotSubHistF11("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotSubHistF11("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotSubHistF11("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotSubHistF11("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotSubHistF11("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotSubHistF11("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotSubHistF11("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotSubHistF11("CalNoise", aNCal, 0, 1/nNCal, iNCal, nNCal) - if (nNI > 0): PlotSubHistF11("SigNoise", aNI, 0, 1/nNI, iNI, nNI) - - - plt.show() - plt.close - - ''' -''' - # only histogram - #print("******************* " + aVar + " *******************") - fig, ax = plt.subplots(nrows=5, ncols=2, sharex=True, sharey=True, figsize=(10, 10)) - iLDR = -1 - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - LDRmin[iLDR] = np.min(aLDRcorr[iLDR,:]) - LDRmax[iLDR] = np.max(aLDRcorr[iLDR,:]) - Rmin = np.min(aLDRcorr[iLDR,:]) * 0.999 - Rmax = np.max(aLDRcorr[iLDR,:]) * 1.001 - plt.subplot(5,2,iLDR+1) - (n, bins, patches) = plt.hist(aLDRcorr[iLDR,:], - range=[Rmin, Rmax], - bins=200, log=False, alpha=0.2, density=False, color = '0.5', histtype='stepfilled') - plt.tick_params(axis='both', labelsize=9) - plt.plot([LDRTrue, LDRTrue], [0, np.max(n)], 'r-', lw=2) - plt.show() - plt.close - # --- End of Plot F11 histograms - ''' - - -''' - # --- Plot K over LDRCal - fig3 = plt.figure() - plt.plot(LDRCal0+aLDRCal*dLDRCal/nLDRCal,aGHK[4,:], linewidth=2.0, color='b') - - plt.xlabel('LDRCal', fontsize=18) - plt.ylabel('K', fontsize=14) - plt.title(LID, fontsize=18) - plt.show() - plt.close - ''' - -# Additional plot routines ======> -''' -#****************************************************************************** -# 1. Plot LDRCorrected - LDR(measured Icross/Iparallel) -LDRa = np.arange(1.,100.)*0.005 -LDRCorra = np.arange(1.,100.) -if Y == - 1.: LDRa = 1./LDRa -LDRCorra = (1./Eta*LDRa*(GT+HT)-(GR+HR))/((GR-HR)-1./Eta*LDRa*(GT-HT)) -if Y == - 1.: LDRa = 1./LDRa -# -#fig = plt.figure() -plt.plot(LDRa,LDRCorra-LDRa) -plt.plot([0.,0.5],[0.,0.5]) -plt.suptitle('LDRCorrected - LDR(measured Icross/Iparallel)', fontsize=16) -plt.xlabel('LDR', fontsize=18) -plt.ylabel('LDRCorr - LDR', fontsize=16) -#plt.savefig('test.png') -# -''' -''' -#****************************************************************************** -# 2. Plot LDRsim (simulated measurements without corrections = Icross/Iparallel) over LDRtrue -LDRa = np.arange(1.,100.)*0.005 -LDRsima = np.arange(1.,100.) - -atruea = (1.-LDRa)/(1+LDRa) -Ita = TiT*TiO*IinL*(GT+atruea*HT) -Ira = TiR*TiO*IinL*(GR+atruea*HR) -LDRsima = Ira/Ita # simulated uncorrected LDR with Y from input file -if Y == -1.: LDRsima = 1./LDRsima -# -#fig = plt.figure() -plt.plot(LDRa,LDRsima) -plt.plot([0.,0.5],[0.,0.5]) -plt.suptitle('LDRsim (simulated measurements without corrections = Icross/Iparallel) over LDRtrue', fontsize=10) -plt.xlabel('LDRtrue', fontsize=18) -plt.ylabel('LDRsim', fontsize=16) -#plt.savefig('test.png') -# -''' \ No newline at end of file
--- a/GHK_0.9.8f_Py3.7.py Wed Jul 07 15:42:30 2021 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,2904 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Copyright 2016, 2019 Volker Freudenthaler - -Licensed under the EUPL, Version 1.1 only (the "Licence"). - -You may not use this work except in compliance with the Licence. -A copy of the licence is distributed with the code. Alternatively, you may obtain -a copy of the Licence at: - -https://joinup.ec.europa.eu/community/eupl/og_page/eupl - -Unless required by applicable law or agreed to in writing, software distributed -under the Licence is distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS -OF ANY KIND, either express or implied. See the Licence for the specific language governing -permissions and limitations under the Licence. - -Equation reference: http://www.atmos-meas-tech-discuss.net/amt-2015-338/amt-2015-338.pdf -With equations code from Appendix C -Python 3.7, seaborn 0.9.0 - -Code description: - -From measured lidar signals we cannot directly determine the desired backscatter coefficient (F11) and the linear depolarization ratio (LDR) -because of the cross talk between the channles and systematic errors of a lidar system. -http://www.atmos-meas-tech-discuss.net/amt-2015-338/amt-2015-338.pdf provides an analytical model for the description of these errors, -with which the measured signals can be corrected. -This code simulates the lidar measurements with "assumed true" model parameters from an input file, and calculates the correction parameters (G,H, and K). -The "assumed true" system parameters are the ones we think are the right ones, but in reality these parameters probably deviate from the assumed truth due to -uncertainties. The uncertainties of the "assumed true" parameters can be described in the input file. Then this code calculates the lidar signals and the -gain ratio eta* with all possible combinations of "errors", which represents the distribution of "possibly real" signals, and "corrects" them with the "assumed true" -GHK parameters (GT0, GR0, HT0, HR0, and K0) to derive finally the distributions of "possibly real" linear depolarization ratios (LDRCorr), -which are plotted for five different input linear depolarization ratios (LDRtrue). The red bars in the plots represent the input values of LDRtrue. -A complication arises from the fact that the correction parameter K = eta*/eta (Eq. 83) can depend on the LDR during the calibration measurement, i.e. LDRcal or aCal -in the code (see e.g. Eqs. (103), (115), and (141); mind the mistake in Eq. (116)). Therefor values of K for LDRcal = 0.004, 0.2, and 0.45 are calculated for -"assumed true" system parameters and printed in the output file behind the GH parameters. The full impact of the LDRcal dependent K can be considered in the error -calculation by specifying a range of possible LDRcal values in the input file. For the real calibration measurements a calibration range with low or no aerosol -content should be chosen, and the default in the input file is a range of LDRcal between 0.004 and 0.014 (i.e. 0.009 +-0.005). - -Tip: In case you run the code with Spyder, all output text and plots can be displayed together in an IPython console, which can be saved as an html file. - -Ver. 0.9.7: includes the random error (signal noise) of the calibration and standard measurements -Changes: - Line 1687 Eta = (TaR * TiR) / (TaT * TiT) - Line 1691 K = Etax / Eta # K of the real system; but correction in Line 1721 with K0 / Etax - should work with nTCalT = nTCalR = 0 -Ver. 0.9.7b: - ToDo: include error due to TCalT und TCalR => determination of NCalT and NCalR etc. in error calculation line 1741ff - combined error loops iNI and INCal for signals -Ver. 0.9.7c: individual error loops for each of the six signals -Ver. 0.9.7c2: different calculation of the signal noise errors -Ver. 0.9.7c3: n.a.different calculation of the signal noise errors -Ver. 0.9.7c4: test to speed up the loops for error calculation by moving them just before the actual calculation: still some code errors -Ver. 0.9.8: - - correct calculation of Eta for cleaned anaylsers considering the combined transmission Eta = (TaT* TiT)(1 + cos2RotaT * DaT * DiT) and (TaR * TiR)(1 + cos2RotaR * DaR * DiR) according to the papers supplement Eqs. (S.10.10.1) ff - - calculation of the PLDR from LDR and BSR, BSR, and LDRm - - ND-filters can be added for the calibration measurements in the transmitted (TCalT) and the reflected path (TCalR) in order to include their uncertainties in the error calculation. -Ver. 0.9.8b: change from "TTa = TiT * TaT" to "TTa = TiT * TaT * ATPT" etc. (compare ver 0.9.8 with 0.9.8b) removes - - the strong Tp dependence of the errors - - the factor 2 in the GH parameters - - see c:\technik\Optik\Polarizers\DepCal\ApplOpt\GH-parameters-190114.odt -Ver. 0.9.8c: includes error of Etax -Ver. 0.9.8d: Eta0, K0 etc in error loop replaced by Eta0y, K0y etc. Changes in signal noise calculations -Ver. 0.9.8e: ambiguous laser spec. DOLP (no discrimination between left and right circular polarisation) replaced by Stokes parameters Qin, Uin -Ver. 0.9.8e2: Added plot of LDRsim, Etax, Etapx, Etamx; LDRCorr and aLDRcorr consistently named -Ver. 0.9.8e3: Change of OutputFile name; Change of Ir and It noise if (CalcFrom0deg) = False; (Different calculation of error contributions tested but not implemented) -Ver. 0.9.8e4: text changed for y=+-1 (see line 274 ff and line 1044 ff -Ver. 0.9.8e5: changed: LDRunCorr = LDRsim / Etax -Ver. 0.9.8e6: K(0.05) instead K(0.02) -Ver. 0.9.8f: Tip from Ioannis Binietoglou for LINUX compatibility: Using os.path.join should work in all operating systems. - # After line 1007: - output_path = os.path.join('output_files', OutputFile) - with open(output_path, 'w') as f: - # Line 1147 - file = open(output_path, 'r') ------------- - - ======================================================== -simulation: LDRsim = Ir / It with variable parameters (possible truths) - G,H,Eta,Etax,K - It = TaT * TiT * ATP1 * TiO * TiE * (GT + atrue * HT) - LDRsim = Ir / It -consistency test: is forward simulation and correction consistent? - LDRCorr = (LDRsim / Eta * (GT + HT) - (GR + HR)) / ((GR - HR) - LDRsim / Eta * (GT - HT)) => atrue? -assumed true: G0,H0,Eta0,Etax0,K0 => actual retrievals of LDRCorr - => correct possible truths with assumed true G0,H0,Eta0 - measure: It, Ir, EtaX - LDRunCorr = LDRsim / Etax - correct it with G0,H0,K0: - LDRCorr = (LDRsim / (Etax / K0) * (GT0 + HT0) - (GR0 + HR0)) / ((GR0 - HR0) - LDRsim0 / (Etax / K0) * (GT0 - HT0)) -""" -# Comment: The code might works with Python 2.7 with the help of following line, which enables Python2 to correctly interpret the Python 3 print statements. -from __future__ import print_function -# !/usr/bin/env python3 - -import os -import sys - -from scipy.stats import kurtosis -from scipy.stats import skew -# use: kurtosis(data, fisher=True,bias=False) => 0; skew(data,bias=False) => 0 -# Comment: the seaborn library makes nicer plots, but the code works also without it. -import numpy as np -import matplotlib.pyplot as plt - -try: - import seaborn as sns - - sns_loaded = True -except ImportError: - sns_loaded = False - -# from time import clock # python 2 -from timeit import default_timer as clock - -# from matplotlib.backends.backend_pdf import PdfPages -# pdffile = '{}.pdf'.format('path') -# pp = PdfPages(pdffile) -## pp.savefig can be called multiple times to save to multiple pages -# pp.savefig() -# pp.close() - -from contextlib import contextmanager - -@contextmanager -def redirect_stdout(new_target): - old_target, sys.stdout = sys.stdout, new_target # replace sys.stdout - try: - yield new_target # run some code with the replaced stdout - finally: - sys.stdout.flush() - sys.stdout = old_target # restore to the previous value - -''' -real_raw_input = vars(__builtins__).get('raw_input',input) -''' -try: - import __builtin__ - - input = getattr(__builtin__, 'raw_input') -except (ImportError, AttributeError): - pass - -from distutils.util import strtobool - - -def user_yes_no_query(question): - sys.stdout.write('%s [y/n]\n' % question) - while True: - try: - return strtobool(input().lower()) - except ValueError: - sys.stdout.write('Please respond with \'y\' or \'n\'.\n') - - -# if user_yes_no_query('want to exit?') == 1: sys.exit() - -abspath = os.path.abspath(__file__) -dname = os.path.dirname(abspath) -fname = os.path.basename(abspath) -os.chdir(dname) - -# PrintToOutputFile = True - -sqr05 = 0.5 ** 0.5 - -# ---- Initial definition of variables; the actual values will be read in with exec(open('./optic_input.py').read()) below -# Do you want to calculate the errors? If not, just the GHK-parameters are determined. -Error_Calc = True -LID = "internal" -EID = "internal" -# --- IL Laser IL and +-Uncertainty -Qin, dQin, nQin = 1., 0.0, 0 # second Stokes vector parameter; default 1 => linear polarization -Vin, dVin, nVin = 0., 0.0, 0 # fourth Stokes vector parameter -RotL, dRotL, nRotL = 0.0, 0.0, 1 # alpha; rotation of laser polarization in degrees; default 0 -# IL = 1e5 #photons in the laser beam, including detection efficiency of the telescope, atmodspheric and r^2 attenuation -# --- ME Emitter and +-Uncertainty -DiE, dDiE, nDiE = 0., 0.00, 1 # Diattenuation -TiE = 1. # Unpolarized transmittance -RetE, dRetE, nRetE = 0., 180.0, 0 # Retardance in degrees -RotE, dRotE, nRotE = 0., 0.0, 0 # beta: Rotation of optical element in degrees -# --- MO Receiver Optics including telescope -DiO, dDiO, nDiO = -0.055, 0.003, 1 -TiO = 0.9 -RetO, dRetO, nRetO = 0., 180.0, 2 -RotO, dRotO, nRotO = 0., 0.1, 1 # gamma -# --- PBS MT transmitting path defined with (TS,TP); and +-Uncertainty -TP, dTP, nTP = 0.98, 0.02, 1 -TS, dTS, nTS = 0.001, 0.001, 1 -TiT = 0.5 * (TP + TS) -DiT = (TP - TS) / (TP + TS) -# PolFilter -RetT, dRetT, nRetT = 0., 180., 0 -ERaT, dERaT, nERaT = 0.001, 0.001, 1 -RotaT, dRotaT, nRotaT = 0., 3., 1 -DaT = (1 - ERaT) / (1 + ERaT) -TaT = 0.5 * (1 + ERaT) -# --- PBS MR reflecting path defined with (RS,RP); and +-Uncertainty -RS_RP_depend_on_TS_TP = False -if (RS_RP_depend_on_TS_TP): - RP, dRP, nRP = 1 - TP, 0.0, 0 - RS, dRS, nRS = 1 - TS, 0.0, 0 -else: - RP, dRP, nRP = 0.05, 0.01, 1 - RS, dRS, nRS = 0.98, 0.01, 1 -TiR = 0.5 * (RP + RS) -DiR = (RP - RS) / (RP + RS) -# PolFilter -RetR, dRetR, nRetR = 0., 180., 0 -ERaR, dERaR, nERaR = 0.001, 0.001, 1 -RotaR, dRotaR, nRotaR = 90., 3., 1 -DaR = (1 - ERaR) / (1 + ERaR) -TaR = 0.5 * (1 + ERaR) - -# +++ Orientation of the PBS with respect to the reference plane (see Polarisation-orientation.png and Polarisation-orientation-2.png in /system_settings) -# Y = +1: PBS incidence plane is parallel to the reference plane and polarisation in reference plane is finally transmitted. -# Y = -1: PBS incidence plane is perpendicular to the reference plane and polarisation in reference plane is finally reflected. -Y = 1. - -# Calibrator = type defined by matrix values -LocC = 4 # location of calibrator: behind laser = 1; behind emitter = 2; before receiver = 3; before PBS = 4 - -# --- Additional attenuation (transmission of the ND-filter) during the calibration -TCalT, dTCalT, nTCalT = 1, 0., 0 # transmitting path; error calc not working yet -TCalR, dTCalR, nTCalR = 1, 0., 0 # reflecting path; error calc not working yet - -# *** signal noise error calculation -# --- number of photon counts in the signal summed up in the calibration range during the calibration measurements -NCalT = 1e6 # default 1e6, assumed the same in +45° and -45° signals -NCalR = 1e6 # default 1e6, assumed the same in +45° and -45° signals -NILfac = 1.0 # duration of standard (0°) measurement relative to calibration measurements -nNCal = 0 # error nNCal: one-sigma in steps to left and right for calibration signals -nNI = 0 # error nNI: one-sigma in steps to left and right for 0° signals -NI = 50000 #number of photon counts in the parallel 0°-signal -eFacT = 1.0 # rel. amplification of transmitted channel, approximate values are sufficient; def. = 1 -eFacR = 10.0 -IoutTp0, IoutTp, dIoutTp0 = 0.5, 0.5, 0.0 -IoutTm0, IoutTm, dIoutTm0 = 0.5, 0.5, 0.0 -IoutRp0, IoutRp, dIoutRp0 = 0.5, 0.5, 0.0 -IoutRm0, IoutRm, dIoutRm0 = 0.5, 0.5, 0.0 -It0, It, dIt0 = 1 , 1, 0 -Ir0, Ir, dTr0 = 1 , 1, 0 -CalcFrom0deg = True - -TypeC = 3 # linear polarizer calibrator -# example with extinction ratio 0.001 -DiC, dDiC, nDiC = 1.0, 0., 0 # ideal 1.0 -TiC = 0.5 # ideal 0.5 -RetC, dRetC, nRetC = 0.0, 0.0, 0 -RotC, dRotC, nRotC = 0.0, 0.1, 0 # constant calibrator offset epsilon -RotationErrorEpsilonForNormalMeasurements = False # is in general False for TypeC == 3 calibrator - -# Rotation error without calibrator: if False, then epsilon = 0 for normal measurements -RotationErrorEpsilonForNormalMeasurements = True -# BSR backscatter ratio -# BSR, dBSR, nBSR = 10, 0.05, 1 -BSR = np.zeros(5) -BSR = [1.1, 2, 5, 10., 50.] -# theoretical molecular LDR LDRm -LDRm, dLDRm, nLDRm = 0.004, 0.001, 1 -# LDRCal assumed atmospheric linear depolarization ratio during the calibration measurements (first guess) -LDRCal0, dLDRCal, nLDRCal = 0.25, 0.04, 1 -LDRCal = LDRCal0 -# measured LDRm will be corrected with calculated parameters -LDRmeas = 0.015 -# LDRtrue for simulation of measurement => LDRsim -LDRtrue = 0.004 -LDRtrue2 = 0.004 -LDRunCorr = 1. -# Initialize other values to 0 -ER, nER, dER = 0.001, 0, 0.001 -K = 0. -Km = 0. -Kp = 0. -LDRCorr = 0. -Eta = 0. -Ir = 0. -It = 0. -h = 1. - -Loc = ['', 'behind the laser', 'behind the emitter', 'before the receiver', 'before the PBS'] -Type = ['', 'Mechanical rotator', 'HWP rotator', 'Linear polarizer', 'QWP rotator', 'Circular polarizer', - 'real HWP +-22.5°'] - -bPlotEtax = False - -# end of initial definition of variables -# ******************************************************************************************************************************* -# --- Read actual lidar system parameters from optic_input.py (must be in the programs sub-directory 'system_settings') -# ******************************************************************************************************************************* - -# InputFile = 'optic_input_0.9.8e4-PollyXT_Lacros.py' -InputFile = 'optic_input_example_lidar_ver0.9.8e.py' -InputFile = 'calibrator-test-1-ver0.9.8e.py' -InputFile = 'optic_input_0.9.8e4-BRC-532.py' -InputFile = '' -InputFile = '' -InputFile = '' -InputFile = 'RALI-may2020-X.py' -InputFile = 'mulhacen_run_532xp-bias.py' - - -# ******************************************************************************************************************************* - -''' -print("From ", dname) -print("Running ", fname) -print("Reading input file ", InputFile, " for") -''' -input_path = os.path.join('.', 'system_settings', InputFile) -# this works with Python 2 and 3! -exec(open(input_path).read(), globals()) -# end of read actual system parameters - - -# --- Manual Parameter Change --- -# (use for quick parameter changes without changing the input file ) -# DiO = 0. -# LDRtrue = 0.45 -# LDRtrue2 = 0.004 -# Y = -1 -# LocC = 4 #location of calibrator: 1 = behind laser; 2 = behind emitter; 3 = before receiver; 4 = before PBS -# #TypeC = 6 Don't change the TypeC here -# RotationErrorEpsilonForNormalMeasurements = True -# LDRCal = 0.25 -# # --- Errors -Qin0, dQin, nQin = Qin, dQin, nQin -Vin0, dVin, nVin = Vin, dVin, nVin -RotL0, dRotL, nRotL = RotL, dRotL, nRotL - -DiE0, dDiE, nDiE = DiE, dDiE, nDiE -RetE0, dRetE, nRetE = RetE, dRetE, nRetE -RotE0, dRotE, nRotE = RotE, dRotE, nRotE - -DiO0, dDiO, nDiO = DiO, dDiO, nDiO -RetO0, dRetO, nRetO = RetO, dRetO, nRetO -RotO0, dRotO, nRotO = RotO, dRotO, nRotO - -DiC0, dDiC, nDiC = DiC, dDiC, nDiC -RetC0, dRetC, nRetC = RetC, dRetC, nRetC -RotC0, dRotC, nRotC = RotC, dRotC, nRotC - -TP0, dTP, nTP = TP, dTP, nTP -TS0, dTS, nTS = TS, dTS, nTS -RetT0, dRetT, nRetT = RetT, dRetT, nRetT - -ERaT0, dERaT, nERaT = ERaT, dERaT, nERaT -RotaT0, dRotaT, nRotaT = RotaT, dRotaT, nRotaT - -RP0, dRP, nRP = RP, dRP, nRP -RS0, dRS, nRS = RS, dRS, nRS -RetR0, dRetR, nRetR = RetR, dRetR, nRetR - -ERaR0, dERaR, nERaR = ERaR, dERaR, nERaR -RotaR0, dRotaR, nRotaR = RotaR, dRotaR, nRotaR - -LDRCal0, dLDRCal, nLDRCal = LDRCal, dLDRCal, nLDRCal - -# BSR0, dBSR, nBSR = BSR, dBSR, nBSR -LDRm0, dLDRm, nLDRm = LDRm, dLDRm, nLDRm -# ---------- End of manual parameter change - -RotL, RotE, RetE, DiE, RotO, RetO, DiO, RotC, RetC, DiC = RotL0, RotE0, RetE0, DiE0, RotO0, RetO0, DiO0, RotC0, RetC0, DiC0 -TP, TS, RP, RS, ERaT, RotaT, RetT, ERaR, RotaR, RetR = TP0, TS0, RP0, RS0, ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0 -LDRCal = LDRCal0 -DTa0, TTa0, DRa0, TRa0, LDRsimx, LDRCorr = 0., 0., 0., 0., 0., 0. -TCalT0, TCalR0 = TCalT, TCalR - -TiT = 0.5 * (TP + TS) -DiT = (TP - TS) / (TP + TS) -ZiT = (1. - DiT ** 2) ** 0.5 -TiR = 0.5 * (RP + RS) -DiR = (RP - RS) / (RP + RS) -ZiR = (1. - DiR ** 2) ** 0.5 - -C2aT = np.cos(np.deg2rad(2. * RotaT)) -C2aR = np.cos(np.deg2rad(2. * RotaR)) -ATPT = float(1. + C2aT * DaT * DiT) -ARPT = float(1. + C2aR * DaR * DiR) -TTa = TiT * TaT * ATPT # unpolarized transmission -TRa = TiR * TaR * ARPT # unpolarized transmission -Eta0 = TRa / TTa - -# --- alternative texts for output -dY = ['perpendicular', '', 'parallel'] -dY2 = ['reflected', '', 'transmitted'] -if ((abs(RotL) < 45 and Y == 1) or (abs(RotL) >= 45 and Y == -1)): - dY3 = "the parallel laser polarisation is detected in the transmitted channel." -else: - dY3 = "the parallel laser polarisation is detected in the reflected channel." - -# --- check input errors -if ((Qin ** 2 + Vin ** 2) ** 0.5) > 1: - print("Error: degree of polarisation of laser > 1. Check Qin and Vin! ") - sys.exit() - -# --- this subroutine is for the calculation of the PLDR from LDR, BSR, and LDRm ------------------- -def CalcPLDR(LDR, BSR, LDRm): - PLDR = (BSR * (1. + LDRm) * LDR - LDRm * (1. + LDR)) / (BSR * (1. + LDRm) - (1. + LDR)) - return (PLDR) -# --- this subroutine is for the calculation with certain fixed parameters ------------------------ -def Calc(TCalT, TCalR, NCalT, NCalR, Qin, Vin, RotL, RotE, RetE, DiE, RotO, RetO, DiO, - RotC, RetC, DiC, TP, TS, RP, RS, - ERaT, RotaT, RetT, ERaR, RotaR, RetR, LDRCal): - # ---- Do the calculations of bra-ket vectors - h = -1. if TypeC == 2 else 1 - # from input file: assumed LDRCal for calibration measurements - aCal = (1. - LDRCal) / (1. + LDRCal) - atrue = (1. - LDRtrue) / (1. + LDRtrue) - - # angles of emitter and laser and calibrator and receiver optics - # RotL = alpha, RotE = beta, RotO = gamma, RotC = epsilon - S2a = np.sin(2 * np.deg2rad(RotL)) - C2a = np.cos(2 * np.deg2rad(RotL)) - S2b = np.sin(2 * np.deg2rad(RotE)) - C2b = np.cos(2 * np.deg2rad(RotE)) - S2ab = np.sin(np.deg2rad(2 * RotL - 2 * RotE)) - C2ab = np.cos(np.deg2rad(2 * RotL - 2 * RotE)) - S2g = np.sin(np.deg2rad(2 * RotO)) - C2g = np.cos(np.deg2rad(2 * RotO)) - - # Laser with Degree of linear polarization DOLP - IinL = 1. - QinL = Qin - UinL = 0. - VinL = Vin - # VinL = (1. - DOLP ** 2) ** 0.5 - - # Stokes Input Vector rotation Eq. E.4 - A = C2a * QinL - S2a * UinL - B = S2a * QinL + C2a * UinL - # Stokes Input Vector rotation Eq. E.9 - C = C2ab * QinL - S2ab * UinL - D = S2ab * QinL + C2ab * UinL - - # emitter optics - CosE = np.cos(np.deg2rad(RetE)) - SinE = np.sin(np.deg2rad(RetE)) - ZiE = (1. - DiE ** 2) ** 0.5 - WiE = (1. - ZiE * CosE) - - # Stokes Input Vector after emitter optics equivalent to Eq. E.9 with already rotated input vector from Eq. E.4 - # b = beta - IinE = (IinL + DiE * C) - QinE = (C2b * DiE * IinL + A + S2b * (WiE * D - ZiE * SinE * VinL)) - UinE = (S2b * DiE * IinL + B - C2b * (WiE * D - ZiE * SinE * VinL)) - VinE = (-ZiE * SinE * D + ZiE * CosE * VinL) - - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - IinF = IinE - QinF = aCal * QinE - UinF = -aCal * UinE - VinF = (1. - 2. * aCal) * VinE - - # receiver optics - CosO = np.cos(np.deg2rad(RetO)) - SinO = np.sin(np.deg2rad(RetO)) - ZiO = (1. - DiO ** 2) ** 0.5 - WiO = (1. - ZiO * CosO) - - # calibrator - CosC = np.cos(np.deg2rad(RetC)) - SinC = np.sin(np.deg2rad(RetC)) - ZiC = (1. - DiC ** 2) ** 0.5 - WiC = (1. - ZiC * CosC) - - # Stokes Input Vector before the polarising beam splitter Eq. E.31 - A = C2g * QinE - S2g * UinE - B = S2g * QinE + C2g * UinE - - IinP = (IinE + DiO * aCal * A) - QinP = (C2g * DiO * IinE + aCal * QinE - S2g * (WiO * aCal * B + ZiO * SinO * (1. - 2. * aCal) * VinE)) - UinP = (S2g * DiO * IinE - aCal * UinE + C2g * (WiO * aCal * B + ZiO * SinO * (1. - 2. * aCal) * VinE)) - VinP = (ZiO * SinO * aCal * B + ZiO * CosO * (1. - 2. * aCal) * VinE) - - # ------------------------- - # F11 assuemd to be = 1 => measured: F11m = IinP / IinE with atrue - # F11sim = TiO*(IinE + DiO*atrue*A)/IinE - # ------------------------- - - # analyser - if (RS_RP_depend_on_TS_TP): - RS = 1. - TS - RP = 1. - TP - - TiT = 0.5 * (TP + TS) - DiT = (TP - TS) / (TP + TS) - ZiT = (1. - DiT ** 2) ** 0.5 - TiR = 0.5 * (RP + RS) - DiR = (RP - RS) / (RP + RS) - ZiR = (1. - DiR ** 2) ** 0.5 - CosT = np.cos(np.deg2rad(RetT)) - SinT = np.sin(np.deg2rad(RetT)) - CosR = np.cos(np.deg2rad(RetR)) - SinR = np.sin(np.deg2rad(RetR)) - - DaT = (1. - ERaT) / (1. + ERaT) - DaR = (1. - ERaR) / (1. + ERaR) - TaT = 0.5 * (1. + ERaT) - TaR = 0.5 * (1. + ERaR) - - S2aT = np.sin(np.deg2rad(h * 2 * RotaT)) - C2aT = np.cos(np.deg2rad(2 * RotaT)) - S2aR = np.sin(np.deg2rad(h * 2 * RotaR)) - C2aR = np.cos(np.deg2rad(2 * RotaR)) - - # Analyzer As before the PBS Eq. D.5; combined PBS and cleaning pol-filter - ATPT = (1. + C2aT * DaT * DiT) # unpolarized transmission correction - TTa = TiT * TaT * ATPT # unpolarized transmission - ATP1 = 1. - ATP2 = Y * (DiT + C2aT * DaT) / ATPT - ATP3 = Y * S2aT * DaT * ZiT * CosT / ATPT - ATP4 = S2aT * DaT * ZiT * SinT / ATPT - ATP = np.array([ATP1, ATP2, ATP3, ATP4]) - DTa = ATP2 * Y - - ARPT = (1 + C2aR * DaR * DiR) # unpolarized transmission correction - TRa = TiR * TaR * ARPT # unpolarized transmission - ARP1 = 1 - ARP2 = Y * (DiR + C2aR * DaR) / ARPT - ARP3 = Y * S2aR * DaR * ZiR * CosR / ARPT - ARP4 = S2aR * DaR * ZiR * SinR / ARPT - ARP = np.array([ARP1, ARP2, ARP3, ARP4]) - DRa = ARP2 * Y - - - # ---- Calculate signals and correction parameters for diffeent locations and calibrators - if LocC == 4: # Calibrator before the PBS - # print("Calibrator location not implemented yet") - - # S2ge = np.sin(np.deg2rad(2*RotO + h*2*RotC)) - # C2ge = np.cos(np.deg2rad(2*RotO + h*2*RotC)) - S2e = np.sin(np.deg2rad(h * 2 * RotC)) - C2e = np.cos(np.deg2rad(2 * RotC)) - # rotated AinP by epsilon Eq. C.3 - ATP2e = C2e * ATP2 + S2e * ATP3 - ATP3e = C2e * ATP3 - S2e * ATP2 - ARP2e = C2e * ARP2 + S2e * ARP3 - ARP3e = C2e * ARP3 - S2e * ARP2 - ATPe = np.array([ATP1, ATP2e, ATP3e, ATP4]) - ARPe = np.array([ARP1, ARP2e, ARP3e, ARP4]) - # Stokes Input Vector before the polarising beam splitter Eq. E.31 - A = C2g * QinE - S2g * UinE - B = S2g * QinE + C2g * UinE - # C = (WiO*aCal*B + ZiO*SinO*(1-2*aCal)*VinE) - Co = ZiO * SinO * VinE - Ca = (WiO * B - 2 * ZiO * SinO * VinE) - # C = Co + aCal*Ca - # IinP = (IinE + DiO*aCal*A) - # QinP = (C2g*DiO*IinE + aCal*QinE - S2g*C) - # UinP = (S2g*DiO*IinE - aCal*UinE + C2g*C) - # VinP = (ZiO*SinO*aCal*B + ZiO*CosO*(1-2*aCal)*VinE) - IinPo = IinE - QinPo = (C2g * DiO * IinE - S2g * Co) - UinPo = (S2g * DiO * IinE + C2g * Co) - VinPo = ZiO * CosO * VinE - - IinPa = DiO * A - QinPa = QinE - S2g * Ca - UinPa = -UinE + C2g * Ca - VinPa = ZiO * (SinO * B - 2 * CosO * VinE) - - IinP = IinPo + aCal * IinPa - QinP = QinPo + aCal * QinPa - UinP = UinPo + aCal * UinPa - VinP = VinPo + aCal * VinPa - # Stokes Input Vector before the polarising beam splitter rotated by epsilon Eq. C.3 - # QinPe = C2e*QinP + S2e*UinP - # UinPe = C2e*UinP - S2e*QinP - QinPoe = C2e * QinPo + S2e * UinPo - UinPoe = C2e * UinPo - S2e * QinPo - QinPae = C2e * QinPa + S2e * UinPa - UinPae = C2e * UinPa - S2e * QinPa - QinPe = C2e * QinP + S2e * UinP - UinPe = C2e * UinP - S2e * QinP - - # Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # rotator calibration Eq. C.4 - # parameters for calibration with aCal - AT = ATP1 * IinP + h * ATP4 * VinP - BT = ATP3e * QinP - h * ATP2e * UinP - AR = ARP1 * IinP + h * ARP4 * VinP - BR = ARP3e * QinP - h * ARP2e * UinP - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATPe, IS1) - GR = np.dot(ARPe, IS1) - HT = np.dot(ATPe, IS2) - HR = np.dot(ARPe, IS2) - elif (TypeC == 3) or (TypeC == 4): # linear polariser calibration Eq. C.5 - # parameters for calibration with aCal - AT = ATP1 * IinP + ATP3e * UinPe + ZiC * CosC * (ATP2e * QinPe + ATP4 * VinP) - BT = DiC * (ATP1 * UinPe + ATP3e * IinP) - ZiC * SinC * (ATP2e * VinP - ATP4 * QinPe) - AR = ARP1 * IinP + ARP3e * UinPe + ZiC * CosC * (ARP2e * QinPe + ARP4 * VinP) - BR = DiC * (ARP1 * UinPe + ARP3e * IinP) - ZiC * SinC * (ARP2e * VinP - ARP4 * QinPe) - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1e = np.array([IinPo + DiC * QinPoe, DiC * IinPo + QinPoe, ZiC * (CosC * UinPoe + SinC * VinPo), - -ZiC * (SinC * UinPoe - CosC * VinPo)]) - IS2e = np.array([IinPa + DiC * QinPae, DiC * IinPa + QinPae, ZiC * (CosC * UinPae + SinC * VinPa), - -ZiC * (SinC * UinPae - CosC * VinPa)]) - GT = np.dot(ATPe, IS1e) - GR = np.dot(ARPe, IS1e) - HT = np.dot(ATPe, IS2e) - HR = np.dot(ARPe, IS2e) - elif (TypeC == 6): # diattenuator calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # parameters for calibration with aCal - AT = ATP1 * IinP + sqr05 * DiC * (ATP1 * QinPe + ATP2e * IinP) + (1. - 0.5 * WiC) * ( - ATP2e * QinPe + ATP3e * UinPe) + ZiC * (sqr05 * SinC * (ATP3e * VinP - ATP4 * UinPe) + ATP4 * CosC * VinP) - BT = sqr05 * DiC * (ATP1 * UinPe + ATP3e * IinP) + 0.5 * WiC * ( - ATP2e * UinPe + ATP3e * QinPe) - sqr05 * ZiC * SinC * (ATP2e * VinP - ATP4 * QinPe) - AR = ARP1 * IinP + sqr05 * DiC * (ARP1 * QinPe + ARP2e * IinP) + (1. - 0.5 * WiC) * ( - ARP2e * QinPe + ARP3e * UinPe) + ZiC * (sqr05 * SinC * (ARP3e * VinP - ARP4 * UinPe) + ARP4 * CosC * VinP) - BR = sqr05 * DiC * (ARP1 * UinPe + ARP3e * IinP) + 0.5 * WiC * ( - ARP2e * UinPe + ARP3e * QinPe) - sqr05 * ZiC * SinC * (ARP2e * VinP - ARP4 * QinPe) - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1e = np.array([IinPo + DiC * QinPoe, DiC * IinPo + QinPoe, ZiC * (CosC * UinPoe + SinC * VinPo), - -ZiC * (SinC * UinPoe - CosC * VinPo)]) - IS2e = np.array([IinPa + DiC * QinPae, DiC * IinPa + QinPae, ZiC * (CosC * UinPae + SinC * VinPa), - -ZiC * (SinC * UinPae - CosC * VinPa)]) - GT = np.dot(ATPe, IS1e) - GR = np.dot(ARPe, IS1e) - HT = np.dot(ATPe, IS2e) - HR = np.dot(ARPe, IS2e) - else: - print("Calibrator not implemented yet") - sys.exit() - - elif LocC == 3: # C before receiver optics Eq.57 - - # S2ge = np.sin(np.deg2rad(2*RotO - 2*RotC)) - # C2ge = np.cos(np.deg2rad(2*RotO - 2*RotC)) - S2e = np.sin(np.deg2rad(2. * RotC)) - C2e = np.cos(np.deg2rad(2. * RotC)) - - # As with C before the receiver optics (rotated_diattenuator_X22x5deg.odt) - AF1 = np.array([1., C2g * DiO, S2g * DiO, 0.]) - AF2 = np.array([C2g * DiO, 1. - S2g ** 2 * WiO, S2g * C2g * WiO, -S2g * ZiO * SinO]) - AF3 = np.array([S2g * DiO, S2g * C2g * WiO, 1. - C2g ** 2 * WiO, C2g * ZiO * SinO]) - AF4 = np.array([0., S2g * SinO, -C2g * SinO, CosO]) - - ATF = (ATP1 * AF1 + ATP2 * AF2 + ATP3 * AF3 + ATP4 * AF4) - ARF = (ARP1 * AF1 + ARP2 * AF2 + ARP3 * AF3 + ARP4 * AF4) - ATF2 = ATF[1] - ATF3 = ATF[2] - ARF2 = ARF[1] - ARF3 = ARF[2] - - # rotated AinF by epsilon - ATF1 = ATF[0] - ATF4 = ATF[3] - ATF2e = C2e * ATF[1] + S2e * ATF[2] - ATF3e = C2e * ATF[2] - S2e * ATF[1] - ARF1 = ARF[0] - ARF4 = ARF[3] - ARF2e = C2e * ARF[1] + S2e * ARF[2] - ARF3e = C2e * ARF[2] - S2e * ARF[1] - - ATFe = np.array([ATF1, ATF2e, ATF3e, ATF4]) - ARFe = np.array([ARF1, ARF2e, ARF3e, ARF4]) - - QinEe = C2e * QinE + S2e * UinE - UinEe = C2e * UinE - S2e * QinE - - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - IinF = IinE - QinF = aCal * QinE - UinF = -aCal * UinE - VinF = (1. - 2. * aCal) * VinE - - IinFo = IinE - QinFo = 0. - UinFo = 0. - VinFo = VinE - - IinFa = 0. - QinFa = QinE - UinFa = -UinE - VinFa = -2. * VinE - - # Stokes Input Vector before receiver optics rotated by epsilon Eq. C.3 - QinFe = C2e * QinF + S2e * UinF - UinFe = C2e * UinF - S2e * QinF - QinFoe = C2e * QinFo + S2e * UinFo - UinFoe = C2e * UinFo - S2e * QinFo - QinFae = C2e * QinFa + S2e * UinFa - UinFae = C2e * UinFa - S2e * QinFa - - # Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # rotator calibration Eq. C.4 - # parameters for calibration with aCal - AT = ATF1 * IinF + ATF4 * h * VinF - BT = ATF3e * QinF - ATF2e * h * UinF - AR = ARF1 * IinF + ARF4 * h * VinF - BR = ARF3e * QinF - ARF2e * h * UinF - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - GT = ATF1 * IinE + ATF4 * VinE - GR = ARF1 * IinE + ARF4 * VinE - HT = ATF2 * QinE - ATF3 * UinE - ATF4 * 2 * VinE - HR = ARF2 * QinE - ARF3 * UinE - ARF4 * 2 * VinE - else: - GT = ATF1 * IinE + ATF4 * h * VinE - GR = ARF1 * IinE + ARF4 * h * VinE - HT = ATF2e * QinE - ATF3e * h * UinE - ATF4 * h * 2 * VinE - HR = ARF2e * QinE - ARF3e * h * UinE - ARF4 * h * 2 * VinE - elif (TypeC == 3) or (TypeC == 4): # linear polariser calibration Eq. C.5 - # p = +45°, m = -45° - IF1e = np.array([IinF, ZiC * CosC * QinFe, UinFe, ZiC * CosC * VinF]) - IF2e = np.array([DiC * UinFe, -ZiC * SinC * VinF, DiC * IinF, ZiC * SinC * QinFe]) - AT = np.dot(ATFe, IF1e) - AR = np.dot(ARFe, IF1e) - BT = np.dot(ATFe, IF2e) - BR = np.dot(ARFe, IF2e) - - # Correction parameters for normal measurements; they are independent of LDR --- the same as for TypeC = 6 - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinE, 0., 0., VinE]) - IS2 = np.array([0., QinE, -UinE, -2. * VinE]) - GT = np.dot(ATF, IS1) - GR = np.dot(ARF, IS1) - HT = np.dot(ATF, IS2) - HR = np.dot(ARF, IS2) - else: - IS1e = np.array([IinFo + DiC * QinFoe, DiC * IinFo + QinFoe, ZiC * (CosC * UinFoe + SinC * VinFo), - -ZiC * (SinC * UinFoe - CosC * VinFo)]) - IS2e = np.array([IinFa + DiC * QinFae, DiC * IinFa + QinFae, ZiC * (CosC * UinFae + SinC * VinFa), - -ZiC * (SinC * UinFae - CosC * VinFa)]) - GT = np.dot(ATFe, IS1e) - GR = np.dot(ARFe, IS1e) - HT = np.dot(ATFe, IS2e) - HR = np.dot(ARFe, IS2e) - - elif (TypeC == 6): # diattenuator calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # parameters for calibration with aCal - IF1e = np.array([IinF + sqr05 * DiC * QinFe, sqr05 * DiC * IinF + (1. - 0.5 * WiC) * QinFe, - (1. - 0.5 * WiC) * UinFe + sqr05 * ZiC * SinC * VinF, - -sqr05 * ZiC * SinC * UinFe + ZiC * CosC * VinF]) - IF2e = np.array([sqr05 * DiC * UinFe, 0.5 * WiC * UinFe - sqr05 * ZiC * SinC * VinF, - sqr05 * DiC * IinF + 0.5 * WiC * QinFe, sqr05 * ZiC * SinC * QinFe]) - AT = np.dot(ATFe, IF1e) - AR = np.dot(ARFe, IF1e) - BT = np.dot(ATFe, IF2e) - BR = np.dot(ARFe, IF2e) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - # IS1 = np.array([IinE,0,0,VinE]) - # IS2 = np.array([0,QinE,-UinE,-2*VinE]) - IS1 = np.array([IinFo, 0., 0., VinFo]) - IS2 = np.array([0., QinFa, UinFa, VinFa]) - GT = np.dot(ATF, IS1) - GR = np.dot(ARF, IS1) - HT = np.dot(ATF, IS2) - HR = np.dot(ARF, IS2) - else: - IS1e = np.array([IinFo + DiC * QinFoe, DiC * IinFo + QinFoe, ZiC * (CosC * UinFoe + SinC * VinFo), - -ZiC * (SinC * UinFoe - CosC * VinFo)]) - IS2e = np.array([IinFa + DiC * QinFae, DiC * IinFa + QinFae, ZiC * (CosC * UinFae + SinC * VinFa), - -ZiC * (SinC * UinFae - CosC * VinFa)]) - # IS1e = np.array([IinFo,0,0,VinFo]) - # IS2e = np.array([0,QinFae,UinFae,VinFa]) - GT = np.dot(ATFe, IS1e) - GR = np.dot(ARFe, IS1e) - HT = np.dot(ATFe, IS2e) - HR = np.dot(ARFe, IS2e) - - else: - print('Calibrator not implemented yet') - sys.exit() - - elif LocC == 2: # C behind emitter optics Eq.57 ------------------------------------------------------- - # print("Calibrator location not implemented yet") - S2e = np.sin(np.deg2rad(2. * RotC)) - C2e = np.cos(np.deg2rad(2. * RotC)) - - # AS with C before the receiver optics (see document rotated_diattenuator_X22x5deg.odt) - AF1 = np.array([1, C2g * DiO, S2g * DiO, 0.]) - AF2 = np.array([C2g * DiO, 1. - S2g ** 2 * WiO, S2g * C2g * WiO, -S2g * ZiO * SinO]) - AF3 = np.array([S2g * DiO, S2g * C2g * WiO, 1. - C2g ** 2 * WiO, C2g * ZiO * SinO]) - AF4 = np.array([0., S2g * SinO, -C2g * SinO, CosO]) - - ATF = (ATP1 * AF1 + ATP2 * AF2 + ATP3 * AF3 + ATP4 * AF4) - ARF = (ARP1 * AF1 + ARP2 * AF2 + ARP3 * AF3 + ARP4 * AF4) - ATF1 = ATF[0] - ATF2 = ATF[1] - ATF3 = ATF[2] - ATF4 = ATF[3] - ARF1 = ARF[0] - ARF2 = ARF[1] - ARF3 = ARF[2] - ARF4 = ARF[3] - - # AS with C behind the emitter - # terms without aCal - ATE1o, ARE1o = ATF1, ARF1 - ATE2o, ARE2o = 0., 0. - ATE3o, ARE3o = 0., 0. - ATE4o, ARE4o = ATF4, ARF4 - # terms with aCal - ATE1a, ARE1a = 0., 0. - ATE2a, ARE2a = ATF2, ARF2 - ATE3a, ARE3a = -ATF3, -ARF3 - ATE4a, ARE4a = -2. * ATF4, -2. * ARF4 - # rotated AinEa by epsilon - ATE2ae = C2e * ATF2 + S2e * ATF3 - ATE3ae = -S2e * ATF2 - C2e * ATF3 - ARE2ae = C2e * ARF2 + S2e * ARF3 - ARE3ae = -S2e * ARF2 - C2e * ARF3 - - ATE1 = ATE1o - ATE2e = aCal * ATE2ae - ATE3e = aCal * ATE3ae - ATE4 = (1 - 2 * aCal) * ATF4 - ARE1 = ARE1o - ARE2e = aCal * ARE2ae - ARE3e = aCal * ARE3ae - ARE4 = (1 - 2 * aCal) * ARF4 - - # rotated IinE - QinEe = C2e * QinE + S2e * UinE - UinEe = C2e * UinE - S2e * QinE - - # Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # +++++++++ rotator calibration Eq. C.4 - AT = ATE1o * IinE + (ATE4o + aCal * ATE4a) * h * VinE - BT = aCal * (ATE3ae * QinEe - ATE2ae * h * UinEe) - AR = ARE1o * IinE + (ARE4o + aCal * ARE4a) * h * VinE - BR = aCal * (ARE3ae * QinEe - ARE2ae * h * UinEe) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - GT = ATE1o * IinE + ATE4o * h * VinE - GR = ARE1o * IinE + ARE4o * h * VinE - HT = ATE2a * QinE + ATE3a * h * UinEe + ATE4a * h * VinE - HR = ARE2a * QinE + ARE3a * h * UinEe + ARE4a * h * VinE - else: - GT = ATE1o * IinE + ATE4o * h * VinE - GR = ARE1o * IinE + ARE4o * h * VinE - HT = ATE2ae * QinE + ATE3ae * h * UinEe + ATE4a * h * VinE - HR = ARE2ae * QinE + ARE3ae * h * UinEe + ARE4a * h * VinE - - elif (TypeC == 3) or (TypeC == 4): # +++++++++ linear polariser calibration Eq. C.5 - # p = +45°, m = -45° - AT = ATE1 * IinE + ZiC * CosC * (ATE2e * QinEe + ATE4 * VinE) + ATE3e * UinEe - BT = DiC * (ATE1 * UinEe + ATE3e * IinE) + ZiC * SinC * (ATE4 * QinEe - ATE2e * VinE) - AR = ARE1 * IinE + ZiC * CosC * (ARE2e * QinEe + ARE4 * VinE) + ARE3e * UinEe - BR = DiC * (ARE1 * UinEe + ARE3e * IinE) + ZiC * SinC * (ARE4 * QinEe - ARE2e * VinE) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - GT = ATE1o * IinE + ATE4o * VinE - GR = ARE1o * IinE + ARE4o * VinE - HT = ATE2a * QinE + ATE3a * UinE + ATE4a * VinE - HR = ARE2a * QinE + ARE3a * UinE + ARE4a * VinE - else: - D = IinE + DiC * QinEe - A = DiC * IinE + QinEe - B = ZiC * (CosC * UinEe + SinC * VinE) - C = -ZiC * (SinC * UinEe - CosC * VinE) - GT = ATE1o * D + ATE4o * C - GR = ARE1o * D + ARE4o * C - HT = ATE2a * A + ATE3a * B + ATE4a * C - HR = ARE2a * A + ARE3a * B + ARE4a * C - - elif (TypeC == 6): # real HWP calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # p = +22.5°, m = -22.5° - IE1e = np.array([IinE + sqr05 * DiC * QinEe, sqr05 * DiC * IinE + (1 - 0.5 * WiC) * QinEe, - (1 - 0.5 * WiC) * UinEe + sqr05 * ZiC * SinC * VinE, - -sqr05 * ZiC * SinC * UinEe + ZiC * CosC * VinE]) - IE2e = np.array([sqr05 * DiC * UinEe, 0.5 * WiC * UinEe - sqr05 * ZiC * SinC * VinE, - sqr05 * DiC * IinE + 0.5 * WiC * QinEe, sqr05 * ZiC * SinC * QinEe]) - ATEe = np.array([ATE1, ATE2e, ATE3e, ATE4]) - AREe = np.array([ARE1, ARE2e, ARE3e, ARE4]) - AT = np.dot(ATEe, IE1e) - AR = np.dot(AREe, IE1e) - BT = np.dot(ATEe, IE2e) - BR = np.dot(AREe, IE2e) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - GT = ATE1o * IinE + ATE4o * VinE - GR = ARE1o * IinE + ARE4o * VinE - HT = ATE2a * QinE + ATE3a * UinE + ATE4a * VinE - HR = ARE2a * QinE + ARE3a * UinE + ARE4a * VinE - else: - D = IinE + DiC * QinEe - A = DiC * IinE + QinEe - B = ZiC * (CosC * UinEe + SinC * VinE) - C = -ZiC * (SinC * UinEe - CosC * VinE) - GT = ATE1o * D + ATE4o * C - GR = ARE1o * D + ARE4o * C - HT = ATE2a * A + ATE3a * B + ATE4a * C - HR = ARE2a * A + ARE3a * B + ARE4a * C - - else: - print('Calibrator not implemented yet') - sys.exit() - - else: - print("Calibrator location not implemented yet") - sys.exit() - - # Determination of the correction K of the calibration factor. - IoutTp = TTa * TiC * TiO * TiE * (AT + BT) - IoutTm = TTa * TiC * TiO * TiE * (AT - BT) - IoutRp = TRa * TiC * TiO * TiE * (AR + BR) - IoutRm = TRa * TiC * TiO * TiE * (AR - BR) - # --- Results and Corrections; electronic etaR and etaT are assumed to be 1 - Etapx = IoutRp / IoutTp - Etamx = IoutRm / IoutTm - Etax = (Etapx * Etamx) ** 0.5 - - Eta = (TRa / TTa) # = TRa / TTa; Eta = Eta*/K Eq. 84 => K = Eta* / Eta; equation corrected according to the papers supplement Eqs. (S.10.10.1) ff - K = Etax / Eta - - # For comparison with Volkers Libreoffice Müller Matrix spreadsheet - # Eta_test_p = (IoutRp/IoutTp) - # Eta_test_m = (IoutRm/IoutTm) - # Eta_test = (Eta_test_p*Eta_test_m)**0.5 - - # ----- random error calculation ---------- - # noise must be calculated with the photon counts of measured signals; - # relative standard deviation of calibration signals with LDRcal; assumed to be statisitcally independent - # normalised noise errors - if (CalcFrom0deg): - dIoutTp = (NCalT * IoutTp) ** -0.5 - dIoutTm = (NCalT * IoutTm) ** -0.5 - dIoutRp = (NCalR * IoutRp) ** -0.5 - dIoutRm = (NCalR * IoutRm) ** -0.5 - else: - dIoutTp = (NCalT ** -0.5) - dIoutTm = (NCalT ** -0.5) - dIoutRp = (NCalR ** -0.5) - dIoutRm = (NCalR ** -0.5) - # Forward simulated 0°-signals with LDRCal with atrue; from input file - - It = TTa * TiO * TiE * (GT + atrue * HT) - Ir = TRa * TiO * TiE * (GR + atrue * HR) - # relative standard deviation of standard signals with LDRmeas; assumed to be statisitcally independent - if (CalcFrom0deg): # this works! - dIt = ((It * NI * eFacT) ** -0.5) - dIr = ((Ir * NI * eFacR) ** -0.5) - ''' - dIt = ((NCalT * It / IoutTp * NILfac / TCalT) ** -0.5) - dIr = ((NCalR * Ir / IoutRp * NILfac / TCalR) ** -0.5) - ''' - else: # does this work? Why not as above? - dIt = ((NCalT * 2 * NILfac / TCalT ) ** -0.5) - dIr = ((NCalR * 2 * NILfac / TCalR) ** -0.5) - - # ----- Forward simulated LDRsim = 1/Eta*Ir/It # simulated LDR* with Y from input file - LDRsim = Ir / It # simulated uncorrected LDR with Y from input file - # Corrected LDRsimCorr from forward simulated LDRsim (atrue) - # LDRsimCorr = (1./Eta*LDRsim*(GT+HT)-(GR+HR))/((GR-HR)-1./Eta*LDRsim*(GT-HT)) - ''' - if ((Y == -1.) and (abs(RotL0) < 45)) or ((Y == +1.) and (abs(RotL0) > 45)): - LDRsimx = 1. / LDRsim / Etax - else: - LDRsimx = LDRsim / Etax - ''' - LDRsimx = LDRsim - - # The following is correct without doubt - # LDRCorr = (LDRsim/(Etax/K)*(GT+HT)-(GR+HR))/((GR-HR)-LDRsim/(Etax/K)*(GT-HT)) - - # The following is a test whether the equations for calibration Etax and normal signal (GHK, LDRsim) are consistent - LDRCorr = (LDRsim / (Etax / K) * (GT + HT) - (GR + HR)) / ((GR - HR) - LDRsim / (Etax / K) * (GT - HT)) - # here we could also use Eta instead of Etax / K => how to test whether Etax is correct? => comparison with MüllerMatrix simulation! - # Without any correction: only measured It, Ir, EtaX are used - LDRunCorr = LDRsim / Etax - # LDRunCorr = (LDRsim / Etax * (GT / abs(GT) + HT / abs(HT)) - (GR / abs(GR) + HR / abs(HR))) / ((GR / abs(GR) - HR / abs(HR)) - LDRsim / Etax * (GT / abs(GT) - HT / abs(HT))) - - #LDRCorr = LDRsimx # for test only - - F11sim = 1 / (TiO * TiE) * ((HR * Eta * It - HT * Ir) / (HR * GT - HT * GR)) # IL = 1, Etat = Etar = 1 ; AMT Eq.64; what is Etax/K? => see about 20 lines above: = Eta - - return (IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr, - GT, HT, GR, HR, K, Eta, LDRsimx, LDRCorr, DTa, DRa, TTa, TRa, F11sim, LDRunCorr) - - - -# ******************************************************************************************************************************* - -# --- CALC with assumed true parameters from the input file -LDRtrue = LDRtrue2 -IoutTp0, IoutTm0, IoutRp0, IoutRm0, It0, Ir0, dIoutTp0, dIoutTm0, dIoutRp0, dIoutRm0, dIt0, dIr0, \ -GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ -Calc(TCalT, TCalR, NCalT, NCalR, Qin0, Vin0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal0) -Etax0 = K0 * Eta0 -Etapx0 = IoutRp0 / IoutTp0 -Etamx0 = IoutRm0 / IoutTm0 -# --- Print parameters to console and output file -OutputFile = 'output_' + InputFile[0:-3] + '_' + fname[0:-3] +'.dat' -output_path = os.path.join('output_files', OutputFile) -# with open('output_files\\' + OutputFile, 'w') as f: -with open(output_path, 'w') as f: - with redirect_stdout(f): - print("From ", dname) - print("Running ", fname) - print("Reading input file ", InputFile) # , " for Lidar system :", EID, ", ", LID) - print("for Lidar system: ", EID, ", ", LID) - # --- Print iput information********************************* - print(" --- Input parameters: value ±error / ±steps ----------------------") - print("{0:7}{1:17} {2:6.4f}±{3:7.4f}/{4:2d}".format("Laser: ", "Qin =", Qin0, dQin, nQin)) - print("{0:7}{1:17} {2:6.4f}±{3:7.4f}/{4:2d}".format("", "Vin =", Vin0, dVin, nVin)) - print("{0:7}{1:17} {2:6.4f}±{3:7.4f}/{4:2d}".format("", "Rotation alpha = ", RotL0, dRotL, nRotL)) - print("{0:7}{1:15} {2:8.4f} {3:17}".format("", "=> DOP", ((Qin ** 2 + Vin ** 2) ** 0.5), " (degree of polarisation)")) - - print("Optic: Diatt., Tunpol, Retard., Rotation (deg)") - print("{0:12} {1:7.4f} ±{2:7.4f} /{8:2d}, {3:7.4f}, {4:3.0f}±{5:3.0f}/{9:2d}, {6:7.4f}±{7:7.4f}/{10:2d}".format( - "Emitter ", DiE0, dDiE, TiE, RetE0, dRetE, RotE0, dRotE, nDiE, nRetE, nRotE)) - print("{0:12} {1:7.4f} ±{2:7.4f} /{8:2d}, {3:7.4f}, {4:3.0f}±{5:3.0f}/{9:2d}, {6:7.4f}±{7:7.4f}/{10:2d}".format( - "Receiver ", DiO0, dDiO, TiO, RetO0, dRetO, RotO0, dRotO, nDiO, nRetO, nRotO)) - print("{0:12} {1:9.6f}±{2:9.6f}/{8:2d}, {3:7.4f}, {4:3.0f}±{5:3.0f}/{9:2d}, {6:7.4f}±{7:7.4f}/{10:2d}".format( - "Calibrator ", DiC0, dDiC, TiC, RetC0, dRetC, RotC0, dRotC, nDiC, nRetC, nRotC)) - print("{0:12}".format(" Pol.-filter ------ ")) - print("{0:12}{1:7.4f}±{2:7.4f}/{3:2d}, {4:7.4f}±{5:7.4f}/{6:2d}".format( - "ERT, RotT :", ERaT0, dERaT, nERaT, RotaT0, dRotaT, nRotaT)) - print("{0:12}{1:7.4f}±{2:7.4f}/{3:2d}, {4:7.4f}±{5:7.4f}/{6:2d}".format( - "ERR, RotR :", ERaR0, dERaR, nERaR, RotaR0, dRotaR, nRotaR)) - print("{0:12}".format(" PBS ------ ")) - print("{0:12}{1:7.4f}±{2:7.4f}/{3:2d}, {4:7.4f}±{5:7.4f}/{6:2d}".format( - "TP,TS :", TP0, dTP, nTP, TS0, dTS, nTS)) - print("{0:12}{1:7.4f}±{2:7.4f}/{3:2d}, {4:7.4f}±{5:7.4f}/{6:2d}".format( - "RP,RS :", RP0, dRP, nRP, RS0, dRS, nRS)) - print("{0:12}{1:7.4f},{2:7.4f}, {3:7.4f},{4:7.4f}, {5:1.0f}".format( - "DT,TT,DR,TR,Y :", DiT, TiT, DiR, TiR, Y)) - print("{0:12}".format(" Combined PBS + Pol.-filter ------ ")) - print("{0:12}{1:7.4f},{2:7.4f}, {3:7.4f},{4:7.4f}".format( - "DT,TT,DR,TR :", DTa0, TTa0, DRa0, TRa0)) - print("{0:26}: {1:6.3f}± {2:5.3f}/{3:2d}".format( - "LDRCal during calibration in calibration range", LDRCal0, dLDRCal, nLDRCal)) - print("{0:12}".format(" --- Additional ND filter attenuation (transmission) during the calibration ---")) - print("{0:12}{1:7.4f}±{2:7.4f}/{3:2d}, {4:7.4f}±{5:7.4f}/{6:2d}".format( - "TCalT,TCalR :", TCalT0, dTCalT, nTCalT, TCalR0, dTCalR, nTCalR)) - print() - print(Type[TypeC],"calibrator is located", Loc[LocC]) - print("Rotation error epsilon is considered also for normal measurements = ", RotationErrorEpsilonForNormalMeasurements) - print("The PBS incidence plane is ", dY[int(Y + 1)], "to the reference plane" ) - print("The laser polarisation in the reference plane is finally", dY2[int(Y + 1)], "=>", dY3) - print("RS_RP_depend_on_TS_TP = ", RS_RP_depend_on_TS_TP) - # end of print actual system parameters - # ****************************************************************************** - - - print() - - K0List = np.zeros(7) - LDRsimxList = np.zeros(7) - LDRCalList = 0.0, 0.004, 0.05, 0.1, 0.2, 0.3, 0.45 - # The loop over LDRCalList is ony for checking whether and how much the LDR depends on the LDRCal during calibration and whether the corrections work. - # Still with assumed true parameters in input file - - ''' - facIt = NCalT / TCalT0 * NILfac - facIr = NCalR / TCalR0 * NILfac - ''' - facIt = NI * eFacT - facIr = NI * eFacR - if (bPlotEtax): - # check error signals - # dIs are relative stdevs - print("LDRCal, IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp,dIoutTm,dIoutRp,dIoutRm,dIt, dIr") - - for i, LDRCal in enumerate(LDRCalList): - IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr, \ - GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ - Calc(TCalT0, TCalR0, NCalT, NCalR, Qin0, Vin0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal) - K0List[i] = K0 - LDRsimxList[i] = LDRsimx - - if (bPlotEtax): - # check error signals - print( "{:0.2f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}".format(LDRCal, IoutTp * NCalT, IoutTm * NCalT, IoutRp * NCalR, IoutRm * NCalR, It * facIt, Ir * facIr, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr)) - #print( "{:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}".format(IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr)) - # end check error signals - print('===========================================================================================================') - print("{0:8},{1:8},{2:8},{3:8},{4:9},{5:8},{6:9},{7:9},{8:9},{9:9},{10:9}".format( - " GR", " GT", " HR", " HT", " K(0.000)", " K(0.004)", " K(0.05)", " K(0.1)", " K(0.2)", " K(0.3)", " K(0.45)")) - print("{0:8.5f},{1:8.5f},{2:8.5f},{3:8.5f},{4:9.5f},{5:9.5f},{6:9.5f},{7:9.5f},{8:9.5f},{9:9.5f},{10:9.5f}".format( - GR0, GT0, HR0, HT0, K0List[0], K0List[1], K0List[2], K0List[3], K0List[4], K0List[5], K0List[6])) - print('===========================================================================================================') - print() - print("Errors from neglecting GHK corrections and/or calibration:") - print("{0:>10},{1:>10},{2:>10},{3:>10},{4:>10},{5:>10}".format( - "LDRtrue", "LDRunCorr", "1/LDRunCorr", "LDRsimx", "1/LDRsimx", "LDRCorr")) - - aF11sim0 = np.zeros(5) - LDRrange = np.zeros(5) - LDRsim0 = np.zeros(5) - LDRrange = [0.004, 0.02, 0.1, 0.3, 0.45] # list - LDRrange[0] = LDRtrue2 # value in the input file; default 0.004 - - # The loop over LDRtrueList is only for checking how much the uncorrected LDRsimx deviates from LDRtrue ... and whether the corrections work. - # LDRsimx = LDRsim = Ir / It or 1/LDRsim - # Still with assumed true parameters in input file - for i, LDRtrue in enumerate(LDRrange): - #for LDRtrue in LDRrange: - IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr, \ - GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ - Calc(TCalT0, TCalR0, NCalT, NCalR, Qin0, Vin0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal0) - print("{0:10.5f},{1:10.5f},{2:10.5f},{3:10.5f},{4:10.5f},{5:10.5f}".format(LDRtrue, LDRunCorr, 1/LDRunCorr, LDRsimx, 1/LDRsimx, LDRCorr)) - aF11sim0[i] = F11sim0 - LDRsim0[i] = Ir / It - # the assumed true aF11sim0 results will be used below to calc the deviation from the real signals - print("LDRsimx = LDR of the nominal system directly from measured signals without calibration and GHK-corrections") - print("LDRunCorr = LDR of the nominal system directly from measured signals with calibration but without GHK-corrections; electronic amplifications = 1 assumed") - print("LDRCorr = LDR calibrated and GHK-corrected") - print() - print("Errors from signal noise:") - print("Signal counts: NI, NCalT, NCalR, NILfac, nNCal, nNI, stdev(NI)/NI = {0:10.0f},{1:10.0f},{2:10.0f},{3:3.0f},{4:2.0f},{5:2.0f},{6:8.5f}".format( - NI, NCalT, NCalR, NILfac, nNCal, nNI, 1.0 / NI ** 0.5)) - print() - print() - '''# das muß wieder weg - print("IoutTp, IoutTm, IoutRp, IoutRm, It , Ir , dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr") - LDRCal = 0.01 - for i, LDRtrue in enumerate(LDRrange): - IoutTp, IoutTm, IoutRp, IoutRm, It, Ir, dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr, \ - GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ - Calc(TCalT0, TCalR0, NCalT, NCalR, DOLP0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal0) - print( "{:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}, {:0.4f}".format( - IoutTp * NCalT, IoutTm * NCalT, IoutRp * NCalR, IoutRm * NCalR, It * facIt, Ir * facIr, - dIoutTp, dIoutTm, dIoutRp, dIoutRm, dIt, dIr)) - aF11sim0[i] = F11sim0 - # the assumed true aF11sim0 results will be used below to calc the deviation from the real signals - # bis hierher weg - ''' - -# file = open('output_files\\' + OutputFile, 'r') -file = open(output_path, 'r') -print(file.read()) -file.close() - -# --- CALC again assumed truth with LDRCal0 and with assumed true parameters in input file to reset all 0-values -LDRtrue = LDRtrue2 -IoutTp0, IoutTm0, IoutRp0, IoutRm0, It0, Ir0, dIoutTp0, dIoutTm0, dIoutRp0, dIoutRm0, dIt0, dIr0, \ -GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ -Calc(TCalT0, TCalR0, NCalT, NCalR, Qin0, Vin0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal0) -Etax0 = K0 * Eta0 -Etapx0 = IoutRp0 / IoutTp0 -Etamx0 = IoutRm0 / IoutTm0 -''' -if(PrintToOutputFile): - f = open('output_ver7.dat', 'w') - old_target = sys.stdout - sys.stdout = f - - print("something") - -if(PrintToOutputFile): - sys.stdout.flush() - f.close - sys.stdout = old_target -''' -if (Error_Calc): - # --- CALC again assumed truth with LDRCal0 and with assumed true parameters in input file to reset all 0-values - LDRtrue = LDRtrue2 - IoutTp0, IoutTm0, IoutRp0, IoutRm0, It0, Ir0, dIoutTp0, dIoutTm0, dIoutRp0, dIoutRm0, dIt0, dIr0, \ - GT0, HT0, GR0, HR0, K0, Eta0, LDRsimx, LDRCorr, DTa0, DRa0, TTa0, TRa0, F11sim0, LDRunCorr = \ - Calc(TCalT0, TCalR0, NCalT, NCalR, Qin0, Vin0, RotL0, RotE0, RetE0, DiE0, - RotO0, RetO0, DiO0, RotC0, RetC0, DiC0, TP0, TS0, RP0, RS0, - ERaT0, RotaT0, RetT0, ERaR0, RotaR0, RetR0, LDRCal0) - Etax0 = K0 * Eta0 - Etapx0 = IoutRp0 / IoutTp0 - Etamx0 = IoutRm0 / IoutTm0 - - # --- Start Error calculation with variable parameters ------------------------------------------------------------------ - # error nNCal: one-sigma in steps to left and right for calibration signals - # error nNI: one-sigma in steps to left and right for 0° signals - - iN = -1 - N = ((nTCalT * 2 + 1) * (nTCalR * 2 + 1) * - (nNCal * 2 + 1) ** 4 * (nNI * 2 + 1) ** 2 * - (nQin * 2 + 1) * (nVin * 2 + 1) * (nRotL * 2 + 1) * - (nRotE * 2 + 1) * (nRetE * 2 + 1) * (nDiE * 2 + 1) * - (nRotO * 2 + 1) * (nRetO * 2 + 1) * (nDiO * 2 + 1) * - (nRotC * 2 + 1) * (nRetC * 2 + 1) * (nDiC * 2 + 1) * - (nTP * 2 + 1) * (nTS * 2 + 1) * (nRP * 2 + 1) * (nRS * 2 + 1) * (nERaT * 2 + 1) * (nERaR * 2 + 1) * - (nRotaT * 2 + 1) * (nRotaR * 2 + 1) * (nRetT * 2 + 1) * (nRetR * 2 + 1) * (nLDRCal * 2 + 1)) - print("number of system variations N = ", N, " ", end="") - - if N > 1e6: - if user_yes_no_query('Warning: processing ' + str( - N) + ' samples will take very long. Do you want to proceed?') == 0: sys.exit() - if N > 5e6: - if user_yes_no_query('Warning: the memory required for ' + str(N) + ' samples might be ' + '{0:5.1f}'.format( - N / 4e6) + ' GB. Do you anyway want to proceed?') == 0: sys.exit() - - # if user_yes_no_query('Warning: processing' + str(N) + ' samples will take very long. Do you want to proceed?') == 0: sys.exit() - - # --- Arrays for plotting ------ - LDRmin = np.zeros(5) - LDRmax = np.zeros(5) - LDRstd = np.zeros(5) - LDRmean = np.zeros(5) - LDRmedian = np.zeros(5) - LDRskew = np.zeros(5) - LDRkurt = np.zeros(5) - LDRsimmin = np.zeros(5) - LDRsimmax = np.zeros(5) - LDRsimmean = np.zeros(5) - - F11min = np.zeros(5) - F11max = np.zeros(5) - Etaxmin = np.zeros(5) - Etaxmax = np.zeros(5) - - aQin = np.zeros(N) - aVin = np.zeros(N) - aERaT = np.zeros(N) - aERaR = np.zeros(N) - aRotaT = np.zeros(N) - aRotaR = np.zeros(N) - aRetT = np.zeros(N) - aRetR = np.zeros(N) - aTP = np.zeros(N) - aTS = np.zeros(N) - aRP = np.zeros(N) - aRS = np.zeros(N) - aDiE = np.zeros(N) - aDiO = np.zeros(N) - aDiC = np.zeros(N) - aRotC = np.zeros(N) - aRetC = np.zeros(N) - aRotL = np.zeros(N) - aRetE = np.zeros(N) - aRotE = np.zeros(N) - aRetO = np.zeros(N) - aRotO = np.zeros(N) - aLDRCal = np.zeros(N) - aNCalTp = np.zeros(N) - aNCalTm = np.zeros(N) - aNCalRp = np.zeros(N) - aNCalRm = np.zeros(N) - aNIt = np.zeros(N) - aNIr = np.zeros(N) - aTCalT = np.zeros(N) - aTCalR = np.zeros(N) - - # each np.zeros((LDRrange, N)) array has the same N-dependency - aLDRcorr = np.zeros((5, N)) - aLDRsim = np.zeros((5, N)) - aF11corr = np.zeros((5, N)) - aPLDR = np.zeros((5, N)) - aEtax = np.zeros((5, N)) - aEtapx = np.zeros((5, N)) - aEtamx = np.zeros((5, N)) - - # np.zeros((GHKs, N)) - aGHK = np.zeros((5, N)) - - atime = clock() - dtime = clock() - - # --- Calc Error signals - # ---- Do the calculations of bra-ket vectors - h = -1. if TypeC == 2 else 1 - - for iLDRCal in range(-nLDRCal, nLDRCal + 1): - # from input file: LDRCal for calibration measurements - LDRCal = LDRCal0 - if nLDRCal > 0: - LDRCal = LDRCal0 + iLDRCal * dLDRCal / nLDRCal - # provides the intensities of the calibration measurements at various LDRCal for signal noise errors - # IoutTp, IoutTm, IoutRp, IoutRm, dIoutTp, dIoutTm, dIoutRp, dIoutRm - - aCal = (1. - LDRCal) / (1. + LDRCal) - for iQin, iVin, iRotL, iRotE, iRetE, iDiE \ - in [(iQin, iVin, iRotL, iRotE, iRetE, iDiE) - for iQin in range(-nQin, nQin + 1) - for iVin in range(-nVin, nVin + 1) - for iRotL in range(-nRotL, nRotL + 1) - for iRotE in range(-nRotE, nRotE + 1) - for iRetE in range(-nRetE, nRetE + 1) - for iDiE in range(-nDiE, nDiE + 1)]: - - if nQin > 0: Qin = Qin0 + iQin * dQin / nQin - if nVin > 0: Vin = Vin0 + iVin * dVin / nVin - if nRotL > 0: RotL = RotL0 + iRotL * dRotL / nRotL - if nRotE > 0: RotE = RotE0 + iRotE * dRotE / nRotE - if nRetE > 0: RetE = RetE0 + iRetE * dRetE / nRetE - if nDiE > 0: DiE = DiE0 + iDiE * dDiE / nDiE - - if ((Qin ** 2 + Vin ** 2) ** 0.5) > 1.0: - print("Error: degree of polarisation of laser > 1. Check Qin and Vin! ") - sys.exit() - # angles of emitter and laser and calibrator and receiver optics - # RotL = alpha, RotE = beta, RotO = gamma, RotC = epsilon - S2a = np.sin(2 * np.deg2rad(RotL)) - C2a = np.cos(2 * np.deg2rad(RotL)) - S2b = np.sin(2 * np.deg2rad(RotE)) - C2b = np.cos(2 * np.deg2rad(RotE)) - S2ab = np.sin(np.deg2rad(2 * RotL - 2 * RotE)) - C2ab = np.cos(np.deg2rad(2 * RotL - 2 * RotE)) - - # Laser with Degree of linear polarization DOLP - IinL = 1. - QinL = Qin - UinL = 0. - VinL = Vin - # VinL = (1. - DOLP ** 2) ** 0.5 - - # Stokes Input Vector rotation Eq. E.4 - A = C2a * QinL - S2a * UinL - B = S2a * QinL + C2a * UinL - # Stokes Input Vector rotation Eq. E.9 - C = C2ab * QinL - S2ab * UinL - D = S2ab * QinL + C2ab * UinL - - # emitter optics - CosE = np.cos(np.deg2rad(RetE)) - SinE = np.sin(np.deg2rad(RetE)) - ZiE = (1. - DiE ** 2) ** 0.5 - WiE = (1. - ZiE * CosE) - - # Stokes Input Vector after emitter optics equivalent to Eq. E.9 with already rotated input vector from Eq. E.4 - # b = beta - IinE = (IinL + DiE * C) - QinE = (C2b * DiE * IinL + A + S2b * (WiE * D - ZiE * SinE * VinL)) - UinE = (S2b * DiE * IinL + B - C2b * (WiE * D - ZiE * SinE * VinL)) - VinE = (-ZiE * SinE * D + ZiE * CosE * VinL) - - # ------------------------- - # F11 assuemd to be = 1 => measured: F11m = IinP / IinE with atrue - # F11sim = (IinE + DiO*atrue*(C2g*QinE - S2g*UinE))/IinE - # ------------------------- - - for iRotO, iRetO, iDiO, iRotC, iRetC, iDiC, iTP, iTS, iRP, iRS, iERaT, iRotaT, iRetT, iERaR, iRotaR, iRetR \ - in [ - (iRotO, iRetO, iDiO, iRotC, iRetC, iDiC, iTP, iTS, iRP, iRS, iERaT, iRotaT, iRetT, iERaR, iRotaR, iRetR) - for iRotO in range(-nRotO, nRotO + 1) - for iRetO in range(-nRetO, nRetO + 1) - for iDiO in range(-nDiO, nDiO + 1) - for iRotC in range(-nRotC, nRotC + 1) - for iRetC in range(-nRetC, nRetC + 1) - for iDiC in range(-nDiC, nDiC + 1) - for iTP in range(-nTP, nTP + 1) - for iTS in range(-nTS, nTS + 1) - for iRP in range(-nRP, nRP + 1) - for iRS in range(-nRS, nRS + 1) - for iERaT in range(-nERaT, nERaT + 1) - for iRotaT in range(-nRotaT, nRotaT + 1) - for iRetT in range(-nRetT, nRetT + 1) - for iERaR in range(-nERaR, nERaR + 1) - for iRotaR in range(-nRotaR, nRotaR + 1) - for iRetR in range(-nRetR, nRetR + 1)]: - - if nRotO > 0: RotO = RotO0 + iRotO * dRotO / nRotO - if nRetO > 0: RetO = RetO0 + iRetO * dRetO / nRetO - if nDiO > 0: DiO = DiO0 + iDiO * dDiO / nDiO - if nRotC > 0: RotC = RotC0 + iRotC * dRotC / nRotC - if nRetC > 0: RetC = RetC0 + iRetC * dRetC / nRetC - if nDiC > 0: DiC = DiC0 + iDiC * dDiC / nDiC - if nTP > 0: TP = TP0 + iTP * dTP / nTP - if nTS > 0: TS = TS0 + iTS * dTS / nTS - if nRP > 0: RP = RP0 + iRP * dRP / nRP - if nRS > 0: RS = RS0 + iRS * dRS / nRS - if nERaT > 0: ERaT = ERaT0 + iERaT * dERaT / nERaT - if nRotaT > 0: RotaT = RotaT0 + iRotaT * dRotaT / nRotaT - if nRetT > 0: RetT = RetT0 + iRetT * dRetT / nRetT - if nERaR > 0: ERaR = ERaR0 + iERaR * dERaR / nERaR - if nRotaR > 0: RotaR = RotaR0 + iRotaR * dRotaR / nRotaR - if nRetR > 0: RetR = RetR0 + iRetR * dRetR / nRetR - - # print("{0:5.2f}, {1:5.2f}, {2:5.2f}, {3:10d}".format(RotL, RotE, RotO, iN)) - - # receiver optics - CosO = np.cos(np.deg2rad(RetO)) - SinO = np.sin(np.deg2rad(RetO)) - ZiO = (1. - DiO ** 2) ** 0.5 - WiO = (1. - ZiO * CosO) - S2g = np.sin(np.deg2rad(2 * RotO)) - C2g = np.cos(np.deg2rad(2 * RotO)) - # calibrator - CosC = np.cos(np.deg2rad(RetC)) - SinC = np.sin(np.deg2rad(RetC)) - ZiC = (1. - DiC ** 2) ** 0.5 - WiC = (1. - ZiC * CosC) - - # analyser - # For POLLY_XTs - if (RS_RP_depend_on_TS_TP): - RS = 1.0 - TS - RP = 1.0 - TP - TiT = 0.5 * (TP + TS) - DiT = (TP - TS) / (TP + TS) - ZiT = (1. - DiT ** 2.) ** 0.5 - TiR = 0.5 * (RP + RS) - DiR = (RP - RS) / (RP + RS) - ZiR = (1. - DiR ** 2.) ** 0.5 - CosT = np.cos(np.deg2rad(RetT)) - SinT = np.sin(np.deg2rad(RetT)) - CosR = np.cos(np.deg2rad(RetR)) - SinR = np.sin(np.deg2rad(RetR)) - - # cleaning pol-filter - DaT = (1.0 - ERaT) / (1.0 + ERaT) - DaR = (1.0 - ERaR) / (1.0 + ERaR) - TaT = 0.5 * (1.0 + ERaT) - TaR = 0.5 * (1.0 + ERaR) - - S2aT = np.sin(np.deg2rad(h * 2.0 * RotaT)) - C2aT = np.cos(np.deg2rad(2.0 * RotaT)) - S2aR = np.sin(np.deg2rad(h * 2.0 * RotaR)) - C2aR = np.cos(np.deg2rad(2.0 * RotaR)) - - # Analyzer As before the PBS Eq. D.5; combined PBS and cleaning pol-filter - ATPT = (1 + C2aT * DaT * DiT) # unpolarized transmission correction - TTa = TiT * TaT * ATPT # unpolarized transmission - ATP1 = 1.0 - ATP2 = Y * (DiT + C2aT * DaT) / ATPT - ATP3 = Y * S2aT * DaT * ZiT * CosT / ATPT - ATP4 = S2aT * DaT * ZiT * SinT / ATPT - ATP = np.array([ATP1, ATP2, ATP3, ATP4]) - DTa = ATP2 * Y - - ARPT = (1 + C2aR * DaR * DiR) # unpolarized transmission correction - TRa = TiR * TaR * ARPT # unpolarized transmission - ARP1 = 1 - ARP2 = Y * (DiR + C2aR * DaR) / ARPT - ARP3 = Y * S2aR * DaR * ZiR * CosR / ARPT - ARP4 = S2aR * DaR * ZiR * SinR / ARPT - ARP = np.array([ARP1, ARP2, ARP3, ARP4]) - DRa = ARP2 * Y - - # ---- Calculate signals and correction parameters for diffeent locations and calibrators - if LocC == 4: # Calibrator before the PBS - # print("Calibrator location not implemented yet") - - # S2ge = np.sin(np.deg2rad(2*RotO + h*2*RotC)) - # C2ge = np.cos(np.deg2rad(2*RotO + h*2*RotC)) - S2e = np.sin(np.deg2rad(h * 2 * RotC)) - C2e = np.cos(np.deg2rad(2 * RotC)) - # rotated AinP by epsilon Eq. C.3 - ATP2e = C2e * ATP2 + S2e * ATP3 - ATP3e = C2e * ATP3 - S2e * ATP2 - ARP2e = C2e * ARP2 + S2e * ARP3 - ARP3e = C2e * ARP3 - S2e * ARP2 - ATPe = np.array([ATP1, ATP2e, ATP3e, ATP4]) - ARPe = np.array([ARP1, ARP2e, ARP3e, ARP4]) - # Stokes Input Vector before the polarising beam splitter Eq. E.31 - A = C2g * QinE - S2g * UinE - B = S2g * QinE + C2g * UinE - # C = (WiO*aCal*B + ZiO*SinO*(1-2*aCal)*VinE) - Co = ZiO * SinO * VinE - Ca = (WiO * B - 2 * ZiO * SinO * VinE) - # C = Co + aCal*Ca - # IinP = (IinE + DiO*aCal*A) - # QinP = (C2g*DiO*IinE + aCal*QinE - S2g*C) - # UinP = (S2g*DiO*IinE - aCal*UinE + C2g*C) - # VinP = (ZiO*SinO*aCal*B + ZiO*CosO*(1-2*aCal)*VinE) - IinPo = IinE - QinPo = (C2g * DiO * IinE - S2g * Co) - UinPo = (S2g * DiO * IinE + C2g * Co) - VinPo = ZiO * CosO * VinE - - IinPa = DiO * A - QinPa = QinE - S2g * Ca - UinPa = -UinE + C2g * Ca - VinPa = ZiO * (SinO * B - 2 * CosO * VinE) - - IinP = IinPo + aCal * IinPa - QinP = QinPo + aCal * QinPa - UinP = UinPo + aCal * UinPa - VinP = VinPo + aCal * VinPa - # Stokes Input Vector before the polarising beam splitter rotated by epsilon Eq. C.3 - # QinPe = C2e*QinP + S2e*UinP - # UinPe = C2e*UinP - S2e*QinP - QinPoe = C2e * QinPo + S2e * UinPo - UinPoe = C2e * UinPo - S2e * QinPo - QinPae = C2e * QinPa + S2e * UinPa - UinPae = C2e * UinPa - S2e * QinPa - QinPe = C2e * QinP + S2e * UinP - UinPe = C2e * UinP - S2e * QinP - - # Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # rotator calibration Eq. C.4 - # parameters for calibration with aCal - AT = ATP1 * IinP + h * ATP4 * VinP - BT = ATP3e * QinP - h * ATP2e * UinP - AR = ARP1 * IinP + h * ARP4 * VinP - BR = ARP3e * QinP - h * ARP2e * UinP - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATPe, IS1) - GR = np.dot(ARPe, IS1) - HT = np.dot(ATPe, IS2) - HR = np.dot(ARPe, IS2) - elif (TypeC == 3) or (TypeC == 4): # linear polariser calibration Eq. C.5 - # parameters for calibration with aCal - AT = ATP1 * IinP + ATP3e * UinPe + ZiC * CosC * (ATP2e * QinPe + ATP4 * VinP) - BT = DiC * (ATP1 * UinPe + ATP3e * IinP) - ZiC * SinC * (ATP2e * VinP - ATP4 * QinPe) - AR = ARP1 * IinP + ARP3e * UinPe + ZiC * CosC * (ARP2e * QinPe + ARP4 * VinP) - BR = DiC * (ARP1 * UinPe + ARP3e * IinP) - ZiC * SinC * (ARP2e * VinP - ARP4 * QinPe) - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1e = np.array( - [IinPo + DiC * QinPoe, DiC * IinPo + QinPoe, ZiC * (CosC * UinPoe + SinC * VinPo), - -ZiC * (SinC * UinPoe - CosC * VinPo)]) - IS2e = np.array( - [IinPa + DiC * QinPae, DiC * IinPa + QinPae, ZiC * (CosC * UinPae + SinC * VinPa), - -ZiC * (SinC * UinPae - CosC * VinPa)]) - GT = np.dot(ATPe, IS1e) - GR = np.dot(ARPe, IS1e) - HT = np.dot(ATPe, IS2e) - HR = np.dot(ARPe, IS2e) - elif (TypeC == 6): # diattenuator calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # parameters for calibration with aCal - AT = ATP1 * IinP + sqr05 * DiC * (ATP1 * QinPe + ATP2e * IinP) + (1 - 0.5 * WiC) * ( - ATP2e * QinPe + ATP3e * UinPe) + ZiC * ( - sqr05 * SinC * (ATP3e * VinP - ATP4 * UinPe) + ATP4 * CosC * VinP) - BT = sqr05 * DiC * (ATP1 * UinPe + ATP3e * IinP) + 0.5 * WiC * ( - ATP2e * UinPe + ATP3e * QinPe) - sqr05 * ZiC * SinC * (ATP2e * VinP - ATP4 * QinPe) - AR = ARP1 * IinP + sqr05 * DiC * (ARP1 * QinPe + ARP2e * IinP) + (1 - 0.5 * WiC) * ( - ARP2e * QinPe + ARP3e * UinPe) + ZiC * ( - sqr05 * SinC * (ARP3e * VinP - ARP4 * UinPe) + ARP4 * CosC * VinP) - BR = sqr05 * DiC * (ARP1 * UinPe + ARP3e * IinP) + 0.5 * WiC * ( - ARP2e * UinPe + ARP3e * QinPe) - sqr05 * ZiC * SinC * (ARP2e * VinP - ARP4 * QinPe) - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinPo, QinPo, UinPo, VinPo]) - IS2 = np.array([IinPa, QinPa, UinPa, VinPa]) - GT = np.dot(ATP, IS1) - GR = np.dot(ARP, IS1) - HT = np.dot(ATP, IS2) - HR = np.dot(ARP, IS2) - else: - IS1e = np.array( - [IinPo + DiC * QinPoe, DiC * IinPo + QinPoe, ZiC * (CosC * UinPoe + SinC * VinPo), - -ZiC * (SinC * UinPoe - CosC * VinPo)]) - IS2e = np.array( - [IinPa + DiC * QinPae, DiC * IinPa + QinPae, ZiC * (CosC * UinPae + SinC * VinPa), - -ZiC * (SinC * UinPae - CosC * VinPa)]) - GT = np.dot(ATPe, IS1e) - GR = np.dot(ARPe, IS1e) - HT = np.dot(ATPe, IS2e) - HR = np.dot(ARPe, IS2e) - else: - print("Calibrator not implemented yet") - sys.exit() - - elif LocC == 3: # C before receiver optics Eq.57 - - # S2ge = np.sin(np.deg2rad(2*RotO - 2*RotC)) - # C2ge = np.cos(np.deg2rad(2*RotO - 2*RotC)) - S2e = np.sin(np.deg2rad(2 * RotC)) - C2e = np.cos(np.deg2rad(2 * RotC)) - - # AS with C before the receiver optics (see document rotated_diattenuator_X22x5deg.odt) - AF1 = np.array([1, C2g * DiO, S2g * DiO, 0]) - AF2 = np.array([C2g * DiO, 1 - S2g ** 2 * WiO, S2g * C2g * WiO, -S2g * ZiO * SinO]) - AF3 = np.array([S2g * DiO, S2g * C2g * WiO, 1 - C2g ** 2 * WiO, C2g * ZiO * SinO]) - AF4 = np.array([0, S2g * SinO, -C2g * SinO, CosO]) - - ATF = (ATP1 * AF1 + ATP2 * AF2 + ATP3 * AF3 + ATP4 * AF4) - ARF = (ARP1 * AF1 + ARP2 * AF2 + ARP3 * AF3 + ARP4 * AF4) - ATF1 = ATF[0] - ATF2 = ATF[1] - ATF3 = ATF[2] - ATF4 = ATF[3] - ARF1 = ARF[0] - ARF2 = ARF[1] - ARF3 = ARF[2] - ARF4 = ARF[3] - - # rotated AinF by epsilon - ATF2e = C2e * ATF[1] + S2e * ATF[2] - ATF3e = C2e * ATF[2] - S2e * ATF[1] - ARF2e = C2e * ARF[1] + S2e * ARF[2] - ARF3e = C2e * ARF[2] - S2e * ARF[1] - - ATFe = np.array([ATF1, ATF2e, ATF3e, ATF4]) - ARFe = np.array([ARF1, ARF2e, ARF3e, ARF4]) - - QinEe = C2e * QinE + S2e * UinE - UinEe = C2e * UinE - S2e * QinE - - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - IinF = IinE - QinF = aCal * QinE - UinF = -aCal * UinE - VinF = (1. - 2. * aCal) * VinE - - IinFo = IinE - QinFo = 0. - UinFo = 0. - VinFo = VinE - - IinFa = 0. - QinFa = QinE - UinFa = -UinE - VinFa = -2. * VinE - - # Stokes Input Vector before receiver optics rotated by epsilon Eq. C.3 - QinFe = C2e * QinF + S2e * UinF - UinFe = C2e * UinF - S2e * QinF - QinFoe = C2e * QinFo + S2e * UinFo - UinFoe = C2e * UinFo - S2e * QinFo - QinFae = C2e * QinFa + S2e * UinFa - UinFae = C2e * UinFa - S2e * QinFa - - # Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # rotator calibration Eq. C.4 - AT = ATF1 * IinF + ATF4 * h * VinF - BT = ATF3e * QinF - ATF2e * h * UinF - AR = ARF1 * IinF + ARF4 * h * VinF - BR = ARF3e * QinF - ARF2e * h * UinF - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - GT = ATF1 * IinE + ATF4 * VinE - GR = ARF1 * IinE + ARF4 * VinE - HT = ATF2 * QinE - ATF3 * UinE - ATF4 * 2 * VinE - HR = ARF2 * QinE - ARF3 * UinE - ARF4 * 2 * VinE - else: - GT = ATF1 * IinE + ATF4 * h * VinE - GR = ARF1 * IinE + ARF4 * h * VinE - HT = ATF2e * QinE - ATF3e * h * UinE - ATF4 * h * 2 * VinE - HR = ARF2e * QinE - ARF3e * h * UinE - ARF4 * h * 2 * VinE - - elif (TypeC == 3) or (TypeC == 4): # linear polariser calibration Eq. C.5 - # p = +45°, m = -45° - IF1e = np.array([IinF, ZiC * CosC * QinFe, UinFe, ZiC * CosC * VinF]) - IF2e = np.array([DiC * UinFe, -ZiC * SinC * VinF, DiC * IinF, ZiC * SinC * QinFe]) - - AT = np.dot(ATFe, IF1e) - AR = np.dot(ARFe, IF1e) - BT = np.dot(ATFe, IF2e) - BR = np.dot(ARFe, IF2e) - - # Correction parameters for normal measurements; they are independent of LDR --- the same as for TypeC = 6 - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - IS1 = np.array([IinE, 0, 0, VinE]) - IS2 = np.array([0, QinE, -UinE, -2 * VinE]) - - GT = np.dot(ATF, IS1) - GR = np.dot(ARF, IS1) - HT = np.dot(ATF, IS2) - HR = np.dot(ARF, IS2) - else: - IS1e = np.array( - [IinFo + DiC * QinFoe, DiC * IinFo + QinFoe, ZiC * (CosC * UinFoe + SinC * VinFo), - -ZiC * (SinC * UinFoe - CosC * VinFo)]) - IS2e = np.array( - [IinFa + DiC * QinFae, DiC * IinFa + QinFae, ZiC * (CosC * UinFae + SinC * VinFa), - -ZiC * (SinC * UinFae - CosC * VinFa)]) - GT = np.dot(ATFe, IS1e) - GR = np.dot(ARFe, IS1e) - HT = np.dot(ATFe, IS2e) - HR = np.dot(ARFe, IS2e) - - elif (TypeC == 6): # diattenuator calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # p = +22.5°, m = -22.5° - IF1e = np.array([IinF + sqr05 * DiC * QinFe, sqr05 * DiC * IinF + (1 - 0.5 * WiC) * QinFe, - (1 - 0.5 * WiC) * UinFe + sqr05 * ZiC * SinC * VinF, - -sqr05 * ZiC * SinC * UinFe + ZiC * CosC * VinF]) - IF2e = np.array([sqr05 * DiC * UinFe, 0.5 * WiC * UinFe - sqr05 * ZiC * SinC * VinF, - sqr05 * DiC * IinF + 0.5 * WiC * QinFe, sqr05 * ZiC * SinC * QinFe]) - - AT = np.dot(ATFe, IF1e) - AR = np.dot(ARFe, IF1e) - BT = np.dot(ATFe, IF2e) - BR = np.dot(ARFe, IF2e) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - # IS1 = np.array([IinE,0,0,VinE]) - # IS2 = np.array([0,QinE,-UinE,-2*VinE]) - IS1 = np.array([IinFo, 0, 0, VinFo]) - IS2 = np.array([0, QinFa, UinFa, VinFa]) - GT = np.dot(ATF, IS1) - GR = np.dot(ARF, IS1) - HT = np.dot(ATF, IS2) - HR = np.dot(ARF, IS2) - else: - # IS1e = np.array([IinE,DiC*IinE,ZiC*SinC*VinE,ZiC*CosC*VinE]) - # IS2e = np.array([DiC*QinEe,QinEe,-ZiC*(CosC*UinEe+2*SinC*VinE),ZiC*(SinC*UinEe-2*CosC*VinE)]) - IS1e = np.array( - [IinFo + DiC * QinFoe, DiC * IinFo + QinFoe, ZiC * (CosC * UinFoe + SinC * VinFo), - -ZiC * (SinC * UinFoe - CosC * VinFo)]) - IS2e = np.array( - [IinFa + DiC * QinFae, DiC * IinFa + QinFae, ZiC * (CosC * UinFae + SinC * VinFa), - -ZiC * (SinC * UinFae - CosC * VinFa)]) - GT = np.dot(ATFe, IS1e) - GR = np.dot(ARFe, IS1e) - HT = np.dot(ATFe, IS2e) - HR = np.dot(ARFe, IS2e) - - - else: - print('Calibrator not implemented yet') - sys.exit() - - elif LocC == 2: # C behind emitter optics Eq.57 - # print("Calibrator location not implemented yet") - S2e = np.sin(np.deg2rad(2 * RotC)) - C2e = np.cos(np.deg2rad(2 * RotC)) - - # AS with C before the receiver optics (see document rotated_diattenuator_X22x5deg.odt) - AF1 = np.array([1, C2g * DiO, S2g * DiO, 0]) - AF2 = np.array([C2g * DiO, 1 - S2g ** 2 * WiO, S2g * C2g * WiO, -S2g * ZiO * SinO]) - AF3 = np.array([S2g * DiO, S2g * C2g * WiO, 1 - C2g ** 2 * WiO, C2g * ZiO * SinO]) - AF4 = np.array([0, S2g * SinO, -C2g * SinO, CosO]) - - ATF = (ATP1 * AF1 + ATP2 * AF2 + ATP3 * AF3 + ATP4 * AF4) - ARF = (ARP1 * AF1 + ARP2 * AF2 + ARP3 * AF3 + ARP4 * AF4) - ATF1 = ATF[0] - ATF2 = ATF[1] - ATF3 = ATF[2] - ATF4 = ATF[3] - ARF1 = ARF[0] - ARF2 = ARF[1] - ARF3 = ARF[2] - ARF4 = ARF[3] - - # AS with C behind the emitter -------------------------------------------- - # terms without aCal - ATE1o, ARE1o = ATF1, ARF1 - ATE2o, ARE2o = 0., 0. - ATE3o, ARE3o = 0., 0. - ATE4o, ARE4o = ATF4, ARF4 - # terms with aCal - ATE1a, ARE1a = 0., 0. - ATE2a, ARE2a = ATF2, ARF2 - ATE3a, ARE3a = -ATF3, -ARF3 - ATE4a, ARE4a = -2 * ATF4, -2 * ARF4 - # rotated AinEa by epsilon - ATE2ae = C2e * ATF2 + S2e * ATF3 - ATE3ae = -S2e * ATF2 - C2e * ATF3 - ARE2ae = C2e * ARF2 + S2e * ARF3 - ARE3ae = -S2e * ARF2 - C2e * ARF3 - - ATE1 = ATE1o - ATE2e = aCal * ATE2ae - ATE3e = aCal * ATE3ae - ATE4 = (1 - 2 * aCal) * ATF4 - ARE1 = ARE1o - ARE2e = aCal * ARE2ae - ARE3e = aCal * ARE3ae - ARE4 = (1. - 2. * aCal) * ARF4 - - # rotated IinE - QinEe = C2e * QinE + S2e * UinE - UinEe = C2e * UinE - S2e * QinE - - # --- Calibration signals and Calibration correction K from measurements with LDRCal / aCal - if (TypeC == 2) or (TypeC == 1): # +++++++++ rotator calibration Eq. C.4 - AT = ATE1o * IinE + (ATE4o + aCal * ATE4a) * h * VinE - BT = aCal * (ATE3ae * QinEe - ATE2ae * h * UinEe) - AR = ARE1o * IinE + (ARE4o + aCal * ARE4a) * h * VinE - BR = aCal * (ARE3ae * QinEe - ARE2ae * h * UinEe) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - GT = ATE1o * IinE + ATE4o * h * VinE - GR = ARE1o * IinE + ARE4o * h * VinE - HT = ATE2a * QinE + ATE3a * h * UinEe + ATE4a * h * VinE - HR = ARE2a * QinE + ARE3a * h * UinEe + ARE4a * h * VinE - else: - GT = ATE1o * IinE + ATE4o * h * VinE - GR = ARE1o * IinE + ARE4o * h * VinE - HT = ATE2ae * QinE + ATE3ae * h * UinEe + ATE4a * h * VinE - HR = ARE2ae * QinE + ARE3ae * h * UinEe + ARE4a * h * VinE - - elif (TypeC == 3) or (TypeC == 4): # +++++++++ linear polariser calibration Eq. C.5 - # p = +45°, m = -45° - AT = ATE1 * IinE + ZiC * CosC * (ATE2e * QinEe + ATE4 * VinE) + ATE3e * UinEe - BT = DiC * (ATE1 * UinEe + ATE3e * IinE) + ZiC * SinC * (ATE4 * QinEe - ATE2e * VinE) - AR = ARE1 * IinE + ZiC * CosC * (ARE2e * QinEe + ARE4 * VinE) + ARE3e * UinEe - BR = DiC * (ARE1 * UinEe + ARE3e * IinE) + ZiC * SinC * (ARE4 * QinEe - ARE2e * VinE) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): - # Stokes Input Vector before receiver optics Eq. E.19 (after atmosphere F) - GT = ATE1o * IinE + ATE4o * VinE - GR = ARE1o * IinE + ARE4o * VinE - HT = ATE2a * QinE + ATE3a * UinE + ATE4a * VinE - HR = ARE2a * QinE + ARE3a * UinE + ARE4a * VinE - else: - D = IinE + DiC * QinEe - A = DiC * IinE + QinEe - B = ZiC * (CosC * UinEe + SinC * VinE) - C = -ZiC * (SinC * UinEe - CosC * VinE) - GT = ATE1o * D + ATE4o * C - GR = ARE1o * D + ARE4o * C - HT = ATE2a * A + ATE3a * B + ATE4a * C - HR = ARE2a * A + ARE3a * B + ARE4a * C - - elif (TypeC == 6): # real HWP calibration +-22.5° rotated_diattenuator_X22x5deg.odt - # p = +22.5°, m = -22.5° - IE1e = np.array([IinE + sqr05 * DiC * QinEe, sqr05 * DiC * IinE + (1 - 0.5 * WiC) * QinEe, - (1. - 0.5 * WiC) * UinEe + sqr05 * ZiC * SinC * VinE, - -sqr05 * ZiC * SinC * UinEe + ZiC * CosC * VinE]) - IE2e = np.array([sqr05 * DiC * UinEe, 0.5 * WiC * UinEe - sqr05 * ZiC * SinC * VinE, - sqr05 * DiC * IinE + 0.5 * WiC * QinEe, sqr05 * ZiC * SinC * QinEe]) - ATEe = np.array([ATE1, ATE2e, ATE3e, ATE4]) - AREe = np.array([ARE1, ARE2e, ARE3e, ARE4]) - AT = np.dot(ATEe, IE1e) - AR = np.dot(AREe, IE1e) - BT = np.dot(ATEe, IE2e) - BR = np.dot(AREe, IE2e) - - # Correction parameters for normal measurements; they are independent of LDR - if (not RotationErrorEpsilonForNormalMeasurements): # calibrator taken out - GT = ATE1o * IinE + ATE4o * VinE - GR = ARE1o * IinE + ARE4o * VinE - HT = ATE2a * QinE + ATE3a * UinE + ATE4a * VinE - HR = ARE2a * QinE + ARE3a * UinE + ARE4a * VinE - else: - D = IinE + DiC * QinEe - A = DiC * IinE + QinEe - B = ZiC * (CosC * UinEe + SinC * VinE) - C = -ZiC * (SinC * UinEe - CosC * VinE) - GT = ATE1o * D + ATE4o * C - GR = ARE1o * D + ARE4o * C - HT = ATE2a * A + ATE3a * B + ATE4a * C - HR = ARE2a * A + ARE3a * B + ARE4a * C - else: - print('Calibrator not implemented yet') - sys.exit() - - for iTCalT, iTCalR, iNCalTp, iNCalTm, iNCalRp, iNCalRm, iNIt, iNIr \ - in [ - (iTCalT, iTCalR, iNCalTp, iNCalTm, iNCalRp, iNCalRm, iNIt, iNIr) - for iTCalT in range(-nTCalT, nTCalT + 1) # Etax - for iTCalR in range(-nTCalR, nTCalR + 1) # Etax - for iNCalTp in range(-nNCal, nNCal + 1) # noise error of calibration signals => Etax - for iNCalTm in range(-nNCal, nNCal + 1) # noise error of calibration signals => Etax - for iNCalRp in range(-nNCal, nNCal + 1) # noise error of calibration signals => Etax - for iNCalRm in range(-nNCal, nNCal + 1) # noise error of calibration signals => Etax - for iNIt in range(-nNI, nNI + 1) - for iNIr in range(-nNI, nNI + 1)]: - - # Calibration signals with aCal => Determination of the correction K of the real calibration factor - IoutTp = TTa * TiC * TiO * TiE * (AT + BT) - IoutTm = TTa * TiC * TiO * TiE * (AT - BT) - IoutRp = TRa * TiC * TiO * TiE * (AR + BR) - IoutRm = TRa * TiC * TiO * TiE * (AR - BR) - - if nTCalT > 0: TCalT = TCalT0 + iTCalT * dTCalT / nTCalT - if nTCalR > 0: TCalR = TCalR0 + iTCalR * dTCalR / nTCalR - # signal noise errors - # ----- random error calculation ---------- - # noise must be calculated from/with the actually measured signals; influence of TCalT, TCalR errors on noise are not considered ? - # actually measured signal counts are in input file and don't change - # relative standard deviation of calibration signals with LDRcal; assumed to be statisitcally independent - # error nNCal: one-sigma in steps to left and right for calibration signals - if nNCal > 0: - if (CalcFrom0deg): - dIoutTp = (NCalT * IoutTp) ** -0.5 - dIoutTm = (NCalT * IoutTm) ** -0.5 - dIoutRp = (NCalR * IoutRp) ** -0.5 - dIoutRm = (NCalR * IoutRm) ** -0.5 - else: - dIoutTp = dIoutTp0 * (IoutTp / IoutTp0) - dIoutTm = dIoutTm0 * (IoutTm / IoutTm0) - dIoutRp = dIoutRp0 * (IoutRp / IoutRp0) - dIoutRm = dIoutRm0 * (IoutRm / IoutRm0) - # print(iTCalT, iTCalR, iNCalTp, iNCalTm, iNCalRp, iNCalRm, iNIt, iNIr, IoutTp, dIoutTp) - IoutTp = IoutTp * (1. + iNCalTp * dIoutTp / nNCal) - IoutTm = IoutTm * (1. + iNCalTm * dIoutTm / nNCal) - IoutRp = IoutRp * (1. + iNCalRp * dIoutRp / nNCal) - IoutRm = IoutRm * (1. + iNCalRm * dIoutRm / nNCal) - - IoutTp = IoutTp * TCalT / TCalT0 - IoutTm = IoutTm * TCalT / TCalT0 - IoutRp = IoutRp * TCalR / TCalR0 - IoutRm = IoutRm * TCalR / TCalR0 - # --- Results and Corrections; electronic etaR and etaT are assumed to be 1 for true and assumed true systems - # calibration factor - Eta = (TRa / TTa) # = TRa / TTa; Eta = Eta*/K Eq. 84; corrected according to the papers supplement Eqs. (S.10.10.1) ff - # possibly real calibration factor - Etapx = IoutRp / IoutTp - Etamx = IoutRm / IoutTm - Etax = (Etapx * Etamx) ** 0.5 - K = Etax / Eta - # print("{0:6.3f},{1:6.3f},{2:6.3f},{3:6.3f},{4:6.3f},{5:6.3f},{6:6.3f},{7:6.3f},{8:6.3f},{9:6.3f},{10:6.3f}".format(AT, BT, AR, BR, DiC, ZiC, RetO, TP, TS, Kp, Km)) - # print("{0:6.3f},{1:6.3f},{2:6.3f},{3:6.3f}".format(DiC, ZiC, Kp, Km)) - - # For comparison with Volkers Libreoffice Müller Matrix spreadsheet - # Eta_test_p = (IoutRp/IoutTp) - # Eta_test_m = (IoutRm/IoutTm) - # Eta_test = (Eta_test_p*Eta_test_m)**0.5 - ''' - for iIt, iIr \ - in [(iIt, iIr) - for iIt in range(-nNI, nNI + 1) - for iIr in range(-nNI, nNI + 1)]: - ''' - - iN = iN + 1 - if (iN == 10001): - ctime = clock() - print(" estimated time ", "{0:4.2f}".format(N / 10000 * (ctime - atime)), "sec ") # , end="") - print("\r elapsed time ", "{0:5.0f}".format((ctime - atime)), "sec ", end="\r") - ctime = clock() - if ((ctime - dtime) > 10): - print("\r elapsed time ", "{0:5.0f}".format((ctime - atime)), "sec ", end="\r") - dtime = ctime - - # *** loop for different real LDRs ********************************************************************** - iLDR = -1 - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - atrue = (1. - LDRTrue) / (1. + LDRTrue) - # ----- Forward simulated signals and LDRsim with atrue; from input file; not considering TiC. - It = TTa * TiO * TiE * (GT + atrue * HT) # TaT*TiT*TiC*TiO*IinL*(GT+atrue*HT) - Ir = TRa * TiO * TiE * (GR + atrue * HR) # TaR*TiR*TiC*TiO*IinL*(GR+atrue*HR) - # # signal noise errors; standard deviation of signals; assumed to be statisitcally independent - # because the signals depend on LDRtrue, the errors dIt and dIr must be calculated for each LDRtrue - if (CalcFrom0deg): - ''' - dIt = ((NCalT * It / IoutTp * NILfac / TCalT) ** -0.5) - dIr = ((NCalR * Ir / IoutRp * NILfac / TCalR) ** -0.5) - ''' - dIt = ((It * NI * eFacT) ** -0.5) - dIr = ((Ir * NI * eFacR) ** -0.5) - else: - dIt = ((It * NI * eFacT) ** -0.5) - dIr = ((Ir * NI * eFacR) ** -0.5) - ''' - # does this work? Why not as above? - dIt = ((NCalT * 2. * NILfac / TCalT ) ** -0.5) - dIr = ((NCalR * 2. * NILfac / TCalR) ** -0.5) - ''' - # error nNI: one-sigma in steps to left and right for 0° signals - if nNI > 0: - It = It * (1. + iNIt * dIt / nNI) - Ir = Ir * (1. + iNIr * dIr / nNI) - - # LDRsim = 1/Eta*Ir/It # simulated LDR* with Y from input file - LDRsim = Ir / It # simulated uncorrected LDR with Y from input file - - # ----- Backward correction - # Corrected LDRCorr with assumed true G0,H0,K0,Eta0 from forward simulated (real) LDRsim(atrue) - LDRCorr = (LDRsim / (Etax / K0) * (GT0 + HT0) - (GR0 + HR0)) / ((GR0 - HR0) - LDRsim / (Etax / K0) * (GT0 - HT0)) - - # The following is a test whether the equations for calibration Etax and normal signal (GHK, LDRsim) are consistent - # LDRCorr = (LDRsim / Eta * (GT + HT) - (GR + HR)) / ((GR - HR) - LDRsim / Eta * (GT - HT)) - # Without any correction - LDRunCorr = LDRsim / Etax - # LDRunCorr = (LDRsim / Etax * (GT / abs(GT) + HT / abs(HT)) - (GR / abs(GR) + HR / abs(HR))) / ((GR / abs(GR) - HR / abs(HR)) - LDRsim / Etax * (GT / abs(GT) - HT / abs(HT))) - - - ''' - # -- F11corr from It and Ir and calibration EtaX - Text1 = "!!! EXPERIMENTAL !!! F11corr from It and Ir with calibration EtaX: x-axis: F11corr(LDRtrue) / F11corr(LDRtrue = 0.004) - 1" - F11corr = 1 / (TiO * TiE) * ( - (HR0 * Etax / K0 * It / TTa - HT0 * Ir / TRa) / (HR0 * GT0 - HT0 * GR0)) # IL = 1 Eq.(64); Etax/K0 = Eta0. - ''' - # Corrected F11corr with assumed true G0,H0,K0 from forward simulated (real) It and Ir (atrue) - Text1 = "!!! EXPERIMENTAL !!! F11corr from real It and Ir with real calibration EtaX: x-axis: F11corr(LDRtrue) / aF11sim0(LDRtrue) - 1" - F11corr = 1 / (TiO * TiE) * ( - (HR0 * Etax / K0 * It / TTa - HT0 * Ir / TRa) / (HR0 * GT0 - HT0 * GR0)) # IL = 1 Eq.(64); Etax/K0 = Eta0. - - # Text1 = "F11corr from It and Ir without corrections but with calibration EtaX: x-axis: F11corr(LDRtrue) devided by F11corr(LDRtrue = 0.004)" - # F11corr = 0.5/(TiO*TiE)*(Etax*It/TTa+Ir/TRa) # IL = 1 Eq.(64) - - # -- It from It only with atrue without corrections - for BERTHA (and PollyXTs) - # Text1 = " x-axis: IT(LDRtrue) / IT(LDRtrue = 0.004) - 1" - # F11corr = It/(TaT*TiT*TiO*TiE) #/(TaT*TiT*TiO*TiE*(GT0+atrue*HT0)) - # ! see below line 1673ff - - aF11corr[iLDR, iN] = F11corr - aLDRcorr[iLDR, iN] = LDRCorr # LDRCorr # LDRsim # for test only - aLDRsim[iLDR, iN] = LDRsim # LDRCorr # LDRsim # for test only - # aPLDR[iLDR, iN] = CalcPLDR(LDRCorr, BSR[iLDR], LDRm0) - aEtax[iLDR, iN] = Etax - aEtapx[iLDR, iN] = Etapx - aEtamx[iLDR, iN] = Etamx - - aGHK[0, iN] = GR - aGHK[1, iN] = GT - aGHK[2, iN] = HR - aGHK[3, iN] = HT - aGHK[4, iN] = K - - aLDRCal[iN] = iLDRCal - aQin[iN] = iQin - aVin[iN] = iVin - aERaT[iN] = iERaT - aERaR[iN] = iERaR - aRotaT[iN] = iRotaT - aRotaR[iN] = iRotaR - aRetT[iN] = iRetT - aRetR[iN] = iRetR - - aRotL[iN] = iRotL - aRotE[iN] = iRotE - aRetE[iN] = iRetE - aRotO[iN] = iRotO - aRetO[iN] = iRetO - aRotC[iN] = iRotC - aRetC[iN] = iRetC - aDiO[iN] = iDiO - aDiE[iN] = iDiE - aDiC[iN] = iDiC - aTP[iN] = iTP - aTS[iN] = iTS - aRP[iN] = iRP - aRS[iN] = iRS - aTCalT[iN] = iTCalT - aTCalR[iN] = iTCalR - - aNCalTp[iN] = iNCalTp # IoutTp, IoutTm, IoutRp, IoutRm => Etax - aNCalTm[iN] = iNCalTm # IoutTp, IoutTm, IoutRp, IoutRm => Etax - aNCalRp[iN] = iNCalRp # IoutTp, IoutTm, IoutRp, IoutRm => Etax - aNCalRm[iN] = iNCalRm # IoutTp, IoutTm, IoutRp, IoutRm => Etax - aNIt[iN] = iNIt # It, Tr - aNIr[iN] = iNIr # It, Tr - - # --- END loop - btime = clock() - # print("\r done in ", "{0:5.0f}".format(btime - atime), "sec. => producing plots now .... some more seconds ..."), # , end="\r"); - print(" done in ", "{0:5.0f}".format(btime - atime), "sec. => producing plots now .... some more seconds ...") - # --- Plot ----------------------------------------------------------------- - print("Errors from GHK correction uncertainties:") - if (sns_loaded): - sns.set_style("whitegrid") - sns.set_palette("bright6", 6) - # for older seaborn versions use: - # sns.set_palette("bright", 6) - - ''' - fig2 = plt.figure() - plt.plot(aLDRcorr[2,:],'b.') - plt.plot(aLDRcorr[3,:],'r.') - plt.plot(aLDRcorr[4,:],'g.') - #plt.plot(aLDRcorr[6,:],'c.') - plt.show - ''' - - # Plot LDR - def PlotSubHist(aVar, aX, X0, daX, iaX, naX): - # aVar is the name of the parameter and aX is the subset of aLDRcorr which is coloured in the plot - # example: PlotSubHist("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP) - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - LDRmin[iLDR] = np.amin(aLDRcorr[iLDR, :]) - LDRmax[iLDR] = np.amax(aLDRcorr[iLDR, :]) - if (LDRmax[iLDR] > 10): LDRmax[iLDR] = 10 - if (LDRmin[iLDR] < -10): LDRmin[iLDR] = -10 - Rmin = LDRmin[iLDR] * 0.995 # np.min(aLDRcorr[iLDR,:]) * 0.995 - Rmax = LDRmax[iLDR] * 1.005 # np.max(aLDRcorr[iLDR,:]) * 1.005 - - # Determine mean distance of all aXmean from each other for each iLDR - meanDist = 0.0 - for iaX in range(-naX, naX + 1): - # mean LDRCorr value for certain error (iaX) of parameter aVar - aXmean[iaX + naX] = np.mean(aLDRcorr[iLDR, aX == iaX]) - # relative to absolute spread of LDRCorrs - meanDist = (np.max(aXmean) - np.min(aXmean)) / (LDRmax[iLDR] - LDRmin[iLDR]) * 100 - - plt.subplot(1, 5, iLDR + 1) - (n, bins, patches) = plt.hist(aLDRcorr[iLDR, :], - bins=100, log=False, - range=[Rmin, Rmax], - alpha=0.5, density=False, color='0.5', histtype='stepfilled') - - for iaX in range(-naX, naX + 1): - # mean LDRCorr value for certain error (iaX) of parameter aVar - plt.hist(aLDRcorr[iLDR, aX == iaX], - range=[Rmin, Rmax], - bins=100, log=False, alpha=0.3, density=False, histtype='stepfilled', - label=str(round(X0 + iaX * daX / naX, 5))) - - if (iLDR == 2): - leg = plt.legend() - leg.get_frame().set_alpha(0.1) - - plt.tick_params(axis='both', labelsize=10) - plt.plot([LDRTrue, LDRTrue], [0, np.max(n)], 'r-', lw=2) - plt.gca().set_title("{0:3.0f}%".format(meanDist)) - plt.gca().set_xlabel('LDRtrue', color="red") - - # plt.ylabel('frequency', fontsize=10) - # plt.xlabel('LDRCorr', fontsize=10) - # fig.tight_layout() - fig.suptitle(LID + ' with ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar + ' error contribution', fontsize=14, y=1.10) - # plt.show() - # fig.savefig(LID + '_' + aVar + '.png', dpi=150, bbox_inches='tight', pad_inches=0) - # plt.close - return - - def PlotLDRsim(aVar, aX, X0, daX, iaX, naX): - # aVar is the name of the parameter and aX is the subset of aLDRsim which is coloured in the plot - # example: PlotSubHist("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP) - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - LDRsimmin[iLDR] = np.amin(aLDRsim[iLDR, :]) - LDRsimmax[iLDR] = np.amax(aLDRsim[iLDR, :]) - # print("LDRsimmin[iLDR], LDRsimmax[iLDR] = ", LDRsimmin[iLDR], LDRsimmax[iLDR]) - # if (LDRsimmax[iLDR] > 10): LDRsimmax[iLDR] = 10 - # if (LDRsimmin[iLDR] < -10): LDRsimmin[iLDR] = -10 - Rmin = LDRsimmin[iLDR] * 0.995 # np.min(aLDRsim[iLDR,:]) * 0.995 - Rmax = LDRsimmax[iLDR] * 1.005 # np.max(aLDRsim[iLDR,:]) * 1.005 - # print("Rmin, Rmax = ", Rmin, Rmax) - - # Determine mean distance of all aXmean from each other for each iLDR - meanDist = 0.0 - for iaX in range(-naX, naX + 1): - # mean LDRCorr value for certain error (iaX) of parameter aVar - aXmean[iaX + naX] = np.mean(aLDRsim[iLDR, aX == iaX]) - # relative to absolute spread of LDRCorrs - meanDist = (np.max(aXmean) - np.min(aXmean)) / (LDRsimmax[iLDR] - LDRsimmin[iLDR]) * 100 - - plt.subplot(1, 5, iLDR + 1) - (n, bins, patches) = plt.hist(aLDRsim[iLDR, :], - bins=100, log=False, - range=[Rmin, Rmax], - alpha=0.5, density=False, color='0.5', histtype='stepfilled') - - for iaX in range(-naX, naX + 1): - # mean LDRCorr value for certain error (iaX) of parameter aVar - plt.hist(aLDRsim[iLDR, aX == iaX], - range=[Rmin, Rmax], - bins=100, log=False, alpha=0.3, density=False, histtype='stepfilled', - label=str(round(X0 + iaX * daX / naX, 5))) - - if (iLDR == 2): - leg = plt.legend() - leg.get_frame().set_alpha(0.1) - - plt.tick_params(axis='both', labelsize=10) - plt.plot([LDRsim0[iLDR], LDRsim0[iLDR]], [0, np.max(n)], 'r-', lw=2) - plt.gca().set_title("{0:3.0f}%".format(meanDist)) - plt.gca().set_xlabel('LDRsim0', color="red") - - fig.suptitle('LDRsim - ' +LID + ' with ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar + ' error contribution', fontsize=14, y=1.10) - return - - - # Plot Etax - def PlotEtax(aVar, aX, X0, daX, iaX, naX): - # aVar is the name of the parameter and aX is the subset of aLDRcorr which is coloured in the plot - # example: PlotSubHist("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP) - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - Etaxmin = np.amin(aEtax[iLDR, :]) - Etaxmax = np.amax(aEtax[iLDR, :]) - Rmin = Etaxmin * 0.995 # np.min(aLDRcorr[iLDR,:]) * 0.995 - Rmax = Etaxmax * 1.005 # np.max(aLDRcorr[iLDR,:]) * 1.005 - - # Determine mean distance of all aXmean from each other for each iLDR - meanDist = 0.0 - for iaX in range(-naX, naX + 1): - # mean Etax value for certain error (iaX) of parameter aVar - aXmean[iaX + naX] = np.mean(aEtax[iLDR, aX == iaX]) - # relative to absolute spread of Etax - meanDist = (np.max(aXmean) - np.min(aXmean)) / (Etaxmax - Etaxmin) * 100 - - plt.subplot(1, 5, iLDR + 1) - (n, bins, patches) = plt.hist(aEtax[iLDR, :], - bins=50, log=False, - range=[Rmin, Rmax], - alpha=0.5, density=False, color='0.5', histtype='stepfilled') - for iaX in range(-naX, naX + 1): - plt.hist(aEtax[iLDR, aX == iaX], - range=[Rmin, Rmax], - bins=50, log=False, alpha=0.3, density=False, histtype='stepfilled', - label=str(round(X0 + iaX * daX / naX, 5))) - if (iLDR == 2): - leg = plt.legend() - leg.get_frame().set_alpha(0.1) - plt.tick_params(axis='both', labelsize=10) - plt.plot([Etax0, Etax0], [0, np.max(n)], 'r-', lw=2) - plt.gca().set_title("{0:3.0f}%".format(meanDist)) - plt.gca().set_xlabel('Etax0', color="red") - fig.suptitle('Etax - ' + LID + ' with ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar + ' error contribution', fontsize=14, y=1.10) - return - - def PlotEtapx(aVar, aX, X0, daX, iaX, naX): - # aVar is the name of the parameter and aX is the subset of aLDRcorr which is coloured in the plot - # example: PlotSubHist("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP) - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - Etapxmin = np.amin(aEtapx[iLDR, :]) - Etapxmax = np.amax(aEtapx[iLDR, :]) - Rmin = Etapxmin * 0.995 # np.min(aLDRcorr[iLDR,:]) * 0.995 - Rmax = Etapxmax * 1.005 # np.max(aLDRcorr[iLDR,:]) * 1.005 - - # Determine mean distance of all aXmean from each other for each iLDR - meanDist = 0.0 - for iaX in range(-naX, naX + 1): - # mean Etapx value for certain error (iaX) of parameter aVar - aXmean[iaX + naX] = np.mean(aEtapx[iLDR, aX == iaX]) - # relative to absolute spread of Etapx - meanDist = (np.max(aXmean) - np.min(aXmean)) / (Etapxmax - Etapxmin) * 100 - - plt.subplot(1, 5, iLDR + 1) - (n, bins, patches) = plt.hist(aEtapx[iLDR, :], - bins=50, log=False, - range=[Rmin, Rmax], - alpha=0.5, density=False, color='0.5', histtype='stepfilled') - for iaX in range(-naX, naX + 1): - plt.hist(aEtapx[iLDR, aX == iaX], - range=[Rmin, Rmax], - bins=50, log=False, alpha=0.3, density=False, histtype='stepfilled', - label=str(round(X0 + iaX * daX / naX, 5))) - if (iLDR == 2): - leg = plt.legend() - leg.get_frame().set_alpha(0.1) - plt.tick_params(axis='both', labelsize=10) - plt.plot([Etapx0, Etapx0], [0, np.max(n)], 'r-', lw=2) - plt.gca().set_title("{0:3.0f}%".format(meanDist)) - plt.gca().set_xlabel('Etapx0', color="red") - fig.suptitle('Etapx - ' + LID + ' with ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar + ' error contribution', fontsize=14, y=1.10) - return - - def PlotEtamx(aVar, aX, X0, daX, iaX, naX): - # aVar is the name of the parameter and aX is the subset of aLDRcorr which is coloured in the plot - # example: PlotSubHist("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP) - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - Etamxmin = np.amin(aEtamx[iLDR, :]) - Etamxmax = np.amax(aEtamx[iLDR, :]) - Rmin = Etamxmin * 0.995 # np.min(aLDRcorr[iLDR,:]) * 0.995 - Rmax = Etamxmax * 1.005 # np.max(aLDRcorr[iLDR,:]) * 1.005 - - # Determine mean distance of all aXmean from each other for each iLDR - meanDist = 0.0 - for iaX in range(-naX, naX + 1): - # mean Etamx value for certain error (iaX) of parameter aVar - aXmean[iaX + naX] = np.mean(aEtamx[iLDR, aX == iaX]) - # relative to absolute spread of Etamx - meanDist = (np.max(aXmean) - np.min(aXmean)) / (Etamxmax - Etamxmin) * 100 - - plt.subplot(1, 5, iLDR + 1) - (n, bins, patches) = plt.hist(aEtamx[iLDR, :], - bins=50, log=False, - range=[Rmin, Rmax], - alpha=0.5, density=False, color='0.5', histtype='stepfilled') - for iaX in range(-naX, naX + 1): - plt.hist(aEtamx[iLDR, aX == iaX], - range=[Rmin, Rmax], - bins=50, log=False, alpha=0.3, density=False, histtype='stepfilled', - label=str(round(X0 + iaX * daX / naX, 5))) - if (iLDR == 2): - leg = plt.legend() - leg.get_frame().set_alpha(0.1) - plt.tick_params(axis='both', labelsize=10) - plt.plot([Etamx0, Etamx0], [0, np.max(n)], 'r-', lw=2) - plt.gca().set_title("{0:3.0f}%".format(meanDist)) - plt.gca().set_xlabel('Etamx0', color="red") - fig.suptitle('Etamx - ' + LID + ' with ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar + ' error contribution', fontsize=14, y=1.10) - return - - # calc contribution of the error of aVar = aX to aY for each LDRtrue - def Contribution(aVar, aX, X0, daX, iaX, naX, aY, Ysum, widthSum): - # aVar is the name of the parameter and aX is the subset of aY which is coloured in the plot - # example: Contribution("DOLP", aDOLP, DOLP0, dDOLP, iDOLP, nDOLP, aLDRcorr, DOLPcontr) - iLDR = -1 - # Ysum, widthSum = np.zeros(5) - meanDist = np.zeros(5) # iLDR - widthDist = np.zeros(5) # iLDR - for LDRTrue in LDRrange: - aXmean = np.zeros(2 * naX + 1) - aXwidth = np.zeros(2 * naX + 1) - iLDR = iLDR + 1 - # total width of distribution - aYmin = np.amin(aY[iLDR, :]) - aYmax = np.amax(aY[iLDR, :]) - aYwidth = aYmax - aYmin - # Determine mean distance of all aXmean from each other for each iLDR - for iaX in range(-naX, naX + 1): - # mean LDRCorr value for all errors iaX of parameter aVar - aXmean[iaX + naX] = np.mean(aY[iLDR, aX == iaX]) - aXwidth[iaX + naX] = np.max(aY[iLDR, aX == iaX]) - np.min(aY[iLDR, aX == iaX]) - # relative to absolute spread of LDRCorrs - meanDist[iLDR] = (np.max(aXmean) - np.min(aXmean)) / aYwidth * 1000 - # meanDist[iLDR] = (aYwidth - aXwidth[naX]) / aYwidth * 1000 - widthDist[iLDR] = (np.max(aXwidth) - aXwidth[naX]) / aYwidth * 1000 - - print("{:12}{:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f}"\ - .format(aVar,meanDist[0],meanDist[1],meanDist[2],meanDist[3],meanDist[4],widthDist[0],widthDist[1],widthDist[2],widthDist[3],widthDist[4])) - Ysum = Ysum + meanDist - widthSum = widthSum + widthDist - return(Ysum, widthSum) - - # print(.format(LDRrangeA[iLDR],)) - - # error contributions to a certain output aY; loop over all variables - def Contribution_aY(aYvar, aY): - Ysum = np.zeros(5) - widthSum = np.zeros(5) - # meanDist = np.zeros(5) # iLDR - LDRrangeA = np.array(LDRrange) - print() - print(aYvar + ": contribution to the total error (per mill)") - print(" of individual parameter errors of combined parameter errors") - print(" at LDRtrue {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f} {:5.3f}"\ - .format(LDRrangeA[0],LDRrangeA[1],LDRrangeA[2],LDRrangeA[3],LDRrangeA[4],LDRrangeA[0],LDRrangeA[1],LDRrangeA[2],LDRrangeA[3],LDRrangeA[4])) - print() - if (nQin > 0): Ysum, widthSum = Contribution("Qin", aQin, Qin0, dQin, iQin, nQin, aY, Ysum, widthSum) - if (nVin > 0): Ysum, widthSum = Contribution("Vin", aVin, Vin0, dVin, iVin, nVin, aY, Ysum, widthSum) - if (nRotL > 0): Ysum, widthSum = Contribution("RotL", aRotL, RotL0, dRotL, iRotL, nRotL, aY, Ysum, widthSum) - if (nRetE > 0): Ysum, widthSum = Contribution("RetE", aRetE, RetE0, dRetE, iRetE, nRetE, aY, Ysum, widthSum) - if (nRotE > 0): Ysum, widthSum = Contribution("RotE", aRotE, RotE0, dRotE, iRotE, nRotE, aY, Ysum, widthSum) - if (nDiE > 0): Ysum, widthSum = Contribution("DiE", aDiE, DiE0, dDiE, iDiE, nDiE, aY, Ysum, widthSum) - if (nRetO > 0): Ysum, widthSum = Contribution("RetO", aRetO, RetO0, dRetO, iRetO, nRetO, aY, Ysum, widthSum) - if (nRotO > 0): Ysum, widthSum = Contribution("RotO", aRotO, RotO0, dRotO, iRotO, nRotO, aY, Ysum, widthSum) - if (nDiO > 0): Ysum, widthSum = Contribution("DiO", aDiO, DiO0, dDiO, iDiO, nDiO, aY, Ysum, widthSum) - if (nDiC > 0): Ysum, widthSum = Contribution("DiC", aDiC, DiC0, dDiC, iDiC, nDiC, aY, Ysum, widthSum) - if (nRotC > 0): Ysum, widthSum = Contribution("RotC", aRotC, RotC0, dRotC, iRotC, nRotC, aY, Ysum, widthSum) - if (nRetC > 0): Ysum, widthSum = Contribution("RetC", aRetC, RetC0, dRetC, iRetC, nRetC, aY, Ysum, widthSum) - if (nTP > 0): Ysum, widthSum = Contribution("TP", aTP, TP0, dTP, iTP, nTP, aY, Ysum, widthSum) - if (nTS > 0): Ysum, widthSum = Contribution("TS", aTS, TS0, dTS, iTS, nTS, aY, Ysum, widthSum) - if (nRP > 0): Ysum, widthSum = Contribution("RP", aRP, RP0, dRP, iRP, nRP, aY, Ysum, widthSum) - if (nRS > 0): Ysum, widthSum = Contribution("RS", aRS, RS0, dRS, iRS, nRS, aY, Ysum, widthSum) - if (nRetT > 0): Ysum, widthSum = Contribution("RetT", aRetT, RetT0, dRetT, iRetT, nRetT, aY, Ysum, widthSum) - if (nRetR > 0): Ysum, widthSum = Contribution("RetR", aRetR, RetR0, dRetR, iRetR, nRetR, aY, Ysum, widthSum) - if (nERaT > 0): Ysum, widthSum = Contribution("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT, aY, Ysum, widthSum) - if (nERaR > 0): Ysum, widthSum = Contribution("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR, aY, Ysum, widthSum) - if (nRotaT > 0): Ysum, widthSum = Contribution("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT, aY, Ysum, widthSum) - if (nRotaR > 0): Ysum, widthSum = Contribution("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR, aY, Ysum, widthSum) - if (nLDRCal > 0): Ysum, widthSum = Contribution("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal, aY, Ysum, widthSum) - if (nTCalT > 0): Ysum, widthSum = Contribution("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT, aY, Ysum, widthSum) - if (nTCalR > 0): Ysum, widthSum = Contribution("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR, aY, Ysum, widthSum) - if (nNCal > 0): Ysum, widthSum = Contribution("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal, aY, Ysum, widthSum) - if (nNCal > 0): Ysum, widthSum = Contribution("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal, aY, Ysum, widthSum) - if (nNCal > 0): Ysum, widthSum = Contribution("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal, aY, Ysum, widthSum) - if (nNCal > 0): Ysum, widthSum = Contribution("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal, aY, Ysum, widthSum) - if (nNI > 0): Ysum, widthSum = Contribution("SigNoiseIt", aNIt, 0, 1, iNIt, nNI, aY, Ysum, widthSum) - if (nNI > 0): Ysum, widthSum = Contribution("SigNoiseIr", aNIr, 0, 1, iNIr, nNI, aY, Ysum, widthSum) - print("{:12}{:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f} {:5.0f}"\ - .format("Sum ",Ysum[0],Ysum[1],Ysum[2],Ysum[3],Ysum[4],widthSum[0],widthSum[1],widthSum[2],widthSum[3],widthSum[4])) - - - # Plot LDR histograms - if (nQin > 0): PlotSubHist("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotSubHist("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotSubHist("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotSubHist("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotSubHist("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotSubHist("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotSubHist("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotSubHist("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotSubHist("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotSubHist("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotSubHist("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotSubHist("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotSubHist("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotSubHist("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotSubHist("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotSubHist("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotSubHist("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotSubHist("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotSubHist("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotSubHist("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotSubHist("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotSubHist("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotSubHist("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotSubHist("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotSubHist("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotSubHist("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal) - if (nNCal > 0): PlotSubHist("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal) - if (nNCal > 0): PlotSubHist("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal) - if (nNCal > 0): PlotSubHist("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal) - if (nNI > 0): PlotSubHist("SigNoiseIt", aNIt, 0, 1, iNIt, nNI) - if (nNI > 0): PlotSubHist("SigNoiseIr", aNIr, 0, 1, iNIr, nNI) - plt.show() - plt.close - - - - # --- Plot LDRmin, LDRmax - iLDR = -1 - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - LDRmin[iLDR] = np.amin(aLDRcorr[iLDR, :]) - LDRmax[iLDR] = np.amax(aLDRcorr[iLDR, :]) - LDRstd[iLDR] = np.std(aLDRcorr[iLDR, :]) - LDRmean[iLDR] = np.mean(aLDRcorr[iLDR, :]) - LDRmedian[iLDR] = np.median(aLDRcorr[iLDR, :]) - LDRskew[iLDR] = skew(aLDRcorr[iLDR, :],bias=False) - LDRkurt[iLDR] = kurtosis(aLDRcorr[iLDR, :],fisher=True,bias=False) - - fig2 = plt.figure() - LDRrangeA = np.array(LDRrange) - if((np.amax(LDRmax - LDRrangeA)-np.amin(LDRmin - LDRrangeA)) < 0.001): - plt.ylim(-0.001,0.001) - plt.plot(LDRrangeA, LDRmax - LDRrangeA, linewidth=2.0, color='b') - plt.plot(LDRrangeA, LDRmin - LDRrangeA, linewidth=2.0, color='g') - - plt.xlabel('LDRtrue', fontsize=18) - plt.ylabel('LDRTrue-LDRmin, LDRTrue-LDRmax', fontsize=14) - plt.title(LID + ' ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]), fontsize=18) - # plt.ylimit(-0.07, 0.07) - plt.show() - plt.close - - # --- Save LDRmin, LDRmax to file - # http://stackoverflow.com/questions/4675728/redirect-stdout-to-a-file-in-python - with open('output_files\\' + OutputFile, 'a') as f: - # with open('output_files\\' + LID + '-' + InputFile[0:-3] + '-LDR_min_max.dat', 'w') as f: - with redirect_stdout(f): - print("Lidar ID: " + LID) - print() - print("minimum and maximum values of the distributions of possibly measured LDR for different LDRtrue") - print("LDRtrue , LDRmin, LDRmax") - for i in range(len(LDRrangeA)): - print("{0:7.4f},{1:7.4f},{2:7.4f}".format(LDRrangeA[i], LDRmin[i], LDRmax[i])) - print() - # Print LDR statistics - print("LDRtrue , mean , median, max-mean, min-mean, std, excess_kurtosis, skewness") - iLDR = -1 - LDRrangeA = np.array(LDRrange) - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - print("{0:8.5f},{1:8.5f},{2:8.5f}, {3:8.5f},{4:8.5f},{5:8.5f}, {6:8.5f},{7:8.5f}"\ - .format(LDRrangeA[iLDR], LDRmean[iLDR], LDRmedian[iLDR], LDRmax[iLDR]-LDRrangeA[iLDR], \ - LDRmin[iLDR]-LDRrangeA[iLDR], LDRstd[iLDR], LDRkurt[iLDR], LDRskew[iLDR])) - print() - # Calculate and print statistics for calibration factors - print("minimum and maximum values of the distributions of signal ratios and calibration factors for different LDRtrue") - iLDR = -1 - LDRrangeA = np.array(LDRrange) - print("LDRtrue , LDRsim, (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - LDRsimmin[iLDR] = np.amin(aLDRsim[iLDR, :]) - LDRsimmax[iLDR] = np.amax(aLDRsim[iLDR, :]) - # LDRsimstd = np.std(aLDRsim[iLDR, :]) - LDRsimmean[iLDR] = np.mean(aLDRsim[iLDR, :]) - # LDRsimmedian = np.median(aLDRsim[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR],LDRsimmean[iLDR],(LDRsimmax[iLDR]-LDRsimmin[iLDR])/2,(LDRsimmax[iLDR]-LDRsimmin[iLDR])/2/LDRsimmean[iLDR])) - iLDR = -1 - print("LDRtrue , Etax , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etaxmin = np.amin(aEtax[iLDR, :]) - Etaxmax = np.amax(aEtax[iLDR, :]) - # Etaxstd = np.std(aEtax[iLDR, :]) - Etaxmean = np.mean(aEtax[iLDR, :]) - # Etaxmedian = np.median(aEtax[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etaxmean, (Etaxmax-Etaxmin)/2, (Etaxmax-Etaxmin)/2/Etaxmean)) - iLDR = -1 - print("LDRtrue , Etapx , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etapxmin = np.amin(aEtapx[iLDR, :]) - Etapxmax = np.amax(aEtapx[iLDR, :]) - # Etapxstd = np.std(aEtapx[iLDR, :]) - Etapxmean = np.mean(aEtapx[iLDR, :]) - # Etapxmedian = np.median(aEtapx[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etapxmean, (Etapxmax-Etapxmin)/2, (Etapxmax-Etapxmin)/2/Etapxmean)) - iLDR = -1 - print("LDRtrue , Etamx , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etamxmin = np.amin(aEtamx[iLDR, :]) - Etamxmax = np.amax(aEtamx[iLDR, :]) - # Etamxstd = np.std(aEtamx[iLDR, :]) - Etamxmean = np.mean(aEtamx[iLDR, :]) - # Etamxmedian = np.median(aEtamx[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etamxmean, (Etamxmax-Etamxmin)/2, (Etamxmax-Etamxmin)/2/Etamxmean)) - - # Print LDR statistics - print("LDRtrue , mean , median, max-mean, min-mean, std, excess_kurtosis, skewness") - iLDR = -1 - LDRrangeA = np.array(LDRrange) - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - print("{0:8.5f},{1:8.5f},{2:8.5f}, {3:8.5f},{4:8.5f},{5:8.5f}, {6:8.5f},{7:8.5f}".format(LDRrangeA[iLDR], LDRmean[iLDR], LDRmedian[iLDR], LDRmax[iLDR]-LDRrangeA[iLDR], LDRmin[iLDR]-LDRrangeA[iLDR], LDRstd[iLDR],LDRkurt[iLDR],LDRskew[iLDR])) - - - with open('output_files\\' + OutputFile, 'a') as f: - # with open('output_files\\' + LID + '-' + InputFile[0:-3] + '-LDR_min_max.dat', 'a') as f: - with redirect_stdout(f): - Contribution_aY("LDRCorr", aLDRcorr) - Contribution_aY("LDRsim", aLDRsim) - Contribution_aY("EtaX, D90", aEtax) - Contribution_aY("Etapx, +45°", aEtapx) - Contribution_aY("Etamx -45°", aEtamx) - - - # Plot other histograms - if (bPlotEtax): - - if (nQin > 0): PlotLDRsim("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotLDRsim("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotLDRsim("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotLDRsim("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotLDRsim("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotLDRsim("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotLDRsim("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotLDRsim("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotLDRsim("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotLDRsim("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotLDRsim("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotLDRsim("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotLDRsim("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotLDRsim("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotLDRsim("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotLDRsim("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotLDRsim("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotLDRsim("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotLDRsim("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotLDRsim("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotLDRsim("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotLDRsim("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotLDRsim("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotLDRsim("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotLDRsim("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotLDRsim("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal) - if (nNCal > 0): PlotLDRsim("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal) - if (nNCal > 0): PlotLDRsim("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal) - if (nNCal > 0): PlotLDRsim("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal) - if (nNI > 0): PlotLDRsim("SigNoiseIt", aNIt, 0, 1, iNIt, nNI) - if (nNI > 0): PlotLDRsim("SigNoiseIr", aNIr, 0, 1, iNIr, nNI) - plt.show() - plt.close - print("---------------------------------------...producing more plots...------------------------------------------------------------------") - - if (nQin > 0): PlotEtax("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotEtax("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotEtax("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotEtax("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotEtax("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotEtax("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotEtax("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotEtax("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotEtax("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotEtax("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotEtax("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotEtax("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotEtax("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotEtax("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotEtax("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotEtax("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotEtax("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotEtax("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotEtax("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotEtax("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotEtax("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotEtax("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotEtax("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotEtax("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotEtax("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotEtax("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal) - if (nNCal > 0): PlotEtax("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal) - if (nNCal > 0): PlotEtax("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal) - if (nNCal > 0): PlotEtax("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal) - if (nNI > 0): PlotEtax("SigNoiseIt", aNIt, 0, 1, iNIt, nNI) - if (nNI > 0): PlotEtax("SigNoiseIr", aNIr, 0, 1, iNIr, nNI) - plt.show() - plt.close - print("---------------------------------------...producing more plots...------------------------------------------------------------------") - - if (nQin > 0): PlotEtapx("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotEtapx("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotEtapx("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotEtapx("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotEtapx("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotEtapx("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotEtapx("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotEtapx("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotEtapx("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotEtapx("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotEtapx("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotEtapx("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotEtapx("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotEtapx("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotEtapx("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotEtapx("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotEtapx("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotEtapx("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotEtapx("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotEtapx("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotEtapx("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotEtapx("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotEtapx("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotEtapx("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotEtapx("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotEtapx("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal) - if (nNCal > 0): PlotEtapx("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal) - if (nNCal > 0): PlotEtapx("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal) - if (nNCal > 0): PlotEtapx("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal) - if (nNI > 0): PlotEtapx("SigNoiseIt", aNIt, 0, 1, iNIt, nNI) - if (nNI > 0): PlotEtapx("SigNoiseIr", aNIr, 0, 1, iNIr, nNI) - plt.show() - plt.close - print("---------------------------------------...producing more plots...------------------------------------------------------------------") - - if (nQin > 0): PlotEtamx("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotEtamx("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotEtamx("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotEtamx("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotEtamx("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotEtamx("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotEtamx("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotEtamx("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotEtamx("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotEtamx("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotEtamx("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotEtamx("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotEtamx("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotEtamx("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotEtamx("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotEtamx("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotEtamx("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotEtamx("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotEtamx("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotEtamx("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotEtamx("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotEtamx("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotEtamx("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotEtamx("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotEtamx("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotEtamx("CalNoiseTp", aNCalTp, 0, 1, iNCalTp, nNCal) - if (nNCal > 0): PlotEtamx("CalNoiseTm", aNCalTm, 0, 1, iNCalTm, nNCal) - if (nNCal > 0): PlotEtamx("CalNoiseRp", aNCalRp, 0, 1, iNCalRp, nNCal) - if (nNCal > 0): PlotEtamx("CalNoiseRm", aNCalRm, 0, 1, iNCalRm, nNCal) - if (nNI > 0): PlotEtamx("SigNoiseIt", aNIt, 0, 1, iNIt, nNI) - if (nNI > 0): PlotEtamx("SigNoiseIr", aNIr, 0, 1, iNIr, nNI) - plt.show() - plt.close - - # Print Etax statistics - Etaxmin = np.amin(aEtax[1, :]) - Etaxmax = np.amax(aEtax[1, :]) - Etaxstd = np.std(aEtax[1, :]) - Etaxmean = np.mean(aEtax[1, :]) - Etaxmedian = np.median(aEtax[1, :]) - print("Etax , max-mean, min-mean, median, mean ± std, eta") - print("{0:8.5f} ±({1:8.5f},{2:8.5f}),{3:8.5f},{4:8.5f}±{5:8.5f},{6:8.5f}".format(Etax0, Etaxmax-Etax0, Etaxmin-Etax0, Etaxmedian, Etaxmean, Etaxstd, Etax0 / K0)) - print() - - # Calculate and print statistics for calibration factors - iLDR = -1 - LDRrangeA = np.array(LDRrange) - print("LDR...., LDRsim, (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - LDRsimmin[iLDR] = np.amin(aLDRsim[iLDR, :]) - LDRsimmax[iLDR] = np.amax(aLDRsim[iLDR, :]) - # LDRsimstd = np.std(aLDRsim[iLDR, :]) - LDRsimmean[iLDR] = np.mean(aLDRsim[iLDR, :]) - # LDRsimmedian = np.median(aLDRsim[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], LDRsimmean[iLDR], (LDRsimmax[iLDR]-LDRsimmin[iLDR])/2, (LDRsimmax[iLDR]-LDRsimmin[iLDR])/2/LDRsimmean[iLDR])) - iLDR = -1 - print("LDR...., Etax , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etaxmin = np.amin(aEtax[iLDR, :]) - Etaxmax = np.amax(aEtax[iLDR, :]) - # Etaxstd = np.std(aEtax[iLDR, :]) - Etaxmean = np.mean(aEtax[iLDR, :]) - # Etaxmedian = np.median(aEtax[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etaxmean, (Etaxmax-Etaxmin)/2, (Etaxmax-Etaxmin)/2/Etaxmean)) - iLDR = -1 - print("LDR...., Etapx , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etapxmin = np.amin(aEtapx[iLDR, :]) - Etapxmax = np.amax(aEtapx[iLDR, :]) - # Etapxstd = np.std(aEtapx[iLDR, :]) - Etapxmean = np.mean(aEtapx[iLDR, :]) - # Etapxmedian = np.median(aEtapx[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etapxmean, (Etapxmax-Etapxmin)/2, (Etapxmax-Etapxmin)/2/Etapxmean)) - iLDR = -1 - print("LDR...., Etamx , (max-min)/2, relerr") - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - Etamxmin = np.amin(aEtamx[iLDR, :]) - Etamxmax = np.amax(aEtamx[iLDR, :]) - # Etamxstd = np.std(aEtamx[iLDR, :]) - Etamxmean = np.mean(aEtamx[iLDR, :]) - # Etamxmedian = np.median(aEtamx[iLDR, :]) - print("{0:8.5f}, {1:8.5f}, {2:8.5f}, {3:8.5f}".format(LDRrangeA[iLDR], Etamxmean, (Etamxmax-Etamxmin)/2, (Etamxmax-Etamxmin)/2/Etamxmean)) - - f.close() - - -''' - # --- Plot F11 histograms - print() - print(" ############################################################################## ") - print(Text1) - print() - - iLDR = 5 - for LDRTrue in LDRrange: - iLDR = iLDR - 1 - #aF11corr[iLDR,:] = aF11corr[iLDR,:] / aF11corr[0,:] - 1.0 - aF11corr[iLDR,:] = aF11corr[iLDR,:] / aF11sim0[iLDR] - 1.0 - # Plot F11 - def PlotSubHistF11(aVar, aX, X0, daX, iaX, naX): - fig, ax = plt.subplots(nrows=1, ncols=5, sharex=True, sharey=True, figsize=(25, 2)) - iLDR = -1 - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - - #F11min[iLDR] = np.min(aF11corr[iLDR,:]) - #F11max[iLDR] = np.max(aF11corr[iLDR,:]) - #Rmin = F11min[iLDR] * 0.995 # np.min(aLDRcorr[iLDR,:]) * 0.995 - #Rmax = F11max[iLDR] * 1.005 # np.max(aLDRcorr[iLDR,:]) * 1.005 - - #Rmin = 0.8 - #Rmax = 1.2 - - #plt.subplot(5,2,iLDR+1) - plt.subplot(1,5,iLDR+1) - (n, bins, patches) = plt.hist(aF11corr[iLDR,:], - bins=100, log=False, - alpha=0.5, density=False, color = '0.5', histtype='stepfilled') - - for iaX in range(-naX,naX+1): - plt.hist(aF11corr[iLDR,aX == iaX], - bins=100, log=False, alpha=0.3, density=False, histtype='stepfilled', label = str(round(X0 + iaX*daX/naX,5))) - - if (iLDR == 2): plt.legend() - - plt.tick_params(axis='both', labelsize=9) - #plt.plot([LDRTrue, LDRTrue], [0, np.max(n)], 'r-', lw=2) - - #plt.title(LID + ' ' + aVar, fontsize=18) - #plt.ylabel('frequency', fontsize=10) - #plt.xlabel('LDRCorr', fontsize=10) - #fig.tight_layout() - fig.suptitle(LID + ' ' + str(Type[TypeC]) + ' ' + str(Loc[LocC]) + ' - ' + aVar, fontsize=14, y=1.05) - #plt.show() - #fig.savefig(LID + '_' + aVar + '.png', dpi=150, bbox_inches='tight', pad_inches=0) - #plt.close - return - - if (nQin > 0): PlotSubHistF11("Qin", aQin, Qin0, dQin, iQin, nQin) - if (nVin > 0): PlotSubHistF11("Vin", aVin, Vin0, dVin, iVin, nVin) - if (nRotL > 0): PlotSubHistF11("RotL", aRotL, RotL0, dRotL, iRotL, nRotL) - if (nRetE > 0): PlotSubHistF11("RetE", aRetE, RetE0, dRetE, iRetE, nRetE) - if (nRotE > 0): PlotSubHistF11("RotE", aRotE, RotE0, dRotE, iRotE, nRotE) - if (nDiE > 0): PlotSubHistF11("DiE", aDiE, DiE0, dDiE, iDiE, nDiE) - if (nRetO > 0): PlotSubHistF11("RetO", aRetO, RetO0, dRetO, iRetO, nRetO) - if (nRotO > 0): PlotSubHistF11("RotO", aRotO, RotO0, dRotO, iRotO, nRotO) - if (nDiO > 0): PlotSubHistF11("DiO", aDiO, DiO0, dDiO, iDiO, nDiO) - if (nDiC > 0): PlotSubHistF11("DiC", aDiC, DiC0, dDiC, iDiC, nDiC) - if (nRotC > 0): PlotSubHistF11("RotC", aRotC, RotC0, dRotC, iRotC, nRotC) - if (nRetC > 0): PlotSubHistF11("RetC", aRetC, RetC0, dRetC, iRetC, nRetC) - if (nTP > 0): PlotSubHistF11("TP", aTP, TP0, dTP, iTP, nTP) - if (nTS > 0): PlotSubHistF11("TS", aTS, TS0, dTS, iTS, nTS) - if (nRP > 0): PlotSubHistF11("RP", aRP, RP0, dRP, iRP, nRP) - if (nRS > 0): PlotSubHistF11("RS", aRS, RS0, dRS, iRS, nRS) - if (nRetT > 0): PlotSubHistF11("RetT", aRetT, RetT0, dRetT, iRetT, nRetT) - if (nRetR > 0): PlotSubHistF11("RetR", aRetR, RetR0, dRetR, iRetR, nRetR) - if (nERaT > 0): PlotSubHistF11("ERaT", aERaT, ERaT0, dERaT, iERaT, nERaT) - if (nERaR > 0): PlotSubHistF11("ERaR", aERaR, ERaR0, dERaR, iERaR, nERaR) - if (nRotaT > 0): PlotSubHistF11("RotaT", aRotaT, RotaT0, dRotaT, iRotaT, nRotaT) - if (nRotaR > 0): PlotSubHistF11("RotaR", aRotaR, RotaR0, dRotaR, iRotaR, nRotaR) - if (nLDRCal > 0): PlotSubHistF11("LDRCal", aLDRCal, LDRCal0, dLDRCal, iLDRCal, nLDRCal) - if (nTCalT > 0): PlotSubHistF11("TCalT", aTCalT, TCalT0, dTCalT, iTCalT, nTCalT) - if (nTCalR > 0): PlotSubHistF11("TCalR", aTCalR, TCalR0, dTCalR, iTCalR, nTCalR) - if (nNCal > 0): PlotSubHistF11("CalNoise", aNCal, 0, 1/nNCal, iNCal, nNCal) - if (nNI > 0): PlotSubHistF11("SigNoise", aNI, 0, 1/nNI, iNI, nNI) - - - plt.show() - plt.close - - ''' -''' - # only histogram - #print("******************* " + aVar + " *******************") - fig, ax = plt.subplots(nrows=5, ncols=2, sharex=True, sharey=True, figsize=(10, 10)) - iLDR = -1 - for LDRTrue in LDRrange: - iLDR = iLDR + 1 - LDRmin[iLDR] = np.min(aLDRcorr[iLDR,:]) - LDRmax[iLDR] = np.max(aLDRcorr[iLDR,:]) - Rmin = np.min(aLDRcorr[iLDR,:]) * 0.999 - Rmax = np.max(aLDRcorr[iLDR,:]) * 1.001 - plt.subplot(5,2,iLDR+1) - (n, bins, patches) = plt.hist(aLDRcorr[iLDR,:], - range=[Rmin, Rmax], - bins=200, log=False, alpha=0.2, density=False, color = '0.5', histtype='stepfilled') - plt.tick_params(axis='both', labelsize=9) - plt.plot([LDRTrue, LDRTrue], [0, np.max(n)], 'r-', lw=2) - plt.show() - plt.close - # --- End of Plot F11 histograms - ''' - - -''' - # --- Plot K over LDRCal - fig3 = plt.figure() - plt.plot(LDRCal0+aLDRCal*dLDRCal/nLDRCal,aGHK[4,:], linewidth=2.0, color='b') - - plt.xlabel('LDRCal', fontsize=18) - plt.ylabel('K', fontsize=14) - plt.title(LID, fontsize=18) - plt.show() - plt.close - ''' - -# Additional plot routines ======> -''' -#****************************************************************************** -# 1. Plot LDRCorrected - LDR(measured Icross/Iparallel) -LDRa = np.arange(1.,100.)*0.005 -LDRCorra = np.arange(1.,100.) -if Y == - 1.: LDRa = 1./LDRa -LDRCorra = (1./Eta*LDRa*(GT+HT)-(GR+HR))/((GR-HR)-1./Eta*LDRa*(GT-HT)) -if Y == - 1.: LDRa = 1./LDRa -# -#fig = plt.figure() -plt.plot(LDRa,LDRCorra-LDRa) -plt.plot([0.,0.5],[0.,0.5]) -plt.suptitle('LDRCorrected - LDR(measured Icross/Iparallel)', fontsize=16) -plt.xlabel('LDR', fontsize=18) -plt.ylabel('LDRCorr - LDR', fontsize=16) -#plt.savefig('test.png') -# -''' -''' -#****************************************************************************** -# 2. Plot LDRsim (simulated measurements without corrections = Icross/Iparallel) over LDRtrue -LDRa = np.arange(1.,100.)*0.005 -LDRsima = np.arange(1.,100.) - -atruea = (1.-LDRa)/(1+LDRa) -Ita = TiT*TiO*IinL*(GT+atruea*HT) -Ira = TiR*TiO*IinL*(GR+atruea*HR) -LDRsima = Ira/Ita # simulated uncorrected LDR with Y from input file -if Y == -1.: LDRsima = 1./LDRsima -# -#fig = plt.figure() -plt.plot(LDRa,LDRsima) -plt.plot([0.,0.5],[0.,0.5]) -plt.suptitle('LDRsim (simulated measurements without corrections = Icross/Iparallel) over LDRtrue', fontsize=10) -plt.xlabel('LDRtrue', fontsize=18) -plt.ylabel('LDRsim', fontsize=16) -#plt.savefig('test.png') -# -''' \ No newline at end of file
--- a/README_2_05.06.2020_141855.md Wed Jul 07 15:42:30 2021 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,34 +0,0 @@ -Calculation of polarisation correction factors for atmospheric lidar system, developed by Volker Freudenthaler (LMU, Munich, Germany). - -# Theory -The theoretical basis of the script is described in detail in : - -Freudenthaler, V.: -About the effects of polarising optics on lidar signals and the Δ90 calibration, -Atmos. Meas. Tech., 9, 4181-4255, doi:10.5194/amt-9-4181-2016, 2016 -http://www.atmos-meas-tech.net/9/4181/2016/ - -Additional information can be found in: - -Bravo-Aranda, J. A., Belegante, L., Freudenthaler, V., Alados-Arboledas, L., Nicolae, D., Granados-Muñoz, M. J., -Guerrero-Rascado, J. L., Amodeo, A., D'Amico, G., Engelmann, R., Pappalardo, G., Kokkalis, P., Mamouri, R., -Papayannis, A., Navas-Guzmán, F., Olmo, F. J., Wandinger, U., Amato, F., and -Haeffelin, M.: -Assessment of lidar depolarization uncertainty by means of a polarimetric lidar simulator, -Atmos. Meas. Tech., 9, 4935-4953, doi:10.5194/amt-9-4935-2016, 2016. -http://www.atmos-meas-tech.net/9/4935/2016/ - -# Use -To run the script you need to: - -1. Read the information in the script header. - -1. Create a file describing your system settings and parameters. You can find an example file in the "system_settings" - folder. Give a descriptive name and save it in the "system_settings" folder. - -2. Edit the "GHK_0.9.8e5_Py3.7.py" or the current script file with an ASCII editor and set the variable InputFile below line 281 to the filename you chose in step 1. - -3. Run the script "GHK_0.9.8e5_Py3.7.py" (or the current version). - -Note: _0.9.8e5 in the script filename is the script version and _Py3.7 indicates that it is tested with Python 3.7. -
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/system_settings/optic_input_0.9.8h-PollyXT_Cyprus_532_210429_vf_4.py Wed Jul 07 15:59:31 2021 +0200 @@ -0,0 +1,191 @@ +# This Python script will be executed from within the main lidar_correction_ghk.py +# Probably it will be better in the future to let the main script rather read a conguration file, +# which might improve the portability of the code within an executable. +# Due to problems I had with some two letter variables, most variables are now with at least +# three letters mixed small and capital. +# To be used with lidar_correction_ghk.py ver. 0.9.5 and larger + +# Do you want to calculate the errors? If not, just the GHK-parameters are determined. +Error_Calc = True + +# Header to identify the lidar system +EID = "li" # Earlinet station ID +LID = "PollyXT Cyprus 210429 532 approx 4" # Additional lidar ID (short descriptive text) +print(" Lidar system :", EID, ", ", LID) + +# +++ IL Laser and +-Uncertainty +Qin, dQin, nQin = 0.9672, 0.01, 1 # second Stokes vector parameter; default 1 => linear polarization 0.999 => LDR = 0.0005 +Vin, dVin, nVin = 0.0, 0.0, 0 # fourth Stokes vector parameter; default 0 => corresponds to LDR 0.0005 with DOP 1 +RotL, dRotL, nRotL = 91.65, 0.24, 1 #alpha; rotation of laser polarization in degrees; alle wellenlängen im PollyXT Lacros sind vertical zum opt. Tisch polarisiert. + +# +++ ME Emitter optics and +-Uncertainty; default = no emitter optics +DiE, dDiE, nDiE = 0.0, 0.02, 0 # Diattenuation +TiE = 1.0 # Unpolarized transmittance +RetE, dRetE, nRetE = 0., 180., 0 # Retardance in degrees +RotE, dRotE, nRotE = 0., 1.0, 0 # beta: Rotation of the optical element in degrees + +# +++ MO Receiver optics including telescope +DiO, dDiO, nDiO = 0.0, 0.02, 0 # Diattenuation +TiO = 1.0 # Unpolarized transmittance +RetO, dRetO, nRetO = 0., 180., 0 # Retardance in degrees +RotO, dRotO, nRotO = 0., 0.5, 0 # gamma: Rotation of the optical element in degrees + +# +++++ PBS MT Transmitting path defined with TS, TP, PolFilter extinction ratio ERaT, and +-Uncertainty +# --- Polarizing beam splitter transmitting path +TP, dTP, nTP = 0.5, 0.01, 1 # transmittance of the PBS for parallel polarized light +TS, dTS, nTS = 0.5, 0.01, 1 # transmittance of the PBS for cross polarized light +RetT, dRetT, nRetT = 0.0, 180., 0 # Retardance in degrees +# --- Pol.Filter behind transmitted path of PBS +ERaT, dERaT, nERaT = 1.0 , 0 , 0 # Extinction ratio 0.00075 +/- 0.00025 +RotaT, dRotaT, nRotaT = 0., 1., 1 # Rotation of the Pol.-filter in degrees; usually close to 0° because TP >> TS, but for PollyXTs it can also be close to 90° +# -- +TiT = 0.5 * (TP + TS) +DiT = (TP-TS)/(TP+TS) +DaT = (1-ERaT)/(1+ERaT) +TaT = 0.5*(1+ERaT) + +# +++++ PBS MR Reflecting path defined with RS, RP, PolFilter extinction ratio ERaR and +-Uncertainty +# ---- for PBS without absorption the change of RS and RP must depend on the change of TP and TS. Hence the values and uncertainties are not independent. +RS_RP_depend_on_TS_TP = False +# --- Polarizing beam splitter reflecting path +#if(RS_RP_depend_on_TS_TP): +# RP, dRP, nRP = 1-TP, 0.00, 0 # do not change this +# RS, dRS, nRS = 1-TS, 0.00, 0 # do not change this +#else: +RP, dRP, nRP = 0.002, 0.001, 1 # change this if RS_RP_depend_on_TS_TP = False; reflectance of the PBS for parallel polarized light +RS, dRS, nRS = 0.998, 0.001, 1 # change this if RS_RP_depend_on_TS_TP = False; reflectance of the PBS for cross polarized light +RetR, dRetR, nRetR = 0.0, 180., 0 # Retardance in degrees +# --- Pol.Filter behind reflected path of PBS +ERaR, dERaR, nERaR = 1.0, 0.0, 0 # Extinction ratio +RotaR, dRotaR, nRotaR = 0., 1., 0 # Rotation of the Pol.-filter in degrees; usually close to 90° because RS >> RP, but for PollyXTs it can also be close to 0° +# -- +TiR = 0.5* (RP + RS) +DiR = (RP-RS)/(RP+RS) +DaR = (1-ERaR)/(1+ERaR) +TaR = 0.5*(1+ERaR) + +# NEW --- Additional ND filter transmission (attenuation) during the calibration +TCalT, dTCalT, nTCalT = 1, 0.01, 0 # transmitting path, default 1, 0, 0 +TCalR, dTCalR, nTCalR = 1, 0.0001, 0 # reflecting path, default 1, 0, 0 + +# +++ Orientation of the PBS with respect to the reference plane (see Improvements_of_lidar_correction_ghk_ver.0.9.8_190124.pdf) +# Y = +1: polarisation in reference plane is finally transmitted, +# Y = -1: polarisation in reference plane is finally reflected. +Y = -1. + +# +++ Calibrator Location +# --- Calibrator Type used; defined by matrix values below +TypeC = 3 #Type of calibrator: 1 = mechanical rotator; 2 = hwp rotator (fixed retardation); 3 = linear polarizer; 4 = qwp; 5 = circular polarizer; 6 = real HWP calibration +-22.5° +# --- Calibrator Location +LocC = 3 #location of calibrator: 1 = behind laser; 2 = behind emitter; 3 = before receiver; 4 = before PBS +# --- MC Calibrator parameters +if TypeC == 1: #mechanical rotator + DiC, dDiC, nDiC = 0., 0., 0 # Diattenuation + TiC = 1. + RetC, dRetC, nRetC = 0., 0., 0 # Retardance in degrees + RotC, dRotC, nRotC = 0., 1.0, 1 #constant calibrator rotation offset epsilon + # Rotation error without calibrator: if False, then epsilon = 0 for normal measurements + RotationErrorEpsilonForNormalMeasurements = True # is in general True for TypeC == 1 calibrator +elif TypeC == 2: # HWP rotator without retardance! + DiC, dDiC, nDiC = 0., 0., 0 # Diattenuation; ideal 0.0 + TiC = 1. + RetC, dRetC, nRetC = 180., 0., 0 # Retardance in degrees + #NOTE: use here twice the HWP-rotation-angle + RotC, dRotC, nRotC = 0.0, 0.1, 1 #constant calibrator rotation offset epsilon + RotationErrorEpsilonForNormalMeasurements = True # is in general True for TypeC == 2 calibrator +elif TypeC == 3: # linear polarizer calibrator. Diattenuation DiC = (1-ERC)/(1+ERC); ERC = extinction ratio of calibrator + DiC, dDiC, nDiC = 0.99928, 0.00021, 1 # Diattenuation; ideal 1.0 + TiC = 0.4 # ideal 0.5 + RetC, dRetC, nRetC = 0., 0., 0 # Retardance in degrees + RotC, dRotC, nRotC = 0.0, 0.1, 0 #constant calibrator rotation offset epsilon + RotationErrorEpsilonForNormalMeasurements = False # is in general False for TypeC == 3 calibrator +elif TypeC == 4: # QWP calibrator + DiC, dDiC, nDiC = 0.0, 0., 0 # Diattenuation; ideal 0.0 + TiC = 1.0 # ideal 0.5 + RetC, dRetC, nRetC = 90., 0., 0 # Retardance in degrees + RotC, dRotC, nRotC = 0.0, 0.1, 1 #constant calibrator rotation offset epsilon + RotationErrorEpsilonForNormalMeasurements = False # is False for TypeC == 4 calibrator +elif TypeC == 6: # real half-wave plate rotator calibration at +-22.5° => rotated_diattenuator_X22x5deg.odt + DiC, dDiC, nDiC = 0., 0., 0 # Diattenuation; ideal 0.0 + TiC = 1. + RetC, dRetC, nRetC = 180., 0., 0 # Retardance in degrees + #Note: use real HWP angles here + RotC, dRotC, nRotC = 0.0, 0.1, 1 #constant calibrator rotation offset epsilon + RotationErrorEpsilonForNormalMeasurements = True # is in general True for TypeC == 6 calibrator +else: + print ('calibrator not implemented yet') + sys.exit() + +# --- LDRCal uncertainty: atmospheric linear depolarization ratio in the range used for the polarisation calibration during the calibration measurements +LDRCal,dLDRCal,nLDRCal= 0.11, 0.1, 1 # spans the atmopsheric variability +# --- example: LDRCal uncertainty with almost clean air +# LDRCal,dLDRCal,nLDRCal= 0.009, 0.005, 1 # spans the interference filter influence between Cabannes and Rayleigh scattering + +# ==================================================== +# NOTE: there is no need to change anything below. +# ==================================================== +# !!! don't change anything in this section !!! +bPlotEtax = False # plot error histogramms for Etax +# NEW *** Only for signal noise errors *** +nNCal = 0 # error nNCal, calibration signals: one-sigma (fixed) in nNCal steps to left and right +nNI = 0 # error nNI, 0° signals: one-sigma (fixed) in nNI steps to left and right; NI signals are calculated from NCalT and NCalR in main programm, but noise is assumed to be independent. + +# --- number of photon counts in the signal summed up in the calibration range during the calibration measurements +NCalT = 40000 # default 1e6, assumed the same in +45° and -45° signals; counts with ND-filter TCalT +NCalR = 40000 # default 1e6, assumed the same in +45° and -45° signals; counts with ND-filter TCalR +NILfac = 1 # (relative duration (laser shots) of standard (0°) measurement to calibration measurements) * (range of std. meas. smoothing / calibration range); example: 100000#/5000# * 100/1000 = 2 + # LDRmeas below will be used to calculate IR and IT of 0° signals. +# calculate signal counts only from parallel 0° signal assuming the same electronic amplification in both channels; overwrites above values +CalcFrom0deg = True +NI = 100000000 #number of photon counts in the parallel 0°-signal 40000 + +if(CalcFrom0deg): + # either eFactT or eFacR is = 1 => rel. amplification + eFacT = 1 # rel. amplification of transmitted channel, approximate values are sufficient; def. = 1 + eFacR = 1 # rel. amplification of reflected channel, approximate values are sufficient; def. = 1 + NILfac = 1 # (relative duration (laser shots) of standard (0°) measurement to calibration measurements) * (range of std. meas. smoothing / calibration range); example: 100000#/5000# * 100/1000 = 2 + + NCalT = NI / NILfac * TCalT * eFacT # photon counts in transmitted signal during calibration + NCalR = NI / NILfac * TCalR * eFacR # photon counts in reflected signal during calibration + # LDRmeas below will be used to calculate IR and IT of 0° signals. +# NEW *** End of signal noise error parameters *** + +# --- LDRtrue for simulation of measurement => LDRsim +LDRtrue = 0.004 +LDRtrue2 = 0.004 + +# --- measured LDRm will be corrected with calculated parameters GHK +LDRmeas = 0.3 + +# --- this is just for correct transfer of the variables to the main file +Qin0, dQin, nQin = Qin, dQin, nQin +Vin0, dVin, nVin = Vin, dVin, nVin +RotL0, dRotL, nRotL = RotL, dRotL, nRotL +# Emitter +DiE0, dDiE, nDiE = DiE, dDiE, nDiE +RetE0, dRetE, nRetE = RetE, dRetE, nRetE +RotE0, dRotE, nRotE = RotE, dRotE, nRotE +# Receiver +DiO0, dDiO, nDiO = DiO, dDiO, nDiO +RetO0, dRetO, nRetO = RetO, dRetO, nRetO +RotO0, dRotO, nRotO = RotO, dRotO, nRotO +# Calibrator +DiC0, dDiC, nDiC = DiC, dDiC, nDiC +RetC0, dRetC, nRetC = RetC, dRetC, nRetC +RotC0, dRotC, nRotC = RotC, dRotC, nRotC +# PBS +TP0, dTP, nTP = TP, dTP, nTP +TS0, dTS, nTS = TS, dTS, nTS +RetT0, dRetT, nRetT = RetT, dRetT, nRetT + +ERaT0, dERaT, nERaT = ERaT, dERaT, nERaT +RotaT0,dRotaT,nRotaT= RotaT,dRotaT,nRotaT + +RP0, dRP, nRP = RP, dRP, nRP +RS0, dRS, nRS = RS, dRS, nRS +RetR0, dRetR, nRetR = RetR, dRetR, nRetR + +ERaR0, dERaR, nERaR = ERaR, dERaR, nERaR +RotaR0,dRotaR,nRotaR= RotaR,dRotaR,nRotaR + +LDRCal0,dLDRCal,nLDRCal=LDRCal,dLDRCal,nLDRCal \ No newline at end of file
--- a/system_settings/output_optic_input_0.9.8h-PollyXT_Cyprus_532_210429_vf_4_GHK_0.9.8h_Py3.7.dat Wed Jul 07 15:42:30 2021 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,197 +0,0 @@ -From C:\Projects\Earlinet-Asos\Lidarsystems\calc_lidar_correction_parameters -Running GHK_0.9.8h_Py3.7.py -Reading input file optic_input_0.9.8h-PollyXT_Cyprus_532_210429_vf_4.py -for Lidar system: li , PollyXT Cyprus 210429 532 approx 4 - --- Input parameters: value ±error / ±steps ---------------------- -Laser: Qin = 0.9672± 0.0100/ 1 - Vin = 0.0000± 0.0000/ 0 - Rotation alpha = 91.6500± 0.2400/ 1 - => DOP 0.9672 (degree of polarisation) -Optic: Diatt., Tunpol, Retard., Rotation (deg) -Emitter 0.0000 ± 0.0200 / 0, 1.0000, 0±180/ 0, 0.0000± 1.0000/ 0 -Receiver 0.0000 ± 0.0200 / 0, 1.0000, 0±180/ 0, 0.0000± 0.5000/ 0 -Calibrator 0.999280± 0.000210/ 1, 0.4000, 0± 0/ 0, 0.0000± 0.1000/ 0 - Pol.-filter ------ -ERT, RotT : 1.0000± 0.0000/ 0, 0.0000± 1.0000/ 1 -ERR, RotR : 1.0000± 0.0000/ 0, 0.0000± 1.0000/ 0 - PBS ------ -TP,TS : 0.5000± 0.0100/ 1, 0.5000± 0.0100/ 1 -RP,RS : 0.0020± 0.0010/ 1, 0.9980± 0.0010/ 1 -DT,TT,DR,TR,Y : 0.0000, 0.5000, -0.9960, 0.5000, -1 - Combined PBS + Pol.-filter ------ -DT,TT,DR,TR : 0.0000, 0.5000, -0.9960, 0.5000 -LDRCal during calibration in calibration range: 0.110± 0.100/ 1 - --- Additional ND filter attenuation (transmission) during the calibration --- -TCalT,TCalR : 1.0000± 0.0100/ 0, 1.0000± 0.0001/ 0 - -Linear polarizer calibrator is located before the receiver -Rotation error epsilon is considered also for normal measurements = False -The PBS incidence plane is perpendicular to the reference plane -The laser polarisation in the reference plane is finally reflected => the parallel laser polarisation is detected in the transmitted channel. -RS_RP_depend_on_TS_TP = False - -=========================================================================================================== - GR , GT , HR , HT , K(0.110), K(0.004), K(0.05) , K(0.1) , K(0.2) , K(0.3) , K(0.45) - 1.00000, 1.00000,-0.96173, 0.00000, 0.97068 , 0.96369, 0.96690, 0.97008, 0.97564, 0.98033, 0.98615 -=========================================================================================================== - -2nd order polyfit: K(LDRcal) = a + (b * LDRcal) + (c * LDRcal^2) -(LDRcal is the volume linear depolarisation ratio in the range used for the polarisation calibration) - a = 0.96352 - b = 0.06904 - c = -0.04188 - -Errors from neglecting GHK corrections and/or calibration: - LDRtrue, LDRunCorr,1/LDRunCorr, LDRsimx, 1/LDRsimx, LDRCorr - 0.00400, 0.04732, 21.13427, 0.04593, 21.77255, 0.00400 - 0.02000, 0.07828, 12.77531, 0.07598, 13.16114, 0.02000 - 0.10000, 0.21956, 4.55449, 0.21313, 4.69204, 0.10000 - 0.30000, 0.49670, 2.01327, 0.48214, 2.07407, 0.30000 - 0.45000, 0.65439, 1.52814, 0.63520, 1.57430, 0.45000 -LDRsimx = LDR of the nominal system directly from measured signals without calibration and GHK-corrections -LDRunCorr = LDR of the nominal system directly from measured signals with calibration but without GHK-corrections; electronic amplifications = 1 assumed -LDRCorr = LDR calibrated and GHK-corrected - -Errors from signal noise: -Signal counts: NI, NCalT, NCalR, NILfac, nNCal, nNI, stdev(NI)/NI = 100000000, 100000000, 100000000, 1, 0, 0, 0.00010 - - -Lidar ID: PollyXT Cyprus 210429 532 approx 4 - -Correction K(LDRCal in calibration range) -LDRCal, K(LDRCal) -0.004, 0.96369 -0.050, 0.96690 -0.100, 0.97008 -0.200, 0.97564 -0.300, 0.98033 -0.450, 0.98615 - -minimum and maximum values of the distributions of possibly measured LDR for different LDRtrue -LDRtrue , LDRmin, LDRmax - 0.0040,-0.0029, 0.0114 - 0.0200, 0.0127, 0.0279 - 0.1000, 0.0906, 0.1102 - 0.3000, 0.2863, 0.3151 - 0.4500, 0.4340, 0.4679 - -LDRCal is the volume linear depolarisation ratio in the range used for the polarisation calibration. K(LDRCal) is the variability of K depending on LDRCal. -If LDRCal is not known, its uncertainty has to be included in the input file for the error calcualtion below. -LDR_min-true(LDR_true) and LDR_max-true(LDR_true) are the difference between the lowest and highest possible retrieved LDR, respectively, and the true LDR depending on the true LDR. They represent the negative and positive uncertainty of the retrieved LDR resulting from all known uncertainties of the optical input parameters. ------------------------------------------------ -2nd order polyfit = a + (b * LDR) + (c * LDR^2) -fit-parameter, K(LDRCal), LDR_min-true(LDRtrue), LDR_max-true(LDRtrue) - a, +0.96352, -0.00674, +0.00727 - b, +0.06904, -0.02805, +0.03080 - c, -0.04188, +0.01659, -0.01587 - -################################################################################## -Further statistical analyses of the uncertainties, their distribution and sources: - -LDRtrue , mean , median, max-mean, min-mean, std, excess_kurtosis, skewness - 0.00400, 0.00404, 0.00402, 0.00739,-0.00685, 0.00431, -1.37505, 0.01060 - 0.02000, 0.02004, 0.02003, 0.00788,-0.00729, 0.00432, -1.35168, 0.01361 - 0.10000, 0.10006, 0.10001, 0.01019,-0.00938, 0.00447, -1.11574, 0.02519 - 0.30000, 0.30013, 0.30010, 0.01508,-0.01366, 0.00523, -0.47128, 0.06082 - 0.45000, 0.45018, 0.45000, 0.01792,-0.01600, 0.00607, -0.34137, 0.12718 - -minimum and maximum values of the distributions of signal ratios and calibration factors for different LDRtrue -LDRtrue , LDRsim, (max-min)/2, relerr - 0.00400, 0.04596, 0.01325, 0.28826 - 0.02000, 0.07602, 0.01353, 0.17791 - 0.10000, 0.21319, 0.01478, 0.06935 - 0.30000, 0.48224, 0.01725, 0.03578 - 0.45000, 0.63531, 0.01866, 0.02937 -LDRtrue , Etax , (max-min)/2, relerr - 0.00400, 0.97066, 0.03207, 0.03304 - 0.02000, 0.97066, 0.03207, 0.03304 - 0.10000, 0.97066, 0.03207, 0.03304 - 0.30000, 0.97066, 0.03207, 0.03304 - 0.45000, 0.97066, 0.03207, 0.03304 -LDRtrue , Etapx , (max-min)/2, relerr - 0.00400, 0.97203, 0.03152, 0.03243 - 0.02000, 0.97203, 0.03152, 0.03243 - 0.10000, 0.97203, 0.03152, 0.03243 - 0.30000, 0.97203, 0.03152, 0.03243 - 0.45000, 0.97203, 0.03152, 0.03243 -LDRtrue , Etamx , (max-min)/2, relerr - 0.00400, 0.96930, 0.03303, 0.03408 - 0.02000, 0.96930, 0.03303, 0.03408 - 0.10000, 0.96930, 0.03303, 0.03408 - 0.30000, 0.96930, 0.03303, 0.03408 - 0.45000, 0.96930, 0.03303, 0.03408 - -LDRCorr: contribution to the total error (per mill) - of individual parameter errors of combined parameter errors - at LDRtrue 0.004 0.020 0.100 0.300 0.450 0.004 0.020 0.100 0.300 0.450 - -Qin 725 680 519 318 230 21 19 13 4 0 -RotL 34 32 25 15 12 1 1 1 1 1 -DiC 15 24 62 133 185 7 8 15 28 37 -TP 31 49 104 145 138 9 9 7 3 0 -TS 31 49 104 145 138 9 9 7 3 0 -RP 141 132 101 62 45 4 4 3 1 0 -RS 0 0 0 0 0 0 0 0 0 0 -RotaT 0 0 0 0 0 0 0 0 0 0 -LDRCal 21 33 84 182 252 10 12 19 34 44 -Sum 999 999 999 999 1000 61 62 64 74 83 - -LDRsim: contribution to the total error (per mill) - of individual parameter errors of combined parameter errors - at LDRtrue 0.004 0.020 0.100 0.300 0.450 0.004 0.020 0.100 0.300 0.450 - -Qin 745 706 550 310 202 15 14 11 6 4 -RotL 35 33 26 14 9 0 0 0 0 0 -DiC 0 0 0 0 0 0 0 0 0 0 -TP 68 108 258 425 465 18 17 13 9 9 -TS 2 4 30 134 216 1 1 4 8 9 -RP 148 143 121 88 73 2 2 2 1 1 -RS 3 5 14 28 34 1 1 1 1 1 -RotaT 0 0 0 0 0 0 0 0 0 0 -LDRCal 0 0 0 0 0 0 0 0 0 0 -Sum 1000 1000 1000 1000 1000 37 35 30 26 25 - -EtaX, D90: contribution to the total error (per mill) - of individual parameter errors of combined parameter errors - at LDRtrue 0.004 0.020 0.100 0.300 0.450 0.004 0.020 0.100 0.300 0.450 - -Qin 10 10 10 10 10 3 3 3 3 3 -RotL 0 0 0 0 0 0 0 0 0 0 -DiC 136 136 136 136 136 24 24 24 24 24 -TP 312 312 312 312 312 7 7 7 7 7 -TS 294 294 294 294 294 13 13 13 13 13 -RP 32 32 32 32 32 0 0 0 0 0 -RS 30 30 30 30 30 1 1 1 1 1 -RotaT 0 0 0 0 0 0 0 0 0 0 -LDRCal 186 186 186 186 186 29 29 29 29 29 -Sum 1000 1000 1000 1000 1000 78 78 78 78 78 - -Etapx, +45°: contribution to the total error (per mill) - of individual parameter errors of combined parameter errors - at LDRtrue 0.004 0.020 0.100 0.300 0.450 0.004 0.020 0.100 0.300 0.450 - -Qin 9 9 9 9 9 3 3 3 3 3 -RotL 6 6 6 6 6 3 3 3 3 3 -DiC 132 132 132 132 132 23 23 23 23 23 -TP 317 317 317 317 317 7 7 7 7 7 -TS 300 300 300 300 300 13 13 13 13 13 -RP 33 33 33 33 33 0 0 0 0 0 -RS 31 31 31 31 31 1 1 1 1 1 -RotaT 0 0 0 0 0 0 0 0 0 0 -LDRCal 172 172 172 172 172 28 28 28 28 28 -Sum 1000 1000 1000 1000 1000 79 79 79 79 79 - -Etamx -45°: contribution to the total error (per mill) - of individual parameter errors of combined parameter errors - at LDRtrue 0.004 0.020 0.100 0.300 0.450 0.004 0.020 0.100 0.300 0.450 - -Qin 10 10 10 10 10 4 4 4 4 4 -RotL 6 6 6 6 6 4 4 4 4 4 -DiC 139 139 139 139 139 27 27 27 27 27 -TP 303 303 303 303 303 7 7 7 7 7 -TS 284 284 284 284 284 13 13 13 13 13 -RP 31 31 31 31 31 0 0 0 0 0 -RS 29 29 29 29 29 1 1 1 1 1 -RotaT 0 0 0 0 0 0 0 0 0 0 -LDRCal 197 197 197 197 197 33 33 33 33 33 -Sum 999 999 999 999 999 89 89 89 89 89
