when i build a FMU with third dependencies like "torch" and begin to simulate in simulink.Something wrong.

[wangyue-cell]

Debug Logging enabled for block fmu_test/FMU

Log from FMU: [category:, status:fmi2Fatal] Fatal py exception encountered: [ctor] findClass
ModuleNotFoundError("No module named 'torch'")
i build FMU with (pythonfmu build -f mytest.py requirements.txt resources),there are numpy,torch,deepxde in the requirements.txt and some necessary file in the resources.
i deploy FMU with (pythonfmu deploy -f Resistor.fmu)
hope to get some advice.

[markaren]

Does it work outside simulink? If yes, simulink has it's own Python environment where torch is not installed.

[wangyue-cell]

the mytest.py does works in the pycharm.I have added firstly( import numpy),then(import deepxde,import torch) in the demoslave.py ,which you gaved.and the first one is ok,but the second one didn't work.ModuleNotFoundError("No module named 'torch'") and ModuleNotFoundError("No module named 'deepxde').But i verified the python environment in the matlab.
try
py.importlib.import_module('torch');
disp('PyTorch loaded successfully！');
catch e
disp(['erorr: ', e.message]);
end
PyTorch loaded successfully！
I noticed that you have a easy demo named mldemo,which used tensorflow.I try to make it come ture.but something wrong.

Debug Logging enabled for block fmu_test/FMU

Log from FMU: [category:, status:fmi2Fatal] Fatal py exception encountered: [doStep] PyObject_CallMethod
"'MLDemo' object has no attribute 'model'"
if the fmu file contains torch or deepxde need some special step?

[markaren]

I had never tested the mldemo myself, but got it to work. It requires running the notebook first (to generate the keras model). This model needs to packed into the FMU inside the resources folder.

Anyhow, can you test your model with say fmpy.gui?

[wangyue-cell]

i have tested it with fmpy.gui,

or would you need the fmu file?

[markaren]

Hmm, I've never seen it complain about fmi2GetBooleanStatus before. I had a glance at the source code, but I could not see in what context it would have been invoked.

If you are ok with sharing the FMU (the source code will be visible) that could help.

[wangyue-cell]

import sys
import os
import torch
import numpy as np
import concurrent.futures
import deepxde as dde
from pythonfmu import Fmi2Causality, Fmi2Variability, Fmi2Slave, Real,String

class FNN(torch.nn.Module):
def init(self, layer_sizes):
super(FNN, self).init()
self.linears = torch.nn.ModuleList()
for i in range(1, len(layer_sizes)):
self.linears.append(torch.nn.Linear(layer_sizes[i - 1], layer_sizes[i]))

def forward(self, x):
    for linear in self.linears[:-1]:
        x = torch.tanh(linear(x))
    x = self.linears[-1](x)
    return x

class Resistor(Fmi2Slave):
description = "FMU for Magnetic Characteristics Calculation"

def __init__(self, **kwargs):
    super().__init__(**kwargs)
    # 初始化神经网络参数
    self.layer_sizes = [3] + [128] * 4 + [9]
    self.path = os.path.join(
        os.path.dirname(__file__),
        "datasave"
    )
    self.nn_files = [
        "w0_12000", "w6_12000", "w12_12000", "w18_12000", "w24_12000",
        "b6_12000", "b12_12000", "b18_12000", "b24_12000"
    ]
    self.nn_list = [os.path.join(self.path, f) for f in self.nn_files]
    self.Gain_dict = {
        os.path.join(self.path, f): gain for f, gain in zip(
            self.nn_files,
            [8, 2000, 400, 15000, 4000, 2000, 400, 15000, 4000]
        )
    }
    # 预加载模型
    self.nn_models = [
        self.load_nn(os.path.join(self.path, f))
        for f in self.nn_files
    ]

    # 初始化变量
    self.id = 0.0
    self.iq = 0.0
    self.i0 = 0.0
    self.DATA_DC=0.0


    # 注册FMU变量
    self.register_variable(Real("id", causality=Fmi2Causality.input))
    self.register_variable(Real("iq", causality=Fmi2Causality.input))
    self.register_variable(Real("i0", causality=Fmi2Causality.input))
    # 注册字符串输出变量
    self.register_variable(Real("DATA_DC", causality=Fmi2Causality.output,
                                ))


