def verify_CECE_LOS(ECRad_results_file):
res = ECRadResults()
res.load(ECRad_results_file)
x,y = plot1DECE(project="toroidal" , freq=res.Scenario["diagnostic"]["f"][0][0]/1.e9,doPlot=False, verb=False)
R,z = plot1DECE(project="poloidal" , freq=res.Scenario["diagnostic"]["f"][0][0]/1.e9,doPlot=False, verb=False)
fig_top = plt.figure()
ax_top = fig_top.add_subplot(111)
fig_side = plt.figure()
ax_side = fig_side.add_subplot(111)
label_Pedro = "Pedro"
for i in [0, 2, 4]:
ax_top.plot(x, y.T[i], "--", label=label_Pedro)
ax_side.plot(R, z.T[i], "--", label=label_Pedro)
label_Pedro =None
label_ECRad = "ECRad"
for ir in range(res.Config["Physics"]["N_ray"]):
phi = np.arctan2(np.array(res["ray"]["y"][0][0][0][ir],dtype=np.float),
np.array(res["ray"]["x"][0][0][0][ir],dtype=np.float))
phi_rot = 22.5 * 8.5
x_ECRad = res["ray"]["R"][0][0][0][ir] * np.cos(phi - np.deg2rad(phi_rot))
y_ECRad = res["ray"]["R"][0][0][0][ir] * np.sin(phi - np.deg2rad(phi_rot))
ax_top.plot(x_ECRad, y_ECRad, "-", label=label_ECRad)
ax_side.plot(res["ray"]["R"][0][0][0][ir], res["ray"]["z"][0][0][0][ir], "-", label=label_ECRad)
label_ECRad = None
ax_top.set_xlabel(r"$x$ [m]")
ax_top.set_xlim(1,3)
ax_top.set_ylim(-0.1,0.2)
ax_top.set_ylabel(r"$y$ [m]")
ax_side.set_xlabel(r"$R$ [m]")
ax_side.set_ylabel(r"$z$ [m]")
ax_side.set_xlim(1,3)
ax_side.set_ylim(-0.1,0.2)
ax_top.legend()
ax_side.legend()
plt.show()
class ECRadRayManipulator(object):
'''
classdocs
'''
def __init__(self, ECRad_result_file):
'''
Constructor
'''
self.org_results_file = ECRad_result_file
self.ECRad_results = ECRadResults()
self.ECRad_results.from_mat_file(ECRad_result_file)
self.N_ch = self.ECRad_results.Scenario.ray_launch[0]["f"]
self.N_ray = self.ECRad_results.Config["Physics"]["N_ray"]
if (self.ECRad_results.Config["Physics"]["considered_modes"] == 1):
self.modes = ["X"]
elif (self.ECRad_results.Config["Physics"]["considered_modes"] == 2):
self.modes = ["O"]
elif (self.ECRad_results.Config["Physics"]["considered_modes"] == 3):
self.modes = ["X", "O"]
else:
raise ValueError("Invalid value in considered modes")
def get_Rz_single_ray(self, it, ich, mode="X", iray=0):
if (self.N_ray == 1):
R = np.sqrt(self.ECRad_results.ray["x"+mode][it][ich]**2 + \
self.ECRad_results.ray["y"+mode][it][ich]**2)
return R, self.ECRad_results.ray["z" + mode][it][ich]
else:
R = np.sqrt(self.ECRad_results.ray["x"+mode][it][ich][iray]**2 + \
self.ECRad_results.ray["y"+mode][it][ich][iray]**2)
return R, self.ECRad_results.ray["z" + mode][it][ich][iray]
def get_field_single_ray(self, field, it, ich, mode="X", iray=0):
if (self.N_ray == 1):
return self.ECRad_results.ray[field + mode][it][ich]
else:
return self.ECRad_results.ray[field + mode][it][ich][iray]
def set_field_single_ray(self, field, values, it, ich, mode="X", iray=0):
if (self.N_ray == 1):
if (self.ECRad_results.ray[field + mode][it][ich].shape !=
values.shape):
raise ValueError(
"The new values must have the same shape as the original values"
)
self.ECRad_results.ray[field + mode][it][ich] = values
else:
if (self.ECRad_results.ray[field + mode][it][ich][iray].shape !=
values.shape):
raise ValueError(
"The new values must have the same shape as the original values"
)
self.ECRad_results.ray[field + mode][it][ich][iray] = values
def save(self, new_filename, comment=""):
if (new_filename == self.org_results_file):
print("This routine does not allow overwriting of the old file!")
return
self.ECRad_results.to_mat_file(new_filename, comment)
def CECE_workflow(working_dir, Results_filename, time):
Results = ECRadResults()
Results.load(Results_filename)
logfile = open(os.path.join(working_dir, f"CECE_params_{Results.Scenario['shot']}"), "w")
run_ECE_TORBEAM_ECRad_Scenario(working_dir, Results, time, logfile=logfile)
get_BPD_width(Results, 0, logfile=logfile)
logfile.close()
plt.show()
def plot_harmonics_and_frequencies(res_file):
Results = ECRadResults()
Results.load(res_file)
fig = plt.figure()
pc_obj = PlottingCore(fig=fig)
ich_list = np.arange(0,
len(Results.Scenario["diagnostic"]["f"][0]),
3,
dtype=np.int)
imode_list = np.zeros(ich_list.shape, dtype=np.int)
ir_list = np.zeros(ich_list.shape, dtype=np.int)
pc_obj.B_plot(Results, 0, ich_list, imode_list, ir_list)
plt.show()
def diag_weight_stand_alone(fig,
ax,
Result_file,
time_point,
ch,
DistWaveFile=None):
Results = ECRadResults()
Results.from_mat_file(Result_file)
fig = diag_weight(fig,
Results,
time_point,
ch,
DistWaveFile=DistWaveFile,
ax=ax)
def get_other_results(self, args):
paths = args[0]
new_results = {}
for path in paths:
result = ECRadResults()
try:
result.load(path)
new_results[str(result.Scenario["shot"]) + "_" +
str(result.edition)] = result
except:
print("Failed to load result at: " + path)
evt_out = GenerticEvt(Unbound_EVT_OTHER_RESULTS_LOADED, self.GetId())
evt_out.insertData(new_results)
wx.PostEvent(self, evt_out)
def repair_ECRad_results(folder_in, folder_out=None):
# Allows to make bulk modification of result files using glob
# If folder_out is True it overwrites!
filelist = glob.glob(os.path.join(folder_in, "*.mat"))
# filelist = ['/tokp/work/sdenk/DRELAX_Results/ECRad_35662_ECECTACTC_run0208.mat']
cur_result = ECRadResults()
for filename in filelist:
cur_result.reset()
cur_result.from_mat_file(filename)
# Enter bulk modifcations here
cur_result.Scenario.used_diags_dict["CTC"].diag = "CTC"
if(folder_out is None):
cur_result.to_mat_file(filename)
else:
cur_result.to_mat_file(os.path.join(folder_out, os.path.basename(filename)))
def FinishUpECRad(self):
if(self.Results.Scenario["dimensions"]["N_time"] == 0):
# Unsuccessful termination
print("None of the ECRad runs were completed succesfully - sorry")
self.Results = ECRadResults()
# We have deleted all entries from the Scenario we need to rebuilt this
self.Results.Scenario.plasma_set = False
self.Progress_label.SetLabel("No ECRad run in progress")
self.ProgressBar.SetRange(1)
self.ProgressBar.SetValue(1)
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('ECRad failed - sorry!')
self.GetEventHandler().ProcessEvent(evt)
self.stop_current_evaluation = True
self.StartECRadButton.Enable()
return
if(not self.Results.Config["Execution"]["batch"]):
# Remove time points in case of early termination
for i in range(self.index, self.Results.Scenario["dimensions"]["N_time"]):
self.Results.Scenario.drop_time_point(i)
self.Results.tidy_up(False)
self.TimeBox.Clear()
for t in self.Results.Scenario["time"]:
self.TimeBox.Append("{0:1.4f}".format(t))
self.KillECRadButton.Disable()
self.stop_current_evaluation = False
self.ExportButton.Enable()
self.NameButton.Enable()
self.Progress_label.SetLabel("No ECRad run in progress")
self.ProgressBar.SetRange(self.index)
self.ProgressBar.SetValue(self.index)
evt = wx.PyCommandEvent()
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('ECRad has Finished!')
wx.PostEvent(self, evt)
if(not self.Results.Config["Execution"]["batch"]):
print("Now saving results")
print("This takes a moment please wait")
WorkerThread(self.SavingThread, [])
evt_2 = UpdateDataEvt(Unbound_EVT_UPDATE_DATA, self.GetId())
evt_2.SetResults(self.Results)
if(globalsettings.AUG):
wx.PostEvent(self.calib_panel, evt)
self.calib_panel.GetEventHandler().ProcessEvent(evt_2)
wx.PostEvent(self.scenario_select_panel, evt_2)
wx.PostEvent(self.plot_panel, evt_2)
self.StartECRadButton.Enable()
def __init__(self, ECRad_result_file):
'''
Constructor
'''
self.org_results_file = ECRad_result_file
self.ECRad_results = ECRadResults()
self.ECRad_results.from_mat_file(ECRad_result_file)
self.N_ch = self.ECRad_results.Scenario.ray_launch[0]["f"]
self.N_ray = self.ECRad_results.Config["Physics"]["N_ray"]
if (self.ECRad_results.Config["Physics"]["considered_modes"] == 1):
self.modes = ["X"]
elif (self.ECRad_results.Config["Physics"]["considered_modes"] == 2):
self.modes = ["O"]
elif (self.ECRad_results.Config["Physics"]["considered_modes"] == 3):
self.modes = ["X", "O"]
else:
raise ValueError("Invalid value in considered modes")
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()
def ECRadRunner(cls, input_queue, output_queue):
ECRad_inferface = ECRadF2PYInterface()
while True:
args = input_queue.get()
try:
command = args[0]
if(command == "close"):
break
Results = args[1]
if(Results.Config["Execution"]["batch"]):
scratch_dir = Results.Config["Execution"]["scratch_dir"]
Results.Scenario.to_netcdf(filename=os.path.join(scratch_dir, "Scenario.nc"))
Results.Config.to_netcdf(filename=os.path.join(scratch_dir, "Config.nc"))
run_ECRad = SetupECRadBatch(Results.Config, Results.Scenario, Results.Scenario["time"][args[2]])
ECRad_batch = Popen(run_ECRad)
ECRad_batch.wait()
try:
filename, ed = Results.get_default_filename_and_edition(True)
NewResults = ECRadResults(False)
NewResults.from_netcdf(filename)
NewResults.to_netcdf()
output_queue.put([True, NewResults])
except:
print("Failed to run remotely. Please check .o and .e files at")
print(scratch_dir)
output_queue.put([False, Results])
else:
Results = ECRad_inferface.process_single_timepoint(Results, args[2])
output_queue.put([True, Results])
except Exception as e:
print(e)
output_queue.put([False, Results])
def run_ECRad_from_script(working_dir, shot, Config, InvokeECRad, args):
Results = ECRadResults()
Results.parse_config(Config, Config.time)
next_time_index_to_analyze = 0
print("Analyzing {0:d} time points".format(len(Config.time)))
while True:
if(next_time_index_to_analyze >= len(Config.time)):
break
print("Working on t = {0:1.4f}".format(Config.time[next_time_index_to_analyze]))
if(os.path.isdir(os.path.join(Config.working_dir, "ECRad_data"))):
shutil.rmtree(os.path.join(Config.working_dir, "ECRad_data"))
for diag_key in Config.used_diags_dict:
if("CT" in diag_key or "IEC" == diag_key):
if(str(Config.used_diags_dict[diag_key].beamline) not in Config.gy_dict):
new_gy = get_ECRH_viewing_angles(Config.shot, \
Config.used_diags_dict[diag_key].beamline)
if(new_gy.error == 0):
Config.gy_dict[str(Config.used_diags_dict[diag_key].beamline)] = new_gy
else:
print("Error when reading viewing angles")
print("Launch aborted")
return
if(not prepare_input_files(Config.time, next_time_index_to_analyze, Config)):
print("Error!! Launch aborted")
return None
print("-------- Launching ECRad -----------\n")
print("-------- INVOKE COMMAND------------\n")
print(InvokeECRad + " " + Config.working_dir)
ECRad_process = subprocess.Popen([InvokeECRad, args])
print("-----------------------------------\n")
ECRad_process = subprocess.Popen([InvokeECRad, Config.working_dir])
ECRad_process.wait()
next_time_index_to_analyze += 1
try:
Results.append_new_results()
except (IOError, IndexError) as e:
print("Error: Results of ECRad cannot be found")
print("Most likely cause is an error that occurred within the ECRad")
print("Please run the ECRad with current input parameters in a separate shell.")
print("The command to launch the ECRad can be found above.")
print("Afterwards please send any error messages that appear at sdenk|at|ipp.mpg.de")
print("If no errors occur make sure that you don't have another instance of ECRad GUI working in the same working directory")
print(e)
return None
Results.tidy_up()
print("Finished!")
return Results
def manipiulate_rays(result_file_in, result_file_out):
res = ECRadResults()
res.from_mat_file(result_file_in)
for index in range(len(res.time)):
for ich in range(len(res.Scenario.ray_launch[index]["f"])):
for mode in res.modes:
if (res.Config["Physics"]["N_ray"] > 1):
for iray in range(len(res.ray["s" + mode][index][ich])):
res.ray["Te" + mode][index][ich][iray][:] /= 2.0
else:
res.ray["Te" + mode][index][ich][:] /= 2.0
res.to_mat_file(result_file_out)
class ECRadDriver():
'''
Driver for ECRad. Passes information to ECRad, runs ECRad and extracts results
'''
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()
def run(self, id=None):
itime = 0
self.Result.set_dimensions()
while itime < self.Result.Scenario["dimensions"]["N_time"]:
try:
self.process_time_point(itime)
itime += 1
except Exception as e:
print("Error when processing t = {0:1.4f}".format(
self.Result.Scenario["time"][itime]))
print("Removing this time point and continuing")
raise (e)
self.Result.Scenario.drop_time_point(itime)
self.Result.set_dimensions()
self.Result.tidy_up(autosave=False)
self.Result.to_netcdf(scratch=True, ed=id)
def process_time_point(self, itime):
self.Result = self.ECRad_F2PY_interface.process_single_timepoint(
self.Result, itime)
def __init__(self, parent, ECRad_runner_process, ECRad_input_queue, ECRad_output_queue):
scrolled.ScrolledPanel.__init__(self, parent, wx.ID_ANY)
self.parent = parent
self.ECRad_running = False
self.ECRad_runner_process = ECRad_runner_process
self.ECRad_input_queue = ECRad_input_queue
self.ECRad_output_queue = ECRad_output_queue
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.Results = ECRadResults(lastused=True)
self.Bind(EVT_MAKE_ECRAD, self.OnProcessTimeStep)
self.Bind(EVT_ECRAD_FINISHED, self.OnProcessEnded)
self.Bind(EVT_NEXT_TIME_STEP, self.OnNextTimeStep)
self.Bind(EVT_UPDATE_DATA, self.OnUpdate)
self.Bind(EVT_LOCK_EXPORT, self.OnLockExport)
self.Bind(wx.EVT_IDLE, self.OnIdle)
self.Bind(EVT_GENE_DATA_LOADED, self.OnGeneLoaded)
self.Bind(EVT_ECRAD_RESULT_LOADED, self.OnResultsImported)
self.Bind(EVT_LOAD_OLD_RESULT, self.OnImport)
self.SetSizer(self.sizer)
self.SetSize((400, 400))
self.SetMinSize((400, 400))
self.data = None
self.ControlSizer = wx.BoxSizer(wx.HORIZONTAL)
self.ButtonSizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.ControlSizer, 0, wx.EXPAND | wx.ALL , 5)
self.StartECRadButton = wx.Button(self, wx.ID_ANY, \
'Start ECRad')
self.KillECRadButton = wx.Button(self, wx.ID_ANY, 'Terminate ECRad')
self.StartECRadButton.Bind(wx.EVT_BUTTON, self.OnStartECRad)
self.KillECRadButton.Bind(wx.EVT_BUTTON, self.OnKillECRad)
self.KillECRadButton.Disable()
self.ExportButton = wx.Button(self, wx.ID_ANY, 'Save results')
self.ExportButton.SetToolTip("If this is grayed out there is no (new) data to save!")
self.ExportButton.Bind(wx.EVT_BUTTON, self.OnExport)
self.ExportButton.Disable()
self.NameButton = wx.Button(self, wx.ID_ANY, 'Comment Results')
self.NameButton.Bind(wx.EVT_BUTTON, self.OnName)
username = "******"
if(getpass.getuser() in ["sdenk", "g2sdenk", "denk"]):
username = "******"
elif(getpass.getuser() == "bva"):
username = "******"
elif(getpass.getuser() == "mwillens"):
username = "******"
elif(getpass.getuser() == "sfreethy"):
username = "******"
self.ButtonSizer.Add(self.StartECRadButton, 0, wx.ALL | \
wx.LEFT, 5)
self.ButtonSizer.Add(self.KillECRadButton, 0, wx.ALL | \
wx.LEFT, 5)
self.ButtonSizer.Add(self.ExportButton, 0, wx.ALL | \
wx.LEFT, 5)
self.ButtonSizer.Add(self.NameButton, 0, wx.ALL | \
wx.LEFT, 5)
self.ControlSizer.Add(self.ButtonSizer, 0, wx.ALIGN_TOP)
self.Log_Box = wx.TextCtrl(self, wx.ID_ANY, size=(200, 100), \
style=wx.TE_MULTILINE | wx.TE_READONLY)
self.Log_Box.AppendText('Welcome to the ECRad GUI' + username + os.linesep)
self.diag_box_sizer = wx.BoxSizer(wx.VERTICAL)
self.diag_box_label = wx.StaticText(self, wx.ID_ANY, "Diagnostics")
self.DiagBox = wx.ListBox(self, wx.ID_ANY, size=(100, 100))
for diag_key in list(self.Results.Scenario["used_diags_dict"]):
self.DiagBox.Append(diag_key)
self.diag_box_sizer.Add(self.diag_box_label, 0, wx.ALL | wx.ALIGN_CENTER_HORIZONTAL , 5)
self.diag_box_sizer.Add(self.DiagBox, 1, wx.ALL | wx.EXPAND , 5)
self.time_box_sizer = wx.BoxSizer(wx.VERTICAL)
self.time_box_label = wx.StaticText(self, wx.ID_ANY, "Time points")
self.TimeBox = wx.ListBox(self, wx.ID_ANY, size=(100, 100))
for time in self.Results.Scenario["time"]:
self.TimeBox.Append("{0:1.5f}".format(time))
self.time_box_sizer.Add(self.time_box_label, 0, wx.ALL | wx.ALIGN_CENTER_HORIZONTAL , 5)
self.time_box_sizer.Add(self.TimeBox, 1, wx.ALL | wx.EXPAND , 5)
self.ControlSizer.Add(self.Log_Box, 1, wx.ALL | wx.EXPAND , 5)
self.ControlSizer.Add(self.diag_box_sizer, 0, wx.ALL | wx.EXPAND, 5)
self.ControlSizer.Add(self.time_box_sizer, 0, wx.ALL | wx.EXPAND, 5)
self.ProgressBar = wx.Gauge(self, wx.ID_ANY, style=wx.GA_HORIZONTAL)
self.Progress_label = wx.StaticText(self, wx.ID_ANY, "No ECRad run in progress")
self.Progress_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.Progress_sizer.Add(self.ProgressBar, 1, wx.ALL | wx.EXPAND, 5)
self.Progress_sizer.Add(self.Progress_label, 0, wx.ALL, 5)
self.Redirector = Redirect_Text(self.Log_Box)
sys.stdout = self.Redirector
self.index = 0 # Index for the iteration over timepoints
self.UpperBook = wx.Notebook(self)
self.scenario_select_panel = ScenarioSelectPanel(self.UpperBook, self.Results.Scenario, self.Results.Config)
self.UpperBook.AddPage(self.scenario_select_panel, "Select scenario time points")
self.launch_panel = LaunchPanel(self.UpperBook, self.Results.Scenario, self.Results.Config["Execution"]["working_dir"])
self.UpperBook.AddPage(self.launch_panel, "Diagnostic configuration")
self.config_panel = ConfigPanel(self.UpperBook, self.Results.Config)
self.UpperBook.AddPage(self.config_panel, "ECRad configuration")
self.plot_panel = PlotPanel(self.UpperBook)
self.UpperBook.AddPage(self.plot_panel, "Misc. Plots")
self.sizer.Add(self.Progress_sizer, 0, wx.ALL | wx.EXPAND, 5)
self.SetScrollRate(20, 20)
if(globalsettings.AUG):
self.calib_panel = CalibPanel(self.UpperBook, self.Results.Scenario)
self.UpperBook.AddPage(self.calib_panel, "ECRad Calibration")
self.calib_evolution_Panel = CalibEvolutionPanel(self.UpperBook, self.Results.Config["Execution"]["working_dir"])
self.UpperBook.AddPage(self.calib_evolution_Panel, "Plotting for calibration")
self.sizer.Add(self.UpperBook, 1, wx.ALL | \
wx.LEFT, 5)
def ECRH_weight(fig,
Result_file,
time_point,
ibeam,
DistWaveFile,
beam_freq=105.e9,
ax=None):
# Currently only RELAX/LUKE distributions supported
# Extension for GENE trivial though
if (ax is None):
ax = fig.add_subplot(111)
harmonic_n = 2
Results = ECRadResults()
Results.from_mat_file(Result_file)
itime = np.argmin(np.abs(time_point -
Results.Scenario.plasma_dict["time"]))
time_cor = Results.Scenario.plasma_dict["time"][itime]
EQObj = EQDataExt(Results.Scenario.shot)
EQObj.set_slices_from_ext(Results.Scenario.plasma_dict["time"],
Results.Scenario.plasma_dict["eq_data"])
B_ax = EQObj.get_B_on_axis(time_cor)
EqSlice = EQObj.GetSlice(time_point)
dist_wave_mat = loadmat(DistWaveFile)
dist_obj = load_f_from_mat(DistWaveFile, True)
f_inter = make_f_inter(Results.Config["Physics"]["dstf"],
dist_obj=dist_obj,
EQObj=EQObj,
time=time_cor)[0]
linear_beam = read_waves_mat_to_beam(dist_wave_mat,
EqSlice,
use_wave_prefix=None)
itme = np.argmin(np.abs(Results.Scenario.plasma_dict["time"] - time_point))
Te_spl = InterpolatedUnivariateSpline(Results.Scenario.plasma_dict[Results.Scenario.plasma_dict["prof_reference"]][itime], \
np.log(Results.Scenario.plasma_dict["Te"][itme]))
ne_spl = InterpolatedUnivariateSpline(Results.Scenario.plasma_dict[Results.Scenario.plasma_dict["prof_reference"]][itime], \
np.log(Results.Scenario.plasma_dict["ne"][itme]))
m = 40
n = 80
u_perp_grid = np.linspace(0.0, np.max(dist_obj.u), m)
u_par_grid = np.linspace(-np.max(dist_obj.u), np.max(f_inter.x), n)
diag_weight_f = np.zeros((m, n))
for ray in linear_beam.rays[ibeam]:
tot_pw_ray, cur_PDP = make_PowerDepo_3D_for_ray(ray, beam_freq, "Re", harmonic_n, \
B_ax, EqSlice, Te_spl, ne_spl, f_inter, \
N_pnts=100, fast= True)
for irhop in range(len(cur_PDP.rho)):
print(irhop + 1, " / ", len(cur_PDP.rho))
intercep_points = find_cell_interceps(u_par_grid, u_perp_grid,
cur_PDP, irhop)
for i_intercep, intercep_point in enumerate(intercep_points[:-1]):
i = np.argmin(np.abs(intercep_point[0] - u_par_grid))
j = np.argmin(np.abs(intercep_point[1] - u_perp_grid))
if (u_par_grid[i] > intercep_point[0]):
i -= 1
if (u_perp_grid[j] > intercep_point[1]):
j -= 1
if (i < 0 or j < 0):
continue # only happens at the lower bounds, where u_perp is very small and, therefore, also j is very small
# Compute arclength
t = np.zeros(cur_PDP.u_par[irhop].shape)
for i_res_line in range(1, len(cur_PDP.u_par[irhop])):
t[i_res_line] = t[i_res_line - 1] + np.sqrt((cur_PDP.u_par[irhop][i_res_line] - cur_PDP.u_par[irhop][i_res_line - 1])**2 + \
(cur_PDP.u_perp[irhop][i_res_line] - cur_PDP.u_perp[irhop][i_res_line - 1])**2)
t /= np.max(t) # Normalize this
# Sort
t_spl = InterpolatedUnivariateSpline(cur_PDP.u_par[irhop], t)
try:
PDP_val_spl = InterpolatedUnivariateSpline(
t, cur_PDP.val[irhop])
except Exception as e:
print(e)
t1 = t_spl(intercep_point[0])
t2 = t_spl(intercep_points[i_intercep + 1][0])
diag_weight_f[j,i] += tot_pw_ray * \
PDP_val_spl.integral(t1, t2)
ax.contourf(u_perp_grid, u_par_grid, diag_weight_f.T / np.max(diag_weight_f.flatten()), \
levels = np.linspace(0.01,1,10), cmap = plt.get_cmap("Greens"))
m = cm.ScalarMappable(cmap=plt.cm.get_cmap("Greens"))
m.set_array(np.linspace(0.01, 1.0, 10))
cb_diag = fig.colorbar(m, pad=0.15, ticks=[0.0, 0.5, 1.0])
cb_diag.set_label(r"$\mathrm{d}P/\mathrm{d}s [\si{{a.u.}}]$")
ax.set_ylabel(r"$u_\parallel$")
ax.set_xlabel(r"$u_\perp$")
ax.set_aspect("equal")
return fig
def OnImport(self, evt):
self.Results = ECRadResults()
print("Now loarding: " + evt.filename)
print("This takes a moment please wait")
WorkerThread(self.ImportThread, [evt.filename])
class Main_Panel(scrolled.ScrolledPanel):
def __init__(self, parent, ECRad_runner_process, ECRad_input_queue, ECRad_output_queue):
scrolled.ScrolledPanel.__init__(self, parent, wx.ID_ANY)
self.parent = parent
self.ECRad_running = False
self.ECRad_runner_process = ECRad_runner_process
self.ECRad_input_queue = ECRad_input_queue
self.ECRad_output_queue = ECRad_output_queue
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.Results = ECRadResults(lastused=True)
self.Bind(EVT_MAKE_ECRAD, self.OnProcessTimeStep)
self.Bind(EVT_ECRAD_FINISHED, self.OnProcessEnded)
self.Bind(EVT_NEXT_TIME_STEP, self.OnNextTimeStep)
self.Bind(EVT_UPDATE_DATA, self.OnUpdate)
self.Bind(EVT_LOCK_EXPORT, self.OnLockExport)
self.Bind(wx.EVT_IDLE, self.OnIdle)
self.Bind(EVT_GENE_DATA_LOADED, self.OnGeneLoaded)
self.Bind(EVT_ECRAD_RESULT_LOADED, self.OnResultsImported)
self.Bind(EVT_LOAD_OLD_RESULT, self.OnImport)
self.SetSizer(self.sizer)
self.SetSize((400, 400))
self.SetMinSize((400, 400))
self.data = None
self.ControlSizer = wx.BoxSizer(wx.HORIZONTAL)
self.ButtonSizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.ControlSizer, 0, wx.EXPAND | wx.ALL , 5)
self.StartECRadButton = wx.Button(self, wx.ID_ANY, \
'Start ECRad')
self.KillECRadButton = wx.Button(self, wx.ID_ANY, 'Terminate ECRad')
self.StartECRadButton.Bind(wx.EVT_BUTTON, self.OnStartECRad)
self.KillECRadButton.Bind(wx.EVT_BUTTON, self.OnKillECRad)
self.KillECRadButton.Disable()
self.ExportButton = wx.Button(self, wx.ID_ANY, 'Save results')
self.ExportButton.SetToolTip("If this is grayed out there is no (new) data to save!")
self.ExportButton.Bind(wx.EVT_BUTTON, self.OnExport)
self.ExportButton.Disable()
self.NameButton = wx.Button(self, wx.ID_ANY, 'Comment Results')
self.NameButton.Bind(wx.EVT_BUTTON, self.OnName)
username = "******"
if(getpass.getuser() in ["sdenk", "g2sdenk", "denk"]):
username = "******"
elif(getpass.getuser() == "bva"):
username = "******"
elif(getpass.getuser() == "mwillens"):
username = "******"
elif(getpass.getuser() == "sfreethy"):
username = "******"
self.ButtonSizer.Add(self.StartECRadButton, 0, wx.ALL | \
wx.LEFT, 5)
self.ButtonSizer.Add(self.KillECRadButton, 0, wx.ALL | \
wx.LEFT, 5)
self.ButtonSizer.Add(self.ExportButton, 0, wx.ALL | \
wx.LEFT, 5)
self.ButtonSizer.Add(self.NameButton, 0, wx.ALL | \
wx.LEFT, 5)
self.ControlSizer.Add(self.ButtonSizer, 0, wx.ALIGN_TOP)
self.Log_Box = wx.TextCtrl(self, wx.ID_ANY, size=(200, 100), \
style=wx.TE_MULTILINE | wx.TE_READONLY)
self.Log_Box.AppendText('Welcome to the ECRad GUI' + username + os.linesep)
self.diag_box_sizer = wx.BoxSizer(wx.VERTICAL)
self.diag_box_label = wx.StaticText(self, wx.ID_ANY, "Diagnostics")
self.DiagBox = wx.ListBox(self, wx.ID_ANY, size=(100, 100))
for diag_key in list(self.Results.Scenario["used_diags_dict"]):
self.DiagBox.Append(diag_key)
self.diag_box_sizer.Add(self.diag_box_label, 0, wx.ALL | wx.ALIGN_CENTER_HORIZONTAL , 5)
self.diag_box_sizer.Add(self.DiagBox, 1, wx.ALL | wx.EXPAND , 5)
self.time_box_sizer = wx.BoxSizer(wx.VERTICAL)
self.time_box_label = wx.StaticText(self, wx.ID_ANY, "Time points")
self.TimeBox = wx.ListBox(self, wx.ID_ANY, size=(100, 100))
for time in self.Results.Scenario["time"]:
self.TimeBox.Append("{0:1.5f}".format(time))
self.time_box_sizer.Add(self.time_box_label, 0, wx.ALL | wx.ALIGN_CENTER_HORIZONTAL , 5)
self.time_box_sizer.Add(self.TimeBox, 1, wx.ALL | wx.EXPAND , 5)
self.ControlSizer.Add(self.Log_Box, 1, wx.ALL | wx.EXPAND , 5)
self.ControlSizer.Add(self.diag_box_sizer, 0, wx.ALL | wx.EXPAND, 5)
self.ControlSizer.Add(self.time_box_sizer, 0, wx.ALL | wx.EXPAND, 5)
self.ProgressBar = wx.Gauge(self, wx.ID_ANY, style=wx.GA_HORIZONTAL)
self.Progress_label = wx.StaticText(self, wx.ID_ANY, "No ECRad run in progress")
self.Progress_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.Progress_sizer.Add(self.ProgressBar, 1, wx.ALL | wx.EXPAND, 5)
self.Progress_sizer.Add(self.Progress_label, 0, wx.ALL, 5)
self.Redirector = Redirect_Text(self.Log_Box)
sys.stdout = self.Redirector
self.index = 0 # Index for the iteration over timepoints
self.UpperBook = wx.Notebook(self)
self.scenario_select_panel = ScenarioSelectPanel(self.UpperBook, self.Results.Scenario, self.Results.Config)
self.UpperBook.AddPage(self.scenario_select_panel, "Select scenario time points")
self.launch_panel = LaunchPanel(self.UpperBook, self.Results.Scenario, self.Results.Config["Execution"]["working_dir"])
self.UpperBook.AddPage(self.launch_panel, "Diagnostic configuration")
self.config_panel = ConfigPanel(self.UpperBook, self.Results.Config)
self.UpperBook.AddPage(self.config_panel, "ECRad configuration")
self.plot_panel = PlotPanel(self.UpperBook)
self.UpperBook.AddPage(self.plot_panel, "Misc. Plots")
self.sizer.Add(self.Progress_sizer, 0, wx.ALL | wx.EXPAND, 5)
self.SetScrollRate(20, 20)
if(globalsettings.AUG):
self.calib_panel = CalibPanel(self.UpperBook, self.Results.Scenario)
self.UpperBook.AddPage(self.calib_panel, "ECRad Calibration")
self.calib_evolution_Panel = CalibEvolutionPanel(self.UpperBook, self.Results.Config["Execution"]["working_dir"])
self.UpperBook.AddPage(self.calib_evolution_Panel, "Plotting for calibration")
self.sizer.Add(self.UpperBook, 1, wx.ALL | \
wx.LEFT, 5)
# def __del__(self):
# if self.ECRad_process is not None:
# self.ECRad_process.Detach()
# self.ECRad_process.CloseOutput()
# self.ECRad_process = None
# Overwrite this to stop the window from constantly jumping
def OnChildFocus(self, evt):
pass
def OnStartECRad(self, evt):
if(self.ECRad_running):
print('ECRad is still running - please wait!')
return
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('Preparing run - GUI might be unresponsive for minutes - please wait!')
self.GetEventHandler().ProcessEvent(evt)
try:
self.Results.Config = self.config_panel.UpdateConfig(self.Results.Config)
except ValueError as e:
print("Failed to parse Configuration")
print("Reason: ", e)
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
self.GetEventHandler().ProcessEvent(evt)
return
if(self.Results.Config["Physics"]["dstf"] not in ["Th", "Re", "Lu", "Ge", "GB"]):
print("Invalid choice of distribution")
print("Possible options:")
print("Th -> thermal plasma")
print("Re -> distribution function computed by RELAX")
print("Lu -> distribution function computed by LUKE (deprecated)")
print("Ge, GB -> distribution function computed by GENE (deprecated)")
print("Please select a valid distribution function identifier.")
return
scenario_updated = False
# Reset only the result fields but leave Scenario and Config untouched
self.Results.reset(light=True)
# Sets time points and stores plasma data in Scenario
if(self.scenario_select_panel.FullUpdateNeeded() or not self.Results.Scenario.plasma_set):
try:
self.Results.Scenario = self.scenario_select_panel.UpdateScenario(self.Results.Scenario, self.Results.Config, None)
if(not self.Results.Scenario.plasma_set):
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
self.GetEventHandler().ProcessEvent(evt)
return
except ValueError as e:
print("Failed to load Scenario")
print("Reason: ", e)
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
self.GetEventHandler().ProcessEvent(evt)
return
self.TimeBox.Clear()
for t in self.Results.Scenario["time"]:
self.TimeBox.Append("{0:1.4f}".format(t))
scenario_updated = True
else:
self.Results.Scenario = self.scenario_select_panel.SetScaling(self.Results.Scenario)
if(self.launch_panel.UpdateNeeded() or not self.Results.Scenario.diags_set):
try:
self.Results.Scenario = self.launch_panel.UpdateScenario(self.Results.Scenario)
if(not self.Results.Scenario.diags_set):
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
self.GetEventHandler().ProcessEvent(evt)
return
except ValueError as e:
print("Failed to parse diagnostic info")
print("Reason: ", e)
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
self.GetEventHandler().ProcessEvent(evt)
return
self.DiagBox.Clear()
for diag in list(self.Results.Scenario["used_diags_dict"]):
self.DiagBox.Append(diag)
scenario_updated = True
self.Results.Scenario.set_up_dimensions()
# Stores launch data in Scenario
self.stop_current_evaluation = False
self.index = 0
old_comment = self.Results.comment
self.Results.comment = old_comment # Keep the comment
if(len(list(self.Results.Scenario["used_diags_dict"].keys())) == 0):
print("No diagnostics selected")
print("Run aborted")
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
self.GetEventHandler().ProcessEvent(evt)
return
if(len(self.Results.Scenario["time"]) == 0):
print("No time points selected")
print("Run aborted")
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
self.GetEventHandler().ProcessEvent(evt)
return
if(self.Results.Config["Physics"]["dstf"] == "Re"):
if(self.Results.Scenario["dist_obj"] is None):
fileDialog=wx.FileDialog(self, "Selectr file with bounce averaged distribution data", \
defaultDir = self.Results.Config["Execution"]["working_dir"], \
wildcard="matlab files (*.mat)|*.mat",
style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
if(fileDialog.ShowModal() == wx.ID_CANCEL):
print("Launch aborted")
return
else:
pathname = fileDialog.GetPath()
self.Results.Scenario.load_dist_obj(pathname)
fileDialog.Destroy()
self.Results.Config.autosave()
if(self.Results.Config["Physics"]["dstf"] not in ["Ge", "GB"]):
self.FinalECRadSetup(scenario_updated)
else:
if(len(self.Results.Scenario["time"]) != 1):
print("For GENE distributions please select only one time point, i.e. the time point of the gene calcuation")
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
self.GetEventHandler().ProcessEvent(evt)
return
fileDialog=wx.FileDialog(self, "Selectr file with GENE distribution data", \
defaultDir = self.Results.Config["Execution"]["working_dir"], \
wildcard="hdf5 files (*.h5)|*.h5",
style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
if(fileDialog.ShowModal() == wx.ID_CANCEL):
print("Launch aborted")
return
else:
pathname = fileDialog.GetPath()
WorkerThread(self.LoadGeneData, [pathname])
fileDialog.Destroy()
def LoadGeneData(self, args):
pathname = args[0]
evt = GENEDataEvt(Unbound_EVT_GENE_DATA_LOADED, wx.ID_ANY)
if(self.Results.Scenario.load_GENE_obj(pathname, self.Results.Config["Physics"]["dstf"])):
evt.set_state(0)
else:
evt.set_state(-1)
wx.PostEvent(self, evt)
def OnGeneLoaded(self, evt):
if(evt.state == 0):
gene_dlg = Select_GENE_timepoints_dlg(self, self.Results.Scenario["GENE_obj"].time)
if(gene_dlg.ShowModal() == wx.ID_OK):
if(len(gene_dlg.used) == 0):
print("No time point selected")
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
wx.PostEvent(self, evt)
return
if(not self.Results.Scenario.integrate_GeneData(np.asarray(gene_dlg.used, dtype=np.float) * 1.e-3)):
print("GENE object not properly initialized - this is most likely due to a bug in the GUI")
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
wx.PostEvent(self, evt)
return
evt_out_2 = UpdateDataEvt(Unbound_EVT_UPDATE_DATA, self.GetId())
evt_out_2.SetResults(self.Results)
wx.PostEvent(self.scenario_select_panel, evt_out_2)
gene_dlg.Destroy()
self.TimeBox.Clear()
for time in self.Results.Scenario["time"]:
self.TimeBox.Append("{0:1.5f}".format(time))
self.FinalECRadSetup(True)
else:
print("Aborted")
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
wx.PostEvent(self, evt)
return
else:
print("Error when loading GENE data - see above")
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('')
wx.PostEvent(self, evt)
return
def FinalECRadSetup(self, scenario_updated):
# Thinga we need to do just before we get going
if(scenario_updated):
self.Results.Scenario.autosave()
self.Results.set_dimensions()
self.ProgressBar.SetRange(self.Results.Scenario["dimensions"]["N_time"])
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('ECRad is running - please wait.')
wx.PostEvent(self, evt)
self.Progress_label.SetLabel("ECRad running - ({0:d}/{1:d})".format(self.index + 1,len(self.Results.Scenario["time"])))
self.ProgressBar.SetValue(self.index)
self.ExportButton.Disable()
self.NameButton.Disable()
self.StartECRadButton.Disable()
evt = wx.PyCommandEvent(Unbound_EVT_MAKE_ECRAD, self.GetId())
wx.PostEvent(self, evt)
def OnProcessTimeStep(self, evt):
self.ECRad_running = True
self.ECRad_input_queue.put(["run ECRad", self.Results, self.index])
def ECRadRunner(cls, input_queue, output_queue):
ECRad_inferface = ECRadF2PYInterface()
while True:
args = input_queue.get()
try:
command = args[0]
if(command == "close"):
break
Results = args[1]
if(Results.Config["Execution"]["batch"]):
scratch_dir = Results.Config["Execution"]["scratch_dir"]
Results.Scenario.to_netcdf(filename=os.path.join(scratch_dir, "Scenario.nc"))
Results.Config.to_netcdf(filename=os.path.join(scratch_dir, "Config.nc"))
run_ECRad = SetupECRadBatch(Results.Config, Results.Scenario, Results.Scenario["time"][args[2]])
ECRad_batch = Popen(run_ECRad)
ECRad_batch.wait()
try:
filename, ed = Results.get_default_filename_and_edition(True)
NewResults = ECRadResults(False)
NewResults.from_netcdf(filename)
NewResults.to_netcdf()
output_queue.put([True, NewResults])
except:
print("Failed to run remotely. Please check .o and .e files at")
print(scratch_dir)
output_queue.put([False, Results])
else:
Results = ECRad_inferface.process_single_timepoint(Results, args[2])
output_queue.put([True, Results])
except Exception as e:
print(e)
output_queue.put([False, Results])
ECRadRunner = classmethod(ECRadRunner)
def OnProcessEnded(self, evt):
self.ECRad_running = False
if(evt.success):
if(self.Results.Config["Execution"]["batch"]):
self.index = self.Results.Scenario["dimensions"]["N_time"]
# Append times twice to track which time points really do have results in case of crashes
self.index += 1
else:
if(self.Results.Config["Execution"]["batch"]):
# If batch crashes we have to dump everything
self.index = 0
while self.index < self.Results.Scenario["dimensions"]["N_time"]:
self.Results.Scenario.drop_time_point(self.index)
else:
print("Sorry, ECRad crashed. Please send the log console output to Severin Denk")
print("Skipping current time point {0:1.4f} and continuing".format(self.Results.Scenario["time"][self.index]))
self.Results.Scenario.drop_time_point(self.index)
self.ProgressBar.SetRange(self.Results.Scenario["dimensions"]["N_time"])
if(self.index < len(self.Results.Scenario["time"]) and not self.stop_current_evaluation):
evt = NewStatusEvt(Unbound_EVT_NEXT_TIME_STEP, self.GetId())
wx.PostEvent(self, evt)
else:
self.FinishUpECRad()
def OnNextTimeStep(self, evt):
if(not self.stop_current_evaluation):
evt = wx.PyCommandEvent(Unbound_EVT_MAKE_ECRAD, self.GetId())
wx.PostEvent(self, evt)
else:
self.FinishUpECRad()
def FinishUpECRad(self):
if(self.Results.Scenario["dimensions"]["N_time"] == 0):
# Unsuccessful termination
print("None of the ECRad runs were completed succesfully - sorry")
self.Results = ECRadResults()
# We have deleted all entries from the Scenario we need to rebuilt this
self.Results.Scenario.plasma_set = False
self.Progress_label.SetLabel("No ECRad run in progress")
self.ProgressBar.SetRange(1)
self.ProgressBar.SetValue(1)
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('ECRad failed - sorry!')
self.GetEventHandler().ProcessEvent(evt)
self.stop_current_evaluation = True
self.StartECRadButton.Enable()
return
if(not self.Results.Config["Execution"]["batch"]):
# Remove time points in case of early termination
for i in range(self.index, self.Results.Scenario["dimensions"]["N_time"]):
self.Results.Scenario.drop_time_point(i)
self.Results.tidy_up(False)
self.TimeBox.Clear()
for t in self.Results.Scenario["time"]:
self.TimeBox.Append("{0:1.4f}".format(t))
self.KillECRadButton.Disable()
self.stop_current_evaluation = False
self.ExportButton.Enable()
self.NameButton.Enable()
self.Progress_label.SetLabel("No ECRad run in progress")
self.ProgressBar.SetRange(self.index)
self.ProgressBar.SetValue(self.index)
evt = wx.PyCommandEvent()
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('ECRad has Finished!')
wx.PostEvent(self, evt)
if(not self.Results.Config["Execution"]["batch"]):
print("Now saving results")
print("This takes a moment please wait")
WorkerThread(self.SavingThread, [])
evt_2 = UpdateDataEvt(Unbound_EVT_UPDATE_DATA, self.GetId())
evt_2.SetResults(self.Results)
if(globalsettings.AUG):
wx.PostEvent(self.calib_panel, evt)
self.calib_panel.GetEventHandler().ProcessEvent(evt_2)
wx.PostEvent(self.scenario_select_panel, evt_2)
wx.PostEvent(self.plot_panel, evt_2)
self.StartECRadButton.Enable()
def SavingThread(self, args):
try:
self.Results.autosave()
except Exception as e:
print("ERROR: Failed to save results")
print(e)
def OnKillECRad(self, evt):
self.stop_current_evaluation = True
print("Waiting for current calculation to finish")
evt = NewStatusEvt(Unbound_EVT_NEW_STATUS, self.GetId())
evt.SetStatus('Termination scheduled - please wait!')
self.GetEventHandler().ProcessEvent(evt)
self.KillECRadButton.Disable()
def OnUpdate(self, evt):
self.Results = evt.Results
self.DiagBox.Clear()
for diag_key in list(self.Results.Scenario["used_diags_dict"]):
self.DiagBox.Append(diag_key)
self.TimeBox.Clear()
for time in self.Results.Scenario["time"]:
self.TimeBox.Append("{0:1.5f}".format(time))
evt_out = UpdateConfigEvt(Unbound_EVT_UPDATE_CONFIG, self.GetId())
self.GetEventHandler().ProcessEvent(evt_out)
self.ExportButton.Enable()
self.NameButton.Enable()
print("Updated main results")
def OnImport(self, evt):
self.Results = ECRadResults()
print("Now loarding: " + evt.filename)
print("This takes a moment please wait")
WorkerThread(self.ImportThread, [evt.filename])
def ImportThread(self,args):
evt = ThreadFinishedEvt(Unbound_EVT_ECRAD_RESULT_LOADED, self.GetId())
try:
self.Results.load(args[0])
evt.SetSuccess(True)
except Exception as e:
print(e)
evt.SetSuccess(False)
wx.PostEvent(self, evt)
def OnResultsImported(self, evt):
if(evt.success):
print("Results loaded")
self.DiagBox.Clear()
for diag_key in self.Results.Scenario["used_diags_dict"]:
self.DiagBox.Append(diag_key)
self.TimeBox.Clear()
for time in self.Results.Scenario["time"]:
self.TimeBox.Append("{0:1.5f}".format(time))
evt_out = UpdateConfigEvt(Unbound_EVT_UPDATE_CONFIG, self.GetId())
evt_out.set_config(self.Results.Config)
evt_out.set_data_origin(self.Results.data_origin)
wx.PostEvent(self.config_panel, evt_out)
evt_out_2 = UpdateDataEvt(Unbound_EVT_UPDATE_DATA, self.GetId())
evt_out_2.SetResults(self.Results)
evt_out_2.SetPath(self.Results.data_origin)
if(globalsettings.AUG):
wx.PostEvent(self.calib_panel, evt_out_2)
wx.PostEvent(self.scenario_select_panel, evt_out_2)
wx.PostEvent(self.launch_panel, evt_out_2)
wx.PostEvent(self.plot_panel, evt_out_2)
else:
print("ERROR: Failed to load Results")
def OnExport(self, evt):
try:
try:
NewConfig = self.config_panel.UpdateConfig(self.Results.Config)
self.Results.Config["Execution"]["working_dir"] = NewConfig["Execution"]["working_dir"]
except ValueError as e:
print("Failed to parse Configuration")
print("Reason: ", e)
print("Did not update working directory")
if(self.Results is not None):
WorkerThread(self.Results.to_netcdf)
else:
print("No results to save")
except AttributeError as e:
print("No results to save")
print(e)
except IOError as e:
print("Failed to save results")
print(e)
def OnLockExport(self, evt):
self.ExportButton.Disable()
self.NameButton.Disable()
def OnIdle(self, evt):
if(self.ECRad_running):
try:
success, self.Results = self.ECRad_output_queue.get(block=False)
evt = ProccessFinishedEvt(Unbound_EVT_ECRAD_FINISHED, self.GetId())
evt.SetSuccess(success)
wx.PostEvent(self, evt)
return
except queue.Empty:
pass
if(not self.ECRad_runner_process.is_alive()):
self.ECRad_runner_process = Process(target=Main_Panel.ECRadRunner, \
args=(self.ECRad_input_queue, \
self.ECRad_output_queue))
self.ECRad_runner_process.start()
success = False
evt = ProccessFinishedEvt(Unbound_EVT_ECRAD_FINISHED, self.GetId())
evt.SetSuccess(success)
wx.PostEvent(self, evt)
# if(self.ECRad_process is not None):
# stream = self.ECRad_process.GetInputStream()
# if stream is not None:
# if stream.CanRead():
# text = stream.read()
# self.Log_Box.AppendText(text)
# evt.RequestMore()
# elif(self.ECRad_running):
# print("ECRad seems to have crashed without the corresponding event chain firing")
# print("This might cause some weird stuff from here on out")
# print("Trying to fix it...")
# self.ECRad_running = False
# self.OnProcessEnded(None)
def OnName(self, evt):
if(self.Results.comment == None):
comment = ""
else:
print(self.Results.comment)
comment = self.Results.comment
comment_dialogue = wx.TextEntryDialog(self, 'Please type comment for your calculation!', value=comment)
if(comment_dialogue.ShowModal() == wx.ID_OK):
self.Results.comment = comment_dialogue.GetValue()
def run_ECRad():
args = sys.argv
working_dir = args[1]
shot = int(args[2])
diag_id = args[3]
shot_data_file = os.path.join(working_dir, args[4])
times_to_analyze = None
try:
if(len(args) > 5):
try:
times_to_analyze = np.loadtxt(os.path.join(working_dir, args[5]))
if(times_to_analyze.ndim == 0):
times_to_analyze = np.array([times_to_analyze])
except:
print("Failed to load " + os.path.join(working_dir, args[5]))
print("Analyzing everything")
except Exception as e:
print("Initialization failed.")
print("Error:", e)
print("Usage: python run_ECRad_no_GUI.py <shotno> <diag id>")
if(globalsettings.TCV):
print("Possible diag ids: UCE, LCE, VCE, CCE")
elif(globalsettings.AUG):
print("Possible diag ids: ECE, CTA, CTC, IEC, ECN, ECO")
else:
print("Only AUG or TCV supported at this time")
print("Got the following args", args)
return -1
try:
Config = ECRadConfig()
Config.from_mat_file(path=os.path.join(working_dir, "UserConfig.mat"))
except IOError:
print("Failed to load user config at : ")
print(os.path.join(working_dir, "UserConfig.mat"))
Config.working_dir = working_dir
if(globalsettings.TCV):
Config.time, Config.plasma_dict = load_plasma_from_mat(Config, shot_data_file)
if(diag_id in ["UCE", "LCE", "VCE"]):
Config.used_diags_dict.update({diag_id: Diag(diag_id, "TCV", diag_id, 0)})
else:
print("Selected diag_id {0:s} is not supported for TCV".format(diag_id))
return -1
Config.Ext_plasma = True
elif(globalsettings.AUG):
Config.time, Config.plasma_dict = load_IDA_data(shot, timepoints=None, exp="AUGD", ed=0)
if(diag_id == "ECE"):
Config.used_diags_dict.update({diag_id: Diag(diag_id, "AUGD", 'RMD', 0)})
elif(diag_id in ["CTA", "CTC", "IEC"]):
if(shot > 33724):
if(diag_id == "CTA"):
beamline = 7
elif(diag_id == "CTC"):
beamline = 8
else:
beamline = 5
else:
if(diag_id == "CTA"):
beamline = 6
else:
beamline = 5
Config.used_diags_dict.update({diag_id: ECRH_diag(diag_id, "AUGD", diag_id, 0, beamline, 1.0, True)})
elif(diag_id in ["ECN", "ECO"]):
if(diag_id == "ECN"):
Config.used_diags_dict.update({diag_id: ECI_diag(diag_id, "AUGD", "TDI", 0, "ECEI", "RZN", 0)})
else:
Config.used_diags_dict.update({diag_id: ECI_diag(diag_id, "AUGD", "TDI", 0, "ECEI", "RZO", 0)})
Config.ECI_dict = get_ECI_launch(Config.used_diags_dict[diag_id], Config.shot)
else:
print("Selected diag_id {0:s} is not supported for TCV".format(diag_id))
return -1
else:
print("Only AUG or TCV supported at this time")
if(Config.time == None):
print("Failed to initialize")
return -1
Config.shot = shot
Config.working_dir = working_dir
for diag_key in Config.used_diags_dict:
if("CT" in diag_key or "IEC" == diag_key):
if(str(Config.used_diags_dict[diag_key].beamline) not in Config.gy_dict):
new_gy = get_ECRH_viewing_angles(Config.shot, \
Config.used_diags_dict[diag_key].beamline)
if(new_gy.error == 0):
Config.gy_dict[str(Config.used_diags_dict[diag_key].beamline)] = new_gy
else:
print("Error when reading viewing angles")
print("Launch aborted")
return
Results = ECRadResults()
Results.parse_config(Config, Config.time)
if(not times_to_analyze is None):
it_ext = 0
actual_times = []
for i in range(len(times_to_analyze)):
actual_times.append(np.argmin(np.abs(Config.time - times_to_analyze[it_ext])))
actual_times = np.array(actual_times)
Config.time = Config.time[actual_times]
Config.plasma_dict["Te"] = Config.plasma_dict["Te"][actual_times]
Config.plasma_dict["ne"] = Config.plasma_dict["ne"][actual_times]
Config.plasma_dict["rhop"] = Config.plasma_dict["rhop"][actual_times]
Config.plasma_dict["ne_rhop_scale"] = Config.plasma_dict["ne_rhop_scale"][actual_times]
if(Config.plasma_dict["eq_data"] is not None):
Config.plasma_dict["eq_data"] = Config.plasma_dict["eq_data"][actual_times]
if(not Config.debug and globalsettings.AUG):
InvokeECRad = "/afs/ipp-garching.mpg.de/home/s/sdenk/F90/ECRad_Model/ECRad_model"
elif(globalsettings.AUG):
InvokeECRad = "/marconi_work/eufus_gw/work/g2sdenk/ECRad_Model_parallel/ECRad_model"
elif(globalsettings.TCV and Config.debug):
InvokeECRad = "../ECRad_Model_TCV/ECRad_model"
elif(globalsettings.TCV):
InvokeECRad = "../ECRad_Model_TCV_no_debug/ECRad_model"
else:
print('Neither AUG nor TCV selected - no Machine!!')
raise IOError
Results = run_ECRad_from_script(working_dir, shot, Config, InvokeECRad, working_dir)
Results.to_mat_file()
print("Finished successfully")
