circlesim.java

Traffic Circle交通系统的仿真程序

//
//  CircleSim.java
//  CircleSim
//
//  Created by Xonix on 2/7/09.
//  Copyright (c) 2009 __MyCompanyName__. All rights reserved.
//

//import java.util.*;
import java.io.*;
import java.util.Vector;
//import java.util.Formatter;
import java.lang.Math;

public class CircleSim 
{
	Circle myCircle;
	double simTime;
	Vector carPool;
	InstantStatistics inStat;
	LongTermStatistics ltStat;
	Strategy wise;
	int[]  ns;
	
  public static void main (String args[]) 
	{
        //System.out.println("Circle Traffic Simulation\n");
		
		new CircleSim();
	}
	
	CircleSim()
	{
		myCircle = new Circle();
		carPool = new Vector();
		inStat = new InstantStatistics(myCircle.nJ);
		ltStat = new LongTermStatistics();
		wise = new Strategy(myCircle.nJ);
		ns = new int[myCircle.nJ];
		
		try{
			StreamTokenizer icTok = new StreamTokenizer(
				new BufferedReader(new FileReader(Const.INCOME_SPEC_FILE)));
			icTok.parseNumbers(); 
		
			StreamTokenizer carTok = new StreamTokenizer(
				new BufferedReader(new FileReader(Const.CAR_SPEC_FILE)));
			carTok.parseNumbers();
		
			simTime = Const.TIME_START;
			
			// simulation loop
			double ts = Const.TIME_STOP;
			while(simTime < ts)
			{
				loadCar(icTok, carTok);
				//generate new state of sign here
//				for(int i = 0; i < myCircle.nJ; i++)
//					ns[i] = 1;
				
				// fuzzyLogic
//				if(wise.fuzzyLogic(inStat, ns, simTime))
//					setSign(ns);
//				else
//					setSign(null);

				runTraffic();
				getStatistics();
				printStatistics();
			
				simTime += Const.TIME_INC;
			}
			
			ltStat.print();
			
		}catch(IOException e)
		{
			System.out.println(e.toString());
			System.exit(-1);
		}
	}
	
	void loadCar(StreamTokenizer ictok, StreamTokenizer carTok) throws IOException
	{
		for(int i = 0; i < myCircle.nJ; i++)
		{
			ictok.nextToken(); int nc = (int)ictok.nval;
			inStat.nArr[i] = nc;
			for(int j = 0; j < nc; j++)
			{
				carTok.nextToken(); int g = (int)carTok.nval;
				
//				if(j == 0) 
//					System.out.print(simTime + "J" + i + ":\t");
//				System.out.print(g + "\t");
//				if(j == nc - 1)
//					System.out.print("\n");

				Car newCar = new Car(myCircle.jc[i], myCircle.jc[g], simTime);
				carPool.add(newCar);
				myCircle.jc[i].addIncomingCar(newCar);
			}
		}
	}
	
	void setSign(int[] newSign)
	{
		if(newSign != null)
			for(int i = 0; i < myCircle.nJ; i++)
				{ myCircle.jc[i].sgn = newSign[i];}
	}
	
