fiqus 2025.12.0__py3-none-any.whl → 2026.1.1__py3-none-any.whl

fiqus/getdp_runners/RunGetdpConductorAC_CC.py

@@ -0,0 +1,123 @@
+import timeit
+import logging
+from enum import Enum
+import os
+import subprocess
+import re
+import pandas as pd
+
+import gmsh
+import numpy as np
+
+#from fiqus.data import RegionsModelFiQuS
+from fiqus.utils.Utils import GmshUtils, FilesAndFolders
+from fiqus.data.RegionsModelFiQuS import RegionsModel
+# import fiqus.data.DataConductorACGeom as geom
+
+from fiqus.pro_assemblers.ProAssembler import ASS_PRO
+
+logger = logging.getLogger('FiQuS')
+
+class Solve:
+    def __init__(self, fdm, GetDP_path, geometry_folder, mesh_folder, verbose=True):
+        self.fdm = fdm
+        self.cacdm = fdm.magnet
+        self.GetDP_path = GetDP_path
+        self.solution_folder = os.path.join(os.getcwd())
+        self.magnet_name = fdm.general.magnet_name
+        self.geometry_folder = geometry_folder
+        self.mesh_folder = mesh_folder
+        self.mesh_file = os.path.join(self.mesh_folder, f"{self.magnet_name}.msh")
+        self.pro_file = os.path.join(self.solution_folder, f"{self.magnet_name}.pro")
+        self.regions_file = os.path.join(mesh_folder, f"{self.magnet_name}.regions")
+        
+        self.verbose = verbose
+        self.gu = GmshUtils(self.solution_folder, self.verbose)
+        self.gu.initialize(verbosity_Gmsh=fdm.run.verbosity_Gmsh)
+
+        self.ass_pro = ASS_PRO(os.path.join(self.solution_folder, self.magnet_name))
+        self.regions_model = FilesAndFolders.read_data_from_yaml(self.regions_file, RegionsModel)
+        self.material_properties_model = None
+
+        self.ed = {} # excitation dictionary
+
+        gmsh.option.setNumber("General.Terminal", verbose)
+
+    def assemble_pro(self):
+        logger.info("Assembling .pro file")
+        self.ass_pro.assemble_combined_pro(template = self.cacdm.solve.pro_template, rm = self.regions_model, dm = self.fdm, ed=self.ed, mp=self.material_properties_model)
+
+    def read_excitation(self, inputs_folder_path):
+        """
+        Function for reading a CSV file for the 'piecewise' excitation case.
+
+        :param inputs_folder_path: The full path to the folder with input files.
+        :type inputs_folder_path: str
+        """
+        if self.cacdm.solve.source_parameters.source_type == 'piecewise' and self.cacdm.solve.source_parameters.piecewise.source_csv_file:
+            input_file = os.path.join(inputs_folder_path, self.cacdm.solve.source_parameters.piecewise.source_csv_file)
+            logger.info(f'Using excitation from file: {input_file}')
+            df = pd.read_csv(input_file, delimiter=',', engine='python')
+            excitation_time = df['time'].to_numpy(dtype='float').tolist()
+            self.ed['time'] = excitation_time
+            excitation_b = df['b'].to_numpy(dtype='float').tolist()
+            self.ed['b'] = excitation_b
+            excitation_I = df['I'].to_numpy(dtype='float').tolist()
+            self.ed['I'] = excitation_I
+
+    def run_getdp(self, solve = True, postOperation = True, gui = False):
+        command = ["-v2", "-verbose", "3"]
+        if solve: 
+            command += ["-solve", "MagDyn", "-mat_mumps_icntl_14","100"] # icntl for mumps just by precaution
+        command += ["-pos", "MagDyn"]
+
+        logger.info(f"Running GetDP with command: {command}")
+        startTime = timeit.default_timer()
+
+        if self.cacdm.solve.general_parameters.noOfMPITasks:
+            mpi_prefix = ["mpiexec", "-np", str(self.cacdm.solve.general_parameters.noOfMPITasks)]
+        else:
+            mpi_prefix = []
+
+        getdpProcess = subprocess.Popen(mpi_prefix + [self.GetDP_path] + [self.pro_file] + command + ["-msh"] + [self.mesh_file], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+        with getdpProcess.stdout:
+            for line in iter(getdpProcess.stdout.readline, b""):
+                line = line.decode("utf-8").rstrip()
+                line = line.split("\r")[-1]
+                if not "Test" in line:
+                    if line.startswith("Info"):
+                        parsedLine = re.sub(r"Info\s+:\s+", "", line)
+                        logger.info(parsedLine)
+                    elif line.startswith("Warning"):
+                        parsedLine = re.sub(r"Warning\s+:\s+", "", line)
+                        logger.warning(parsedLine)
+                    elif line.startswith("Error"):
+                        parsedLine = re.sub(r"Error\s+:\s+", "", line)
+                        logger.error(parsedLine)
+                        logger.error("Solving CAC failed.")
+                        # raise Exception(parsedLine)
+                    elif re.match("##", line):
+                        logger.critical(line)
+                    else:
+                        logger.info(line)
+        
+        simulation_time = timeit.default_timer()-startTime
+        
+        if gui and ((postOperation and not solve) or (solve and postOperation)): # and self.cacdm.postproc.generate_pos_files
+            # gmsh.option.setNumber("Geometry.Volumes", 1)
+            # gmsh.option.setNumber("Geometry.Surfaces", 1)
+            # gmsh.option.setNumber("Geometry.Curves", 1)
+            # gmsh.option.setNumber("Geometry.Points", 0)
+            posFiles = [
+                fileName
+                for fileName in os.listdir(self.solution_folder)
+                if fileName.endswith(".pos")
+            ]
+            for posFile in posFiles:
+                gmsh.open(os.path.join(self.solution_folder, posFile))
+            self.gu.launch_interactive_GUI()
+        else:
+            if gmsh.isInitialized():
+                gmsh.clear()
+                gmsh.finalize()

fiqus/getdp_runners/RunGetdpMultipole.py

@@ -4,6 +4,7 @@ import subprocess
 import logging
 import timeit
 import re
+import pandas as pd
 
 import gmsh
 from fiqus.pro_assemblers.ProAssembler import ASS_PRO as aP
@@ -13,8 +14,9 @@ from fiqus.data import DataFiQuS as dF
 from fiqus.data import RegionsModelFiQuS as rM
 from fiqus.data import DataMultipole as dM
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('FiQuS')
 
+trigger_time_deactivated = 99999
 
 class AssignNaming:
     def __init__(self, data: dF.FDM() = None):
@@ -24,16 +26,30 @@ class AssignNaming:
         """
         self.data: dF.FDM() = data
 
-        self.naming_conv = {'omega': 'Omega', 'boundary': 'Bd_', 'powered': '_p', 'induced': '_i', 'air': '_a',
-                            'air_far_field': '_aff', 'iron': '_bh', 'conducting': '_c', 'insulator': '_ins', 'terms': 'Terms'}
+        self.naming_conv = {'omega': 'Omega',
+                            'boundary': 'Bnd_',
+                            'powered': '_p', 'induced': '_i',
+                            'air': '_a',
+                            'air_far_field': '_aff',
+                            'conducting': '_c',
+                            'insulator': '_ins',
+                            'terms': 'Terms',
+                            'iron_yoke': '_bh', #todo: consider renaming this
+                            'collar': '_collar',
+                            'ref_mesh': '_refmesh',
+                            'poles': '_poles'}
+
         self.data.magnet.postproc.electromagnetics.volumes = \
-            [self.naming_conv['omega'] + (self.naming_conv[var] if var != 'omega' else '') for var in self.data.magnet.postproc.electromagnetics.volumes]
+            [self.naming_conv['omega'] + (self.naming_conv[var] if var != 'omega' else '') for var in
+             self.data.magnet.postproc.electromagnetics.volumes]
         self.data.magnet.postproc.thermal.volumes = \
-            [self.naming_conv['omega'] + (self.naming_conv[var] if var != 'omega' else '') for var in self.data.magnet.postproc.thermal.volumes]
+            [self.naming_conv['omega'] + (self.naming_conv[var] if var != 'omega' else '') for var in
+             self.data.magnet.postproc.thermal.volumes]
 
 
 class RunGetdpMultipole:
-    def __init__(self, data: AssignNaming = None, solution_folder: str = None, GetDP_path: str = None, verbose: bool = False):
+    def __init__(self, data: AssignNaming = None, solution_folder: str = None, GetDP_path: str = None,
+                 verbose: bool = False):
         """
         Class to solve pro file
         :param data: FiQuS data model
@@ -48,62 +64,116 @@ class RunGetdpMultipole:
         self.solution_folder = solution_folder
         self.GetDP_path = GetDP_path
         self.verbose: bool = verbose
-        self.call_method = 'subprocess'  # or onelab
+        self.call_method = 'subprocess'  # or onelab or subprocess or alt_solver
 
         self.rm_EM = rM.RegionsModel()
         self.rm_TH = rM.RegionsModel()
-        self.rc = dM.MultipoleRegionCoordinate()\
+        self.aux = {
+            "half_turns": {
+                "ht": {},  # Dictionary to store half-turn data
+                "max_reg": None,  # Maximum region number to avoid overlaps of physical regions
+                "block": {}  # Dictionary that stores the relation between magnet blocks(groups) and half-turn areas
+
+            },
+            "e_cliq": {},  # Dictionary that stores the E-CLIQ source current LUTs from a csv
+            "tsa_collar": {},
+            "sim_info": {
+                'date': '',
+                'author': ''
+            }
+        }
+        self.material_properties_model = None
+        self.rohm = {}  # rohm parameter dictionary
+        self.rohf = {}  # rohf parameter dictionary
+        self.rc = dM.MultipoleRegionCoordinate() \
             if self.data.magnet.mesh.thermal.isothermal_conductors and self.data.magnet.solve.thermal.solve_type else None
 
         self.gu = GmshUtils(self.solution_folder, self.verbose)
         self.gu.initialize(verbosity_Gmsh=self.data.run.verbosity_Gmsh)
         self.occ = gmsh.model.occ
         self.mesh = gmsh.model.mesh
-
-        self.brep_iron_curves = {1: set(), 2: set(), 3: set(), 4: set()}
+        self.brep_curves = {}
+        for name in self.data.magnet.geometry.electromagnetics.areas:
+            self.brep_curves[name] = {1: set(), 2: set(), 3: set(), 4: set()}
         self.mesh_files = os.path.join(os.path.dirname(self.solution_folder), self.data.general.magnet_name)
         self.model_file = os.path.join(self.solution_folder, 'Center_line.csv')
 
         self.mf = {'EM': f"{self.mesh_files}_EM.msh", 'TH': f"{self.mesh_files}_TH.msh"}
 
     def loadRegionFiles(self):
+        """
+        Read the regions' files and store the information in a variable. used for extracting the maximum region number.
+        :param
+        :return: Data from the regions files
+        """
         if self.data.magnet.solve.electromagnetics.solve_type:
             self.rm_EM = Util.read_data_from_yaml(f"{self.mesh_files}_EM.reg", rM.RegionsModel)
         if self.data.magnet.solve.thermal.solve_type:
             self.rm_TH = Util.read_data_from_yaml(f"{self.mesh_files}_TH.reg", rM.RegionsModel)
 
     def loadRegionCoordinateFile(self):
+        """
+        Read the reco file and store the information in a variable.
+        :param
+        :return: Data from the reco file
+        """
         self.rc = Util.read_data_from_yaml(f"{self.mesh_files}_TH.reco", dM.MultipoleRegionCoordinate)
 
     def assemblePro(self):
+        """
+        Assemble the .pro file using the right template depending on the inputs from the yaml
+        :param
+        :return: Assembled .pro file
+        """
         logger.info(f"Assembling pro file...")
         start_time = timeit.default_timer()
-        ap = aP(file_base_path=os.path.join(self.solution_folder, self.data.general.magnet_name), naming_conv=self.naming_conv)
-        BH_curves_path = os.path.join(pathlib.Path(os.path.dirname(__file__)).parent, 'pro_material_functions', 'ironBHcurves.pro')
-        ap.assemble_combined_pro(template='Multipole_template.pro', rm_EM=self.rm_EM, rm_TH=self.rm_TH, rc=self.rc, dm=self.data, mf=self.mf, BH_curves_path=BH_curves_path)
+        ap = aP(file_base_path=os.path.join(self.solution_folder, self.data.general.magnet_name),
+                naming_conv=self.naming_conv)
+        BH_curves_path = os.path.join(pathlib.Path(os.path.dirname(__file__)).parent, 'pro_material_functions',
+                                      'ironBHcurves.pro')
+        template = 'Multipole_template.pro'
+        ap.assemble_combined_pro(template=template, rm_EM=self.rm_EM, rm_TH=self.rm_TH, rc=self.rc, dm=self.data,
+                                 mf=self.mf, BH_curves_path=BH_curves_path, aux=self.aux)
         logger.info(
             f"Assembling pro file took"
             f" {timeit.default_timer() - start_time:.2f} s."
         )
 
     def solve_and_postprocess(self):
+        """
+        Generates the necessary GetDP commands to solve and postprocess the model, and runs them.
+        :param
+        :return: None
+        """
         commands = None
         if self.call_method == 'onelab':
             commands = f"-solve -v2 -pos -verbose {self.data.run.verbosity_GetDP}"
         elif self.call_method == 'subprocess':
-            commands = []
-            commands.append(["-solve", 'resolution', "-v2", "-pos", "Dummy", "-verbose", str(self.data.run.verbosity_GetDP)])
-
+            commands = [["-solve", 'resolution', "-v2", "-pos", "Dummy", "-verbose", str(self.data.run.verbosity_GetDP),
+                         "-mat_mumps_icntl_14", "250"]]
         self._run(commands=commands)
 
     def postprocess(self):
+        """
+        Generates the necessary GetDP commands to postprocess the model, and runs them.
+        :param
+        :return: None
+        """
         if self.call_method == 'onelab':
-            command = "-v2 -pos -verbose {self.data.run.verbosity_GetDP}"
+            commands = f"-v2 -pos -verbose {self.data.run.verbosity_GetDP}"
         elif self.call_method == 'subprocess':
-            command = [["-v2", "-pos", "-verbose", str(self.data.run.verbosity_GetDP)]]
-        self._run(commands=command)
+            commands = [["-v2", "-pos", "Dummy", "-verbose", str(self.data.run.verbosity_GetDP)]]
+        elif self.call_method == 'alt_solver':
+            commands = [["-solve", 'resolution', "-v2", "-pos", "Dummy"]]
+
+        self._run(commands=commands)
 
     def _run(self, commands):
+        """
+        runs GetDP with the specified commands. Additionally it captures and logs the output.
+        :param commands: List of commands to run GetDP with
+        :return: None
+        """
         logger.info("Solving...")
         start_time = timeit.default_timer()
         if self.call_method == 'onelab':
@@ -111,7 +181,7 @@ class RunGetdpMultipole:
                 gmsh.onelab.run(f"{self.data.general.magnet_name}",
                                 f"{self.GetDP_path} {os.path.join(self.solution_folder, self.data.general.magnet_name)}.pro {command}")
             gmsh.onelab.setChanged("GetDP", 0)
-        elif self.call_method == 'subprocess':
+        elif self.call_method == 'subprocess' or self.call_method == 'alt_solver':
             # subprocess.call([f"{self.GetDP_path}", f"{os.path.join(self.solution_folder, self.data.general.magnet_name)}.pro"] + command + ["-msh", f"{self.mesh_files}.msh"])
 
             # view_tag = gmsh.view.getTags()  # this should be b
@@ -122,14 +192,26 @@ class RunGetdpMultipole:
                 mpi_prefix = ["mpiexec", "-np", str(self.data.magnet.solve.noOfMPITasks)]
             else:
                 mpi_prefix = []
-            
+
             for command in commands:
-                getdpProcess = subprocess.Popen(
-                    mpi_prefix + [f"{self.GetDP_path}", f"{os.path.join(self.solution_folder, self.data.general.magnet_name)}.pro"] +
-                    command,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.STDOUT,
-                )
+                use_predefined_pro = False  # If True, one can use a predefined .pro file
+                if use_predefined_pro:
+                    logger.warning("Using predefined .pro file")
+                    getdpProcess = subprocess.Popen(
+                        mpi_prefix + [f"{self.GetDP_path}",
+                                      f"{os.path.join(os.path.abspath(os.path.join(self.solution_folder, '..', '..', '..')), '_out/TEST')}.pro"] +
+                        command,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.STDOUT,
+                    )
+                else:
+                    getdpProcess = subprocess.Popen(
+                        mpi_prefix + [f"{self.GetDP_path}",
+                                      f"{os.path.join(self.solution_folder, self.data.general.magnet_name)}.pro"] +
+                        command,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.STDOUT,
+                    )
                 with getdpProcess.stdout:
                     for line in iter(getdpProcess.stdout.readline, b""):
                         line = line.decode("utf-8").rstrip()
@@ -139,8 +221,7 @@ class RunGetdpMultipole:
                             logger.info(parsedLine)
                         elif "Warning" in line:
                             parsedLine = re.sub(r"Warning\s*:\s*", "", line)
-                            if "Unknown" not in parsedLine:
-                                logger.warning(parsedLine)
+                            logger.warning(parsedLine)
                         elif "Error" in line:
                             parsedLine = re.sub(r"Error\s*:\s*", "", line)
                             logger.error(parsedLine)
@@ -163,8 +244,77 @@ class RunGetdpMultipole:
         )
 
     def ending_step(self, gui: bool = False):
