Пример #1
0
  public void inheritFrom(Dynamics src) {
    for (DerivedVariable dv : src.derivedVariables) {
      derivedVariables.add(dv.makeCopy());
    }
    for (ConditionalDerivedVariable dv : src.conditionalDerivedVariables) {
      conditionalDerivedVariables.add(dv.makeCopy());
    }

    for (StateVariable sv : src.stateVariables) {
      stateVariables.add(sv.makeCopy());
    }
    for (TimeDerivative td : src.timeDerivatives) {
      timeDerivatives.add(td.makeCopy());
    }
    for (KineticScheme ks : src.kineticSchemes) {
      kineticSchemes.add(ks.makeCopy());
    }
    for (OnStart os : src.onStarts) {
      onStarts.add(os.makeCopy());
    }
    for (OnEvent oe : src.onEvents) {
      onEvents.add(oe.makeCopy());
    }
    for (OnCondition oc : src.onConditions) {
      onConditions.add(oc.makeCopy());
    }
    for (Regime r : src.regimes) {
      regimes.add(r.makeCopy());
    }
  }
Пример #2
0
  public void checkEquations(HashMap<String, Dimensional> cdimHM) throws ContentError {

    HashMap<String, Dimensional> dimHM = new HashMap<String, Dimensional>();

    dimHM.putAll(cdimHM);

    for (RequiredVar rv : p_requiredVars) {
      dimHM.put(rv.getName(), rv.getDimensionality());
    }

    for (StateVariable sv : stateVariables) {
      dimHM.put(sv.getName(), sv.getDimensionality());
    }

    for (FinalParam fp : r_type.getFinalParams()) {
      dimHM.put(fp.getName(), fp.getDimensionality());
    }

    for (InstanceProperty ip : r_type.getInstancePropertys()) {
      dimHM.put(ip.getName(), ip.getDimensionality());
    }

    ExprDimensional tdim = new ExprDimensional();
    tdim.setT(1);
    dimHM.put("t", tdim);

    for (DerivedVariable dv : derivedVariables) {
      try {
        dimHM.put(dv.getName(), dv.getDimensionality(dimHM));
      } catch (ContentError ce) {
        E.error("Checking " + dv + " in " + r_type + " " + ce.getMessage());
      }
    }

    for (ConditionalDerivedVariable cdv : conditionalDerivedVariables) {
      try {
        dimHM.put(cdv.getName(), cdv.getDimensionality(dimHM));
      } catch (ContentError ce) {
        E.error("Checking " + cdv + " in " + r_type + " " + ce.getMessage());
      }
    }

    for (TimeDerivative td : timeDerivatives) {
      td.checkDimensions(dimHM);
    }
    for (PointResponse pr : onStarts) {
      pr.checkEquations(dimHM);
    }
    for (PointResponse pr : onEvents) {
      pr.checkEquations(dimHM);
    }
    for (OnCondition oc : onConditions) {
      oc.checkEquations(dimHM);
      oc.checkConditionDimensions(dimHM);
    }
  }
