gspn.java

来自「Petri网分析工具PIPE is open-source」· Java 代码 · 共 1,440 行 · 第 1/4 页

		//check if there are any potential transitions from marking 1 to marking 2 - if not return probability 0	
		boolean hasAChance = false;
		for (int i = 0; i < transCount; i++) {	
			if (matchingTransition[i] == true){
				hasAChance = true;	
			}
		}
		if (hasAChance == false) {
			return 0.0;
		}
		//*****************************************************************************************************
		//if a transition is needed to get to marking 2 but isn't enabled at marking 1, return probability 0
		boolean enabledAndMatching = false;
		for (int i = 0; i <transCount; i++) {	
			if ((matchingTransition[i] == true) && (marking1EnabledTransitions[i] == true)) {
				enabledAndMatching  = true;	
			}
		}
		if (enabledAndMatching = false) {
			return 0.0;
		}
		//******************************************************************************************************	
		//work out the sum of firing weights of input transitions
		double candidateTransitionWeighting = 0.0;
		for (int i = 0; i < transCount; i++) {
			if((matchingTransition[i] == true) && (marking1EnabledTransitions[i] == true)){
				candidateTransitionWeighting += pnmlData.getTransitions()[i].getRate(); 	
			}
		}
		//*****************************************************************************************************	
		//work out the sum of firing weights of enabled transitions
		double enabledTransitionWeighting = 0.0;
		for (int i = 0; i < transCount; i++) {
			if (marking1EnabledTransitions[i] == true) {
				enabledTransitionWeighting += pnmlData.getTransitions()[i].getRate();
			}
		}
		return (candidateTransitionWeighting/enabledTransitionWeighting);			
	}
		
//######################################################################################################################
	//This function is used to generate E-twiddle, the matrix specifying the rates for a specific state change leaving
	//a tangible Mi and entering a vanishing state Mj.
	private double getRateForSpecificStateChange(DataLayer pnmlData, int[] marking1, int[] marking2) {
		int markSize = marking1.length;
		int[][] incidenceMatrix = pnmlData.getIncidenceMatrix();
		int transCount = pnmlData.getTransitions().length;
		boolean[] marking1EnabledTransitions = new boolean[transCount];// = getTransitionEnabledStatus(pnmlData, marking1); //get list of transitions enabled at marking1
		boolean[] matchingTransition = new boolean[transCount];
		for (int i = 0; i <transCount; i++) {
			marking1EnabledTransitions[i] = getTransitionEnabledStatus(pnmlData, marking1, i);
		}
		
		//**************************************************** *************************************************
		for (int j = 0; j <transCount; j ++) {
			matchingTransition[j] = true;  //initialise matrix of potential transition values to true
		}
		//*****************************************************************************************************
		//get transition needed to fire to get from marking1 to marking2
		for (int i = 0; i < transCount; i++) {
			for (int k = 0; k <markSize; k++) {
				//if the sum of the incidence matrix and marking 1 doesn't equal marking 2, 
				//set that candidate transition possibility to be false 
				if (((int)marking1[k] + (int)incidenceMatrix[k][i])!= (int)marking2[k]){
					matchingTransition[i] = false;
				}
			}
		}
		//if the state is tangible, all transitions will be timed, 
		//so all can be considered in the probability calculation.
		//Otherwise, reset the enabled status of timed transitions to false, as immediate transitions
		//will always fire first.
		
		if (isTangibleState(pnmlData, marking1)== false) { 
			for (int i = 0; i <transCount; i++) {
				if (pnmlData.getTransitions()[i].getTimed() == true) {
					marking1EnabledTransitions[i] = false;
				}
			}
		}
		//*****************************************************************************************************
		//check if there are any potential transitions from marking 1 to marking 2 - if not return probability 0	
		boolean hasAChance = false;
		for (int i = 0; i < transCount; i++) {	
			if (matchingTransition[i] == true){
				hasAChance = true;	
			}
		}
		if (hasAChance == false) {
			return 0.0;
		}
		//*****************************************************************************************************
		//if a transition is needed to get to marking 2 but isn't enabled at marking 1, return probability 0
		boolean enabledAndMatching = false;
		for (int i = 0; i <transCount; i++) {	
			if ((matchingTransition[i] == true) && (marking1EnabledTransitions[i] == true)) {
				enabledAndMatching  = true;	
			}
		}
		if (enabledAndMatching = false) {
			return 0.0;
		}
		//******************************************************************************************************	
		//work out the sum of firing weights of input transitions
		double candidateTransitionWeighting = 0.0;
		for (int i = 0; i < transCount; i++) {
			if((matchingTransition[i] == true) && (marking1EnabledTransitions[i] == true)){
				candidateTransitionWeighting += pnmlData.getTransitions()[i].getRate(); 	
			}
		}
		
		return candidateTransitionWeighting;
		
		
	}
