model_function2

Two models, A & B, that send/receive scalars and arrays. Model A iterates over received array input from a table, calling the indicated model function for each array element, and then sends all of outputs from the iteration as an array to model B. Model B receives input arrays from model A and sends it’s output to a file. Both models are functions that are automatically wrapped by yggdrasil with the appropriate interface calls. This example demonstrates the use of the function model YAML parameter and auto-wrapping as well as iteration over input/output arrays via the iter_function_over model YAML paramter.

C Version

Model Code:

#include <stdio.h>

int model_function(float x, float* y) {
  y[0] = x + 1.0;
  printf("Model A: %f -> %f\n", x, *y);
  return 0;

}

#include <stdio.h>

int model_function(float *x, uint64_t length_x,
		   float **y, uint64_t *length_y) {
  uint64_t i;
  length_y[0] = length_x;
  y[0] = (float*)malloc(length_x * sizeof(float));
  for (i = 0; i < length_x; i++)
    (*y)[i] = x[i] + 2.0;
  printf("Model B: [");
  for (i = 0; i < length_x; i++)
    printf("%f ", x[i]);
  printf("] -> [");
  for (i = 0; i < length_x; i++)
    printf("%f ", (*y)[i]);
  printf("]\n");
  return 0;

}

Model YAML:

models:
  - name: c_modelA
    language: c
    args: ./src/model_function_modelA.c
    function: model_function
    iter_function_over: [x, y]
    inputs:
      name: x
      default_file:
        name: ./Input/input.txt
        filetype: table
        as_array: true
    outputs: y
  - name: c_modelB
    language: c
    args: ./src/model_function_modelB.c
    function: model_function
    inputs: x
    outputs:
      name: y
      default_file:
        name: ./output.txt
        filetype: table
        as_array: true
        field_names: [mass]
        field_units: [g]

connections:
  - input: c_modelA:y  # Connection between model A output & model B input
    output: c_modelB:x

C++ Version

Model Code:

#include <iostream>

int model_function(float x, float& y) {
  y = x + 1.0;
  std::cout << "Model A: " << x << "->" << y << std::endl;
  return 0;
}

#include <iostream>
#include <vector>

int model_function(std::vector<float> x,
		   std::vector<float> &y) {
  std::vector<float>::iterator it;
  for (it = x.begin(); it != x.end(); it++)
    y.push_back(*it + 2.0);
  std::cout << "Model B: [";
  for (it = x.begin(); it != x.end(); it++)
    std::cout << *it << " ";
  std::cout << "] -> [";
  for (it = y.begin(); it != y.end(); it++)
    std::cout << *it << " ";
  std::cout << "]" << std::endl;
  return 0;

}

Model YAML:

models:
  - name: cpp_modelA
    language: c++
    args: ./src/model_function_modelA.cpp
    function: model_function
    iter_function_over: [x, y]
    inputs:
      name: x
      default_file:
        name: ./Input/input.txt
        filetype: table
        as_array: true
    outputs: y
  - name: cpp_modelB
    language: c++
    args: ./src/model_function_modelB.cpp
    function: model_function
    inputs: x
    outputs:
      name: y
      default_file:
        name: ./output.txt
        filetype: table
        as_array: true
        field_names: [mass]
        field_units: [g]

connections:
  - input: cpp_modelA:y  # Connection between model A output & model B input
    output: cpp_modelB:x

Fortran Version

Model Code:

function model_function(x) result(y)
  real(kind=4), intent(in) :: x
  real(kind=4) :: y
  y = x + 1.0
  write(*, '("Model A: ",F10.5," -> ",F10.5)') x, y
end function model_function

function model_function(x) result(y)
  real(kind=4), dimension(:), intent(in) :: x
  real(kind=4), dimension(:), allocatable :: y
  integer :: i
  allocate(y(size(x, 1)))
  do i = 1, size(x, 1)
     y(i) = x(i) + 2.0
  end do
  write(*, '("Model B: [")', advance="no")
  do i = 1, size(x, 1)
     write(*, '(F10.5," ")', advance="no") x(i)
  end do
  write(*, '("] -> [")', advance="no")
  do i = 1, size(y, 1)
     write(*, '(F10.5," ")', advance="no") y(i)
  end do
  write(*, '("]")')
end function model_function

Model YAML:

models:
  - name: fortran_modelA
    language: fortran
    args: ./src/model_function_modelA.f90
    function: model_function
    iter_function_over: [x, y]
    inputs:
      name: x
      default_file:
        name: ./Input/input.txt
        filetype: table
        as_array: true
    outputs: y
  - name: fortran_modelB
    language: fortran
    args: ./src/model_function_modelB.f90
    function: model_function
    inputs: x
    outputs:
      name: y
      default_file:
        name: ./output.txt
        filetype: table
        as_array: true
        field_names: [mass]
        field_units: [g]

