电梯调度算法

经过一系列的讨论，确定了可能要用到的变量

电梯外部的需求信号称为“外召信号”

      内部的需求新号称谓“内召信号”

Fc：当前外召信号所在楼层
Fo-电梯当前所在的楼层
Fm：电梯运行方向上最远的内召目标楼层
Fmax：电梯当前运行方向需要响应的最远楼层

Fmin：电梯反向运行到达的最远楼层
Tr：电梯匀速运行一个楼层所需时间
Ts-电梯在一个楼层的平均停靠时间
N：电梯到达外召楼层所需要响应的召唤总数
N1：电梯在当前运行方向上到达最远内召目标层所需响应的召唤总数
On：电梯当前已登记的停层次数

确定了两个重要的参量时间  TOW()和TOR（）

代码如下：

        int TOW(int Foutside, int Fcurrent, int Fmax, int Fmin, int N, int state) //T1，T2作为常量

        {

            if (state == 0)//外信号与电梯运行方向相同，且在前方



                return System.Math.Abs(Foutside - Fcurrent) * T1 + N * T2;



            else if (state == 1)//外信号与电梯运行方向相同，且在后方



                return (System.Math.Abs(Fmax - Fcurrent) + System.Math.Abs(Fmax - Fmin) + System.Math.Abs(Fmin - Foutside)) * T1 + N * T2;



            else                //外信号与电梯运行反方向相反

                return (System.Math.Abs(Fmax - Fcurrent) + System.Math.Abs(Fmax - Foutside)) * T1 + N * T2;



        }



        int TOR(int Fmax, int Fcurrent, int N)

        {

            return System.Math.Abs(Fmax - Fcurrent) * T1 + N * T2;

        }

约束条件：超载。

public bool isOverLoad(IElevator elev)

        {

            if (elev.FreeCapability < 45)

                return true;

            else

                return false;

        }

设想的相应算法流程如下

(1)读出系统初始化时电梯匀速运行一个楼层所需
时间Tr、电梯在一个楼层的平均停靠时间Ts；
(2)读出当前外召信号所在楼层Fc,
(3)读出各单梯的运行状态：Fo，Fm，Fmax，N，N1，
Qn：
(4)计算出各单梯的TOW(n)，TOR(n)。

算法的主代码：

private void assignReq(IRequest req)

        {

            switch (_Scenario)

            {

                case Scenario.Random:

                    double opt = Double.MaxValue;

                    int optElev = -1;

                    for (int i = 0; i < 4; i++)

                    {

                        int tow = 0;

                        int tor = 0;

                        double time = 0;

                        

                        IElevator elev = _Elevators[i].Elev;

                        Direction direction = elev.CurrentStatus.CurrentDirection == Direction.No ? elev.HistoryDirection : elev.CurrentStatus.CurrentDirection;

                        if (direction == req.UpDown)

                        {

                            if (direction == Direction.Up && elev.CurrentStatus.CurrentHeight < req.DirectionReqSource * floorHeight

                                || direction == Direction.Down && elev.CurrentStatus.CurrentHeight > req.DirectionReqSource * floorHeight)

                            {

                                tow = TOW(req.DirectionReqSource, elev.CurrentStatus.CurrentFloor, 0, 0, _Elevators[i].GetN(req.DirectionReqSource), 0);

                            }



                            if (direction == Direction.Up && elev.CurrentStatus.CurrentHeight > req.DirectionReqSource * floorHeight

                                || direction == Direction.Down && elev.CurrentStatus.CurrentHeight < req.DirectionReqSource * floorHeight)

                            {

                                tow = TOW(req.DirectionReqSource, elev.CurrentStatus.CurrentFloor, _Elevators[i].getMaxCodirFloor(), _Elevators[i].getMaxIndirFloor(), _Elevators[i].GetN(req.DirectionReqSource), 1);

                            }

                        }

                        else

                        {

                            tow = TOW(req.DirectionReqSource, elev.CurrentStatus.CurrentFloor, _Elevators[i].getMaxCodirFloor(), _Elevators[i].getMaxIndirFloor(), _Elevators[i].GetN(req.DirectionReqSource), 2);

                        }

                        

                        tor = TOR(_Elevators[i].getMaxCodistFloor(),elev.CurrentStatus.CurrentFloor,_Elevators[i].GetN(req.DirectionReqSource));

                        time = k1*tor + k2*tow;

                        if (time < opt)

                        {

                            optElev = i;

                            opt = time;

                        }

                    }

                    wrapReq(req, _Elevators[optElev].Elev);

                    break;

                case Scenario.RushHourCome:

                case Scenario.RushHourLeave:

                    break;

            }

        }

可以进行的改进：将情况进行分类

(1)基站上召请求
If基站有空闲梯Then派某空闲梯
Else if有下行的梯Then根据优化算法派出适量台去基站
Else if无下行的梯Then查找上行任务将执行完的若干梯，派去基站
(2)非基站上召请求
If有上行且将经过外召楼层的梯And此梯未满载
{
If有梯在该层有内选Then根据优化算法从中派出最优梯
Else if没有梯在该层有内选Then根据优化算法派出最优梯
)

Else if上行梯全部已过外召层
Then查找下行梯中最快到达基站的梯等待它从基站上来响应(下行梯应尽
量返回基站，不应被上行呼叫截停)
(3)下召请求
If有下行且将经过外召楼层的梯
{
If有梯在该层有内选Then根据多目标优化算法从中派出最优梯
Else if没有梯在该层有内选Then根据多目标优化算法派出最优梯
)
Else查找在上行梯之中响应该呼叫时间最短的梯(已经路过了的下行梯应尽快
返回基站)