Пример #3
0
  public StateType makeStateType(Component cpt, HashMap<String, Double> fixedHM)
      throws ContentError, ParseError {

    StateType ret = new StateType(cpt.getID(), cpt.getComponentType().getName());

    ret.setSimultaneous(simultaneous);

    for (ParamValue pv : cpt.getParamValues()) {
      String qn = pv.getName();
      double qv = pv.getDoubleValue();
      ret.addFixed(qn, qv);
      fixedHM.put(qn, qv);
    }

    for (RequiredVar rv : p_requiredVars) {
      ret.addIndependentVariable(rv.getName(), rv.getDimensionString());
    }

    for (ExposedVar ev : p_exposedVars) {
      ret.addExposedVariable(ev.getName(), ev.getDimensionString());
    }

    HashSet<StateVariable> varHS = new HashSet<StateVariable>();
    for (StateVariable sv : stateVariables) {
      varHS.add(sv);
      ret.addStateVariable(sv.getName(), sv.getDimensionString());
      if (sv.hasExposure()) {
        ret.addExposureMapping(sv.getName(), sv.getExposure().getName());
      }
    }

    for (InstanceProperty ip : cpt.getComponentType().getInstancePropertys()) {
      String pnm = ip.getName();
      ret.addExposureMapping(pnm, pnm);
      ret.addInstanceProperty(ip);
    }

    /*
    for (ExternalQuantity equan : externalQuantitys) {
     String qn = equan.getName();
     double qv = PathEvaluator.getValue(cpt, equan.getPath());
     ret.addFixed(qn, qv);
     fixedHM.put(qn, qv); // MUSTDO we don't need both of these:
     // either Ext quans shouldn't say they are fixed and we should use ret.addFixed, or it should
     // and use fixedHM.put.
    }
    */

    for (DerivedVariable dv : derivedVariables) {
      if (dv.hasExpression()) {

        DoubleEvaluator db = dv.getParseTree().makeFloatFixedEvaluator(fixedHM);

        ret.addExpressionDerived(dv.getName(), db, dv.getDimensionString());

      } else if (dv.hasSelection()) {
        ret.addPathDerived(
            dv.getName(),
            dv.getPath(),
            dv.getFunc(),
            dv.isRequired(),
            dv.getReduce(),
            dv.getDimensionString());

      } else {
        throw new ContentError("Derived variable needs as selection or an expression");
      }
      if (dv.hasExposure()) {
        ret.addExposureMapping(dv.getName(), dv.getExposure().getName());
      }
    }

    for (ConditionalDerivedVariable cdv : conditionalDerivedVariables) {
      DoubleEvaluator db = cdv.makeFloatFixedEvaluator(fixedHM);

      ret.addExpressionDerived(cdv.getName(), db, cdv.getDimensionString());

      if (cdv.hasExposure()) {
        ret.addExposureMapping(cdv.getName(), cdv.getExposure().getName());
      }
    }

    for (TimeDerivative sd : timeDerivatives) {
      StateVariable sv = sd.getStateVariable();
      varHS.remove(sv);

      ParseTree pt = sd.getParseTree();
      DoubleEvaluator db = pt.makeFloatFixedEvaluator(fixedHM);
      ret.addRate(sv.getName(), db, sd.getDimensionString());
    }

    for (OnStart os : onStarts) {
      ActionBlock ea = os.makeEventAction(fixedHM);
      ret.addInitialization(ea);
    }

    for (OnEvent oe : onEvents) {
      EventAction er = new EventAction(oe.getPortName());
      ActionBlock ea = oe.makeEventAction(fixedHM);
      er.setAction(ea);
      if (ea == null) {
        throw new ContentError("Null action block from OnEvent " + oe);
      }
      ret.addEventResponse(er);
    }
    if (regimes.size() > 0) {
      for (EventPort p : r_type.getEventPorts()) {
        if (p.isDirectionIn()) {
          if (onEvents.hasName(p.getName())) {
            // OK, the existing action will also send the event on to the active regime
          } else {
            EventAction er = new EventAction(p.getName());
            ret.addEventResponse(er);
          }
        }
      }
    }

    for (OnCondition oc : onConditions) {

      ParseTree pt = oc.getParseTree();
      BooleanEvaluator bb = pt.makeBooleanFixedEvaluator(fixedHM);

      ConditionAction cr = new ConditionAction(bb);
      ActionBlock ea = oc.makeEventAction(fixedHM);
      cr.setAction(ea);
      ret.addConditionResponse(cr);
    }

    for (KineticScheme ks : kineticSchemes) {
      ArrayList<Component> states = cpt.getChildrenAL(ks.getNodesName());
      ArrayList<Component> rates = cpt.getChildrenAL(ks.getEdgesName());

      KScheme scheme = ks.makeKScheme(states, rates);

      ret.addKScheme(scheme);
    }

    for (EventPort p : r_type.getEventPorts()) {
      if (p.isDirectionIn()) {
        ret.addInputPort(p.getName());
      }
      // TODO - also need output ports done the same way, in case send action is in a sub-regime
    }

    for (Regime reg : regimes) {
      ComponentRegime crb = reg.makeComponentRegime(ret, cpt, copyFixed(fixedHM));
      ret.addComponentRegime(crb);
    }

    // TODO - could do something with children of parent type here, but don't have to as they
    // come in again via the structure of the component itself.

    /*
    for (StateVariable sv : varHS) {
    // E.info("sv without derivative " + sv + " in mcb for " + cpt.getID() + " " + cpt.hashCode());
    }
    */

    ret.fix();
    return ret;
  }
