From e1da0586979056e90b163beb12e7d02b0b715f46 Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Tue, 7 Mar 2023 21:19:25 -0800 Subject: [PATCH 01/26] Added profiles from CAKE - Ripped out other references to profiles needs to be reviewed carefully --- omas/machine_mappings/d3d.json | 49 +++++++++++++++++++--------------- omas/machine_mappings/d3d.py | 29 ++++++++++++++++++++ 2 files changed, 57 insertions(+), 21 deletions(-) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index 7199e87e9..f080130ab 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -113,32 +113,39 @@ "coils_non_axisymmetric.coil.:.name": { "PYTHON": "coils_non_axisymmetric_hardware(ods, {pulse})" }, - "core_profiles.global_quantities.v_loop": { - "COCOSIO": 11, - "PYTHON": "core_profiles_global_quantities_data(ods, {pulse})" - }, "core_profiles.profiles_1d.:": { - "TDI": "size(\\{PROFILES_tree}::TOP.PROFILES.EDENSFIT,1)", - "treename": "{PROFILES_tree}" + "PYTHON": "core_profiles_profile_1d(ods, {pulse})" }, - "core_profiles.profiles_1d.:.electrons.density_thermal": { - "TDI": "\\{PROFILES_tree}::TOP.PROFILES.EDENSFIT", - "treename": "{PROFILES_tree}" + "core_profiles.profiles_1d.:.electrons.density": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse})" }, "core_profiles.profiles_1d.:.electrons.temperature": { - "TDI": "\\{PROFILES_tree}::TOP.PROFILES.ETEMPFIT", - "treename": "{PROFILES_tree}" + "PYTHON": "core_profiles_profile_1d(ods, {pulse})" + }, + "core_profiles.profiles_1d.:.grid.rho_pol_norm": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse})" }, "core_profiles.profiles_1d.:.grid.rho_tor_norm": { - "eval2TDI": "py2tdi(tile,'dim_of(\\{PROFILES_tree}::TOP.PROFILES.EDENSFIT,0)','size(\\{PROFILES_tree}::TOP.PROFILES.EDENSFIT,1)')", - "treename": "{PROFILES_tree}" + "PYTHON": "core_profiles_profile_1d(ods, {pulse})" + }, + "core_profiles.profiles_1d.:.ion.:": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse})" + }, + "core_profiles.profiles_1d.:.ion.:.density": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse})" + }, + "core_profiles.profiles_1d.:.ion.:.temperature": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse})" + }, + "core_profiles.profiles_1d.:.ion.:.velocity.toroidal": { + "COCOSIO": 11, + "PYTHON": "core_profiles_profile_1d(ods, {pulse})" }, "core_profiles.profiles_1d.:.time": { - "TDI": "dim_of(\\{PROFILES_tree}::TOP.PROFILES.EDENSFIT,1)/1000.", - "treename": "{PROFILES_tree}" + "PYTHON": "core_profiles_profile_1d(ods, {pulse})" }, "core_profiles.time": { - "PYTHON": "core_profiles_global_quantities_data(ods, {pulse})" + "PYTHON": "core_profiles_profile_1d(ods, {pulse})" }, "ec_launchers.beam.:": { "PYTHON": "ec_launcher_active_hardware(ods, {pulse})" @@ -333,7 +340,7 @@ "PYTHON": "langmuir_probes_data(ods, {pulse})" }, "langmuir_probes.embedded.:.identifier": { - "PYTHON": "langmuir_probes_data(ods, {pulse})" + "PYTHON": "langmuir_probes_hardware(ods, {pulse})" }, "langmuir_probes.embedded.:.ion_saturation_current.data": { "PYTHON": "langmuir_probes_data(ods, {pulse})" @@ -342,17 +349,17 @@ "PYTHON": "langmuir_probes_data(ods, {pulse})" }, "langmuir_probes.embedded.:.name": { - "PYTHON": "langmuir_probes_data(ods, {pulse})" + "PYTHON": "langmuir_probes_hardware(ods, {pulse})" }, "langmuir_probes.embedded.:.position.phi": { "COCOSIO": 11, - "PYTHON": "langmuir_probes_data(ods, {pulse})" + "PYTHON": "langmuir_probes_hardware(ods, {pulse})" }, "langmuir_probes.embedded.:.position.r": { - "PYTHON": "langmuir_probes_data(ods, {pulse})" + "PYTHON": "langmuir_probes_hardware(ods, {pulse})" }, "langmuir_probes.embedded.:.position.z": { - "PYTHON": "langmuir_probes_data(ods, {pulse})" + "PYTHON": "langmuir_probes_hardware(ods, {pulse})" }, "langmuir_probes.embedded.:.surface_area_effective.data": { "PYTHON": "langmuir_probes_data(ods, {pulse})" diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index ebe38dd10..31c8463ec 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1341,6 +1341,35 @@ def ip_bt_dflux_data(ods, pulse): ods['tf.b_field_tor_vacuum_r.data'] *= 1.6955 +@machine_mapping_function(__regression_arguments__, pulse=194455001) +def core_profiles_profile_1d(ods, pulse): + omfit_profiles_node = '\\TOP.' + query = { + "grid.rho_tor_norm": "rho", + "electrons.density": "n_e", + "electrons.temperature": "T_e", + "ion[0].density": "n_D", + "ion[0].temperature": "T_i", + "ion[0].velocity.toroidal": "V_tor_C", + "ion[0].density": "n_C" + } + for entry in query: + query[entry] = omfit_profiles_node + query[entry] + data = mdsvalue('d3d', treename='OMFIT_PROFS', pulse=pulse, TDI=query).raw() + dim_info = mdsvalue('d3d', treename='OMFIT_PROFS', pulse=pulse, TDI="\\TOP.n_e") + data['time'] = dim_info.dim_of(1) * 1.e-3 + psi_n = dim_info.dim_of(0) + data['grid.rho_pol_norm'] = np.zeros((data['time'].shape + psi_n.shape)) + data['grid.rho_pol_norm'][:] = np.sqrt(psi_n) + data["ion[1].temperature"] = data["ion[0].temperature"] + data["ion[1].velocity.toroidal"] = data["ion[0].velocity.toroidal"] + ods[f"core_profiles.time"] = data['time'] + for entry in data: + for i_time, time in enumerate(data["time"]): + ods[f"core_profiles.profiles_1d[{i_time}]."+entry] = data[entry][i_time] + + + # ================================ @machine_mapping_function(__regression_arguments__, pulse=133221) From 7f2063d1981e5ce7b3503dcbe6777ed0cb99b0f0 Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Wed, 8 Mar 2023 11:27:20 -0800 Subject: [PATCH 02/26] Re-added support for ZIPFITS. - The use of coniditionals seems to cause problems for the .json - Code could probably use some refactoring --- omas/machine_mappings/d3d.json | 48 +++++---------------- omas/machine_mappings/d3d.py | 76 +++++++++++++++++++++------------- 2 files changed, 58 insertions(+), 66 deletions(-) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index f080130ab..3ff9a6870 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -12,7 +12,8 @@ "default_tree": "D3D", "fast_ece": false, "nref": 0, - "revision": "BLESSED" + "revision": "BLESSED", + "tree": "OMFIT_PROFS" }, "bolometer.channel.:": { "PYTHON": "bolometer_hardware(ods, {pulse})" @@ -113,39 +114,12 @@ "coils_non_axisymmetric.coil.:.name": { "PYTHON": "coils_non_axisymmetric_hardware(ods, {pulse})" }, - "core_profiles.profiles_1d.:": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse})" - }, - "core_profiles.profiles_1d.:.electrons.density": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse})" - }, - "core_profiles.profiles_1d.:.electrons.temperature": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse})" - }, - "core_profiles.profiles_1d.:.grid.rho_pol_norm": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse})" - }, - "core_profiles.profiles_1d.:.grid.rho_tor_norm": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse})" - }, - "core_profiles.profiles_1d.:.ion.:": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse})" - }, - "core_profiles.profiles_1d.:.ion.:.density": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse})" - }, - "core_profiles.profiles_1d.:.ion.:.temperature": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse})" - }, - "core_profiles.profiles_1d.:.ion.:.velocity.toroidal": { + "core_profiles.global_quantities.v_loop": { "COCOSIO": 11, - "PYTHON": "core_profiles_profile_1d(ods, {pulse})" + "PYTHON": "core_profiles_global_quantities_data(ods, {pulse})" }, - "core_profiles.profiles_1d.:.time": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse})" - }, - "core_profiles.time": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse})" + "core_profiles.profiles_1d.:": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree})" }, "ec_launchers.beam.:": { "PYTHON": "ec_launcher_active_hardware(ods, {pulse})" @@ -340,7 +314,7 @@ "PYTHON": "langmuir_probes_data(ods, {pulse})" }, "langmuir_probes.embedded.:.identifier": { - "PYTHON": "langmuir_probes_hardware(ods, {pulse})" + "PYTHON": "langmuir_probes_data(ods, {pulse})" }, "langmuir_probes.embedded.:.ion_saturation_current.data": { "PYTHON": "langmuir_probes_data(ods, {pulse})" @@ -349,17 +323,17 @@ "PYTHON": "langmuir_probes_data(ods, {pulse})" }, "langmuir_probes.embedded.:.name": { - "PYTHON": "langmuir_probes_hardware(ods, {pulse})" + "PYTHON": "langmuir_probes_data(ods, {pulse})" }, "langmuir_probes.embedded.:.position.phi": { "COCOSIO": 11, - "PYTHON": "langmuir_probes_hardware(ods, {pulse})" + "PYTHON": "langmuir_probes_data(ods, {pulse})" }, "langmuir_probes.embedded.:.position.r": { - "PYTHON": "langmuir_probes_hardware(ods, {pulse})" + "PYTHON": "langmuir_probes_data(ods, {pulse})" }, "langmuir_probes.embedded.:.position.z": { - "PYTHON": "langmuir_probes_hardware(ods, {pulse})" + "PYTHON": "langmuir_probes_data(ods, {pulse})" }, "langmuir_probes.embedded.:.surface_area_effective.data": { "PYTHON": "langmuir_probes_data(ods, {pulse})" diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index 31c8463ec..293f934f1 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1341,35 +1341,53 @@ def ip_bt_dflux_data(ods, pulse): ods['tf.b_field_tor_vacuum_r.data'] *= 1.6955 -@machine_mapping_function(__regression_arguments__, pulse=194455001) -def core_profiles_profile_1d(ods, pulse): - omfit_profiles_node = '\\TOP.' - query = { - "grid.rho_tor_norm": "rho", - "electrons.density": "n_e", - "electrons.temperature": "T_e", - "ion[0].density": "n_D", - "ion[0].temperature": "T_i", - "ion[0].velocity.toroidal": "V_tor_C", - "ion[0].density": "n_C" - } - for entry in query: - query[entry] = omfit_profiles_node + query[entry] - data = mdsvalue('d3d', treename='OMFIT_PROFS', pulse=pulse, TDI=query).raw() - dim_info = mdsvalue('d3d', treename='OMFIT_PROFS', pulse=pulse, TDI="\\TOP.n_e") - data['time'] = dim_info.dim_of(1) * 1.e-3 - psi_n = dim_info.dim_of(0) - data['grid.rho_pol_norm'] = np.zeros((data['time'].shape + psi_n.shape)) - data['grid.rho_pol_norm'][:] = np.sqrt(psi_n) - data["ion[1].temperature"] = data["ion[0].temperature"] - data["ion[1].velocity.toroidal"] = data["ion[0].velocity.toroidal"] - ods[f"core_profiles.time"] = data['time'] - for entry in data: - for i_time, time in enumerate(data["time"]): - ods[f"core_profiles.profiles_1d[{i_time}]."+entry] = data[entry][i_time] - - - +@machine_mapping_function(__regression_arguments__, pulse=194455001, tree="OMFIT_PROFS") +def core_profiles_profile_1d(ods, pulse, tree="OMFIT_PROFS"): + if "OMFIT_PROFS" in tree: + omfit_profiles_node = '\\TOP.' + query = { + "grid.rho_tor_norm": "rho", + "electrons.density": "n_e", + "electrons.temperature": "T_e", + "ion[0].density": "n_D", + "ion[0].temperature": "T_i", + "ion[0].velocity.toroidal": "V_tor_C", + "ion[0].density": "n_C" + } + for entry in query: + query[entry] = omfit_profiles_node + query[entry] + data = mdsvalue('d3d', treename='OMFIT_PROFS', pulse=pulse, TDI=query).raw() + dim_info = mdsvalue('d3d', treename='OMFIT_PROFS', pulse=pulse, TDI="\\TOP.n_e") + data['time'] = dim_info.dim_of(1) * 1.e-3 + psi_n = dim_info.dim_of(0) + data['grid.rho_pol_norm'] = np.zeros((data['time'].shape + psi_n.shape)) + data['grid.rho_pol_norm'][:] = np.sqrt(psi_n) + data["ion[1].temperature"] = data["ion[0].temperature"] + data["ion[1].velocity.toroidal"] = data["ion[0].velocity.toroidal"] + ods[f"core_profiles.time"] = data['time'] + for entry in data: + for i_time, time in enumerate(data["time"]): + ods[f"core_profiles.profiles_1d[{i_time}]."+entry] = data[entry][i_time] + else: + profiles_node = '\\TOP.PROFILES.' + query = { + "electrons.density": "EDENSFIT", + "electrons.density_thermal": "EDENSFIT", + "electrons.temperature": "ETEMPFIT" + } + for entry in query: + query[entry] = profiles_node + query[entry] + data = mdsvalue('d3d', treename=tree, pulse=pulse, TDI=query).raw() + dim_info = mdsvalue('d3d', treename=tree, pulse=pulse, TDI="\\TOP.PROFILES.EDENSFIT") + data['time'] = dim_info.dim_of(1) * 1.e-3 + rho_tor_norm = dim_info.dim_of(0) + data['grid.rho_tor_norm'] = np.zeros((data['time'].shape + rho_tor_norm.shape)) + data['grid.rho_tor_norm'][:] = rho_tor_norm + ods[f"core_profiles.time"] = data['time'] + for entry in data: + print(entry) + for i_time, time in enumerate(data["time"]): + ods[f"core_profiles.profiles_1d[{i_time}]."+entry] = data[entry][i_time] # ================================ @machine_mapping_function(__regression_arguments__, pulse=133221) From 33ded7f0f51dd86854c4a07f1b9e3ada4c657b5d Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Wed, 8 Mar 2023 21:17:25 -0800 Subject: [PATCH 03/26] Fixed issues with treenames and ZIPFIT --- omas/machine_mappings/d3d.json | 48 +++++++++++++++++++++++++++++++--- omas/machine_mappings/d3d.py | 18 ++++++++----- 2 files changed, 56 insertions(+), 10 deletions(-) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index 3ff9a6870..0d539f370 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -12,8 +12,7 @@ "default_tree": "D3D", "fast_ece": false, "nref": 0, - "revision": "BLESSED", - "tree": "OMFIT_PROFS" + "revision": "BLESSED" }, "bolometer.channel.:": { "PYTHON": "bolometer_hardware(ods, {pulse})" @@ -119,7 +118,50 @@ "PYTHON": "core_profiles_global_quantities_data(ods, {pulse})" }, "core_profiles.profiles_1d.:": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree})" + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.electrons.density": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.electrons.density_thermal": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.electrons.temperature": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.grid.rho_pol_norm": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.grid.rho_tor_norm": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.density": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.element.:": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.element.:.a": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.element.:.z_n": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.temperature": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.velocity.toroidal": { + "COCOSIO": 11, + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.time": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.time": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, "ec_launchers.beam.:": { "PYTHON": "ec_launcher_active_hardware(ods, {pulse})" diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index 293f934f1..ee08a53f5 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1341,9 +1341,9 @@ def ip_bt_dflux_data(ods, pulse): ods['tf.b_field_tor_vacuum_r.data'] *= 1.6955 -@machine_mapping_function(__regression_arguments__, pulse=194455001, tree="OMFIT_PROFS") -def core_profiles_profile_1d(ods, pulse, tree="OMFIT_PROFS"): - if "OMFIT_PROFS" in tree: +@machine_mapping_function(__regression_arguments__, pulse=194455001, PROFILES_tree="OMFIT_PROFS") +def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): + if "OMFIT_PROFS" in PROFILES_tree: omfit_profiles_node = '\\TOP.' query = { "grid.rho_tor_norm": "rho", @@ -1356,8 +1356,8 @@ def core_profiles_profile_1d(ods, pulse, tree="OMFIT_PROFS"): } for entry in query: query[entry] = omfit_profiles_node + query[entry] - data = mdsvalue('d3d', treename='OMFIT_PROFS', pulse=pulse, TDI=query).raw() - dim_info = mdsvalue('d3d', treename='OMFIT_PROFS', pulse=pulse, TDI="\\TOP.n_e") + data = mdsvalue('d3d', treename=PROFILES_tree, pulse=pulse, TDI=query).raw() + dim_info = mdsvalue('d3d', treename=PROFILES_tree, pulse=pulse, TDI="\\TOP.n_e") data['time'] = dim_info.dim_of(1) * 1.e-3 psi_n = dim_info.dim_of(0) data['grid.rho_pol_norm'] = np.zeros((data['time'].shape + psi_n.shape)) @@ -1368,6 +1368,10 @@ def core_profiles_profile_1d(ods, pulse, tree="OMFIT_PROFS"): for entry in data: for i_time, time in enumerate(data["time"]): ods[f"core_profiles.profiles_1d[{i_time}]."+entry] = data[entry][i_time] + ods[f"core_profiles.profiles_1d[:].ion[0].element[0].z_n"] = 1 + ods[f"core_profiles.profiles_1d[:].ion[0].element[0].a"] = 2.0141 + ods[f"core_profiles.profiles_1d[:].ion[0].element[1].z_n"] = 6 + ods[f"core_profiles.profiles_1d[:].ion[0].element[1].a"] = 12.011 else: profiles_node = '\\TOP.PROFILES.' query = { @@ -1377,8 +1381,8 @@ def core_profiles_profile_1d(ods, pulse, tree="OMFIT_PROFS"): } for entry in query: query[entry] = profiles_node + query[entry] - data = mdsvalue('d3d', treename=tree, pulse=pulse, TDI=query).raw() - dim_info = mdsvalue('d3d', treename=tree, pulse=pulse, TDI="\\TOP.PROFILES.EDENSFIT") + data = mdsvalue('d3d', treename=PROFILES_tree, pulse=pulse, TDI=query).raw() + dim_info = mdsvalue('d3d', treename=PROFILES_tree, pulse=pulse, TDI="\\TOP.PROFILES.EDENSFIT") data['time'] = dim_info.dim_of(1) * 1.e-3 rho_tor_norm = dim_info.dim_of(0) data['grid.rho_tor_norm'] = np.zeros((data['time'].shape + rho_tor_norm.shape)) From 98eccb22ec40755ccac45f2a8ece8da15d5993dd Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Wed, 8 Mar 2023 22:03:17 -0800 Subject: [PATCH 04/26] Added errors, minor refactpring --- omas/machine_mappings/d3d.json | 15 ++++++++++++++ omas/machine_mappings/d3d.py | 37 ++++++++++++++++++++++------------ 2 files changed, 39 insertions(+), 13 deletions(-) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index 0d539f370..e25539863 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -123,12 +123,18 @@ "core_profiles.profiles_1d.:.electrons.density": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.electrons.density_error_upper": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.electrons.density_thermal": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, "core_profiles.profiles_1d.:.electrons.temperature": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.electrons.temperature_error_upper": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.grid.rho_pol_norm": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, @@ -141,6 +147,9 @@ "core_profiles.profiles_1d.:.ion.:.density": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.ion.:.density_error_upper": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.ion.:.element.:": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, @@ -153,10 +162,16 @@ "core_profiles.profiles_1d.:.ion.:.temperature": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.ion.:.temperature_error_upper": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.ion.:.velocity.toroidal": { "COCOSIO": 11, "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.ion.:.velocity.toroidal_error_upper": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.time": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index ee08a53f5..a6a9b1b51 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -6,6 +6,7 @@ from omas import * from omas.omas_utils import printd, printe, unumpy from omas.machine_mappings._common import * +from uncertainties import unumpy __all__ = [] __regression_arguments__ = {'__all__': __all__} @@ -1346,32 +1347,43 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): if "OMFIT_PROFS" in PROFILES_tree: omfit_profiles_node = '\\TOP.' query = { - "grid.rho_tor_norm": "rho", "electrons.density": "n_e", "electrons.temperature": "T_e", "ion[0].density": "n_D", "ion[0].temperature": "T_i", "ion[0].velocity.toroidal": "V_tor_C", - "ion[0].density": "n_C" + "ion[1].density": "n_C" } + uncertain_entries = list(query.keys()) + query["grid.rho_tor_norm"] = "rho" for entry in query: query[entry] = omfit_profiles_node + query[entry] + for entry in uncertain_entries: + query[entry + ".data_error_upper"] = "error_of(" + query[entry] + ")" data = mdsvalue('d3d', treename=PROFILES_tree, pulse=pulse, TDI=query).raw() dim_info = mdsvalue('d3d', treename=PROFILES_tree, pulse=pulse, TDI="\\TOP.n_e") data['time'] = dim_info.dim_of(1) * 1.e-3 psi_n = dim_info.dim_of(0) data['grid.rho_pol_norm'] = np.zeros((data['time'].shape + psi_n.shape)) data['grid.rho_pol_norm'][:] = np.sqrt(psi_n) - data["ion[1].temperature"] = data["ion[0].temperature"] - data["ion[1].velocity.toroidal"] = data["ion[0].velocity.toroidal"] - ods[f"core_profiles.time"] = data['time'] - for entry in data: - for i_time, time in enumerate(data["time"]): - ods[f"core_profiles.profiles_1d[{i_time}]."+entry] = data[entry][i_time] - ods[f"core_profiles.profiles_1d[:].ion[0].element[0].z_n"] = 1 - ods[f"core_profiles.profiles_1d[:].ion[0].element[0].a"] = 2.0141 - ods[f"core_profiles.profiles_1d[:].ion[0].element[1].z_n"] = 6 - ods[f"core_profiles.profiles_1d[:].ion[0].element[1].a"] = 12.011 + for unc in ["", ".data_error_upper"]: + data["ion[1].temperature" + unc] = data["ion[0].temperature" + unc] + data["ion[1].velocity.toroidal" + unc] = data["ion[0].velocity.toroidal" + unc] + ods["core_profiles.time"] = data['time'] + sh = "core_profiles.profiles_1d" + for i_time, time in enumerate(data["time"]): + print("time", i_time) + ods[f"{sh}[{i_time}].grid.rho_pol_norm"] = data['grid.rho_pol_norm'][i_time] + ods[f"{sh}[{i_time}].grid.rho_tor_norm"] = data['grid.rho_tor_norm'][i_time] + for entry in uncertain_entries: + print(entry) + ods[f"{sh}[{i_time}]."+entry] = unumpy.uarray( + data[entry][i_time], + data[entry + ".data_error_upper"][i_time]) + ods[f"{sh}[{i_time}].ion[0].element[0].z_n"] = 1 + ods[f"{sh}[{i_time}].ion[0].element[0].a"] = 2.0141 + ods[f"{sh}[{i_time}].ion[1].element[0].z_n"] = 6 + ods[f"{sh}[{i_time}].ion[1].element[0].a"] = 12.011 else: profiles_node = '\\TOP.PROFILES.' query = { @@ -1389,7 +1401,6 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): data['grid.rho_tor_norm'][:] = rho_tor_norm ods[f"core_profiles.time"] = data['time'] for entry in data: - print(entry) for i_time, time in enumerate(data["time"]): ods[f"core_profiles.profiles_1d[{i_time}]."+entry] = data[entry][i_time] From b33081ca91e3efdc15d70c21346c54ba61e7b0b7 Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Mon, 13 Mar 2023 11:37:20 -0700 Subject: [PATCH 05/26] Updated equilibrium_summary for oams_viewer --- omas/omas_plot.py | 92 +++++++++++++++++++++++++++++++++-------------- 1 file changed, 66 insertions(+), 26 deletions(-) diff --git a/omas/omas_plot.py b/omas/omas_plot.py index 42f9811e8..cd77cdeaa 100644 --- a/omas/omas_plot.py +++ b/omas/omas_plot.py @@ -939,7 +939,7 @@ def equilibrium_CX_topview(ods, time_index=None, time=None, ax=None, **kw): @add_to__ODS__ -def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_triangles=None, **kw): +def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_triangles=None, omas_viewer=False, **kw): """ Plot equilibrium cross-section and P, q, P', FF' profiles as per `ods['equilibrium']['time_slice'][time_index]` @@ -986,8 +986,10 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr return ods_time_plot( equilibrium_summary, ods, time_index, time, fig=fig, ggd_points_triangles=ggd_points_triangles, ax=axs, **kw ) - - ax = cached_add_subplot(fig, axs, 1, 3, 1) + if omas_viewer: + ax = cached_add_subplot(fig, axs, 1, 4, 1) + else: + ax = cached_add_subplot(fig, axs, 1, 3, 1) contour_quantity = kw.pop('contour_quantity', 'rho_tor_norm') tmp = equilibrium_CX( ods, time_index=time_index, ax=ax, contour_quantity=contour_quantity, ggd_points_triangles=ggd_points_triangles, **kw @@ -1005,17 +1007,28 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr xName = nice_names.get(raw_xName, raw_xName) # pressure - ax = cached_add_subplot(fig, axs, 2, 3, 2) - ax.plot(x, eq['profiles_1d']['pressure'], **kw) + if omas_viewer: + ax = cached_add_subplot(fig, axs, 2, 4, 2) + else: + ax = cached_add_subplot(fig, axs, 2, 3, 2) + ax.plot(x, eq['profiles_1d']['pressure'] * 1.e-3, **kw) + ax.set_ylabel("$p$ [kPa]") + ax.set_xlabel(xName) + ax.set_xlim(0,1) kw.setdefault('color', ax.lines[-1].get_color()) ax.set_title(r'$\,$ Pressure') - ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') - pyplot.setp(ax.get_xticklabels(), visible=False) - + # ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') + if not omas_viewer: + pyplot.setp(ax.get_xticklabels(), visible=False) # q - ax = cached_add_subplot(fig, axs, 2, 3, 3, sharex=ax) + if omas_viewer: + ax = cached_add_subplot(fig, axs, 2, 4, 3, sharex=ax) + else: + ax = cached_add_subplot(fig, axs, 2, 3, 3, sharex=ax) ax.plot(x, eq['profiles_1d']['q'], **kw) ax.set_title('$q$ Safety factor') + ax.set_ylabel("$q$") + ax.set_xlabel(xName) ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') if 'label' in kw: leg = ax.legend(loc=0) @@ -1025,25 +1038,52 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr leg.set_draggable(True) else: leg.draggable(True) - pyplot.setp(ax.get_xticklabels(), visible=False) - - # dP_dpsi - ax = cached_add_subplot(fig, axs, 2, 3, 5, sharex=ax) - ax.plot(x, eq['profiles_1d']['dpressure_dpsi'], **kw) - ax.set_title(r"$P\,^\prime$ source function") - ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') - pyplot.xlabel(xName) - - # FdF_dpsi - ax = cached_add_subplot(fig, axs, 2, 3, 6, sharex=ax) - ax.plot(x, eq['profiles_1d']['f_df_dpsi'], **kw) - ax.set_title(r"$FF\,^\prime$ source function") - ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') - pyplot.xlabel(xName) - + if not omas_viewer: + pyplot.setp(ax.get_xticklabels(), visible=False) + if omas_viewer: + # j_tor,j_parallel have no data + ax = cached_add_subplot(fig, axs, 2, 4, 4, sharex=ax) + # ax.plot(x, eq['profiles_1d']['j_parallel'], **kw) + ax.set_title(r"$j_\mathrm{tor}$") + # ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') + # pyplot.xlabel(xName) + else: + # dP_dpsi + ax = cached_add_subplot(fig, axs, 2, 3, 5, sharex=ax) + ax.plot(x, eq['profiles_1d']['dpressure_dpsi'], **kw) + ax.set_title(r"$P\,^\prime$ source function") + ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') + pyplot.xlabel(xName) + if omas_viewer: + ax = cached_add_subplot(fig, axs, 2, 4, 6) + # ax.plot(eq['profiles_1d']['convergence']['iteration'], + # eq['profiles_1d']['convergence']['grad_shafranov_deviation_value'], **kw) + ax.set_title(r"GS Convergence") + ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') + pyplot.xlabel(xName) + else: + # FdF_dpsi + ax = cached_add_subplot(fig, axs, 2, 3, 6, sharex=ax) + ax.plot(x, eq['profiles_1d']['f_df_dpsi'], **kw) + ax.set_title(r"$FF\,^\prime$ source function") + ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') + pyplot.xlabel(xName) + + if omas_viewer: + # Problems loading fields and no data + ax = cached_add_subplot(fig, axs, 2, 4, 7) + # ax.plot(range(len(eq['constraints.flux_loop'])) + 1, eq['constraints.flux_loop'][:]["chi_squared"], **kw) + ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') + ax.set_title(r"$\chi^2$ convergence") + pyplot.xlabel("Flux loop \#") + ax = cached_add_subplot(fig, axs, 2, 4, 8) + # ax.plot(range(len(eq['constraints.flux_loop'])) + 1, eq['constraints.flux_loop'][:]["chi_squared"], **kw) + ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') + ax.set_title(r"???") + pyplot.xlabel("???") if raw_xName.endswith('norm'): ax.set_xlim([0, 1]) - + fig.tight_layout() return {'ax': axs} From 3355078552ae16bf7d517cd0be39c450e63c0893 Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Mon, 13 Mar 2023 12:19:53 -0700 Subject: [PATCH 06/26] Some refactoring and clean-up - Removed GS error evolution plot --- omas/omas_plot.py | 90 +++++++++++++++++++---------------------------- 1 file changed, 37 insertions(+), 53 deletions(-) diff --git a/omas/omas_plot.py b/omas/omas_plot.py index cd77cdeaa..ca1456371 100644 --- a/omas/omas_plot.py +++ b/omas/omas_plot.py @@ -936,6 +936,15 @@ def equilibrium_CX_topview(ods, time_index=None, time=None, ax=None, **kw): 'phi_norm': '$\\phi$', 'q': '$q$', } +def plot_1d_equilbrium_quantity(ax, x, y, xlabel, ylabel, title, visible_x = True, **kw): + from matplotlib import pyplot + ax.plot(x, y, **kw) + if visible_x: + ax.set_xlabel(xlabel) + else: + pyplot.setp(ax.get_xticklabels(), visible=False) + ax.set_ylabel(ylabel) + ax.set_title(title) @add_to__ODS__ @@ -986,10 +995,7 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr return ods_time_plot( equilibrium_summary, ods, time_index, time, fig=fig, ggd_points_triangles=ggd_points_triangles, ax=axs, **kw ) - if omas_viewer: - ax = cached_add_subplot(fig, axs, 1, 4, 1) - else: - ax = cached_add_subplot(fig, axs, 1, 3, 1) + ax = cached_add_subplot(fig, axs, 1, 3, 1) contour_quantity = kw.pop('contour_quantity', 'rho_tor_norm') tmp = equilibrium_CX( ods, time_index=time_index, ax=ax, contour_quantity=contour_quantity, ggd_points_triangles=ggd_points_triangles, **kw @@ -1007,29 +1013,20 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr xName = nice_names.get(raw_xName, raw_xName) # pressure - if omas_viewer: - ax = cached_add_subplot(fig, axs, 2, 4, 2) - else: - ax = cached_add_subplot(fig, axs, 2, 3, 2) - ax.plot(x, eq['profiles_1d']['pressure'] * 1.e-3, **kw) - ax.set_ylabel("$p$ [kPa]") - ax.set_xlabel(xName) - ax.set_xlim(0,1) + ax = cached_add_subplot(fig, axs, 2, 3, 2) + plot_1d_equilbrium_quantity(ax, x, eq['profiles_1d']['pressure'] * 1.e-3, + xName, r"$p$ [kPa]", r'$\,$ Pressure', + visible_x=omas_viewer, **kw) kw.setdefault('color', ax.lines[-1].get_color()) - ax.set_title(r'$\,$ Pressure') - # ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') - if not omas_viewer: - pyplot.setp(ax.get_xticklabels(), visible=False) # q if omas_viewer: - ax = cached_add_subplot(fig, axs, 2, 4, 3, sharex=ax) + ax = cached_add_subplot(fig, axs, 2, 3, 5, sharex=ax) else: ax = cached_add_subplot(fig, axs, 2, 3, 3, sharex=ax) - ax.plot(x, eq['profiles_1d']['q'], **kw) - ax.set_title('$q$ Safety factor') - ax.set_ylabel("$q$") - ax.set_xlabel(xName) - ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') + plot_1d_equilbrium_quantity(ax, x, eq['profiles_1d']['q'], + xName, r'$q$ Safety factor', r'$q$ Safety factor', + visible_x=omas_viewer, **kw) + #ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') if 'label' in kw: leg = ax.legend(loc=0) import matplotlib @@ -1041,52 +1038,39 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr if not omas_viewer: pyplot.setp(ax.get_xticklabels(), visible=False) if omas_viewer: + ax = cached_add_subplot(fig, axs, 2, 3, 3, sharex=ax) # j_tor,j_parallel have no data - ax = cached_add_subplot(fig, axs, 2, 4, 4, sharex=ax) # ax.plot(x, eq['profiles_1d']['j_parallel'], **kw) ax.set_title(r"$j_\mathrm{tor}$") # ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') # pyplot.xlabel(xName) else: - # dP_dpsi ax = cached_add_subplot(fig, axs, 2, 3, 5, sharex=ax) - ax.plot(x, eq['profiles_1d']['dpressure_dpsi'], **kw) - ax.set_title(r"$P\,^\prime$ source function") - ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') - pyplot.xlabel(xName) + plot_1d_equilbrium_quantity(ax, x, eq['profiles_1d']['dpressure_dpsi'] * 1.e-3, + xName, r'$P\,^\prime$ [kPa Wb$^{-1}$]', + r"$P\,^\prime$ source function", + visible_x=True, **kw) + if raw_xName.endswith('norm'): + ax.set_xlim([0, 1]) + ax = cached_add_subplot(fig, axs, 2, 3, 6, sharex=ax) if omas_viewer: - ax = cached_add_subplot(fig, axs, 2, 4, 6) + ax = cached_add_subplot(fig, axs, 2, 3, 6) # ax.plot(eq['profiles_1d']['convergence']['iteration'], # eq['profiles_1d']['convergence']['grad_shafranov_deviation_value'], **kw) - ax.set_title(r"GS Convergence") - ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') - pyplot.xlabel(xName) + ax.set_title(r"$\chi^2$ convergence") + + ax.set_xlabel(r"Flux loop \#") + ax.set_ylabel(r"Residiaul [std. dev.]") else: - # FdF_dpsi ax = cached_add_subplot(fig, axs, 2, 3, 6, sharex=ax) - ax.plot(x, eq['profiles_1d']['f_df_dpsi'], **kw) - ax.set_title(r"$FF\,^\prime$ source function") - ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') - pyplot.xlabel(xName) - - if omas_viewer: - # Problems loading fields and no data - ax = cached_add_subplot(fig, axs, 2, 4, 7) - # ax.plot(range(len(eq['constraints.flux_loop'])) + 1, eq['constraints.flux_loop'][:]["chi_squared"], **kw) - ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') - ax.set_title(r"$\chi^2$ convergence") - pyplot.xlabel("Flux loop \#") - ax = cached_add_subplot(fig, axs, 2, 4, 8) - # ax.plot(range(len(eq['constraints.flux_loop'])) + 1, eq['constraints.flux_loop'][:]["chi_squared"], **kw) - ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') - ax.set_title(r"???") - pyplot.xlabel("???") - if raw_xName.endswith('norm'): - ax.set_xlim([0, 1]) + # FdF_dpsi + plot_1d_equilbrium_quantity(ax, x, eq['profiles_1d']['f_df_dpsi'], + xName, r'$FF\,^\prime$ [T$^2$ m$^2$ Wb$^{-1}$]', + r"$FF\,^\prime$ source function", + visible_x=True, **kw) fig.tight_layout() return {'ax': axs} - @add_to__ODS__ def core_profiles_currents_summary(ods, time_index=None, time=None, ax=None, **kw): """ From acbb9843b4706b22ed46e3c7adab6fc0b2d3ec88 Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Mon, 13 Mar 2023 17:35:12 -0700 Subject: [PATCH 07/26] Added homogeneous_time=1 for core_profiles --- omas/machine_mappings/d3d.json | 3 +++ omas/machine_mappings/d3d.py | 1 + 2 files changed, 4 insertions(+) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index e25539863..81b8819a4 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -117,6 +117,9 @@ "COCOSIO": 11, "PYTHON": "core_profiles_global_quantities_data(ods, {pulse})" }, + "core_profiles.ids_properties.homogeneous_time": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index a6a9b1b51..ab8e11745 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1344,6 +1344,7 @@ def ip_bt_dflux_data(ods, pulse): @machine_mapping_function(__regression_arguments__, pulse=194455001, PROFILES_tree="OMFIT_PROFS") def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): + ods["core_profiles.ids_properties.homogeneous_time"] = 1 if "OMFIT_PROFS" in PROFILES_tree: omfit_profiles_node = '\\TOP.' query = { From 4450aedf74af3a5cc4bbb15c6d701efe08c92ca4 Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Mon, 13 Mar 2023 18:16:05 -0700 Subject: [PATCH 08/26] Removed stale entry in d3d.json - Also added labels for ion --- omas/machine_mappings/d3d.json | 6 +++--- omas/machine_mappings/d3d.py | 3 ++- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index 81b8819a4..2e25831ac 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -162,6 +162,9 @@ "core_profiles.profiles_1d.:.ion.:.element.:.z_n": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.ion.:.label": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.ion.:.temperature": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, @@ -175,9 +178,6 @@ "core_profiles.profiles_1d.:.ion.:.velocity.toroidal_error_upper": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, - "core_profiles.profiles_1d.:.time": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" - }, "core_profiles.time": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index ab8e11745..645e154ef 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1373,7 +1373,6 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): ods["core_profiles.time"] = data['time'] sh = "core_profiles.profiles_1d" for i_time, time in enumerate(data["time"]): - print("time", i_time) ods[f"{sh}[{i_time}].grid.rho_pol_norm"] = data['grid.rho_pol_norm'][i_time] ods[f"{sh}[{i_time}].grid.rho_tor_norm"] = data['grid.rho_tor_norm'][i_time] for entry in uncertain_entries: @@ -1385,6 +1384,8 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): ods[f"{sh}[{i_time}].ion[0].element[0].a"] = 2.0141 ods[f"{sh}[{i_time}].ion[1].element[0].z_n"] = 6 ods[f"{sh}[{i_time}].ion[1].element[0].a"] = 12.011 + ods[f"{sh}[{i_time}].ion[0].label"] = "D" + ods[f"{sh}[{i_time}].ion[1].label"] = "C" else: profiles_node = '\\TOP.PROFILES.' query = { From 82f36e4e67d403d7be6f657a3eabcf94c64719ea Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Tue, 14 Mar 2023 06:33:46 -0700 Subject: [PATCH 09/26] Fixed profile loading, added pressure and current --- omas/machine_mappings/d3d.json | 7 ++++++ omas/machine_mappings/d3d.py | 42 +++++++++++++++++++++++----------- 2 files changed, 36 insertions(+), 13 deletions(-) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index 2e25831ac..86a1b797c 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -178,6 +178,13 @@ "core_profiles.profiles_1d.:.ion.:.velocity.toroidal_error_upper": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.j_total": { + "COCOSIO": 11, + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.pressure_perpendicular": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.time": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index 645e154ef..ebff1e371 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1348,15 +1348,20 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): if "OMFIT_PROFS" in PROFILES_tree: omfit_profiles_node = '\\TOP.' query = { - "electrons.density": "n_e", - "electrons.temperature": "T_e", - "ion[0].density": "n_D", - "ion[0].temperature": "T_i", - "ion[0].velocity.toroidal": "V_tor_C", - "ion[1].density": "n_C" + "electrons.density": "N_E", + "electrons.temperature": "T_E", + "ion[0].density": "N_D", + "ion[0].temperature": "T_D", + "ion[0].velocity.toroidal": "V_TOR_C", + "ion[1].density": "N_C", + "ion[1].temperature": "T_C" } uncertain_entries = list(query.keys()) + query["j_total"] = "J_TOT" + query["pressure_perpendicular"] = "P_TOT" + #query["e_field.radial"] = "ER_C" query["grid.rho_tor_norm"] = "rho" + normal_entries = set(query.keys()) - set(uncertain_entries) for entry in query: query[entry] = omfit_profiles_node + query[entry] for entry in uncertain_entries: @@ -1368,18 +1373,29 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): data['grid.rho_pol_norm'] = np.zeros((data['time'].shape + psi_n.shape)) data['grid.rho_pol_norm'][:] = np.sqrt(psi_n) for unc in ["", ".data_error_upper"]: - data["ion[1].temperature" + unc] = data["ion[0].temperature" + unc] - data["ion[1].velocity.toroidal" + unc] = data["ion[0].velocity.toroidal" + unc] + data[f"ion[1].velocity.toroidal{unc}"] = data[f"ion[0].velocity.toroidal{unc}"] ods["core_profiles.time"] = data['time'] sh = "core_profiles.profiles_1d" for i_time, time in enumerate(data["time"]): ods[f"{sh}[{i_time}].grid.rho_pol_norm"] = data['grid.rho_pol_norm'][i_time] - ods[f"{sh}[{i_time}].grid.rho_tor_norm"] = data['grid.rho_tor_norm'][i_time] for entry in uncertain_entries: - print(entry) - ods[f"{sh}[{i_time}]."+entry] = unumpy.uarray( - data[entry][i_time], - data[entry + ".data_error_upper"][i_time]) + try: + print("Uncertain entry", entry) + ods[f"{sh}[{i_time}]."+entry] = unumpy.uarray( + data[entry][i_time], + data[entry + ".data_error_upper"][i_time]) + except: + print("================ DATA =================") + print(data[entry][i_time]) + print("================ ERROR =================") + print(data[entry + ".data_error_upper"][i_time]) + for entry in normal_entries: + try: + print("Normal entry", entry) + ods[f"{sh}[{i_time}]."+entry] = data[entry][i_time] + except: + print("================ DATA =================") + print(data[entry][i_time]) ods[f"{sh}[{i_time}].ion[0].element[0].z_n"] = 1 ods[f"{sh}[{i_time}].ion[0].element[0].a"] = 2.0141 ods[f"{sh}[{i_time}].ion[1].element[0].z_n"] = 6 From f4477d526f1ef7f3a35ea327e36b9125210ea015 Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Thu, 23 Mar 2023 08:25:01 -0700 Subject: [PATCH 10/26] Ovverhauled profile and equilibirum plots - Load missing equilibrium quantities via OMFIT - Added functions for improved unit and scale handling in plots - Added extra optional argument `omas_viewer` to equilibrium summary - It plots `p`, `q`, `j_tor`, and `chi^2` for diagnostics - Creates annotations for the `chi^2` plot with identifiers - Shows contraints for `j_tor` and `p` from `code.paramters` --- omas/machine_mappings/_common.py | 1 + omas/machine_mappings/d3d.json | 1064 ++++++++++++++++++- omas/machine_mappings/d3d.py | 65 +- omas/omas_machine.py | 285 +---- omas/omas_physics.py | 18 + omas/omas_plot.py | 108 +- omas/utilities/machine_mapping_decorator.py | 66 ++ omas/utilities/omas_mds.py | 215 ++++ 8 files changed, 1488 insertions(+), 334 deletions(-) create mode 100644 omas/utilities/machine_mapping_decorator.py create mode 100644 omas/utilities/omas_mds.py diff --git a/omas/machine_mappings/_common.py b/omas/machine_mappings/_common.py index 572f671e9..b42b3a476 100644 --- a/omas/machine_mappings/_common.py +++ b/omas/machine_mappings/_common.py @@ -3,6 +3,7 @@ from omas.omas_utils import printd import os import glob +from omas.omas_setup import omas_dir __support_files_cache__ = {} diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index 86a1b797c..ef984bb3b 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -117,12 +117,21 @@ "COCOSIO": 11, "PYTHON": "core_profiles_global_quantities_data(ods, {pulse})" }, + "core_profiles": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" +}, "core_profiles.ids_properties.homogeneous_time": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, "core_profiles.profiles_1d.:": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.e_field.radial": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.e_field.radial_error_upper": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.electrons.density": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, @@ -188,6 +197,9 @@ "core_profiles.time": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "dataset_description.data_entry.pulse": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, "ec_launchers.beam.:": { "PYTHON": "ec_launcher_active_hardware(ods, {pulse})" }, @@ -285,6 +297,1030 @@ "ece.line_of_sight.second_point.z": { "PYTHON": "electron_cyclotron_emission_hardware(ods, {pulse}, {fast_ece!r})" }, + "equilibrium.code": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" +}, +"equilibrium.code.parameters": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" +}, + "equilibrium.code.parameters.time_slice.:": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.auxquantities.degrees_of_freedom": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.auxquantities.num_fit_variables": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.auxquantities.num_hard_constraints": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.auxquantities.num_input_data": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.auxquantities.sigxxj": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.alphafp": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.bitec": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.bitfc": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.bitip": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.bitmpi": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.brsp": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.btor": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.calpa": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.cgama": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.coils": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.currn1": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.denr": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.denv": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.dflux": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.dmass": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.dnbeam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.dpsiecn": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ecurrt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.efitversion": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.elomin": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.errmag": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.errmagb": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.errmin": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.error": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.expmp2": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fcurbd": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ff2bdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ffbdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ffknt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fftens": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fitfcsum": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fitsiref": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fitzts": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fwtbp": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fwtcur": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fwtdlc": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fwtec": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fwtfc": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fwtfcsum": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fwtmp2": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fwtpre": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fwtqa": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.fwtsi": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.iavem": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.iaveus": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ibtcomp": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.iconvr": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.icprof": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.icutfp": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.iecurr": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ierchk": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ifcurr": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ifindopt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ifitvs": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.imagsigma": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.input_dir": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.iout": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.iplcout": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.iplim": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ishot": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.isolve": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.itek": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.itime": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.itimeu": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.itrace": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ixray": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kbound": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kcalpa": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kcgama": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kedgef": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kedgep": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.keehord": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.keqdsk": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kersil": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kff2bdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kffbdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kffcur": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kfffnc": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kffhord": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kffknt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kframe": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kpp2bdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kppbdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kppcur": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kppfnc": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kpphord": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kppknt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kprfit": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kskipvs": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ktear": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kwripre": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kww2bdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kwwbdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kwwfnc": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kwwknt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.kzeroj": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.limitr": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.mxiter": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.n1coil": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.nbdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.nbdrymx": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.nbeam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ndokin": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.nextra": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.nmass": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.npress": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.pbeam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.pcurbd": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.plasma": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.pnbeam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.pp2bdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ppbdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ppknt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.pptens": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.pressr": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.psibit": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.psiecn": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.qvfit": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.rbdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.rcentr": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.relax": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.req_valid": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.rpress": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.rzeroj": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.saicon": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.saimin": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.scrape": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.serror": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.sibeam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.sigdlc": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.sigpre": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.siloplim": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.siref": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.store_dir": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.table_dir": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.tolbndpsi": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.use_previous": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.vbit": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.vloop": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.vsdamp": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.ww2bdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.wwbdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.wwknt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.wwtens": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.xalpa": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.xgama": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.xltype": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.xltype_180": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.zbdry": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.in1.zelip": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.aa1gam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.aa2gam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.aa3gam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.aa4gam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.aa5gam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.aa6gam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.aa7gam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.dtmsefull": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.fwtgam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.kwaitmse": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.mse_certree": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.mse_quiet": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.mse_spave_on": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.mse_strict": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.mse_use_cer210": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.mse_use_cer330": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.mse_usecer": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.msebkp": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.msefitfun": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.ok_210lt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.ok_30rt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.rrrgam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.sgamma": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.t_max_beam_off": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.tgamma": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.tgammauncor": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.v210lt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.v210rt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.v30lt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.v30rt": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.ins.zzzgam": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.currc139": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.currc199": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.currc79": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.curril150": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.curril30": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.curril90": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.curriu150": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.curriu30": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.curriu90": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.errdelz": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.fitdelz": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.fwtxxj": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.ifitdelz": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.nccoil": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.nicoil": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.oldccomp": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.oldcomp": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.psiwant": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.relaxdz": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.rexpan": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.scaledz": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.sizeroj": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.vzeroj": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters.time_slice.:.inwant.znose": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.ids_properties.comment": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.ids_properties.homogeneous_time": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.boundary.outline.r": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.boundary.outline.z": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.boundary.x_point.:": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.boundary.x_point.:.r": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.boundary.x_point.:.z": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.bpol_probe.:": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.bpol_probe.:.chi_squared": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.bpol_probe.:.exact": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.bpol_probe.:.measured": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.bpol_probe.:.reconstructed": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.bpol_probe.:.weight": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.chi_squared_total": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.diamagnetic_flux.exact": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.diamagnetic_flux.measured": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.diamagnetic_flux.measured_error_upper": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.flux_loop.:": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.flux_loop.:.chi_squared": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.flux_loop.:.exact": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.flux_loop.:.measured": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.flux_loop.:.reconstructed": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.flux_loop.:.weight": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.ip.exact": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.ip.measured": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.ip.reconstructed": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.chi_squared": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.exact": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.measured": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.measured_error_upper": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.reconstructed": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.weight": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.pf_current.:": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.pf_current.:.exact": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.pf_current.:.measured": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.pf_current.:.reconstructed": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.pf_current.:.weight": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.pressure.:": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.pressure.:.chi_squared": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.pressure.:.exact": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.pressure.:.measured": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.pressure.:.measured_error_upper": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.constraints.pressure.:.reconstructed": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.convergence.grad_shafranov_deviation_expression.description": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.convergence.grad_shafranov_deviation_expression.index": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.convergence.grad_shafranov_deviation_expression.name": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.convergence.grad_shafranov_deviation_value": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.convergence.iterations_n": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.beta_normal": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.beta_pol": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.beta_tor": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.ip": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.li_3": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.magnetic_axis.b_field_tor": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.magnetic_axis.r": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.magnetic_axis.z": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.psi_axis": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.psi_boundary": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.q_95": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.q_axis": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.q_min.rho_tor_norm": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.global_quantities.q_min.value": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.area": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.b_field_average": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.b_field_max": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.b_field_min": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.centroid.r": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.centroid.r_max": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.centroid.r_min": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.centroid.z": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.darea_dpsi": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.darea_drho_tor": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.dpressure_dpsi": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.dpsi_drho_tor": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.dvolume_dpsi": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.dvolume_drho_tor": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.elongation": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.f": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.f_df_dpsi": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.geometric_axis.r": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.geometric_axis.z": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.gm1": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.gm2": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.gm5": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.gm8": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.gm9": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.j_tor": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.phi": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.pressure": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.psi": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.q": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.r_inboard": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.r_outboard": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.rho_tor": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.rho_tor_norm": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.squareness_lower_inner": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.squareness_lower_outer": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.squareness_upper_inner": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.squareness_upper_outer": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.surface": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.trapped_fraction": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.triangularity_lower": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.triangularity_upper": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_1d.volume": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_2d.:": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_2d.:.b_field_r": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_2d.:.b_field_tor": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_2d.:.b_field_z": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_2d.:.grid.dim1": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_2d.:.grid.dim2": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_2d.:.grid_type.index": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_2d.:.phi": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.profiles_2d.:.psi": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.time_slice.:.time": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.vacuum_toroidal_field.b0": { + "COCOSIO": 11, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.vacuum_toroidal_field.r0": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, "gas_injection.pipe.:": { "PYTHON": "gas_injection_hardware(ods, {pulse})" }, @@ -622,25 +1658,25 @@ "wall.description_2d.:": { "VALUE": 1 }, + "wall.description_2d.:.limiter.type.description": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "wall.description_2d.:.limiter.type.index": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "wall.description_2d.:.limiter.type.name": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, "wall.description_2d.:.limiter.unit.:": { "VALUE": 1 }, "wall.description_2d.:.limiter.unit.:.outline.r": { - "TDI": "transpose(data(\\{EFIT_tree}::TOP.RESULTS.GEQDSK.LIM)[0,])", - "TRANSPOSE": [ - 1, - 0, - 2 - ], - "treename": "{EFIT_tree}" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" }, "wall.description_2d.:.limiter.unit.:.outline.z": { - "TDI": "transpose(data(\\{EFIT_tree}::TOP.RESULTS.GEQDSK.LIM)[1,])", - "TRANSPOSE": [ - 1, - 0, - 2 - ], - "treename": "{EFIT_tree}" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "wall.time": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" } } \ No newline at end of file diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index ebff1e371..8b68e7f5b 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -7,6 +7,9 @@ from omas.omas_utils import printd, printe, unumpy from omas.machine_mappings._common import * from uncertainties import unumpy +from omas.utilities.machine_mapping_decorator import machine_mapping_function +from omas.utilities.omas_mds import mdsvalue +from omas.omas_core import ODS __all__ = [] __regression_arguments__ = {'__all__': __all__} @@ -1342,6 +1345,31 @@ def ip_bt_dflux_data(ods, pulse): ods['tf.b_field_tor_vacuum_r.data'] *= 1.6955 +@machine_mapping_function(__regression_arguments__, pulse=19438702, EFIT_tree="EFIT") +def equilibrium_special(ods, pulse, EFIT_tree="EFIT"): + from omfit_classes.omfit_eqdsk import from_mds_plus, OMFITkeqdsk + from scipy.interpolate import InterpolatedUnivariateSpline + kfiles = mdsvalue('d3d', treename=EFIT_tree, pulse=pulse, TDI="\\TOP.NAMELISTS.KEQDSKS").raw() # + times = mdsvalue('d3d', treename=EFIT_tree, pulse=pulse, TDI="\\TOP.NAMELISTS.KEQDSKS.KTIME").raw() # + ods["equilibrium.ids_properties.homogeneous_time"] = 1 + ods["equilibrium.time"]= times / 1.e3 + # for i_time, time in enumerate(times): + # ods[f"equilibrium.time_slice[{i_time}].time"] = time / 1.e3 + eq = from_mds_plus(device="d3d", shot=pulse, times=times, + exact=True, snap_file=EFIT_tree, get_afile=False, get_mfile=True, + show_missing_data_warnings=None, close=True) + for time_index, time in enumerate(times): + kstrstr = '\n'.join(list(kfiles[time_index])) + kEQDSK = OMFITkeqdsk(f'k{pulse}.{time_index}',fromString=kstrstr) + kEQDSK.to_omas(ods, time_index=time_index) + eq['gEQDSK'][time].to_omas(ods, time_index=time_index) + ods = eq['mEQDSK'][time].to_omas(ods, time_index=time_index) + if (np.abs(ods[f"equilibrium.time_slice[{time_index}].global_quantities.ip"] - + ods[f"equilibrium.code.parameters.time_slice.{time_index}.in1.plasma"]) > + np.abs(0.08*ods[f"equilibrium.time_slice[{time_index}].global_quantities.ip"])): + raise ValueError("Cannot reconstruct contraints, current constraints not met.") + ods[f"equilibrium.code.parameters.time_slice.{time_index}.inwant.vzeroj"] *= ods[f"equilibrium.time_slice[{time_index}].global_quantities.ip"] + @machine_mapping_function(__regression_arguments__, pulse=194455001, PROFILES_tree="OMFIT_PROFS") def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): ods["core_profiles.ids_properties.homogeneous_time"] = 1 @@ -1352,50 +1380,59 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): "electrons.temperature": "T_E", "ion[0].density": "N_D", "ion[0].temperature": "T_D", - "ion[0].velocity.toroidal": "V_TOR_C", + "ion[1].velocity.toroidal": "V_TOR_C", "ion[1].density": "N_C", "ion[1].temperature": "T_C" } uncertain_entries = list(query.keys()) query["j_total"] = "J_TOT" query["pressure_perpendicular"] = "P_TOT" - #query["e_field.radial"] = "ER_C" + # query["e_field.radial"] = "Er_12C6" query["grid.rho_tor_norm"] = "rho" normal_entries = set(query.keys()) - set(uncertain_entries) for entry in query: query[entry] = omfit_profiles_node + query[entry] for entry in uncertain_entries: - query[entry + ".data_error_upper"] = "error_of(" + query[entry] + ")" + query[entry + "_error_upper"] = "error_of(" + query[entry] + ")" data = mdsvalue('d3d', treename=PROFILES_tree, pulse=pulse, TDI=query).raw() dim_info = mdsvalue('d3d', treename=PROFILES_tree, pulse=pulse, TDI="\\TOP.n_e") data['time'] = dim_info.dim_of(1) * 1.e-3 psi_n = dim_info.dim_of(0) data['grid.rho_pol_norm'] = np.zeros((data['time'].shape + psi_n.shape)) data['grid.rho_pol_norm'][:] = np.sqrt(psi_n) - for unc in ["", ".data_error_upper"]: - data[f"ion[1].velocity.toroidal{unc}"] = data[f"ion[0].velocity.toroidal{unc}"] + # for density in densities: + # data[density] *= 1.e6 + for unc in ["", "_error_upper"]: + data[f"ion[0].velocity.toroidal{unc}"] = data[f"ion[1].velocity.toroidal{unc}"] ods["core_profiles.time"] = data['time'] sh = "core_profiles.profiles_1d" for i_time, time in enumerate(data["time"]): ods[f"{sh}[{i_time}].grid.rho_pol_norm"] = data['grid.rho_pol_norm'][i_time] - for entry in uncertain_entries: + for entry in uncertain_entries + ["ion[0].velocity.toroidal"]: + # print(entry) + for i_time, time in enumerate(data["time"]): try: + ods[f"{sh}[{i_time}]." + entry] = data[entry][i_time] + ods[f"{sh}[{i_time}]." + entry + "_error_upper"] = data[entry + "_error_upper"][i_time] + except Exception as e: print("Uncertain entry", entry) - ods[f"{sh}[{i_time}]."+entry] = unumpy.uarray( - data[entry][i_time], - data[entry + ".data_error_upper"][i_time]) - except: print("================ DATA =================") print(data[entry][i_time]) print("================ ERROR =================") - print(data[entry + ".data_error_upper"][i_time]) - for entry in normal_entries: + print(data[entry + "_error_upper"][i_time]) + print(data[entry][i_time].shape, + data[entry + "_error_upper"][i_time].shape) + print(e) + for entry in normal_entries: + # print(entry) + for i_time, time in enumerate(data["time"]): try: - print("Normal entry", entry) ods[f"{sh}[{i_time}]."+entry] = data[entry][i_time] except: + print("Normal entry", entry) print("================ DATA =================") print(data[entry][i_time]) + for i_time, time in enumerate(data["time"]): ods[f"{sh}[{i_time}].ion[0].element[0].z_n"] = 1 ods[f"{sh}[{i_time}].ion[0].element[0].a"] = 2.0141 ods[f"{sh}[{i_time}].ion[1].element[0].z_n"] = 6 @@ -1445,4 +1482,4 @@ def core_profiles_global_quantities_data(ods, pulse): # ================================ if __name__ == '__main__': - test_machine_mapping_functions(__all__, globals(), locals()) + test_machine_mapping_functions(["equilibrium_special"], globals(), locals()) diff --git a/omas/omas_machine.py b/omas/omas_machine.py index dda08e9e3..717ba8ad7 100644 --- a/omas/omas_machine.py +++ b/omas/omas_machine.py @@ -6,17 +6,16 @@ from .omas_utils import * from .omas_core import ODS, dynamic_ODS, omas_environment, omas_info_node, imas_json_dir, omas_rcparams from .omas_physics import cocos_signals +from omas.machine_mappings import d3d +from omas.utilities.machine_mapping_decorator import machine_mapping_function __all__ = [ 'machine_expression_types', 'machines', 'machine_mappings', 'load_omas_machine', - 'machine_mapping_function', 'test_machine_mapping_functions', - 'mdstree', - 'mdsvalue', - 'reload_machine_mappings', + 'reload_machine_mappings' ] machine_expression_types = ['VALUE', 'EVAL', 'ENVIRON', 'PYTHON', 'TDI', 'eval2TDI'] @@ -150,9 +149,10 @@ def machine_to_omas(ods, machine, pulse, location, options={}, branch='', user_m namespace['ods'] = ODS() namespace['__file__'] = machines(machine, branch)[:-5] + '.py' printd(f"Calling `{call}` in {os.path.basename(namespace['__file__'])}", topic='machine') - tmp = compile(call, namespace['__file__'], 'exec') - exec(tmp, namespace) - ods = namespace[mapped.get('RETURN', 'ods')] + # Add the callback for mapping updates + # By supplyinh the function to the decorator we avoid a ringinclusion + call_w_update_mapping = call[:-1] + ", update_callback=update_mapping)" + exec( machine + "." + call_w_update_mapping) if isinstance(cache, dict): cache[call] = ods if location.endswith(':'): @@ -531,65 +531,8 @@ def update_mapping(machine, location, value, cocosio=None, default_options=None, return new_raw_mappings -# =================== -# machine mapping functions -# =================== -def machine_mapping_function(__regression_arguments__, **regression_args): - """ - Decorator used to identify machine mapping functions - - :param \**regression_args: arguments used to run regression test - - NOTE: use `inspect.unwrap(function)` to call a function decorated with `@machine_mapping_function` - from another function decorated with `@machine_mapping_function` - """ - - __all__ = __regression_arguments__['__all__'] - - def machine_mapping_decorator(f, __all__): - __all__.append(f.__name__) - if __regression_arguments__ is not None: - __regression_arguments__[f.__name__] = regression_args - - @functools.wraps(f) - def machine_mapping_caller(*args, **kwargs): - clean_ods = True - if len(args[0]): - clean_ods = False - if clean_ods and omas_git_repo: - import inspect - # figure out the machine name from where the function `f` is defined - machine = os.path.splitext(os.path.split(inspect.getfile(f))[1])[0] - if machine == '': # if `f` is called via exec then we need to look at the call stack to figure out the machine name - machine = os.path.splitext(os.path.split(inspect.getframeinfo(inspect.currentframe().f_back)[0])[1])[0] - - # call signature - argspec = inspect.getfullargspec(f) - f_args_str = ", ".join('{%s!r}' % item for item in argspec.args if not item.startswith('_')) - # f_args_str = ", ".join(item + '={%s!r}' % item for item in argspec.args if not item.startswith('_')) # to use keywords arguments - call = f"{f.__qualname__}({f_args_str})".replace('{ods!r}', 'ods').replace('{pulse!r}', '{pulse}') - default_options = None - if argspec.defaults: - default_options = dict(zip(argspec.args[::-1], argspec.defaults[::-1])) - default_options = {item: value for item, value in default_options.items() if not item.startswith('_')} - - # call - out = f(*args, **kwargs) - - # update mappings definitions - if clean_ods and omas_git_repo: - for ulocation in numpy.unique(list(map(o2u, args[0].flat().keys()))): - update_mapping(machine, ulocation, {'PYTHON': call}, 11, default_options, update_path=True) - - return out - - return machine_mapping_caller - - return lambda f: machine_mapping_decorator(f, __all__) - - -def test_machine_mapping_functions(__all__, global_namespace, local_namespace): +def test_machine_mapping_functions(__all__, global_namespace, local_namespace, break_schema=False): """ Function used to test python mapping functions @@ -616,7 +559,7 @@ def test_machine_mapping_functions(__all__, global_namespace, local_namespace): print(func_name) pprint(regression_kw) print('=' * len(func_name)) - ods = ODS() + ods = ODS(consistency_check= not break_schema) func = eval(func_name, global_namespace, local_namespace) try: try: @@ -651,216 +594,6 @@ def test_machine_mapping_functions(__all__, global_namespace, local_namespace): os.environ['OMAS_DEBUG_TOPIC'] = old_OMAS_DEBUG_TOPIC -# =================== -# MDS+ functions -# =================== -def tunnel_mds(server, treename): - """ - Resolve MDS+ server - NOTE: This function makes use of the optional `omfit_classes` dependency to establish a SSH tunnel to the MDS+ server. - - :param server: MDS+ server address:port - - :param treename: treename (in case treename affects server to be used) - - :return: string with MDS+ server and port to be used - """ - try: - import omfit_classes.omfit_mds - except (ImportError, ModuleNotFoundError): - return server.format(**os.environ) - else: - server0 = omfit_classes.omfit_mds.translate_MDSserver(server, treename) - tunneled_server = omfit_classes.omfit_mds.tunneled_MDSserver(server0, quiet=False) - return tunneled_server - - return server.format(**os.environ) - - -_mds_connection_cache = {} - - -class mdstree(dict): - """ - Class to handle the structure of an MDS+ tree. - Nodes in this tree are mdsvalue objects - """ - - def __init__(self, server, treename, pulse): - for TDI in sorted(mdsvalue(server, treename, pulse, rf'getnci("***","FULLPATH")').raw())[::-1]: - try: - TDI = TDI.decode('utf8') - except AttributeError: - pass - TDI = TDI.strip() - path = TDI.replace('::TOP', '').lstrip('\\').replace(':', '.').split('.') - h = self - for p in path[1:-1]: - h = h.setdefault(p, mdsvalue(server, treename, pulse, '')) - if path[-1] not in h: - h[path[-1]] = mdsvalue(server, treename, pulse, TDI) - else: - h[path[-1]].TDI = TDI - - -class mdsvalue(dict): - """ - Execute MDS+ TDI functions - """ - - def __init__(self, server, treename, pulse, TDI, old_MDS_server=False): - self.treename = treename - self.pulse = pulse - self.TDI = TDI - if 'nstx' in server: - old_MDS_server = True - try: - # handle the case that server is just the machine name - tmp = machine_mappings(server, '') - except NotImplementedError: - # hanlde case where server is actually a URL - if '.' not in server: - raise - else: - if '__mdsserver__' not in tmp or not len(tmp['__mdsserver__']): - raise Exception(f'Must specify `__mdsserver__` for {server}') - else: - server = tmp['__mdsserver__'] - self.server = tunnel_mds(server, self.treename) - old_servers = ['skylark.pppl.gov:8500', 'skylark.pppl.gov:8501', 'skylark.pppl.gov:8000'] - if server in old_servers or self.server in old_servers: - old_MDS_server = True - self.old_MDS_server = old_MDS_server - - def data(self): - return self.raw(f'data({self.TDI})') - - def dim_of(self, dim): - return self.raw(f'dim_of({self.TDI},{dim})') - - def units(self): - return self.raw(f'units({self.TDI})') - - def error(self): - return self.raw(f'error({self.TDI})') - - def error_dim_of(self, dim): - return self.raw(f'error_dim_of({self.TDI},{dim})') - - def units_dim_of(self, dim): - return self.raw(f'units_dim_of({self.TDI},{dim})') - - def size(self, dim): - return self.raw(f'size({self.TDI})') - - def raw(self, TDI=None): - """ - Fetch data from MDS+ with connection caching - - :param TDI: string, list or dict of strings - MDS+ TDI expression(s) (overrides the one passed when the object was instantiated) - - :return: result of TDI expression, or dictionary with results of TDI expressions - """ - try: - import time - - t0 = time.time() - import MDSplus - - def mdsk(value): - """ - Translate strings to MDS+ bytes - """ - return str(str(value).encode('utf8')) - - if TDI is None: - TDI = self.TDI - - try: - out_results = None - - # try connecting and re-try on fail - for fallback in [0, 1]: - if (self.server, self.treename, self.pulse) not in _mds_connection_cache: - conn = MDSplus.Connection(self.server) - if self.treename is not None: - conn.openTree(self.treename, self.pulse) - _mds_connection_cache[(self.server, self.treename, self.pulse)] = conn - try: - conn = _mds_connection_cache[(self.server, self.treename, self.pulse)] - break - except Exception as _excp: - if (self.server, self.treename, self.pulse) in _mds_connection_cache: - del _mds_connection_cache[(self.server, self.treename, self.pulse)] - if fallback: - raise - - # list of TDI expressions - if isinstance(TDI, (list, tuple)): - TDI = {expr: expr for expr in TDI} - - # dictionary of TDI expressions - if isinstance(TDI, dict): - # old versions of MDS+ server do not support getMany - if self.old_MDS_server: - results = {} - for tdi in TDI: - try: - results[tdi] = mdsvalue(self.server, self.treename, self.pulse, TDI[tdi]).raw() - except Exception as _excp: - results[tdi] = Exception(str(_excp)) - out_results = results - - # more recent MDS+ server - else: - conns = conn.getMany() - for name, expr in TDI.items(): - conns.append(name, expr) - res = conns.execute() - results = {} - for name, expr in TDI.items(): - try: - results[name] = MDSplus.Data.data(res[mdsk(name)][mdsk('value')]) - except KeyError: - try: - results[name] = MDSplus.Data.data(res[str(name)][str('value')]) - except KeyError: - try: - results[name] = Exception(MDSplus.Data.data(res[mdsk(name)][mdsk('error')])) - except KeyError: - results[name] = Exception(MDSplus.Data.data(res[str(name)][str('error')])) - out_results = results - - # single TDI expression - else: - out_results = MDSplus.Data.data(conn.get(TDI)) - - # return values - return out_results - - except Exception as _excp: - txt = [] - for item in ['server', 'treename', 'pulse']: - txt += [f' - {item}: {getattr(self, item)}'] - txt += [f' - TDI: {TDI}'] - raise _excp.__class__(str(_excp) + '\n' + '\n'.join(txt)) - - finally: - if out_results is not None: - if isinstance(out_results, dict): - if all(isinstance(out_results[k], Exception) for k in out_results): - printd(f'{TDI} \tall NO\t {time.time() - t0:3.3f} secs', topic='machine') - elif any(isinstance(out_results[k], Exception) for k in out_results): - printd(f'{TDI} \tsome OK/NO\t {time.time() - t0:3.3f} secs', topic='machine') - else: - printd(f'{TDI} \tall OK\t {time.time() - t0:3.3f} secs', topic='machine') - else: - printd(f'{TDI} \tOK\t {time.time() - t0:3.3f} secs', topic='machine') - else: - printd(f'{TDI} \tNO\t {time.time() - t0:3.3f} secs', topic='machine') - - # =================== # Loading machine data in ODSs # =================== diff --git a/omas/omas_physics.py b/omas/omas_physics.py index 7ff00c406..529b849cb 100644 --- a/omas/omas_physics.py +++ b/omas/omas_physics.py @@ -2493,6 +2493,24 @@ def search_in_array_structure(ods, conditions, no_matches_return=0, no_matches_r return match +@add_to__ALL__ +def get_plot_scale_and_unit(phys_quant): + """ + Returns normalizing scale for a physical quantity. + E.g. "temprerature" returns 1.e-3 and keV + :param phys_qaunt: str with a physical quantity. Uses IMAS scheme names where possible + :return: scale, unit + """ + print(phys_quant) + if "temperature" in phys_quant: + return 1.e-3, r"\mathrm{keV}" + elif "density" in phys_quant : + return 1.e-19, r"\times 10^{19}\,\mathrm{m}^{-3}" + elif "velocity" in phys_quant: + return 1.e-6, r"\mathrm{Mm}\,\mathrm{s}^{-1}" + elif "e_field" in phys_quant: + return 1.e-3, r"\mathrm{kV}\,\mathrm{m}^{-1}" + @add_to__ALL__ def define_cocos(cocos_ind): diff --git a/omas/omas_plot.py b/omas/omas_plot.py index ca1456371..8e62821c8 100644 --- a/omas/omas_plot.py +++ b/omas/omas_plot.py @@ -1008,22 +1008,26 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr x = eq['profiles_1d'][raw_xName] else: raw_xName = 'psi' - x = eq['profiles_1d']['psi_norm'] - x = (x - min(x)) / (max(x) - min(x)) + x = ((eq['profiles_1d']['psi'] - eq['global_quantities']['psi_axis']) + / ( eq['global_quantities']['psi_boundary'] - eq['global_quantities']['psi_axis'])) xName = nice_names.get(raw_xName, raw_xName) # pressure ax = cached_add_subplot(fig, axs, 2, 3, 2) + if omas_viewer: + ax.plot(-ods[f"equilibrium.code.parameters.time_slice.{time_index}.in1.rpress"], + ods[f"equilibrium.code.parameters.time_slice.{time_index}.in1.pressr"]/1.e3, ".r") plot_1d_equilbrium_quantity(ax, x, eq['profiles_1d']['pressure'] * 1.e-3, xName, r"$p$ [kPa]", r'$\,$ Pressure', visible_x=omas_viewer, **kw) kw.setdefault('color', ax.lines[-1].get_color()) + # q if omas_viewer: ax = cached_add_subplot(fig, axs, 2, 3, 5, sharex=ax) else: ax = cached_add_subplot(fig, axs, 2, 3, 3, sharex=ax) - plot_1d_equilbrium_quantity(ax, x, eq['profiles_1d']['q'], + plot_1d_equilbrium_quantity(ax, x, numpy.abs(eq['profiles_1d']['q']), xName, r'$q$ Safety factor', r'$q$ Safety factor', visible_x=omas_viewer, **kw) #ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') @@ -1039,11 +1043,12 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr pyplot.setp(ax.get_xticklabels(), visible=False) if omas_viewer: ax = cached_add_subplot(fig, axs, 2, 3, 3, sharex=ax) - # j_tor,j_parallel have no data - # ax.plot(x, eq['profiles_1d']['j_parallel'], **kw) - ax.set_title(r"$j_\mathrm{tor}$") - # ax.ticklabel_format(style='sci', scilimits=(-1, 2), axis='y') - # pyplot.xlabel(xName) + ax.plot(ods[f"equilibrium.code.parameters.time_slice.{time_index}.inwant.sizeroj"], + ods[f"equilibrium.code.parameters.time_slice.{time_index}.inwant.vzeroj"] / 1.e6, ".r") + plot_1d_equilbrium_quantity(ax, x, eq['profiles_1d']['j_tor']/1.e6, + xName, r"$\langle j_\mathrm{tor} / R \rangle$ [MA m$^{-2}$]", + r"$j_\mathrm{tor}$", + visible_x=omas_viewer, **kw) else: ax = cached_add_subplot(fig, axs, 2, 3, 5, sharex=ax) plot_1d_equilbrium_quantity(ax, x, eq['profiles_1d']['dpressure_dpsi'] * 1.e-3, @@ -1052,16 +1057,39 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr visible_x=True, **kw) if raw_xName.endswith('norm'): ax.set_xlim([0, 1]) - ax = cached_add_subplot(fig, axs, 2, 3, 6, sharex=ax) if omas_viewer: + ax = cached_add_subplot(fig, axs, 2, 3, 6) ax = cached_add_subplot(fig, axs, 2, 3, 6) # ax.plot(eq['profiles_1d']['convergence']['iteration'], # eq['profiles_1d']['convergence']['grad_shafranov_deviation_value'], **kw) - ax.set_title(r"$\chi^2$ convergence") - - ax.set_xlabel(r"Flux loop \#") - ax.set_ylabel(r"Residiaul [std. dev.]") + diag_chi_2 = [] + labels = [] + try: + diag_chi_2.append(eq[f'constraints.pf_current[:].chi_squared']) + for i in range(len(diag_chi_2)): + labels.append("PF coil " + ods[f'pf_active.coil[[{i}].identifier']) + except: + printd("Failed to find pf_active chi^2. Skipping pf_active in chi^2 plot.") + for constraint, imas_mangetics_id, nice_label in zip(["flux_loop", "bpol_probe"], + ["flux_loop", "b_field_pol_probe"], + ["Flux loop ", r"$B_\mathrm{pol}$ Probe "]): + chi_2 = list(eq[f'constraints.{constraint}[:].chi_squared']) + for i in range(len(chi_2)): + labels.append(nice_label + ods[f'magnetics.{imas_mangetics_id}[{i}].identifier']) + diag_chi_2 += chi_2 + indices = numpy.array(range(len(diag_chi_2))) + 1 + plot_1d_equilbrium_quantity(ax, indices, diag_chi_2, + r"Diagnostic #", r"$\chi^2$ convergence", + r"Magnetics $\chi^2$", + visible_x=True, marker="+", linestyle='', **kw) + for i_label, label in enumerate(labels): + annot = ax.annotate(label, xy=(indices[i_label],diag_chi_2[i_label]), + xytext=(20,20),textcoords="offset points", + bbox=dict(boxstyle="round", fc="w"), + arrowprops=dict(arrowstyle="->")) + annot.set_visible(False) else: + ax = cached_add_subplot(fig, axs, 2, 3, 6, sharex=ax) ax = cached_add_subplot(fig, axs, 2, 3, 6, sharex=ax) # FdF_dpsi plot_1d_equilbrium_quantity(ax, x, eq['profiles_1d']['f_df_dpsi'], @@ -1124,7 +1152,8 @@ def core_profiles_currents_summary(ods, time_index=None, time=None, ax=None, **k @add_to__ODS__ -def core_profiles_summary(ods, time_index=None, time=None, fig=None, ods_species=None, quantities=['density_thermal', 'temperature'], **kw): +def core_profiles_summary(ods, time_index=None, time=None, fig=None, + ods_species=None, quantities=['density_thermal', 'temperature'], **kw): """ Plot densities and temperature profiles for electrons and all ion species as per `ods['core_profiles']['profiles_1d'][time_index]` @@ -1151,7 +1180,7 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, ods_species """ from matplotlib import pyplot - + from omas.omas_physics import get_plot_scale_and_unit axs = kw.pop('ax', {}) if axs is None: axs = {} @@ -1190,20 +1219,26 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, ods_species label_name_z = [] unit_list = [] for q in quantities: - if 'density' in q or 'temperature' in q: + if 'density' in q or 'temperature' in q or "velocity.toroidal" in q or "e_field.radial" in q: for index, specie in enumerate(species_in_tree): - unit_list.append(omas_info_node(o2u(f"core_profiles.profiles_1d.0.{specie}.{q}"))['units']) + #unit_list.append(omas_info_node(o2u(f"core_profiles.profiles_1d.0.{specie}.{q}"))['units']) + scale, unit = get_plot_scale_and_unit(q) + unit_list.append(unit) if q in prof1d[specie]: - if 'density' in q and 'ion' in specie and prof1d[specie]['element[0].z_n'] != 1.0: - plotting_list.append(prof1d[specie][q] * prof1d[specie]['element[0].z_n']) - label_name_z.append(r'$\times$' + f" {int(prof1d[specie]['element[0].z_n'])}") + # if 'density' in q and 'ion' in specie and prof1d[specie]['element[0].z_n'] != 1.0: + # plotting_list.append(prof1d[specie][q]*scale * prof1d[specie]['element[0].z_n']) + # label_name_z.append(r'$\times$' + f" {int(prof1d[specie]['element[0].z_n'])}") + # else: + if len(prof1d[specie][q]) == len(prof1d[specie][q + "_error_upper"]): + plotting_list.append(unumpy.uarray(prof1d[specie][q]*scale, + prof1d[specie][q + "_error_upper"]*scale)) else: - plotting_list.append(prof1d[specie][q]) - label_name_z.append("") + plotting_list.append(prof1d[specie][q]*scale) + label_name_z.append("") label_name.append(f'{names[index]} {q.capitalize()}') - else: - plotting_list.append(numpy.zeros(len(rho))) + # else: + # plotting_list.append(numpy.zeros(len(rho))) else: unit_list.append(omas_info_node(o2u(f"core_profiles.profiles_1d.0.{q}"))['units']) @@ -1211,14 +1246,27 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, ods_species label_name.append(q.capitalize()) for index, y in enumerate(plotting_list): + if index >= len(label_name): + break plot = index + 1 - if index % ncols == 0: + # if index % ncols == 0: + # sharey = None + # sharex = None + # el + if index == 0: sharey = None sharex = None - elif 'Density' in label_name[index] or 'Temperature' in label_name[index]: - sharey = ax - sharex = ax + try: + if 'Density' in label_name[index] or 'Temperature' in label_name[index]: + sharex = ax + sharey = ax + elif "Velocity" in label_name[index]: + sharex = ax + sharey = None + except: + sharex = None + sharey = None ax = cached_add_subplot(fig, axs, nrows, ncols, plot, sharex=sharex, sharey=sharey) uband(rho, y, ax=ax, **kw) @@ -1232,8 +1280,8 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, ods_species ax.set_xlabel('$\\rho$') if 'label' in kw: ax.legend(loc='lower center') - ax.set_xlim([0, 1]) - + ax.set_xlim(0, 1) + fig.tight_layout() return {'ax': axs, 'fig': fig} diff --git a/omas/utilities/machine_mapping_decorator.py b/omas/utilities/machine_mapping_decorator.py new file mode 100644 index 000000000..9ee4ae395 --- /dev/null +++ b/omas/utilities/machine_mapping_decorator.py @@ -0,0 +1,66 @@ +from omas.omas_setup import omas_git_repo +import os +import functools +import numpy +from omas.omas_core import o2u +__all__ = [ + 'machine_mapping_function' +] + + +# =================== +# machine mapping functions +# =================== +def machine_mapping_function(__regression_arguments__, **regression_args): + """ + Decorator used to identify machine mapping functions + + :param \**regression_args: arguments used to run regression test + + NOTE: use `inspect.unwrap(function)` to call a function decorated with `@machine_mapping_function` + from another function decorated with `@machine_mapping_function` + """ + + __all__ = __regression_arguments__['__all__'] + + def machine_mapping_decorator(f, __all__): + __all__.append(f.__name__) + if __regression_arguments__ is not None: + __regression_arguments__[f.__name__] = regression_args + + @functools.wraps(f) + def machine_mapping_caller(*args, **kwargs): + clean_ods = True + if len(args[0]): + clean_ods = False + if clean_ods and omas_git_repo: + import inspect + + # figure out the machine name from where the function `f` is defined + machine = os.path.splitext(os.path.split(inspect.getfile(f))[1])[0] + if machine == '': # if `f` is called via exec then we need to look at the call stack to figure out the machine name + machine = os.path.splitext(os.path.split(inspect.getframeinfo(inspect.currentframe().f_back)[0])[1])[0] + + # call signature + argspec = inspect.getfullargspec(f) + f_args_str = ", ".join('{%s!r}' % item for item in argspec.args if not item.startswith('_')) + # f_args_str = ", ".join(item + '={%s!r}' % item for item in argspec.args if not item.startswith('_')) # to use keywords arguments + call = f"{f.__qualname__}({f_args_str})".replace('{ods!r}', 'ods').replace('{pulse!r}', '{pulse}') + default_options = None + if argspec.defaults: + default_options = dict(zip(argspec.args[::-1], argspec.defaults[::-1])) + default_options = {item: value for item, value in default_options.items() if not item.startswith('_')} + + # call + update_mapping = kwargs.pop("update_callback") + out = f(*args, **kwargs) + #update mappings definitions + if clean_ods and omas_git_repo: + for ulocation in numpy.unique(list(map(o2u, args[0].flat().keys()))): + update_mapping(machine, ulocation, {'PYTHON': call}, 11, default_options, update_path=True) + + return out + + return machine_mapping_caller + + return lambda f: machine_mapping_decorator(f, __all__) diff --git a/omas/utilities/omas_mds.py b/omas/utilities/omas_mds.py new file mode 100644 index 000000000..65ed58ae4 --- /dev/null +++ b/omas/utilities/omas_mds.py @@ -0,0 +1,215 @@ +import json +import os +from omas.omas_utils import printd + +__all__ = [ + 'mdstree', + 'mdsvalue' +] + +_mds_connection_cache = {} + +# =================== +# MDS+ functions +# =================== +def tunnel_mds(server, treename): + """ + Resolve MDS+ server + NOTE: This function makes use of the optional `omfit_classes` dependency to establish a SSH tunnel to the MDS+ server. + + :param server: MDS+ server address:port + + :param treename: treename (in case treename affects server to be used) + + :return: string with MDS+ server and port to be used + """ + try: + import omfit_classes.omfit_mds + except (ImportError, ModuleNotFoundError): + return server.format(**os.environ) + else: + server0 = omfit_classes.omfit_mds.translate_MDSserver(server, treename) + tunneled_server = omfit_classes.omfit_mds.tunneled_MDSserver(server0, quiet=False) + return tunneled_server + + return server.format(**os.environ) + + + + + +class mdsvalue(dict): + """ + Execute MDS+ TDI functions + """ + + def __init__(self, server, treename, pulse, TDI, old_MDS_server=False): + self.treename = treename + self.pulse = pulse + self.TDI = TDI + if 'nstx' in server: + old_MDS_server = True + try: + # handle the case that server is just the machine name + machine_mappings_path = os.path.join(os.path.dirname(__file__), "../", "machine_mappings") + machine_mappings_path = os.path.join(machine_mappings_path, server + ".json") + with open(machine_mappings_path, "r") as machine_file: + server = json.load(machine_file)["__mdsserver__"] + except Exception: + # hanlde case where server is actually a URL + if '.' not in server: + raise + self.server = tunnel_mds(server, self.treename) + old_servers = ['skylark.pppl.gov:8500', 'skylark.pppl.gov:8501', 'skylark.pppl.gov:8000'] + if server in old_servers or self.server in old_servers: + old_MDS_server = True + self.old_MDS_server = old_MDS_server + + def data(self): + return self.raw(f'data({self.TDI})') + + def dim_of(self, dim): + return self.raw(f'dim_of({self.TDI},{dim})') + + def units(self): + return self.raw(f'units({self.TDI})') + + def error(self): + return self.raw(f'error({self.TDI})') + + def error_dim_of(self, dim): + return self.raw(f'error_dim_of({self.TDI},{dim})') + + def units_dim_of(self, dim): + return self.raw(f'units_dim_of({self.TDI},{dim})') + + def size(self, dim): + return self.raw(f'size({self.TDI})') + + def raw(self, TDI=None): + """ + Fetch data from MDS+ with connection caching + + :param TDI: string, list or dict of strings + MDS+ TDI expression(s) (overrides the one passed when the object was instantiated) + + :return: result of TDI expression, or dictionary with results of TDI expressions + """ + try: + import time + + t0 = time.time() + import MDSplus + + def mdsk(value): + """ + Translate strings to MDS+ bytes + """ + return str(str(value).encode('utf8')) + + if TDI is None: + TDI = self.TDI + + try: + out_results = None + + # try connecting and re-try on fail + for fallback in [0, 1]: + if (self.server, self.treename, self.pulse) not in _mds_connection_cache: + conn = MDSplus.Connection(self.server) + if self.treename is not None: + conn.openTree(self.treename, self.pulse) + _mds_connection_cache[(self.server, self.treename, self.pulse)] = conn + try: + conn = _mds_connection_cache[(self.server, self.treename, self.pulse)] + break + except Exception as _excp: + if (self.server, self.treename, self.pulse) in _mds_connection_cache: + del _mds_connection_cache[(self.server, self.treename, self.pulse)] + if fallback: + raise + + # list of TDI expressions + if isinstance(TDI, (list, tuple)): + TDI = {expr: expr for expr in TDI} + + # dictionary of TDI expressions + if isinstance(TDI, dict): + # old versions of MDS+ server do not support getMany + if self.old_MDS_server: + results = {} + for tdi in TDI: + try: + results[tdi] = mdsvalue(self.server, self.treename, self.pulse, TDI[tdi]).raw() + except Exception as _excp: + results[tdi] = Exception(str(_excp)) + out_results = results + + # more recent MDS+ server + else: + conns = conn.getMany() + for name, expr in TDI.items(): + conns.append(name, expr) + res = conns.execute() + results = {} + for name, expr in TDI.items(): + try: + results[name] = MDSplus.Data.data(res[mdsk(name)][mdsk('value')]) + except KeyError: + try: + results[name] = MDSplus.Data.data(res[str(name)][str('value')]) + except KeyError: + try: + results[name] = Exception(MDSplus.Data.data(res[mdsk(name)][mdsk('error')])) + except KeyError: + results[name] = Exception(MDSplus.Data.data(res[str(name)][str('error')])) + out_results = results + + # single TDI expression + else: + out_results = MDSplus.Data.data(conn.get(TDI)) + + # return values + return out_results + + except Exception as _excp: + txt = [] + for item in ['server', 'treename', 'pulse']: + txt += [f' - {item}: {getattr(self, item)}'] + txt += [f' - TDI: {TDI}'] + + finally: + if out_results is not None: + if isinstance(out_results, dict): + if all(isinstance(out_results[k], Exception) for k in out_results): + printd(f'{TDI} \tall NO\t {time.time() - t0:3.3f} secs', topic='machine') + elif any(isinstance(out_results[k], Exception) for k in out_results): + printd(f'{TDI} \tsome OK/NO\t {time.time() - t0:3.3f} secs', topic='machine') + else: + printd(f'{TDI} \tall OK\t {time.time() - t0:3.3f} secs', topic='machine') + else: + printd(f'{TDI} \tOK\t {time.time() - t0:3.3f} secs', topic='machine') + else: + printd(f'{TDI} \tNO\t {time.time() - t0:3.3f} secs', topic='machine') + +class mdstree(dict): + """ + Class to handle the structure of an MDS+ tree. + Nodes in this tree are mdsvalue objects + """ + + def __init__(self, server, treename, pulse): + for TDI in sorted(mdsvalue(server, treename, pulse, rf'getnci("***","FULLPATH")').raw())[::-1]: + try: + TDI = TDI.decode('utf8') + except AttributeError: + pass + TDI = TDI.strip() + path = TDI.replace('::TOP', '').lstrip('\\').replace(':', '.').split('.') + h = self + for p in path[1:-1]: + h = h.setdefault(p, mdsvalue(server, treename, pulse, '')) + if path[-1] not in h: + h[path[-1]] = mdsvalue(server, treename, pulse, TDI) + else: + h[path[-1]].TDI = TDI \ No newline at end of file From 80cf9bb7f20b143c46dace992e2251e9dc0f434b Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Thu, 23 Mar 2023 08:40:31 -0700 Subject: [PATCH 11/26] Refactored omas_machine to remove ringinclusion - Moved functions needed by mappings to seprate file - Moved the machine mapping decorator to a utilities file - Moved MDS+ related routines into their own file - Added extra argument to pass `update_mapping` as an argument - Removed `compile` statement as it was causing trouble for the debugger --- omas/machine_mappings/_common.py | 1 + omas/machine_mappings/d3d.py | 4 + omas/omas_machine.py | 282 +------------------- omas/utilities/machine_mapping_decorator.py | 66 +++++ omas/utilities/omas_mds.py | 215 +++++++++++++++ 5 files changed, 293 insertions(+), 275 deletions(-) create mode 100644 omas/utilities/machine_mapping_decorator.py create mode 100644 omas/utilities/omas_mds.py diff --git a/omas/machine_mappings/_common.py b/omas/machine_mappings/_common.py index 572f671e9..b42b3a476 100644 --- a/omas/machine_mappings/_common.py +++ b/omas/machine_mappings/_common.py @@ -3,6 +3,7 @@ from omas.omas_utils import printd import os import glob +from omas.omas_setup import omas_dir __support_files_cache__ = {} diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index 4ece501bf..9cca288e9 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -6,6 +6,10 @@ from omas import * from omas.omas_utils import printd, printe, unumpy from omas.machine_mappings._common import * +from uncertainties import unumpy +from omas.utilities.machine_mapping_decorator import machine_mapping_function +from omas.utilities.omas_mds import mdsvalue +from omas.omas_core import ODS __all__ = [] __regression_arguments__ = {'__all__': __all__} diff --git a/omas/omas_machine.py b/omas/omas_machine.py index 2a6d1cb44..291fd704a 100644 --- a/omas/omas_machine.py +++ b/omas/omas_machine.py @@ -6,17 +6,16 @@ from .omas_utils import * from .omas_core import ODS, dynamic_ODS, omas_environment, omas_info_node, imas_json_dir, omas_rcparams from .omas_physics import cocos_signals +from omas.machine_mappings import d3d +from omas.utilities.machine_mapping_decorator import machine_mapping_function __all__ = [ 'machine_expression_types', 'machines', 'machine_mappings', 'load_omas_machine', - 'machine_mapping_function', 'test_machine_mapping_functions', - 'mdstree', - 'mdsvalue', - 'reload_machine_mappings', + 'reload_machine_mappings' ] machine_expression_types = ['VALUE', 'EVAL', 'ENVIRON', 'PYTHON', 'TDI', 'eval2TDI'] @@ -153,9 +152,10 @@ def machine_to_omas(ods, machine, pulse, location, options={}, branch='', user_m namespace['ods'] = ODS() namespace['__file__'] = machines(machine, branch)[:-5] + '.py' printd(f"Calling `{call}` in {os.path.basename(namespace['__file__'])}", topic='machine') - tmp = compile(call, namespace['__file__'], 'exec') - exec(tmp, namespace) - ods = namespace[mapped.get('RETURN', 'ods')] + # Add the callback for mapping updates + # By supplyinh the function to the decorator we avoid a ringinclusion + call_w_update_mapping = call[:-1] + ", update_callback=update_mapping)" + exec( machine + "." + call_w_update_mapping) if isinstance(cache, dict): cache[call] = ods if location.endswith(':'): @@ -534,63 +534,6 @@ def update_mapping(machine, location, value, cocosio=None, default_options=None, return new_raw_mappings -# =================== -# machine mapping functions -# =================== -def machine_mapping_function(__regression_arguments__, **regression_args): - """ - Decorator used to identify machine mapping functions - - :param \**regression_args: arguments used to run regression test - - NOTE: use `inspect.unwrap(function)` to call a function decorated with `@machine_mapping_function` - from another function decorated with `@machine_mapping_function` - """ - - __all__ = __regression_arguments__['__all__'] - - def machine_mapping_decorator(f, __all__): - __all__.append(f.__name__) - if __regression_arguments__ is not None: - __regression_arguments__[f.__name__] = regression_args - - @functools.wraps(f) - def machine_mapping_caller(*args, **kwargs): - clean_ods = True - if len(args[0]): - clean_ods = False - if clean_ods and omas_git_repo: - import inspect - - # figure out the machine name from where the function `f` is defined - machine = os.path.splitext(os.path.split(inspect.getfile(f))[1])[0] - if machine == '': # if `f` is called via exec then we need to look at the call stack to figure out the machine name - machine = os.path.splitext(os.path.split(inspect.getframeinfo(inspect.currentframe().f_back)[0])[1])[0] - - # call signature - argspec = inspect.getfullargspec(f) - f_args_str = ", ".join('{%s!r}' % item for item in argspec.args if not item.startswith('_')) - # f_args_str = ", ".join(item + '={%s!r}' % item for item in argspec.args if not item.startswith('_')) # to use keywords arguments - call = f"{f.__qualname__}({f_args_str})".replace('{ods!r}', 'ods').replace('{pulse!r}', '{pulse}') - default_options = None - if argspec.defaults: - default_options = dict(zip(argspec.args[::-1], argspec.defaults[::-1])) - default_options = {item: value for item, value in default_options.items() if not item.startswith('_')} - - # call - out = f(*args, **kwargs) - - # update mappings definitions - if clean_ods and omas_git_repo: - for ulocation in numpy.unique(list(map(o2u, args[0].flat().keys()))): - update_mapping(machine, ulocation, {'PYTHON': call}, 11, default_options, update_path=True) - - return out - - return machine_mapping_caller - - return lambda f: machine_mapping_decorator(f, __all__) - def test_machine_mapping_functions(__all__, global_namespace, local_namespace): """ @@ -654,217 +597,6 @@ def test_machine_mapping_functions(__all__, global_namespace, local_namespace): os.environ['OMAS_DEBUG_TOPIC'] = old_OMAS_DEBUG_TOPIC -# =================== -# MDS+ functions -# =================== -def tunnel_mds(server, treename): - """ - Resolve MDS+ server - NOTE: This function makes use of the optional `omfit_classes` dependency to establish a SSH tunnel to the MDS+ server. - - :param server: MDS+ server address:port - - :param treename: treename (in case treename affects server to be used) - - :return: string with MDS+ server and port to be used - """ - try: - import omfit_classes.omfit_mds - except (ImportError, ModuleNotFoundError): - return server.format(**os.environ) - else: - server0 = omfit_classes.omfit_mds.translate_MDSserver(server, treename) - tunneled_server = omfit_classes.omfit_mds.tunneled_MDSserver(server0, quiet=False) - return tunneled_server - - return server.format(**os.environ) - - -_mds_connection_cache = {} - - -class mdstree(dict): - """ - Class to handle the structure of an MDS+ tree. - Nodes in this tree are mdsvalue objects - """ - - def __init__(self, server, treename, pulse): - pulse = int(pulse) - for TDI in sorted(mdsvalue(server, treename, pulse, rf'getnci("***","FULLPATH")').raw())[::-1]: - try: - TDI = TDI.decode('utf8') - except AttributeError: - pass - TDI = TDI.strip() - path = TDI.replace('::TOP', '').lstrip('\\').replace(':', '.').split('.') - h = self - for p in path[1:-1]: - h = h.setdefault(p, mdsvalue(server, treename, pulse, '')) - if path[-1] not in h: - h[path[-1]] = mdsvalue(server, treename, pulse, TDI) - else: - h[path[-1]].TDI = TDI - - -class mdsvalue(dict): - """ - Execute MDS+ TDI functions - """ - - def __init__(self, server, treename, pulse, TDI, old_MDS_server=False): - self.treename = treename - self.pulse = int(pulse) - self.TDI = TDI - if 'nstx' in server: - old_MDS_server = True - try: - # handle the case that server is just the machine name - tmp = machine_mappings(server, '') - except NotImplementedError: - # hanlde case where server is actually a URL - if '.' not in server: - raise - else: - if '__mdsserver__' not in tmp or not len(tmp['__mdsserver__']): - raise Exception(f'Must specify `__mdsserver__` for {server}') - else: - server = tmp['__mdsserver__'] - self.server = tunnel_mds(server, self.treename) - old_servers = ['skylark.pppl.gov:8500', 'skylark.pppl.gov:8501', 'skylark.pppl.gov:8000'] - if server in old_servers or self.server in old_servers: - old_MDS_server = True - self.old_MDS_server = old_MDS_server - - def data(self): - return self.raw(f'data({self.TDI})') - - def dim_of(self, dim): - return self.raw(f'dim_of({self.TDI},{dim})') - - def units(self): - return self.raw(f'units({self.TDI})') - - def error(self): - return self.raw(f'error({self.TDI})') - - def error_dim_of(self, dim): - return self.raw(f'error_dim_of({self.TDI},{dim})') - - def units_dim_of(self, dim): - return self.raw(f'units_dim_of({self.TDI},{dim})') - - def size(self, dim): - return self.raw(f'size({self.TDI})') - - def raw(self, TDI=None): - """ - Fetch data from MDS+ with connection caching - - :param TDI: string, list or dict of strings - MDS+ TDI expression(s) (overrides the one passed when the object was instantiated) - - :return: result of TDI expression, or dictionary with results of TDI expressions - """ - try: - import time - - t0 = time.time() - import MDSplus - - def mdsk(value): - """ - Translate strings to MDS+ bytes - """ - return str(str(value).encode('utf8')) - - if TDI is None: - TDI = self.TDI - - try: - out_results = None - - # try connecting and re-try on fail - for fallback in [0, 1]: - if (self.server, self.treename, self.pulse) not in _mds_connection_cache: - conn = MDSplus.Connection(self.server) - if self.treename is not None: - conn.openTree(self.treename, self.pulse) - _mds_connection_cache[(self.server, self.treename, self.pulse)] = conn - try: - conn = _mds_connection_cache[(self.server, self.treename, self.pulse)] - break - except Exception as _excp: - if (self.server, self.treename, self.pulse) in _mds_connection_cache: - del _mds_connection_cache[(self.server, self.treename, self.pulse)] - if fallback: - raise - - # list of TDI expressions - if isinstance(TDI, (list, tuple)): - TDI = {expr: expr for expr in TDI} - - # dictionary of TDI expressions - if isinstance(TDI, dict): - # old versions of MDS+ server do not support getMany - if self.old_MDS_server: - results = {} - for tdi in TDI: - try: - results[tdi] = mdsvalue(self.server, self.treename, self.pulse, TDI[tdi]).raw() - except Exception as _excp: - results[tdi] = Exception(str(_excp)) - out_results = results - - # more recent MDS+ server - else: - conns = conn.getMany() - for name, expr in TDI.items(): - conns.append(name, expr) - res = conns.execute() - results = {} - for name, expr in TDI.items(): - try: - results[name] = MDSplus.Data.data(res[mdsk(name)][mdsk('value')]) - except KeyError: - try: - results[name] = MDSplus.Data.data(res[str(name)][str('value')]) - except KeyError: - try: - results[name] = Exception(MDSplus.Data.data(res[mdsk(name)][mdsk('error')])) - except KeyError: - results[name] = Exception(MDSplus.Data.data(res[str(name)][str('error')])) - out_results = results - - # single TDI expression - else: - out_results = MDSplus.Data.data(conn.get(TDI)) - - # return values - return out_results - - except Exception as _excp: - txt = [] - for item in ['server', 'treename', 'pulse']: - txt += [f' - {item}: {getattr(self, item)}'] - txt += [f' - TDI: {TDI}'] - raise _excp.__class__(str(_excp) + '\n' + '\n'.join(txt)) - - finally: - if out_results is not None: - if isinstance(out_results, dict): - if all(isinstance(out_results[k], Exception) for k in out_results): - printd(f'{TDI} \tall NO\t {time.time() - t0:3.3f} secs', topic='machine') - elif any(isinstance(out_results[k], Exception) for k in out_results): - printd(f'{TDI} \tsome OK/NO\t {time.time() - t0:3.3f} secs', topic='machine') - else: - printd(f'{TDI} \tall OK\t {time.time() - t0:3.3f} secs', topic='machine') - else: - printd(f'{TDI} \tOK\t {time.time() - t0:3.3f} secs', topic='machine') - else: - printd(f'{TDI} \tNO\t {time.time() - t0:3.3f} secs', topic='machine') - - # =================== # Loading machine data in ODSs # =================== diff --git a/omas/utilities/machine_mapping_decorator.py b/omas/utilities/machine_mapping_decorator.py new file mode 100644 index 000000000..9ee4ae395 --- /dev/null +++ b/omas/utilities/machine_mapping_decorator.py @@ -0,0 +1,66 @@ +from omas.omas_setup import omas_git_repo +import os +import functools +import numpy +from omas.omas_core import o2u +__all__ = [ + 'machine_mapping_function' +] + + +# =================== +# machine mapping functions +# =================== +def machine_mapping_function(__regression_arguments__, **regression_args): + """ + Decorator used to identify machine mapping functions + + :param \**regression_args: arguments used to run regression test + + NOTE: use `inspect.unwrap(function)` to call a function decorated with `@machine_mapping_function` + from another function decorated with `@machine_mapping_function` + """ + + __all__ = __regression_arguments__['__all__'] + + def machine_mapping_decorator(f, __all__): + __all__.append(f.__name__) + if __regression_arguments__ is not None: + __regression_arguments__[f.__name__] = regression_args + + @functools.wraps(f) + def machine_mapping_caller(*args, **kwargs): + clean_ods = True + if len(args[0]): + clean_ods = False + if clean_ods and omas_git_repo: + import inspect + + # figure out the machine name from where the function `f` is defined + machine = os.path.splitext(os.path.split(inspect.getfile(f))[1])[0] + if machine == '': # if `f` is called via exec then we need to look at the call stack to figure out the machine name + machine = os.path.splitext(os.path.split(inspect.getframeinfo(inspect.currentframe().f_back)[0])[1])[0] + + # call signature + argspec = inspect.getfullargspec(f) + f_args_str = ", ".join('{%s!r}' % item for item in argspec.args if not item.startswith('_')) + # f_args_str = ", ".join(item + '={%s!r}' % item for item in argspec.args if not item.startswith('_')) # to use keywords arguments + call = f"{f.__qualname__}({f_args_str})".replace('{ods!r}', 'ods').replace('{pulse!r}', '{pulse}') + default_options = None + if argspec.defaults: + default_options = dict(zip(argspec.args[::-1], argspec.defaults[::-1])) + default_options = {item: value for item, value in default_options.items() if not item.startswith('_')} + + # call + update_mapping = kwargs.pop("update_callback") + out = f(*args, **kwargs) + #update mappings definitions + if clean_ods and omas_git_repo: + for ulocation in numpy.unique(list(map(o2u, args[0].flat().keys()))): + update_mapping(machine, ulocation, {'PYTHON': call}, 11, default_options, update_path=True) + + return out + + return machine_mapping_caller + + return lambda f: machine_mapping_decorator(f, __all__) diff --git a/omas/utilities/omas_mds.py b/omas/utilities/omas_mds.py new file mode 100644 index 000000000..65ed58ae4 --- /dev/null +++ b/omas/utilities/omas_mds.py @@ -0,0 +1,215 @@ +import json +import os +from omas.omas_utils import printd + +__all__ = [ + 'mdstree', + 'mdsvalue' +] + +_mds_connection_cache = {} + +# =================== +# MDS+ functions +# =================== +def tunnel_mds(server, treename): + """ + Resolve MDS+ server + NOTE: This function makes use of the optional `omfit_classes` dependency to establish a SSH tunnel to the MDS+ server. + + :param server: MDS+ server address:port + + :param treename: treename (in case treename affects server to be used) + + :return: string with MDS+ server and port to be used + """ + try: + import omfit_classes.omfit_mds + except (ImportError, ModuleNotFoundError): + return server.format(**os.environ) + else: + server0 = omfit_classes.omfit_mds.translate_MDSserver(server, treename) + tunneled_server = omfit_classes.omfit_mds.tunneled_MDSserver(server0, quiet=False) + return tunneled_server + + return server.format(**os.environ) + + + + + +class mdsvalue(dict): + """ + Execute MDS+ TDI functions + """ + + def __init__(self, server, treename, pulse, TDI, old_MDS_server=False): + self.treename = treename + self.pulse = pulse + self.TDI = TDI + if 'nstx' in server: + old_MDS_server = True + try: + # handle the case that server is just the machine name + machine_mappings_path = os.path.join(os.path.dirname(__file__), "../", "machine_mappings") + machine_mappings_path = os.path.join(machine_mappings_path, server + ".json") + with open(machine_mappings_path, "r") as machine_file: + server = json.load(machine_file)["__mdsserver__"] + except Exception: + # hanlde case where server is actually a URL + if '.' not in server: + raise + self.server = tunnel_mds(server, self.treename) + old_servers = ['skylark.pppl.gov:8500', 'skylark.pppl.gov:8501', 'skylark.pppl.gov:8000'] + if server in old_servers or self.server in old_servers: + old_MDS_server = True + self.old_MDS_server = old_MDS_server + + def data(self): + return self.raw(f'data({self.TDI})') + + def dim_of(self, dim): + return self.raw(f'dim_of({self.TDI},{dim})') + + def units(self): + return self.raw(f'units({self.TDI})') + + def error(self): + return self.raw(f'error({self.TDI})') + + def error_dim_of(self, dim): + return self.raw(f'error_dim_of({self.TDI},{dim})') + + def units_dim_of(self, dim): + return self.raw(f'units_dim_of({self.TDI},{dim})') + + def size(self, dim): + return self.raw(f'size({self.TDI})') + + def raw(self, TDI=None): + """ + Fetch data from MDS+ with connection caching + + :param TDI: string, list or dict of strings + MDS+ TDI expression(s) (overrides the one passed when the object was instantiated) + + :return: result of TDI expression, or dictionary with results of TDI expressions + """ + try: + import time + + t0 = time.time() + import MDSplus + + def mdsk(value): + """ + Translate strings to MDS+ bytes + """ + return str(str(value).encode('utf8')) + + if TDI is None: + TDI = self.TDI + + try: + out_results = None + + # try connecting and re-try on fail + for fallback in [0, 1]: + if (self.server, self.treename, self.pulse) not in _mds_connection_cache: + conn = MDSplus.Connection(self.server) + if self.treename is not None: + conn.openTree(self.treename, self.pulse) + _mds_connection_cache[(self.server, self.treename, self.pulse)] = conn + try: + conn = _mds_connection_cache[(self.server, self.treename, self.pulse)] + break + except Exception as _excp: + if (self.server, self.treename, self.pulse) in _mds_connection_cache: + del _mds_connection_cache[(self.server, self.treename, self.pulse)] + if fallback: + raise + + # list of TDI expressions + if isinstance(TDI, (list, tuple)): + TDI = {expr: expr for expr in TDI} + + # dictionary of TDI expressions + if isinstance(TDI, dict): + # old versions of MDS+ server do not support getMany + if self.old_MDS_server: + results = {} + for tdi in TDI: + try: + results[tdi] = mdsvalue(self.server, self.treename, self.pulse, TDI[tdi]).raw() + except Exception as _excp: + results[tdi] = Exception(str(_excp)) + out_results = results + + # more recent MDS+ server + else: + conns = conn.getMany() + for name, expr in TDI.items(): + conns.append(name, expr) + res = conns.execute() + results = {} + for name, expr in TDI.items(): + try: + results[name] = MDSplus.Data.data(res[mdsk(name)][mdsk('value')]) + except KeyError: + try: + results[name] = MDSplus.Data.data(res[str(name)][str('value')]) + except KeyError: + try: + results[name] = Exception(MDSplus.Data.data(res[mdsk(name)][mdsk('error')])) + except KeyError: + results[name] = Exception(MDSplus.Data.data(res[str(name)][str('error')])) + out_results = results + + # single TDI expression + else: + out_results = MDSplus.Data.data(conn.get(TDI)) + + # return values + return out_results + + except Exception as _excp: + txt = [] + for item in ['server', 'treename', 'pulse']: + txt += [f' - {item}: {getattr(self, item)}'] + txt += [f' - TDI: {TDI}'] + + finally: + if out_results is not None: + if isinstance(out_results, dict): + if all(isinstance(out_results[k], Exception) for k in out_results): + printd(f'{TDI} \tall NO\t {time.time() - t0:3.3f} secs', topic='machine') + elif any(isinstance(out_results[k], Exception) for k in out_results): + printd(f'{TDI} \tsome OK/NO\t {time.time() - t0:3.3f} secs', topic='machine') + else: + printd(f'{TDI} \tall OK\t {time.time() - t0:3.3f} secs', topic='machine') + else: + printd(f'{TDI} \tOK\t {time.time() - t0:3.3f} secs', topic='machine') + else: + printd(f'{TDI} \tNO\t {time.time() - t0:3.3f} secs', topic='machine') + +class mdstree(dict): + """ + Class to handle the structure of an MDS+ tree. + Nodes in this tree are mdsvalue objects + """ + + def __init__(self, server, treename, pulse): + for TDI in sorted(mdsvalue(server, treename, pulse, rf'getnci("***","FULLPATH")').raw())[::-1]: + try: + TDI = TDI.decode('utf8') + except AttributeError: + pass + TDI = TDI.strip() + path = TDI.replace('::TOP', '').lstrip('\\').replace(':', '.').split('.') + h = self + for p in path[1:-1]: + h = h.setdefault(p, mdsvalue(server, treename, pulse, '')) + if path[-1] not in h: + h[path[-1]] = mdsvalue(server, treename, pulse, TDI) + else: + h[path[-1]].TDI = TDI \ No newline at end of file From 98c1080793ff768844c47c5bea0cc2c7f6fb51b5 Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Thu, 23 Mar 2023 08:57:47 -0700 Subject: [PATCH 12/26] Fixes for `test_machine_mapping_functions` test --- omas/machine_mappings/_common.py | 1 + omas/machine_mappings/d3d.py | 2 ++ omas/omas_core.py | 2 ++ omas/omas_machine.py | 1 + 4 files changed, 6 insertions(+) diff --git a/omas/machine_mappings/_common.py b/omas/machine_mappings/_common.py index b42b3a476..2f8ad1bfd 100644 --- a/omas/machine_mappings/_common.py +++ b/omas/machine_mappings/_common.py @@ -4,6 +4,7 @@ import os import glob from omas.omas_setup import omas_dir +from omas.utilities.omas_mds import mdsvalue __support_files_cache__ = {} diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index 9cca288e9..51db0ad18 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1028,6 +1028,8 @@ def langmuir_probes_data(ods, pulse, _get_measurements=True): if data_present[i]: try: r = mdsvalue('d3d', pulse=pulse, treename='langmuir', TDI=r'\langmuir::top.probe_{:03d}.r'.format(i)).data() + if r is None: + raise ValueError() except Exception: continue if r > 0: diff --git a/omas/omas_core.py b/omas/omas_core.py index 3eec91764..c67683d2e 100644 --- a/omas/omas_core.py +++ b/omas/omas_core.py @@ -2910,4 +2910,6 @@ def through_omas_pkl(ods): from .omas_mongo import * from .omas_symbols import * from .omas_machine import * +from .utilities.machine_mapping_decorator import * +from .utilities.omas_mds import * from . import omas_structure diff --git a/omas/omas_machine.py b/omas/omas_machine.py index 291fd704a..7ae1913d9 100644 --- a/omas/omas_machine.py +++ b/omas/omas_machine.py @@ -566,6 +566,7 @@ def test_machine_mapping_functions(__all__, global_namespace, local_namespace): func = eval(func_name, global_namespace, local_namespace) try: try: + regression_kw["update_callback"] = update_mapping func(ods, **regression_kw) except Exception: raise From 92ec163848097fcabb51ef2c4314b2d4c285909e Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Thu, 23 Mar 2023 14:16:15 -0700 Subject: [PATCH 13/26] Fix mds_value import in omas-machine --- omas/omas_machine.py | 1 + 1 file changed, 1 insertion(+) diff --git a/omas/omas_machine.py b/omas/omas_machine.py index 7ae1913d9..fb67190bf 100644 --- a/omas/omas_machine.py +++ b/omas/omas_machine.py @@ -8,6 +8,7 @@ from .omas_physics import cocos_signals from omas.machine_mappings import d3d from omas.utilities.machine_mapping_decorator import machine_mapping_function +from omas.utilities.omas_mds import mdsvalue __all__ = [ 'machine_expression_types', From 37ce0f37765ab6e4115ce64a1df369e177fa4aba Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Fri, 24 Mar 2023 08:08:29 -0700 Subject: [PATCH 14/26] Added fit data to profile plots --- omas/machine_mappings/d3d.json | 61 +++++++++++++++++++++++++++++----- omas/machine_mappings/d3d.py | 49 +++++++++++++++++++++++---- omas/omas_machine.py | 2 +- omas/omas_physics.py | 1 - omas/omas_plot.py | 41 ++++++++++++++++++++--- 5 files changed, 133 insertions(+), 21 deletions(-) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index ef984bb3b..428cac3dc 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -113,13 +113,13 @@ "coils_non_axisymmetric.coil.:.name": { "PYTHON": "coils_non_axisymmetric_hardware(ods, {pulse})" }, + "core_profiles": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.global_quantities.v_loop": { "COCOSIO": 11, "PYTHON": "core_profiles_global_quantities_data(ods, {pulse})" }, - "core_profiles": { - "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" -}, "core_profiles.ids_properties.homogeneous_time": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, @@ -138,6 +138,15 @@ "core_profiles.profiles_1d.:.electrons.density_error_upper": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.electrons.density_fit.measured": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.electrons.density_fit.measured_error_upper": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.electrons.density_fit.psi_norm": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.electrons.density_thermal": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, @@ -147,6 +156,15 @@ "core_profiles.profiles_1d.:.electrons.temperature_error_upper": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.electrons.temperature_fit.measured": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.electrons.temperature_fit.measured_error_upper": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.electrons.temperature_fit.psi_norm": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.grid.rho_pol_norm": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, @@ -162,6 +180,15 @@ "core_profiles.profiles_1d.:.ion.:.density_error_upper": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.ion.:.density_fit.measured": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.density_fit.measured_error_upper": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.density_fit.psi_norm": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.ion.:.element.:": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, @@ -180,6 +207,15 @@ "core_profiles.profiles_1d.:.ion.:.temperature_error_upper": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.ion.:.temperature_fit.measured": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.temperature_fit.measured_error_upper": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.temperature_fit.psi_norm": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.ion.:.velocity.toroidal": { "COCOSIO": 11, "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" @@ -187,6 +223,15 @@ "core_profiles.profiles_1d.:.ion.:.velocity.toroidal_error_upper": { "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, + "core_profiles.profiles_1d.:.ion.:.velocity.toroidal_fit.measured": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.velocity.toroidal_fit.measured_error_upper": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, + "core_profiles.profiles_1d.:.ion.:.velocity.toroidal_fit.psi_norm": { + "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" + }, "core_profiles.profiles_1d.:.j_total": { "COCOSIO": 11, "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" @@ -298,11 +343,11 @@ "PYTHON": "electron_cyclotron_emission_hardware(ods, {pulse}, {fast_ece!r})" }, "equilibrium.code": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" -}, -"equilibrium.code.parameters": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" -}, + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, + "equilibrium.code.parameters": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + }, "equilibrium.code.parameters.time_slice.:": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" }, diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index d34112bfb..a13e7656f 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -10,6 +10,8 @@ from omas.utilities.machine_mapping_decorator import machine_mapping_function from omas.utilities.omas_mds import mdsvalue from omas.omas_core import ODS +from omas.omas_structure import add_extra_structures +# from omas.omas_structure import add_extra_structures __all__ = [] __regression_arguments__ = {'__all__': __all__} @@ -1374,23 +1376,59 @@ def equilibrium_special(ods, pulse, EFIT_tree="EFIT"): raise ValueError("Cannot reconstruct contraints, current constraints not met.") ods[f"equilibrium.code.parameters.time_slice.{time_index}.inwant.vzeroj"] *= ods[f"equilibrium.time_slice[{time_index}].global_quantities.ip"] +def add_extra_profile_structures(): + extra_structures = {} + extra_structures["core_profiles"] = {} + sh = "core_profiles.profiles_1d" + for quant in ["ion.:.density_fit.psi_norm", "electrons.density_fit.psi_norm", + "ion.:.temperature_fit.psi_norm", "electrons.temperature_fit.psi_norm", + "ion.:.velocity.toroidal_fit.psi_norm"]: + if "velocity" in quant: + psi_struct = {"coordinates": "1- 1...N"} + else: + psi_struct = {"coordinates": sh + ".:." + quant.replace("psi_norm", "rho_tor_norm")} + psi_struct["documentation"] = "Normalized Psi for fit data." + psi_struct["data_type"] = "FLT_1D" + psi_struct["units"] = "" + extra_structures["core_profiles"][f"core_profiles.profiles_1d.:.{quant}"] = psi_struct + velo_struct = {"coordinates": sh + ".:." + "ion.:.velocity.toroidal_fit.psi_norm"} + velo_struct["documentation"] = "Information on the fit used to obtain the toroidal velocity profile [m/s]" + velo_struct["data_type"] = "FLT_1D" + velo_struct["units"] = "m.s^-1" + extra_structures["core_profiles"][f"core_profiles.profiles_1d.:.ion.:.velocity.toroidal_fit.measured"] = velo_struct + extra_structures["core_profiles"][f"core_profiles.profiles_1d.:.ion.:.velocity.toroidal_fit.measured_error_upper"] = velo_struct + add_extra_structures(extra_structures) + + @machine_mapping_function(__regression_arguments__, pulse=194455001, PROFILES_tree="OMFIT_PROFS") def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): + add_extra_profile_structures() ods["core_profiles.ids_properties.homogeneous_time"] = 1 if "OMFIT_PROFS" in PROFILES_tree: omfit_profiles_node = '\\TOP.' query = { "electrons.density": "N_E", + "electrons.density_fit.measured": "RW_N_E", "electrons.temperature": "T_E", + "electrons.temperature_fit.measured": "RW_T_E", "ion[0].density": "N_D", "ion[0].temperature": "T_D", "ion[1].velocity.toroidal": "V_TOR_C", + "ion[1].velocity.toroidal_fit.measured": "RW_V_TOR_C", "ion[1].density": "N_C", - "ion[1].temperature": "T_C" + "ion[1].density_fit.measured": "RW_N_C", + "ion[1].temperature": "T_C", + "ion[1].temperature_fit.measured": "RW_T_C", } uncertain_entries = list(query.keys()) - query["j_total"] = "J_TOT" - query["pressure_perpendicular"] = "P_TOT" + query["electrons.density_fit.psi_norm"] = "PS_N_E" + query["electrons.temperature_fit.psi_norm"] = "PS_T_E" + query["ion[1].density_fit.psi_norm"] = "PS_N_C" + query["ion[1].temperature_fit.psi_norm"] = "PS_T_C" + query["ion[1].density_fit.psi_norm"] = "PS_T_C" + query["ion[1].velocity.toroidal_fit.psi_norm"]= "PS_V_TOR_C" + #query["j_total"] = "J_TOT" + #query["pressure_perpendicular"] = "P_TOT" # query["e_field.radial"] = "Er_12C6" query["grid.rho_tor_norm"] = "rho" normal_entries = set(query.keys()) - set(uncertain_entries) @@ -1413,7 +1451,6 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): for i_time, time in enumerate(data["time"]): ods[f"{sh}[{i_time}].grid.rho_pol_norm"] = data['grid.rho_pol_norm'][i_time] for entry in uncertain_entries + ["ion[0].velocity.toroidal"]: - # print(entry) for i_time, time in enumerate(data["time"]): try: ods[f"{sh}[{i_time}]." + entry] = data[entry][i_time] @@ -1428,7 +1465,6 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): data[entry + "_error_upper"][i_time].shape) print(e) for entry in normal_entries: - # print(entry) for i_time, time in enumerate(data["time"]): try: ods[f"{sh}[{i_time}]."+entry] = data[entry][i_time] @@ -1460,9 +1496,10 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): data['grid.rho_tor_norm'][:] = rho_tor_norm ods[f"core_profiles.time"] = data['time'] for entry in data: + if isinstance(data[entry], Exception): + continue for i_time, time in enumerate(data["time"]): ods[f"core_profiles.profiles_1d[{i_time}]."+entry] = data[entry][i_time] - # ================================ @machine_mapping_function(__regression_arguments__, pulse=133221) def core_profiles_global_quantities_data(ods, pulse): diff --git a/omas/omas_machine.py b/omas/omas_machine.py index d75af546c..8c9523401 100644 --- a/omas/omas_machine.py +++ b/omas/omas_machine.py @@ -563,7 +563,7 @@ def test_machine_mapping_functions(__all__, global_namespace, local_namespace): print(func_name) pprint(regression_kw) print('=' * len(func_name)) - ods = ODS(consistency_check= not break_schema) + ods = ODS() #consistency_check= not break_schema func = eval(func_name, global_namespace, local_namespace) try: try: diff --git a/omas/omas_physics.py b/omas/omas_physics.py index 529b849cb..9e778ecec 100644 --- a/omas/omas_physics.py +++ b/omas/omas_physics.py @@ -2501,7 +2501,6 @@ def get_plot_scale_and_unit(phys_quant): :param phys_qaunt: str with a physical quantity. Uses IMAS scheme names where possible :return: scale, unit """ - print(phys_quant) if "temperature" in phys_quant: return 1.e-3, r"\mathrm{keV}" elif "density" in phys_quant : diff --git a/omas/omas_plot.py b/omas/omas_plot.py index 8e62821c8..210d3880d 100644 --- a/omas/omas_plot.py +++ b/omas/omas_plot.py @@ -1153,7 +1153,8 @@ def core_profiles_currents_summary(ods, time_index=None, time=None, ax=None, **k @add_to__ODS__ def core_profiles_summary(ods, time_index=None, time=None, fig=None, - ods_species=None, quantities=['density_thermal', 'temperature'], **kw): + ods_species=None, quantities=['density_thermal', 'temperature'], + x_axis = "rho_tor_norm", **kw): """ Plot densities and temperature profiles for electrons and all ion species as per `ods['core_profiles']['profiles_1d'][time_index]` @@ -1198,8 +1199,15 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, ) prof1d = ods['core_profiles']['profiles_1d'][time_index] - rho = prof1d['grid.rho_tor_norm'] - + if x_axis == "psi_norm": + x = prof1d['grid.rho_pol_norm']**2 + x_label = r"$\Psi$" + else: + x = prof1d[f'grid.{x_axis}'] + if "tor" in x_axis: + x_label = r'$\rho$' + elif "pol" in x_axis: + x_label = r'$\rho_\mathrm{pol}$' # Determine subplot rows x colls if ods_species is None: ncols = len(prof1d['ion']) + 1 @@ -1218,6 +1226,7 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, label_name = [] label_name_z = [] unit_list = [] + data_list = [] for q in quantities: if 'density' in q or 'temperature' in q or "velocity.toroidal" in q or "e_field.radial" in q: for index, specie in enumerate(species_in_tree): @@ -1234,6 +1243,13 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, prof1d[specie][q + "_error_upper"]*scale)) else: plotting_list.append(prof1d[specie][q]*scale) + if x_axis == "psi_norm": + try: + data_list.append([prof1d[specie][q + "_fit.psi_norm"], + prof1d[specie][q + "_fit.measured"]*scale, + prof1d[specie][q + "_fit.measured_error_upper"]*scale]) + except Exception as e: + data_list.append(None) label_name_z.append("") label_name.append(f'{names[index]} {q.capitalize()}') @@ -1269,7 +1285,21 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, sharey = None ax = cached_add_subplot(fig, axs, nrows, ncols, plot, sharex=sharex, sharey=sharey) - uband(rho, y, ax=ax, **kw) + uband(x, y, ax=ax, **kw) + if data_list[index] is not None: + mask = numpy.ones(data_list[index][0].shape, dtype=bool) + # Remove NaNs + for j in range(3): + mask[numpy.isnan(data_list[index][j])] = False + # Remove measuremetns with 100% or more uncertainty + x_data = data_list[index][0][mask] + y_data = data_list[index][1][mask] + y_data_err = data_list[index][2][mask] + mask = mask[mask] + mask[numpy.abs(y_data_err[mask]) > numpy.abs(y_data[mask])] = False + if numpy.any(mask): + ax.errorbar(x_data[mask], y_data[mask], y_data_err[mask], + linestyle='', marker="+", color='red', **kw) if "Temp" in label_name[index]: ax.set_ylabel(r'$T_{{{}}}$'.format(label_name[index].split()[0]) + imas_units_to_latex(unit_list[index])) elif "Density" in label_name[index]: @@ -1277,7 +1307,8 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, else: ax.set_ylabel(label_name[index][:10] + imas_units_to_latex(unit_list[index])) if (nplots - plot) < ncols: - ax.set_xlabel('$\\rho$') + ax.set_xlabel(x_label) + if 'label' in kw: ax.legend(loc='lower center') ax.set_xlim(0, 1) From d67c543cb93d4f98b67863002f839698a826587d Mon Sep 17 00:00:00 2001 From: Will DeShazer Date: Fri, 24 Mar 2023 09:59:25 -0700 Subject: [PATCH 15/26] Adding new equilibrium_quality to omas_plot --- omas/omas_plot.py | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/omas/omas_plot.py b/omas/omas_plot.py index 8e62821c8..e210481c7 100644 --- a/omas/omas_plot.py +++ b/omas/omas_plot.py @@ -946,6 +946,28 @@ def plot_1d_equilbrium_quantity(ax, x, y, xlabel, ylabel, title, visible_x = Tru ax.set_ylabel(ylabel) ax.set_title(title) +@add_to__ODS__ +def equilibrium_quality(ods, fig=None, **kw): + """ + Plot equilibrium convergence error and total Chi-squared as a function of time + + :param ods: input ods + + :param fig: figure to plot in (a new figure is generated if `fig is None`) + """ + from matplotlib import pyplot + + axs = kw.pop('ax', {}) + if axs is None: + axs = {} + if not len(axs) and fig is None: + fig = pyplot.figure() + + ax1 = cached_add_subplot(fig, axs, 1, 2, 1) + ax2 = cached_add_subplot(fig, axs, 1, 2, 2, sharex=ax1) + + ax1.plot(ods['equilibrium.time'], ods['equilibrium.time_slice[:].constraints.chi_squared_total']) + ax2.plot(ods['equilibrium.time'], ods['equilibrium.time_slice[:].convergence.grad_shafranov_deviation_value']) @add_to__ODS__ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_triangles=None, omas_viewer=False, **kw): @@ -1284,7 +1306,6 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, fig.tight_layout() return {'ax': axs, 'fig': fig} - @add_to__ODS__ def core_profiles_pressures(ods, time_index=None, time=None, ax=None, **kw): """ From 183c500bf233d08bcca4fdd153c6739c755e385d Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Fri, 24 Mar 2023 08:56:08 -0700 Subject: [PATCH 16/26] Fix bug for profiles w/o errors --- omas/machine_mappings/d3d.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index a13e7656f..53777aecd 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1451,6 +1451,8 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): for i_time, time in enumerate(data["time"]): ods[f"{sh}[{i_time}].grid.rho_pol_norm"] = data['grid.rho_pol_norm'][i_time] for entry in uncertain_entries + ["ion[0].velocity.toroidal"]: + if isinstance(data[entry], Exception): + continue for i_time, time in enumerate(data["time"]): try: ods[f"{sh}[{i_time}]." + entry] = data[entry][i_time] @@ -1465,6 +1467,8 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): data[entry + "_error_upper"][i_time].shape) print(e) for entry in normal_entries: + if isinstance(data[entry], Exception): + continue for i_time, time in enumerate(data["time"]): try: ods[f"{sh}[{i_time}]."+entry] = data[entry][i_time] @@ -1523,4 +1527,6 @@ def core_profiles_global_quantities_data(ods, pulse): # ================================ if __name__ == '__main__': - test_machine_mapping_functions(["equilibrium_special"], globals(), locals()) + ods = ODS() + core_profiles_profile_1d(ods, 174082001, "OMFIT_PROFS") + # test_machine_mapping_functions(["equilibrium_special"], globals(), locals()) From 0c3297b05d9b4f0b41179b10fd8f1a1e81621cf3 Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Fri, 24 Mar 2023 13:57:31 -0700 Subject: [PATCH 17/26] Added E_r plot, fixed machine mapping test --- omas/omas_machine.py | 16 ++++++++++------ omas/omas_plot.py | 19 +++++++++++++++---- 2 files changed, 25 insertions(+), 10 deletions(-) diff --git a/omas/omas_machine.py b/omas/omas_machine.py index 8c9523401..f5148f199 100644 --- a/omas/omas_machine.py +++ b/omas/omas_machine.py @@ -3,10 +3,11 @@ import subprocess import functools import shutil -from .omas_utils import * -from .omas_core import ODS, dynamic_ODS, omas_environment, omas_info_node, imas_json_dir, omas_rcparams -from .omas_physics import cocos_signals +from omas.omas_utils import * +from omas.omas_core import ODS, dynamic_ODS, omas_environment, omas_info_node, imas_json_dir, omas_rcparams +from omas.omas_physics import cocos_signals from omas.machine_mappings import d3d +from omas.machine_mappings.d3d import __regression_arguments__ from omas.utilities.machine_mapping_decorator import machine_mapping_function from omas.utilities.omas_mds import mdsvalue @@ -536,7 +537,7 @@ def update_mapping(machine, location, value, cocosio=None, default_options=None, -def test_machine_mapping_functions(__all__, global_namespace, local_namespace): +def test_machine_mapping_functions(machine, __all__, global_namespace, local_namespace): """ Function used to test python mapping functions @@ -550,7 +551,7 @@ def test_machine_mapping_functions(__all__, global_namespace, local_namespace): os.environ['OMAS_DEBUG_TOPIC'] = 'machine' # call machine mapping to make sure the json file is properly formatted - machine = os.path.splitext(os.path.split(local_namespace['__file__'])[1])[0] + # machine = os.path.splitext(os.path.split(local_namespace['__file__'])[1])[0] print(f'Sanity check of `{machine}` mapping files: ... ', end='') machine_mappings(machine, '', raise_errors=True) print('OK') @@ -564,7 +565,7 @@ def test_machine_mapping_functions(__all__, global_namespace, local_namespace): pprint(regression_kw) print('=' * len(func_name)) ods = ODS() #consistency_check= not break_schema - func = eval(func_name, global_namespace, local_namespace) + func = eval(machine + "." + func_name, global_namespace, local_namespace) try: try: regression_kw["update_callback"] = update_mapping @@ -688,3 +689,6 @@ def load_omas_machine( print(location) machine_to_omas(ods, machine, pulse, location, options, branch) return ods + +if __name__ == '__main__': + test_machine_mapping_functions('d3d', ["core_profiles_profile_1d"], globals(), locals()) \ No newline at end of file diff --git a/omas/omas_plot.py b/omas/omas_plot.py index af646a563..3f9c18cdd 100644 --- a/omas/omas_plot.py +++ b/omas/omas_plot.py @@ -1250,7 +1250,7 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, unit_list = [] data_list = [] for q in quantities: - if 'density' in q or 'temperature' in q or "velocity.toroidal" in q or "e_field.radial" in q: + if 'density' in q or 'temperature' in q or "velocity.toroidal" in q : for index, specie in enumerate(species_in_tree): #unit_list.append(omas_info_node(o2u(f"core_profiles.profiles_1d.0.{specie}.{q}"))['units']) scale, unit = get_plot_scale_and_unit(q) @@ -1282,7 +1282,16 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, unit_list.append(omas_info_node(o2u(f"core_profiles.profiles_1d.0.{q}"))['units']) plotting_list.append(prof1d[q]) label_name.append(q.capitalize()) - + if "e_field.radial" in quantities: + try: + scale, unit = get_plot_scale_and_unit("e_field.radial") + unit_list.append(unit) + plotting_list.append(unumpy.uarray(prof1d["e_field.radial"]*scale, + prof1d["e_field.radial" + "_error_upper"]*scale)) + label_name_z.append("") + label_name.append(r'$E_\mathrm{r}$') + except: + pass for index, y in enumerate(plotting_list): if index >= len(label_name): break @@ -1322,10 +1331,12 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, if numpy.any(mask): ax.errorbar(x_data[mask], y_data[mask], y_data_err[mask], linestyle='', marker="+", color='red', **kw) + species_label = label_name[index].split()[0] + species_label = species_label.replace("electron", "e") if "Temp" in label_name[index]: - ax.set_ylabel(r'$T_{{{}}}$'.format(label_name[index].split()[0]) + imas_units_to_latex(unit_list[index])) + ax.set_ylabel(r'$T_{{{}}}$'.format(species_label) + imas_units_to_latex(unit_list[index])) elif "Density" in label_name[index]: - ax.set_ylabel(r'$n_{{{}}}$'.format(label_name[index].split()[0]) + imas_units_to_latex(unit_list[index]) + label_name_z[index]) + ax.set_ylabel(r'$n_{{{}}}$'.format(species_label) + imas_units_to_latex(unit_list[index]) + label_name_z[index]) else: ax.set_ylabel(label_name[index][:10] + imas_units_to_latex(unit_list[index])) if (nplots - plot) < ncols: From 72088fe388cd41fb37348a7f93c80561f3791b7d Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Fri, 24 Mar 2023 13:57:50 -0700 Subject: [PATCH 18/26] Some error handling for empty MDS trees --- omas/machine_mappings/d3d.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index 53777aecd..046948acf 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1357,6 +1357,9 @@ def equilibrium_special(ods, pulse, EFIT_tree="EFIT"): from scipy.interpolate import InterpolatedUnivariateSpline kfiles = mdsvalue('d3d', treename=EFIT_tree, pulse=pulse, TDI="\\TOP.NAMELISTS.KEQDSKS").raw() # times = mdsvalue('d3d', treename=EFIT_tree, pulse=pulse, TDI="\\TOP.NAMELISTS.KEQDSKS.KTIME").raw() # + if times is None: + print("No mds+ data") + raise ValueError(f"Could not find any data in MDS+ for {pulse} and {EFIT_tree}") ods["equilibrium.ids_properties.homogeneous_time"] = 1 ods["equilibrium.time"]= times / 1.e3 # for i_time, time in enumerate(times): @@ -1400,7 +1403,7 @@ def add_extra_profile_structures(): add_extra_structures(extra_structures) -@machine_mapping_function(__regression_arguments__, pulse=194455001, PROFILES_tree="OMFIT_PROFS") +@machine_mapping_function(__regression_arguments__, pulse=194842001, PROFILES_tree="OMFIT_PROFS") def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): add_extra_profile_structures() ods["core_profiles.ids_properties.homogeneous_time"] = 1 @@ -1429,7 +1432,7 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): query["ion[1].velocity.toroidal_fit.psi_norm"]= "PS_V_TOR_C" #query["j_total"] = "J_TOT" #query["pressure_perpendicular"] = "P_TOT" - # query["e_field.radial"] = "Er_12C6" + query["e_field.radial"] = "ER_C" query["grid.rho_tor_norm"] = "rho" normal_entries = set(query.keys()) - set(uncertain_entries) for entry in query: @@ -1437,6 +1440,9 @@ def core_profiles_profile_1d(ods, pulse, PROFILES_tree="OMFIT_PROFS"): for entry in uncertain_entries: query[entry + "_error_upper"] = "error_of(" + query[entry] + ")" data = mdsvalue('d3d', treename=PROFILES_tree, pulse=pulse, TDI=query).raw() + if data is None: + print("No mds+ data") + raise ValueError(f"Could not find any data in MDS+ for {pulse} and {PROFILES_tree}") dim_info = mdsvalue('d3d', treename=PROFILES_tree, pulse=pulse, TDI="\\TOP.n_e") data['time'] = dim_info.dim_of(1) * 1.e-3 psi_n = dim_info.dim_of(0) @@ -1526,7 +1532,3 @@ def core_profiles_global_quantities_data(ods, pulse): # ================================ -if __name__ == '__main__': - ods = ODS() - core_profiles_profile_1d(ods, 174082001, "OMFIT_PROFS") - # test_machine_mapping_functions(["equilibrium_special"], globals(), locals()) From 09aee934f9636e68bf5c87811b1fcf17d86e573e Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Mon, 27 Mar 2023 20:18:14 -0700 Subject: [PATCH 19/26] Separated time fetching for better performance --- omas/machine_mappings/d3d.json | 659 +++++++++++++++++---------------- omas/machine_mappings/d3d.py | 22 +- 2 files changed, 344 insertions(+), 337 deletions(-) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index 428cac3dc..2b09b884f 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -11,6 +11,7 @@ "analysis_type": "CERQUICK", "default_tree": "D3D", "fast_ece": false, + "get_all": true, "nref": 0, "revision": "BLESSED" }, @@ -243,7 +244,7 @@ "PYTHON": "core_profiles_profile_1d(ods, {pulse}, {PROFILES_tree!r})" }, "dataset_description.data_entry.pulse": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "ec_launchers.beam.:": { "PYTHON": "ec_launcher_active_hardware(ods, {pulse})" @@ -352,1019 +353,1019 @@ "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" }, "equilibrium.code.parameters.time_slice.:.auxquantities.degrees_of_freedom": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.auxquantities.num_fit_variables": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.auxquantities.num_hard_constraints": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.auxquantities.num_input_data": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.auxquantities.sigxxj": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.alphafp": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.bitec": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.bitfc": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.bitip": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.bitmpi": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.brsp": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.btor": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.calpa": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.cgama": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.coils": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.currn1": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.denr": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.denv": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.dflux": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.dmass": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.dnbeam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.dpsiecn": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ecurrt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.efitversion": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.elomin": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.errmag": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.errmagb": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.errmin": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.error": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.expmp2": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fcurbd": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ff2bdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ffbdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ffknt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fftens": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fitfcsum": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fitsiref": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fitzts": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fwtbp": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fwtcur": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fwtdlc": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fwtec": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fwtfc": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fwtfcsum": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fwtmp2": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fwtpre": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fwtqa": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.fwtsi": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.iavem": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.iaveus": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ibtcomp": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.iconvr": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.icprof": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.icutfp": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.iecurr": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ierchk": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ifcurr": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ifindopt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ifitvs": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.imagsigma": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.input_dir": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.iout": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.iplcout": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.iplim": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ishot": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.isolve": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.itek": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.itime": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.itimeu": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.itrace": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ixray": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kbound": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kcalpa": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kcgama": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kedgef": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kedgep": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.keehord": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.keqdsk": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kersil": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kff2bdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kffbdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kffcur": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kfffnc": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kffhord": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kffknt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kframe": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kpp2bdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kppbdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kppcur": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kppfnc": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kpphord": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kppknt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kprfit": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kskipvs": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ktear": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kwripre": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kww2bdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kwwbdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kwwfnc": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kwwknt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.kzeroj": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.limitr": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.mxiter": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.n1coil": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.nbdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.nbdrymx": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.nbeam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ndokin": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.nextra": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.nmass": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.npress": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.pbeam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.pcurbd": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.plasma": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.pnbeam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.pp2bdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ppbdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ppknt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.pptens": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.pressr": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.psibit": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.psiecn": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.qvfit": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.rbdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.rcentr": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.relax": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.req_valid": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.rpress": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.rzeroj": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.saicon": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.saimin": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.scrape": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.serror": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.sibeam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.sigdlc": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.sigpre": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.siloplim": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.siref": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.store_dir": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.table_dir": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.tolbndpsi": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.use_previous": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.vbit": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.vloop": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.vsdamp": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.ww2bdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.wwbdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.wwknt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.wwtens": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.xalpa": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.xgama": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.xltype": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.xltype_180": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.zbdry": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.in1.zelip": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.aa1gam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.aa2gam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.aa3gam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.aa4gam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.aa5gam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.aa6gam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.aa7gam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.dtmsefull": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.fwtgam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.kwaitmse": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.mse_certree": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.mse_quiet": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.mse_spave_on": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.mse_strict": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.mse_use_cer210": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.mse_use_cer330": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.mse_usecer": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.msebkp": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.msefitfun": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.ok_210lt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.ok_30rt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.rrrgam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.sgamma": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.t_max_beam_off": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.tgamma": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.tgammauncor": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.v210lt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.v210rt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.v30lt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.v30rt": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.ins.zzzgam": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.currc139": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.currc199": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.currc79": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.curril150": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.curril30": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.curril90": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.curriu150": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.curriu30": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.curriu90": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.errdelz": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.fitdelz": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.fwtxxj": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.ifitdelz": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.nccoil": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.nicoil": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.oldccomp": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.oldcomp": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.psiwant": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.relaxdz": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.rexpan": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.scaledz": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.sizeroj": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.vzeroj": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.code.parameters.time_slice.:.inwant.znose": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.ids_properties.comment": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.ids_properties.homogeneous_time": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibirum_time(ods, {pulse}, {EFIT_tree!r})" }, "equilibrium.time_slice.:.boundary.outline.r": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.boundary.outline.z": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.boundary.x_point.:": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" }, "equilibrium.time_slice.:.boundary.x_point.:.r": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.boundary.x_point.:.z": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.bpol_probe.:": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" }, "equilibrium.time_slice.:.constraints.bpol_probe.:.chi_squared": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.bpol_probe.:.exact": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.bpol_probe.:.measured": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.bpol_probe.:.reconstructed": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.bpol_probe.:.weight": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.chi_squared_total": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.diamagnetic_flux.exact": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.diamagnetic_flux.measured": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.diamagnetic_flux.measured_error_upper": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.flux_loop.:": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" }, "equilibrium.time_slice.:.constraints.flux_loop.:.chi_squared": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.flux_loop.:.exact": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.flux_loop.:.measured": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.flux_loop.:.reconstructed": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.flux_loop.:.weight": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.ip.exact": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.ip.measured": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.ip.reconstructed": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" }, "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.chi_squared": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.exact": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.measured": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.measured_error_upper": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.reconstructed": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.mse_polarisation_angle.:.weight": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.pf_current.:": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" }, "equilibrium.time_slice.:.constraints.pf_current.:.exact": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.pf_current.:.measured": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.pf_current.:.reconstructed": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.pf_current.:.weight": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.pressure.:": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" }, "equilibrium.time_slice.:.constraints.pressure.:.chi_squared": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.pressure.:.exact": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.pressure.:.measured": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.pressure.:.measured_error_upper": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.constraints.pressure.:.reconstructed": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.convergence.grad_shafranov_deviation_expression.description": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.convergence.grad_shafranov_deviation_expression.index": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.convergence.grad_shafranov_deviation_expression.name": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.convergence.grad_shafranov_deviation_value": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.convergence.iterations_n": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.beta_normal": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.beta_pol": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.beta_tor": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.ip": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.li_3": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.magnetic_axis.b_field_tor": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.magnetic_axis.r": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.magnetic_axis.z": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.psi_axis": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.psi_boundary": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.q_95": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.q_axis": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.q_min.rho_tor_norm": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.global_quantities.q_min.value": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.area": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.b_field_average": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.b_field_max": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.b_field_min": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.centroid.r": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.centroid.r_max": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.centroid.r_min": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.centroid.z": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.darea_dpsi": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.darea_drho_tor": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.dpressure_dpsi": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.dpsi_drho_tor": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.dvolume_dpsi": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.dvolume_drho_tor": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.elongation": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.f": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.f_df_dpsi": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.geometric_axis.r": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.geometric_axis.z": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.gm1": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.gm2": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.gm5": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.gm8": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.gm9": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.j_tor": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.phi": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.pressure": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.psi": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.q": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.r_inboard": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.r_outboard": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.rho_tor": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.rho_tor_norm": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.squareness_lower_inner": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.squareness_lower_outer": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.squareness_upper_inner": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.squareness_upper_outer": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.surface": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.trapped_fraction": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.triangularity_lower": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.triangularity_upper": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_1d.volume": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_2d.:": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" }, "equilibrium.time_slice.:.profiles_2d.:.b_field_r": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_2d.:.b_field_tor": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_2d.:.b_field_z": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_2d.:.grid.dim1": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_2d.:.grid.dim2": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_2d.:.grid_type.index": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_2d.:.phi": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.profiles_2d.:.psi": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.time": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.vacuum_toroidal_field.b0": { "COCOSIO": 11, - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.vacuum_toroidal_field.r0": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "gas_injection.pipe.:": { "PYTHON": "gas_injection_hardware(ods, {pulse})" @@ -1704,24 +1705,24 @@ "VALUE": 1 }, "wall.description_2d.:.limiter.type.description": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "wall.description_2d.:.limiter.type.index": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "wall.description_2d.:.limiter.type.name": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "wall.description_2d.:.limiter.unit.:": { "VALUE": 1 }, "wall.description_2d.:.limiter.unit.:.outline.r": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "wall.description_2d.:.limiter.unit.:.outline.z": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "wall.time": { - "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" } } \ No newline at end of file diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index 046948acf..4dd831f81 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1352,18 +1352,24 @@ def ip_bt_dflux_data(ods, pulse): ods['tf.b_field_tor_vacuum_r.data'] *= 1.6955 @machine_mapping_function(__regression_arguments__, pulse=19438702, EFIT_tree="EFIT") -def equilibrium_special(ods, pulse, EFIT_tree="EFIT"): +def equilibirum_time(ods, pulse, EFIT_tree="EFIT"): + unwrap(equilibrium_special)(ods, pulse, EFIT_tree, False) + + +@machine_mapping_function(__regression_arguments__, pulse=19438702, EFIT_tree="EFIT", get_all=True) +def equilibrium_special(ods, pulse, EFIT_tree="EFIT", get_all=True): from omfit_classes.omfit_eqdsk import from_mds_plus, OMFITkeqdsk - from scipy.interpolate import InterpolatedUnivariateSpline - kfiles = mdsvalue('d3d', treename=EFIT_tree, pulse=pulse, TDI="\\TOP.NAMELISTS.KEQDSKS").raw() # - times = mdsvalue('d3d', treename=EFIT_tree, pulse=pulse, TDI="\\TOP.NAMELISTS.KEQDSKS.KTIME").raw() # + times = mdsvalue('d3d', treename=EFIT_tree, pulse=pulse, TDI="\\TOP.NAMELISTS.KEQDSKS.KTIME").raw() if times is None: - print("No mds+ data") - raise ValueError(f"Could not find any data in MDS+ for {pulse} and {EFIT_tree}") + print("No mds+ data") + raise ValueError(f"Could not find any data in MDS+ for {pulse} and {EFIT_tree}") ods["equilibrium.ids_properties.homogeneous_time"] = 1 ods["equilibrium.time"]= times / 1.e3 - # for i_time, time in enumerate(times): - # ods[f"equilibrium.time_slice[{i_time}].time"] = time / 1.e3 + for i_time, time in enumerate(times): + ods[f"equilibrium.time_slice[{i_time}].time"] = time / 1.e3 + if get_all == False: + return + kfiles = mdsvalue('d3d', treename=EFIT_tree, pulse=pulse, TDI="\\TOP.NAMELISTS.KEQDSKS").raw() # eq = from_mds_plus(device="d3d", shot=pulse, times=times, exact=True, snap_file=EFIT_tree, get_afile=False, get_mfile=True, show_missing_data_warnings=None, close=True) From b4b2ecf250cbf02dbe868a9c81064a4ff5a5c4fc Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Wed, 29 Mar 2023 15:59:24 -0700 Subject: [PATCH 20/26] More plotting tweaks --- omas/machine_mappings/d3d.json | 3 ++ omas/machine_mappings/d3d.py | 4 ++- omas/omas_physics.py | 7 +++-- omas/omas_plot.py | 50 ++++++++++++++++++++++------------ 4 files changed, 43 insertions(+), 21 deletions(-) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index 2b09b884f..6504f2a54 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -1142,6 +1142,9 @@ "equilibrium.time_slice.:.convergence.iterations_n": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, + "equilibrium.time_slice.:.global_quantities.area": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" + }, "equilibrium.time_slice.:.global_quantities.beta_normal": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index 4dd831f81..c0871b878 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1383,7 +1383,9 @@ def equilibrium_special(ods, pulse, EFIT_tree="EFIT", get_all=True): ods[f"equilibrium.code.parameters.time_slice.{time_index}.in1.plasma"]) > np.abs(0.08*ods[f"equilibrium.time_slice[{time_index}].global_quantities.ip"])): raise ValueError("Cannot reconstruct contraints, current constraints not met.") - ods[f"equilibrium.code.parameters.time_slice.{time_index}.inwant.vzeroj"] *= ods[f"equilibrium.time_slice[{time_index}].global_quantities.ip"] + ods[f"equilibrium.code.parameters.time_slice.{time_index}.inwant.vzeroj"] *= \ + ods[f"equilibrium.time_slice[{time_index}].global_quantities.ip"] /\ + ods[f"equilibrium.time_slice[{time_index}].global_quantities.area"] def add_extra_profile_structures(): extra_structures = {} diff --git a/omas/omas_physics.py b/omas/omas_physics.py index 9e778ecec..7df4c82a4 100644 --- a/omas/omas_physics.py +++ b/omas/omas_physics.py @@ -2494,7 +2494,7 @@ def search_in_array_structure(ods, conditions, no_matches_return=0, no_matches_r return match @add_to__ALL__ -def get_plot_scale_and_unit(phys_quant): +def get_plot_scale_and_unit(phys_quant, species=None): """ Returns normalizing scale for a physical quantity. E.g. "temprerature" returns 1.e-3 and keV @@ -2504,7 +2504,10 @@ def get_plot_scale_and_unit(phys_quant): if "temperature" in phys_quant: return 1.e-3, r"\mathrm{keV}" elif "density" in phys_quant : - return 1.e-19, r"\times 10^{19}\,\mathrm{m}^{-3}" + if species is not None and species not in ["H", "D", "He"]: + return 1.e-18, r"\times 10^{18}\,\mathrm{m}^{-3}" + else: + return 1.e-19, r"\times 10^{19}\,\mathrm{m}^{-3}" elif "velocity" in phys_quant: return 1.e-6, r"\mathrm{Mm}\,\mathrm{s}^{-1}" elif "e_field" in phys_quant: diff --git a/omas/omas_plot.py b/omas/omas_plot.py index 3f9c18cdd..3d181d6be 100644 --- a/omas/omas_plot.py +++ b/omas/omas_plot.py @@ -1028,11 +1028,12 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr if tmp['contour_quantity'] in eq['profiles_1d']: raw_xName = tmp['contour_quantity'] x = eq['profiles_1d'][raw_xName] + xName = nice_names.get(raw_xName, raw_xName) else: raw_xName = 'psi' x = ((eq['profiles_1d']['psi'] - eq['global_quantities']['psi_axis']) / ( eq['global_quantities']['psi_boundary'] - eq['global_quantities']['psi_axis'])) - xName = nice_names.get(raw_xName, raw_xName) + xName = r"$\Psi_\mathrm{n}$" # pressure ax = cached_add_subplot(fig, axs, 2, 3, 2) @@ -1118,7 +1119,6 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr xName, r'$FF\,^\prime$ [T$^2$ m$^2$ Wb$^{-1}$]', r"$FF\,^\prime$ source function", visible_x=True, **kw) - fig.tight_layout() return {'ax': axs} @add_to__ODS__ @@ -1172,7 +1172,6 @@ def core_profiles_currents_summary(ods, time_index=None, time=None, ax=None, **k ax.set_xlabel(r'$\rho_{tor}$') return {'ax': ax} - @add_to__ODS__ def core_profiles_summary(ods, time_index=None, time=None, fig=None, ods_species=None, quantities=['density_thermal', 'temperature'], @@ -1223,7 +1222,7 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, prof1d = ods['core_profiles']['profiles_1d'][time_index] if x_axis == "psi_norm": x = prof1d['grid.rho_pol_norm']**2 - x_label = r"$\Psi$" + x_label = r"$\Psi_\mathrm{n}$" else: x = prof1d[f'grid.{x_axis}'] if "tor" in x_axis: @@ -1236,8 +1235,14 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, ods_species = [-1] + list(prof1d['ion']) else: ncols = len(ods_species) - - nplots = sum([ncols if 'density' in i or 'temperature' in i else 1 for i in quantities]) + nplots = 0 + for quant in quantities: + if 'density' in quant or 'temperature' in quant: + nplots += ncols + elif 'velocity' in quant: + nplots += ncols - 1 + else: + nplots += 1 nrows = int(numpy.ceil(nplots / ncols)) # Generate species with corresponding name @@ -1253,9 +1258,12 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, if 'density' in q or 'temperature' in q or "velocity.toroidal" in q : for index, specie in enumerate(species_in_tree): #unit_list.append(omas_info_node(o2u(f"core_profiles.profiles_1d.0.{specie}.{q}"))['units']) - scale, unit = get_plot_scale_and_unit(q) - unit_list.append(unit) if q in prof1d[specie]: + if "label" in prof1d[specie]: + scale, unit = get_plot_scale_and_unit(q, prof1d[specie]["label"]) + else: + scale, unit = get_plot_scale_and_unit(q) + unit_list.append(unit) # if 'density' in q and 'ion' in specie and prof1d[specie]['element[0].z_n'] != 1.0: # plotting_list.append(prof1d[specie][q]*scale * prof1d[specie]['element[0].z_n']) # label_name_z.append(r'$\times$' + f" {int(prof1d[specie]['element[0].z_n'])}") @@ -1278,20 +1286,22 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, # else: # plotting_list.append(numpy.zeros(len(rho))) - else: + elif "e_field.radial" not in q: unit_list.append(omas_info_node(o2u(f"core_profiles.profiles_1d.0.{q}"))['units']) plotting_list.append(prof1d[q]) label_name.append(q.capitalize()) + data_list.append(None) if "e_field.radial" in quantities: try: scale, unit = get_plot_scale_and_unit("e_field.radial") unit_list.append(unit) - plotting_list.append(unumpy.uarray(prof1d["e_field.radial"]*scale, - prof1d["e_field.radial" + "_error_upper"]*scale)) + plotting_list.append(prof1d["e_field.radial"]*scale) label_name_z.append("") - label_name.append(r'$E_\mathrm{r}$') + label_name.append('e_field.radial') + data_list.append(None) except: pass + last_quant = None for index, y in enumerate(plotting_list): if index >= len(label_name): break @@ -1305,18 +1315,17 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, sharey = None sharex = None try: - if 'Density' in label_name[index] or 'Temperature' in label_name[index]: + if last_quant.split(" ")[-1] == label_name[index].split(" ")[-1]: sharex = ax sharey = ax - elif "Velocity" in label_name[index]: + else: sharex = ax sharey = None except: sharex = None sharey = None + last_quant = label_name[index] ax = cached_add_subplot(fig, axs, nrows, ncols, plot, sharex=sharex, sharey=sharey) - - uband(x, y, ax=ax, **kw) if data_list[index] is not None: mask = numpy.ones(data_list[index][0].shape, dtype=bool) # Remove NaNs @@ -1330,13 +1339,19 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, mask[numpy.abs(y_data_err[mask]) > numpy.abs(y_data[mask])] = False if numpy.any(mask): ax.errorbar(x_data[mask], y_data[mask], y_data_err[mask], - linestyle='', marker="+", color='red', **kw) + linestyle='', marker=".", color=(1.0, 0.0, 0.0, 0.3), zorder=-10, **kw) + uband(x, y, ax=ax, **kw) + species_label = label_name[index].split()[0] species_label = species_label.replace("electron", "e") if "Temp" in label_name[index]: ax.set_ylabel(r'$T_{{{}}}$'.format(species_label) + imas_units_to_latex(unit_list[index])) elif "Density" in label_name[index]: ax.set_ylabel(r'$n_{{{}}}$'.format(species_label) + imas_units_to_latex(unit_list[index]) + label_name_z[index]) + elif "e_field" in label_name[index].lower(): + ax.set_ylabel(r'$E_\mathrm{r}$' + imas_units_to_latex(unit_list[index])) + elif "Velocity" in label_name[index]: + ax.set_ylabel(r"$v_\mathrm{" + species_label[0] + r"}$" + imas_units_to_latex(unit_list[index])) else: ax.set_ylabel(label_name[index][:10] + imas_units_to_latex(unit_list[index])) if (nplots - plot) < ncols: @@ -1345,7 +1360,6 @@ def core_profiles_summary(ods, time_index=None, time=None, fig=None, if 'label' in kw: ax.legend(loc='lower center') ax.set_xlim(0, 1) - fig.tight_layout() return {'ax': axs, 'fig': fig} @add_to__ODS__ From c1149de6e1cd99d6f4693f6ceac6dac043ce6d9b Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Mon, 3 Apr 2023 21:18:24 -0700 Subject: [PATCH 21/26] Some bugfixes for caching working in omas_viewer --- omas/machine_mappings/d3d.json | 5 ++++- omas/machine_mappings/d3d.py | 4 ++-- omas/omas_plot.py | 2 +- 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index 6504f2a54..431da7211 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -343,6 +343,9 @@ "ece.line_of_sight.second_point.z": { "PYTHON": "electron_cyclotron_emission_hardware(ods, {pulse}, {fast_ece!r})" }, + "equilibrium": { + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" + }, "equilibrium.code": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r})" }, @@ -992,7 +995,7 @@ "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:": { - "PYTHON": "equilibirum_time(ods, {pulse}, {EFIT_tree!r})" + "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" }, "equilibrium.time_slice.:.boundary.outline.r": { "PYTHON": "equilibrium_special(ods, {pulse}, {EFIT_tree!r}, {get_all!r})" diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index c0871b878..849ec8f53 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1365,10 +1365,10 @@ def equilibrium_special(ods, pulse, EFIT_tree="EFIT", get_all=True): raise ValueError(f"Could not find any data in MDS+ for {pulse} and {EFIT_tree}") ods["equilibrium.ids_properties.homogeneous_time"] = 1 ods["equilibrium.time"]= times / 1.e3 - for i_time, time in enumerate(times): - ods[f"equilibrium.time_slice[{i_time}].time"] = time / 1.e3 if get_all == False: return + for i_time, time in enumerate(times): + ods[f"equilibrium.time_slice[{i_time}].time"] = time / 1.e3 kfiles = mdsvalue('d3d', treename=EFIT_tree, pulse=pulse, TDI="\\TOP.NAMELISTS.KEQDSKS").raw() # eq = from_mds_plus(device="d3d", shot=pulse, times=times, exact=True, snap_file=EFIT_tree, get_afile=False, get_mfile=True, diff --git a/omas/omas_plot.py b/omas/omas_plot.py index 3d181d6be..9350ca399 100644 --- a/omas/omas_plot.py +++ b/omas/omas_plot.py @@ -1088,7 +1088,7 @@ def equilibrium_summary(ods, time_index=None, time=None, fig=None, ggd_points_tr diag_chi_2 = [] labels = [] try: - diag_chi_2.append(eq[f'constraints.pf_current[:].chi_squared']) + diag_chi_2 += list(eq[f'constraints.pf_current[:].chi_squared'].flatten()) for i in range(len(diag_chi_2)): labels.append("PF coil " + ods[f'pf_active.coil[[{i}].identifier']) except: From 7fa7ea8a5bd0ec1a6404fffbcc8b93966ce607ea Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Tue, 16 May 2023 12:47:21 -0700 Subject: [PATCH 22/26] Enabled ece to be used by machine_to_omas --- omas/machine_mappings/d3d.json | 3 +++ 1 file changed, 3 insertions(+) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index 431da7211..0e0cb5610 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -305,6 +305,9 @@ "ec_launchers.beam.:.time": { "PYTHON": "ec_launcher_active_hardware(ods, {pulse})" }, + "ece": { + "PYTHON": "electron_cyclotron_emission_hardware(ods, {pulse}, {fast_ece!r})" +}, "ece.channel.:": { "PYTHON": "electron_cyclotron_emission_hardware(ods, {pulse}, {fast_ece!r})" }, From bc520b97b7e37f8496f17c14aae509307c0f5dfa Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Wed, 21 Jun 2023 13:15:41 -0700 Subject: [PATCH 23/26] extra ece --- omas/machine_mappings/d3d.json | 7 +++++-- omas/machine_mappings/d3d.py | 8 +++++++- 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/omas/machine_mappings/d3d.json b/omas/machine_mappings/d3d.json index 0e0cb5610..39442dbac 100644 --- a/omas/machine_mappings/d3d.json +++ b/omas/machine_mappings/d3d.json @@ -306,8 +306,8 @@ "PYTHON": "ec_launcher_active_hardware(ods, {pulse})" }, "ece": { - "PYTHON": "electron_cyclotron_emission_hardware(ods, {pulse}, {fast_ece!r})" -}, + "PYTHON": "electron_cyclotron_emission_hardware(ods, {pulse}, {fast_ece!r})" + }, "ece.channel.:": { "PYTHON": "electron_cyclotron_emission_hardware(ods, {pulse}, {fast_ece!r})" }, @@ -323,6 +323,9 @@ "ece.channel.:.t_e.data": { "PYTHON": "electron_cyclotron_emission_data(ods, {pulse}, {fast_ece!r})" }, + "ece.channel.:.t_e.data_error_upper": { + "PYTHON": "electron_cyclotron_emission_data(ods, {pulse}, {fast_ece!r})" + }, "ece.channel.:.time": { "PYTHON": "electron_cyclotron_emission_hardware(ods, {pulse}, {fast_ece!r})" }, diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index 849ec8f53..00a35bf90 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -778,6 +778,11 @@ def electron_cyclotron_emission_data(ods, pulse=133221, fast_ece=False, _measure for ich in range(1, N_ch + 1): query[f'T{ich}'] = TECE + '{0:02d}'.format(ich) ece_data = mdsvalue('d3d', treename='ELECTRONS', pulse=pulse, TDI=query).raw() + ece_uncertainty = {} + for key in ece_data: + # Calculate uncertainties and convert to eV + # Assumes 7% calibration error (optimisitic) + Poisson uncertainty + ece_uncertainty[key] = np.sqrt(np.abs(ece_data[key] * 1.e3)) + 70 * np.abs(ece_data[key]) # Not in mds+ if not _measurements: @@ -798,7 +803,8 @@ def electron_cyclotron_emission_data(ods, pulse=133221, fast_ece=False, _measure for ich in range(N_ch): ch = ods['ece']['channel'][ich] if _measurements: - ch['t_e']['data'] = ece_data[f'T{ich + 1}'] * 1.0e3 + ch['t_e']['data'] = unumpy.uarray(ece_data[f'T{ich + 1}'] * 1.0e3, + ece_uncertainty[f'T{ich + 1}'] )# Already converted else: ch['name'] = 'ECE' + str(ich + 1) ch['identifier'] = TECE + '{0:02d}'.format(ich + 1) From 0ca0f7ff3416fc51366126695598b60f0ddbfaf8 Mon Sep 17 00:00:00 2001 From: Sterling Smith Date: Fri, 25 Oct 2024 06:30:47 -0700 Subject: [PATCH 24/26] machine_mappings:d3d:Get equilibrium times from the gfile times, not kfile times --- omas/machine_mappings/d3d.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/omas/machine_mappings/d3d.py b/omas/machine_mappings/d3d.py index 849ec8f53..091800953 100644 --- a/omas/machine_mappings/d3d.py +++ b/omas/machine_mappings/d3d.py @@ -1359,7 +1359,7 @@ def equilibirum_time(ods, pulse, EFIT_tree="EFIT"): @machine_mapping_function(__regression_arguments__, pulse=19438702, EFIT_tree="EFIT", get_all=True) def equilibrium_special(ods, pulse, EFIT_tree="EFIT", get_all=True): from omfit_classes.omfit_eqdsk import from_mds_plus, OMFITkeqdsk - times = mdsvalue('d3d', treename=EFIT_tree, pulse=pulse, TDI="\\TOP.NAMELISTS.KEQDSKS.KTIME").raw() + times = mdsvalue('d3d', treename=EFIT_tree, pulse=pulse, TDI="\\TOP.RESULTS.GEQDSK.GTIME").raw() if times is None: print("No mds+ data") raise ValueError(f"Could not find any data in MDS+ for {pulse} and {EFIT_tree}") From e5951b9544660f562cbf05a2a934da079bba1818 Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Mon, 6 Jan 2025 10:13:52 -0800 Subject: [PATCH 25/26] Shutdown Mongo client in test --- omas/tests/failed_imports.py | 1 + 1 file changed, 1 insertion(+) diff --git a/omas/tests/failed_imports.py b/omas/tests/failed_imports.py index f3b72c0a6..f570bc237 100644 --- a/omas/tests/failed_imports.py +++ b/omas/tests/failed_imports.py @@ -57,6 +57,7 @@ up = get_mongo_credentials(server=omas_rcparams['default_mongo_server']) client = MongoClient(omas_rcparams['default_mongo_server'].format(**up), serverSelectionTimeoutMS=1000) client.server_info() + client.close() failed_MONGO = False except (ImportError, ServerSelectionTimeoutError) as _excp: failed_MONGO = _excp From 6cd43a828095c188be114f260d447f302936a6bd Mon Sep 17 00:00:00 2001 From: AreWeDreaming Date: Mon, 6 Jan 2025 10:58:28 -0800 Subject: [PATCH 26/26] Adjust to matplotlib API change --- omas/omas_plot.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/omas/omas_plot.py b/omas/omas_plot.py index d9a31e314..825bf8413 100644 --- a/omas/omas_plot.py +++ b/omas/omas_plot.py @@ -843,8 +843,11 @@ def get2d(contour_quantity): # Internal flux surfaces w/ or w/o masking if wall is not None: - for collection in cs.collections: - collection.set_clip_path(wall_path) + if hasattr(cs, "collections"): # Matplotlib < 3.10 + for collection in cs.collections: + collection.set_clip_path(wall_path) + else: + cs.set_clip_path(wall_path) # Wall if wall is not None and show_wall: