gspn.java

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

/*
 * Created on Feb 6, 2004
 *
 * To change the template for this generated file go to
 * Window - Preferences - Java - Code Generation - Code and Comments
 */
package pipe.modules.gspn;
//import java.applet.AudioClip;
//import java.applet.Applet.*;
import jama.Matrix;

import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.DecimalFormat;
import java.util.ArrayList;

import javax.swing.BoxLayout;
import javax.swing.JDialog;

import pipe.dataLayer.Arc;
import pipe.dataLayer.DataLayer;
import pipe.dataLayer.PNMatrix;
import pipe.dataLayer.Place;
import pipe.dataLayer.PlaceTransitionObject;
import pipe.dataLayer.Transition;
import pipe.dataLayer.calculations.StateList;
import pipe.dataLayer.calculations.TreeTooBigException;
import pipe.dataLayer.calculations.myTree;
import pipe.gui.CreateGui;
import pipe.gui.widgets.ButtonBar;
import pipe.gui.widgets.PetriNetChooserPanel;
import pipe.gui.widgets.ResultsHTMLPane;
import pipe.modules.Module;
import pipe.modules.classification.Classification;


/**
 * @author Matthew Cook
 *
 * 
 */
public class GSPN extends Classification implements Module{
	
	private static final String MODULE_NAME = "GSPN Analysis";
	private PetriNetChooserPanel sourceFilePanel;
	private ResultsHTMLPane results;
  
//######################################################################################################################	
	public void run(DataLayer pnmlData) {
		// Build interface
		JDialog guiDialog = new JDialog(CreateGui.getApp(),MODULE_NAME,true);
		
		// 1 Set layout
		Container contentPane=guiDialog.getContentPane();
		contentPane.setLayout(new BoxLayout(contentPane,BoxLayout.PAGE_AXIS));
		
		// 2 Add file browser
		contentPane.add(sourceFilePanel=new PetriNetChooserPanel("Source net",pnmlData));
		
		// 3 Add results pane
		contentPane.add(results=new ResultsHTMLPane());
		
		// 4 Add button
		contentPane.add(new ButtonBar("Analyse GSPN",runAnalysis));
		//contentPane.add(new ButtonBar("Play a tune!",playMidi));
		// 5 Make window fit contents' preferred size
		guiDialog.pack();
		
		// 6 Move window to the middle of the screen
		guiDialog.setLocationRelativeTo(null);
		
		guiDialog.setVisible(true);
	}
//######################################################################################################################	
	/**
	 * Analyse button click handler
	 */
	ActionListener runAnalysis=new ActionListener() {
		public void actionPerformed(ActionEvent arg0) {
			DataLayer sourceDataLayer=sourceFilePanel.getDataLayer();
			String s="<h2>GSPN analysis results</h2>";
			if(sourceDataLayer==null) return;
			if (!hasTimedTransitions(sourceDataLayer)){
				s+= "This Petri net has no timed transitions, so GSPN analysis cannot be performed.";
				
			}
			else if (!hasImmediateTransitions(sourceDataLayer)){
				s+= "This Petri net has no immediate transitions, so GSPN analysis cannot be performed.";
				
			}
			
			
			else if (!testEqualConflict(sourceDataLayer)) {
				s+= "Condition Equal Conflict is not satisfied.  GSPN analysis cannot continue.";
				
			}
			
			else {
				
			//set up data for display	
			try {
				StateList reachSet = getReachabilitySet(sourceDataLayer);
				int reachSize = reachSet.size();
				getTransitionProbabilityMatrix(sourceDataLayer, reachSet);
				//int placeCount = sourceDataLayer.getPlaces().length;
				
				StateList vanishing = new StateList();
				
				StateList tangible = new StateList();
				getVanishingAndTangible (sourceDataLayer, reachSet, vanishing, tangible);
				if (tangible.size() == 0) {
					s+= "This petri net has no tangible states.  GSPN analysis cannot continue";
				}
				else  if (vanishing.size() == 0) {
					s+= "This petri net has no vanishing states.  GSPN analysis cannot continue";
				}
				else {
					double[][] c = new double [vanishing.size()][vanishing.size()];
					double[][] d = new double [vanishing.size()][tangible.size()];
					double[][] e = new double [tangible.size()][vanishing.size()];
					double[][] f = new double [tangible.size()][tangible.size()];
					c = probabilityMatrix(sourceDataLayer, vanishing, vanishing);
					d = probabilityMatrix(sourceDataLayer, vanishing, tangible);
					e = probabilityMatrix(sourceDataLayer, tangible, vanishing);
					f = probabilityMatrix(sourceDataLayer, tangible, tangible);
					Matrix cM = new Matrix(c);
					Matrix dM = new Matrix(d);
					Matrix eM = new Matrix(e);
					Matrix fM = new Matrix(f);
					int cSize = cM.getColumnDimension();
					Matrix iD = new Matrix (cSize, cSize);
					for (int i = 0; i<cSize; i++){
						for (int j = 0; j < cSize; j++){
							if (i==j) iD.set(i,j,1.0);
							else iD.set(i,j,0.0);
						}
					}
					Matrix iMinusCInverse = new Matrix(cSize, cSize);
					iMinusCInverse = iD.minus(cM);
					iMinusCInverse = iMinusCInverse.inverse();
					double[] sojournTimes = calcSojournTime(sourceDataLayer, tangible);
					double[] embeddedMarkovChainDist = getEmbeddedMarkovChainSteadyStateDistribution(cM,dM,eM,fM);
					Matrix meanVisits = calcMeanNumVisits(embeddedMarkovChainDist);
					double xHat = xHat(sojournTimes, embeddedMarkovChainDist);
					double[] meanCycleTimes = calcMeanCycleTimes(embeddedMarkovChainDist, xHat);
					int meanCycleLength = meanCycleTimes.length;
					double[] steadyStateDistribution = getSteadyStateDistribution(meanCycleTimes, sojournTimes);
					double[][] rates = rateMatrix(sourceDataLayer, tangible, vanishing);
					Matrix eTwiddle = new Matrix(rates);
					Matrix eTwiddleIMinusCInverse = eTwiddle.times(iMinusCInverse);
					Matrix steadyStateDistrib = new Matrix(1,meanCycleLength);
					for (int i=0; i< meanCycleLength; i++) {
						steadyStateDistrib.set(0,i,steadyStateDistribution[i]);
					}
					Matrix vanishingSteadyState = steadyStateDistrib.times(eTwiddleIMinusCInverse);
					double[] throughput = getTransitionThroughput(sourceDataLayer ,vanishing, tangible, vanishingSteadyState, steadyStateDistribution);
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Entire reachability set",
							renderStateSpaceLinked(sourceDataLayer, reachSet)
						},1,false,false,true,false);
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Set of vanishing markings",
							renderStateSpace(sourceDataLayer, vanishing)
					},1, false,false,true,false);
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Set of tangible markings",
							renderStateSpace(sourceDataLayer, tangible)
					},1, false,false,true,false);
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Probability of transition between two vanishing states",
							renderProbabilities(c, vanishing, vanishing)
					},1,false,false,true,false);	
										
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Probability of transition from a vanishing state to a tangible state",
							renderProbabilities(d, vanishing, tangible)
					},1,false,false,true,false);
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Probability of transition from a tangible state to a vanishing state",
							renderProbabilities(e, tangible, vanishing)
					},1,false,false,true,false);
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Probability of transition from a tangible state to a tangible state",
							renderProbabilities(f, tangible, tangible)
					},1,false,false,true,false);
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Steady state distribution  of the embedded Markov chain",
							renderLists(embeddedMarkovChainDist, tangible)
					},1,false,false,true,false);
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Mean number of visits between tangible states",
							renderProbabilities(meanVisits.getArrayCopy(), tangible, tangible)
					},1,false,false,true,false);
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Sojourn times for tangible states",
							renderLists(sojournTimes, tangible)
					},1,false,false,true,false);
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Mean cycle times for tangible states",
							renderLists(meanCycleTimes, tangible)
					},1,false,false,true,false);
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Steady state distribution for tangible states",
							renderLists(steadyStateDistribution, tangible)
					},1,false,false,true,false);			
					
					s+=ResultsHTMLPane.makeTable(new String[]{
							"Throughput",
							renderThroughput(sourceDataLayer, throughput)
					},1,false,false,true,false);			
				}
			} 	catch (TreeTooBigException e) {
				s+= e.getMessage();
				}
			}
			results.setText(s);
		}
		
	
		
			
		
	};
	/*
	ActionListener playMidi = new ActionListener() {

		public void actionPerformed(ActionEvent arg0) {
			// TODO Auto-generated method stub
			AudioClip midi = new AudioClip(CreateGui.imgPath+"FANTASY.mid");
		}
		
	};
	*/
