std::tuple<std::shared_ptr<terrama2::core::DataManager>, std::shared_ptr<terrama2::core::Service>, std::shared_ptr<terrama2::core::ProcessLogger> > createService(const std::string& serviceType) { if(serviceType == collectorType) return createCollector(); if(serviceType == analysisType) return createAnalysis(); if(serviceType == viewType) return createView(); exit(SERVICE_LOAD_ERROR); }
MetronamicaOF2RandstadLargeCaseStudy3Obj(boost::filesystem::path & metro_exe, boost::filesystem::path & mck_exe, boost::filesystem::path & wine_exe, boost::filesystem::path & java_exe, boost::filesystem::path & geoproj_edit_jar, boost::filesystem::path & template_path, boost::filesystem::path & working_dir, boost::filesystem::path & save_dir, std::string &_wine_work_dir, std::string &_geoproj_name, boost::filesystem::path & _logfile_name, boost::filesystem::path & actual_map_path, boost::filesystem::path & original_map_path, boost::filesystem::path & masking_map_path, boost::filesystem::path & fks_coefficients_path, boost::filesystem::path & wine_regedit_path, int _id = 0, bool _is_logging = false, int _replicates = 10) : num_objectives(3), num_real_decision_vars(238), num_int_decision_vars(0), num_constraints(0), replicates(_replicates), geo_cmd(metro_exe), java_geoproj_edit(geoproj_edit_jar), mck_cmd(mck_exe), wine_cmd(wine_exe), java_cmd(java_exe), template_dir(template_path), working_dir(working_dir), save_dir(save_dir), wine_temp_dir(_wine_work_dir), geoproject_name(_geoproj_name), metro_logfile_name(_logfile_name), actual_map(actual_map_path), original_map(original_map_path), masking_map(masking_map_path), fks_coefficients(fks_coefficients_path), wine_regedit(wine_regedit_path), int_lowerbounds(0, std::numeric_limits<int>::min()), int_upperbounds(0, std::numeric_limits<int>::max()), prob_defs(new ProblemDefinitions(min_dv_values, max_dv_values, int_lowerbounds, int_upperbounds, minimise_or_maximise, num_constraints)), objectives_and_constrataints(std::piecewise_construct, std::make_tuple(num_objectives, std::numeric_limits<double>::max()), std::make_tuple(num_constraints)), evaluator_id(_id), is_logging(_is_logging), eval_count(0) { analysisNum = createAnalysis(); loadMapActual(analysisNum, actual_map.c_str()); loadOriginalMap(analysisNum, original_map.c_str()); loadMaskingMap(analysisNum, masking_map.c_str()); loadTransitionFuzzyWeights(analysisNum, fks_coefficients.c_str()); numClasses(analysisNum, 9); std::string temp_dir_template = "Metro_Cal_OF_worker" + std::to_string(evaluator_id) + "_%%%%-%%%%"; worker_dir = boost::filesystem::unique_path(working_dir / temp_dir_template); // create_directories(ph); copyDir(template_dir, worker_dir); namespace fs = boost::filesystem; std::string metro_cp_log_name = "calibration_log_%%%%-%%%%.xml"; boost::filesystem::path metro_cp_log_path = boost::filesystem::unique_path(worker_dir / metro_cp_log_name); fs::copy_file( metro_logfile_name, metro_cp_log_path ); cp_metro_log_name = metro_cp_log_path.filename().string(); // std::string filename = "logWorker" + std::to_string(evaluator_id) + "_WineRegEdit_" + boost::posix_time::to_simple_string(boost::posix_time::second_clock::local_time()) + ".log"; // boost::filesystem::path log_file_name = working_dir / filename; // std::ofstream logging_file; // if (is_logging) // { // logging_file.open(log_file_name.c_str(), std::ios_base::app); // if (!logging_file.is_open()) is_logging = false; // } // std::stringstream cmd; // cmd << wine_cmd << " regedit " << wine_regedit_path; // if (is_logging) cmd << " >> \"" << log_file_name.c_str() << "\" 2>&1"; // if (is_logging) logging_file << "Running: " << cmd.str() << "\n"; // system(cmd.str().c_str()); colour_mapper.push_back(std::make_tuple(255, 255, 160)); colour_mapper.push_back(std::make_tuple(255, 128, 0)); colour_mapper.push_back(std::make_tuple(255, 0, 0)); colour_mapper.push_back(std::make_tuple( 78, 0, 192)); colour_mapper.push_back(std::make_tuple(158, 12, 234)); colour_mapper.push_back(std::make_tuple(255, 87, 255)); colour_mapper.push_back(std::make_tuple( 0, 192, 0)); colour_mapper.push_back(std::make_tuple(192, 157, 0)); colour_mapper.push_back(std::make_tuple( 0, 0, 0)); colour_mapper.push_back(std::make_tuple( 0, 128, 255)); //Make sure the number of dv is correct BOOST_ASSERT(max_dv_values.size() == 520); }
/* This function builds up the netlist representation from the checked netlist input. It creates circuit components as necessary. */ void input::factory (void) { struct definition_t * def, * next; struct node_t * nodes; struct pair_t * pairs; circuit * c; object * o; analysis * a; substrate * s; nodeset * n; int i; // go through the list of input definitions for (def = definition_root; def != NULL; def = next) { next = def->next; // handle actions if (def->action) { if ((a = createAnalysis (def->type)) != NULL) { a->setName (def->instance); // add the properties to analysis for (pairs = def->pairs; pairs != NULL; pairs = pairs->next) if (pairs->value->ident) { if (pairs->value->var && strcmp (pairs->key, "Param")) { variable * v; if ((v = def->env->getVariable (pairs->value->ident)) != NULL) { // equation variable reference in analysis property a->addProperty (pairs->key, v); } else { // should not be reached! a->addProperty (pairs->key, pairs->value->ident); } } else { // ususal string property a->addProperty (pairs->key, pairs->value->ident); } } else { if (pairs->value->var) { // add list sweeps and constants to the properties variable * v = new variable (pairs->key); constant * c = new constant (TAG_VECTOR); c->v = createVector (pairs->value); v->setConstant (c); a->addProperty (pairs->key, v); } else { a->addProperty (pairs->key, pairs->value->value); } } // additionally add missing optional properties assignDefaultProperties (a, def->define); a->setEnv (def->env); subnet->insertAnalysis (a); } // remove this definition from the list definition_root = netlist_unchain_definition (definition_root, def); } } // go through the list of input definitions for (def = definition_root; def != NULL; def = next) { next = def->next; // handle substrate definitions if (!def->action && def->substrate) { if ((s = createSubstrate (def->type)) != NULL) { s->setName (def->instance); // add the properties to substrate for (pairs = def->pairs; pairs != NULL; pairs = pairs->next) if (pairs->value->ident) { // a variable if (pairs->value->var) { // at this stage it should be ensured that the variable is // already in the root environment variable * v = def->env->getVariable (pairs->value->ident); s->addProperty (pairs->key, v); } // a usual string property else { s->addProperty (pairs->key, pairs->value->ident); } } else { s->addProperty (pairs->key, pairs->value->value); } // additionally add missing optional properties assignDefaultProperties (s, def->define); // put new substrate definition into environment char * n = strrchr (def->instance, '.'); variable * v = new variable (n ? n + 1 : def->instance); v->setSubstrate (s); def->env->addVariable (v); } // remove this definition from the list definition_root = netlist_unchain_definition (definition_root, def); } // handle nodeset definitions else if (!def->action && def->nodeset) { n = new nodeset (); n->setName (def->nodes->node); n->setValue (def->pairs->value->value); subnet->addNodeset (n); // remove this definition from the list definition_root = netlist_unchain_definition (definition_root, def); } } // go through the list of input definitions for (def = definition_root; def != NULL; def = next) { next = def->next; // handle component definitions if (!def->action && !def->substrate && !def->nodeset) { c = createCircuit (def->type); assert (c != NULL); o = (object *) c; c->setName (def->instance); c->setNonLinear (def->nonlinear != 0); c->setSubcircuit (def->subcircuit); // change size (number of ports) of variable sized components if (c->isVariableSized ()) { c->setSize (def->ncount); } // add appropriate nodes to circuit for (i = 0, nodes = def->nodes; nodes; nodes = nodes->next, i++) if (i < c->getSize ()) c->setNode (i, nodes->node); // add the properties to circuit for (pairs = def->pairs; pairs != NULL; pairs = pairs->next) { if (pairs->value == NULL) { // zero-length value lists variable * v = new variable (pairs->key); constant * c = new constant (TAG_VECTOR); c->v = new vector (); v->setConstant (c); o->addProperty (pairs->key, v); } else if (pairs->value->ident) { if (pairs->value->var) { // at this stage it should be ensured that the variable is // already in the root environment variable * v = def->env->getVariable (pairs->value->ident); o->addProperty (pairs->key, v); } else { if (pairs->value->subst) { variable * v = def->env->getVariable (pairs->value->ident); c->setSubstrate (v->getSubstrate ()); } o->addProperty (pairs->key, pairs->value->ident); } } else { if (pairs->value->var) { // add value lists to the properties variable * v = new variable (pairs->key); constant * c = new constant (TAG_VECTOR); c->v = createVector (pairs->value); v->setConstant (c); o->addProperty (pairs->key, v); } else { o->addProperty (pairs->key, pairs->value->value); } } } // set local circuit environment c->setEnv (def->env); // additionally add missing optional properties assignDefaultProperties (c, def->define); // insert the circuit into the netlist object subnet->insertCircuit (c); // remove this definition from the list definition_root = netlist_unchain_definition (definition_root, def); } } }