	void runTraffic()
	{
		// run the cars
		for(int i = 0; i < carPool.size(); i++)
		{
			Car car = (Car) carPool.elementAt(i);
			if(car.state == 1) // running
			{
				// check if reach any junction
				double nextPos = Tools.unifyRad(car.pos + car.v * Const.TIME_INC / myCircle.r);
				int j = passingJunc(nextPos, car.sid);
				if( j != -1)
				{
					Junction junc = myCircle.jc[j];
					Sector sec = myCircle.sc[(j - 1 + myCircle.nJ) % myCircle.nJ];
					if(car.to.id != j)
					{ // next time the car may pass the junction
						if(sec.q.size() > 0)
						{ // previous car already in the queue, so it also gets in the queue
							sec.enterQue(car);
						}
						else
						{ // no waiting queue on the sector, so check the sign
							double rnd = Math.random();
							if(junc.sgn == 1 || (junc.sgn == 0 && rnd > 0.5))
							{ // stop
									if(junc.iq.size() == 0 && myCircle.sc[j].inCap > 1 &&
										myCircle.sc[j].Cap - myCircle.sc[j].nCar > 1) 
									{// no incoming car at this junction
									 // and next sector is available
										sec.nCar--;
										car.sid = j;
										car.pos = nextPos;
										
										myCircle.sc[j].nCar++;
										myCircle.sc[j].inCap -= 1;
									}
									else
									{
										sec.enterQue(car);
									}
							}
							else if(junc.sgn == 2 || junc.sgn == 4 || (junc.sgn == 0 && rnd < 0.5))
							{ // yield or green
									if(myCircle.sc[j].inCap >1 && myCircle.sc[j].Cap - myCircle.sc[j].nCar > 1)
									{
										sec.nCar--;
										car.sid = j;
										car.pos = nextPos;
										
										myCircle.sc[j].nCar++;
										myCircle.sc[j].inCap -= 1;
									}
									else
									{
										sec.enterQue(car);
									}
							}
							else if(junc.sgn == 3)
							{ // red
									sec.enterQue(car);
							}
						}
					}
					else
					{ //next junction is the goal of the car
						sec.enterQue(car);
					}
				}
				else car.pos = nextPos;
			}
		}
		
		// out-going
		outGoing();
		
		// what happens in the junction
		for(int i = 0; i < myCircle.nJ; i++)
		{
			int j = (i - 1 + myCircle.nJ) % myCircle.nJ; // the previous sector id;
			switch(myCircle.jc[i].sgn)
			{
				case 1: //stop
					incoming(i);
					cycling(j);
					break;
				case 2: //yield
					cycling(j);
					incoming(i);
					break;
				case 3: //red
					incoming(i);
					break;
				case 4: //green
					cycling(j);
					break;
				default: //free
					if(Math.random() > 0.5)
					{
						incoming(i);
						cycling(j);
					}
					else
					{
						cycling(j);
						incoming(i); 
					}
					break;
			}
		}
	
		// update cars
		for(int i = carPool.size() - 1; i >= 0; i--)
		{
			Car car = (Car) carPool.elementAt(i);
			if(car.state == 2) // destroy
			{
				ltStat.carCount++;
				ltStat.totalDelay += (car.tExit - car.tEnter) - 
						(Tools.angleDis(car.from.pos, car.to.pos) / Const.SECTOR_TOP_SPEED);
				carPool.removeElementAt(i);
			}
			else if(car.state == 1) // running
			{
				car.v = myCircle.sc[car.sid].v;
			}
			else // waiting
			{
				car.cu.update();
			}
		}
		
		// update sectors and junctions
		for(int i = 0; i < myCircle.nJ; i++)
		{
			myCircle.sc[i].update();
			myCircle.jc[i].update();
		}

	}
	
	int passingJunc(double pos, int sid)
	{
		Junction junc = myCircle.jc[ (sid + 1) % myCircle.nJ ];
		double d = Tools.angleDis(junc.pos, pos) * myCircle.r;
		if(d < myCircle.sc[junc.id].len)
			return junc.id;
		else
			return -1;
	}

	void cycling(int sec)
	{
		Sector cur = myCircle.sc[sec],
			   next = myCircle.sc[(sec + 1) % myCircle.nJ];
		
		double iCap = next.inCap;
		
		boolean flag = true;
		while(iCap > 1 && next.Cap - next.nCar > 1 && flag)
		{
			flag = false;
			for(int i = 0; i < cur.q.size() && i < myCircle.nL; i++)
			{
				Car car = (Car) cur.q.elementAt(i);
				if(car.to.id != next.id)
				{
					cur.q.removeElementAt(i);
					cur.nCar--;
					cur.cu.modInc(-Const.TIME_INC);
					cur.cu.mod(-car.cu.getCWT());
					car.state = 1; // running;
					car.sid = next.id;
					car.pos = Tools.unifyRad(myCircle.jc[next.id].pos + Const.EPS_LENGTH / myCircle.r);
					next.nCar++;
					iCap -= 1;
					flag = true;
					break;
				}
			}
		}
		next.inCap = iCap;
	}
	
	void incoming(int jid)
	{
		Junction junc = myCircle.jc[jid];
		Sector	sec = myCircle.sc[jid];
		
		double iCap = sec.inCap;
		boolean flag = true;
		while(iCap > 1 && sec.Cap - sec.nCar > 1 && flag)
		{
			flag = false;
			for(int i = 0; i < junc.iq.size() && i < junc.nL; i++)
			{
				Car car = (Car) junc.iq.elementAt(i);
				junc.iq.removeElementAt(i);
				junc.cu.modInc(-Const.TIME_INC);
				junc.cu.mod(-car.cu.getCWT());
				car.pos = Tools.unifyRad(car.pos + Const.EPS_LENGTH / myCircle.r);
				car.state = 1;  // running;
				car.sid = junc.id;
				sec.nCar++;
				iCap -= 1;
				flag = true;
				break;
			}
		}
		sec.inCap = iCap;
	}
	