connections:
  - input: fortran_modelA:y  # Connection between model A output & model B input
    output: fortran_modelB:x

Julia Version

Model Code:

using Unitful
using Printf

function model_function(x)
  y = x .+ 1.0u"g"
  @printf("Model A: %s -> %s\n", x, y)
  return y
end

using Unitful
using Printf

function model_function(x)
  y = x .+ 2.0u"g"
  @printf("Model B: %s -> %s\n", x, y)
  return y
end

Model YAML:

models:
  - name: julia_modelA
    language: julia
    args: ./src/model_function_modelA.jl
    function: model_function
    iter_function_over: [x, y]
    inputs:
      name: x
      default_file:
        name: ./Input/input.txt
        filetype: table
        as_array: true
    outputs: y
  - name: julia_modelB
    language: julia
    args: ./src/model_function_modelB.jl
    function: model_function
    inputs: x
    outputs:
      name: y
      default_file:
        name: ./output.txt
        filetype: table
        as_array: true
        field_names: [mass]

connections:
  - input: julia_modelA:y  # Connection between model A output & model B input
    output: julia_modelB:x

Matlab Version

Model Code:

function y = model_function_modelA(x)
  if isa(x, 'sym')
    y = x + 1.0 * str2symunit('g');
    fprintf('Model A: %f -> %f\n', separateUnits(simplify(x)), separateUnits(simplify(y)));
  else;
    y = x + 1.0;
    fprintf('Model A: %f -> %f\n', x, y);
  end;
end

function y = model_function_modelB(x)
  if isa(x, 'sym')
    y = x + 2.0 * str2symunit('g');
    fprintf('Model B: %f -> %f\n', separateUnits(simplify(x)), separateUnits(simplify(y)));
  else;
    y = x + 2.0;
    fprintf('Model B: %f -> %f\n', x, y);
  end;
end

Model YAML:

models:
  - name: matlab_modelA
    language: matlab
    args: ./src/model_function_modelA.m
    function: model_function_modelA
    iter_function_over: [x, y]
    inputs:
      name: x
      default_file:
        name: ./Input/input.txt
        filetype: table
        as_array: true
    outputs: y
  - name: matlab_modelB
    language: matlab
    args: ./src/model_function_modelB.m
    function: model_function_modelB
    inputs: x
    outputs:
      name: y
      default_file:
        name: ./output.txt
        filetype: table
        as_array: true
        field_names: [mass]
        field_units: [g]

connections:
  - input: matlab_modelA:y  # Connection between model A output & model B input
    output: matlab_modelB:x

Python Version

Model Code:

from yggdrasil import units


def model_function(x):
    y = x + units.add_units(1.0, 'g')
    print("Model A: %s -> %s" % (x, y))
    return y

from yggdrasil import units


def model_function(x):
    y = x + units.add_units(2.0, 'g')
    print("Model B: %s -> %s" % (x, y))
    return y

Model YAML:

models:
  - name: python_modelA
    language: python
    args: ./src/model_function_modelA.py
    function: model_function
    iter_function_over: [x, y]
    inputs:
      name: x
      default_file:
        name: ./Input/input.txt
        filetype: table
        as_array: true
    outputs: y
  - name: python_modelB
    language: python
    args: ./src/model_function_modelB.py
    function: model_function
    inputs: x
    outputs:
      name: y
      default_file:
        name: ./output.txt
        filetype: table
        as_array: true
        field_names: [mass]

connections:
  - input: python_modelA:y  # Connection between model A output & model B input
    output: python_modelB:x

R Version

Model Code:

model_function <- function(x) {
  y <- x + units::set_units(1.0, "g", mode="standard")
  print(sprintf("Model A: %f -> %f", x, y))
  return(y)
}

model_function <- function(x) {
  y <- x + units::set_units(2.0, "g", mode="standard")
  print(sprintf("Model B: %f -> %f", x, y))
  return(y)
}

Model YAML:

models:
  - name: r_modelA
    language: R
    args: ./src/model_function_modelA.R
    function: model_function
    iter_function_over: [x, y]
    inputs:
      name: x
      default_file:
        name: ./Input/input.txt
        filetype: table
        as_array: true
    outputs: y
  - name: r_modelB
    language: R
    args: ./src/model_function_modelB.R
    function: model_function
    inputs: x
    outputs:
      name: y
      default_file:
        name: ./output.txt
        filetype: table
        as_array: true
        field_names: [mass]

connections:
  - input: r_modelA:y  # Connection between model A output & model B input
    output: r_modelB:x