krockema / mate

Prove of Concept for aManufacturing on Actor Technology System in an Industrial 4.0 Environment

MATE - Manufacturing on Actor Technology

The Project build status and other details:

This project is part of a research project to evalutate self-organizing concepts in an industrial production planning and control application.

Short troduction into the topic of self-organizing production planning and controll and showcase of MATE. Comunity Standup of Akka.Net on youtube.com from 13.04.2021

#Project structure

• Mate

  Provides basic webinterface on ASP.Net for showcase purpose

• Mate.DataCore

  Provides database and initializer for basic schema and primary data, as it is build as "code-first" with Entity Framework

• Mate.Production.CLI

  Provides a small CLI that acts as headless runtime, used for remote deployment that register themself as worker for the Hangfire module.

• Mate.Production.Core

  Actor simulation runtime that can be initalized as self-irganized, distributed or central organized system to validate production planning algorithms using tertiary objectives

• Mate.Production.Immutables

  Immutable message definitions for the actor system.

• Mate.Test

  Provides online and offline test for the project. Be aware that some of them are not used as intended ;).

How to Install

Setup:

• Install Visual Studio (works with Visual Studio Community 2022 17.1) with default components and also make sure to have:
  • .NET 6.0 Runtime
  • F#
  • SQL Server Express 2019 LocalDB
  • ASP Web-Development

1. Clone repository
2. If localDb shall be used (which is the default case for Windows user) - set it via command line with: setx UseLocalDb true
3. Open Visual Studio and go to Mate/libman.json. Left click and "Restore Client-Side Libraries"
4. Done - Run the project

To reset database: run the unit test: Mate.Test.SimulationEnvironment.AgentSystem.ResetAllDatabase (Delete and Create all DBs)

Releated Papers

• 2018 - An Approach to a Self-organizing Production in Comparison to a Centrally Planned Production
• 2020 - SOBA: A Self-Organizing Bucket Architecture to Reduce Setup Times in an Event-Driven Production
• 2021 - Agent-based Decentral Production Planning and Control: A New Approach for Multi-resource Scheduling
• 2021 - Suitability of Self-Organization for Different Types of Production

Releated Projects

• Akka.Hive

  An Agent Simulation Framework based on Akka.Net

• SEED - Sintesizer for Enterprise Experimentation Data

  An Framework to populate Primary-Data, like Material, BOM, Operations. . . based on statistical indicators

mate's Issues

Transfer operations into single agents.

Transfer WorkItems from Production Agent into dedicated operation agents.

• May required due to machine to skill to operation mapping based on recipies
  • could be crated when the operation is fix sheduled on one mashine
    • ensures correct processing
    • enables tracing on operational level
    • further specialisation for specific incidents prossible

opens problems:

• syncing parallel processing
• more than one agent per product

Implement Feedback from Collectors to enable dynamic feedback for Parameter adoption. (Firstly for Throughput times)

Implement Setuptimes for Tooling on the Machines

Introduce job manager for resource agent

Feature calculate max bucket proportions

IDEA:

• count arriving operations and their durations --> automatically calculate proportions of for max bucket size
• forget operations older than 1 week

IMPLEMENTATION:

• object with dictionary having (string) "Group technology" and (int) "totalduration"
• new arriving operation --> "totalduration" += operation.duration

Generator for final product structures

Design and Implement Product-Generator, which can be feeded with manualy or auto generated subproducts and generate a given amount of final products. This products should have a variation in product structure.

Aimed behaviour:

• manualy and auto create mediate products (including required machine-capabilities)

input: Amount of possible final products, interval of product structure,

output: auto generate boms for

Simulation of a self-organizing production in AR

Problem:
Visualization simulation of a self-organizing production in AR

Possible solutions:

