UML Diagrams¶

@startuml classes_GOLIAT
skinparam linetype poly
skinparam ranksep 300
set namespaceSeparator none
class "Analyzer" as src.analysis.analyzer.Analyzer {
  all_organ_results : list
  all_results : list
  base_dir
  config : str
  phantom_name : str
  plotter
  results_base_dir
  strategy : str
  tissue_group_definitions : dict
  __init__(config: 'Config', phantom_name: str, strategy: 'BaseAnalysisStrategy')
  _convert_units_and_cache(results_df: pd.DataFrame, organ_results_df: pd.DataFrame) -> pd.DataFrame
  _export_reports(results_df: pd.DataFrame, all_organ_results_df: pd.DataFrame)
  _generate_plots(results_df: pd.DataFrame, all_organ_results_df: pd.DataFrame)
  _process_single_result(frequency_mhz: int, scenario_name: str, pos_name: str, orient_name: str)
  run_analysis()
}
class "Antenna" as src.antenna.Antenna {
  antenna_config
  config : str
  frequency_mhz : int
  __init__(config: 'Config', frequency_mhz: int)
  get_centered_antenna_path(centered_antennas_dir: str) -> str
  get_config_for_frequency() -> dict
  get_model_type() -> str
  get_source_entity_name() -> str
}
class "BaseAnalysisStrategy" as src.analysis.base_strategy.BaseAnalysisStrategy {
  base_dir
  config : str
  phantom_name : str
  __init__(config: 'Config', phantom_name: str)
  {abstract}apply_bug_fixes(result_entry: dict) -> dict
  {abstract}calculate_summary_stats(results_df: pd.DataFrame) -> pd.DataFrame
  {abstract}extract_data(pickle_data: dict, frequency_mhz: int, detailed_name: str, scenario_name: str, sim_power: float, norm_factor: float) -> tuple[dict, list]
  {abstract}generate_plots(analyzer: 'Analyzer', plotter: 'Plotter', results_df: pd.DataFrame, all_organ_results_df: pd.DataFrame)
  {abstract}get_normalization_factor(frequency_mhz: int, simulated_power_w: float) -> float
  {abstract}get_plots_dir() -> str
  {abstract}get_results_base_dir() -> str
  {abstract}load_and_process_results(analyzer: 'Analyzer')
}
class "BaseAnalysisStrategy" as src.analysis.strategies.BaseAnalysisStrategy {
  base_dir
  config
  phantom_name
  __init__(config, phantom_name)
  {abstract}apply_bug_fixes(result_entry)
  {abstract}calculate_summary_stats(results_df)
  {abstract}extract_data(pickle_data, frequency_mhz, detailed_name, scenario_name, sim_power, norm_factor)
  {abstract}generate_plots(analyzer, plotter, results_df, all_organ_results_df)
  {abstract}get_normalization_factor(frequency_mhz, simulated_power_w)
  {abstract}get_plots_dir()
  {abstract}get_results_base_dir()
  {abstract}load_and_process_results(analyzer)
}
class "BaseSetup" as src.setups.base_setup.BaseSetup {
  config : str
  emfdtd
  model
  progress_logger : str
  s4l_v1
  verbose_logger : str
  __init__(config: 'Config', verbose_logger: 'Logger', progress_logger: 'Logger')
  _add_point_sensors(simulation: 'emfdtd.Simulation', sim_bbox_entity_name: str)
  _apply_simulation_time_and_termination(simulation: 'emfdtd.Simulation', sim_bbox_entity: 'model.Entity', frequency_mhz: int)
  _finalize_setup(project_manager: 'ProjectManager', simulation: 'emfdtd.Simulation', all_simulation_parts: list, frequency_mhz: int)
  _setup_solver_settings(simulation: 'emfdtd.Simulation')
  {abstract}run_full_setup(project_manager: 'ProjectManager')
}
class "BaseStudy" as src.studies.base_study.BaseStudy {
  base_dir
  config
  gui : str
  line_profiler : NoneType
  profiler
  progress_logger : NoneType, RootLogger
  project_manager
  study_type : str
  verbose_logger : NoneType, RootLogger
  __init__(study_type: str, config_filename: str, gui: 'QueueGUI', profiler)
  _check_for_stop_signal()
  {abstract}_run_study()
  _setup_line_profiler(subtask_name: str, instance) -> tuple
  end_stage_animation()
  run()
  start_stage_animation(task_name: str, end_value: int)
  subtask(task_name: str, instance_to_profile)
}
class "BatchGUI" as src.osparc_batch.gui.BatchGUI {
  button_layout
  cancel_jobs_requested
  force_stop_button
  layout
  print_progress_requested
  progress_button
  stop_and_cancel_button
  stop_run_requested
  tray_button
  tray_icon
  __init__()
  closeEvent(event)
  force_stop_run()
  hide_to_tray()
  init_ui()
  show_from_tray()
  stop_and_cancel_jobs()
  tray_icon_activated(reason)
}
class "BoundarySetup" as src.setups.boundary_setup.BoundarySetup {
  simulation : str
  __init__(config: 'Config', simulation: 'emfdtd.Simulation', verbose_logger: 'Logger', progress_logger: 'Logger')
  setup_boundary_conditions()
}
class "Cleaner" as src.extraction.cleaner.Cleaner {
  parent : str
  __init__(parent: 'ResultsExtractor')
  _delete_files(cleanup_types: list, file_patterns: dict) -> int
  _delete_single_file(file_path: str) -> bool
  cleanup_simulation_files()
}
class "ColorFormatter" as src.logging_manager.ColorFormatter {
  format(record: logging.LogRecord) -> str
}
class "Config" as src.config.Config <> {
  base_dir : str
  config
  config_path
  material_mapping
  material_mapping_path
  profiling_config
  profiling_config_path
  __init__(base_dir: str, config_filename: str)
  _load_config_with_inheritance(path: str) -> dict
  _load_json(path: str) -> dict
  _resolve_config_path(config_filename: str, base_path: str) -> str
  get_antenna_component_names(antenna_model_type: str) -> list
  get_antenna_config() -> dict
  get_auto_cleanup_previous_results() -> list
  get_bandwidth() -> float
  get_download_email() -> str
  get_excitation_type() -> str
  get_freespace_expansion() -> list
  get_gridding_parameters() -> dict
  get_line_profiling_config() -> dict
  get_manual_isolve() -> bool
  get_material_mapping(phantom_name: str) -> dict
  get_only_write_input_file() -> bool
  get_osparc_credentials() -> dict
  get_phantom_definition(phantom_name: str) -> dict
  get_placement_scenario(scenario_name: str) -> dict
  get_profiling_config(study_type: str) -> dict
  get_setting(path: str, default)
  get_simulation_parameters() -> dict
  get_solver_settings() -> dict
}
class "FarFieldAnalysisStrategy" as src.analysis.far_field_strategy.FarFieldAnalysisStrategy {
  apply_bug_fixes(result_entry: dict) -> dict
  calculate_summary_stats(results_df: pd.DataFrame) -> pd.DataFrame
  extract_data(pickle_data: dict, frequency_mhz: int, placement_name: str, scenario_name: str, sim_power: float, norm_factor: float) -> tuple[dict, list]
  generate_plots(analyzer: 'Analyzer', plotter: 'Plotter', results_df: pd.DataFrame, all_organ_results_df: pd.DataFrame)
  get_normalization_factor(frequency_mhz: int, simulated_power_w: float) -> float
  get_plots_dir() -> str
  get_results_base_dir() -> str
  load_and_process_results(analyzer: 'Analyzer')
}
class "FarFieldAnalysisStrategy" as src.analysis.strategies.FarFieldAnalysisStrategy {
  apply_bug_fixes(result_entry)
  calculate_summary_stats(results_df)
  extract_data(pickle_data, frequency_mhz, placement_name, scenario_name, sim_power, norm_factor)
  generate_plots(analyzer, plotter, results_df, all_organ_results_df)
  get_normalization_factor(frequency_mhz, simulated_power_w)
  get_plots_dir()
  get_results_base_dir()
  load_and_process_results(analyzer)
}
class "FarFieldSetup" as src.setups.far_field_setup.FarFieldSetup {
  direction_name : str
  document
  frequency_mhz : int
  phantom_name : str
  polarization_name : str
  project_manager : str
  simulation_type
  __init__(config: 'Config', phantom_name: str, frequency_mhz: int, direction_name: str, polarization_name: str, project_manager: 'ProjectManager', verbose_logger: 'Logger', progress_logger: 'Logger')
  _apply_common_settings(simulation: 'emfdtd.Simulation')
  _create_or_get_simulation_bbox() -> 'model.Entity'
  _create_simulation_entity(bbox_entity: 'model.Entity') -> 'emfdtd.Simulation'
  _finalize_setup(project_manager: 'ProjectManager', simulation: 'emfdtd.Simulation', frequency_mhz: int)
  run_full_setup(phantom_setup: 'PhantomSetup') -> 'emfdtd.Simulation'
}
class "FarFieldStudy" as src.studies.far_field_study.FarFieldStudy {
  __init__(config_filename: str, gui: 'QueueGUI')
  _extract_results_for_project(phantom_name: str, freq: int, simulations_to_extract: list)
  _run_study()
  _validate_auto_cleanup_config(do_setup: bool, do_run: bool, do_extract: bool, auto_cleanup: list)
}
class "GriddingSetup" as src.setups.gridding_setup.GriddingSetup {
  antenna : str
  frequency_mhz : Optional[int]
  placement_name : str
  simulation : str
  units
  __init__(config: 'Config', simulation: 'emfdtd.Simulation', placement_name: str, antenna: 'Antenna', verbose_logger: 'Logger', progress_logger: 'Logger', frequency_mhz: Optional[int])
  _setup_main_grid()
  _setup_subgrids(antenna_components: dict)
  setup_gridding(antenna_components: dict)
}
class "LoggingMixin" as src.logging_manager.LoggingMixin {
  _log(message: str, level: str, log_type: str)
}
class "MaterialSetup" as src.setups.material_setup.MaterialSetup {
  XCoreModeling
  antenna : str
  database
  free_space : bool
  phantom_name : str
  simulation : str
  __init__(config: 'Config', simulation: 'emfdtd.Simulation', antenna: 'Antenna', phantom_name: str, verbose_logger: 'Logger', progress_logger: 'Logger', free_space: bool)
  _assign_antenna_materials(antenna_components: dict)
  _assign_phantom_materials()
  assign_materials(antenna_components: dict, phantom_only: bool)
}
class "NearFieldAnalysisStrategy" as src.analysis.near_field_strategy.NearFieldAnalysisStrategy {
  apply_bug_fixes(result_entry: dict) -> dict
  calculate_summary_stats(results_df: pd.DataFrame) -> pd.DataFrame
  extract_data(pickle_data: dict, frequency_mhz: int, placement_name: str, scenario_name: str, sim_power: float, norm_factor: float) -> tuple[dict, list]
  generate_plots(analyzer: 'Analyzer', plotter: 'Plotter', results_df: pd.DataFrame, all_organ_results_df: pd.DataFrame)
  get_normalization_factor(frequency_mhz: int, simulated_power_w: float) -> float
  get_plots_dir() -> str
  get_results_base_dir() -> str
  load_and_process_results(analyzer: 'Analyzer')
}
class "NearFieldAnalysisStrategy" as src.analysis.strategies.NearFieldAnalysisStrategy {
  apply_bug_fixes(result_entry)
  calculate_summary_stats(results_df)
  extract_data(pickle_data, frequency_mhz, placement_name, scenario_name, sim_power, norm_factor)
  generate_plots(analyzer, plotter, results_df, all_organ_results_df)
  get_normalization_factor(frequency_mhz, simulated_power_w)
  get_plots_dir()
  get_results_base_dir()
  load_and_process_results(analyzer)
}
class "NearFieldSetup" as src.setups.near_field_setup.NearFieldSetup {
  XCoreModeling
  antenna : str
  base_placement_name : str
  document
  free_space : bool
  frequency_mhz : int
  orientation_name : str
  phantom_name : str
  placement_name : str
  position_name : str
  __init__(config: 'Config', phantom_name: str, frequency_mhz: int, scenario_name: str, position_name: str, orientation_name: str, antenna: 'Antenna', verbose_logger: 'Logger', progress_logger: 'Logger', free_space: bool)
  _create_simulation_bbox()
  _finalize_setup(project_manager: 'ProjectManager', simulation: 'emfdtd.Simulation', antenna_components: dict)
  _get_antenna_components() -> dict
  _setup_bounding_boxes()
  _setup_simulation_entity() -> 'emfdtd.Simulation'
  run_full_setup(project_manager: 'ProjectManager', lock) -> 'emfdtd.Simulation'
}
class "NearFieldStudy" as src.studies.near_field_study.NearFieldStudy {
  __init__(config_filename: str, gui: 'QueueGUI')
  _run_placement(phantom_name: str, freq: int, scenario_name: str, position_name: str, orientation_name: str, do_setup: bool, do_run: bool, do_extract: bool)
  _run_study()
  _validate_auto_cleanup_config(do_setup: bool, do_run: bool, do_extract: bool, auto_cleanup: list)
}
class "NumpyArrayEncoder" as src.extraction.json_encoder.NumpyArrayEncoder {
  default(obj: Any) -> Any
}
class "PhantomSetup" as src.setups.phantom_setup.PhantomSetup {
  XCoreModeling
  data
  model
  phantom_name : str
  __init__(config: 'Config', phantom_name: str, verbose_logger: 'Logger', progress_logger: 'Logger')
  _log(message: str, log_type: str)
  ensure_phantom_is_loaded() -> bool
}
class "PlacementSetup" as src.setups.placement_setup.PlacementSetup {
  XCoreMath
  antenna : str
  base_placement_name : str
  free_space : bool
  frequency_mhz : int
  orientation_name : str
  phantom_name : str
  placement_name : str
  position_name : str
  __init__(config: 'Config', phantom_name: str, frequency_mhz: int, scenario_name: str, position_name: str, orientation_name: str, antenna: 'Antenna', verbose_logger: 'Logger', progress_logger: 'Logger', free_space: bool)
  _get_placement_details() -> tuple
  place_antenna()
}
class "Plotter" as src.analysis.plotter.Plotter {
  plots_dir : str
  __init__(plots_dir: str)
  _plot_heatmap(fig, ax, data: pd.DataFrame, title: str, cbar: bool, cbar_ax)
  plot_average_sar_bar(scenario_name: str, avg_results: pd.DataFrame, progress_info: pd.Series)
  plot_far_field_distribution_boxplot(results_df: pd.DataFrame, metric: str)
  plot_peak_sar_heatmap(organ_df: pd.DataFrame, group_df: pd.DataFrame, tissue_groups: dict, value_col: str, title: str)
  plot_peak_sar_line(summary_stats: pd.DataFrame)
  plot_pssar_line(scenario_name: str, avg_results: pd.DataFrame)
  plot_sar_distribution_boxplots(scenario_name: str, scenario_results_df: pd.DataFrame)
  plot_sar_heatmap(organ_df: pd.DataFrame, group_df: pd.DataFrame, tissue_groups: dict)
  plot_whole_body_sar_bar(avg_results: pd.DataFrame)
}
class "PowerExtractor" as src.extraction.power_extractor.PowerExtractor {
  config
  document
  frequency_mhz
  parent : str
  placement_name
  progress_logger
  results_data : dict
  simulation
  study_type
  verbose_logger
  __init__(parent: 'ResultsExtractor', results_data: dict)
  _extract_far_field_power()
  _extract_near_field_power(simulation_extractor: 'analysis.Extractor')
  extract_input_power(simulation_extractor: 'analysis.Extractor')
  extract_power_balance(simulation_extractor: 'analysis.Extractor')
}
class "Profiler" as src.profiler.Profiler {
  completed_phases : set
  completed_simulations : int
  completed_stages_in_phase : int
  config_path : str
  current_phase : NoneType, str
  current_project : int
  execution_control : dict
  phase_start_time : NoneType
  phase_weights : dict
  profiling_config : dict
  run_phase_total_duration : int
  start_time
  study_type : str
  subtask_stack : list
  subtask_times : defaultdict
  total_projects : int
  total_simulations : int
  total_stages_in_phase : int
  __init__(execution_control: dict, profiling_config: dict, study_type: str, config_path: str)
  _calculate_phase_weights() -> dict
  complete_run_phase()
  end_stage()
  get_subtask_estimate(task_name: str) -> float
  get_time_remaining(current_stage_progress: float) -> float
  get_weighted_progress(phase_name: str, phase_progress_ratio: float) -> float
  save_estimates()
  set_current_project(project_index: int)
  set_project_scope(total_projects: int)
  set_total_simulations(total: int)
  start_stage(phase_name: str, total_stages: int)
  update_and_save_estimates()
}
class "Profiler" as src.utils.Profiler {
  completed_runs : int
  config_path : str
  current_run_start_time : NoneType
  profiling_config
  run_times : list
  start_time
  study_type : str
  total_runs : int
  __init__(config_path: str, study_type: str)
  _load_config() -> dict
  end_run()
  get_average_run_time() -> float
  get_elapsed() -> float
  get_time_remaining() -> float
  save_estimates()
  start_run()
  start_study(total_runs: int)
  subtask(name: str)
}
class "ProgressGUI" as src.gui_manager.ProgressGUI {
  animation_active : bool
  animation_duration : float, int
  animation_end_value : int
  animation_start_time : int
  animation_start_value : int
  animation_timer
  button_layout
  clock_timer
  elapsed_label
  eta_label
  grid_layout
  layout
  overall_progress_bar
  overall_progress_label
  phase_name_map : dict
  process
  profiler
  profiler_phase : NoneType
  progress_logger : NoneType, RootLogger
  queue : str
  queue_timer
  stage_label
  stage_progress_bar
  start_time
  status_log_label
  status_text
  stop_button
  stop_event : str
  total_steps_for_stage : int
  tray_button
  tray_icon
  verbose_logger : NoneType, RootLogger
  window_title : str
  __init__(queue: 'Queue', stop_event: 'Event', process, window_title: str)
  closeEvent(event)
  end_stage_animation()
  hide_to_tray()
  init_ui()
  process_queue()
  show_from_tray()
  start_stage_animation(estimated_duration: float, end_step: int)
  stop_study()
  study_finished(error: bool)
  tray_icon_activated(reason)
  update_animation()
  update_clock()
  update_overall_progress(current_step: int, total_steps: int)
  update_stage_progress(stage_name: str, current_step: int, total_steps: int)
  update_status(message: str, log_type: str)
}
class "ProjectCorruptionError" as src.project_manager.ProjectCorruptionError {
}
class "ProjectManager" as src.project_manager.ProjectManager {
  config : str
  document
  execution_control
  gui : str
  progress_logger : str
  project_path : NoneType
  verbose_logger : str
  __init__(config: 'Config', verbose_logger: 'Logger', progress_logger: 'Logger', gui: 'QueueGUI')
  _is_valid_smash_file() -> bool
  cleanup()
  close()
  create_new()
  create_or_open_project(phantom_name: str, frequency_mhz: int, scenario_name: str, position_name: str, orientation_name: str)
  open()
  reload_project()
  save()
}
class "QueueGUI" as src.gui_manager.QueueGUI {
  profiler : str
  progress_logger : str
  queue : str
  stop_event : str
  verbose_logger : str
  __init__(queue: 'Queue', stop_event: 'Event', profiler: 'Profiler', progress_logger: 'Logger', verbose_logger: 'Logger')
  end_stage_animation()
  is_stopped() -> bool
  log(message: str, level: str, log_type: str)
  {abstract}process_events()
  start_stage_animation(task_name: str, end_value: int)
  update_overall_progress(current_step: int, total_steps: int)
  update_profiler()
  update_stage_progress(stage_name: str, current_step: int, total_steps: int)
}
class "Reporter" as src.extraction.reporter.Reporter {
  parent : str
  __init__(parent: 'ResultsExtractor')
  _build_html_content(df: pd.DataFrame, tissue_groups: dict, group_sar_stats: dict, results_data: dict) -> str
  _get_results_dir() -> str
  _save_html_report(results_dir: str, df: pd.DataFrame, tissue_groups: dict, group_sar_stats: dict, results_data: dict)
  _save_pickle_report(results_dir: str, df: pd.DataFrame, tissue_groups: dict, group_sar_stats: dict, results_data: dict)
  save_reports(df: pd.DataFrame, tissue_groups: dict, group_sar_stats: dict, results_data: dict)
}
class "ResultsExtractor" as src.results_extractor.ResultsExtractor {
  analysis
  config : str
  document
  free_space : bool
  frequency_mhz : int
  gui : str
  orientation_name : str
  phantom_name : str
  placement_name : str
  progress_logger : str
  simulation : str
  study : str
  study_type : str
  units
  verbose_logger : str
  __init__(config: 'Config', simulation: 's4l_v1.simulation.emfdtd.Simulation', phantom_name: str, frequency_mhz: int, scenario_name: str, position_name: str, orientation_name: str, study_type: str, verbose_logger: 'Logger', progress_logger: 'Logger', free_space: bool, gui: 'QueueGUI', study: 'BaseStudy')
  _save_json_results(results_data: dict)
  extract()
}
class "SarExtractor" as src.extraction.sar_extractor.SarExtractor {
  analysis
  config
  document
  parent : str
  phantom_name
  placement_name
  progress_logger
  results_data : dict
  simulation
  units
  verbose_logger
  __init__(parent: 'ResultsExtractor', results_data: dict)
  _calculate_group_sar(df: pd.DataFrame, tissue_groups: dict) -> dict
  _define_tissue_groups(available_tissues: list) -> dict
  extract_peak_sar_details(em_sensor_extractor: 'analysis.Extractor')
  extract_sar_statistics(simulation_extractor: 'analysis.Extractor')
}
class "SensorExtractor" as src.extraction.sensor_extractor.SensorExtractor {
  parent : str
  progress_logger
  results_data : dict
  verbose_logger
  __init__(parent: 'ResultsExtractor', results_data: dict)
  _save_plot(fig, ax)
  extract_point_sensor_data(simulation_extractor: 'analysis.Extractor')
}
class "SimulationRunner" as src.simulation_runner.SimulationRunner <> {
  config : str
  document
  gui : str
  progress_logger : str
  project_path : str
  simulations : list
  study : str
  verbose_logger : str
  __init__(config: 'Config', project_path: str, simulations: Union['s4l_v1.simulation.emfdtd.Simulation', List['s4l_v1.simulation.emfdtd.Simulation']], verbose_logger: 'Logger', progress_logger: 'Logger', gui: 'QueueGUI', study: 'BaseStudy')
  _get_server_id(server_name: str) -> str
  _run_isolve_manual(simulation: 's4l_v1.simulation.emfdtd.Simulation')
  _run_osparc_direct(simulation: 's4l_v1.simulation.emfdtd.Simulation', server_name: str)
  run(simulation: 's4l_v1.simulation.emfdtd.Simulation')
  run_all()
}
class "SourceSetup" as src.setups.source_setup.SourceSetup {
  antenna : str
  free_space : bool
  frequency_mhz : int
  simulation : str
  units
  __init__(config: 'Config', simulation: 'emfdtd.Simulation', frequency_mhz: int, antenna: 'Antenna', verbose_logger: 'Logger', progress_logger: 'Logger', free_space: bool)
  setup_source_and_sensors(antenna_components: dict)
}
class "StudyCancelledError" as src.utils.StudyCancelledError {
}
class "Worker" as src.osparc_batch.worker.Worker {
  client_cfg : NoneType
  config : NoneType
  config_path : str
  download_and_process_results : Callable[..., Any]
  download_executor : ThreadPoolExecutor
  downloaded_jobs : set
  file_retries : dict
  file_to_job_id : dict
  finished
  get_osparc_client_config : Callable[..., Any]
  get_progress_report : Callable[..., str]
  input_files : list
  job_statuses : dict
  jobs_being_downloaded : set
  logger : Logger
  main_process_logic : Callable[..., Any]
  progress
  running_jobs : dict
  status_update_requested
  stop_requested : bool
  timer
  __init__(config_path: str, logger: logging.Logger, get_osparc_client_config_func: Callable[..., Any], download_and_process_results_func: Callable[..., Any], get_progress_report_func: Callable[..., str], main_process_logic_func: Callable[..., Any])
  _check_jobs_status()
  _download_job_in_thread(job, solver, file_path: Path)
  _update_job_status(job_id: str, status: str)
  cancel_jobs()
  request_progress_report()
  run()
  stop()
}
src.analysis.far_field_strategy.FarFieldAnalysisStrategy --|> src.analysis.base_strategy.BaseAnalysisStrategy
src.analysis.near_field_strategy.NearFieldAnalysisStrategy --|> src.analysis.base_strategy.BaseAnalysisStrategy
src.analysis.strategies.FarFieldAnalysisStrategy --|> src.analysis.strategies.BaseAnalysisStrategy
src.analysis.strategies.NearFieldAnalysisStrategy --|> src.analysis.strategies.BaseAnalysisStrategy
src.extraction.power_extractor.PowerExtractor --|> src.logging_manager.LoggingMixin
src.extraction.sar_extractor.SarExtractor --|> src.logging_manager.LoggingMixin
src.gui_manager.QueueGUI --|> src.logging_manager.LoggingMixin
src.project_manager.ProjectManager --|> src.logging_manager.LoggingMixin
src.results_extractor.ResultsExtractor --|> src.logging_manager.LoggingMixin
src.setups.base_setup.BaseSetup --|> src.logging_manager.LoggingMixin
src.setups.boundary_setup.BoundarySetup --|> src.setups.base_setup.BaseSetup
src.setups.far_field_setup.FarFieldSetup --|> src.setups.base_setup.BaseSetup
src.setups.gridding_setup.GriddingSetup --|> src.setups.base_setup.BaseSetup
src.setups.material_setup.MaterialSetup --|> src.setups.base_setup.BaseSetup
src.setups.near_field_setup.NearFieldSetup --|> src.setups.base_setup.BaseSetup
src.setups.phantom_setup.PhantomSetup --|> src.setups.base_setup.BaseSetup
src.setups.placement_setup.PlacementSetup --|> src.setups.base_setup.BaseSetup
src.setups.source_setup.SourceSetup --|> src.setups.base_setup.BaseSetup
src.simulation_runner.SimulationRunner --|> src.logging_manager.LoggingMixin
src.studies.base_study.BaseStudy --|> src.logging_manager.LoggingMixin
src.studies.far_field_study.FarFieldStudy --|> src.studies.base_study.BaseStudy
src.studies.near_field_study.NearFieldStudy --|> src.studies.base_study.BaseStudy
src.analysis.plotter.Plotter --* src.analysis.analyzer.Analyzer : plotter
src.config.Config --* src.studies.base_study.BaseStudy : config
src.profiler.Profiler --* src.studies.base_study.BaseStudy : profiler
src.project_manager.ProjectManager --* src.studies.base_study.BaseStudy : project_manager
src.config.Config --o src.osparc_batch.worker.Worker : config
@enduml