def load_nn(self, nn_path):
    """加载神经网络模型"""
    try:
        model = FNN(self.layer_sizes)
        state_dict = torch.load(nn_path)
        model.load_state_dict(state_dict['model_state_dict'])
        return model
    except Exception as e:
        raise RuntimeError(f"Failed to load model from {nn_path}: {str(e)}")

def trans(self, model, inputs):
    """前向传播计算磁链和电感矩阵"""
    inputs.requires_grad_(True)
    u = model(inputs).view(-1, 3, 3)
    I_mat = inputs.unsqueeze(1)
    w = torch.matmul(torch.matmul(I_mat, u), I_mat.transpose(1, 2)).squeeze()

    # 计算磁链
    flux = torch.autograd.grad(
        w, inputs,
        grad_outputs=torch.ones_like(w),
        create_graph=True,
        retain_graph=True
    )[0]

    # 计算电感矩阵分量
    L_components = []
    for i in range(3):
        grad = torch.autograd.grad(
            flux[:, i], inputs,
            grad_outputs=torch.ones_like(flux[:, i]),
            create_graph=True,
            retain_graph=True
        )[0]
        L_components.append(grad)

    L_matrix = torch.stack(L_components, dim=1)
    # 展平为 (batch_size, 9)
    L_matrix_flat = L_matrix.view(-1, 9)  # 或 L_matrix.flatten(start_dim=1)
    return L_matrix_flat, flux, w

