Function getModelicaSetup

src/workflow/RunModelica.cpp:261–338

  }

  ModelicaSetup getModelicaSetup(const WorkflowJSON& workflowJSON, const boost::optional<openstudio::path>& finalSeedModelicaFile) {
    ModelicaSetup setup;

    auto addSearchPath = [&setup](const openstudio::path& dir) {
      if (dir.empty()) {
        return;
      }
      setup.searchPaths.push_back(dir);
    };

    auto addFileToLoad = [&setup, &addSearchPath](const openstudio::path& file) {
      if (file.empty()) {
        return;
      }
      const auto absoluteFile = boost::filesystem::absolute(file);
      setup.files.push_back(absoluteFile);
      addSearchPath(absoluteFile.parent_path());
    };

    const auto handleDirectory = [&addFileToLoad, &addSearchPath](const openstudio::path& dir) {
      const auto absoluteDir = boost::filesystem::absolute(dir);
      addSearchPath(absoluteDir);
      const auto packageMo = absoluteDir / toPath("package.mo");
      if (openstudio::filesystem::exists(packageMo)) {
        addFileToLoad(packageMo);
      }
    };

    for (const auto& envPath : getModelicaPathEnvEntries()) {
      addSearchPath(envPath);
    }

    for (const auto& packageSpec : workflowJSON.modelicaPackages()) {
      openstudio::path resolved;
      if (packageSpec.is_absolute()) {
        resolved = packageSpec;
      } else {
        if (auto located = workflowJSON.findFile(packageSpec)) {
          resolved = *located;
        }
      }

      if (resolved.empty()) {
        throw std::runtime_error(fmt::format("Modelica package '{}' could not be resolved", toString(packageSpec)));
      }

      if (!openstudio::filesystem::exists(resolved)) {
        throw std::runtime_error(fmt::format("Modelica package '{}' does not exist at '{}'", toString(packageSpec), resolved.generic_string()));
      }

      if (openstudio::filesystem::is_directory(resolved)) {
        handleDirectory(resolved);
      } else {
        addFileToLoad(resolved);
      }
    }

    if (finalSeedModelicaFile) {