@startuml packages_GOLIAT
skinparam linetype ortho
skinparam ranksep 200
set namespaceSeparator none
package "src" as src {
}
package "src.analysis" as src.analysis {
}
package "src.analysis.analyzer" as src.analysis.analyzer {
}
package "src.analysis.base_strategy" as src.analysis.base_strategy {
}
package "src.analysis.far_field_strategy" as src.analysis.far_field_strategy {
}
package "src.analysis.near_field_strategy" as src.analysis.near_field_strategy {
}
package "src.analysis.plotter" as src.analysis.plotter {
}
package "src.analysis.strategies" as src.analysis.strategies {
}
package "src.antenna" as src.antenna {
}
package "src.colors" as src.colors {
}
package "src.config" as src.config {
}
package "src.data_extractor" as src.data_extractor {
}
package "src.extraction" as src.extraction {
}
package "src.extraction.cleaner" as src.extraction.cleaner {
}
package "src.extraction.json_encoder" as src.extraction.json_encoder {
}
package "src.extraction.power_extractor" as src.extraction.power_extractor {
}
package "src.extraction.reporter" as src.extraction.reporter {
}
package "src.extraction.sar_extractor" as src.extraction.sar_extractor {
}
package "src.extraction.sensor_extractor" as src.extraction.sensor_extractor {
}
package "src.gui_manager" as src.gui_manager {
}
package "src.logging_manager" as src.logging_manager {
}
package "src.osparc_batch" as src.osparc_batch {
}
package "src.osparc_batch.cleanup" as src.osparc_batch.cleanup {
}
package "src.osparc_batch.file_finder" as src.osparc_batch.file_finder {
}
package "src.osparc_batch.gui" as src.osparc_batch.gui {
}
package "src.osparc_batch.logging_utils" as src.osparc_batch.logging_utils {
}
package "src.osparc_batch.main_logic" as src.osparc_batch.main_logic {
}
package "src.osparc_batch.osparc_client" as src.osparc_batch.osparc_client {
}
package "src.osparc_batch.progress" as src.osparc_batch.progress {
}
package "src.osparc_batch.runner" as src.osparc_batch.runner {
}
package "src.osparc_batch.worker" as src.osparc_batch.worker {
}
package "src.profiler" as src.profiler {
}
package "src.project_manager" as src.project_manager {
}
package "src.results_extractor" as src.results_extractor {
}
package "src.setups" as src.setups {
}
package "src.setups.base_setup" as src.setups.base_setup {
}
package "src.setups.boundary_setup" as src.setups.boundary_setup {
}
package "src.setups.far_field_setup" as src.setups.far_field_setup {
}
package "src.setups.gridding_setup" as src.setups.gridding_setup {
}
package "src.setups.material_setup" as src.setups.material_setup {
}
package "src.setups.near_field_setup" as src.setups.near_field_setup {
}
package "src.setups.phantom_setup" as src.setups.phantom_setup {
}
package "src.setups.placement_setup" as src.setups.placement_setup {
}
package "src.setups.source_setup" as src.setups.source_setup {
}
package "src.simulation_runner" as src.simulation_runner {
}
package "src.studies" as src.studies {
}
package "src.studies.base_study" as src.studies.base_study {
}
package "src.studies.far_field_study" as src.studies.far_field_study {
}
package "src.studies.near_field_study" as src.studies.near_field_study {
}
package "src.utils" as src.utils {
}
src.analysis.analyzer --> src.analysis.plotter
src.analysis.far_field_strategy --> src.analysis.base_strategy
src.analysis.near_field_strategy --> src.analysis.base_strategy
src.extraction --> src.extraction.cleaner
src.extraction --> src.extraction.power_extractor
src.extraction --> src.extraction.reporter
src.extraction --> src.extraction.sar_extractor
src.extraction --> src.extraction.sensor_extractor
src.gui_manager --> src.logging_manager
src.gui_manager --> src.profiler
src.gui_manager --> src.utils
src.logging_manager --> src.colors
src.osparc_batch.cleanup --> src.osparc_batch.logging_utils
src.osparc_batch.file_finder --> src.osparc_batch.logging_utils
src.osparc_batch.main_logic --> src.osparc_batch.logging_utils
src.osparc_batch.main_logic --> src.osparc_batch.osparc_client
src.osparc_batch.osparc_client --> src.osparc_batch.logging_utils
src.osparc_batch.progress --> src.osparc_batch.logging_utils
src.osparc_batch.runner --> src.config
src.osparc_batch.runner --> src.osparc_batch.cleanup
src.osparc_batch.runner --> src.osparc_batch.file_finder
src.osparc_batch.runner --> src.osparc_batch.gui
src.osparc_batch.runner --> src.osparc_batch.logging_utils
src.osparc_batch.runner --> src.osparc_batch.main_logic
src.osparc_batch.runner --> src.osparc_batch.osparc_client
src.osparc_batch.runner --> src.osparc_batch.progress
src.osparc_batch.runner --> src.osparc_batch.worker
src.osparc_batch.worker --> src.osparc_batch.runner
src.project_manager --> src.logging_manager
src.project_manager --> src.utils
src.results_extractor --> src.extraction.cleaner
src.results_extractor --> src.extraction.json_encoder
src.results_extractor --> src.extraction.power_extractor
src.results_extractor --> src.extraction.reporter
src.results_extractor --> src.extraction.sar_extractor
src.results_extractor --> src.extraction.sensor_extractor
src.results_extractor --> src.logging_manager
src.setups.base_setup --> src.logging_manager
src.setups.boundary_setup --> src.setups.base_setup
src.setups.far_field_setup --> src.setups.base_setup
src.setups.far_field_setup --> src.setups.boundary_setup
src.setups.far_field_setup --> src.setups.gridding_setup
src.setups.far_field_setup --> src.setups.material_setup
src.setups.gridding_setup --> src.setups.base_setup
src.setups.material_setup --> src.setups.base_setup
src.setups.near_field_setup --> src.setups.base_setup
src.setups.near_field_setup --> src.setups.boundary_setup
src.setups.near_field_setup --> src.setups.gridding_setup
src.setups.near_field_setup --> src.setups.material_setup
src.setups.near_field_setup --> src.setups.phantom_setup
src.setups.near_field_setup --> src.setups.placement_setup
src.setups.near_field_setup --> src.setups.source_setup
src.setups.phantom_setup --> src.setups.base_setup
src.setups.placement_setup --> src.setups.base_setup
src.setups.source_setup --> src.setups.base_setup
src.simulation_runner --> src.logging_manager
src.simulation_runner --> src.utils
src.studies.base_study --> src.config
src.studies.base_study --> src.logging_manager
src.studies.base_study --> src.profiler
src.studies.base_study --> src.project_manager
src.studies.base_study --> src.utils
src.studies.far_field_study --> src.studies.base_study
src.studies.near_field_study --> src.studies.base_study
src.analysis.analyzer ..> src.analysis.base_strategy
src.analysis.base_strategy ..> src.analysis.analyzer
src.analysis.base_strategy ..> src.analysis.plotter
src.analysis.far_field_strategy ..> src.analysis.analyzer
src.analysis.far_field_strategy ..> src.analysis.plotter
src.analysis.near_field_strategy ..> src.analysis.analyzer
src.analysis.near_field_strategy ..> src.analysis.plotter
src.antenna ..> src.config
src.osparc_batch.file_finder ..> src.config
src.osparc_batch.main_logic ..> src.osparc_batch.worker
src.osparc_batch.osparc_client ..> src.config
src.project_manager ..> src.config
src.project_manager ..> src.gui_manager
src.results_extractor ..> src.config
src.results_extractor ..> src.gui_manager
src.results_extractor ..> src.studies.base_study
src.setups.far_field_setup ..> src.setups.phantom_setup
src.simulation_runner ..> src.config
src.simulation_runner ..> src.gui_manager
src.simulation_runner ..> src.studies.base_study
src.utils ..> src.studies.base_study
@enduml