def single_calculate(self,iset, Flux_Gain, nn):

    la, a, wa = self.trans(nn, iset)
    la = la / 200 / Flux_Gain
    a = a / Flux_Gain
    wa = wa * 200 / Flux_Gain

    ## dLdd 对id，iq，i0求微分
    plddidqa = dde.grad.jacobian(la, iset, 0) / 200 / Flux_Gain
    plddida = plddidqa[0, 0]
    plddiqa = plddidqa[0, 1]
    plddi0a = plddidqa[0, 2]

    # dLdq 对id，iq，i0求微分
    pldqidqa = dde.grad.jacobian(la, iset, 1) / 200 / Flux_Gain
    pldqida = pldqidqa[0, 0]
    pldqiqa = pldqidqa[0, 1]
    pldqi0a = pldqidqa[0, 2]

    # dLd0 对id，iq，i0求微分
    pld0idqa = dde.grad.jacobian(la, iset, 2) / 200 / Flux_Gain
    pld0ida = pld0idqa[0, 0]
    pld0iqa = pld0idqa[0, 1]
    pld0i0a = pld0idqa[0, 2]

    ## dLqd 对id，iq，i0求微分
    plqdidqa = dde.grad.jacobian(la, iset, 3) / 200 / Flux_Gain
    plqdida = plqdidqa[0, 0]
    plqdiqa = plqdidqa[0, 1]
    plqdi0a = plqdidqa[0, 2]

    ## dLqq 对id，iq，i0求微分
    plqqidqa = dde.grad.jacobian(la, iset, 4) / 200 / Flux_Gain
    plqqida = plqqidqa[0, 0]
    plqqiqa = plqqidqa[0, 1]
    plqqi0a = plqqidqa[0, 2]

    ## dLq0 对id，iq，i0求微分
    plq0idqa = dde.grad.jacobian(la, iset, 5) / 200 / Flux_Gain
    plq0ida = plq0idqa[0, 0]
    plq0iqa = plq0idqa[0, 1]
    plq0i0a = plq0idqa[0, 2]

    ## dL0d 对id，iq，i0求微分
    pl0didqa = dde.grad.jacobian(la, iset, 6) / 200 / Flux_Gain
    pl0dida = pl0didqa[0, 0]
    pl0diqa = pl0didqa[0, 1]
    pl0di0a = pl0didqa[0, 2]

    ## dL0q 对id，iq，i0求微分
    pl0qidqa = dde.grad.jacobian(la, iset, 7) / 200 / Flux_Gain
    pl0qida = pl0qidqa[0, 0]
    pl0qiqa = pl0qidqa[0, 1]
    pl0qi0a = pl0qidqa[0, 2]

    ## dL00 对id，iq，i0求微分
    pl00idqa = dde.grad.jacobian(la, iset, 8) / 200 / Flux_Gain
    pl00ida = pl00idqa[0, 0]
    pl00iqa = pl00idqa[0, 1]
    pl00i0a = pl00idqa[0, 2]

    la = la.detach().cpu().numpy()
    a = a.detach().cpu().numpy()
    wa = wa.detach().cpu().numpy()

    plddida = plddida.detach().cpu().numpy()
    plddiqa = plddiqa.detach().cpu().numpy()
    plddi0a = plddi0a.detach().cpu().numpy()

    pldqida = pldqida.detach().cpu().numpy()
    pldqiqa = pldqiqa.detach().cpu().numpy()
    pldqi0a = pldqi0a.detach().cpu().numpy()

    pld0ida = pld0ida.detach().cpu().numpy()
    pld0iqa = pld0iqa.detach().cpu().numpy()
    pld0i0a = pld0i0a.detach().cpu().numpy()

    plqdida = plqdida.detach().cpu().numpy()
    plqdiqa = plqdiqa.detach().cpu().numpy()
    plqdi0a = plqdi0a.detach().cpu().numpy()

    plqqida = plqqida.detach().cpu().numpy()
    plqqiqa = plqqiqa.detach().cpu().numpy()
    plqqi0a = plqqi0a.detach().cpu().numpy()

    plq0ida = plq0ida.detach().cpu().numpy()
    plq0iqa = plq0iqa.detach().cpu().numpy()
    plq0i0a = plq0i0a.detach().cpu().numpy()

    pl0dida = pl0dida.detach().cpu().numpy()
    pl0diqa = pl0diqa.detach().cpu().numpy()
    pl0di0a = pl0di0a.detach().cpu().numpy()

    pl0qida = pl0qida.detach().cpu().numpy()
    pl0qiqa = pl0qiqa.detach().cpu().numpy()
    pl0qi0a = pl0qi0a.detach().cpu().numpy()

    pl00ida = pl00ida.detach().cpu().numpy()
    pl00iqa = pl00iqa.detach().cpu().numpy()
    pl00i0a = pl00i0a.detach().cpu().numpy()

    torch.cuda.empty_cache()  # ??? CUDA ???
    # del plddidqa, plddidqa

    return la, a, wa, plddida, plddiqa, plddi0a, pldqida, pldqiqa, pldqi0a, pld0ida, pld0iqa, pld0i0a, plqdida, plqdiqa, plqdi0a, plqqida, plqqiqa, plqqi0a, plq0ida, plq0iqa, plq0i0a, pl0dida, pl0diqa, pl0di0a, pl0qida, pl0qiqa, pl0qi0a, pl00ida, pl00iqa, pl00i0a