//######################################################################################################################
	
	//Format StateList data nicely.
	private String renderStateSpace(DataLayer pnmldata, StateList data) {
		if((data.size()==0)||(data.get(0).length==0)) return "n/a";
		int markSize = data.get(0).length;
		ArrayList result=new ArrayList();
		// add headers to table
		result.add("");
		for (int i=0;i<markSize;i++) 
			{result.add(pnmldata.getPlaces()[i].getName());
			//result.add("<A NAME= 'M" + i + "'></A>");
			}
		
		for (int i=0; i<data.size(); i++) {
			result.add(data.getID(i));
			for (int j=0; j<markSize; j++)
				result.add(Integer.toString(data.get(i)[j]));
		}
		
		return ResultsHTMLPane.makeTable(result.toArray(),markSize + 1,false,true,true,true);
	}
	
	
	
//######################################################################################################################
	
	//Format StateList data nicely.
	private String renderStateSpaceLinked(DataLayer pnmldata, StateList data) {
		if((data.size()==0)||(data.get(0).length==0)) return "n/a";
		int markSize = data.get(0).length;
		ArrayList result=new ArrayList();
		// add headers to table
		result.add("");
		for (int i=0;i<markSize;i++) 
		{result.add(pnmldata.getPlaces()[i].getName());
		//result.add("<A NAME= 'M" + i + "'></A>");
		}
		
		for (int i=0; i<data.size(); i++) {
			result.add(data.getID(i)+ "<A NAME= 'M" + i + "'></A>");
			for (int j=0; j<markSize; j++)
				result.add(Integer.toString(data.get(i)[j]));
		}
		
		return ResultsHTMLPane.makeTable(result.toArray(),markSize + 1,false,true,true,true);
	}
	
