formatted_io3 Example — cis_interface 0.3.0 documentation

# formatted_io3 Example

## Python Version

Model Code:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    # Import classes for input/output channels
    from cis_interface.interface.CisInterface import (
        CisAsciiArrayInput, CisAsciiArrayOutput)

    # Initialize input/output channels
    in_channel = CisAsciiArrayInput('inputA')
    out_channel = CisAsciiArrayOutput('outputA', '%6s\t%d\t%f\n')

    # Loop until there is no longer input or the queues are closed
    while True:

        # Receive input from input channel
        # If there is an error, the flag will be False
        flag, arr = in_channel.recv()
        if not flag:
            print("Model A: No more input.")
            break

        # Print received message
        print('Model A: (%d rows)' % len(arr))
        for i in range(len(arr)):
            print('   %s, %d, %f' % tuple(arr[i]))

        # Send output to output channel
        # If there is an error, the flag will be False
        flag = out_channel.send(arr)
        if not flag:
            print("Model A: Error sending output.")
            break

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    # Import classes for input/output channels
    from cis_interface.interface.CisInterface import (
        CisAsciiArrayInput, CisAsciiArrayOutput)

    # Initialize input/output channels
    in_channel = CisAsciiArrayInput('inputB')
    out_channel = CisAsciiArrayOutput('outputB', '%6s\t%d\t%f\n')

    # Loop until there is no longer input or the queues are closed
    while True:

        # Receive input from input channel
        # If there is an error, the flag will be False
        flag, arr = in_channel.recv()
        if not flag:
            print("Model B: No more input.")
            break

        # Print received message
        print('Model B: (%d rows)' % len(arr))
        for i in range(len(arr)):
            print('   %s, %d, %f' % tuple(arr[i]))

        # Send output to output channel
        # If there is an error, the flag will be False
        flag = out_channel.send(arr)
        if not flag:
            print("Model B: Error sending output.")
            break

Model YAML:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    models:
      - name: python_modelA
        language: python
        args: ./src/formatted_io3_modelA.py
        inputs: inputA
        outputs:
          name: outputA
          field_names: name,count,size

      - name: python_modelB
        language: python
        args: ./src/formatted_io3_modelB.py
        inputs: inputB
        outputs:
          name: outputB
          field_names: name,count,size

    connections:
      - input: outputA  # Connection between model A output & model B input
        output: inputB
      - input: ./Input/input.txt  # Connection between file and model A input
        output: inputA
        as_array: True
        filetype: table
      - input: outputB  # Connection between model B output and file
        output: ./output.txt
        as_array: True
        filetype: table

## C++ Version

Model Code:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    #include <iostream>
    // Include methods for input/output channels
    #include "CisInterface.hpp"

    int main(int argc, char *argv[]) {
      // Initialize input/output channels
      CisAsciiArrayInput in_channel("inputA");
      CisAsciiArrayOutput out_channel("outputA", "%6s\t%d\t%f\n");

      // Declare resulting variables and create buffer for received message
      int flag = 1;
      char *name = NULL;
      int *count = NULL;
      double *size = NULL;

      // Loop until there is no longer input or the queues are closed
      while (flag >= 0) {

        // Receive input from input channel
        // If there is an error, the flag will be negative
        // Otherwise, it is the size of the received message
        flag = in_channel.recv(3, &name, &count, &size);
        if (flag < 0) {
          std::cout << "Model A: No more input." << std::endl;
          break;
        }

        // Print received message
        int nrows = flag;
        printf("Model A: (%d rows)\n", nrows);
        int i;
        for (i = 0; i < nrows; i++)
          printf("   %.6s, %d, %f\n", &name[6*i], count[i], size[i]);

        // Send output to output channel
        // If there is an error, the flag will be negative
        flag = out_channel.send(3, nrows, name, count, size);
        if (flag < 0) {
          std::cout << "Model A: Error sending output." << std::endl;
          break;
        }

      }

      // Free dynamically allocated columns
      if (name) free(name);
      if (count) free(count);
      if (size) free(size);

      return 0;
    }

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    #include <iostream>
    // Include methods for input/output channels
    #include "CisInterface.hpp"

    #define MYBUFSIZ 1000

    int main(int argc, char *argv[]) {
      // Initialize input/output channels
      CisAsciiArrayInput in_channel("inputB");
      CisAsciiArrayOutput out_channel("outputB", "%6s\t%d\t%f\n");

      // Declare resulting variables and create buffer for received message
      int flag = 1;
      char *name = NULL;
      int *count = NULL;
      double *size = NULL;

      // Loop until there is no longer input or the queues are closed
      while (flag >= 0) {

        // Receive input from input channel
        // If there is an error, the flag will be negative
        // Otherwise, it is the size of the received message
        flag = in_channel.recv(3, &name, &count, &size);
        if (flag < 0) {
          std::cout << "Model B: No more input." << std::endl;
          break;
        }

        // Print received message
        int nrows = flag;
        printf("Model A: (%d rows)\n", nrows);
        int i;
        for (i = 0; i < nrows; i++)
          printf("   %.6s, %d, %f\n", &name[6*i], count[i], size[i]);

        // Send output to output channel
        // If there is an error, the flag will be negative
        flag = out_channel.send(3, nrows, name, count, size);
        if (flag < 0) {
          std::cout << "Model B: Error sending output." << std::endl;
          break;
        }

      }

      // Free dynamically allocated columns
      if (name) free(name);
      if (count) free(count);
      if (size) free(size);

      return 0;
    }