def postprocessing(self,id_list, iq_list, i0_list, nn_net):

    id = id_list  # ????? i ?????
    iq = iq_list  # ????? i ?????
    i0 = i0_list  # ????? i ?????
    # idq0 = np.array([id, iq, i0])

    iset = torch.tensor([[id / 200, iq / 200, i0 / 200]], dtype=torch.float)
    iset.requires_grad = True
    A = B = np.empty((3, 0))
    LA = LB = np.empty((9, 0))
    WA = WB = np.array([], dtype=float)
    # Ld
    pLddidA = pLddidB = np.array([], dtype=float)
    pLddiqA = pLddiqB = np.array([], dtype=float)
    pLddi0A = pLddi0B = np.array([], dtype=float)

    pLdqidA = pLdqidB = np.array([], dtype=float)
    pLdqiqA = pLdqiqB = np.array([], dtype=float)
    pLdqi0A = pLdqi0B = np.array([], dtype=float)

    pLd0idA = pLd0idB = np.array([], dtype=float)
    pLd0iqA = pLd0iqB = np.array([], dtype=float)
    pLd0i0A = pLd0i0B = np.array([], dtype=float)
    # Lq
    pLqdidA = pLqdidB = np.array([], dtype=float)
    pLqdiqA = pLqdiqB = np.array([], dtype=float)
    pLqdi0A = pLqdi0B = np.array([], dtype=float)

    pLqqidA = pLqqidB = np.array([], dtype=float)
    pLqqiqA = pLqqiqB = np.array([], dtype=float)
    pLqqi0A = pLqqi0B = np.array([], dtype=float)

    pLq0idA = pLq0idB = np.array([], dtype=float)
    pLq0iqA = pLq0iqB = np.array([], dtype=float)
    pLq0i0A = pLq0i0B = np.array([], dtype=float)
    # L0
    pL0didA = pL0didB = np.array([], dtype=float)
    pL0diqA = pL0diqB = np.array([], dtype=float)
    pL0di0A = pL0di0B = np.array([], dtype=float)

    pL0qidA = pL0qidB = np.array([], dtype=float)
    pL0qiqA = pL0qiqB = np.array([], dtype=float)
    pL0qi0A = pL0qi0B = np.array([], dtype=float)

    pL00idA = pL00idB = np.array([], dtype=float)
    pL00iqA = pL00iqB = np.array([], dtype=float)
    pL00i0A = pL00i0B = np.array([], dtype=float)

    inputdata = [(iset, self.Gain_dict[nn_name], nn) for nn_name, nn in zip(self.nn_list, nn_net)]

    with concurrent.futures.ThreadPoolExecutor() as executor:
        results = list(executor.map(lambda x: self.single_calculate(*x), inputdata))

    for i in range(len(self.nn_list)):

        # la, a, wa = results[i]
        la, a, wa, plddida, plddiqa, plddi0a, pldqida, pldqiqa, pldqi0a, pld0ida, pld0iqa, pld0i0a, plqdida, plqdiqa, plqdi0a, plqqida, plqqiqa, plqqi0a, plq0ida, plq0iqa, plq0i0a, pl0dida, pl0diqa, pl0di0a, pl0qida, pl0qiqa, pl0qi0a, pl00ida, pl00iqa, pl00i0a = \
        results[i]

        if i == 0:

            # np.hstack((a, b))
            LDC = la.reshape(9, 1)
            DC = a.reshape(3, 1)
            WDC = wa



        elif i <= 4:

            LA = np.hstack((LA, la.reshape(9, 1)))
            A = np.hstack((A, a.reshape(3, 1)))
            WA = np.hstack((WA, wa))



    return DC, A, B, WDC, WA, WB, LDC, LA, LB

def do_step(self, current_time, step_size):
    """FMU仿真步进"""

    # 执行计算
    results = self.postprocessing(self.id, self.iq, self.i0,self.nn_models)
    # 序列化矩阵为JSON字符串(此处应修改）
    self.DATA_DC = results[0][0]

if name == "main":
resistor = Resistor(instance_name="resistor_instance")
resistor.id = 100 # 设置输入值
resistor.iq = 50
resistor.i0 = 0
resistor.do_step(0, 1e-3) # 触发计算
print(resistor.DATA_DC) # 输出更新后的值'''

[markaren]

This model seems to depend on files I don't have access to, so I can't run the model. But I wonder if this might be the issue you face with the fmpy run. Use self.resources to get the location of the resources folder inside the FMU and be sure your extra files are located within the resources folder in the FMU.

[wangyue-cell]

maybe you can give me a email and i send the whole FMU to you .

[markaren]

btw, the reason an error is thrown on fmi2GetBooleanStatus is that do_step does not return True.. This causes fmpy to try to call an unimplemented method in pythonfmu.
I just got the same issue on a new model and was a bit puzzled..

[markaren]

Closing as error is caused by returning False. #244 added fmi2GetBooleanStatus , so this should not cause issues anymore.