Dr Richard Peters, Peters Research Ltd
This paper was presented at ELEVCON ZURICH 1998, The International Congress on Vertical Transportation Technologies and first published in the IAEE book “Elevator Technology 9”, edited by G. C. Barney. It is reproduced with permission from The International Assocication of Elevator Engineers. The paper was republished by Elevatori January/February 1999. This web version © Peters Research Ltd 2009.
Elevate is a development platform for elevator control systems and an advanced elevator traffic analysis tool. The program is written in the C++ language using the latest object oriented programming techniques, and has a Microsoft Windows[TM] user interface. Passengers are generated automatically from arrival rates entered by the user. The elevators answer passenger calls as directed by the selected dispatcher algorithm. An analysis of passenger waiting and transit times is given. Elevate applies research in ideal elevator kinematics giving total control of elevator speed profiles.
Elevate is a development platform for elevator control systems and an advanced elevator traffic analysis tool. Elevate’s features and functions include:
In this paper we will review how Elevate is designed using object oriented technology, give an overview of its interface, and discuss some applications.
(Windows is a registered trademark of the Microsoft Corporation.)
Traditional structural programming techniques break a program into several smaller tasks by defining a set of functions. Object oriented programming (OOP) builds on structured programming techniques by introducing objects. The variables and functions of an object are defined by the class to which it belongs.
Figure 1 Ginger the cat graphic from 
For an example of how OOP is mimicking the real world, consider Ginger the cat in Figure 1.
The world has a class cat. Everything in the cat class has a set of the same variables (no of paws, age, sex, etc.) and a range of functions (if you chase it, it runs; if you pat it, it purrs). “Ginger” is an object, and an instance of the cat class. He has all the functions and variables of a cat.
Once a class is defined, its complexities are hidden, so we can create and apply objects simply. In this way OOP helps break down complex problems into manageable parts that are easy to work with as they represent familiar ideas or components.
Applying this approach, consider a circle class with a radius variable r, and functions CalculateArea() and DrawCircle(). Here is an extract of a C++ application using the circle class (the functionality of which has been defined elsewhere):
//(double lines precede comments)
//create a circle object, called “cir” with a radius r circle cir(r);
//display the circle’s area cout << “The area is ” << cir.CalculateArea();
//draw the circle on the screen cir.DrawCircle();
Returning to elevators, we can define the class elevator with variables such as capacity and speed, and functions such as StartJourney(). We can create as many elevator objects as we need; each elevator object is independent, but may use all the variables and functions defined by the class.
Elevate has six main classes which it uses to implement a simulation. They are:
Elevate’s interface is Windows based, and allows the user to edit all the system data in dialog boxes containing standard Windows controls (radio buttons, drop downs, etc.), and a spreadsheet-like control for tabular data entry. The program uses a multi-document interface, so the user can be working on a number of different simulations at the same time. In addition to the standard Windows features (save, print, etc.) there are five data entry dialog boxes which can be accessed via the menus or button bar:
Figure 3 Examples of data entry dialog boxes
The passenger generator uses the traffic class to create passengers (person objects) in software based on the Passenger data entered by the user.
The program then performs a time slice simulation; it calculates the status (position, speed, etc.) of the elevators, increments the time, re-calculates status, increments time, and so on. Provided that there are not too many other demands on the computer’s processor, the simulation will run faster than real time on a Pentium PC using a time slice of 0.01 seconds.
The main area of the screen is used to give a visual display of the simulation as shown in Figure 4. The user can zoom in/out of this display using buttons on the Toolbar.
Figure 4 Simulation display
Elevators are displayed according to their current position and door status:
Indicates that the elevator’s doors are fully closed.
Indicates that the elevator’s doors are opening or closing.
Indicates that the elevator’s doors are fully open.
Landing and car calls are displayed according to their status:
Red arrows indicate which up and down landing calls have been registered by waiting passengers at each floor.
Red squares indicate car calls registered by the passengers travelling in each elevator. Car calls are aligned with the floors for which they are registered.
P Indicates a parking call used to re-locate an “idle” car (used in up peak algorithms).
The current direction, position, speed and load is displayed above each elevator. The number of passengers queuing is displayed at each floor.
Once the simulation is complete, a print preview of the data and results are displayed as shown in Figure 5. Results include:
The object oriented nature of Elevate makes it relatively straightforward to design new control systems by revising the dispatch object.
The dispatch object has to review new landing calls, and allocate them to an appropriate elevator. The elevators can be queried to find out their position, direction of travel, load, etc. For example, given an array of elevator objects, e
//the current position (m above reference) of elevator 2 is e.m_CurrentPosition;
//the direction (where -1 down, 0 none, 1 up) of elevator 2 is e.m_Direction;
//this allocates an up landing call to elevator 2 for floor 5 e.m_UpLandingCalls=1;
Once calls have been allocated to an elevator, the elevator will answer the landing calls in the right order, and accept car calls from the passengers. These and all the other features of Elevate are available to the new control system without additional programming.
The result of this approach is that new control systems can be implemented in Elevate in as little as 300 lines of software code.
Elevate has been used to develop and test a range of control systems. Its application in the research and development of energy saving, green elevator control systems is discussed in .
Elevate can be used to analyse the elevator performance of all building types including offices, hotels, hospitals, shopping centers, flats, warehouses, etc. Unlike conventional “up peak” round trip time calculations, you are not restricted to passengers loading at the ground floor; all types of passenger and goods loads can travel between all floors.
An example print out of data/results in Appendix 1 shows how Elevate can be used to model the performance of a elevator system in a shopping center. Note that in a shopping center:
Elevate has been designed as a development platform for elevator control systems and as an advanced traffic analysis tool.
Elevate is written in Microsoft Visual C++. It uses object oriented techniques, breaking down the programming tasks into classes. These classes represent objects (e.g. elevator, person, building) which are straight forward to conceptualise, and therefore easier to work with.
The interface is Windows based. The user enters data about the system into dialog boxes titled: Building data, Elevator data, Passenger data, Simulation data and Job data.
The program performs a time slice simulation, providing a graphical representation of the elevators as they serve the passenger calls. Once the simulation is complete, Elevate displays results on screen in a print preview format. These results include details of input data, waiting times and transit times.