arrivalrateparametricanalysis.java

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

        if (singleClass) {
            double sum = 0;
            double increment = (finalValue - initialValue)/((double)(numberOfSteps-1));
            values = new Vector(numberOfSteps);
            for (int i=0;i<numberOfSteps;i++) {
                double value = initialValue + sum;
                ((Vector)values).add(new Double(value));
                sum += increment;                              //note that the increment may be < 0
            }
            originalValues = new Double(initialValue);
        }
        else {
            double sum = 1;
            double increment = (finalValue - initialValue)/(100*(double)(numberOfSteps-1));
            //find the set of avaible classes
            Vector allClasses = classDef.getOpenClassKeys();
            avaibleClasses = new Vector(0,1);
            for (int i=0;i<allClasses.size();i++) {
                Object thisClass = allClasses.get(i);
                Object temp = classDef.getClassDistribution(thisClass);
                if (temp instanceof Distribution) {
                    Distribution distr = (Distribution) temp;
                    if (distr.hasMean()) avaibleClasses.add(thisClass);
                }
            }
            values = new ValuesTable(classDef,avaibleClasses,numberOfSteps);
            for (int i=0; i<numberOfSteps; i++) {
                for (int k=0;k<avaibleClasses.size();k++) {
                    Object thisClass = avaibleClasses.get(k);
                    double thisInitialArrivalRate = 1/(((Distribution)classDef.getClassDistribution(thisClass)).getMean());
                    double value = thisInitialArrivalRate*(sum);
                    ((ValuesTable)values).setValue(thisClass,value);
                }
                sum += increment;                             //note that the increment may be < 0
            }
            //used to save the initial values of service time
            originalValues = new Vector(avaibleClasses.size());
            for (int i=0; i<avaibleClasses.size();i++) {
                Object thisClass = avaibleClasses.get(i);
                double thisRate = 1/(((Distribution)classDef.getClassDistribution(thisClass)).getMean());
                ((Vector)originalValues).add(new Double(thisRate));
            }
        }
    }

    /**
     * Restore the original values of the parameter
     */
    public void restoreOriginalValues() {
        if (originalValues != null) {
            if (singleClass) {
                Distribution distr = (Distribution)classDef.getClassDistribution(classKey);
                Double rate = (Double)originalValues;
                distr.setMean(1/(rate.doubleValue()));
            }
            else {
                Vector values = (Vector)originalValues;
                Vector avaibleClasses = classDef.getOpenClassKeys();
                for (int i=0;i<avaibleClasses.size();i++) {
                    Object thisClass = avaibleClasses.get(i);
                    Distribution distr = (Distribution)classDef.getClassDistribution(thisClass);
                    Double thisRate = (Double)values.get(i);
                    distr.setMean(1/(thisRate.doubleValue()));
                }
            }
        }
    }

    /**
     * Checks if the PA model is still coherent with simulation model definition. If
     * the <code>autocorrect</code> variable is set to true, if the PA model is no more
     * valid but it can be corrected it will be changed.
     *
     * @param autocorrect if true the PA model will be autocorrected
     *
     * @return 0 - If the PA model is still valid <br>
     *         1 - If the PA model is no more valid, but it will be corrected <br>
     *         2 - If the PA model can be no more used
     */
    public int checkCorrectness(boolean autocorrect) {
        int code = 0;
        ParametricAnalysisChecker checker = new ParametricAnalysisChecker(classDef,stationDef,simDef);
        Vector openClasses = classDef.getOpenClassKeys();
        Vector avaibleClasses = checker.checkForArrivalRatesParametricSimulationAvaibleClasses();
        if (avaibleClasses.isEmpty()) code = 2;
        else {
            //if is single class...
            if (isSingleClass()) {
                // ... and the selected close class is no more avaible
                if (!avaibleClasses.contains(classKey)) {
                    code = 1;
                    if (autocorrect) {
                        classKey = openClasses.get(0);   //change the reference class
                        setDefaultInitialValue();
                        setDefaultFinalValue();
                    }
                }
                else {
                    double refRate = 1/(((Distribution)classDef.getClassDistribution(classKey)).getMean());
                    //If the arrival rate of reference class was changed...
                    if (initialValue != refRate) {
                        code = 1;
                        if (autocorrect) {
                            initialValue = refRate;
                            finalValue = refRate*INCREMENT_SINGLE;
                        }
                    }
                }
            }
            else {
                if ( (avaibleClasses.size() < openClasses.size()) || (openClasses.size() == 1) ) {
                    code = 1;
                    if (autocorrect) {
                        classKey = avaibleClasses.get(0);
                        singleClass = true;
                        setDefaultInitialValue();
                        setDefaultFinalValue();
                    }
                }
            }
        }
        return code;
    }

    /**
     * Returns the values assumed by the varying parameter
     *
     * @return a Vector containing the values assumed by the varying parameter
     */
    public Vector getParameterValues() {
        Vector assumedValues = new Vector(numberOfSteps);
        if (singleClass) {
            return (Vector)values;
        }
        else {
            ValuesTable temp = (ValuesTable)values;
            double originalValue = ((Double)((Vector)originalValues).get(0)).doubleValue();
            for (int i=0; i<numberOfSteps; i++) {
                double thisValue = temp.getValue(avaibleClasses.get(0),i);
                double ratio = thisValue/originalValue*100;
                assumedValues.add(new Double(ratio));
            }
        }
        return assumedValues;
    }

    /**
     * Get the reference class name
     *
     * @return the name of the class
     */
    public String getReferenceClassName() {
        return classDef.getClassName(classKey);
    }

    /**
     * Gets a TreeMap containing for each property its value. The supported properties are
     * defined as constants inside this class.
     * @return a TreeMap containing the value for each property
     */
    public Map getProperties() {
        TreeMap properties = new TreeMap();
        properties.put(TYPE_PROPERTY,getType());
        properties.put(TO_PROPERTY,Double.toString(finalValue));
        properties.put(STEPS_PROPERTY,Integer.toString(numberOfSteps));
        properties.put(IS_SINGLE_CLASS_PROPERTY,Boolean.toString(singleClass));
        if (singleClass) properties.put(REFERENCE_CLASS_PROPERTY,classDef.getClassName(classKey));
        return properties;
    }

    /**
     * Sets the value for the specified property. The supported properties are: <br>
     * - TO_PROPERTY  <br>
     * - STEPS_PROPERTY <br>
     * - IS_SINGLE_CLASS_PROPERTY <br>
     * - REFERENCE_CLASS_PROPERTY
     * @param propertyName the name of the property to be set
     * @param value the value to be set
     */
    public void setProperty(String propertyName, String value) {
        if (propertyName.equals(TO_PROPERTY )) {
            finalValue = Double.parseDouble(value);
        }
        else if (propertyName.equals(STEPS_PROPERTY )) {
            numberOfSteps = Integer.parseInt(value);
            if (numberOfSteps > MAX_STEP_NUMBER) numberOfSteps = MAX_STEP_NUMBER;
        }
        else if (propertyName.equals(IS_SINGLE_CLASS_PROPERTY )) {
            singleClass = Boolean.valueOf(value).booleanValue();
            this.setDefaultInitialValue();
            this.setDefaultFinalValue();
        }
        else if (propertyName.equals(REFERENCE_CLASS_PROPERTY )) {
            classKey = classDef.getClassByName(value);
        }
        simDef.setSaveChanged();
    }
}