Пример #4
0
  private void realResolve(Lems lems, Parser parser) throws ContentError, ParseError {
    if (lems.looseResolving()) {
      // then we expose anything with a name that matches the name of an exposure
      HashSet<String> expHS = new HashSet<String>();
      for (Exposure exp : getComponentType().getExposures()) {
        expHS.add(exp.getName());
      }

      for (StateVariable sv : stateVariables) {
        if (sv.exposure == null && expHS.contains(sv.name)) {
          sv.exposure = sv.name;
          E.shortWarning(
              "Implicitly exposing a state variable because its name matches an exposure: " + sv);
        }
      }
      for (DerivedVariable dv : derivedVariables) {
        if (dv.exposure == null && expHS.contains(dv.name)) {
          dv.exposure = dv.name;
          E.shortWarning(
              "Implicitly exposing a derived variable because its name matches an exposure: " + dv);
        }
      }

      for (ConditionalDerivedVariable dv : conditionalDerivedVariables) {
        if (dv.exposure == null && expHS.contains(dv.name)) {
          dv.exposure = dv.name;
          E.shortWarning(
              "Implicitly exposing a derived variable because its name matches an exposure: " + dv);
        }
      }
    }

    HashMap<String, Integer> exposedHM = new HashMap<String, Integer>();

    for (Requirement req : getComponentType().getRequirements()) {
      p_requiredVars.add(new RequiredVar(req.getName(), req.getDimension()));
    }

    for (Exposure exp : getComponentType().getExposures()) {
      p_exposedVars.add(new ExposedVar(exp.getName(), exp.getDimension()));
      exposedHM.put(exp.getName(), 0);
    }

    checkMakeValHM();

    addToMap(lems.getGlobals(), valHM);

    addToMap(lems.getConstantValueds(), valHM);

    for (DerivedVariable dvar : derivedVariables) {
      dvar.resolve(lems, lems.getDimensions(), r_type, valHM, parser);
      if (dvar.hasExposure()) {
        countExposure(dvar.getExposure(), exposedHM);
      }
    }

    for (ConditionalDerivedVariable dvar : conditionalDerivedVariables) {
      dvar.resolve(lems, lems.getDimensions(), r_type, valHM, parser);
      if (dvar.hasExposure()) {
        countExposure(dvar.getExposure(), exposedHM);
      }
    }

    for (StateVariable sv : stateVariables) {
      sv.resolve(r_type, lems.getDimensions());
      if (sv.hasExposure()) {
        countExposure(sv.getExposure(), exposedHM);
      }
    }

    for (StateScalarField scf : stateScalarFields) {
      scf.resolve(r_type, lems.getDimensions());
    }

    for (DerivedScalarField dcf : derivedScalarFields) {
      dcf.resolve(r_type, lems.getDimensions());
    }

    for (DerivedPunctateField dpf : derivedPunctateFields) {
      dpf.resolve(r_type, lems.getDimensions());
    }

    for (TimeDerivative sd : timeDerivatives) {
      sd.resolve(stateVariables, valHM, parser);
    }

    for (OnStart os : onStarts) {
      os.resolve(this, stateVariables, valHM, parser);
    }

    for (OnEvent oe : onEvents) {
      oe.resolve(this, stateVariables, valHM, parser);
    }

    for (OnCondition oc : onConditions) {
      oc.resolve(this, stateVariables, valHM, parser);
    }

    for (Regime reg : regimes) {
      reg.setBehavior(this);
      reg.resolve(stateVariables, lems, parser, exposedHM);
    }

    for (KineticScheme ks : kineticSchemes) {
      ks.resolve(r_type);
    }

    for (String enm : exposedHM.keySet()) {
      if (exposedHM.get(enm) == 0) {
        E.oneLineWarning(
            "No internal variable is linked to the exposure: "
                + enm
                + " for ComponentType "
                + getComponentType().getName());
      }
    }
  }