krockema / mate Goto Github PK

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

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

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)

@Krockema

Input/Changes:

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

Output:

• db dump of ResultDB (KPIs)

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

• 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

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

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.

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

expected behavior:

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

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.

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

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

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

• 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

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

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

Switch vom AkkaSim to Akka.Hive

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

and implement more priority rules

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

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

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

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)

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