//######################################################################################################################
	
	//Format throughput data nicely.
	private String renderThroughput(DataLayer pnmldata, double[] data) {
		if((data.length)==0) return "n/a";
		int transCount = data.length;
		ArrayList result=new ArrayList();
		// add headers to table
		result.add("Transition");
		result.add("Throughput");
    DecimalFormat f=new DecimalFormat();
    f.setMaximumFractionDigits(5);
		for (int i=0;i<transCount;i++) {
			result.add(pnmldata.getTransitions()[i].getName());
			result.add(f.format(data[i]));
		}
		
		return ResultsHTMLPane.makeTable(result.toArray(),2,false,true,true,true);
	}
	
//######################################################################################################################	
	
	//Format probability matrices nicely
	private String renderProbabilities(double[][] probabilities, StateList list1, StateList list2) {
		if((list1.size()==0)||(list2.get(0).length==0)) return "n/a";
		int rows = list1.size();
		int cols = list2.size();
		ArrayList result=new ArrayList();
		// add headers to table
		result.add("");
		for (int i=0;i<cols;i++) result.add("<A HREF='#M" + i + "'>" + list2.getID(i)+ "</A>");
		
    DecimalFormat f=new DecimalFormat();
    f.setMaximumFractionDigits(5);
		for (int i=0; i<rows; i++) {
			result.add("<A HREF='#M" + i + "'>" + list1.getID(i)+ "</A>");
			for (int j=0; j<cols; j++)
				result.add(f.format(probabilities[i][j]));
		}
		
		return ResultsHTMLPane.makeTable(result.toArray(),cols + 1,false,true,true,true);
	}
	
//######################################################################################################################	
	
	//Format lists of doubles nicely
	private String renderLists(double[] data, StateList list) {
		if((list.size()==0)) return "n/a";
		int rows = list.size();
		
		ArrayList result=new ArrayList();
		// add headers to table
		result.add("Marking");
		result.add("Value");

    DecimalFormat f=new DecimalFormat();
    f.setMaximumFractionDigits(5);
		for (int i=0; i<rows; i++) {
			result.add("<A HREF='#" + list.getID(i) + "'>" + list.getID(i).toString().toUpperCase()+ "</A>");
			result.add(f.format(data[i]));
		}
		
		return ResultsHTMLPane.makeTable(result.toArray(),2,false,true,true,true);
	}
	
//######################################################################################################################
	/**Qualitative analysis - see if the supplied GSPN is an EFC-GSPN.  This is a necessary precondition