void use_erdosrenyi_graph_generator(const vle::devs::InitEventList& events) { vle::translator::graph_generator::parameter param{ std::bind(&Builder::graph_generator_make_model, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3), graph_generator_connectivity(), directed }; vle::translator::graph_generator gg(param); if (events.exist("fraction")) gg.make_erdos_renyi(*this, generator, model_number, events.getDouble("fraction"), events.getBoolean("allow-self-loops")); else gg.make_erdos_renyi(*this, generator, model_number, events.getInt("edges_number"), events.getBoolean("allow-self-loops")); }
void use_1d_regular_graph_generator(const vle::devs::InitEventList& events) { vle::translator::regular_graph_generator::parameter param{ std::bind(&Builder::regular_graph_generator_make_model, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3), regular_graph_generator_connectivity() }; vle::translator::regular_graph_generator rgg(param); const auto& v = events.getSet("mask").value(); std::vector<std::string> mask; std::transform(v.begin(), v.end(), std::back_inserter(mask), [](const auto& v) { return v->toString().value(); }); rgg.make_1d(*this, events.getInt("lenght"), events.getBoolean("graph-wrap"), mask, events.getInt("x-mask")); }
TimeSlicingMethod(DifferentialEquation& eq, const vd::InitEventList& events) : DifferentialEquationImpl(eq, events), devs_state(INIT), devs_options(), devs_guards(), devs_internal(), int_method(*this, events) { if (events.exist("output_period")) { const value::Value& v = *(events.get("output_period")); devs_options.output_period = 0; if (v.isInteger()) { devs_options.output_period = v.toInteger().value(); } if (devs_options.output_period < 1) { throw utils::ModellingError(vle::utils::format( "[%s] Parameter 'output_period' should be an int > 0", getModelName().c_str())); } } if (events.exist("time_step")) { devs_options.dt = events.getDouble("time_step"); if (devs_options.dt <= 0) { throw utils::ModellingError(vle::utils::format( "[%s] Parameter 'time_step' should be > 0", getModelName().c_str())); } } }
Generator(const vd::DynamicsInit& init, const vd::InitEventList& events) : vd::Dynamics(init, events) { vg::ConnectionList my_list; // m_duration = vv::toDouble(events.get("duration")); m_duration = 0.1; if (events.end() != events.find("source_init_level")) { m_val = vv::toDouble(events.get("source_init_level")); } else { m_val = 1; Trace(6, "Warning : Model %s got no init" " output level (source_init_level) : assuming 1\n", getModelName().c_str()); } if (events.end() != events.find("source_trend")) { m_trend = vv::toDouble(events.get("source_trend")); if (events.end() != events.find("source_quantum")) { m_quantum = vv::toDouble(events.get("source_quantum")); } else { m_quantum = 0.01; Trace(6, "Warning : Model %s got no output" " quantum (source_quantum) : assuming 0.01\n", getModelName().c_str()); } } else { m_trend = 0; Trace(6, "%s got no output trend (source_trend)" " : assuming 0\n", getModelName().c_str()); // no trend => quantum is useless but.. m_quantum = 0.01; } if (0 == m_quantum) { throw vu::ModellingError("Model %s has null output quantum.", getModelName().c_str()); } m_has_output_port = false; my_list = getModel().getOutputPortList(); if (my_list.size() > 0) { m_output_port_label = (my_list.begin())->first; m_has_output_port = true; } if (my_list.size() > 1) { Trace(6, "Warning: multiple output ports." " Will use only port %s\n", m_output_port_label.c_str()); } }
Rm(const vle::devs::DynamicsInit& model, const vle::devs::InitEventList& events) : DifferentialEquation(model,events) { gamma = events.getDouble("gamma"); //= 0.2 nu = events.getDouble("nu");// = 0.0 R.init(this, "R", events); S.init(this, "S", events); I.init(this, "I", events); }
Rm(const vle::devs::DynamicsInit& model, const vle::devs::InitEventList& events) : ved::DifferentialEquation(model,events) { gamma = events.getDouble("gamma"); //= 0.2 nu = events.getDouble("nu");// = 0.0 R = createVar("R"); S = createExt("S"); I = createExt("I"); }
LotkaVolterraY(const vle::devs::DynamicsInit& model, const vle::devs::InitEventList& events) : DifferentialEquation(model,events) { gamma = (events.exist("gamma")) ? events.getDouble("gamma") : 0.5; delta = (events.exist("delta")) ? events.getDouble("delta") : 0.5; Y.init(this, "Y", events); X.init(this, "X", events); }
LotkaVolterraX(const vle::devs::DynamicsInit& model, const vle::devs::InitEventList& events) : ved::DifferentialEquation(model,events) { alpha = (events.exist("alpha")) ? events.getDouble("alpha") : 0.5; beta = (events.exist("beta")) ? events.getDouble("beta") : 0.5; X = createVar("X"); Y = createExt("Y"); }
LotkaVolterraY(const vle::devs::DynamicsInit& model, const vle::devs::InitEventList& events) : ved::DifferentialEquation(model,events) { gamma = (events.exist("gamma")) ? events.getDouble("gamma") : 0.5; delta = (events.exist("delta")) ? events.getDouble("delta") : 0.5; Y = createVar("Y"); X = createExt("X"); }
Sm(const vle::devs::DynamicsInit& model, const vle::devs::InitEventList& events) : ved::DifferentialEquation(model,events) { beta = events.getDouble("beta");// = 0.9 nu = events.getDouble("nu");// = 0.0 S = createVar("S"); E = createExt("E"); I = createExt("I"); R = createExt("R"); }
ExBohachevsky(const vd::DynamicsInit& init, const vd::InitEventList& events) : vd::Dynamics(init,events) { x1 = events.getDouble("x1"); x2 = events.getDouble("x2"); my = pow(x1,2) + 2 * pow(x2,2) - 0.3 * cos(3 * M_PI * x1) - 0.4 * cos(4 * M_PI * x2) + 0.7; mrand.seed(events.getInt("seed")); double noise = mrand.normal(0,0.1); my_noise = my + noise; }
void use_defined_graph_generator(const vle::devs::InitEventList& events) { vle::utils::Array<bool> userdefined(model_number, model_number); { const auto& v = events.getTuple("user-defined"); if (v.size() != vle::utils::numeric_cast<std::size_t>( model_number * model_number)) throw vle::utils::ModellingError( "User defined model size error"); int pos = 0; for (int i = 0; i != model_number; ++i) for (int j = 0; j != model_number; ++j, ++pos) userdefined(i, j) = (v.get(pos) != 0.0); } vle::translator::graph_generator::parameter param{ std::bind(&Builder::graph_generator_make_model, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3), graph_generator_connectivity(), directed }; vle::translator::graph_generator gg(param); gg.make_graph(*this, model_number, userdefined); }
M( const vd::DynamicsInit& init, const vd::InitEventList& events) : ve::DifferentialEquation(init, events) { C3 = createVar("C3"); C1 = createVar("C1"); DSAT = createVar("DSAT"); C2 = createVar("C2"); if (events.exist("p1")) p1 = events.getDouble("p1"); else throw vle::utils::ModellingError("Parameter p1 not found"); }
Seir(const vle::devs::DynamicsInit& model, const vle::devs::InitEventList& events) : DifferentialEquation(model,events) { beta = events.getDouble("beta");// = 0.9 gamma = events.getDouble("gamma"); //= 0.2 sigma = events.getDouble("sigma"); // = 0.5 nu = events.getDouble("nu");// = 0.0 S.init(this, "S", events); E.init(this, "E", events); I.init(this, "I", events); R.init(this, "R", events); n = S()+E()+I()+R(); }
XRay::XRay(const vd::DynamicsInit& init, const vd::InitEventList& events) : vd::Dynamics(init, events) { mProbabilityRightSR = vv::toDouble(events.get("probabilityRightSR")); mProbabilityRightI = vv::toDouble(events.get("probabilityRightI")); mObservationTimeStep = vv::toDouble(events.get("timeStep")); if (events.exist("R_INIT") and (vv::toBoolean(events.get("R_INIT")))) { mNbModel =vv::toInteger(events.get("graphInfo_number")); mPrefix =vv::toString(events.get("graphInfo_prefix")); } else { mNbModel = events.getMap("graphInfo").getInt("number"); mPrefix = events.getMap("graphInfo").getString("prefix"); } mSampleSize = /*boost::lexical_cast<int>*/ (vv::toDouble(events.get("echProp")) * mNbModel); //std::cout<<"smplesize= "<<mSampleSize<<"\n"; mPrevalence=0.; mIncidence=0.; }
LogEx(const vle::devs::DynamicsInit& init, const vle::devs::InitEventList& events) : DiscreteTimeDyn(init, events) { x.init(this, "x",events); y.init(this, "y",events); y_noise.init(this, "y_noise",events); y.init_value(x()); y_noise.init_value(x()); mrand.seed(events.getInt("seed")); }
Im(const vle::devs::DynamicsInit& model, const vle::devs::InitEventList& events) : ved::DifferentialEquation(model,events) { gamma = events.getDouble("gamma"); //= 0.2 sigma = events.getDouble("sigma"); // = 0.5 I = createVar("I"); E = createExt("E"); }
Im(const vle::devs::DynamicsInit& model, const vle::devs::InitEventList& events) : DifferentialEquation(model,events) { gamma = events.getDouble("gamma"); //= 0.2 sigma = events.getDouble("sigma"); // = 0.5 I.init(this, "I", events); E.init(this, "E", events); }
void use_regular_graph_generator(const vle::devs::InitEventList& events) { int dimension = events.getInt("graph-dimension"); if (dimension == 1) use_1d_regular_graph_generator(events); else if (dimension == 2) use_2d_regular_graph_generator(events); else throw vle::utils::ModellingError( "Undefined regular graph with %d dimension", dimension); }
Y( const vd::DynamicsInit& init, const vd::InitEventList& events) : ve::DifferentialEquation(init, events) { X = createVar("X"); maturing = createVar("maturing"); masse = createVar("masse"); if (events.exist("KS")) KS = events.getDouble("KS"); else throw vle::utils::ModellingError("Parameter KS not found"); if (events.exist("KG")) KG = events.getDouble("KG"); else throw vle::utils::ModellingError("Parameter KG not found"); }
void use_sortederdesrenyi_graph_generator( const vle::devs::InitEventList& events) { vle::translator::graph_generator::parameter param{ std::bind(&Builder::graph_generator_make_model, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3), graph_generator_connectivity(), directed }; vle::translator::graph_generator gg(param); gg.make_sorted_erdos_renyi(*this, generator, model_number, events.getDouble("probability"), events.getBoolean("allow-self-loops")); }
void use_graph_generator(const vle::devs::InitEventList& events) { model_number = events.getInt("model-number"); std::string generator_name = events.getString("graph-generator"); if (events.exist("graph-seed")) generator.seed(events.getInt("graph-seed")); if (generator_name == "defined") use_defined_graph_generator(events); else if (generator_name == "small-world") use_smallworld_graph_generator(events); else if (generator_name == "scale-free") use_scalefree_graph_generator(events); else if (generator_name == "sorted-erdos-renyi") use_sortederdesrenyi_graph_generator(events); else if (generator_name == "erdos_renyi") use_erdosrenyi_graph_generator(events); else throw vle::utils::ModellingError("Unknown graph gererator: %s", generator_name.c_str()); }
Smartgardener( const vd::DynamicsInit& init, const vd::InitEventList& evts) : vmd::Agent(init, evts), plantlouse_population(0), ladybird_population(0), treatment_effect_on_plantlouse(0), treatment_effect_on_ladybird(0), plantlouse_max_population(1000), ladybird_min_population(-1000) { treatment_effect_on_plantlouse = evts.getDouble("treatment_effect_on_plantlouse"); treatment_effect_on_ladybird = evts.getDouble("treatment_effect_on_ladybird"); plantlouse_max_population = evts.getDouble("plantlouse_max_population"); ladybird_min_population = evts.getDouble("ladybird_min_population"); addPredicates(this) += P("TwoManyPlantlouse", &Smartgardener::TwoManyPlantlouse), P("NotToSmallLadybirdPopulation", &Smartgardener::NotToSmallLadybirdPopulation); addFacts(this) += F("x", &Smartgardener::x), F("y", &Smartgardener::y); addOutputFunctions(this) += O("treat", &Smartgardener::treat); vle::utils::Package pack(context(), "vle.examples"); std::string filePath = pack.getDataFile("Smartgardener.txt"); std::ifstream fileStream(filePath.c_str()); KnowledgeBase::plan().fill(fileStream); }
void use_2d_regular_graph_generator(const vle::devs::InitEventList& events) { vle::translator::regular_graph_generator::parameter param{ std::bind(&Builder::regular_graph_generator_make_model, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3), regular_graph_generator_connectivity() }; vle::translator::regular_graph_generator rgg(param); int width_mask = events.getInt("mask-width"); int height_mask = events.getInt("mask-height"); vle::utils::Array<std::string> mask(width_mask, height_mask); const auto& v = events.getSet("mask").value(); { if (vle::utils::numeric_cast<int>(mask.size()) != width_mask * height_mask) throw vle::utils::ModellingError("mask definition error"); int i = 0, j = 0; for (const auto& str : v) { mask(i, j) = str->toString().value(); ++j; if (j >= height_mask) { i++; j = 0; } } } rgg.make_2d(*this, { { events.getInt("width"), events.getInt("height") } }, { { events.getBoolean("wrap-width"), events.getBoolean("wrap-height") } }, mask, events.getInt("x-mask"), events.getInt("y-mask")); }
CompareDateAI(const vle::devs::ExecutiveInit &init, const vle::devs::InitEventList &evts) : vle::devs::Executive(init, evts) { vle::utils::Package package("safihr.cropmodel"); initialize_date(package.getDataFile(evts.getString("filename"))); std::sort(date.begin(), date.end(), [] (const data& lhs, const data& rhs) { return lhs.dmin < rhs.dmin; }); DTraceModel(vle::fmt("AI need to build: %1% models") % date.size()); DTraceModel(vle::fmt("Table: %1%") % date); }
Builder(const vle::devs::ExecutiveInit& init, const vle::devs::InitEventList& events) : vle::devs::Executive(init, events) { model_prefix = events.getString("model-prefix"); model_classname = events.getString("model-class"); condition_name = events.getString("node-condition"); graph_type = events.getString("graph-type"); graph_connectivity = events.getString("graph-connectiviy"); directed = events.getBoolean("graph-directed"); if (graph_type == "graph") use_graph_generator(events); else if (graph_type == "regular") use_regular_graph_generator(events); else throw vle::utils::ModellingError("Unknown graph type %s", graph_type.c_str()); }
AdaptativeQuantifier(const vd::DynamicsInit &init, const vd::InitEventList &events) : vd::Dynamics(init, events) { const auto& my_list = getModel().getOutputPortList(); if (not my_list.empty()) { m_output_port_label = (my_list.begin())->first; m_has_output_port = true; } if (my_list.size() > 1) Trace(context(), 6, "Warning: multiple output ports." " Will use only port %s\n", m_output_port_label.c_str()); m_adaptative = true; if (events.end() != events.find("allow_offsets")) { m_adaptative = vv::toBoolean(events.get("allow_offsets")); } if (m_adaptative) { m_adapt_state = POSSIBLE; } else { m_adapt_state = IMPOSSIBLE; } m_zero_init_offset = false; if (events.end() != events.find("zero_init_offset")) { m_zero_init_offset = vv::toBoolean(events.get("zero_init_offset")); } if (events.end() != events.find("quantum")) { m_step_size = vv::toDouble(events.get("quantum")); } else { Trace(context(), 6, "Warning : no quantum value provided for" " Quantifier %s. Using default value (0.1)\n", getModelName().c_str()); m_step_size = 0.1; } if (0 >= m_step_size) throw vu::ModellingError("Bad quantum value (provided value : %f, " "should be strictly positive)", m_step_size); if (events.end() != events.find("archive_length")) { m_past_length = vv::toInteger(events.get("archive_length")); } else { m_past_length = 3; } if (2 >= m_past_length) { throw vu::ModellingError("Bad archive length value ( provided value" ": %u, should at least 3)", m_past_length); } }
ActivityScheduler(const vle::devs::DynamicsInit& init, const vle::devs::InitEventList& events) : vle::devs::Dynamics(init, events), mActivities(events.get("activities")) { }
ConstantGenerator(const vle::devs::DynamicsInit &init, const vle::devs::InitEventList &events) : vle::devs::Dynamics(init, events) { m_neighborhood = events.getInt("neighborhood"); }