Furnace.h

Go to the documentation of this file.

#ifndef FURNACE_INCLUDED
#define FURNACE_INCLUDED

#include <odem.h>

#include "Bath.h"
#include "HStorage.h"
#include "Observer.h"
#include "Automation.h"
#include "PaletteFrame.h"
#include "CraneRequestq.h"
#include "SetOfRingStack.h"

//Furnace Types
//const int SINGLE                              =  1;
//const int DOUBLE                              =  2;
//enum States {empty, singleState, half, doubleMix, doublePure};

enum ProcedureClass {A, B, C};

class BathAssistent : public Discrete {
public:
        Furnace *myFurnace;
        PlaceConfiguration*     placeConfiguration;
        Place                   *chillPlace;    // kann Stellplatz, Polymer- oder Wasserbad sein
        CraneRequestq   *craneRequestQ; // Registrierung von Krananforderungen
        Waitq                   *finalOutAirQ;  // Synchronisation mit Kran zur Abholung der Palette
        SetOfRingStack  *myPalette;     // Palettenzuordnung
        Treatment*              treatment;              // Aktuelle Wärmebehandlung

        BathAssistent (char *n, Furnace * myF, CraneRequestq *cReq, Waitq *foutAq, PlaceConfiguration* pC) : 
                                Discrete(n), 
                                myFurnace(myF),
                                craneRequestQ(cReq), 
                                finalOutAirQ(foutAq),
                                myPalette(0),
                                chillPlace(0),
                                placeConfiguration(pC)
        {};
        virtual int main();

};

class Furnace : public Discrete {
public:
//      static  double  lastStart;              // Der Wert [time() - lastStart] muß größer
                                        // gleich SHIFT sein
        int                             number;                 // Ofennummer   
        int                             capacity;               // Ofenkapazität
        Res                             *occu;                  // Ofenauslastungsbeobachtung

//      States                  occupied;
//      bool                    firstTime;

        PlaceConfiguration*     placeConfiguration;
        Place                   *chillPlace;            // kann Stellplatz, Polymer- oder Wasserbad sein
        Place                   *secondChillPlace;      // z.B. Wasser -> Polymer
        BathAssistent   *myAssistent;

        CraneRequestq   *craneRequestQ; // Registrierung von Krananforderungen

        Waitq                   *emptyFurnaceQ, // Synchronisation mit Kran als freier Single-Ofen (1 Palette)                          
                                        *inAirQ,                // Synchronisation mit Kran als heisser Ofen (Abschreckung)                             
                                        *outAirQ,               // Synchronisation mit Kran als heisser Ofen (Abschreckung)
                                        *inBathQ,               // Synchronisation mit Kran als heisser Ofen (Abschreckung)                             
                                        *outBathQ,              // Synchronisation mit Kran als heisser Ofen (Abschreckung)     
                                        *finalOutAirQ,
                                        *nextBathQ,             // Synchronisation mit Kran als heisser Ofen (2.Abschreckung)   
                                        *readyFurnaceQ, // Synchronisation mit Kran als fertiger Ofen 
                                        *dispatcherQ;   // zum Test einer Folgepalette
        Waitq                   *assistentQ;

        SetOfRingStack  *myPalette;     // erste Palettenbelegung (0, falls leer)
                                

        Count                   *inUse;                 // Zähler augenblicklicher Paletten im Ofen

        //Histo                 *profileLoading;// Zeitprofil der Wartezeiten
        //Histo                 *waitSumA;              // Wartezeit eines Ofens (auf Kran oder freies Bad nach Start)
//      Histo                   *waitSumB;              // Wartezeit eines Ofens (auf Kran oder freies Bad nach Start)

//      Histo                   *cycleTimeSum;  // Laufzeit eines Ofens
//      Count                   *cycleNumber;   // Anzahl von Ofenzyklen
        //Histo                 *realShift;             //

        //void                  coolingIn(int type); // 0->Water, 1->Polymer, 2->Water/Polymer
        Observer                *observe;

//      long                    vpos; // Position im Animator

        Treatment*              treatment; // Aktuelle Wärmebehandlung
        int                             state; // Abarbeitungszustand in der aktuellen Wärmebehandlung

        Automation*             automat;                        // Zeiger auf Pufferstrecke für Aktivierung

//      Histo*  blockedWater;                   // Registratur der Wartezeiten auf Abschreckung
        
        virtual int main();
        Furnace(char *n, 
                        int no, 
                        int cap, 
                        CraneRequestq *cReq, 
                        Waitq *eFq,
                        Waitq *inAq, 
                        Waitq *outAq, 
                        Waitq *inBq, 
                        Waitq *outBq,
                        Waitq *nextBq,
                        Waitq *fOutAirQ,
                        Waitq *rFq,
                        Waitq *dPq,  
                        Automation* at, /*Histo *hL,*/
                        long number, /*Histo *rS,*/
                        Observer *ob, 
//                      long vp,
//                      Histo *blW,
                        PlaceConfiguration* pC) : 

                        Discrete(n), number(no), capacity(cap), 
                                //firstTime(true),                              
                                occu(new Res ("Furnace",cap)), 
                                //occupied(empty), 
                                craneRequestQ(cReq), 
                                emptyFurnaceQ(eFq), 
                                inAirQ(inAq),
                                outAirQ(outAq),
                                inBathQ(inBq),
                                outBathQ(outBq),
                                nextBathQ(nextBq),
                                finalOutAirQ(fOutAirQ),
                                readyFurnaceQ(rFq), 
                                dispatcherQ(dPq),
                                myPalette(0),
                                secondChillPlace(0),
                                placeConfiguration(pC),

                                assistentQ(new Waitq("assistentQ")),
                        
                            inUse               (new Count("imOfen")), 
//                              singleUse       (new Count("FurnUsed")),

                                /*profileLoading(hL),*/
//                              cycleTimeSum(new Histo("FurnCycleTime",21,23,5)),
//                              waitSumA        (new Histo("waitSumA",0,50,10)),
//                              waitSumB        (new Histo("waitSumB",0,50,10)),
//                              cycleNumber     (new Count("cycleNumber")),
                                /*realShift(rS),*/
                                observe(ob),
//                              vpos(vp),
                                automat(at)
                                //blockedWater(blW)
        {}

        double getFreeIn();
        
private:
        void waterOrPolymerChill(BathType type);
        void waterAndPolymerChill();
        void ventilatorChill();
        void finalVentilatorChill();
        void airChill();
};

#endif

---