How to initialize PYFMI models in parallel?

Question

I am using pyfmi to do simulations with EnergyPlus. I recognized that initializing the individual EnergyPlus models takes quite some time. Therefore, I hope to find a way to initialize the models in parallel. I tried the python library multiprocessing with no success. If it matters, I am on Ubuntu 16.10 and use Python 3.6. Here is what I want to get done in serial:

fmus        = {}
for id in id_list:
    chdir(fmu_path+str(id))
    fmus[id]  = load_fmu('f_' + str(id)+'.fmu',fmu_path+str(id))
    fmus[id].initialize(start_time,final_time)

The result is a dictionary with ids as key and the models as value: {id1:FMUModelCS1,id2:FMUModelCS1}

The purpose is to call later the models by their key and do simulations.

Here is my attempt with multiprocessing:

def ep_intialization(id,start_time,final_time):
    chdir(fmu_path+str(id))
    model  = load_fmu('f_' + str(id)+'.fmu',fmu_path+str(id))
    model.initialize(start_time,final_time)
    return {id:model}

data         = ((id,start_time,final_time) for id in id_list)
if __name__ == '__main__':
    pool         = Pool(processes=cpus)
    pool.starmap(ep_intialization, data)
    pool.close() 
    pool.join() 

I can see the processes of the models in my system monitor but then the script raise an error because the models are not pickable:

MaybeEncodingError: Error sending result: '[{id2: <pyfmi.fmi.FMUModelCS1 object at 0x561eaf851188>}]'. Reason: 'TypeError('self._fmu,self.callBackFunctions,self.callbacks,self.context,self.variable_list cannot be converted to a Python object for pickling',)'

But I cannot imagine that there is no way to initialize the models in parallel. Other frameworks/libraries than threading/multiprocessing are also welcome.

I saw this answer but it seems that it focuses on the simulations after initialization.

Answer 1

The answer below the one you refer to seems to explain what the problem with multiprocessing and FMU instantiation is.

I tried with pathos suggested in this answer, but run into the same problem:

from pyfmi import load_fmu
from multiprocessing import Pool
from os import chdir
from pathos.multiprocessing import Pool

def ep_intialization(id):
    chdir('folder' + str(id))
    model  = load_fmu('BouncingBall.fmu')
    model.initialize(0,10)
    return {id:model}

id_list = [1,2]
cpus = 2    
data = ((id) for id in id_list)

pool = Pool(cpus)
out = pool.map(ep_intialization, data)

This gives:

MaybeEncodingError: Error sending result: '[{1: <pyfmi.fmi.FMUModelME2 object at 0x564e0c529290>}]'. Reason: 'TypeError('self._context,self._fmu,self.callBackFunctions,self.callbacks cannot be converted to a Python object for pickling',)'

Here is another idea:

I suppose the instantiation is slow because EnergyPlus links plenty of libraries into the FMU. If the components you are modelling all have the same interface (input, output, parameters), you can probably use a single FMU with an additional parameter that switches between the models.

This would be much more efficient: You would only have to instantiate a single FMU and could call it in parallel with different parameters and inputs.

Example:

I have never worked with EnergyPlus, but maybe the following example will illustrate the approach:

You have three variants of a building and you are merely interested in the total heat flux over the entire surface area of buildings as a function of - "weather" (whatever that means - maybe a lot of variables).

Put all three buildings into a single EnergyPlus model and build an if or case clause around them (pseudo code):

if (id_building == 1) {
    [model the building one]
elseif (if_building == 2) {
    [model the building two]
[...]

Define the "weather" or whatever you need as an input variable for the FMU and define id_building also as a parameter. Define the overall heat flux as output variable.

This would allow you to choose the building before starting the simulation.

The two requirements are:

1. EnergyPlus Syntax allows if or case structures.
2. All your models work with the same interface (in our example we have weather as in and a flux as out variables)

There is a dirty workaround for the second requirement: Just define all the variables all your models need and only use what you need in the respective if block.