+        """
+        Finalize the GetDP runner, either by launching the GUI or finalizing gmsh.
+        :param gui: If True, launches the interactive GUI; otherwise finalizes gmsh.
+        :return: None
+        """
         if gui:
             self.gu.launch_interactive_GUI()
         else:
-            gmsh.clear()
-            gmsh.finalize()
+            if gmsh.isInitialized():
+                gmsh.clear()
+                gmsh.finalize()
+
+    def read_aux_file(self, aux_file_path):
+        """
+        Read the auxiliary file and store the information in a variable. Necessary to extract half-turn information from blocks.
+        :param aux_file_path: Path to the auxiliary file
+        :return: Data from the auxiliary file
+        """
+        try:
+            self.aux_data = Util.read_data_from_yaml(aux_file_path, dM.MultipoleData)
+            logger.info(f"Auxiliary data loaded from {aux_file_path}")
+        except FileNotFoundError:
+            logger.error(f"Auxiliary file not found: {aux_file_path}")
+        except Exception as e:
+            logger.error(f"Error reading auxiliary file: {e}")
+
+    def extract_half_turn_blocks(self):
+        """
+        Extract a dictionary from the .aux file where the keys are integers corresponding to the block number
+        and the dictionary entries for these keys are a list of all the half-turn areas included in that block.
+        :return: Dictionary with block numbers as keys and lists of half-turn areas as values
+        """
+        aux_data = self.aux_data
+
+        half_turn_areas = {}
+        info_block = {}
+        coils = aux_data.geometries.coil.coils
+        for coil_nr, coil_data in coils.items():
+            poles = coil_data.poles
+            for pole_nr, pole_data in poles.items():
+                layers = pole_data.layers
+                for layer_nr, layer_data in layers.items():
+                    windings = layer_data.windings
+                    for winding_nr, winding_data in windings.items():
+                        blocks = winding_data.blocks
+                        for block_nr, block_data in blocks.items():
+                            half_turns = block_data.half_turns.areas
+                            info_block[block_nr] = [int(area) for area in half_turns.keys()]
+                            half_turn_areas[int(block_nr)] = [int(area) for area in half_turns.keys()]
+
+        self.aux["half_turns"]["ht"] = half_turn_areas
+        self.aux["half_turns"]["block"] = info_block
+        pass
+
+    def extract_specific_TSA_lines(self):
+        """
+        Extract a dictionary from the thermal .aux file, collects the outer lines of the half-turns and wedges used for the TSA collar
+        """
+        aux_data = self.aux_data
+        pg = aux_data.domains.physical_groups
+        max_layer = len([k for k in self.aux_data.geometries.coil.coils[1].poles[1].layers.keys()])  # todo : more elegant way ? @emma
+        tags = []
+        for block in pg.blocks.values():
+            for ht in block.half_turns.values():
+                if ht.group[-1] == str(max_layer):  # r1_a2 or r2_a2
+                    tags.append(ht.lines['o'])
+        self.aux["tsa_collar"]['ht_lines'] = tags
+
+        tags = []
+        for wedge in pg.wedges.values():
+            if wedge.group[-1] == str(max_layer):  # r1_a2 or r2_a2
+                tags.append(wedge.lines['o'])
+        self.aux["tsa_collar"]['wedge_lines'] = tags
+        pass