//######################################################################################################################
	//This function generates a matrix of e-twiddles - used in calculation of throughput.
	private double[][] rateMatrix(DataLayer pnmlData, StateList list1, StateList list2) {
		int rows = list1.size();
		int cols = list2.size();
		double[][] result = new double[rows][cols];
		for (int i = 0; i<rows; i++){
			for (int j = 0; j < cols; j++){
				result[i][j] = getRateForSpecificStateChange(pnmlData, list1.get(i),list2.get(j));
			}
		}
		return result;
	}
	
//######################################################################################################################
	//This function works out the throughput of an immediate transition for a vanishing state.
	private double getVanishingStateThroughput (DataLayer pnmldata, StateList list1, int transitionNumber, Matrix rateForSpecificState) {
		int length = list1.size();
		double result = 0;
		
		for (int i = 0; i< length; i++){
			double enabledTransitionRates = 0;
			double specifiedTransitionRate = 0;
			boolean[] transStatus = getTangibleTransitionEnabledStatusArray(pnmldata, list1.get(i));
			if (transStatus[transitionNumber]==true){
				int transCount = transStatus.length;
				for (int j = 0; j<transCount; j++){
					if (transStatus[j]==true){
						enabledTransitionRates += pnmldata.getTransitions()[j].getRate();
					}
				}
				specifiedTransitionRate = pnmldata.getTransitions()[transitionNumber].getRate();
				result+= (specifiedTransitionRate/enabledTransitionRates)*rateForSpecificState.get(0,i);
			}
			
		}
		return result;
	}
	
//######################################################################################################################
	
	private double getTransitionThroughputSPN (DataLayer pnmldata, StateList list, double[] steadyStateDistrib, int transitionNumber){
		int length = list.size();
		double result = 0;
		
		for (int i = 0; i< length; i++){
			double specifiedTransitionRate = 0;
			boolean[] transStatus = getTransitionEnabledStatusArray(pnmldata, list.get(i));
			//System.out.println(transStatus[0] + " " + transStatus[1]+ " "+ transStatus[2]+ " "+ transStatus[3]+ " "+ transStatus[4]+ " transStatuses" );
			if (transStatus[transitionNumber]==true){
				specifiedTransitionRate = pnmldata.getTransitions()[transitionNumber].getRate();
				//System.out.println(specifiedTransitionRate +" specified transition rate");
				result+= (specifiedTransitionRate*steadyStateDistrib[i]);
			}
		}
		return result;
	}
	
//######################################################################################################################	
	
	private double[] getTransitionThroughput(DataLayer pnmldata, StateList vanishing, StateList tangible, Matrix rateForSpecificChange, double[] steadyStateDistribution) {
		Transition[] transitions = pnmldata.getTransitions();
		int transCount = transitions.length;
		double[] result = new double[transCount];
		for (int i = 0; i<transCount; i++) {
			if (transitions[i].getTimed()==true){
				result[i] = getTransitionThroughputSPN(pnmldata, tangible, steadyStateDistribution, i);
			}
			else 
				result[i] = getVanishingStateThroughput(pnmldata, vanishing, i, rateForSpecificChange);
		}
		return result;
	}
	
	
//######################################################################################################################	
	/**Constructs a matrix of probabilities of changing from one marking to another.
	 * Uses the reachability set to determine all markings, and applies the 
	 * probMarkingAToMarkingB function to calculate probability for each pair of markings
	 * @param pnmlData
	 * @return
	 */
	private double[][]getTransitionProbabilityMatrix(DataLayer pnmlData, StateList reachabilitySet) {
		int setLength = reachabilitySet.size();
		double [][] transitionProbabilityMatrix = new double[setLength][setLength];
		int recordSize = reachabilitySet.get(0).length;
		int [] stateSpace1 = new int[recordSize];
		int [] stateSpace2 = new int [recordSize];
		for (int i = 0; i< setLength; i++){
			stateSpace1 = reachabilitySet.get(i);
			for (int j = 0; j < setLength; j++) {
				stateSpace2 = reachabilitySet.get(j);
				transitionProbabilityMatrix[i][j] = probMarkingAToMarkingB(pnmlData, stateSpace1, stateSpace2);
			}
		}
		return transitionProbabilityMatrix;
	}

//######################################################################################################################
	//This is a debugging function for viewing results in the console - not part of analysis 
	private void print (boolean[] transitions) {
		int size = transitions.length;
		for (int i = 0; i < size ; i++) {
			System.out.print( transitions[i] +" ");
		}
		System.out.println();
	}
	

//######################################################################################################################
	public String getName() {
		return MODULE_NAME;
	}

	
	
