Rewrite code to use the design pattern "Factory"

[SteffanWullems]

Recently i started looking at the code. I saw a lot of conditions and functions directly related to an calculation. To make de code more maintainable and easier to add functions i think the design pattern "Factory" would be a good option.
The way i see it is that we have a common interface(python: protocol) like (sample)

## The Interface
class  PowerGridModel(Protocol) :
   ## The Create Class/Struct function for the Factory class  
   def __init__(input_data: Dict[str, np.ndarray], system_frequency: float) ->PowerGridModel
   ## The function for calculating
   def calculate() -> PGMResults

## Factory class
class FactoryPowerGridModel:
    models: Dict
    ## Register models
    def register_model(calutation_name:  string,  creator : PowerGridModel):
       ## add name as key to an array with creator as the model
       pass
    ## Create Model
    def create_model(calutation_name:  string, input_data: Dict[str, np.ndarray], system_frequency: float) -> PowerGridModel
       ## Remember to throw Model not found if not registerd.
       ## Return the result of creating the object with its params
       pass

## Calculation: Sample
class SamplePowerGridModel:
    CALCULATION_NAME="Sample"
    ## The Create Class/Struct function for the Model  
   def __init__(input_data: Dict[str, np.ndarray], system_frequency: float) ->PowerGridModel :
      pass
   ## The function for calculating
   def calculate() -> PGMResults:
      pass

fpgm = FactoryPowerGridModel()
fpgm.register_model(SamplePowerGridModel.CALCULATION_NAME, SamplePowerGridModel())

### Some code giving input_data and frequency

sample_pgm = fpgm.create_model(SamplePowerGridModel.CALCULATION_NAME, input_data, frequency)
result = sample_pgm.calculate()

Sorry its python and if there are errors in this sample. It's been a while i done this in C++ but it is the same principle.
This way you will repeat the same code if you use python. In C++ i would use a base class with 2 pure virtual functions so small common code blocks can be reused or not skipped.

This is my opener and it needs more work. Please let me know your opinions and feedback.

[mgovers]

We are slowly moving towards a functional programming design rather than an object oriented one. In that model, the core engine becomes no more than a runner and all relevant data is stored in individual data structures. Independently, the actual functions can be provided to the engine.

This factory model fits that design and would be the last step in the refactoring.