def reset(self, noLoad=True, light=False): # Does not reset Config or Scenario self.status = 0 self.edition = 0 self.init = False # Edition of this result # Remains zero until the result is saved # Time of the results, should be identical to self.Scenario.plasma_dict["time"] # This holds the same information as the scenario self.modes = None self.comment = "" self["dimensions"] = {} self["dimensions"]["N_LOS"] = [] self["git"] = {} for key in self.result_keys: if (key in ["dimensions"]): continue self.failed_keys[key] = [] self[key] = {} if (key in self.sub_keys): for sub_key in self.sub_keys[key]: self[key][sub_key] = [] if (not light): self.Config = ECRadConfig(noLoad=noLoad) self.Scenario = ECRadScenario(noLoad=noLoad) self.data_origin = None
def LoadFromOMAS(self, evt): dlg = wx.FileDialog(\ self, message="Choose an OMAS file", \ defaultDir=self.working_dir, \ wildcard=("Pickle and Netcdf4 files (*.pkl;*.nc)|*.pkl;*.nc"), style=wx.FD_OPEN) if(dlg.ShowModal() == wx.ID_OK): path = dlg.GetPath() NewSceario = ECRadScenario(noLoad=True) try: from omas import ODS ods = ODS() ods.load(path) NewSceario.set_up_launch_from_imas(ods) newExtDiag = EXT_diag("EXT") if(len( ods['ece']['channel']['time']) == 1): itime = 0 else: timepoint_dlg = Select_Raylaunch_timepoint(self, ods['ece']['channel']['time']) if(not (timepoint_dlg.ShowModal() == wx.ID_OK)): print("Aborted") return itime = timepoint_dlg.itime except Exception as e: print("ERROR: Failed to load launch from OMAS") print(e) return newExtDiag.set_from_scenario_diagnostic(NewSceario["diagnostic"], itime, set_only_EXT=False) NewSceario.avail_diags_dict.update({"EXT": newExtDiag}) curScenario = self.GetCurScenario() curScenario["avail_diags_dict"].update({"EXT": newExtDiag}) curScenario["used_diags_dict"].update({"EXT": newExtDiag}) self.SetScenario(curScenario, self.working_dir)
def GenExtFromOld(self, evt): dlg = wx.FileDialog(\ self, message="Choose a preexisting calculation", \ defaultDir=self.working_dir, \ wildcard=("Matlab and Netcdf4 files (*.mat;*.nc)|*.mat;*.nc"), style=wx.FD_OPEN) if(dlg.ShowModal() == wx.ID_OK): path = dlg.GetPath() NewSceario = ECRadScenario(noLoad=True) NewSceario.load(filename=path) newExtDiag = EXT_diag("EXT") if(len(NewSceario["time"]) == 1): itime = 0 else: timepoint_dlg = Select_Raylaunch_timepoint(self, NewSceario["time"]) if(not (timepoint_dlg.ShowModal() == wx.ID_OK)): print("Aborted") return itime = timepoint_dlg.itime newExtDiag.set_from_scenario_diagnostic(NewSceario["diagnostic"], itime, set_only_EXT=False) NewSceario["avail_diags_dict"].update({"EXT": newExtDiag}) curScenario = self.GetCurScenario() curScenario["avail_diags_dict"].update({"EXT": newExtDiag}) curScenario["used_diags_dict"].update({"EXT": newExtDiag}) self.SetScenario(curScenario, self.working_dir)
def LoadLaunch(self, evt): dlg = wx.FileDialog(\ self, message="Choose a preexisting calculation", \ defaultDir=self.working_dir, \ wildcard=("Matlab and Netcdf4 files (*.mat;*.nc)|*.mat;*.nc"), style=wx.FD_OPEN) if(dlg.ShowModal() == wx.ID_OK): path = dlg.GetPath() NewScenario = ECRadScenario(noLoad=True) NewScenario.load(filename=path) self.SetScenario(NewScenario, os.path.dirname(path))
def GetCurScenario(self): Scenario = ECRadScenario(noLoad=True) Scenario["avail_diags_dict"] = self.Notebook.UpdateDiagDict(Scenario["avail_diags_dict"]) for Diagkey in self.diag_cb_dict: if(self.diag_cb_dict[Diagkey].GetValue()): Scenario["used_diags_dict"].update({Diagkey : Scenario["avail_diags_dict"][Diagkey]}) return Scenario
def LoadFromIMAS(self, evt): dlg = IMASSelectDialog(self) if(dlg.ShowModal() == wx.ID_OK): ids = dlg.ids check=ids.open() if check[0]!=0: print('ERROR: Could not open the IMAS file with plasma') return try: ece_ids = ids.get('ece') except Exception as e: print(e) print("ERROR: Cannot access ECE in IDS") return NewSceario = ECRadScenario(noLoad=True) try: NewSceario.set_up_launch_from_imas(ece_ids) newExtDiag = EXT_diag("EXT") if(len( ids['ece']['channel']['time']) == 1): itime = 0 else: timepoint_dlg = Select_Raylaunch_timepoint(self, ids['ece']['channel']['time']) if(not (timepoint_dlg.ShowModal() == wx.ID_OK)): print("Aborted") return itime = timepoint_dlg.itime except Exception as e: print("ERROR: Failed to load launch from IMAS!") print("ERROR: There are probably required entries missing in the IDS") print(e) return newExtDiag.set_from_scenario_diagnostic(NewSceario["diagnostic"], itime, set_only_EXT=False) NewSceario.avail_diags_dict.update({"EXT": newExtDiag}) curScenario = self.GetCurScenario() curScenario["avail_diags_dict"].update({"EXT": newExtDiag}) curScenario["used_diags_dict"].update({"EXT": newExtDiag}) self.SetScenario(curScenario, self.working_dir) dlg.Destroy()
def set_launch_in_Scenario(scenario_file_in, scenario_file_out, launch_dict): Scenario = ECRadScenario(noLoad=True) Scenario.load(scenario_file_in) for key in Scenario["diagnostic"]: Scenario["diagnostic"][key] = [] for time in Scenario["time"]: Scenario["diagnostic"][key].append(launch_dict[key]) Scenario["diagnostic"][key] = np.array(Scenario["diagnostic"][key]) Scenario['diagnostic']["diag_name"] = np.array( Scenario["diagnostic"]["f"].shape, dtype="|S3") Scenario['diagnostic']["diag_name"][:] = "EXT" Scenario.to_netcdf(filename=scenario_file_out)
def __init__(self, Result=None, Scenario_file=None, Config_file=None): ''' Constructor ''' if (Result is None): if (Scenario_file is None or Config_file is None): raise ValueError( "Either result or a Scenario and Config file must be present" ) else: self.Result = ECRadResults() self.Result.Scenario = ECRadScenario(noLoad=True) self.Result.Scenario.load(Scenario_file) self.Result.Config = ECRadConfig(noLoad=True) self.Result.Config.load(Config_file) else: self.Result = Result self.ECRad_F2PY_interface = ECRadF2PYInterface()
class ECRadResults(dict): def __init__(self, lastused=False): self.result_keys = [ "Trad", "resonance", "ray", "BPD", "weights", "dimensions" ] self.shapes = {} self.units = {} self.scales = {} self.xaxis_link = {} self.legend_entries = {} self.labels = {} self.sub_keys = {} self.graph_style = {} self.failed_keys = {} # Mode order is mixed, X, O self.sub_keys["Trad"] = ["Trad", "tau", "T", \ "Trad_second", "tau_second", "T_second"] self.shapes["Trad"] = ["N_time", "N_mode_mix", "N_ch"] self.units["Trad"] = {"Trad":"keV", "tau":"", "T":"", \ "Trad_second":"keV", "tau_second":"", "T_second":""} self.scales["Trad"] = {"Trad":1.e-3, "tau":1.0, "T":1.0, \ "Trad_second":1.e-3, "tau_second":1.0, "T_second":1.0} self.xaxis_link["Trad"] = ["resonance", "Trad"] self.legend_entries["Trad"] = {"Trad":r"$T_" + globalsettings.mathrm + r"{rad}$", "tau":r"$\tau$", "T":r"$T$", \ "Trad_second":r"$T_" + globalsettings.mathrm + r"{rad,2nd\,model}$", \ "tau_second":r"$\tau_" + globalsettings.mathrm + r"{2nd\,model}$", "T_second":r"$T_" + globalsettings.mathrm + r"{2nd\,model}$"} self.labels["Trad"] = {"Trad":r"$T_" + globalsettings.mathrm + r"{rad}$", "tau":r"$\tau$", "T":r"$T$", \ "Trad_second":r"$T_" + globalsettings.mathrm + r"{rad}$", "tau_second":r"$\tau$", "T_second":r"$T$"} self.graph_style["Trad"] = "point" self.sub_keys["resonance"] = ["s_cold", "R_cold", "z_cold", \ "rhop_cold", "rhot_cold", "s_warm", "R_warm", \ "z_warm", "rhop_warm", "rhot_warm", \ "s_warm_second", "R_warm_second", \ "z_warm_second", "rhop_warm_second", \ "rhot_warm_second"] # You want the channel as the inner most index since you want to plot as a function of channel self.shapes["resonance"] = ["N_time", "N_mode_mix", "N_ch"] self.units["resonance"] = {} self.scales["resonance"] = {} for sub_key in self.sub_keys["resonance"]: if (sub_key.startswith("rho")): self.units["resonance"][sub_key] = "" else: self.units["resonance"][sub_key] = "m" self.scales["resonance"][sub_key] = 1.0 self.xaxis_link["resonance"] = ["Trad", "resonance"] self.legend_entries["resonance"] = {"s_cold":r"$s_" + globalsettings.mathrm + r"{cold}$", \ "R_cold":r"$R_" + globalsettings.mathrm + r"{cold}$", \ "z_cold":r"$z_" + globalsettings.mathrm + r"{cold}$", \ "rhop_cold":r"$\rho_" + globalsettings.mathrm + r"{pol,cold}$", \ "rhot_cold":r"$\rho_" + globalsettings.mathrm + r"{tor,cold}$", \ "s_warm":r"$s_" + globalsettings.mathrm + r"{warm}$", \ "R_warm":r"$R_" + globalsettings.mathrm + r"{warm}$", \ "z_warm":r"$z_" + globalsettings.mathrm + r"{warm}$", \ "rhop_warm":r"$\rho_" + globalsettings.mathrm + r"{pol,warm}$", \ "rhot_warmd":r"$\rho_" + globalsettings.mathrm + r"{tor,warm}$", \ "s_warm_second":r"$s_" + globalsettings.mathrm + r"{warm,\,2nd\,model}$", \ "R_warm_second":r"$R_" + globalsettings.mathrm + r"{warm,\,2nd\,model}$", \ "z_warm_second":r"$z_" + globalsettings.mathrm + r"{warm,\,2nd\,model}$", \ "rhop_warm_second":r"$\rho_" + globalsettings.mathrm + r"{pol,warm,\,2nd\,model}$", \ "rhot_warm_second":r"$\rho_" + globalsettings.mathrm + r"{tor,warm,\,2nd\,model}$"} self.labels["resonance"] = {"s_cold":r"$s_" + globalsettings.mathrm + r"{cold}$", \ "R_cold":r"$R_" + globalsettings.mathrm + r"{cold}$", \ "z_cold":r"$z_" + globalsettings.mathrm + r"{cold}$", \ "rhop_cold":r"$\rho_" + globalsettings.mathrm + r"{pol,cold}$", \ "rhot_cold":r"$\rho_" + globalsettings.mathrm + r"{tor,cold}$", \ "s_warm":r"$s_" + globalsettings.mathrm + r"{warm}$", \ "R_warm":r"$R_" + globalsettings.mathrm + r"{warm}$", \ "z_warm":r"$z_" + globalsettings.mathrm + r"{warm}$", \ "rhop_warm":r"$\rho_" + globalsettings.mathrm + r"{pol,warm}$", \ "rhot_warmd":r"$\rho_" + globalsettings.mathrm + r"{tor,warm}$", \ "s_warm_second":r"$s_" + globalsettings.mathrm + r"{warm}$", \ "R_warm_second":r"$R_" + globalsettings.mathrm + r"{warm}$", \ "z_warm_second":r"$z_" + globalsettings.mathrm + r"{warm}$", \ "rhop_warm_second":r"$\rho_" + globalsettings.mathrm + r"{pol,warm}$", \ "rhot_warm_second":r"$\rho_" + globalsettings.mathrm + r"{tor,warm}$"} self.graph_style["resonance"] = "point" self.sub_keys["ray"] = ["s", "x", "y", "R", "z", \ "Nx", "Ny", "Nz", \ "Bx", "By", "Bz", \ "H", "N", "Nc", \ "X", "Y", "rhop", "rhot" ,\ "Te", "ne", \ "theta", "BPD", \ "BPD_second", "Trad", "Trad_second", "em", \ "em_second", "ab", \ "ab_second", \ "T", "T_second", \ "v_g_perp"] self.shapes["ray"] = ["N_time", "N_ch", "N_mode", "N_ray", "N_LOS"] self.legend_entries["ray"] = {"s":r"$s$", "x":r"$x$", "y":r"$y$", "R":r"$R$", "z":r"$z$", \ "Nx":r"$N_" + globalsettings.mathrm + r"{x}$", "Ny":r"$N_" + globalsettings.mathrm + r"{y}$", \ "Nz":r"$N_" + globalsettings.mathrm + r"{z}$", "Bx":r"$B_" + globalsettings.mathrm + r"{x}$", \ "By":r"$B_" + globalsettings.mathrm + r"{y}$", "Bz":r"$B_" + globalsettings.mathrm + r"{z}$", \ "H":r"Hamiltonian", "N":r"$N_" + globalsettings.mathrm + r"{ray}$", \ "Nc":r"$N_" + globalsettings.mathrm + r"{disp}$", "X":r"Stix Parameter $X$", \ "Y":r"Stix Parameter $Y$", "rhop":r"$\rho_" + globalsettings.mathrm + r"{pol}$", \ "rhot":r"$\rho_" + globalsettings.mathrm + r"{tor}$", "Te":r"$T_" + globalsettings.mathrm + r"{e}$", \ "ne":r"$n_" + globalsettings.mathrm + r"{e}$", "theta":r"$\theta$", \ "BPD":"BPD", "BPD_second":"BPD$_" + globalsettings.mathrm + r"{2nd\,model}$", \ "Trad":r"$T_" + globalsettings.mathrm + r"{rad}$", "Trad_second":r"$T_" + globalsettings.mathrm + r"{rad,\,2nd\,model}}$", \ "em":r"$j$", \ "em_second":r"$j_{" + globalsettings.mathrm + r"{2nd\,model}}$", "ab":r"$\alpha$", \ "ab_second":r"$\alpha_{" + globalsettings.mathrm + r"{2nd\,model}}$", "T":r"$\mathcal{T}$", \ "T_second":r"$\mathcal{T}_{" + globalsettings.mathrm + r"{2nd\,model}}$", "v_g_perp":r"$v_{" + globalsettings.mathrm + r"{g},\perp}$"} self.labels["ray"] = {"s":r"$s$", "x":r"$x$", "y":r"$y$", "R":r"$R$", "z":r"$z$", \ "Nx":r"$N_" + globalsettings.mathrm + r"{x}$", "Ny":r"$N_" + globalsettings.mathrm + r"{y}$", \ "Nz":r"$N_" + globalsettings.mathrm + r"{z}$", "Bx":r"$B_" + globalsettings.mathrm + r"{x}$", \ "By":r"$B_" + globalsettings.mathrm + r"{y}$", "Bz":r"$B_" + globalsettings.mathrm + r"{z}$", \ "H":r"Hamiltonian", "N":r"$N_" + globalsettings.mathrm + r"{ray}$", \ "Nc":r"$N_" + globalsettings.mathrm + r"{disp}$", "X":r"Stix Parameter $X$", \ "Y":r"Stix Parameter $Y$", "rhop":r"$\rho_" + globalsettings.mathrm + r"{pol}$", \ "rhot":r"$\rho_" + globalsettings.mathrm + r"{tor}$", "Te":r"$T_" + globalsettings.mathrm + r"{e}$", \ "ne":r"$n_" + globalsettings.mathrm + r"{e}$", "theta":r"$\theta$", \ "BPD":"BPD", "BPD_second":"BPD", \ "Trad":r"$T_" + globalsettings.mathrm + r"{rad}$", "Trad_second":r"$T_" + globalsettings.mathrm + r"{rad}$", \ "em":r"$j_\omega$", \ "em_second":r"$j_\omega$", "ab":r"$\alpha_\omega$", \ "ab_second":r"$\alpha_\omega$", "T":r"$\mathcal{T}_\omega$", \ "T_second":r"$\mathcal{T}_\omega$", "v_g_perp":r"$v_{" + globalsettings.mathrm + r"{g},\perp}$"} self.units["ray"] = {"s":"m", "x":"m", "y":"m", "R":"m", "z":"m", \ "Nx":"", "Ny":"", "Nz":"", \ "Bx":"T", "By":"T", "Bz":"T", \ "H":"", "N":"", "Nc":"", \ "X":"", "Y":"", \ "rhop":"", "rhot":"",\ "Te":r"keV", "ne":r"$10^{19}$m$^{-3}$", \ "theta":r"$^\circ$", "BPD":r"m$^{-1}$", \ "BPD_second":r"m$^{-1}$", \ "Trad":r"keV", "Trad_second":r"keV", \ "em":r"nW m$^{-3}$", \ "em_second":r"nW m$^{-3}$", "ab":r"m$^{-1}$", \ "ab_second":r"m$^{-1}$", \ "T":"", "T_second":"", \ "v_g_perp":""} self.scales["ray"] = {"s":1, "x":1, "y":1, "R":1, "z":1, \ "Nx":1, "Ny":1, "Nz":1, \ "Bx":1, "By":1, "Bz":1, \ "H":1, "N":1, "Nc":1, \ "X":1, "Y":1, \ "rhop":1, "rhot":1, \ "Te":1.e-3, "ne":1.e-19, \ "theta":np.rad2deg(1), "BPD":1, \ "BPD_second":1, \ "Trad":1.e-3, "Trad_second":1.e-3, \ "em":1.e9, \ "em_second":1.e9, "ab":1, \ "ab_second":1, \ "T":1, "T_second":1, \ "v_g_perp":1.0/cnst.speed_of_light} self.xaxis_link["ray"] = ["ray"] self.graph_style["ray"] = "line" self.sub_keys["BPD"] = ["rhop", "rhot", "BPD", "BPD_second"] self.scales["BPD"] = { "rhop": 1.0, "rhot": 1.0, "BPD": 1.0, "BPD_second": 1.0 } self.labels["BPD"] = {"rhop":r"$\rho_" + globalsettings.mathrm + r"{pol}$", "rhot":r"$\rho_" + globalsettings.mathrm + r"{tor}$", \ "BPD":"BPD","BPD_second":"BPD"} self.legend_entries["BPD"] = {"rhop":r"$\rho_" + globalsettings.mathrm + r"{pol}$", "rhot":r"$\rho_" + globalsettings.mathrm + r"{tor}$", \ "BPD":"BPD","BPD_second":"BPD$_" + globalsettings.mathrm + r"{2nd\,model}$"} self.units["BPD"] = {"rhop":"", "rhot":"", "BPD":"m$^{-1}$", \ "BPD_second":"m$^{-1}$"} self.xaxis_link["BPD"] = ["BPD"] self.shapes["BPD"] = ["N_time", "N_ch", "N_mode_mix", "N_BPD"] self.graph_style["BPD"] = "line" self.sub_keys["weights"] = [ "mode_frac", "mode_frac_second", "ray_weights", "freq_weights" ] self.units["weights"] = {} self.scales["weights"] = {} self.graph_style["weights"] = "point" for sub_key in self.sub_keys["weights"]: self.units["weights"][sub_key] = r'$\%$' self.scales["weights"][sub_key] = 1.e2 self.labels["weights"] = {"mode_frac":r"Mode contribution", "mode_frac_second":"Mode contribution", \ "ray_weights":"ray weight","freq_weights":"frequency weight"} self.legend_entries["weights"] = {"mode_frac":r"Mode contribution", "mode_frac_second":"Mode contribution", \ "ray_weights":"ray weight","freq_weights":"frequency weight"} # The weights have a lot of different shapes need to store those by sub_key self.shapes["mode_frac"] = ["N_time", "N_mode", "N_ch"] self.shapes["mode_frac_second"] = ["N_time", "N_mode", "N_ch"] self.shapes["ray_weights"] = ["N_time", "N_ch", "N_ray"] self.shapes["freq_weights"] = ["N_time", "N_ch", "N_freq"] self.xaxis_link["weights"] = ["weights"] self.graph_style["BPD"] = "line" self["git"] = { "ECRad": "Unknoiwn", "GUI": "Unknoiwn", "Pylib": "Unknoiwn" } self["types"] = {} for key in self.result_keys: if (key == 'dimensions'): self["types"][key] = "int" else: self["types"][key] = "float" for key in self.units.keys(): for sub_key in self.units[key].keys(): if (len(self.units[key][sub_key]) > 0): self.units[key][ sub_key] = "[" + self.units[key][sub_key] + "]" self.reset(not lastused) def reset(self, noLoad=True, light=False): # Does not reset Config or Scenario self.status = 0 self.edition = 0 self.init = False # Edition of this result # Remains zero until the result is saved # Time of the results, should be identical to self.Scenario.plasma_dict["time"] # This holds the same information as the scenario self.modes = None self.comment = "" self["dimensions"] = {} self["dimensions"]["N_LOS"] = [] self["git"] = {} for key in self.result_keys: if (key in ["dimensions"]): continue self.failed_keys[key] = [] self[key] = {} if (key in self.sub_keys): for sub_key in self.sub_keys[key]: self[key][sub_key] = [] if (not light): self.Config = ECRadConfig(noLoad=noLoad) self.Scenario = ECRadScenario(noLoad=noLoad) self.data_origin = None def load(self, filename): if (filename is not None): ext = os.path.splitext(filename)[1] if (ext == ".mat"): self.from_mat(filename=filename) elif (ext == ".nc"): self.from_netcdf(filename=filename) else: print("Extension " + ext + " is unknown") raise (ValueError) def tidy_up(self, autosave=True): if (self.status != 0): return # Put everything into numpy arrays for key in self.result_keys: if (key in ["dimensions", "git", "types"]): continue for sub_key in self.sub_keys[key]: self[key][sub_key] = np.array(self[key][sub_key]) # Autosave results self["git"]["ECRad"] = np.genfromtxt(os.path.join( globalsettings.ECRadRoot, "id"), dtype=str).item() self["git"]["GUI"] = np.genfromtxt(os.path.join( globalsettings.ECRadGUIRoot, "id"), dtype=str).item() self["git"]["Pylib"] = np.genfromtxt(os.path.join( globalsettings.ECRadPylibRoot, "id"), dtype=str).item() self.data_origin = "ECRad" if (autosave): self.autosave() def autosave(self, filename=None): self.to_netcdf(filename) def get_shape(self, key, start=None, stop=None,i_time=None, \ i_ch=None, i_mode=None, i_ray=None): shape = () for dim_ref in self.shapes[key][start:stop]: if (np.isscalar(self["dimensions"][dim_ref])): shape += (self["dimensions"][dim_ref], ) else: # Cannot use numpy indexing here because the time dimension # will be appended as we go shape += (self["dimensions"][dim_ref][i_time][i_ch, i_mode, i_ray], ) return shape def get_index_reference(self, key, sub_key, ndim, index): # Retrieves the value this particular index refers to # used in plotting to label graphs. # The routine formats the quantity and returns a string # Note that the index should have the shape corresponding to the requested quantity if (key != "weights"): dim_ref = self.shapes[key][ndim] else: dim_ref = self.shapes[sub_key][ndim] if (dim_ref == "N_time"): return r"$t = $ " + "{0:1.3f}".format( self.Scenario["time"][index[ndim]]) + " s" elif (dim_ref == "N_ch"): return r"$f = $ " + "{0:3.1f}".format( self.Scenario["diagnostic"]["f"][index[0]][index[ndim]] / 1.e9) + " GHz" elif (dim_ref in ["N_mode"]): if (self.Config["Physics"]["considered_modes"] == 1): return "X-mode" elif (self.Config["Physics"]["considered_modes"] == 2): return "O-mode" else: if (index[ndim] == 0): return "X-mode" else: return "O-mode" elif (dim_ref == "N_mode_mix"): if (self.Config["Physics"]["considered_modes"] < 3): return "" else: if (index[ndim] == 1): return "X-mode" elif (index[ndim] == 2): return "O-mode" else: return "" elif (dim_ref == "N_ray"): if (index[ndim] == 0): return "" else: return r"ray \#" + str(index[ndim] + 1) else: raise ValueError( "ECRadResults.get_index_reference could unexpected dim ref " + key + " " + sub_key + " " + str(ndim)) def set_dimensions(self): # Sets the dimensions from Scenario and Configself["dimensions"]["N_time"] = len(self.Scenario.plasma_dict["time"]) self["dimensions"]["N_time"] = self.Scenario["dimensions"]["N_time"] self["dimensions"]["N_ray"] = self.Config["Physics"]["N_ray"] self["dimensions"]["N_freq"] = self.Config["Physics"]["N_freq"] self["dimensions"]["N_BPD"] = self.Config["Numerics"]["N_BPD"] self["dimensions"]["N_ch"] = self.Scenario["dimensions"]["N_ch"] if (self.Config["Physics"]["considered_modes"] > 2): self["dimensions"]["N_mode"] = 2 self["dimensions"]["N_mode_mix"] = 3 modes_mix = ["", "X", "O"] modes = ["X", "O"] else: self["dimensions"]["N_mode"] = 1 self["dimensions"]["N_mode_mix"] = 1 modes = ["X"] if (self.Config["Physics"]["considered_modes"] == 2): modes = ["O"] modes_mix = [""] self["dimensions"]["N_ch"] = self.Scenario["dimensions"]["N_ch"] return modes, modes_mix def from_mat(self, filename): try: mdict = loadmat(filename, chars_as_strings=True, squeeze_me=True) except IOError as e: print(e) print("Error: " + filename + " does not exist") return self.Config.from_mat(mdict=mdict) self.Scenario.from_mat(mdict=mdict, load_plasma_dict=True) self.edition = mdict["edition"] # We need to do this song and dance because # 3D equlibria use rho tor instead of rho pol # This was not clearly indicated in the old # .mat files, but the new result files distinguish this. # Further cases are marked with #3D rhot if (self.Scenario["plasma"]["eq_dim"] == 3): rho = "rhot" else: rho = "rhop" if ("comment" in mdict): self.comment = mdict["comment"] try: if (type(self.comment) == np.ndarray): if (len(self.comment) > 0): self.comment = self.comment[0] else: self.comment = "" except Exception as e: print("Failed to parse comment") print(e) self.comment = "" modes, modes_mix = self.set_dimensions() for key in ["Trad"]: for sub_key in self.sub_keys[key]: self[key][sub_key] = np.zeros(self.get_shape(key)) for i_mode, mode in enumerate(modes_mix): if (sub_key == "T"): self[key][sub_key] = np.exp(-self["Trad"]["tau"]) continue elif (sub_key == "T_second"): self[key][sub_key] = np.exp( -self["Trad"]["tau_second"]) continue mdict_key = sub_key.replace("second", "comp") self[key][sub_key][...,i_mode,:] = mdict[mode+mdict_key].reshape(self.get_shape(key,stop=1) + \ self.get_shape(key,start=2)) *1.e3 if (self["dimensions"]["N_mode"] > 1): mode_info_printed = False # mode resolved resonances are not available in .mat files for key in ["resonance"]: for sub_key in self.sub_keys[key]: self[key][sub_key] = np.zeros(self.get_shape(key)) if (sub_key.endswith("second")): formatted_key = sub_key + "ary" else: formatted_key = sub_key #3D rhot if (rho == "rhot" and sub_key.startswith("rhot")): formatted_key = formatted_key.replace("rhot", "rhop") elif (rho == "rhot" and formatted_key.startswith("rhop")): continue try: self[key][sub_key][...,0,:] = mdict[formatted_key].reshape(self.get_shape(key,stop=1) + \ self.get_shape(key,start=2)) if (not mode_info_printed): print( "INFO:: No mode specific resonances in .mat files. Using mixed modes for all resonances." ) mode_info_printed = True for imode in range(1, 3): self[key][sub_key][ ..., imode, :] = self[key][sub_key][..., 0, :] except KeyError: print("INFO: Couldn't load " + sub_key + " from result file") else: for key in ["resonance"]: for sub_key in self.sub_keys[key]: if (sub_key.endswith("second")): formatted_key = sub_key + "ary" else: formatted_key = sub_key #3D rhot if (rho == "rhot" and sub_key.startswith("rhot")): formatted_key = formatted_key.replace("rhot", "rhop") elif (rho == "rhot" and formatted_key.startswith("rhop")): continue try: self[key][sub_key] = mdict[formatted_key].reshape( self.get_shape(key)) except KeyError: print("INFO: Couldn't load " + sub_key + " from result file") self["dimensions"]["N_LOS"] = np.zeros(self.get_shape("ray", 0, -1), dtype=np.int) # We need to fix the shape of the mdict ray info key = "ray" for sub_key in self.sub_keys[key]: for mode in modes: if(sub_key in ["em", "ab", "T", "BPD", "Trad", "Trad_second",\ "em_second", "ab_second", "T_second", "BPD_second"]): mdict_key = "ray_" + sub_key #3D rhot elif (sub_key == "rhot" and rho == "rhot"): mdict_key = "rhop" elif (sub_key == "rhop" and rho == "rhot"): continue else: mdict_key = sub_key if (mdict_key + mode not in mdict.keys()): print("Cannot find " + key + "/" + sub_key + " in .mat") if (sub_key not in self.failed_keys[key]): self.failed_keys[key].append(sub_key) continue if (self["dimensions"]["N_time"] == 1): mdict[mdict_key + mode] = np.expand_dims( mdict[mdict_key + mode], 0) if (self["dimensions"]["N_ch"] == 1): mdict[mdict_key + mode] = np.expand_dims( mdict[mdict_key + mode], 1) if (self["dimensions"]["N_ray"] == 1): mdict[mdict_key + mode] = np.expand_dims( mdict[mdict_key + mode], 2) for key in ["ray", "BPD"]: for sub_key in self.sub_keys[key]: sub_key_error_printed = False if (key == "BPD"): mdict_key = None #3D rhot if (sub_key == "rhot" and self.Scenario["plasma"]["eq_dim"] == 2): continue elif (sub_key == "rhop" and self.Scenario["plasma"]["eq_dim"] == 3): continue elif (sub_key == "rhot" and self.Scenario["plasma"]["eq_dim"] == 3): # The BPD axis is mislabeled for 3D equilibria. It should be rhot mdict_key = "BPD" + "rhop" if (mdict_key is None): if (sub_key in ["rhop", "rhot"]): mdict_key = "BPD" + sub_key else: mdict_key = sub_key if (mdict_key + mode not in mdict.keys()): print("INFO: Cannot load " + key + "/" + sub_key) if (sub_key not in self.failed_keys[key]): self.failed_keys[key].append(sub_key) continue self[key][sub_key] = np.zeros(self.get_shape(key)) for i_mode, mode in enumerate(modes): self[key][sub_key][...,i_mode,:] = mdict[mdict_key+mode].reshape(self.get_shape(key,stop=-2) + \ (self["dimensions"]["N_BPD"],)) else: if(sub_key in ["em", "ab", "T", "BPD", \ "em_second", "ab_second", "T_second", "BPD_second"]): mdict_key = "ray_" + sub_key #3D rhot elif (sub_key == "rhot" and rho == "rhot"): mdict_key = "rhop" elif (sub_key == "rhop" and rho == "rhot"): continue else: mdict_key = sub_key if (mdict_key + mode not in mdict.keys()): if (sub_key != "R"): print("INFO: Cannot load " + key + "/" + sub_key) if (sub_key not in self.failed_keys[key]): self.failed_keys[key].append(sub_key) continue self["ray"][sub_key] = [] for i_time in range(self["dimensions"]["N_time"]): self["ray"][sub_key].append([]) for i_ch in range(self["dimensions"]["N_ch"]): self["ray"][sub_key][i_time].append([]) for i_mode, mode in enumerate(modes): self["ray"][sub_key][i_time][i_ch].append([]) for i_ray in range( self["dimensions"]["N_ray"]): try: self["ray"][sub_key][i_time][i_ch][i_mode].append( \ mdict[mdict_key+mode][i_time][i_ch][i_ray]) self["dimensions"]["N_LOS"][i_time][i_ch][i_mode][i_ray] = \ len(self["ray"][sub_key][i_time][i_ch][i_mode][i_ray]) except IndexError: if (not sub_key_error_printed): print( "INFO: Failed to load {0:s} {1:s}" .format(key, sub_key)) print( "INFO: For time index {0:d} channel {1:d} mode index {2:d} ray {3:d}" .format( i_time, i_ch, i_mode, i_ray)) sub_key_error_printed = True self["ray"][sub_key][i_time][i_ch][ i_mode].append([]) self["dimensions"]["N_LOS"][i_time][ i_ch][i_mode][i_ray] = 0 # Convert to ragged np array self["ray"][sub_key] = np.array(self["ray"][sub_key], dtype=np.object) self["weights"]["ray_weights"] = mdict["ray_weights"] self["weights"]["freq_weights"] = mdict["ray_weights"] if (self.Config["Physics"]["considered_modes"] > 2): self["weights"]["mode_frac"] = np.zeros( self.get_shape("mode_frac")) self["weights"]["mode_frac_second"] = np.zeros( self.get_shape("mode_frac_second")) self["weights"]["mode_frac"][...,0,:] = mdict["X_mode_frac"].reshape(self.get_shape("mode_frac",stop=1) + \ self.get_shape("mode_frac",start=2)) self["weights"]["mode_frac_second"][...,0,:] = mdict["X_mode_frac_comp"].reshape(self.get_shape("mode_frac_second",stop=1) + \ self.get_shape("mode_frac_second",start=2)) self["weights"]["mode_frac"][...,1,:] = 1 - mdict["X_mode_frac"].reshape(self.get_shape("mode_frac",stop=1) + \ self.get_shape("mode_frac",start=2)) self["weights"]["mode_frac_second"][...,1,:] = 1 - mdict["X_mode_frac_comp"].reshape(self.get_shape("mode_frac_second",stop=1) + \ self.get_shape("mode_frac_second",start=2)) else: self["weights"]["mode_frac"] = np.ones(self.get_shape("mode_frac")) self["weights"]["mode_frac_second"] = np.ones( self.get_shape("mode_frac_second")) self["ray"]["R"] = np.zeros(self.get_shape("ray", stop=-1), dtype=np.object) print("INFO: Fixing missing ray/R.") for itime in range(self["dimensions"]["N_time"]): for ich in range(self["dimensions"]["N_ch"]): for imode in range(self["dimensions"]["N_mode"]): for iray in range(self["dimensions"]["N_ray"]): if (self["dimensions"]["N_LOS"][i_time][i_ch][i_mode] [i_ray] > 0): self["ray"]["R"][itime,ich,imode,iray] = np.sqrt(self["ray"]["x"][itime,ich,imode,iray]**2 + \ self["ray"]["y"][itime,ich,imode,iray]**2) # We fix R later so we do not need to delete it self.failed_keys["ray"].remove("R") self["git"]["ECRad"] = mdict["ECRad_git_tag"] self["git"]["GUI"] = mdict["ECRadGUI_git_tag"] self["git"]["Pylib"] = mdict["ECRadPylib_git_tag"] self.data_origin = filename self.init = True return True def get_default_filename_and_edition(self, scratch=False, ed=None): if (scratch): dir = self.Config["Execution"]["scratch_dir"] else: dir = self.Config["Execution"]["working_dir"] diag_str = "" for key in self.Scenario["used_diags_dict"]: diag_str += key if (ed is None): ed = 1 filename = os.path.join( dir, "ECRad_{0:5d}_{1:s}_ed{2:d}.nc".format(self.Scenario["shot"], diag_str, ed)) while (os.path.exists(filename)): ed += 1 filename = os.path.join( dir, "ECRad_{0:5d}_{1:s}_ed{2:d}.nc".format( self.Scenario["shot"], diag_str, ed)) return filename, ed else: filename = os.path.join(dir, "ECRad_Results_{0:d}.nc".format(ed)) return filename, 0 def to_netcdf(self, filename=None, scratch=False, ed=None): if (filename is not None): rootgrp = Dataset(filename, "w", format="NETCDF4") else: filename, self.edition = self.get_default_filename_and_edition( scratch, ed=ed) rootgrp = Dataset(filename, "w", format="NETCDF4") rootgrp.createGroup("Results") self.Config.to_netcdf(rootgrp=rootgrp) self.Scenario.to_netcdf(rootgrp=rootgrp) for sub_key in self["dimensions"].keys(): if (np.isscalar(self["dimensions"][sub_key])): rootgrp["Results"].createDimension(sub_key, self["dimensions"][sub_key]) else: rootgrp["Results"].createDimension(sub_key, None) for key in self.result_keys: if (key == "dimensions" or key == "ray"): continue dtype = "f8" if (self["types"][key] != "float"): dtype = "i8" try: for sub_key in self.sub_keys[key]: if (len(self[key][sub_key]) == 0): print("INFO: Not saving " + key + " " + sub_key + " because there is no data.") continue if (sub_key in self.failed_keys[key]): continue if (sub_key == "rhot" and self.Scenario["plasma"]["eq_dim"] == 2): continue elif (sub_key == "rhop" and self.Scenario["plasma"]["eq_dim"] == 3): continue if (key != "weights"): var = rootgrp["Results"].createVariable( key + "_" + sub_key, dtype, tuple(self.shapes[key])) else: var = rootgrp["Results"].createVariable( key + "_" + sub_key, dtype, tuple(self.shapes[sub_key])) var[:] = self[key][sub_key] except Exception as e: print(key, sub_key) raise e key = "ray" for sub_key in self.sub_keys["ray"]: if (sub_key in self.failed_keys[key]): continue elif (len(self[key][sub_key]) == 0): continue var = rootgrp["Results"].createVariable(key + "_" + sub_key, dtype, tuple(self.shapes[key])) for i_time in range(self["dimensions"]["N_time"]): for i_ch in range(self["dimensions"]["N_ch"]): for i_mode in range(self["dimensions"]["N_mode"]): for i_ray in range(self["dimensions"]["N_ray"]): var[i_time, i_ch, i_mode, i_ray, :] = self[key][sub_key][i_time, i_ch, i_mode, i_ray] # Get the shape information of the individual LOS length into the NETCDF file var = rootgrp["Results"].createVariable("dimensions" + "_" + "N_LOS", "i8", self.shapes["ray"][:-1]) var[:] = self["dimensions"]["N_LOS"] rootgrp["Results"].comment = self.comment rootgrp["Results"].edition = self.edition rootgrp["Results"].ECRad_git_tag = self["git"]["ECRad"] rootgrp["Results"].ECRadGUI_git_tag = self["git"]["GUI"] rootgrp["Results"].ECRadPylib_git_tag = self["git"]["Pylib"] rootgrp.close() print("Created " + filename) def from_netcdf(self, filename): rootgrp = Dataset(filename, "r", format="NETCDF4") self.Config.from_netcdf(rootgrp=rootgrp) self.Scenario.from_netcdf(rootgrp=rootgrp) for sub_key in rootgrp["Results"].dimensions.keys(): self["dimensions"][sub_key] = rootgrp["Results"].dimensions[ sub_key].size self["dimensions"]["N_LOS"] = np.array( rootgrp["Results"]["dimensions" + "_" + "N_LOS"]) for key in self.result_keys: if (key == "dimensions" or key == "ray"): continue for sub_key in self.sub_keys[key]: if (key + "_" + sub_key not in rootgrp["Results"].variables.keys()): print("INFO: Could not find " + key + " " + sub_key + " in the result file.") self.failed_keys[key].append(sub_key) continue if (key == "BPD"): if (sub_key == "rhot" and self.Scenario["plasma"]["eq_dim"] == 2): continue elif (sub_key == "rhop" and self.Scenario["plasma"]["eq_dim"] == 3): continue self[key][sub_key] = np.array(rootgrp["Results"][key + "_" + sub_key]) key = "ray" for sub_key in self.sub_keys["ray"]: self["ray"][sub_key] = [] if (key + "_" + sub_key not in rootgrp["Results"].variables.keys()): print("INFO: Cannot load " + key + "/" + sub_key) self.failed_keys[key].append(sub_key) continue for i_time in range(self["dimensions"]["N_time"]): self["ray"][sub_key].append([]) for i_ch in range(self["dimensions"]["N_ch"]): self["ray"][sub_key][i_time].append([]) for i_mode in range(self["dimensions"]["N_mode"]): self["ray"][sub_key][i_time][i_ch].append([]) for i_ray in range(self["dimensions"]["N_ray"]): self["ray"][sub_key][i_time][i_ch][i_mode].append( \ rootgrp["Results"][key+ "_" +sub_key][i_time,i_ch,i_mode,i_ray,\ :self["dimensions"]["N_LOS"][i_time,i_ch,i_mode,i_ray]]) self["ray"][sub_key] = np.array(self["ray"][sub_key], dtype=np.object) # Get the shape information of the individual LOS length into the NETCDF file self.comment = rootgrp["Results"].comment self.edition = rootgrp["Results"].edition self["git"]["ECRad"] = rootgrp["Results"].ECRad_git_tag self["git"]["GUI"] = rootgrp["Results"].ECRadGUI_git_tag self["git"]["Pylib"] = rootgrp["Results"].ECRadPylib_git_tag self.data_origin = filename rootgrp.close()
self.set_equilibrium(Result.Scenario, itime) if(Result.Config["Physics"]["dstf"] != "Th"): self.set_distribution(Result.Scenario, Result.Config, itime) self.make_rays(Result.Scenario, itime) Result = self.run_and_get_output(Result, itime) return Result if(__name__ == "__main__"): from Plotting_Configuration import plt ECRad_folder = "/mnt/c/Users/Severin/ECRad/" os.chdir(globalsettings.ECRadLibDir) print(os.getcwd()) ECRad_file = os.path.join(ECRad_folder, "ECRad_35662_EXT_ed1.mat") # ECRad_file = "/gss_efgw_work/work/g2sdenk/ECRad_runs/ECRad_20180823016002_EXT_ed20.mat" Scenario = ECRadScenario(True) Config = ECRadConfig(True) Config.from_mat(path_in=ECRad_file) Scenario.from_mat(path_in=ECRad_file) Config.working_dir = ECRad_folder Config.scratch_dir = Config.working_dir Config.extra_output =False Config.batch = False ecrad_f2py_interface = ECRadF2PYInterface(Config, Scenario) ecrad_f2py_interface.set_config_and_diag(Config, Scenario, 0) rhop_out = ecrad_f2py_interface.set_equilibrium(Scenario, 0 ) rhop = Scenario.plasma_dict["rhop_prof"][0] ne = Scenario.plasma_dict["ne"][0] Te = Scenario.plasma_dict["Te"][0] rhop_out = ecrad_f2py_interface.make_rays(Scenario, 0) fm_flag = np.zeros(ecrad_f2py_interface.N_ch, dtype=np.bool)
def scale_launch_parameter(Scenario_file_in, scenario_file_out, para_name, scale): Scenario = ECRadScenario(True) Scenario.load(filename=Scenario_file_in) Scenario["diagnostic"][para_name] *= scale Scenario.to_netcdf(filename=scenario_file_out)
def make_W7X_Scenario(ScenarioName, shot, time, folder, \ ray_launch_file, wall_filename, ECE_freqs=None, B_scale=1.0): Scenario = ECRadScenario(noLoad=True) profs = np.loadtxt(os.path.join(folder, "plasma_profiles.txt"), skiprows=3) if (len(profs.T[0]) > 40): Scenario.plasma_dict["rhot_prof"] = [profs.T[0]] Scenario.plasma_dict["Te"] = [profs.T[2] * 1.e3] Scenario.plasma_dict["ne"] = [profs.T[1]] else: rho = np.linspace(profs.T[0][0], profs.T[0][-1], 200) profs.T[1][profs.T[1] <= 0.0] = 20.e-3 # room temperature profs.T[2][profs.T[2] <= 0.0] = 1.e17 # arbitray Te_spl = InterpolatedUnivariateSpline(profs.T[0], np.log(profs.T[1])) ne_spl = InterpolatedUnivariateSpline(profs.T[0], np.log(profs.T[2])) Scenario.plasma_dict["rhot_prof"] = [rho] Scenario.plasma_dict["Te"] = [np.exp(Te_spl(rho)) * 1.e3] Scenario.plasma_dict["ne"] = [np.exp(ne_spl(rho)) * 1.e20] Scenario.shot = shot Scenario.IDA_exp = "W7X" Scenario.IDA_ed = -1 Scenario.EQ_diag = "VMEC" Scenario.EQ_exp = "W7X" Scenario.EQ_ed = -1 Scenario.plasma_dict["time"] = [time] Scenario.use3Dscen.used = True Scenario.use3Dscen.equilibrium_file = os.path.join(folder, "VMEC.txt") Scenario.use3Dscen.equilibrium_type = "VMEC" Scenario.use3Dscen.vessel_filename = wall_filename Scenario.use3Dscen.B_ref = B_scale if (not ScenarioName.endswith(".mat")): ScenarioName = ScenarioName + ".mat" ext_diag = EXT_diag("EXT") ext_diag.set_from_mat(ray_launch_file) if (ECE_freqs is not None): ext_diag.f = np.loadtxt(ECE_freqs, skiprows=1).T[2] * 1.e9 #skiprows=12 ext_diag.N_ch = len(ext_diag.f) for key in ["df", "R", "phi", "z", "theta_pol", "phi_tor", \ "dist_focus", "width", "pol_coeff_X"]: temp_val = np.zeros(ext_diag.N_ch) temp_val[:] = getattr(ext_diag, key)[0] setattr(ext_diag, key, temp_val) ext_diag.theta_pol[:] = 6.4913006098335915 # Launch params for W7X ECE ext_diag.phi_tor[:] = 9.828001340036531 # # Launch params for W7X ECE Scenario.avail_diags_dict.update({"EXT": ext_diag}) Scenario.used_diags_dict.update({"EXT": ext_diag}) Scenario.ray_launch = [] Scenario.ray_launch.append(ext_diag.get_launch()) Scenario.use3Dscen.used = True Scenario.data_source = "Ext" Scenario.to_mat_file(ScenarioName)