Model YAML:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    models:
      - name: cpp_modelA
        language: c++
        args: ./src/formatted_io3_modelA.cpp
        inputs: inputA
        outputs:
          name: outputA
          field_names: name,count,size

      - name: cpp_modelB
        language: c++
        args: ./src/formatted_io3_modelB.cpp
        inputs: inputB
        outputs:
          name: outputB
          field_names: name,count,size

    connections:
      - input: outputA  # Connection between model A output & model B input
        output: inputB
      - input: ./Input/input.txt  # Connection between file and model A input
        output: inputA
        as_array: True
        filetype: table
      - input: outputB  # Connection between model B output and file
        output: ./output.txt
        as_array: True
        filetype: table

## C Version

Model Code:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    #include <stdio.h>
    // Include methods for input/output channels
    #include "CisInterface.h"

    int main(int argc, char *argv[]) {
      // Initialize input/output channels
      cisAsciiArrayInput_t in_channel = cisAsciiArrayInput("inputA");
      cisAsciiArrayOutput_t out_channel = cisAsciiArrayOutput("outputA", "%6s\t%d\t%f\n");

      // Declare resulting variables and create buffer for received message
      int flag = 1;
      char *name = NULL;
      int *count = NULL;
      double *size = NULL;

      // Loop until there is no longer input or the queues are closed
      while (flag >= 0) {

        // Receive input from input channel
        // If there is an error, the flag will be negative
        // Otherwise, it is the size of the received message
        flag = cisRecv(in_channel, &name, &count, &size);
        if (flag < 0) {
          printf("Model A: No more input.\n");
          break;
        }

        // Print received message
        int nrows = flag;
        printf("Model A: (%d rows)\n", nrows);
        int i;
        for (i = 0; i < nrows; i++)
          printf("   %.6s, %d, %f\n", &name[6*i], count[i], size[i]);

        // Send output to output channel
        // If there is an error, the flag will be negative
        flag = cisSend(out_channel, nrows, name, count, size);
        if (flag < 0) {
          printf("Model A: Error sending output.\n");
          break;
        }

      }

      // Free dynamically allocated columns
      if (name) free(name);
      if (count) free(count);
      if (size) free(size);

      return 0;
    }

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    #include <stdio.h>
    // Include methods for input/output channels
    #include "CisInterface.h"

    int main(int argc, char *argv[]) {
      // Initialize input/output channels
      cisAsciiArrayInput_t in_channel = cisAsciiArrayInput("inputB");
      cisAsciiArrayOutput_t out_channel = cisAsciiArrayOutput("outputB", "%6s\t%d\t%f\n");

      // Declare resulting variables and create buffer for received message
      int flag = 1;
      char *name = NULL;
      int *count = NULL;
      double *size = NULL;

      // Loop until there is no longer input or the queues are closed
      while (flag >= 0) {

        // Receive input from input channel
        // If there is an error, the flag will be negative
        // Otherwise, it is the size of the received message
        flag = cisRecv(in_channel, &name, &count, &size);
        if (flag < 0) {
          printf("Model B: No more input.\n");
          break;
        }

        // Print received message
        int nrows = flag;
        printf("Model B: (%d rows)\n", nrows);
        int i;
        for (i = 0; i < nrows; i++)
          printf("   %.6s, %d, %f\n", &name[6*i], count[i], size[i]);

        // Send output to output channel
        // If there is an error, the flag will be negative
        flag = cisSend(out_channel, nrows, name, count, size);
        if (flag < 0) {
          printf("Model B: Error sending output.\n");
          break;
        }

      }

      // Free dynamically allocated columns
      if (name) free(name);
      if (count) free(count);
      if (size) free(size);

      return 0;
    }

