bool ParserCreateQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
{
ParserKeyword s_create("CREATE");
ParserKeyword s_temporary("TEMPORARY");
ParserKeyword s_attach("ATTACH");
ParserKeyword s_table("TABLE");
ParserKeyword s_database("DATABASE");
ParserKeyword s_if_not_exists("IF NOT EXISTS");
ParserKeyword s_as("AS");
ParserKeyword s_view("VIEW");
ParserKeyword s_materialized("MATERIALIZED");
ParserKeyword s_populate("POPULATE");
ParserToken s_dot(TokenType::Dot);
ParserToken s_lparen(TokenType::OpeningRoundBracket);
ParserToken s_rparen(TokenType::ClosingRoundBracket);
ParserStorage storage_p;
ParserIdentifier name_p;
ParserColumnsOrIndicesDeclarationList columns_or_indices_p;
ParserSelectWithUnionQuery select_p;
ASTPtr database;
ASTPtr table;
ASTPtr columns_list;
ASTPtr to_database;
ASTPtr to_table;
ASTPtr storage;
ASTPtr as_database;
ASTPtr as_table;
ASTPtr select;
String cluster_str;
bool attach = false;
bool if_not_exists = false;
bool is_view = false;
bool is_materialized_view = false;
bool is_populate = false;
bool is_temporary = false;
if (!s_create.ignore(pos, expected))
{
if (s_attach.ignore(pos, expected))
attach = true;
else
return false;
}
if (s_temporary.ignore(pos, expected))
{
is_temporary = true;
}
if (s_table.ignore(pos, expected))
{
if (s_if_not_exists.ignore(pos, expected))
if_not_exists = true;
if (!name_p.parse(pos, table, expected))
return false;
if (s_dot.ignore(pos, expected))
{
database = table;
if (!name_p.parse(pos, table, expected))
return false;
}
if (ParserKeyword{"ON"}.ignore(pos, expected))
{
if (!ASTQueryWithOnCluster::parse(pos, cluster_str, expected))
return false;
}
// Shortcut for ATTACH a previously detached table
if (attach && (!pos.isValid() || pos.get().type == TokenType::Semicolon))
{
auto query = std::make_shared<ASTCreateQuery>();
node = query;
query->attach = attach;
query->if_not_exists = if_not_exists;
query->cluster = cluster_str;
getIdentifierName(database, query->database);
getIdentifierName(table, query->table);
return true;
}
/// List of columns.
if (s_lparen.ignore(pos, expected))
{
if (!columns_or_indices_p.parse(pos, columns_list, expected))
return false;
if (!s_rparen.ignore(pos, expected))
return false;
if (!storage_p.parse(pos, storage, expected) && !is_temporary)
return false;
}
else
{
storage_p.parse(pos, storage, expected);
if (!s_as.ignore(pos, expected))
return false;
if (!select_p.parse(pos, select, expected)) /// AS SELECT ...
{
/// AS [db.]table
if (!name_p.parse(pos, as_table, expected))
return false;
if (s_dot.ignore(pos, expected))
{
as_database = as_table;
if (!name_p.parse(pos, as_table, expected))
return false;
}
/// Optional - ENGINE can be specified.
if (!storage)
storage_p.parse(pos, storage, expected);
}
}
}
else if (is_temporary)
return false;
else if (s_database.ignore(pos, expected))
{
if (s_if_not_exists.ignore(pos, expected))
if_not_exists = true;
if (!name_p.parse(pos, database, expected))
return false;
if (ParserKeyword{"ON"}.ignore(pos, expected))
{
if (!ASTQueryWithOnCluster::parse(pos, cluster_str, expected))
return false;
}
storage_p.parse(pos, storage, expected);
}
else
{
/// VIEW or MATERIALIZED VIEW
if (s_materialized.ignore(pos, expected))
{
is_materialized_view = true;
}
else
is_view = true;
if (!s_view.ignore(pos, expected))
return false;
if (s_if_not_exists.ignore(pos, expected))
if_not_exists = true;
if (!name_p.parse(pos, table, expected))
return false;
if (s_dot.ignore(pos, expected))
{
database = table;
if (!name_p.parse(pos, table, expected))
return false;
}
if (ParserKeyword{"ON"}.ignore(pos, expected))
{
if (!ASTQueryWithOnCluster::parse(pos, cluster_str, expected))
return false;
}
// TO [db.]table
if (ParserKeyword{"TO"}.ignore(pos, expected))
{
if (!name_p.parse(pos, to_table, expected))
return false;
if (s_dot.ignore(pos, expected))
{
to_database = to_table;
if (!name_p.parse(pos, to_table, expected))
return false;
}
}
/// Optional - a list of columns can be specified. It must fully comply with SELECT.
if (s_lparen.ignore(pos, expected))
{
if (!columns_or_indices_p.parse(pos, columns_list, expected))
return false;
if (!s_rparen.ignore(pos, expected))
return false;
}
if (is_materialized_view && !to_table)
{
/// Internal ENGINE for MATERIALIZED VIEW must be specified.
if (!storage_p.parse(pos, storage, expected))
return false;
if (s_populate.ignore(pos, expected))
is_populate = true;
}
/// AS SELECT ...
if (!s_as.ignore(pos, expected))
return false;
if (!select_p.parse(pos, select, expected))
return false;
}
auto query = std::make_shared<ASTCreateQuery>();
node = query;
query->attach = attach;
query->if_not_exists = if_not_exists;
query->is_view = is_view;
query->is_materialized_view = is_materialized_view;
query->is_populate = is_populate;
query->temporary = is_temporary;
getIdentifierName(database, query->database);
getIdentifierName(table, query->table);
query->cluster = cluster_str;
getIdentifierName(to_database, query->to_database);
getIdentifierName(to_table, query->to_table);
query->set(query->columns_list, columns_list);
query->set(query->storage, storage);
getIdentifierName(as_database, query->as_database);
getIdentifierName(as_table, query->as_table);
query->set(query->select, select);
return true;
}
int main(int argc, char* argv[])
{
// Define nonlinear thermal conductivity lambda(u) via a cubic spline.
// Step 1: Fill the x values and use lambda_macro(u) = 1 + u^4 for the y values.
#define lambda_macro(x) (1 + Hermes::pow(x, 4))
Hermes::vector<double> lambda_pts(-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0);
Hermes::vector<double> lambda_val;
for (unsigned int i = 0; i < lambda_pts.size(); i++)
lambda_val.push_back(lambda_macro(lambda_pts[i]));
// Step 2: Create the cubic spline (and plot it for visual control).
double bc_left = 0.0;
double bc_right = 0.0;
bool first_der_left = false;
bool first_der_right = false;
bool extrapolate_der_left = true;
bool extrapolate_der_right = true;
CubicSpline lambda(lambda_pts, lambda_val, bc_left, bc_right, first_der_left, first_der_right,
extrapolate_der_left, extrapolate_der_right);
info("Saving cubic spline into a Pylab file spline.dat.");
double interval_extension = 3.0; // The interval of definition of the spline will be
// extended by "interval_extension" on both sides.
lambda.plot("spline.dat", interval_extension);
// Load the mesh.
Mesh mesh;
MeshReaderH2D mloader;
mloader.load("square.mesh", &mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_GLOB_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary("Bdy", INIT_BDY_REF_NUM);
// Initialize boundary conditions.
CustomEssentialBCNonConst bc_essential("Bdy");
EssentialBCs<double> bcs(&bc_essential);
// Create an H1 space with default shapeset.
H1Space<double> space(&mesh, &bcs, P_INIT);
int ndof = space.get_num_dofs();
info("ndof: %d", ndof);
// Initialize the weak formulation.
Hermes2DFunction<double> src(-heat_src);
DefaultWeakFormPoisson<double> wf(HERMES_ANY, &lambda, &src);
// Initialize the FE problem.
DiscreteProblem<double> dp(&wf, &space);
// Project the initial condition on the FE space to obtain initial
// coefficient vector for the Newton's method.
// NOTE: If you want to start from the zero vector, just define
// coeff_vec to be a vector of ndof zeros (no projection is needed).
info("Projecting to obtain initial vector for the Newton's method.");
double* coeff_vec = new double[ndof];
CustomInitialCondition init_sln(&mesh);
OGProjection<double>::project_global(&space, &init_sln, coeff_vec, matrix_solver);
// Initialize Newton solver.
NewtonSolver<double> newton(&dp, matrix_solver);
// Perform Newton's iteration.
bool freeze_jacobian = false;
if (!newton.solve(coeff_vec, NEWTON_TOL, NEWTON_MAX_ITER, freeze_jacobian))
error("Newton's iteration failed.");
// Translate the resulting coefficient vector into a Solution.
Solution<double> sln;
Solution<double>::vector_to_solution(newton.get_sln_vector(), &space, &sln);
// Get info about time spent during assembling in its respective parts.
//dp.get_all_profiling_output(std::cout);
// Clean up.
delete [] coeff_vec;
// Visualise the solution and mesh.
ScalarView s_view("Solution", new WinGeom(0, 0, 440, 350));
s_view.show_mesh(false);
s_view.show(&sln);
OrderView<double> o_view("Mesh", new WinGeom(450, 0, 400, 350));
o_view.show(&space);
// Wait for all views to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// Load the mesh.
MeshSharedPtr mesh(new Mesh);
MeshReaderH2D mloader;
mloader.load("square.mesh", mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_GLOB_REF_NUM; i++)
mesh->refine_all_elements();
mesh->refine_towards_boundary("Bdy", INIT_BDY_REF_NUM);
// Initialize boundary conditions.
CustomEssentialBCNonConst bc_essential("Bdy");
EssentialBCs<double> bcs(&bc_essential);
// Create an H1 space with default shapeset.
SpaceSharedPtr<double> space(new H1Space<double>(mesh, &bcs, P_INIT));
int ndof = space->get_num_dofs();
// Initialize previous iteration solution for the Picard's method.
MeshFunctionSharedPtr<double> init_condition(new ConstantSolution<double>(mesh, INIT_COND_CONST));
// Initialize the weak formulation.
CustomNonlinearity lambda(alpha);
Hermes2DFunction<double> src(-heat_src);
CustomWeakFormPicard wf(init_condition, &lambda, &src);
// Initialize the Picard solver.
PicardSolver<double> picard(&wf, space);
picard.set_max_allowed_iterations(PICARD_MAX_ITER);
logger.info("Default tolerance");
try
{
picard.solve(init_condition);
}
catch(std::exception& e)
{
std::cout << e.what();
}
int iter_1 = picard.get_num_iters();
logger.info("Adjusted tolerance without Anderson");
// Perform the Picard's iteration (Anderson acceleration on by default).
picard.clear_tolerances();
picard.set_tolerance(PICARD_TOL, Hermes::Solvers::SolutionChangeAbsolute);
try
{
picard.solve(init_condition);
}
catch(std::exception& e)
{
std::cout << e.what();
}
int iter_2 = picard.get_num_iters();
// Translate the coefficient vector into a Solution.
MeshFunctionSharedPtr<double> sln(new Solution<double>);
Solution<double>::vector_to_solution(picard.get_sln_vector(), space, sln);
logger.info("Default tolerance without Anderson and good initial guess");
PicardSolver<double> picard2(&wf, space);
picard2.set_tolerance(1e-3, Hermes::Solvers::SolutionChangeRelative);
picard2.set_max_allowed_iterations(PICARD_MAX_ITER);
try
{
picard2.solve(sln);
}
catch(std::exception& e)
{
std::cout << e.what();
}
int iter_3 = picard2.get_num_iters();
logger.info("Default tolerance with Anderson and good initial guess");
picard2.use_Anderson_acceleration(true);
picard2.set_num_last_vector_used(PICARD_NUM_LAST_ITER_USED);
picard2.set_anderson_beta(PICARD_ANDERSON_BETA);
try
{
picard2.solve(sln);
}
catch(std::exception& e)
{
std::cout << e.what();
}
int iter_4 = picard2.get_num_iters();
#ifdef SHOW_OUTPUT
// Visualise the solution and mesh.
ScalarView s_view("Solution", new WinGeom(0, 0, 440, 350));
s_view.show_mesh(false);
s_view.show(sln);
OrderView o_view("Mesh", new WinGeom(450, 0, 420, 350));
o_view.show(space);
// Wait for all views to be closed.
View::wait();
#endif
bool success = Testing::test_value(iter_1, 14, "# of iterations 1", 1); // Tested value as of September 2013.
success = Testing::test_value(iter_2, 12, "# of iterations 2", 1) & success; // Tested value as of September 2013.
success = Testing::test_value(iter_3, 3, "# of iterations 3", 1) & success; // Tested value as of September 2013.
success = Testing::test_value(iter_4, 3, "# of iterations 4", 1) & success; // Tested value as of September 2013.
if(success)
{
printf("Success!\n");
return 0;
}
else
{
printf("Failure!\n");
return -1;
}
}
int main(int argc, char* argv[])
{
#ifdef WITH_PARALUTION
HermesCommonApi.set_integral_param_value(matrixSolverType, SOLVER_PARALUTION_ITERATIVE);
// Load the mesh.
MeshSharedPtr mesh(new Mesh);
MeshReaderH2D mloader;
mloader.load("square.mesh", mesh);
// Perform initial mesh refinements.
for(int i = 0; i < INIT_GLOB_REF_NUM; i++) mesh->refine_all_elements();
mesh->refine_towards_boundary("Bdy", INIT_BDY_REF_NUM);
// Initialize boundary conditions.
CustomEssentialBCNonConst bc_essential("Bdy");
EssentialBCs<double> bcs(&bc_essential);
// Create an H1 space with default shapeset.
SpaceSharedPtr<double> space(new H1Space<double>(mesh, &bcs, P_INIT));
int ndof = space->get_num_dofs();
// Initialize the weak formulation
CustomNonlinearity lambda(alpha);
Hermes2DFunction<double> src(-heat_src);
DefaultWeakFormPoisson<double> wf(HERMES_ANY, &lambda, &src);
#ifdef SHOW_OUTPUT
ScalarView s_view("Solution");
#endif
double* coeff_vec = new double[ndof];
MeshFunctionSharedPtr<double> init_sln(new CustomInitialCondition(mesh));
OGProjection<double> ogProjection; ogProjection.project_global(space, init_sln, coeff_vec);
MeshFunctionSharedPtr<double> sln(new Solution<double>);
// Testing is happening here.
Hermes::vector<int> numbers_of_nonlinear_iterations;
Hermes::vector<int> numbers_of_linear_iterations_in_last_nonlinear_step;
// Iterative - original initial guess.
HermesCommonApi.set_integral_param_value(matrixSolverType, SOLVER_PARALUTION_ITERATIVE);
{
// Initialize Newton solver.
NewtonSolver<double> newton(&wf, space);
newton.set_tolerance(NEWTON_TOL, ResidualNormAbsolute);
newton.set_max_steps_with_reused_jacobian(0);
newton.get_linear_matrix_solver()->as_IterSolver()->set_solver_type(Solvers::GMRES);
newton.get_linear_matrix_solver()->as_IterSolver()->set_tolerance(1e-5);
// Perform Newton's iteration.
newton.solve(coeff_vec);
numbers_of_nonlinear_iterations.push_back(newton.get_num_iters());
numbers_of_linear_iterations_in_last_nonlinear_step.push_back(newton.get_linear_matrix_solver()->as_IterSolver()->get_num_iters());
// Translate the resulting coefficient vector into a Solution.
Solution<double>::vector_to_solution(newton.get_sln_vector(), space, sln);
#ifdef SHOW_OUTPUT
s_view.show(sln);
#endif
}
// Iterative - "exact" initial guess.
{
// Initialize Newton solver.
NewtonSolver<double> newton(&wf, space);
newton.set_tolerance(NEWTON_TOL, ResidualNormAbsolute);
newton.get_linear_matrix_solver()->as_IterSolver()->set_solver_type(Solvers::GMRES);
// Perform Newton's iteration.
newton.solve(sln);
numbers_of_nonlinear_iterations.push_back(newton.get_num_iters());
numbers_of_linear_iterations_in_last_nonlinear_step.push_back(newton.get_linear_matrix_solver()->as_IterSolver()->get_num_iters());
// Translate the resulting coefficient vector into a Solution.
Solution<double>::vector_to_solution(newton.get_sln_vector(), space, sln);
#ifdef SHOW_OUTPUT
s_view.show(sln);
#endif
}
bool success = true;
success = Hermes::Testing::test_value(numbers_of_nonlinear_iterations[0], 10, "Nonlinear iterations[0]", 1) && success;
success = Hermes::Testing::test_value(numbers_of_nonlinear_iterations[1], 1, "Nonlinear iterations[1]", 1) && success;
success = Hermes::Testing::test_value(numbers_of_linear_iterations_in_last_nonlinear_step[0], 5, "Linear iterations[0]", 1) && success;
success = Hermes::Testing::test_value(numbers_of_linear_iterations_in_last_nonlinear_step[1], 7, "Linear iterations[1]", 1) && success;
if(success == true)
{
printf("Success!\n");
return 0;
}
else
{
printf("Failure!\n");
return -1;
}
#endif
return 0;
}
