datalayer.java

Petri网分析工具PIPE is open-source

  	arcPoint.setAttribute("xCoord", x);
  	arcPoint.setAttribute("yCoord", y);
  	arcPoint.setAttribute("arcPointType", type);
  	
  	return arcPoint;
  }

  /**
   * Creates all Petri-Net Matrixes from current Petri-Net
   *
   */
  private void createMatrixes(){
    createFowardIncidenceMatrix();
    createBackwardsIncidenceMatrix();
    createIncidenceMatrix();
    createInitialMarkupMatrix();
    createCurrentMarkupMatrix();
  }

  /**
   * Creates Foward Incidence Matrix from current Petri-Net
   *
   */
  private void createFowardIncidenceMatrix(){//m
    int placeNo = 0, transitionNo = 0;
    int placeSize = placesArray.size();
    int transitionSize = transitionsArray.size();

    Arc arc = null;
    Place place = null;
    Transition transition = null;

    fowardsIncidenceMatrix = new PNMatrix(placeSize, transitionSize);

    fowardsIncidenceMatrix.setToZero();

    for(int i = 0 ; i < arcsArray.size() ; i++) {
      arc = (Arc)arcsArray.get(i);
      if(arc != null) {
        PetriNetObject pnObject = arc.getTarget();
        if(pnObject != null){
          if(pnObject instanceof Place) {
            place = (Place)pnObject;
            pnObject = arc.getSource();
            if(pnObject != null){
              if(pnObject instanceof Transition){
                transition = (Transition)pnObject;
                transitionNo = getListPosition(transition);
                placeNo = getListPosition(place);
                fowardsIncidenceMatrix.set(placeNo, transitionNo, arc.getWeight());
              }
            }
          }
        }
      }
    }
  }

  /**
   * Creates Backwards Incidence Matrix from current Petri-Net
   *
   */
  private void createBackwardsIncidenceMatrix(){//Matthew
    int placeNo = 0, transitionNo = 0;
    int placeSize = placesArray.size();
    int transitionSize = transitionsArray.size();

    Arc arc = null;
    Place place = null;
    Transition transition = null;

    backwardsIncidenceMatrix = new PNMatrix(placeSize, transitionSize);

    backwardsIncidenceMatrix.setToZero();

    for(int i = 0 ; i < arcsArray.size() ; i++) {
      arc = (Arc)arcsArray.get(i);
      if(arc != null) {
        PetriNetObject pnObject = arc.getSource();
        if(pnObject != null){
          if(pnObject instanceof Place) {
            place = (Place)pnObject;
            pnObject = arc.getTarget();
            if(pnObject != null){
              if(pnObject instanceof Transition){
                transition = (Transition)pnObject;
                transitionNo = getListPosition(transition);
                placeNo = getListPosition(place);
                backwardsIncidenceMatrix.set(placeNo, transitionNo, arc.getWeight());
              }
            }
          }
        }
      }
    }
  }

  /**
   * Creates Incidence Matrix from current Petri-Net
   *
   */
  private void createIncidenceMatrix(){
    createFowardIncidenceMatrix();
    createBackwardsIncidenceMatrix();
    incidenceMatrix = new PNMatrix(fowardsIncidenceMatrix.getArrayCopy());   
    incidenceMatrix = incidenceMatrix.minus(backwardsIncidenceMatrix);
  }

  /**
   * Creates Initial Markup Matrix from current Petri-Net
   *
   */
  private void createInitialMarkupMatrix(){
    int placeNo = 0;
    int placeSize = placesArray.size();
    initialMarkupMatrix = new int[placeSize];
    for( ; placeNo < placeSize ; placeNo++)
      initialMarkupMatrix[placeNo] = ((Place)placesArray.get(placeNo)).getInitialMarking();
  }

  /**
   * Creates Initial Markup Matrix from current Petri-Net
   *
   */
  private void createCurrentMarkupMatrix(){
    int placeNo = 0;
    int placeSize = placesArray.size();
    currentMarkupMatrix = new int[placeSize];
    for( ; placeNo < placeSize ; placeNo++)
      currentMarkupMatrix[placeNo] = ((Place)placesArray.get(placeNo)).getCurrentMarking();
  }

  /**
   * Stores Initial Markup Matrix from current Petri-Net Markup
   *
   */
  public void storeInitialMarking(){
    createMatrixes();
    int placeNo = 0;
    int placeSize = placesArray.size();
    initialMarkupMatrix = new int[placeSize];
    for( ; placeNo < placeSize ; placeNo++)
      initialMarkupMatrix[placeNo] = ((Place)placesArray.get(placeNo)).getCurrentMarking();
  }

  /**
   * Restores Initial Markup Matrix to current Petri-Net Markup
   *
   */
  public void restoreInitialMarking(){
    createMatrixes();
    int placeNo = 0;
    int placeSize = placesArray.size();
    for( ; placeNo < placeSize ; placeNo++) {
      Place place = ((Place)placesArray.get(placeNo));
      if(place != null) {
        place.setCurrentMarking(initialMarkupMatrix[placeNo]);
        setChanged();
        notifyObservers(place);
      }
    }
  }

  /**
   * Stores Current Markup
   *
   */
  public void storeState(){
    int placeNo = 0;
    int placeSize = placesArray.size();
    markupMatrixAnimationStorage = new int[placeSize];
    for( ; placeNo < placeSize ; placeNo++)
      markupMatrixAnimationStorage[placeNo] = ((Place)placesArray.get(placeNo)).getCurrentMarking();
  }

  /**
   * Restores To previous Stored Markup
   */
  public void restoreState(){
    if(markupMatrixAnimationStorage != null) {
      int placeNo = 0;
      int placeSize = placesArray.size();
      for( ; placeNo < placeSize ; placeNo++) {
        Place place = ((Place)placesArray.get(placeNo));
        if(place != null) {
          place.setCurrentMarking(markupMatrixAnimationStorage[placeNo]);
          setChanged();
          notifyObservers(place);
        }
      }
    }
  }

  /**
   * Fire a specified transition, no affect if transtions not enabled
   * @param transition Reference of specifiec Transition
   */
  public void fireTransition(Transition transition) {
    if(transition != null) {
      setEnabledTransitions();
      if(transition.isEnabled() && placesArray != null){
        int transitionNo = transitionsArray.indexOf(transition);
        for(int placeNo = 0 ; placeNo < placesArray.size() ; placeNo++) {
          ((Place)placesArray.get(placeNo)).setCurrentMarking((currentMarkupMatrix[placeNo] + incidenceMatrix.get(placeNo, transitionNo)));
        }
      }
    }
  }

  /**
   * Fire a specified transition, no affect if transtions not enabled
   * @param transitionNo Position of Transition in internal ArrayList
   */
  private void fireTransition(int transitionNo) {
    setEnabledTransitions();
    if(((Transition)transitionsArray.get(transitionNo)).isEnabled() && placesArray != null){
      for(int placeNo = 0 ; placeNo < placesArray.size() ; placeNo++) {
        ((Place)placesArray.get(placeNo)).setCurrentMarking((currentMarkupMatrix[placeNo] + incidenceMatrix.get(placeNo, transitionNo)));
      }
    }
  }

  /**
   * Fire a random transition, takes rate (probability) of Transitions into account
   */
  public Transition fireRandomTransition() {
    Transition result=null;
    setEnabledTransitions();
//    int transitionsSize = transitionsArray.size()*transitionsArray.size()*transitionsArray.size();
    int randomTransition = 0;
    int transitionNo = 0;
    double rate = 0;
    ArrayList enabledTransitions = new ArrayList();

    for(transitionNo = 0 ; transitionNo < transitionsArray.size() ; transitionNo++) {
      if(((Transition)transitionsArray.get(transitionNo)).isEnabled()) {
        rate = ((Transition)transitionsArray.get(transitionNo)).getRate();
        for(int i = 0 ; i < rate ; i++ ) {
          enabledTransitions.add(new Integer(transitionNo));
        }
      }
    }
    randomTransition = randomNumber.nextInt((enabledTransitions.size() > 0 ? enabledTransitions.size() : 1 ));
    if(randomTransition < enabledTransitions.size()) {
      if(enabledTransitions.get(randomTransition) != null) {
        int n=((Integer)enabledTransitions.get(randomTransition)).intValue();
        result=(Transition)(transitionsArray.get(n));
        fireTransition(n);
      }
    }
    resetEnabledTransitions();
    return result;
  }

  public void fireTransitionBackwards(Transition transition) {
    if(transition != null) {
      setEnabledTransitionsBackwards();
      if(transition.isEnabled() && placesArray != null){
        int transitionNo = transitionsArray.indexOf(transition);
        for(int placeNo = 0 ; placeNo < placesArray.size() ; placeNo++) {
          ((Place)placesArray.get(placeNo)).setCurrentMarking((currentMarkupMatrix[placeNo] - incidenceMatrix.get(placeNo, transitionNo)));
        }
      }
    }
  }

  private void fireTransitionBackwards(int transitionNo) {
    setEnabledTransitionsBackwards();
    if(((Transition)transitionsArray.get(transitionNo)).isEnabled() && placesArray != null){
      for(int placeNo = 0 ; placeNo < placesArray.size() ; placeNo++) {
        ((Place)placesArray.get(placeNo)).setCurrentMarking((currentMarkupMatrix[placeNo] - incidenceMatrix.get(placeNo, transitionNo)));
      }
    }
  }

  public void fireRandomTransitionBackwards() {
    setEnabledTransitionsBackwards();
    int transitionsSize = transitionsArray.size()*transitionsArray.size()*transitionsArray.size();
    int randonTransition = 0;
    do {
      randonTransition = randomNumber.nextInt(transitionsArray.size());
      transitionsSize--;
      if(transitionsSize <= 0) break;
    } while(!((Transition)transitionsArray.get(randonTransition)).isEnabled());
    fireTransitionBackwards(randonTransition);
//    System.out.println("Random Fired Transition Backwards" + ((Transition)transitionsArray.get(randonTransition)).getId());
  }

  /**
   * Determines whether all transitions are enabled and sets
   * the correct value of the enabled boolean
   */
  public void setEnabledTransitions() {
    createMatrixes();
    if(transitionsArray != null && placesArray != null) {
      for(int transitionNo = 0 ; transitionNo < transitionsArray.size() ; transitionNo++) {
        Transition transition = (Transition)transitionsArray.get(transitionNo);
        if(transition != null) {
          int test = placesArray.size();
          for(int placeNo = 0 ; placeNo < placesArray.size() ; placeNo++) {
            if(backwardsIncidenceMatrix.get(placeNo, transitionNo) <= currentMarkupMatrix[placeNo]) {
              test--;
            }
          }
          if(test <= 0) {
            transition.setEnabled(true);
            setChanged();
            notifyObservers(transition);
          } else {
            transition.setEnabled(false);
            setChanged();
            notifyObservers(transition);
          }
        }
      }
    }
  }

  public void resetEnabledTransitions() {
    createMatrixes();
    if(transitionsArray != null && placesArray != null) {
      for(int transitionNo = 0 ; transitionNo < transitionsArray.size() ; transitionNo++) {
        Transition transition = (Transition)transitionsArray.get(transitionNo);
        if(transition != null) {
          int test = placesArray.size();
          for(int placeNo = 0 ; placeNo < placesArray.size() ; placeNo++) {
            if(backwardsIncidenceMatrix.get(placeNo, transitionNo) <= currentMarkupMatrix[placeNo]) {
              test--;
            }
          }
          if(test <= 0) {
            transition.setEnabled(false);
          } else {
            transition.setEnabled(false);
          }
          setChanged();
          notifyObservers(transition);
        }
      }
    }
  }

  /**
   * Determines whether all transitions are enabled and sets
   * the correct value of the enabled boolean
   */
  public void setEnabledTransitionsBackwards() {