Model YAML:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    models:
      - name: c_modelA
        language: c
        args: ./src/formatted_io3_modelA.c
        inputs: inputA
        outputs:
          name: outputA
          field_names: name,count,size

      - name: c_modelB
        language: c
        args: ./src/formatted_io3_modelB.c
        inputs: inputB
        outputs:
          name: outputB
          field_names: name,count,size

    connections:
      - input: outputA  # Connection between model A output & model B input
        output: inputB
      - input: ./Input/input.txt  # Connection between file and model A input
        output: inputA
        as_array: True
        filetype: table
      - input: outputB  # Connection between model B output and file
        output: ./output.txt
        as_array: True
        filetype: table

## Matlab Version

Model Code:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    % Initialize input/output channels
    in_channel = CisInterface('CisAsciiArrayInput', 'inputA');
    out_channel = CisInterface('CisAsciiArrayOutput', 'outputA', '%6s\t%d\t%f\n');

    flag = true;

    % Loop until there is no longer input or the queues are closed
    while flag

      % Receive input from input channel
      % If there is an error, the flag will be False.
      [flag, arr] = in_channel.recv();
      if (~flag)
        disp('Model A: No more input.');
        break;
      end;

      % Print received message
      nr = size(arr, 1);
      fprintf('Model A: (%d rows)\n', nr);
      for i = 1:nr
        fprintf('   %s, %d, %f\n', arr{i,1}, arr{i,2}, arr{i,3});
      end;

      % Send output to output channel
      % If there is an error, the flag will be False
      flag = out_channel.send(arr);
      if (~flag)
        disp('Model A: Error sending output.');
        break;
      end;

    end;

    exit(0);

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    % Initialize input/output channels
    in_channel = CisInterface('CisAsciiArrayInput', 'inputB');
    out_channel = CisInterface('CisAsciiArrayOutput', 'outputB', '%6s\t%d\t%f\n');

    flag = true;

    % Loop until there is no longer input or the queues are closed
    while flag

      % Receive input from input channel
      % If there is an error, the flag will be False.
      [flag, arr] = in_channel.recv();
      if (~flag)
        disp('Model B: No more input.');
        break;
      end;

      % Print received message
      nr = size(arr, 1);
      fprintf('Model B: (%d rows)\n', nr);
      for i = 1:nr
        fprintf('   %s, %d, %f\n', arr{i,1}, arr{i,2}, arr{i,3});
      end;

      % Send output to output channel
      % If there is an error, the flag will be False
      flag = out_channel.send(arr);
      if (~flag)
        disp('Model B: Error sending output.');
        break;
      end;

    end;

    exit(0);

Model YAML:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    models:
      - name: matlab_modelA
        language: matlab
        args: ./src/formatted_io3_modelA.m
        inputs: inputA
        outputs:
          name: outputA
          field_names: name,count,size

      - name: matlab_modelB
        language: matlab
        args: ./src/formatted_io3_modelB.m
        inputs: inputB
        outputs:
          name: outputB
          field_names: name,count,size

    connections:
      - input: outputA  # Connection between model A output & model B input
        output: inputB
      - input: ./Input/input.txt  # Connection between file and model A input
        output: inputA
        as_array: True
        filetype: table
      - input: outputB  # Connection between model B output and file
        output: ./output.txt
        as_array: True
        filetype: table