solvermulticlosednorm.java

一个用于排队系统仿真的开源软件,有非常形象的图象仿真过程!

			initStatus();
			for (int n = 1; n < tempQueue.length; n++) {
				tempQueue[n] = 0;
				count = 0;
				do {
					status[count] += 1;
					flag = true;
					if (status[count] > population[count]) {
						status[count] = 0;
						count += 1;
						flag = false;
					}
				} while ((count < classes) && !flag);
				for (int k = 0; k < classes; k++) {
					if (status[k] - 1 >= 0) {
						util = visits[stations - 1][k] * (G[n - popMult[k]] / G[n]) * servTime[stations - 1][k][0];
						tempQueue[n] += util * (1 + tempQueue[n - popMult[k]]);
					}
				}
			}
			for (int j = 0; j < classes; j++) {
				throughput[stations - 1][j] = visits[stations - 1][j] * G[G.length - 1 - popMult[j]] / G[G.length - 1];
				if (type[stations - 1] == Solver.LI) {
					utilization[stations - 1][j] = servTime[stations - 1][j][0] * throughput[stations - 1][j];
					queueLen[stations - 1][j] = utilization[stations - 1][j] * (1 + tempQueue[tempQueue.length - 1 - popMult[j]]);
					residenceTime[stations - 1][j] = queueLen[stations - 1][j] / throughput[stations - 1][j];
					scThroughput[stations - 1] += throughput[stations - 1][j];
					scUtilization[stations - 1] += utilization[stations - 1][j];
					clsRespTime[j] = residenceTime[stations - 1][j];
				}

			}
		} else if (type[stations - 1] == Solver.LD) {
			for (int j = 0; j < classes; j++) {
				throughput[stations - 1][j] = visits[stations - 1][j] * G[G.length - 1 - popMult[j]] / G[G.length - 1];

				// calculate FM
				initStatus();
				totPop = 0;
				FM[0] = 1;
				for (int i = 1; i < G.length; i++) {
					count = 0;
					do {
						status[count] += 1;
						flag = true;
						if (status[count] > population[count]) {
							status[count] = 0;
							totPop -= population[count];
							count += 1;
							flag = false;
						} else {
							totPop += 1;
						}
					} while ((count < classes) && !flag);
					sum = 0;
					for (int cls = 0; cls < classes; cls++) {
						if (status[cls] - 1 >= 0)
							sum += visits[stations - 1][cls] * servTime[stations - 1][cls][totPop] * FM[i - popMult[cls]];
					}
					FM[i] = sum;
					//pw.println("FM : " + FM[i] + " at " + i);
					//printStatus(i);
				}

				initStatus();
				totPop = 0;
				for (int i = 1; i < G.length; i++) {
					count = 0;
					do {
						status[count] += 1;
						flag = true;
						if (status[count] > population[count]) {
							status[count] = 0;
							totPop -= population[count];
							count += 1;
							flag = false;
						} else {
							totPop += 1;
						}
					} while ((count < classes) && !flag);
					if (status[j] != 0) {
						margProb = FM[i] * auxFun[G.length - 1 - i] / G[G.length - 1];
						queueLen[stations - 1][j] += margProb * status[j];
						utilization[stations - 1][j] += margProb * status[j] / totPop;
					}
				}
				residenceTime[stations - 1][j] = queueLen[stations - 1][j] / throughput[stations - 1][j];
				scThroughput[stations - 1] += throughput[stations - 1][j];
				scUtilization[stations - 1] += utilization[stations - 1][j];
				clsRespTime[j] = residenceTime[stations - 1][j];
			}
		}

		/* index calculation for all other stations */
		for (int i = (stations - 2); i >= 0; i--) {
			if (type[i] == Solver.LI) {
				initStatus();
				for (int n = 1; n < tempQueue.length; n++) {
					tempQueue[n] = 0;
					count = 0;
					do {
						status[count] += 1;
						flag = true;
						if (status[count] > population[count]) {
							status[count] = 0;
							count += 1;
							flag = false;
						}
					} while ((count < classes) && !flag);
					for (int k = 0; k < classes; k++) {
						if (status[k] - 1 >= 0) {
							util = visits[i][k] * (G[n - popMult[k]] / G[n]) * servTime[i][k][0];
							tempQueue[n] += util * (1 + tempQueue[n - popMult[k]]);
						}
					}
				}
				for (int j = 0; j < classes; j++) {
					throughput[i][j] = visits[i][j] * G[G.length - 1 - popMult[j]] / G[G.length - 1];
					utilization[i][j] = servTime[i][j][0] * throughput[i][j];
					queueLen[i][j] = utilization[i][j] * (1 + tempQueue[tempQueue.length - 1 - popMult[j]]);
					residenceTime[i][j] = queueLen[i][j] / throughput[i][j];
					scThroughput[i] += throughput[i][j];
					scUtilization[i] += utilization[i][j];
					clsRespTime[j] += residenceTime[i][j];
				}
			} else if (type[i] == Solver.LD) {
				calcAuxFun(i);
				for (int j = 0; j < classes; j++) {
					throughput[i][j] = visits[i][j] * G[G.length - 1 - popMult[j]] / G[G.length - 1];

					// calculate FM
					initStatus();
					totPop = 0;
					FM[0] = 1;
					for (int n = 1; n < G.length; n++) {
						count = 0;
						do {
							status[count] += 1;
							flag = true;
							if (status[count] > population[count]) {
								status[count] = 0;
								totPop -= population[count];
								count += 1;
								flag = false;
							} else {
								totPop += 1;
							}
						} while ((count < classes) && !flag);
						sum = 0;
						for (int cls = 0; cls < classes; cls++) {
							if (status[cls] - 1 >= 0)
								sum += visits[i][cls] * servTime[i][cls][totPop] * FM[n - popMult[cls]];
						}
						FM[n] = sum;
						//pw.println("FM : " + FM[n] + " at " + n);
						//printStatus(n);
					}
					initStatus();
					totPop = 0;
					for (int k = 1; k < G.length; k++) {
						count = 0;
						do {
							status[count] += 1;
							flag = true;
							if (status[count] > population[count]) {
								status[count] = 0;
								totPop -= population[count];
								count += 1;
								flag = false;
							} else {
								totPop += 1;
							}
						} while ((count < classes) && !flag);
						if (status[j] != 0) {
							margProb = FM[k] * auxFun[G.length - 1 - k] / G[G.length - 1];
							queueLen[i][j] += margProb * status[j];
							utilization[i][j] += margProb * status[j] / totPop;
						}
					}
					residenceTime[i][j] = queueLen[i][j] / throughput[i][j];
					scThroughput[i] += throughput[i][j];
					scUtilization[i] += utilization[i][j];
					clsRespTime[j] += residenceTime[i][j];
				}
			}
		}
		for (int j = 0; j < classes; j++) {
			clsThroughput[j] = population[j] / clsRespTime[j];
			sysThroughput += clsThroughput[j];
		}
		for (int i = 0; i < stations; i++) {
            scQueueLen[i]=0;
			for (int j = 0; j < classes; j++) {
				scQueueLen[i] += queueLen[i][j];
				scResidTime[i] += residenceTime[i][j] * clsThroughput[j];
			}
			scResidTime[i] /= sysThroughput;
		}
		for (int j = 0; j < classes; j++)
			sysResponseTime += population[j] / sysThroughput;
		/* Generate output */
		pw.println("End of parameters calculation.");
		end = System.currentTimeMillis();
		pw.println("Time elapsed in milliseconds : " + (end - start));
		return;
	}


	/** Calculates the auxiliary function needful to calculate marginal
	 * probabilities
	 * @param center service center for witch it is calculated
	 */
	private void calcAuxFun(int center) {
		double[] FM = new double[G.length];
		double sum = 0;
		int totPop = 0;
		int count = 0;
		boolean flag;

		initStatus();
		FM[0] = 1;
		for (int i = 1; i < G.length; i++) {
			count = 0;
			do {
				status[count] += 1;
				flag = true;
				if (status[count] > population[count]) {
					status[count] = 0;
					totPop -= population[count];
					count += 1;
					flag = false;
				} else {
					totPop += 1;
				}
			} while ((count < classes) && !flag);
			sum = 0;
			for (int j = 0; j < classes; j++) {
				if (status[j] - 1 >= 0)
					sum += visits[center][j] * servTime[center][j][totPop] * FM[i - popMult[j]];
			}
			FM[i] = sum;
			//pw.println("FM : " + FM[i] + " at " + i);
			//printStatus(i);
		}

		initStatus();
		auxFun[0] = 1;
		for (int i = 1; i < G.length - 1; i++) {
			auxFun[i] = 0;
			count = 0;
			do {
				status[count] += 1;
				flag = true;
				if (status[count] > population[count]) {
					status[count] = 0;
					count += 1;
					flag = false;
				}
			} while ((count < classes) && !flag);
			sum = 0;

			int[] newStatus = new int[status.length];
			newStatus[0] = -1;
			for (int c = 1; c < status.length; c++)
				newStatus[c] = 0;

			for (int j = 0; j <= i; j++) {
				count = 0;
				do {
					newStatus[count] += 1;
					flag = true;
					if (newStatus[count] > population[count]) {
						newStatus[count] = 0;
						count += 1;
						flag = false;
					}
				} while ((count < classes) && !flag);
				if (validStatus(newStatus))
					sum += FM[j] * auxFun[i - j];
			}
			auxFun[i] = G[i] - sum;
			//pw.println("Auxil Function : " + auxFun[i] + " at " + i);
			//printStatus(i);
		}
		//pw.println("Auxil Function : " + auxFun[G.length -1] + " at " + name[center]);
	}

	/*Reinitializes the status variable*/
	private final void initStatus() {
		System.arraycopy(intZeros, 0, status, 0, intZeros.length);
	}

	/* calculates the actual status*/
	private final void calcStatus(int pos) {
		for (int i = (classes - 1); i >= 0; i--) {
			status[i] = pos / popMult[i];
			pos = pos - (status[i] * popMult[i]);
		}
	}

	/** Prints the actual status of the system: it's a debug function
	 */
	public void printStatus() {
		for (int i = 0; i < classes; i++) {
			pw.print(status[i]);
			pw.print(" ");
		}
		pw.print("\n");
	}

	/** Prints the actual status of the system:it's a debug function
	 * @param pos the actual position
	 */
	public void printStatus(int pos) {
		calcStatus(pos);
		printStatus();
	}

	/*returns true if the status is valid(p.e. population < 0)*/
	private final boolean validStatus(int[] ns) {
		for (int i = 0; i < status.length; i++) {
			if (status[i] - ns[i] < 0)
				return false;
		}
		return true;
	}


}