fiqus/mains/MainConductorAC_CC.py

@@ -0,0 +1,148 @@
+
+"""MainConductorAC_CC.py:"""
+
+import os
+import sys
+
+from fiqus.geom_generators.GeometryConductorAC_CC import Generate_geometry
+from fiqus.mesh_generators.MeshConductorAC_CC import Mesh
+from fiqus.getdp_runners.RunGetdpConductorAC_CC import Solve
+from fiqus.post_processors.PostProcessAC_CC import Post_Process
+
+if len(sys.argv) == 3:
+    sys.path.insert(0, os.path.join(os.getcwd(), 'steam-fiqus-dev'))
+from fiqus.data.DataFiQuS import FDM
+
+class MainConductorAC_CC:
+    def __init__(self, fdm, inputs_folder_path='', verbose=True):
+        """
+        Main class for working with simulations for CAC_CC type magnets
+        :param fdm: FiQuS data model
+        :type fdm: FDM
+        :param inputs_folder_path: full path to folder with input files, i.e. conductor and STEP files
+        :type inputs_folder_path: str
+        :param verbose: if True, more info is printed in the console
+        :type verbose: bool
+        :return: nothing, only saves files on disk
+        :rtype: none
+        """
+        self.verbose = verbose
+        self.fdm = fdm
+        self.inputs_folder_path = inputs_folder_path
+        self.GetDP_path = None
+        self.geom_folder = None
+        self.mesh_folder = None
+        self.solution_folder = None
+        self.model_file = None
+        self.model_folder = None
+
+    def generate_geometry(self, gui=False):
+        """
+        Main method for loading the geometry of CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: nothing, only saves files on disk
+        :rtype: none
+        """
+        os.chdir(self.geom_folder)
+        gg = Generate_geometry(fdm=self.fdm, inputs_folder_path=self.inputs_folder_path, verbose=self.verbose)
+        gg.generate_HTS_layer()        
+        gg.generate_silver_top_layer()              
+        gg.generate_substrate_layer()        
+        gg.generate_copper_top_layer()
+        gg.generate_silver_bottom_layer()        
+        gg.generate_copper_bottom_layer()
+        gg.generate_copper_left_layer()
+        gg.generate_copper_right_layer()        
+        gg.generate_air_region()
+        gg.finalize_and_write()
+
+    def load_geometry(self, gui=False):
+        """
+        Main method for loading the geometry of CAC_CC models
+        """
+        os.chdir(self.geom_folder)
+        gg = Generate_geometry(fdm=self.fdm, inputs_folder_path=self.inputs_folder_path, verbose=self.verbose)
+        self.geometry = gg
+        gg.load_geometry(gui=gui)
+
+    def pre_process(self, gui=False):
+        """
+        Main method for preprocessing of CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: nothing, only saves files on disk
+        :rtype: none
+        """
+        os.chdir(self.geom_folder)
+
+
+    def mesh(self, gui=False):
+        """
+        Main method for building the mesh of CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: dictionary with mesh quality stats
+        :rtype: dict
+        """
+        os.chdir(self.mesh_folder)
+        m = Mesh(self.fdm)
+        m.generate_mesh(self.geom_folder)
+        return {"gamma": 0}
+
+
+    def load_mesh(self, gui=False):
+        """
+        Main method for loading the mesh of CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: Nothing, only saves files on disk
+        :rtype: none
+        """
+        os.chdir(self.mesh_folder)
+
+    def solve_and_postprocess_getdp(self, gui: bool = False):
+        """
+        Assembles the .pro-file from the template, then runs the simulation and the post-processing steps using GetDP.
+        """
+        os.chdir(self.solution_folder)
+
+        s = Solve(self.fdm, self.GetDP_path, self.geom_folder, self.mesh_folder, self.verbose)
+        s.read_excitation(inputs_folder_path=self.inputs_folder_path)
+        s.assemble_pro()
+        s.run_getdp(solve = True, postOperation = True, gui = gui)
+    
+    def post_process_getdp(self, gui: bool = False):
+        """ 
+        Runs the post-processing steps trough GetDP.
+        """
+        os.chdir(self.solution_folder)
+
+        s = Solve(self.fdm, self.GetDP_path, self.geom_folder, self.mesh_folder, self.verbose)
+        s.read_excitation(inputs_folder_path=self.inputs_folder_path)
+        s.assemble_pro()
+        s.run_getdp(solve = False, postOperation = True, gui = gui)
+
+    def post_process_python(self, gui=False):
+        """
+        Main method for postprocessing using python (without solving) of CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: Nothing, only saves files on disk
+        :rtype: none
+        """
+        os.chdir(self.solution_folder)
+        p=Post_Process(self.fdm, verbose=self.verbose)
+        p.cleanup()
+        return {'overall_error': 0}
+
+    def plot_python(self, gui=False):
+        """
+        Main method for making python plots related to CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: Nothing, only saves files on disk
+        :rtype: none
+        """
+        os.chdir(self.solution_folder)
+