Commit 9fbedc59 authored by Aleksandra Mnich's avatar Aleksandra Mnich
Browse files

Merge branch 'SIGMON-145_fixes' into 'dev'

[SIGMON-145] notebook syntax fixes

See merge request !53
parents 6e07335d 4bc756c6
Pipeline #3167299 failed with stages
in 174 minutes and 17 seconds
%% Cell type:markdown id: tags:
<h1><center>Analysis of an FPA in an 600A Circuit - with/without Energy Extraction</center></h1>
Figure 1 shows a generic circuit diagram, equipped with EE and parallel resistor, as well as lead resistances and a quench resistance.
<img src="https://gitlab.cern.ch/LHCData/lhc-sm-hwc/-/raw/master/figures/600A/600A.png" width=75%>
source: Test Procedure and Acceptance Criteria for the 600 A Circuits, MP3 Procedure, <a href="https://edms.cern.ch/document/874716">https://edms.cern.ch/document/874716</a>
%% Cell type:markdown id: tags:
# Analysis Assumptions
- We consider standard analysis scenarios, i.e., all signals can be queried. If a signal is missing, an analysis can raise a warning and continue or an error and abort the analysis.
- It is recommended to execute each cell one after another. However, since the signals are queried prior to analysis, any order of execution is allowed. In case an analysis cell is aborted, the following ones may not be executed (e.g. I\_MEAS not present).
# Plot Convention
- Scales are labeled with signal name followed by a comma and a unit in square brackets, e.g., I_MEAS, [A].
- If a reference signal is present, it is represented with a dashed line.
- If the main current is present, its axis is on the left. Remaining signals are attached to the axis on the right. The legend of these signals is located on the lower left and upper right, respectively.
- The grid comes from the left axis.
- The title contains timestamp, circuit name, and signal name allowing to re-access the signal.
- The plots assigned to the left scale have colors: blue (C0) and orange (C1). Plots presented on the right have colors red (C2) and green (C3).
- Each plot has an individual time-synchronization mentioned explicitly in the description.
- If an axis has a single signal, then the color of the label matches the signal's color. Otherwise, the label color is black.
%% Cell type:markdown id: tags:
# 0. Initialise Working Environment
%% Cell type:code id: tags:
``` python
# External libraries
print('Loading (1/16)'); import pandas as pd
print('Loading (2/16)'); import numpy as np
print('Loading (3/16)'); import sys
print('Loading (4/16)'); from IPython.display import display, Javascript, clear_output, HTML
# Internal libraries
print('Loading (5/16)'); import lhcsmapi
print('Loading (6/16)'); from lhcsmapi.Time import Time
print('Loading (7/16)'); from lhcsmapi.Timer import Timer
print('Loading (8/16)'); from lhcsmapi.analysis.R600ACircuitQuery import R600ACircuitQuery
print('Loading (9/16)'); from lhcsmapi.analysis.R600ACircuitAnalysis import R600ACircuitAnalysis
print('Loading (10/16)'); from lhcsmapi.analysis.expert_input import get_expert_decision
print('Loading (11/16)'); from lhcsmapi.analysis.report_template import apply_report_template
print('Loading (12/16)'); from lhcsmapi.gui.DateTimeBaseModule import DateTimeBaseModule
print('Loading (13/16)'); from lhcsmapi.gui.pc.FgcPmSearchModuleMediator import FgcPmSearchModuleMediator
print('Loading (14/16)'); from lhcsmapi.metadata.SignalMetadata import SignalMetadata
print('Loading (15/16)'); from lhcsmnb.parameters import are_all_parameters_injected, NbType
print('Loading (16/16)'); import lhcsmnb.utils
clear_output()
lhcsmapi.get_lhcsmapi_version()
lhcsmapi.get_lhcsmhwc_version('../__init__.py')
```
%% Cell type:markdown id: tags:
# 1. Select FGC Post Mortem Entry
%% Cell type:markdown id: tags:skip_cell
In order to perform the analysis of a FPA in an 600A circuit with/without EE please:
1. Select circuit family (e.g., RCS)
2. Choose start and end time
3. Choose analysis mode (Automatic by default)
Once these inputs are provided, click 'Find FGC PM' button entries'. This will trigger a search of the PM database in order to provide a list of timestamps of FGC events associated with the selected circuit name for the provided period of time. Select one timestamp from the 'FGC PM Entries' list to be processed by the following cells.
**Note that 24 hours is the maximum duration of a single PM query for an event. To avoid delays in querying events, please restrict your query duration as much as possible.**
%% Cell type:code id: tags:parameters
``` python
circuit_type = '600A'
fgc_pm_search = FgcPmSearchModuleMediator(DateTimeBaseModule(start_date_time='2021-01-26 00:00:00+01:00',
end_date_time='2021-01-31 00:00:00+01:00'), circuit_type=circuit_type)
```
%% Cell type:markdown id: tags:
# 2. Query All Signals Prior to Analysis
%% Cell type:code id: tags:skip_output
``` python
with Timer():
if not are_all_parameters_injected(NbType.FGC, locals()):
author = fgc_pm_search.get_author()
is_automatic = fgc_pm_search.is_automatic_mode()
timestamp_fgc = fgc_pm_search.get_fgc_timestamp()
circuit_name = fgc_pm_search.get_fgc_circuit()
query = R600ACircuitQuery(circuit_type, circuit_name, max_executions=10)
i_meas_df, i_a_df, i_ref_df, i_earth_df = query.query_pc_pm(timestamp_fgc, timestamp_fgc, signal_names=['I_MEAS', 'I_A', 'I_REF', 'I_EARTH'])
events_action_df, events_symbol_df = query.query_pc_pm_events(timestamp_fgc, signal_names=['ACTION', 'SYMBOL'])
# Create results table
results_table = query.create_report_analysis_template(timestamp_fgc, init_file_path='../__init__.py', author=author)
# PIC
timestamp_pic = query.find_timestamp_pic(timestamp_fgc, spark=spark)
# EE
if 'EE' in SignalMetadata.get_system_types_per_circuit_name(circuit_type, circuit_name):
query.max_executions += 2
source_timestamp_ee_df = query.find_source_timestamp_ee(timestamp_fgc)
timestamp_ee = lhcsmnb.utils.get_at(source_timestamp_ee_df, 0, 'timestamp')
u_dump_res_df = query.query_ee_u_dump_res_pm(timestamp_ee, timestamp_fgc, system='EE', signal_names=['U_DUMP_RES'])[0]
else:
source_timestamp_ee_df = pd.DataFrame()
# QDS
# To check if there was any drift of QDS cards prior to the trigger
i_meas_nxcals_df = query.query_pc_nxcals(timestamp_fgc, signal_names=['I_MEAS'], spark=spark)[0]
u_res_nxcals_df = query.query_iqps_nxcals(timestamp_fgc, signal_names=['U_RES'], spark=spark)[0]
source_timestamp_qds_df = query.find_source_timestamp_qds_board_ab(timestamp_fgc, duration=[(2, 's'), (2, 's')])
timestamp_qds = lhcsmnb.utils.get_at(source_timestamp_qds_df, 0, 'timestamp', default=np.nan)
i_dcct_df, i_didt_df, u_res_df, u_diff_df = query.query_qds_pm(timestamp_qds, timestamp_qds, signal_names=['I_DCCT', 'I_DIDT', 'U_RES', 'U_DIFF'])
# LEADS
leads_name = [x for x in SignalMetadata.get_system_types_per_circuit_name(circuit_type, circuit_name) if 'LEADS' in x][0]
source_timestamp_leads_df = query.find_timestamp_leads(timestamp_fgc, leads_name)
u_hts_leads_dfs = query.query_leads(timestamp_fgc, source_timestamp_leads_df, system=leads_name, signal_names=['U_HTS'], spark=spark, duration=[(300, 's'), (900, 's')])
u_res_leads_dfs = query.query_leads(timestamp_fgc, source_timestamp_leads_df, system=leads_name, signal_names=['U_RES'], spark=spark, duration=[(300, 's'), (900, 's')])
analysis = R600ACircuitAnalysis(circuit_type, results_table, is_automatic=is_automatic)
timestamp_dct = {'FGC': timestamp_fgc, 'PIC': timestamp_pic,
'QDS_A': lhcsmnb.utils.get_at(source_timestamp_qds_df, 0, 'timestamp', default=np.nan),
'QDS_B': slhcsmnb.utils.get_at(source_timestamp_qds_df, 1, 'timestamp', default=np.nan)}
'QDS_B': lhcsmnb.utils.get_at(source_timestamp_qds_df, 1, 'timestamp', default=np.nan)}
if 'EE' in SignalMetadata.get_system_types_per_circuit_name(circuit_type, circuit_name):
timestamp_dct['EE'] = lhcsmnb.utils.get_at(source_timestamp_ee_df, 0, 'timestamp', default=np.nan)
```
%% Cell type:markdown id: tags:
# 3. Timestamps
The analysis for MP3 consists of checking the existence of PM file and of consistency of the PM timestamps (PC, QPS, EE if applicable). The criterion of passing this test described in detail in 600APIC2.
In short the following criteria should be checked:
- 2 PM DQAMGNA (A+B) files and 1 PM EE file should be generated for 600 A circuits with EE
- Difference between QPS board A and B timestamp = 1 ms
- PC timestamp is QPS timestamp +/- 20 ms
- EE timestamp is +/-20 ms from the QPS timestamp
If one or more of these conditions are not fulfilled, then an in-depth analysis has to be performed by the QPS team.
%% Cell type:code id: tags:
``` python
analysis.create_timestamp_table(timestamp_dct, circuit_name)
```
%% Cell type:markdown id: tags:
# 4. PC
## 4.1. Main Current
*ANALYSIS*:
- determination of the source of an FPA trigger based on EVENTS.SYMBOL and EVENTS.ACTION signals
- detection of the start of a quench as a deviation of I_A and I_REF
- calculation of the MIITs
- calculation of the quench current
- calculation of the duration of a plateau / the ramp rate before a quench
**You may manually adjust the automatically calculated quench start by clicking the right button on a mouse of a plot with current zoom.**
*GRAPHS*:
- dashed blue line denotes the start of a quench (I_A starts to deviate from I_REF)
- t = 0 s corresponds to the FGC timestamp
%% Cell type:code id: tags:
``` python
import matplotlib as mpl
mpl.rcParams['savefig.dpi'] = 80
mpl.rcParams['figure.dpi'] = 80
%matplotlib notebook
analysis.plot_i_meas_pc(circuit_name, timestamp_fgc, [i_meas_df, i_a_df, i_ref_df])
```
%% Cell type:code id: tags:
``` python
t_quench = analysis.estimate_quench_start_from_i_ref_i_a(i_ref_df, i_a_df)
t_quench = 0 if t_quench is None else t_quench
t_quench_correction = analysis.plot_i_meas_pc_with_cursor(circuit_name, timestamp_fgc, [i_meas_df, i_a_df, i_ref_df], t_quench)
```
%% Cell type:code id: tags:
``` python
analysis.analyze_i_meas_pc_trigger(timestamp_fgc, events_action_df, events_symbol_df)
t_quench = analysis.choose_quench_time_from_auto_or_manual(t_quench_correction)
analysis.calculate_current_miits_i_meas_i_a(i_meas_df, i_a_df, t_quench, col_name='MIITS_circ')
analysis.calculate_quench_current(i_meas_df, t_quench, col_name='I_Q_circ')
analysis.calculate_current_slope(i_meas_df, col_name=['Ramp rate', 'Plateau duration'])
```
%% Cell type:markdown id: tags:
## 4.2. Earth Current
*ANALYSIS*:
- calculation of the maximum absolute earth current (maintaining the sign)
*PLOT*:
- t = 0 s corresponds to the FGC timestamp
%% Cell type:code id: tags:
``` python
analysis.plot_i_earth_pc(circuit_name, timestamp_fgc, i_earth_df)
analysis.calculate_max_i_earth_pc(i_earth_df, col_name='I_Earth_max')
```
%% Cell type:markdown id: tags:
# 5. EE
The analysis is only performed for circuits with an EE system.
*ANALYSIS*:
- calculation of the maximum voltage over the energy extraction system
*GRAPHS*:
- t = 0 s corresponds to the FGC timestamp
%% Cell type:code id: tags:
``` python
if 'EE' in SignalMetadata.get_system_types_per_circuit_name(circuit_type, circuit_name):
analysis.analyze_u_dump_res_ee(circuit_name, timestamp_fgc, i_meas_df, u_dump_res_df, col_name='U_EE_max')
else:
print('Circuit %s does not contain an EE system, analysis skipped.' % circuit_name)
```
%% Cell type:code id: tags:
``` python
if 'EE' in SignalMetadata.get_system_types_per_circuit_name(circuit_type, circuit_name):
analysis.results_table['EE analysis'] = get_expert_decision('EE analysis: ', ['PASS', 'FAIL'])
else:
analysis.results_table['EE analysis'] = 'No EE'
```
%% Cell type:markdown id: tags:
# 6. QDS
The quench voltage U_RES is calculated according to the following formula:
\begin{equation}
U_{\text{RES}} = U_{\text{DIFF}} + L d/dt (I+U_{\text{DIFF}}/R).
\end{equation}
Note that I_DCCT is the QPS signal name, even though the current is actually measured not with a DCCT, but with a LEM detector, hence the poorer quality w.r.t. to the FGC I_A/B/MEAS signals that are measured with a DCCT.
It can be seen from the sign convention in the figure below that a resistive voltage always has opposite sign to the measured current.
<img src="https://gitlab.cern.ch/LHCData/lhc-sm-hwc/-/raw/master/figures/600A/600A.png" width=75%>
As U_DIFF contributes directly to U_RES, the resolution of U_RES is, at least partially, limited by that of U_DIFF. Moreover, U_RES is affected by the noisy time derivative of the current signal.
The QPS signals that are communicated to the post-mortem system have only 12 bit resolution.
%% Cell type:markdown id: tags:
## 6.1. Resistive Voltage
*ANALYSIS*:
- Check if the U_RES signal before a quench is increasing for at least one board, which would indicate a QPS trip
- Calculate the initial voltage slope of U_RES signal. The slope is calculated as a ratio of the voltage change from 50 to 200 mV and the corresponding time change.
*GRAPHS*:
First plot (U_RES and I_MEAS prior to a quench)
- t = 0 s corresponds to the FGC timestamp
Second plot (U_RES and the initial slope of U_RES)
- t = 0 s corresponds to the QPS timestamp
%% Cell type:code id: tags:
``` python
analysis.plot_u_res(circuit_name, timestamp_qds, u_res_nxcals_df, i_meas_nxcals_df)
```
%% Cell type:code id: tags:
``` python
u_res_slope_df = analysis.calculate_u_res_slope(u_res_df, col_name='dU_QPS/dt')
analysis.plot_u_res_slope(circuit_name, timestamp_qds, u_res_df, u_res_slope_df)
```
%% Cell type:markdown id: tags:
## 6.2. I_DCCT, I_DIDT Currents; U_RES, U_DIFF Voltages
*ANALYSIS*
- Check the integrity of all four signals (U_DIFF, I_DCCT, I_DIDT and U_RES). If one of the signals (especially U_DIFF or I_DCCT) stays at zero or shows wrong values the cabling of this quench detector could have issues. Compare U_DIFF (measured signal) to U_REF (signal compensated for inductive voltage).
*CRITERIA*
- U_RES < 0.7*100 mV
- **noise of U_RES on the plateaus < 20mV**
*GRAPHS*:
- t = 0 s corresponds to the QPS timestamp
%% Cell type:code id: tags:
``` python
analysis.plot_qds(circuit_name, timestamp_qds, i_dcct_df, i_didt_df, u_diff_df, u_res_df)
```
%% Cell type:markdown id: tags:
## 6.3. LEADS
*ANALYSIS*:
- check if U_HTS for 2 consecutive datapoints is above the threshold 3 mV
- check if U_RES for 2 consecutive datapoints is above the threshold 100 mV
*GRAPHS*:
- t = 0 s corresponds to the FGC timestamp
%% Cell type:code id: tags:
``` python
analysis.analyze_leads_voltage(u_hts_leads_dfs, circuit_name, timestamp_fgc, signal='U_HTS', value_min=-0.003, value_max=0.003)
```
%% Cell type:code id: tags:
``` python
analysis.analyze_leads_voltage(u_res_leads_dfs, circuit_name, timestamp_fgc, signal='U_RES', value_min=-0.1, value_max=0.1)
```
%% Cell type:code id: tags:
``` python
if not is_automatic:
analysis.results_table['FPA Reason'] = get_expert_decision('Reason for FPA: ', ['QPS trip', 'Converter trip', 'EE spurious opening', 'Spurious heater firing', 'Busbar quench', 'Magnet quench', 'HTS current lead quench' ,'RES current lead overvoltage', 'No quench', 'Unknown'])
analysis.results_table['Type of Quench'] = get_expert_decision('Type of Quench: ', ['Training', 'Heater-provoked', 'Beam-induced', 'GHe propagation', 'QPS crate reset', 'Single Event Upset' ,'Short-to-ground', 'EM disturbance', 'No quench', 'Unknown'])
analysis.results_table['QDS trigger origin'] = get_expert_decision('QDS trigger origin: ', ['QPS', 'HTS current lead', 'RES current lead', 'Busbar', 'No quench'])
```
%% Cell type:markdown id: tags:
# 7. Analysis Comment
%% Cell type:code id: tags:
``` python
if not is_automatic:
analysis.results_table['Comment'] = input('Comment: ')
```
%% Cell type:markdown id: tags:ignore
# 8. Final Report
%% Cell type:code id: tags:ignore
``` python
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', None)
analysis_start_time = Time.get_analysis_start_time()
date_time_fgc = Time.to_datetime(timestamp_fgc).strftime("%Y-%m-%d-%Hh%M")
prefix_circuit_name = SignalMetadata.parse_600A_circuit_name_to_family_name(circuit_name)
!mkdir -p /eos/project/m/mp3/600A/$prefix_circuit_name/$circuit_name/FPA
file_name = "{}_FPA-{}-{}".format(circuit_name, date_time_fgc, analysis_start_time)
full_path = '/eos/project/m/mp3/600A/{}/{}/FPA/{}.csv'.format(prefix_circuit_name, circuit_name, file_name)
mp3_results_table = analysis.create_mp3_results_table()
display(HTML(mp3_results_table.T.to_html()))
mp3_results_table.to_csv(full_path, index=False)
print('MP3 results table saved to (Windows): ' + '\\\\cernbox-smb' + full_path.replace('/', '\\'))
apply_report_template()
full_path = '/eos/project/m/mp3/600A/{}/{}/FPA/{}.html'.format(prefix_circuit_name, circuit_name, file_name)
print('Compact notebook report saved to (Windows): ' + '\\\\cernbox-smb' + full_path.replace('/', '\\'))
display(Javascript('IPython.notebook.save_notebook();'))
Time.sleep(5)
file_name_html = file_name + '.html'
!{sys.executable} -m jupyter nbconvert --to html $'AN_600A_with_without_EE_FPA.ipynb' --output /eos/project/m/mp3/600A/$prefix_circuit_name/$circuit_name/FPA/$file_name_html --TemplateExporter.exclude_input=True --TagRemovePreprocessor.remove_all_outputs_tags='["skip_output"]' --TagRemovePreprocessor.remove_cell_tags='["skip_cell"]'
```
%% Cell type:code id: tags:
``` python
```
......
%% Cell type:markdown id: tags:
<h1><center>Analysis of a PLI2.e3 HWC Test in an IPQ Circuit</center></h1>
The Individually Powered Quadrupole magnets (IPQs) in the LHC are located on both sides of the Interaction Regions (IR), in the matching sector and in the dispersion suppressor. The IPQ circuits RQ4 to RQ7 are part of the matching sector, and the IPQ circuits RQ8 to RQ10 are part of the dispersion suppressor. The magnets Q4 to Q6 are operated at
4.5 K, whereas the magnets Q7 to Q10 are operated at 1.9 K.
The MQM quadrupole consists of two individually powered apertures assembled in a common yoke structure.
The MQY wide-aperture quadrupole consists of two individually powered apertures assembled in a common yoke structure.
### PLI2.E3 - SPLICE MAPPING AND UNBALANCED SLOW POWER ABORT
For the HWC 2014, this test has been modified to include splice mapping. By increasing the current level from I\_INTERM\_1 to I\_INTERM\_2, the difference in maximum current between this test and next test at I\_PNO is reduced. In addition a plateau at I\_INJECTION is added to serve the splice mapping.
The aim of this test is to verify the response of both power converters in case of Slow Power Abort with unbalanced currents and to perform splice mapping.
<img src="https://gitlab.cern.ch/LHCData/lhc-sm-hwc/-/raw/master/figures/ipq/PLI2.E3_current.png" width=50%>
<center>Current during PLI2.E3 for tests starting from 2014 HWC. The actual values of current may deviate from the values shown above.</center>
Offline analyses are listed below:
|Responsible|Type of Analysis|Criteria|
|-----------|----------------|--------|
|PC|Verify acceleration and ramp rate of the PCs||
|PC|PC voltage and current||
|MP3|Check if QPS tripped (it is not expected).||
| |Check if PM file was created (it is not expected).||
| |Calculate splice resistances (**not possible due to limited logging resolution**)||
| |Check DFB regulation|T_top_HTS = 50 +/- 4 K|
| ||T_top_Cu = temperature at 0 A current +/- 10 K|
source: Test Procedure for the Individually Powered 4-6 kA Quadrupole-Circuits in the LHC Insertions, MP3 Procedure, <a href="https://edms.cern.ch/document/874884">https://edms.cern.ch/document/874884</a> (Please follow this link for the latest version)
%% Cell type:markdown id: tags:
# Analysis Assumptions
- We consider standard analysis scenarios, i.e., all signals can be queried. If a signal is missing, an analysis can raise a warning and continue or an error and abort the analysis.
- It is recommended to execute each cell one after another. However, since the signals are queried prior to analysis, any order of execution is allowed. In case an analysis cell is aborted, the following ones may not be executed (e.g. I\_MEAS not present).
# Plot Convention
- Scales are labeled with signal name followed by a comma and a unit in square brackets, e.g., I_MEAS, [A].
- If a reference signal is present, it is represented with a dashed line.
- If the main current is present, its axis is on the left. Remaining signals are attached to the axis on the right. The legend of these signals is located on the lower left and upper right, respectively.
- The grid comes from the left axis.
- The title contains timestamp, circuit name, and signal name allowing to re-access the signal.
- The plots assigned to the left scale have colors: blue (C0) and orange (C1). Plots presented on the right have colors red (C2) and green (C3).
- Each plot has an individual time-synchronization mentioned explicitly in the description.
- If an axis has a single signal, then the color of the label matches the signal's color. Otherwise, the label color is black.
%% Cell type:markdown id: tags:
# 0. Initialise Working Environment
%% Cell type:code id: tags:
``` python
# External libraries
print('Loading (1/13)'); import sys
print('Loading (2/13)'); import pandas as pd
print('Loading (3/13)'); import numpy as np
print('Loading (4/13)'); from IPython.display import display, Javascript, clear_output
print('Loading (1/14)'); import sys
print('Loading (2/14)'); import pandas as pd
print('Loading (3/14)'); import numpy as np
print('Loading (4/14)'); from IPython.display import display, Javascript, clear_output
# Internal libraries
print('Loading (5/13)'); import lhcsmapi
print('Loading (6/13)'); from lhcsmapi.Time import Time
print('Loading (7/13)'); from lhcsmapi.Timer import Timer
print('Loading (8/13)'); from lhcsmapi.analysis.IpqCircuitQuery import IpqCircuitQuery
print('Loading (9/13)'); from lhcsmapi.analysis.IpqCircuitAnalysis import IpqCircuitAnalysis
print('Loading (10/13)'); from lhcsmapi.analysis.report_template import apply_report_template
print('Loading (11/13)'); from lhcsmapi.gui.hwc.HwcSearchModuleMediator import HwcSearchModuleMediator
print('Loading (12/13)'); from lhcsmapi.pyedsl.PlotBuilder import create_hwc_plot_title_with_circuit_name
print('Loading (13/13)'); from lhcsmapi.analysis.expert_input import get_expert_decision
print('Loading (5/14)'); import lhcsmapi
print('Loading (6/14)'); from lhcsmapi.Time import Time
print('Loading (7/14)'); from lhcsmapi.Timer import Timer
print('Loading (8/14)'); from lhcsmapi.analysis.IpqCircuitQuery import IpqCircuitQuery
print('Loading (9/14)'); from lhcsmapi.analysis.IpqCircuitAnalysis import IpqCircuitAnalysis
print('Loading (10/14)'); from lhcsmapi.analysis.report_template import apply_report_template
print('Loading (11/14)'); from lhcsmapi.gui.hwc.HwcSearchModuleMediator import HwcSearchModuleMediator
print('Loading (12/14)'); from lhcsmapi.pyedsl.PlotBuilder import create_hwc_plot_title_with_circuit_name
print('Loading (13/14)'); from lhcsmapi.analysis.expert_input import get_expert_decision
print('Loading (14/14)'); import lhcsmnb.utils
clear_output()
lhcsmapi.get_lhcsmapi_version()
lhcsmapi.get_lhcsmhwc_version('../__init__.py')
print('Analysis performed by %s' % HwcSearchModuleMediator.get_user())
```
%% Cell type:markdown id: tags:
# 1. User Input
1. Copy code from AccTesting and paste into an empty cell below
<img src="https://gitlab.cern.ch/LHCData/lhc-sm-hwc/-/raw/master/figures/swan-manual-acctesting-integration.png">
- If you only want to test the notebook only for the copy&paste feature (without opening the AccTesting), please copy and execute the code below
```
hwc_test = 'PLI2.e3'
circuit_name = 'RQ10.L2'
campaign = 'HWC_2017'
t_start = '2017-04-21 17:28:45.861'
t_end = '2017-04-21 17:54:39.795'
```
2. To analyze a historical test with a browser GUI, copy and execute the following code in the cell below
```
circuit_type = 'IPQ'
hwc_test = 'PLI2.e3'
hwcb = HwcSearchModuleMediator(circuit_type=circuit_type, hwc_test=hwc_test, hwc_summary_path='/eos/project/l/lhcsm/hwc/HWC_Summary.csv')
```
- After opening the browser GUI, choose a circuit name in order to display HWC test with, campaign name as well as start and end time
%% Cell type:code id: tags:parameters
``` python
```
%% Cell type:code id: tags:
``` python
print('hwc_test = \'%s\'\ncircuit_name = \'%s\'\ncampaign = \'%s\'\nt_start = \'%s\'\nt_end = \'%s\'' % (hwc_test, circuit_name, campaign, t_start, t_end))
```
%% Cell type:markdown id: tags:
# 2. Query All Signals Prior to Analysis
%% Cell type:code id: tags:skip_output
``` python
circuit_type = 'IPQ'
if 'hwcb' in locals():
circuit_name = hwcb.get_circuit_name()
t_start = Time.to_unix_timestamp(hwcb.get_start_time())
t_end = Time.to_unix_timestamp(hwcb.get_end_time())
is_automatic = hwcb.is_automatic_mode()
else:
t_start = Time.to_unix_timestamp(t_start)
t_end = Time.to_unix_timestamp(t_end)
is_automatic = False
ipq_query = IpqCircuitQuery(circuit_type, circuit_name, max_executions=5)
ipq_analysis = IpqCircuitAnalysis(circuit_type, pd.DataFrame(), circuit_name=circuit_name)
with Timer():
# PIC
dt = Time.to_unix_timestamp(t_end)-Time.to_unix_timestamp(t_start)
timestamp_pic = ipq_query.find_timestamp_pic(t_start, duration=(dt, 'ns'), spark=spark)
# PC
i_meas_b1_df, i_meas_b2_df = ipq_query.query_signal_nxcals(t_start, t_end, t0=t_start, system='PC', signal_names='I_MEAS', spark=spark)
source_timestamp_fgc_df = ipq_query.find_source_timestamp_pc(t_start, t_end)
if not source_timestamp_fgc_df.empty:
source_fgc_b1, timestamp_fgc_b1 = ipq_query.split_source_timestamp_fgc(source_timestamp_fgc_df, 'B1')
source_fgc_b2, timestamp_fgc_b2 = ipq_query.split_source_timestamp_fgc(source_timestamp_fgc_df, 'B2')
else:
timestamp_fgc_b1, timestamp_fgc_b2 = np.nan, np.nan
# QDS
if not source_timestamp_fgc_df.empty:
source_timestamp_qds_df = ipq_query.find_source_timestamp_qds_board_ab(timestamp_fgc_b1, duration=[(2, 's'), (2, 's')])
else:
source_timestamp_qds_df = pd.DataFrame()
# Splice resistance
u_res_b1_raw_df, u_res_b2_raw_df = ipq_query.query_raw_signal_nxcals(t_start, t_end, system='QDS', signal_names=['U_RES_B1', 'U_RES_B2'], spark=spark)
# LEADS
tt893_nxcals_b1_dfs = ipq_query.query_dfb_signal_nxcals(t_start, t_end, system='LEADS_B1_NXCALS_WINCCOA', signal_names='TT893', spark=spark)
tt891a_nxcals_b1_dfs = ipq_query.query_dfb_signal_nxcals(t_start, t_end, system='LEADS_B1_NXCALS_WINCCOA', signal_names='TT891A', spark=spark)
# DFB
tt893_nxcals_b2_dfs = ipq_query.query_dfb_signal_nxcals(t_start, t_end, system='LEADS_B2_NXCALS_WINCCOA', signal_names='TT893', spark=spark)
tt891a_nxcals_b2_dfs = ipq_query.query_dfb_signal_nxcals(t_start, t_end, system='LEADS_B2_NXCALS_WINCCOA', signal_names='TT891A', spark=spark)
timestamp_dct = {'FGC_B1': timestamp_fgc_b1, 'FGC_B2': timestamp_fgc_b2, 'PIC': timestamp_pic,
'QDS_A':lhcsmnb.utils.get_at(source_timestamp_qds_df, 0, 'timestamp', default=np.nan),
'QDS_B':lhcsmnb.utils.get_at(source_timestamp_qds_df, 1, 'timestamp', deafult=np.nan)}
'QDS_B':lhcsmnb.utils.get_at(source_timestamp_qds_df, 1, 'timestamp', default=np.nan)}
```
%% Cell type:markdown id: tags:
# 3. Timestamps
It is expected that neither the PC nor QPS PM files were created.
In case the QPS tripped, the analysis for MP3 consists of checking the existence of PM file and of consistency of the PM timestamps (PC, QPS).
In short the following criteria should be checked:
- The PC timestamp (51_self) is QPS timestamp +-20 ms.
- The difference between QPS board A and B timestamp = 1ms.
If one or more of these conditions are not fulfilled, then an in-depth analysis has to be performed by the QPS team.
%% Cell type:code id: tags:
``` python
ipq_analysis.create_timestamp_table(timestamp_dct)
```
%% Cell type:markdown id: tags:
# 4. PC
## 4.1. Main Current
*GRAPHS*:
- t = 0 s corresponds to the start of the test
- one plot for each power converter
- orange boxes denote current plateaus
%% Cell type:code id: tags:
``` python
import matplotlib as mpl
mpl.rcParams['savefig.dpi'] = 80
mpl.rcParams['figure.dpi'] = 80
%matplotlib notebook
title = '%sB1, %s: %s-%s' % (circuit_name, hwc_test, Time.to_string(t_start).split('.')[0], Time.to_string(t_end).split('.')[0])
ipq_analysis.plot_i_meas(i_meas_b1_df, title=title)
```
%% Cell type:code id: tags:
``` python
title = '%sB2, %s: %s-%s' % (circuit_name, hwc_test, Time.to_string(t_start).split('.')[0], Time.to_string(t_end).split('.')[0])
ipq_analysis.plot_i_meas(i_meas_b2_df, title=title)
```
%% Cell type:markdown id: tags:
# 5. Quench Protection System
The signal names used for quench detection are shown in the figure below (*please run a cell below to display a QPS circuit schematic corresponding to the circuit name under analysis*).
**Quench Detector Type**
DQQDC – current leads quench detector
DQAMG – controller attached to global protection
**Current Leads:**
- Typical resistance for U_RES: 7 uOhm
- Threshold for U_HTS: 3 mV, 1 s
- Polarity convention: if I_B1 = I_B2 > 0, LD1:U_RES < 0, LD3:U_RES > 0
- PM file:
- Buffer range: 0 to 250, event at point 50
- Time range: -10 to 40 s
- Frequency: 5 Hz (dt = 200 ms)
**Magnet:**
- See polarity convention here above
- U_RES_B1 = U_1_B1 + U_2_B1
- U_RES_B2 = U_1_B2 + U_2_B2
- Threshold on U_RES: 100 mV, 10 ms
- Attention: B1 signals & B2 signals can be shifted by 4ms from each other
- If pure inductive signal:
- If dI/dt < 0:
- U_1_Qx = Ldi / dt < 0
- U_2_Qx = -Ldi / dt > 0
- PM file:
- Buffer range: 501 to 1500, event at point 1000
- Time range: -2 to 2s
- Frequency: 250Hz (dt = 4ms)
%% Cell type:code id: tags:
``` python
from lhcsmapi.gui.pc.fgc_pm_event_select.IpqFgcPmEventSelectBaseModule import IpqFgcPmEventSelectBaseModule
IpqFgcPmEventSelectBaseModule('IPQ').display_qps_circuit_schematic(circuit_name)
```
%% Cell type:markdown id: tags:
## 5.1. Splice Resistance
*CRITERIA*
- Check if R_max < 5 nOhm **Due to limited voltage resolution of logged signals this check is only possible with ELQA measurements**
*GRAPHS*:
- voltage and current measurements for splice resistance calculation
%% Cell type:code id: tags:
``` python
from copy import deepcopy
u_res_b1_df = deepcopy(u_res_b1_raw_df)
u_res_b1_df.index = (u_res_b1_df.index-u_res_b1_df.index[0])/1e9
```
%% Cell type:code id: tags:
``` python
title = '%sB1, %s: %s-%s' % (circuit_name, hwc_test, Time.to_string(t_start).split('.')[0], Time.to_string(t_end).split('.')[0])
ipq_analysis.plot_i_meas_u_res_current_plateau(i_meas_b1_df, u_res_b1_df, t0=None, plateau_start=[], plateau_end=[], title=title)
```
%% Cell type:code id: tags:
``` python
u_res_b2_df = deepcopy(u_res_b2_raw_df)
u_res_b2_df.index = (u_res_b2_df.index-u_res_b2_df.index[0])/1e9
```
%% Cell type:code id: tags:
``` python
title = '%sB2, %s: %s-%s' % (circuit_name, hwc_test, Time.to_string(t_start).split('.')[0], Time.to_string(t_end).split('.')[0])
ipq_analysis.plot_i_meas_u_res_current_plateau(i_meas_b2_df, u_res_b2_df, t0=None, plateau_start=[], plateau_end=[], title=title)
```
%% Cell type:markdown id: tags:
## 5.2. DFB Regulation
*CRITERIA*
- Check if the temperatures TT893 at the top of the copper part of the four current leads, is over dew point, but not overheated: 280 K < TT893 < 320 K, even without current
- Check if the temperatures TT891A at the top of the HTS part of the four current leads, is regulated around 50 K: 46 K < TT891A < 54 K, even without current
*GRAPHS*:
- t = 0 s corresponds to the start of the test
- green boxes denote the acceptance criteria
%% Cell type:code id: tags:
``` python
ipq_analysis.assert_tt893_min_max_value(tt893_nxcals_b1_dfs, i_meas_b1_df, value_range=(280, 320))
```
%% Cell type:code id: tags:
``` python
ipq_analysis.assert_tt893_min_max_value(tt893_nxcals_b2_dfs, i_meas_b2_df, value_range=(280, 320))
```
%% Cell type:code id: tags:
``` python
ipq_analysis.assert_tt891a_min_max_value(tt891a_nxcals_b1_dfs, i_meas_b1_df, value_range=(46, 54))
```
%% Cell type:code id: tags:
``` python
ipq_analysis.assert_tt891a_min_max_value(tt891a_nxcals_b2_dfs, i_meas_b2_df, value_range=(46, 54))
```
%% Cell type:markdown id: tags:ignore
# 5. Signature Decision
%% Cell type:code id: tags:ignore
``` python
signature = get_expert_decision('Expert Signature Decision: ', ['PASSED', 'FAILED'])
```
%% Cell type:markdown id: tags:ignore
# 6. Final Report
%% Cell type:code id: tags:ignore
``` python
analysis_start_time = Time.get_analysis_start_time()
prefix_circuit_name = circuit_name.split('.')[0]
file_name_html = '{}_{}-{}-{}_{}.html'.format(circuit_name, hwc_test, Time.to_datetime(t_start).strftime("%Y-%m-%d-%Hh%M"), analysis_start_time, signature)
full_path = '/eos/project/m/mp3/IPQ/{}/{}/{}/{}'.format(prefix_circuit_name, circuit_name, hwc_test, file_name_html)
!mkdir -p /eos/project/m/mp3/IPQ/$prefix_circuit_name/$circuit_name/$hwc_test
print('Compact notebook report saved to (Windows): ' + '\\\\cernbox-smb' + full_path.replace('/', '\\'))
display(Javascript('IPython.notebook.save_notebook();'))
Time.sleep(5)
!{sys.executable} -m jupyter nbconvert --to html $'AN_IPQ_PLI2.e3.ipynb' --output /eos/project/m/mp3/IPQ/$prefix_circuit_name/$circuit_name/$hwc_test/$file_name_html --TemplateExporter.exclude_input=True --TagRemovePreprocessor.remove_all_outputs_tags='["skip_output"]'
```
%% Cell type:code id: tags:
``` python
```
......
%% Cell type:markdown id: tags:
<h1><center>Analysis of PLI1.b2 HWC Test in an RB Circuit</center></h1>
<img src="https://gitlab.cern.ch/LHCData/lhc-sm-hwc/raw/master/figures/rb/RB.png" width=75%>
The current in the circuit is increased to I_INJECTION and shortly maintained constant. A quench simulation from one current lead is performed provoking a discharge of the energy through the EE system. The aim of the test is to check at a low current level the performance of the QPS and EE systems.
From 2010 on, a time delay is implemented between the switch opening and the FPA signal received (300 ms at the odd point, 600 ms at the even point).
<img src="https://gitlab.cern.ch/LHCData/lhc-sm-hwc/raw/master/figures/rb/PLI1_current.png" width=75%>
The required analysis and signatures are listed below.
|Responsible|Type of analysis|Criterion|
|-----------|----------------|---------|
|PC|PC voltage check|PC voltage ~ -1.5 V ± 0.5 V, 1 s after the EE activation. The current decay time constant should be within 20% of Decay_Time_const. Smooth exponential waveform on the PC voltage and current during the whole decay|
|PC|Earth Current Analysis|The maximum earth current <50 mA during EE activation disregarding the peak at the opening of the EE system.|
|EE|Energy discharge|Maximum voltage on EE resistance ($R*I$±10%) and maximum temperature of the EE resistance (±10% from theoretical value)|
|EE|Energy discharge|Time delay on switch opening (300±50ms at odd point and 600±50ms at even point)|
source: Powering Procedure and Acceptance Criteria for the 13 kA Dipole Circuits, MP3 Procedure, <a href="https://edms.cern.ch/document/874713">https://edms.cern.ch/document/874713</a> (Please follow this link for the latest version)
%% Cell type:markdown id: tags:
# Analysis Assumptions
- We consider standard analysis scenarios, i.e., all signals can be queried. If a signal is missing, an analysis can raise a warning and continue or an error and abort the analysis.
- It is recommended to execute each cell one after another. However, since the signals are queried prior to analysis, any order of execution is allowed. In case an analysis cell is aborted, the following ones may not be executed (e.g. I\_MEAS not present).
# Plot Convention
- Scales are labeled with signal name followed by a comma and a unit in square brackets, e.g., I_MEAS, [A].
- If a reference signal is present, it is represented with a dashed line.
- If the main current is present, its axis is on the left. Remaining signals are attached to the axis on the right. The legend of these signals is located on the lower left and upper right, respectively.
- The grid comes from the left axis.
- The title contains timestamp, circuit name, and signal name allowing to re-access the signal.
- The plots assigned to the left scale have colors: blue (C0) and orange (C1). Plots presented on the right have colors red (C2) and green (C3).
- Each plot has an individual time-synchronization mentioned explicitly in the description.
- If an axis has a single signal, then the color of the label matches the signal's color. Otherwise, the label color is black.
%% Cell type:markdown id: tags:
# 0. Initialise Working Environment
%% Cell type:code id: tags:
``` python
# External libraries
print('Loading (1/12)'); import sys; import pandas as pd
print('Loading (2/12)'); from IPython.display import display, Javascript, clear_output
# Internal libraries
print('Loading (3/12)'); import lhcsmapi
print('Loading (4/12)'); from lhcsmapi.Time import Time
print('Loading (5/12)'); from lhcsmapi.Timer import Timer
print('Loading (6/12)'); from lhcsmapi.analysis.RbCircuitQuery import RbCircuitQuery
print('Loading (7/12)'); from lhcsmapi.analysis.RbCircuitAnalysis import RbCircuitAnalysis
print('Loading (8/12)'); from lhcsmapi.analysis.report_template import apply_report_template
print('Loading (9/12)'); from lhcsmapi.gui.hwc.HwcSearchModuleMediator import HwcSearchModuleMediator
print('Loading (10/12)'); from lhcsmapi.pyedsl.PlotBuilder import create_hwc_plot_title_with_circuit_name
print('Loading (11/12)'); from lhcsmapi.analysis.expert_input import get_expert_decision
print('Loading (12/12)'); import lhcsmnb.utils
clear_output()
lhcsmapi.get_lhcsmapi_version()
lhcsmapi.get_lhcsmhwc_version('../__init__.py')
print('Analysis performed by %s' % HwcSearchModuleMediator.get_user())
```
%% Cell type:markdown id: tags:
# 1. User Input
1. Copy code from AccTesting and paste into an empty cell below
<img src="https://gitlab.cern.ch/LHCData/lhc-sm-hwc/-/raw/master/figures/swan-manual-acctesting-integration.png">
- If you only want to test the notebook only for the copy&paste feature (without opening the AccTesting), please copy and execute the code below
```
hwc_test = 'PLI1.b2'
circuit_name = 'RB.A12'
campaign = 'HWC_2018_1'
t_start = '2018-03-16 18:55:57.270'
t_end = '2018-03-16 19:07:00.286'
```
2. To analyze a historical test with a browser GUI, copy and execute the following code in the cell below
```
circuit_type = 'RB'
hwc_test = 'PLI1.b2'
hwcb = HwcSearchModuleMediator(circuit_type=circuit_type, hwc_test=hwc_test, hwc_summary_path='/eos/project/l/lhcsm/hwc/HWC_Summary.csv')
```
- After opening the browser GUI, choose a circuit name in order to display HWC test with, campaign name as well as start and end time
%% Cell type:code id: tags:parameters
``` python
```
%% Cell type:code id: tags:
``` python
print('hwc_test = \'%s\'\ncircuit_name = \'%s\'\ncampaign = \'%s\'\nt_start = \'%s\'\nt_end = \'%s\'' % (hwc_test, circuit_name, campaign, t_start, t_end))
```
%% Cell type:markdown id: tags:
# 2. Query All Signals Prior to Analysis
%% Cell type:code id: tags:skip_output
``` python
circuit_type = 'RB'
if 'hwcb' in locals():
circuit_name = hwcb.get_circuit_name()
t_start = Time.to_unix_timestamp(hwcb.get_start_time())
t_end = Time.to_unix_timestamp(hwcb.get_end_time())
t_start_ref = Time.to_unix_timestamp(hwcb.get_ref_start_time())
t_end_ref = Time.to_unix_timestamp(hwcb.get_ref_end_time())
is_automatic = hwcb.is_automatic_mode()
else:
t_start = Time.to_unix_timestamp(t_start)
t_end = Time.to_unix_timestamp(t_end)
t_start_ref, t_end_ref = HwcSearchModuleMediator.get_last_ref_start_end_time('/eos/project/l/lhcsm/hwc/HWC_Summary.csv', circuit_name, hwc_test, Time.to_string_short(t_start))
t_start_ref, t_end_ref = Time.to_unix_timestamp(t_start_ref), Time.to_unix_timestamp(t_end_ref)
is_automatic = False
rb_query = RbCircuitQuery(circuit_type, circuit_name, max_executions=28)
rb_analysis = RbCircuitAnalysis(circuit_type, results_table=None, is_automatic=is_automatic)
with Timer():
# PC
i_meas_nxcals_df = rb_query.query_signal_nxcals(t_start, t_end, t0=t_start, system='PC', signal_names='I_MEAS', spark=spark)[0]
source_timestamp_pc = rb_query.find_source_timestamp_pc(t_start, t_end)
timestamp_fgc = source_timestamp_pc.at[0, 'timestamp']
i_meas_df, i_a_df, i_ref_df, i_earth_df, i_earth_pcnt_df, v_meas_df = rb_query.query_pc_pm(timestamp_fgc, timestamp_fgc, signal_names=['I_MEAS', 'I_A', 'I_REF', 'I_EARTH', 'I_EARTH_PCNT', 'V_MEAS'])
# PC Reference
if t_start_ref:
source_timestamp_pc_ref = rb_query.find_source_timestamp_pc(t_start_ref, t_end_ref)
timestamp_fgc_ref = source_timestamp_pc_ref.at[0, 'timestamp']
else:
timestamp_fgc_ref = float('nan')
i_meas_ref_df = rb_query.query_pc_pm(timestamp_fgc_ref, timestamp_fgc_ref, signal_names=['I_MEAS'])[0]
# PIC
timestamp_pic = rb_query.find_timestamp_pic(timestamp_fgc, spark=spark)
# EE Voltage
source_timestamp_ee_odd_df = rb_query.find_source_timestamp_ee(timestamp_fgc, system='EE_ODD')
timestamp_ee_odd = lhcsmnb.utils.get_at(source_timestamp_ee_odd_df, 0, 'timestamp')
source_ee_odd = lhcsmnb.utils.get_at(source_timestamp_ee_odd_df, 0, 'source')
u_dump_res_odd_df = rb_query.query_ee_u_dump_res_pm(timestamp_ee_odd, timestamp_fgc, system='EE_ODD', signal_names=['U_DUMP_RES'])[0]
source_timestamp_ee_even_df = rb_query.find_source_timestamp_ee(timestamp_fgc, system='EE_EVEN')
timestamp_ee_even = lhcsmnb.utils.get_at(source_timestamp_ee_even_df, 0, 'timestamp')
source_ee_even = lhcsmnb.utils.get_at(source_timestamp_ee_even_df, 0, 'source')
u_dump_res_even_df = rb_query.query_ee_u_dump_res_pm(timestamp_ee_even, timestamp_fgc, system='EE_EVEN', signal_names=['U_DUMP_RES'])[0]
# EE Temperature
t_res_odd_0_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_odd_df, 0, 'timestamp'), timestamp_fgc, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_ODD')
if len(source_timestamp_ee_odd_df) > 1:
t_res_odd_1_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_odd_df, 1, 'timestamp'), timestamp_fgc, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_ODD')
else:
t_res_odd_1_df = [pd.DataFrame(columns=['T_RES_BODY_1']), pd.DataFrame(columns=['T_RES_BODY_2']), pd.DataFrame(columns=['T_RES_BODY_3'])]
t_res_even_0_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_even_df, 0, 'timestamp'), timestamp_fgc, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_EVEN')
if len(source_timestamp_ee_even_df) > 1:
t_res_even_1_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_even_df, 1, 'timestamp'), timestamp_fgc, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_EVEN')
else:
t_res_even_1_df = [pd.DataFrame(columns=['T_RES_BODY_1']), pd.DataFrame(columns=['T_RES_BODY_2']), pd.DataFrame(columns=['T_RES_BODY_3'])]
# EE Voltage Reference
if t_start_ref:
source_timestamp_ee_odd_ref_df = rb_query.find_source_timestamp_ee(timestamp_fgc_ref, system='EE_ODD')
source_timestamp_ee_even_ref_df = rb_query.find_source_timestamp_ee(timestamp_fgc_ref, system='EE_EVEN')
u_dump_res_odd_ref_df = rb_query.query_ee_u_dump_res_pm(lhcsmnb.utils.get_at(lhcsmnb.utils.get_at(source_timestamp_ee_odd_ref_df, 0, 'timestamp'), timestamp_fgc_ref, system='EE_ODD', signal_names=['U_DUMP_RES'])[0]
u_dump_res_odd_ref_df = rb_query.query_ee_u_dump_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_odd_ref_df, 0, 'timestamp'), timestamp_fgc_ref, system='EE_ODD', signal_names=['U_DUMP_RES'])[0]
u_dump_res_even_ref_df = rb_query.query_ee_u_dump_res_pm(lhcsmnb.utils.get_at(lhcsmnb.utils.get_at(source_timestamp_ee_even_ref_df, 0, 'timestamp'), timestamp_fgc_ref, system='EE_EVEN', signal_names=['U_DUMP_RES'])[0]
u_dump_res_even_ref_df = rb_query.query_ee_u_dump_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_even_ref_df, 0, 'timestamp'), timestamp_fgc_ref, system='EE_EVEN', signal_names=['U_DUMP_RES'])[0]
# EE Temperature Reference
t_res_odd_0_ref_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_odd_ref_df, 0, 'timestamp'), timestamp_fgc_ref, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_ODD')
if len(source_timestamp_ee_odd_ref_df) > 1:
t_res_odd_1_ref_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_odd_ref_df, 1, 'timestamp'), timestamp_fgc_ref, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_ODD')
else:
t_res_odd_1_ref_df = [pd.DataFrame(columns=['T_RES_BODY_1']), pd.DataFrame(columns=['T_RES_BODY_2']), pd.DataFrame(columns=['T_RES_BODY_3'])]
t_res_even_0_ref_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_even_ref_df, 0, 'timestamp'), timestamp_fgc_ref, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_EVEN')
if len(source_timestamp_ee_even_ref_df) > 1:
t_res_even_1_ref_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_even_ref_df, 1, 'timestamp'), timestamp_fgc_ref, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_EVEN')
else:
t_res_even_1_ref_df = [pd.DataFrame(columns=['T_RES_BODY_1']), pd.DataFrame(columns=['T_RES_BODY_2']), pd.DataFrame(columns=['T_RES_BODY_3'])]
# DFB
source_timestamp_leads_odd_df = rb_query.find_timestamp_leads(timestamp_fgc, 'LEADS_ODD')
t0 = t_start if source_timestamp_leads_odd_df.empty else timestamp_fgc
u_hts_odd_dfs = rb_query.query_leads(t0, source_timestamp_leads_odd_df, system='LEADS_ODD', signal_names=['U_HTS'], spark=spark, duration=[(t_end-t_start, 'ns')])
u_res_odd_dfs = rb_query.query_leads(t0, source_timestamp_leads_odd_df, system='LEADS_ODD', signal_names=['U_RES'], spark=spark, duration=[(t_end-t_start, 'ns')])
source_timestamp_leads_even_df = rb_query.find_timestamp_leads(timestamp_fgc, 'LEADS_EVEN')
t0 = t_start if source_timestamp_leads_even_df.empty else timestamp_fgc
u_hts_even_dfs = rb_query.query_leads(t_start, source_timestamp_leads_even_df, system='LEADS_EVEN', signal_names=['U_HTS'], spark=spark, duration=[(t_end-t_start, 'ns')])
u_res_even_dfs = rb_query.query_leads(t_start, source_timestamp_leads_even_df, system='LEADS_EVEN', signal_names=['U_RES'], spark=spark, duration=[(t_end-t_start, 'ns')])
timestamp_dct = {'FGC': timestamp_fgc, 'PIC': min(timestamp_pic), 'EE_EVEN': timestamp_ee_even, 'EE_ODD': timestamp_ee_odd, 'LEADS_ODD': source_timestamp_leads_odd_df, 'LEADS_EVEN': source_timestamp_leads_even_df}
```
%% Cell type:markdown id: tags:
# 3. Timestamps
%% Cell type:code id: tags:
``` python
rb_analysis.create_timestamp_table(timestamp_dct)
```
%% Cell type:markdown id: tags:
# 4. Power Converter
## 4.1. Plot of the Power Converter Main Current
*GRAPHS*:
- t = 0 s corresponds to the start of the test
%% Cell type:code id: tags:
``` python
import matplotlib as mpl
mpl.rcParams['savefig.dpi'] = 80
mpl.rcParams['figure.dpi'] = 80
%matplotlib notebook
title = create_hwc_plot_title_with_circuit_name(circuit_name=circuit_name, hwc_test=hwc_test,
t_start=t_start, t_end=t_end, signal='I_MEAS')
rb_analysis.plot_i_meas(i_meas_nxcals_df, title=title)
```
%% Cell type:markdown id: tags:
## 4.2. Analysis of the Power Converter Main Current
This analysis module displays the main current of the power converter (I_MEAS) compared to the one obtained from the reference FPA (HWC PNO.b2 test with opening of EE systems and without magnet quench).
*ANALYSIS*:
- The evolution of the characteristic time $\tau$ of an exponential decay $f(t)$ is obtained as
\begin{equation}
-\frac{f(t)}{\partial_t f(t)} = -\frac{f_0 e^{-t/\tilde{\tau}}}{\partial_t (f_0 e^{-t/\tilde{\tau}})} = -\frac{f_0 e^{-t/\tilde{\tau}}}{-f_0/\tilde{\tau} e^{-t/\tilde{\tau}}}=-\frac{1}{-1/\tau}=\tau
\end{equation}
Naturally, this formula only applies to exponential decayed characterised by a time constant. Nonetheless, for pseudo-exponential decays, this formula gives a notion of the change of the characteristic time $\tilde{\tau}$. For a circuit we compute the time-varying characteristic time as
\begin{equation}
\tilde{\tau} = - \frac{\text{I_MEAS}}{\partial_t \text{I_MEAS}}
\end{equation}
*CRITERIA*
- Check if the characteristic time of pseudo-exponential decay of I_MEAS from t=1 to 120 s is 90 s< Tau <110 s
*PLOT*:
- The main power converter current (analyzed and reference) on the left axis, I_MEAS
- The characteristic time calculated for the main current (reference and actual) on the right axis, -I_MEAS/dI_MEAS_dt
The actual characteristic time contains steps, which indicate a quenching magnet (decrease of circuit inductance); note that for the reference one the steps are not present. Timing of PIC abort, FGC timestamp, and the maximum current are reported next to the graph.
- t = 0 s corresponds to the respective (analyzed and reference) FGC timestamps.
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_i_meas_pc(circuit_name, timestamp_fgc, timestamp_fgc_ref, min(timestamp_pic), i_meas_df, i_meas_ref_df)
```
%% Cell type:markdown id: tags:
## 4.3. Analysis of the Power Converter Main Current Smoothness
*ANALYSIS*:
- The current smoothness is evaluated on the basis of its second derivative. The derivative is calculated as a rolling division of current and time differences. The rolling window is fixed and equal to 10 points; with the sampling time equal to 0.1 s the time difference is equal to $dt=1 s$.
\begin{equation}
\frac{d i(t)}{dt} = \frac{i(t+dt)-i(t)}{dt}
\end{equation}
To obtain the second derivative of the current decay, the formula above is applied twice to the current profile from PM after the second EE opening (for t > 1 s).
*CRITERIA*
- Check if the second derivative of the current decay of I_MEAS from t = 1 s is -10 A/s^2< dI_MEAS/dt^2 < 10 A/s^2
*PLOT*:
- The second derivative of the main power converter current on the left axis, dI_MEAS/dt^2
- Green bar denotes the acceptance threshold for the second derivative of the main power converter current
- The main power converter current on the right axis, I_MEAS
%% Cell type:code id: tags:
``` python
title = create_hwc_plot_title_with_circuit_name(circuit_name=circuit_name, hwc_test=hwc_test, t_start=t_start, t_end=t_end, signal='I_MEAS smoothness')
rb_analysis.plot_i_meas_smoothness(i_meas_df, title=title)
```
%% Cell type:markdown id: tags:
## 4.4. Power Converter Voltage Analysis
*CRITERIA*
- Check if the V_MEAS voltage is within -1.5 +/- 0.5 V range 1 s after the EE timestamp
*GRAPHS*
- t = 0 s corresponds to the PM timestamp of the FGC
%% Cell type:code id: tags:
``` python
title = create_hwc_plot_title_with_circuit_name(circuit_name=circuit_name, hwc_test=hwc_test, t_start=t_start, t_end=t_end, signal='V_MEAS')
rb_analysis.assert_v_meas(timestamp_ee_even, min(timestamp_pic), t_after_ee=1, v_meas_df=v_meas_df, value_min=-2.0, value_max=-1.0, title=title, xmax=25)
```
%% Cell type:markdown id: tags:
## 4.5. Power Converter Earth Current
*CRITERIA*
- Check if the maximum absolute earth current is below 50 mA
*GRAPHS*:
- t = 0 s corresponds to the PM timestamp of the FGC
%% Cell type:code id: tags:
``` python
rb_analysis.plot_i_earth_pc(circuit_name, timestamp_fgc, i_earth_df)
rb_analysis.calculate_max_i_earth_pc(i_earth_df, col_name='Earth Current')
```
%% Cell type:markdown id: tags:
# 5. Energy Extraction System
## 5.1. Analysis of the Energy Extraction Voltage
*ANALYSIS*:
- Calculate U_dump_res (t=0)
- Calculate the characteristic time of pseudo-exponential current decay with the charge approach
*CRITERIA*:
- Check if U_DUMP_RES (t=0) = (±10%) U_DUMP_RES reference.
- Check if the timestamp difference between FGC and EE an odd point is 100±50 ms
The opening delay was 300±50 ms prior to YETS 2017/8
- Check if the time stamp difference between FGC and EE an even point: 600±50 ms
*WARNING*:
- Check if the characteristic time of pseudo-exponential decay of I_MEAS from t=1 to 120 s is 110 s<-Tau <130 s
*GRAPHS*:
- t = 0 s corresponds to the PM timestamp of the FGC
First plot (global view):
- the power converter converter current on the left axis, I_MEAS
- the two energy extraction voltages on the right, U_DUMP_RES, U_DUMP_RES
Second plot (triggering view):
- the power converter current on the left axis, I_MEAS
- the power converter reference current on the left axis, STATUS.I_REF (should stop at the moment of the FGC PM timestamp)
- the two energy extraction voltages on the right axis, U_DUMP_RES, U_DUMP_RES
- the green dashed line denotes the PIC timestamp
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_char_time_u_dump_res_ee(circuit_name, timestamp_fgc, [u_dump_res_odd_df, u_dump_res_even_df], i_meas_df)
```
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_delay_time_u_dump_res_ee(circuit_name, timestamp_fgc, min(timestamp_pic), [timestamp_ee_odd, timestamp_ee_even],
i_a_df, i_ref_df, [u_dump_res_odd_df, u_dump_res_even_df])
```
%% Cell type:code id: tags:
``` python
rb_analysis.compare_max_u_res_dump_to_reference(u_dump_res_odd_df, u_dump_res_odd_ref_df, 'U_DUMP_RES_ODD')
rb_analysis.compare_max_u_res_dump_to_reference(u_dump_res_even_df, u_dump_res_even_ref_df, 'U_DUMP_RES_EVEN')
```
%% Cell type:markdown id: tags:
## 5.2. Analysis of the Energy Extraction Temperature
*WARNING*
- Check if temperature profile is +/-25 K w.r.t. the reference temperature profile
*PLOT*:
- Temperature signals on the left axis, T
- A reference signal with an acceptable signal range is also provided on the left axis
- t = 0 s corresponds to PM timestamps of each temperature PM entry
%% Cell type:code id: tags:
``` python
rb_analysis.plot_ee_temp(circuit_name + '_EE_ODD', timestamp_ee_odd, t_res_odd_0_df + t_res_odd_1_df, t_res_odd_0_ref_df + t_res_odd_1_ref_df)
```
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_ee_temp(circuit_name + '_EE_ODD', timestamp_ee_odd, t_res_odd_0_df + t_res_odd_1_df, t_res_odd_0_ref_df + t_res_odd_1_ref_df, abs_margin=25, scaling=1)
```
%% Cell type:code id: tags:
``` python
rb_analysis.plot_ee_temp(circuit_name + '_EE_EVEN', timestamp_ee_even, t_res_even_0_df + t_res_even_1_df, t_res_even_0_ref_df + t_res_even_1_ref_df)
```
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_ee_temp(circuit_name + '_EE_EVEN', timestamp_ee_even, t_res_even_0_df + t_res_even_1_df, t_res_even_0_ref_df + t_res_even_1_ref_df, abs_margin=25, scaling=1)
```
%% Cell type:markdown id: tags:
# 6. Current Leads
## 6.1. Plot of Current Leads
*CRITERIA*:
- Check if the quench detection signal for U_HTS is below the threshold (3 mV)
- Check if the quench detection signal for U_RES is below the threshold (100 mV)
*GRAPHS*:
- t = 0 s corresponds to the FGC timestamp (if signal comes from PM, otherwise t = 0 s is the start of the test)
Global view (for odd and even leads)
- voltage of the HTS leads on the left axis, U_HTS
- voltage of the normal conducting leads on the left axis, U_RES
Zoom view (for odd and even leads)
- voltage of the HTS leads on the left axis, U_HTS
- blue horizontal dashed line denotes the FGC timestamp
- cyan horizontal dashed line denotes the EE odd timestamp
- green horizontal dashed line denotes the EE even timestamp
%% Cell type:code id: tags:
``` python
timestamp = lhcsmnb.utils.get_at(source_timestamp_leads_odd_df, 0, 'timestamp', default=t_start)
rb_analysis.analyze_leads_voltage(u_hts_odd_dfs, circuit_name, timestamp, signal='U_HTS', value_min=-0.001, value_max=0.001)
```
%% Cell type:code id: tags:
``` python
timestamp = lhcsmnb.utils.get_at(source_timestamp_leads_even_df, 0, 'timestamp', default=t_start)
rb_analysis.analyze_leads_voltage(u_hts_even_dfs, circuit_name, timestamp, signal='U_HTS', value_min=-0.001, value_max=0.001)
```
%% Cell type:code id: tags:
``` python
timestamp = lhcsmnb.utils.get_at(source_timestamp_leads_odd_df, 0, 'timestamp', default=t_start)
rb_analysis.analyze_leads_voltage(u_res_odd_dfs, circuit_name, timestamp, signal='U_RES', value_min=-0.1, value_max=0.1)
```
%% Cell type:code id: tags:
``` python
timestamp = lhcsmnb.utils.get_at(source_timestamp_leads_even_df, 0, 'timestamp', default=t_start)
rb_analysis.analyze_leads_voltage(u_res_even_dfs, circuit_name, timestamp, signal='U_RES', value_min=-0.1, value_max=0.1)
```
%% Cell type:markdown id: tags:ignore
# 7. Signature Decision
%% Cell type:code id: tags:ignore
``` python
signature = get_expert_decision('Expert Signature Decision: ', ['PASSED', 'FAILED'])
```
%% Cell type:markdown id: tags:ignore
# 8. Final Report
%% Cell type:code id: tags:ignore
``` python
analysis_start_time = Time.get_analysis_start_time()
apply_report_template()
file_name_html = '{}_{}-{}-{}_{}.html'.format(circuit_name, hwc_test, Time.to_datetime(t_start).strftime("%Y-%m-%d-%Hh%M"), analysis_start_time, signature)
full_path = '/eos/project/m/mp3/RB/{}/{}/{}'.format(circuit_name, hwc_test, file_name_html)
!mkdir -p /eos/project/m/mp3/RB/$circuit_name/$hwc_test
print('Compact notebook report saved to (Windows): ' + '\\\\cernbox-smb' + full_path.replace('/', '\\'))
display(Javascript('IPython.notebook.save_notebook();'))
Time.sleep(5)
!{sys.executable} -m jupyter nbconvert --to html $'AN_RB_PLI1.b2.ipynb' --output /eos/project/m/mp3/RB/$circuit_name/$hwc_test/$file_name_html --TemplateExporter.exclude_input=True --TagRemovePreprocessor.remove_all_outputs_tags='["skip_output"]'
```
%% Cell type:code id: tags:
``` python
```
......
%% Cell type:markdown id: tags:
<h1><center>Analysis of PLI2.f1 HWC Test in an RB Circuit</center></h1>
<img src="https://gitlab.cern.ch/LHCData/lhc-sm-hwc/raw/master/figures/rb/RB.png" width=75%>
source: Powering Procedure and Acceptance Criteria for the 13 kA Dipole Circuits, MP3 Procedure, <a href="https://edms.cern.ch/document/874713">https://edms.cern.ch/document/874713</a>
%% Cell type:markdown id: tags:
# Analysis Assumptions
- We consider standard analysis scenarios, i.e., all signals can be queried. If a signal is missing, an analysis can raise a warning and continue or an error and abort the analysis.
- It is recommended to execute each cell one after another. However, since the signals are queried prior to analysis, any order of execution is allowed. In case an analysis cell is aborted, the following ones may not be executed (e.g. I\_MEAS not present).
# Plot Convention
- Scales are labeled with signal name followed by a comma and a unit in square brackets, e.g., I_MEAS, [A].
- If a reference signal is present, it is represented with a dashed line.
- If the main current is present, its axis is on the left. Remaining signals are attached to the axis on the right. The legend of these signals is located on the lower left and upper right, respectively.
- The grid comes from the left axis.
- The title contains timestamp, circuit name, and signal name allowing to re-access the signal.
- The plots assigned to the left scale have colors: blue (C0) and orange (C1). Plots presented on the right have colors red (C2) and green (C3).
- Each plot has an individual time-synchronization mentioned explicitly in the description.
- If an axis has a single signal, then the color of the label matches the signal's color. Otherwise, the label color is black.
%% Cell type:markdown id: tags:
# 0. Initialise Working Environment
%% Cell type:code id: tags:
``` python
# External libraries
print('Loading (1/12)'); import sys, warnings
print('Loading (2/12)'); from IPython.display import display, Javascript, HTML, clear_output
print('Loading (3/12)'); import pandas as pd
# Internal libraries
print('Loading (4/12)'); import lhcsmapi
print('Loading (5/12)'); from lhcsmapi.Time import Time
print('Loading (6/12)'); from lhcsmapi.Timer import Timer
print('Loading (7/12)'); from lhcsmapi.analysis.RbCircuitQuery import RbCircuitQuery
print('Loading (8/12)'); from lhcsmapi.analysis.RbCircuitAnalysis import RbCircuitAnalysis
print('Loading (9/12)'); from lhcsmapi.analysis.report_template import apply_report_template
print('Loading (10/12)'); from lhcsmapi.analysis.expert_input import get_expert_decision
print('Loading (11/12)'); from lhcsmapi.gui.hwc.HwcSearchModuleMediator import HwcSearchModuleMediator
print('Loading (12/12)'); import lhcsmnb.utils
clear_output()
lhcsmapi.get_lhcsmapi_version()
lhcsmapi.get_lhcsmhwc_version('../__init__.py')
print('Analysis performed by %s' % HwcSearchModuleMediator.get_user())
```
%% Cell type:markdown id: tags:
# 1. User Input
1. Copy code from AccTesting and paste into an empty cell below
<img src="https://gitlab.cern.ch/LHCData/lhc-sm-hwc/-/raw/master/figures/swan-manual-acctesting-integration.png">
- If you only want to test the notebook only for the copy&paste feature (without opening the AccTesting), please copy and execute the code below
```
hwc_test = 'PLI2.f1'
circuit_name = 'RB.A12'
campaign = 'HWC_2014'
t_start = '2014-12-11 21:35:48.943'
t_end = '2014-12-11 21:59:44.442'
```
2. To analyze a historical test with a browser GUI, copy and execute the following code in the cell below
```
circuit_type = 'RB'
hwc_test = 'PLI2.f1'
hwcb = HwcSearchModuleMediator(circuit_type=circuit_type, hwc_test=hwc_test, hwc_summary_path='/eos/project/l/lhcsm/hwc/HWC_Summary.csv')
```
- After opening the browser GUI, choose a circuit name in order to display HWC test with, campaign name as well as start and end time
%% Cell type:code id: tags:parameters
``` python
```
%% Cell type:code id: tags:
``` python
print('hwc_test = \'%s\'\ncircuit_name = \'%s\'\ncampaign = \'%s\'\nt_start = \'%s\'\nt_end = \'%s\'' % (hwc_test, circuit_name, campaign, t_start, t_end))
```
%% Cell type:markdown id: tags:
# 2. Query All Signals Prior to Analysis
%% Cell type:code id: tags:skip_output
``` python
circuit_type = 'RB'
if 'hwcb' in locals():
circuit_name = hwcb.get_circuit_name()
t_start = Time.to_unix_timestamp(hwcb.get_start_time())
t_end = Time.to_unix_timestamp(hwcb.get_end_time())
t_start_ref = Time.to_unix_timestamp(hwcb.get_ref_start_time())
t_end_ref = Time.to_unix_timestamp(hwcb.get_ref_end_time())
is_automatic = hwcb.is_automatic_mode()
else:
t_start = Time.to_unix_timestamp(t_start)
t_end = Time.to_unix_timestamp(t_end)
t_start_ref, t_end_ref = HwcSearchModuleMediator.get_last_ref_start_end_time('/eos/project/l/lhcsm/hwc/HWC_Summary.csv', circuit_name, hwc_test, Time.to_string_short(t_start))
t_start_ref, t_end_ref = Time.to_unix_timestamp(t_start_ref), Time.to_unix_timestamp(t_end_ref)
if 'is_automatic' not in locals():
is_automatic = False
rb_query = RbCircuitQuery(circuit_type, circuit_name, max_executions=40)
with Timer():
source_timestamp_pc = rb_query.find_source_timestamp_pc(t_start, t_end)
timestamp_fgc = source_timestamp_pc.at[0, 'timestamp']
# PIC
timestamp_pic = rb_query.find_timestamp_pic(timestamp_fgc, spark=spark)
# PC Current
i_meas_df, i_a_df, i_earth_df, i_earth_pcnt_df, i_ref_df = rb_query.query_pc_pm(timestamp_fgc, timestamp_fgc, signal_names=['I_MEAS', 'I_A', 'I_EARTH', 'I_EARTH_PCNT', 'I_REF'])
source_timestamp_pc_ref_df = rb_query.find_source_timestamp_pc(t_start_ref, t_end_ref)
timestamp_fgc_ref = source_timestamp_pc_ref_df.at[0, 'timestamp']
i_meas_ref_df, i_earth_ref_df, i_earth_pcnt_ref_df = rb_query.query_pc_pm(timestamp_fgc_ref, timestamp_fgc_ref, signal_names=['I_MEAS', 'I_EARTH', 'I_EARTH_PCNT'])
# EE Voltage
source_timestamp_ee_odd_df = rb_query.find_source_timestamp_ee(timestamp_fgc, system='EE_ODD')
timestamp_ee_odd = lhcsmnb.utils.get_at(source_timestamp_ee_odd_df, 0, 'timestamp')
source_ee_odd = lhcsmnb.utils.get_at(source_timestamp_ee_odd_df, 0, 'source')
u_dump_res_odd_df = rb_query.query_ee_u_dump_res_pm(timestamp_ee_odd, timestamp_fgc, system='EE_ODD', signal_names=['U_DUMP_RES'])[0]
source_timestamp_ee_even_df = rb_query.find_source_timestamp_ee(timestamp_fgc, system='EE_EVEN')
timestamp_ee_even = lhcsmnb.utils.get_at(source_timestamp_ee_even_df, 0, 'timestamp')
source_ee_even = lhcsmnb.utils.get_at(source_timestamp_ee_even_df, 0, 'source')
u_dump_res_even_df = rb_query.query_ee_u_dump_res_pm(timestamp_ee_even, timestamp_fgc, system='EE_EVEN', signal_names=['U_DUMP_RES'])[0]
# EE TEMPERATURE
t_res_odd_0_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_odd_df, 0, 'timestamp'), timestamp_fgc, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_ODD')
if len(source_timestamp_ee_odd_df) > 1:
t_res_odd_1_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_odd_df, 1, 'timestamp'), timestamp_fgc, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_ODD')
else:
t_res_odd_1_df = [pd.DataFrame(columns=['T_RES_BODY_1']), pd.DataFrame(columns=['T_RES_BODY_2']), pd.DataFrame(columns=['T_RES_BODY_3'])]
t_res_even_0_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_even_df, 0, 'timestamp'), timestamp_fgc, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_EVEN')
if len(source_timestamp_ee_even_df) > 1:
t_res_even_1_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_even_df, 1, 'timestamp'), timestamp_fgc, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_EVEN')
else:
t_res_even_1_df = [pd.DataFrame(columns=['T_RES_BODY_1']), pd.DataFrame(columns=['T_RES_BODY_2']), pd.DataFrame(columns=['T_RES_BODY_3'])]
# EE TEMPERATURE REF
source_timestamp_ee_odd_ref_df = rb_query.find_source_timestamp_ee(timestamp_fgc_ref, system='EE_ODD')
source_timestamp_ee_even_ref_df = rb_query.find_source_timestamp_ee(timestamp_fgc_ref, system='EE_EVEN')
t_res_odd_0_ref_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(lhcsmnb.utils.get_at(source_timestamp_ee_odd_ref_df, 0, 'timestamp'), timestamp_fgc_ref, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_ODD')
t_res_odd_0_ref_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_odd_ref_df, 0, 'timestamp'), timestamp_fgc_ref, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_ODD')
if len(source_timestamp_ee_odd_ref_df) > 1:
t_res_odd_1_ref_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(lhcsmnb.utils.get_at(source_timestamp_ee_odd_ref_df, 1, 'timestamp'), timestamp_fgc_ref, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_ODD')
t_res_odd_1_ref_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_odd_ref_df, 1, 'timestamp'), timestamp_fgc_ref, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_ODD')
else:
t_res_odd_1_ref_df = [pd.DataFrame(columns=['T_RES_BODY_1']), pd.DataFrame(columns=['T_RES_BODY_2']), pd.DataFrame(columns=['T_RES_BODY_3'])]
t_res_even_0_ref_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_even_ref_df, 0, 'timestamp'), timestamp_fgc_ref, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_EVEN')
if len(source_timestamp_ee_even_ref_df) > 1:
t_res_even_1_ref_df = rb_query.query_ee_t_res_pm(lhcsmnb.utils.get_at(source_timestamp_ee_even_ref_df, 1, 'timestamp'), timestamp_fgc_ref, signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], system='EE_EVEN')
else:
t_res_even_1_ref_df = [pd.DataFrame(columns=['T_RES_BODY_1']), pd.DataFrame(columns=['T_RES_BODY_2']), pd.DataFrame(columns=['T_RES_BODY_3'])]
# U_DIODE - CALS
u_diode_rb_dfs = rb_query.query_voltage_nxcals('DIODE_RB', 'U_DIODE_RB', timestamp_fgc, spark=spark, duration=[(50, 's'), (350, 's')])
# iQPS, nQPS - PM
source_timestamp_qds_df = rb_query.find_source_timestamp_qds(timestamp_fgc)
source_timestamp_nqps_df = rb_query.find_source_timestamp_nqps(timestamp_fgc)
results_table = rb_query.create_report_analysis_template(source_timestamp_qds_df, source_timestamp_nqps_df, min(timestamp_pic), timestamp_fgc, '../__init__.py', i_meas_df, HwcSearchModuleMediator.get_user())
# QDS
u_qds_dfs = rb_query.query_voltage_logic_iqps(source_timestamp_qds_df, signal_names=['U_QS0', 'U_1', 'U_2', 'ST_NQD0', 'ST_MAGNET_OK'])
if not source_timestamp_nqps_df.empty:
u_nqps_dfs = rb_query.query_voltage_nqps(source_timestamp_nqps_df, source_timestamp_qds_df, timestamp_fgc, spark=spark)
else:
u_nqps_dfs = []
# QDS from second board (A/B)
source_timestamp_qds_df['timestamp'] = source_timestamp_qds_df['timestamp'] + 2000000
u_qds_dfs2 = rb_query.query_voltage_logic_iqps(source_timestamp_qds_df, signal_names=['U_QS0', 'U_1', 'U_2', 'ST_NQD0', 'ST_MAGNET_OK'])
source_timestamp_qds_df['timestamp'] = source_timestamp_qds_df['timestamp'] - 2000000
# QH
source_timestamp_qh_df = rb_query.find_source_timestamp_qh(timestamp_fgc, duration=[(10, 's'), (500, 's')])
i_hds_dfs = rb_query.query_qh_pm(source_timestamp_qh_df, signal_names='I_HDS')
u_hds_dfs = rb_query.query_qh_pm(source_timestamp_qh_df, signal_names='U_HDS')
# QH REF
i_hds_ref_dfs = rb_query.query_qh_pm(source_timestamp_qds_df, signal_names='I_HDS', is_ref=True)
u_hds_ref_dfs = rb_query.query_qh_pm(source_timestamp_qds_df, signal_names='U_HDS', is_ref=True)
# DIODE LEADS
i_a_u_diode_u_ref_pm_dfs = rb_query.query_current_voltage_diode_leads_pm(timestamp_fgc, source_timestamp_qds_df)
i_meas_u_diode_nxcals_dfs = rb_query.query_current_voltage_diode_leads_nxcals(source_timestamp_qds_df, spark=spark, duration=[(50, 's'), (350, 's')])
# U_EARTH
u_earth_rb_dfs = rb_query.query_voltage_nxcals('VF', 'U_EARTH_RB', timestamp_fgc, spark=spark, duration=[(50, 's'), (350, 's')])
# DFB
source_timestamp_leads_odd_df = rb_query.find_timestamp_leads(timestamp_fgc, 'LEADS_ODD')
u_hts_odd_dfs = rb_query.query_leads(timestamp_fgc, source_timestamp_leads_odd_df, system='LEADS_ODD', signal_names=['U_HTS'], spark=spark)
u_res_odd_dfs = rb_query.query_leads(timestamp_fgc, source_timestamp_leads_odd_df, system='LEADS_ODD', signal_names=['U_RES'], spark=spark)
source_timestamp_leads_even_df = rb_query.find_timestamp_leads(timestamp_fgc, 'LEADS_EVEN')
u_hts_even_dfs = rb_query.query_leads(timestamp_fgc, source_timestamp_leads_even_df, system='LEADS_EVEN', signal_names=['U_HTS'], spark=spark)
u_res_even_dfs = rb_query.query_leads(timestamp_fgc, source_timestamp_leads_even_df, system='LEADS_EVEN', signal_names=['U_RES'], spark=spark)
# EE after 3 hours
unix_time_now = Time.to_unix_timestamp(Time.now())
time_diff = (unix_time_now - timestamp_fgc)*1e-9
if time_diff > 3 * 3600:
t_res_body_long_dfs = rb_query.query_ee_nxcals(timestamp_fgc, system='EE_ODD', signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], spark=spark) \
+ rb_query.query_ee_nxcals(timestamp_fgc, system='EE_EVEN', signal_names=['T_RES_BODY_1', 'T_RES_BODY_2', 'T_RES_BODY_3'], spark=spark)
st_res_overtemp_long_dfs = rb_query.query_ee_nxcals(timestamp_fgc, system='EE_ODD', signal_names='ST_RES_OVERTEMP', spark=spark, t_thr=0) \
+ rb_query.query_ee_nxcals(timestamp_fgc, system='EE_EVEN', signal_names='ST_RES_OVERTEMP', spark=spark, t_thr=0)
else:
t_res_body_long_dfs = []
st_res_overtemp_long_dfs = []
print('Wait {} seconds to query EE temperature and status signals'.format(time_diff))
rb_analysis = RbCircuitAnalysis(circuit_type, results_table, is_automatic=is_automatic)
```
%% Cell type:markdown id: tags:
# 3. Timestamps
## 3.1. FPA
Table below provides timestamps ordered achronologically and represents the sequence of events that occurred in the analyzed circuit. Only the first PIC timestamp is reported. Note that for iQPS and nQPS only the first timestamp is reported. Tables with all iQPS and NQPS timestamps are presented in the section dedicated to magnet and quench protection analysis. The table also contains time difference in milliseconds from the first event and from the FGC event.
In short, the following criteria should be kept:
- The PC timestamp (51_self) is QPS time stamp +/-20 ms.
- Time stamp difference between FGC and EE at an odd (RR or UJ) point: 290±50 ms
After YETS 2017/8 the EE timestamp odd has been reduced and should now be 100+-50 ms after the FGC time stamp
- Time stamp difference between FGC and EE at an even (UA) point: 600±50 ms
%% Cell type:code id: tags:
``` python
timestamp_dct = {'FGC': timestamp_fgc, 'PIC': min(timestamp_pic), 'EE_EVEN': timestamp_ee_even, 'EE_ODD': timestamp_ee_odd,
'iQPS': source_timestamp_qds_df, 'nQPS': source_timestamp_nqps_df,
'LEADS_ODD': source_timestamp_leads_odd_df, 'LEADS_EVEN': source_timestamp_leads_even_df}
rb_analysis.create_timestamp_table(timestamp_dct)
```
%% Cell type:markdown id: tags:
## 3.2. Reference
Table below contains reference timestamps of signals used for comparison to the analyzed FPA. The reference comes as the last PNO.b2 HWC test with activation of EE systems and no magnets quenching.
%% Cell type:code id: tags:
``` python
timestamp_ref_dct = {'FGC': timestamp_fgc_ref,
'EE_ODD_first': lhcsmnb.utils.get_at(source_timestamp_ee_odd_ref_df, 0, 'timestamp'), 'EE_ODD_second': lhcsmnb.utils.get_at(source_timestamp_ee_odd_ref_df, 1, 'timestamp', default = float('nan')),
'EE_EVEN_first': lhcsmnb.utils.get_at(source_timestamp_ee_even_ref_df, 0, 'timestamp'), 'EE_EVEN_second': lhcsmnb.utils.get_at(source_timestamp_ee_even_ref_df, 1, 'timestamp', default = float('nan') }
'EE_EVEN_first': lhcsmnb.utils.get_at(source_timestamp_ee_even_ref_df, 0, 'timestamp'), 'EE_EVEN_second': lhcsmnb.utils.get_at(source_timestamp_ee_even_ref_df, 1, 'timestamp', default = float('nan')) }
rb_analysis.create_ref_timestamp_table(timestamp_ref_dct)
```
%% Cell type:markdown id: tags:
# 4. Schematic
The interactive schematic represents the analyzed circuit and contains:
- All magnets (the quenched ones are in red and the order of quenching is displayed)
- All nQPS crates in blue (the ones with the quenched magnets in red)
- Power converter with FGC timestamp
- Energy extraction systems (even and odd) with corresponding timestamps
- Current leads with PM timestamps (if applicable)
**Note that the drawing may take about 5 minutes**. The most of the time is spent on initializing the plotting library.
%% Cell type:code id: tags:
``` python
if len(results_table) > 1:
print('Loading RbCircuitSchematic...');
from lhcsmapi.analysis.RbCircuitSchematic import show_schematic
show_schematic(circuit_type, circuit_name, results_table, source_timestamp_nqps_df, source_timestamp_leads_odd_df, source_timestamp_leads_even_df,
timestamp_fgc, source_ee_odd, timestamp_ee_odd, source_ee_even, timestamp_ee_even, show_magnet_name=False)
```
%% Cell type:markdown id: tags:
# 5. PIC
## 5.1. Analysis of the PIC Timestamp
*ANALYSIS*:
- Show warning if the two PIC timestamps differ by more than a 1 ms.
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_pic(timestamp_pic)
```
%% Cell type:markdown id: tags:
# 6. Power Converter
## 6.1. Analysis of the Power Converter Main Current
This analysis module displays the main current of the power converter (I_MEAS) compared to the one obtained from the reference FPA (HWC PNO.b2 test with opening of EE systems and without magnet quench).
*ANALYSIS*:
- The evolution of the characteristic time $\tau$ of an exponential decay $f(t)$ is obtained as
\begin{equation}
-\frac{f(t)}{\partial_t f(t)} = -\frac{f_0 e^{-t/\tilde{\tau}}}{\partial_t (f_0 e^{-t/\tilde{\tau}})} = -\frac{f_0 e^{-t/\tilde{\tau}}}{-f_0/\tilde{\tau} e^{-t/\tilde{\tau}}}=-\frac{1}{-1/\tau}=\tau
\end{equation}
Naturally, this formula only applies to exponential decayed characterised by a time constant. Nonetheless, for pseudo-exponential decays, this formula gives a notion of the change of the characteristic time $\tilde{\tau}$. For a circuit we compute the time-varying characteristic time as
\begin{equation}
\tilde{\tau} = \frac{\partial \text{I_MEAS}}{\partial_t}
\end{equation}
*CRITERIA*
- Characteristic time of pseudo-exponential decay of I_MEAS from t=1 to 120 s: 90 s< Tau <110 s
*PLOT*:
- The main power converter current (analyzed and reference) on the left axis, I_MEAS
- The characteristic time calculated for the main current (reference and actual) on the right axis, -I_MEAS/dI_MEAS_dt
The actual characteristic time contains steps, which indicate a quenching magnet (decrease of circuit inductance); note that for the reference one the steps are not present. Timing of PIC abort, FGC timestamp, and the maximum current are reported next to the graph.
- t = 0 s corresponds to the respective (analyzed and reference) FGC timestamps.
%% Cell type:code id: tags:
``` python
%matplotlib notebook
rb_analysis.analyze_i_meas_pc(circuit_name, timestamp_fgc, timestamp_fgc_ref, min(timestamp_pic), i_meas_df, i_meas_ref_df)
rb_analysis.calculate_current_miits_i_meas_i_a(i_meas_df, i_a_df, t_quench=0, col_name='MIITS_circ')
rb_analysis.calculate_quench_current(i_meas_df, t_quench=0, col_name='I_Q_circ')
rb_analysis.calculate_current_slope(i_meas_df, col_name=['Ramp rate', 'Plateau duration'])
```
%% Cell type:markdown id: tags:
## 6.2. Analysis of the Power Converter Earth Current
*CRITERIA*:
- Checks whether for t > 3 s, I_EARTH_PCNT is within +/-3 % w.r.t. the reference
*PLOT*:
t = 0 s corresponds to respective (actual and reference) FGC PM timestamps
First plot (absolute scale)
- The main power converter current on the left axis, I_A
- Actual and reference earth current on the right axis, IEARTH
Second plot (percentage scale)
- The main power converter current on the left axis, I_MEAS
- Actual and reference earth current on the right axis, I_EARTH_PCNT; I_EARTH_PCNT scaled according to the peak value of the main reference current
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_i_earth_pc(circuit_name, timestamp_fgc, i_a_df, i_earth_df, i_earth_ref_df, xlim=(-1, 5))
rb_analysis.calculate_max_i_earth_pc(i_earth_df, col_name='I_Earth_max')
```
%% Cell type:code id: tags:
``` python
%matplotlib notebook
rb_analysis.analyze_i_earth_pcnt_pc(circuit_type, circuit_name, timestamp_fgc, i_meas_df, i_meas_ref_df, i_earth_pcnt_df, i_earth_pcnt_ref_df, xlim=(-50, 350))
```
%% Cell type:markdown id: tags:
# 7. Energy Extraction System
## 7.1. Analysis of the Energy Extraction Voltage
*ANALYSIS*:
- Calculate U_dump_res (t=0)
- Calculate the characteristic time of pseudo-exponential current decay with the charge approach
*CRITERIA*:
- Check if U_dump_res (t=0) = 0.075*I V (±10%).
- Check if the characteristic time of pseudo-exponential decay of I_MEAS from t=1 to 120 s is 110 s<-Tau <130 s
- Check if the timestamp difference between FGC and EE an odd point is 100±50 ms
The opening delay was 290±50 ms prior to YETS 2017/8
- Check if the time stamp difference between FGC and EE an even point: 600±50 ms
*GRAPHS*:
t = 0 s corresponds to the PM timestamp of the FGC
First plot (global view):
- the power converter converter current on the left axis, I_MEAS
- the two energy extraction voltages on the right, U_DUMP_RES, U_DUMP_RES
Second plot (triggering view):
- the power converter current on the left axis, I_MEAS
- the power converter reference current on the left axis, STATUS.I_REF (should stop at the moment of the FGC PM timestamp)
- the two energy extraction voltages on the right axis, U_DUMP_RES, U_DUMP_RES
- the green dashed line denotes the PIC timestamp
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_char_time_u_dump_res_ee(circuit_name, timestamp_fgc, [u_dump_res_odd_df, u_dump_res_even_df], i_meas_df)
rb_analysis.results_table['U_EE_max_ODD'] = u_dump_res_odd_df.max()[0]
rb_analysis.results_table['U_EE_max_EVEN'] = u_dump_res_even_df.max()[0]
```
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_delay_time_u_dump_res_ee(circuit_name, timestamp_fgc, min(timestamp_pic), [timestamp_ee_odd, timestamp_ee_even],
i_a_df, i_ref_df, [u_dump_res_odd_df, u_dump_res_even_df])
```
%% Cell type:markdown id: tags:
## 7.2. Analysis of the Energy Extraction Temperature
*CRITERIA*
- Checks whether temperature profile is +/-25 K w.r.t. the reference temperature profile
- Checks whether maximum temperatures are within [100, 200] K range
*PLOT*:
- Temperature signals on the left axis, T
- A reference signal with an acceptable signal range is also provided on the left axis
- t = 0 s corresponds to PM timestamps of each temperature PM entry
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_ee_temp(circuit_name + '_EE_ODD', timestamp_ee_odd, t_res_odd_0_df + t_res_odd_1_df, t_res_odd_0_ref_df + t_res_odd_1_ref_df, abs_margin=25, scaling=1)
```
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_ee_temp(circuit_name + '_EE_EVEN', timestamp_ee_even, t_res_even_0_df + t_res_even_1_df, t_res_even_0_ref_df + t_res_even_1_ref_df, abs_margin=25, scaling=1)
```
%% Cell type:markdown id: tags:
# 8. Quench Protection System
<img src="https://gitlab.cern.ch/LHCData/lhc-sm-hwc/raw/master/figures/rb/RB_QPS_Signals.png" width=75%>
The table below shows the sign of the resistive voltages and inductive voltages (for positive ramp rate) of U1 and U2. U_QS0=-U1-U2.
|Circuit |Resistive voltage U1 |Resistive voltage U2 |Inductive voltage U1 |Inductive voltage U2|
|-----------|-----------------------|-----------------------|-----------------------|--------------------|
|RB.A12 |Pos |Neg |Pos |Neg|
|RB.A23 |Neg |Pos |Neg |Pos|
|RB.A34 |Neg |Pos |Neg |Pos|
|RB.A45 |Neg |Pos |Neg |Pos|
|RB.A56 |Pos |Neg |Pos |Neg|
|RB.A67 |Pos |Neg |Pos |Neg|
|RB.A78 |Pos |Neg |Pos |Neg|
|RB.A81 |Neg |Pos |Neg |Pos|
The thresholds and evaluation times for the QPS on the RB circuits are given in the following table:
|Class |System |Threshold |Evaluation time |Signal |Comment|
|-------|-------|-----------|-------------------|-------|:------|
|DQAMCNMB_PMSTD |iQPS, DQQDL |100 mV |10 ms discrimination |U_QS0 |Old QPS. Detection of quench in one aperture based upon voltage difference between both apertures in same magnet U_QS0 >10 ms above threshold, otherwise discriminator is reset|
|DQAMCNMB_PMHSU |iQPS, nQPS |-|-|-|Firing of quench heaters by quench protection. Generation of PM buffers sometimes happens even if there is no heater firing.|
|DQAMGNSRB (slow sampling rate), DQAMGNSRB_PMREL (fast sampling rate) |nQPS, DQQDS |500 mV * |>20 ms moving average +1 ms discrimination |U_DIODE |New QPS. Detection of quench in both apertures based upon comparing voltage across the magnet (bypass diode) from 3 magnets in same half-cell and one reference from adjacent half-cell. 50Hz notch moving average filter (20ms worst case). The signals in the 2 classes are identical, only the sampling rate differs. The data with the slow sampling rate is no longer generated as they can be found in the logging database. The recording of data is usually triggered during a FPA, depending on current in circuit, and always when a symmetric quench occurs. The PM buffers are only sent if the DQAMGNS crate trips (what ever the reason).|
|DQAMGNSRB |nQPS, DQQBS| 4 mV | >10 s moving average | U_RES |New QPS. Busbar protection. The signal is not compensated for inductive voltage during ramp.|
|DQAMGNDRB_EVEN, DQAMGNDRB_ODD |iQPS, DQQDC |1 mV, 100 mV |1 s |U_HTS, U_RES |Old QPS. Leads protection. U_HTS is for the high temperature superconducting leads, and U_RES is for the room temperature leads.|
|DQAMGNDRB_EVEN, DQAMGNDRB_ODD |iQPS, DQQDB |+200 V | -50 V | U_BB1, U_BB2 |Old QPS. U_BB1 is the total voltage across the sector. U_BB2 is the voltage across the energy extraction (EE)|
|DQAMSNRB |-|-|-|-|Opening of energy extraction (EE) switches during fast power abort (FPA). 2 EE switches per sector. One for "even" points (EE2). One for "odd" points (EE1).|
*: It was 800 mV before LS1. After LS1 we changed it to 300 or 400 mV. During the training after LS1 we increased it to 500 mV.
%% Cell type:markdown id: tags:
## 8.1. Plot of Voltage Across All Magnets (U_DIODE_RB)
*PLOT*:
t = 0 s corresponds to the PM timestamp of the FGC
First plot (global)
- the power converter current on the left axis, I_MEAS
- diode voltage on the right axis, U_DIODE_RB
Second plot (zoom)
- the power converter current on the left axis, I_MEAS
- diode voltage on the right axis, U_DIODE_RB
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_u_diode_nqps(circuit_name, timestamp_fgc, i_meas_df, u_diode_rb_dfs, 'U_DIODE_RB', 'DIODE_RB', xlim=(-5, 350))
```
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_u_diode_nqps(circuit_name, timestamp_fgc, i_meas_df, u_diode_rb_dfs, 'U_DIODE_RB', 'DIODE_RB', xlim=(-2, 3))
```
%% Cell type:code id: tags:
``` python
u_diode_with_quench_rb_dfs = rb_analysis.filter_quenched_magnets(u_diode_rb_dfs, results_table['Position'])
rb_analysis.analyze_u_diode_nqps(circuit_name, timestamp_fgc, i_meas_df, u_diode_with_quench_rb_dfs, 'U_DIODE_RB', 'DIODE_RB', legend=True, xlim=(-5, 350))
rb_analysis.analyze_u_diode_nqps(circuit_name, timestamp_fgc, i_meas_df, u_diode_with_quench_rb_dfs, 'U_DIODE_RB', 'DIODE_RB', legend=True, xlim=(-2, 3))
```
%% Cell type:markdown id: tags:
## 8.2. Analysis of Quenched Magnets by QDS - PM
*ANALYSIS*:
- calculates the current at which a quench occured by finding the timestamp of the current dataframe (i_meas_df) closest to the quench time and the curresponding value of current - I_MEAS_quench
- determines the type of the QPS board that generated the PM entry (a board could fail to write to PM) - i_qps_board_type
- compute the time difference (in seconds) from the first quench - dt_quench
%% Cell type:code id: tags:
``` python
rb_analysis.results_table[['Circuit Name', 'Position', 'nQPS crate name', 'Delta_t(iQPS-PIC)','I_Q_circ', 'Delta_t(nQPS-PIC)']]
```
%% Cell type:markdown id: tags:
## 8.3. Analysis of Quench Detection Voltage and Logic Signals for Quenched Magnets
%% Cell type:markdown id: tags:
*ANALYSIS*:
- finds the first timestamp, t_st_magnet_ok, for which the ST_MAGNET_OK signal is False indicating that the quench detection signal U_QS0 is outside of the +/- 100 mV threshold.
- for t > t_st_magnet_ok, finds the first timestamp, t_st_nqd0 for which the ST_NQD0 signal is Fals indicating that the U_QS0 signal is outside of the +/- 100 mV threshold for more than the 10 ms discrimination time. This signifies quench detection and results in triggering quench heaters.
- finds U_QS0 value at the moment of quench detection, u_ST_NQD0 = U_QS0(t=t_st_nqd0)
- if the minimum value of the absolute value of U_QS0 is above greater than 100 ms, then find the start time of a quench, t_start_quench, as a moment at which U_QS0 value is 10 mV greater than its initial value. Otherwise, the start time of a quench is set to 0 s.
- finds U_QS0 value, u_start_quench, at the moment of quench start as u_start_quench = U_QS0(t=t_start_quench)
- the slope of the quench detection signals is calculated as du_dt = (u_ST_NQD0 - u_start_quench) / (t_st_nqd0 - t_start_quench)
- the quench detection signal polarity is taken as the sign of its slope
- the delay of the quench heaters triggering, t_delay_qh_trigger, is assumed to be the negative value of t_st_magnet_ok, t_delay_qh_trigger = -t_st_magnet_ok
Determine source of QH trigger for nQPS signals in PM:
- calculates nQPS differences for the symmetric quench detection
- selects only the differences that involve the quenched magnet and exclude already quenched magnets in the cell
- for t in [-0.2 s, t_st_magnet_ok] take the maximum value of voltage difference
- if the maximum is above 1V (considering sun glasses active from t = 0 s) and the time of maximum is less than t_st_magnet_ok, than the QH system was triggered by nQPS, otherwise iQPS
- it is assumed that the first training quench was detected by iQPS
*PLOT*:
t = 0 s corresponds to the PM timestamp of the QDS
Upper left (iQPS analog signals)
- the quench detection voltage on the left axis, U_QS0
- voltage across the first and the second aperture on the right axis, respectively, U_1 and U_2
- the green box denotes an envelope of the +/- 100 mV quench detection threshold
- the orange box denotes an envelope of the rise of the quench signal from its start until reaching the threshold
Lower left (iQPS digital signals)
- the quench detection voltage on the left axis, U_QS0
- digital quench detection signals, ST_MAGNET_OK, ST_NQD0
- the green box denotes an envelope of the +/- 100 mV quench detection threshold
- the orange box denotes an envelope of the rise of the quench signal from its start until reaching the threshold
Upper right (nQPS analog signals)
For PM signals (global view)
- the diode voltages used by the nQPS crate for quench detection on the left axis, U_DIODE_RB and U_REF_N1
For NXCALS signals (global view)
- the diode voltages used by the nQPS crate for quench detection on the left axis, U_DIODE_RB and U_REF_N1
Lower right (nQPS analog signals)
For PM signals (difference view)
- the differences of diode voltages (containing the quenched magnet; in case the signals are missing, the plot is not displayed) used by the nQPS crate for quench detection on the left axis, U (Calculated diode differences)
- the green box denotes an envelope of 1 V quench detection threshold (assuming active 'sun glasses') before the iQPS quench detection. If the nQPS difference goes outside of the envelope, it means that the quench was detected by nQPS.
For NXCALS signals (zoomed view)
- the diode voltages used by the nQPS crate for quench detection on the left axis, U_DIODE_RB and U_REF_N1
%% Cell type:code id: tags:
``` python
# iQPS Threshold
threshold_iqps = 0.1
```
%% Cell type:code id: tags:
``` python
%matplotlib inline
if u_nqps_dfs:
rb_analysis.analyze_qds(timestamp_fgc, min(timestamp_pic), u_qds_dfs, u_qds_dfs2, u_nqps_dfs, i_meas_df, threshold=threshold_iqps)
rb_analysis.results_table[['Circuit Name', 'Position', 'nQPS crate name', 'Delta_t(iQPS-PIC)','I_Q_circ', 'I_Q_M', 'Delta_t(nQPS-PIC)', 'QDS trigger origin', 'dU_iQPS/dt', 'Type of Quench']]
```
%% Cell type:markdown id: tags:
## 8.4. Analysis of Quench Heater Discharges
*CRITERIA*:
- all characteristic times of an exponential decay calculated with the 'charge' approach for voltage and current are +/- 3 ms from the reference ones
- all initial resistances are +/- 0.5 Ohm from the reference ones
- all initial voltages are between 780 and 980 V
- all final voltages are between 15 and 70 V
*PLOT*:
t = 0 s corresponds to the start of the pseudo-exponential decay.
Line for actual signal is continuous and dashed for the reference.
Left plot (Voltage view)
- the querried and filtered quench heater voltage on the left axis, U_HDS
Middle plot (Current view)
- the querried and filtered quench heater current on the left axis, I_HDS
Right plot (Resistance view)
- the calculated quench heater resistance on the left axis, R_HDS
%% Cell type:code id: tags:
``` python
if u_hds_dfs:
rb_analysis.analyze_multi_qh_voltage_current_with_ref(source_timestamp_qh_df, u_hds_dfs, i_hds_dfs, u_hds_ref_dfs, i_hds_ref_dfs, current_offset=0.085)
rb_analysis.results_table[['Circuit Name', 'Position', 'Delta_t(iQPS-PIC)','I_Q_circ', 'Delta_t(nQPS-PIC)', 'QDS trigger origin', 'QH analysis']]
else:
print(f"No quench heater discharges!")
```
%% Cell type:markdown id: tags:
## 8.5. Analysis of Diode Lead Resistance
*ANALYSIS*:
- calculates diode lead resistance from voltage (board A and B) and current
*CRITERIA*
- if the maximum resistance is above 50 uOhm, then raise a warning
- if the maximum resistance is above 150 uOhm, then raise an alarm
*PLOT*:
Upper PM (Input view)
- the main power converter current on the left axis, IAB.I_A
- quenched magnet voltage from two boards, U_DIODE_A, U_DIODE_B. The difference between both signals is the diode lead voltage.
- reference nQPS board voltage on the right axis, U_REF
- diplayed on the left only if a quench occured no later than 2 seconds after the FGC PM timestamp
- t = 0 s corresponds to the PM timestamp of the QPS
Lower PM (Output view)
- the main power converter current on the left axis, IAB.I_A
- the calculated diode lead resistance on the right axis, R_DIODE_LEADS
- diplayed on the left only if a quench occured no later than 2 seconds after the FGC PM timestamp
- t = 0 s corresponds to the PM timestamp of the QPS
Upper CALS (Input view)
- the main power converter current on the left axis, I_MEAS
- quenched magnet voltage from two boards is saved as a single signal, U_DIODE_RB. The two signals are stored by means of value toggling between board A and board B. The difference between both sub-signals is the diode lead voltage.
- t = 0 s corresponds to the PM timestamp of the FGC
Lower CALS (Output view)
- the main power converter current on the left axis, I_MEAS
- the calculated diode lead resistance on the right axis, R_DIODE_LEADS
- t = 0 s corresponds to the PM timestamp of the FGC
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_diode_leads(source_timestamp_qds_df, timestamp_fgc, results_table['I_Q_M'], circuit_name, i_a_u_diode_u_ref_pm_dfs, i_meas_u_diode_nxcals_dfs)
rb_analysis.results_table[['Circuit Name', 'Date (FGC)', 'Time (FGC)', 'R_DL_max', 'I at R_DL_max']]
```
%% Cell type:markdown id: tags:
## 8.6. Plot of Voltage Feelers
*ANALYSIS*:
- if the voltage of a voltage feeler is equal to 0 V, then it means that the corresponding card is disabled
- if the voltage of a voltage feeler is equal to -2000 V, then it means that the corresponding card is not communicating
*PLOT*:
t = 0 s corresponds to the PM timestamp of the FGC
First plot (global)
- the power converter current on the left axis, I_MEAS
- earth voltage on the right axis, U_EARTH_RB
Second plot (zoom)
- the power converter current on the left axis, I_MEAS
- earth voltage on the right axis, U_EARTH_RB
%% Cell type:code id: tags:
``` python
rb_analysis.analyze_voltage_feelers(circuit_name, timestamp_fgc, i_meas_df, u_earth_rb_dfs, 'U_EARTH_RB', 'VF')
```
%% Cell type:code id: tags:
``` python
if not is_automatic:
rb_analysis.results_table['V feeler analysis'] = get_expert_decision('Voltage feeler analysis: ', ['PASS', 'FAIL'])
```
%% Cell type:markdown id: tags:
## 8.7. Plot of Current Leads
*CRITERIA*:
- Check if the quench detection signal for U_HTS is below the threshold (3 mV)
- Check if the quench detection signal for U_RES is below the threshold (100 mV)
*PLOT*: