Plurk paste

/////////////////////////////////////////////////////////////////////
// DESP-C++ (Discrete-Event Simulation Package)
// Version 1.1, February 1998
// Jerome Darmont
// LIMOS, Blaise Pascal University (Clermont-Ferrand II), France
/////////////////////////////////////////////////////////////////////
// eventc.h: Event Manager classes definition
// Variable with simulated systems
/////////////////////////////////////////////////////////////////////
#include <vector>

using namespace std;
// Active resources declaration
class PatientInfo;
class Secretary;
class HoldingNurse;
class Pass;
class PatientCareSupport;
class PreopRoom;
class CirclingNurse;
class CirclingNurseHeart;
class ScrubTech;
class ScrubTechHeart;
class PA;
class PAHeart;
class Anesthesiologist;
class ORs;
class Doctor;
class RecoveryRoomLevel1;
class RecoveryRoomLevel2;

/////////////////////////////////////////////////////////////////////
// CLASS EventManager
/////////////////////////////////////////////////////////////////////
// Simulation events management
/////////////////////////////////////////////////////////////////////

// The Event Manager must "know" all (active and passive) resources.

class EventManager 
{

  public:

    // Methods

    EventManager(Simulation *sim, int *, int, int);      // Constructor
    ~EventManager();                    // Destructor
    void ExecuteEvent(int code, Client *client); // Event execution
    void Init();                        // Initialization
    void InitRep();                     // Replication initialization 
    void Stats();                       // Stats computation (end of replication)
    void DisplayStats();                // Statistics display

	void SaveResult();						// save result to txt file
	int GetNumCustomerOut();				// Return number of customers out of system
	double GetReplicSumLOS();
	
  private:
	  int *SaveResCap, NumCustomerOut, GetNumOfDoctor, GetNumOfOR;
	  double ReplicSumLOS;

    // Attributes

    Simulation *simul;                  // Pointer toward simulation object

    // Passive resources
    // E.g. Resource *pr;

    // Active resources
	PatientInfo *PatientInfo_obj;
	Secretary *Secretary_obj;
	HoldingNurse *HoldingNurse_obj;
	Pass *Pass_obj;
	PatientCareSupport *PatientCareSupport_obj;
	PreopRoom *PreopRoom_obj;
	CirclingNurse *CirclingNurse_obj;
	CirclingNurseHeart *CirclingNurseHeart_obj;
	ScrubTech *ScrubTech_obj;
	ScrubTechHeart *ScrubTechHeart_obj;
	PA *PA_obj;
	PAHeart *PAHeart_obj;
	Anesthesiologist *Anesthesiologist_obj;

	vector<ORs> ORList;
	ORs *ORs_obj;
	vector<Doctor> DoctorList;
	Doctor *Doctor_obj;

	RecoveryRoomLevel1 *RecoveryRoomLevel1_obj;
	RecoveryRoomLevel2 *RecoveryRoomLevel2_obj;
};

/////////////////////////////////////////////////////////////////////
// CLASS Client
/////////////////////////////////////////////////////////////////////
// Custom simulation entity
/////////////////////////////////////////////////////////////////////

class Client 
{
  public:
           // Add here (in public) additional attributes

           Client *next;
           Client *previous;

		   double PatArrivalTime, PatSurgeryTime;
		   int PatORNum, PatDocNum;
		   bool Heart;

		   int LevelControl;
};
//==================================
// class PatientInfo	// dummy resource
//==================================
class PatientInfo: public Resource
{
	public:
		PatientInfo(char n[STRS], int cap, Simulation *sim);	// read patient data
		~PatientInfo();

		void Event0(Client *client);	// initial new a client
		void Event1(Client *client);	// new clients
	
	private:	
		double *ArrivalSchedule, *SurgerySchedule;
		int *ORNum, *DoctorNum;
		bool *ForHeart;
};
//==================================
// class Secretary
//==================================
class Secretary: public Resource
{
	public:
		Secretary(char n[STRS], int cap, Simulation *sim);
		~Secretary();

		void Event100(Client *client);	// seize a secretary
		void Event101(Client *client);	// registration process
		void Event102(Client *client);	// release a secretary
		
	private:
};
//==================================
// class Pass
//==================================
class Pass: public Resource
{
	public:
		Pass(char n[STRS], int cap, Simulation *sim);
		~Pass();

		void Event103(Client *client);	// seize pass
		void Event104(Client *client);	// pre-admission process
		void Event105(Client *client);	// release pass
		
	private:
};
//==================================
// class PatientCareSupport
//==================================
class PatientCareSupport: public Resource
{
	public:
		PatientCareSupport(char n[STRS], int cap, Simulation *sim);
		~PatientCareSupport();

		void Event106(Client *client);	// seize a patient care support
		void Event107(Client *client);	// route from bathroom to pre-operating
		void Event108(Client *client);	// release a patient care support
		
	private:
		
};
//==================================
// class PreopRoom
//==================================
class PreopRoom: public Resource
{
	public:
		PreopRoom(char n[STRS], int cap, Simulation *sim);
		~PreopRoom();
		void Event200(Client *client);	// seize a pre-operating room
		void Event204(Client *client);	// release a pre-operating room
		
	private:
		
};
//==================================
// class HoldingNurse
//==================================
class HoldingNurse: public Resource
{
	public:
		HoldingNurse(char n[STRS], int cap, Simulation *sim);
		~HoldingNurse();

		void Event201(Client *client);	// seize a holding nurse
		void Event202(Client *client);	// pre-operating process
		void Event203(Client *client);	// release a holding nurse
		
		void Event402(Client *client);	// seize a holding nurse
		void Event406(Client *client);	// release a holding nurse
		
	private:
		
};
//==================================
// class Anesthesiologist
//==================================
class Anesthesiologist: public Resource
{
	public:
		Anesthesiologist(char n[STRS], int cap, Simulation *sim);
		~Anesthesiologist();
		void Event205(Client *client);	// seize an anesthesiologist
		void Event207(Client *client);	// Delay Surgery Wait
		void Event208(Client *client);	// route from pre-operating to OR
		void Event404(Client *client);	// release an anesthesiologist
		
	private:
		
};
//==================================
// class CirclingNurse
//==================================
class CirclingNurse: public Resource
{
	public:
		CirclingNurse(char n[STRS], int cap, Simulation *sim);
		~CirclingNurse();
		void Event206(Client *client);	// seize a circling nurse
		void Event310(Client *client);	// route from OR to recorvery
		void Event400(Client *client);	// release a circling nurse
		
	private:
		
};
//==================================
// class CirclingNurseHeart
//==================================
class CirclingNurseHeart: public Resource
{
	public:
		CirclingNurseHeart(char n[STRS], int cap, Simulation *sim);
		~CirclingNurseHeart();
		void Event206(Client *client);	// seize a circling nurse
		void Event310(Client *client);	// route from OR to recorvery
		void Event400(Client *client);	// release a circling nurse
		
	private:
		
};
//==================================
// class ORs
//==================================
class ORs: public Resource
{
	public:
		ORs(char n[STRS], int cap, Simulation *sim);
		~ORs();
		void Event300(Client *client);	// seize an operating room
		void Event309(Client *client);	// release an operating room

	private:

};
//==================================
// class ScrubTech
//==================================
class ScrubTech: public Resource
{
	public:
		ScrubTech(char n[STRS], int cap, Simulation *sim);
		~ScrubTech();
		void Event301(Client *client);	// seize a scrub tech
		void Event302(Client *client);	// sedate patient process
		void Event308(Client *client);	// release a scrub tech
		
	private:
		
};
//==================================
// class ScrubTechHeart
//==================================
class ScrubTechHeart: public Resource
{
	public:
		ScrubTechHeart(char n[STRS], int cap, Simulation *sim);
		~ScrubTechHeart();
		void Event301(Client *client);	// seize a scrub tech
		void Event302(Client *client);	// sedate patient process
		void Event308(Client *client);	// release a scrub tech
		
	private:
		
};
//==================================
// class PA
//==================================
class PA: public Resource
{
	public:
		PA(char n[STRS], int cap, Simulation *sim);
		~PA();
		void Event303(Client *client);	// seize a PA
		void Event307(Client *client);	// release a PA
		
	private:
		
};
//==================================
// class PAHeart
//==================================
class PAHeart: public Resource
{
	public:
		PAHeart(char n[STRS], int cap, Simulation *sim);
		~PAHeart();
		void Event303(Client *client);	// seize a PA
		void Event307(Client *client);	// release a PA
		
	private:
		
};
//==================================
// class Doctor
//==================================
class Doctor: public Resource
{
	public:
		Doctor(char n[STRS], int cap, Simulation *sim);
		~Doctor();
		void Event304(Client *client);	// seize a doctor
		void Event305(Client *client);	// operation process
		void Event306(Client *client);	// release a doctor

	private:
		RNG RandomDistribution;

};
//==================================
// class RecoveryRoomLevel1
//==================================
class RecoveryRoomLevel1: public Resource
{
	public:
		RecoveryRoomLevel1(char n[STRS], int cap, Simulation *sim);
		~RecoveryRoomLevel1();
		void Event401(Client *client);	// seize a recovery room
		void Event403(Client *client);	// patient stablized process
		void Event405(Client *client);	// recovery process
		void Event407(Client *client);	// release a recovery room
		void Event408(Client *client);	// dispatch process
		void Event409(Client *client);	// dispatch patient
		
	private:
		
};
//==================================
// class RecoveryRoomLevel2
//==================================
class RecoveryRoomLevel2: public Resource
{
	public:
		RecoveryRoomLevel2(char n[STRS], int cap, Simulation *sim);
		~RecoveryRoomLevel2();
		void Event401(Client *client);	// seize a recovery room
		void Event403(Client *client);	// patient stablized process
		void Event405(Client *client);	// recovery process
		void Event407(Client *client);	// release a recovery room
		void Event408(Client *client);	// dispatch patient
		
	private:
		
};