daily pastebin goal
43%
SHARE
TWEET

Untitled

a guest Jan 20th, 2019 58 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package main
  2.  
  3. import (
  4.     "math/rand"
  5.     "sync"
  6. )
  7.  
  8. //-------------------------------------------STRUCTS-------------------------------------------
  9. var wg sync.WaitGroup
  10. var wg2 sync.WaitGroup
  11.  
  12.  
  13. var wgSimulationsEnde sync.WaitGroup
  14. var warteAufSteuerlogik sync.WaitGroup
  15.  
  16. type Aufzug struct {
  17.     aufzugNr int // aufzug Nr
  18.     fahrgaeste int  //Anzahl Passagiere
  19.     max int         //Maximalkapazität
  20.     strecke int     //Gesamt-Wegstrecke
  21.     etage int // aktuelle Etage
  22.     zielEtage int // nächster halt
  23.     event string // 0 bereit, 1 einsteigend, 2 eingestiegen,3 fahrend, 4 aussteigend, 5 ausgestiegen
  24. }
  25. type Person struct {
  26.     wartezeit int//Wartezeit in schritten
  27.     soll int//Distanz start- ziel etage
  28.     ist int// tatstächlich gefahrene Strecke
  29.     abweichung int // differenz zwischen ist und soll
  30.     start int // Startegage
  31.     ziel int //Zieletage
  32.     status int //  0 = wartend auf zuteilung, 1 = zugeteilt, 12 einsteigend, 2 = fahrend, 23 aussteigend, 3 = ausgestiegen
  33.     aufzugNr int // nr des befördernden aufzugs
  34. }
  35. type Zentrale struct {
  36.     anzSim int // anzahl an Simulationsläufen
  37.     anzAufz int // anzahl Aufzüge
  38.     maxPers int // maximale anzahl an personen pro simulation
  39.     dauer int // dauer des simulationslaufs in Gesamtschritten
  40.     algNr int // aufzugalgorithmen (Nr)
  41.     auswertung []Auswertung // auswertung weiteres struct ???
  42. }
  43. type Auswertung struct { // alle aufzüge addiert!!!
  44.     wartezeitP int //gesamtwartezeit der passagiere in schritten
  45.     abweichungP int // gesamtdifferenz von soll- zu ist-strecken der passagiere in schritten
  46.     streckeA int // gesamtstrecke aller Aufzüge addiert
  47. }
  48.  
  49. type aufzugUndPerson struct{
  50.     p [] Person
  51.     a [] Aufzug
  52. }
  53.  
  54. type DatenPersonUndAuf struct{
  55.     a Aufzug
  56.     p Person
  57. }
  58.  
  59. var channelAuswertungAufzuege= make (chan []Aufzug,1)
  60. var channelAuswertungPersonen=make(chan []Person,1)
  61.  
  62.  
  63. // ---------------------------------------------ZENTRALE STEUERLOGIK----------------------------------------
  64. func ZentraleSteuerlogik() {
  65.  
  66.     auswertungsListe := make([]Auswertung,0)
  67.  
  68.     anzahlSimulationsläufe := 1
  69.     anzahlAufzüge := 4
  70.     dauer := 10000
  71.     maxPersonen := 10
  72.  
  73.     // angegebene anzahl von Simulationsläufen aufrufen, auswertung wird als rückgabewert erhalten und an liste angehängt
  74.     for i := 0; anzahlSimulationsläufe > i; i++{
  75.  
  76.         auswertung :=  Steuersimulation(anzahlAufzüge,dauer,maxPersonen)
  77.         auswertungsListe = append(auswertungsListe,auswertung)
  78.  
  79.         println("Abweichung Personen",auswertung.abweichungP,"Strecke Aufzug=",auswertung.streckeA,"Wartezeit P=",auswertung.wartezeitP)
  80.     }
  81.  
  82.     wgSimulationsEnde.Done() //Hier angekommen, sind die Simulationenfertig
  83.  
  84. }
  85.  
  86.  
  87.  
  88.  
  89. //----------------------------------------------STEUERLOGIK EINES SIMULATIONSLAUFS---------------------------------------------------
  90.  
  91. func Steuersimulation (anz, dauer, maxPers int/*, algorithmus func()*/)(auswertung Auswertung){
  92.  
  93.     // slices erzeugen
  94.     aufzugListe := make([]Aufzug,0)
  95.     fahrgaesteListe := make([]Person,0)
  96.  
  97.     // channels erzeugen
  98.     channelGP := make (chan Person,maxPers)
  99.     channelGA := make (chan Aufzug,anz)
  100.  
  101.  
  102.  
  103.  
  104.     aufzugUndPersonCHAN:=make(chan aufzugUndPerson)
  105.  
  106.  
  107.  
  108.     //generiere Aufzüge
  109.     GeneriereAufzuege(anz, channelGA) // aufzüge erzeugen
  110.     //empfange Nachrichten von generiere Aufzug, solange welche gesendet werden
  111.  
  112.     for i:=0;i<anz;i++{
  113.         neuerAufzug := <-channelGA
  114.         aufzugListe = append(aufzugListe, neuerAufzug)
  115.  
  116.     }
  117.  
  118.  
  119.     // erzeuge neue Personen
  120.     GenerierePassagiere(maxPers, channelGP)// übergibt berechnete maximal erlaubte personenanzahl
  121.     //empfange Nachrichten von GenerierePassagiere
  122.     for i:=0;i<maxPers;i++{
  123.         neueAnfragen := <-channelGP // speichere Nachricht in variabel
  124.         fahrgaesteListe = append(fahrgaesteListe, neueAnfragen)// hänge neue anfrage an fahrgästeliste an
  125.  
  126.     }
  127.  
  128.     // algorithmus aufrufen
  129.     go Aufzugsteuerungs_Agorithmus_1(aufzugUndPersonCHAN,maxPers, dauer, anz)
  130.     // auswertung senden
  131.  
  132.     aufzugUndPersonCHAN<-aufzugUndPerson{fahrgaesteListe,aufzugListe}
  133.  
  134.  
  135.     a:=<-aufzugUndPersonCHAN
  136.  
  137.     println("Test",len(a.p),len(a.a))
  138.  
  139.     //nach beendigung der simulation
  140.     // erstelle auswertung
  141.     for i := range aufzugListe{
  142.         auswertung.streckeA += aufzugListe[i].strecke // gesamtstrecke aller Aufzüge addiert
  143.     }
  144.     for i := range fahrgaesteListe{
  145.         auswertung.wartezeitP += fahrgaesteListe[i].wartezeit //gesamtwartezeit der passagiere in schritten
  146.         auswertung.abweichungP += fahrgaesteListe[i].abweichung // gesamtdifferenz von soll- zu ist-strecken der passagiere in schritten
  147.     }
  148.  
  149.  
  150.     //println("Abweichung Personen",auswertung.abweichungP,"Strecke Aufzug=",auswertung.streckeA,"Wartezeit P=",auswertung.wartezeitP)
  151.     println("Eine Runde ist fertig")
  152.     return // gibt auswertung des simulationslaufs zurück
  153.  
  154. }
  155.  
  156. //--------------------------------------------GENERIERE AUFZÜGE---------------------------------------------------
  157. func GeneriereAufzuege (anzA int, channelGA chan Aufzug){
  158.  
  159.     maxPers := 1 // wieviele dürfen höchstens mitfahren
  160.     for i := 1; anzA >= i; i++{
  161.  
  162.  
  163.         neuerAufzug := Aufzug{i,0,maxPers,0,-3,-2,"aufzug bereit"}
  164.  
  165.         channelGA <- neuerAufzug
  166.     }
  167.  
  168. }
  169.  
  170.  
  171.  
  172.  
  173. //------------------------------------------GENERIERE PASSAGIERE-----------------------------------------------------
  174.  
  175. func GenerierePassagiere(max int, channelGP chan Person){ // hier kann anzahl an personen je schritt und anzahl etagen geändert werden
  176.  
  177.     for ; max > 0; max--{
  178.  
  179.         startEtage := rand.Intn(4)
  180.         zielEtage := 0
  181.  
  182.  
  183.         for ungleich := false; ungleich == false;{ // damit start und zieletage nicht gleich sind
  184.             zielEtage = rand.Intn(4)
  185.  
  186.             if startEtage != zielEtage{
  187.                 ungleich = true
  188.             }
  189.         }
  190.         neueAnfrage := Person{0,0,0,0,startEtage,zielEtage  ,0,0} // wie macht man einen channel ????????
  191.  
  192.         channelGP <- neueAnfrage
  193.  
  194.  
  195.     }
  196.  
  197.  
  198. }
  199.  
  200.  
  201.  
  202.  
  203.  
  204.  
  205. //---------------------------------------GOROUTINE PERSON-----------------------------------------------
  206.  
  207. func goroutineP(chanMitAlgo chan DatenPersonUndAuf,doneChan chan bool){
  208.  
  209.     simuLaueft:=true
  210.     for simuLaueft{
  211.  
  212.         var aufzug Aufzug
  213.         var fahrgast Person
  214.  
  215.         neueDaten:=<-chanMitAlgo
  216.  
  217.         aufzug=neueDaten.a
  218.         fahrgast= neueDaten.p
  219.         switch fahrgast.status {
  220.         case 0: fahrgast.ist += 1
  221.             fahrgast.wartezeit += 1
  222.         case 11:
  223.             if aufzug.event == "aufzug bereit"{
  224.                 //println("Person hat Zielaufzug")
  225.                 fahrgast.status = 1 // fahrgast hat jetzt einen zielaufzug
  226.                 fahrgast.aufzugNr = aufzug.aufzugNr
  227.                 fahrgast.soll = fahrgast.ziel - fahrgast.start
  228.                 if fahrgast.soll < 0{
  229.                     fahrgast.soll = fahrgast.soll *-1 // negative werte umkehren
  230.                 }
  231.             }else{
  232.                 fahrgast.ist += 1
  233.                 fahrgast.wartezeit += 1
  234.             }
  235.         case 1:
  236.             fahrgast.ist += 1
  237.             fahrgast.wartezeit += 1
  238.             //println("Erhöhe um 1")
  239.         case 12:
  240.             fahrgast.status = 2
  241.         case 2:
  242.             fahrgast.ist += 1
  243.         case 23:
  244.             println("Person ist ausgestiegen markiert")
  245.             fahrgast.status = 3 // fahrgast als ausgestiegen markieren
  246.             fahrgast.abweichung = fahrgast.ist - fahrgast.soll
  247.         default:
  248.  
  249.         }
  250.  
  251.         chanMitAlgo<-DatenPersonUndAuf{aufzug,fahrgast}
  252.  
  253.         //Stoppe  Schleife
  254.         select {
  255.         case msg1 := <-doneChan:
  256.             simuLaueft = msg1
  257.         default:
  258.         }
  259.     }
  260.  
  261.  
  262. }
  263.  
  264. //------------------------------------------------------GOROUTINE AUFZUG------------------------------------------------------
  265.  
  266. func goroutineA(chanMitAlgorithmus chan DatenPersonUndAuf,done chan bool){
  267.  
  268.  
  269.     //BEKOMMT AUFZUG UND UPDATET NACH EVENT
  270.     //BEKOMMT PERSON ZIELETAGE
  271.     simuLaueft:=true
  272.     for simuLaueft{
  273.  
  274.         var aufzug Aufzug
  275.         var fahrgast Person
  276.  
  277.         neueDaten:=<-chanMitAlgorithmus
  278.  
  279.         aufzug=neueDaten.a
  280.         fahrgast= neueDaten.p
  281.         switch aufzug.event {
  282.         case "aufzug bereit":
  283.             aufzug.zielEtage = fahrgast.start
  284.             aufzug.fahrgaeste+=1    // aufzug erhält neues ziel
  285.         case "aussteigen":
  286.             //println("aussteigen")
  287.             aufzug.fahrgaeste -= 1// anzahl der fahrgäste im Aufzug reduzieren
  288.         case "einsteigen":
  289.             aufzug.zielEtage=fahrgast.ziel
  290.             //aufzug.fahrgaeste += 1
  291.         case "anfrage unten":
  292.             aufzug.etage -= 1
  293.             aufzug.strecke += 1 // gesamtstrecke des aufzugs erhöhen
  294.         case "anfrage oben":
  295.             aufzug.etage += 1
  296.             aufzug.strecke += 1 // gesamtstrecke des aufzugs erhöhen
  297.         case "ziel unten":
  298.             aufzug.etage -= 1
  299.             aufzug.strecke += 1
  300.         case "ziel oben":
  301.             aufzug.etage += 1
  302.             aufzug.strecke += 1
  303.         }
  304.  
  305.         chanMitAlgorithmus<- DatenPersonUndAuf{aufzug,fahrgast}
  306.  
  307.         select { //for i:=0;i<anz*dauer;i++{
  308.         case msg1 := <-done:
  309.             simuLaueft = msg1
  310.             println("Fertig")
  311.         default:
  312.         }
  313.     }
  314.  
  315.  
  316.  
  317. }
  318.  
  319.  
  320. //----------------------------------------------ALGORITHMUS------------------------------------------------------------------
  321.  
  322. //func Aufzugsteuerungs_Agorithmus_1 (channelAlgA, channelAuswertungAufzuege chan []Aufzug, channelAlgP,channelAuswertungPersonen chan []Person, maxPers, dauer)
  323.  
  324.  
  325. func Aufzugsteuerungs_Agorithmus_1 (aufzugUndPersonChan chan aufzugUndPerson,maxPers int, dauer int ,anz int){
  326.     aufzugListe := make([]Aufzug,0)
  327.     fahrgaesteListe := make([]Person,0)
  328.  
  329.     chanMitAufzug:=make(chan DatenPersonUndAuf)
  330.     chanMitPerson:=make(chan DatenPersonUndAuf)
  331.  
  332.  
  333.     chanDoneAuf:=make(chan bool,1)
  334.     chanDonePerRoutine:=make(chan bool,1)
  335.  
  336.  
  337.     aUp:=<-aufzugUndPersonChan
  338.  
  339.     aufzugListe =aUp.a
  340.     fahrgaesteListe = aUp.p
  341.  
  342.     go goroutineP(chanMitPerson,chanDonePerRoutine)
  343.     go goroutineA(chanMitAufzug,chanDoneAuf)
  344.  
  345.  
  346.     for ; dauer >= 0; dauer--{
  347.         for i := range aufzugListe {
  348.             // planung
  349.             if aufzugListe[i].fahrgaeste == 0{
  350.                 //aufzug leer? dann erhalte neue anfrage
  351.                 for k:= range fahrgaesteListe{
  352.                     if fahrgaesteListe[k].status == 0{ // nehme ersten wartenden fahrgast
  353.                         aufzugListe[i].event = "aufzug bereit"
  354.                         chanMitAufzug<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[k]}
  355.                         antwort:=<-chanMitAufzug
  356.                         aufzugListe[i]=antwort.a
  357.  
  358.                         fahrgaesteListe[k].status = 11
  359.                         chanMitPerson<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[k]}
  360.  
  361.                         antwortPerson:=<-chanMitPerson
  362.                         fahrgaesteListe[k]=antwortPerson.p
  363.                         //println("Aufzug",aufzugListe[i].aufzugNr,"Aufzugfahrgäste",aufzugListe[i].fahrgaeste)
  364.                         break
  365.                     }
  366.                 }
  367.             }
  368.  
  369.             // ausführung
  370.  
  371.             for j:= range fahrgaesteListe{
  372.                 //schritt: aussteigen lassen
  373.  
  374.                 if aufzugListe[i].etage == fahrgaesteListe[j].ziel && fahrgaesteListe[j].status == 2 && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr{
  375.                     println("Jmd steigt Aus")
  376.                     aufzugListe[i].event = "aussteigen"
  377.                     fahrgaesteListe[j].status = 23
  378.                     chanMitAufzug<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  379.                     antwortAufzug:=<-chanMitAufzug
  380.                     chanMitPerson<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  381.                     antwortPerson:=<-chanMitPerson
  382.                     aufzugListe[i]=antwortAufzug.a
  383.                     fahrgaesteListe[j]=antwortPerson.p
  384.                     // schritt: einsteigen lassen
  385.                 } else if aufzugListe[i].etage == fahrgaesteListe[j].start && fahrgaesteListe[j].status == 1 && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr{
  386.                     //println("Einsteigen")
  387.                     aufzugListe[i].event = "einsteigen"
  388.                     fahrgaesteListe[j].status = 12
  389.                     chanMitAufzug<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  390.                     antwortAufzug:=<-chanMitAufzug
  391.                     chanMitPerson<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  392.                     antwortPerson:=<-chanMitPerson
  393.                     aufzugListe[i]=antwortAufzug.a
  394.                     fahrgaesteListe[j]=antwortPerson.p
  395.                     //println("Status",fahrgaesteListe[j].status)
  396.  
  397.                     //schritt: zu anfrage runter fahren
  398.                 }else if aufzugListe[i].etage > aufzugListe[i].zielEtage && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr && fahrgaesteListe[j].status == 1{ // aufzug runter fahren
  399.                     //println("Anfrage Unten")
  400.                     aufzugListe[i].event = "anfrage unten"
  401.  
  402.                     chanMitAufzug<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  403.                     antwortAufzug:=<-chanMitAufzug
  404.                     chanMitPerson<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  405.                     antwortPerson:=<-chanMitPerson
  406.                     aufzugListe[i]=antwortAufzug.a
  407.                     fahrgaesteListe[j]=antwortPerson.p
  408.  
  409.  
  410.                     //schritt: zu anfrage rauf fahren
  411.                 }else if aufzugListe[i].etage < aufzugListe[i].zielEtage && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr && fahrgaesteListe[j].status == 1{ // aufzug rauf fahren
  412.  
  413.                     //println("Anfrage Oben")
  414.                     aufzugListe[i].event = "anfrage oben"
  415.  
  416.                     chanMitAufzug<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  417.                     antwortAufzug:=<-chanMitAufzug
  418.                     chanMitPerson<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  419.                     antwortPerson:=<-chanMitPerson
  420.                     aufzugListe[i]=antwortAufzug.a
  421.                     fahrgaesteListe[j]=antwortPerson.p
  422.  
  423.  
  424.                     //schritt: zu ziel des gasts runter fahren
  425.                     } else if aufzugListe[i].etage > aufzugListe[i].zielEtage && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr && fahrgaesteListe[j].status == 2{
  426.                         //println("Ziel Unten")
  427.                     aufzugListe[i].event = "ziel unten"
  428.  
  429.                     chanMitAufzug<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  430.                     antwortAufzug:=<-chanMitAufzug
  431.                     chanMitPerson<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  432.                     antwortPerson:=<-chanMitPerson
  433.                     aufzugListe[i]=antwortAufzug.a
  434.                     fahrgaesteListe[j]=antwortPerson.p
  435.  
  436.  
  437.  
  438.                     //schritt: zu ziel des gasts rauf fahren
  439.                     }else if aufzugListe[i].etage < aufzugListe[i].zielEtage && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr && fahrgaesteListe[j].status == 2{
  440.                     //println("Ziel Oben")
  441.                     aufzugListe[i].event = "ziel oben"
  442.  
  443.                     chanMitAufzug<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  444.                     antwortAufzug:=<-chanMitAufzug
  445.                     chanMitPerson<-DatenPersonUndAuf{aufzugListe[i],fahrgaesteListe[j]}
  446.                     antwortPerson:=<-chanMitPerson
  447.                     aufzugListe[i]=antwortAufzug.a
  448.                     fahrgaesteListe[j]=antwortPerson.p
  449.  
  450.                 }
  451.  
  452.  
  453.             }
  454.  
  455.         }
  456.  
  457.  
  458.  
  459.     }
  460.  
  461.     chanDoneAuf<-false
  462.     chanDonePerRoutine<-false
  463.     aufzugUndPersonChan<-aufzugUndPerson{fahrgaesteListe,aufzugListe}
  464.  
  465. }
  466.  
  467.  
  468.  
  469.  
  470. //----------------------------------------------------MAIN--------------------------------------------------
  471. func main(){
  472.  
  473.     go ZentraleSteuerlogik()
  474.     wgSimulationsEnde.Add(1) //Warte auf Simulationsende
  475.     wgSimulationsEnde.Wait()
  476.     println("Alles fertig")
  477.  
  478. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top