CustomerRequest.h

Go to the documentation of this file.

#ifndef CUSTOMERREQUEST_INCLUDED
#define CUSTOMERREQUEST_INCLUDED

#include <cassert>
#include <odem.h>
#include <string>
#include <list>

#include "HStorage.h"
#include "Bath.h"

#include "ConfigParser.h"

//const char* ProcString[] =  {"N+V","V","T","QT","TQ+T","V+E","N+V+E","NT","N","TN","G+A","other","unknown",0};
extern const char* ProcString[];
extern const char* ProcStringForReport[];

enum Procedure  {       
                                        NV,V,T,QT,TQT,  // Variante 1
                                        VE,NVE,                 // Variante 2
                                        NT,                             // Variante 3
                                        N,TN,                   // Variante 4
                                        GA,                             // Variante 5
                                        Other           // nicht zu berücksichtigen
                                };

int variante(Procedure p);

Procedure proc (const char* s);
BathType String2BathType (const char* s);

class Treatment {
        static std::list<Treatment*> all;
        Procedure p;
        double temp1;
        double temp2;
        BathType c;
        Treatment (Procedure proc, double ptemp1, double ptemp2, BathType cool): p(proc), temp1(ptemp1), temp2(ptemp2), c(cool){}
public:
        static Treatment* newTreatment(Procedure proc, double temp1, double temp2, BathType cool)
        {
                Treatment* newT = new Treatment(proc, temp1, temp2, cool);
                for (std::list<Treatment*>::iterator it=all.begin(); it!=all.end(); ++it)
                        if (**it==*newT) { delete newT; return *it; }
                all.push_back(newT);
                return newT;
        }
                
        bool operator==(const Treatment& other) const { 
                return p==other.p && c==other.c && temp1==other.temp1 && temp2==other.temp2; 
        }
        friend std::ostream& operator<<(std::ostream& o, const Treatment& t)
        {
                return o<<ProcString[t.p]<<'\t'<<t.temp1<<'\t'<<t.temp2<<'\t'<<BathString[t.c]<<'\n';
        }
        static void printAll(std::ostream& os) {
                for (std::list<Treatment*>::iterator it=all.begin(); it!=all.end(); ++it)
                        os<<**it;
        }


        // Vorabkühlung der Palette noch außerhalb, oder schon im Ofen 
        double timePreCool()const{ double time = conf.getONPALETTE(variante(p)); return time;}
        // depricated!
        double timeOnPalette()const { std::cerr<<"\ntimeOnPalette depricated: use timePrePaletteCool instead\n";
                                                                  return timePreCool(); }

        // erste Ofenphase: für alle Aufträge zu berücksichtigen
        double timeOven1()const     { double time = conf.getOVEN1(variante(p)); return time;}
        
        // zweite Ofenphase: nur für Aufträge der Varianten 1 - 3 (nicht N, G+A)
        double timeOven2()const     { 
                assert (("oventime 2 not allowed", p < N));
                double time = conf.getOVEN2(variante(p)); return time;
        }

        // Nachkühlung der Palette: immer außerhalb des Ofens
        double timePostCool()const{ double time = conf.getCOOLING  (variante(p)); return time;}
        // depricated!
        double timeEndCooling()const{ std::cerr<<"\ntimeEndCooling depricated: use timePostCool instead\n";
                                                                  return timePostCool(); }

        // Abschreckung, falls noch eine 2. Ofenphase folgt, nur für Aufträge der Varianten 1 - 3 (nicht N, G+A)
        double timeChill1()const        { 
                assert (("chilltime 1 not allowed", p < N));
                double time = conf.getCHILL(variante(p), c); return time; 
        }
        
        // Abschreckung, falls KEINE 2. Ofenphase folgt, nur für Aufträge der Varianten 4 und 5 (N, G+A)
        double timeChill2()const        { 
                assert (("chilltime 2 not allowed", p >= N));
                double time = conf.getCHILL(variante(p), c); return time; 
        }                                                       
        
        // Palette mit Ofenabkühlung (OAK)! Zeit noch unspezifiziert!
        double timeCool1()const { 
                return 0; 
        }       

        // Ofenabkühlzeit (Ofen leer) vor Neubeschickung: Zeit noch unspezifiziert!
        double timeCool2() const     { return 0; }

        // Abschreckung in beiden Bädern:
        // A: Zeit im Wasserbad
        double timeChill_A()const       { return 10;}
        // B: Zeit im Polymerbad
        double timeChill_B()const       { return 30;}

        Procedure getProcedure() const {return p;}
        BathType getBath() const  {return c;}
};



class CustomerRequest: public Msg {
public:
        // given parameters per input
        
        double                  diameter;                       // Durchmesser der Ringe des Auftrages

        double                  height;                         // Höhe eines Ringes

        double                  mass;
        
        Treatment*      treatment;                      // Veredelungsverfahren für alle Ringe
        
        std::string             material;
        
        SIMTIME         startTime;                      // Beginn der Auftragsrealisierung
        SIMTIME         endTime;                        // Ende der Auftragsabarbeitung

        Buff_tail*      outputAreaH;

private:
        int                     no;                                     // Auftragsnummer
        int                     noOfRings;                      // Gesamtzahl von Ringen

        int                     openNumberOfRings;      // Zähler von Ringen, die noch nicht fertig sind

private:
        // request monitoring
        static CustomerRequest* firstRequest;
        CustomerRequest* nextRequest;   // pointer to next request for concatenation

public:
        CustomerRequest(int number, int numberOfRings, 
                                        double diameter, double height, double mass, Treatment* treatment, 
                                        std::string material, Buff_tail* oa);

        int getNumber() const {return no;}
        int getNumberOfRings() const {return noOfRings;}
        int getOpenNumberOfRings() const {return openNumberOfRings;}
        Treatment* getTreatment() const {return treatment;}
        void setNumberOfRings(int n);

protected:
        ~CustomerRequest(); // CustomerRequest may not be deleted

public:
        // Data
        int getRequestNumber() const {return no;}

        // Vergleiche
        bool isCompatibleTo(const CustomerRequest* r);

public:
        // request monitoring
        static CustomerRequest* getFirstRequest() {return firstRequest;}
        static CustomerRequest* getRequest(int number) {
                CustomerRequest* r = getFirstRequest();
                while (r!=0 && r->no!=number) r=r->nextRequest;
                return r;
        }
        const CustomerRequest* getNextRequest() const {return nextRequest;}

        bool isLastRequest() const {return nextRequest==0;}
        bool isDone() const {return openNumberOfRings==0;}

        SIMTIME productionTime() const {return endTime - startTime;}

        // palette done
        void ringFinished();
};


#endif

---