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);
}