• Web-Framework / Multiplattform solution: A-Frame / SignalR https://aframe.io/
• 3D Models with Blender (currently as glTF-File https://docs.blender.org/manual/en/2.80/addons/io_scene_gltf2.html)
• Android nativ with ARCore https://developers.google.com/ar/discover
• iOS nativ with ARKit https://developer.apple.com/documentation/arkit

Enable diverging product structure

• Let StorageAgent create ProductionAgent for multiply orders
• Use-Case i.e. Splitting raw material for multiply orders

show case procedure for dispo agents:
(1) create new DispoAgent with diverging product structure
(2) if no bucket for same raw material exits or all exiting buckets for same raw material are already at their limit --> the DispoAgent creates a new bucket at storageagent, else add to busket
(3) as soon as any dispo agent inside bucket reaches priority the bucket creates a production agent with all including dispoagents

assumptions:

• spare capacties on raw material can be neglected

extension:

• storage can create new dummy dispoagents if raw material has spare capacities

Save Config and Realation to Simulation Number.

Extend for Product Generator
Extend for Version number, to Estimate which Mate version is Compatible
Create an MVP - Mate Version Protocol

Rework Simulation Report

Replace the SimulationComparingView with a new one based on new Reporting Values.

Replace Gantt by ChartJs Timeline view.

Separate seeds for inter arrival time / process deviation

• seed for inter arriaval time
• seed for process deviation
• seed operations sequence with create foperation --> operation durations are not influenced by the order of processing

Implement Bucket Processing

Batches For Workshedules with the same Tooling Setup. (Collect at Hubagent, and release them on a certain threshhold - First try with Min(RequiredDate) - (3x Item.duration).

Overall TODO:
[ ] Add swapping current tool on resource in "Default" behaviour depending on requierd tool for next running job
[ ] Add proposal times to resource depending on swap resource tool or not
[ ] Create the Bucket behaviour for Agents and run with default behaviour
[ ] Add a BucketManager at hub agent (handle all Buckets for a hub categorized by setup typs)
[ ] Implement functionality with lead time oriented bucket behaviour
[ ] at enqueue foperation - search for open buckets with: same setup tool && where bucket.start < currentOperation.start && bucket.end > currentOperation.end
[ ] Enhance machine utiliaziation with setup time to evalute work/setup ratio

Refactoring Agent Core

List of implementation

• Parent/Child-Creation and Finishing for Dispo Agent / Production Agent
  • delete virtual Childs releation between Dispo and Prod (dont delete relation between Prod and Dispo)
    • finish Dispo Agents when MaterialsProvided
    • finish Prod Agents when all operations finished and all dispoagents (virtual childs) terminated
  • implement forward scheduling (Production Agent all Dispo Agent --> take the one with later ending time)
• Implement Methods for Default Behaviour
  • Only allow top down changes for IJobItem properties
  • SPOT at Hub Agent
  • restructure handling with JobItems, only send them if necessary
• Restructure and Implement Unit Tests
  • implement new unit tests for data structures
  • implement new unit tests for agents
  • restructure folder structure for unit tests
  • add unit test to Travis
• Refactoring InitializeSimulation
  • loading analyzer
  • loading guards
  • initialize resources
  • initialize stocks
  • Refectoring DatabaseConnection by replace MasterDBConnection with DbConnection (seperate connections for each Agent/Object.)
• take Properties from Agent.Properties to behaviour and use an Interface for behaviours to access the properties
  • check F# modules & types if necessary
• Introduce Agent Behaviour for Contract, Directory, Storage, Dispo, Hub, Production, Resource
  • Implement Default
• Refactoring F# Simulation Messages
  • IKey and IJob usable for any planning element (i.e. Operation or Bucket)
  • Remove ItemState AND introduce (bool) MaterialsProvided and (bool) PreconditionsProvided (own objects)

Implement Batches

Implement batch processing, i.e. Collection of Operations with the same set-up, processed all at once.

i.e. Backery baking rolls.

Creating batches dependent on Machine capabilities:

• Possible solutions:
  • Machine dependencies telling max batch size on request,
    based on that, a bucket limit is created.
  • Machine splits the Bucket into batches and returns overflow.

Implement guardians for Stock, Dispo, Production to Keep the Agents Indipendent from their tree structure (BoM).

Reimplementing Central Planing Algorithm to Replace Sebastians solution.

Time coupled production processes

Sheduling of Products that have time dependencies betweeen consecutive operations.
i.E. Applying color -> drytime -> applying finish.

Cases:

• min wait time
• max wait time
• exact wait time

Dynamic pegging

Implement the dynamic pegging

Aimed behaviour:
If new orders arrival with an earlier due, dynamic pegging should change the due for the existing production and instead create the dispo and production agents for the new order with the later due time of the replaced item.

Split StockExchange into Withdraw and Insert

Due to refactoring it is needed to Split StockExchange Table into Withdraw and Insert.

Add one machine to multiple capabilities

Make priority rules configurable

and implement more priority rules

Fix UI OrderNo

Multiply HubAgents for Resources

• FHubInformation with List
• enable Resources to link with multiply HubAgents

expected behavior:

• resource can contain to multiply HubAgents
• resource can propose to multiply HubAgents

Enable Agent-Model to work in Real-Time

Allgemein einen Wrapper für die SimulationTime da sie im Moment wird ausschließlich long genutzt.

ResourceGuardian / change sequence for creating Resources and Hubs

create a ResourceGuardian for resources

Change the sequence of creating resources and hubs to:
[1] Create Resources that provides ResourcesSkills (with containing Setups)
[2] Register Resources at DirectoryAgent
[3] Create new HubAgents depending on the provide ResourceSkills

Additional:

• make resources addable and deletable (note: dependencies to HubAgents)

Quality assurance

Track any single production unit through all maschines + setups to quaranty quality and track down issues.

PMT - Agent lighthouse

Create a AKKA Cluster to create a distributed solution based on:

• https://petabridge.com/blog/intro-to-akka-cluster/

It is may required to implement your own MQTT Client to create an Interface to a physical layer and other agent Implementations based on:

• https://github.com/berczeck/Paho-Akka.net

PMT - Integration with Akka.Hive

Switch vom AkkaSim to Akka.Hive

Create name/description for connection between simulation and test-approach

Problem:

• create multiple approachs and executing many simulation, the connection between simulation and approach is no longer possible

Solution:

• implement parameter with "Name" for each simulation
  or
• add ApproachID to simulation in order to enable an assignment afterwards

PMT - Logistic Agent

Implement logistic agent for transportation of products between production units.
Possible solutions:

• as own Operation with Resource requirement.
• as additional Parameter on an Operation (external set-up time)
• as indipendent logistic Agent

Change Naming from Machine to Resource and Fix Ressource to Resource

AI Data generation

@Krockema

Input/Changes:

• use current feature KI branch
• steps to ~1.000.000
• change seed (?)

Output:

• db dump of ResultDB (KPIs)