int game_init(const char *file_name, const char *back_name, const char *grad_name, int t, int e) { my_clock = (float) t / 100.f; if (game_state) game_free(); game_ix = 0.f; game_iz = 0.f; game_rx = 0.f; game_rz = 0.f; /* Initialize jump and goal states. */ jump_e = 1; jump_b = 0; goal_e = e ? 1 : 0; goal_k = e ? 1.0f : 0.0f; /* Reset the hud. */ hud_ball_pulse(0.f); hud_time_pulse(0.f); hud_coin_pulse(0.f); /* Initialise the level, background, particles, fade, and view. */ fade_k = 1.0f; fade_d = -2.0f; part_reset(GOAL_HEIGHT); view_init(); back_init(grad_name, config_get_d(CONFIG_GEOMETRY)); if (sol_load(&back, config_data(back_name), config_get_d(CONFIG_TEXTURES), 0) && sol_load(&file, config_data(file_name), config_get_d(CONFIG_TEXTURES), config_get_d(CONFIG_SHADOW))) return (game_state = 1); else return (game_state = 0); }
convchecker(double timeout_sec): rpc_server(timeout_sec) { rpc_server::add<bool(std::string, config_data) >("set_config", pfi::lang::bind(&Impl::set_config, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<config_data(std::string) >("get_config", pfi::lang::bind(&Impl::get_config, static_cast<Impl*>(this), pfi::lang::_1)); rpc_server::add<std::string(std::string, datum) >("query", pfi::lang::bind(&Impl::query, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<std::string(std::string, std::vector<datum >) >("bulk_query", pfi::lang::bind(&Impl::bulk_query, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<bool(std::string, std::string) >("save", pfi::lang::bind(&Impl::save, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<bool(std::string, std::string) >("load", pfi::lang::bind(&Impl::load, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<std::map<std::string, std::map<std::string, std::string > >(std::string) >("get_status", pfi::lang::bind(&Impl::get_status, static_cast<Impl*>(this), pfi::lang::_1)); }
static sp_session * create_session(PyObject *client, PyObject *settings) { sp_session_config config; sp_session* session; sp_error error; memset(&config, 0, sizeof(config)); config.api_version = SPOTIFY_API_VERSION; config.userdata = (void*)client; config.callbacks = &g_callbacks; config.cache_location = ""; config.user_agent = "pyspotify-fallback"; config_data(settings, "application_key", &config.application_key, &config.application_key_size); config_string(settings, "cache_location", &config.cache_location); config_string(settings, "settings_location", &config.settings_location); config_string(settings, "user_agent", &config.user_agent); config_string(client, "proxy", &config.proxy); config_string(client, "proxy_username", &config.proxy_username); config_string(client, "proxy_password", &config.proxy_password); debug_printf("cache_location = %s", config.cache_location); debug_printf("settings_location = %s", config.settings_location); debug_printf("user_agent = %s", config.user_agent); debug_printf("proxy = %s", config.proxy); debug_printf("proxy_username = %s", config.proxy_username); debug_printf("proxy_password = %s", config.proxy_password); debug_printf("application_key_size = %zu", config.application_key_size); if (PyErr_Occurred() != NULL) { return NULL; } if (strlen(config.user_agent) > 255) { PyErr_SetString(SpotifyError, "user_agent may not be longer than 255."); return NULL; } if (config.application_key_size == 0) { PyErr_SetString(SpotifyError, "application_key must be provided."); return NULL; } debug_printf("creating session..."); /* TODO: Figure out if we should ever release the session */ error = sp_session_create(&config, &session); if (error != SP_ERROR_OK) { PyErr_SetString(SpotifyError, sp_error_message(error)); return NULL; } session_constructed = 1; g_session = session; return session; }
static nodes_data::ptr configure_test_setup(const std::string &path) { start_nodes_config start_config(results_reporter::get_stream(), std::vector<server_config>({ server_config::default_value().apply_options(config_data() ("group", 5) ("cache_size", "100K") ("cache_shards", 1) ) }), path); return start_nodes(start_config); }
static void configure_nodes(const std::vector<std::string> &remotes, const std::string &path) { if (remotes.empty()) { global_data = start_nodes(results_reporter::get_stream(), std::vector<server_config>({ server_config::default_value().apply_options(config_data() ("group", 2) ) }), path); } else { global_data = start_nodes(results_reporter::get_stream(), remotes, path); } }
void read_nwchem_task(gpointer scan, gpointer config, gint *symbols, gint num_symbols) { gint i, value; struct nwchem_pak *nwchem; //printf("task line = %s\n", scan_cur_line(scan)); nwchem = config_data(config); if (!nwchem) return; for (i=0 ; i<num_symbols ; i++) { value = symbols[i]; switch (value) { /* theory */ case NWCHEM_TASK_SCF: case NWCHEM_TASK_DFT: case NWCHEM_TASK_MP2: case NWCHEM_TASK_DIRECT_MP2: case NWCHEM_TASK_RIMP2: case NWCHEM_TASK_CCSD: case NWCHEM_TASK_CCSD3: case NWCHEM_TASK_CCSD4: case NWCHEM_TASK_MCSCF: case NWCHEM_TASK_SELCI: case NWCHEM_TASK_MD: case NWCHEM_TASK_PSPW: case NWCHEM_TASK_BAND: case NWCHEM_TASK_TCE: g_free(nwchem->task_theory); nwchem->task_theory = g_strdup(nwchem_symbol_table[value]); break; /* operation */ case NWCHEM_TASK_ENERGY: case NWCHEM_TASK_GRADIENT: case NWCHEM_TASK_OPTIMIZE: case NWCHEM_TASK_SADDLE: case NWCHEM_TASK_HESSIAN: case NWCHEM_TASK_FREQUENCIES: case NWCHEM_TASK_PROPERTY: case NWCHEM_TASK_DYNAMICS: case NWCHEM_TASK_THERMODYNAMICS: g_free(nwchem->task_operation); nwchem->task_operation = g_strdup(nwchem_symbol_table[value]); break; } } }
void read_nwchem_basis_library(gpointer scan, gpointer config) { gint i, num_tokens; gchar *line, **buff1, **buff2; struct nwchem_pak *nwchem; nwchem = config_data(config); if (!nwchem) return; while (!scan_complete(scan)) { line = scan_get_line(scan); if (g_strrstr(line, "end")) break; #if DEBUG_READ_NWCHEM_BASIS_LIBRARY printf("+%s", line); #endif /* cope with ";" element separator */ buff1 = g_strsplit(line, ";", -1); i=0; if (buff1) { while (buff1[i]) { buff2 = tokenize(buff1[i], &num_tokens); if (num_tokens > 2) { #if DEBUG_READ_NWCHEM_BASIS_LIBRARY printf("[%s] -> [%s]\n", buff2[0], buff2[2]); #endif g_hash_table_insert(nwchem->library, g_strdup(buff2[0]), g_strdup(buff2[2])); } g_strfreev(buff2); i++; } } g_strfreev(buff1); } }
recommender(double timeout_sec): rpc_server(timeout_sec) { rpc_server::add<bool(std::string, config_data) >("set_config", pfi::lang::bind(&Impl::set_config, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<config_data(std::string) >("get_config", pfi::lang::bind(&Impl::get_config, static_cast<Impl*>(this), pfi::lang::_1)); rpc_server::add<bool(std::string, std::string) >("clear_row", pfi::lang::bind(&Impl::clear_row, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<bool(std::string, std::string, datum) >("update_row", pfi::lang::bind(&Impl::update_row, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2, pfi::lang::_3)); rpc_server::add<bool(std::string) >("clear", pfi::lang::bind(&Impl::clear, static_cast<Impl*>(this), pfi::lang::_1)); rpc_server::add<datum(std::string, std::string) >("complete_row_from_id", pfi::lang::bind(&Impl::complete_row_from_id, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<datum(std::string, datum) >("complete_row_from_data", pfi::lang::bind(&Impl::complete_row_from_data, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<similar_result(std::string, std::string, uint32_t) >("similar_row_from_id", pfi::lang::bind(&Impl::similar_row_from_id, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2, pfi::lang::_3)); rpc_server::add<similar_result(std::string, datum, uint32_t) >("similar_row_from_data", pfi::lang::bind(&Impl::similar_row_from_data, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2, pfi::lang::_3)); rpc_server::add<datum(std::string, std::string) >("decode_row", pfi::lang::bind(&Impl::decode_row, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<std::vector<std::string >(std::string) >("get_all_rows", pfi::lang::bind(&Impl::get_all_rows, static_cast<Impl*>(this), pfi::lang::_1)); rpc_server::add<float(std::string, datum, datum) >("similarity", pfi::lang::bind(&Impl::similarity, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2, pfi::lang::_3)); rpc_server::add<float(std::string, datum) >("l2norm", pfi::lang::bind(&Impl::l2norm, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<bool(std::string, std::string) >("save", pfi::lang::bind(&Impl::save, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<bool(std::string, std::string) >("load", pfi::lang::bind(&Impl::load, static_cast<Impl*>(this), pfi::lang::_1, pfi::lang::_2)); rpc_server::add<std::map<std::string, std::map<std::string, std::string > >(std::string) >("get_status", pfi::lang::bind(&Impl::get_status, static_cast<Impl*>(this), pfi::lang::_1)); }
void ConfigFileReader::read() { std::ifstream config_data(filename_.c_str()); if (config_data.fail()) { std::cerr << "Cannot open " << filename_ << std::endl; exit(-1); } std::string config_string; while (!config_data.eof()) { std::string line; getline(config_data,line); config_string.append(line + "\n"); } try { manager_->read(config_string); } catch (ConfigParseError e) { std::cerr << "Invalid input in " << filename_ << ": '" << e.getLine() << "'" << std::endl; exit(-1); } }
config_data config_data::default_srw_value() { return config_data() ("log", "/dev/stderr") ("log_level", DNET_LOG_DEBUG) ("join", 1) ("flags", 4) ("group", DUMMY_VALUE) ("addr", DUMMY_VALUE) ("remote", DUMMY_VALUE) ("wait_timeout", 60) ("check_timeout", 60) ("io_thread_num", 50) ("nonblocking_io_thread_num", 16) ("net_thread_num", 16) ("indexes_shard_count", 16) ("history", DUMMY_VALUE) ("daemon", 0) ("auth_cookie", DUMMY_VALUE) ("bg_ionice_class", 3) ("bg_ionice_prio", 0) ("server_net_prio", 1) ("client_net_prio", 6) ("cache_size", 1024 * 1024 * 256) ("caches_number", 16) ("srw_config", DUMMY_VALUE) ("monitor_port", 1027) ("backend", "blob") ("sync", 5) ("data", DUMMY_VALUE) ("data_block_size", 1024) ("blob_flags", 6) ("iterate_thread_num", 1) ("blob_size", "10M") ("records_in_blob", 10000000) ("defrag_timeout", 3600) ("defrag_percentage", 25); }
// no coords - just control data for the run // coords - .pdb file // topology - .frx file gint reaxmd_input_import(gpointer import) { gint *symbols, num_symbols, unknown; gchar *line, *fullname_model; gchar *filename, *filepath; gpointer scan, config; GString *unparsed; struct reaxmd_pak *reaxmd; struct model_pak *model; FILE *fp; scan = scan_new(import_fullpath(import)); if (!scan) return(1); /* populate symbol table */ reaxmd_symbols_init(scan); config = config_new(REAXMD, NULL); reaxmd = config_data(config); unparsed = g_string_new(NULL); while (!scan_complete(scan)) { symbols = scan_get_symbols(scan, &num_symbols); if (num_symbols) { unknown = FALSE; /* process first recognized symbol */ switch (symbols[0]) { case REAXMD_NSTEPS: reaxmd->total_steps = parse_nth_token_dup(1, scan_cur_line(scan)); break; case REAXMD_TIMESTEP: case REAXMD_TEMPERATURE: case REAXMD_THERMOSTAT: case REAXMD_BAROSTAT: case REAXMD_CUTOFF: case REAXMD_UPDATE: case REAXMD_NWRITE: case REAXMD_GRID: break; case REAXMD_PLUMED_FILE: filename = parse_nth_token_dup(1, scan_cur_line(scan)); filepath = g_build_filename(import_path(import), filename, NULL); //printf("Looking for: %s\n", filepath); if (g_file_test(filepath, G_FILE_TEST_EXISTS)) project_job_file_append(NULL, filepath, sysenv.workspace); else gui_text_show(ERROR, "REAXMD plumed file was not found!\n"); g_free(filename); g_free(filepath); break; default: unknown = TRUE; } g_free(symbols); } else unknown=TRUE; if (unknown) { line = scan_cur_line(scan); if (line) g_string_append(unparsed, line); } } config_unparsed_set(g_string_free(unparsed, FALSE), config); /* CURRENT - free this, until we add a GUI */ //import_object_add(IMPORT_CONFIG, config, import); config_free(config); /* done irx parse */ scan_free(scan); /* NEW - attempt to load reference coordinates */ fullname_model = parse_extension_set(import_fullpath(import), "pdb"); fp = fopen(fullname_model, "rt"); if (fp) { model = model_new(); read_pdb_block(fp, model); fclose(fp); import_object_add(IMPORT_MODEL, model, import); } else { gui_text_show(WARNING, "Failed to open reference PDB model for ReaxMD.\n"); } g_free(fullname_model); /* init */ import_init(import); return(0); }
config_data get_config(std::string name) { return call<config_data(std::string)>("get_config")(name); }
gint nwchem_input_export(gpointer import) { gint i, n; gdouble x[3]; gchar *text; gpointer config, value; GList *list, *keys; GSList *item; GString *buffer; struct model_pak *model; struct nwchem_pak *nwchem; struct core_pak *core; model = import_object_nth_get(IMPORT_MODEL, 0, import); if (!model) return(1); config = import_config_get(NWCHEM, import); if (!config) config = config_new(NWCHEM, NULL); //nwchem = import_config_data_get(NWCHEM, import); nwchem = config_data(config); if (!nwchem) { printf("Error: couldn't obtain an nwchem config.\n"); return(2); } buffer = g_string_new(NULL); g_string_append_printf(buffer, "#--- created by GDIS\n\n"); /* output start */ if (nwchem->start) g_string_append_printf(buffer, "%s\n", nwchem->start); /* output charge */ if (nwchem->charge) g_string_append_printf(buffer, "charge %s\n\n", nwchem->charge); /* output periodicity info */ switch (model->periodic) { case 3: g_string_append_printf(buffer, "system crystal\n"); g_string_append_printf(buffer, "lat_a %f lat_b %f lat_c %f\n", model->pbc[0], model->pbc[1], model->pbc[2]); g_string_append_printf(buffer, "alpha %f beta %f gamma %f\n", R2D*model->pbc[3], R2D*model->pbc[4], R2D*model->pbc[5]); g_string_append_printf(buffer, "end\n"); break; case 2: g_string_append_printf(buffer, "system surface\n"); g_string_append_printf(buffer, "lat_a %f lat_b %f\n", model->pbc[0], model->pbc[1]); g_string_append_printf(buffer, "gamma %f\n", R2D*model->pbc[5]); g_string_append_printf(buffer, "end\n"); break; case 1: g_string_append_printf(buffer, "system polymer\n"); g_string_append_printf(buffer, "lat_a %f\n", model->pbc[0]); g_string_append_printf(buffer, "end\n"); break; } /* output geometry */ g_string_append_printf(buffer, "geometry\n"); n = zmat_entries_get(model->zmatrix); if (n) { g_string_append_printf(buffer, " zmatrix\n"); text = zmatrix_connect_text(model->zmatrix); g_string_append(buffer, text); g_free(text); g_string_append_printf(buffer, " constants\n"); text = zmatrix_constants_text(model->zmatrix); g_string_append(buffer, text); g_free(text); g_string_append_printf(buffer, " variables\n"); text = zmatrix_variables_text(model->zmatrix); g_string_append(buffer, text); g_free(text); g_string_append_printf(buffer, " end\n"); } else { for (item=model->cores ; item ; item=g_slist_next(item)) { core = item->data; /* cartesian coords */ ARR3SET(x, core->x); vecmat(model->latmat, x); /* set fractional part */ for (i=0 ; i<model->periodic ; i++) if (model->fractional) x[i] = core->x[i]; /* from NWCHEM manual, coords are always fractional in periodic directions, else cartesian */ g_string_append_printf(buffer, "%s %f %f %f\n", core->atom_label, x[0], x[1], x[2]); } } g_string_append_printf(buffer, "end\n\n"); /* output basis library */ keys = g_hash_table_get_keys(nwchem->library); if (g_list_length(keys)) { g_string_append_printf(buffer, "basis\n"); for (list=keys ; list ; list=g_list_next(list)) { value = g_hash_table_lookup(nwchem->library, list->data); g_string_append_printf(buffer, "%s library %s\n", (gchar *) list->data, (gchar *) value); } g_string_append_printf(buffer, "end\n"); } /* unparsed */ // TODO - if it's just blank lines - skip text = config_unparsed_get(config); if (text) g_string_append_printf(buffer, "\n# --- unparsed start ---\n\n%s\n# --- unparsed stop ---\n\n", text); /* last item is the task to be performed */ /* CURRENT - some files may not have a task? */ if (nwchem->task_operation) { g_string_append_printf(buffer, "task"); if (nwchem->task_theory) g_string_append_printf(buffer, " %s", nwchem->task_theory); if (nwchem->task_operation) g_string_append_printf(buffer, " %s", nwchem->task_operation); } /* all done, write to disk or preview mode? */ if (import_preview_get(import)) { /* preview mode only */ import_preview_buffer_set(buffer->str, import); g_string_free(buffer, FALSE); } else { /* flush contents to disk */ g_file_set_contents(import_fullpath(import), buffer->str, -1, NULL); g_string_free(buffer, TRUE); } return(1); }
gint nwchem_input_import(gpointer import) { gint *symbols, num_symbols, num_tokens, value; gchar *line, **buff; gpointer scan, config; GString *unparsed; struct model_pak *model=NULL; // CURRENT - will break if more than one in a file struct nwchem_pak *nwchem; scan = scan_new(import_fullpath(import)); if (!scan) return(1); /* populate symbol table */ nwchem_scan_symbols_init(scan); config = config_new(NWCHEM, NULL); nwchem = config_data(config); unparsed = g_string_new(NULL); while (!scan_complete(scan)) { symbols = scan_get_symbols(scan, &num_symbols); if (num_symbols) { /* process first recognized symbol */ value = symbols[0]; switch (value) { case NWCHEM_START: /* TODO - could this serve as title? */ nwchem->start = parse_strip(scan_cur_line(scan)); break; case NWCHEM_BASIS: // TODO - don't want to use this for predefined basis sets read_nwchem_basis_library(scan, config); break; case NWCHEM_CHARGE: line = scan_cur_line(scan); buff = tokenize(line, &num_tokens); if (num_tokens > 1) nwchem->charge = g_strdup(buff[1]); g_strfreev(buff); break; case NWCHEM_GEOMETRY: if (!model) { model = model_new(); import_object_add(IMPORT_MODEL, model, import); } read_nwchem_geometry(scan, model); break; case NWCHEM_SYSTEM: if (!model) { model = model_new(); import_object_add(IMPORT_MODEL, model, import); } read_nwchem_system(scan, model); break; case NWCHEM_TASK: read_nwchem_task(scan, config, symbols, num_symbols); break; default: /* add lines that have recognized symbols (but no special trigger) to unparsed */ /* this'll happen for symbols that occur in multiple locations (eg dft) */ line = scan_cur_line(scan); if (line) g_string_append(unparsed, line); } g_free(symbols); } else { /* add non-NULL lines to unparsed list */ line = scan_cur_line(scan); if (line) g_string_append(unparsed, line); } } config_unparsed_set(g_string_free(unparsed, FALSE), config); import_object_add(IMPORT_CONFIG, config, import); scan_free(scan); import_init(import); return(0); }
/* TODO - separate widget from config so it can be re-used */ void gui_siesta_widget(GtkWidget *box, gpointer config) { gchar *text; GSList *list, *list1; GtkWidget *notebook, *vbox, *hbox, *label, *textbox; GtkWidget *page, *left, *right; struct siesta_pak *siesta; g_assert(box != NULL); g_assert(config != NULL); siesta = config_data(config); /* true false (default) list */ list1 = NULL; list1 = g_slist_prepend(list1, "False"); list1 = g_slist_prepend(list1, "True"); list1 = g_slist_prepend(list1, ""); /* build widget */ notebook = gtk_notebook_new(); gtk_container_add(GTK_CONTAINER(box), notebook); /* file write page */ page = gtk_vbox_new(FALSE, 0); label = gtk_label_new(" File I/O "); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); vbox = gui_frame_vbox(NULL, FALSE, FALSE, page); gui_text_entry("System Label ", &siesta->system_label, TRUE, TRUE, vbox); /* vbox = gui_frame_vbox("Mesh potential", FALSE, FALSE, page); gui_text_entry("Density of states ", &siesta->density_of_states, TRUE, FALSE, vbox); gui_text_entry("Density on mesh ", &siesta->density_on_mesh, TRUE, FALSE, vbox); gui_text_entry("Electrostatic pot on mesh ", &siesta->electrostatic_pot_on_mesh, TRUE, FALSE, vbox); */ hbox = gui_frame_hbox(NULL, FALSE, FALSE, page); left = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), left, TRUE, TRUE, 0); right = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), right, TRUE, TRUE, 0); /* left */ gui_pd_new("Use saved data", &siesta->use_saved_data, list1, left); gui_pd_new("Long output ", &siesta->long_output, list1, left); gui_pd_new("Write coordinates", &siesta->write_coor_step, list1, left); gui_pd_new("Write cerius coordinates", &siesta->write_coor_cerius, list1, left); gui_pd_new("Write xmol coordinates", &siesta->write_coor_xmol, list1, left); gui_pd_new("Write xmol animation", &siesta->write_md_xmol, list1, left); gui_pd_new("Write trajectory history", &siesta->write_md_history, list1, left); gui_pd_new("Write forces", &siesta->write_forces, list1, left); /* right */ gui_pd_new("Write wavefunctions", &siesta->write_wavefunctions, list1, right); gui_pd_new("Write density matrix", &siesta->write_dm, list1, right); gui_pd_new("Write k points", &siesta->write_kpoints, list1, right); gui_pd_new("Write eigenvalues", &siesta->write_eigenvalues, list1, right); gui_pd_new("Write k bands", &siesta->write_kbands, list1, right); gui_pd_new("Write bands", &siesta->write_bands, list1, right); gui_pd_new("Write Mulliken population", &siesta->write_mullikenpop, list1, right); /* electronic page */ page = gtk_vbox_new(FALSE, 0); label = gtk_label_new("Electronic"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(page), hbox, TRUE, TRUE, 0); left = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), left, TRUE, TRUE, 0); right = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), right, TRUE, TRUE, 0); /* basis set */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, left); list = NULL; list = g_slist_prepend(list, "nonodes"); list = g_slist_prepend(list, "nodes"); list = g_slist_prepend(list, "splitgauss"); list = g_slist_prepend(list, "split"); list = g_slist_prepend(list, ""); gui_pd_new("Basis type", &siesta->basis_type, list, vbox); g_slist_free(list); list = NULL; list = g_slist_prepend(list, "DZP"); list = g_slist_prepend(list, "SZP"); list = g_slist_prepend(list, "DZ"); list = g_slist_prepend(list, "SZ"); list = g_slist_prepend(list, ""); gui_pd_new("Basis size", &siesta->basis_size, list, vbox); g_slist_free(list); /* custom zeta ie %block PAO.basis */ /* gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0); gui_text_entry("Zeta level ", &siesta->custom_zeta, TRUE, FALSE, vbox); gui_text_entry("Polarisation level ", &siesta->custom_zeta_polarisation, TRUE, FALSE, vbox); */ /* functional */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, left); list = NULL; list = g_slist_prepend(list, "LDA"); list = g_slist_prepend(list, "GGA"); list = g_slist_prepend(list, ""); gui_pd_new("X-C functional", &siesta->xc_functional, list, vbox); g_slist_free(list); list = NULL; list = g_slist_prepend(list, "LYP"); list = g_slist_prepend(list, "RPBE"); list = g_slist_prepend(list, "revPBE"); list = g_slist_prepend(list, "PBE"); list = g_slist_prepend(list, "PW92"); list = g_slist_prepend(list, "CA"); list = g_slist_prepend(list, ""); gui_pd_new("X-C authors", &siesta->xc_authors, list, vbox); g_slist_free(list); gui_pd_new("Harris functional", &siesta->harris_functional, list1, vbox); /* spin */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, left); gui_pd_new("Spin polarised", &siesta->spin_polarised, list1, vbox); gui_pd_new("Non co-linear spin", &siesta->non_collinear_spin, list1, vbox); gui_pd_new("Fixed spin", &siesta->fixed_spin, list1, vbox); list = NULL; list = g_slist_prepend(list, "0.5"); list = g_slist_prepend(list, "1.0"); list = g_slist_prepend(list, "1.5"); list = g_slist_prepend(list, "2.0"); list = g_slist_prepend(list, ""); gui_pd_new("Total spin", &siesta->total_spin, list, vbox); g_slist_free(list); gui_pd_new("Single excitation", &siesta->single_excitation, list1, vbox); /* SCF options */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, right); gui_text_entry("Number of SCF cycles ", &siesta->no_of_cycles, TRUE, FALSE, vbox); gui_text_entry("Mixing weight ", &siesta->mixing_weight, TRUE, FALSE, vbox); gui_text_entry("Number of Pulay matrices ", &siesta->no_of_pulay_matrices, TRUE, FALSE, vbox); /* other options */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, right); gui_text_entry("Energy shift (Ryd)", &siesta->energy_shift, TRUE, FALSE, vbox); gui_text_entry("Split zeta norm", &siesta->split_zeta_norm, TRUE, FALSE, vbox); gui_text_entry("Mesh cutoff (Ryd)", &siesta->mesh_cutoff, TRUE, FALSE, vbox); gui_text_entry("kgrid cutoff ", &siesta->kgrid_cutoff, TRUE, FALSE, vbox); /* speed hacks left/right */ /* hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(page), hbox, TRUE, TRUE, 0); left = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), left, TRUE, TRUE, 0); right = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), right, TRUE, TRUE, 0); */ /* speed hacks */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, left); list = NULL; list = g_slist_prepend(list, "orderN"); list = g_slist_prepend(list, "diagon"); list = g_slist_prepend(list, ""); gui_pd_new("Solution method", &siesta->solution_method, list, vbox); g_slist_free(list); /* NEW */ list = NULL; list = g_slist_prepend(list, "MP"); list = g_slist_prepend(list, "FD"); list = g_slist_prepend(list, ""); gui_pd_new("Occupation function", &siesta->occupation_function, list, vbox); g_slist_free(list); list = NULL; list = g_slist_prepend(list, "Files"); list = g_slist_prepend(list, "Ordejon-Mauri"); list = g_slist_prepend(list, "Kim"); list = g_slist_prepend(list, ""); gui_pd_new("Order N functional", &siesta->ordern_functional, list, vbox); g_slist_free(list); vbox = gui_frame_vbox(NULL, FALSE, FALSE, right); gui_text_entry("Electronic temperature", &siesta->electronic_temperature, TRUE, FALSE, vbox); gui_text_entry("Occupation MP order ", &siesta->occupation_mp_order, TRUE, FALSE, vbox); gui_text_entry("Order N iterations ", &siesta->ordern_iterations, TRUE, FALSE, vbox); gui_text_entry("Order N energy tolerance ", &siesta->ordern_energy_tolerance, TRUE, FALSE, vbox); gui_text_entry("Order N eta ", &siesta->ordern_eta, TRUE, FALSE, vbox); gui_text_entry("Order N eta_alpha ", &siesta->ordern_eta_alpha, TRUE, FALSE, vbox); gui_text_entry("Order N eta_beta ", &siesta->ordern_eta_beta, TRUE, FALSE, vbox); /* Run page */ page = gtk_vbox_new(FALSE, 0); label = gtk_label_new("Geometric"); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); /* split pane */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(page), hbox, TRUE, TRUE, 0); left = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), left, TRUE, TRUE, 0); right = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), right, TRUE, TRUE, 0); /* main setup */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, left); list = NULL; list = g_slist_prepend(list, "Phonon"); list = g_slist_prepend(list, "FC"); list = g_slist_prepend(list, "Anneal"); list = g_slist_prepend(list, "NoseParrinelloRahman"); list = g_slist_prepend(list, "ParrinelloRahman"); list = g_slist_prepend(list, "Nose"); list = g_slist_prepend(list, "Verlet"); list = g_slist_prepend(list, "Broyden"); list = g_slist_prepend(list, "CG"); list = g_slist_prepend(list, ""); gui_pd_new("Run type", &siesta->md_type_of_run, list, vbox); g_slist_free(list); gui_pd_new("Variable cell", &siesta->md_variable_cell, list1, vbox); /* MD steps */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, left); gui_text_entry("Initial time step ", &siesta->md_initial_time_step, TRUE, FALSE, vbox); gui_text_entry("Final time step ", &siesta->md_final_time_step, TRUE, FALSE, vbox); gui_text_entry("Length of time step ", &siesta->md_length_time_step, TRUE, FALSE, vbox); /* CG steps */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, left); gui_text_entry("Max CG steps", &siesta->md_num_cg_steps, TRUE, FALSE, vbox); gui_text_entry("Max CG displacement", &siesta->md_max_cg_displacement, TRUE, FALSE, vbox); gui_text_entry("Max force tolerance", &siesta->md_max_force_tol, TRUE, FALSE, vbox); gui_text_entry("Max stress tolerance", &siesta->md_max_stress_tol, TRUE, FALSE, vbox); /* temperature */ vbox = gui_frame_vbox(NULL, FALSE, FALSE, right); gui_text_entry("Initial temperature ", &siesta->md_initial_temperature, TRUE, FALSE, vbox); gui_text_entry("Target temperature ", &siesta->md_target_temperature,TRUE, FALSE, vbox); gui_text_entry("Target pressure", &siesta->md_target_pressure, TRUE, FALSE, vbox); //gui_text_entry("Number of Steps ", &siesta->number_of_steps, TRUE, FALSE, vbox); /* additional options */ vbox = gui_frame_vbox("Target stress tensor", FALSE, FALSE, right); gui_text_entry("xx", &siesta->md_target_stress[0], TRUE, FALSE, vbox); gui_text_entry("yy", &siesta->md_target_stress[1], TRUE, FALSE, vbox); gui_text_entry("zz", &siesta->md_target_stress[2], TRUE, FALSE, vbox); gui_text_entry("xy", &siesta->md_target_stress[3], TRUE, FALSE, vbox); gui_text_entry("xz", &siesta->md_target_stress[4], TRUE, FALSE, vbox); gui_text_entry("yz", &siesta->md_target_stress[5], TRUE, FALSE, vbox); //vbox = gui_frame_vbox("Differencing", FALSE, FALSE, geompage); //gui_direct_spin("Finite Difference step size ", &siesta->finite_diff_step_size, 0.1, 10.0, 0.1, NULL, NULL, vbox); /* unprocessed lines */ page = gtk_vbox_new(FALSE, 0); label = gtk_label_new (" Unprocessed "); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label); vbox = gui_frame_vbox(NULL, TRUE, TRUE, page); text = config_unparsed_get(config); /* FIXME - allowing this to be edited -> core dump */ textbox = gui_text_window(&text, FALSE); gtk_box_pack_start(GTK_BOX(vbox), textbox, TRUE, TRUE, 0); /* cleanup */ g_slist_free(list1); gui_relation_update(NULL); }