	void outGoing()
	{
		for(int i = 0;  i < myCircle.nJ; i++)
		{
			double oCap = myCircle.jc[(i + 1) % myCircle.nJ].outCap;
			boolean flag = true;
			while(myCircle.sc[i].q.size() > 0 && oCap > 1 && flag)
			{
				flag = false;
				for(int j = 0; j < myCircle.sc[i].q.size() && j < myCircle.nL; j++)
				{
					Car car = (Car) myCircle.sc[i].q.elementAt(j);
					if(car.to.id == (i + 1) % myCircle.nJ)
					{
						car.tExit = simTime;
						car.state = 2; // destroyed;
						myCircle.sc[i].q.removeElementAt(j);
						myCircle.sc[i].nCar -= 1;
						myCircle.sc[i].cu.modInc(-Const.TIME_INC);
						myCircle.sc[i].cu.mod(-car.cu.getCWT());
						oCap -= 1;
						flag = true;
						break;
					}
				}
			}
			myCircle.jc[(i+1) % myCircle.nJ].outCap = oCap;
		}
	}
	
	//void getStatistics()
//	{
//		System.out.println("=====================================================\n");
//		System.out.println("TIME: " + simTime);
//		// Juntion index
//		System.out.print("\t\t\t\t");
//		for(int i = 0; i < myCircle.nJ; i++)
//		{	
//			System.out.print("J" +i + "\t\t" + "S" +i + "\t\t"); 
//		}
//		System.out.print("\n");
//		
//		// arrival count
//		System.out.print("ARRIVAL:\t\t");
//		for(int i = 0; i < myCircle.nJ; i++)
//		{	
//			System.out.print(inStat.nArr[i] + "\t\t\t\t"); 
//		}
//		System.out.print("\n");
//		
//		// number of cars on each sector
//		System.out.print("CAR COUNT:\t\t");
//		for(int i = 0; i < myCircle.nJ; i++)
//		{	
//			inStat.niq[i] = myCircle.jc[i].iq.size();
//			inStat.nCar[i] = myCircle.sc[i].nCar;
//			System.out.print("\t\t" + inStat.nCar[i] + "\t\t"); 
//		}
//		System.out.print("\n");
//		
//		// incoming queue size
//		System.out.print("Q_SIZE:\t\t");
//		for(int i = 0; i < myCircle.nJ; i++)
//		{	
//			inStat.niq[i] = myCircle.jc[i].iq.size();
//			inStat.nsq[i] = myCircle.sc[i].q.size();
//			System.out.print(inStat.niq[i] + "\t\t" + inStat.nsq[i] + "\t\t"); 
//		}
//		System.out.print("\n");
//		
//		// sector speed
//		System.out.print("Sector V:\t\t");
//		for(int i = 0; i < myCircle.nJ; i++)
//		{	
//			inStat.secV[i] = myCircle.sc[i].v;
//			System.out.print("\t\t" + (int) inStat.secV[i] + "\t\t"); 
//		}
//		System.out.print("\n");
//		
//		// CWT
//		System.out.print("QUEUE CWT:\t\t");
//		for(int i = 0; i < myCircle.nJ; i++)
//		{	
//			inStat.jCWT[i] = myCircle.jc[i].cu.getCWT();
//			inStat.sCWT[i] = myCircle.sc[i].cu.getCWT();
//			System.out.print((int) inStat.jCWT[i] + "\t\t" + (int) inStat.sCWT[i] + "\t\t"); 
//		}
//		System.out.print("\n");
//		
//		// CWT
//		System.out.print("SIGNAL:\t\t");
//		for(int i = 0; i < myCircle.nJ; i++)
//		{	
//			System.out.print(myCircle.jc[i].sgn + "\t\t\t\t"); 
//		}
//		System.out.print("\n");
//				
////		// outgoing queue size
////		System.out.print("OUTQUE:\t\t");
////		for(int i = 0; i < myCircle.nJ; i++)
////		{	
////			inStat.noq[i] = myCircle.jc[i].oq.size();
////			System.out.print(inStat.noq[i] + "\t\t"); 
////		}
////		System.out.print("\n");
//	}

	void printStatistics()
	{
		System.out.println("=====================================================\n");
		System.out.println("TIME: " + simTime);
		// Juntion index
		System.out.print("\t\t\t\t");
		for(int i = 0; i < myCircle.nJ; i++)
		{	
			System.out.print("J" +i + "\t\t" + "S" +i + "\t\t"); 
		}
		System.out.print("\n");
		
		// arrival count
		System.out.print("ARRIVAL:\t\t");
		for(int i = 0; i < myCircle.nJ; i++)
		{	
			System.out.print(inStat.nArr[i] + "\t\t\t\t"); 
		}
		System.out.print("\n");
		
		// number of cars on each sector
		System.out.print("CAR COUNT:\t\t");
		for(int i = 0; i < myCircle.nJ; i++)
		{	
			System.out.print("\t\t" + inStat.nCar[i] + "\t\t"); 
		}
		System.out.print("\n");