//######################################################################################################################
	/*
	private void runAnalysis(DataLayer pnmldata) {
		Transition[] transitions = pnmldata.getTransitions();
		int transCount = transitions.length;
		boolean hasTimed = false; */
		/*
		for (int i = 0; i< length; i++) {
			System.out.println("Timed attribute of transition " + transCount[i].getId());
			System.out.println(transCount[i].getTimed());
			if (transCount[i].getTimed()==true)
				hasTimed = true;
		}
		*/
/*		if (hasTimed = false){
			System.out.println("There are no timed transitions in this net.");
			System.out.println("GSPN analysis cannot be performed.");
			return;
		}
		
		if (testEqualConflict(pnmldata) == false) {
			System.out.println("Condition equal conflict does not hold, so analysis cannot continue");
			//TODO - put exit condition and apology in here
			return;
		}
		
		//if (isEFCGSPN(pnmldata) )
		System.out.println(isEFCGSPN(pnmldata) +" is EFCGSPN");
		System.out.println("Condition equal conflict = " + testEqualConflict(pnmldata));
		StateList reachSet = getReachabilitySet(pnmldata);
		int reachSize = reachSet.size();
		
		System.out.println("********************************************************");
		System.out.println("********************************************************");
		System.out.println("Decide whether states are vanishing or not");
		
		for (int j = 0; j <reachSize; j ++){
			int[] currentMarking = reachSet.get(j);
			System.out.println(isTangibleState(pnmldata, currentMarking) + "...is tangible state");
			printMarking(currentMarking);
		}
		
		getTransitionProbabilityMatrix(pnmldata, reachSet);
*/		
	
		//generate matrices C, D, E, F
		
/*		StateList tangible = new StateList();
		StateList vanishing = new StateList();
		
		getVanishingAndTangible(pnmldata, reachSet, vanishing, tangible);
*/		
		//MarkingProbability dummy = new MarkingProbability();
/*		double[][] cMatrix, dMatrix, eMatrix, fMatrix, iMinusC, pPrime;
		int cSize = vanishing.size();
		int fSize = tangible.size();
		
		cMatrix = probabilityMatrix(pnmldata, vanishing, vanishing);
		dMatrix = probabilityMatrix(pnmldata, vanishing, tangible);
		eMatrix = probabilityMatrix (pnmldata, tangible, vanishing);
		fMatrix = probabilityMatrix (pnmldata, tangible, tangible);
		iMinusC = identityMatrix(cSize);	//initialise to be the identity matrix
				

		System.out.println("C, D, E, F matrices follow:");
		printMatrix(cMatrix);
		printMatrix(dMatrix);
		printMatrix(eMatrix);
		printMatrix(fMatrix);
		printMatrix(iMinusC);		
		
		System.out.println("Generated C matrix" + cSize);
		
		//generate P' = F + ((E x (I - C) ^-1) x D)
		subtractMatrix(iMinusC, cMatrix);  //get the (I - C) term in the above expression
		
		Matrix iMin = new Matrix(iMinusC);
		Matrix f = new Matrix (fMatrix);
		Matrix d = new Matrix (dMatrix);
		Matrix e = new Matrix (eMatrix);
		Matrix c = new Matrix (cMatrix);
		
		
		Matrix iMinusCInverse = iMin.inverse();
		
		iMinusCInverse.print(8,5);
		
		Matrix iMinusCInverseD = new Matrix(iMinusCInverse.getRowDimension(),d.getColumnDimension());
		iMinusCInverseD = iMinusCInverse.times(d);
		
		iMinusCInverseD.print(8,5);
		
		Matrix eIMinusCInverseD = new Matrix(e.getRowDimension(),iMinusCInverseD.getColumnDimension());
		
		eIMinusCInverseD = e.times(iMinusCInverseD);
		
		eIMinusCInverseD.print(8,5);
		
		f.plusEquals(eIMinusCInverseD);
		
		System.out.println("The answer...");
		f.print(8,5);
		
		Matrix piBarM = new Matrix(1,f.getColumnDimension());
		for (int i = 0; i <f.getColumnDimension(); i++){
		piBarM.set(0,i,1);	
		}
		piBarM.print(8,5);
		
		Matrix ps = piBarM.times(f);
		
		System.out.println("See what this does");
		ps.print(8,5);
		
		Matrix inv = f.transpose();
		System.out.println("The inverse");
		inv.print(8,5);
		
		for (int j = 0; j <inv.getRowDimension(); j ++) {
			inv.set(j, j, (inv.get(j,j)) - 1);
		}
		inv.print (8,5);
		int row = inv.getColumnDimension();
		
		Matrix enh = new Matrix(row+1, row+1);
		
		for (int i = 0; i <= row; i++){
			enh.set(0, i, 1);
		}