cleanup
This commit is contained in:
776
gridmanager/gridmanager.cpp
Normal file
776
gridmanager/gridmanager.cpp
Normal file
@@ -0,0 +1,776 @@
|
||||
/********************************************************
|
||||
* ██████╗ ██████╗████████╗██╗
|
||||
* ██╔════╝ ██╔════╝╚══██╔══╝██║
|
||||
* ██║ ███╗██║ ██║ ██║
|
||||
* ██║ ██║██║ ██║ ██║
|
||||
* ╚██████╔╝╚██████╗ ██║ ███████╗
|
||||
* ╚═════╝ ╚═════╝ ╚═╝ ╚══════╝
|
||||
* Geophysical Computational Tools & Library (GCTL)
|
||||
*
|
||||
* Copyright (c) 2023 Yi Zhang (yizhang-geo@zju.edu.cn)
|
||||
*
|
||||
* GCTL is distributed under a dual licensing scheme. You can redistribute
|
||||
* it and/or modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation, either version 2
|
||||
* of the License, or (at your option) any later version. You should have
|
||||
* received a copy of the GNU Lesser General Public License along with this
|
||||
* program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
* If the terms and conditions of the LGPL v.2. would prevent you from using
|
||||
* the GCTL, please consider the option to obtain a commercial license for a
|
||||
* fee. These licenses are offered by the GCTL's original author. As a rule,
|
||||
* licenses are provided "as-is", unlimited in time for a one time fee. Please
|
||||
* send corresponding requests to: yizhang-geo@zju.edu.cn. Please do not forget
|
||||
* to include some description of your company and the realm of its activities.
|
||||
* Also add information on how to contact you by electronic and paper mail.
|
||||
******************************************************/
|
||||
|
||||
#include "gridmanager.h"
|
||||
// We use the editline library to handle all inputs
|
||||
#include "editline.h"
|
||||
// install configuration
|
||||
#include "../gctl_toolkits_config.h"
|
||||
|
||||
cmd_pair curr_cmd; // Executing command
|
||||
gctl::regular_grid rg; // Grid object
|
||||
|
||||
extern "C" {
|
||||
|
||||
/*
|
||||
* Strip whitespace from the start and end of STRING. Return a pointer
|
||||
* into STRING.
|
||||
*/
|
||||
char *stripwhite(char *string)
|
||||
{
|
||||
char *s, *t;
|
||||
|
||||
for (s = string; isspace(*s); s++) ;
|
||||
|
||||
if (*s == 0)
|
||||
return s;
|
||||
|
||||
t = s + strlen(s) - 1;
|
||||
while (t > s && isspace(*t))
|
||||
t--;
|
||||
*++t = '\0';
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
/* Generator function for command completion. STATE lets us
|
||||
know whether to start from scratch; without any state
|
||||
(i.e. STATE == 0), then we start at the top of the list. */
|
||||
char *command_generator(const char *text, int state)
|
||||
{
|
||||
static int list_index, len;
|
||||
|
||||
/* If this is a new word to complete, initialize now. This
|
||||
includes saving the length of TEXT for efficiency, and
|
||||
initializing the index variable to 0. */
|
||||
if (!state)
|
||||
{
|
||||
list_index = 0;
|
||||
len = strlen(text);
|
||||
}
|
||||
|
||||
/* Return the next name which partially matches from the command list. */
|
||||
while (list_index < CMD_NUM)
|
||||
{
|
||||
if (std::string(text) == commands[list_index].name.substr(0, len))
|
||||
{
|
||||
//const char* name = commands[list_index].name.data();
|
||||
return strdup(commands[list_index].name.data());
|
||||
}
|
||||
else list_index++;
|
||||
}
|
||||
|
||||
/* If no names matched, then return NULL. */
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/*
|
||||
* Attempt to complete on the contents of TEXT. START and END
|
||||
* bound the region of rl_line_buffer that contains the word to
|
||||
* complete. TEXT is the word to complete. We can use the entire
|
||||
* contents of rl_line_buffer in case we want to do some simple
|
||||
* parsing. Return the array of matches, or NULL if there aren't any.
|
||||
*/
|
||||
char **gridmanager_completion(const char *text, int start, int end)
|
||||
{
|
||||
char **matches = nullptr;
|
||||
|
||||
/* If this word is at the start of the line, then it is a command
|
||||
to complete. Otherwise it is the name of a file in the current
|
||||
directory. */
|
||||
if (start == 0) matches = rl_completion_matches(text, command_generator);
|
||||
|
||||
return matches;
|
||||
}
|
||||
|
||||
void initialize_readline(void)
|
||||
{
|
||||
/* Allow conditional parsing of the ~/.inputrc file. */
|
||||
rl_readline_name = "gridmanager";
|
||||
|
||||
/* Tell the completer that we want a crack first. */
|
||||
rl_attempted_completion_function = gridmanager_completion;
|
||||
}
|
||||
|
||||
} // End C section
|
||||
|
||||
void display_cmds()
|
||||
{
|
||||
std::clog << "Command:\n";
|
||||
for (size_t i = 0; i < CMD_NUM - 1; i++)
|
||||
{
|
||||
std::clog << std::setw(12) << commands[i].name << ":\t" << commands[i].brief << "\n";
|
||||
}
|
||||
|
||||
std::clog << "\nEnter \"<command>?\" to see detailed instructions.\n\n";
|
||||
std::clog << "Keywords:\n";
|
||||
for (size_t i = 0; i < KEY_NUM; i++)
|
||||
{
|
||||
std::clog << std::setw(12) << keywords[i].name << ":\t" << keywords[i].brief << "\n";
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void display_help(std::string input_cmd)
|
||||
{
|
||||
std::string install_dir = GCTL_TOOLKITS_INSTALL_PREFIX;
|
||||
std::ifstream helpin;
|
||||
open_infile(helpin, install_dir + "/sbin/share/readme_gridmanager", ".md");
|
||||
|
||||
std::string tmp_l, tmp_help;
|
||||
std::vector<std::string> cmds;
|
||||
std::vector<std::string> helps;
|
||||
while (getline(helpin, tmp_l))
|
||||
{
|
||||
if (tmp_l.substr(0, 4) == "####")
|
||||
{
|
||||
cmds.push_back(tmp_l.substr(5));
|
||||
tmp_help = "";
|
||||
while (getline(helpin, tmp_l))
|
||||
{
|
||||
if (tmp_l == "") break;
|
||||
else tmp_help += tmp_l + "\n";
|
||||
}
|
||||
helps.push_back(tmp_help);
|
||||
}
|
||||
}
|
||||
helpin.close();
|
||||
|
||||
std::string cmd_str;
|
||||
for (size_t j = 0; j < cmds.size(); j++)
|
||||
{
|
||||
parse_string_to_value(cmds[j], ' ', true, cmd_str);
|
||||
if (input_cmd == cmd_str)
|
||||
{
|
||||
replace_all(tmp_l, cmds[j], "\\", "");
|
||||
std::cout << GCTL_BOLDGREEN << tmp_l << GCTL_RESET << "\n";
|
||||
std::cout << helps[j] << "\n";
|
||||
break;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void exec_cmd(std::string cmd)
|
||||
{
|
||||
std::string cmd_name;
|
||||
parse_string_to_value(cmd, ' ', true, cmd_name);
|
||||
|
||||
// show instruction if there is a question mark at end of the command
|
||||
if (cmd_name.back() == '?')
|
||||
{
|
||||
cmd_name = cmd_name.substr(0, cmd_name.length() - 1);
|
||||
display_help(cmd_name);
|
||||
return;
|
||||
}
|
||||
|
||||
// set default command to null
|
||||
curr_cmd = commands[CMD_NUM - 1];
|
||||
for (size_t i = 0; i < CMD_NUM - 1; i++)
|
||||
{
|
||||
if (cmd_name == commands[i].name)
|
||||
{
|
||||
curr_cmd = commands[i]; break;
|
||||
}
|
||||
}
|
||||
|
||||
if (curr_cmd.func_p == nullptr) throw gctl::runtime_error("Invalid command: " + cmd_name);
|
||||
|
||||
std::vector<std::string> cmd_units;
|
||||
parse_string_with_quotes(cmd, cmd_units);
|
||||
|
||||
return curr_cmd.func_p(cmd_units);
|
||||
}
|
||||
|
||||
// This function is defined to avoid potential breakdown while running in script mode.
|
||||
void quit(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void mesh_info(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// info [\<new-grid-name\>] [\<new-info\>]
|
||||
if (cmd_units.size() == 1)
|
||||
{
|
||||
rg.show_info();
|
||||
return;
|
||||
}
|
||||
|
||||
gctl::array<std::string> copy_str(2, "null");
|
||||
for (size_t i = 1; i <= GCTL_MIN(cmd_units.size() - 1, 2); i++)
|
||||
{
|
||||
copy_str[i - 1] = cmd_units[i];
|
||||
}
|
||||
|
||||
if (copy_str[0] != "null") rg.set_meshname(copy_str[0]);
|
||||
if (copy_str[1] != "null") rg.set_meshinfo(copy_str[1]);
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef GCTL_MESH_EXPRTK
|
||||
|
||||
inline double expr2double(std::string s)
|
||||
{
|
||||
exprtk::symbol_table<double> sym_tab;
|
||||
exprtk::expression<double> expr;
|
||||
exprtk::parser<double> p;
|
||||
|
||||
sym_tab.add_constants();
|
||||
expr.register_symbol_table(sym_tab);
|
||||
p.compile(s, expr);
|
||||
|
||||
return expr.value();
|
||||
}
|
||||
|
||||
#endif // GCTL_MESH_EXPRTK
|
||||
|
||||
void new_grid(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// new \<new-file\> \<xnum\> \<ynum\> \<xmin\> \<ymin\> \<dx\> \<dy\> [\<info\>]
|
||||
if (cmd_units.size() < 8) throw std::runtime_error("new-grid: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(8, "null");
|
||||
for (size_t i = 1; i <= GCTL_MIN(cmd_units.size() - 1, 8); i++)
|
||||
{
|
||||
copy_str[i - 1] = cmd_units[i];
|
||||
}
|
||||
|
||||
if (rg.initiated()) rg.clear_regular_grid();
|
||||
|
||||
double xmin, ymin, dx, dy;
|
||||
#ifdef GCTL_MESH_EXPRTK
|
||||
|
||||
xmin = expr2double(copy_str[3]);
|
||||
ymin = expr2double(copy_str[4]);
|
||||
dx = expr2double(copy_str[5]);
|
||||
dy = expr2double(copy_str[6]);
|
||||
|
||||
#else
|
||||
|
||||
xmin = atof(copy_str[3].c_str());
|
||||
ymin = atof(copy_str[4].c_str());
|
||||
dx = atof(copy_str[5].c_str());
|
||||
dy = atof(copy_str[6].c_str());
|
||||
|
||||
#endif // GCTL_MESH_EXPRTK
|
||||
|
||||
rg.init(copy_str[0], copy_str[7], atoi(copy_str[1].c_str()),
|
||||
atoi(copy_str[2].c_str()), xmin, ymin, dx, dy);
|
||||
return;
|
||||
}
|
||||
|
||||
void open_grid(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// open binary <file>
|
||||
// open netcdf <file> [<x-name> <y-name>] [<data-name>] [node|cell]
|
||||
// open surfer <file> <new-data-name> [surfer6-text|surfer6-binary|surfer7] [node|cell]
|
||||
if (cmd_units.size() < 3) throw std::runtime_error("open: insufficient parameters.");
|
||||
|
||||
if (cmd_units[1] == "binary") open_binary(cmd_units);
|
||||
else if (cmd_units[1] == "netcdf") open_netcdf(cmd_units);
|
||||
else if (cmd_units[1] == "surfer") open_surfer(cmd_units);
|
||||
else throw std::runtime_error("open: unknown file format.");
|
||||
return;
|
||||
}
|
||||
|
||||
void save_grid(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// save binary <file>
|
||||
// save netcdf <file> [<data-name>|node|cell]
|
||||
// save surfer <file> <data-name> [surfer6-text|surfer6-binary|surfer7]
|
||||
// save gmsh <file>
|
||||
// save text <file> <data-name> [<data-name>]...
|
||||
if (cmd_units.size() < 3) throw std::runtime_error("save: insufficient parameters.");
|
||||
|
||||
if (cmd_units[1] == "binary") save_binary(cmd_units);
|
||||
else if (cmd_units[1] == "netcdf") save_netcdf(cmd_units);
|
||||
else if (cmd_units[1] == "surfer") save_surfer(cmd_units);
|
||||
else if (cmd_units[1] == "gmsh") save_gmsh(cmd_units);
|
||||
else if (cmd_units[1] == "text") save_text(cmd_units);
|
||||
else throw std::runtime_error("save: unknown file format.");
|
||||
return;
|
||||
}
|
||||
|
||||
void open_binary(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// open binary <file>
|
||||
rg.load_binary(cmd_units[2]);
|
||||
return;
|
||||
}
|
||||
|
||||
void save_binary(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// save binary <file>
|
||||
rg.save_binary(cmd_units[2]);
|
||||
return;
|
||||
}
|
||||
|
||||
void open_netcdf(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// open netcdf <file> [<x-name> <y-name>] [<data-name>] [node|cell]
|
||||
if (cmd_units.size() < 3) throw std::runtime_error("open: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(5, "null");
|
||||
for (size_t i = 0; i < GCTL_MIN(cmd_units.size() - 2, 5); i++)
|
||||
{
|
||||
copy_str[i] = cmd_units[i + 2];
|
||||
}
|
||||
|
||||
mesh_data_type_e d_type = NodeData;
|
||||
if (copy_str[4] == "cell") d_type = ElemData;
|
||||
else if (copy_str[4] == "node") d_type = NodeData;
|
||||
|
||||
if (copy_str[1] == "null") copy_str[1] = "x";
|
||||
if (copy_str[2] == "null") copy_str[2] = "y";
|
||||
if (copy_str[3] == "null") rg.load_netcdf_grid(copy_str[0], d_type, copy_str[1], copy_str[2]);
|
||||
else rg.load_netcdf_grid(copy_str[0], d_type, copy_str[1], copy_str[2], copy_str[3]);
|
||||
return;
|
||||
}
|
||||
|
||||
void save_netcdf(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// save netcdf <file> [<data-name>|node|cell] [xname] [yname]
|
||||
if (cmd_units.size() < 3) throw std::runtime_error("save: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(4, "null");
|
||||
for (size_t i = 0; i < GCTL_MIN(cmd_units.size() - 2, 4); i++)
|
||||
{
|
||||
copy_str[i] = cmd_units[i + 2];
|
||||
}
|
||||
|
||||
std::string xname = "x", yname = "y";
|
||||
if (copy_str[2] != "null") xname = copy_str[2];
|
||||
if (copy_str[3] != "null") yname = copy_str[3];
|
||||
|
||||
if (copy_str[1] == "null") rg.save_netcdf_grid(copy_str[0], NodeData, xname, yname);
|
||||
else if (copy_str[1] == "node") rg.save_netcdf_grid(copy_str[0], NodeData, xname, yname);
|
||||
else if (copy_str[1] == "cell") rg.save_netcdf_grid(copy_str[0], ElemData, xname, yname);
|
||||
else rg.save_netcdf_grid(copy_str[0], copy_str[1], xname, yname);
|
||||
return;
|
||||
}
|
||||
|
||||
void save_gmsh(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// save gmsh <file>
|
||||
if (cmd_units.size() < 3) throw std::runtime_error("save: insufficient parameters.");
|
||||
|
||||
rg.save_gmsh_withdata(cmd_units[2], OverWrite, NotPacked);
|
||||
return;
|
||||
}
|
||||
|
||||
void open_surfer(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// open surfer <file> [<new-data-name>] [surfer6-text|surfer6-binary|surfer7] [node|cell]
|
||||
if (cmd_units.size() < 4) throw std::runtime_error("open: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(4, "null");
|
||||
for (size_t i = 0; i < GCTL_MIN(cmd_units.size() - 2, 4); i++)
|
||||
{
|
||||
copy_str[i] = cmd_units[i + 2];
|
||||
}
|
||||
|
||||
surfer_file_type_e st = Surfer6Text;
|
||||
if (copy_str[2] == "surfer6-text") st = Surfer6Text;
|
||||
else if (copy_str[2] == "surfer6-binary") st = Surfer6Binary;
|
||||
else if (copy_str[2] == "surfer7") st = Surfer7Grid;
|
||||
|
||||
mesh_data_type_e d_type = NodeData;
|
||||
if (copy_str[3] == "node") d_type = NodeData;
|
||||
else if (copy_str[3] == "cell") d_type = ElemData;
|
||||
|
||||
if (copy_str[1] == "null") rg.load_surfer_grid(copy_str[0], "Untitled", d_type, st);
|
||||
else rg.load_surfer_grid(copy_str[0], copy_str[3], d_type, st);
|
||||
return;
|
||||
}
|
||||
|
||||
void save_surfer(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// save surfer <file> <data-name> [surfer6-text|surfer6-binary|surfer7]
|
||||
if (cmd_units.size() < 4) throw std::runtime_error("save: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(3, "null");
|
||||
for (size_t i = 0; i < GCTL_MIN(cmd_units.size() - 2, 3); i++)
|
||||
{
|
||||
copy_str[i] = cmd_units[i + 2];
|
||||
}
|
||||
|
||||
surfer_file_type_e st = Surfer6Text;
|
||||
if (copy_str[2] == "surfer6-text") st = Surfer6Text;
|
||||
else if (copy_str[2] == "surfer6-binary") st = Surfer6Binary;
|
||||
else if (copy_str[2] == "surfer7") st = Surfer7Grid;
|
||||
|
||||
rg.save_surfer_grid(copy_str[0], copy_str[1] ,st);
|
||||
return;
|
||||
}
|
||||
|
||||
void save_text(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// save text <file> <data-name>
|
||||
if (cmd_units.size() < 4) throw std::runtime_error("save: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(cmd_units.size() - 3, "null");
|
||||
for (size_t i = 0; i < cmd_units.size() - 3; i++)
|
||||
{
|
||||
copy_str[i] = cmd_units[i + 3];
|
||||
}
|
||||
|
||||
rg.save_text(cmd_units[2], copy_str);
|
||||
return;
|
||||
}
|
||||
|
||||
void data_cloud(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// data-cloud \<new-data-name\> node|cell \<data-could-file\> \<search-x\> \<search-y\> \<search-deg\>
|
||||
if (cmd_units.size() < 7) throw std::runtime_error("data-cloud: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(7, "null");
|
||||
for (size_t i = 1; i <= GCTL_MIN(cmd_units.size() - 1, 7); i++)
|
||||
{
|
||||
copy_str[i - 1] = cmd_units[i];
|
||||
}
|
||||
|
||||
mesh_data_type_e d_type = NodeData;
|
||||
if (copy_str[1] == "node") d_type = NodeData;
|
||||
else if (copy_str[1] == "cell") d_type = ElemData;
|
||||
else throw std::runtime_error("open-surfer: invalid grid data type.");
|
||||
|
||||
geodsv_io text_in;
|
||||
text_in.load_text(copy_str[2]);
|
||||
|
||||
array<point2dc> posi_arr;
|
||||
_1d_array data_vec;
|
||||
text_in.get_column_point2dc(posi_arr, 0, 1);
|
||||
text_in.get_column(data_vec, 2);
|
||||
|
||||
rg.load_data_cloud(posi_arr, data_vec, atof(copy_str[3].c_str()), atof(copy_str[4].c_str()), atof(copy_str[5].c_str()), copy_str[0], d_type);
|
||||
return;
|
||||
}
|
||||
|
||||
void gradient(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// gradient <data-name> <new-data-name> dx|dy <order>
|
||||
if (cmd_units.size() < 4) throw std::runtime_error("gradient: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(4, "null");
|
||||
for (size_t i = 1; i <= GCTL_MIN(cmd_units.size() - 1, 4); i++)
|
||||
{
|
||||
copy_str[i - 1] = cmd_units[i];
|
||||
}
|
||||
|
||||
gradient_type_e g_type;
|
||||
if (copy_str[2] == "dx") g_type = Dx;
|
||||
else if (copy_str[2] == "dy") g_type = Dy;
|
||||
else throw std::runtime_error("gradient: invalid gradient type.");
|
||||
|
||||
int order = 1;
|
||||
if (copy_str[3] != "null") order = atoi(copy_str[3].c_str());
|
||||
|
||||
rg.gradient(copy_str[0], copy_str[1], g_type, order);
|
||||
return;
|
||||
}
|
||||
|
||||
void wavelet(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// wavelet \<data-name\> \<wavelet-name\> \<order\> [\<show-summary\>]
|
||||
if (cmd_units.size() < 4) throw std::runtime_error("wavelet: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(4, "null");
|
||||
for (size_t i = 1; i <= GCTL_MIN(cmd_units.size() - 1, 4); i++)
|
||||
{
|
||||
copy_str[i - 1] = cmd_units[i];
|
||||
}
|
||||
|
||||
int order = order = atoi(copy_str[2].c_str());
|
||||
|
||||
if (copy_str[3] == "yes") rg.wavelet(copy_str[0], copy_str[1], order, true);
|
||||
else rg.wavelet(copy_str[0], copy_str[1], order, false);
|
||||
return;
|
||||
}
|
||||
|
||||
void sum_data(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// sum-data \<new-data\> \<data1\> \<data2\>
|
||||
if (cmd_units.size() < 4) throw std::runtime_error("sum: insufficient parameters.");
|
||||
|
||||
rg.sum(cmd_units[1], cmd_units[2], cmd_units[3]);
|
||||
return;
|
||||
}
|
||||
|
||||
void diff_data(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// diff \<new-data\> \<data1\> \<data2\>
|
||||
if (cmd_units.size() < 4) throw std::runtime_error("diff: insufficient parameters.");
|
||||
|
||||
rg.diff(cmd_units[1], cmd_units[2], cmd_units[3]);
|
||||
return;
|
||||
}
|
||||
|
||||
void bool_data(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// bool \<new-data-name\> \<data-name1> \<bool-data\> [reverse]
|
||||
if (cmd_units.size() < 4) throw std::runtime_error("bool: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(4, "null");
|
||||
for (size_t i = 1; i <= GCTL_MIN(cmd_units.size() - 1, 4); i++)
|
||||
{
|
||||
copy_str[i - 1] = cmd_units[i];
|
||||
}
|
||||
|
||||
if (copy_str[3] == "reverse") rg.boolean(copy_str[0], copy_str[1], copy_str[2], true);
|
||||
else rg.boolean(copy_str[0], copy_str[1], copy_str[2]);
|
||||
return;
|
||||
}
|
||||
|
||||
void func_data(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// function \<expression\> \<new-data-name\>
|
||||
if (cmd_units.size() < 3) throw std::runtime_error("function: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(3, "null");
|
||||
for (size_t i = 0; i <= GCTL_MIN(cmd_units.size() - 1, 3); i++)
|
||||
{
|
||||
copy_str[i] = cmd_units[i + 1];
|
||||
}
|
||||
|
||||
rg.function(copy_str[0], copy_str[1]);
|
||||
return;
|
||||
}
|
||||
|
||||
void calculator(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// calculator \<expression\> \<var1,data-name1\> \<var2,data-name2\>...
|
||||
if (cmd_units.size() < 4) throw std::runtime_error("calculator: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(cmd_units.size() - 1, "null");
|
||||
for (size_t i = 1; i <= cmd_units.size() - 1; i++)
|
||||
{
|
||||
copy_str[i - 1] = cmd_units[i];
|
||||
}
|
||||
|
||||
array<std::string> var_list(copy_str.size() - 1), data_list(copy_str.size() - 1);
|
||||
for (size_t i = 0; i < var_list.size(); i++)
|
||||
{
|
||||
parse_string_to_value(copy_str[i + 1], ',', true, var_list[i], data_list[i]);
|
||||
}
|
||||
|
||||
rg.calculator(copy_str[0], var_list, data_list);
|
||||
return;
|
||||
}
|
||||
|
||||
void data_output(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// data-output enable|disable \<data-name1\> \<data-name2\>...
|
||||
if (cmd_units.size() < 3) throw std::runtime_error("data-output: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(cmd_units.size() - 1, "null");
|
||||
for (size_t i = 1; i <= cmd_units.size() - 1; i++)
|
||||
{
|
||||
copy_str[i - 1] = cmd_units[i];
|
||||
}
|
||||
|
||||
meshdata *data_ptr;
|
||||
if (copy_str[0] == "enable")
|
||||
{
|
||||
for (size_t i = 1; i < copy_str.size(); i++)
|
||||
{
|
||||
data_ptr = rg.get_data_ptr(copy_str[i]);
|
||||
data_ptr->output_ok_ = true;
|
||||
}
|
||||
}
|
||||
else if (copy_str[0] == "disable")
|
||||
{
|
||||
for (size_t i = 1; i < copy_str.size(); i++)
|
||||
{
|
||||
data_ptr = rg.get_data_ptr(copy_str[i]);
|
||||
data_ptr->output_ok_ = false;
|
||||
}
|
||||
}
|
||||
else throw std::runtime_error("data-output: invalid operation type.");
|
||||
return;
|
||||
}
|
||||
|
||||
void data_rename(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// data-rename [\<old-name\>] [\<new-name\>]
|
||||
if (cmd_units.size() < 3) throw std::runtime_error("rename: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(2, "null");
|
||||
for (size_t i = 1; i <= GCTL_MIN(cmd_units.size() - 1, 2); i++)
|
||||
{
|
||||
copy_str[i - 1] = cmd_units[i];
|
||||
}
|
||||
|
||||
meshdata &curr_data = rg.get_data(copy_str[0]);
|
||||
curr_data.name_ = copy_str[1];
|
||||
return;
|
||||
}
|
||||
|
||||
void data_view(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// plot [\<data-name\>]...
|
||||
if (cmd_units.size() < 2) throw std::runtime_error("view: insufficient parameters.");
|
||||
|
||||
for (size_t i = 1; i < cmd_units.size(); i++)
|
||||
{
|
||||
rg.view(cmd_units[i]);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void data_plot(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// plot [\<data-name\>]...
|
||||
if (cmd_units.size() < 2) throw std::runtime_error("plot: insufficient parameters.");
|
||||
|
||||
for (size_t i = 1; i < cmd_units.size(); i++)
|
||||
{
|
||||
rg.plot(cmd_units[i]);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void get_stats(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// statistic \<data-name1\> \<data-name2\>...
|
||||
if (cmd_units.size() < 2) throw std::runtime_error("statistic: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(cmd_units.size() - 1, "null");
|
||||
for (size_t i = 1; i <= cmd_units.size() - 1; i++)
|
||||
{
|
||||
copy_str[i - 1] = cmd_units[i];
|
||||
}
|
||||
|
||||
meshdata *data_ptr;
|
||||
std::vector<double> stats;
|
||||
for (size_t i = 0; i < copy_str.size(); i++)
|
||||
{
|
||||
data_ptr = rg.get_data_ptr(copy_str[i]);
|
||||
data_ptr->show_info();
|
||||
data_ptr->show_stats();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void get_profile(const std::vector<std::string> &cmd_units)
|
||||
{
|
||||
// profile \<data-name\> \<out-file\> {\<x\>,\<y\> \<x\>,\<y\> \<num\>}|{\<xy-file\>}
|
||||
if (cmd_units.size() < 4) throw std::runtime_error("profile: insufficient parameters.");
|
||||
|
||||
gctl::array<std::string> copy_str(5, "null");
|
||||
for (size_t i = 1; i <= GCTL_MIN(cmd_units.size() - 1, 5); i++)
|
||||
{
|
||||
copy_str[i - 1] = cmd_units[i];
|
||||
}
|
||||
|
||||
array<point2dc> xys;
|
||||
array<double> p_data;
|
||||
if (access(copy_str[2].c_str(), R_OK))
|
||||
{
|
||||
point2dc st_p, ed_p;
|
||||
gctl::parse_string_to_value(copy_str[2], ',', true, st_p.x, st_p.y);
|
||||
gctl::parse_string_to_value(copy_str[3], ',', true, ed_p.x, ed_p.y);
|
||||
rg.extract_profile(copy_str[0], st_p, ed_p, atoi(copy_str[4].c_str()), xys, p_data);
|
||||
}
|
||||
else // File exist
|
||||
{
|
||||
geodsv_io fio;
|
||||
fio.load_text(copy_str[2]);
|
||||
fio.get_column_point2dc(xys, 0, 1);
|
||||
|
||||
rg.extract_points(copy_str[0], xys, p_data);
|
||||
}
|
||||
|
||||
std::ofstream ofile;
|
||||
open_outfile(ofile, copy_str[1], ".txt");
|
||||
ofile << "# x y d val\n";
|
||||
for (size_t i = 0; i < xys.size(); i++)
|
||||
{
|
||||
ofile << xys[i].x << " " << xys[i].y << " " << distance(xys[0], xys[i]) << " " << p_data[i] << "\n";
|
||||
}
|
||||
ofile.close();
|
||||
return;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
if (argc >= 2)
|
||||
{
|
||||
std::string tmp_l;
|
||||
std::ifstream cmdin;
|
||||
|
||||
// Run commands from files. Each line is a command.
|
||||
// You can give more than one file
|
||||
for (size_t i = 1; i < argc; i++) try
|
||||
{
|
||||
open_infile(cmdin, argv[i]);
|
||||
while (getline(cmdin, tmp_l) && tmp_l != "" && tmp_l[0] != '#')
|
||||
{
|
||||
exec_cmd(tmp_l);
|
||||
}
|
||||
cmdin.close();
|
||||
}
|
||||
catch(std::exception& e)
|
||||
{
|
||||
GCTL_ShowWhatError(e.what(), GCTL_ERROR_ERROR, 0, "run gridmanager in the interactive mode for instructions.", 0);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
setlocale(LC_CTYPE, "");
|
||||
initialize_readline(); /* Bind our completer. */
|
||||
|
||||
display_logo();
|
||||
std::clog << "gridmanager - conversion, compuatation and manipulation of the grid data.\n";
|
||||
std::clog << "Enter '?' to see all available commands.\n";
|
||||
|
||||
std::string cmd_str;
|
||||
char *c_line = (char *)NULL;
|
||||
char *c_line_s = (char *)NULL;
|
||||
bool quit = false;
|
||||
|
||||
while (!quit) try
|
||||
{
|
||||
c_line = readline(">> ");
|
||||
if (!c_line) break;
|
||||
|
||||
c_line_s = stripwhite(c_line);
|
||||
cmd_str = c_line_s;
|
||||
|
||||
if (cmd_str == "quit") quit = true;
|
||||
else if (cmd_str == "?") display_cmds();
|
||||
else exec_cmd(cmd_str);
|
||||
|
||||
free(c_line);
|
||||
}
|
||||
catch(std::exception& e)
|
||||
{
|
||||
GCTL_ShowWhatError(e.what(), GCTL_ERROR_ERROR, 0, "Enter 'help' for instructions.", 0);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user